{"version":3,"sources":["webpack:///static-appopensalud/js/6.ff34009e1b917d6e7238.js","webpack:///src/components/views/FAQs.vue","webpack:///./src/components/views/FAQs.vue?de0b","webpack:///./src/components/views/FAQs.vue?4d37","webpack:///./node_modules/lunr/lunr.js","webpack:///./src/components/views/FAQs.vue?d13a","webpack:///./src/components/views/FAQs.vue"],"names":["webpackJsonp","2823","module","__webpack_exports__","__webpack_require__","__WEBPACK_IMPORTED_MODULE_0_bootstrap_vue__","__WEBPACK_IMPORTED_MODULE_1_lunr__","__WEBPACK_IMPORTED_MODULE_1_lunr___default","n","name","components","BBreadcrumb","BCard","BCardBody","BListGroup","BListGroupItem","BCollapse","BIconChevronDown","BIconChevronUp","BIconArrowRight","mounted","this","faqs","faqsData","idx","builder","ref","field","group","questions","forEach","add","faq","groupId","$refs","click","selectGroup","visibleFaqs","faqId","selectFaq","selectedGroup","find","props","hideSearcher","Boolean","Array","data","selectedFaq","searchText","searchResults","watch","methods","isSelectedFaq","id","isSelectedGroup","isLastMenuItem","menuItems","indexOf","item","length","search","results","map","title","computed","active","push","text","to","2915","exports","content","i","locals","2916","2917","lunr","config","Builder","pipeline","trimmer","stopWordFilter","stemmer","searchPipeline","call","build","version","utils","warn","global","message","console","asString","obj","toString","clone","undefined","Object","create","keys","key","val","isArray","slice","TypeError","FieldRef","docRef","fieldName","stringValue","_stringValue","joiner","fromString","s","fieldRef","prototype","Set","elements","complete","intersect","other","union","contains","empty","object","a","b","intersection","element","concat","idf","posting","documentCount","documentsWithTerm","x","Math","log","abs","Token","str","metadata","update","fn","tokenizer","t","toLowerCase","len","tokens","sliceEnd","sliceStart","char","charAt","sliceLength","match","separator","tokenMetadata","Pipeline","_stack","registeredFunctions","registerFunction","label","warnIfFunctionNotRegistered","load","serialised","fnName","Error","arguments","after","existingFn","newFn","pos","splice","before","remove","run","stackLength","memo","j","result","k","runString","token","reset","toJSON","Vector","_magnitude","positionForIndex","index","start","end","pivotPoint","floor","pivotIndex","insert","insertIdx","upsert","position","magnitude","sumOfSquares","elementsLength","sqrt","dot","otherVector","dotProduct","aLen","bLen","aVal","bVal","similarity","toArray","output","step2list","step3list","v","C","c","re_mgr0","RegExp","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","w","stem","suffix","firstch","re","re2","re3","re4","substr","toUpperCase","test","replace","fp","exec","generateStopWordFilter","stopWords","words","reduce","stopWord","TokenSet","final","edges","_nextId","fromArray","arr","finish","root","fromClause","clause","fromFuzzyString","term","editDistance","stack","node","editsRemaining","frame","pop","noEditNode","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","queryString","query","QueryParser","parse","Query","matchingFields","queryVectors","termFieldCache","requiredMatches","prohibitedMatches","clauses","terms","clauseMatches","usePipeline","m","termTokenSet","expandedTerms","presence","REQUIRED","expandedTerm","termIndex","_index","fieldPosting","matchingDocumentRefs","termField","matchingDocumentsSet","PROHIBITED","boost","l","fieldMatch","matchingDocumentRef","matchingFieldRef","MatchData","allRequiredMatches","allProhibitedMatches","matchingFieldRefs","matches","isNegated","docMatch","fieldVector","score","matchData","combine","serializedIndex","serializedVectors","serializedInvertedIndex","tokenSetBuilder","tuple","_ref","_fields","_documents","fieldTermFrequencies","fieldLengths","_b","_k1","metadataWhitelist","attributes","RangeError","number","k1","doc","extractor","fieldTerms","metadataKey","calculateAverageFieldLengths","fieldRefs","numberOfFields","accumulator","documentsWithField","averageFieldLength","createFieldVectors","fieldRefsLength","termIdfCache","fieldLength","termFrequencies","termsLength","fieldBoost","docBoost","scoreWithPrecision","tf","round","createTokenSet","use","args","unshift","apply","clonedMetadata","metadataKeys","otherMatchData","allFields","wildcard","String","NONE","LEADING","TRAILING","OPTIONAL","options","QueryParseError","QueryLexer","lexemes","escapeCharPositions","state","lexText","sliceString","subSlices","join","emit","type","escapeCharacter","EOS","width","ignore","backup","acceptDigitRun","charCode","charCodeAt","more","FIELD","TERM","EDIT_DISTANCE","BOOST","PRESENCE","lexField","lexer","lexTerm","lexEditDistance","lexBoost","lexEOS","termSeparator","currentClause","lexemeIdx","parseClause","peekLexeme","consumeLexeme","lexeme","nextClause","completedClause","parser","parsePresence","parseField","parseTerm","errorMessage","nextLexeme","possibleFields","f","parseEditDistance","parseBoost","parseInt","isNaN","factory","2918","render","_vm","_h","$createElement","_c","_self","staticClass","xs","lg","_l","tag","_v","_s","_e","placeholder","$t","on","model","value","callback","$$v","expression","slot","scopedSlots","_u","refInFor","staticStyle","cursor","$event","proxy","visible","class","question","domProps","innerHTML","answer","staticRenderFns","_withStripped","esExports","515","injectStyle","ssrContext","disposed","normalizeComponent","__vue_styles__","Component","__file"],"mappings":"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AAIC,GAAQD,EAAUE,OAAO,SAAU/E,EAAMgF,GAE3C,MADAhF,GAAKgF,GAAYA,EACVhF,MAGT,OAAO,UAAUK,GACf,GAAIA,GAASyE,EAAMzE,EAAMtF,cAAgBsF,EAAMtF,WAAY,MAAOsF,KAiBtExG,EAAKK,eAAiBL,EAAK+K,wBACzB,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,SAGF/K,EAAK+E,SAASG,iBAAiBlF,EAAKK,eAAgB;;;;AAqBpDL,EAAKI,QAAU,SAAUoG,GACvB,MAAOA,GAAMxC,OAAO,SAAU5B,GAC5B,MAAOA,GAAEwI,QAAQ,OAAQ,IAAIA,QAAQ,OAAQ,OAIjD5K,EAAK+E,SAASG,iBAAiBlF,EAAKI,QAAS;;;;AA2B7CJ,EAAKoL,SAAW,WACd3O,KAAK4O,OAAQ,EACb5O,KAAK6O,SACL7O,KAAKgC,GAAKuB,EAAKoL,SAASG,QACxBvL,EAAKoL,SAASG,SAAW,GAW3BvL,EAAKoL,SAASG,QAAU,EASxBvL,EAAKoL,SAASI,UAAY,SAAUC,GAGlC,IAAK,GAFD5O,GAAU,GAAImD,GAAKoL,SAASlL,QAEvBN,EAAI,EAAGyE,EAAMoH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","file":"static-appopensalud/js/6.ff34009e1b917d6e7238.js","sourcesContent":["webpackJsonp([6],{\n\n/***/ 2823:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_bootstrap_vue__ = __webpack_require__(17);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_lunr__ = __webpack_require__(2917);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_lunr___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lunr__);\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n\n\n\n\n/* harmony default export */ __webpack_exports__[\"a\"] = ({\n    name: 'faqs',\n    components: {\n        BBreadcrumb: __WEBPACK_IMPORTED_MODULE_0_bootstrap_vue__[\"c\" /* BBreadcrumb */],\n        BCard: __WEBPACK_IMPORTED_MODULE_0_bootstrap_vue__[\"e\" /* BCard */],\n        BCardBody: __WEBPACK_IMPORTED_MODULE_0_bootstrap_vue__[\"f\" /* BCardBody */],\n        BListGroup: __WEBPACK_IMPORTED_MODULE_0_bootstrap_vue__[\"_30\" /* BListGroup */],\n        BListGroupItem: __WEBPACK_IMPORTED_MODULE_0_bootstrap_vue__[\"_31\" /* BListGroupItem */],\n        BCollapse: __WEBPACK_IMPORTED_MODULE_0_bootstrap_vue__[\"j\" /* BCollapse */],\n        BIconChevronDown: __WEBPACK_IMPORTED_MODULE_0_bootstrap_vue__[\"O\" /* BIconChevronDown */],\n        BIconChevronUp: __WEBPACK_IMPORTED_MODULE_0_bootstrap_vue__[\"R\" /* BIconChevronUp */],\n        BIconArrowRight: __WEBPACK_IMPORTED_MODULE_0_bootstrap_vue__[\"F\" /* BIconArrowRight */]\n    },\n    mounted: function mounted() {\n        var _this = this;\n\n        this.faqs = this.faqsData;\n        this.idx = __WEBPACK_IMPORTED_MODULE_1_lunr___default()(function (builder) {\n            builder.ref('id');\n            builder.field('question');\n            builder.field('answer');\n            _this.faqs.forEach(function (group) {\n                group.questions.forEach(function (faq) {\n                    builder.add(faq);\n                });\n            });\n        });\n        var groupId = this.$route.params.groupId;\n        var faqId = this.$route.params.questionId;\n        if (groupId) {\n            this.$refs[groupId][0].click();\n        } else {\n            this.selectGroup(this.visibleFaqs[0]);\n        }\n        if (faqId) {\n            this.selectFaq(this.selectedGroup.questions.find(function (faq) {\n                return faq.id === faqId;\n            }));\n        } else {\n            this.selectFaq(this.selectedGroup.questions.find(function (faq) {\n                return !!faq;\n            }));\n        }\n    },\n\n    props: {\n        hideSearcher: Boolean,\n        faqsData: Array\n    },\n    data: function data() {\n        return {\n            idx: null,\n            selectedFaq: null,\n            selectedGroup: null,\n            faqs: null,\n            searchText: null,\n            searchResults: null\n        };\n    },\n\n    watch: {},\n    methods: {\n        selectFaq: function selectFaq(faq) {\n            /* this.selectGroup(this.faqs.find(group => group.questions.find(_faq => _faq.id === faq.id))) */\n            this.selectedFaq = faq;\n            /* setTimeout(() => {\r\n                document.querySelector(`[name=\"${faq.id}\"]`).scrollIntoView({ block: 'end', behavior: 'smooth' })\r\n            }, 1) */\n            /* this.$router.push(`/faqs/${this.selectedGroup.id}/${faq.id}`) */\n        },\n        isSelectedFaq: function isSelectedFaq(id) {\n            return this.selectedFaq && this.selectedFaq.id === id;\n        },\n        selectGroup: function selectGroup(group) {\n            if (this.isSelectedGroup(group.id)) {\n                this.selectedGroup = null;\n                this.selectedFaq = null;\n            } else {\n                this.selectedGroup = this.isSelectedGroup(group.id) ? null : group;\n                this.selectedFaq = this.selectedGroup.questions.find(function (faq) {\n                    return !!faq;\n                });\n            }\n            /* this.$router.push(`/faqs/${group.id}`) */\n        },\n        isSelectedGroup: function isSelectedGroup(id) {\n            return this.selectedGroup && this.selectedGroup.id === id;\n        },\n        isLastMenuItem: function isLastMenuItem(item) {\n            return this.menuItems.indexOf(item) === this.menuItems.length - 1;\n        },\n        search: function search() {\n            var _this2 = this;\n\n            if (!this.searchText) {\n                this.searchResults = null;\n                return;\n            }\n            var results = this.idx.search(this.searchText);\n            this.searchResults = results.map(function (result) {\n                var faq = _this2.faqs.find(function (group) {\n                    return group.questions.find(function (faq) {\n                        return faq.id === result.ref;\n                    });\n                });\n                return {\n                    id: faq.id,\n                    title: faq.title,\n                    questions: [faq.questions.find(function (faq) {\n                        return faq.id === result.ref;\n                    })]\n                };\n            });\n            this.selectGroup(this.searchResults[0]);\n        }\n    },\n    computed: {\n        menuItems: function menuItems() {\n            var menuItems = [{\n                text: this.$t('faqs-title'),\n                to: '/faqs'\n            }];\n            if (this.selectedGroup) {\n                menuItems.forEach(function (item) {\n                    item.active = false;\n                });\n                menuItems.push({\n                    text: this.selectedGroup.title,\n                    to: '/faqs/' + this.selectedGroup.id,\n                    active: true\n                });\n\n                if (this.selectedFaq) {\n                    menuItems.forEach(function (item) {\n                        item.active = false;\n                    });\n                    menuItems.push({\n                        text: this.selectedFaq.question,\n                        to: '/faqs/' + this.selectedGroup.id + '/' + this.selectedFaq.id,\n                        active: true\n                    });\n                }\n            }\n            return menuItems;\n        },\n        visibleFaqs: function visibleFaqs() {\n            return this.searchResults || this.faqs;\n        }\n    }\n});\n\n/***/ }),\n\n/***/ 2915:\n/***/ (function(module, exports, __webpack_require__) {\n\n// style-loader: Adds some css to the DOM by adding a <style> tag\n\n// load the styles\nvar content = __webpack_require__(2916);\nif(typeof content === 'string') content = [[module.i, content, '']];\nif(content.locals) module.exports = content.locals;\n// add the styles to the DOM\nvar update = __webpack_require__(9)(\"f59fcf9e\", content, false, {});\n// Hot Module Replacement\nif(false) {\n // When the styles change, update the <style> tags\n if(!content.locals) {\n   module.hot.accept(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-7c8cda4e\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/sass-loader/dist/cjs.js?{\\\"data\\\":\\\"@import \\\\\\\"static-appopensalud/css/scss/shared.scss\\\\\\\";\\\",\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./FAQs.vue\", function() {\n     var newContent = require(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-7c8cda4e\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/sass-loader/dist/cjs.js?{\\\"data\\\":\\\"@import \\\\\\\"static-appopensalud/css/scss/shared.scss\\\\\\\";\\\",\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./FAQs.vue\");\n     if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];\n     update(newContent);\n   });\n }\n // When the module is disposed, remove the <style> tags\n module.hot.dispose(function() { update(); });\n}\n\n/***/ }),\n\n/***/ 2916:\n/***/ (function(module, exports, __webpack_require__) {\n\nexports = module.exports = __webpack_require__(8)(false);\n// imports\n\n\n// module\nexports.push([module.i, \"\\n.overline-typescale{font-size:12px;letter-spacing:1.25px;font-weight:lighter;text-transform:uppercase\\n}\\n.slide-down-enter-active,.slide-down-leave-active{-webkit-transition:all 0.5s ease;transition:all 0.5s ease\\n}\\n.slide-down-enter,.slide-down-leave-to{-webkit-transform:translateY(-100%);transform:translateY(-100%);opacity:0\\n}\\n.slide-fade-left-enter-active,.slide-fade-left-leave-active{-webkit-transition:opacity 0.3s ease, -webkit-transform 0.3s ease;transition:opacity 0.3s ease, -webkit-transform 0.3s ease;transition:transform 0.3s ease, opacity 0.3s ease;transition:transform 0.3s ease, opacity 0.3s ease, -webkit-transform 0.3s ease\\n}\\n.slide-fade-left-enter,.slide-fade-left-leave-to{-webkit-transform:translateX(100%);transform:translateX(100%);opacity:0\\n}\\n.fade-enter-active{-webkit-transition:opacity 0.3s ease;transition:opacity 0.3s ease\\n}\\n.fade-enter,.fade-leave-to{opacity:0\\n}\\n@media only screen and (min-width: 1024px){\\n.ctm-container{padding-right:11rem;padding-left:11rem\\n}\\n}\\n@media only screen and (min-width: 2000px){\\n.ctm-container{padding-right:11rem;padding-left:11rem\\n}\\n}\\n@media only screen and (min-width: 0px) and (max-width: 1023px) and (orientation: landscape){\\n.ctm-container{padding-right:2rem;padding-left:2rem\\n}\\n}\\n@media only screen and (min-width: 576px) and (max-width: 1023px) and (orientation: portrait), only screen and (min-device-width: 1024px) and (max-device-height: 1366px) and (-webkit-min-device-pixel-ratio: 2) and (orientation: portrait){\\n.ctm-container{padding-right:6rem;padding-left:6rem\\n}\\n}\\n@media (min-width: 768px) and (max-width: 1199.98px) and (orientation: landscape){\\n.ctm-container{padding-right:6rem;padding-left:6rem\\n}\\n}\\n@media only screen and (max-width: 575px){\\n.ctm-container{padding-right:2rem;padding-left:2rem\\n}\\n}\\n\", \"\"]);\n\n// exports\n\n\n/***/ }),\n\n/***/ 2917:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/**\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 (true) {\n      // AMD. Register as an anonymous module.\n      !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :\n\t\t\t\t__WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))\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\n/***/ }),\n\n/***/ 2918:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nvar render = function() {\n  var _vm = this\n  var _h = _vm.$createElement\n  var _c = _vm._self._c || _h\n  return _c(\n    \"div\",\n    { attrs: { id: \"faqs-template\" } },\n    [\n      _c(\n        \"b-row\",\n        [\n          _vm.menuItems\n            ? _c(\n                \"b-col\",\n                { staticClass: \"pb-4\", attrs: { xs: \"12\", lg: \"9\" } },\n                _vm._l(_vm.menuItems, function(item) {\n                  return _c(\n                    \"span\",\n                    { key: item.to },\n                    [\n                      _c(\"router-link\", { attrs: { tag: \"a\", to: item.to } }, [\n                        _vm._v(\n                          \"\\n                  \" +\n                            _vm._s(item.text) +\n                            \"\\n              \"\n                        )\n                      ]),\n                      _vm._v(\n                        \"\\n              \" +\n                          _vm._s(_vm.isLastMenuItem(item) ? \"\" : \">\") +\n                          \"\\n          \"\n                      )\n                    ],\n                    1\n                  )\n                }),\n                0\n              )\n            : _vm._e(),\n          _vm._v(\" \"),\n          !_vm.hideSearcher\n            ? _c(\n                \"b-col\",\n                { attrs: { xs: \"12\", lg: \"3\" } },\n                [\n                  _c(\n                    \"base-input\",\n                    {\n                      attrs: { placeholder: _vm.$t(\"search\") },\n                      on: { \"keyup:enter\": _vm.search },\n                      model: {\n                        value: _vm.searchText,\n                        callback: function($$v) {\n                          _vm.searchText = $$v\n                        },\n                        expression: \"searchText\"\n                      }\n                    },\n                    [\n                      _c(\"template\", { slot: \"append\" }, [\n                        _c(\n                          \"i\",\n                          { on: { click: _vm.search } },\n                          [_c(\"b-icon-arrow-right\")],\n                          1\n                        )\n                      ])\n                    ],\n                    2\n                  )\n                ],\n                1\n              )\n            : _vm._e()\n        ],\n        1\n      ),\n      _vm._v(\" \"),\n      _c(\n        \"b-row\",\n        [\n          _c(\n            \"b-col\",\n            { attrs: { xs: \"12\", lg: \"3\" } },\n            _vm._l(_vm.visibleFaqs, function(group) {\n              return _c(\n                \"b-card\",\n                {\n                  key: group.id,\n                  staticClass: \"mb-3\",\n                  scopedSlots: _vm._u(\n                    [\n                      {\n                        key: \"header\",\n                        fn: function() {\n                          return [\n                            _c(\n                              \"div\",\n                              {\n                                ref: group.id,\n                                refInFor: true,\n                                staticClass: \"w-100\",\n                                staticStyle: { cursor: \"pointer\" },\n                                on: {\n                                  click: function($event) {\n                                    return _vm.selectGroup(group)\n                                  }\n                                }\n                              },\n                              [\n                                _vm._v(\n                                  \"\\n                      \" +\n                                    _vm._s(group.title) +\n                                    \"\\n                      \"\n                                ),\n                                _c(\n                                  \"span\",\n                                  { staticClass: \"float-right\" },\n                                  [\n                                    _vm.isSelectedGroup(group.id)\n                                      ? _c(\"b-icon-chevron-down\")\n                                      : _c(\"b-icon-chevron-up\")\n                                  ],\n                                  1\n                                )\n                              ]\n                            )\n                          ]\n                        },\n                        proxy: true\n                      }\n                    ],\n                    null,\n                    true\n                  )\n                },\n                [\n                  _vm._v(\" \"),\n                  _c(\n                    \"b-collapse\",\n                    {\n                      attrs: {\n                        id: group.id,\n                        visible: _vm.isSelectedGroup(group.id)\n                      }\n                    },\n                    [\n                      _c(\n                        \"b-list-group\",\n                        _vm._l(group.questions, function(faq) {\n                          return _c(\n                            \"b-list-group-item\",\n                            {\n                              key: faq.id,\n                              class: { active: _vm.isSelectedFaq(faq.id) },\n                              staticStyle: { cursor: \"pointer\" },\n                              on: {\n                                click: function($event) {\n                                  return _vm.selectFaq(faq)\n                                }\n                              }\n                            },\n                            [\n                              _vm._v(\n                                \"\\n                          \" +\n                                  _vm._s(faq.question) +\n                                  \"\\n                      \"\n                              )\n                            ]\n                          )\n                        }),\n                        1\n                      )\n                    ],\n                    1\n                  )\n                ],\n                1\n              )\n            }),\n            1\n          ),\n          _vm._v(\" \"),\n          _c(\n            \"b-col\",\n            {\n              staticClass: \"px-0 pt-4 px-md-5 pt-md-0\",\n              attrs: { xs: \"12\", lg: \"9\" }\n            },\n            [\n              _c(\"transition\", [\n                _vm.selectedFaq\n                  ? _c(\"div\", { attrs: { name: _vm.selectedFaq.id } }, [\n                      _c(\"h3\", [_vm._v(_vm._s(_vm.selectedFaq.question))]),\n                      _vm._v(\" \"),\n                      _c(\"p\", {\n                        domProps: { innerHTML: _vm._s(_vm.selectedFaq.answer) }\n                      })\n                    ])\n                  : _vm._e()\n              ])\n            ],\n            1\n          )\n        ],\n        1\n      )\n    ],\n    1\n  )\n}\nvar staticRenderFns = []\nrender._withStripped = true\nvar esExports = { render: render, staticRenderFns: staticRenderFns }\n/* harmony default export */ __webpack_exports__[\"a\"] = (esExports);\nif (false) {\n  module.hot.accept()\n  if (module.hot.data) {\n    require(\"vue-hot-reload-api\")      .rerender(\"data-v-7c8cda4e\", esExports)\n  }\n}\n\n/***/ }),\n\n/***/ 515:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_FAQs_vue__ = __webpack_require__(2823);\n/* empty harmony namespace reexport */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_7c8cda4e_hasScoped_false_transformToRequire_video_src_poster_source_src_img_src_image_xlink_href_buble_transforms_node_modules_vue_loader_lib_selector_type_template_index_0_FAQs_vue__ = __webpack_require__(2918);\nvar disposed = false\nfunction injectStyle (ssrContext) {\n  if (disposed) return\n  __webpack_require__(2915)\n}\nvar normalizeComponent = __webpack_require__(6)\n/* script */\n\n\n/* template */\n\n/* template functional */\nvar __vue_template_functional__ = false\n/* styles */\nvar __vue_styles__ = injectStyle\n/* scopeId */\nvar __vue_scopeId__ = null\n/* moduleIdentifier (server only) */\nvar __vue_module_identifier__ = null\nvar Component = normalizeComponent(\n  __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_FAQs_vue__[\"a\" /* default */],\n  __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_7c8cda4e_hasScoped_false_transformToRequire_video_src_poster_source_src_img_src_image_xlink_href_buble_transforms_node_modules_vue_loader_lib_selector_type_template_index_0_FAQs_vue__[\"a\" /* default */],\n  __vue_template_functional__,\n  __vue_styles__,\n  __vue_scopeId__,\n  __vue_module_identifier__\n)\nComponent.options.__file = \"src/components/views/FAQs.vue\"\n\n/* hot reload */\nif (false) {(function () {\n  var hotAPI = require(\"vue-hot-reload-api\")\n  hotAPI.install(require(\"vue\"), false)\n  if (!hotAPI.compatible) return\n  module.hot.accept()\n  if (!module.hot.data) {\n    hotAPI.createRecord(\"data-v-7c8cda4e\", Component.options)\n  } else {\n    hotAPI.reload(\"data-v-7c8cda4e\", Component.options)\n  }\n  module.hot.dispose(function (data) {\n    disposed = true\n  })\n})()}\n\n/* harmony default export */ __webpack_exports__[\"default\"] = (Component.exports);\n\n\n/***/ })\n\n});\n\n\n// WEBPACK FOOTER //\n// static-appopensalud/js/6.ff34009e1b917d6e7238.js","<template>\r\n  <div id=\"faqs-template\">\r\n    <b-row>\r\n        <b-col xs=\"12\" lg=\"9\" v-if=\"menuItems\" class=\"pb-4\">\r\n            <span v-for=\"item in menuItems\" :key=\"item.to\">\r\n                <router-link tag=\"a\" :to=\"item.to\">\r\n                    {{ item.text }}\r\n                </router-link>\r\n                {{ isLastMenuItem(item) ? '' : '>' }}\r\n            </span>\r\n        </b-col>\r\n        <b-col v-if=\"!hideSearcher\" xs=\"12\" lg=\"3\">\r\n            <base-input v-model=\"searchText\" :placeholder=\"$t('search')\" @keyup:enter=\"search\" >\r\n                <template slot=\"append\">\r\n                    <i @click=\"search\"><b-icon-arrow-right></b-icon-arrow-right></i>\r\n                </template>\r\n            </base-input>\r\n        </b-col>\r\n    </b-row>\r\n    <b-row> \r\n        <b-col xs=\"12\" lg=\"3\">\r\n            <b-card class=\"mb-3\" v-for=\"group in visibleFaqs\" :key=\"group.id\">\r\n                <template #header>\r\n                    <div :ref=\"group.id\" class=\"w-100\" @click=\"selectGroup(group)\" style=\"cursor: pointer\">\r\n                        {{ group.title }}\r\n                        <span class=\"float-right\">\r\n                            <b-icon-chevron-down v-if=\"isSelectedGroup(group.id)\"></b-icon-chevron-down>\r\n                            <b-icon-chevron-up v-else></b-icon-chevron-up>\r\n                        </span>\r\n                    </div>\r\n                    \r\n                </template>\r\n                <b-collapse :id=\"group.id\" :visible=\"isSelectedGroup(group.id)\">\r\n                    <b-list-group>\r\n                        <b-list-group-item v-for=\"faq in group.questions\" :key=\"faq.id\" @click=\"selectFaq(faq)\" :class=\"{ 'active': isSelectedFaq(faq.id)}\" style=\"cursor: pointer;\">\r\n                            {{ faq.question }}\r\n                        </b-list-group-item>\r\n                    </b-list-group>\r\n                </b-collapse>\r\n            </b-card>\r\n        </b-col>\r\n        <b-col xs=\"12\" lg=\"9\" class=\"px-0 pt-4 px-md-5 pt-md-0\">\r\n            <transition>\r\n                <div :name=\"selectedFaq.id\" v-if=\"selectedFaq\">\r\n                    <h3>{{ selectedFaq.question }}</h3>\r\n                    <p v-html=\"selectedFaq.answer\"></p>\r\n                </div>\r\n            </transition>\r\n        </b-col>\r\n    </b-row>\r\n  </div>\r\n</template>\r\n\r\n<script>\r\nimport { BCard, BCardBody, BListGroup, BListGroupItem, BCollapse, BIconChevronDown, BIconChevronUp, BBreadcrumb, BIconArrowRight } from 'bootstrap-vue'\r\nimport lunr from 'lunr'\r\n\r\nexport default {\r\n    name: 'faqs',\r\n    components: {\r\n        BBreadcrumb,\r\n        BCard,\r\n        BCardBody,\r\n        BListGroup,\r\n        BListGroupItem,\r\n        BCollapse,\r\n        BIconChevronDown,\r\n        BIconChevronUp,\r\n        BIconArrowRight\r\n    },\r\n    mounted () {\r\n        this.faqs = this.faqsData\r\n        this.idx = lunr((builder) => {\r\n            builder.ref('id')\r\n            builder.field('question')\r\n            builder.field('answer')\r\n            this.faqs.forEach(group => {\r\n                group.questions.forEach(faq => {\r\n                    builder.add(faq)\r\n                })\r\n            })\r\n        })\r\n        const groupId = this.$route.params.groupId\r\n        const faqId = this.$route.params.questionId\r\n        if (groupId) {\r\n            this.$refs[groupId][0].click()\r\n        } else {\r\n            this.selectGroup(this.visibleFaqs[0])\r\n        }\r\n        if (faqId) {\r\n            this.selectFaq(this.selectedGroup.questions.find(faq => faq.id === faqId))\r\n        } else {\r\n            this.selectFaq(this.selectedGroup.questions.find(faq => !!faq))\r\n        }\r\n    },\r\n    props: {\r\n        hideSearcher: Boolean,\r\n        faqsData: Array\r\n    },\r\n    data () {\r\n        return {\r\n            idx: null,\r\n            selectedFaq: null,\r\n            selectedGroup: null,\r\n            faqs: null,\r\n            searchText: null,\r\n            searchResults: null\r\n        }\r\n    },\r\n    watch: {\r\n    },\r\n    methods: {\r\n        selectFaq (faq) {\r\n\t\t\t\t\t\t/* this.selectGroup(this.faqs.find(group => group.questions.find(_faq => _faq.id === faq.id))) */\r\n            this.selectedFaq = faq\r\n            /* setTimeout(() => {\r\n                document.querySelector(`[name=\"${faq.id}\"]`).scrollIntoView({ block: 'end', behavior: 'smooth' })\r\n            }, 1) */\r\n            /* this.$router.push(`/faqs/${this.selectedGroup.id}/${faq.id}`) */\r\n        },\r\n        isSelectedFaq (id) {\r\n            return this.selectedFaq && this.selectedFaq.id === id\r\n        },\r\n        selectGroup (group) {\r\n\t\t\t\t\t\tif (this.isSelectedGroup(group.id)) {\r\n\t\t\t\t\t\t\tthis.selectedGroup = null\r\n\t\t\t\t\t\t\tthis.selectedFaq = null\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tthis.selectedGroup = this.isSelectedGroup(group.id) ? null : group\r\n\t\t\t\t\t\t\tthis.selectedFaq = this.selectedGroup.questions.find(faq => !!faq)\r\n\t\t\t\t\t\t}\r\n            /* this.$router.push(`/faqs/${group.id}`) */\r\n        },\r\n        isSelectedGroup (id) {\r\n            return this.selectedGroup && this.selectedGroup.id === id\r\n        },\r\n        isLastMenuItem (item) {\r\n            return this.menuItems.indexOf(item) === this.menuItems.length - 1\r\n        },\r\n        search () {\r\n            if (!this.searchText) {\r\n                this.searchResults = null\r\n                return\r\n            }\r\n            const results = this.idx.search(this.searchText)\r\n            this.searchResults = results.map(result => {\r\n                const faq = this.faqs.find(group => group.questions.find(faq => faq.id === result.ref))\r\n                return {\r\n                    id: faq.id,\r\n                    title: faq.title,\r\n                    questions: [faq.questions.find(faq => faq.id === result.ref)]\r\n                }\r\n            })\r\n            this.selectGroup(this.searchResults[0])\r\n        }\r\n    },\r\n    computed: {\r\n        menuItems () {\r\n            let menuItems = [\r\n                {\r\n                    text: this.$t('faqs-title'),\r\n                    to: '/faqs'\r\n                }\r\n            ]\r\n            if (this.selectedGroup) {\r\n                menuItems.forEach(item => {\r\n                    item.active = false\r\n                })\r\n                menuItems.push({\r\n                    text: this.selectedGroup.title,\r\n                    to: `/faqs/${this.selectedGroup.id}`,\r\n                    active: true\r\n                })\r\n\r\n\t\t\t\t\t\t\t\tif (this.selectedFaq) {\r\n\t\t\t\t\t\t\t\t\tmenuItems.forEach(item => {\r\n\t\t\t\t\t\t\t\t\t\t\titem.active = false\r\n\t\t\t\t\t\t\t\t\t})\r\n\t\t\t\t\t\t\t\t\tmenuItems.push({\r\n\t\t\t\t\t\t\t\t\t\t\ttext: this.selectedFaq.question,\r\n\t\t\t\t\t\t\t\t\t\t\tto: `/faqs/${this.selectedGroup.id}/${this.selectedFaq.id}`,\r\n\t\t\t\t\t\t\t\t\t\t\tactive: true\r\n\t\t\t\t\t\t\t\t\t})\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n            return menuItems\r\n        },\r\n\t\t\t\tvisibleFaqs () {\r\n\t\t\t\t\treturn (this.searchResults || this.faqs)\r\n\t\t\t\t}\r\n    }\r\n}\r\n</script>\r\n\r\n<style lang=\"scss\">\r\n.ctm-container {\r\n    @include container-padding;\r\n}\r\n\r\n</style>\n\n\n// WEBPACK FOOTER //\n// src/components/views/FAQs.vue","// style-loader: Adds some css to the DOM by adding a <style> tag\n\n// load the styles\nvar content = require(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-7c8cda4e\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/sass-loader/dist/cjs.js?{\\\"data\\\":\\\"@import \\\\\\\"static-appopensalud/css/scss/shared.scss\\\\\\\";\\\",\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./FAQs.vue\");\nif(typeof content === 'string') content = [[module.id, content, '']];\nif(content.locals) module.exports = content.locals;\n// add the styles to the DOM\nvar update = require(\"!../../../node_modules/vue-style-loader/lib/addStylesClient.js\")(\"f59fcf9e\", content, false, {});\n// Hot Module Replacement\nif(module.hot) {\n // When the styles change, update the <style> tags\n if(!content.locals) {\n   module.hot.accept(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-7c8cda4e\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/sass-loader/dist/cjs.js?{\\\"data\\\":\\\"@import \\\\\\\"static-appopensalud/css/scss/shared.scss\\\\\\\";\\\",\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./FAQs.vue\", function() {\n     var newContent = require(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-7c8cda4e\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/sass-loader/dist/cjs.js?{\\\"data\\\":\\\"@import \\\\\\\"static-appopensalud/css/scss/shared.scss\\\\\\\";\\\",\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./FAQs.vue\");\n     if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];\n     update(newContent);\n   });\n }\n // When the module is disposed, remove the <style> tags\n module.hot.dispose(function() { update(); });\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-style-loader!./node_modules/css-loader?{\"sourceMap\":false}!./node_modules/vue-loader/lib/style-compiler?{\"vue\":true,\"id\":\"data-v-7c8cda4e\",\"scoped\":false,\"hasInlineConfig\":false}!./node_modules/sass-loader/dist/cjs.js?{\"data\":\"@import /\"static-appopensalud/css/scss/shared.scss/\";\",\"sourceMap\":false}!./node_modules/vue-loader/lib/selector.js?type=styles&index=0!./src/components/views/FAQs.vue\n// module id = 2915\n// module chunks = 6 68","exports = module.exports = require(\"../../../node_modules/css-loader/lib/css-base.js\")(false);\n// imports\n\n\n// module\nexports.push([module.id, \"\\n.overline-typescale{font-size:12px;letter-spacing:1.25px;font-weight:lighter;text-transform:uppercase\\n}\\n.slide-down-enter-active,.slide-down-leave-active{-webkit-transition:all 0.5s ease;transition:all 0.5s ease\\n}\\n.slide-down-enter,.slide-down-leave-to{-webkit-transform:translateY(-100%);transform:translateY(-100%);opacity:0\\n}\\n.slide-fade-left-enter-active,.slide-fade-left-leave-active{-webkit-transition:opacity 0.3s ease, -webkit-transform 0.3s ease;transition:opacity 0.3s ease, -webkit-transform 0.3s ease;transition:transform 0.3s ease, opacity 0.3s ease;transition:transform 0.3s ease, opacity 0.3s ease, -webkit-transform 0.3s ease\\n}\\n.slide-fade-left-enter,.slide-fade-left-leave-to{-webkit-transform:translateX(100%);transform:translateX(100%);opacity:0\\n}\\n.fade-enter-active{-webkit-transition:opacity 0.3s ease;transition:opacity 0.3s ease\\n}\\n.fade-enter,.fade-leave-to{opacity:0\\n}\\n@media only screen and (min-width: 1024px){\\n.ctm-container{padding-right:11rem;padding-left:11rem\\n}\\n}\\n@media only screen and (min-width: 2000px){\\n.ctm-container{padding-right:11rem;padding-left:11rem\\n}\\n}\\n@media only screen and (min-width: 0px) and (max-width: 1023px) and (orientation: landscape){\\n.ctm-container{padding-right:2rem;padding-left:2rem\\n}\\n}\\n@media only screen and (min-width: 576px) and (max-width: 1023px) and (orientation: portrait), only screen and (min-device-width: 1024px) and (max-device-height: 1366px) and (-webkit-min-device-pixel-ratio: 2) and (orientation: portrait){\\n.ctm-container{padding-right:6rem;padding-left:6rem\\n}\\n}\\n@media (min-width: 768px) and (max-width: 1199.98px) and (orientation: landscape){\\n.ctm-container{padding-right:6rem;padding-left:6rem\\n}\\n}\\n@media only screen and (max-width: 575px){\\n.ctm-container{padding-right:2rem;padding-left:2rem\\n}\\n}\\n\", \"\"]);\n\n// exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/css-loader?{\"sourceMap\":false}!./node_modules/vue-loader/lib/style-compiler?{\"vue\":true,\"id\":\"data-v-7c8cda4e\",\"scoped\":false,\"hasInlineConfig\":false}!./node_modules/sass-loader/dist/cjs.js?{\"data\":\"@import /\"static-appopensalud/css/scss/shared.scss/\";\",\"sourceMap\":false}!./node_modules/vue-loader/lib/selector.js?type=styles&index=0!./src/components/views/FAQs.vue\n// module id = 2916\n// module chunks = 6 68","/**\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\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lunr/lunr.js\n// module id = 2917\n// module chunks = 6 68","var render = function() {\n  var _vm = this\n  var _h = _vm.$createElement\n  var _c = _vm._self._c || _h\n  return _c(\n    \"div\",\n    { attrs: { id: \"faqs-template\" } },\n    [\n      _c(\n        \"b-row\",\n        [\n          _vm.menuItems\n            ? _c(\n                \"b-col\",\n                { staticClass: \"pb-4\", attrs: { xs: \"12\", lg: \"9\" } },\n                _vm._l(_vm.menuItems, function(item) {\n                  return _c(\n                    \"span\",\n                    { key: item.to },\n                    [\n                      _c(\"router-link\", { attrs: { tag: \"a\", to: item.to } }, [\n                        _vm._v(\n                          \"\\n                  \" +\n                            _vm._s(item.text) +\n                            \"\\n              \"\n                        )\n                      ]),\n                      _vm._v(\n                        \"\\n              \" +\n                          _vm._s(_vm.isLastMenuItem(item) ? \"\" : \">\") +\n                          \"\\n          \"\n                      )\n                    ],\n                    1\n                  )\n                }),\n                0\n              )\n            : _vm._e(),\n          _vm._v(\" \"),\n          !_vm.hideSearcher\n            ? _c(\n                \"b-col\",\n                { attrs: { xs: \"12\", lg: \"3\" } },\n                [\n                  _c(\n                    \"base-input\",\n                    {\n                      attrs: { placeholder: _vm.$t(\"search\") },\n                      on: { \"keyup:enter\": _vm.search },\n                      model: {\n                        value: _vm.searchText,\n                        callback: function($$v) {\n                          _vm.searchText = $$v\n                        },\n                        expression: \"searchText\"\n                      }\n                    },\n                    [\n                      _c(\"template\", { slot: \"append\" }, [\n                        _c(\n                          \"i\",\n                          { on: { click: _vm.search } },\n                          [_c(\"b-icon-arrow-right\")],\n                          1\n                        )\n                      ])\n                    ],\n                    2\n                  )\n                ],\n                1\n              )\n            : _vm._e()\n        ],\n        1\n      ),\n      _vm._v(\" \"),\n      _c(\n        \"b-row\",\n        [\n          _c(\n            \"b-col\",\n            { attrs: { xs: \"12\", lg: \"3\" } },\n            _vm._l(_vm.visibleFaqs, function(group) {\n              return _c(\n                \"b-card\",\n                {\n                  key: group.id,\n                  staticClass: \"mb-3\",\n                  scopedSlots: _vm._u(\n                    [\n                      {\n                        key: \"header\",\n                        fn: function() {\n                          return [\n                            _c(\n                              \"div\",\n                              {\n                                ref: group.id,\n                                refInFor: true,\n                                staticClass: \"w-100\",\n                                staticStyle: { cursor: \"pointer\" },\n                                on: {\n                                  click: function($event) {\n                                    return _vm.selectGroup(group)\n                                  }\n                                }\n                              },\n                              [\n                                _vm._v(\n                                  \"\\n                      \" +\n                                    _vm._s(group.title) +\n                                    \"\\n                      \"\n                                ),\n                                _c(\n                                  \"span\",\n                                  { staticClass: \"float-right\" },\n                                  [\n                                    _vm.isSelectedGroup(group.id)\n                                      ? _c(\"b-icon-chevron-down\")\n                                      : _c(\"b-icon-chevron-up\")\n                                  ],\n                                  1\n                                )\n                              ]\n                            )\n                          ]\n                        },\n                        proxy: true\n                      }\n                    ],\n                    null,\n                    true\n                  )\n                },\n                [\n                  _vm._v(\" \"),\n                  _c(\n                    \"b-collapse\",\n                    {\n                      attrs: {\n                        id: group.id,\n                        visible: _vm.isSelectedGroup(group.id)\n                      }\n                    },\n                    [\n                      _c(\n                        \"b-list-group\",\n                        _vm._l(group.questions, function(faq) {\n                          return _c(\n                            \"b-list-group-item\",\n                            {\n                              key: faq.id,\n                              class: { active: _vm.isSelectedFaq(faq.id) },\n                              staticStyle: { cursor: \"pointer\" },\n                              on: {\n                                click: function($event) {\n                                  return _vm.selectFaq(faq)\n                                }\n                              }\n                            },\n                            [\n                              _vm._v(\n                                \"\\n                          \" +\n                                  _vm._s(faq.question) +\n                                  \"\\n                      \"\n                              )\n                            ]\n                          )\n                        }),\n                        1\n                      )\n                    ],\n                    1\n                  )\n                ],\n                1\n              )\n            }),\n            1\n          ),\n          _vm._v(\" \"),\n          _c(\n            \"b-col\",\n            {\n              staticClass: \"px-0 pt-4 px-md-5 pt-md-0\",\n              attrs: { xs: \"12\", lg: \"9\" }\n            },\n            [\n              _c(\"transition\", [\n                _vm.selectedFaq\n                  ? _c(\"div\", { attrs: { name: _vm.selectedFaq.id } }, [\n                      _c(\"h3\", [_vm._v(_vm._s(_vm.selectedFaq.question))]),\n                      _vm._v(\" \"),\n                      _c(\"p\", {\n                        domProps: { innerHTML: _vm._s(_vm.selectedFaq.answer) }\n                      })\n                    ])\n                  : _vm._e()\n              ])\n            ],\n            1\n          )\n        ],\n        1\n      )\n    ],\n    1\n  )\n}\nvar staticRenderFns = []\nrender._withStripped = true\nvar esExports = { render: render, staticRenderFns: staticRenderFns }\nexport default esExports\nif (module.hot) {\n  module.hot.accept()\n  if (module.hot.data) {\n    require(\"vue-hot-reload-api\")      .rerender(\"data-v-7c8cda4e\", esExports)\n  }\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-loader/lib/template-compiler?{\"id\":\"data-v-7c8cda4e\",\"hasScoped\":false,\"transformToRequire\":{\"video\":[\"src\",\"poster\"],\"source\":\"src\",\"img\":\"src\",\"image\":\"xlink:href\"},\"buble\":{\"transforms\":{}}}!./node_modules/vue-loader/lib/selector.js?type=template&index=0!./src/components/views/FAQs.vue\n// module id = 2918\n// module chunks = 6 68","var disposed = false\nfunction injectStyle (ssrContext) {\n  if (disposed) return\n  require(\"!!vue-style-loader!css-loader?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-7c8cda4e\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!sass-loader?{\\\"data\\\":\\\"@import \\\\\\\"static-appopensalud/css/scss/shared.scss\\\\\\\";\\\",\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector?type=styles&index=0!./FAQs.vue\")\n}\nvar normalizeComponent = require(\"!../../../node_modules/vue-loader/lib/component-normalizer\")\n/* script */\nexport * from \"!!babel-loader!../../../node_modules/vue-loader/lib/selector?type=script&index=0!./FAQs.vue\"\nimport __vue_script__ from \"!!babel-loader!../../../node_modules/vue-loader/lib/selector?type=script&index=0!./FAQs.vue\"\n/* template */\nimport __vue_template__ from \"!!../../../node_modules/vue-loader/lib/template-compiler/index?{\\\"id\\\":\\\"data-v-7c8cda4e\\\",\\\"hasScoped\\\":false,\\\"transformToRequire\\\":{\\\"video\\\":[\\\"src\\\",\\\"poster\\\"],\\\"source\\\":\\\"src\\\",\\\"img\\\":\\\"src\\\",\\\"image\\\":\\\"xlink:href\\\"},\\\"buble\\\":{\\\"transforms\\\":{}}}!../../../node_modules/vue-loader/lib/selector?type=template&index=0!./FAQs.vue\"\n/* template functional */\nvar __vue_template_functional__ = false\n/* styles */\nvar __vue_styles__ = injectStyle\n/* scopeId */\nvar __vue_scopeId__ = null\n/* moduleIdentifier (server only) */\nvar __vue_module_identifier__ = null\nvar Component = normalizeComponent(\n  __vue_script__,\n  __vue_template__,\n  __vue_template_functional__,\n  __vue_styles__,\n  __vue_scopeId__,\n  __vue_module_identifier__\n)\nComponent.options.__file = \"src/components/views/FAQs.vue\"\n\n/* hot reload */\nif (module.hot) {(function () {\n  var hotAPI = require(\"vue-hot-reload-api\")\n  hotAPI.install(require(\"vue\"), false)\n  if (!hotAPI.compatible) return\n  module.hot.accept()\n  if (!module.hot.data) {\n    hotAPI.createRecord(\"data-v-7c8cda4e\", Component.options)\n  } else {\n    hotAPI.reload(\"data-v-7c8cda4e\", Component.options)\n  }\n  module.hot.dispose(function (data) {\n    disposed = true\n  })\n})()}\n\nexport default Component.exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/components/views/FAQs.vue\n// module id = 515\n// module chunks = 6 68"],"sourceRoot":""}