mkdocs-material/material/assets/javascripts/worker/search.0a5433f7.min.js.map

{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/tslib/tslib.es6.js","webpack:///./src/assets/javascripts/integrations/search/document/index.ts","webpack:///./src/assets/javascripts/integrations/search/_/index.ts","webpack:///./node_modules/escape-html/index.js","webpack:///./src/assets/javascripts/integrations/search/highlight/index.ts","webpack:///./node_modules/escape-string-regexp/index.js","webpack:///./node_modules/lunr/lunr.js","webpack:///./src/assets/javascripts/workers/search/message/index.ts","webpack:///./src/assets/javascripts/workers/search/main/index.ts"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","__assign","assign","arguments","length","apply","this","__values","iterator","next","done","__read","e","ar","push","error","__spread","concat","setupSearchDocumentMap","docs","documents","Map","doc","path","hash","location","title","text","replace","parent","linked","set","config","pipeline","index","highlight","lunr","trimmer","stopwords","reset","add","stopWordFilter","lang","use","multiLanguage","field","boost","ref","Index","load","JSON","parse","search","query","groups","reduce","results","result","document","map","sections","article","section","err","console","warn","toString","stringify","matchHtmlRegExp","string","escape","str","match","exec","html","lastIndex","charCodeAt","substring","setupSearchHighlighter","separator","RegExp","_","data","term","trim","matchOperatorsRegex","TypeError","global","step2list","step3list","v","C","re_mgr0","re_mgr1","re_meq1","re_s_v","re_1a","re2_1a","re_1b","re2_1b","re_1b_2","re2_1b_2","re3_1b_2","re4_1b_2","re_1c","re_2","re_3","re_4","re2_4","re_5","re_5_1","re3_5","porterStemmer","builder","Builder","stemmer","searchPipeline","build","version","utils","message","asString","obj","clone","keys","val","Array","isArray","slice","FieldRef","docRef","fieldName","stringValue","_stringValue","joiner","fromString","indexOf","fieldRef","undefined","Set","elements","complete","intersect","other","union","contains","empty","a","b","intersection","element","idf","posting","documentCount","documentsWithTerm","x","Math","log","abs","Token","metadata","update","fn","tokenizer","toLowerCase","len","tokens","sliceEnd","sliceStart","sliceLength","charAt","tokenMetadata","Pipeline","_stack","registeredFunctions","registerFunction","label","warnIfFunctionNotRegistered","serialised","forEach","fnName","Error","fns","after","existingFn","newFn","pos","splice","before","remove","run","stackLength","memo","j","k","runString","token","toJSON","Vector","_magnitude","positionForIndex","start","end","pivotPoint","floor","pivotIndex","insert","insertIdx","upsert","position","magnitude","sumOfSquares","elementsLength","sqrt","dot","otherVector","dotProduct","aLen","bLen","aVal","bVal","similarity","toArray","output","w","stem","suffix","firstch","re","re2","re3","re4","substr","toUpperCase","test","fp","generateStopWordFilter","stopWords","words","stopWord","TokenSet","final","edges","id","_nextId","fromArray","arr","finish","root","fromClause","clause","fromFuzzyString","editDistance","stack","node","editsRemaining","frame","pop","noEditNode","char","insertionNode","substitutionNode","transposeNode","charA","charB","prefix","edge","_str","labels","sort","qNode","qEdges","qLen","nEdges","nLen","q","qEdge","nEdge","previousWord","uncheckedNodes","minimizedNodes","word","commonPrefix","minimize","child","nextNode","downTo","childKey","attrs","invertedIndex","fieldVectors","tokenSet","fields","queryString","QueryParser","Query","matchingFields","queryVectors","termFieldCache","requiredMatches","prohibitedMatches","clauses","terms","clauseMatches","usePipeline","termTokenSet","expandedTerms","presence","REQUIRED","expandedTerm","termIndex","_index","fieldPosting","matchingDocumentRefs","termField","matchingDocumentsSet","PROHIBITED","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","extractor","fieldTerms","metadataKey","calculateAverageFieldLengths","fieldRefs","numberOfFields","accumulator","documentsWithField","averageFieldLength","createFieldVectors","fieldRefsLength","termIdfCache","fieldLength","termFrequencies","termsLength","fieldBoost","docBoost","scoreWithPrecision","tf","round","createTokenSet","args","unshift","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","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","SearchMessageType","handler","SETUP","base","scripts","self","importScripts","setupLunrLanguages","DUMP","QUERY","RESULT","addEventListener","ev","postMessage"],"mappings":"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A,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,SAGFxM,EAAKwI,SAASG,iBAAiB3I,EAAKK,eAAgB;;;;IAqBpDL,EAAKC,QAAU,SAAU+J,GACvB,OAAOA,EAAMnC,QAAO,SAAUjK,GAC5B,OAAOA,EAAE4B,QAAQ,OAAQ,IAAIA,QAAQ,OAAQ,QAIjDQ,EAAKwI,SAASG,iBAAiB3I,EAAKC,QAAS;;;;IA2B7CD,EAAK4M,SAAW,WACd1O,KAAK2O,OAAQ,EACb3O,KAAK4O,MAAQ,GACb5O,KAAK6O,GAAK/M,EAAK4M,SAASI,QACxBhN,EAAK4M,SAASI,SAAW,GAW3BhN,EAAK4M,SAASI,QAAU,EASxBhN,EAAK4M,SAASK,UAAY,SAAUC,GAGlC,IAFA,IAAIrI,EAAU,IAAI7E,EAAK4M,SAAS9H,QAEvBjJ,EAAI,EAAGoM,EAAMiF,EAAIlP,OAAQnC,EAAIoM,EAAKpM,IACzCgJ,EAAQ6F,OAAOwC,EAAIrR,IAIrB,OADAgJ,EAAQsI,SACDtI,EAAQuI,MAYjBpN,EAAK4M,SAASS,WAAa,SAAUC,GACnC,MAAI,iBAAkBA,EACbtN,EAAK4M,SAASW,gBAAgBD,EAAOvK,KAAMuK,EAAOE,cAElDxN,EAAK4M,SAASzG,WAAWmH,EAAOvK,OAmB3C/C,EAAK4M,SAASW,gBAAkB,SAAUpL,EAAKqL,GAS7C,IARA,IAAIJ,EAAO,IAAIpN,EAAK4M,SAEhBa,EAAQ,CAAC,CACXC,KAAMN,EACNO,eAAgBH,EAChBrL,IAAKA,IAGAsL,EAAMzP,QAAQ,CACnB,IAAI4P,EAAQH,EAAMI,MAGlB,GAAID,EAAMzL,IAAInE,OAAS,EAAG,CACxB,IACI8P,EADAC,EAAOH,EAAMzL,IAAImG,OAAO,GAGxByF,KAAQH,EAAMF,KAAKZ,MACrBgB,EAAaF,EAAMF,KAAKZ,MAAMiB,IAE9BD,EAAa,IAAI9N,EAAK4M,SACtBgB,EAAMF,KAAKZ,MAAMiB,GAAQD,GAGH,GAApBF,EAAMzL,IAAInE,SACZ8P,EAAWjB,OAAQ,GAGrBY,EAAM/O,KAAK,CACTgP,KAAMI,EACNH,eAAgBC,EAAMD,eACtBxL,IAAKyL,EAAMzL,IAAIyD,MAAM,KAIzB,GAA4B,GAAxBgI,EAAMD,eAAV,CAKA,GAAI,MAAOC,EAAMF,KAAKZ,MACpB,IAAIkB,EAAgBJ,EAAMF,KAAKZ,MAAM,SAChC,CACDkB,EAAgB,IAAIhO,EAAK4M,SAC7BgB,EAAMF,KAAKZ,MAAM,KAAOkB,EAiC1B,GA9BwB,GAApBJ,EAAMzL,IAAInE,SACZgQ,EAAcnB,OAAQ,GAGxBY,EAAM/O,KAAK,CACTgP,KAAMM,EACNL,eAAgBC,EAAMD,eAAiB,EACvCxL,IAAKyL,EAAMzL,MAMTyL,EAAMzL,IAAInE,OAAS,GACrByP,EAAM/O,KAAK,CACTgP,KAAME,EAAMF,KACZC,eAAgBC,EAAMD,eAAiB,EACvCxL,IAAKyL,EAAMzL,IAAIyD,MAAM,KAMD,GAApBgI,EAAMzL,IAAInE,SACZ4P,EAAMF,KAAKb,OAAQ,GAMjBe,EAAMzL,IAAInE,QAAU,EAAG,CACzB,GAAI,MAAO4P,EAAMF,KAAKZ,MACpB,IAAImB,EAAmBL,EAAMF,KAAKZ,MAAM,SACnC,CACDmB,EAAmB,IAAIjO,EAAK4M,SAChCgB,EAAMF,KAAKZ,MAAM,KAAOmB,EAGF,GAApBL,EAAMzL,IAAInE,SACZiQ,EAAiBpB,OAAQ,GAG3BY,EAAM/O,KAAK,CACTgP,KAAMO,EACNN,eAAgBC,EAAMD,eAAiB,EACvCxL,IAAKyL,EAAMzL,IAAIyD,MAAM,KAOzB,GAAIgI,EAAMzL,IAAInE,OAAS,EAAG,CACxB,IAEIkQ,EAFAC,EAAQP,EAAMzL,IAAImG,OAAO,GACzB8F,EAAQR,EAAMzL,IAAImG,OAAO,GAGzB8F,KAASR,EAAMF,KAAKZ,MACtBoB,EAAgBN,EAAMF,KAAKZ,MAAMsB,IAEjCF,EAAgB,IAAIlO,EAAK4M,SACzBgB,EAAMF,KAAKZ,MAAMsB,GAASF,GAGJ,GAApBN,EAAMzL,IAAInE,SACZkQ,EAAcrB,OAAQ,GAGxBY,EAAM/O,KAAK,CACTgP,KAAMQ,EACNP,eAAgBC,EAAMD,eAAiB,EACvCxL,IAAKgM,EAAQP,EAAMzL,IAAIyD,MAAM,OAKnC,OAAOwH,GAaTpN,EAAK4M,SAASzG,WAAa,SAAUhE,GAYnC,IAXA,IAAIuL,EAAO,IAAI1N,EAAK4M,SAChBQ,EAAOM,EAUF7R,EAAI,EAAGoM,EAAM9F,EAAInE,OAAQnC,EAAIoM,EAAKpM,IAAK,CAC9C,IAAIkS,EAAO5L,EAAItG,GACXgR,EAAShR,GAAKoM,EAAM,EAExB,GAAY,KAAR8F,EACFL,EAAKZ,MAAMiB,GAAQL,EACnBA,EAAKb,MAAQA,MAER,CACL,IAAIxO,EAAO,IAAI2B,EAAK4M,SACpBvO,EAAKwO,MAAQA,EAEba,EAAKZ,MAAMiB,GAAQ1P,EACnBqP,EAAOrP,GAIX,OAAO+O,GAaTpN,EAAK4M,SAASnP,UAAUiO,QAAU,WAQhC,IAPA,IAAIgB,EAAQ,GAERe,EAAQ,CAAC,CACXY,OAAQ,GACRX,KAAMxP,OAGDuP,EAAMzP,QAAQ,CACnB,IAAI4P,EAAQH,EAAMI,MACdf,EAAQvQ,OAAOiJ,KAAKoI,EAAMF,KAAKZ,OAC/B7E,EAAM6E,EAAM9O,OAEZ4P,EAAMF,KAAKb,QAKbe,EAAMS,OAAO/F,OAAO,GACpBoE,EAAMhO,KAAKkP,EAAMS,SAGnB,IAAK,IAAIxS,EAAI,EAAGA,EAAIoM,EAAKpM,IAAK,CAC5B,IAAIyS,EAAOxB,EAAMjR,GAEjB4R,EAAM/O,KAAK,CACT2P,OAAQT,EAAMS,OAAOxP,OAAOyP,GAC5BZ,KAAME,EAAMF,KAAKZ,MAAMwB,MAK7B,OAAO5B,GAaT1M,EAAK4M,SAASnP,UAAUqE,SAAW,WASjC,GAAI5D,KAAKqQ,KACP,OAAOrQ,KAAKqQ,KAOd,IAJA,IAAIpM,EAAMjE,KAAK2O,MAAQ,IAAM,IACzB2B,EAASjS,OAAOiJ,KAAKtH,KAAK4O,OAAO2B,OACjCxG,EAAMuG,EAAOxQ,OAERnC,EAAI,EAAGA,EAAIoM,EAAKpM,IAAK,CAC5B,IAAI+M,EAAQ4F,EAAO3S,GAGnBsG,EAAMA,EAAMyG,EAFD1K,KAAK4O,MAAMlE,GAEGmE,GAG3B,OAAO5K,GAaTnC,EAAK4M,SAASnP,UAAUiJ,UAAY,SAAUM,GAU5C,IATA,IAAI2E,EAAS,IAAI3L,EAAK4M,SAClBgB,OAAQtH,EAERmH,EAAQ,CAAC,CACXiB,MAAO1H,EACP2E,OAAQA,EACR+B,KAAMxP,OAGDuP,EAAMzP,QAAQ,CACnB4P,EAAQH,EAAMI,MAWd,IALA,IAAIc,EAASpS,OAAOiJ,KAAKoI,EAAMc,MAAM5B,OACjC8B,EAAOD,EAAO3Q,OACd6Q,EAAStS,OAAOiJ,KAAKoI,EAAMF,KAAKZ,OAChCgC,EAAOD,EAAO7Q,OAET+Q,EAAI,EAAGA,EAAIH,EAAMG,IAGxB,IAFA,IAAIC,EAAQL,EAAOI,GAEVzR,EAAI,EAAGA,EAAIwR,EAAMxR,IAAK,CAC7B,IAAI2R,EAAQJ,EAAOvR,GAEnB,GAAI2R,GAASD,GAAkB,KAATA,EAAc,CAClC,IAAItB,EAAOE,EAAMF,KAAKZ,MAAMmC,GACxBP,EAAQd,EAAMc,MAAM5B,MAAMkC,GAC1BnC,EAAQa,EAAKb,OAAS6B,EAAM7B,MAC5BxO,OAAOiI,EAEP2I,KAASrB,EAAMjC,OAAOmB,OAIxBzO,EAAOuP,EAAMjC,OAAOmB,MAAMmC,IACrBpC,MAAQxO,EAAKwO,OAASA,IAM3BxO,EAAO,IAAI2B,EAAK4M,UACXC,MAAQA,EACbe,EAAMjC,OAAOmB,MAAMmC,GAAS5Q,GAG9BoP,EAAM/O,KAAK,CACTgQ,MAAOA,EACP/C,OAAQtN,EACRqP,KAAMA,MAOhB,OAAO/B,GAET3L,EAAK4M,SAAS9H,QAAU,WACtB5G,KAAKgR,aAAe,GACpBhR,KAAKkP,KAAO,IAAIpN,EAAK4M,SACrB1O,KAAKiR,eAAiB,GACtBjR,KAAKkR,eAAiB,IAGxBpP,EAAK4M,SAAS9H,QAAQrH,UAAUiN,OAAS,SAAU2E,GACjD,IAAI3B,EACA4B,EAAe,EAEnB,GAAID,EAAOnR,KAAKgR,aACd,MAAM,IAAIjG,MAAO,+BAGnB,IAAK,IAAIpN,EAAI,EAAGA,EAAIwT,EAAKrR,QAAUnC,EAAIqC,KAAKgR,aAAalR,QACnDqR,EAAKxT,IAAMqC,KAAKgR,aAAarT,GAD8BA,IAE/DyT,IAGFpR,KAAKqR,SAASD,GAGZ5B,EADgC,GAA9BxP,KAAKiR,eAAenR,OACfE,KAAKkP,KAELlP,KAAKiR,eAAejR,KAAKiR,eAAenR,OAAS,GAAGwR,MAG7D,IAAS3T,EAAIyT,EAAczT,EAAIwT,EAAKrR,OAAQnC,IAAK,CAC/C,IAAI4T,EAAW,IAAIzP,EAAK4M,SACpBmB,EAAOsB,EAAKxT,GAEhB6R,EAAKZ,MAAMiB,GAAQ0B,EAEnBvR,KAAKiR,eAAezQ,KAAK,CACvBe,OAAQiO,EACRK,KAAMA,EACNyB,MAAOC,IAGT/B,EAAO+B,EAGT/B,EAAKb,OAAQ,EACb3O,KAAKgR,aAAeG,GAGtBrP,EAAK4M,SAAS9H,QAAQrH,UAAU0P,OAAS,WACvCjP,KAAKqR,SAAS,IAGhBvP,EAAK4M,SAAS9H,QAAQrH,UAAU8R,SAAW,SAAUG,GACnD,IAAK,IAAI7T,EAAIqC,KAAKiR,eAAenR,OAAS,EAAGnC,GAAK6T,EAAQ7T,IAAK,CAC7D,IAAI6R,EAAOxP,KAAKiR,eAAetT,GAC3B8T,EAAWjC,EAAK8B,MAAM1N,WAEtB6N,KAAYzR,KAAKkR,eACnB1B,EAAKjO,OAAOqN,MAAMY,EAAKK,MAAQ7P,KAAKkR,eAAeO,IAInDjC,EAAK8B,MAAMjB,KAAOoB,EAElBzR,KAAKkR,eAAeO,GAAYjC,EAAK8B,OAGvCtR,KAAKiR,eAAetB;;;;IAwBxB7N,EAAKY,MAAQ,SAAUgP,GACrB1R,KAAK2R,cAAgBD,EAAMC,cAC3B3R,KAAK4R,aAAeF,EAAME,aAC1B5R,KAAK6R,SAAWH,EAAMG,SACtB7R,KAAK8R,OAASJ,EAAMI,OACpB9R,KAAK2B,SAAW+P,EAAM/P,UA0ExBG,EAAKY,MAAMnD,UAAUuD,OAAS,SAAUiP,GACtC,OAAO/R,KAAK+C,OAAM,SAAUA,GACb,IAAIjB,EAAKkQ,YAAYD,EAAahP,GACxCF,YA6BXf,EAAKY,MAAMnD,UAAUwD,MAAQ,SAAU6G,GAoBrC,IAZA,IAAI7G,EAAQ,IAAIjB,EAAKmQ,MAAMjS,KAAK8R,QAC5BI,EAAiB7T,OAAOY,OAAO,MAC/BkT,EAAe9T,OAAOY,OAAO,MAC7BmT,EAAiB/T,OAAOY,OAAO,MAC/BoT,EAAkBhU,OAAOY,OAAO,MAChCqT,EAAoBjU,OAAOY,OAAO,MAO7BtB,EAAI,EAAGA,EAAIqC,KAAK8R,OAAOhS,OAAQnC,IACtCwU,EAAanS,KAAK8R,OAAOnU,IAAM,IAAImE,EAAKkK,OAG1CpC,EAAG9L,KAAKiF,EAAOA,GAEf,IAASpF,EAAI,EAAGA,EAAIoF,EAAMwP,QAAQzS,OAAQnC,IAAK,CAS7C,IAAIyR,EAASrM,EAAMwP,QAAQ5U,GACvB6U,EAAQ,KACRC,EAAgB3Q,EAAKuG,IAAIE,SAG3BiK,EADEpD,EAAOsD,YACD1S,KAAK2B,SAASkK,UAAUuD,EAAOvK,KAAM,CAC3CiN,OAAQ1C,EAAO0C,SAGT,CAAC1C,EAAOvK,MAGlB,IAAK,IAAI9G,EAAI,EAAGA,EAAIyU,EAAM1S,OAAQ/B,IAAK,CACrC,IAAI8G,EAAO2N,EAAMzU,GAQjBqR,EAAOvK,KAAOA,EAOd,IAAI8N,EAAe7Q,EAAK4M,SAASS,WAAWC,GACxCwD,EAAgB5S,KAAK6R,SAASrJ,UAAUmK,GAAcnF,UAQ1D,GAA6B,IAAzBoF,EAAc9S,QAAgBsP,EAAOyD,WAAa/Q,EAAKmQ,MAAMY,SAASC,SAAU,CAClF,IAAK,IAAIlH,EAAI,EAAGA,EAAIwD,EAAO0C,OAAOhS,OAAQ8L,IAAK,CAE7CyG,EADI9P,EAAQ6M,EAAO0C,OAAOlG,IACD9J,EAAKuG,IAAIO,MAGpC,MAGF,IAAK,IAAI+C,EAAI,EAAGA,EAAIiH,EAAc9S,OAAQ6L,IAKxC,KAAIoH,EAAeH,EAAcjH,GAC7BzC,EAAUlJ,KAAK2R,cAAcoB,GAC7BC,EAAY9J,EAAQ+J,OAExB,IAASrH,EAAI,EAAGA,EAAIwD,EAAO0C,OAAOhS,OAAQ8L,IAAK,CAS7C,IACIsH,EAAehK,EADf3G,EAAQ6M,EAAO0C,OAAOlG,IAEtBuH,EAAuB9U,OAAOiJ,KAAK4L,GACnCE,EAAYL,EAAe,IAAMxQ,EACjC8Q,EAAuB,IAAIvR,EAAKuG,IAAI8K,GAoBxC,GAbI/D,EAAOyD,UAAY/Q,EAAKmQ,MAAMY,SAASC,WACzCL,EAAgBA,EAAc/J,MAAM2K,QAELjL,IAA3BiK,EAAgB9P,KAClB8P,EAAgB9P,GAAST,EAAKuG,IAAIE,WASlC6G,EAAOyD,UAAY/Q,EAAKmQ,MAAMY,SAASS,YA4B3C,GANAnB,EAAa5P,GAAOmK,OAAOsG,EAAW5D,EAAO5M,OAAO,SAAUqG,EAAGC,GAAK,OAAOD,EAAIC,MAM7EsJ,EAAegB,GAAnB,CAIA,IAAK,IAAIxV,EAAI,EAAGA,EAAIuV,EAAqBrT,OAAQlC,IAAK,CAOpD,IAGI2V,EAHAC,EAAsBL,EAAqBvV,GAC3C6V,EAAmB,IAAI3R,EAAK6F,SAAU6L,EAAqBjR,GAC3DmH,EAAWwJ,EAAaM,QAG4BpL,KAAnDmL,EAAarB,EAAeuB,IAC/BvB,EAAeuB,GAAoB,IAAI3R,EAAK4R,UAAWX,EAAcxQ,EAAOmH,GAE5E6J,EAAWrR,IAAI6Q,EAAcxQ,EAAOmH,GAKxC0I,EAAegB,IAAa,aAnDOhL,IAA7BkK,EAAkB/P,KACpB+P,EAAkB/P,GAAST,EAAKuG,IAAIO,OAGtC0J,EAAkB/P,GAAS+P,EAAkB/P,GAAOmG,MAAM2K,KA0DlE,GAAIjE,EAAOyD,WAAa/Q,EAAKmQ,MAAMY,SAASC,SAC1C,IAASlH,EAAI,EAAGA,EAAIwD,EAAO0C,OAAOhS,OAAQ8L,IAAK,CAE7CyG,EADI9P,EAAQ6M,EAAO0C,OAAOlG,IACDyG,EAAgB9P,GAAOiG,UAAUiK,IAUhE,IAAIkB,EAAqB7R,EAAKuG,IAAIE,SAC9BqL,EAAuB9R,EAAKuG,IAAIO,MAEpC,IAASjL,EAAI,EAAGA,EAAIqC,KAAK8R,OAAOhS,OAAQnC,IAAK,CAC3C,IAAI4E,EAEA8P,EAFA9P,EAAQvC,KAAK8R,OAAOnU,MAGtBgW,EAAqBA,EAAmBnL,UAAU6J,EAAgB9P,KAGhE+P,EAAkB/P,KACpBqR,EAAuBA,EAAqBlL,MAAM4J,EAAkB/P,KAIxE,IAAIsR,EAAoBxV,OAAOiJ,KAAK4K,GAChChP,EAAU,GACV4Q,EAAUzV,OAAOY,OAAO,MAY5B,GAAI8D,EAAMgR,YAAa,CACrBF,EAAoBxV,OAAOiJ,KAAKtH,KAAK4R,cAErC,IAASjU,EAAI,EAAGA,EAAIkW,EAAkB/T,OAAQnC,IAAK,CAC7C8V,EAAmBI,EAAkBlW,GAAzC,IACIwK,EAAWrG,EAAK6F,SAASM,WAAWwL,GACxCvB,EAAeuB,GAAoB,IAAI3R,EAAK4R,WAIhD,IAAS/V,EAAI,EAAGA,EAAIkW,EAAkB/T,OAAQnC,IAAK,CASjD,IACIiK,GADAO,EAAWrG,EAAK6F,SAASM,WAAW4L,EAAkBlW,KACpCiK,OAEtB,GAAK+L,EAAmBhL,SAASf,KAI7BgM,EAAqBjL,SAASf,GAAlC,CAIA,IAEIoM,EAFAC,EAAcjU,KAAK4R,aAAazJ,GAChC+L,EAAQ/B,EAAahK,EAASN,WAAW0F,WAAW0G,GAGxD,QAAqC7L,KAAhC4L,EAAWF,EAAQlM,IACtBoM,EAASE,OAASA,EAClBF,EAASG,UAAUC,QAAQlC,EAAe/J,QACrC,CACL,IAAIjE,EAAQ,CACVzB,IAAKmF,EACLsM,MAAOA,EACPC,UAAWjC,EAAe/J,IAE5B2L,EAAQlM,GAAU1D,EAClBhB,EAAQ1C,KAAK0D,KAOjB,OAAOhB,EAAQqN,MAAK,SAAU1H,EAAGC,GAC/B,OAAOA,EAAEoL,MAAQrL,EAAEqL,UAYvBpS,EAAKY,MAAMnD,UAAUwM,OAAS,WAC5B,IAAI4F,EAAgBtT,OAAOiJ,KAAKtH,KAAK2R,eAClCpB,OACAlN,KAAI,SAAUwB,GACb,MAAO,CAACA,EAAM7E,KAAK2R,cAAc9M,MAChC7E,MAED4R,EAAevT,OAAOiJ,KAAKtH,KAAK4R,cACjCvO,KAAI,SAAUZ,GACb,MAAO,CAACA,EAAKzC,KAAK4R,aAAanP,GAAKsJ,YACnC/L,MAEL,MAAO,CACLgH,QAASlF,EAAKkF,QACd8K,OAAQ9R,KAAK8R,OACbF,aAAcA,EACdD,cAAeA,EACfhQ,SAAU3B,KAAK2B,SAASoK,WAU5BjK,EAAKY,MAAMC,KAAO,SAAU0R,GAC1B,IAAI3C,EAAQ,GACRE,EAAe,GACf0C,EAAoBD,EAAgBzC,aACpCD,EAAgBtT,OAAOY,OAAO,MAC9BsV,EAA0BF,EAAgB1C,cAC1C6C,EAAkB,IAAI1S,EAAK4M,SAAS9H,QACpCjF,EAAWG,EAAKwI,SAAS3H,KAAK0R,EAAgB1S,UAE9C0S,EAAgBrN,SAAWlF,EAAKkF,SAClClF,EAAKmF,MAAMtD,KAAK,4EAA8E7B,EAAKkF,QAAU,sCAAwCqN,EAAgBrN,QAAU,KAGjL,IAAK,IAAIrJ,EAAI,EAAGA,EAAI2W,EAAkBxU,OAAQnC,IAAK,CACjD,IACI8E,GADAgS,EAAQH,EAAkB3W,IACd,GACZ2K,EAAWmM,EAAM,GAErB7C,EAAanP,GAAO,IAAIX,EAAKkK,OAAO1D,GAGtC,IAAS3K,EAAI,EAAGA,EAAI4W,EAAwBzU,OAAQnC,IAAK,CACvD,IAAI8W,EACA5P,GADA4P,EAAQF,EAAwB5W,IACnB,GACbuL,EAAUuL,EAAM,GAEpBD,EAAgBhI,OAAO3H,GACvB8M,EAAc9M,GAAQqE,EAYxB,OATAsL,EAAgBvF,SAEhByC,EAAMI,OAASuC,EAAgBvC,OAE/BJ,EAAME,aAAeA,EACrBF,EAAMC,cAAgBA,EACtBD,EAAMG,SAAW2C,EAAgBtF,KACjCwC,EAAM/P,SAAWA,EAEV,IAAIG,EAAKY,MAAMgP;;;;IA+BxB5P,EAAK8E,QAAU,WACb5G,KAAK0U,KAAO,KACZ1U,KAAK2U,QAAUtW,OAAOY,OAAO,MAC7Be,KAAK4U,WAAavW,OAAOY,OAAO,MAChCe,KAAK2R,cAAgBtT,OAAOY,OAAO,MACnCe,KAAK6U,qBAAuB,GAC5B7U,KAAK8U,aAAe,GACpB9U,KAAK6J,UAAY/H,EAAK+H,UACtB7J,KAAK2B,SAAW,IAAIG,EAAKwI,SACzBtK,KAAK8G,eAAiB,IAAIhF,EAAKwI,SAC/BtK,KAAKmJ,cAAgB,EACrBnJ,KAAK+U,GAAK,IACV/U,KAAKgV,IAAM,IACXhV,KAAKgT,UAAY,EACjBhT,KAAKiV,kBAAoB,IAe3BnT,EAAK8E,QAAQrH,UAAUkD,IAAM,SAAUA,GACrCzC,KAAK0U,KAAOjS,GAmCdX,EAAK8E,QAAQrH,UAAUgD,MAAQ,SAAUsF,EAAWqN,GAClD,GAAI,KAAK9G,KAAKvG,GACZ,MAAM,IAAIsN,WAAY,UAAYtN,EAAY,oCAGhD7H,KAAK2U,QAAQ9M,GAAaqN,GAAc,IAW1CpT,EAAK8E,QAAQrH,UAAUuJ,EAAI,SAAUsM,GAEjCpV,KAAK+U,GADHK,EAAS,EACD,EACDA,EAAS,EACR,EAEAA,GAWdtT,EAAK8E,QAAQrH,UAAU8V,GAAK,SAAUD,GACpCpV,KAAKgV,IAAMI,GAoBbtT,EAAK8E,QAAQrH,UAAU2C,IAAM,SAAUlB,EAAKkU,GAC1C,IAAItN,EAAS5G,EAAIhB,KAAK0U,MAClB5C,EAASzT,OAAOiJ,KAAKtH,KAAK2U,SAE9B3U,KAAK4U,WAAWhN,GAAUsN,GAAc,GACxClV,KAAKmJ,eAAiB,EAEtB,IAAK,IAAIxL,EAAI,EAAGA,EAAImU,EAAOhS,OAAQnC,IAAK,CACtC,IAAIkK,EAAYiK,EAAOnU,GACnB2X,EAAYtV,KAAK2U,QAAQ9M,GAAWyN,UACpC/S,EAAQ+S,EAAYA,EAAUtU,GAAOA,EAAI6G,GACzCmC,EAAShK,KAAK6J,UAAUtH,EAAO,CAC7BuP,OAAQ,CAACjK,KAEX2K,EAAQxS,KAAK2B,SAAS6J,IAAIxB,GAC1B7B,EAAW,IAAIrG,EAAK6F,SAAUC,EAAQC,GACtC0N,EAAalX,OAAOY,OAAO,MAE/Be,KAAK6U,qBAAqB1M,GAAYoN,EACtCvV,KAAK8U,aAAa3M,GAAY,EAG9BnI,KAAK8U,aAAa3M,IAAaqK,EAAM1S,OAGrC,IAAK,IAAI6L,EAAI,EAAGA,EAAI6G,EAAM1S,OAAQ6L,IAAK,CACrC,IAAI9G,EAAO2N,EAAM7G,GAUjB,GARwBvD,MAApBmN,EAAW1Q,KACb0Q,EAAW1Q,GAAQ,GAGrB0Q,EAAW1Q,IAAS,EAIYuD,MAA5BpI,KAAK2R,cAAc9M,GAAoB,CACzC,IAAIqE,EAAU7K,OAAOY,OAAO,MAC5BiK,EAAgB,OAAIlJ,KAAKgT,UACzBhT,KAAKgT,WAAa,EAElB,IAAK,IAAIpH,EAAI,EAAGA,EAAIkG,EAAOhS,OAAQ8L,IACjC1C,EAAQ4I,EAAOlG,IAAMvN,OAAOY,OAAO,MAGrCe,KAAK2R,cAAc9M,GAAQqE,EAIsBd,MAA/CpI,KAAK2R,cAAc9M,GAAMgD,GAAWD,KACtC5H,KAAK2R,cAAc9M,GAAMgD,GAAWD,GAAUvJ,OAAOY,OAAO,OAK9D,IAAK,IAAIrB,EAAI,EAAGA,EAAIoC,KAAKiV,kBAAkBnV,OAAQlC,IAAK,CACtD,IAAI4X,EAAcxV,KAAKiV,kBAAkBrX,GACrC8L,EAAW7E,EAAK6E,SAAS8L,GAEmCpN,MAA5DpI,KAAK2R,cAAc9M,GAAMgD,GAAWD,GAAQ4N,KAC9CxV,KAAK2R,cAAc9M,GAAMgD,GAAWD,GAAQ4N,GAAe,IAG7DxV,KAAK2R,cAAc9M,GAAMgD,GAAWD,GAAQ4N,GAAahV,KAAKkJ,OAYtE5H,EAAK8E,QAAQrH,UAAUkW,6BAA+B,WAOpD,IALA,IAAIC,EAAYrX,OAAOiJ,KAAKtH,KAAK8U,cAC7Ba,EAAiBD,EAAU5V,OAC3B8V,EAAc,GACdC,EAAqB,GAEhBlY,EAAI,EAAGA,EAAIgY,EAAgBhY,IAAK,CACvC,IAAIwK,EAAWrG,EAAK6F,SAASM,WAAWyN,EAAU/X,IAC9C4E,EAAQ4F,EAASN,UAErBgO,EAAmBtT,KAAWsT,EAAmBtT,GAAS,GAC1DsT,EAAmBtT,IAAU,EAE7BqT,EAAYrT,KAAWqT,EAAYrT,GAAS,GAC5CqT,EAAYrT,IAAUvC,KAAK8U,aAAa3M,GAG1C,IAAI2J,EAASzT,OAAOiJ,KAAKtH,KAAK2U,SAE9B,IAAShX,EAAI,EAAGA,EAAImU,EAAOhS,OAAQnC,IAAK,CACtC,IAAIkK,EAAYiK,EAAOnU,GACvBiY,EAAY/N,GAAa+N,EAAY/N,GAAagO,EAAmBhO,GAGvE7H,KAAK8V,mBAAqBF,GAQ5B9T,EAAK8E,QAAQrH,UAAUwW,mBAAqB,WAM1C,IALA,IAAInE,EAAe,GACf8D,EAAYrX,OAAOiJ,KAAKtH,KAAK6U,sBAC7BmB,EAAkBN,EAAU5V,OAC5BmW,EAAe5X,OAAOY,OAAO,MAExBtB,EAAI,EAAGA,EAAIqY,EAAiBrY,IAAK,CAaxC,IAZA,IAAIwK,EAAWrG,EAAK6F,SAASM,WAAWyN,EAAU/X,IAC9CkK,EAAYM,EAASN,UACrBqO,EAAclW,KAAK8U,aAAa3M,GAChC8L,EAAc,IAAInS,EAAKkK,OACvBmK,EAAkBnW,KAAK6U,qBAAqB1M,GAC5CqK,EAAQnU,OAAOiJ,KAAK6O,GACpBC,EAAc5D,EAAM1S,OAGpBuW,EAAarW,KAAK2U,QAAQ9M,GAAWrF,OAAS,EAC9C8T,EAAWtW,KAAK4U,WAAWzM,EAASP,QAAQpF,OAAS,EAEhDmJ,EAAI,EAAGA,EAAIyK,EAAazK,IAAK,CACpC,IAGI1C,EAAKiL,EAAOqC,EAHZ1R,EAAO2N,EAAM7G,GACb6K,EAAKL,EAAgBtR,GACrBmO,EAAYhT,KAAK2R,cAAc9M,GAAMoO,YAGd7K,IAAvB6N,EAAapR,IACfoE,EAAMnH,EAAKmH,IAAIjJ,KAAK2R,cAAc9M,GAAO7E,KAAKmJ,eAC9C8M,EAAapR,GAAQoE,GAErBA,EAAMgN,EAAapR,GAGrBqP,EAAQjL,IAAQjJ,KAAKgV,IAAM,GAAKwB,IAAOxW,KAAKgV,KAAO,EAAIhV,KAAK+U,GAAK/U,KAAK+U,IAAMmB,EAAclW,KAAK8V,mBAAmBjO,KAAe2O,GACjItC,GAASmC,EACTnC,GAASoC,EACTC,EAAqBjN,KAAKmN,MAAc,IAARvC,GAAgB,IAQhDD,EAAYzH,OAAOwG,EAAWuD,GAGhC3E,EAAazJ,GAAY8L,EAG3BjU,KAAK4R,aAAeA,GAQtB9P,EAAK8E,QAAQrH,UAAUmX,eAAiB,WACtC1W,KAAK6R,SAAW/P,EAAK4M,SAASK,UAC5B1Q,OAAOiJ,KAAKtH,KAAK2R,eAAepB,SAYpCzO,EAAK8E,QAAQrH,UAAUwH,MAAQ,WAK7B,OAJA/G,KAAKyV,+BACLzV,KAAK+V,qBACL/V,KAAK0W,iBAEE,IAAI5U,EAAKY,MAAM,CACpBiP,cAAe3R,KAAK2R,cACpBC,aAAc5R,KAAK4R,aACnBC,SAAU7R,KAAK6R,SACfC,OAAQzT,OAAOiJ,KAAKtH,KAAK2U,SACzBhT,SAAU3B,KAAK8G,kBAkBnBhF,EAAK8E,QAAQrH,UAAU8C,IAAM,SAAUuH,GACrC,IAAI+M,EAAOnP,MAAMjI,UAAUmI,MAAM5J,KAAK+B,UAAW,GACjD8W,EAAKC,QAAQ5W,MACb4J,EAAG7J,MAAMC,KAAM2W,IAcjB7U,EAAK4R,UAAY,SAAU7O,EAAMtC,EAAOmH,GAStC,IARA,IAAImN,EAAiBxY,OAAOY,OAAO,MAC/B6X,EAAezY,OAAOiJ,KAAKoC,GAAY,IAOlC/L,EAAI,EAAGA,EAAImZ,EAAahX,OAAQnC,IAAK,CAC5C,IAAIuB,EAAM4X,EAAanZ,GACvBkZ,EAAe3X,GAAOwK,EAASxK,GAAKwI,QAGtC1H,KAAK0J,SAAWrL,OAAOY,OAAO,WAEjBmJ,IAATvD,IACF7E,KAAK0J,SAAS7E,GAAQxG,OAAOY,OAAO,MACpCe,KAAK0J,SAAS7E,GAAMtC,GAASsU,IAajC/U,EAAK4R,UAAUnU,UAAU6U,QAAU,SAAU2C,GAG3C,IAFA,IAAIvE,EAAQnU,OAAOiJ,KAAKyP,EAAerN,UAE9B/L,EAAI,EAAGA,EAAI6U,EAAM1S,OAAQnC,IAAK,CACrC,IAAIkH,EAAO2N,EAAM7U,GACbmU,EAASzT,OAAOiJ,KAAKyP,EAAerN,SAAS7E,IAEtBuD,MAAvBpI,KAAK0J,SAAS7E,KAChB7E,KAAK0J,SAAS7E,GAAQxG,OAAOY,OAAO,OAGtC,IAAK,IAAI0M,EAAI,EAAGA,EAAImG,EAAOhS,OAAQ6L,IAAK,CACtC,IAAIpJ,EAAQuP,EAAOnG,GACfrE,EAAOjJ,OAAOiJ,KAAKyP,EAAerN,SAAS7E,GAAMtC,IAEnB6F,MAA9BpI,KAAK0J,SAAS7E,GAAMtC,KACtBvC,KAAK0J,SAAS7E,GAAMtC,GAASlE,OAAOY,OAAO,OAG7C,IAAK,IAAI2M,EAAI,EAAGA,EAAItE,EAAKxH,OAAQ8L,IAAK,CACpC,IAAI1M,EAAMoI,EAAKsE,GAEwBxD,MAAnCpI,KAAK0J,SAAS7E,GAAMtC,GAAOrD,GAC7Bc,KAAK0J,SAAS7E,GAAMtC,GAAOrD,GAAO6X,EAAerN,SAAS7E,GAAMtC,GAAOrD,GAEvEc,KAAK0J,SAAS7E,GAAMtC,GAAOrD,GAAOc,KAAK0J,SAAS7E,GAAMtC,GAAOrD,GAAKyB,OAAOoW,EAAerN,SAAS7E,GAAMtC,GAAOrD,QAexH4C,EAAK4R,UAAUnU,UAAU2C,IAAM,SAAU2C,EAAMtC,EAAOmH,GACpD,KAAM7E,KAAQ7E,KAAK0J,UAGjB,OAFA1J,KAAK0J,SAAS7E,GAAQxG,OAAOY,OAAO,WACpCe,KAAK0J,SAAS7E,GAAMtC,GAASmH,GAI/B,GAAMnH,KAASvC,KAAK0J,SAAS7E,GAO7B,IAFA,IAAIiS,EAAezY,OAAOiJ,KAAKoC,GAEtB/L,EAAI,EAAGA,EAAImZ,EAAahX,OAAQnC,IAAK,CAC5C,IAAIuB,EAAM4X,EAAanZ,GAEnBuB,KAAOc,KAAK0J,SAAS7E,GAAMtC,GAC7BvC,KAAK0J,SAAS7E,GAAMtC,GAAOrD,GAAOc,KAAK0J,SAAS7E,GAAMtC,GAAOrD,GAAKyB,OAAO+I,EAASxK,IAElFc,KAAK0J,SAAS7E,GAAMtC,GAAOrD,GAAOwK,EAASxK,QAZ7Cc,KAAK0J,SAAS7E,GAAMtC,GAASmH,GA2BjC5H,EAAKmQ,MAAQ,SAAU+E,GACrBhX,KAAKuS,QAAU,GACfvS,KAAKgX,UAAYA,GA2BnBlV,EAAKmQ,MAAMgF,SAAW,IAAIC,OAAQ,KAClCpV,EAAKmQ,MAAMgF,SAASE,KAAO,EAC3BrV,EAAKmQ,MAAMgF,SAASG,QAAU,EAC9BtV,EAAKmQ,MAAMgF,SAASI,SAAW,EAa/BvV,EAAKmQ,MAAMY,SAAW,CAIpByE,SAAU,EAMVxE,SAAU,EAMVQ,WAAY,GA0BdxR,EAAKmQ,MAAM1S,UAAU6P,OAAS,SAAUA,GA+BtC,MA9BM,WAAYA,IAChBA,EAAO0C,OAAS9R,KAAKgX,WAGjB,UAAW5H,IACfA,EAAO5M,MAAQ,GAGX,gBAAiB4M,IACrBA,EAAOsD,aAAc,GAGjB,aAActD,IAClBA,EAAO6H,SAAWnV,EAAKmQ,MAAMgF,SAASE,MAGnC/H,EAAO6H,SAAWnV,EAAKmQ,MAAMgF,SAASG,SAAahI,EAAOvK,KAAKuF,OAAO,IAAMtI,EAAKmQ,MAAMgF,WAC1F7H,EAAOvK,KAAO,IAAMuK,EAAOvK,MAGxBuK,EAAO6H,SAAWnV,EAAKmQ,MAAMgF,SAASI,UAAcjI,EAAOvK,KAAK6C,OAAO,IAAM5F,EAAKmQ,MAAMgF,WAC3F7H,EAAOvK,KAAYuK,EAAOvK,KAAO,KAG7B,aAAcuK,IAClBA,EAAOyD,SAAW/Q,EAAKmQ,MAAMY,SAASyE,UAGxCtX,KAAKuS,QAAQ/R,KAAK4O,GAEXpP,MAUT8B,EAAKmQ,MAAM1S,UAAUwU,UAAY,WAC/B,IAAK,IAAIpW,EAAI,EAAGA,EAAIqC,KAAKuS,QAAQzS,OAAQnC,IACvC,GAAIqC,KAAKuS,QAAQ5U,GAAGkV,UAAY/Q,EAAKmQ,MAAMY,SAASS,WAClD,OAAO,EAIX,OAAO,GA6BTxR,EAAKmQ,MAAM1S,UAAUsF,KAAO,SAAUA,EAAM0S,GAC1C,GAAI/P,MAAMC,QAAQ5C,GAEhB,OADAA,EAAKgG,SAAQ,SAAUhM,GAAKmB,KAAK6E,KAAKhG,EAAGiD,EAAKmF,MAAMI,MAAMkQ,MAAavX,MAChEA,KAGT,IAAIoP,EAASmI,GAAW,GAKxB,OAJAnI,EAAOvK,KAAOA,EAAKjB,WAEnB5D,KAAKoP,OAAOA,GAELpP,MAET8B,EAAK0V,gBAAkB,SAAUtQ,EAASiF,EAAOC,GAC/CpM,KAAK9B,KAAO,kBACZ8B,KAAKkH,QAAUA,EACflH,KAAKmM,MAAQA,EACbnM,KAAKoM,IAAMA,GAGbtK,EAAK0V,gBAAgBjY,UAAY,IAAIwL,MACrCjJ,EAAK2V,WAAa,SAAUxT,GAC1BjE,KAAK0X,QAAU,GACf1X,KAAKiE,IAAMA,EACXjE,KAAKF,OAASmE,EAAInE,OAClBE,KAAKoL,IAAM,EACXpL,KAAKmM,MAAQ,EACbnM,KAAK2X,oBAAsB,IAG7B7V,EAAK2V,WAAWlY,UAAUiM,IAAM,WAG9B,IAFA,IAAIoM,EAAQ9V,EAAK2V,WAAWI,QAErBD,GACLA,EAAQA,EAAM5X,OAIlB8B,EAAK2V,WAAWlY,UAAUuY,YAAc,WAKtC,IAJA,IAAIC,EAAY,GACZ7N,EAAalK,KAAKmM,MAClBlC,EAAWjK,KAAKoL,IAEXzN,EAAI,EAAGA,EAAIqC,KAAK2X,oBAAoB7X,OAAQnC,IACnDsM,EAAWjK,KAAK2X,oBAAoBha,GACpCoa,EAAUvX,KAAKR,KAAKiE,IAAIyD,MAAMwC,EAAYD,IAC1CC,EAAaD,EAAW,EAM1B,OAHA8N,EAAUvX,KAAKR,KAAKiE,IAAIyD,MAAMwC,EAAYlK,KAAKoL,MAC/CpL,KAAK2X,oBAAoB7X,OAAS,EAE3BiY,EAAUC,KAAK,KAGxBlW,EAAK2V,WAAWlY,UAAU0Y,KAAO,SAAUC,GACzClY,KAAK0X,QAAQlX,KAAK,CAChB0X,KAAMA,EACNjU,IAAKjE,KAAK8X,cACV3L,MAAOnM,KAAKmM,MACZC,IAAKpM,KAAKoL,MAGZpL,KAAKmM,MAAQnM,KAAKoL,KAGpBtJ,EAAK2V,WAAWlY,UAAU4Y,gBAAkB,WAC1CnY,KAAK2X,oBAAoBnX,KAAKR,KAAKoL,IAAM,GACzCpL,KAAKoL,KAAO,GAGdtJ,EAAK2V,WAAWlY,UAAUY,KAAO,WAC/B,GAAIH,KAAKoL,KAAOpL,KAAKF,OACnB,OAAOgC,EAAK2V,WAAWW,IAGzB,IAAIvI,EAAO7P,KAAKiE,IAAImG,OAAOpK,KAAKoL,KAEhC,OADApL,KAAKoL,KAAO,EACLyE,GAGT/N,EAAK2V,WAAWlY,UAAU8Y,MAAQ,WAChC,OAAOrY,KAAKoL,IAAMpL,KAAKmM,OAGzBrK,EAAK2V,WAAWlY,UAAU+Y,OAAS,WAC7BtY,KAAKmM,OAASnM,KAAKoL,MACrBpL,KAAKoL,KAAO,GAGdpL,KAAKmM,MAAQnM,KAAKoL,KAGpBtJ,EAAK2V,WAAWlY,UAAUgZ,OAAS,WACjCvY,KAAKoL,KAAO,GAGdtJ,EAAK2V,WAAWlY,UAAUiZ,eAAiB,WACzC,IAAI3I,EAAM4I,EAEV,GAEEA,GADA5I,EAAO7P,KAAKG,QACImE,WAAW,SACpBmU,EAAW,IAAMA,EAAW,IAEjC5I,GAAQ/N,EAAK2V,WAAWW,KAC1BpY,KAAKuY,UAITzW,EAAK2V,WAAWlY,UAAUmZ,KAAO,WAC/B,OAAO1Y,KAAKoL,IAAMpL,KAAKF,QAGzBgC,EAAK2V,WAAWW,IAAM,MACtBtW,EAAK2V,WAAWkB,MAAQ,QACxB7W,EAAK2V,WAAWmB,KAAO,OACvB9W,EAAK2V,WAAWoB,cAAgB,gBAChC/W,EAAK2V,WAAWqB,MAAQ,QACxBhX,EAAK2V,WAAWsB,SAAW,WAE3BjX,EAAK2V,WAAWuB,SAAW,SAAUC,GAInC,OAHAA,EAAMV,SACNU,EAAMhB,KAAKnW,EAAK2V,WAAWkB,OAC3BM,EAAMX,SACCxW,EAAK2V,WAAWI,SAGzB/V,EAAK2V,WAAWyB,QAAU,SAAUD,GAQlC,GAPIA,EAAMZ,QAAU,IAClBY,EAAMV,SACNU,EAAMhB,KAAKnW,EAAK2V,WAAWmB,OAG7BK,EAAMX,SAEFW,EAAMP,OACR,OAAO5W,EAAK2V,WAAWI,SAI3B/V,EAAK2V,WAAW0B,gBAAkB,SAAUF,GAI1C,OAHAA,EAAMX,SACNW,EAAMT,iBACNS,EAAMhB,KAAKnW,EAAK2V,WAAWoB,eACpB/W,EAAK2V,WAAWI,SAGzB/V,EAAK2V,WAAW2B,SAAW,SAAUH,GAInC,OAHAA,EAAMX,SACNW,EAAMT,iBACNS,EAAMhB,KAAKnW,EAAK2V,WAAWqB,OACpBhX,EAAK2V,WAAWI,SAGzB/V,EAAK2V,WAAW4B,OAAS,SAAUJ,GAC7BA,EAAMZ,QAAU,GAClBY,EAAMhB,KAAKnW,EAAK2V,WAAWmB,OAe/B9W,EAAK2V,WAAW6B,cAAgBxX,EAAK+H,UAAUpF,UAE/C3C,EAAK2V,WAAWI,QAAU,SAAUoB,GAClC,OAAa,CACX,IAAIpJ,EAAOoJ,EAAM9Y,OAEjB,GAAI0P,GAAQ/N,EAAK2V,WAAWW,IAC1B,OAAOtW,EAAK2V,WAAW4B,OAIzB,GAA0B,IAAtBxJ,EAAKvL,WAAW,GAApB,CAKA,GAAY,KAARuL,EACF,OAAO/N,EAAK2V,WAAWuB,SAGzB,GAAY,KAARnJ,EAKF,OAJAoJ,EAAMV,SACFU,EAAMZ,QAAU,GAClBY,EAAMhB,KAAKnW,EAAK2V,WAAWmB,MAEtB9W,EAAK2V,WAAW0B,gBAGzB,GAAY,KAARtJ,EAKF,OAJAoJ,EAAMV,SACFU,EAAMZ,QAAU,GAClBY,EAAMhB,KAAKnW,EAAK2V,WAAWmB,MAEtB9W,EAAK2V,WAAW2B,SAMzB,GAAY,KAARvJ,GAAiC,IAAlBoJ,EAAMZ,QAEvB,OADAY,EAAMhB,KAAKnW,EAAK2V,WAAWsB,UACpBjX,EAAK2V,WAAWI,QAMzB,GAAY,KAARhI,GAAiC,IAAlBoJ,EAAMZ,QAEvB,OADAY,EAAMhB,KAAKnW,EAAK2V,WAAWsB,UACpBjX,EAAK2V,WAAWI,QAGzB,GAAIhI,EAAK3L,MAAMpC,EAAK2V,WAAW6B,eAC7B,OAAOxX,EAAK2V,WAAWyB,aAzCvBD,EAAMd,oBA8CZrW,EAAKkQ,YAAc,SAAU/N,EAAKlB,GAChC/C,KAAKiZ,MAAQ,IAAInX,EAAK2V,WAAYxT,GAClCjE,KAAK+C,MAAQA,EACb/C,KAAKuZ,cAAgB,GACrBvZ,KAAKwZ,UAAY,GAGnB1X,EAAKkQ,YAAYzS,UAAUsD,MAAQ,WACjC7C,KAAKiZ,MAAMzN,MACXxL,KAAK0X,QAAU1X,KAAKiZ,MAAMvB,QAI1B,IAFA,IAAIE,EAAQ9V,EAAKkQ,YAAYyH,YAEtB7B,GACLA,EAAQA,EAAM5X,MAGhB,OAAOA,KAAK+C,OAGdjB,EAAKkQ,YAAYzS,UAAUma,WAAa,WACtC,OAAO1Z,KAAK0X,QAAQ1X,KAAKwZ,YAG3B1X,EAAKkQ,YAAYzS,UAAUoa,cAAgB,WACzC,IAAIC,EAAS5Z,KAAK0Z,aAElB,OADA1Z,KAAKwZ,WAAa,EACXI,GAGT9X,EAAKkQ,YAAYzS,UAAUsa,WAAa,WACtC,IAAIC,EAAkB9Z,KAAKuZ,cAC3BvZ,KAAK+C,MAAMqM,OAAO0K,GAClB9Z,KAAKuZ,cAAgB,IAGvBzX,EAAKkQ,YAAYyH,YAAc,SAAUM,GACvC,IAAIH,EAASG,EAAOL,aAEpB,GAActR,MAAVwR,EAIJ,OAAQA,EAAO1B,MACb,KAAKpW,EAAK2V,WAAWsB,SACnB,OAAOjX,EAAKkQ,YAAYgI,cAC1B,KAAKlY,EAAK2V,WAAWkB,MACnB,OAAO7W,EAAKkQ,YAAYiI,WAC1B,KAAKnY,EAAK2V,WAAWmB,KACnB,OAAO9W,EAAKkQ,YAAYkI,UAC1B,QACE,IAAIC,EAAe,4CAA8CP,EAAO1B,KAMxE,MAJI0B,EAAO3V,IAAInE,QAAU,IACvBqa,GAAgB,gBAAkBP,EAAO3V,IAAM,KAG3C,IAAInC,EAAK0V,gBAAiB2C,EAAcP,EAAOzN,MAAOyN,EAAOxN,OAIzEtK,EAAKkQ,YAAYgI,cAAgB,SAAUD,GACzC,IAAIH,EAASG,EAAOJ,gBAEpB,GAAcvR,MAAVwR,EAAJ,CAIA,OAAQA,EAAO3V,KACb,IAAK,IACH8V,EAAOR,cAAc1G,SAAW/Q,EAAKmQ,MAAMY,SAASS,WACpD,MACF,IAAK,IACHyG,EAAOR,cAAc1G,SAAW/Q,EAAKmQ,MAAMY,SAASC,SACpD,MACF,QACE,IAAIqH,EAAe,kCAAoCP,EAAO3V,IAAM,IACpE,MAAM,IAAInC,EAAK0V,gBAAiB2C,EAAcP,EAAOzN,MAAOyN,EAAOxN,KAGvE,IAAIgO,EAAaL,EAAOL,aAExB,GAAkBtR,MAAdgS,EAAyB,CACvBD,EAAe,yCACnB,MAAM,IAAIrY,EAAK0V,gBAAiB2C,EAAcP,EAAOzN,MAAOyN,EAAOxN,KAGrE,OAAQgO,EAAWlC,MACjB,KAAKpW,EAAK2V,WAAWkB,MACnB,OAAO7W,EAAKkQ,YAAYiI,WAC1B,KAAKnY,EAAK2V,WAAWmB,KACnB,OAAO9W,EAAKkQ,YAAYkI,UAC1B,QACMC,EAAe,mCAAqCC,EAAWlC,KAAO,IAC1E,MAAM,IAAIpW,EAAK0V,gBAAiB2C,EAAcC,EAAWjO,MAAOiO,EAAWhO,QAIjFtK,EAAKkQ,YAAYiI,WAAa,SAAUF,GACtC,IAAIH,EAASG,EAAOJ,gBAEpB,GAAcvR,MAAVwR,EAAJ,CAIA,IAAmD,GAA/CG,EAAOhX,MAAMiU,UAAU9O,QAAQ0R,EAAO3V,KAAY,CACpD,IAAIoW,EAAiBN,EAAOhX,MAAMiU,UAAU3T,KAAI,SAAUiX,GAAK,MAAO,IAAMA,EAAI,OAAOtC,KAAK,MACxFmC,EAAe,uBAAyBP,EAAO3V,IAAM,uBAAyBoW,EAElF,MAAM,IAAIvY,EAAK0V,gBAAiB2C,EAAcP,EAAOzN,MAAOyN,EAAOxN,KAGrE2N,EAAOR,cAAczH,OAAS,CAAC8H,EAAO3V,KAEtC,IAAImW,EAAaL,EAAOL,aAExB,GAAkBtR,MAAdgS,EAAyB,CACvBD,EAAe,gCACnB,MAAM,IAAIrY,EAAK0V,gBAAiB2C,EAAcP,EAAOzN,MAAOyN,EAAOxN,KAGrE,OAAQgO,EAAWlC,MACjB,KAAKpW,EAAK2V,WAAWmB,KACnB,OAAO9W,EAAKkQ,YAAYkI,UAC1B,QACMC,EAAe,0BAA4BC,EAAWlC,KAAO,IACjE,MAAM,IAAIpW,EAAK0V,gBAAiB2C,EAAcC,EAAWjO,MAAOiO,EAAWhO,QAIjFtK,EAAKkQ,YAAYkI,UAAY,SAAUH,GACrC,IAAIH,EAASG,EAAOJ,gBAEpB,GAAcvR,MAAVwR,EAAJ,CAIAG,EAAOR,cAAc1U,KAAO+U,EAAO3V,IAAI6F,eAEP,GAA5B8P,EAAO3V,IAAIiE,QAAQ,OACrB6R,EAAOR,cAAc7G,aAAc,GAGrC,IAAI0H,EAAaL,EAAOL,aAExB,GAAkBtR,MAAdgS,EAKJ,OAAQA,EAAWlC,MACjB,KAAKpW,EAAK2V,WAAWmB,KAEnB,OADAmB,EAAOF,aACA/X,EAAKkQ,YAAYkI,UAC1B,KAAKpY,EAAK2V,WAAWkB,MAEnB,OADAoB,EAAOF,aACA/X,EAAKkQ,YAAYiI,WAC1B,KAAKnY,EAAK2V,WAAWoB,cACnB,OAAO/W,EAAKkQ,YAAYuI,kBAC1B,KAAKzY,EAAK2V,WAAWqB,MACnB,OAAOhX,EAAKkQ,YAAYwI,WAC1B,KAAK1Y,EAAK2V,WAAWsB,SAEnB,OADAgB,EAAOF,aACA/X,EAAKkQ,YAAYgI,cAC1B,QACE,IAAIG,EAAe,2BAA6BC,EAAWlC,KAAO,IAClE,MAAM,IAAIpW,EAAK0V,gBAAiB2C,EAAcC,EAAWjO,MAAOiO,EAAWhO,UApB7E2N,EAAOF,eAwBX/X,EAAKkQ,YAAYuI,kBAAoB,SAAUR,GAC7C,IAAIH,EAASG,EAAOJ,gBAEpB,GAAcvR,MAAVwR,EAAJ,CAIA,IAAItK,EAAemL,SAASb,EAAO3V,IAAK,IAExC,GAAIyW,MAAMpL,GAAe,CACvB,IAAI6K,EAAe,gCACnB,MAAM,IAAIrY,EAAK0V,gBAAiB2C,EAAcP,EAAOzN,MAAOyN,EAAOxN,KAGrE2N,EAAOR,cAAcjK,aAAeA,EAEpC,IAAI8K,EAAaL,EAAOL,aAExB,GAAkBtR,MAAdgS,EAKJ,OAAQA,EAAWlC,MACjB,KAAKpW,EAAK2V,WAAWmB,KAEnB,OADAmB,EAAOF,aACA/X,EAAKkQ,YAAYkI,UAC1B,KAAKpY,EAAK2V,WAAWkB,MAEnB,OADAoB,EAAOF,aACA/X,EAAKkQ,YAAYiI,WAC1B,KAAKnY,EAAK2V,WAAWoB,cACnB,OAAO/W,EAAKkQ,YAAYuI,kBAC1B,KAAKzY,EAAK2V,WAAWqB,MACnB,OAAOhX,EAAKkQ,YAAYwI,WAC1B,KAAK1Y,EAAK2V,WAAWsB,SAEnB,OADAgB,EAAOF,aACA/X,EAAKkQ,YAAYgI,cAC1B,QACMG,EAAe,2BAA6BC,EAAWlC,KAAO,IAClE,MAAM,IAAIpW,EAAK0V,gBAAiB2C,EAAcC,EAAWjO,MAAOiO,EAAWhO,UApB7E2N,EAAOF,eAwBX/X,EAAKkQ,YAAYwI,WAAa,SAAUT,GACtC,IAAIH,EAASG,EAAOJ,gBAEpB,GAAcvR,MAAVwR,EAAJ,CAIA,IAAIpX,EAAQiY,SAASb,EAAO3V,IAAK,IAEjC,GAAIyW,MAAMlY,GAAQ,CAChB,IAAI2X,EAAe,wBACnB,MAAM,IAAIrY,EAAK0V,gBAAiB2C,EAAcP,EAAOzN,MAAOyN,EAAOxN,KAGrE2N,EAAOR,cAAc/W,MAAQA,EAE7B,IAAI4X,EAAaL,EAAOL,aAExB,GAAkBtR,MAAdgS,EAKJ,OAAQA,EAAWlC,MACjB,KAAKpW,EAAK2V,WAAWmB,KAEnB,OADAmB,EAAOF,aACA/X,EAAKkQ,YAAYkI,UAC1B,KAAKpY,EAAK2V,WAAWkB,MAEnB,OADAoB,EAAOF,aACA/X,EAAKkQ,YAAYiI,WAC1B,KAAKnY,EAAK2V,WAAWoB,cACnB,OAAO/W,EAAKkQ,YAAYuI,kBAC1B,KAAKzY,EAAK2V,WAAWqB,MACnB,OAAOhX,EAAKkQ,YAAYwI,WAC1B,KAAK1Y,EAAK2V,WAAWsB,SAEnB,OADAgB,EAAOF,aACA/X,EAAKkQ,YAAYgI,cAC1B,QACMG,EAAe,2BAA6BC,EAAWlC,KAAO,IAClE,MAAM,IAAIpW,EAAK0V,gBAAiB2C,EAAcC,EAAWjO,MAAOiO,EAAWhO,UApB7E2N,EAAOF,oBA+BS,0BAAd,EAYI,WAMN,OAAO/X,IAlBS,kCAx3GnB,I,wCCyBiB6Y,ECEd/Y,E,mBA+CG,SAASgZ,EAAQ1T,GACtB,OAAQA,EAAQgR,MAGd,KAAKyC,EAAkBE,MAGrB,OAxCN,SAA4BnZ,G,QACpBoZ,EAAO,UAGPC,EAAU,G,IAChB,IAAmB,kBAAArZ,EAAOU,MAAI,8BAAE,CAA3B,IAAMA,EAAI,QACA,OAATA,GAAe2Y,EAAQva,KAAQsa,EAAI,mBAC1B,OAAT1Y,GAAe2Y,EAAQva,KAAQsa,EAAI,aAAa1Y,EAAI,Y,iGAItD2Y,EAAQjb,OAAS,GACnBib,EAAQva,KAAQsa,EAAI,0BAGlBC,EAAQjb,QACVkb,KAAKC,cAAa,MAAlBD,KAAI,aACCF,EAAI,oCACJC,IAoBHG,CAAmBhU,EAAQtC,KAAKlD,QAChCE,EAAQ,IAAI,IAAYsF,EAAQtC,MACzB,CACLsT,KAAMyC,EAAkBQ,KACxBvW,KAAMhD,EAAMgC,YAIhB,KAAK+W,EAAkBS,MACrB,MAAO,CACLlD,KAAMyC,EAAkBU,OACxBzW,KAAMhD,EAAQA,EAAMkB,OAAOoE,EAAQtC,MAAQ,IAI/C,QACE,MAAM,IAAII,UAAU,0BDtE1B,SAAkB2V,GAChB,qBACA,mBACA,qBACA,uBAJF,CAAkBA,MAAiB,KC/BnC,wCA6GAK,KAAKM,iBAAiB,WAAW,SAAAC,GAC/BP,KAAKQ,YAAYZ,EAAQW,EAAG3W","file":"assets/javascripts/worker/search.0a5433f7.min.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 7);\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","/*\n * Copyright (c) 2016-2020 Martin Donath <martin.donath@squidfunk.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport * as escapeHTML from \"escape-html\"\n\nimport { SearchIndexDocument } from \"../_\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * A top-level article\n */\nexport interface ArticleDocument extends SearchIndexDocument {\n  linked: boolean                      /* Whether the section was linked */\n}\n\n/**\n * A section of an article\n */\nexport interface SectionDocument extends SearchIndexDocument {\n  parent: ArticleDocument              /* Parent article */\n}\n\n/* ------------------------------------------------------------------------- */\n\n/**\n * Search document\n */\nexport type SearchDocument =\n  | ArticleDocument\n  | SectionDocument\n\n/**\n * Search document mapping\n */\nexport type SearchDocumentMap = Map<string, SearchDocument>\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Create a search document mapping\n *\n * @param docs - Search index documents\n *\n * @return Search document map\n */\nexport function setupSearchDocumentMap(\n  docs: SearchIndexDocument[]\n): SearchDocumentMap {\n  const documents = new Map<string, SearchDocument>()\n  for (const doc of docs) {\n    const [path, hash] = doc.location.split(\"#\")\n\n    /* Extract location and title */\n    const location = doc.location\n    const title    = doc.title\n\n    /* Escape and cleanup text */\n    const text = escapeHTML(doc.text)\n      .replace(/\\s+(?=[,.:;!?])/g, \"\")\n      .replace(/\\s+/g, \" \")\n\n    /* Handle section */\n    if (hash) {\n      const parent = documents.get(path) as ArticleDocument\n\n      /* Ignore first section, override article */\n      if (!parent.linked) {\n        parent.title  = doc.title\n        parent.text   = text\n        parent.linked = true\n\n      /* Add subsequent section */\n      } else {\n        documents.set(location, {\n          location,\n          title,\n          text,\n          parent\n        })\n      }\n\n    /* Add article */\n    } else {\n      documents.set(location, {\n        location,\n        title,\n        text,\n        linked: false\n      })\n    }\n  }\n  return documents\n}\n","/*\n * Copyright (c) 2016-2020 Martin Donath <martin.donath@squidfunk.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport {\n  ArticleDocument,\n  SearchDocumentMap,\n  SectionDocument,\n  setupSearchDocumentMap\n} from \"../document\"\nimport {\n  SearchHighlightFactoryFn,\n  setupSearchHighlighter\n} from \"../highlight\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Search index configuration\n */\nexport interface SearchIndexConfig {\n  lang: string[]                       /* Search languages */\n  separator: string                    /* Search separator */\n}\n\n/**\n * Search index document\n */\nexport interface SearchIndexDocument {\n  location: string                     /* Document location */\n  title: string                        /* Document title */\n  text: string                         /* Document text */\n}\n\n/**\n * Search index pipeline\n */\nexport interface SearchIndexPipeline {\n  trimmer: boolean                     /* Add trimmer to pipeline */\n  stopwords: boolean                   /* Add stopword filter to pipeline */\n}\n\n/* ------------------------------------------------------------------------- */\n\n/**\n * Search index options\n *\n * This interfaces describes the format of the `search_index.json` file which\n * is automatically built by the MkDocs search plugin.\n */\nexport interface SearchIndexOptions {\n  config: SearchIndexConfig            /* Search index configuration */\n  docs: SearchIndexDocument[]          /* Search index documents */\n  pipeline?: SearchIndexPipeline       /* Search index pipeline */\n  index?: object | string              /* Prebuilt or serialized index */\n}\n\n/* ------------------------------------------------------------------------- */\n\n/**\n * Search result\n */\nexport interface SearchResult {\n  article: ArticleDocument             /* Article document */\n  sections: SectionDocument[]          /* Section documents */\n}\n\n/* ----------------------------------------------------------------------------\n * Class\n * ------------------------------------------------------------------------- */\n\n/**\n * Search index\n *\n * Note that `lunr` is injected via Webpack, as it will otherwise also be\n * bundled in the application bundle.\n */\nexport class SearchIndex {\n\n  /**\n   * Search document mapping\n   *\n   * A mapping of URLs (including hash fragments) to the actual articles and\n   * sections of the documentation. The search document mapping must be created\n   * regardless of whether the index was prebuilt or not, as `lunr` itself will\n   * only store the actual index.\n   */\n  protected documents: SearchDocumentMap\n\n  /**\n   * Search highlight factory function\n   */\n  protected highlight: SearchHighlightFactoryFn\n\n  /**\n   * The `lunr` search index\n   */\n  protected index: lunr.Index\n\n  /**\n   * Create a search index\n   *\n   * @param options - Options\n   */\n  public constructor({ config, docs, pipeline, index }: SearchIndexOptions) {\n    this.documents = setupSearchDocumentMap(docs)\n    this.highlight = setupSearchHighlighter(config)\n\n    /* If no index was given, create it */\n    if (typeof index === \"undefined\") {\n      this.index = lunr(function() {\n        pipeline = pipeline || {\n          trimmer: true,\n          stopwords: true\n        }\n\n        /* Remove stemmer, as it cripples search experience */\n        this.pipeline.reset()\n        if (pipeline.trimmer)\n          this.pipeline.add(lunr.trimmer)\n        if (pipeline.stopwords)\n          this.pipeline.add(lunr.stopWordFilter)\n\n        /* Set up alternate search languages */\n        if (config.lang.length === 1 && config.lang[0] !== \"en\") {\n          this.use((lunr as any)[config.lang[0]])\n        } else if (config.lang.length > 1) {\n          this.use((lunr as any).multiLanguage(...config.lang))\n        }\n\n        /* Setup fields and reference */\n        this.field(\"title\", { boost: 10 })\n        this.field(\"text\")\n        this.ref(\"location\")\n\n        /* Index documents */\n        for (const doc of docs)\n          this.add(doc)\n      })\n\n    /* Prebuilt or serialized index */\n    } else {\n      this.index = lunr.Index.load(\n        typeof index === \"string\"\n          ? JSON.parse(index)\n          : index\n      )\n    }\n  }\n\n  /**\n   * Search for matching documents\n   *\n   * The search index which MkDocs provides is divided up into articles, which\n   * contain the whole content of the individual pages, and sections, which only\n   * contain the contents of the subsections obtained by breaking the individual\n   * pages up at `h1` ... `h6`. As there may be many sections on different pages\n   * with indentical titles (for example within this very project, e.g. \"Usage\"\n   * or \"Installation\"), they need to be put into the context of the containing\n   * page. For this reason, section results are grouped within their respective\n   * articles which are the top-level results that are returned.\n   *\n   * @param query - Query string\n   *\n   * @return Search results\n   */\n  public search(query: string): SearchResult[] {\n    if (query) {\n      try {\n\n        /* Group sections by containing article */\n        const groups = this.index.search(query)\n          .reduce((results, result) => {\n            const document = this.documents.get(result.ref)\n            if (typeof document !== \"undefined\") {\n              if (\"parent\" in document) {\n                const ref = document.parent.location\n                results.set(ref, [...results.get(ref) || [], result])\n              } else {\n                const ref = document.location\n                results.set(ref, results.get(ref) || [])\n              }\n            }\n            return results\n          }, new Map<string, lunr.Index.Result[]>())\n\n        /* Create highlighter for query */\n        const fn = this.highlight(query)\n\n        /* Map groups to search documents */\n        return [...groups].map(([ref, sections]) => ({\n          article: fn(this.documents.get(ref) as ArticleDocument),\n          sections: sections.map(section => {\n            return fn(this.documents.get(section.ref) as SectionDocument)\n          })\n        }))\n\n      /* Log errors to console (for now) */\n      } catch (err) {\n        // tslint:disable-next-line no-console\n        console.warn(`Invalid query: ${query} – see https://bit.ly/2s3ChXG`)\n      }\n    }\n\n    /* Return nothing in case of error or empty query */\n    return []\n  }\n\n  /**\n   * Serialize search index\n   *\n   * @return String representation\n   */\n  public toString(): string {\n    return JSON.stringify(this.index)\n  }\n}\n","/*!\n * escape-html\n * Copyright(c) 2012-2013 TJ Holowaychuk\n * Copyright(c) 2015 Andreas Lubbe\n * Copyright(c) 2015 Tiancheng \"Timothy\" Gu\n * MIT Licensed\n */\n\n'use strict';\n\n/**\n * Module variables.\n * @private\n */\n\nvar matchHtmlRegExp = /[\"'&<>]/;\n\n/**\n * Module exports.\n * @public\n */\n\nmodule.exports = escapeHtml;\n\n/**\n * Escape special characters in the given string of html.\n *\n * @param  {string} string The string to escape for inserting into HTML\n * @return {string}\n * @public\n */\n\nfunction escapeHtml(string) {\n  var str = '' + string;\n  var match = matchHtmlRegExp.exec(str);\n\n  if (!match) {\n    return str;\n  }\n\n  var escape;\n  var html = '';\n  var index = 0;\n  var lastIndex = 0;\n\n  for (index = match.index; index < str.length; index++) {\n    switch (str.charCodeAt(index)) {\n      case 34: // \"\n        escape = '&quot;';\n        break;\n      case 38: // &\n        escape = '&amp;';\n        break;\n      case 39: // '\n        escape = '&#39;';\n        break;\n      case 60: // <\n        escape = '&lt;';\n        break;\n      case 62: // >\n        escape = '&gt;';\n        break;\n      default:\n        continue;\n    }\n\n    if (lastIndex !== index) {\n      html += str.substring(lastIndex, index);\n    }\n\n    lastIndex = index + 1;\n    html += escape;\n  }\n\n  return lastIndex !== index\n    ? html + str.substring(lastIndex, index)\n    : html;\n}\n","/*\n * Copyright (c) 2016-2020 Martin Donath <martin.donath@squidfunk.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport * as escapeRegExp from \"escape-string-regexp\"\n\nimport { SearchIndexConfig } from \"../_\"\nimport { SearchDocument } from \"../document\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Search highlight function\n *\n * @template T - Search document type\n *\n * @param document - Search document\n *\n * @return Highlighted document\n */\nexport type SearchHighlightFn =\n  <T extends SearchDocument>(document: Readonly<T>) => T\n\n/**\n * Search highlight factory function\n *\n * @param query - Query string\n *\n * @return Search highlight function\n */\nexport type SearchHighlightFactoryFn =\n  (query: string) => SearchHighlightFn\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Create a search highlighter\n *\n * @param config - Search index configuration\n *\n * @return Search highlight factory function\n */\nexport function setupSearchHighlighter(\n  config: SearchIndexConfig\n): SearchHighlightFactoryFn {\n  const separator = new RegExp(config.separator, \"img\")\n  const highlight = (_: unknown, data: string, term: string) => {\n    return `${data}<em>${term}</em>`\n  }\n\n  /* Return factory function */\n  return (query: string) => {\n    query = query\n      .replace(/[\\s*+-:~^]+/g, \" \")\n      .trim()\n\n    /* Create search term match expression */\n    const match = new RegExp(`(^|${config.separator})(${\n      escapeRegExp(query).replace(separator, \"|\")\n    })`, \"img\")\n\n    /* Highlight document */\n    return document => ({\n      ...document,\n      title: document.title.replace(match, highlight),\n      text:  document.text.replace(match, highlight)\n    })\n  }\n}\n","'use strict';\n\nconst matchOperatorsRegex = /[|\\\\{}()[\\]^$+*?.-]/g;\n\nmodule.exports = string => {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\treturn string.replace(matchOperatorsRegex, '\\\\$&');\n};\n","/**\n * lunr - http://lunrjs.com - A bit like Solr, but much smaller and not as bright - 2.3.8\n * Copyright (C) 2019 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.8\"\n/*!\n * lunr.utils\n * Copyright (C) 2019 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) 2019 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 (other) {\n    return other\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) 2019 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) 2019 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) 2019 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) 2019 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) 2019 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) 2019 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) 2019 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) 2019 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.complete\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) 2019 Oliver Nightingale\n */\n\n/**\n * lunr.Builder performs indexing on a set of documents and\n * returns instances of lunr.Index ready for querying.\n *\n * All configuration of the index is done via the builder, the\n * fields to index, the document reference, the text processing\n * pipeline and document scoring parameters are all set on the\n * builder before indexing.\n *\n * @constructor\n * @property {string} _ref - Internal reference to the document reference field.\n * @property {string[]} _fields - Internal reference to the document fields to index.\n * @property {object} invertedIndex - The inverted index maps terms to document fields.\n * @property {object} documentTermFrequencies - Keeps track of document term frequencies.\n * @property {object} documentLengths - Keeps track of the length of documents added to the index.\n * @property {lunr.tokenizer} tokenizer - Function for splitting strings into tokens for indexing.\n * @property {lunr.Pipeline} pipeline - The pipeline performs text processing on tokens before indexing.\n * @property {lunr.Pipeline} searchPipeline - A pipeline for processing search terms before querying the index.\n * @property {number} documentCount - Keeps track of the total number of documents indexed.\n * @property {number} _b - A parameter to control field length normalization, setting this to 0 disabled normalization, 1 fully normalizes field lengths, the default value is 0.75.\n * @property {number} _k1 - A parameter to control how quickly an increase in term frequency results in term frequency saturation, the default value is 1.2.\n * @property {number} termIndex - A counter incremented for each unique term, used to identify a terms position in the vector space.\n * @property {array} metadataWhitelist - A list of metadata keys that have been whitelisted for entry in the index.\n */\nlunr.Builder = function () {\n  this._ref = \"id\"\n  this._fields = Object.create(null)\n  this._documents = Object.create(null)\n  this.invertedIndex = Object.create(null)\n  this.fieldTermFrequencies = {}\n  this.fieldLengths = {}\n  this.tokenizer = lunr.tokenizer\n  this.pipeline = new lunr.Pipeline\n  this.searchPipeline = new lunr.Pipeline\n  this.documentCount = 0\n  this._b = 0.75\n  this._k1 = 1.2\n  this.termIndex = 0\n  this.metadataWhitelist = []\n}\n\n/**\n * Sets the document field used as the document reference. Every document must have this field.\n * The type of this field in the document should be a string, if it is not a string it will be\n * coerced into a string by calling toString.\n *\n * The default ref is 'id'.\n *\n * The ref should _not_ be changed during indexing, it should be set before any documents are\n * added to the index. Changing it during indexing can lead to inconsistent results.\n *\n * @param {string} ref - The name of the reference field in the document.\n */\nlunr.Builder.prototype.ref = function (ref) {\n  this._ref = ref\n}\n\n/**\n * A function that is used to extract a field from a document.\n *\n * Lunr expects a field to be at the top level of a document, if however the field\n * is deeply nested within a document an extractor function can be used to extract\n * the right field for indexing.\n *\n * @callback fieldExtractor\n * @param {object} doc - The document being added to the index.\n * @returns {?(string|object|object[])} obj - The object that will be indexed for this field.\n * @example <caption>Extracting a nested field</caption>\n * function (doc) { return doc.nested.field }\n */\n\n/**\n * Adds a field to the list of document fields that will be indexed. Every document being\n * indexed should have this field. Null values for this field in indexed documents will\n * not cause errors but will limit the chance of that document being retrieved by searches.\n *\n * All fields should be added before adding documents to the index. Adding fields after\n * a document has been indexed will have no effect on already indexed documents.\n *\n * Fields can be boosted at build time. This allows terms within that field to have more\n * importance when ranking search results. Use a field boost to specify that matches within\n * one field are more important than other fields.\n *\n * @param {string} fieldName - The name of a field to index in all documents.\n * @param {object} attributes - Optional attributes associated with this field.\n * @param {number} [attributes.boost=1] - Boost applied to all terms within this field.\n * @param {fieldExtractor} [attributes.extractor] - Function to extract a field from a document.\n * @throws {RangeError} fieldName cannot contain unsupported characters '/'\n */\nlunr.Builder.prototype.field = function (fieldName, attributes) {\n  if (/\\//.test(fieldName)) {\n    throw new RangeError (\"Field '\" + fieldName + \"' contains illegal character '/'\")\n  }\n\n  this._fields[fieldName] = attributes || {}\n}\n\n/**\n * A parameter to tune the amount of field length normalisation that is applied when\n * calculating relevance scores. A value of 0 will completely disable any normalisation\n * and a value of 1 will fully normalise field lengths. The default is 0.75. Values of b\n * will be clamped to the range 0 - 1.\n *\n * @param {number} number - The value to set for this tuning parameter.\n */\nlunr.Builder.prototype.b = function (number) {\n  if (number < 0) {\n    this._b = 0\n  } else if (number > 1) {\n    this._b = 1\n  } else {\n    this._b = number\n  }\n}\n\n/**\n * A parameter that controls the speed at which a rise in term frequency results in term\n * frequency saturation. The default value is 1.2. Setting this to a higher value will give\n * slower saturation levels, a lower value will result in quicker saturation.\n *\n * @param {number} number - The value to set for this tuning parameter.\n */\nlunr.Builder.prototype.k1 = function (number) {\n  this._k1 = number\n}\n\n/**\n * Adds a document to the index.\n *\n * Before adding fields to the index the index should have been fully setup, with the document\n * ref and all fields to index already having been specified.\n *\n * The document must have a field name as specified by the ref (by default this is 'id') and\n * it should have all fields defined for indexing, though null or undefined values will not\n * cause errors.\n *\n * Entire documents can be boosted at build time. Applying a boost to a document indicates that\n * this document should rank higher in search results than other documents.\n *\n * @param {object} doc - The document to add to the index.\n * @param {object} attributes - Optional attributes associated with this document.\n * @param {number} [attributes.boost=1] - Boost applied to all terms within this document.\n */\nlunr.Builder.prototype.add = function (doc, attributes) {\n  var docRef = doc[this._ref],\n      fields = Object.keys(this._fields)\n\n  this._documents[docRef] = attributes || {}\n  this.documentCount += 1\n\n  for (var i = 0; i < fields.length; i++) {\n    var fieldName = fields[i],\n        extractor = this._fields[fieldName].extractor,\n        field = extractor ? extractor(doc) : doc[fieldName],\n        tokens = this.tokenizer(field, {\n          fields: [fieldName]\n        }),\n        terms = this.pipeline.run(tokens),\n        fieldRef = new lunr.FieldRef (docRef, fieldName),\n        fieldTerms = Object.create(null)\n\n    this.fieldTermFrequencies[fieldRef] = fieldTerms\n    this.fieldLengths[fieldRef] = 0\n\n    // store the length of this field for this document\n    this.fieldLengths[fieldRef] += terms.length\n\n    // calculate term frequencies for this field\n    for (var j = 0; j < terms.length; j++) {\n      var term = terms[j]\n\n      if (fieldTerms[term] == undefined) {\n        fieldTerms[term] = 0\n      }\n\n      fieldTerms[term] += 1\n\n      // add to inverted index\n      // create an initial posting if one doesn't exist\n      if (this.invertedIndex[term] == undefined) {\n        var posting = Object.create(null)\n        posting[\"_index\"] = this.termIndex\n        this.termIndex += 1\n\n        for (var k = 0; k < fields.length; k++) {\n          posting[fields[k]] = Object.create(null)\n        }\n\n        this.invertedIndex[term] = posting\n      }\n\n      // add an entry for this term/fieldName/docRef to the invertedIndex\n      if (this.invertedIndex[term][fieldName][docRef] == undefined) {\n        this.invertedIndex[term][fieldName][docRef] = Object.create(null)\n      }\n\n      // store all whitelisted metadata about this token in the\n      // inverted index\n      for (var l = 0; l < this.metadataWhitelist.length; l++) {\n        var metadataKey = this.metadataWhitelist[l],\n            metadata = term.metadata[metadataKey]\n\n        if (this.invertedIndex[term][fieldName][docRef][metadataKey] == undefined) {\n          this.invertedIndex[term][fieldName][docRef][metadataKey] = []\n        }\n\n        this.invertedIndex[term][fieldName][docRef][metadataKey].push(metadata)\n      }\n    }\n\n  }\n}\n\n/**\n * Calculates the average document length for this index\n *\n * @private\n */\nlunr.Builder.prototype.calculateAverageFieldLengths = function () {\n\n  var fieldRefs = Object.keys(this.fieldLengths),\n      numberOfFields = fieldRefs.length,\n      accumulator = {},\n      documentsWithField = {}\n\n  for (var i = 0; i < numberOfFields; i++) {\n    var fieldRef = lunr.FieldRef.fromString(fieldRefs[i]),\n        field = fieldRef.fieldName\n\n    documentsWithField[field] || (documentsWithField[field] = 0)\n    documentsWithField[field] += 1\n\n    accumulator[field] || (accumulator[field] = 0)\n    accumulator[field] += this.fieldLengths[fieldRef]\n  }\n\n  var fields = Object.keys(this._fields)\n\n  for (var i = 0; i < fields.length; i++) {\n    var fieldName = fields[i]\n    accumulator[fieldName] = accumulator[fieldName] / documentsWithField[fieldName]\n  }\n\n  this.averageFieldLength = accumulator\n}\n\n/**\n * Builds a vector space model of every document using lunr.Vector\n *\n * @private\n */\nlunr.Builder.prototype.createFieldVectors = function () {\n  var fieldVectors = {},\n      fieldRefs = Object.keys(this.fieldTermFrequencies),\n      fieldRefsLength = fieldRefs.length,\n      termIdfCache = Object.create(null)\n\n  for (var i = 0; i < fieldRefsLength; i++) {\n    var fieldRef = lunr.FieldRef.fromString(fieldRefs[i]),\n        fieldName = fieldRef.fieldName,\n        fieldLength = this.fieldLengths[fieldRef],\n        fieldVector = new lunr.Vector,\n        termFrequencies = this.fieldTermFrequencies[fieldRef],\n        terms = Object.keys(termFrequencies),\n        termsLength = terms.length\n\n\n    var fieldBoost = this._fields[fieldName].boost || 1,\n        docBoost = this._documents[fieldRef.docRef].boost || 1\n\n    for (var j = 0; j < termsLength; j++) {\n      var term = terms[j],\n          tf = termFrequencies[term],\n          termIndex = this.invertedIndex[term]._index,\n          idf, score, scoreWithPrecision\n\n      if (termIdfCache[term] === undefined) {\n        idf = lunr.idf(this.invertedIndex[term], this.documentCount)\n        termIdfCache[term] = idf\n      } else {\n        idf = termIdfCache[term]\n      }\n\n      score = idf * ((this._k1 + 1) * tf) / (this._k1 * (1 - this._b + this._b * (fieldLength / this.averageFieldLength[fieldName])) + tf)\n      score *= fieldBoost\n      score *= docBoost\n      scoreWithPrecision = Math.round(score * 1000) / 1000\n      // Converts 1.23456789 to 1.234.\n      // Reducing the precision so that the vectors take up less\n      // space when serialised. Doing it now so that they behave\n      // the same before and after serialisation. Also, this is\n      // the fastest approach to reducing a number's precision in\n      // JavaScript.\n\n      fieldVector.insert(termIndex, scoreWithPrecision)\n    }\n\n    fieldVectors[fieldRef] = fieldVector\n  }\n\n  this.fieldVectors = fieldVectors\n}\n\n/**\n * Creates a token set of all tokens in the index using lunr.TokenSet\n *\n * @private\n */\nlunr.Builder.prototype.createTokenSet = function () {\n  this.tokenSet = lunr.TokenSet.fromArray(\n    Object.keys(this.invertedIndex).sort()\n  )\n}\n\n/**\n * Builds the index, creating an instance of lunr.Index.\n *\n * This completes the indexing process and should only be called\n * once all documents have been added to the index.\n *\n * @returns {lunr.Index}\n */\nlunr.Builder.prototype.build = function () {\n  this.calculateAverageFieldLengths()\n  this.createFieldVectors()\n  this.createTokenSet()\n\n  return new lunr.Index({\n    invertedIndex: this.invertedIndex,\n    fieldVectors: this.fieldVectors,\n    tokenSet: this.tokenSet,\n    fields: Object.keys(this._fields),\n    pipeline: this.searchPipeline\n  })\n}\n\n/**\n * Applies a plugin to the index builder.\n *\n * A plugin is a function that is called with the index builder as its context.\n * Plugins can be used to customise or extend the behaviour of the index\n * in some way. A plugin is just a function, that encapsulated the custom\n * behaviour that should be applied when building the index.\n *\n * The plugin function will be called with the index builder as its argument, additional\n * arguments can also be passed when calling use. The function will be called\n * with the index builder as its context.\n *\n * @param {Function} plugin The plugin to apply.\n */\nlunr.Builder.prototype.use = function (fn) {\n  var args = Array.prototype.slice.call(arguments, 1)\n  args.unshift(this)\n  fn.apply(this, args)\n}\n/**\n * Contains and collects metadata about a matching document.\n * A single instance of lunr.MatchData is returned as part of every\n * lunr.Index~Result.\n *\n * @constructor\n * @param {string} term - The term this match data is associated with\n * @param {string} field - The field in which the term was found\n * @param {object} metadata - The metadata recorded about this term in this field\n * @property {object} metadata - A cloned collection of metadata associated with this document.\n * @see {@link lunr.Index~Result}\n */\nlunr.MatchData = function (term, field, metadata) {\n  var clonedMetadata = Object.create(null),\n      metadataKeys = Object.keys(metadata || {})\n\n  // Cloning the metadata to prevent the original\n  // being mutated during match data combination.\n  // Metadata is kept in an array within the inverted\n  // index so cloning the data can be done with\n  // Array#slice\n  for (var i = 0; i < metadataKeys.length; i++) {\n    var key = metadataKeys[i]\n    clonedMetadata[key] = metadata[key].slice()\n  }\n\n  this.metadata = Object.create(null)\n\n  if (term !== undefined) {\n    this.metadata[term] = Object.create(null)\n    this.metadata[term][field] = clonedMetadata\n  }\n}\n\n/**\n * An instance of lunr.MatchData will be created for every term that matches a\n * document. However only one instance is required in a lunr.Index~Result. This\n * method combines metadata from another instance of lunr.MatchData with this\n * objects metadata.\n *\n * @param {lunr.MatchData} otherMatchData - Another instance of match data to merge with this one.\n * @see {@link lunr.Index~Result}\n */\nlunr.MatchData.prototype.combine = function (otherMatchData) {\n  var terms = Object.keys(otherMatchData.metadata)\n\n  for (var i = 0; i < terms.length; i++) {\n    var term = terms[i],\n        fields = Object.keys(otherMatchData.metadata[term])\n\n    if (this.metadata[term] == undefined) {\n      this.metadata[term] = Object.create(null)\n    }\n\n    for (var j = 0; j < fields.length; j++) {\n      var field = fields[j],\n          keys = Object.keys(otherMatchData.metadata[term][field])\n\n      if (this.metadata[term][field] == undefined) {\n        this.metadata[term][field] = Object.create(null)\n      }\n\n      for (var k = 0; k < keys.length; k++) {\n        var key = keys[k]\n\n        if (this.metadata[term][field][key] == undefined) {\n          this.metadata[term][field][key] = otherMatchData.metadata[term][field][key]\n        } else {\n          this.metadata[term][field][key] = this.metadata[term][field][key].concat(otherMatchData.metadata[term][field][key])\n        }\n\n      }\n    }\n  }\n}\n\n/**\n * Add metadata for a term/field pair to this instance of match data.\n *\n * @param {string} term - The term this match data is associated with\n * @param {string} field - The field in which the term was found\n * @param {object} metadata - The metadata recorded about this term in this field\n */\nlunr.MatchData.prototype.add = function (term, field, metadata) {\n  if (!(term in this.metadata)) {\n    this.metadata[term] = Object.create(null)\n    this.metadata[term][field] = metadata\n    return\n  }\n\n  if (!(field in this.metadata[term])) {\n    this.metadata[term][field] = metadata\n    return\n  }\n\n  var metadataKeys = Object.keys(metadata)\n\n  for (var i = 0; i < metadataKeys.length; i++) {\n    var key = metadataKeys[i]\n\n    if (key in this.metadata[term][field]) {\n      this.metadata[term][field][key] = this.metadata[term][field][key].concat(metadata[key])\n    } else {\n      this.metadata[term][field][key] = metadata[key]\n    }\n  }\n}\n/**\n * A lunr.Query provides a programmatic way of defining queries to be performed\n * against a {@link lunr.Index}.\n *\n * Prefer constructing a lunr.Query using the {@link lunr.Index#query} method\n * so the query object is pre-initialized with the right index fields.\n *\n * @constructor\n * @property {lunr.Query~Clause[]} clauses - An array of query clauses.\n * @property {string[]} allFields - An array of all available fields in a lunr.Index.\n */\nlunr.Query = function (allFields) {\n  this.clauses = []\n  this.allFields = allFields\n}\n\n/**\n * Constants for indicating what kind of automatic wildcard insertion will be used when constructing a query clause.\n *\n * This allows wildcards to be added to the beginning and end of a term without having to manually do any string\n * concatenation.\n *\n * The wildcard constants can be bitwise combined to select both leading and trailing wildcards.\n *\n * @constant\n * @default\n * @property {number} wildcard.NONE - The term will have no wildcards inserted, this is the default behaviour\n * @property {number} wildcard.LEADING - Prepend the term with a wildcard, unless a leading wildcard already exists\n * @property {number} wildcard.TRAILING - Append a wildcard to the term, unless a trailing wildcard already exists\n * @see lunr.Query~Clause\n * @see lunr.Query#clause\n * @see lunr.Query#term\n * @example <caption>query term with trailing wildcard</caption>\n * query.term('foo', { wildcard: lunr.Query.wildcard.TRAILING })\n * @example <caption>query term with leading and trailing wildcard</caption>\n * query.term('foo', {\n *   wildcard: lunr.Query.wildcard.LEADING | lunr.Query.wildcard.TRAILING\n * })\n */\n\nlunr.Query.wildcard = new String (\"*\")\nlunr.Query.wildcard.NONE = 0\nlunr.Query.wildcard.LEADING = 1\nlunr.Query.wildcard.TRAILING = 2\n\n/**\n * Constants for indicating what kind of presence a term must have in matching documents.\n *\n * @constant\n * @enum {number}\n * @see lunr.Query~Clause\n * @see lunr.Query#clause\n * @see lunr.Query#term\n * @example <caption>query term with required presence</caption>\n * query.term('foo', { presence: lunr.Query.presence.REQUIRED })\n */\nlunr.Query.presence = {\n  /**\n   * Term's presence in a document is optional, this is the default value.\n   */\n  OPTIONAL: 1,\n\n  /**\n   * Term's presence in a document is required, documents that do not contain\n   * this term will not be returned.\n   */\n  REQUIRED: 2,\n\n  /**\n   * Term's presence in a document is prohibited, documents that do contain\n   * this term will not be returned.\n   */\n  PROHIBITED: 3\n}\n\n/**\n * A single clause in a {@link lunr.Query} contains a term and details on how to\n * match that term against a {@link lunr.Index}.\n *\n * @typedef {Object} lunr.Query~Clause\n * @property {string[]} fields - The fields in an index this clause should be matched against.\n * @property {number} [boost=1] - Any boost that should be applied when matching this clause.\n * @property {number} [editDistance] - Whether the term should have fuzzy matching applied, and how fuzzy the match should be.\n * @property {boolean} [usePipeline] - Whether the term should be passed through the search pipeline.\n * @property {number} [wildcard=lunr.Query.wildcard.NONE] - Whether the term should have wildcards appended or prepended.\n * @property {number} [presence=lunr.Query.presence.OPTIONAL] - The terms presence in any matching documents.\n */\n\n/**\n * Adds a {@link lunr.Query~Clause} to this query.\n *\n * Unless the clause contains the fields to be matched all fields will be matched. In addition\n * a default boost of 1 is applied to the clause.\n *\n * @param {lunr.Query~Clause} clause - The clause to add to this query.\n * @see lunr.Query~Clause\n * @returns {lunr.Query}\n */\nlunr.Query.prototype.clause = function (clause) {\n  if (!('fields' in clause)) {\n    clause.fields = this.allFields\n  }\n\n  if (!('boost' in clause)) {\n    clause.boost = 1\n  }\n\n  if (!('usePipeline' in clause)) {\n    clause.usePipeline = true\n  }\n\n  if (!('wildcard' in clause)) {\n    clause.wildcard = lunr.Query.wildcard.NONE\n  }\n\n  if ((clause.wildcard & lunr.Query.wildcard.LEADING) && (clause.term.charAt(0) != lunr.Query.wildcard)) {\n    clause.term = \"*\" + clause.term\n  }\n\n  if ((clause.wildcard & lunr.Query.wildcard.TRAILING) && (clause.term.slice(-1) != lunr.Query.wildcard)) {\n    clause.term = \"\" + clause.term + \"*\"\n  }\n\n  if (!('presence' in clause)) {\n    clause.presence = lunr.Query.presence.OPTIONAL\n  }\n\n  this.clauses.push(clause)\n\n  return this\n}\n\n/**\n * A negated query is one in which every clause has a presence of\n * prohibited. These queries require some special processing to return\n * the expected results.\n *\n * @returns boolean\n */\nlunr.Query.prototype.isNegated = function () {\n  for (var i = 0; i < this.clauses.length; i++) {\n    if (this.clauses[i].presence != lunr.Query.presence.PROHIBITED) {\n      return false\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a term to the current query, under the covers this will create a {@link lunr.Query~Clause}\n * to the list of clauses that make up this query.\n *\n * The term is used as is, i.e. no tokenization will be performed by this method. Instead conversion\n * to a token or token-like string should be done before calling this method.\n *\n * The term will be converted to a string by calling `toString`. Multiple terms can be passed as an\n * array, each term in the array will share the same options.\n *\n * @param {object|object[]} term - The term(s) to add to the query.\n * @param {object} [options] - Any additional properties to add to the query clause.\n * @returns {lunr.Query}\n * @see lunr.Query#clause\n * @see lunr.Query~Clause\n * @example <caption>adding a single term to a query</caption>\n * query.term(\"foo\")\n * @example <caption>adding a single term to a query and specifying search fields, term boost and automatic trailing wildcard</caption>\n * query.term(\"foo\", {\n *   fields: [\"title\"],\n *   boost: 10,\n *   wildcard: lunr.Query.wildcard.TRAILING\n * })\n * @example <caption>using lunr.tokenizer to convert a string to tokens before using them as terms</caption>\n * query.term(lunr.tokenizer(\"foo bar\"))\n */\nlunr.Query.prototype.term = function (term, options) {\n  if (Array.isArray(term)) {\n    term.forEach(function (t) { this.term(t, lunr.utils.clone(options)) }, this)\n    return this\n  }\n\n  var clause = options || {}\n  clause.term = term.toString()\n\n  this.clause(clause)\n\n  return this\n}\nlunr.QueryParseError = function (message, start, end) {\n  this.name = \"QueryParseError\"\n  this.message = message\n  this.start = start\n  this.end = end\n}\n\nlunr.QueryParseError.prototype = new Error\nlunr.QueryLexer = function (str) {\n  this.lexemes = []\n  this.str = str\n  this.length = str.length\n  this.pos = 0\n  this.start = 0\n  this.escapeCharPositions = []\n}\n\nlunr.QueryLexer.prototype.run = function () {\n  var state = lunr.QueryLexer.lexText\n\n  while (state) {\n    state = state(this)\n  }\n}\n\nlunr.QueryLexer.prototype.sliceString = function () {\n  var subSlices = [],\n      sliceStart = this.start,\n      sliceEnd = this.pos\n\n  for (var i = 0; i < this.escapeCharPositions.length; i++) {\n    sliceEnd = this.escapeCharPositions[i]\n    subSlices.push(this.str.slice(sliceStart, sliceEnd))\n    sliceStart = sliceEnd + 1\n  }\n\n  subSlices.push(this.str.slice(sliceStart, this.pos))\n  this.escapeCharPositions.length = 0\n\n  return subSlices.join('')\n}\n\nlunr.QueryLexer.prototype.emit = function (type) {\n  this.lexemes.push({\n    type: type,\n    str: this.sliceString(),\n    start: this.start,\n    end: this.pos\n  })\n\n  this.start = this.pos\n}\n\nlunr.QueryLexer.prototype.escapeCharacter = function () {\n  this.escapeCharPositions.push(this.pos - 1)\n  this.pos += 1\n}\n\nlunr.QueryLexer.prototype.next = function () {\n  if (this.pos >= this.length) {\n    return lunr.QueryLexer.EOS\n  }\n\n  var char = this.str.charAt(this.pos)\n  this.pos += 1\n  return char\n}\n\nlunr.QueryLexer.prototype.width = function () {\n  return this.pos - this.start\n}\n\nlunr.QueryLexer.prototype.ignore = function () {\n  if (this.start == this.pos) {\n    this.pos += 1\n  }\n\n  this.start = this.pos\n}\n\nlunr.QueryLexer.prototype.backup = function () {\n  this.pos -= 1\n}\n\nlunr.QueryLexer.prototype.acceptDigitRun = function () {\n  var char, charCode\n\n  do {\n    char = this.next()\n    charCode = char.charCodeAt(0)\n  } while (charCode > 47 && charCode < 58)\n\n  if (char != lunr.QueryLexer.EOS) {\n    this.backup()\n  }\n}\n\nlunr.QueryLexer.prototype.more = function () {\n  return this.pos < this.length\n}\n\nlunr.QueryLexer.EOS = 'EOS'\nlunr.QueryLexer.FIELD = 'FIELD'\nlunr.QueryLexer.TERM = 'TERM'\nlunr.QueryLexer.EDIT_DISTANCE = 'EDIT_DISTANCE'\nlunr.QueryLexer.BOOST = 'BOOST'\nlunr.QueryLexer.PRESENCE = 'PRESENCE'\n\nlunr.QueryLexer.lexField = function (lexer) {\n  lexer.backup()\n  lexer.emit(lunr.QueryLexer.FIELD)\n  lexer.ignore()\n  return lunr.QueryLexer.lexText\n}\n\nlunr.QueryLexer.lexTerm = function (lexer) {\n  if (lexer.width() > 1) {\n    lexer.backup()\n    lexer.emit(lunr.QueryLexer.TERM)\n  }\n\n  lexer.ignore()\n\n  if (lexer.more()) {\n    return lunr.QueryLexer.lexText\n  }\n}\n\nlunr.QueryLexer.lexEditDistance = function (lexer) {\n  lexer.ignore()\n  lexer.acceptDigitRun()\n  lexer.emit(lunr.QueryLexer.EDIT_DISTANCE)\n  return lunr.QueryLexer.lexText\n}\n\nlunr.QueryLexer.lexBoost = function (lexer) {\n  lexer.ignore()\n  lexer.acceptDigitRun()\n  lexer.emit(lunr.QueryLexer.BOOST)\n  return lunr.QueryLexer.lexText\n}\n\nlunr.QueryLexer.lexEOS = function (lexer) {\n  if (lexer.width() > 0) {\n    lexer.emit(lunr.QueryLexer.TERM)\n  }\n}\n\n// This matches the separator used when tokenising fields\n// within a document. These should match otherwise it is\n// not possible to search for some tokens within a document.\n//\n// It is possible for the user to change the separator on the\n// tokenizer so it _might_ clash with any other of the special\n// characters already used within the search string, e.g. :.\n//\n// This means that it is possible to change the separator in\n// such a way that makes some words unsearchable using a search\n// string.\nlunr.QueryLexer.termSeparator = lunr.tokenizer.separator\n\nlunr.QueryLexer.lexText = function (lexer) {\n  while (true) {\n    var char = lexer.next()\n\n    if (char == lunr.QueryLexer.EOS) {\n      return lunr.QueryLexer.lexEOS\n    }\n\n    // Escape character is '\\'\n    if (char.charCodeAt(0) == 92) {\n      lexer.escapeCharacter()\n      continue\n    }\n\n    if (char == \":\") {\n      return lunr.QueryLexer.lexField\n    }\n\n    if (char == \"~\") {\n      lexer.backup()\n      if (lexer.width() > 0) {\n        lexer.emit(lunr.QueryLexer.TERM)\n      }\n      return lunr.QueryLexer.lexEditDistance\n    }\n\n    if (char == \"^\") {\n      lexer.backup()\n      if (lexer.width() > 0) {\n        lexer.emit(lunr.QueryLexer.TERM)\n      }\n      return lunr.QueryLexer.lexBoost\n    }\n\n    // \"+\" indicates term presence is required\n    // checking for length to ensure that only\n    // leading \"+\" are considered\n    if (char == \"+\" && lexer.width() === 1) {\n      lexer.emit(lunr.QueryLexer.PRESENCE)\n      return lunr.QueryLexer.lexText\n    }\n\n    // \"-\" indicates term presence is prohibited\n    // checking for length to ensure that only\n    // leading \"-\" are considered\n    if (char == \"-\" && lexer.width() === 1) {\n      lexer.emit(lunr.QueryLexer.PRESENCE)\n      return lunr.QueryLexer.lexText\n    }\n\n    if (char.match(lunr.QueryLexer.termSeparator)) {\n      return lunr.QueryLexer.lexTerm\n    }\n  }\n}\n\nlunr.QueryParser = function (str, query) {\n  this.lexer = new lunr.QueryLexer (str)\n  this.query = query\n  this.currentClause = {}\n  this.lexemeIdx = 0\n}\n\nlunr.QueryParser.prototype.parse = function () {\n  this.lexer.run()\n  this.lexemes = this.lexer.lexemes\n\n  var state = lunr.QueryParser.parseClause\n\n  while (state) {\n    state = state(this)\n  }\n\n  return this.query\n}\n\nlunr.QueryParser.prototype.peekLexeme = function () {\n  return this.lexemes[this.lexemeIdx]\n}\n\nlunr.QueryParser.prototype.consumeLexeme = function () {\n  var lexeme = this.peekLexeme()\n  this.lexemeIdx += 1\n  return lexeme\n}\n\nlunr.QueryParser.prototype.nextClause = function () {\n  var completedClause = this.currentClause\n  this.query.clause(completedClause)\n  this.currentClause = {}\n}\n\nlunr.QueryParser.parseClause = function (parser) {\n  var lexeme = parser.peekLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  switch (lexeme.type) {\n    case lunr.QueryLexer.PRESENCE:\n      return lunr.QueryParser.parsePresence\n    case lunr.QueryLexer.FIELD:\n      return lunr.QueryParser.parseField\n    case lunr.QueryLexer.TERM:\n      return lunr.QueryParser.parseTerm\n    default:\n      var errorMessage = \"expected either a field or a term, found \" + lexeme.type\n\n      if (lexeme.str.length >= 1) {\n        errorMessage += \" with value '\" + lexeme.str + \"'\"\n      }\n\n      throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n}\n\nlunr.QueryParser.parsePresence = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  switch (lexeme.str) {\n    case \"-\":\n      parser.currentClause.presence = lunr.Query.presence.PROHIBITED\n      break\n    case \"+\":\n      parser.currentClause.presence = lunr.Query.presence.REQUIRED\n      break\n    default:\n      var errorMessage = \"unrecognised presence operator'\" + lexeme.str + \"'\"\n      throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    var errorMessage = \"expecting term or field, found nothing\"\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  switch (nextLexeme.type) {\n    case lunr.QueryLexer.FIELD:\n      return lunr.QueryParser.parseField\n    case lunr.QueryLexer.TERM:\n      return lunr.QueryParser.parseTerm\n    default:\n      var errorMessage = \"expecting term or field, found '\" + nextLexeme.type + \"'\"\n      throw new lunr.QueryParseError (errorMessage, nextLexeme.start, nextLexeme.end)\n  }\n}\n\nlunr.QueryParser.parseField = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  if (parser.query.allFields.indexOf(lexeme.str) == -1) {\n    var possibleFields = parser.query.allFields.map(function (f) { return \"'\" + f + \"'\" }).join(', '),\n        errorMessage = \"unrecognised field '\" + lexeme.str + \"', possible fields: \" + possibleFields\n\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  parser.currentClause.fields = [lexeme.str]\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    var errorMessage = \"expecting term, found nothing\"\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  switch (nextLexeme.type) {\n    case lunr.QueryLexer.TERM:\n      return lunr.QueryParser.parseTerm\n    default:\n      var errorMessage = \"expecting term, found '\" + nextLexeme.type + \"'\"\n      throw new lunr.QueryParseError (errorMessage, nextLexeme.start, nextLexeme.end)\n  }\n}\n\nlunr.QueryParser.parseTerm = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  parser.currentClause.term = lexeme.str.toLowerCase()\n\n  if (lexeme.str.indexOf(\"*\") != -1) {\n    parser.currentClause.usePipeline = false\n  }\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    parser.nextClause()\n    return\n  }\n\n  switch (nextLexeme.type) {\n    case lunr.QueryLexer.TERM:\n      parser.nextClause()\n      return lunr.QueryParser.parseTerm\n    case lunr.QueryLexer.FIELD:\n      parser.nextClause()\n      return lunr.QueryParser.parseField\n    case lunr.QueryLexer.EDIT_DISTANCE:\n      return lunr.QueryParser.parseEditDistance\n    case lunr.QueryLexer.BOOST:\n      return lunr.QueryParser.parseBoost\n    case lunr.QueryLexer.PRESENCE:\n      parser.nextClause()\n      return lunr.QueryParser.parsePresence\n    default:\n      var errorMessage = \"Unexpected lexeme type '\" + nextLexeme.type + \"'\"\n      throw new lunr.QueryParseError (errorMessage, nextLexeme.start, nextLexeme.end)\n  }\n}\n\nlunr.QueryParser.parseEditDistance = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  var editDistance = parseInt(lexeme.str, 10)\n\n  if (isNaN(editDistance)) {\n    var errorMessage = \"edit distance must be numeric\"\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  parser.currentClause.editDistance = editDistance\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    parser.nextClause()\n    return\n  }\n\n  switch (nextLexeme.type) {\n    case lunr.QueryLexer.TERM:\n      parser.nextClause()\n      return lunr.QueryParser.parseTerm\n    case lunr.QueryLexer.FIELD:\n      parser.nextClause()\n      return lunr.QueryParser.parseField\n    case lunr.QueryLexer.EDIT_DISTANCE:\n      return lunr.QueryParser.parseEditDistance\n    case lunr.QueryLexer.BOOST:\n      return lunr.QueryParser.parseBoost\n    case lunr.QueryLexer.PRESENCE:\n      parser.nextClause()\n      return lunr.QueryParser.parsePresence\n    default:\n      var errorMessage = \"Unexpected lexeme type '\" + nextLexeme.type + \"'\"\n      throw new lunr.QueryParseError (errorMessage, nextLexeme.start, nextLexeme.end)\n  }\n}\n\nlunr.QueryParser.parseBoost = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  var boost = parseInt(lexeme.str, 10)\n\n  if (isNaN(boost)) {\n    var errorMessage = \"boost must be numeric\"\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  parser.currentClause.boost = boost\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    parser.nextClause()\n    return\n  }\n\n  switch (nextLexeme.type) {\n    case lunr.QueryLexer.TERM:\n      parser.nextClause()\n      return lunr.QueryParser.parseTerm\n    case lunr.QueryLexer.FIELD:\n      parser.nextClause()\n      return lunr.QueryParser.parseField\n    case lunr.QueryLexer.EDIT_DISTANCE:\n      return lunr.QueryParser.parseEditDistance\n    case lunr.QueryLexer.BOOST:\n      return lunr.QueryParser.parseBoost\n    case lunr.QueryLexer.PRESENCE:\n      parser.nextClause()\n      return lunr.QueryParser.parsePresence\n    default:\n      var errorMessage = \"Unexpected lexeme type '\" + nextLexeme.type + \"'\"\n      throw new lunr.QueryParseError (errorMessage, nextLexeme.start, nextLexeme.end)\n  }\n}\n\n  /**\n   * export the module via AMD, CommonJS or as a browser global\n   * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js\n   */\n  ;(function (root, factory) {\n    if (typeof define === 'function' && define.amd) {\n      // AMD. Register as an anonymous module.\n      define(factory)\n    } else if (typeof exports === 'object') {\n      /**\n       * Node. Does not work with strict CommonJS, but\n       * only CommonJS-like enviroments that support module.exports,\n       * like Node.\n       */\n      module.exports = factory()\n    } else {\n      // Browser globals (root is window)\n      root.lunr = factory()\n    }\n  }(this, function () {\n    /**\n     * Just return a value to define the module export.\n     * This example returns an object, but the module\n     * can return a function as the exported value.\n     */\n    return lunr\n  }))\n})();\n","/*\n * Copyright (c) 2016-2020 Martin Donath <martin.donath@squidfunk.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A RTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { SearchIndexOptions, SearchResult } from \"integrations/search\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Search message type\n */\nexport const enum SearchMessageType {\n  SETUP,                               /* Search index setup */\n  DUMP,                                /* Search index dump */\n  QUERY,                               /* Search query */\n  RESULT                               /* Search results */\n}\n\n/* ------------------------------------------------------------------------- */\n\n/**\n * A message containing the data necessary to setup the search index\n */\nexport interface SearchSetupMessage {\n  type: SearchMessageType.SETUP        /* Message type */\n  data: SearchIndexOptions             /* Message data */\n}\n\n/**\n * A message containing the a dump of the search index\n */\nexport interface SearchDumpMessage {\n  type: SearchMessageType.DUMP        /* Message type */\n  data: string                        /* Message data */\n}\n\n/**\n * A message containing a search query\n */\nexport interface SearchQueryMessage {\n  type: SearchMessageType.QUERY        /* Message type */\n  data: string                         /* Message data */\n}\n\n/**\n * A message containing results for a search query\n */\nexport interface SearchResultMessage {\n  type: SearchMessageType.RESULT       /* Message type */\n  data: SearchResult[]                 /* Message data */\n}\n\n/* ------------------------------------------------------------------------- */\n\n/**\n * A message exchanged with the search worker\n */\nexport type SearchMessage =\n  | SearchSetupMessage\n  | SearchDumpMessage\n  | SearchQueryMessage\n  | SearchResultMessage\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Type guard for search setup messages\n *\n * @param message - Search worker message\n *\n * @return Test result\n */\nexport function isSearchSetupMessage(\n  message: SearchMessage\n): message is SearchSetupMessage {\n  return message.type === SearchMessageType.SETUP\n}\n\n/**\n * Type guard for search dump messages\n *\n * @param message - Search worker message\n *\n * @return Test result\n */\nexport function isSearchDumpMessage(\n  message: SearchMessage\n): message is SearchDumpMessage {\n  return message.type === SearchMessageType.DUMP\n}\n\n/**\n * Type guard for search query messages\n *\n * @param message - Search worker message\n *\n * @return Test result\n */\nexport function isSearchQueryMessage(\n  message: SearchMessage\n): message is SearchQueryMessage {\n  return message.type === SearchMessageType.QUERY\n}\n\n/**\n * Type guard for search result messages\n *\n * @param message - Search worker message\n *\n * @return Test result\n */\nexport function isSearchResultMessage(\n  message: SearchMessage\n): message is SearchResultMessage {\n  return message.type === SearchMessageType.RESULT\n}\n","/*\n * Copyright (c) 2016-2020 Martin Donath <martin.donath@squidfunk.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A RTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { SearchIndex, SearchIndexConfig } from \"integrations/search\"\n\nimport { SearchMessage, SearchMessageType } from \"../message\"\n\n/* ----------------------------------------------------------------------------\n * Data\n * ------------------------------------------------------------------------- */\n\n/**\n * Search index\n */\nlet index: SearchIndex\n\n/* ----------------------------------------------------------------------------\n * Helper functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Setup multi-language support through `lunr-languages`\n *\n * This function will automatically import the stemmers necessary to process\n * the languages which were given through the search index configuration.\n *\n * @param config - Search index configuration\n */\nfunction setupLunrLanguages(config: SearchIndexConfig): void {\n  const base = \"../lunr\"\n\n  /* Add scripts for languages */\n  const scripts = []\n  for (const lang of config.lang) {\n    if (lang === \"ja\") scripts.push(`${base}/tinyseg.min.js`)\n    if (lang !== \"en\") scripts.push(`${base}/min/lunr.${lang}.min.js`)\n  }\n\n  /* Add multi-language support */\n  if (scripts.length > 1)\n    scripts.push(`${base}/min/lunr.multi.min.js`)\n\n  /* Load scripts synchronously */\n  if (scripts.length)\n    self.importScripts(\n      `${base}/min/lunr.stemmer.support.min.js`,\n      ...scripts\n    )\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Message handler\n *\n * @param message - Source message\n *\n * @return Target message\n */\nexport function handler(message: SearchMessage): SearchMessage {\n  switch (message.type) {\n\n    /* Setup search index */\n    case SearchMessageType.SETUP:\n      setupLunrLanguages(message.data.config)\n      index = new SearchIndex(message.data)\n      return {\n        type: SearchMessageType.DUMP,\n        data: index.toString()\n      }\n\n    /* Query search index */\n    case SearchMessageType.QUERY:\n      return {\n        type: SearchMessageType.RESULT,\n        data: index ? index.search(message.data) : []\n      }\n\n    /* All other messages */\n    default:\n      throw new TypeError(\"Invalid message type\")\n  }\n}\n\n/* ----------------------------------------------------------------------------\n * Worker\n * ------------------------------------------------------------------------- */\n\nself.addEventListener(\"message\", ev => {\n  self.postMessage(handler(ev.data))\n})\n"],"sourceRoot":""}