{"version":3,"file":"2d7a8ebab7046e0d956cde851273ecbb2a0f4a63-1ce9d57bfadc76a344d5.js","mappings":"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","sources":["webpack://@kensho/public-api-docs/./node_modules/@kensho/icons/esm/IconSearch.js","webpack://@kensho/public-api-docs/./node_modules/@kensho/icons/esm/IconXSmall.js","webpack://@kensho/public-api-docs/./node_modules/lunr/lunr.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/add-to-unscopables.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/array-species-constructor.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/array-species-create.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/classof.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/does-not-exceed-safe-integer.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/flatten-into-array.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/function-bind-context.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/html.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/is-array.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/is-constructor.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/object-create.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/object-define-properties.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/object-keys.js","webpack://@kensho/public-api-docs/./node_modules/core-js/internals/to-string-tag-support.js","webpack://@kensho/public-api-docs/./node_modules/core-js/modules/es.array.flat.js","webpack://@kensho/public-api-docs/./node_modules/core-js/modules/es.array.unscopables.flat.js","webpack://@kensho/public-api-docs/./src/components/SearchResult.tsx","webpack://@kensho/public-api-docs/./src/hooks/useMultiSearchIndex.ts","webpack://@kensho/public-api-docs/./src/hooks/useTOCHighlight.ts","webpack://@kensho/public-api-docs/./src/components/nav/NavItem.tsx","webpack://@kensho/public-api-docs/./src/components/nav/Sidebar.tsx","webpack://@kensho/public-api-docs/./src/components/ButtonLink.tsx","webpack://@kensho/public-api-docs/./src/layouts/PageWithNav.tsx","webpack://@kensho/public-api-docs/./src/hooks/useDelay.tsx","webpack://@kensho/public-api-docs/./src/providers/NavigationContext.tsx","webpack://@kensho/public-api-docs/./src/providers/NavigationProvider.tsx","webpack://@kensho/public-api-docs/./src/providers/VersionProvider.tsx","webpack://@kensho/public-api-docs/./node_modules/lodash/_baseTrim.js","webpack://@kensho/public-api-docs/./node_modules/lodash/_trimmedEndIndex.js","webpack://@kensho/public-api-docs/./node_modules/lodash/debounce.js","webpack://@kensho/public-api-docs/./node_modules/lodash/now.js","webpack://@kensho/public-api-docs/./node_modules/lodash/throttle.js","webpack://@kensho/public-api-docs/./node_modules/lodash/toNumber.js","webpack://@kensho/public-api-docs/./node_modules/@babel/runtime/helpers/construct.js","webpack://@kensho/public-api-docs/./node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js"],"sourcesContent":["import icon from './icon';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nvar Icon = icon(\"-629 392 20 17\", \"Search\", /*#__PURE__*/_jsx(\"path\", {\n  d: \"M-621.2 403.7c1.3 0 2.6-.5 3.5-1.3l1.4 1.4-.4.4 4 4 1.4-1.4-4-4-.4.4-1.4-1.4c.8-1 1.3-2.2 1.3-3.5 0-3-2.5-5.5-5.5-5.5s-5.5 2.5-5.5 5.5 2.6 5.4 5.6 5.4zm0-10c2.5 0 4.5 2 4.5 4.5s-2 4.5-4.5 4.5-4.5-2-4.5-4.5 2-4.5 4.5-4.5z\"\n}));\nif (process.env.NODE_ENV !== 'production') Icon.displayName = \"IconSearch\";\nexport default Icon;","import icon from './icon';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nvar Icon = icon(\"0 0 20 17\", \"X Small\", /*#__PURE__*/_jsx(\"path\", {\n  d: \"m13.72 5.49-.7-.71L10 7.79 6.98 4.78l-.7.71L9.29 8.5l-3.01 3.02.7.7L10 9.21l3.02 3.01.7-.7-3.01-3.02 3.01-3.01z\"\n}));\nif (process.env.NODE_ENV !== 'production') Icon.displayName = \"IconXSmall\";\nexport default Icon;","/**\n * lunr - http://lunrjs.com - A bit like Solr, but much smaller and not as bright - 2.3.9\n * Copyright (C) 2020 Oliver Nightingale\n * @license MIT\n */\n\n;\n(function () {\n  /**\n   * A convenience function for configuring and constructing\n   * a new lunr Index.\n   *\n   * A lunr.Builder instance is created and the pipeline setup\n   * with a trimmer, stop word filter and stemmer.\n   *\n   * This builder object is yielded to the configuration function\n   * that is passed as a parameter, allowing the list of fields\n   * and other builder parameters to be customised.\n   *\n   * All documents _must_ be added within the passed config function.\n   *\n   * @example\n   * var idx = lunr(function () {\n   *   this.field('title')\n   *   this.field('body')\n   *   this.ref('id')\n   *\n   *   documents.forEach(function (doc) {\n   *     this.add(doc)\n   *   }, this)\n   * })\n   *\n   * @see {@link lunr.Builder}\n   * @see {@link lunr.Pipeline}\n   * @see {@link lunr.trimmer}\n   * @see {@link lunr.stopWordFilter}\n   * @see {@link lunr.stemmer}\n   * @namespace {function} lunr\n   */\n  var lunr = function lunr(config) {\n    var builder = new lunr.Builder();\n    builder.pipeline.add(lunr.trimmer, lunr.stopWordFilter, lunr.stemmer);\n    builder.searchPipeline.add(lunr.stemmer);\n    config.call(builder, builder);\n    return builder.build();\n  };\n  lunr.version = \"2.3.9\";\n  /*!\n   * lunr.utils\n   * Copyright (C) 2020 Oliver Nightingale\n   */\n\n  /**\n   * A namespace containing utils for the rest of the lunr library\n   * @namespace lunr.utils\n   */\n  lunr.utils = {};\n\n  /**\n   * Print a warning message to the console.\n   *\n   * @param {String} message The message to be printed.\n   * @memberOf lunr.utils\n   * @function\n   */\n  lunr.utils.warn = function (global) {\n    /* eslint-disable no-console */\n    return function (message) {\n      if (global.console && console.warn) {\n        console.warn(message);\n      }\n    };\n    /* eslint-enable no-console */\n  }(this);\n\n  /**\n   * Convert an object to a string.\n   *\n   * In the case of `null` and `undefined` the function returns\n   * the empty string, in all other cases the result of calling\n   * `toString` on the passed object is returned.\n   *\n   * @param {Any} obj The object to convert to a string.\n   * @return {String} string representation of the passed object.\n   * @memberOf lunr.utils\n   */\n  lunr.utils.asString = function (obj) {\n    if (obj === void 0 || obj === null) {\n      return \"\";\n    } else {\n      return obj.toString();\n    }\n  };\n\n  /**\n   * Clones an object.\n   *\n   * Will create a copy of an existing object such that any mutations\n   * on the copy cannot affect the original.\n   *\n   * Only shallow objects are supported, passing a nested object to this\n   * function will cause a TypeError.\n   *\n   * Objects with primitives, and arrays of primitives are supported.\n   *\n   * @param {Object} obj The object to clone.\n   * @return {Object} a clone of the passed object.\n   * @throws {TypeError} when a nested object is passed.\n   * @memberOf Utils\n   */\n  lunr.utils.clone = function (obj) {\n    if (obj === null || obj === undefined) {\n      return obj;\n    }\n    var clone = Object.create(null),\n      keys = Object.keys(obj);\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i],\n        val = obj[key];\n      if (Array.isArray(val)) {\n        clone[key] = val.slice();\n        continue;\n      }\n      if (typeof val === 'string' || typeof val === 'number' || typeof val === 'boolean') {\n        clone[key] = val;\n        continue;\n      }\n      throw new TypeError(\"clone is not deep and does not support nested objects\");\n    }\n    return clone;\n  };\n  lunr.FieldRef = function (docRef, fieldName, stringValue) {\n    this.docRef = docRef;\n    this.fieldName = fieldName;\n    this._stringValue = stringValue;\n  };\n  lunr.FieldRef.joiner = \"/\";\n  lunr.FieldRef.fromString = function (s) {\n    var n = s.indexOf(lunr.FieldRef.joiner);\n    if (n === -1) {\n      throw \"malformed field ref string\";\n    }\n    var fieldRef = s.slice(0, n),\n      docRef = s.slice(n + 1);\n    return new lunr.FieldRef(docRef, fieldRef, s);\n  };\n  lunr.FieldRef.prototype.toString = function () {\n    if (this._stringValue == undefined) {\n      this._stringValue = this.fieldName + lunr.FieldRef.joiner + this.docRef;\n    }\n    return this._stringValue;\n  };\n  /*!\n   * lunr.Set\n   * Copyright (C) 2020 Oliver Nightingale\n   */\n\n  /**\n   * A lunr set.\n   *\n   * @constructor\n   */\n  lunr.Set = function (elements) {\n    this.elements = Object.create(null);\n    if (elements) {\n      this.length = elements.length;\n      for (var i = 0; i < this.length; i++) {\n        this.elements[elements[i]] = true;\n      }\n    } else {\n      this.length = 0;\n    }\n  };\n\n  /**\n   * A complete set that contains all elements.\n   *\n   * @static\n   * @readonly\n   * @type {lunr.Set}\n   */\n  lunr.Set.complete = {\n    intersect: function intersect(other) {\n      return other;\n    },\n    union: function union() {\n      return this;\n    },\n    contains: function contains() {\n      return true;\n    }\n  };\n\n  /**\n   * An empty set that contains no elements.\n   *\n   * @static\n   * @readonly\n   * @type {lunr.Set}\n   */\n  lunr.Set.empty = {\n    intersect: function intersect() {\n      return this;\n    },\n    union: function union(other) {\n      return other;\n    },\n    contains: function contains() {\n      return false;\n    }\n  };\n\n  /**\n   * Returns true if this set contains the specified object.\n   *\n   * @param {object} object - Object whose presence in this set is to be tested.\n   * @returns {boolean} - True if this set contains the specified object.\n   */\n  lunr.Set.prototype.contains = function (object) {\n    return !!this.elements[object];\n  };\n\n  /**\n   * Returns a new set containing only the elements that are present in both\n   * this set and the specified set.\n   *\n   * @param {lunr.Set} other - set to intersect with this set.\n   * @returns {lunr.Set} a new set that is the intersection of this and the specified set.\n   */\n\n  lunr.Set.prototype.intersect = function (other) {\n    var a,\n      b,\n      elements,\n      intersection = [];\n    if (other === lunr.Set.complete) {\n      return this;\n    }\n    if (other === lunr.Set.empty) {\n      return other;\n    }\n    if (this.length < other.length) {\n      a = this;\n      b = other;\n    } else {\n      a = other;\n      b = this;\n    }\n    elements = Object.keys(a.elements);\n    for (var i = 0; i < elements.length; i++) {\n      var element = elements[i];\n      if (element in b.elements) {\n        intersection.push(element);\n      }\n    }\n    return new lunr.Set(intersection);\n  };\n\n  /**\n   * Returns a new set combining the elements of this and the specified set.\n   *\n   * @param {lunr.Set} other - set to union with this set.\n   * @return {lunr.Set} a new set that is the union of this and the specified set.\n   */\n\n  lunr.Set.prototype.union = function (other) {\n    if (other === lunr.Set.complete) {\n      return lunr.Set.complete;\n    }\n    if (other === lunr.Set.empty) {\n      return this;\n    }\n    return new lunr.Set(Object.keys(this.elements).concat(Object.keys(other.elements)));\n  };\n  /**\n   * A function to calculate the inverse document frequency for\n   * a posting. This is shared between the builder and the index\n   *\n   * @private\n   * @param {object} posting - The posting for a given term\n   * @param {number} documentCount - The total number of documents.\n   */\n  lunr.idf = function (posting, documentCount) {\n    var documentsWithTerm = 0;\n    for (var fieldName in posting) {\n      if (fieldName == '_index') continue; // Ignore the term index, its not a field\n      documentsWithTerm += Object.keys(posting[fieldName]).length;\n    }\n    var x = (documentCount - documentsWithTerm + 0.5) / (documentsWithTerm + 0.5);\n    return Math.log(1 + Math.abs(x));\n  };\n\n  /**\n   * A token wraps a string representation of a token\n   * as it is passed through the text processing pipeline.\n   *\n   * @constructor\n   * @param {string} [str=''] - The string token being wrapped.\n   * @param {object} [metadata={}] - Metadata associated with this token.\n   */\n  lunr.Token = function (str, metadata) {\n    this.str = str || \"\";\n    this.metadata = metadata || {};\n  };\n\n  /**\n   * Returns the token string that is being wrapped by this object.\n   *\n   * @returns {string}\n   */\n  lunr.Token.prototype.toString = function () {\n    return this.str;\n  };\n\n  /**\n   * A token update function is used when updating or optionally\n   * when cloning a token.\n   *\n   * @callback lunr.Token~updateFunction\n   * @param {string} str - The string representation of the token.\n   * @param {Object} metadata - All metadata associated with this token.\n   */\n\n  /**\n   * Applies the given function to the wrapped string token.\n   *\n   * @example\n   * token.update(function (str, metadata) {\n   *   return str.toUpperCase()\n   * })\n   *\n   * @param {lunr.Token~updateFunction} fn - A function to apply to the token string.\n   * @returns {lunr.Token}\n   */\n  lunr.Token.prototype.update = function (fn) {\n    this.str = fn(this.str, this.metadata);\n    return this;\n  };\n\n  /**\n   * Creates a clone of this token. Optionally a function can be\n   * applied to the cloned token.\n   *\n   * @param {lunr.Token~updateFunction} [fn] - An optional function to apply to the cloned token.\n   * @returns {lunr.Token}\n   */\n  lunr.Token.prototype.clone = function (fn) {\n    fn = fn || function (s) {\n      return s;\n    };\n    return new lunr.Token(fn(this.str, this.metadata), this.metadata);\n  };\n  /*!\n   * lunr.tokenizer\n   * Copyright (C) 2020 Oliver Nightingale\n   */\n\n  /**\n   * A function for splitting a string into tokens ready to be inserted into\n   * the search index. Uses `lunr.tokenizer.separator` to split strings, change\n   * the value of this property to change how strings are split into tokens.\n   *\n   * This tokenizer will convert its parameter to a string by calling `toString` and\n   * then will split this string on the character in `lunr.tokenizer.separator`.\n   * Arrays will have their elements converted to strings and wrapped in a lunr.Token.\n   *\n   * Optional metadata can be passed to the tokenizer, this metadata will be cloned and\n   * added as metadata to every token that is created from the object to be tokenized.\n   *\n   * @static\n   * @param {?(string|object|object[])} obj - The object to convert into tokens\n   * @param {?object} metadata - Optional metadata to associate with every token\n   * @returns {lunr.Token[]}\n   * @see {@link lunr.Pipeline}\n   */\n  lunr.tokenizer = function (obj, metadata) {\n    if (obj == null || obj == undefined) {\n      return [];\n    }\n    if (Array.isArray(obj)) {\n      return obj.map(function (t) {\n        return new lunr.Token(lunr.utils.asString(t).toLowerCase(), lunr.utils.clone(metadata));\n      });\n    }\n    var str = obj.toString().toLowerCase(),\n      len = str.length,\n      tokens = [];\n    for (var sliceEnd = 0, sliceStart = 0; sliceEnd <= len; sliceEnd++) {\n      var char = str.charAt(sliceEnd),\n        sliceLength = sliceEnd - sliceStart;\n      if (char.match(lunr.tokenizer.separator) || sliceEnd == len) {\n        if (sliceLength > 0) {\n          var tokenMetadata = lunr.utils.clone(metadata) || {};\n          tokenMetadata[\"position\"] = [sliceStart, sliceLength];\n          tokenMetadata[\"index\"] = tokens.length;\n          tokens.push(new lunr.Token(str.slice(sliceStart, sliceEnd), tokenMetadata));\n        }\n        sliceStart = sliceEnd + 1;\n      }\n    }\n    return tokens;\n  };\n\n  /**\n   * The separator used to split a string into tokens. Override this property to change the behaviour of\n   * `lunr.tokenizer` behaviour when tokenizing strings. By default this splits on whitespace and hyphens.\n   *\n   * @static\n   * @see lunr.tokenizer\n   */\n  lunr.tokenizer.separator = /[\\s\\-]+/;\n  /*!\n   * lunr.Pipeline\n   * Copyright (C) 2020 Oliver Nightingale\n   */\n\n  /**\n   * lunr.Pipelines maintain an ordered list of functions to be applied to all\n   * tokens in documents entering the search index and queries being ran against\n   * the index.\n   *\n   * An instance of lunr.Index created with the lunr shortcut will contain a\n   * pipeline with a stop word filter and an English language stemmer. Extra\n   * functions can be added before or after either of these functions or these\n   * default functions can be removed.\n   *\n   * When run the pipeline will call each function in turn, passing a token, the\n   * index of that token in the original list of all tokens and finally a list of\n   * all the original tokens.\n   *\n   * The output of functions in the pipeline will be passed to the next function\n   * in the pipeline. To exclude a token from entering the index the function\n   * should return undefined, the rest of the pipeline will not be called with\n   * this token.\n   *\n   * For serialisation of pipelines to work, all functions used in an instance of\n   * a pipeline should be registered with lunr.Pipeline. Registered functions can\n   * then be loaded. If trying to load a serialised pipeline that uses functions\n   * that are not registered an error will be thrown.\n   *\n   * If not planning on serialising the pipeline then registering pipeline functions\n   * is not necessary.\n   *\n   * @constructor\n   */\n  lunr.Pipeline = function () {\n    this._stack = [];\n  };\n  lunr.Pipeline.registeredFunctions = Object.create(null);\n\n  /**\n   * A pipeline function maps lunr.Token to lunr.Token. A lunr.Token contains the token\n   * string as well as all known metadata. A pipeline function can mutate the token string\n   * or mutate (or add) metadata for a given token.\n   *\n   * A pipeline function can indicate that the passed token should be discarded by returning\n   * null, undefined or an empty string. This token will not be passed to any downstream pipeline\n   * functions and will not be added to the index.\n   *\n   * Multiple tokens can be returned by returning an array of tokens. Each token will be passed\n   * to any downstream pipeline functions and all will returned tokens will be added to the index.\n   *\n   * Any number of pipeline functions may be chained together using a lunr.Pipeline.\n   *\n   * @interface lunr.PipelineFunction\n   * @param {lunr.Token} token - A token from the document being processed.\n   * @param {number} i - The index of this token in the complete list of tokens for this document/field.\n   * @param {lunr.Token[]} tokens - All tokens for this document/field.\n   * @returns {(?lunr.Token|lunr.Token[])}\n   */\n\n  /**\n   * Register a function with the pipeline.\n   *\n   * Functions that are used in the pipeline should be registered if the pipeline\n   * needs to be serialised, or a serialised pipeline needs to be loaded.\n   *\n   * Registering a function does not add it to a pipeline, functions must still be\n   * added to instances of the pipeline for them to be used when running a pipeline.\n   *\n   * @param {lunr.PipelineFunction} fn - The function to check for.\n   * @param {String} label - The label to register this function with\n   */\n  lunr.Pipeline.registerFunction = function (fn, label) {\n    if (label in this.registeredFunctions) {\n      lunr.utils.warn('Overwriting existing registered function: ' + label);\n    }\n    fn.label = label;\n    lunr.Pipeline.registeredFunctions[fn.label] = fn;\n  };\n\n  /**\n   * Warns if the function is not registered as a Pipeline function.\n   *\n   * @param {lunr.PipelineFunction} fn - The function to check for.\n   * @private\n   */\n  lunr.Pipeline.warnIfFunctionNotRegistered = function (fn) {\n    var isRegistered = fn.label && fn.label in this.registeredFunctions;\n    if (!isRegistered) {\n      lunr.utils.warn('Function is not registered with pipeline. This may cause problems when serialising the index.\\n', fn);\n    }\n  };\n\n  /**\n   * Loads a previously serialised pipeline.\n   *\n   * All functions to be loaded must already be registered with lunr.Pipeline.\n   * If any function from the serialised data has not been registered then an\n   * error will be thrown.\n   *\n   * @param {Object} serialised - The serialised pipeline to load.\n   * @returns {lunr.Pipeline}\n   */\n  lunr.Pipeline.load = function (serialised) {\n    var pipeline = new lunr.Pipeline();\n    serialised.forEach(function (fnName) {\n      var fn = lunr.Pipeline.registeredFunctions[fnName];\n      if (fn) {\n        pipeline.add(fn);\n      } else {\n        throw new Error('Cannot load unregistered function: ' + fnName);\n      }\n    });\n    return pipeline;\n  };\n\n  /**\n   * Adds new functions to the end of the pipeline.\n   *\n   * Logs a warning if the function has not been registered.\n   *\n   * @param {lunr.PipelineFunction[]} functions - Any number of functions to add to the pipeline.\n   */\n  lunr.Pipeline.prototype.add = function () {\n    var fns = Array.prototype.slice.call(arguments);\n    fns.forEach(function (fn) {\n      lunr.Pipeline.warnIfFunctionNotRegistered(fn);\n      this._stack.push(fn);\n    }, this);\n  };\n\n  /**\n   * Adds a single function after a function that already exists in the\n   * pipeline.\n   *\n   * Logs a warning if the function has not been registered.\n   *\n   * @param {lunr.PipelineFunction} existingFn - A function that already exists in the pipeline.\n   * @param {lunr.PipelineFunction} newFn - The new function to add to the pipeline.\n   */\n  lunr.Pipeline.prototype.after = function (existingFn, newFn) {\n    lunr.Pipeline.warnIfFunctionNotRegistered(newFn);\n    var pos = this._stack.indexOf(existingFn);\n    if (pos == -1) {\n      throw new Error('Cannot find existingFn');\n    }\n    pos = pos + 1;\n    this._stack.splice(pos, 0, newFn);\n  };\n\n  /**\n   * Adds a single function before a function that already exists in the\n   * pipeline.\n   *\n   * Logs a warning if the function has not been registered.\n   *\n   * @param {lunr.PipelineFunction} existingFn - A function that already exists in the pipeline.\n   * @param {lunr.PipelineFunction} newFn - The new function to add to the pipeline.\n   */\n  lunr.Pipeline.prototype.before = function (existingFn, newFn) {\n    lunr.Pipeline.warnIfFunctionNotRegistered(newFn);\n    var pos = this._stack.indexOf(existingFn);\n    if (pos == -1) {\n      throw new Error('Cannot find existingFn');\n    }\n    this._stack.splice(pos, 0, newFn);\n  };\n\n  /**\n   * Removes a function from the pipeline.\n   *\n   * @param {lunr.PipelineFunction} fn The function to remove from the pipeline.\n   */\n  lunr.Pipeline.prototype.remove = function (fn) {\n    var pos = this._stack.indexOf(fn);\n    if (pos == -1) {\n      return;\n    }\n    this._stack.splice(pos, 1);\n  };\n\n  /**\n   * Runs the current list of functions that make up the pipeline against the\n   * passed tokens.\n   *\n   * @param {Array} tokens The tokens to run through the pipeline.\n   * @returns {Array}\n   */\n  lunr.Pipeline.prototype.run = function (tokens) {\n    var stackLength = this._stack.length;\n    for (var i = 0; i < stackLength; i++) {\n      var fn = this._stack[i];\n      var memo = [];\n      for (var j = 0; j < tokens.length; j++) {\n        var result = fn(tokens[j], j, tokens);\n        if (result === null || result === void 0 || result === '') continue;\n        if (Array.isArray(result)) {\n          for (var k = 0; k < result.length; k++) {\n            memo.push(result[k]);\n          }\n        } else {\n          memo.push(result);\n        }\n      }\n      tokens = memo;\n    }\n    return tokens;\n  };\n\n  /**\n   * Convenience method for passing a string through a pipeline and getting\n   * strings out. This method takes care of wrapping the passed string in a\n   * token and mapping the resulting tokens back to strings.\n   *\n   * @param {string} str - The string to pass through the pipeline.\n   * @param {?object} metadata - Optional metadata to associate with the token\n   * passed to the pipeline.\n   * @returns {string[]}\n   */\n  lunr.Pipeline.prototype.runString = function (str, metadata) {\n    var token = new lunr.Token(str, metadata);\n    return this.run([token]).map(function (t) {\n      return t.toString();\n    });\n  };\n\n  /**\n   * Resets the pipeline by removing any existing processors.\n   *\n   */\n  lunr.Pipeline.prototype.reset = function () {\n    this._stack = [];\n  };\n\n  /**\n   * Returns a representation of the pipeline ready for serialisation.\n   *\n   * Logs a warning if the function has not been registered.\n   *\n   * @returns {Array}\n   */\n  lunr.Pipeline.prototype.toJSON = function () {\n    return this._stack.map(function (fn) {\n      lunr.Pipeline.warnIfFunctionNotRegistered(fn);\n      return fn.label;\n    });\n  };\n  /*!\n   * lunr.Vector\n   * Copyright (C) 2020 Oliver Nightingale\n   */\n\n  /**\n   * A vector is used to construct the vector space of documents and queries. These\n   * vectors support operations to determine the similarity between two documents or\n   * a document and a query.\n   *\n   * Normally no parameters are required for initializing a vector, but in the case of\n   * loading a previously dumped vector the raw elements can be provided to the constructor.\n   *\n   * For performance reasons vectors are implemented with a flat array, where an elements\n   * index is immediately followed by its value. E.g. [index, value, index, value]. This\n   * allows the underlying array to be as sparse as possible and still offer decent\n   * performance when being used for vector calculations.\n   *\n   * @constructor\n   * @param {Number[]} [elements] - The flat list of element index and element value pairs.\n   */\n  lunr.Vector = function (elements) {\n    this._magnitude = 0;\n    this.elements = elements || [];\n  };\n\n  /**\n   * Calculates the position within the vector to insert a given index.\n   *\n   * This is used internally by insert and upsert. If there are duplicate indexes then\n   * the position is returned as if the value for that index were to be updated, but it\n   * is the callers responsibility to check whether there is a duplicate at that index\n   *\n   * @param {Number} insertIdx - The index at which the element should be inserted.\n   * @returns {Number}\n   */\n  lunr.Vector.prototype.positionForIndex = function (index) {\n    // For an empty vector the tuple can be inserted at the beginning\n    if (this.elements.length == 0) {\n      return 0;\n    }\n    var start = 0,\n      end = this.elements.length / 2,\n      sliceLength = end - start,\n      pivotPoint = Math.floor(sliceLength / 2),\n      pivotIndex = this.elements[pivotPoint * 2];\n    while (sliceLength > 1) {\n      if (pivotIndex < index) {\n        start = pivotPoint;\n      }\n      if (pivotIndex > index) {\n        end = pivotPoint;\n      }\n      if (pivotIndex == index) {\n        break;\n      }\n      sliceLength = end - start;\n      pivotPoint = start + Math.floor(sliceLength / 2);\n      pivotIndex = this.elements[pivotPoint * 2];\n    }\n    if (pivotIndex == index) {\n      return pivotPoint * 2;\n    }\n    if (pivotIndex > index) {\n      return pivotPoint * 2;\n    }\n    if (pivotIndex < index) {\n      return (pivotPoint + 1) * 2;\n    }\n  };\n\n  /**\n   * Inserts an element at an index within the vector.\n   *\n   * Does not allow duplicates, will throw an error if there is already an entry\n   * for this index.\n   *\n   * @param {Number} insertIdx - The index at which the element should be inserted.\n   * @param {Number} val - The value to be inserted into the vector.\n   */\n  lunr.Vector.prototype.insert = function (insertIdx, val) {\n    this.upsert(insertIdx, val, function () {\n      throw \"duplicate index\";\n    });\n  };\n\n  /**\n   * Inserts or updates an existing index within the vector.\n   *\n   * @param {Number} insertIdx - The index at which the element should be inserted.\n   * @param {Number} val - The value to be inserted into the vector.\n   * @param {function} fn - A function that is called for updates, the existing value and the\n   * requested value are passed as arguments\n   */\n  lunr.Vector.prototype.upsert = function (insertIdx, val, fn) {\n    this._magnitude = 0;\n    var position = this.positionForIndex(insertIdx);\n    if (this.elements[position] == insertIdx) {\n      this.elements[position + 1] = fn(this.elements[position + 1], val);\n    } else {\n      this.elements.splice(position, 0, insertIdx, val);\n    }\n  };\n\n  /**\n   * Calculates the magnitude of this vector.\n   *\n   * @returns {Number}\n   */\n  lunr.Vector.prototype.magnitude = function () {\n    if (this._magnitude) return this._magnitude;\n    var sumOfSquares = 0,\n      elementsLength = this.elements.length;\n    for (var i = 1; i < elementsLength; i += 2) {\n      var val = this.elements[i];\n      sumOfSquares += val * val;\n    }\n    return this._magnitude = Math.sqrt(sumOfSquares);\n  };\n\n  /**\n   * Calculates the dot product of this vector and another vector.\n   *\n   * @param {lunr.Vector} otherVector - The vector to compute the dot product with.\n   * @returns {Number}\n   */\n  lunr.Vector.prototype.dot = function (otherVector) {\n    var dotProduct = 0,\n      a = this.elements,\n      b = otherVector.elements,\n      aLen = a.length,\n      bLen = b.length,\n      aVal = 0,\n      bVal = 0,\n      i = 0,\n      j = 0;\n    while (i < aLen && j < bLen) {\n      aVal = a[i], bVal = b[j];\n      if (aVal < bVal) {\n        i += 2;\n      } else if (aVal > bVal) {\n        j += 2;\n      } else if (aVal == bVal) {\n        dotProduct += a[i + 1] * b[j + 1];\n        i += 2;\n        j += 2;\n      }\n    }\n    return dotProduct;\n  };\n\n  /**\n   * Calculates the similarity between this vector and another vector.\n   *\n   * @param {lunr.Vector} otherVector - The other vector to calculate the\n   * similarity with.\n   * @returns {Number}\n   */\n  lunr.Vector.prototype.similarity = function (otherVector) {\n    return this.dot(otherVector) / this.magnitude() || 0;\n  };\n\n  /**\n   * Converts the vector to an array of the elements within the vector.\n   *\n   * @returns {Number[]}\n   */\n  lunr.Vector.prototype.toArray = function () {\n    var output = new Array(this.elements.length / 2);\n    for (var i = 1, j = 0; i < this.elements.length; i += 2, j++) {\n      output[j] = this.elements[i];\n    }\n    return output;\n  };\n\n  /**\n   * A JSON serializable representation of the vector.\n   *\n   * @returns {Number[]}\n   */\n  lunr.Vector.prototype.toJSON = function () {\n    return this.elements;\n  };\n  /* eslint-disable */\n  /*!\n   * lunr.stemmer\n   * Copyright (C) 2020 Oliver Nightingale\n   * Includes code from - http://tartarus.org/~martin/PorterStemmer/js.txt\n   */\n\n  /**\n   * lunr.stemmer is an english language stemmer, this is a JavaScript\n   * implementation of the PorterStemmer taken from http://tartarus.org/~martin\n   *\n   * @static\n   * @implements {lunr.PipelineFunction}\n   * @param {lunr.Token} token - The string to stem\n   * @returns {lunr.Token}\n   * @see {@link lunr.Pipeline}\n   * @function\n   */\n  lunr.stemmer = function () {\n    var step2list = {\n        \"ational\": \"ate\",\n        \"tional\": \"tion\",\n        \"enci\": \"ence\",\n        \"anci\": \"ance\",\n        \"izer\": \"ize\",\n        \"bli\": \"ble\",\n        \"alli\": \"al\",\n        \"entli\": \"ent\",\n        \"eli\": \"e\",\n        \"ousli\": \"ous\",\n        \"ization\": \"ize\",\n        \"ation\": \"ate\",\n        \"ator\": \"ate\",\n        \"alism\": \"al\",\n        \"iveness\": \"ive\",\n        \"fulness\": \"ful\",\n        \"ousness\": \"ous\",\n        \"aliti\": \"al\",\n        \"iviti\": \"ive\",\n        \"biliti\": \"ble\",\n        \"logi\": \"log\"\n      },\n      step3list = {\n        \"icate\": \"ic\",\n        \"ative\": \"\",\n        \"alize\": \"al\",\n        \"iciti\": \"ic\",\n        \"ical\": \"ic\",\n        \"ful\": \"\",\n        \"ness\": \"\"\n      },\n      c = \"[^aeiou]\",\n      // consonant\n      v = \"[aeiouy]\",\n      // vowel\n      C = c + \"[^aeiouy]*\",\n      // consonant sequence\n      V = v + \"[aeiou]*\",\n      // vowel sequence\n\n      mgr0 = \"^(\" + C + \")?\" + V + C,\n      // [C]VC... is m>0\n      meq1 = \"^(\" + C + \")?\" + V + C + \"(\" + V + \")?$\",\n      // [C]VC[V] is m=1\n      mgr1 = \"^(\" + C + \")?\" + V + C + V + C,\n      // [C]VCVC... is m>1\n      s_v = \"^(\" + C + \")?\" + v; // vowel in stem\n\n    var re_mgr0 = new RegExp(mgr0);\n    var re_mgr1 = new RegExp(mgr1);\n    var re_meq1 = new RegExp(meq1);\n    var re_s_v = new RegExp(s_v);\n    var re_1a = /^(.+?)(ss|i)es$/;\n    var re2_1a = /^(.+?)([^s])s$/;\n    var re_1b = /^(.+?)eed$/;\n    var re2_1b = /^(.+?)(ed|ing)$/;\n    var re_1b_2 = /.$/;\n    var re2_1b_2 = /(at|bl|iz)$/;\n    var re3_1b_2 = new RegExp(\"([^aeiouylsz])\\\\1$\");\n    var re4_1b_2 = new RegExp(\"^\" + C + v + \"[^aeiouwxy]$\");\n    var re_1c = /^(.+?[^aeiou])y$/;\n    var re_2 = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;\n    var re_3 = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;\n    var re_4 = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;\n    var re2_4 = /^(.+?)(s|t)(ion)$/;\n    var re_5 = /^(.+?)e$/;\n    var re_5_1 = /ll$/;\n    var re3_5 = new RegExp(\"^\" + C + v + \"[^aeiouwxy]$\");\n    var porterStemmer = function porterStemmer(w) {\n      var stem, suffix, firstch, re, re2, re3, re4;\n      if (w.length < 3) {\n        return w;\n      }\n      firstch = w.substr(0, 1);\n      if (firstch == \"y\") {\n        w = firstch.toUpperCase() + w.substr(1);\n      }\n\n      // Step 1a\n      re = re_1a;\n      re2 = re2_1a;\n      if (re.test(w)) {\n        w = w.replace(re, \"$1$2\");\n      } else if (re2.test(w)) {\n        w = w.replace(re2, \"$1$2\");\n      }\n\n      // Step 1b\n      re = re_1b;\n      re2 = re2_1b;\n      if (re.test(w)) {\n        var fp = re.exec(w);\n        re = re_mgr0;\n        if (re.test(fp[1])) {\n          re = re_1b_2;\n          w = w.replace(re, \"\");\n        }\n      } else if (re2.test(w)) {\n        var fp = re2.exec(w);\n        stem = fp[1];\n        re2 = re_s_v;\n        if (re2.test(stem)) {\n          w = stem;\n          re2 = re2_1b_2;\n          re3 = re3_1b_2;\n          re4 = re4_1b_2;\n          if (re2.test(w)) {\n            w = w + \"e\";\n          } else if (re3.test(w)) {\n            re = re_1b_2;\n            w = w.replace(re, \"\");\n          } else if (re4.test(w)) {\n            w = w + \"e\";\n          }\n        }\n      }\n\n      // Step 1c - replace suffix y or Y by i if preceded by a non-vowel which is not the first letter of the word (so cry -> cri, by -> by, say -> say)\n      re = re_1c;\n      if (re.test(w)) {\n        var fp = re.exec(w);\n        stem = fp[1];\n        w = stem + \"i\";\n      }\n\n      // Step 2\n      re = re_2;\n      if (re.test(w)) {\n        var fp = re.exec(w);\n        stem = fp[1];\n        suffix = fp[2];\n        re = re_mgr0;\n        if (re.test(stem)) {\n          w = stem + step2list[suffix];\n        }\n      }\n\n      // Step 3\n      re = re_3;\n      if (re.test(w)) {\n        var fp = re.exec(w);\n        stem = fp[1];\n        suffix = fp[2];\n        re = re_mgr0;\n        if (re.test(stem)) {\n          w = stem + step3list[suffix];\n        }\n      }\n\n      // Step 4\n      re = re_4;\n      re2 = re2_4;\n      if (re.test(w)) {\n        var fp = re.exec(w);\n        stem = fp[1];\n        re = re_mgr1;\n        if (re.test(stem)) {\n          w = stem;\n        }\n      } else if (re2.test(w)) {\n        var fp = re2.exec(w);\n        stem = fp[1] + fp[2];\n        re2 = re_mgr1;\n        if (re2.test(stem)) {\n          w = stem;\n        }\n      }\n\n      // Step 5\n      re = re_5;\n      if (re.test(w)) {\n        var fp = re.exec(w);\n        stem = fp[1];\n        re = re_mgr1;\n        re2 = re_meq1;\n        re3 = re3_5;\n        if (re.test(stem) || re2.test(stem) && !re3.test(stem)) {\n          w = stem;\n        }\n      }\n      re = re_5_1;\n      re2 = re_mgr1;\n      if (re.test(w) && re2.test(w)) {\n        re = re_1b_2;\n        w = w.replace(re, \"\");\n      }\n\n      // and turn initial Y back to y\n\n      if (firstch == \"y\") {\n        w = firstch.toLowerCase() + w.substr(1);\n      }\n      return w;\n    };\n    return function (token) {\n      return token.update(porterStemmer);\n    };\n  }();\n  lunr.Pipeline.registerFunction(lunr.stemmer, 'stemmer');\n  /*!\n   * lunr.stopWordFilter\n   * Copyright (C) 2020 Oliver Nightingale\n   */\n\n  /**\n   * lunr.generateStopWordFilter builds a stopWordFilter function from the provided\n   * list of stop words.\n   *\n   * The built in lunr.stopWordFilter is built using this generator and can be used\n   * to generate custom stopWordFilters for applications or non English languages.\n   *\n   * @function\n   * @param {Array} token The token to pass through the filter\n   * @returns {lunr.PipelineFunction}\n   * @see lunr.Pipeline\n   * @see lunr.stopWordFilter\n   */\n  lunr.generateStopWordFilter = function (stopWords) {\n    var words = stopWords.reduce(function (memo, stopWord) {\n      memo[stopWord] = stopWord;\n      return memo;\n    }, {});\n    return function (token) {\n      if (token && words[token.toString()] !== token.toString()) return token;\n    };\n  };\n\n  /**\n   * lunr.stopWordFilter is an English language stop word list filter, any words\n   * contained in the list will not be passed through the filter.\n   *\n   * This is intended to be used in the Pipeline. If the token does not pass the\n   * filter then undefined will be returned.\n   *\n   * @function\n   * @implements {lunr.PipelineFunction}\n   * @params {lunr.Token} token - A token to check for being a stop word.\n   * @returns {lunr.Token}\n   * @see {@link lunr.Pipeline}\n   */\n  lunr.stopWordFilter = lunr.generateStopWordFilter(['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', 'do', 'does', 'either', 'else', 'ever', 'every', 'for', 'from', 'get', 'got', 'had', 'has', 'have', 'he', 'her', 'hers', 'him', 'his', 'how', 'however', 'i', 'if', 'in', 'into', 'is', 'it', 'its', 'just', 'least', 'let', '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', 'this', 'tis', 'to', 'too', 'twas', 'us', 'wants', 'was', 'we', 'were', 'what', 'when', 'where', 'which', 'while', 'who', 'whom', 'why', 'will', 'with', 'would', 'yet', 'you', 'your']);\n  lunr.Pipeline.registerFunction(lunr.stopWordFilter, 'stopWordFilter');\n  /*!\n   * lunr.trimmer\n   * Copyright (C) 2020 Oliver Nightingale\n   */\n\n  /**\n   * lunr.trimmer is a pipeline function for trimming non word\n   * characters from the beginning and end of tokens before they\n   * enter the index.\n   *\n   * This implementation may not work correctly for non latin\n   * characters and should either be removed or adapted for use\n   * with languages with non-latin characters.\n   *\n   * @static\n   * @implements {lunr.PipelineFunction}\n   * @param {lunr.Token} token The token to pass through the filter\n   * @returns {lunr.Token}\n   * @see lunr.Pipeline\n   */\n  lunr.trimmer = function (token) {\n    return token.update(function (s) {\n      return s.replace(/^\\W+/, '').replace(/\\W+$/, '');\n    });\n  };\n  lunr.Pipeline.registerFunction(lunr.trimmer, 'trimmer');\n  /*!\n   * lunr.TokenSet\n   * Copyright (C) 2020 Oliver Nightingale\n   */\n\n  /**\n   * A token set is used to store the unique list of all tokens\n   * within an index. Token sets are also used to represent an\n   * incoming query to the index, this query token set and index\n   * token set are then intersected to find which tokens to look\n   * up in the inverted index.\n   *\n   * A token set can hold multiple tokens, as in the case of the\n   * index token set, or it can hold a single token as in the\n   * case of a simple query token set.\n   *\n   * Additionally token sets are used to perform wildcard matching.\n   * Leading, contained and trailing wildcards are supported, and\n   * from this edit distance matching can also be provided.\n   *\n   * Token sets are implemented as a minimal finite state automata,\n   * where both common prefixes and suffixes are shared between tokens.\n   * This helps to reduce the space used for storing the token set.\n   *\n   * @constructor\n   */\n  lunr.TokenSet = function () {\n    this.final = false;\n    this.edges = {};\n    this.id = lunr.TokenSet._nextId;\n    lunr.TokenSet._nextId += 1;\n  };\n\n  /**\n   * Keeps track of the next, auto increment, identifier to assign\n   * to a new tokenSet.\n   *\n   * TokenSets require a unique identifier to be correctly minimised.\n   *\n   * @private\n   */\n  lunr.TokenSet._nextId = 1;\n\n  /**\n   * Creates a TokenSet instance from the given sorted array of words.\n   *\n   * @param {String[]} arr - A sorted array of strings to create the set from.\n   * @returns {lunr.TokenSet}\n   * @throws Will throw an error if the input array is not sorted.\n   */\n  lunr.TokenSet.fromArray = function (arr) {\n    var builder = new lunr.TokenSet.Builder();\n    for (var i = 0, len = arr.length; i < len; i++) {\n      builder.insert(arr[i]);\n    }\n    builder.finish();\n    return builder.root;\n  };\n\n  /**\n   * Creates a token set from a query clause.\n   *\n   * @private\n   * @param {Object} clause - A single clause from lunr.Query.\n   * @param {string} clause.term - The query clause term.\n   * @param {number} [clause.editDistance] - The optional edit distance for the term.\n   * @returns {lunr.TokenSet}\n   */\n  lunr.TokenSet.fromClause = function (clause) {\n    if ('editDistance' in clause) {\n      return lunr.TokenSet.fromFuzzyString(clause.term, clause.editDistance);\n    } else {\n      return lunr.TokenSet.fromString(clause.term);\n    }\n  };\n\n  /**\n   * Creates a token set representing a single string with a specified\n   * edit distance.\n   *\n   * Insertions, deletions, substitutions and transpositions are each\n   * treated as an edit distance of 1.\n   *\n   * Increasing the allowed edit distance will have a dramatic impact\n   * on the performance of both creating and intersecting these TokenSets.\n   * It is advised to keep the edit distance less than 3.\n   *\n   * @param {string} str - The string to create the token set from.\n   * @param {number} editDistance - The allowed edit distance to match.\n   * @returns {lunr.Vector}\n   */\n  lunr.TokenSet.fromFuzzyString = function (str, editDistance) {\n    var root = new lunr.TokenSet();\n    var stack = [{\n      node: root,\n      editsRemaining: editDistance,\n      str: str\n    }];\n    while (stack.length) {\n      var frame = stack.pop();\n\n      // no edit\n      if (frame.str.length > 0) {\n        var char = frame.str.charAt(0),\n          noEditNode;\n        if (char in frame.node.edges) {\n          noEditNode = frame.node.edges[char];\n        } else {\n          noEditNode = new lunr.TokenSet();\n          frame.node.edges[char] = noEditNode;\n        }\n        if (frame.str.length == 1) {\n          noEditNode.final = true;\n        }\n        stack.push({\n          node: noEditNode,\n          editsRemaining: frame.editsRemaining,\n          str: frame.str.slice(1)\n        });\n      }\n      if (frame.editsRemaining == 0) {\n        continue;\n      }\n\n      // insertion\n      if (\"*\" in frame.node.edges) {\n        var insertionNode = frame.node.edges[\"*\"];\n      } else {\n        var insertionNode = new lunr.TokenSet();\n        frame.node.edges[\"*\"] = insertionNode;\n      }\n      if (frame.str.length == 0) {\n        insertionNode.final = true;\n      }\n      stack.push({\n        node: insertionNode,\n        editsRemaining: frame.editsRemaining - 1,\n        str: frame.str\n      });\n\n      // deletion\n      // can only do a deletion if we have enough edits remaining\n      // and if there are characters left to delete in the string\n      if (frame.str.length > 1) {\n        stack.push({\n          node: frame.node,\n          editsRemaining: frame.editsRemaining - 1,\n          str: frame.str.slice(1)\n        });\n      }\n\n      // deletion\n      // just removing the last character from the str\n      if (frame.str.length == 1) {\n        frame.node.final = true;\n      }\n\n      // substitution\n      // can only do a substitution if we have enough edits remaining\n      // and if there are characters left to substitute\n      if (frame.str.length >= 1) {\n        if (\"*\" in frame.node.edges) {\n          var substitutionNode = frame.node.edges[\"*\"];\n        } else {\n          var substitutionNode = new lunr.TokenSet();\n          frame.node.edges[\"*\"] = substitutionNode;\n        }\n        if (frame.str.length == 1) {\n          substitutionNode.final = true;\n        }\n        stack.push({\n          node: substitutionNode,\n          editsRemaining: frame.editsRemaining - 1,\n          str: frame.str.slice(1)\n        });\n      }\n\n      // transposition\n      // can only do a transposition if there are edits remaining\n      // and there are enough characters to transpose\n      if (frame.str.length > 1) {\n        var charA = frame.str.charAt(0),\n          charB = frame.str.charAt(1),\n          transposeNode;\n        if (charB in frame.node.edges) {\n          transposeNode = frame.node.edges[charB];\n        } else {\n          transposeNode = new lunr.TokenSet();\n          frame.node.edges[charB] = transposeNode;\n        }\n        if (frame.str.length == 1) {\n          transposeNode.final = true;\n        }\n        stack.push({\n          node: transposeNode,\n          editsRemaining: frame.editsRemaining - 1,\n          str: charA + frame.str.slice(2)\n        });\n      }\n    }\n    return root;\n  };\n\n  /**\n   * Creates a TokenSet from a string.\n   *\n   * The string may contain one or more wildcard characters (*)\n   * that will allow wildcard matching when intersecting with\n   * another TokenSet.\n   *\n   * @param {string} str - The string to create a TokenSet from.\n   * @returns {lunr.TokenSet}\n   */\n  lunr.TokenSet.fromString = function (str) {\n    var node = new lunr.TokenSet(),\n      root = node;\n\n    /*\n     * Iterates through all characters within the passed string\n     * appending a node for each character.\n     *\n     * When a wildcard character is found then a self\n     * referencing edge is introduced to continually match\n     * any number of any characters.\n     */\n    for (var i = 0, len = str.length; i < len; i++) {\n      var char = str[i],\n        final = i == len - 1;\n      if (char == \"*\") {\n        node.edges[char] = node;\n        node.final = final;\n      } else {\n        var next = new lunr.TokenSet();\n        next.final = final;\n        node.edges[char] = next;\n        node = next;\n      }\n    }\n    return root;\n  };\n\n  /**\n   * Converts this TokenSet into an array of strings\n   * contained within the TokenSet.\n   *\n   * This is not intended to be used on a TokenSet that\n   * contains wildcards, in these cases the results are\n   * undefined and are likely to cause an infinite loop.\n   *\n   * @returns {string[]}\n   */\n  lunr.TokenSet.prototype.toArray = function () {\n    var words = [];\n    var stack = [{\n      prefix: \"\",\n      node: this\n    }];\n    while (stack.length) {\n      var frame = stack.pop(),\n        edges = Object.keys(frame.node.edges),\n        len = edges.length;\n      if (frame.node.final) {\n        /* In Safari, at this point the prefix is sometimes corrupted, see:\n         * https://github.com/olivernn/lunr.js/issues/279 Calling any\n         * String.prototype method forces Safari to \"cast\" this string to what\n         * it's supposed to be, fixing the bug. */\n        frame.prefix.charAt(0);\n        words.push(frame.prefix);\n      }\n      for (var i = 0; i < len; i++) {\n        var edge = edges[i];\n        stack.push({\n          prefix: frame.prefix.concat(edge),\n          node: frame.node.edges[edge]\n        });\n      }\n    }\n    return words;\n  };\n\n  /**\n   * Generates a string representation of a TokenSet.\n   *\n   * This is intended to allow TokenSets to be used as keys\n   * in objects, largely to aid the construction and minimisation\n   * of a TokenSet. As such it is not designed to be a human\n   * friendly representation of the TokenSet.\n   *\n   * @returns {string}\n   */\n  lunr.TokenSet.prototype.toString = function () {\n    // NOTE: Using Object.keys here as this.edges is very likely\n    // to enter 'hash-mode' with many keys being added\n    //\n    // avoiding a for-in loop here as it leads to the function\n    // being de-optimised (at least in V8). From some simple\n    // benchmarks the performance is comparable, but allowing\n    // V8 to optimize may mean easy performance wins in the future.\n\n    if (this._str) {\n      return this._str;\n    }\n    var str = this.final ? '1' : '0',\n      labels = Object.keys(this.edges).sort(),\n      len = labels.length;\n    for (var i = 0; i < len; i++) {\n      var label = labels[i],\n        node = this.edges[label];\n      str = str + label + node.id;\n    }\n    return str;\n  };\n\n  /**\n   * Returns a new TokenSet that is the intersection of\n   * this TokenSet and the passed TokenSet.\n   *\n   * This intersection will take into account any wildcards\n   * contained within the TokenSet.\n   *\n   * @param {lunr.TokenSet} b - An other TokenSet to intersect with.\n   * @returns {lunr.TokenSet}\n   */\n  lunr.TokenSet.prototype.intersect = function (b) {\n    var output = new lunr.TokenSet(),\n      frame = undefined;\n    var stack = [{\n      qNode: b,\n      output: output,\n      node: this\n    }];\n    while (stack.length) {\n      frame = stack.pop();\n\n      // NOTE: As with the #toString method, we are using\n      // Object.keys and a for loop instead of a for-in loop\n      // as both of these objects enter 'hash' mode, causing\n      // the function to be de-optimised in V8\n      var qEdges = Object.keys(frame.qNode.edges),\n        qLen = qEdges.length,\n        nEdges = Object.keys(frame.node.edges),\n        nLen = nEdges.length;\n      for (var q = 0; q < qLen; q++) {\n        var qEdge = qEdges[q];\n        for (var n = 0; n < nLen; n++) {\n          var nEdge = nEdges[n];\n          if (nEdge == qEdge || qEdge == '*') {\n            var node = frame.node.edges[nEdge],\n              qNode = frame.qNode.edges[qEdge],\n              final = node.final && qNode.final,\n              next = undefined;\n            if (nEdge in frame.output.edges) {\n              // an edge already exists for this character\n              // no need to create a new node, just set the finality\n              // bit unless this node is already final\n              next = frame.output.edges[nEdge];\n              next.final = next.final || final;\n            } else {\n              // no edge exists yet, must create one\n              // set the finality bit and insert it\n              // into the output\n              next = new lunr.TokenSet();\n              next.final = final;\n              frame.output.edges[nEdge] = next;\n            }\n            stack.push({\n              qNode: qNode,\n              output: next,\n              node: node\n            });\n          }\n        }\n      }\n    }\n    return output;\n  };\n  lunr.TokenSet.Builder = function () {\n    this.previousWord = \"\";\n    this.root = new lunr.TokenSet();\n    this.uncheckedNodes = [];\n    this.minimizedNodes = {};\n  };\n  lunr.TokenSet.Builder.prototype.insert = function (word) {\n    var node,\n      commonPrefix = 0;\n    if (word < this.previousWord) {\n      throw new Error(\"Out of order word insertion\");\n    }\n    for (var i = 0; i < word.length && i < this.previousWord.length; i++) {\n      if (word[i] != this.previousWord[i]) break;\n      commonPrefix++;\n    }\n    this.minimize(commonPrefix);\n    if (this.uncheckedNodes.length == 0) {\n      node = this.root;\n    } else {\n      node = this.uncheckedNodes[this.uncheckedNodes.length - 1].child;\n    }\n    for (var i = commonPrefix; i < word.length; i++) {\n      var nextNode = new lunr.TokenSet(),\n        char = word[i];\n      node.edges[char] = nextNode;\n      this.uncheckedNodes.push({\n        parent: node,\n        char: char,\n        child: nextNode\n      });\n      node = nextNode;\n    }\n    node.final = true;\n    this.previousWord = word;\n  };\n  lunr.TokenSet.Builder.prototype.finish = function () {\n    this.minimize(0);\n  };\n  lunr.TokenSet.Builder.prototype.minimize = function (downTo) {\n    for (var i = this.uncheckedNodes.length - 1; i >= downTo; i--) {\n      var node = this.uncheckedNodes[i],\n        childKey = node.child.toString();\n      if (childKey in this.minimizedNodes) {\n        node.parent.edges[node.char] = this.minimizedNodes[childKey];\n      } else {\n        // Cache the key for this node since\n        // we know it can't change anymore\n        node.child._str = childKey;\n        this.minimizedNodes[childKey] = node.child;\n      }\n      this.uncheckedNodes.pop();\n    }\n  };\n  /*!\n   * lunr.Index\n   * Copyright (C) 2020 Oliver Nightingale\n   */\n\n  /**\n   * An index contains the built index of all documents and provides a query interface\n   * to the index.\n   *\n   * Usually instances of lunr.Index will not be created using this constructor, instead\n   * lunr.Builder should be used to construct new indexes, or lunr.Index.load should be\n   * used to load previously built and serialized indexes.\n   *\n   * @constructor\n   * @param {Object} attrs - The attributes of the built search index.\n   * @param {Object} attrs.invertedIndex - An index of term/field to document reference.\n   * @param {Object<string, lunr.Vector>} attrs.fieldVectors - Field vectors\n   * @param {lunr.TokenSet} attrs.tokenSet - An set of all corpus tokens.\n   * @param {string[]} attrs.fields - The names of indexed document fields.\n   * @param {lunr.Pipeline} attrs.pipeline - The pipeline to use for search terms.\n   */\n  lunr.Index = function (attrs) {\n    this.invertedIndex = attrs.invertedIndex;\n    this.fieldVectors = attrs.fieldVectors;\n    this.tokenSet = attrs.tokenSet;\n    this.fields = attrs.fields;\n    this.pipeline = attrs.pipeline;\n  };\n\n  /**\n   * A result contains details of a document matching a search query.\n   * @typedef {Object} lunr.Index~Result\n   * @property {string} ref - The reference of the document this result represents.\n   * @property {number} score - A number between 0 and 1 representing how similar this document is to the query.\n   * @property {lunr.MatchData} matchData - Contains metadata about this match including which term(s) caused the match.\n   */\n\n  /**\n   * Although lunr provides the ability to create queries using lunr.Query, it also provides a simple\n   * query language which itself is parsed into an instance of lunr.Query.\n   *\n   * For programmatically building queries it is advised to directly use lunr.Query, the query language\n   * is best used for human entered text rather than program generated text.\n   *\n   * At its simplest queries can just be a single term, e.g. `hello`, multiple terms are also supported\n   * and will be combined with OR, e.g `hello world` will match documents that contain either 'hello'\n   * or 'world', though those that contain both will rank higher in the results.\n   *\n   * Wildcards can be included in terms to match one or more unspecified characters, these wildcards can\n   * be inserted anywhere within the term, and more than one wildcard can exist in a single term. Adding\n   * wildcards will increase the number of documents that will be found but can also have a negative\n   * impact on query performance, especially with wildcards at the beginning of a term.\n   *\n   * Terms can be restricted to specific fields, e.g. `title:hello`, only documents with the term\n   * hello in the title field will match this query. Using a field not present in the index will lead\n   * to an error being thrown.\n   *\n   * Modifiers can also be added to terms, lunr supports edit distance and boost modifiers on terms. A term\n   * boost will make documents matching that term score higher, e.g. `foo^5`. Edit distance is also supported\n   * to provide fuzzy matching, e.g. 'hello~2' will match documents with hello with an edit distance of 2.\n   * Avoid large values for edit distance to improve query performance.\n   *\n   * Each term also supports a presence modifier. By default a term's presence in document is optional, however\n   * this can be changed to either required or prohibited. For a term's presence to be required in a document the\n   * term should be prefixed with a '+', e.g. `+foo bar` is a search for documents that must contain 'foo' and\n   * optionally contain 'bar'. Conversely a leading '-' sets the terms presence to prohibited, i.e. it must not\n   * appear in a document, e.g. `-foo bar` is a search for documents that do not contain 'foo' but may contain 'bar'.\n   *\n   * To escape special characters the backslash character '\\' can be used, this allows searches to include\n   * characters that would normally be considered modifiers, e.g. `foo\\~2` will search for a term \"foo~2\" instead\n   * of attempting to apply a boost of 2 to the search term \"foo\".\n   *\n   * @typedef {string} lunr.Index~QueryString\n   * @example <caption>Simple single term query</caption>\n   * hello\n   * @example <caption>Multiple term query</caption>\n   * hello world\n   * @example <caption>term scoped to a field</caption>\n   * title:hello\n   * @example <caption>term with a boost of 10</caption>\n   * hello^10\n   * @example <caption>term with an edit distance of 2</caption>\n   * hello~2\n   * @example <caption>terms with presence modifiers</caption>\n   * -foo +bar baz\n   */\n\n  /**\n   * Performs a search against the index using lunr query syntax.\n   *\n   * Results will be returned sorted by their score, the most relevant results\n   * will be returned first.  For details on how the score is calculated, please see\n   * the {@link https://lunrjs.com/guides/searching.html#scoring|guide}.\n   *\n   * For more programmatic querying use lunr.Index#query.\n   *\n   * @param {lunr.Index~QueryString} queryString - A string containing a lunr query.\n   * @throws {lunr.QueryParseError} If the passed query string cannot be parsed.\n   * @returns {lunr.Index~Result[]}\n   */\n  lunr.Index.prototype.search = function (queryString) {\n    return this.query(function (query) {\n      var parser = new lunr.QueryParser(queryString, query);\n      parser.parse();\n    });\n  };\n\n  /**\n   * A query builder callback provides a query object to be used to express\n   * the query to perform on the index.\n   *\n   * @callback lunr.Index~queryBuilder\n   * @param {lunr.Query} query - The query object to build up.\n   * @this lunr.Query\n   */\n\n  /**\n   * Performs a query against the index using the yielded lunr.Query object.\n   *\n   * If performing programmatic queries against the index, this method is preferred\n   * over lunr.Index#search so as to avoid the additional query parsing overhead.\n   *\n   * A query object is yielded to the supplied function which should be used to\n   * express the query to be run against the index.\n   *\n   * Note that although this function takes a callback parameter it is _not_ an\n   * asynchronous operation, the callback is just yielded a query object to be\n   * customized.\n   *\n   * @param {lunr.Index~queryBuilder} fn - A function that is used to build the query.\n   * @returns {lunr.Index~Result[]}\n   */\n  lunr.Index.prototype.query = function (fn) {\n    // for each query clause\n    // * process terms\n    // * expand terms from token set\n    // * find matching documents and metadata\n    // * get document vectors\n    // * score documents\n\n    var query = new lunr.Query(this.fields),\n      matchingFields = Object.create(null),\n      queryVectors = Object.create(null),\n      termFieldCache = Object.create(null),\n      requiredMatches = Object.create(null),\n      prohibitedMatches = Object.create(null);\n\n    /*\n     * To support field level boosts a query vector is created per\n     * field. An empty vector is eagerly created to support negated\n     * queries.\n     */\n    for (var i = 0; i < this.fields.length; i++) {\n      queryVectors[this.fields[i]] = new lunr.Vector();\n    }\n    fn.call(query, query);\n    for (var i = 0; i < query.clauses.length; i++) {\n      /*\n       * Unless the pipeline has been disabled for this term, which is\n       * the case for terms with wildcards, we need to pass the clause\n       * term through the search pipeline. A pipeline returns an array\n       * of processed terms. Pipeline functions may expand the passed\n       * term, which means we may end up performing multiple index lookups\n       * for a single query term.\n       */\n      var clause = query.clauses[i],\n        terms = null,\n        clauseMatches = lunr.Set.empty;\n      if (clause.usePipeline) {\n        terms = this.pipeline.runString(clause.term, {\n          fields: clause.fields\n        });\n      } else {\n        terms = [clause.term];\n      }\n      for (var m = 0; m < terms.length; m++) {\n        var term = terms[m];\n\n        /*\n         * Each term returned from the pipeline needs to use the same query\n         * clause object, e.g. the same boost and or edit distance. The\n         * simplest way to do this is to re-use the clause object but mutate\n         * its term property.\n         */\n        clause.term = term;\n\n        /*\n         * From the term in the clause we create a token set which will then\n         * be used to intersect the indexes token set to get a list of terms\n         * to lookup in the inverted index\n         */\n        var termTokenSet = lunr.TokenSet.fromClause(clause),\n          expandedTerms = this.tokenSet.intersect(termTokenSet).toArray();\n\n        /*\n         * If a term marked as required does not exist in the tokenSet it is\n         * impossible for the search to return any matches. We set all the field\n         * scoped required matches set to empty and stop examining any further\n         * clauses.\n         */\n        if (expandedTerms.length === 0 && clause.presence === lunr.Query.presence.REQUIRED) {\n          for (var k = 0; k < clause.fields.length; k++) {\n            var field = clause.fields[k];\n            requiredMatches[field] = lunr.Set.empty;\n          }\n          break;\n        }\n        for (var j = 0; j < expandedTerms.length; j++) {\n          /*\n           * For each term get the posting and termIndex, this is required for\n           * building the query vector.\n           */\n          var expandedTerm = expandedTerms[j],\n            posting = this.invertedIndex[expandedTerm],\n            termIndex = posting._index;\n          for (var k = 0; k < clause.fields.length; k++) {\n            /*\n             * For each field that this query term is scoped by (by default\n             * all fields are in scope) we need to get all the document refs\n             * that have this term in that field.\n             *\n             * The posting is the entry in the invertedIndex for the matching\n             * term from above.\n             */\n            var field = clause.fields[k],\n              fieldPosting = posting[field],\n              matchingDocumentRefs = Object.keys(fieldPosting),\n              termField = expandedTerm + \"/\" + field,\n              matchingDocumentsSet = new lunr.Set(matchingDocumentRefs);\n\n            /*\n             * if the presence of this term is required ensure that the matching\n             * documents are added to the set of required matches for this clause.\n             *\n             */\n            if (clause.presence == lunr.Query.presence.REQUIRED) {\n              clauseMatches = clauseMatches.union(matchingDocumentsSet);\n              if (requiredMatches[field] === undefined) {\n                requiredMatches[field] = lunr.Set.complete;\n              }\n            }\n\n            /*\n             * if the presence of this term is prohibited ensure that the matching\n             * documents are added to the set of prohibited matches for this field,\n             * creating that set if it does not yet exist.\n             */\n            if (clause.presence == lunr.Query.presence.PROHIBITED) {\n              if (prohibitedMatches[field] === undefined) {\n                prohibitedMatches[field] = lunr.Set.empty;\n              }\n              prohibitedMatches[field] = prohibitedMatches[field].union(matchingDocumentsSet);\n\n              /*\n               * Prohibited matches should not be part of the query vector used for\n               * similarity scoring and no metadata should be extracted so we continue\n               * to the next field\n               */\n              continue;\n            }\n\n            /*\n             * The query field vector is populated using the termIndex found for\n             * the term and a unit value with the appropriate boost applied.\n             * Using upsert because there could already be an entry in the vector\n             * for the term we are working with. In that case we just add the scores\n             * together.\n             */\n            queryVectors[field].upsert(termIndex, clause.boost, function (a, b) {\n              return a + b;\n            });\n\n            /**\n             * If we've already seen this term, field combo then we've already collected\n             * the matching documents and metadata, no need to go through all that again\n             */\n            if (termFieldCache[termField]) {\n              continue;\n            }\n            for (var l = 0; l < matchingDocumentRefs.length; l++) {\n              /*\n               * All metadata for this term/field/document triple\n               * are then extracted and collected into an instance\n               * of lunr.MatchData ready to be returned in the query\n               * results\n               */\n              var matchingDocumentRef = matchingDocumentRefs[l],\n                matchingFieldRef = new lunr.FieldRef(matchingDocumentRef, field),\n                metadata = fieldPosting[matchingDocumentRef],\n                fieldMatch;\n              if ((fieldMatch = matchingFields[matchingFieldRef]) === undefined) {\n                matchingFields[matchingFieldRef] = new lunr.MatchData(expandedTerm, field, metadata);\n              } else {\n                fieldMatch.add(expandedTerm, field, metadata);\n              }\n            }\n            termFieldCache[termField] = true;\n          }\n        }\n      }\n\n      /**\n       * If the presence was required we need to update the requiredMatches field sets.\n       * We do this after all fields for the term have collected their matches because\n       * the clause terms presence is required in _any_ of the fields not _all_ of the\n       * fields.\n       */\n      if (clause.presence === lunr.Query.presence.REQUIRED) {\n        for (var k = 0; k < clause.fields.length; k++) {\n          var field = clause.fields[k];\n          requiredMatches[field] = requiredMatches[field].intersect(clauseMatches);\n        }\n      }\n    }\n\n    /**\n     * Need to combine the field scoped required and prohibited\n     * matching documents into a global set of required and prohibited\n     * matches\n     */\n    var allRequiredMatches = lunr.Set.complete,\n      allProhibitedMatches = lunr.Set.empty;\n    for (var i = 0; i < this.fields.length; i++) {\n      var field = this.fields[i];\n      if (requiredMatches[field]) {\n        allRequiredMatches = allRequiredMatches.intersect(requiredMatches[field]);\n      }\n      if (prohibitedMatches[field]) {\n        allProhibitedMatches = allProhibitedMatches.union(prohibitedMatches[field]);\n      }\n    }\n    var matchingFieldRefs = Object.keys(matchingFields),\n      results = [],\n      matches = Object.create(null);\n\n    /*\n     * If the query is negated (contains only prohibited terms)\n     * we need to get _all_ fieldRefs currently existing in the\n     * index. This is only done when we know that the query is\n     * entirely prohibited terms to avoid any cost of getting all\n     * fieldRefs unnecessarily.\n     *\n     * Additionally, blank MatchData must be created to correctly\n     * populate the results.\n     */\n    if (query.isNegated()) {\n      matchingFieldRefs = Object.keys(this.fieldVectors);\n      for (var i = 0; i < matchingFieldRefs.length; i++) {\n        var matchingFieldRef = matchingFieldRefs[i];\n        var fieldRef = lunr.FieldRef.fromString(matchingFieldRef);\n        matchingFields[matchingFieldRef] = new lunr.MatchData();\n      }\n    }\n    for (var i = 0; i < matchingFieldRefs.length; i++) {\n      /*\n       * Currently we have document fields that match the query, but we\n       * need to return documents. The matchData and scores are combined\n       * from multiple fields belonging to the same document.\n       *\n       * Scores are calculated by field, using the query vectors created\n       * above, and combined into a final document score using addition.\n       */\n      var fieldRef = lunr.FieldRef.fromString(matchingFieldRefs[i]),\n        docRef = fieldRef.docRef;\n      if (!allRequiredMatches.contains(docRef)) {\n        continue;\n      }\n      if (allProhibitedMatches.contains(docRef)) {\n        continue;\n      }\n      var fieldVector = this.fieldVectors[fieldRef],\n        score = queryVectors[fieldRef.fieldName].similarity(fieldVector),\n        docMatch;\n      if ((docMatch = matches[docRef]) !== undefined) {\n        docMatch.score += score;\n        docMatch.matchData.combine(matchingFields[fieldRef]);\n      } else {\n        var match = {\n          ref: docRef,\n          score: score,\n          matchData: matchingFields[fieldRef]\n        };\n        matches[docRef] = match;\n        results.push(match);\n      }\n    }\n\n    /*\n     * Sort the results objects by score, highest first.\n     */\n    return results.sort(function (a, b) {\n      return b.score - a.score;\n    });\n  };\n\n  /**\n   * Prepares the index for JSON serialization.\n   *\n   * The schema for this JSON blob will be described in a\n   * separate JSON schema file.\n   *\n   * @returns {Object}\n   */\n  lunr.Index.prototype.toJSON = function () {\n    var invertedIndex = Object.keys(this.invertedIndex).sort().map(function (term) {\n      return [term, this.invertedIndex[term]];\n    }, this);\n    var fieldVectors = Object.keys(this.fieldVectors).map(function (ref) {\n      return [ref, this.fieldVectors[ref].toJSON()];\n    }, this);\n    return {\n      version: lunr.version,\n      fields: this.fields,\n      fieldVectors: fieldVectors,\n      invertedIndex: invertedIndex,\n      pipeline: this.pipeline.toJSON()\n    };\n  };\n\n  /**\n   * Loads a previously serialized lunr.Index\n   *\n   * @param {Object} serializedIndex - A previously serialized lunr.Index\n   * @returns {lunr.Index}\n   */\n  lunr.Index.load = function (serializedIndex) {\n    var attrs = {},\n      fieldVectors = {},\n      serializedVectors = serializedIndex.fieldVectors,\n      invertedIndex = Object.create(null),\n      serializedInvertedIndex = serializedIndex.invertedIndex,\n      tokenSetBuilder = new lunr.TokenSet.Builder(),\n      pipeline = lunr.Pipeline.load(serializedIndex.pipeline);\n    if (serializedIndex.version != lunr.version) {\n      lunr.utils.warn(\"Version mismatch when loading serialised index. Current version of lunr '\" + lunr.version + \"' does not match serialized index '\" + serializedIndex.version + \"'\");\n    }\n    for (var i = 0; i < serializedVectors.length; i++) {\n      var tuple = serializedVectors[i],\n        ref = tuple[0],\n        elements = tuple[1];\n      fieldVectors[ref] = new lunr.Vector(elements);\n    }\n    for (var i = 0; i < serializedInvertedIndex.length; i++) {\n      var tuple = serializedInvertedIndex[i],\n        term = tuple[0],\n        posting = tuple[1];\n      tokenSetBuilder.insert(term);\n      invertedIndex[term] = posting;\n    }\n    tokenSetBuilder.finish();\n    attrs.fields = serializedIndex.fields;\n    attrs.fieldVectors = fieldVectors;\n    attrs.invertedIndex = invertedIndex;\n    attrs.tokenSet = tokenSetBuilder.root;\n    attrs.pipeline = pipeline;\n    return new lunr.Index(attrs);\n  };\n  /*!\n   * lunr.Builder\n   * Copyright (C) 2020 Oliver Nightingale\n   */\n\n  /**\n   * lunr.Builder performs indexing on a set of documents and\n   * returns instances of lunr.Index ready for querying.\n   *\n   * All configuration of the index is done via the builder, the\n   * fields to index, the document reference, the text processing\n   * pipeline and document scoring parameters are all set on the\n   * builder before indexing.\n   *\n   * @constructor\n   * @property {string} _ref - Internal reference to the document reference field.\n   * @property {string[]} _fields - Internal reference to the document fields to index.\n   * @property {object} invertedIndex - The inverted index maps terms to document fields.\n   * @property {object} documentTermFrequencies - Keeps track of document term frequencies.\n   * @property {object} documentLengths - Keeps track of the length of documents added to the index.\n   * @property {lunr.tokenizer} tokenizer - Function for splitting strings into tokens for indexing.\n   * @property {lunr.Pipeline} pipeline - The pipeline performs text processing on tokens before indexing.\n   * @property {lunr.Pipeline} searchPipeline - A pipeline for processing search terms before querying the index.\n   * @property {number} documentCount - Keeps track of the total number of documents indexed.\n   * @property {number} _b - A parameter to control field length normalization, setting this to 0 disabled normalization, 1 fully normalizes field lengths, the default value is 0.75.\n   * @property {number} _k1 - A parameter to control how quickly an increase in term frequency results in term frequency saturation, the default value is 1.2.\n   * @property {number} termIndex - A counter incremented for each unique term, used to identify a terms position in the vector space.\n   * @property {array} metadataWhitelist - A list of metadata keys that have been whitelisted for entry in the index.\n   */\n  lunr.Builder = function () {\n    this._ref = \"id\";\n    this._fields = Object.create(null);\n    this._documents = Object.create(null);\n    this.invertedIndex = Object.create(null);\n    this.fieldTermFrequencies = {};\n    this.fieldLengths = {};\n    this.tokenizer = lunr.tokenizer;\n    this.pipeline = new lunr.Pipeline();\n    this.searchPipeline = new lunr.Pipeline();\n    this.documentCount = 0;\n    this._b = 0.75;\n    this._k1 = 1.2;\n    this.termIndex = 0;\n    this.metadataWhitelist = [];\n  };\n\n  /**\n   * Sets the document field used as the document reference. Every document must have this field.\n   * The type of this field in the document should be a string, if it is not a string it will be\n   * coerced into a string by calling toString.\n   *\n   * The default ref is 'id'.\n   *\n   * The ref should _not_ be changed during indexing, it should be set before any documents are\n   * added to the index. Changing it during indexing can lead to inconsistent results.\n   *\n   * @param {string} ref - The name of the reference field in the document.\n   */\n  lunr.Builder.prototype.ref = function (ref) {\n    this._ref = ref;\n  };\n\n  /**\n   * A function that is used to extract a field from a document.\n   *\n   * Lunr expects a field to be at the top level of a document, if however the field\n   * is deeply nested within a document an extractor function can be used to extract\n   * the right field for indexing.\n   *\n   * @callback fieldExtractor\n   * @param {object} doc - The document being added to the index.\n   * @returns {?(string|object|object[])} obj - The object that will be indexed for this field.\n   * @example <caption>Extracting a nested field</caption>\n   * function (doc) { return doc.nested.field }\n   */\n\n  /**\n   * Adds a field to the list of document fields that will be indexed. Every document being\n   * indexed should have this field. Null values for this field in indexed documents will\n   * not cause errors but will limit the chance of that document being retrieved by searches.\n   *\n   * All fields should be added before adding documents to the index. Adding fields after\n   * a document has been indexed will have no effect on already indexed documents.\n   *\n   * Fields can be boosted at build time. This allows terms within that field to have more\n   * importance when ranking search results. Use a field boost to specify that matches within\n   * one field are more important than other fields.\n   *\n   * @param {string} fieldName - The name of a field to index in all documents.\n   * @param {object} attributes - Optional attributes associated with this field.\n   * @param {number} [attributes.boost=1] - Boost applied to all terms within this field.\n   * @param {fieldExtractor} [attributes.extractor] - Function to extract a field from a document.\n   * @throws {RangeError} fieldName cannot contain unsupported characters '/'\n   */\n  lunr.Builder.prototype.field = function (fieldName, attributes) {\n    if (/\\//.test(fieldName)) {\n      throw new RangeError(\"Field '\" + fieldName + \"' contains illegal character '/'\");\n    }\n    this._fields[fieldName] = attributes || {};\n  };\n\n  /**\n   * A parameter to tune the amount of field length normalisation that is applied when\n   * calculating relevance scores. A value of 0 will completely disable any normalisation\n   * and a value of 1 will fully normalise field lengths. The default is 0.75. Values of b\n   * will be clamped to the range 0 - 1.\n   *\n   * @param {number} number - The value to set for this tuning parameter.\n   */\n  lunr.Builder.prototype.b = function (number) {\n    if (number < 0) {\n      this._b = 0;\n    } else if (number > 1) {\n      this._b = 1;\n    } else {\n      this._b = number;\n    }\n  };\n\n  /**\n   * A parameter that controls the speed at which a rise in term frequency results in term\n   * frequency saturation. The default value is 1.2. Setting this to a higher value will give\n   * slower saturation levels, a lower value will result in quicker saturation.\n   *\n   * @param {number} number - The value to set for this tuning parameter.\n   */\n  lunr.Builder.prototype.k1 = function (number) {\n    this._k1 = number;\n  };\n\n  /**\n   * Adds a document to the index.\n   *\n   * Before adding fields to the index the index should have been fully setup, with the document\n   * ref and all fields to index already having been specified.\n   *\n   * The document must have a field name as specified by the ref (by default this is 'id') and\n   * it should have all fields defined for indexing, though null or undefined values will not\n   * cause errors.\n   *\n   * Entire documents can be boosted at build time. Applying a boost to a document indicates that\n   * this document should rank higher in search results than other documents.\n   *\n   * @param {object} doc - The document to add to the index.\n   * @param {object} attributes - Optional attributes associated with this document.\n   * @param {number} [attributes.boost=1] - Boost applied to all terms within this document.\n   */\n  lunr.Builder.prototype.add = function (doc, attributes) {\n    var docRef = doc[this._ref],\n      fields = Object.keys(this._fields);\n    this._documents[docRef] = attributes || {};\n    this.documentCount += 1;\n    for (var i = 0; i < fields.length; i++) {\n      var fieldName = fields[i],\n        extractor = this._fields[fieldName].extractor,\n        field = extractor ? extractor(doc) : doc[fieldName],\n        tokens = this.tokenizer(field, {\n          fields: [fieldName]\n        }),\n        terms = this.pipeline.run(tokens),\n        fieldRef = new lunr.FieldRef(docRef, fieldName),\n        fieldTerms = Object.create(null);\n      this.fieldTermFrequencies[fieldRef] = fieldTerms;\n      this.fieldLengths[fieldRef] = 0;\n\n      // store the length of this field for this document\n      this.fieldLengths[fieldRef] += terms.length;\n\n      // calculate term frequencies for this field\n      for (var j = 0; j < terms.length; j++) {\n        var term = terms[j];\n        if (fieldTerms[term] == undefined) {\n          fieldTerms[term] = 0;\n        }\n        fieldTerms[term] += 1;\n\n        // add to inverted index\n        // create an initial posting if one doesn't exist\n        if (this.invertedIndex[term] == undefined) {\n          var posting = Object.create(null);\n          posting[\"_index\"] = this.termIndex;\n          this.termIndex += 1;\n          for (var k = 0; k < fields.length; k++) {\n            posting[fields[k]] = Object.create(null);\n          }\n          this.invertedIndex[term] = posting;\n        }\n\n        // add an entry for this term/fieldName/docRef to the invertedIndex\n        if (this.invertedIndex[term][fieldName][docRef] == undefined) {\n          this.invertedIndex[term][fieldName][docRef] = Object.create(null);\n        }\n\n        // store all whitelisted metadata about this token in the\n        // inverted index\n        for (var l = 0; l < this.metadataWhitelist.length; l++) {\n          var metadataKey = this.metadataWhitelist[l],\n            metadata = term.metadata[metadataKey];\n          if (this.invertedIndex[term][fieldName][docRef][metadataKey] == undefined) {\n            this.invertedIndex[term][fieldName][docRef][metadataKey] = [];\n          }\n          this.invertedIndex[term][fieldName][docRef][metadataKey].push(metadata);\n        }\n      }\n    }\n  };\n\n  /**\n   * Calculates the average document length for this index\n   *\n   * @private\n   */\n  lunr.Builder.prototype.calculateAverageFieldLengths = function () {\n    var fieldRefs = Object.keys(this.fieldLengths),\n      numberOfFields = fieldRefs.length,\n      accumulator = {},\n      documentsWithField = {};\n    for (var i = 0; i < numberOfFields; i++) {\n      var fieldRef = lunr.FieldRef.fromString(fieldRefs[i]),\n        field = fieldRef.fieldName;\n      documentsWithField[field] || (documentsWithField[field] = 0);\n      documentsWithField[field] += 1;\n      accumulator[field] || (accumulator[field] = 0);\n      accumulator[field] += this.fieldLengths[fieldRef];\n    }\n    var fields = Object.keys(this._fields);\n    for (var i = 0; i < fields.length; i++) {\n      var fieldName = fields[i];\n      accumulator[fieldName] = accumulator[fieldName] / documentsWithField[fieldName];\n    }\n    this.averageFieldLength = accumulator;\n  };\n\n  /**\n   * Builds a vector space model of every document using lunr.Vector\n   *\n   * @private\n   */\n  lunr.Builder.prototype.createFieldVectors = function () {\n    var fieldVectors = {},\n      fieldRefs = Object.keys(this.fieldTermFrequencies),\n      fieldRefsLength = fieldRefs.length,\n      termIdfCache = Object.create(null);\n    for (var i = 0; i < fieldRefsLength; i++) {\n      var fieldRef = lunr.FieldRef.fromString(fieldRefs[i]),\n        fieldName = fieldRef.fieldName,\n        fieldLength = this.fieldLengths[fieldRef],\n        fieldVector = new lunr.Vector(),\n        termFrequencies = this.fieldTermFrequencies[fieldRef],\n        terms = Object.keys(termFrequencies),\n        termsLength = terms.length;\n      var fieldBoost = this._fields[fieldName].boost || 1,\n        docBoost = this._documents[fieldRef.docRef].boost || 1;\n      for (var j = 0; j < termsLength; j++) {\n        var term = terms[j],\n          tf = termFrequencies[term],\n          termIndex = this.invertedIndex[term]._index,\n          idf,\n          score,\n          scoreWithPrecision;\n        if (termIdfCache[term] === undefined) {\n          idf = lunr.idf(this.invertedIndex[term], this.documentCount);\n          termIdfCache[term] = idf;\n        } else {\n          idf = termIdfCache[term];\n        }\n        score = idf * ((this._k1 + 1) * tf) / (this._k1 * (1 - this._b + this._b * (fieldLength / this.averageFieldLength[fieldName])) + tf);\n        score *= fieldBoost;\n        score *= docBoost;\n        scoreWithPrecision = Math.round(score * 1000) / 1000;\n        // Converts 1.23456789 to 1.234.\n        // Reducing the precision so that the vectors take up less\n        // space when serialised. Doing it now so that they behave\n        // the same before and after serialisation. Also, this is\n        // the fastest approach to reducing a number's precision in\n        // JavaScript.\n\n        fieldVector.insert(termIndex, scoreWithPrecision);\n      }\n      fieldVectors[fieldRef] = fieldVector;\n    }\n    this.fieldVectors = fieldVectors;\n  };\n\n  /**\n   * Creates a token set of all tokens in the index using lunr.TokenSet\n   *\n   * @private\n   */\n  lunr.Builder.prototype.createTokenSet = function () {\n    this.tokenSet = lunr.TokenSet.fromArray(Object.keys(this.invertedIndex).sort());\n  };\n\n  /**\n   * Builds the index, creating an instance of lunr.Index.\n   *\n   * This completes the indexing process and should only be called\n   * once all documents have been added to the index.\n   *\n   * @returns {lunr.Index}\n   */\n  lunr.Builder.prototype.build = function () {\n    this.calculateAverageFieldLengths();\n    this.createFieldVectors();\n    this.createTokenSet();\n    return new lunr.Index({\n      invertedIndex: this.invertedIndex,\n      fieldVectors: this.fieldVectors,\n      tokenSet: this.tokenSet,\n      fields: Object.keys(this._fields),\n      pipeline: this.searchPipeline\n    });\n  };\n\n  /**\n   * Applies a plugin to the index builder.\n   *\n   * A plugin is a function that is called with the index builder as its context.\n   * Plugins can be used to customise or extend the behaviour of the index\n   * in some way. A plugin is just a function, that encapsulated the custom\n   * behaviour that should be applied when building the index.\n   *\n   * The plugin function will be called with the index builder as its argument, additional\n   * arguments can also be passed when calling use. The function will be called\n   * with the index builder as its context.\n   *\n   * @param {Function} plugin The plugin to apply.\n   */\n  lunr.Builder.prototype.use = function (fn) {\n    var args = Array.prototype.slice.call(arguments, 1);\n    args.unshift(this);\n    fn.apply(this, args);\n  };\n  /**\n   * Contains and collects metadata about a matching document.\n   * A single instance of lunr.MatchData is returned as part of every\n   * lunr.Index~Result.\n   *\n   * @constructor\n   * @param {string} term - The term this match data is associated with\n   * @param {string} field - The field in which the term was found\n   * @param {object} metadata - The metadata recorded about this term in this field\n   * @property {object} metadata - A cloned collection of metadata associated with this document.\n   * @see {@link lunr.Index~Result}\n   */\n  lunr.MatchData = function (term, field, metadata) {\n    var clonedMetadata = Object.create(null),\n      metadataKeys = Object.keys(metadata || {});\n\n    // Cloning the metadata to prevent the original\n    // being mutated during match data combination.\n    // Metadata is kept in an array within the inverted\n    // index so cloning the data can be done with\n    // Array#slice\n    for (var i = 0; i < metadataKeys.length; i++) {\n      var key = metadataKeys[i];\n      clonedMetadata[key] = metadata[key].slice();\n    }\n    this.metadata = Object.create(null);\n    if (term !== undefined) {\n      this.metadata[term] = Object.create(null);\n      this.metadata[term][field] = clonedMetadata;\n    }\n  };\n\n  /**\n   * An instance of lunr.MatchData will be created for every term that matches a\n   * document. However only one instance is required in a lunr.Index~Result. This\n   * method combines metadata from another instance of lunr.MatchData with this\n   * objects metadata.\n   *\n   * @param {lunr.MatchData} otherMatchData - Another instance of match data to merge with this one.\n   * @see {@link lunr.Index~Result}\n   */\n  lunr.MatchData.prototype.combine = function (otherMatchData) {\n    var terms = Object.keys(otherMatchData.metadata);\n    for (var i = 0; i < terms.length; i++) {\n      var term = terms[i],\n        fields = Object.keys(otherMatchData.metadata[term]);\n      if (this.metadata[term] == undefined) {\n        this.metadata[term] = Object.create(null);\n      }\n      for (var j = 0; j < fields.length; j++) {\n        var field = fields[j],\n          keys = Object.keys(otherMatchData.metadata[term][field]);\n        if (this.metadata[term][field] == undefined) {\n          this.metadata[term][field] = Object.create(null);\n        }\n        for (var k = 0; k < keys.length; k++) {\n          var key = keys[k];\n          if (this.metadata[term][field][key] == undefined) {\n            this.metadata[term][field][key] = otherMatchData.metadata[term][field][key];\n          } else {\n            this.metadata[term][field][key] = this.metadata[term][field][key].concat(otherMatchData.metadata[term][field][key]);\n          }\n        }\n      }\n    }\n  };\n\n  /**\n   * Add metadata for a term/field pair to this instance of match data.\n   *\n   * @param {string} term - The term this match data is associated with\n   * @param {string} field - The field in which the term was found\n   * @param {object} metadata - The metadata recorded about this term in this field\n   */\n  lunr.MatchData.prototype.add = function (term, field, metadata) {\n    if (!(term in this.metadata)) {\n      this.metadata[term] = Object.create(null);\n      this.metadata[term][field] = metadata;\n      return;\n    }\n    if (!(field in this.metadata[term])) {\n      this.metadata[term][field] = metadata;\n      return;\n    }\n    var metadataKeys = Object.keys(metadata);\n    for (var i = 0; i < metadataKeys.length; i++) {\n      var key = metadataKeys[i];\n      if (key in this.metadata[term][field]) {\n        this.metadata[term][field][key] = this.metadata[term][field][key].concat(metadata[key]);\n      } else {\n        this.metadata[term][field][key] = metadata[key];\n      }\n    }\n  };\n  /**\n   * A lunr.Query provides a programmatic way of defining queries to be performed\n   * against a {@link lunr.Index}.\n   *\n   * Prefer constructing a lunr.Query using the {@link lunr.Index#query} method\n   * so the query object is pre-initialized with the right index fields.\n   *\n   * @constructor\n   * @property {lunr.Query~Clause[]} clauses - An array of query clauses.\n   * @property {string[]} allFields - An array of all available fields in a lunr.Index.\n   */\n  lunr.Query = function (allFields) {\n    this.clauses = [];\n    this.allFields = allFields;\n  };\n\n  /**\n   * Constants for indicating what kind of automatic wildcard insertion will be used when constructing a query clause.\n   *\n   * This allows wildcards to be added to the beginning and end of a term without having to manually do any string\n   * concatenation.\n   *\n   * The wildcard constants can be bitwise combined to select both leading and trailing wildcards.\n   *\n   * @constant\n   * @default\n   * @property {number} wildcard.NONE - The term will have no wildcards inserted, this is the default behaviour\n   * @property {number} wildcard.LEADING - Prepend the term with a wildcard, unless a leading wildcard already exists\n   * @property {number} wildcard.TRAILING - Append a wildcard to the term, unless a trailing wildcard already exists\n   * @see lunr.Query~Clause\n   * @see lunr.Query#clause\n   * @see lunr.Query#term\n   * @example <caption>query term with trailing wildcard</caption>\n   * query.term('foo', { wildcard: lunr.Query.wildcard.TRAILING })\n   * @example <caption>query term with leading and trailing wildcard</caption>\n   * query.term('foo', {\n   *   wildcard: lunr.Query.wildcard.LEADING | lunr.Query.wildcard.TRAILING\n   * })\n   */\n\n  lunr.Query.wildcard = new String(\"*\");\n  lunr.Query.wildcard.NONE = 0;\n  lunr.Query.wildcard.LEADING = 1;\n  lunr.Query.wildcard.TRAILING = 2;\n\n  /**\n   * Constants for indicating what kind of presence a term must have in matching documents.\n   *\n   * @constant\n   * @enum {number}\n   * @see lunr.Query~Clause\n   * @see lunr.Query#clause\n   * @see lunr.Query#term\n   * @example <caption>query term with required presence</caption>\n   * query.term('foo', { presence: lunr.Query.presence.REQUIRED })\n   */\n  lunr.Query.presence = {\n    /**\n     * Term's presence in a document is optional, this is the default value.\n     */\n    OPTIONAL: 1,\n    /**\n     * Term's presence in a document is required, documents that do not contain\n     * this term will not be returned.\n     */\n    REQUIRED: 2,\n    /**\n     * Term's presence in a document is prohibited, documents that do contain\n     * this term will not be returned.\n     */\n    PROHIBITED: 3\n  };\n\n  /**\n   * A single clause in a {@link lunr.Query} contains a term and details on how to\n   * match that term against a {@link lunr.Index}.\n   *\n   * @typedef {Object} lunr.Query~Clause\n   * @property {string[]} fields - The fields in an index this clause should be matched against.\n   * @property {number} [boost=1] - Any boost that should be applied when matching this clause.\n   * @property {number} [editDistance] - Whether the term should have fuzzy matching applied, and how fuzzy the match should be.\n   * @property {boolean} [usePipeline] - Whether the term should be passed through the search pipeline.\n   * @property {number} [wildcard=lunr.Query.wildcard.NONE] - Whether the term should have wildcards appended or prepended.\n   * @property {number} [presence=lunr.Query.presence.OPTIONAL] - The terms presence in any matching documents.\n   */\n\n  /**\n   * Adds a {@link lunr.Query~Clause} to this query.\n   *\n   * Unless the clause contains the fields to be matched all fields will be matched. In addition\n   * a default boost of 1 is applied to the clause.\n   *\n   * @param {lunr.Query~Clause} clause - The clause to add to this query.\n   * @see lunr.Query~Clause\n   * @returns {lunr.Query}\n   */\n  lunr.Query.prototype.clause = function (clause) {\n    if (!('fields' in clause)) {\n      clause.fields = this.allFields;\n    }\n    if (!('boost' in clause)) {\n      clause.boost = 1;\n    }\n    if (!('usePipeline' in clause)) {\n      clause.usePipeline = true;\n    }\n    if (!('wildcard' in clause)) {\n      clause.wildcard = lunr.Query.wildcard.NONE;\n    }\n    if (clause.wildcard & lunr.Query.wildcard.LEADING && clause.term.charAt(0) != lunr.Query.wildcard) {\n      clause.term = \"*\" + clause.term;\n    }\n    if (clause.wildcard & lunr.Query.wildcard.TRAILING && clause.term.slice(-1) != lunr.Query.wildcard) {\n      clause.term = \"\" + clause.term + \"*\";\n    }\n    if (!('presence' in clause)) {\n      clause.presence = lunr.Query.presence.OPTIONAL;\n    }\n    this.clauses.push(clause);\n    return this;\n  };\n\n  /**\n   * A negated query is one in which every clause has a presence of\n   * prohibited. These queries require some special processing to return\n   * the expected results.\n   *\n   * @returns boolean\n   */\n  lunr.Query.prototype.isNegated = function () {\n    for (var i = 0; i < this.clauses.length; i++) {\n      if (this.clauses[i].presence != lunr.Query.presence.PROHIBITED) {\n        return false;\n      }\n    }\n    return true;\n  };\n\n  /**\n   * Adds a term to the current query, under the covers this will create a {@link lunr.Query~Clause}\n   * to the list of clauses that make up this query.\n   *\n   * The term is used as is, i.e. no tokenization will be performed by this method. Instead conversion\n   * to a token or token-like string should be done before calling this method.\n   *\n   * The term will be converted to a string by calling `toString`. Multiple terms can be passed as an\n   * array, each term in the array will share the same options.\n   *\n   * @param {object|object[]} term - The term(s) to add to the query.\n   * @param {object} [options] - Any additional properties to add to the query clause.\n   * @returns {lunr.Query}\n   * @see lunr.Query#clause\n   * @see lunr.Query~Clause\n   * @example <caption>adding a single term to a query</caption>\n   * query.term(\"foo\")\n   * @example <caption>adding a single term to a query and specifying search fields, term boost and automatic trailing wildcard</caption>\n   * query.term(\"foo\", {\n   *   fields: [\"title\"],\n   *   boost: 10,\n   *   wildcard: lunr.Query.wildcard.TRAILING\n   * })\n   * @example <caption>using lunr.tokenizer to convert a string to tokens before using them as terms</caption>\n   * query.term(lunr.tokenizer(\"foo bar\"))\n   */\n  lunr.Query.prototype.term = function (term, options) {\n    if (Array.isArray(term)) {\n      term.forEach(function (t) {\n        this.term(t, lunr.utils.clone(options));\n      }, this);\n      return this;\n    }\n    var clause = options || {};\n    clause.term = term.toString();\n    this.clause(clause);\n    return this;\n  };\n  lunr.QueryParseError = function (message, start, end) {\n    this.name = \"QueryParseError\";\n    this.message = message;\n    this.start = start;\n    this.end = end;\n  };\n  lunr.QueryParseError.prototype = new Error();\n  lunr.QueryLexer = function (str) {\n    this.lexemes = [];\n    this.str = str;\n    this.length = str.length;\n    this.pos = 0;\n    this.start = 0;\n    this.escapeCharPositions = [];\n  };\n  lunr.QueryLexer.prototype.run = function () {\n    var state = lunr.QueryLexer.lexText;\n    while (state) {\n      state = state(this);\n    }\n  };\n  lunr.QueryLexer.prototype.sliceString = function () {\n    var subSlices = [],\n      sliceStart = this.start,\n      sliceEnd = this.pos;\n    for (var i = 0; i < this.escapeCharPositions.length; i++) {\n      sliceEnd = this.escapeCharPositions[i];\n      subSlices.push(this.str.slice(sliceStart, sliceEnd));\n      sliceStart = sliceEnd + 1;\n    }\n    subSlices.push(this.str.slice(sliceStart, this.pos));\n    this.escapeCharPositions.length = 0;\n    return subSlices.join('');\n  };\n  lunr.QueryLexer.prototype.emit = function (type) {\n    this.lexemes.push({\n      type: type,\n      str: this.sliceString(),\n      start: this.start,\n      end: this.pos\n    });\n    this.start = this.pos;\n  };\n  lunr.QueryLexer.prototype.escapeCharacter = function () {\n    this.escapeCharPositions.push(this.pos - 1);\n    this.pos += 1;\n  };\n  lunr.QueryLexer.prototype.next = function () {\n    if (this.pos >= this.length) {\n      return lunr.QueryLexer.EOS;\n    }\n    var char = this.str.charAt(this.pos);\n    this.pos += 1;\n    return char;\n  };\n  lunr.QueryLexer.prototype.width = function () {\n    return this.pos - this.start;\n  };\n  lunr.QueryLexer.prototype.ignore = function () {\n    if (this.start == this.pos) {\n      this.pos += 1;\n    }\n    this.start = this.pos;\n  };\n  lunr.QueryLexer.prototype.backup = function () {\n    this.pos -= 1;\n  };\n  lunr.QueryLexer.prototype.acceptDigitRun = function () {\n    var char, charCode;\n    do {\n      char = this.next();\n      charCode = char.charCodeAt(0);\n    } while (charCode > 47 && charCode < 58);\n    if (char != lunr.QueryLexer.EOS) {\n      this.backup();\n    }\n  };\n  lunr.QueryLexer.prototype.more = function () {\n    return this.pos < this.length;\n  };\n  lunr.QueryLexer.EOS = 'EOS';\n  lunr.QueryLexer.FIELD = 'FIELD';\n  lunr.QueryLexer.TERM = 'TERM';\n  lunr.QueryLexer.EDIT_DISTANCE = 'EDIT_DISTANCE';\n  lunr.QueryLexer.BOOST = 'BOOST';\n  lunr.QueryLexer.PRESENCE = 'PRESENCE';\n  lunr.QueryLexer.lexField = function (lexer) {\n    lexer.backup();\n    lexer.emit(lunr.QueryLexer.FIELD);\n    lexer.ignore();\n    return lunr.QueryLexer.lexText;\n  };\n  lunr.QueryLexer.lexTerm = function (lexer) {\n    if (lexer.width() > 1) {\n      lexer.backup();\n      lexer.emit(lunr.QueryLexer.TERM);\n    }\n    lexer.ignore();\n    if (lexer.more()) {\n      return lunr.QueryLexer.lexText;\n    }\n  };\n  lunr.QueryLexer.lexEditDistance = function (lexer) {\n    lexer.ignore();\n    lexer.acceptDigitRun();\n    lexer.emit(lunr.QueryLexer.EDIT_DISTANCE);\n    return lunr.QueryLexer.lexText;\n  };\n  lunr.QueryLexer.lexBoost = function (lexer) {\n    lexer.ignore();\n    lexer.acceptDigitRun();\n    lexer.emit(lunr.QueryLexer.BOOST);\n    return lunr.QueryLexer.lexText;\n  };\n  lunr.QueryLexer.lexEOS = function (lexer) {\n    if (lexer.width() > 0) {\n      lexer.emit(lunr.QueryLexer.TERM);\n    }\n  };\n\n  // This matches the separator used when tokenising fields\n  // within a document. These should match otherwise it is\n  // not possible to search for some tokens within a document.\n  //\n  // It is possible for the user to change the separator on the\n  // tokenizer so it _might_ clash with any other of the special\n  // characters already used within the search string, e.g. :.\n  //\n  // This means that it is possible to change the separator in\n  // such a way that makes some words unsearchable using a search\n  // string.\n  lunr.QueryLexer.termSeparator = lunr.tokenizer.separator;\n  lunr.QueryLexer.lexText = function (lexer) {\n    while (true) {\n      var char = lexer.next();\n      if (char == lunr.QueryLexer.EOS) {\n        return lunr.QueryLexer.lexEOS;\n      }\n\n      // Escape character is '\\'\n      if (char.charCodeAt(0) == 92) {\n        lexer.escapeCharacter();\n        continue;\n      }\n      if (char == \":\") {\n        return lunr.QueryLexer.lexField;\n      }\n      if (char == \"~\") {\n        lexer.backup();\n        if (lexer.width() > 0) {\n          lexer.emit(lunr.QueryLexer.TERM);\n        }\n        return lunr.QueryLexer.lexEditDistance;\n      }\n      if (char == \"^\") {\n        lexer.backup();\n        if (lexer.width() > 0) {\n          lexer.emit(lunr.QueryLexer.TERM);\n        }\n        return lunr.QueryLexer.lexBoost;\n      }\n\n      // \"+\" indicates term presence is required\n      // checking for length to ensure that only\n      // leading \"+\" are considered\n      if (char == \"+\" && lexer.width() === 1) {\n        lexer.emit(lunr.QueryLexer.PRESENCE);\n        return lunr.QueryLexer.lexText;\n      }\n\n      // \"-\" indicates term presence is prohibited\n      // checking for length to ensure that only\n      // leading \"-\" are considered\n      if (char == \"-\" && lexer.width() === 1) {\n        lexer.emit(lunr.QueryLexer.PRESENCE);\n        return lunr.QueryLexer.lexText;\n      }\n      if (char.match(lunr.QueryLexer.termSeparator)) {\n        return lunr.QueryLexer.lexTerm;\n      }\n    }\n  };\n  lunr.QueryParser = function (str, query) {\n    this.lexer = new lunr.QueryLexer(str);\n    this.query = query;\n    this.currentClause = {};\n    this.lexemeIdx = 0;\n  };\n  lunr.QueryParser.prototype.parse = function () {\n    this.lexer.run();\n    this.lexemes = this.lexer.lexemes;\n    var state = lunr.QueryParser.parseClause;\n    while (state) {\n      state = state(this);\n    }\n    return this.query;\n  };\n  lunr.QueryParser.prototype.peekLexeme = function () {\n    return this.lexemes[this.lexemeIdx];\n  };\n  lunr.QueryParser.prototype.consumeLexeme = function () {\n    var lexeme = this.peekLexeme();\n    this.lexemeIdx += 1;\n    return lexeme;\n  };\n  lunr.QueryParser.prototype.nextClause = function () {\n    var completedClause = this.currentClause;\n    this.query.clause(completedClause);\n    this.currentClause = {};\n  };\n  lunr.QueryParser.parseClause = function (parser) {\n    var lexeme = parser.peekLexeme();\n    if (lexeme == undefined) {\n      return;\n    }\n    switch (lexeme.type) {\n      case lunr.QueryLexer.PRESENCE:\n        return lunr.QueryParser.parsePresence;\n      case lunr.QueryLexer.FIELD:\n        return lunr.QueryParser.parseField;\n      case lunr.QueryLexer.TERM:\n        return lunr.QueryParser.parseTerm;\n      default:\n        var errorMessage = \"expected either a field or a term, found \" + lexeme.type;\n        if (lexeme.str.length >= 1) {\n          errorMessage += \" with value '\" + lexeme.str + \"'\";\n        }\n        throw new lunr.QueryParseError(errorMessage, lexeme.start, lexeme.end);\n    }\n  };\n  lunr.QueryParser.parsePresence = function (parser) {\n    var lexeme = parser.consumeLexeme();\n    if (lexeme == undefined) {\n      return;\n    }\n    switch (lexeme.str) {\n      case \"-\":\n        parser.currentClause.presence = lunr.Query.presence.PROHIBITED;\n        break;\n      case \"+\":\n        parser.currentClause.presence = lunr.Query.presence.REQUIRED;\n        break;\n      default:\n        var errorMessage = \"unrecognised presence operator'\" + lexeme.str + \"'\";\n        throw new lunr.QueryParseError(errorMessage, lexeme.start, lexeme.end);\n    }\n    var nextLexeme = parser.peekLexeme();\n    if (nextLexeme == undefined) {\n      var errorMessage = \"expecting term or field, found nothing\";\n      throw new lunr.QueryParseError(errorMessage, lexeme.start, lexeme.end);\n    }\n    switch (nextLexeme.type) {\n      case lunr.QueryLexer.FIELD:\n        return lunr.QueryParser.parseField;\n      case lunr.QueryLexer.TERM:\n        return lunr.QueryParser.parseTerm;\n      default:\n        var errorMessage = \"expecting term or field, found '\" + nextLexeme.type + \"'\";\n        throw new lunr.QueryParseError(errorMessage, nextLexeme.start, nextLexeme.end);\n    }\n  };\n  lunr.QueryParser.parseField = function (parser) {\n    var lexeme = parser.consumeLexeme();\n    if (lexeme == undefined) {\n      return;\n    }\n    if (parser.query.allFields.indexOf(lexeme.str) == -1) {\n      var possibleFields = parser.query.allFields.map(function (f) {\n          return \"'\" + f + \"'\";\n        }).join(', '),\n        errorMessage = \"unrecognised field '\" + lexeme.str + \"', possible fields: \" + possibleFields;\n      throw new lunr.QueryParseError(errorMessage, lexeme.start, lexeme.end);\n    }\n    parser.currentClause.fields = [lexeme.str];\n    var nextLexeme = parser.peekLexeme();\n    if (nextLexeme == undefined) {\n      var errorMessage = \"expecting term, found nothing\";\n      throw new lunr.QueryParseError(errorMessage, lexeme.start, lexeme.end);\n    }\n    switch (nextLexeme.type) {\n      case lunr.QueryLexer.TERM:\n        return lunr.QueryParser.parseTerm;\n      default:\n        var errorMessage = \"expecting term, found '\" + nextLexeme.type + \"'\";\n        throw new lunr.QueryParseError(errorMessage, nextLexeme.start, nextLexeme.end);\n    }\n  };\n  lunr.QueryParser.parseTerm = function (parser) {\n    var lexeme = parser.consumeLexeme();\n    if (lexeme == undefined) {\n      return;\n    }\n    parser.currentClause.term = lexeme.str.toLowerCase();\n    if (lexeme.str.indexOf(\"*\") != -1) {\n      parser.currentClause.usePipeline = false;\n    }\n    var nextLexeme = parser.peekLexeme();\n    if (nextLexeme == undefined) {\n      parser.nextClause();\n      return;\n    }\n    switch (nextLexeme.type) {\n      case lunr.QueryLexer.TERM:\n        parser.nextClause();\n        return lunr.QueryParser.parseTerm;\n      case lunr.QueryLexer.FIELD:\n        parser.nextClause();\n        return lunr.QueryParser.parseField;\n      case lunr.QueryLexer.EDIT_DISTANCE:\n        return lunr.QueryParser.parseEditDistance;\n      case lunr.QueryLexer.BOOST:\n        return lunr.QueryParser.parseBoost;\n      case lunr.QueryLexer.PRESENCE:\n        parser.nextClause();\n        return lunr.QueryParser.parsePresence;\n      default:\n        var errorMessage = \"Unexpected lexeme type '\" + nextLexeme.type + \"'\";\n        throw new lunr.QueryParseError(errorMessage, nextLexeme.start, nextLexeme.end);\n    }\n  };\n  lunr.QueryParser.parseEditDistance = function (parser) {\n    var lexeme = parser.consumeLexeme();\n    if (lexeme == undefined) {\n      return;\n    }\n    var editDistance = parseInt(lexeme.str, 10);\n    if (isNaN(editDistance)) {\n      var errorMessage = \"edit distance must be numeric\";\n      throw new lunr.QueryParseError(errorMessage, lexeme.start, lexeme.end);\n    }\n    parser.currentClause.editDistance = editDistance;\n    var nextLexeme = parser.peekLexeme();\n    if (nextLexeme == undefined) {\n      parser.nextClause();\n      return;\n    }\n    switch (nextLexeme.type) {\n      case lunr.QueryLexer.TERM:\n        parser.nextClause();\n        return lunr.QueryParser.parseTerm;\n      case lunr.QueryLexer.FIELD:\n        parser.nextClause();\n        return lunr.QueryParser.parseField;\n      case lunr.QueryLexer.EDIT_DISTANCE:\n        return lunr.QueryParser.parseEditDistance;\n      case lunr.QueryLexer.BOOST:\n        return lunr.QueryParser.parseBoost;\n      case lunr.QueryLexer.PRESENCE:\n        parser.nextClause();\n        return lunr.QueryParser.parsePresence;\n      default:\n        var errorMessage = \"Unexpected lexeme type '\" + nextLexeme.type + \"'\";\n        throw new lunr.QueryParseError(errorMessage, nextLexeme.start, nextLexeme.end);\n    }\n  };\n  lunr.QueryParser.parseBoost = function (parser) {\n    var lexeme = parser.consumeLexeme();\n    if (lexeme == undefined) {\n      return;\n    }\n    var boost = parseInt(lexeme.str, 10);\n    if (isNaN(boost)) {\n      var errorMessage = \"boost must be numeric\";\n      throw new lunr.QueryParseError(errorMessage, lexeme.start, lexeme.end);\n    }\n    parser.currentClause.boost = boost;\n    var nextLexeme = parser.peekLexeme();\n    if (nextLexeme == undefined) {\n      parser.nextClause();\n      return;\n    }\n    switch (nextLexeme.type) {\n      case lunr.QueryLexer.TERM:\n        parser.nextClause();\n        return lunr.QueryParser.parseTerm;\n      case lunr.QueryLexer.FIELD:\n        parser.nextClause();\n        return lunr.QueryParser.parseField;\n      case lunr.QueryLexer.EDIT_DISTANCE:\n        return lunr.QueryParser.parseEditDistance;\n      case lunr.QueryLexer.BOOST:\n        return lunr.QueryParser.parseBoost;\n      case lunr.QueryLexer.PRESENCE:\n        parser.nextClause();\n        return lunr.QueryParser.parsePresence;\n      default:\n        var errorMessage = \"Unexpected lexeme type '\" + nextLexeme.type + \"'\";\n        throw new lunr.QueryParseError(errorMessage, nextLexeme.start, nextLexeme.end);\n    }\n  }\n\n  /**\n   * export the module via AMD, CommonJS or as a browser global\n   * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js\n   */;\n  (function (root, factory) {\n    if (typeof define === 'function' && define.amd) {\n      // AMD. Register as an anonymous module.\n      define(factory);\n    } else if (typeof exports === 'object') {\n      /**\n       * Node. Does not work with strict CommonJS, but\n       * only CommonJS-like enviroments that support module.exports,\n       * like Node.\n       */\n      module.exports = factory();\n    } else {\n      // Browser globals (root is window)\n      root.lunr = factory();\n    }\n  })(this, function () {\n    /**\n     * Just return a value to define the module export.\n     * This example returns an object, but the module\n     * can return a function as the exported value.\n     */\n    return lunr;\n  });\n})();","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar defineProperty = require('../internals/object-define-property').f;\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n  defineProperty(ArrayPrototype, UNSCOPABLES, {\n    configurable: true,\n    value: create(null)\n  });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n  ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","var isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\nvar $Array = Array;\n\n// a part of `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray) {\n  var C;\n  if (isArray(originalArray)) {\n    C = originalArray.constructor;\n    // cross-realm fallback\n    if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;\n    else if (isObject(C)) {\n      C = C[SPECIES];\n      if (C === null) C = undefined;\n    }\n  } return C === undefined ? $Array : C;\n};\n","var arraySpeciesConstructor = require('../internals/array-species-constructor');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n  return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);\n};\n","var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar $Object = Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n  try {\n    return it[key];\n  } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n  var O, tag, result;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag\n    // builtinTag case\n    : CORRECT_ARGUMENTS ? classofRaw(O)\n    // ES3 arguments fallback\n    : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","var $TypeError = TypeError;\nvar MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991\n\nmodule.exports = function (it) {\n  if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');\n  return it;\n};\n","'use strict';\nvar isArray = require('../internals/is-array');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');\nvar bind = require('../internals/function-bind-context');\n\n// `FlattenIntoArray` abstract operation\n// https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray\nvar flattenIntoArray = function (target, original, source, sourceLen, start, depth, mapper, thisArg) {\n  var targetIndex = start;\n  var sourceIndex = 0;\n  var mapFn = mapper ? bind(mapper, thisArg) : false;\n  var element, elementLen;\n\n  while (sourceIndex < sourceLen) {\n    if (sourceIndex in source) {\n      element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];\n\n      if (depth > 0 && isArray(element)) {\n        elementLen = lengthOfArrayLike(element);\n        targetIndex = flattenIntoArray(target, original, element, elementLen, targetIndex, depth - 1) - 1;\n      } else {\n        doesNotExceedSafeInteger(targetIndex + 1);\n        target[targetIndex] = element;\n      }\n\n      targetIndex++;\n    }\n    sourceIndex++;\n  }\n  return targetIndex;\n};\n\nmodule.exports = flattenIntoArray;\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n  aCallable(fn);\n  return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {\n    return fn.apply(that, arguments);\n  };\n};\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","var classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n  return classof(argument) == 'Array';\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.exec(noop);\n\nvar isConstructorModern = function isConstructor(argument) {\n  if (!isCallable(argument)) return false;\n  try {\n    construct(noop, empty, argument);\n    return true;\n  } catch (error) {\n    return false;\n  }\n};\n\nvar isConstructorLegacy = function isConstructor(argument) {\n  if (!isCallable(argument)) return false;\n  switch (classof(argument)) {\n    case 'AsyncFunction':\n    case 'GeneratorFunction':\n    case 'AsyncGeneratorFunction': return false;\n  }\n  try {\n    // we can't check .prototype since constructors produced by .bind haven't it\n    // `Function#toString` throws on some built-it function in some legacy engines\n    // (for example, `DOMQuad` and similar in FF41-)\n    return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n  } catch (error) {\n    return true;\n  }\n};\n\nisConstructorLegacy.sham = true;\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n  var called;\n  return isConstructorModern(isConstructorModern.call)\n    || !isConstructorModern(Object)\n    || !isConstructorModern(function () { called = true; })\n    || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar definePropertiesModule = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n  activeXDocument.write(scriptTag(''));\n  activeXDocument.close();\n  var temp = activeXDocument.parentWindow.Object;\n  activeXDocument = null; // avoid memory leak\n  return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = documentCreateElement('iframe');\n  var JS = 'java' + SCRIPT + ':';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  html.appendChild(iframe);\n  // https://github.com/zloirock/core-js/issues/475\n  iframe.src = String(JS);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(scriptTag('document.F=Object'));\n  iframeDocument.close();\n  return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n  try {\n    activeXDocument = new ActiveXObject('htmlfile');\n  } catch (error) { /* ignore */ }\n  NullProtoObject = typeof document != 'undefined'\n    ? document.domain && activeXDocument\n      ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n      : NullProtoObjectViaIFrame()\n    : NullProtoObjectViaActiveX(activeXDocument); // WSH\n  var length = enumBugKeys.length;\n  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n  return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\n// eslint-disable-next-line es/no-object-create -- safe\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    EmptyConstructor[PROTOTYPE] = anObject(O);\n    result = new EmptyConstructor();\n    EmptyConstructor[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = NullProtoObject();\n  return Properties === undefined ? result : definePropertiesModule.f(result, Properties);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nexports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var props = toIndexedObject(Properties);\n  var keys = objectKeys(Properties);\n  var length = keys.length;\n  var index = 0;\n  var key;\n  while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n  return O;\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n  return internalObjectKeys(O, enumBugKeys);\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","'use strict';\nvar $ = require('../internals/export');\nvar flattenIntoArray = require('../internals/flatten-into-array');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\n// `Array.prototype.flat` method\n// https://tc39.es/ecma262/#sec-array.prototype.flat\n$({ target: 'Array', proto: true }, {\n  flat: function flat(/* depthArg = 1 */) {\n    var depthArg = arguments.length ? arguments[0] : undefined;\n    var O = toObject(this);\n    var sourceLen = lengthOfArrayLike(O);\n    var A = arraySpeciesCreate(O, 0);\n    A.length = flattenIntoArray(A, O, O, sourceLen, 0, depthArg === undefined ? 1 : toIntegerOrInfinity(depthArg));\n    return A;\n  }\n});\n","// this method was added to unscopables after implementation\n// in popular engines, so it's moved to a separate module\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('flat');\n","import React from 'react'\nimport {css} from '@emotion/react'\n\nimport {MultiSearchIndexResult} from '../hooks/useMultiSearchIndex'\n\ninterface SearchResultProps {\n  active?: boolean\n  result: MultiSearchIndexResult\n  pathPrefix?: string\n  onSelect: (result: MultiSearchIndexResult) => void\n  onMouseEnter: (event: React.MouseEvent<HTMLDivElement>) => void\n}\n\nconst searchResultCss = css`\n  padding: 8px 10px;\n  margin: 0;\n  border-radius: 2px;\n  cursor: pointer;\n\n  > p {\n    margin: 0;\n    white-space: nowrap;\n    text-overflow: ellipsis;\n    overflow: hidden;\n  }\n`\n\nconst activeSearchResultCss = css`\n  background: rgba(144, 219, 236, 0.3);\n`\n\nconst titleCss = css`\n  font-weight: bold;\n`\n\nfunction getResultPath(title: string, path: string[]): string {\n  let resultPath = [...path, title]\n  // if page title and first path heading are the same remove one\n  if (resultPath[0] === resultPath[1]) resultPath = resultPath.splice(1).filter((item) => item)\n  return resultPath.join(' » ')\n}\n\nexport default function SearchResult({\n  active,\n  result,\n  onSelect,\n  onMouseEnter,\n}: SearchResultProps): JSX.Element {\n  const {ref, store} = result\n  const {title, path = []} = store\n\n  return (\n    <li key={ref}>\n      <div\n        data-testid=\"search-result\"\n        css={[searchResultCss, active && activeSearchResultCss]}\n        onClick={(event) => {\n          event.stopPropagation()\n          onSelect(result)\n        }}\n        onKeyDown={(event) => {\n          if (event.key === 'Enter') onSelect(result)\n        }}\n        onMouseEnter={onMouseEnter}\n      >\n        <p css={titleCss}>{title}</p>\n        <p>{getResultPath(title, path)}</p>\n      </div>\n    </li>\n  )\n}\n","import {useCallback, useState} from 'react'\nimport lunr from 'lunr'\n\ntype LoadSearchIndex = () => Promise<void>\n\nexport type Indices = (string | SerializedIndexWithStore)[]\n\ninterface SerializedIndexWithStore {\n  index: Record<string, unknown>\n  store: Record<string, unknown>\n}\n\ninterface IndexWithStore {\n  index: lunr.Index\n  store: Record<string, unknown>\n}\n\ninterface MultiSearchIndexState {\n  multiSearchIndex?: MultiSearchIndex\n  loadSearchIndex: LoadSearchIndex\n  loading: boolean\n  loaded: boolean\n  error?: string\n}\n\ninterface StoredSearchResult {\n  title: string\n  url: string\n  path: string[]\n}\n\nexport interface MultiSearchIndexResult extends lunr.Index.Result {\n  store: StoredSearchResult\n}\n\nclass MultiSearchIndex {\n  indices: IndexWithStore[]\n\n  constructor(indices: IndexWithStore[]) {\n    this.indices = indices\n  }\n\n  search(queryString: string): MultiSearchIndexResult[] {\n    return this.indices.reduce<MultiSearchIndexResult[]>((acc, searchIndex) => {\n      try {\n        // run the query on every search index and concat the results together sorted by score\n        return acc\n          .concat(\n            searchIndex.index.search(queryString).map((result) => ({\n              // zip stored value with lunr result\n              store: searchIndex.store[result.ref],\n              ...result,\n            }))\n          )\n          .sort((a, b) => b.score - a.score)\n      } catch (e) {\n        return acc\n      }\n    }, [])\n  }\n}\n\nexport default function useMultiSearchIndex({\n  indices,\n  loadOnMount = false,\n}: {\n  indices: Indices\n  loadOnMount?: boolean\n}): MultiSearchIndexState {\n  const [loading, setLoading] = useState(!!loadOnMount)\n  const [loaded, setLoaded] = useState(false)\n  const [error, setError] = useState<string | null>(null)\n  const [multiSearchIndex, setMultiSearchIndex] = useState<MultiSearchIndex | null>(null)\n\n  const loadSearchIndex = useCallback(() => {\n    setMultiSearchIndex(null)\n    setLoading(true)\n    setLoaded(false)\n    setError(null)\n\n    return Promise.all(\n      indices.map((pathOrIndex) => {\n        if (typeof pathOrIndex === 'string') {\n          return fetch(pathOrIndex).then((response) => response.json())\n        }\n        return Promise.resolve(pathOrIndex as SerializedIndexWithStore)\n      })\n    )\n      .then((indexResults) =>\n        indexResults.map(({index, store}) => ({index: lunr.Index.load(index), store}))\n      )\n      .then((searchIndices: IndexWithStore[]) => {\n        setMultiSearchIndex(new MultiSearchIndex(searchIndices))\n        setLoading(false)\n        setLoaded(true)\n        setError(null)\n      })\n      .catch(() => {\n        setLoading(false)\n        setError('Failed to load search index')\n      })\n  }, [indices])\n\n  const multiSearchIndexState: MultiSearchIndexState = {\n    loadSearchIndex,\n    loading,\n    loaded,\n  }\n  if (multiSearchIndex) multiSearchIndexState.multiSearchIndex = multiSearchIndex\n  if (error) multiSearchIndexState.error = error\n  return multiSearchIndexState\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * This is a modified version of the Docusaurus TOCHighlight, which can be found here:\n * https://github.com/facebook/docusaurus/blob/5ccd24/packages/docusaurus-theme-classic/src/theme/hooks/useTOCHighlight.ts\n */\n\nimport {useEffect, useState} from 'react'\n\nfunction useTOCHighlight(\n  scrollContainer?: React.RefObject<HTMLElement>,\n  linkClassName: string,\n  linkActiveClassName: string,\n  topOffset: number\n): void {\n  const [lastActiveLink, setLastActiveLink] = useState<HTMLAnchorElement | undefined>(undefined)\n\n  useEffect(() => {\n    let headersAnchors: HTMLCollectionOf<Element>\n    let links: HTMLCollectionOf<HTMLAnchorElement>\n\n    function setActiveLink(): void {\n      function getActiveHeaderAnchorValue(): string | null {\n        let index = 0\n        const activeHeaderAnchor: HTMLAnchorElement | null = null\n\n        // @ts-expect-error: ts(2339)\n        headersAnchors = document.querySelectorAll(`a[href*=\"#\"]:not(.${linkClassName})`)\n        while (index < headersAnchors.length && !activeHeaderAnchor) {\n          const headerAnchor = headersAnchors[index]\n          const {top} = headerAnchor.getBoundingClientRect()\n\n          if (top + topOffset >= 0) {\n            const {href} = headerAnchor\n            const headerAnchorValue = decodeURIComponent(href.substring(href.indexOf('#') + 1))\n            return headerAnchorValue\n          }\n\n          index += 1\n        }\n\n        return null\n      }\n\n      const activeHeaderAnchorValue = getActiveHeaderAnchorValue()\n\n      if (activeHeaderAnchorValue) {\n        let index = 0\n        let itemHighlighted = false\n\n        // @ts-expect-error: Must be <a> tags.\n        links = document.getElementsByClassName(linkClassName)\n        while (index < links.length && !itemHighlighted) {\n          const link = links[index]\n          const {href} = link\n          const anchorValue = decodeURIComponent(href.substring(href.indexOf('#') + 1))\n\n          if (activeHeaderAnchorValue === anchorValue) {\n            if (lastActiveLink) {\n              lastActiveLink.classList.remove(linkActiveClassName)\n            }\n            link.classList.add(linkActiveClassName)\n            setLastActiveLink(link)\n            itemHighlighted = true\n          }\n\n          index += 1\n        }\n      }\n    }\n\n    const element = scrollContainer?.current || document\n    element.addEventListener('scroll', setActiveLink)\n    element.addEventListener('resize', setActiveLink)\n\n    setActiveLink()\n\n    return () => {\n      element.removeEventListener('scroll', setActiveLink)\n      element.removeEventListener('resize', setActiveLink)\n    }\n  }, [scrollContainer, lastActiveLink, linkActiveClassName, linkClassName, topOffset])\n}\n\nexport default useTOCHighlight\n","import React from 'react'\n\nimport Link from '../Link'\n\nimport getNavItemUrl from './getNavItemUrl'\nimport {NavItemProps} from './types'\n\nexport default function NavItem({\n  navEntry,\n  location,\n  pathPrefix = '',\n  flat,\n  className,\n  linkCss,\n  listCss,\n  linkClassName = '',\n}: NavItemProps): JSX.Element {\n  const {title, url = '', items} = navEntry\n\n  return (\n    <li className={className}>\n      {url ? (\n        <Link css={linkCss} className={linkClassName} to={getNavItemUrl(navEntry, pathPrefix)}>\n          {title}\n        </Link>\n      ) : (\n        // TODO: style header\n        title\n      )}\n      {!!items?.length && !flat && (\n        <ul css={listCss}>\n          {items.map((entry) => (\n            <NavItem\n              key={`${entry.title}:${entry.url}`}\n              location={location}\n              pathPrefix={pathPrefix}\n              className={className}\n              linkCss={linkCss}\n              listCss={listCss}\n              linkClassName={linkClassName}\n              navEntry={entry}\n            />\n          ))}\n        </ul>\n      )}\n    </li>\n  )\n}\n","import React from 'react'\nimport {PageProps} from 'gatsby'\nimport {css} from '@emotion/react'\n\nimport useTOCHighlight from '../../hooks/useTOCHighlight'\n\nimport NavItem from './NavItem'\nimport {NavEntry} from './types'\n\nconst LINK_CLASS_NAME = 'toc-link'\nconst LINK_ACTIVE_CLASS_NAME = 'active'\n\nconst listCss = css`\n  margin: 0 10px 4px;\n  list-style-type: none;\n  margin-left: 20px;\n`\n\nconst linkCss = css`\n  display: block;\n  text-decoration: none;\n  color: black;\n  margin-bottom: 4px;\n  border-radius: 4px;\n  padding: 4px;\n  line-height: 16px;\n\n  &.${LINK_ACTIVE_CLASS_NAME} {\n    font-weight: bold;\n  }\n\n  &:hover {\n    background: #e4e4ed;\n  }\n`\n\nconst navItemCss = css`\n  margin: 4px 0;\n`\n\nconst navCss = css`\n  overflow-y: auto;\n`\n\ninterface SidebarProps {\n  className?: string\n  scrollContainer?: React.RefObject<HTMLElement>\n  navList?: NavEntry[]\n  location: PageProps['location']\n  pathPrefix?: string\n}\n\nexport default function Sidebar({\n  className,\n  navList,\n  location,\n  pathPrefix = '',\n  scrollContainer,\n}: SidebarProps): JSX.Element {\n  useTOCHighlight(scrollContainer, LINK_CLASS_NAME, LINK_ACTIVE_CLASS_NAME, 25)\n  return (\n    <nav css={navCss} className={className}>\n      <ul css={listCss} className=\"parent-list\">\n        {navList?.length &&\n          navList.map((entry) => (\n            <NavItem\n              location={location}\n              key={entry.title}\n              pathPrefix={pathPrefix}\n              css={navItemCss}\n              linkCss={linkCss}\n              linkClassName={LINK_CLASS_NAME}\n              listCss={listCss}\n              navEntry={entry}\n            />\n          ))}\n      </ul>\n    </nav>\n  )\n}\n","import React, {forwardRef} from 'react'\nimport {css} from '@emotion/react'\n\nimport Link, {LinkProps} from './Link'\n\nconst buttonCss = css`\n  font-size: 16px;\n  text-align: center;\n  transition: all 300ms;\n  background-color: #139ebf;\n  padding: 10px 15px;\n  border: none;\n  color: white;\n\n  &:hover {\n    background-color: #1086a3;\n  }\n\n  svg {\n    vertical-align: middle;\n  }\n`\n\ninterface ButtonLinkProps extends LinkProps {\n  icon?: React.ReactNode\n}\n\nfunction ButtonLink(\n  {children, icon, ...passthru}: ButtonLinkProps,\n  ref: React.Ref<HTMLAnchorElement>\n): JSX.Element {\n  return (\n    /* @ts-ignore */\n    <Link ref={ref} {...passthru} css={buttonCss}>\n      {children}\n      {icon}\n    </Link>\n  )\n}\n\nexport default forwardRef(ButtonLink)\n","import {css, SerializedStyles} from '@emotion/react'\nimport {PageProps, withPrefix} from 'gatsby'\nimport React, {useContext, useState, useEffect, useMemo, useRef} from 'react'\nimport {throttle} from 'lodash'\n\nimport HorizontalNav from '../components/nav/HorizontalNav'\nimport Sidebar from '../components/nav/Sidebar'\nimport SearchBar from '../components/SearchBar'\nimport NavigationContext from '../providers/NavigationContext'\nimport Header from '../components/Header'\nimport Meta from '../components/Meta'\nimport VersionContext from '../providers/VersionContext'\nimport {PageEntry} from '../types'\nimport {secondaryHeaderHeight, headerHeight, fadingHeaderSpeed} from '../constants'\nimport ButtonLink from '../components/ButtonLink'\nimport UserContext from '../providers/UserContext'\nimport HeaderHeightContext from '../providers/HeaderHeightContext'\nimport normalizePath from '../utils/normalizePath'\nimport useDelay from '../hooks/useDelay'\n\nimport Base from './Base'\nimport {fixedHeaderCss, mainContentCss} from './PageWithHeader'\n\nconst wrapperCss = css`\n  display: flex;\n  flex: 1 1 auto;\n  width: 1250px;\n  max-width: 100vw;\n  transition: margin-top ${fadingHeaderSpeed};\n  margin: ${headerHeight + secondaryHeaderHeight}px auto 0 auto;\n`\n\nconst sidebarContainer = css`\n  width: 250px;\n  padding: 0;\n  position: relative;\n\n  @media (max-width: 1024px) {\n    display: none;\n  }\n`\n\nconst initialSidebarOffset = headerHeight + secondaryHeaderHeight + 10\nconst sidebarCss = css`\n  position: sticky;\n  transition: top ${fadingHeaderSpeed};\n  top: ${initialSidebarOffset}px;\n  max-height: calc(100vh - ${initialSidebarOffset}px);\n`\n\nconst secondaryHeaderCss = css`\n  display: flex;\n  background: #292f31;\n  position: relative;\n  flex: 1 1 100%;\n  height: ${secondaryHeaderHeight}px;\n  z-index: -1;\n  align-items: center;\n  justify-content: space-between;\n  padding: 5px 5px 5px 14px;\n  border-bottom: 1px solid black;\n  transition: all ${fadingHeaderSpeed};\n\n  @media screen and (max-width: 1024px) {\n    padding-right: 0px;\n  }\n`\n\nconst hiddenHeaderCss = css`\n  height: 0;\n  padding-top: 0;\n  padding-bottom: 0;\n  overflow: hidden;\n`\n\nconst buttonCss = css`\n  max-width: 100px;\n  margin: 0 10px 0 auto;\n  padding: 6px 10px;\n  white-space: nowrap;\n  overflow: hidden;\n  position: relative;\n  width: 100%;\n\n  @media screen and (max-width: 600px) {\n    display: none;\n  }\n`\n\ninterface PageWithNavProps {\n  className?: string\n  children: React.ReactNode\n  location: PageProps['location']\n  pathPrefix?: string\n  pageConfig?: PageEntry\n  mainCssOverrides?: SerializedStyles\n}\n\nexport default function PageWithNav({\n  className,\n  children,\n  location,\n  pageConfig,\n  mainCssOverrides,\n}: PageWithNavProps): JSX.Element {\n  const {version} = useContext(VersionContext)\n  const {fullHeaderHeight, setFullHeaderHeight} = useContext(HeaderHeightContext)\n  const {navList, tableOfContents} = useContext(NavigationContext)\n  const pathPrefix = version?.latest ? '' : `/${version?.identifier}`\n  const mainRef = useRef<HTMLElement>(null)\n  const {user, _state: userState} = useContext(UserContext)\n  const demoPage = navList.find(({type}) => type === 'demo')\n  const indices = useMemo(() => {\n    if (!version) return []\n    return [withPrefix(`${version.identifier}_search_index.json?v=${BUILD_DATE}`)]\n  }, [version])\n  const sidebarOffset = fullHeaderHeight + 10\n\n  const [secondaryHeaderVisible, setSecondaryHeaderVisible] = useState(true)\n\n  // reset the header when navigating between pages, otherwise can get stuck hidden if navigating\n  // to a page without scroll overflow\n  const [headerHideDelay, setHeaderHideDelay] = useDelay(1000)\n  useEffect(() => {\n    setSecondaryHeaderVisible(true)\n    setHeaderHideDelay(false)\n  }, [location.pathname, setHeaderHideDelay])\n\n  useEffect(() => {\n    let lastScrollY = window.scrollY\n    const onScroll = throttle((): void => {\n      if (headerHideDelay) setSecondaryHeaderVisible(lastScrollY > window.scrollY)\n      lastScrollY = window.scrollY\n    }, 300)\n\n    window.addEventListener('scroll', onScroll)\n\n    return () => {\n      window.removeEventListener('scroll', onScroll)\n    }\n  }, [headerHideDelay])\n\n  useEffect(() => {\n    setFullHeaderHeight(\n      secondaryHeaderVisible ? headerHeight + secondaryHeaderHeight : headerHeight\n    )\n  }, [secondaryHeaderVisible, setFullHeaderHeight])\n\n  return (\n    <>\n      <Meta pageConfig={pageConfig} />\n      <Base>\n        <header css={fixedHeaderCss}>\n          <Header pageConfig={pageConfig} location={location} />\n          <div\n            data-testid=\"secondary-nav\"\n            css={[secondaryHeaderCss, !secondaryHeaderVisible && hiddenHeaderCss]}\n          >\n            <HorizontalNav\n              location={location}\n              navList={navList}\n              pathPrefix={pathPrefix}\n              activeItem={pageConfig?.url}\n              activeSection={pageConfig?.section}\n            />\n            {demoPage && userState === 'known' && !user?.email && (\n              <ButtonLink css={buttonCss} to={normalizePath(demoPage?.url)}>\n                Try for Free\n              </ButtonLink>\n            )}\n            <SearchBar\n              indices={indices}\n              pathPrefix={version && !version.latest ? `/${version.identifier}` : ''}\n            />\n          </div>\n        </header>\n\n        <div\n          css={[\n            wrapperCss,\n            css`\n              margin-top: fullHeaderHeight;\n            `,\n          ]}\n          className={className}\n        >\n          {!!(\n            tableOfContents &&\n            (tableOfContents.length > 1 || tableOfContents[0]?.items?.length)\n          ) && (\n            <aside css={sidebarContainer}>\n              <Sidebar\n                css={[\n                  sidebarCss,\n                  css`\n                    top: ${sidebarOffset}px;\n                    max-height: calc(100vh - ${sidebarOffset}px);\n                  `,\n                ]}\n                location={location}\n                navList={tableOfContents}\n                pathPrefix={pathPrefix}\n              />\n            </aside>\n          )}\n          <main ref={mainRef} css={[mainContentCss, mainCssOverrides]}>\n            {children}\n          </main>\n        </div>\n      </Base>\n    </>\n  )\n}\n","import React, {useEffect, useState} from 'react'\n\nexport default function useDelay(\n  delay: number\n): [boolean, React.Dispatch<React.SetStateAction<boolean>>] {\n  const [delayReached, setDelayReached] = useState(false)\n\n  useEffect(() => {\n    let timeoutId: number\n\n    if (!delayReached) {\n      timeoutId = window.setTimeout(() => {\n        setDelayReached(true)\n      }, delay)\n    }\n\n    return () => {\n      window.clearTimeout(timeoutId)\n    }\n  }, [delayReached, delay])\n\n  return [delayReached, setDelayReached]\n}\n","import {createContext} from 'react'\n\nimport {NavEntry} from '../components/nav/types'\n\ninterface NavigationContext {\n  navList: NavEntry[]\n  tableOfContents: NavEntry[]\n}\n\nexport default createContext<NavigationContext>({navList: [], tableOfContents: []})\n","import React, {useContext, useMemo} from 'react'\n\nimport {NavEntry} from '../components/nav/types'\n\nimport NavigationContext from './NavigationContext'\nimport UserContext from './UserContext'\n\ninterface NavigationProviderProps {\n  navList?: NavEntry[]\n  tableOfContents?: NavEntry[]\n}\n\nexport default function NavigationProvide({\n  children,\n  navList,\n  tableOfContents,\n}: React.PropsWithChildren<NavigationProviderProps>): JSX.Element {\n  const {user} = useContext(UserContext)\n  const visibleNavList = useMemo(\n    () =>\n      navList?.filter((navEntry) => {\n        // hide links with authDisplay mode based on auth state\n        if (navEntry.authDisplay === 'unauthenticated' && user?.email) return false\n        if (navEntry.authDisplay === 'authenticated' && !user?.email) return false\n        return true\n      }),\n    [navList, user]\n  )\n  const navigationContext = useMemo(\n    () => ({\n      navList: visibleNavList,\n      tableOfContents,\n    }),\n    [visibleNavList, tableOfContents]\n  )\n  return (\n    <NavigationContext.Provider value={navigationContext}>{children}</NavigationContext.Provider>\n  )\n}\n","import React, {useMemo} from 'react'\n\nimport {Version} from '../types'\n\nimport VersionContext from './VersionContext'\n\ninterface VersionProviderProps {\n  versions: Version[]\n  version?: Version\n}\nexport default function VersionProvider({\n  children,\n  version,\n  versions,\n}: React.PropsWithChildren<VersionProviderProps>): JSX.Element {\n  const versionsContext = useMemo(\n    () => ({\n      versions,\n      version,\n    }),\n    [version, versions]\n  )\n  return <VersionContext.Provider value={versionsContext}>{children}</VersionContext.Provider>\n}\n","var trimmedEndIndex = require('./_trimmedEndIndex');\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n  return string\n    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n    : string;\n}\n\nmodule.exports = baseTrim;\n","/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n  var index = string.length;\n\n  while (index-- && reWhitespace.test(string.charAt(index))) {}\n  return index;\n}\n\nmodule.exports = trimmedEndIndex;\n","var isObject = require('./isObject'),\n    now = require('./now'),\n    toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nmodule.exports = now;\n","var debounce = require('./debounce'),\n    isObject = require('./isObject');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\nmodule.exports = throttle;\n","var baseTrim = require('./_baseTrim'),\n    isObject = require('./isObject'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n","var setPrototypeOf = require(\"./setPrototypeOf.js\");\nvar isNativeReflectConstruct = require(\"./isNativeReflectConstruct.js\");\nfunction _construct(Parent, args, Class) {\n  if (isNativeReflectConstruct()) {\n    module.exports = _construct = Reflect.construct.bind(), module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  } else {\n    module.exports = _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) setPrototypeOf(instance, Class.prototype);\n      return instance;\n    }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  }\n  return _construct.apply(null, arguments);\n}\nmodule.exports = _construct, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\nmodule.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;"],"names":["Icon","d","global","step2list","step3list","v","C","re_mgr0","re_mgr1","re_meq1","re_s_v","re_1a","re2_1a","re_1b","re2_1b","re_1b_2","re2_1b_2","re3_1b_2","re4_1b_2","re_1c","re_2","re_3","re_4","re2_4","re_5","re_5_1","re3_5","porterStemmer","lunr","config","builder","Builder","pipeline","add","trimmer","stopWordFilter","stemmer","searchPipeline","call","build","version","utils","warn","this","message","console","asString","obj","toString","clone","Object","create","keys","i","length","key","val","Array","isArray","slice","TypeError","FieldRef","docRef","fieldName","stringValue","_stringValue","joiner","fromString","s","n","indexOf","fieldRef","prototype","undefined","Set","elements","complete","intersect","other","union","contains","empty","object","a","b","intersection","element","push","concat","idf","posting","documentCount","documentsWithTerm","x","Math","log","abs","Token","str","metadata","update","fn","tokenizer","map","t","toLowerCase","len","tokens","sliceEnd","sliceStart","sliceLength","charAt","match","separator","tokenMetadata","Pipeline","_stack","registeredFunctions","registerFunction","label","warnIfFunctionNotRegistered","load","serialised","forEach","fnName","Error","fns","arguments","after","existingFn","newFn","pos","splice","before","remove","run","stackLength","memo","j","result","k","runString","token","reset","toJSON","Vector","_magnitude","positionForIndex","index","start","end","pivotPoint","floor","pivotIndex","insert","insertIdx","upsert","position","magnitude","sumOfSquares","elementsLength","sqrt","dot","otherVector","dotProduct","aLen","bLen","aVal","bVal","similarity","toArray","output","c","RegExp","w","stem","suffix","firstch","re","re2","re3","re4","substr","toUpperCase","test","replace","fp","exec","generateStopWordFilter","stopWords","words","reduce","stopWord","TokenSet","final","edges","id","_nextId","fromArray","arr","finish","root","fromClause","clause","fromFuzzyString","term","editDistance","stack","node","editsRemaining","frame","pop","noEditNode","char","insertionNode","substitutionNode","transposeNode","charA","charB","next","prefix","edge","_str","labels","sort","qNode","qEdges","qLen","nEdges","nLen","q","qEdge","nEdge","previousWord","uncheckedNodes","minimizedNodes","word","commonPrefix","minimize","child","nextNode","parent","downTo","childKey","Index","attrs","invertedIndex","fieldVectors","tokenSet","fields","search","queryString","query","QueryParser","parse","Query","matchingFields","queryVectors","termFieldCache","requiredMatches","prohibitedMatches","clauses","terms","clauseMatches","usePipeline","m","termTokenSet","expandedTerms","presence","REQUIRED","field","expandedTerm","termIndex","_index","fieldPosting","matchingDocumentRefs","termField","matchingDocumentsSet","PROHIBITED","boost","l","fieldMatch","matchingDocumentRef","matchingFieldRef","MatchData","allRequiredMatches","allProhibitedMatches","matchingFieldRefs","results","matches","isNegated","docMatch","fieldVector","score","matchData","combine","ref","serializedIndex","serializedVectors","serializedInvertedIndex","tokenSetBuilder","tuple","_ref","_fields","_documents","fieldTermFrequencies","fieldLengths","_b","_k1","metadataWhitelist","attributes","RangeError","number","k1","doc","extractor","fieldTerms","metadataKey","calculateAverageFieldLengths","fieldRefs","numberOfFields","accumulator","documentsWithField","averageFieldLength","createFieldVectors","fieldRefsLength","termIdfCache","fieldLength","termFrequencies","termsLength","fieldBoost","docBoost","scoreWithPrecision","tf","round","createTokenSet","use","args","unshift","apply","clonedMetadata","metadataKeys","otherMatchData","allFields","wildcard","String","NONE","LEADING","TRAILING","OPTIONAL","options","QueryParseError","name","QueryLexer","lexemes","escapeCharPositions","state","lexText","sliceString","subSlices","join","emit","type","escapeCharacter","EOS","width","ignore","backup","acceptDigitRun","charCode","charCodeAt","more","FIELD","TERM","EDIT_DISTANCE","BOOST","PRESENCE","lexField","lexer","lexTerm","lexEditDistance","lexBoost","lexEOS","termSeparator","currentClause","lexemeIdx","parseClause","peekLexeme","consumeLexeme","lexeme","nextClause","completedClause","parser","parsePresence","parseField","parseTerm","errorMessage","nextLexeme","possibleFields","f","parseEditDistance","parseBoost","parseInt","isNaN","wellKnownSymbol","defineProperty","UNSCOPABLES","ArrayPrototype","configurable","value","module","exports","isConstructor","isObject","SPECIES","$Array","originalArray","constructor","arraySpeciesConstructor","TO_STRING_TAG_SUPPORT","isCallable","classofRaw","TO_STRING_TAG","$Object","CORRECT_ARGUMENTS","it","O","tag","error","tryGet","callee","$TypeError","lengthOfArrayLike","doesNotExceedSafeInteger","bind","flattenIntoArray","target","original","source","sourceLen","depth","mapper","thisArg","elementLen","targetIndex","sourceIndex","mapFn","uncurryThis","aCallable","NATIVE_BIND","that","getBuiltIn","classof","argument","fails","inspectSource","noop","construct","constructorRegExp","INCORRECT_TO_STRING","isConstructorModern","isConstructorLegacy","sham","called","activeXDocument","anObject","definePropertiesModule","enumBugKeys","hiddenKeys","html","documentCreateElement","sharedKey","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObjectViaActiveX","write","close","temp","parentWindow","NullProtoObject","ActiveXObject","iframeDocument","iframe","document","domain","style","display","appendChild","src","contentWindow","open","F","Properties","DESCRIPTORS","V8_PROTOTYPE_DEFINE_BUG","definePropertyModule","toIndexedObject","objectKeys","defineProperties","props","internalObjectKeys","$","toObject","toIntegerOrInfinity","arraySpeciesCreate","proto","flat","depthArg","A","addToUnscopables","searchResultCss","activeSearchResultCss","titleCss","SearchResult","active","onSelect","onMouseEnter","store","title","path","css","onClick","event","stopPropagation","onKeyDown","resultPath","filter","item","getResultPath","MultiSearchIndex","indices","acc","searchIndex","e","useMultiSearchIndex","loadOnMount","useState","loading","setLoading","loaded","setLoaded","setError","multiSearchIndex","setMultiSearchIndex","multiSearchIndexState","loadSearchIndex","useCallback","Promise","all","pathOrIndex","fetch","then","response","json","resolve","indexResults","searchIndices","catch","scrollContainer","linkClassName","linkActiveClassName","topOffset","lastActiveLink","setLastActiveLink","useEffect","headersAnchors","links","setActiveLink","activeHeaderAnchorValue","querySelectorAll","headerAnchor","getBoundingClientRect","top","href","decodeURIComponent","substring","getActiveHeaderAnchorValue","itemHighlighted","getElementsByClassName","link","classList","current","addEventListener","removeEventListener","NavItem","navEntry","location","pathPrefix","className","linkCss","listCss","url","items","Link","to","getNavItemUrl","entry","LINK_CLASS_NAME","LINK_ACTIVE_CLASS_NAME","navItemCss","navCss","Sidebar","navList","useTOCHighlight","buttonCss","ButtonLink","children","icon","passthru","forwardRef","wrapperCss","fadingHeaderSpeed","headerHeight","secondaryHeaderHeight","sidebarContainer","initialSidebarOffset","sidebarCss","secondaryHeaderCss","hiddenHeaderCss","PageWithNav","pageConfig","mainCssOverrides","useContext","VersionContext","HeaderHeightContext","fullHeaderHeight","setFullHeaderHeight","NavigationContext","tableOfContents","latest","identifier","mainRef","useRef","UserContext","user","userState","_state","demoPage","find","useMemo","withPrefix","sidebarOffset","secondaryHeaderVisible","setSecondaryHeaderVisible","delay","delayReached","setDelayReached","timeoutId","window","setTimeout","clearTimeout","useDelay","headerHideDelay","setHeaderHideDelay","pathname","lastScrollY","scrollY","onScroll","Meta","Base","fixedHeaderCss","Header","HorizontalNav","activeItem","activeSection","section","email","normalizePath","SearchBar","mainContentCss","createContext","NavigationProvide","visibleNavList","authDisplay","navigationContext","VersionProvider","versions","versionsContext","trimmedEndIndex","reTrimStart","string","reWhitespace","now","toNumber","nativeMax","max","nativeMin","min","func","wait","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","invokeFunc","time","leadingEdge","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","cancel","flush","Date","debounce","baseTrim","isSymbol","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","valueOf","isBinary","setPrototypeOf","isNativeReflectConstruct","_construct","Parent","Class","Reflect","__esModule","instance","Function","Proxy","Boolean"],"sourceRoot":""}