{"version":3,"file":"main.30c4c99817464660d57a.js","mappings":"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,GAAYA,EACVpD,CACT,GAAG,CAAC,GAEJ,OAAO,SAAUI,GACf,GAAIA,GAAS8C,EAAM9C,EAAM5L,cAAgB4L,EAAM5L,WAAY,OAAO4L,CACpE,CACF,EAeArG,EAAKO,eAAiBP,EAAKiJ,uBAAuB,CAChD,IACA,OACA,QACA,SACA,QACA,MACA,SACA,OACA,KACA,QACA,KACA,MACA,MACA,MACA,KACA,KACA,KACA,UACA,OACA,MACA,KACA,MACA,SACA,QACA,OACA,MACA,KACA,OACA,SACA,OACA,OACA,QACA,MACA,OACA,MACA,MACA,MACA,MACA,OACA,KACA,MACA,OACA,MACA,MACA,MACA,UACA,IACA,KACA,KACA,OACA,KACA,KACA,MACA,OACA,QACA,MACA,OACA,SACA,MACA,KACA,QACA,OACA,OACA,KACA,UACA,KACA,MACA,MACA,KACA,MACA,QACA,KACA,OACA,KACA,QACA,MACA,MACA,SACA,OACA,MACA,OACA,MACA,SACA,QACA,KACA,OACA,OACA,OACA,MACA,QACA,OACA,OACA,QACA,QACA,OACA,OACA,MACA,KACA,MACA,OACA,KACA,QACA,MACA,KACA,OACA,OACA,OACA,QACA,QACA,QACA,MACA,OACA,MACA,OACA,OACA,QACA,MACA,MACA,SAGFjJ,EAAK6E,SAASG,iBAAiBhF,EAAKO,eAAgB,kBAqBpDP,EAAKM,QAAU,SAAU+F,GACvB,OAAOA,EAAMvC,QAAO,SAAU5B,GAC5B,OAAOA,EAAErE,QAAQ,OAAQ,IAAIA,QAAQ,OAAQ,GAC/C,GACF,EAEAmC,EAAK6E,SAASG,iBAAiBhF,EAAKM,QAAS,YA2B7CN,EAAKsJ,SAAW,WACdvM,KAAKwM,OAAQ,EACbxM,KAAKyM,MAAQ,CAAC,EACdzM,KAAK0M,GAAKzJ,EAAKsJ,SAASI,QACxB1J,EAAKsJ,SAASI,SAAW,CAC3B,GAUcA,QAAU,EASxB1J,EAAKsJ,SAASK,UAAY,SAAUC,GAGlC,IAFA,IAAI1J,EAAU,IAAIF,EAAKsJ,SAASnJ,QAEvBkB,EAAI,EAAG+C,EAAMwF,EAAItI,OAAQD,EAAI+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","sources":["webpack://deveth0.de/./node_modules/lodash.throttle/index.js","webpack://deveth0.de/./node_modules/lunr/lunr.js","webpack://deveth0.de/./themes/deveth0-theme/src/components/backToTop.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/commento/count.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/commentsLazyLoader.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/cookieConsent.ts","webpack://deveth0.de/./themes/deveth0-theme/src/util/cookieHelper.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/gallery.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/lazyLoader.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/lightbox.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/postList.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/postNav.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/readingPositionIndicator.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/search.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/svgLoader.ts","webpack://deveth0.de/./themes/deveth0-theme/src/main.ts","webpack://deveth0.de/./themes/deveth0-theme/src/util/mqHelper.ts","webpack://deveth0.de/./themes/deveth0-theme/src/util/navObserver.ts","webpack://deveth0.de/webpack/bootstrap","webpack://deveth0.de/webpack/runtime/compat get default export","webpack://deveth0.de/webpack/runtime/define property getters","webpack://deveth0.de/webpack/runtime/global","webpack://deveth0.de/webpack/runtime/hasOwnProperty shorthand","webpack://deveth0.de/webpack/runtime/make namespace object","webpack://deveth0.de/./src/main.ts"],"sourcesContent":["/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\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 * 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\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        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\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        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\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\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\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 = value.replace(reTrim, '');\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 = throttle;\n","/**\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;(function(){\n\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 */\nvar lunr = function (config) {\n  var builder = new lunr.Builder\n\n  builder.pipeline.add(\n    lunr.trimmer,\n    lunr.stopWordFilter,\n    lunr.stemmer\n  )\n\n  builder.searchPipeline.add(\n    lunr.stemmer\n  )\n\n  config.call(builder, builder)\n  return builder.build()\n}\n\nlunr.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 */\nlunr.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 */\nlunr.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 */\nlunr.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 */\nlunr.utils.clone = function (obj) {\n  if (obj === null || obj === undefined) {\n    return obj\n  }\n\n  var clone = Object.create(null),\n      keys = Object.keys(obj)\n\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i],\n        val = obj[key]\n\n    if (Array.isArray(val)) {\n      clone[key] = val.slice()\n      continue\n    }\n\n    if (typeof val === 'string' ||\n        typeof val === 'number' ||\n        typeof val === 'boolean') {\n      clone[key] = val\n      continue\n    }\n\n    throw new TypeError(\"clone is not deep and does not support nested objects\")\n  }\n\n  return clone\n}\nlunr.FieldRef = function (docRef, fieldName, stringValue) {\n  this.docRef = docRef\n  this.fieldName = fieldName\n  this._stringValue = stringValue\n}\n\nlunr.FieldRef.joiner = \"/\"\n\nlunr.FieldRef.fromString = function (s) {\n  var n = s.indexOf(lunr.FieldRef.joiner)\n\n  if (n === -1) {\n    throw \"malformed field ref string\"\n  }\n\n  var fieldRef = s.slice(0, n),\n      docRef = s.slice(n + 1)\n\n  return new lunr.FieldRef (docRef, fieldRef, s)\n}\n\nlunr.FieldRef.prototype.toString = function () {\n  if (this._stringValue == undefined) {\n    this._stringValue = this.fieldName + lunr.FieldRef.joiner + this.docRef\n  }\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 */\nlunr.Set = function (elements) {\n  this.elements = Object.create(null)\n\n  if (elements) {\n    this.length = elements.length\n\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 */\nlunr.Set.complete = {\n  intersect: function (other) {\n    return other\n  },\n\n  union: function () {\n    return this\n  },\n\n  contains: function () {\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 */\nlunr.Set.empty = {\n  intersect: function () {\n    return this\n  },\n\n  union: function (other) {\n    return other\n  },\n\n  contains: function () {\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 */\nlunr.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\nlunr.Set.prototype.intersect = function (other) {\n  var a, b, elements, intersection = []\n\n  if (other === lunr.Set.complete) {\n    return this\n  }\n\n  if (other === lunr.Set.empty) {\n    return other\n  }\n\n  if (this.length < other.length) {\n    a = this\n    b = other\n  } else {\n    a = other\n    b = this\n  }\n\n  elements = Object.keys(a.elements)\n\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\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\nlunr.Set.prototype.union = function (other) {\n  if (other === lunr.Set.complete) {\n    return lunr.Set.complete\n  }\n\n  if (other === lunr.Set.empty) {\n    return this\n  }\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 */\nlunr.idf = function (posting, documentCount) {\n  var documentsWithTerm = 0\n\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\n  var x = (documentCount - documentsWithTerm + 0.5) / (documentsWithTerm + 0.5)\n\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 */\nlunr.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 */\nlunr.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 */\nlunr.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 */\nlunr.Token.prototype.clone = function (fn) {\n  fn = fn || function (s) { return s }\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 */\nlunr.tokenizer = function (obj, metadata) {\n  if (obj == null || obj == undefined) {\n    return []\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map(function (t) {\n      return new lunr.Token(\n        lunr.utils.asString(t).toLowerCase(),\n        lunr.utils.clone(metadata)\n      )\n    })\n  }\n\n  var str = obj.toString().toLowerCase(),\n      len = str.length,\n      tokens = []\n\n  for (var sliceEnd = 0, sliceStart = 0; sliceEnd <= len; sliceEnd++) {\n    var char = str.charAt(sliceEnd),\n        sliceLength = sliceEnd - sliceStart\n\n    if ((char.match(lunr.tokenizer.separator) || sliceEnd == len)) {\n\n      if (sliceLength > 0) {\n        var tokenMetadata = lunr.utils.clone(metadata) || {}\n        tokenMetadata[\"position\"] = [sliceStart, sliceLength]\n        tokenMetadata[\"index\"] = tokens.length\n\n        tokens.push(\n          new lunr.Token (\n            str.slice(sliceStart, sliceEnd),\n            tokenMetadata\n          )\n        )\n      }\n\n      sliceStart = sliceEnd + 1\n    }\n\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 */\nlunr.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 */\nlunr.Pipeline = function () {\n  this._stack = []\n}\n\nlunr.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 */\nlunr.Pipeline.registerFunction = function (fn, label) {\n  if (label in this.registeredFunctions) {\n    lunr.utils.warn('Overwriting existing registered function: ' + label)\n  }\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 */\nlunr.Pipeline.warnIfFunctionNotRegistered = function (fn) {\n  var isRegistered = fn.label && (fn.label in this.registeredFunctions)\n\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 */\nlunr.Pipeline.load = function (serialised) {\n  var pipeline = new lunr.Pipeline\n\n  serialised.forEach(function (fnName) {\n    var fn = lunr.Pipeline.registeredFunctions[fnName]\n\n    if (fn) {\n      pipeline.add(fn)\n    } else {\n      throw new Error('Cannot load unregistered function: ' + fnName)\n    }\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 */\nlunr.Pipeline.prototype.add = function () {\n  var fns = Array.prototype.slice.call(arguments)\n\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 */\nlunr.Pipeline.prototype.after = function (existingFn, newFn) {\n  lunr.Pipeline.warnIfFunctionNotRegistered(newFn)\n\n  var pos = this._stack.indexOf(existingFn)\n  if (pos == -1) {\n    throw new Error('Cannot find existingFn')\n  }\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 */\nlunr.Pipeline.prototype.before = function (existingFn, newFn) {\n  lunr.Pipeline.warnIfFunctionNotRegistered(newFn)\n\n  var pos = this._stack.indexOf(existingFn)\n  if (pos == -1) {\n    throw new Error('Cannot find existingFn')\n  }\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 */\nlunr.Pipeline.prototype.remove = function (fn) {\n  var pos = this._stack.indexOf(fn)\n  if (pos == -1) {\n    return\n  }\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 */\nlunr.Pipeline.prototype.run = function (tokens) {\n  var stackLength = this._stack.length\n\n  for (var i = 0; i < stackLength; i++) {\n    var fn = this._stack[i]\n    var memo = []\n\n    for (var j = 0; j < tokens.length; j++) {\n      var result = fn(tokens[j], j, tokens)\n\n      if (result === null || result === void 0 || result === '') continue\n\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\n    tokens = memo\n  }\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 */\nlunr.Pipeline.prototype.runString = function (str, metadata) {\n  var token = new lunr.Token (str, metadata)\n\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 */\nlunr.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 */\nlunr.Pipeline.prototype.toJSON = function () {\n  return this._stack.map(function (fn) {\n    lunr.Pipeline.warnIfFunctionNotRegistered(fn)\n\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 */\nlunr.Vector = function (elements) {\n  this._magnitude = 0\n  this.elements = elements || []\n}\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 */\nlunr.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\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\n  while (sliceLength > 1) {\n    if (pivotIndex < index) {\n      start = pivotPoint\n    }\n\n    if (pivotIndex > index) {\n      end = pivotPoint\n    }\n\n    if (pivotIndex == index) {\n      break\n    }\n\n    sliceLength = end - start\n    pivotPoint = start + Math.floor(sliceLength / 2)\n    pivotIndex = this.elements[pivotPoint * 2]\n  }\n\n  if (pivotIndex == index) {\n    return pivotPoint * 2\n  }\n\n  if (pivotIndex > index) {\n    return pivotPoint * 2\n  }\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 */\nlunr.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 */\nlunr.Vector.prototype.upsert = function (insertIdx, val, fn) {\n  this._magnitude = 0\n  var position = this.positionForIndex(insertIdx)\n\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 */\nlunr.Vector.prototype.magnitude = function () {\n  if (this._magnitude) return this._magnitude\n\n  var sumOfSquares = 0,\n      elementsLength = this.elements.length\n\n  for (var i = 1; i < elementsLength; i += 2) {\n    var val = this.elements[i]\n    sumOfSquares += val * val\n  }\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 */\nlunr.Vector.prototype.dot = function (otherVector) {\n  var dotProduct = 0,\n      a = this.elements, b = otherVector.elements,\n      aLen = a.length, bLen = b.length,\n      aVal = 0, bVal = 0,\n      i = 0, j = 0\n\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\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 */\nlunr.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 */\nlunr.Vector.prototype.toArray = function () {\n  var output = new Array (this.elements.length / 2)\n\n  for (var i = 1, j = 0; i < this.elements.length; i += 2, j++) {\n    output[j] = this.elements[i]\n  }\n\n  return output\n}\n\n/**\n * A JSON serializable representation of the vector.\n *\n * @returns {Number[]}\n */\nlunr.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 */\nlunr.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\n    step3list = {\n      \"icate\" : \"ic\",\n      \"ative\" : \"\",\n      \"alize\" : \"al\",\n      \"iciti\" : \"ic\",\n      \"ical\" : \"ic\",\n      \"ful\" : \"\",\n      \"ness\" : \"\"\n    },\n\n    c = \"[^aeiou]\",          // consonant\n    v = \"[aeiouy]\",          // vowel\n    C = c + \"[^aeiouy]*\",    // consonant sequence\n    V = v + \"[aeiou]*\",      // vowel sequence\n\n    mgr0 = \"^(\" + C + \")?\" + V + C,               // [C]VC... is m>0\n    meq1 = \"^(\" + C + \")?\" + V + C + \"(\" + V + \")?$\",  // [C]VC[V] is m=1\n    mgr1 = \"^(\" + C + \")?\" + V + C + V + C,       // [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\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\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\n  var re_3 = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;\n\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\n  var re_5 = /^(.+?)e$/;\n  var re_5_1 = /ll$/;\n  var re3_5 = new RegExp(\"^\" + C + v + \"[^aeiouwxy]$\");\n\n  var porterStemmer = function porterStemmer(w) {\n    var stem,\n      suffix,\n      firstch,\n      re,\n      re2,\n      re3,\n      re4;\n\n    if (w.length < 3) { 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\n    if (re.test(w)) { w = w.replace(re,\"$1$2\"); }\n    else if (re2.test(w)) { w = w.replace(re2,\"$1$2\"); }\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)) { w = w + \"e\"; }\n        else if (re3.test(w)) { re = re_1b_2; w = w.replace(re,\"\"); }\n        else if (re4.test(w)) { w = w + \"e\"; }\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\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\n    return w;\n  };\n\n  return function (token) {\n    return token.update(porterStemmer);\n  }\n})();\n\nlunr.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 */\nlunr.generateStopWordFilter = function (stopWords) {\n  var words = stopWords.reduce(function (memo, stopWord) {\n    memo[stopWord] = stopWord\n    return memo\n  }, {})\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 */\nlunr.stopWordFilter = lunr.generateStopWordFilter([\n  'a',\n  'able',\n  'about',\n  'across',\n  'after',\n  'all',\n  'almost',\n  'also',\n  'am',\n  'among',\n  'an',\n  'and',\n  'any',\n  'are',\n  'as',\n  'at',\n  'be',\n  'because',\n  'been',\n  'but',\n  'by',\n  'can',\n  'cannot',\n  'could',\n  'dear',\n  'did',\n  'do',\n  'does',\n  'either',\n  'else',\n  'ever',\n  'every',\n  'for',\n  'from',\n  'get',\n  'got',\n  'had',\n  'has',\n  'have',\n  'he',\n  'her',\n  'hers',\n  'him',\n  'his',\n  'how',\n  'however',\n  'i',\n  'if',\n  'in',\n  'into',\n  'is',\n  'it',\n  'its',\n  'just',\n  'least',\n  'let',\n  'like',\n  'likely',\n  'may',\n  'me',\n  'might',\n  'most',\n  'must',\n  'my',\n  'neither',\n  'no',\n  'nor',\n  'not',\n  'of',\n  'off',\n  'often',\n  'on',\n  'only',\n  'or',\n  'other',\n  'our',\n  'own',\n  'rather',\n  'said',\n  'say',\n  'says',\n  'she',\n  'should',\n  'since',\n  'so',\n  'some',\n  'than',\n  'that',\n  'the',\n  'their',\n  'them',\n  'then',\n  'there',\n  'these',\n  'they',\n  'this',\n  'tis',\n  'to',\n  'too',\n  'twas',\n  'us',\n  'wants',\n  'was',\n  'we',\n  'were',\n  'what',\n  'when',\n  'where',\n  'which',\n  'while',\n  'who',\n  'whom',\n  'why',\n  'will',\n  'with',\n  'would',\n  'yet',\n  'you',\n  'your'\n])\n\nlunr.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 */\nlunr.trimmer = function (token) {\n  return token.update(function (s) {\n    return s.replace(/^\\W+/, '').replace(/\\W+$/, '')\n  })\n}\n\nlunr.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 */\nlunr.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 */\nlunr.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 */\nlunr.TokenSet.fromArray = function (arr) {\n  var builder = new lunr.TokenSet.Builder\n\n  for (var i = 0, len = arr.length; i < len; i++) {\n    builder.insert(arr[i])\n  }\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 */\nlunr.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 */\nlunr.TokenSet.fromFuzzyString = function (str, editDistance) {\n  var root = new lunr.TokenSet\n\n  var stack = [{\n    node: root,\n    editsRemaining: editDistance,\n    str: str\n  }]\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\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\n      if (frame.str.length == 1) {\n        noEditNode.final = true\n      }\n\n      stack.push({\n        node: noEditNode,\n        editsRemaining: frame.editsRemaining,\n        str: frame.str.slice(1)\n      })\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\n    if (frame.str.length == 0) {\n      insertionNode.final = true\n    }\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\n      if (frame.str.length == 1) {\n        substitutionNode.final = true\n      }\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\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\n      if (frame.str.length == 1) {\n        transposeNode.final = true\n      }\n\n      stack.push({\n        node: transposeNode,\n        editsRemaining: frame.editsRemaining - 1,\n        str: charA + frame.str.slice(2)\n      })\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 */\nlunr.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\n    if (char == \"*\") {\n      node.edges[char] = node\n      node.final = final\n\n    } else {\n      var next = new lunr.TokenSet\n      next.final = final\n\n      node.edges[char] = next\n      node = next\n    }\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 */\nlunr.TokenSet.prototype.toArray = function () {\n  var words = []\n\n  var stack = [{\n    prefix: \"\",\n    node: this\n  }]\n\n  while (stack.length) {\n    var frame = stack.pop(),\n        edges = Object.keys(frame.node.edges),\n        len = edges.length\n\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\n    for (var i = 0; i < len; i++) {\n      var edge = edges[i]\n\n      stack.push({\n        prefix: frame.prefix.concat(edge),\n        node: frame.node.edges[edge]\n      })\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 */\nlunr.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\n  var str = this.final ? '1' : '0',\n      labels = Object.keys(this.edges).sort(),\n      len = labels.length\n\n  for (var i = 0; i < len; i++) {\n    var label = labels[i],\n        node = this.edges[label]\n\n    str = str + label + node.id\n  }\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 */\nlunr.TokenSet.prototype.intersect = function (b) {\n  var output = new lunr.TokenSet,\n      frame = undefined\n\n  var stack = [{\n    qNode: b,\n    output: output,\n    node: this\n  }]\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\n    for (var q = 0; q < qLen; q++) {\n      var qEdge = qEdges[q]\n\n      for (var n = 0; n < nLen; n++) {\n        var nEdge = nEdges[n]\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\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\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\n          stack.push({\n            qNode: qNode,\n            output: next,\n            node: node\n          })\n        }\n      }\n    }\n  }\n\n  return output\n}\nlunr.TokenSet.Builder = function () {\n  this.previousWord = \"\"\n  this.root = new lunr.TokenSet\n  this.uncheckedNodes = []\n  this.minimizedNodes = {}\n}\n\nlunr.TokenSet.Builder.prototype.insert = function (word) {\n  var node,\n      commonPrefix = 0\n\n  if (word < this.previousWord) {\n    throw new Error (\"Out of order word insertion\")\n  }\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\n  this.minimize(commonPrefix)\n\n  if (this.uncheckedNodes.length == 0) {\n    node = this.root\n  } else {\n    node = this.uncheckedNodes[this.uncheckedNodes.length - 1].child\n  }\n\n  for (var i = commonPrefix; i < word.length; i++) {\n    var nextNode = new lunr.TokenSet,\n        char = word[i]\n\n    node.edges[char] = nextNode\n\n    this.uncheckedNodes.push({\n      parent: node,\n      char: char,\n      child: nextNode\n    })\n\n    node = nextNode\n  }\n\n  node.final = true\n  this.previousWord = word\n}\n\nlunr.TokenSet.Builder.prototype.finish = function () {\n  this.minimize(0)\n}\n\nlunr.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\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\n      this.minimizedNodes[childKey] = node.child\n    }\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 */\nlunr.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 */\nlunr.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 */\nlunr.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\n  fn.call(query, query)\n\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\n    if (clause.usePipeline) {\n      terms = this.pipeline.runString(clause.term, {\n        fields: clause.fields\n      })\n    } else {\n      terms = [clause.term]\n    }\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\n        break\n      }\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\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\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\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) { return a + b })\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\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\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          }\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\n  for (var i = 0; i < this.fields.length; i++) {\n    var field = this.fields[i]\n\n    if (requiredMatches[field]) {\n      allRequiredMatches = allRequiredMatches.intersect(requiredMatches[field])\n    }\n\n    if (prohibitedMatches[field]) {\n      allProhibitedMatches = allProhibitedMatches.union(prohibitedMatches[field])\n    }\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\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\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\n    if (!allRequiredMatches.contains(docRef)) {\n      continue\n    }\n\n    if (allProhibitedMatches.contains(docRef)) {\n      continue\n    }\n\n    var fieldVector = this.fieldVectors[fieldRef],\n        score = queryVectors[fieldRef.fieldName].similarity(fieldVector),\n        docMatch\n\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 */\nlunr.Index.prototype.toJSON = function () {\n  var invertedIndex = Object.keys(this.invertedIndex)\n    .sort()\n    .map(function (term) {\n      return [term, this.invertedIndex[term]]\n    }, this)\n\n  var fieldVectors = Object.keys(this.fieldVectors)\n    .map(function (ref) {\n      return [ref, this.fieldVectors[ref].toJSON()]\n    }, this)\n\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 */\nlunr.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\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\n  for (var i = 0; i < serializedVectors.length; i++) {\n    var tuple = serializedVectors[i],\n        ref = tuple[0],\n        elements = tuple[1]\n\n    fieldVectors[ref] = new lunr.Vector(elements)\n  }\n\n  for (var i = 0; i < serializedInvertedIndex.length; i++) {\n    var tuple = serializedInvertedIndex[i],\n        term = tuple[0],\n        posting = tuple[1]\n\n    tokenSetBuilder.insert(term)\n    invertedIndex[term] = posting\n  }\n\n  tokenSetBuilder.finish()\n\n  attrs.fields = serializedIndex.fields\n\n  attrs.fieldVectors = fieldVectors\n  attrs.invertedIndex = invertedIndex\n  attrs.tokenSet = tokenSetBuilder.root\n  attrs.pipeline = pipeline\n\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 */\nlunr.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 */\nlunr.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 */\nlunr.Builder.prototype.field = function (fieldName, attributes) {\n  if (/\\//.test(fieldName)) {\n    throw new RangeError (\"Field '\" + fieldName + \"' contains illegal character '/'\")\n  }\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 */\nlunr.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 */\nlunr.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 */\nlunr.Builder.prototype.add = function (doc, attributes) {\n  var docRef = doc[this._ref],\n      fields = Object.keys(this._fields)\n\n  this._documents[docRef] = attributes || {}\n  this.documentCount += 1\n\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\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\n      if (fieldTerms[term] == undefined) {\n        fieldTerms[term] = 0\n      }\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\n        for (var k = 0; k < fields.length; k++) {\n          posting[fields[k]] = Object.create(null)\n        }\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\n        if (this.invertedIndex[term][fieldName][docRef][metadataKey] == undefined) {\n          this.invertedIndex[term][fieldName][docRef][metadataKey] = []\n        }\n\n        this.invertedIndex[term][fieldName][docRef][metadataKey].push(metadata)\n      }\n    }\n\n  }\n}\n\n/**\n * Calculates the average document length for this index\n *\n * @private\n */\nlunr.Builder.prototype.calculateAverageFieldLengths = function () {\n\n  var fieldRefs = Object.keys(this.fieldLengths),\n      numberOfFields = fieldRefs.length,\n      accumulator = {},\n      documentsWithField = {}\n\n  for (var i = 0; i < numberOfFields; i++) {\n    var fieldRef = lunr.FieldRef.fromString(fieldRefs[i]),\n        field = fieldRef.fieldName\n\n    documentsWithField[field] || (documentsWithField[field] = 0)\n    documentsWithField[field] += 1\n\n    accumulator[field] || (accumulator[field] = 0)\n    accumulator[field] += this.fieldLengths[fieldRef]\n  }\n\n  var fields = Object.keys(this._fields)\n\n  for (var i = 0; i < fields.length; i++) {\n    var fieldName = fields[i]\n    accumulator[fieldName] = accumulator[fieldName] / documentsWithField[fieldName]\n  }\n\n  this.averageFieldLength = accumulator\n}\n\n/**\n * Builds a vector space model of every document using lunr.Vector\n *\n * @private\n */\nlunr.Builder.prototype.createFieldVectors = function () {\n  var fieldVectors = {},\n      fieldRefs = Object.keys(this.fieldTermFrequencies),\n      fieldRefsLength = fieldRefs.length,\n      termIdfCache = Object.create(null)\n\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\n\n    var fieldBoost = this._fields[fieldName].boost || 1,\n        docBoost = this._documents[fieldRef.docRef].boost || 1\n\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, score, scoreWithPrecision\n\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\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\n    fieldVectors[fieldRef] = fieldVector\n  }\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 */\nlunr.Builder.prototype.createTokenSet = function () {\n  this.tokenSet = lunr.TokenSet.fromArray(\n    Object.keys(this.invertedIndex).sort()\n  )\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 */\nlunr.Builder.prototype.build = function () {\n  this.calculateAverageFieldLengths()\n  this.createFieldVectors()\n  this.createTokenSet()\n\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 */\nlunr.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 */\nlunr.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\n  this.metadata = Object.create(null)\n\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 */\nlunr.MatchData.prototype.combine = function (otherMatchData) {\n  var terms = Object.keys(otherMatchData.metadata)\n\n  for (var i = 0; i < terms.length; i++) {\n    var term = terms[i],\n        fields = Object.keys(otherMatchData.metadata[term])\n\n    if (this.metadata[term] == undefined) {\n      this.metadata[term] = Object.create(null)\n    }\n\n    for (var j = 0; j < fields.length; j++) {\n      var field = fields[j],\n          keys = Object.keys(otherMatchData.metadata[term][field])\n\n      if (this.metadata[term][field] == undefined) {\n        this.metadata[term][field] = Object.create(null)\n      }\n\n      for (var k = 0; k < keys.length; k++) {\n        var key = keys[k]\n\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/**\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 */\nlunr.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\n  if (!(field in this.metadata[term])) {\n    this.metadata[term][field] = metadata\n    return\n  }\n\n  var metadataKeys = Object.keys(metadata)\n\n  for (var i = 0; i < metadataKeys.length; i++) {\n    var key = metadataKeys[i]\n\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 */\nlunr.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\nlunr.Query.wildcard = new String (\"*\")\nlunr.Query.wildcard.NONE = 0\nlunr.Query.wildcard.LEADING = 1\nlunr.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 */\nlunr.Query.presence = {\n  /**\n   * Term's presence in a document is optional, this is the default value.\n   */\n  OPTIONAL: 1,\n\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  /**\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 */\nlunr.Query.prototype.clause = function (clause) {\n  if (!('fields' in clause)) {\n    clause.fields = this.allFields\n  }\n\n  if (!('boost' in clause)) {\n    clause.boost = 1\n  }\n\n  if (!('usePipeline' in clause)) {\n    clause.usePipeline = true\n  }\n\n  if (!('wildcard' in clause)) {\n    clause.wildcard = lunr.Query.wildcard.NONE\n  }\n\n  if ((clause.wildcard & lunr.Query.wildcard.LEADING) && (clause.term.charAt(0) != lunr.Query.wildcard)) {\n    clause.term = \"*\" + clause.term\n  }\n\n  if ((clause.wildcard & lunr.Query.wildcard.TRAILING) && (clause.term.slice(-1) != lunr.Query.wildcard)) {\n    clause.term = \"\" + clause.term + \"*\"\n  }\n\n  if (!('presence' in clause)) {\n    clause.presence = lunr.Query.presence.OPTIONAL\n  }\n\n  this.clauses.push(clause)\n\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 */\nlunr.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\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 */\nlunr.Query.prototype.term = function (term, options) {\n  if (Array.isArray(term)) {\n    term.forEach(function (t) { this.term(t, lunr.utils.clone(options)) }, this)\n    return this\n  }\n\n  var clause = options || {}\n  clause.term = term.toString()\n\n  this.clause(clause)\n\n  return this\n}\nlunr.QueryParseError = function (message, start, end) {\n  this.name = \"QueryParseError\"\n  this.message = message\n  this.start = start\n  this.end = end\n}\n\nlunr.QueryParseError.prototype = new Error\nlunr.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\nlunr.QueryLexer.prototype.run = function () {\n  var state = lunr.QueryLexer.lexText\n\n  while (state) {\n    state = state(this)\n  }\n}\n\nlunr.QueryLexer.prototype.sliceString = function () {\n  var subSlices = [],\n      sliceStart = this.start,\n      sliceEnd = this.pos\n\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\n  subSlices.push(this.str.slice(sliceStart, this.pos))\n  this.escapeCharPositions.length = 0\n\n  return subSlices.join('')\n}\n\nlunr.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\n  this.start = this.pos\n}\n\nlunr.QueryLexer.prototype.escapeCharacter = function () {\n  this.escapeCharPositions.push(this.pos - 1)\n  this.pos += 1\n}\n\nlunr.QueryLexer.prototype.next = function () {\n  if (this.pos >= this.length) {\n    return lunr.QueryLexer.EOS\n  }\n\n  var char = this.str.charAt(this.pos)\n  this.pos += 1\n  return char\n}\n\nlunr.QueryLexer.prototype.width = function () {\n  return this.pos - this.start\n}\n\nlunr.QueryLexer.prototype.ignore = function () {\n  if (this.start == this.pos) {\n    this.pos += 1\n  }\n\n  this.start = this.pos\n}\n\nlunr.QueryLexer.prototype.backup = function () {\n  this.pos -= 1\n}\n\nlunr.QueryLexer.prototype.acceptDigitRun = function () {\n  var char, charCode\n\n  do {\n    char = this.next()\n    charCode = char.charCodeAt(0)\n  } while (charCode > 47 && charCode < 58)\n\n  if (char != lunr.QueryLexer.EOS) {\n    this.backup()\n  }\n}\n\nlunr.QueryLexer.prototype.more = function () {\n  return this.pos < this.length\n}\n\nlunr.QueryLexer.EOS = 'EOS'\nlunr.QueryLexer.FIELD = 'FIELD'\nlunr.QueryLexer.TERM = 'TERM'\nlunr.QueryLexer.EDIT_DISTANCE = 'EDIT_DISTANCE'\nlunr.QueryLexer.BOOST = 'BOOST'\nlunr.QueryLexer.PRESENCE = 'PRESENCE'\n\nlunr.QueryLexer.lexField = function (lexer) {\n  lexer.backup()\n  lexer.emit(lunr.QueryLexer.FIELD)\n  lexer.ignore()\n  return lunr.QueryLexer.lexText\n}\n\nlunr.QueryLexer.lexTerm = function (lexer) {\n  if (lexer.width() > 1) {\n    lexer.backup()\n    lexer.emit(lunr.QueryLexer.TERM)\n  }\n\n  lexer.ignore()\n\n  if (lexer.more()) {\n    return lunr.QueryLexer.lexText\n  }\n}\n\nlunr.QueryLexer.lexEditDistance = function (lexer) {\n  lexer.ignore()\n  lexer.acceptDigitRun()\n  lexer.emit(lunr.QueryLexer.EDIT_DISTANCE)\n  return lunr.QueryLexer.lexText\n}\n\nlunr.QueryLexer.lexBoost = function (lexer) {\n  lexer.ignore()\n  lexer.acceptDigitRun()\n  lexer.emit(lunr.QueryLexer.BOOST)\n  return lunr.QueryLexer.lexText\n}\n\nlunr.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.\nlunr.QueryLexer.termSeparator = lunr.tokenizer.separator\n\nlunr.QueryLexer.lexText = function (lexer) {\n  while (true) {\n    var char = lexer.next()\n\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\n    if (char == \":\") {\n      return lunr.QueryLexer.lexField\n    }\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\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\n    if (char.match(lunr.QueryLexer.termSeparator)) {\n      return lunr.QueryLexer.lexTerm\n    }\n  }\n}\n\nlunr.QueryParser = function (str, query) {\n  this.lexer = new lunr.QueryLexer (str)\n  this.query = query\n  this.currentClause = {}\n  this.lexemeIdx = 0\n}\n\nlunr.QueryParser.prototype.parse = function () {\n  this.lexer.run()\n  this.lexemes = this.lexer.lexemes\n\n  var state = lunr.QueryParser.parseClause\n\n  while (state) {\n    state = state(this)\n  }\n\n  return this.query\n}\n\nlunr.QueryParser.prototype.peekLexeme = function () {\n  return this.lexemes[this.lexemeIdx]\n}\n\nlunr.QueryParser.prototype.consumeLexeme = function () {\n  var lexeme = this.peekLexeme()\n  this.lexemeIdx += 1\n  return lexeme\n}\n\nlunr.QueryParser.prototype.nextClause = function () {\n  var completedClause = this.currentClause\n  this.query.clause(completedClause)\n  this.currentClause = {}\n}\n\nlunr.QueryParser.parseClause = function (parser) {\n  var lexeme = parser.peekLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\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\n      if (lexeme.str.length >= 1) {\n        errorMessage += \" with value '\" + lexeme.str + \"'\"\n      }\n\n      throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n}\n\nlunr.QueryParser.parsePresence = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\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\n  var nextLexeme = parser.peekLexeme()\n\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\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\nlunr.QueryParser.parseField = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  if (parser.query.allFields.indexOf(lexeme.str) == -1) {\n    var possibleFields = parser.query.allFields.map(function (f) { return \"'\" + f + \"'\" }).join(', '),\n        errorMessage = \"unrecognised field '\" + lexeme.str + \"', possible fields: \" + possibleFields\n\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  parser.currentClause.fields = [lexeme.str]\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    var errorMessage = \"expecting term, found nothing\"\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\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\nlunr.QueryParser.parseTerm = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  parser.currentClause.term = lexeme.str.toLowerCase()\n\n  if (lexeme.str.indexOf(\"*\") != -1) {\n    parser.currentClause.usePipeline = false\n  }\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    parser.nextClause()\n    return\n  }\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\nlunr.QueryParser.parseEditDistance = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  var editDistance = parseInt(lexeme.str, 10)\n\n  if (isNaN(editDistance)) {\n    var errorMessage = \"edit distance must be numeric\"\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  parser.currentClause.editDistance = editDistance\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    parser.nextClause()\n    return\n  }\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\nlunr.QueryParser.parseBoost = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  var boost = parseInt(lexeme.str, 10)\n\n  if (isNaN(boost)) {\n    var errorMessage = \"boost must be numeric\"\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  parser.currentClause.boost = boost\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    parser.nextClause()\n    return\n  }\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})();\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\nimport throttle from \"lodash.throttle\";\n\nconst cssClasses = {\n  hidden: \"backToTop--hidden\",\n};\nlet bttElem: HTMLElement;\nconst thresholdY = 500;\n\nfunction onScroll() {\n  const currentY = window.pageYOffset;\n  // display button when at least X pixel where scrolled\n  if (currentY > thresholdY) {\n    bttElem.classList.remove(cssClasses.hidden);\n  } else if (currentY < thresholdY) {\n    bttElem.classList.add(cssClasses.hidden);\n  }\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  bttElem = document.getElementById(\"backToTop-js\");\n  if (bttElem) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-call\n    document.addEventListener(\"scroll\", throttle(onScroll, 500, { leading: true, trailing: true }));\n    bttElem.addEventListener(\"click\", () => {\n      bttElem.blur();\n      window.scrollTo(0, 0);\n    });\n  }\n});\n","type CountResponseJson = {\n  commentCounts: { [key: string]: number };\n  success: boolean;\n};\n\nfunction initCount(countSpan: HTMLElement) {\n  const commentsUrl = document.body.dataset.commentsUrl;\n  if (commentsUrl) {\n    const data = getPostData();\n    const request = new XMLHttpRequest();\n    request.open(\"POST\", `${commentsUrl}/api/comment/count`, true);\n    request.send(JSON.stringify(data));\n\n    request.onload = () => {\n      if (request.status === 200) {\n        displayCount(countSpan, request.response as string);\n      }\n    };\n  }\n}\n\nfunction displayCount(countSpan: HTMLElement, countResponse: string) {\n  try {\n    const responseJson = JSON.parse(countResponse) as CountResponseJson;\n    if (!responseJson.success) {\n      return;\n    }\n    let count;\n    if (\n      responseJson.commentCounts[location.pathname] &&\n      typeof responseJson.commentCounts[location.pathname] === \"number\"\n    ) {\n      count = responseJson.commentCounts[location.pathname];\n    } else {\n      count = 0;\n    }\n    countSpan.textContent = `${count} ${count === 1 ? \"comment\" : \"comments\"}`;\n  } catch (ex) {\n    // do nothing\n  }\n}\n\nfunction getPostData() {\n  return {\n    domain: location.host,\n    paths: [location.pathname],\n  };\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  const countSpan = document.getElementById(\"post__meta-comments-js\");\n  if (countSpan) {\n    initCount(countSpan);\n  }\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\n/**\n * Lazy-Loader for the comments section\n */\nconst observer = new IntersectionObserver(commentsSectionIntersecting);\n\nfunction commentsSectionIntersecting(entries: IntersectionObserverEntry[]) {\n  entries\n    .filter(e => e.isIntersecting)\n    .forEach(e => {\n      window.commento.main();\n      observer.unobserve(e.target);\n    });\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  const commentsElem = document.getElementById(\"comments-section-js\");\n  if (commentsElem) {\n    if (typeof window.commento.main !== \"undefined\") {\n      observer.observe(commentsElem);\n    } else {\n      // if commento is not available, we remove the comments section\n      commentsElem.parentNode.removeChild(commentsElem);\n    }\n  }\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\nimport { getCookie, setCookie } from \"../util/cookieHelper\";\n// name of the cookie\nconst cookieName = \"cookie-consent\";\n\n/* Check if cookie bar needs to be displayed */\nfunction setupCookieBar() {\n  const hasAccepted = getCookie(cookieName);\n  const cookieConsent = document.getElementById(\"cookie-consent-js\");\n  const cookieConsentButton = document.getElementById(\"cookie-consent__btn-js\");\n  if (cookieConsent && cookieConsentButton && !hasAccepted) {\n    cookieConsent.style.display = \"initial\";\n    cookieConsentButton.addEventListener(\"click\", function () {\n      setCookie(cookieName, \"true\", 365);\n      cookieConsent.classList.add(\"cookie-consent__fadeout\");\n    });\n  }\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  setupCookieBar();\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\n/**\n *\n * @param {string} name - name of the cookie\n * @returns {string} value of the cookie or null\n */\nexport function getCookie(name: string) {\n  const value = document.cookie.match(\"(^|;) ?\" + name + \"=([^;]*)(;|$)\");\n  return value ? value[2] : null;\n}\n\n/**\n *\n * @param {string} name - name of the cookie\n * @param {string} value - value of the cookie\n * @param {number} days - how many days the cookie is valid\n */\nexport function setCookie(name: string, value: string, days: number) {\n  const d = new Date();\n  d.setDate(d.getDate() + days);\n  document.cookie = name + \"=\" + value + \";path=/;expires=\" + d.toUTCString();\n}\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\nimport throttle from \"lodash.throttle\";\nimport { observe } from \"./lazyLoader\";\n\nlet galleryTemplate: HTMLTemplateElement,\n  galleryElem: HTMLElement,\n  galleryLightbox: HTMLElement,\n  activeThumb: HTMLPictureElement,\n  scrollerLeft: HTMLElement[],\n  scrollerRight: HTMLElement[];\n\nlet swipeX: number = null;\n\nconst cssClasses = {\n  lightbox: \"gallery__lightbox\",\n  thumbnail: \"gallery__thumbnails-item\",\n  caption: \"gallery__caption\",\n  thumbnailActive: \"gallery__thumbnails-item--active\",\n  thumbnailList: \"gallery__thumbnails-list\",\n  item: \"gallery__item\",\n  scrollerHidden: \"gallery__scroller--hidden\",\n  scrollerLeft: \"gallery__scroller-left\",\n  scrollerRight: \"gallery__scroller-right\",\n};\n\nfunction initGallery() {\n  galleryTemplate = document.getElementById(\"gallery__item-template-js\") as HTMLTemplateElement;\n  galleryLightbox = document.getElementById(\"gallery__lightbox-js\");\n\n  const galleryThumbs = Array.from(galleryElem.getElementsByClassName(cssClasses.thumbnail)) as HTMLPictureElement[];\n  galleryThumbs.forEach(thumb => (thumb.onclick = e => showImage(e.currentTarget as HTMLPictureElement)));\n\n  const thumbsList = document.getElementsByClassName(cssClasses.thumbnailList)[0];\n  thumbsList.addEventListener(\"mousedown\", swipeLock, false);\n  thumbsList.addEventListener(\"touchstart\", swipeLock, false);\n  thumbsList.addEventListener(\"mouseup\", swipeMove, false);\n  thumbsList.addEventListener(\"touchend\", swipeMove, false);\n\n  scrollerLeft = Array.from(galleryElem.getElementsByClassName(cssClasses.scrollerLeft)) as HTMLElement[];\n  scrollerLeft.forEach(\n    scroller =>\n      (scroller.onclick = throttle(previousImage, 500, {\n        leading: true,\n        trailing: true,\n      })),\n  );\n\n  scrollerRight = Array.from(galleryElem.getElementsByClassName(cssClasses.scrollerRight)) as HTMLElement[];\n  scrollerRight.forEach(\n    scroller =>\n      (scroller.onclick = throttle(nextImage, 500, {\n        leading: true,\n        trailing: true,\n      })),\n  );\n\n  showImage(galleryThumbs[0]);\n}\n\nfunction showImage(thumb: HTMLPictureElement) {\n  // remove onclick listener\n  thumb.onclick = null;\n  // set active state\n  (\n    Array.from((thumb.parentNode as HTMLElement).getElementsByClassName(cssClasses.thumbnailActive)) as HTMLElement[]\n  ).forEach(activeItem => {\n    activeItem.onclick = e => showImage(e.currentTarget as HTMLPictureElement);\n    activeItem.classList.remove(cssClasses.thumbnailActive);\n  });\n  thumb.classList.add(cssClasses.thumbnailActive);\n\n  scrollToItem(thumb);\n\n  const galleryItemTemplate = createGalleryItem(thumb);\n\n  // reattach the element\n  const old = galleryElem.getElementsByClassName(cssClasses.item)[0];\n  galleryLightbox.replaceChild(galleryItemTemplate, old);\n\n  const galleryItem = galleryElem.getElementsByClassName(cssClasses.item)[0] as HTMLElement;\n\n  // trigger lazy-loading\n  observe(galleryItem);\n\n  // register event listener for swipe / touch\n  galleryItem.addEventListener(\"mousedown\", swipeLock, false);\n  galleryItem.addEventListener(\"touchstart\", swipeLock, false);\n  galleryItem.addEventListener(\"mouseup\", swipeMove, false);\n  galleryItem.addEventListener(\"touchend\", swipeMove, false);\n  // click should open next image\n  galleryItem.addEventListener(\"click\", nextImage, false);\n\n  updateScroller(thumb);\n  activeThumb = thumb;\n}\n\n/**\n * update all scroller buttons to match the new situation when thumb is displayed\n * @param thumb\n */\nfunction updateScroller(thumb: HTMLPictureElement) {\n  // if there is no next element, remove scroller right, otherwise display it\n  scrollerRight.forEach(s => {\n    if (thumb.nextElementSibling) {\n      s.classList.remove(cssClasses.scrollerHidden);\n    } else {\n      s.classList.add(cssClasses.scrollerHidden);\n    }\n  });\n  // if there is no prev element, remove scroller left, otherwise display it\n  scrollerLeft.forEach(s => {\n    if (thumb.previousElementSibling) {\n      s.classList.remove(cssClasses.scrollerHidden);\n    } else {\n      s.classList.add(cssClasses.scrollerHidden);\n    }\n  });\n}\n\n/**\n * create the gallery item from the given thumbnail using a template\n * @param thumb\n */\nfunction createGalleryItem(thumb: HTMLPictureElement) {\n  // create new item from template\n  const galleryItemTemplate = document.importNode(galleryTemplate.content, true);\n\n  const galleryPicture = galleryItemTemplate.getElementById(\"gallery__item-picture-js\");\n  // add new sources\n  const sources = Array.from(thumb.getElementsByTagName(\"source\"));\n  sources.reverse().forEach(e => {\n    const clone = e.cloneNode() as HTMLImageElement;\n    clone.sizes = \"(min-width: 120em) calc(1920px - 8em), (min-width: 64em) calc(100vw - 8em), calc(100vw - 2em)\";\n    galleryPicture.prepend(clone);\n  });\n\n  // set img src\n  const img = thumb.getElementsByTagName(\"img\")[0];\n  galleryPicture.querySelector(\"img\").dataset.src = img.src;\n\n  const caption = thumb.getElementsByClassName(cssClasses.caption)[0];\n  const templateCaption = galleryItemTemplate.getElementById(\"gallery__thumbnails-item-caption-js\");\n  if (caption) {\n    templateCaption.innerHTML = caption.innerHTML;\n  } else {\n    templateCaption.remove();\n  }\n  return galleryItemTemplate;\n}\n\nfunction nextImage() {\n  const next = activeThumb.nextElementSibling as HTMLPictureElement;\n  if (next) {\n    showImage(next);\n  }\n}\n\nfunction previousImage() {\n  const prev = activeThumb.previousElementSibling as HTMLPictureElement;\n  if (prev) {\n    showImage(prev);\n  }\n}\n\nfunction scrollToItem(thumb: HTMLPictureElement) {\n  const scrollable = thumb.parentNode as HTMLElement;\n  scrollable.scrollLeft = thumb.offsetLeft;\n}\n\n/**\n * Start swipe / mouse\n * @param e\n */\nfunction swipeLock(e: TouchEvent | MouseEvent) {\n  swipeX = unify(e);\n}\n\nfunction swipeMove(e: TouchEvent | MouseEvent) {\n  if (swipeX || swipeX === 0) {\n    const dx = unify(e) - swipeX;\n    if (dx > 0) {\n      previousImage();\n    } else if (dx < 0) {\n      nextImage();\n    }\n  }\n}\n\n/**\n * unify the two event types for mouse and swipe\n * @param e\n * @returns {Touch}\n */\nfunction unify(e: TouchEvent | MouseEvent): number {\n  return e instanceof TouchEvent ? e.changedTouches[0].clientX : e.clientX;\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", () => {\n  galleryElem = document.getElementById(\"gallery-js\");\n  if (galleryElem) {\n    initGallery();\n  }\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\n/**\n * Lazy-Loader for all images marked as lazy-media.\n */\nconst observer = new IntersectionObserver(imageIntersecting);\n\n/**\n * Observe the given lazy image element\n * @param elem\n */\nfunction observe(elem: HTMLElement) {\n  observer.observe(elem);\n}\n\nexport { observe };\n\nfunction registerObserver() {\n  const elems = Array.from(document.getElementsByClassName(\"lazy-media\")) as HTMLElement[];\n\n  elems.forEach(e => {\n    observe(e);\n  });\n}\n\nfunction imageIntersecting(entries: IntersectionObserverEntry[]) {\n  entries\n    .filter(e => e.isIntersecting)\n    .forEach(e => {\n      loadMedia(e.target as HTMLElement);\n      observer.unobserve(e.target);\n    });\n}\n\n/**\n * Load the picture defined in the given element\n * @param elem\n */\nexport function loadMedia(elem: HTMLElement) {\n  let lazyMedia = elem.getElementsByTagName(\"picture\")[0];\n  let isVideo = false;\n  if (!lazyMedia) {\n    lazyMedia = elem.getElementsByTagName(\"video\")[0];\n    isVideo = true;\n  }\n  if (lazyMedia) {\n    // replace all the properties required to display an image\n    Array.from(lazyMedia.getElementsByTagName(\"source\")).forEach(source => {\n      if (source.dataset.srcset) {\n        source.srcset = source.dataset.srcset;\n        delete source.dataset.srcset;\n      } else if (source.dataset.src) {\n        source.src = source.dataset.src;\n        delete source.dataset.src;\n      }\n    });\n    // finally set img-src to trigger display\n    const img = lazyMedia.getElementsByTagName(\"img\")[0];\n    if (img) {\n      if (img.dataset.src) {\n        img.src = img.dataset.src;\n        delete img.dataset.src;\n      }\n\n      img.onload = e => {\n        const img = e.currentTarget as HTMLImageElement;\n        // remove event\n        img.onload = null;\n        const spinner = elem.getElementsByClassName(\"spinner\")[0];\n        if (spinner) {\n          elem.removeChild(spinner);\n        }\n      };\n    } else if (isVideo) {\n      (lazyMedia as HTMLVideoElement).load();\n      lazyMedia.onloadeddata = e => {\n        const video = e.currentTarget as HTMLVideoElement;\n        // remove event\n        video.onloadeddata = null;\n        const spinner = elem.getElementsByClassName(\"spinner\")[0];\n        if (spinner) {\n          elem.removeChild(spinner);\n        }\n      };\n    }\n  }\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", registerObserver);\n","/**\n * Disable scrolling on the body to show a lightbox\n */\nimport { loadMedia } from \"./lazyLoader\";\n\nexport function showLightbox() {\n  document.body.classList.add(\"lightbox__no-scroll\");\n}\n\n/**\n * close lightbox\n */\nexport function closeLightbox() {\n  document.body.classList.remove(\"lightbox__no-scroll\");\n}\n\nfunction initLightbox(trigger: HTMLElement) {\n  // the lightbox is always a parallel object to the trigger\n  //TODO: replace this with a unique ID per lightbox\n  const lightbox = trigger.parentElement.getElementsByClassName(\"lightbox\")[0];\n  const lightboxContent = lightbox.getElementsByClassName(\"lightbox__content\")[0] as HTMLElement;\n  if (lightbox && lightboxContent) {\n    trigger.addEventListener(\"click\", () => {\n      lightbox.classList.add(\"lightbox--open\");\n      // trigger image loading\n      loadMedia(lightboxContent);\n      showLightbox();\n    });\n    lightbox.addEventListener(\"click\", () => {\n      lightbox.classList.remove(\"lightbox--open\");\n      closeLightbox();\n    });\n  }\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  const lightboxTrigger = Array.from(document.getElementsByClassName(\"lightbox__trigger-js\"));\n\n  lightboxTrigger.forEach(initLightbox);\n});\n","/**\n * Render all posts into matching columns\n */\nimport { getCurrentMQ, getViewportWidth, MQs } from \"../util/mqHelper\";\n\nimport throttle from \"lodash.throttle\";\nimport { observe } from \"./lazyLoader\";\n\nlet lastKnownWidth: number;\n\ntype ColDefinition = {\n  length: number;\n  elem: HTMLElement;\n};\n\nfunction renderPosts() {\n  // only render, if the width has changed (height changes don't matter for the postlist)\n  if (!viewportWidthChanged()) return;\n\n  const postList = document.getElementById(\"postlist-js\");\n  const posts = Array.from(postList.getElementsByTagName(\"template\"));\n  clearCols();\n  const numCols = getNumberActiveCols();\n  const cols: ColDefinition[] = [];\n  for (let i = 1; i <= numCols; i++) {\n    cols.push({\n      length: 0,\n      elem: document.getElementById(`postlist__col${i}-js`),\n    });\n  }\n  addPostsToColumns(posts, cols);\n\n  // make sure, that the lazy loader gets all new images\n  cols\n    .map(col => col.elem)\n    .forEach(elem => Array.from(elem.getElementsByClassName(\"lazy-media\")).forEach(e => observe(e as HTMLElement)));\n}\n\n/**\n *\n * @returns {boolean} - true if the viewport width has changed\n */\nfunction viewportWidthChanged() {\n  const viewPortWidth = getViewportWidth();\n  if (lastKnownWidth === viewPortWidth) {\n    return false;\n  }\n  lastKnownWidth = viewPortWidth;\n  return true;\n}\n\n/**\n *\n * @returns {number} - number of active cols (depending on the viewport width)\n */\nfunction getNumberActiveCols() {\n  const mq = getCurrentMQ();\n  if (mq === MQs.small) {\n    return 1;\n  } else if (mq === MQs.medium) {\n    return 2;\n  }\n  return 3;\n}\n\n/**\n * clear content of all cols\n */\nfunction clearCols() {\n  for (let i = 1; i <= 3; i++) {\n    document.getElementById(`postlist__col${i}-js`).innerHTML = \"\";\n  }\n}\n\n/**\n *\n * @param {Array} posts - all posts to be rendered\n * @param {Array} cols - columns which can be used\n */\nfunction addPostsToColumns(posts: HTMLTemplateElement[], cols: ColDefinition[]) {\n  if (cols.length === 1) {\n    const col = cols[0];\n    posts.forEach(post => {\n      col.elem.appendChild(post.content.cloneNode(true));\n    });\n  } else {\n    posts.forEach(post => {\n      addPostToShortestColumn(post, cols);\n    });\n  }\n}\n\n/**\n * Add given post to the shortest available column\n * @param {Object} post - post to be added\n * @param {Array} cols - all columns\n */\nfunction addPostToShortestColumn(post: HTMLTemplateElement, cols: ColDefinition[]) {\n  const shortest = findShortestColumn(cols);\n  const postToRender = post.content.cloneNode(true);\n  const shortestColElem = shortest.elem;\n  shortestColElem.appendChild(postToRender);\n  shortest.length += (shortestColElem.lastElementChild as HTMLElement).offsetHeight;\n}\n\n/**\n * return the shortest column\n * @param {array} cols\n * @return {object} - the shortest element from the array\n */\nfunction findShortestColumn(cols: ColDefinition[]) {\n  let shortest: ColDefinition;\n  cols.forEach(col => {\n    if (!shortest || col.length < shortest.length) {\n      shortest = col;\n    }\n  });\n  return shortest;\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  if (document.getElementById(\"postlist-js\")) {\n    renderPosts();\n    // rerender on resize, throttled\n    window.addEventListener(\"resize\", throttle(renderPosts, 500, { leading: true, trailing: true }));\n  }\n});\n","import { getCurrentMQ, MQs } from \"../util/mqHelper\";\n\nimport throttle from \"lodash.throttle\";\n\nconst ids = {\n  content: \"post__nav-content-js\",\n  toggle: \"post__nav-toggle-id\",\n};\n\nlet contentElem: HTMLElement;\n\nconst getHeight = (el: HTMLElement) => {\n  const initialStyle = el.style;\n  const el_style = window.getComputedStyle(el),\n    el_display = el_style.display,\n    el_max_height = el_style.maxHeight.replace(\"px\", \"\").replace(\"%\", \"\");\n\n  // if it's not hidden we just return normal height\n  if (el_display !== \"none\" && el_max_height !== \"0\") {\n    return el.offsetHeight;\n  }\n\n  // the element is hidden so:\n  // making the el block so we can measure its height but still be hidden\n  el.style.position = \"absolute\";\n  el.style.visibility = \"hidden\";\n  el.style.display = \"block\";\n  el.style.maxHeight = \"initial\";\n\n  const height = el.offsetHeight;\n\n  // reverting to the original values\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore\n  el.style = initialStyle;\n\n  return height;\n};\n\nconst init = (expand: boolean) => {\n  const height = getHeight(contentElem);\n  contentElem.style.setProperty(\"--post__nav-content-height\", `${height}px`);\n\n  if (expand) {\n    const mq = getCurrentMQ();\n    if (mq === MQs.small) {\n      // navi is shown on small devices by default\n      (document.getElementById(ids.toggle) as HTMLInputElement).checked = true;\n    }\n  }\n};\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  contentElem = document.getElementById(ids.content);\n  if (contentElem) {\n    init(true);\n    // rerender on resize, throttled\n    window.addEventListener(\n      \"resize\",\n      throttle(() => init(false), 500, { leading: true, trailing: true }),\n    );\n  }\n});\n","import throttle from \"lodash.throttle\";\n\nlet progressBar: HTMLProgressElement,\n  contentNavWrapper: HTMLElement,\n  startY: number,\n  currentY: number,\n  screenHeight: number;\nlet ticking = false;\n\nfunction onScroll() {\n  if (!ticking) {\n    currentY = window.pageYOffset || document.documentElement.scrollTop;\n    window.requestAnimationFrame(function () {\n      if (currentY >= startY) {\n        // the content-nav-wrapper's height might change, so we update max every time\n        progressBar.setAttribute(\"max\", (contentNavWrapper.clientHeight - screenHeight).toString());\n        progressBar.setAttribute(\"value\", (currentY - startY).toString());\n      } else {\n        progressBar.setAttribute(\"value\", \"0\");\n      }\n      ticking = false;\n    });\n    ticking = true;\n  }\n}\n\nfunction init() {\n  startY = contentNavWrapper.getBoundingClientRect().top + (window.pageYOffset || document.documentElement.scrollTop);\n  screenHeight = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);\n  progressBar.setAttribute(\"max\", (contentNavWrapper.clientHeight - screenHeight).toString());\n  ticking = false;\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  progressBar = document.getElementById(\"progress-js\") as HTMLProgressElement;\n  contentNavWrapper = document.getElementById(\"page__content-nav-wrapper-js\");\n  if (progressBar && contentNavWrapper) {\n    init();\n    document.addEventListener(\"scroll\", onScroll);\n    window.addEventListener(\"resize\", throttle(init, 500, { leading: true, trailing: true }));\n  }\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\nimport { closeLightbox, showLightbox } from \"./lightbox\";\nimport * as lunr from \"lunr\";\n\nconst selector = {\n  search: \"search-js\",\n  searchToggle: \"search__form-js\",\n  searchInput: \"search__input-js\",\n  result: \"search__result-js\",\n  closeButton: \"search__close-js\",\n  noResult: \"search__result-no-results-js\",\n  resultList: \"search__result-list-js\",\n  resultNumber: \"search__result-number-js\",\n};\n\ntype PageIndexEntry = {\n  date: string;\n  keywords: string[];\n  summary: string;\n  title: string;\n  uri: string;\n};\n\nlet lunrSearch: lunr.Index,\n  pageIndex: PageIndexEntry[],\n  resultTarget: HTMLElement,\n  noResultTarget: HTMLElement,\n  searchTarget: HTMLElement,\n  resultListTarget: HTMLElement,\n  resultNumberTarget: HTMLElement,\n  searchToggleTarget: HTMLElement;\n\n/**\n * Initialize lunr and load the required index\n */\nfunction initSearch() {\n  searchTarget = document.getElementById(selector.search);\n  searchToggleTarget = document.getElementById(selector.searchToggle);\n  resultTarget = document.getElementById(selector.result);\n  resultListTarget = document.getElementById(selector.resultList);\n  resultNumberTarget = document.getElementById(selector.resultNumber);\n  noResultTarget = document.getElementById(selector.noResult);\n  if (\n    searchTarget &&\n    searchTarget.dataset.searchUrl &&\n    resultTarget &&\n    searchToggleTarget &&\n    noResultTarget &&\n    resultListTarget &&\n    resultNumberTarget\n  ) {\n    initSearchBar();\n  }\n  /*\n    setTimeout(() => {\n      searchToggleTarget.click();\n    }, 500);\n\n    setTimeout(() => {\n      search(\"Foo\");\n    }, 1500);\n\n  /*setTimeout(() => {\n    search(\"Foobar\");\n  }, 3000);\n\n  setTimeout(() => {\n    document.getElementById(selector.closeButton).click();\n  }, 5000);\n   */\n}\n\nfunction initSearchBar() {\n  const searchInput = document.getElementById(selector.searchInput) as HTMLInputElement;\n  const closeButton = document.getElementById(selector.closeButton);\n  if (searchInput && closeButton) {\n    searchToggleTarget.addEventListener(\"click\", () => {\n      // open the searchbox\n      if (typeof lunrSearch === \"undefined\") {\n        initLunr();\n      }\n      searchTarget.classList.add(\"search--open\");\n      showLightbox();\n      searchInput.focus();\n    });\n\n    searchInput.addEventListener(\"input\", handleSearchInput);\n\n    closeButton.addEventListener(\"click\", () => {\n      // close the searchbox\n      searchInput.value = \"\";\n      searchInput.blur();\n      resultListTarget.innerHTML = \"\";\n      resultTarget.classList.add(\"search--hidden\");\n      searchTarget.classList.remove(\"search--open\");\n      closeLightbox();\n      noResultTarget.classList.add(\"search--hidden\");\n    });\n  }\n}\n\nfunction handleSearchInput(event: InputEvent) {\n  const target = event.currentTarget as HTMLInputElement;\n  // only search, if at least 3 characters were entered\n  if (target.value.length >= 3) {\n    search(target.value);\n  } else {\n    clearResults();\n  }\n}\n\nfunction initLunr() {\n  const request = new XMLHttpRequest();\n  request.open(\"GET\", searchTarget.dataset.searchUrl, true);\n  request.send();\n\n  request.onload = () => {\n    pageIndex = JSON.parse(request.responseText) as PageIndexEntry[];\n    lunrSearch = lunr(builder => {\n      builder.field(\"title\", { boost: 10 });\n      builder.field(\"keywords\", { boost: 5 });\n      builder.field(\"summary\");\n      builder.ref(\"uri\");\n      pageIndex.forEach(page => {\n        builder.add(page);\n      }, this);\n    });\n  };\n}\n\n/**\n * Perform a search for the given query and render the results\n *\n * @param {String} query - QueryString\n */\nfunction search(query: string) {\n  const results: PageIndexEntry[] = lunrSearch.search(query.trim() + \"*\").map(function (result) {\n    return pageIndex.filter(page => page.uri === result.ref)[0];\n  });\n  renderResults(results);\n}\n\n/**\n * Render the given results into the result target\n * @param {Object} results - Array with results\n *\n */\nfunction renderResults(results: PageIndexEntry[]) {\n  if (!results.length || !resultTarget) {\n    clearResults();\n    return;\n  }\n\n  const resultsHtml = results.map(result => renderResult(result)).join(\"\");\n\n  resultListTarget.innerHTML = resultsHtml.trim();\n  resultNumberTarget.innerHTML = `<span>Your search returned ${results.length} results<span>`;\n  resultTarget.classList.remove(\"search--hidden\");\n  noResultTarget.classList.add(\"search--hidden\");\n}\n\n/**\n * Render a single result\n * @param result\n * @return {string} result as html\n */\nfunction renderResult(result: PageIndexEntry) {\n  const tagsHtml = result.keywords ? result.keywords.map(keyword => renderTag(keyword)).join(\"\") : \"\";\n  const dateFormatted = formatDate(result.date);\n  return `<div class=\"search__result-item\">\n<a class=\"search__result-item-link\" href=\"${result.uri}\">\n<h5 class=\"search__result-item-meta\">${dateFormatted}</h5>\n<h2 class=\"search__result-item-headline\">${result.title}</h2>\n<div class=\"search__result-item-text\">\n<span>${result.summary}</span>\n</div>\n<ul class=\"search__result-item-tags\">\n${tagsHtml}\n</ul>\n</a>\n</div>\n`;\n}\n\n/**\n *\n * @param {String} dateString - the date as iso\n */\nfunction formatDate(dateString: string) {\n  const date = new Date(dateString);\n  const day = \"00\" + String(date.getDate()).slice(-2);\n  const month = \"00\" + String(date.getMonth() + 1).slice(-2);\n  return `${day}.${month}.${date.getFullYear()}`;\n}\n\nfunction renderTag(tag: string) {\n  return `<li class=\"e-tag-item\">${tag}</li>`;\n}\n\nfunction clearResults() {\n  resultListTarget.innerHTML = \"\";\n  resultTarget.classList.add(\"search--hidden\");\n  noResultTarget.classList.remove(\"search--hidden\");\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", () => {\n  initSearch();\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\nconst selector = \"svg-sprite\";\n\nfunction loadSvg() {\n  const svgTarget = document.getElementById(selector);\n\n  if (svgTarget && svgTarget.dataset.svgUrl) {\n    const request = new XMLHttpRequest();\n    request.open(\"GET\", svgTarget.dataset.svgUrl, true);\n    request.send();\n\n    request.onload = () => {\n      svgTarget.innerHTML = request.responseText;\n    };\n  }\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function() {\n  loadSvg();\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\nrequire(\"./components/cookieConsent\");\nrequire(\"./components/svgLoader\");\nrequire(\"./components/search\");\nrequire(\"./components/postList\");\nrequire(\"./components/backToTop\");\nrequire(\"./components/postNav\");\nrequire(\"./components/lightbox\");\nrequire(\"./components/gallery\");\nrequire(\"./components/commentsLazyLoader\");\nrequire(\"./components/commento/count\");\nrequire(\"./components/lazyLoader\");\nrequire(\"./components/readingPositionIndicator\");\nrequire(\"./util/navObserver\");\n","/**\n * All breakpoints\n * @type {{small: number, large: number, xlarge: number, xxlarge: number, medium: number}}\n */\nexport const MQs: { [key: string]: number } = {\n  xxlarge: 160,\n  xlarge: 120,\n  large: 85.375,\n  medium: 64,\n  small: 48,\n};\n\nimport throttle from \"lodash.throttle\";\nlet lastViewportHeight: number;\n\n/**\n *\n * @returns {Number} the current breakpoint\n */\nexport function getCurrentMQ() {\n  const widthEm = getViewportWidth();\n\n  // find first MQ that has at least the calculated width (min-width in media-query)\n  const mq = Object.keys(MQs).find(mq => {\n    return widthEm >= MQs[mq];\n  });\n  return mq ? MQs[mq] : MQs.small;\n}\n\n/**\n *\n * @returns {number} - viewport width in em\n */\nexport function getViewportWidth() {\n  // we define the mqs in em, therefor we first need to calculate the width in ems\n  const width = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);\n  const fontSize = parseFloat(getComputedStyle(document.body).fontSize);\n  return width / fontSize;\n}\n\nfunction updateViewportSize() {\n  // First we get the viewport height and we multiple it by 1% to get a value for a vh unit\n  const vh = window.innerHeight * 0.01;\n  if (!lastViewportHeight || lastViewportHeight !== vh) {\n    // Then we set the value in the --vh custom property to the root of the document\n    document.documentElement.style.setProperty(\"--vh\", `${vh}px`);\n    lastViewportHeight = vh;\n  }\n}\n\n/**\n * Ensure, that the --vh variable is set\n */\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  updateViewportSize();\n  // rerender on resize, throttled\n  window.addEventListener(\"resize\", throttle(updateViewportSize, 500, { leading: true, trailing: true }));\n});\n","/**\n * Observer for a navigation\n */\nclass NavObserver {\n  private navElem: HTMLElement;\n  private content: HTMLElement;\n  private readonly activeClass: string;\n  private observer: IntersectionObserver;\n\n  private navAnchors: Map<string, HTMLAnchorElement>;\n  /**\n   * Constructor\n   * @param navElem - element where the anchors are\n   * @param content - content to observe\n   * @param activeClass - css class to add for active elements\n   */\n  constructor(navElem: HTMLElement, content: HTMLElement, activeClass: string) {\n    this.navElem = navElem;\n    this.content = content;\n    this.activeClass = activeClass;\n    this.observer = new IntersectionObserver(e => this.elementIntersecting(e), {\n      threshold: 0.75,\n    });\n    const headings = this.findHeadings();\n    if (headings.length >= 0) {\n      headings.forEach(h => this.observer.observe(h));\n      this.navAnchors = this.findAnchors();\n    }\n  }\n\n  /**\n   * @returns {any[]} array with all headlines from the content\n   */\n  findHeadings() {\n    return Array.from(this.content.getElementsByTagName(\"h2\"));\n  }\n\n  /**\n   * @return {Map} map - map with all anchors in the nav element\n   */\n  findAnchors() {\n    return new Map(Array.from(this.navElem.getElementsByTagName(\"a\")).map(ele => [decodeURI(ele.hash), ele]));\n  }\n\n  elementIntersecting(entries: IntersectionObserverEntry[]) {\n    this.elementBecomesVisible(\n      entries\n        .filter(e => e.isIntersecting && e.intersectionRatio >= 0.75)\n        .map(e => {\n          return this.navAnchors.get(`#${e.target.id}`);\n        })\n        .filter(e => e),\n    );\n    this.elementBecomesInvisible(\n      entries\n        .filter(e => !e.isIntersecting)\n        .map(e => this.navAnchors.get(`#${e.target.id}`))\n        .filter(e => e),\n    );\n  }\n\n  elementBecomesVisible(enteringAnchors: HTMLElement[]) {\n    const rev = enteringAnchors.reverse();\n    for (let i = 0; i < rev.length; i++) {\n      rev[i].parentElement.classList.add(this.activeClass);\n    }\n  }\n\n  elementBecomesInvisible(leavingAnchors: HTMLElement[]) {\n    leavingAnchors.forEach(anchor => anchor.parentElement.classList.remove(this.activeClass));\n  }\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  const postContent = document.getElementById(\"post-content-js\");\n  if (postContent) {\n    const pageNav = document.getElementById(\"page-nav-js\");\n    if (pageNav) {\n      new NavObserver(pageNav, postContent, \"page__nav-item--active\");\n    }\n    const postNav = document.getElementById(\"post-nav-js\");\n    if (postNav) {\n      new NavObserver(postNav, postContent, \"post__nav-item--active\");\n    }\n  }\n});\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\nrequire(\"../themes/deveth0-theme/src/main\");\n"],"names":["FUNC_ERROR_TEXT","NAN","symbolTag","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","freeGlobal","global","Object","freeSelf","self","root","Function","objectToString","prototype","toString","nativeMax","Math","max","nativeMin","min","now","Date","debounce","func","wait","options","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","args","thisArg","undefined","apply","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","setTimeout","remainingWait","debounced","isInvoking","arguments","this","leadingEdge","toNumber","isObject","cancel","clearTimeout","flush","value","type","isObjectLike","call","isSymbol","other","valueOf","replace","isBinary","test","slice","module","exports","step2list","step3list","v","C","V","meq1","mgr1","s_v","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","build","version","utils","warn","message","console","asString","obj","clone","create","keys","i","length","key","val","Array","isArray","FieldRef","docRef","fieldName","stringValue","_stringValue","joiner","fromString","s","n","indexOf","fieldRef","Set","elements","complete","intersect","union","contains","empty","object","a","b","intersection","element","push","concat","idf","posting","documentCount","documentsWithTerm","x","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","after","existingFn","newFn","pos","splice","before","remove","run","stackLength","memo","j","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","fp","exec","generateStopWordFilter","stopWords","words","reduce","stopWord","TokenSet","final","edges","id","_nextId","fromArray","arr","finish","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","unshift","clonedMetadata","metadataKeys","otherMatchData","allFields","wildcard","String","NONE","LEADING","TRAILING","OPTIONAL","QueryParseError","name","QueryLexer","lexemes","escapeCharPositions","state","lexText","sliceString","subSlices","join","emit","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","isNaN","define","cssClasses","bttElem","onScroll","currentY","window","pageYOffset","classList","document","addEventListener","getElementById","blur","scrollTo","initCount","countSpan","commentsUrl","body","dataset","data","domain","location","host","paths","pathname","request","XMLHttpRequest","open","send","JSON","stringify","onload","status","countResponse","responseJson","success","count","commentCounts","textContent","ex","displayCount","response","observer","IntersectionObserver","entries","filter","e","isIntersecting","commento","main","unobserve","target","commentsElem","observe","parentNode","removeChild","cookieName","setupCookieBar","hasAccepted","cookie","getCookie","cookieConsent","cookieConsentButton","style","display","days","d","setDate","getDate","toUTCString","setCookie","galleryTemplate","galleryElem","galleryLightbox","activeThumb","scrollerLeft","scrollerRight","swipeX","lightbox","thumbnail","caption","thumbnailActive","thumbnailList","item","scrollerHidden","showImage","thumb","onclick","from","getElementsByClassName","activeItem","currentTarget","scrollable","scrollLeft","offsetLeft","scrollToItem","galleryItemTemplate","importNode","content","galleryPicture","sources","getElementsByTagName","reverse","cloneNode","sizes","prepend","img","querySelector","src","templateCaption","innerHTML","createGalleryItem","old","replaceChild","galleryItem","swipeLock","swipeMove","nextImage","nextElementSibling","previousElementSibling","updateScroller","previousImage","prev","unify","dx","TouchEvent","changedTouches","clientX","galleryThumbs","thumbsList","scroller","initGallery","loadMedia","elem","lazyMedia","isVideo","source","srcset","spinner","onloadeddata","showLightbox","closeLightbox","initLightbox","trigger","parentElement","lightboxContent","lastKnownWidth","renderPosts","viewPortWidth","viewportWidthChanged","postList","posts","clearCols","numCols","mq","small","medium","getNumberActiveCols","cols","col","post","appendChild","shortest","findShortestColumn","postToRender","shortestColElem","lastElementChild","offsetHeight","addPostToShortestColumn","addPostsToColumns","ids","contentElem","init","expand","height","el","initialStyle","el_style","getComputedStyle","el_display","el_max_height","maxHeight","visibility","getHeight","setProperty","checked","progressBar","contentNavWrapper","startY","screenHeight","ticking","documentElement","scrollTop","requestAnimationFrame","setAttribute","clientHeight","getBoundingClientRect","top","innerHeight","selector","searchToggle","searchInput","closeButton","noResult","resultList","resultNumber","lunrSearch","pageIndex","resultTarget","noResultTarget","searchTarget","resultListTarget","resultNumberTarget","searchToggleTarget","initSearch","searchUrl","responseText","page","initLunr","focus","handleSearchInput","initSearchBar","event","clearResults","resultsHtml","tagsHtml","keywords","keyword","dateFormatted","dateString","date","day","month","getMonth","getFullYear","formatDate","uri","title","summary","renderResult","trim","renderResults","svgTarget","svgUrl","loadSvg","MQs","xxlarge","xlarge","large","lastViewportHeight","getCurrentMQ","widthEm","getViewportWidth","find","clientWidth","innerWidth","parseFloat","fontSize","updateViewportSize","vh","NavObserver","constructor","navElem","activeClass","elementIntersecting","threshold","headings","findHeadings","h","navAnchors","findAnchors","Map","ele","decodeURI","hash","elementBecomesVisible","intersectionRatio","get","elementBecomesInvisible","enteringAnchors","rev","leavingAnchors","anchor","postContent","pageNav","postNav","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","__esModule","definition","o","defineProperty","enumerable","g","globalThis","prop","hasOwnProperty","r","Symbol","toStringTag"],"sourceRoot":""}