{"version":3,"sources":["webpack://gatsby-starter-default/./node_modules/js-search/dist/esm/js-search.js","webpack://gatsby-starter-default/./src/components/searchBar.js","webpack://gatsby-starter-default/./src/images/newspaper.png"],"names":["AllSubstringsIndexStrategy","prototype","expandToken","token","string","expandedTokens","i","length","j","charAt","push","PrefixIndexStrategy","CaseSensitiveSanitizer","sanitize","text","trim","LowerCaseSanitizer","toLocaleLowerCase","getNestedFieldValue","object","path","value","TfIdfSearchIndex","uidFieldName","this","_uidFieldName","_tokenToIdfCache","_tokenMap","_proto","indexDocument","uid","doc","tokenDatum","tokenMap","$numDocumentOccurrences","$totalNumOccurrences","$uidMap","uidMap","$document","$numTokenOccurrences","search","tokens","corpus","uidToDocumentMap","numTokens","tokenMetadata","numKeys","keys","Object","documents","calculateTfIdf","_createCalculateTfIdf","sort","documentA","documentB","_createCalculateIdf","tokenToIdfCache","numDocumentsWithToken","Math","log","calculateIdf","document","score","inverseDocumentFrequency","Infinity","Array","UnorderedSearchIndex","_tokenToUidToDocumentMap","intersectingDocumentMap","tokenToUidToDocumentMap","documentMap","REGEX","SimpleTokenizer","tokenize","split","filter","StopWordsMap","a","able","about","across","after","all","almost","also","am","among","an","and","any","are","as","at","be","because","been","but","by","can","cannot","could","dear","did","does","either","ever","every","from","got","had","has","have","he","her","hers","him","his","how","however","into","is","it","its","just","least","like","likely","may","me","might","most","must","my","neither","no","nor","not","of","off","often","on","only","or","other","our","own","rather","said","say","says","she","should","since","so","some","than","that","the","their","them","then","there","these","they","tis","to","too","twas","us","wants","was","we","were","what","when","where","which","who","whom","why","will","would","yet","you","your","StopWordsTokenizer","decoratedTokenizer","_tokenizer","_defineProperties","target","props","descriptor","enumerable","configurable","writable","defineProperty","key","Search","Error","_indexStrategy","_searchIndex","_sanitizer","_documents","_searchableFields","Constructor","protoProps","staticProps","addDocument","addDocuments","concat","indexDocuments_","addIndex","field","query","_initialized","indexStrategy","sanitizer","searchIndex","tokenizer","di","numDocuments","sfi","numSearchableFields","fieldValue","searchableField","toString","fieldTokens","fti","numFieldValues","fieldToken","eti","nummExpandedTokens","expandedToken","set","get","onQuery","placeholder","useState","textInput","setTextInput","className","type","onChange","txt","onKeyDown","e","charCode","onClick","icon","faSearch"],"mappings":"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","file":"3fc7725eeaec0288171dc603ba39d2dde6764328-e78cef37da842300d85d.js","sourcesContent":["/**\n * Indexes for all substring searches (e.g. the term \"cat\" is indexed as \"c\", \"ca\", \"cat\", \"a\", \"at\", and \"t\").\n */\nvar AllSubstringsIndexStrategy = /*#__PURE__*/function () {\n  function AllSubstringsIndexStrategy() {}\n\n  var _proto = AllSubstringsIndexStrategy.prototype;\n  /**\n   * @inheritDocs\n   */\n\n  _proto.expandToken = function expandToken(token) {\n    var expandedTokens = [];\n    var string;\n\n    for (var i = 0, length = token.length; i < length; ++i) {\n      string = '';\n\n      for (var j = i; j < length; ++j) {\n        string += token.charAt(j);\n        expandedTokens.push(string);\n      }\n    }\n\n    return expandedTokens;\n  };\n\n  return AllSubstringsIndexStrategy;\n}();\n/**\n * Indexes for exact word matches.\n */\n\n\nvar ExactWordIndexStrategy = /*#__PURE__*/function () {\n  function ExactWordIndexStrategy() {}\n\n  var _proto = ExactWordIndexStrategy.prototype;\n  /**\n   * @inheritDocs\n   */\n\n  _proto.expandToken = function expandToken(token) {\n    return token ? [token] : [];\n  };\n\n  return ExactWordIndexStrategy;\n}();\n/**\n * Indexes for prefix searches (e.g. the term \"cat\" is indexed as \"c\", \"ca\", and \"cat\" allowing prefix search lookups).\n */\n\n\nvar PrefixIndexStrategy = /*#__PURE__*/function () {\n  function PrefixIndexStrategy() {}\n\n  var _proto = PrefixIndexStrategy.prototype;\n  /**\n   * @inheritDocs\n   */\n\n  _proto.expandToken = function expandToken(token) {\n    var expandedTokens = [];\n    var string = '';\n\n    for (var i = 0, length = token.length; i < length; ++i) {\n      string += token.charAt(i);\n      expandedTokens.push(string);\n    }\n\n    return expandedTokens;\n  };\n\n  return PrefixIndexStrategy;\n}();\n/**\n * Enforces case-sensitive text matches.\n */\n\n\nvar CaseSensitiveSanitizer = /*#__PURE__*/function () {\n  function CaseSensitiveSanitizer() {}\n\n  var _proto = CaseSensitiveSanitizer.prototype;\n  /**\n   * @inheritDocs\n   */\n\n  _proto.sanitize = function sanitize(text) {\n    return text ? text.trim() : '';\n  };\n\n  return CaseSensitiveSanitizer;\n}();\n/**\n * Sanitizes text by converting to a locale-friendly lower-case version and triming leading and trailing whitespace.\n */\n\n\nvar LowerCaseSanitizer = /*#__PURE__*/function () {\n  function LowerCaseSanitizer() {}\n\n  var _proto = LowerCaseSanitizer.prototype;\n  /**\n   * @inheritDocs\n   */\n\n  _proto.sanitize = function sanitize(text) {\n    return text ? text.toLocaleLowerCase().trim() : '';\n  };\n\n  return LowerCaseSanitizer;\n}();\n/**\n * Find and return a nested object value.\n *\n * @param object to crawl\n * @param path Property path\n * @returns {any}\n */\n\n\nfunction getNestedFieldValue(object, path) {\n  path = path || [];\n  object = object || {};\n  var value = object; // walk down the property path\n\n  for (var i = 0; i < path.length; i++) {\n    value = value[path[i]];\n\n    if (value == null) {\n      return null;\n    }\n  }\n\n  return value;\n}\n/**\n * Search index capable of returning results matching a set of tokens and ranked according to TF-IDF.\n */\n\n\nvar TfIdfSearchIndex = /*#__PURE__*/function () {\n  function TfIdfSearchIndex(uidFieldName) {\n    this._uidFieldName = uidFieldName;\n    this._tokenToIdfCache = {};\n    this._tokenMap = {};\n  }\n  /**\n   * @inheritDocs\n   */\n\n\n  var _proto = TfIdfSearchIndex.prototype;\n\n  _proto.indexDocument = function indexDocument(token, uid, doc) {\n    this._tokenToIdfCache = {}; // New index invalidates previous IDF caches\n\n    var tokenMap = this._tokenMap;\n    var tokenDatum;\n\n    if (typeof tokenMap[token] !== 'object') {\n      tokenMap[token] = tokenDatum = {\n        $numDocumentOccurrences: 0,\n        $totalNumOccurrences: 1,\n        $uidMap: {}\n      };\n    } else {\n      tokenDatum = tokenMap[token];\n      tokenDatum.$totalNumOccurrences++;\n    }\n\n    var uidMap = tokenDatum.$uidMap;\n\n    if (typeof uidMap[uid] !== 'object') {\n      tokenDatum.$numDocumentOccurrences++;\n      uidMap[uid] = {\n        $document: doc,\n        $numTokenOccurrences: 1\n      };\n    } else {\n      uidMap[uid].$numTokenOccurrences++;\n    }\n  }\n  /**\n   * @inheritDocs\n   */\n  ;\n\n  _proto.search = function search(tokens, corpus) {\n    var uidToDocumentMap = {};\n\n    for (var i = 0, numTokens = tokens.length; i < numTokens; i++) {\n      var token = tokens[i];\n      var tokenMetadata = this._tokenMap[token]; // Short circuit if no matches were found for any given token.\n\n      if (!tokenMetadata) {\n        return [];\n      }\n\n      if (i === 0) {\n        var keys = Object.keys(tokenMetadata.$uidMap);\n\n        for (var j = 0, numKeys = keys.length; j < numKeys; j++) {\n          var uid = keys[j];\n          uidToDocumentMap[uid] = tokenMetadata.$uidMap[uid].$document;\n        }\n      } else {\n        var keys = Object.keys(uidToDocumentMap);\n\n        for (var j = 0, numKeys = keys.length; j < numKeys; j++) {\n          var uid = keys[j];\n\n          if (typeof tokenMetadata.$uidMap[uid] !== 'object') {\n            delete uidToDocumentMap[uid];\n          }\n        }\n      }\n    }\n\n    var documents = [];\n\n    for (var uid in uidToDocumentMap) {\n      documents.push(uidToDocumentMap[uid]);\n    }\n\n    var calculateTfIdf = this._createCalculateTfIdf(); // Return documents sorted by TF-IDF\n\n\n    return documents.sort(function (documentA, documentB) {\n      return calculateTfIdf(tokens, documentB, corpus) - calculateTfIdf(tokens, documentA, corpus);\n    });\n  };\n\n  _proto._createCalculateIdf = function _createCalculateIdf() {\n    var tokenMap = this._tokenMap;\n    var tokenToIdfCache = this._tokenToIdfCache;\n    return function calculateIdf(token, documents) {\n      if (!tokenToIdfCache[token]) {\n        var numDocumentsWithToken = typeof tokenMap[token] !== 'undefined' ? tokenMap[token].$numDocumentOccurrences : 0;\n        tokenToIdfCache[token] = 1 + Math.log(documents.length / (1 + numDocumentsWithToken));\n      }\n\n      return tokenToIdfCache[token];\n    };\n  };\n\n  _proto._createCalculateTfIdf = function _createCalculateTfIdf() {\n    var tokenMap = this._tokenMap;\n    var uidFieldName = this._uidFieldName;\n\n    var calculateIdf = this._createCalculateIdf();\n\n    return function calculateTfIdf(tokens, document, documents) {\n      var score = 0;\n\n      for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {\n        var token = tokens[i];\n        var inverseDocumentFrequency = calculateIdf(token, documents);\n\n        if (inverseDocumentFrequency === Infinity) {\n          inverseDocumentFrequency = 0;\n        }\n\n        var uid;\n\n        if (uidFieldName instanceof Array) {\n          uid = document && getNestedFieldValue(document, uidFieldName);\n        } else {\n          uid = document && document[uidFieldName];\n        }\n\n        var termFrequency = typeof tokenMap[token] !== 'undefined' && typeof tokenMap[token].$uidMap[uid] !== 'undefined' ? tokenMap[token].$uidMap[uid].$numTokenOccurrences : 0;\n        score += termFrequency * inverseDocumentFrequency;\n      }\n\n      return score;\n    };\n  };\n\n  return TfIdfSearchIndex;\n}();\n/**\n * Search index capable of returning results matching a set of tokens but without any meaningful rank or order.\n */\n\n\nvar UnorderedSearchIndex = /*#__PURE__*/function () {\n  function UnorderedSearchIndex() {\n    this._tokenToUidToDocumentMap = {};\n  }\n  /**\n   * @inheritDocs\n   */\n\n\n  var _proto = UnorderedSearchIndex.prototype;\n\n  _proto.indexDocument = function indexDocument(token, uid, doc) {\n    if (typeof this._tokenToUidToDocumentMap[token] !== 'object') {\n      this._tokenToUidToDocumentMap[token] = {};\n    }\n\n    this._tokenToUidToDocumentMap[token][uid] = doc;\n  }\n  /**\n   * @inheritDocs\n   */\n  ;\n\n  _proto.search = function search(tokens, corpus) {\n    var intersectingDocumentMap = {};\n    var tokenToUidToDocumentMap = this._tokenToUidToDocumentMap;\n\n    for (var i = 0, numTokens = tokens.length; i < numTokens; i++) {\n      var token = tokens[i];\n      var documentMap = tokenToUidToDocumentMap[token]; // Short circuit if no matches were found for any given token.\n\n      if (!documentMap) {\n        return [];\n      }\n\n      if (i === 0) {\n        var keys = Object.keys(documentMap);\n\n        for (var j = 0, numKeys = keys.length; j < numKeys; j++) {\n          var uid = keys[j];\n          intersectingDocumentMap[uid] = documentMap[uid];\n        }\n      } else {\n        var keys = Object.keys(intersectingDocumentMap);\n\n        for (var j = 0, numKeys = keys.length; j < numKeys; j++) {\n          var uid = keys[j];\n\n          if (typeof documentMap[uid] !== 'object') {\n            delete intersectingDocumentMap[uid];\n          }\n        }\n      }\n    }\n\n    var keys = Object.keys(intersectingDocumentMap);\n    var documents = [];\n\n    for (var i = 0, numKeys = keys.length; i < numKeys; i++) {\n      var uid = keys[i];\n      documents.push(intersectingDocumentMap[uid]);\n    }\n\n    return documents;\n  };\n\n  return UnorderedSearchIndex;\n}();\n\nvar REGEX = /[^a-zа-яё0-9\\-']+/i;\n/**\n * Simple tokenizer that splits strings on whitespace characters and returns an array of all non-empty substrings.\n */\n\nvar SimpleTokenizer = /*#__PURE__*/function () {\n  function SimpleTokenizer() {}\n\n  var _proto = SimpleTokenizer.prototype;\n  /**\n   * @inheritDocs\n   */\n\n  _proto.tokenize = function tokenize(text) {\n    return text.split(REGEX).filter(function (text) {\n      return text;\n    } // Filter empty tokens\n    );\n  };\n\n  return SimpleTokenizer;\n}();\n/**\n * Stemming is the process of reducing search tokens to their root (or stem) so that searches for different forms of a\n * word will match. For example \"search\", \"searching\" and \"searched\" are all reduced to the stem \"search\".\n *\n * <p>This stemming tokenizer converts tokens (words) to their stem forms before returning them. It requires an\n * external stemming function to be provided; for this purpose I recommend the NPM 'porter-stemmer' library.\n *\n * <p>For more information see http : //tartarus.org/~martin/PorterStemmer/\n */\n\n\nvar StemmingTokenizer = /*#__PURE__*/function () {\n  /**\n   * Constructor.\n   *\n   * @param stemmingFunction Function capable of accepting a word and returning its stem.\n   * @param decoratedIndexStrategy Index strategy to be run after all stop words have been removed.\n   */\n  function StemmingTokenizer(stemmingFunction, decoratedTokenizer) {\n    this._stemmingFunction = stemmingFunction;\n    this._tokenizer = decoratedTokenizer;\n  }\n  /**\n   * @inheritDocs\n   */\n\n\n  var _proto = StemmingTokenizer.prototype;\n\n  _proto.tokenize = function tokenize(text) {\n    return this._tokenizer.tokenize(text).map(this._stemmingFunction);\n  };\n\n  return StemmingTokenizer;\n}();\n/**\n * Stop words list copied from Lunr JS.\n */\n\n\nvar StopWordsMap = {\n  a: true,\n  able: true,\n  about: true,\n  across: true,\n  after: true,\n  all: true,\n  almost: true,\n  also: true,\n  am: true,\n  among: true,\n  an: true,\n  and: true,\n  any: true,\n  are: true,\n  as: true,\n  at: true,\n  be: true,\n  because: true,\n  been: true,\n  but: true,\n  by: true,\n  can: true,\n  cannot: true,\n  could: true,\n  dear: true,\n  did: true,\n  'do': true,\n  does: true,\n  either: true,\n  'else': true,\n  ever: true,\n  every: true,\n  'for': true,\n  from: true,\n  'get': true,\n  got: true,\n  had: true,\n  has: true,\n  have: true,\n  he: true,\n  her: true,\n  hers: true,\n  him: true,\n  his: true,\n  how: true,\n  however: true,\n  i: true,\n  'if': true,\n  'in': true,\n  into: true,\n  is: true,\n  it: true,\n  its: true,\n  just: true,\n  least: true,\n  \"let\": true,\n  like: true,\n  likely: true,\n  may: true,\n  me: true,\n  might: true,\n  most: true,\n  must: true,\n  my: true,\n  neither: true,\n  no: true,\n  nor: true,\n  not: true,\n  of: true,\n  off: true,\n  often: true,\n  on: true,\n  only: true,\n  or: true,\n  other: true,\n  our: true,\n  own: true,\n  rather: true,\n  said: true,\n  say: true,\n  says: true,\n  she: true,\n  should: true,\n  since: true,\n  so: true,\n  some: true,\n  than: true,\n  that: true,\n  the: true,\n  their: true,\n  them: true,\n  then: true,\n  there: true,\n  these: true,\n  they: true,\n  'this': true,\n  tis: true,\n  to: true,\n  too: true,\n  twas: true,\n  us: true,\n  wants: true,\n  was: true,\n  we: true,\n  were: true,\n  what: true,\n  when: true,\n  where: true,\n  which: true,\n  'while': true,\n  who: true,\n  whom: true,\n  why: true,\n  will: true,\n  'with': true,\n  would: true,\n  yet: true,\n  you: true,\n  your: true\n}; // Prevent false positives for inherited properties\n\nStopWordsMap.constructor = false;\nStopWordsMap.hasOwnProperty = false;\nStopWordsMap.isPrototypeOf = false;\nStopWordsMap.propertyIsEnumerable = false;\nStopWordsMap.toLocaleString = false;\nStopWordsMap.toString = false;\nStopWordsMap.valueOf = false;\n/**\n * Stop words are very common (e.g. \"a\", \"and\", \"the\") and are often not semantically meaningful in the context of a\n * search. This tokenizer removes stop words from a set of tokens before passing the remaining tokens along for\n * indexing or searching purposes.\n */\n\nvar StopWordsTokenizer = /*#__PURE__*/function () {\n  /**\n   * Constructor.\n   *\n   * @param decoratedIndexStrategy Index strategy to be run after all stop words have been removed.\n   */\n  function StopWordsTokenizer(decoratedTokenizer) {\n    this._tokenizer = decoratedTokenizer;\n  }\n  /**\n   * @inheritDocs\n   */\n\n\n  var _proto = StopWordsTokenizer.prototype;\n\n  _proto.tokenize = function tokenize(text) {\n    return this._tokenizer.tokenize(text).filter(function (token) {\n      return !StopWordsMap[token];\n    });\n  };\n\n  return StopWordsTokenizer;\n}();\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n/**\n * Simple client-side searching within a set of documents.\n *\n * <p>Documents can be searched by any number of fields. Indexing and search strategies are highly customizable.\n */\n\n\nvar Search = /*#__PURE__*/function () {\n  /**\n   * Array containing either a property name or a path (list of property names) to a nested value\n   */\n\n  /**\n   * Constructor.\n   * @param uidFieldName Field containing values that uniquely identify search documents; this field's values are used\n   *                     to ensure that a search result set does not contain duplicate objects.\n   */\n  function Search(uidFieldName) {\n    if (!uidFieldName) {\n      throw Error('js-search requires a uid field name constructor parameter');\n    }\n\n    this._uidFieldName = uidFieldName; // Set default/recommended strategies\n\n    this._indexStrategy = new PrefixIndexStrategy();\n    this._searchIndex = new TfIdfSearchIndex(uidFieldName);\n    this._sanitizer = new LowerCaseSanitizer();\n    this._tokenizer = new SimpleTokenizer();\n    this._documents = [];\n    this._searchableFields = [];\n  }\n  /**\n   * Override the default index strategy.\n   * @param value Custom index strategy\n   * @throws Error if documents have already been indexed by this search instance\n   */\n\n\n  var _proto = Search.prototype;\n  /**\n   * Add a searchable document to the index. Document will automatically be indexed for search.\n   * @param document\n   */\n\n  _proto.addDocument = function addDocument(document) {\n    this.addDocuments([document]);\n  }\n  /**\n   * Adds searchable documents to the index. Documents will automatically be indexed for search.\n   * @param document\n   */\n  ;\n\n  _proto.addDocuments = function addDocuments(documents) {\n    this._documents = this._documents.concat(documents);\n    this.indexDocuments_(documents, this._searchableFields);\n  }\n  /**\n   * Add a new searchable field to the index. Existing documents will automatically be indexed using this new field.\n   *\n   * @param field Searchable field or field path. Pass a string to index a top-level field and an array of strings for nested fields.\n   */\n  ;\n\n  _proto.addIndex = function addIndex(field) {\n    this._searchableFields.push(field);\n\n    this.indexDocuments_(this._documents, [field]);\n  }\n  /**\n   * Search all documents for ones matching the specified query text.\n   * @param query\n   * @returns {Array<Object>}\n   */\n  ;\n\n  _proto.search = function search(query) {\n    var tokens = this._tokenizer.tokenize(this._sanitizer.sanitize(query));\n\n    return this._searchIndex.search(tokens, this._documents);\n  }\n  /**\n   * @param documents\n   * @param _searchableFields Array containing property names and paths (lists of property names) to nested values\n   * @private\n   */\n  ;\n\n  _proto.indexDocuments_ = function indexDocuments_(documents, _searchableFields) {\n    this._initialized = true;\n    var indexStrategy = this._indexStrategy;\n    var sanitizer = this._sanitizer;\n    var searchIndex = this._searchIndex;\n    var tokenizer = this._tokenizer;\n    var uidFieldName = this._uidFieldName;\n\n    for (var di = 0, numDocuments = documents.length; di < numDocuments; di++) {\n      var doc = documents[di];\n      var uid;\n\n      if (uidFieldName instanceof Array) {\n        uid = getNestedFieldValue(doc, uidFieldName);\n      } else {\n        uid = doc[uidFieldName];\n      }\n\n      for (var sfi = 0, numSearchableFields = _searchableFields.length; sfi < numSearchableFields; sfi++) {\n        var fieldValue;\n        var searchableField = _searchableFields[sfi];\n\n        if (searchableField instanceof Array) {\n          fieldValue = getNestedFieldValue(doc, searchableField);\n        } else {\n          fieldValue = doc[searchableField];\n        }\n\n        if (fieldValue != null && typeof fieldValue !== 'string' && fieldValue.toString) {\n          fieldValue = fieldValue.toString();\n        }\n\n        if (typeof fieldValue === 'string') {\n          var fieldTokens = tokenizer.tokenize(sanitizer.sanitize(fieldValue));\n\n          for (var fti = 0, numFieldValues = fieldTokens.length; fti < numFieldValues; fti++) {\n            var fieldToken = fieldTokens[fti];\n            var expandedTokens = indexStrategy.expandToken(fieldToken);\n\n            for (var eti = 0, nummExpandedTokens = expandedTokens.length; eti < nummExpandedTokens; eti++) {\n              var expandedToken = expandedTokens[eti];\n              searchIndex.indexDocument(expandedToken, uid, doc);\n            }\n          }\n        }\n      }\n    }\n  };\n\n  _createClass(Search, [{\n    key: \"indexStrategy\",\n    set: function set(value) {\n      if (this._initialized) {\n        throw Error('IIndexStrategy cannot be set after initialization');\n      }\n\n      this._indexStrategy = value;\n    },\n    get: function get() {\n      return this._indexStrategy;\n    }\n    /**\n     * Override the default text sanitizing strategy.\n     * @param value Custom text sanitizing strategy\n     * @throws Error if documents have already been indexed by this search instance\n     */\n\n  }, {\n    key: \"sanitizer\",\n    set: function set(value) {\n      if (this._initialized) {\n        throw Error('ISanitizer cannot be set after initialization');\n      }\n\n      this._sanitizer = value;\n    },\n    get: function get() {\n      return this._sanitizer;\n    }\n    /**\n     * Override the default search index strategy.\n     * @param value Custom search index strategy\n     * @throws Error if documents have already been indexed\n     */\n\n  }, {\n    key: \"searchIndex\",\n    set: function set(value) {\n      if (this._initialized) {\n        throw Error('ISearchIndex cannot be set after initialization');\n      }\n\n      this._searchIndex = value;\n    },\n    get: function get() {\n      return this._searchIndex;\n    }\n    /**\n     * Override the default text tokenizing strategy.\n     * @param value Custom text tokenizing strategy\n     * @throws Error if documents have already been indexed by this search instance\n     */\n\n  }, {\n    key: \"tokenizer\",\n    set: function set(value) {\n      if (this._initialized) {\n        throw Error('ITokenizer cannot be set after initialization');\n      }\n\n      this._tokenizer = value;\n    },\n    get: function get() {\n      return this._tokenizer;\n    }\n  }]);\n\n  return Search;\n}();\n/**\n * This utility highlights the occurrences of tokens within a string of text. It can be used to give visual indicators\n * of match criteria within searchable fields.\n *\n * <p>For performance purposes this highlighter only works with full-word or prefix token indexes.\n */\n\n\nvar TokenHighlighter = /*#__PURE__*/function () {\n  /**\n   * Constructor.\n   *\n   * @param opt_indexStrategy Index strategy used by Search\n   * @param opt_sanitizer Sanitizer used by Search\n   * @param opt_wrapperTagName Optional wrapper tag name; defaults to 'mark' (e.g. <mark>)\n   */\n  function TokenHighlighter(opt_indexStrategy, opt_sanitizer, opt_wrapperTagName) {\n    this._indexStrategy = opt_indexStrategy || new PrefixIndexStrategy();\n    this._sanitizer = opt_sanitizer || new LowerCaseSanitizer();\n    this._wrapperTagName = opt_wrapperTagName || 'mark';\n  }\n  /**\n   * Highlights token occurrences within a string by wrapping them with a DOM element.\n   *\n   * @param text e.g. \"john wayne\"\n   * @param tokens e.g. [\"wa\"]\n   * @returns {string} e.g. \"john <mark>wa</mark>yne\"\n   */\n\n\n  var _proto = TokenHighlighter.prototype;\n\n  _proto.highlight = function highlight(text, tokens) {\n    var tagsLength = this._wrapText('').length;\n\n    var tokenDictionary = Object.create(null); // Create a token map for easier lookup below.\n\n    for (var i = 0, numTokens = tokens.length; i < numTokens; i++) {\n      var token = this._sanitizer.sanitize(tokens[i]);\n\n      var expandedTokens = this._indexStrategy.expandToken(token);\n\n      for (var j = 0, numExpandedTokens = expandedTokens.length; j < numExpandedTokens; j++) {\n        var expandedToken = expandedTokens[j];\n\n        if (!tokenDictionary[expandedToken]) {\n          tokenDictionary[expandedToken] = [token];\n        } else {\n          tokenDictionary[expandedToken].push(token);\n        }\n      }\n    } // Track actualCurrentWord and sanitizedCurrentWord separately in case we encounter nested tags.\n\n\n    var actualCurrentWord = '';\n    var sanitizedCurrentWord = '';\n    var currentWordStartIndex = 0; // Note this assumes either prefix or full word matching.\n\n    for (var i = 0, textLength = text.length; i < textLength; i++) {\n      var character = text.charAt(i);\n\n      if (character === ' ') {\n        actualCurrentWord = '';\n        sanitizedCurrentWord = '';\n        currentWordStartIndex = i + 1;\n      } else {\n        actualCurrentWord += character;\n        sanitizedCurrentWord += this._sanitizer.sanitize(character);\n      }\n\n      if (tokenDictionary[sanitizedCurrentWord] && tokenDictionary[sanitizedCurrentWord].indexOf(sanitizedCurrentWord) >= 0) {\n        actualCurrentWord = this._wrapText(actualCurrentWord);\n        text = text.substring(0, currentWordStartIndex) + actualCurrentWord + text.substring(i + 1);\n        i += tagsLength;\n        textLength += tagsLength;\n      }\n    }\n\n    return text;\n  }\n  /**\n   * @param text to wrap\n   * @returns Text wrapped by wrapper tag (e.g. \"foo\" becomes \"<mark>foo</mark>\")\n   * @private\n   */\n  ;\n\n  _proto._wrapText = function _wrapText(text) {\n    var tagName = this._wrapperTagName;\n    return \"<\" + tagName + \">\" + text + \"</\" + tagName + \">\";\n  };\n\n  return TokenHighlighter;\n}();\n\nexport { AllSubstringsIndexStrategy, CaseSensitiveSanitizer, ExactWordIndexStrategy, LowerCaseSanitizer, PrefixIndexStrategy, Search, SimpleTokenizer, StemmingTokenizer, StopWordsMap, StopWordsTokenizer, TfIdfSearchIndex, TokenHighlighter, UnorderedSearchIndex };","import React, { useState } from 'react'\nimport { FontAwesomeIcon } from '@fortawesome/react-fontawesome'\nimport { faSearch } from '@fortawesome/free-solid-svg-icons'\nimport '../css/_searchBar.scss'\n\nconst SearchBar = ({ onQuery, placeholder }) => {\n\n  const [textInput, setTextInput] = useState('')\n\n  const handleInputChange = (txt) => {\n    setTextInput(txt.target.value) // Seteando valor de textInput\n    if (txt.target.value.length >= 3 || txt.target.value.length === 0) {\n      onQuery(txt.target.value) // Buscando segun valor ingresado\n    }\n  }\n\n  const handlePressKey = (e) => {\n    if (((e.charCode === 13) && (textInput.length >= 3)) || (e.charCode === 13 && textInput.length === 0)) {\n      onQuery(textInput, e) // Buscando segun valor del textInput\n    }\n  }\n\n  const handleClick = (e) => {\n    onQuery(textInput, e)\n  }\n  \n  return (\n    <div className='searchBar'>\n      <div className=\"inputContainer p-md-1\">\n        <input\n          type=\"text\"\n          placeholder={placeholder}\n          value={textInput}\n          onChange={handleInputChange}\n          onKeyDown={handlePressKey}\n        />\n        <button onClick={handleClick}>\n          <FontAwesomeIcon icon={faSearch}  />\n        </button>\n      </div>\n\n    </div>\n  )\n}\n\nexport default SearchBar","export default __webpack_public_path__ + \"static/newspaper-9048c7494e4f9bd46a2835fc9c3b0bf3.png\";"],"sourceRoot":""}