{"version":3,"sources":["webpack:///./node_modules/.cache/nuxt/content/query-builder.js","webpack:///./node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack:///./node_modules/@lokidb/loki/lokidb.loki.js","webpack:///./node_modules/@lokidb/full-text-search/lokidb.full-text-search.js","webpack:///./node_modules/.cache/nuxt/content/plugin.client.lazy.js"],"names":["pick","obj","keys","Object","filter","key","includes","reduce","newObj","assign","omit","QueryBuilder","options","query","path","init","text","postprocess","this","onlyKeys","withoutKeys","sortKeys","limitN","skipN","unshift","data","map","item","Array","isArray","field","direction","push","find","value","$fts","type","prefix_length","fuzziness","extended","minimum_should_match","should","fullTextSearchFields","operator","sortByScoring","slugOrPath","before","after","_key","indexOf","fn","index","findIndex","slice","fill","prevSlice","nextSlice","prevIndex","i","nextIndex","n","parseInt","length","compoundsort","offset","limit","removeMeta","watch","Error","JSON","parse","stringify","module","exports","asyncGeneratorStep","gen","resolve","reject","_next","_throw","arg","info","error","done","Promise","then","self","args","arguments","apply","err","undefined","__esModule","factory","modules","installedModules","__webpack_require__","moduleId","l","call","m","c","d","name","getter","o","defineProperty","enumerable","get","r","Symbol","toStringTag","t","mode","ns","create","bind","object","property","prototype","hasOwnProperty","p","s","__webpack_exports__","ComparatorMap","_operator_packages__WEBPACK_IMPORTED_MODULE_0__","val","val2","v1","Date","toISOString","v2","global","getGlobal","glob","PLUGINS","sym","for","aeqHelper","prop1","prop2","t1","t2","cv1","Number","cv2","toString","ltHelper","equal","gtHelper","sortHelper","descending","LokiOperatorPackageMap","LokiOperatorPackage","$eq","a","b","$ne","$gt","$gte","$lt","$lte","$between","range","$in","$nin","$keyin","$nkeyin","$definedin","$undefinedin","$regex","test","$containsNone","$containsAny","checkFn","containsCheckFn","some","$contains","every","$type","doQueryOp","$finite","isFinite","$size","$len","$where","$not","$and","idx","len","$or","op","constructor","super","event_emitter","UniqueIndex","propertyField","_field","_lokiMap","_valMap","set","id","update","remove","oldValue","clear","add","copy","walk","target","getTime","Function","deepCopy","clone","method","cloned","operator_packages","comparators","resolveTransformObject","subObj","params","depth","prop","pname","substring","indexedOps","$dteq","result_set_ResultSet","collection","_filteredRows","_filterInitialized","_scoring","_collection","reset","toJSON","qty","_prepareFullDocIndex","pos","result","transform","parameters","_transforms","resolvedTransform","clonedStep","resolveTransformParams","rs","step","where","simplesort","sort","desc","dataOptions","eqJoin","joinData","leftJoinKey","rightJoinKey","mapFun","mapReduce","mapFunction","reduceFunction","comparefun","_data","propname","_rangedIndexes","sortedIds","rangeRequest","dataPositions","reverse","comparator","sortComparator","_unindexedSortComparator","properties","_compoundeval","obj1","obj2","res","ascending","score","getScoring","scoring","findOr","expressionArray","docset","idxset","origCount","count","ei","elen","fr","frlen","fri","findAnd","firstOnly","queryObject","queryObjectOp","filters","RegExp","searchByIndex","operatorPackage","_defaultLokiOperatorPackage","_fullTextSearch","search","_constraints","unique","row","rowIdx","ri","idResult","high","fun","viewFunction","TypeError","j","k","forceClones","forceCloneMethod","_cloneMethod","_disableDeltaChangesApi","_cloneObjects","_defineNestedProperties","$loki","meta","updateFunction","rcd","rightDataLength","rightData","leftKeyisFunction","rightKeyisFunction","joinMap","leftData","leftDataLength","collection_Collection","chain","left","right","insert","dynamic_view_DynamicView","_rebuildPending","_resultData","_resultDirty","_cachedResultSet","_filterPipeline","_sortFunction","_sortCriteria","_sortCriteriaSimple","_sortByScoring","_sortDirty","persistent","_persistent","sortPriority","_sortPriority","minRebuildInterval","_minRebuildInterval","_resultSet","_events","_rematerialize","removeWhereFilters","fpi","ofp","applyFind","emit","branchResultSet","static","dv","removeFilters","queueSortPhase","_queueSortPhase","applySort","applySimpleSort","applySortCriteria","criteria","applySortByScoring","startTransaction","commit","rollback","_indexOfFilterWithId","uid","_addFilter","reapplyFilters","_queueRebuildEvent","applyFilter","applyWhere","removeFilter","splice","_performSortPhase","suppressRebuildEvent","setTimeout","_evaluateDocument","objIndex","isNew","ofr","oldPos","oldlen","evalResultSet","newPos","_removeDocument","ranged_indexes","common_plugin","average","array","getNestedPropertyValue","pathIdx","curr","_idIndex","_lokimap","_dirty","_cached","_nestedProperties","_ttl","age","ttlInterval","daemon","_maxId","_dynamicViews","_changes","_stages","_commitLog","disableMeta","disableChangesApi","disableDeltaChangesApi","ttl","unindexedSortComparator","defaultLokiOperatorPackage","forEach","fullTextSearch","_transactional","transactional","_asyncListeners","asyncListeners","_disableMeta","_disableChangesApi","cloneMethod","_serializableIndexes","serializableIndexes","nestedProperties","nestedProperty","split","setTTL","_ensureId","rangedIndexes","ensureRangedIndex","indexTypeName","comparatorName","setChangesApi","flushChanges","uniqueNames","transforms","idIndex","maxId","cloneObjects","changes","coll","retainDirtyFlags","loader","collOptions","proto","inflater","inflate","src","dest","collObj","makeLoader","sri","rii","rif","restore","ensureUniqueIndex","fromJSONObject","addTransform","getTransform","setTransform","removeTransform","interval","clearInterval","setInterval","now","member","timestamp","updated","created","diff","indexes","ensureIndex","addDynamicView","removeDynamicView","getDynamicView","findAndUpdate","filterObject","findAndRemove","doc","insertOne","results","bulkInsert","returnObj","version","revision","_add","_insertMeta","_insertMetaWithChange","part","configurable","removeIndices","arr","oldInternal","position","newInternal","updateDocument","_updateMeta","_updateMetaWithChange","isNaN","newDoc","constrUnique","addedPos","dvlen","addDocument","updateWhere","filterFunction","removeWhere","removeDataOnly","aDoc","removeDocument","_createChange","getChanges","_getObjectDelta","oldObject","newObject","propertyNames","delta","propertyName","propertyDelta","_getChangeDelta","old","operation","_createInsertChange","_createUpdateChange","returnPosition","max","min","mid","by","lokiId","findOne","findOneUnindexed","rib","backup","leftJoinProp","rightJoinProp","getStage","stage","stageName","commitStage","message","extract","Math","extractNumerical","minRecord","parseFloat","maxRecord","avg","stdDev","values","avgSquareDiff","sqrt","standardDeviation","dict","maxCount","el","median","half","floor","AvlTreeIndex","nodes","apex","tree","node","parent","balance","height","siblings","insertNode","current","updateBalance","leftLeftCase","leftRightCase","rightRightCase","rightLeftCase","hl","hr","rotateRight","rotateLeft","getValuesAsTree","removeNode","alphaSiblingId","shift","alphaSibling","updateChildLink","si","promoteSuccessor","promoteChild","parentId","oldChildId","newChildId","child","gpId","gp","oldId","glsId","glsValue","glsSiblings","successor","lchild","findGreaterLeaf","rchild","findLesserLeaf","collateIds","match","locate","collateRequest","cmp1","cmp2","validateIndex","nc","validateNode","eh","sid","RangedIndexFactoryMap","LokiEventEmitter","on","eventName","listener","event","currentEventName","addListener","removeListener","listeners","Loki","_event_emitter__WEBPACK_IMPORTED_MODULE_0__","_collection__WEBPACK_IMPORTED_MODULE_1__","_common_plugin__WEBPACK_IMPORTED_MODULE_2__","_comparators__WEBPACK_IMPORTED_MODULE_3__","_ranged_indexes__WEBPACK_IMPORTED_MODULE_4__","_operator_packages__WEBPACK_IMPORTED_MODULE_5__","getENV","process","document","URL","window","SyntaxError","filename","databaseVersion","engineVersion","_persistenceMethod","_persistenceAdapter","_throttledSaves","_throttledSaveRunning","_throttledSavePending","_autosave","_autosaveInterval","_autosaveRunning","_autosaveHandler","_collections","serializationMethod","_serializationMethod","destructureDelimiter","_destructureDelimiter","env","_env","comparatorMap","rangedIndexFactoryMap","lokiOperatorPackageMap","lop","clearChanges","initializePersistence","loaded","_autosaveDisable","autosave","autosaveInterval","persistenceMethod","throttledSaves","DEFAULT_PERSISTENCE","PERSISTENCE_METHODS","adapter","possiblePersistenceMethods","autoload","_loadDatabase","_autosaveEnable","databaseCopy","loadJSONObject","removeNonSerializable","addCollection","loadCollection","getCollection","renameCollection","oldName","newName","listCollections","colls","removeCollection","collectionName","tmpcol","curcol","serialize","serializeDestructured","partitioned","delimited","delimiter","partition","serializeCollection","collectionIndex","dbcopy","reconstruct","sidx","join","doccount","resultlines","docidx","deserializeDestructured","destructuredSource","deserializeCollection","cdb","collCount","collIndex","workarray","lineIndex","pop","loadJSON","serializedDb","dbObject","close","_autosaveDirty","saveDatabase","generateChangesNotification","arrayOfCollectionNames","selectedCollections","concat","serializeChanges","collectionNamesArray","throttledSaveDrain","recursiveWait","recursiveWaitLimit","recursiveWaitLimitDuration","started","all","ignore_not_found","loadDatabase","dbString","catch","e","_saveDatabase","exportDatabase","_autosaveClearFlags","deleteDatabase","g","eval","_loki__WEBPACK_IMPORTED_MODULE_0__","whitespaceTokenizer","lowercaseTokenFilter","token","toLowerCase","uppercaseTokenFilter","toUpperCase","analyze","analyzer","str","char_filter","tokens","tokenizer","token_filter","analyzer_StandardAnalyzer","toCodePoints","chr","charCodeAt","low","inverted_index_InvertedIndex","docCount","docStore","Map","totalFieldLength","root","store","_store","optimizeChanges","_optimizeChanges","docId","has","fieldTokens","fieldLength","indexRef","defineProperties","writable","Set","tf","branch","pa","dc","df","delete","size","_remove","term","start","termIndices","extendTermIndex","_serializeIndex","serialized","invIdx","_deserializeIndex","_regenerate","v","ref","Scorer","invIdxs","_cache","_invIdxs","setDirty","fieldName","boost","termIdx","doScoring","queryResults","idf","_idf","scoreConstant","finalScore","finalResult","k1","bm25","explain","docScore","docExplanation","queryResult","_calculateFieldLength","avgFieldLength","_avgFieldLength","tfNorm","docID","String","fromCharCode","explanation","_getCache","idfs","docFreq","cache","log","RunAutomaton","automaton","getNumStates","_points","getStartPoints","_accept","_transitions","isAccept","_classmap","getCharClass","state","MAX_CODE_POINT","sortByDestMinMax","sortByMinMaxDest","Automaton","_stateTransitions","_nextState","_currState","createState","setAccept","accept","finishState","_finishCurrentState","upto","pointset","states","trans","tran","from","label","addTransition","source","Long","_low","_high","shiftRight","numBits","shiftLeft","and","other","toInt","MASKS","ParametricDescription","w","minErrors","_w","_n","_minErrors","absState","getPosition","bitsPerValue","bitLoc","dataLoc","bitStart","toStates0","offsetIncrs0","toStates1","offsetIncrs1","toStates2","offsetIncrs2","toStates3","offsetIncrs3","lev1t_parametric_description_Lev1TParametricDescription","transition","vector","loc","unpack","lev2t_parametric_description_toStates0","lev2t_parametric_description_offsetIncrs0","lev2t_parametric_description_toStates1","lev2t_parametric_description_offsetIncrs1","lev2t_parametric_description_toStates2","lev2t_parametric_description_offsetIncrs2","lev2t_parametric_description_toStates3","lev2t_parametric_description_offsetIncrs3","toStates4","offsetIncrs4","toStates5","offsetIncrs5","lev2t_parametric_description_Lev2TParametricDescription","levenshtein_automata_LevenshteinAutomata","input","editDistance","_word","_editDistance","_alphabet","_numRanges","_rangeLower","_rangeUpper","lower","higher","_description","toAutomaton","automat","numStates","xpos","end","x","ch","cvec","_getVector","calculateMinShouldMatch","optionalClauseCount","spec","parts","calc","ceil","index_searcher_IndexSearcher","docs","_docs","_scorer","_recursive","calculate_scoring","must","_getUnique","shouldDocs","_getAll","empty","msm","not","notDocs","_","cps","getTermIndex","f","prefixLength","startIdx","prefix","fuzzy","determineEditDistance","ed","prev","calculateLevenshteinDistance","recursive","distance","fuzzySearch","enableScoring","enable_scoring","wildcard","escaped","indices","wildcardSearch","tmpQueryResults","termIdxs","terms","boolQuery","subQueries","queries","currDocs","full_text_search_FullTextSearch","fieldOptions","fieldOption","_id","_idxSearcher","fieldNames","ii","analyzers","fts","LokiFullTextSearch","register","db","items","dirs","$content","paths","argument","deep","replace","isDir","dir","database"],"mappings":"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","file":"60987fe.js","sourcesContent":["const pick = (obj, keys = []) => {\n  return Object.keys(obj)\n    .filter(key => keys.includes(key))\n    .reduce((newObj, key) => Object.assign(newObj, { [key]: obj[key] }), {})\n}\n\nconst omit = (obj, keys = []) => {\n  return Object.keys(obj)\n    .filter(key => !keys.includes(key))\n    .reduce((newObj, key) => Object.assign(newObj, { [key]: obj[key] }), {})\n}\n\nclass QueryBuilder {\n  constructor ({ query, path, init, text, postprocess = [] }, options) {\n    this.query = query\n    this.path = path\n    this.init = init\n    this.postprocess = postprocess\n    this.options = options || {}\n    this.onlyKeys = null\n    this.withoutKeys = null\n    this.sortKeys = []\n    this.limitN = null\n    this.skipN = null\n\n    if (!text) {\n      // Remove text field from response\n      this.postprocess.unshift(data => data.map(item => omit(item, ['text'])))\n    }\n  }\n\n  /**\n   * Select a subset of fields\n   * @param {Array} keys - Array of fields to be picked.\n   * @returns {QueryBuilder} Returns current instance to be chained\n   */\n  only (keys) {\n    // Assign keys to this.onlyKeys to be processed in fetch\n    this.onlyKeys = Array.isArray(keys) ? keys : [keys]\n    // Return current instance\n    return this\n  }\n\n  /**\n   * Remove a subset of fields\n   * @param {Array} keys - Array of fields to be picked.\n   * @returns {QueryBuilder} Returns current instance to be chained\n   */\n  without (keys) {\n    // Assign keys to this.withoutKeys to be processed in fetch\n    this.withoutKeys = Array.isArray(keys) ? keys : [keys]\n    // Return current instance\n    return this\n  }\n\n  /**\n   * Sort results\n   * @param {string} field - Field key to sort on.\n   * @param {string} direction - Direction of sort (asc / desc).\n   * @returns {QueryBuilder} Returns current instance to be chained\n   */\n  sortBy (field, direction) {\n    this.sortKeys.push([field, direction === 'desc'])\n    return this\n  }\n\n  /**\n   * Filter results\n   * @param {object} query - Where query.\n   * @returns {QueryBuilder} Returns current instance to be chained\n   */\n  where (query) {\n    this.query = this.query.find(query)\n    return this\n  }\n\n  /**\n   * Search results\n   * @param {(Object|string)} query - Search query object or field or search value.\n   * @param {string} value - Value of search (means query equals to field).\n   * @returns {QueryBuilder} Returns current instance to be chained\n   */\n  search (query, value) {\n    // Passing an empty or falsey value as query will avoid triggering a search to allow optional chaining\n    if (!query) { return this }\n\n    let $fts\n\n    if (typeof query === 'object') {\n      $fts = query\n    } else if (value) {\n      $fts = {\n        query: {\n          type: 'match',\n          field: query,\n          value,\n          prefix_length: 1,\n          fuzziness: 1,\n          extended: true,\n          minimum_should_match: 1\n        }\n      }\n    } else {\n      $fts = {\n        query: {\n          type: 'bool',\n          should: this.options.fullTextSearchFields.map(field => ({\n            type: 'match',\n            field,\n            value: query,\n            prefix_length: 1,\n            operator: 'and',\n            minimum_should_match: 1,\n            fuzziness: 1,\n            extended: true\n          }))\n        }\n      }\n    }\n\n    this.query = this.query.find({ $fts }).sortByScoring()\n\n    return this\n  }\n\n  /**\n   * Surround results\n   * @param {string} slugOrPath - Slug or path of the file to surround.\n   * @param {Object} options - Options to surround (before / after).\n   * @returns {QueryBuilder} Returns current instance to be chained\n   */\n  surround (slugOrPath, { before = 1, after = 1 } = {}) {\n    const _key = slugOrPath.indexOf('/') === 0 ? 'path' : 'slug'\n\n    // Add slug or path to onlyKeys if only method has been called before\n    if (this.onlyKeys) {\n      this.onlyKeys.push(_key)\n    }\n    // Remove slug or path from withoutKeys if without method has been called before\n    if (this.withoutKeys) {\n      this.withoutKeys = this.withoutKeys.filter(key => key !== _key)\n    }\n\n    const fn = (data) => {\n      const index = data.findIndex(item => item[_key] === slugOrPath)\n      const slice = new Array(before + after).fill(null, 0)\n      if (index === -1) {\n        return slice\n      }\n\n      const prevSlice = data.slice(index - before, index)\n      const nextSlice = data.slice(index + 1, index + 1 + after)\n\n      let prevIndex = 0\n      for (let i = before - 1; i >= 0; i--) {\n        slice[i] = prevSlice[prevIndex] || null\n        prevIndex++\n      }\n\n      let nextIndex = 0\n      for (let i = before; i <= after; i++) {\n        slice[i] = nextSlice[nextIndex] || null\n        nextIndex++\n      }\n\n      return slice\n    }\n\n    this.postprocess.push(fn)\n    return this\n  }\n\n  /**\n   * Limit number of results\n   * @param {number} n - Limit number.\n   * @returns {QueryBuilder} Returns current instance to be chained\n   */\n  limit (n) {\n    if (typeof n === 'string') { n = parseInt(n) }\n\n    this.limitN = n\n    return this\n  }\n\n  /**\n   * Skip number of results\n   * @param {number} n - Skip number.\n   * @returns {QueryBuilder} Returns current instance to be chained\n   */\n  skip (n) {\n    if (typeof n === 'string') { n = parseInt(n) }\n\n    this.skipN = n\n    return this\n  }\n\n  /**\n   * Collect data and apply process filters\n   * @returns {(Object|Array)} Returns processed data\n   */\n  // eslint-disable-next-line require-await\n  async fetch () {\n    if (this.sortKeys && this.sortKeys.length) {\n      this.query = this.query.compoundsort(this.sortKeys)\n    }\n    if (this.skipN) {\n      this.query = this.query.offset(this.skipN)\n    }\n    if (this.limitN) {\n      this.query = this.query.limit(this.limitN)\n    }\n    // Collect data without meta fields\n    let data = this.query.data({ removeMeta: true })\n    // Handle only keys\n    if (this.onlyKeys) {\n      // Add `path` and `extension` to onlyKeys if watch to ensure live edit\n      if (this.options.watch) {\n        this.onlyKeys.push('path', 'extension')\n      }\n      // Map data and returns object picked by keys\n      const fn = data => data.map(item => pick(item, this.onlyKeys))\n      // Apply pick during postprocess\n      this.postprocess.unshift(fn)\n    }\n    // Handle without keys\n    if (this.withoutKeys) {\n      // Remove `path` and `extension` from withoutKeys if watch to ensure live edit\n      if (this.options.watch) {\n        this.withoutKeys = this.withoutKeys.filter(key => !['path', 'extension'].includes(key))\n      }\n      // Map data and returns object picked by keys\n      const fn = data => data.map(item => omit(item, this.withoutKeys))\n      // Apply pick during postprocess\n      this.postprocess.unshift(fn)\n    }\n    // Apply postprocess fns to data\n    for (const fn of this.postprocess) {\n      data = fn(data)\n    }\n\n    if (!data) {\n      throw new Error(`${this.path} not found`)\n    }\n\n    return JSON.parse(JSON.stringify(data))\n  }\n}\n\nmodule.exports = QueryBuilder\n","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n      args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n      _next(undefined);\n    });\n  };\n}\nmodule.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"@lokidb/loki\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"@lokidb/loki\"] = factory();\n\telse\n\t\t{ root[\"@lokidb/loki\"] = factory(); root[\"Loki\"] = root[\"@lokidb/loki\"].default; }\n})(typeof self !== 'undefined' ? self : this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \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 = 8);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return ComparatorMap; });\n/* unused harmony export CreateJavascriptComparator */\n/* unused harmony export CreateAbstractJavascriptComparator */\n/* unused harmony export CreateAbstractDateJavascriptComparator */\n/* unused harmony export CreateLokiComparator */\n/* harmony import */ var _operator_packages__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);\n/**\n * This file contains LokiOperatorPackages, RangedIndex and Comparator interfaces, as well as\n * global map object instances for registered LokiOperatorPackages, RangedIndex implementations, and Comparator functions\n */\n\n/** Map/Register of named ILokiComparer functions returning -1, 0, 1 for lt/eq/gt assertions for two passed parameters */\nlet ComparatorMap = {\n    \"js\": CreateJavascriptComparator(),\n    \"abstract-js\": CreateAbstractJavascriptComparator(),\n    \"abstract-date\": CreateAbstractDateJavascriptComparator(),\n    \"loki\": CreateLokiComparator()\n};\n/** Typescript-friendly factory for strongly typed 'js' comparators */\nfunction CreateJavascriptComparator() {\n    return (val, val2) => {\n        if (val === val2)\n            return 0;\n        if (val < val2)\n            return -1;\n        return 1;\n    };\n}\n/** Typescript-friendly factory for strongly typed 'abstract js' comparators */\nfunction CreateAbstractJavascriptComparator() {\n    return (val, val2) => {\n        if (val == val2)\n            return 0;\n        if (val < val2)\n            return -1;\n        return 1;\n    };\n}\n/**\n * Comparator which attempts to deal with deal with dates at comparator level.\n * Should work for dates in any of the object, string, and number formats\n */\nfunction CreateAbstractDateJavascriptComparator() {\n    return (val, val2) => {\n        let v1 = (new Date(val).toISOString());\n        let v2 = (new Date(val2).toISOString());\n        if (v1 == v2)\n            return 0;\n        if (v1 < v2)\n            return -1;\n        return 1;\n    };\n}\n/** Typescript-friendly factory for strongly typed 'loki' comparators */\nfunction CreateLokiComparator() {\n    return (val, val2) => {\n        if (Object(_operator_packages__WEBPACK_IMPORTED_MODULE_0__[/* aeqHelper */ \"b\"])(val, val2))\n            return 0;\n        if (Object(_operator_packages__WEBPACK_IMPORTED_MODULE_0__[/* ltHelper */ \"c\"])(val, val2, false))\n            return -1;\n        return 1;\n    };\n}\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return PLUGINS; });\nfunction getGlobal() {\n    let glob;\n    (function (global) {\n        glob = global;\n    })(global !== undefined && global || this);\n    return glob;\n}\nfunction create() {\n    const global = getGlobal();\n    const sym = Symbol.for(\"LOKI\");\n    if (global[sym] === undefined) {\n        global[sym] = {};\n    }\n    return global[sym];\n}\n/**\n * @hidden\n */\nconst PLUGINS = create();\n\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(7)))\n\n/***/ }),\n/* 2 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"b\", function() { return aeqHelper; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"c\", function() { return ltHelper; });\n/* unused harmony export gtHelper */\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"d\", function() { return sortHelper; });\n/* unused harmony export LokiOperatorPackage */\n/* unused harmony export LokiAbstractOperatorPackage */\n/* unused harmony export ComparatorOperatorPackage */\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return LokiOperatorPackageMap; });\n/**\n * Helper function for determining 'loki' abstract equality which is a little more abstract than ==\n *     aeqHelper(5, '5') === true\n *     aeqHelper(5.0, '5') === true\n *     aeqHelper(new Date(\"1/1/2011\"), new Date(\"1/1/2011\")) === true\n *     aeqHelper({a:1}, {z:4}) === true (all objects sorted equally)\n *     aeqHelper([1, 2, 3], [1, 3]) === false\n *     aeqHelper([1, 2, 3], [1, 2, 3]) === true\n *     aeqHelper(undefined, null) === true\n * @param {any} prop1\n * @param {any} prop2\n * @returns {boolean}\n * @hidden\n */\nfunction aeqHelper(prop1, prop2) {\n    if (prop1 === prop2)\n        return true;\n    // 'falsy' and Boolean handling\n    if (!prop1 || !prop2 || prop1 === true || prop2 === true || prop1 !== prop1 || prop2 !== prop2) {\n        let t1;\n        let t2;\n        // dates and NaN conditions (typed dates before serialization)\n        switch (prop1) {\n            case undefined:\n                t1 = 1;\n                break;\n            case null:\n                t1 = 1;\n                break;\n            case false:\n                t1 = 3;\n                break;\n            case true:\n                t1 = 4;\n                break;\n            case \"\":\n                t1 = 5;\n                break;\n            default:\n                t1 = (prop1 === prop1) ? 9 : 0;\n                break;\n        }\n        switch (prop2) {\n            case undefined:\n                t2 = 1;\n                break;\n            case null:\n                t2 = 1;\n                break;\n            case false:\n                t2 = 3;\n                break;\n            case true:\n                t2 = 4;\n                break;\n            case \"\":\n                t2 = 5;\n                break;\n            default:\n                t2 = (prop2 === prop2) ? 9 : 0;\n                break;\n        }\n        // one or both is edge case\n        if (t1 !== 9 || t2 !== 9) {\n            return (t1 === t2);\n        }\n    }\n    // Handle 'Number-like' comparisons\n    let cv1 = Number(prop1);\n    let cv2 = Number(prop2);\n    // if one or both are 'number-like'...\n    if (cv1 === cv1 || cv2 === cv2) {\n        return (cv1 === cv2);\n    }\n    // not strict equal nor less than nor gt so must be mixed types, convert to string and use that to compare\n    cv1 = prop1.toString();\n    cv2 = prop2.toString();\n    return (cv1 == cv2);\n}\n/**\n * Helper function for determining 'less-than' conditions for ops, sorting, and binary indices.\n *     In the future we might want $lt and $gt ops to use their own functionality/helper.\n *     Since binary indices on a property might need to index [12, NaN, new Date(), Infinity], we\n *     need this function (as well as gtHelper) to always ensure one value is LT, GT, or EQ to another.\n * @hidden\n */\nfunction ltHelper(prop1, prop2, equal) {\n    // if one of the params is falsy or strictly true or not equal to itself\n    // 0, 0.0, \"\", NaN, null, undefined, not defined, false, true\n    if (!prop1 || !prop2 || prop1 === true || prop2 === true || prop1 !== prop1 || prop2 !== prop2) {\n        let t1;\n        let t2;\n        switch (prop1) {\n            case undefined:\n                t1 = 1;\n                break;\n            case null:\n                t1 = 1;\n                break;\n            case false:\n                t1 = 3;\n                break;\n            case true:\n                t1 = 4;\n                break;\n            case \"\":\n                t1 = 5;\n                break;\n            // if strict equal probably 0 so sort higher, otherwise probably NaN so sort lower than even null\n            default:\n                t1 = (prop1 === prop1) ? 9 : 0;\n                break;\n        }\n        switch (prop2) {\n            case undefined:\n                t2 = 1;\n                break;\n            case null:\n                t2 = 1;\n                break;\n            case false:\n                t2 = 3;\n                break;\n            case true:\n                t2 = 4;\n                break;\n            case \"\":\n                t2 = 5;\n                break;\n            default:\n                t2 = (prop2 === prop2) ? 9 : 0;\n                break;\n        }\n        // one or both is edge case\n        if (t1 !== 9 || t2 !== 9) {\n            return (t1 === t2) ? equal : (t1 < t2);\n        }\n    }\n    // if both are numbers (string encoded or not), compare as numbers\n    let cv1 = Number(prop1);\n    let cv2 = Number(prop2);\n    if (cv1 === cv1 && cv2 === cv2) {\n        if (cv1 < cv2)\n            return true;\n        if (cv1 > cv2)\n            return false;\n        return equal;\n    }\n    if (cv1 === cv1 && cv2 !== cv2) {\n        return true;\n    }\n    if (cv2 === cv2 && cv1 !== cv1) {\n        return false;\n    }\n    if (prop1 < prop2)\n        return true;\n    if (prop1 > prop2)\n        return false;\n    if (prop1 == prop2)\n        return equal;\n    // not strict equal nor less than nor gt so must be mixed types, convert to string and use that to compare\n    cv1 = prop1.toString();\n    cv2 = prop2.toString();\n    if (cv1 < cv2) {\n        return true;\n    }\n    if (cv1 == cv2) {\n        return equal;\n    }\n    return false;\n}\n/**\n * @hidden\n * @param {any} prop1\n * @param {any} prop2\n * @param {boolean} equal\n * @returns {boolean}\n */\nfunction gtHelper(prop1, prop2, equal) {\n    // 'falsy' and Boolean handling\n    if (!prop1 || !prop2 || prop1 === true || prop2 === true || prop1 !== prop1 || prop2 !== prop2) {\n        let t1;\n        let t2;\n        switch (prop1) {\n            case undefined:\n                t1 = 1;\n                break;\n            case null:\n                t1 = 1;\n                break;\n            case false:\n                t1 = 3;\n                break;\n            case true:\n                t1 = 4;\n                break;\n            case \"\":\n                t1 = 5;\n                break;\n            // NaN 0\n            default:\n                t1 = (prop1 === prop1) ? 9 : 0;\n                break;\n        }\n        switch (prop2) {\n            case undefined:\n                t2 = 1;\n                break;\n            case null:\n                t2 = 1;\n                break;\n            case false:\n                t2 = 3;\n                break;\n            case true:\n                t2 = 4;\n                break;\n            case \"\":\n                t2 = 5;\n                break;\n            default:\n                t2 = (prop2 === prop2) ? 9 : 0;\n                break;\n        }\n        // one or both is edge case\n        if (t1 !== 9 || t2 !== 9) {\n            return (t1 === t2) ? equal : (t1 > t2);\n        }\n    }\n    // if both are numbers (string encoded or not), compare as numbers\n    let cv1 = Number(prop1);\n    let cv2 = Number(prop2);\n    if (cv1 === cv1 && cv2 === cv2) {\n        if (cv1 > cv2)\n            return true;\n        if (cv1 < cv2)\n            return false;\n        return equal;\n    }\n    if (cv1 === cv1 && cv2 !== cv2) {\n        return false;\n    }\n    if (cv2 === cv2 && cv1 !== cv1) {\n        return true;\n    }\n    if (prop1 > prop2)\n        return true;\n    if (prop1 < prop2)\n        return false;\n    if (prop1 == prop2)\n        return equal;\n    // not strict equal nor less than nor gt so must be dates or mixed types\n    // convert to string and use that to compare\n    cv1 = prop1.toString();\n    cv2 = prop2.toString();\n    if (cv1 > cv2) {\n        return true;\n    }\n    if (cv1 == cv2) {\n        return equal;\n    }\n    return false;\n}\n/**\n * @param {any} prop1\n * @param {any} prop2\n * @param {boolean} descending\n * @returns {number}\n * @hidden\n */\nfunction sortHelper(prop1, prop2, descending) {\n    if (aeqHelper(prop1, prop2)) {\n        return 0;\n    }\n    if (ltHelper(prop1, prop2, false)) {\n        return descending ? 1 : -1;\n    }\n    if (gtHelper(prop1, prop2, false)) {\n        return descending ? -1 : 1;\n    }\n    // not lt, not gt so implied equality-- date compatible\n    return 0;\n}\n/**\n * Default implementation of LokiOperatorPackage, using fastest javascript comparison operators.\n */\nclass LokiOperatorPackage {\n    // comparison operators\n    // a is the value in the collection\n    // b is the query value\n    $eq(a, b) {\n        return a === b;\n    }\n    $ne(a, b) {\n        return a !== b;\n    }\n    $gt(a, b) {\n        return a > b;\n    }\n    $gte(a, b) {\n        return a >= b;\n    }\n    $lt(a, b) {\n        return a < b;\n    }\n    $lte(a, b) {\n        return a <= b;\n    }\n    $between(a, range) {\n        if (a === undefined || a === null)\n            return false;\n        return a >= range[0] && a <= range[1];\n    }\n    $in(a, b) {\n        return b.indexOf(a) !== -1;\n    }\n    $nin(a, b) {\n        return b.indexOf(a) === -1;\n    }\n    $keyin(a, b) {\n        return a in b;\n    }\n    $nkeyin(a, b) {\n        return !(a in b);\n    }\n    $definedin(a, b) {\n        return b[a] !== undefined;\n    }\n    $undefinedin(a, b) {\n        return b[a] === undefined;\n    }\n    $regex(a, b) {\n        return b.test(a);\n    }\n    $containsNone(a, b) {\n        return !this.$containsAny(a, b);\n    }\n    $containsAny(a, b) {\n        const checkFn = this.containsCheckFn(a);\n        if (checkFn !== null) {\n            return (Array.isArray(b)) ? (b.some(checkFn)) : (checkFn(b));\n        }\n        return false;\n    }\n    $contains(a, b) {\n        const checkFn = this.containsCheckFn(a);\n        if (checkFn !== null) {\n            return (Array.isArray(b)) ? (b.every(checkFn)) : (checkFn(b));\n        }\n        return false;\n    }\n    $type(a, b) {\n        let type = typeof a;\n        if (type === \"object\") {\n            if (Array.isArray(a)) {\n                type = \"array\";\n            }\n            else if (a instanceof Date) {\n                type = \"date\";\n            }\n        }\n        return (typeof b !== \"object\") ? (type === b) : this.doQueryOp(type, b);\n    }\n    $finite(a, b) {\n        return (b === isFinite(a));\n    }\n    $size(a, b) {\n        if (Array.isArray(a)) {\n            return (typeof b !== \"object\") ? (a.length === b) : this.doQueryOp(a.length, b);\n        }\n        return false;\n    }\n    $len(a, b) {\n        if (typeof a === \"string\") {\n            return (typeof b !== \"object\") ? (a.length === b) : this.doQueryOp(a.length, b);\n        }\n        return false;\n    }\n    $where(a, b) {\n        return b(a) === true;\n    }\n    // field-level logical operators\n    // a is the value in the collection\n    // b is the nested query operation (for '$not')\n    //   or an array of nested query operations (for '$and' and '$or')\n    $not(a, b) {\n        return !this.doQueryOp(a, b);\n    }\n    $and(a, b) {\n        for (let idx = 0, len = b.length; idx < len; idx++) {\n            if (!this.doQueryOp(a, b[idx])) {\n                return false;\n            }\n        }\n        return true;\n    }\n    $or(a, b) {\n        for (let idx = 0, len = b.length; idx < len; idx++) {\n            if (this.doQueryOp(a, b[idx])) {\n                return true;\n            }\n        }\n        return false;\n    }\n    doQueryOp(val, op) {\n        for (let p in op) {\n            if (Object.hasOwnProperty.call(op, p)) {\n                return this[p](val, op[p]);\n            }\n        }\n        return false;\n    }\n    containsCheckFn(a) {\n        if (typeof a === \"string\" || Array.isArray(a)) {\n            return (b) => a.indexOf(b) !== -1;\n        }\n        else if (typeof a === \"object\" && a !== null) {\n            return (b) => Object.hasOwnProperty.call(a, b);\n        }\n        return null;\n    }\n}\n/**\n * LokiOperatorPackage which utilizes abstract 'loki' comparisons for basic relational equality op implementations.\n */\nclass LokiAbstractOperatorPackage extends LokiOperatorPackage {\n    constructor() {\n        super();\n    }\n    $eq(a, b) {\n        return aeqHelper(a, b);\n    }\n    $ne(a, b) {\n        return !aeqHelper(a, b);\n    }\n    $gt(a, b) {\n        return gtHelper(a, b, false);\n    }\n    $gte(a, b) {\n        return gtHelper(a, b, true);\n    }\n    $lt(a, b) {\n        return ltHelper(a, b, false);\n    }\n    $lte(a, b) {\n        return ltHelper(a, b, true);\n    }\n    $between(a, range) {\n        if (a === undefined || a === null)\n            return false;\n        return gtHelper(a, range[0], true) && ltHelper(a, range[1], true);\n    }\n}\n/**\n * LokiOperatorPackage which utilizes provided comparator for basic relational equality op implementations.\n */\nclass ComparatorOperatorPackage extends LokiOperatorPackage {\n    constructor(comparator) {\n        super();\n        this.comparator = comparator;\n    }\n    $eq(a, b) {\n        return this.comparator(a, b) === 0;\n    }\n    $ne(a, b) {\n        return this.comparator(a, b) !== 0;\n    }\n    $gt(a, b) {\n        return this.comparator(a, b) === 1;\n    }\n    $gte(a, b) {\n        return this.comparator(a, b) > -1;\n    }\n    $lt(a, b) {\n        return this.comparator(a, b) === -1;\n    }\n    $lte(a, b) {\n        return this.comparator(a, b) < 1;\n    }\n    $between(a, range) {\n        if (a === undefined || a === null)\n            return false;\n        return this.comparator(a, range[0]) > -1 && this.comparator(a, range[1]) < 1;\n    }\n}\n/**\n * Map/Register of named LokiOperatorPackages which implement all unindexed query ops within 'find' query objects\n */\nlet LokiOperatorPackageMap = {\n    \"js\": new LokiOperatorPackage(),\n    \"loki\": new LokiAbstractOperatorPackage()\n};\n\n\n/***/ }),\n/* 3 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n\n// EXTERNAL MODULE: ./packages/loki/src/event_emitter.ts\nvar event_emitter = __webpack_require__(5);\n\n// CONCATENATED MODULE: ./packages/loki/src/unique_index.ts\nclass UniqueIndex {\n    /**\n     * Constructs an unique index object.\n     * @param {string} propertyField - the property field to index\n     */\n    constructor(propertyField) {\n        this._field = propertyField;\n        this._lokiMap = {};\n        this._valMap = {};\n    }\n    /**\n     * Sets a document's unique index.\n     * @param {number} id loki id to associate with value\n     * @param {*} value  value to associate with id\n     */\n    set(id, value) {\n        // unique index should not include null/undefined values\n        if (value !== null && value !== undefined) {\n            if (value in this._lokiMap) {\n                throw new Error(\"Duplicate key for property \" + this._field + \": \" + value);\n            }\n            if (id in this._valMap) {\n                throw new Error(\"Duplicate key for property $loki : \" + id);\n            }\n            this._lokiMap[value] = id;\n            this._valMap[id] = value;\n        }\n    }\n    /**\n     * Returns the $loki id of an unique value.\n     * @param {*} value the value to retrieve a loki id match for\n     */\n    get(value) {\n        return this._lokiMap[value];\n    }\n    /**\n     * Updates a document's unique index.\n     * @param {number} id (loki) id of document to update the value to\n     * @param {*} value value to associate with loki id\n     */\n    update(id, value) {\n        // if the value has not changed, do nothing\n        if (value === this._valMap[id]) {\n            return;\n        }\n        // the value must have changed, so check if new value already exists\n        if (value in this._lokiMap) {\n            throw new Error(\"Duplicate key for property \" + this._field + \": \" + value);\n        }\n        this.remove(id);\n        this.set(id, value);\n    }\n    /**\n     * Removes an unique index.\n     * @param {number} id (loki) id to remove from index\n     */\n    remove(id) {\n        if (!(id in this._valMap)) {\n            throw new Error(\"Key is not in unique index: \" + this._field);\n        }\n        let oldValue = this._valMap[id];\n        delete this._lokiMap[oldValue];\n        delete this._valMap[id];\n    }\n    /**\n     * Clears the unique index.\n     */\n    clear() {\n        this._lokiMap = {};\n        this._valMap = {};\n    }\n}\n\n// CONCATENATED MODULE: ./packages/loki/src/clone.ts\nfunction add(copy, key, value) {\n    if (copy instanceof Array) {\n        copy.push(value);\n        return copy[copy.length - 1];\n    }\n    else if (copy instanceof Object) {\n        copy[key] = value;\n        return copy[key];\n    }\n}\nfunction walk(target, copy) {\n    for (let key in target) {\n        let obj = target[key];\n        if (obj instanceof Date) {\n            let value = new Date(obj.getTime());\n            add(copy, key, value);\n        }\n        else if (obj instanceof Function) {\n            let value = obj;\n            add(copy, key, value);\n        }\n        else if (obj instanceof Array) {\n            let value = [];\n            let last = add(copy, key, value);\n            walk(obj, last);\n        }\n        else if (obj instanceof Object) {\n            let value = {};\n            let last = add(copy, key, value);\n            walk(obj, last);\n        }\n        else {\n            let value = obj;\n            add(copy, key, value);\n        }\n    }\n}\n// Deep copy from Simeon Velichkov.\n/**\n * @param target\n * @returns {any}\n */\nfunction deepCopy(target) {\n    if (/number|string|boolean/.test(typeof target)) {\n        return target;\n    }\n    else if (target instanceof Date) {\n        return new Date(target.getTime());\n    }\n    const copy = (target instanceof Array) ? [] : {};\n    walk(target, copy);\n    return copy;\n}\n/**\n * @hidden\n */\nfunction clone(data, method = \"parse-stringify\") {\n    if (data === null || data === undefined) {\n        return null;\n    }\n    let cloned;\n    switch (method) {\n        case \"parse-stringify\":\n            cloned = JSON.parse(JSON.stringify(data));\n            break;\n        case \"deep\":\n            cloned = deepCopy(data);\n            break;\n        case \"shallow\":\n            cloned = Object.create(data.constructor.prototype);\n            Object.assign(cloned, data);\n            break;\n        case \"shallow-recurse\":\n            // shallow clone top level properties\n            cloned = clone(data, \"shallow\");\n            const keys = Object.keys(data);\n            // for each of the top level properties which are object literals, recursively shallow copy\n            for (let i = 0; i < keys.length; i++) {\n                const key = keys[i];\n                if (typeof data[key] === \"object\" && data[key].constructor.name === \"Object\") {\n                    cloned[key] = clone(data[key], \"shallow-recurse\");\n                }\n            }\n            break;\n        default:\n            break;\n    }\n    return cloned;\n}\n\n// EXTERNAL MODULE: ./packages/loki/src/operator_packages.ts\nvar operator_packages = __webpack_require__(2);\n\n// EXTERNAL MODULE: ./packages/loki/src/comparators.ts\nvar comparators = __webpack_require__(0);\n\n// CONCATENATED MODULE: ./packages/loki/src/result_set.ts\n\n\n\n\n// used to recursively scan hierarchical transform step object for param substitution\nfunction resolveTransformObject(subObj, params, depth = 0) {\n    if (++depth >= 10) {\n        return subObj;\n    }\n    for (const prop in subObj) {\n        if (typeof subObj[prop] === \"string\" && subObj[prop].indexOf(\"[%lktxp]\") === 0) {\n            const pname = subObj[prop].substring(8);\n            if (params[pname] !== undefined) {\n                subObj[prop] = params[pname];\n            }\n        }\n        else if (typeof subObj[prop] === \"object\") {\n            subObj[prop] = resolveTransformObject(subObj[prop], params, depth);\n        }\n    }\n    return subObj;\n}\n// top level utility to resolve an entire (single) transform (array of steps) for parameter substitution\nfunction resolveTransformParams(transform, params) {\n    if (params === undefined) {\n        return transform;\n    }\n    // iterate all steps in the transform array\n    const resolvedTransform = [];\n    for (let idx = 0; idx < transform.length; idx++) {\n        // clone transform so our scan/replace can operate directly on cloned transform\n        const clonedStep = clone(transform[idx], \"shallow-recurse\");\n        resolvedTransform.push(resolveTransformObject(clonedStep, params));\n    }\n    return resolvedTransform;\n}\n/**\n * @hidden\n */\n// if an op is registered in this object, our 'calculateRange' can use it with our binary indices.\n// if the op is registered to a function, we will run that function/op as a 2nd pass filter on results.\n// those 2nd pass filter functions should be similar to LokiOps functions, accepting 2 vals to compare.\nconst indexedOps = {\n    $eq: true,\n    $dteq: true,\n    $gt: true,\n    $gte: true,\n    $lt: true,\n    $lte: true,\n    $in: true,\n    $between: true\n};\n/**\n * ResultSet class allowing chainable queries.  Intended to be instanced internally.\n *    Collection.find(), Collection.where(), and Collection.chain() instantiate this.\n *\n * @example\n *    mycollection.chain()\n *      .find({ 'doors' : 4 })\n *      .where(function(obj) { return obj.name === 'Toyota' })\n *      .data();\n *\n * @param <TData> - the data type\n * @param <TNested> - nested properties of data type\n */\nclass result_set_ResultSet {\n    /**\n     * Constructor.\n     * @param {Collection} collection - the collection which this ResultSet will query against\n     */\n    constructor(collection) {\n        this._filteredRows = [];\n        this._filterInitialized = false;\n        // Holds the scoring result of the last full-text search.\n        this._scoring = null;\n        // retain reference to collection we are querying against\n        this._collection = collection;\n    }\n    /**\n     * Reset the ResultSet to its initial state.\n     * @returns {ResultSet} Reference to this ResultSet, for future chain operations.\n     */\n    reset() {\n        if (this._filteredRows.length > 0) {\n            this._filteredRows = [];\n        }\n        this._filterInitialized = false;\n        return this;\n    }\n    /**\n     * Override of toJSON to avoid circular references\n     */\n    toJSON() {\n        const copy = this.copy();\n        copy._collection = null;\n        return copy;\n    }\n    /**\n     * Allows you to limit the number of documents passed to next chain operation.\n     * A ResultSet copy() is made to avoid altering original ResultSet.\n     * @param {int} qty - The number of documents to return.\n     * @returns {ResultSet} Returns a copy of the ResultSet, limited by qty, for subsequent chain ops.\n     */\n    limit(qty) {\n        // if this has no filters applied, we need to populate filteredRows first\n        if (!this._filterInitialized && this._filteredRows.length === 0) {\n            this._filteredRows = this._collection._prepareFullDocIndex();\n        }\n        this._filteredRows = this._filteredRows.slice(0, qty);\n        this._filterInitialized = true;\n        return this;\n    }\n    /**\n     * Used for skipping 'pos' number of documents in the ResultSet.\n     * @param {int} pos - Number of documents to skip; all preceding documents are filtered out.\n     * @returns {ResultSet} Returns a copy of the ResultSet, containing docs starting at 'pos' for subsequent chain ops.\n     */\n    offset(pos) {\n        // if this has no filters applied, we need to populate filteredRows first\n        if (!this._filterInitialized && this._filteredRows.length === 0) {\n            this._filteredRows = this._collection._prepareFullDocIndex();\n        }\n        this._filteredRows = this._filteredRows.slice(pos);\n        this._filterInitialized = true;\n        return this;\n    }\n    /**\n     * To support reuse of ResultSet in branched query situations.\n     * @returns {ResultSet} Returns a copy of the ResultSet (set) but the underlying document references will be the same.\n     */\n    copy() {\n        const result = new result_set_ResultSet(this._collection);\n        result._filteredRows = this._filteredRows.slice();\n        result._filterInitialized = this._filterInitialized;\n        return result;\n    }\n    /**\n     * Executes a named collection transform or raw array of transform steps against the ResultSet.\n     * @param {(string|array)} transform - name of collection transform or raw transform array\n     * @param {object} [parameters=] - object property hash of parameters, if the transform requires them.\n     * @returns {ResultSet} either (this) ResultSet or a clone of of this ResultSet (depending on steps)\n     */\n    transform(transform, parameters) {\n        // if transform is name, then do lookup first\n        if (typeof transform === \"string\") {\n            transform = this._collection._transforms[transform];\n        }\n        if (parameters !== undefined) {\n            transform = resolveTransformParams(transform, parameters);\n        }\n        let rs = this;\n        for (let idx = 0; idx < transform.length; idx++) {\n            const step = transform[idx];\n            switch (step.type) {\n                case \"find\":\n                    rs.find(step.value);\n                    break;\n                case \"where\":\n                    rs.where(step.value);\n                    break;\n                case \"simplesort\":\n                    rs.simplesort(step.property, step.options);\n                    break;\n                case \"compoundsort\":\n                    rs.compoundsort(step.value);\n                    break;\n                case \"sort\":\n                    rs.sort(step.value);\n                    break;\n                case \"sortByScoring\":\n                    rs.sortByScoring(step.desc);\n                    break;\n                case \"limit\":\n                    rs = rs.limit(step.value);\n                    break; // limit makes copy so update reference\n                case \"offset\":\n                    rs = rs.offset(step.value);\n                    break; // offset makes copy so update reference\n                case \"map\":\n                    rs = rs.map(step.value, step.dataOptions);\n                    break;\n                case \"eqJoin\":\n                    rs = rs.eqJoin(step.joinData, step.leftJoinKey, step.rightJoinKey, step.mapFun, step.dataOptions);\n                    break;\n                // following cases break chain by returning array data so make any of these last in transform steps\n                case \"mapReduce\":\n                    rs = rs.mapReduce(step.mapFunction, step.reduceFunction);\n                    break;\n                // following cases update documents in current filtered ResultSet (use carefully)\n                case \"update\":\n                    rs.update(step.value);\n                    break;\n                case \"remove\":\n                    rs.remove();\n                    break;\n                default:\n                    break;\n            }\n        }\n        return rs;\n    }\n    /**\n     * User supplied compare function is provided two documents to compare. (chainable)\n     * @example\n     *    rslt.sort(function(obj1, obj2) {\n       *      if (obj1.name === obj2.name) return 0;\n       *      if (obj1.name > obj2.name) return 1;\n       *      if (obj1.name < obj2.name) return -1;\n       *    });\n     * @param {function} comparefun - A javascript compare function used for sorting.\n     * @returns {ResultSet} Reference to this ResultSet, sorted, for future chain operations.\n     */\n    sort(comparefun) {\n        // if this has no filters applied, just we need to populate filteredRows first\n        if (!this._filterInitialized && this._filteredRows.length === 0) {\n            this._filteredRows = this._collection._prepareFullDocIndex();\n        }\n        const data = this._collection._data;\n        const wrappedComparer = (a, b) => comparefun(data[a], data[b]);\n        this._filteredRows.sort(wrappedComparer);\n        return this;\n    }\n    /**\n     * Simpler, loose evaluation for user to sort based on a property name. (chainable).\n     * Sorting based on the same lt/gt helper functions used for binary indices.\n     * @param {string} propname - name of property to sort by.\n     * @param {boolean|object=} options - boolean for sort descending or options object\n     * @param {boolean} [options.desc=false] - whether to sort descending\n     * @param {string} [options.sortComparator] override default with name of comparator registered in ComparatorMap\n     * @returns {ResultSet} Reference to this ResultSet, sorted, for future chain operations.\n     */\n    simplesort(propname, options = { desc: false }) {\n        if (typeof options === \"boolean\") {\n            options = {\n                desc: options\n            };\n        }\n        if (!this._filterInitialized && this._collection._rangedIndexes.hasOwnProperty(propname)) {\n            let sortedIds = this._collection._rangedIndexes[propname].index.rangeRequest();\n            let dataPositions = [];\n            // until we refactor resultset to store $loki ids in filteredrows,\n            // we need to convert $loki ids to data array positions\n            for (let id of sortedIds) {\n                dataPositions.push(this._collection.get(id, true)[1]);\n            }\n            this._filteredRows = options.desc ? dataPositions.reverse() : dataPositions;\n            this._filterInitialized = true;\n            return this;\n        }\n        // if this has no filters applied, just we need to populate filteredRows first\n        if (!this._filterInitialized && this._filteredRows.length === 0) {\n            this._filteredRows = this._collection._prepareFullDocIndex();\n        }\n        const data = this._collection._data;\n        let comparator = (options.sortComparator) ?\n            comparators[\"a\" /* ComparatorMap */][options.sortComparator] :\n            comparators[\"a\" /* ComparatorMap */][this._collection._unindexedSortComparator];\n        const wrappedComparer = (a, b) => {\n            return comparator(data[a][propname], data[b][propname]);\n        };\n        this._filteredRows.sort(wrappedComparer);\n        if (options.desc) {\n            this._filteredRows.reverse();\n        }\n        return this;\n    }\n    /**\n     * Allows sorting a ResultSet based on multiple columns.\n     * @example\n     * // to sort by age and then name (both ascending)\n     * rs.compoundsort(['age', 'name']);\n     * // to sort by age (ascending) and then by name (descending)\n     * rs.compoundsort(['age', ['name', true]);\n     * @param {array} properties - array of property names or subarray of [propertyname, isdesc] used evaluate sort order\n     * @returns {ResultSet} Reference to this ResultSet, sorted, for future chain operations.\n     */\n    compoundsort(properties) {\n        if (properties.length === 0) {\n            throw new Error(\"Invalid call to compoundsort, need at least one property\");\n        }\n        if (properties.length === 1) {\n            const prop = properties[0];\n            if (typeof prop === \"string\") {\n                return this.simplesort(prop, false);\n            }\n            else {\n                return this.simplesort(prop[0], prop[1]);\n            }\n        }\n        // unify the structure of 'properties' to avoid checking it repeatedly while sorting\n        for (let i = 0, len = properties.length; i < len; i++) {\n            const prop = properties[i];\n            if (typeof prop === \"string\") {\n                properties[i] = [prop, false];\n            }\n        }\n        // if this has no filters applied, just we need to populate filteredRows first\n        if (!this._filterInitialized && this._filteredRows.length === 0) {\n            this._filteredRows = this._collection._prepareFullDocIndex();\n        }\n        const data = this._collection._data;\n        const wrappedComparer = (a, b) => this._compoundeval(properties, data[a], data[b]);\n        this._filteredRows.sort(wrappedComparer);\n        return this;\n    }\n    /**\n     * Helper function for compoundsort(), performing individual object comparisons\n     * @param {Array} properties - array of property names, in order, by which to evaluate sort order\n     * @param {object} obj1 - first object to compare\n     * @param {object} obj2 - second object to compare\n     * @returns {number} 0, -1, or 1 to designate if identical (sortwise) or which should be first\n     */\n    _compoundeval(properties, obj1, obj2) {\n        for (let i = 0, len = properties.length; i < len; i++) {\n            const prop = properties[i];\n            const field = prop[0];\n            const res = Object(operator_packages[\"d\" /* sortHelper */])(obj1[field], obj2[field], prop[1]);\n            if (res !== 0) {\n                return res;\n            }\n        }\n        return 0;\n    }\n    /**\n     * Sorts the ResultSet based on the last full-text-search scoring.\n     * @param {boolean} [ascending=false] - sort ascending\n     * @returns {ResultSet}\n     */\n    sortByScoring(ascending = false) {\n        if (this._scoring === null) {\n            throw new Error(\"No scoring available\");\n        }\n        if (ascending) {\n            this._filteredRows.sort((a, b) => this._scoring[a].score - this._scoring[b].score);\n        }\n        else {\n            this._filteredRows.sort((a, b) => this._scoring[b].score - this._scoring[a].score);\n        }\n        return this;\n    }\n    /**\n     * Returns the scoring of the last full-text-search.\n     * @returns {ScoreResult[]}\n     */\n    getScoring() {\n        if (this._scoring === null) {\n            throw new Error(\"No scoring available\");\n        }\n        const scoring = [];\n        for (let i = 0; i < this._filteredRows.length; i++) {\n            scoring.push(this._scoring[this._filteredRows[i]]);\n        }\n        return scoring;\n    }\n    /**\n     * Oversee the operation of OR'ed query expressions.\n     * OR'ed expression evaluation runs each expression individually against the full collection,\n     * and finally does a set OR on each expression's results.\n     * Each evaluation can utilize a binary index to prevent multiple linear array scans.\n     * @param {array} expressionArray - array of expressions\n     * @returns {ResultSet} this ResultSet for further chain ops.\n     */\n    findOr(expressionArray) {\n        const docset = [];\n        const idxset = [];\n        const origCount = this.count();\n        // If filter is already initialized, then we query against only those items already in filter.\n        // This means no index utilization for fields, so hopefully its filtered to a smallish filteredRows.\n        for (let ei = 0, elen = expressionArray.length; ei < elen; ei++) {\n            // we need to branch existing query to run each filter separately and combine results\n            const fr = this.copy().find(expressionArray[ei])._filteredRows;\n            const frlen = fr.length;\n            // if the find operation did not reduce the initial set, then the initial set is the actual result\n            if (frlen === origCount) {\n                return this;\n            }\n            // add any document 'hits'\n            for (let fri = 0; fri < frlen; fri++) {\n                const idx = fr[fri];\n                if (idxset[idx] === undefined) {\n                    idxset[idx] = true;\n                    docset.push(idx);\n                }\n            }\n        }\n        this._filteredRows = docset;\n        this._filterInitialized = true;\n        return this;\n    }\n    $or(expressionArray) {\n        return this.findOr(expressionArray);\n    }\n    /**\n     * Oversee the operation of AND'ed query expressions.\n     * AND'ed expression evaluation runs each expression progressively against the full collection,\n     * internally utilizing existing chained ResultSet functionality.\n     * Only the first filter can utilize a binary index.\n     * @param {array} expressionArray - array of expressions\n     * @returns {ResultSet} this ResultSet for further chain ops.\n     */\n    findAnd(expressionArray) {\n        // we have already implementing method chaining in this (our ResultSet class)\n        // so lets just progressively apply user supplied and filters\n        for (let i = 0, len = expressionArray.length; i < len; i++) {\n            if (this.count() === 0) {\n                return this;\n            }\n            this.find(expressionArray[i]);\n        }\n        return this;\n    }\n    $and(expressionArray) {\n        return this.findAnd(expressionArray);\n    }\n    /**\n     * Used for querying via a mongo-style query object.\n     *\n     * @param {object} query - A mongo-style query object used for filtering current results.\n     * @param {boolean} firstOnly - (Optional) Used by collection.findOne() - flag if this was invoked via findOne()\n     * @returns {ResultSet} this ResultSet for further chain ops.\n     */\n    find(query, firstOnly = false) {\n        if (this._collection._data.length === 0) {\n            this._filteredRows = [];\n            this._filterInitialized = true;\n            return this;\n        }\n        const queryObject = query || \"getAll\";\n        let property;\n        let queryObjectOp;\n        let value;\n        if (typeof queryObject === \"object\") {\n            let filters = [];\n            for (let p in queryObject) {\n                let obj = {};\n                obj[p] = queryObject[p];\n                filters.push(obj);\n                if (queryObject[p] !== undefined) {\n                    property = p;\n                    queryObjectOp = queryObject[p];\n                }\n            }\n            // if more than one expression in single query object,\n            // convert implicit $and to explicit $and\n            if (filters.length > 1) {\n                return this.find({ \"$and\": filters }, firstOnly);\n            }\n        }\n        // apply no filters if they want all\n        if (!property || queryObject === \"getAll\") {\n            if (firstOnly) {\n                this._filteredRows = (this._collection._data.length > 0) ? [0] : [];\n                this._filterInitialized = true;\n            }\n            return this;\n        }\n        // injecting $and and $or expression tree evaluation here.\n        if (property === \"$and\" || property === \"$or\") {\n            this[property](queryObjectOp);\n            // for chained find with firstOnly,\n            if (firstOnly && this._filteredRows.length > 1) {\n                this._filteredRows = this._filteredRows.slice(0, 1);\n            }\n            return this;\n        }\n        // see if query object is in shorthand mode (assuming eq operator)\n        let operator = \"\";\n        if (queryObjectOp === null || (typeof queryObjectOp !== \"object\" || queryObjectOp instanceof Date)) {\n            operator = \"$eq\";\n            value = queryObjectOp;\n        }\n        else if (typeof queryObjectOp === \"object\") {\n            for (let key in queryObjectOp) {\n                if (queryObjectOp[key] !== undefined) {\n                    operator = key;\n                    value = queryObjectOp[key];\n                    break;\n                }\n            }\n        }\n        else {\n            throw new Error(\"Do not know what you want to do.\");\n        }\n        // for regex ops, precompile\n        if (operator === \"$regex\") {\n            if (Array.isArray(value)) {\n                value = new RegExp(value[0], value[1]);\n            }\n            else if (!(value instanceof RegExp)) {\n                value = new RegExp(value);\n            }\n        }\n        // if an index exists for the property being queried against, use it\n        // for now only enabling where it is the first filter applied and prop is indexed\n        const doIndexCheck = !this._filterInitialized;\n        let searchByIndex = false;\n        if (doIndexCheck && this._collection._rangedIndexes[property] && indexedOps[operator]) {\n            searchByIndex = true;\n        }\n        // the comparison function\n        const operatorPackage = operator_packages[\"a\" /* LokiOperatorPackageMap */][this._collection._defaultLokiOperatorPackage];\n        // \"shortcut\" for collection data\n        const data = this._collection._data;\n        // Query executed differently depending on :\n        //    - whether the property being queried has an index defined\n        //    - if chained, we handle first pass differently for initial filteredRows[] population\n        //\n        // For performance reasons, each case has its own if block to minimize in-loop calculations\n        let result = [];\n        // If the filteredRows[] is already initialized, use it\n        if (this._filterInitialized) {\n            let filter = this._filteredRows;\n            if (property === \"$fts\") {\n                this._scoring = this._collection._fullTextSearch.search(queryObject.$fts);\n                let keys = Object.keys(this._scoring);\n                for (let i = 0; i < keys.length; i++) {\n                    if (filter.indexOf(+keys[i]) !== -1) {\n                        result.push(+keys[i]);\n                    }\n                }\n            }\n            else if (this._collection._constraints.unique[property] !== undefined && operator === \"$eq\") {\n                // convert back to position for filtered rows (until we refactor filteredrows to store $loki instead of data pos)\n                const id = this._collection._constraints.unique[property].get(value);\n                if (id !== undefined) {\n                    const row = this._collection.get(id, true)[1];\n                    if (filter.indexOf(row) !== -1) {\n                        result.push(row);\n                    }\n                }\n            }\n            else {\n                for (let i = 0; i < filter.length; i++) {\n                    let rowIdx = filter[i];\n                    // calling operator as method property of operator package preserves 'this'\n                    if (operatorPackage[operator](data[rowIdx][property], value)) {\n                        result.push(rowIdx);\n                    }\n                }\n            }\n            this._filteredRows = result;\n            this._filterInitialized = true; // next time work against filteredRows[]\n            return this;\n        }\n        this._filteredRows = result;\n        this._filterInitialized = true; // next time work against filteredRows[]\n        if (property === \"$fts\") {\n            this._scoring = this._collection._fullTextSearch.search(queryObject.$fts);\n            let keys = Object.keys(this._scoring);\n            for (let i = 0; i < keys.length; i++) {\n                result.push(+keys[i]);\n            }\n            return this;\n        }\n        // Use unique constraint for search.\n        if (this._collection._constraints.unique[property] !== undefined && operator === \"$eq\") {\n            // convert back to position for filtered rows (until we refactor filteredrows to store $loki instead of data pos)\n            const id = this._collection._constraints.unique[property].get(value);\n            if (id !== undefined) {\n                result.push(this._collection.get(id, true)[1]);\n            }\n            return this;\n        }\n        // if not searching by index\n        if (!searchByIndex) {\n            // determine comparator to use for ops\n            for (let i = 0; i < data.length; i++) {\n                // calling operator as method property of operator package preserves 'this'\n                if (operatorPackage[operator](data[i][property], value)) {\n                    result.push(i);\n                    if (firstOnly) {\n                        return this;\n                    }\n                }\n            }\n            return this;\n        }\n        // If we have a rangedIndex defined, use that and bail\n        if (this._collection._rangedIndexes[property]) {\n            if (operator === \"$in\") {\n                let ri = this._collection._rangedIndexes[property];\n                // iterate each $in array value\n                for (let val of value) {\n                    // request matches where val eq current iterated val\n                    let idResult = ri.index.rangeRequest({ op: \"$eq\", val: val });\n                    // for each result in match\n                    for (let id of idResult) {\n                        // convert $loki id to data position and add to result (filteredrows)\n                        result.push(this._collection.get(id, true)[1]);\n                    }\n                }\n                return this;\n            }\n            if (operator === \"$between\") {\n                let idResult = this._collection._rangedIndexes[property].index.rangeRequest({\n                    op: operator,\n                    val: value[0],\n                    high: value[1]\n                });\n                // for now we will have to 'shim' the binary tree index's $loki ids back\n                // into data array indices, ideally i would like to repurpose filteredrows to use loki ids\n                for (let id of idResult) {\n                    result.push(this._collection.get(id, true)[1]);\n                }\n                return this;\n            }\n            let idResult = this._collection._rangedIndexes[property].index.rangeRequest({\n                op: operator,\n                val: value\n            });\n            // if our op requires 'second pass'\n            if (indexedOps[operator] !== true) {\n                for (let id of idResult) {\n                    let pos = this._collection.get(id, true)[1];\n                    if (indexedOps[operator](data[pos][property], value)) {\n                        result.push(pos);\n                    }\n                }\n            }\n            else {\n                // for now we will have to 'shim' the binary tree index's $loki ids back\n                // into data array indices, ideally i would like to repurpose filteredrows to use loki ids\n                for (let id of idResult) {\n                    result.push(this._collection.get(id, true)[1]);\n                }\n            }\n        }\n        return this;\n    }\n    /**\n     * Used for filtering via a javascript filter function.\n     * @param {function} fun - A javascript function used for filtering current results by.\n     * @returns {ResultSet} this ResultSet for further chain ops.\n     */\n    where(fun) {\n        let viewFunction;\n        let result = [];\n        if (\"function\" === typeof fun) {\n            viewFunction = fun;\n        }\n        else {\n            throw new TypeError(\"Argument is not a stored view or a function\");\n        }\n        // If the filteredRows[] is already initialized, use it\n        if (this._filterInitialized) {\n            let j = this._filteredRows.length;\n            while (j--) {\n                if (viewFunction(this._collection._data[this._filteredRows[j]]) === true) {\n                    result.push(this._filteredRows[j]);\n                }\n            }\n            this._filteredRows = result;\n            return this;\n        }\n        // otherwise this is initial chained op, work against data, push into filteredRows[]\n        else {\n            let k = this._collection._data.length;\n            while (k--) {\n                if (viewFunction(this._collection._data[k]) === true) {\n                    result.push(k);\n                }\n            }\n            this._filteredRows = result;\n            this._filterInitialized = true;\n            return this;\n        }\n    }\n    /**\n     * Returns the number of documents in the ResultSet.\n     * @returns {number} The number of documents in the ResultSet.\n     */\n    count() {\n        if (this._filterInitialized) {\n            return this._filteredRows.length;\n        }\n        return this._collection.count();\n    }\n    /**\n     * Terminates the chain and returns array of filtered documents\n     * @param {object} options\n     * @param {boolean} [options.forceClones] - Allows forcing the return of cloned objects even when\n     *        the collection is not configured for clone object.\n     * @param {string} [options.forceCloneMethod] - Allows overriding the default or collection specified cloning method.\n     *        Possible values 'parse-stringify', 'deep', and 'shallow' and\n     * @param {boolean} [options.removeMeta] - will force clones and strip $loki and meta properties from documents\n     *\n     * @returns {Array} Array of documents in the ResultSet\n     */\n    data(options = {}) {\n        let forceClones;\n        let forceCloneMethod;\n        let removeMeta;\n        ({\n            forceClones = false,\n            forceCloneMethod = this._collection._cloneMethod,\n            removeMeta = false\n        } = options);\n        let result = [];\n        let data = this._collection._data;\n        let obj;\n        let method;\n        // if user opts to strip meta, then force clones and use 'shallow' if 'force' options are not present\n        if (removeMeta && !forceClones) {\n            forceClones = true;\n            forceCloneMethod = \"shallow\";\n        }\n        // if collection has delta changes active, then force clones and use CloneMethod.DEEP for effective change tracking of nested objects\n        if (!this._collection._disableDeltaChangesApi) {\n            forceClones = true;\n            forceCloneMethod = \"deep\";\n        }\n        // if this has no filters applied, just return collection.data\n        if (!this._filterInitialized) {\n            if (this._filteredRows.length === 0) {\n                // determine whether we need to clone objects or not\n                if (this._collection._cloneObjects || forceClones) {\n                    method = forceCloneMethod;\n                    for (let i = 0; i < data.length; i++) {\n                        obj = this._collection._defineNestedProperties(clone(data[i], method));\n                        if (removeMeta) {\n                            delete obj.$loki;\n                            delete obj.meta;\n                        }\n                        result.push(obj);\n                    }\n                    return result;\n                }\n                // otherwise we are not cloning so return sliced array with same object references\n                else {\n                    return data.slice();\n                }\n            }\n            else {\n                // filteredRows must have been set manually, so use it\n                this._filterInitialized = true;\n            }\n        }\n        const fr = this._filteredRows;\n        if (this._collection._cloneObjects || forceClones) {\n            method = forceCloneMethod;\n            for (let i = 0; i < fr.length; i++) {\n                obj = this._collection._defineNestedProperties(clone(data[fr[i]], method));\n                if (removeMeta) {\n                    delete obj.$loki;\n                    delete obj.meta;\n                }\n                result.push(obj);\n            }\n        }\n        else {\n            for (let i = 0; i < fr.length; i++) {\n                result.push(data[fr[i]]);\n            }\n        }\n        return result;\n    }\n    /**\n     * Used to run an update operation on all documents currently in the ResultSet.\n     * @param {function} updateFunction - User supplied updateFunction(obj) will be executed for each document object.\n     * @returns {ResultSet} this ResultSet for further chain ops.\n     */\n    update(updateFunction) {\n        // if this has no filters applied, we need to populate filteredRows first\n        if (!this._filterInitialized && this._filteredRows.length === 0) {\n            this._filteredRows = this._collection._prepareFullDocIndex();\n        }\n        const len = this._filteredRows.length;\n        const rcd = this._collection._data;\n        // pass in each document object currently in ResultSet to user supplied updateFunction\n        for (let idx = 0; idx < len; idx++) {\n            // if we have cloning option specified or are doing differential delta changes, clone object first\n            if (this._collection._cloneObjects || !this._collection._disableDeltaChangesApi) {\n                const obj = clone(rcd[this._filteredRows[idx]], this._collection._cloneMethod);\n                updateFunction(obj);\n                this._collection.update(obj);\n            }\n            else {\n                // no need to clone, so just perform update on collection data object instance\n                updateFunction(rcd[this._filteredRows[idx]]);\n                this._collection.update(rcd[this._filteredRows[idx]]);\n            }\n        }\n        return this;\n    }\n    /**\n     * Removes all document objects which are currently in ResultSet from collection (as well as ResultSet)\n     * @returns {ResultSet} this (empty) ResultSet for further chain ops.\n     */\n    remove() {\n        // if this has no filters applied, we need to populate filteredRows first\n        if (!this._filterInitialized && this._filteredRows.length === 0) {\n            this._filteredRows = this._collection._prepareFullDocIndex();\n        }\n        this._collection.remove(this.data());\n        this._filteredRows = [];\n        return this;\n    }\n    /**\n     * data transformation via user supplied functions\n     *\n     * @param {function} mapFunction - this function accepts a single document for you to transform and return\n     * @param {function} reduceFunction - this function accepts many (array of map outputs) and returns single value\n     * @returns {value} The output of your reduceFunction\n     */\n    mapReduce(mapFunction, reduceFunction) {\n        try {\n            return reduceFunction(this.data().map(mapFunction));\n        }\n        catch (err) {\n            throw err;\n        }\n    }\n    /**\n     * Left joining two sets of data. Join keys can be defined or calculated properties\n     * eqJoin expects the right join key values to be unique.  Otherwise left data will be joined on the last joinData object with that key\n     * @param {Array|ResultSet|Collection} joinData - Data array to join to.\n     * @param {(string|function)} leftJoinKey - Property name in this result set to join on or a function to produce a value to join on\n     * @param {(string|function)} rightJoinKey - Property name in the joinData to join on or a function to produce a value to join on\n     * @param {function} [mapFun=] - a function that receives each matching pair and maps them into output objects - function(left,right){return joinedObject}\n     * @param {object} [dataOptions=] - optional options to apply to data() calls for left and right sides\n     * @param {boolean} dataOptions.removeMeta - allows removing meta before calling mapFun\n     * @param {boolean} dataOptions.forceClones - forcing the return of cloned objects to your map object\n     * @param {string} dataOptions.forceCloneMethod - allows overriding the default or collection specified cloning method\n     * @returns {ResultSet} A ResultSet with data in the format [{left: leftObj, right: rightObj}]\n     */\n    eqJoin(joinData, leftJoinKey, rightJoinKey, mapFun, dataOptions) {\n        let rightData = [];\n        let rightDataLength;\n        let key;\n        let result = [];\n        let leftKeyisFunction = typeof leftJoinKey === \"function\";\n        let rightKeyisFunction = typeof rightJoinKey === \"function\";\n        let joinMap = {};\n        //get the left data\n        let leftData = this.data(dataOptions);\n        let leftDataLength = leftData.length;\n        //get the right data\n        if (joinData instanceof collection_Collection) {\n            rightData = joinData.chain().data(dataOptions);\n        }\n        else if (joinData instanceof result_set_ResultSet) {\n            rightData = joinData.data(dataOptions);\n        }\n        else if (Array.isArray(joinData)) {\n            rightData = joinData;\n        }\n        else {\n            throw new TypeError(\"joinData needs to be an array or result set\");\n        }\n        rightDataLength = rightData.length;\n        //construct a lookup table\n        for (let i = 0; i < rightDataLength; i++) {\n            key = rightKeyisFunction\n                ? rightJoinKey(rightData[i])\n                : rightData[i][rightJoinKey];\n            joinMap[key] = rightData[i];\n        }\n        if (!mapFun) {\n            mapFun = (left, right) => ({\n                left,\n                right\n            });\n        }\n        //Run map function over each object in the ResultSet\n        for (let j = 0; j < leftDataLength; j++) {\n            key = leftKeyisFunction\n                ? leftJoinKey(leftData[j])\n                : leftData[j][leftJoinKey];\n            result.push(mapFun(leftData[j], joinMap[key] || {}));\n        }\n        //return a new ResultSet with no filters\n        this._collection = new collection_Collection(\"joinData\");\n        this._collection.insert(result);\n        this._filteredRows = [];\n        this._filterInitialized = false;\n        return this;\n    }\n    /**\n     * Applies a map function into a new collection for further chaining.\n     * @param {function} mapFun - javascript map function\n     * @param {object} [dataOptions=] - options to data() before input to your map function\n     * @param {boolean} dataOptions.removeMeta - allows removing meta before calling mapFun\n     * @param {boolean} dataOptions.forceClones - forcing the return of cloned objects to your map object\n     * @param {string} dataOptions.forceCloneMethod - Allows overriding the default or collection specified cloning method\n     * @return {ResultSet}\n     */\n    map(mapFun, dataOptions) {\n        const data = this.data(dataOptions).map(mapFun);\n        //return return a new ResultSet with no filters\n        this._collection = new collection_Collection(\"mappedData\");\n        this._collection.insert(data);\n        this._filteredRows = [];\n        this._filterInitialized = false;\n        return this;\n    }\n}\n\n// CONCATENATED MODULE: ./packages/loki/src/dynamic_view.ts\n\n\n/**\n * DynamicView class is a versatile 'live' view class which can have filters and sorts applied.\n *    Collection.addDynamicView(name) instantiates this DynamicView object and notifies it\n *    whenever documents are add/updated/removed so it can remain up-to-date. (chainable)\n *\n * @example\n * let mydv = mycollection.addDynamicView('test');  // default is non-persistent\n * mydv.applyFind({ 'doors' : 4 });\n * mydv.applyWhere(function(obj) { return obj.name === 'Toyota'; });\n * let results = mydv.data();\n *\n * @extends LokiEventEmitter\n\n * @see {@link Collection#addDynamicView} to construct instances of DynamicView\n *\n * @param <TData> - the data type\n * @param <TNested> - nested properties of data type\n */\nclass dynamic_view_DynamicView extends event_emitter[\"a\" /* LokiEventEmitter */] {\n    /**\n     * Constructor.\n     * @param {Collection} collection - a reference to the collection to work agains\n     * @param {string} name - the name of this dynamic view\n     * @param {object} options - the options\n     * @param {boolean} [options.persistent=false] - indicates if view is to main internal results array in 'resultdata'\n     * @param {string} [options.sortPriority=\"passive\"] - the sort priority\n     * @param {number} [options.minRebuildInterval=1] - minimum rebuild interval (need clarification to docs here)\n     */\n    constructor(collection, name, options = {}) {\n        super();\n        this._rebuildPending = false;\n        this._resultData = [];\n        this._resultDirty = false;\n        this._cachedResultSet = null;\n        // keep ordered filter pipeline\n        this._filterPipeline = [];\n        // sorting member variables\n        // we only support one active search, applied using applySort() or applySimpleSort()\n        this._sortFunction = null;\n        this._sortCriteria = null;\n        this._sortCriteriaSimple = null;\n        this._sortByScoring = null;\n        this._sortDirty = false;\n        ({\n            persistent: this._persistent = false,\n            // 'passive' will defer the sort phase until they call data(). (most efficient overall)\n            // 'active' will sort async whenever next idle. (prioritizes read speeds)\n            sortPriority: this._sortPriority = \"passive\",\n            minRebuildInterval: this._minRebuildInterval = 1\n        } = options);\n        this._collection = collection;\n        this.name = name;\n        this._resultSet = new result_set_ResultSet(collection);\n        // for now just have 1 event for when we finally rebuilt lazy view\n        // once we refactor transactions, i will tie in certain transactional events\n        this._events = {\n            \"rebuild\": []\n        };\n    }\n    /**\n     * Internally used immediately after deserialization (loading)\n     *    This will clear out and reapply filterPipeline ops, recreating the view.\n     *    Since where filters do not persist correctly, this method allows\n     *    restoring the view to state where user can re-apply those where filters.\n     *\n     * @param removeWhereFilters\n     * @returns {DynamicView} This dynamic view for further chained ops.\n     * @fires DynamicView.rebuild\n     */\n    _rematerialize({ removeWhereFilters = false }) {\n        this._resultData = [];\n        this._resultDirty = true;\n        this._resultSet = new result_set_ResultSet(this._collection);\n        if (this._sortFunction || this._sortCriteria || this._sortCriteriaSimple || this._sortByScoring !== null) {\n            this._sortDirty = true;\n        }\n        if (removeWhereFilters) {\n            // for each view see if it had any where filters applied... since they don't\n            // serialize those functions lets remove those invalid filters\n            let fpi = this._filterPipeline.length;\n            while (fpi--) {\n                if (this._filterPipeline[fpi].type === \"where\") {\n                    if (fpi !== this._filterPipeline.length - 1) {\n                        this._filterPipeline[fpi] = this._filterPipeline[this._filterPipeline.length - 1];\n                    }\n                    this._filterPipeline.length--;\n                }\n            }\n        }\n        // back up old filter pipeline, clear filter pipeline, and reapply pipeline ops\n        const ofp = this._filterPipeline;\n        this._filterPipeline = [];\n        // now re-apply 'find' filterPipeline ops\n        for (let idx = 0; idx < ofp.length; idx++) {\n            this.applyFind(ofp[idx].val);\n        }\n        // during creation of unit tests, i will remove this forced refresh and leave lazy\n        this.data();\n        // emit rebuild event in case user wants to be notified\n        this.emit(\"rebuild\", this);\n        return this;\n    }\n    /**\n     * Makes a copy of the internal ResultSet for branched queries.\n     * Unlike this dynamic view, the branched ResultSet will not be 'live' updated,\n     * so your branched query should be immediately resolved and not held for future evaluation.\n     * @param {(string|array=)} transform - Optional name of collection transform, or an array of transform steps\n     * @param {object} parameters - optional parameters (if optional transform requires them)\n     * @returns {ResultSet} A copy of the internal ResultSet for branched queries.\n     */\n    branchResultSet(transform, parameters) {\n        const rs = this._resultSet.copy();\n        if (transform === undefined) {\n            return rs;\n        }\n        return rs.transform(transform, parameters);\n    }\n    /**\n     * Override of toJSON to avoid circular references.\n     */\n    toJSON() {\n        return {\n            name: this.name,\n            _persistent: this._persistent,\n            _sortPriority: this._sortPriority,\n            _minRebuildInterval: this._minRebuildInterval,\n            _resultSet: this._resultSet,\n            _filterPipeline: this._filterPipeline,\n            _sortCriteria: this._sortCriteria,\n            _sortCriteriaSimple: this._sortCriteriaSimple,\n            _sortByScoring: this._sortByScoring,\n            _sortDirty: this._sortDirty,\n        };\n    }\n    static fromJSONObject(collection, obj) {\n        let dv = new dynamic_view_DynamicView(collection, obj.name);\n        dv._resultDirty = true;\n        dv._filterPipeline = obj._filterPipeline;\n        dv._resultData = [];\n        dv._sortCriteria = obj._sortCriteria;\n        dv._sortCriteriaSimple = obj._sortCriteriaSimple;\n        dv._sortByScoring = obj._sortByScoring;\n        dv._sortDirty = obj._sortDirty;\n        dv._resultSet._filteredRows = obj._resultSet._filteredRows;\n        dv._resultSet._filterInitialized = obj._resultSet._filterInitialized;\n        dv._rematerialize({\n            removeWhereFilters: true\n        });\n        return dv;\n    }\n    /**\n     * Used to clear pipeline and reset dynamic view to initial state.\n     * Existing options should be retained.\n     * @param {boolean} queueSortPhase - (default: false) if true we will async rebuild view (maybe set default to true in future?)\n     */\n    removeFilters({ queueSortPhase = false } = {}) {\n        this._rebuildPending = false;\n        this._resultSet.reset();\n        this._resultData = [];\n        this._resultDirty = true;\n        this._cachedResultSet = null;\n        // keep ordered filter pipeline\n        this._filterPipeline = [];\n        // sorting member variables\n        // we only support one active search, applied using applySort() or applySimpleSort()\n        this._sortFunction = null;\n        this._sortCriteria = null;\n        this._sortCriteriaSimple = null;\n        this._sortByScoring = null;\n        this._sortDirty = false;\n        if (queueSortPhase === true) {\n            this._queueSortPhase();\n        }\n    }\n    /**\n     * Used to apply a sort to the dynamic view\n     * @example\n     * dv.applySort(function(obj1, obj2) {\n       *   if (obj1.name === obj2.name) return 0;\n       *   if (obj1.name > obj2.name) return 1;\n       *   if (obj1.name < obj2.name) return -1;\n       * });\n     * @param {function} comparefun - a javascript compare function used for sorting\n     * @returns {DynamicView} this DynamicView object, for further chain ops.\n     */\n    applySort(comparefun) {\n        this._sortFunction = comparefun;\n        this._sortCriteria = null;\n        this._sortCriteriaSimple = null;\n        this._sortByScoring = null;\n        this._queueSortPhase();\n        return this;\n    }\n    /**\n     * Used to specify a property used for view translation.\n     * @param {string} field - the field name\n     * @param {boolean|object=} options - boolean for sort descending or options object\n     * @param {boolean} [options.desc=false] - whether we should sort descending.\n     * @param {boolean} [options.disableIndexIntersect=false] - whether we should explicity not use array intersection.\n     * @param {boolean} [options.forceIndexIntersect=false] - force array intersection (if binary index exists).\n     * @param {boolean} [options.useJavascriptSorting=false] - whether results are sorted via basic javascript sort.\n     * @returns {DynamicView} this DynamicView object, for further chain ops.\n     * @example\n     * dv.applySimpleSort(\"name\");\n     */\n    applySimpleSort(field, options = false) {\n        this._sortCriteriaSimple = { field, options };\n        this._sortFunction = null;\n        this._sortCriteria = null;\n        this._sortByScoring = null;\n        this._queueSortPhase();\n        return this;\n    }\n    /**\n     * Allows sorting a ResultSet based on multiple columns.\n     * @param {Array} criteria - array of property names or subarray of [propertyname, isdesc] used evaluate sort order\n     * @returns {DynamicView} Reference to this DynamicView, sorted, for future chain operations.\n     * @example\n     * // to sort by age and then name (both ascending)\n     * dv.applySortCriteria(['age', 'name']);\n     * // to sort by age (ascending) and then by name (descending)\n     * dv.applySortCriteria(['age', ['name', true]]);\n     * // to sort by age (descending) and then by name (descending)\n     * dv.applySortCriteria([['age', true], ['name', true]]);\n     */\n    applySortCriteria(criteria) {\n        this._sortCriteria = criteria;\n        this._sortCriteriaSimple = null;\n        this._sortFunction = null;\n        this._sortByScoring = null;\n        this._queueSortPhase();\n        return this;\n    }\n    /**\n     * Used to apply a sort by the latest full-text-search scoring.\n     * @param {boolean} [ascending=false] - sort ascending\n     */\n    applySortByScoring(ascending = false) {\n        this._sortFunction = null;\n        this._sortCriteria = null;\n        this._sortCriteriaSimple = null;\n        this._sortByScoring = ascending;\n        this._queueSortPhase();\n        return this;\n    }\n    /**\n     * Returns the scoring of the last full-text-search.\n     * @returns {ScoreResult[]}\n     */\n    getScoring() {\n        return this._resultSet.getScoring();\n    }\n    /**\n     * Marks the beginning of a transaction.\n     * @returns {DynamicView} this DynamicView object, for further chain ops.\n     */\n    startTransaction() {\n        this._cachedResultSet = this._resultSet.copy();\n        return this;\n    }\n    /**\n     * Commits a transaction.\n     * @returns {DynamicView} this DynamicView object, for further chain ops.\n     */\n    commit() {\n        this._cachedResultSet = null;\n        return this;\n    }\n    /**\n     * Rolls back a transaction.\n     * @returns {DynamicView} this DynamicView object, for further chain ops.\n     */\n    rollback() {\n        this._resultSet = this._cachedResultSet;\n        if (this._persistent) {\n            // for now just rebuild the persistent dynamic view data in this worst case scenario\n            // (a persistent view utilizing transactions which get rolled back), we already know the filter so not too bad.\n            this._resultData = this._resultSet.data();\n            this.emit(\"rebuild\", this);\n        }\n        return this;\n    }\n    /**\n     * Find the index of a filter in the pipeline, by that filter's ID.\n     * @param {(string|number)} uid - The unique ID of the filter.\n     * @returns {number}: index of the referenced filter in the pipeline; -1 if not found.\n     */\n    _indexOfFilterWithId(uid) {\n        if (typeof uid === \"string\" || typeof uid === \"number\") {\n            for (let idx = 0, len = this._filterPipeline.length; idx < len; idx++) {\n                if (uid === this._filterPipeline[idx].uid) {\n                    return idx;\n                }\n            }\n        }\n        return -1;\n    }\n    /**\n     * Add the filter object to the end of view's filter pipeline and apply the filter to the ResultSet.\n     * @param {object} filter - The filter object. Refer to applyFilter() for extra details.\n     */\n    _addFilter(filter) {\n        this._filterPipeline.push(filter);\n        this._resultSet[filter.type](filter.val);\n    }\n    /**\n     * Reapply all the filters in the current pipeline.\n     *\n     * @returns {DynamicView} this DynamicView object, for further chain ops.\n     */\n    reapplyFilters() {\n        this._resultSet.reset();\n        this._cachedResultSet = null;\n        if (this._persistent) {\n            this._resultData = [];\n            this._resultDirty = true;\n        }\n        const filters = this._filterPipeline;\n        this._filterPipeline = [];\n        for (let idx = 0, len = filters.length; idx < len; idx++) {\n            this._addFilter(filters[idx]);\n        }\n        if (this._sortFunction || this._sortCriteria || this._sortCriteriaSimple || this._sortByScoring !== null) {\n            this._queueSortPhase();\n        }\n        else {\n            this._queueRebuildEvent();\n        }\n        return this;\n    }\n    /**\n     * Adds or updates a filter in the DynamicView filter pipeline\n     * @param {object} filter - A filter object to add to the pipeline.\n     *    The object is in the format { 'type': filter_type, 'val', filter_param, 'uid', optional_filter_id }\n     * @returns {DynamicView} this DynamicView object, for further chain ops.\n     */\n    applyFilter(filter) {\n        const idx = this._indexOfFilterWithId(filter.uid);\n        if (idx >= 0) {\n            this._filterPipeline[idx] = filter;\n            return this.reapplyFilters();\n        }\n        this._cachedResultSet = null;\n        if (this._persistent) {\n            this._resultData = [];\n            this._resultDirty = true;\n        }\n        this._addFilter(filter);\n        if (this._sortFunction || this._sortCriteria || this._sortCriteriaSimple || this._sortByScoring !== null) {\n            this._queueSortPhase();\n        }\n        else {\n            this._queueRebuildEvent();\n        }\n        return this;\n    }\n    /**\n     * applyFind() - Adds or updates a mongo-style query option in the DynamicView filter pipeline\n     *\n     * @param {object} query - A mongo-style query object to apply to pipeline\n     * @param {(string|number)} uid - Optional: The unique ID of this filter, to reference it in the future.\n     * @returns {DynamicView} this DynamicView object, for further chain ops.\n     */\n    applyFind(query, uid = \"\") {\n        this.applyFilter({\n            type: \"find\",\n            val: query,\n            uid\n        });\n        return this;\n    }\n    /**\n     * Adds or updates a javascript filter function in the DynamicView filter pipeline\n     * @param {function} fun - A javascript filter function to apply to pipeline\n     * @param {(string|number)} uid - Optional: The unique ID of this filter, to reference it in the future.\n     * @returns {DynamicView} this DynamicView object, for further chain ops.\n     */\n    applyWhere(fun, uid) {\n        this.applyFilter({\n            type: \"where\",\n            val: fun,\n            uid\n        });\n        return this;\n    }\n    /**\n     * Remove the specified filter from the DynamicView filter pipeline\n     * @param {(string|number)} uid - The unique ID of the filter to be removed.\n     * @returns {DynamicView} this DynamicView object, for further chain ops.\n     */\n    removeFilter(uid) {\n        const idx = this._indexOfFilterWithId(uid);\n        if (idx < 0) {\n            throw new Error(\"Dynamic view does not contain a filter with ID: \" + uid);\n        }\n        this._filterPipeline.splice(idx, 1);\n        this.reapplyFilters();\n        return this;\n    }\n    /**\n     * Returns the number of documents representing the current DynamicView contents.\n     * @returns {number} The number of documents representing the current DynamicView contents.\n     */\n    count() {\n        // in order to be accurate we will pay the minimum cost (and not alter dv state management)\n        // recurring ResultSet data resolutions should know internally its already up to date.\n        // for persistent data this will not update resultdata nor fire rebuild event.\n        if (this._resultDirty) {\n            this._resultData = this._resultSet.data();\n        }\n        return this._resultSet.count();\n    }\n    /**\n     * Resolves and pending filtering and sorting, then returns document array as result.\n     * @param {object} options - optional parameters to pass to ResultSet.data() if non-persistent\n     * @param {boolean} [options.forceClones] - Allows forcing the return of cloned objects even when\n     *        the collection is not configured for clone object.\n     * @param {string} [options.forceCloneMethod] - Allows overriding the default or collection specified cloning method.\n     *        Possible values include 'parse-stringify', 'jquery-extend-deep', 'shallow', 'shallow-assign'\n     * @param {boolean} [options.removeMeta] - will force clones and strip $loki and meta properties from documents\n     *\n     * @returns {Array} An array of documents representing the current DynamicView contents.\n     */\n    data(options = {}) {\n        // using final sort phase as 'catch all' for a few use cases which require full rebuild\n        if (this._sortDirty || this._resultDirty) {\n            this._performSortPhase({\n                suppressRebuildEvent: true\n            });\n        }\n        return (this._persistent) ? (this._resultData) : (this._resultSet.data(options));\n    }\n    /**\n     * When the view is not sorted we may still wish to be notified of rebuild events.\n     * This event will throttle and queue a single rebuild event when batches of updates affect the view.\n     */\n    _queueRebuildEvent() {\n        if (this._rebuildPending) {\n            return;\n        }\n        this._rebuildPending = true;\n        setTimeout(() => {\n            if (this._rebuildPending) {\n                this._rebuildPending = false;\n                this.emit(\"rebuild\", this);\n            }\n        }, this._minRebuildInterval);\n    }\n    /**\n     * If the view is sorted we will throttle sorting to either :\n     * (1) passive - when the user calls data(), or\n     * (2) active - once they stop updating and yield js thread control\n     */\n    _queueSortPhase() {\n        // already queued? exit without queuing again\n        if (this._sortDirty) {\n            return;\n        }\n        this._sortDirty = true;\n        if (this._sortPriority === \"active\") {\n            // active sorting... once they are done and yield js thread, run async performSortPhase()\n            setTimeout(() => {\n                this._performSortPhase();\n            }, this._minRebuildInterval);\n        }\n        else {\n            // must be passive sorting... since not calling performSortPhase (until data call), lets use queueRebuildEvent to\n            // potentially notify user that data has changed.\n            this._queueRebuildEvent();\n        }\n    }\n    /**\n     * Invoked synchronously or asynchronously to perform final sort phase (if needed)\n     */\n    _performSortPhase(options = {}) {\n        // async call to this may have been pre-empted by synchronous call to data before async could fire\n        if (!this._sortDirty && !this._resultDirty) {\n            return;\n        }\n        if (this._sortDirty) {\n            if (this._sortFunction) {\n                this._resultSet.sort(this._sortFunction);\n            }\n            else if (this._sortCriteria) {\n                this._resultSet.compoundsort(this._sortCriteria);\n            }\n            else if (this._sortCriteriaSimple) {\n                this._resultSet.simplesort(this._sortCriteriaSimple.field, this._sortCriteriaSimple.options);\n            }\n            else if (this._sortByScoring !== null) {\n                this._resultSet.sortByScoring(this._sortByScoring);\n            }\n            this._sortDirty = false;\n        }\n        if (this._persistent) {\n            // persistent view, rebuild local resultdata array\n            this._resultData = this._resultSet.data();\n            this._resultDirty = false;\n        }\n        if (!options.suppressRebuildEvent) {\n            this.emit(\"rebuild\", this);\n        }\n    }\n    /**\n     * (Re)evaluating document inclusion.\n     * Called by : collection.insert() and collection.update().\n     * @param {int} objIndex - index of document to (re)run through filter pipeline.\n     * @param {boolean} isNew - true if the document was just added to the collection.\n     * @hidden\n     */\n    _evaluateDocument(objIndex, isNew) {\n        // if no filter applied yet, the result 'set' should remain 'everything'\n        if (!this._resultSet._filterInitialized) {\n            if (this._persistent) {\n                this._resultData = this._resultSet.data();\n            }\n            // need to re-sort to sort new document\n            if (this._sortFunction || this._sortCriteria || this._sortCriteriaSimple) {\n                this._queueSortPhase();\n            }\n            else {\n                this._queueRebuildEvent();\n            }\n            return;\n        }\n        const ofr = this._resultSet._filteredRows;\n        const oldPos = (isNew) ? (-1) : (ofr.indexOf(+objIndex));\n        const oldlen = ofr.length;\n        // creating a 1-element ResultSet to run filter chain ops on to see if that doc passes filters;\n        // mostly efficient algorithm, slight stack overhead price (this function is called on inserts and updates)\n        const evalResultSet = new result_set_ResultSet(this._collection);\n        evalResultSet._filteredRows = [objIndex];\n        evalResultSet._filterInitialized = true;\n        let filter;\n        for (let idx = 0, len = this._filterPipeline.length; idx < len; idx++) {\n            filter = this._filterPipeline[idx];\n            evalResultSet[filter.type](filter.val);\n        }\n        // not a true position, but -1 if not pass our filter(s), 0 if passed filter(s)\n        const newPos = (evalResultSet._filteredRows.length === 0) ? -1 : 0;\n        // wasn't in old, shouldn't be now... do nothing\n        if (oldPos === -1 && newPos === -1)\n            return;\n        // wasn't in ResultSet, should be now... add\n        if (oldPos === -1 && newPos !== -1) {\n            ofr.push(objIndex);\n            if (this._persistent) {\n                this._resultData.push(this._collection._data[objIndex]);\n            }\n            // need to re-sort to sort new document\n            if (this._sortFunction || this._sortCriteria || this._sortCriteriaSimple) {\n                this._queueSortPhase();\n            }\n            else {\n                this._queueRebuildEvent();\n            }\n            return;\n        }\n        // was in ResultSet, shouldn't be now... delete\n        if (oldPos !== -1 && newPos === -1) {\n            if (oldPos < oldlen - 1) {\n                ofr.splice(oldPos, 1);\n                if (this._persistent) {\n                    this._resultData.splice(oldPos, 1);\n                }\n            }\n            else {\n                ofr.length = oldlen - 1;\n                if (this._persistent) {\n                    this._resultData.length = oldlen - 1;\n                }\n            }\n            // in case changes to data altered a sort column\n            if (this._sortFunction || this._sortCriteria || this._sortCriteriaSimple) {\n                this._queueSortPhase();\n            }\n            else {\n                this._queueRebuildEvent();\n            }\n            return;\n        }\n        // was in ResultSet, should still be now... (update persistent only?)\n        if (oldPos !== -1 && newPos !== -1) {\n            if (this._persistent) {\n                // in case document changed, replace persistent view data with the latest collection._data document\n                this._resultData[oldPos] = this._collection._data[objIndex];\n            }\n            // in case changes to data altered a sort column\n            if (this._sortFunction || this._sortCriteria || this._sortCriteriaSimple) {\n                this._queueSortPhase();\n            }\n            else {\n                this._queueRebuildEvent();\n            }\n        }\n    }\n    /**\n     * Internal function called on collection.delete().\n     * @hidden\n     */\n    _removeDocument(objIndex) {\n        // if no filter applied yet, the result 'set' should remain 'everything'\n        if (!this._resultSet._filterInitialized) {\n            if (this._persistent) {\n                this._resultData = this._resultSet.data();\n            }\n            // in case changes to data altered a sort column\n            if (this._sortFunction || this._sortCriteria || this._sortCriteriaSimple) {\n                this._queueSortPhase();\n            }\n            else {\n                this._queueRebuildEvent();\n            }\n            return;\n        }\n        const ofr = this._resultSet._filteredRows;\n        const oldPos = ofr.indexOf(+objIndex);\n        let oldlen = ofr.length;\n        if (oldPos !== -1) {\n            // if not last row in resultdata, swap last to hole and truncate last row\n            if (oldPos < oldlen - 1) {\n                ofr[oldPos] = ofr[oldlen - 1];\n                ofr.length = oldlen - 1;\n                if (this._persistent) {\n                    this._resultData[oldPos] = this._resultData[oldlen - 1];\n                    this._resultData.length = oldlen - 1;\n                }\n            }\n            // last row, so just truncate last row\n            else {\n                ofr.length = oldlen - 1;\n                if (this._persistent) {\n                    this._resultData.length = oldlen - 1;\n                }\n            }\n            // in case changes to data altered a sort column\n            if (this._sortFunction || this._sortCriteria || this._sortCriteriaSimple) {\n                this._queueSortPhase();\n            }\n            else {\n                this._queueRebuildEvent();\n            }\n        }\n        // since we are using filteredRows to store data array positions\n        // if they remove a document (whether in our view or not),\n        // we need to adjust array positions -1 for all document array references after that position\n        oldlen = ofr.length;\n        for (let idx = 0; idx < oldlen; idx++) {\n            if (ofr[idx] > objIndex) {\n                ofr[idx]--;\n            }\n        }\n    }\n    /**\n     * Data transformation via user supplied functions\n     * @param {function} mapFunction - this function accepts a single document for you to transform and return\n     * @param {function} reduceFunction - this function accepts many (array of map outputs) and returns single value\n     * @returns The output of your reduceFunction\n     */\n    mapReduce(mapFunction, reduceFunction) {\n        try {\n            return reduceFunction(this.data().map(mapFunction));\n        }\n        catch (err) {\n            throw err;\n        }\n    }\n}\n\n// EXTERNAL MODULE: ./packages/loki/src/ranged_indexes.ts + 1 modules\nvar ranged_indexes = __webpack_require__(4);\n\n// EXTERNAL MODULE: ./packages/common/plugin.ts\nvar common_plugin = __webpack_require__(1);\n\n// CONCATENATED MODULE: ./packages/loki/src/collection.ts\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return collection_Collection; });\n\n\n\n\n\n\n\n\nfunction average(array) {\n    return (array.reduce((a, b) => a + b, 0)) / array.length;\n}\nfunction standardDeviation(values) {\n    const avg = average(values);\n    const squareDiffs = values.map((value) => {\n        const diff = value - avg;\n        return diff * diff;\n    });\n    const avgSquareDiff = average(squareDiffs);\n    return Math.sqrt(avgSquareDiff);\n}\n/**\n * Returns an array with the value of a nested property of an object.\n * Returns an array of values if the nested property is across child arrays.\n * @param {object} obj - the object\n * @param {string[]} path - the path of the nested property\n * @param {any[]} array - the result array\n * @param {number} pathIdx - the current path idx\n * @returns {boolean} true if nested property is across child arrays, otherwise false\n */\nfunction getNestedPropertyValue(obj, path, array, pathIdx = 0) {\n    if (obj === undefined) {\n        return false;\n    }\n    if (pathIdx + 1 === path.length) {\n        array.push(obj[path[pathIdx]]);\n        return false;\n    }\n    const curr = obj[path[pathIdx]];\n    if (Array.isArray(curr)) {\n        for (let i = 0; i < curr.length; i++) {\n            getNestedPropertyValue(curr[i], path, array, pathIdx + 1);\n        }\n        return true;\n    }\n    else {\n        return getNestedPropertyValue(curr, path, array, pathIdx + 1);\n    }\n}\n/**\n * Collection class that handles documents of same type\n * @extends LokiEventEmitter\n * @param <TData> - the data type\n * @param <TNested> - nested properties of data type\n */\nclass collection_Collection extends event_emitter[\"a\" /* LokiEventEmitter */] {\n    /**\n     * @param {string} name - collection name\n     * @param {(object)} [options={}] - a configuration object\n     * @param {string[]} [options.unique=[]] - array of property names to define unique constraints for\n     * @param {string[]} [options.exact=[]] - array of property names to define exact constraints for\n     * @param {RangedIndexOptions} [options.rangedIndexes] - configuration object for ranged indexes\n     * @param {boolean} [options.asyncListeners=false] - whether listeners are invoked asynchronously\n     * @param {boolean} [options.disableMeta=false] - set to true to disable meta property on documents\n     * @param {boolean} [options.disableChangesApi=true] - set to false to enable Changes API\n     * @param {boolean} [options.disableDeltaChangesApi=true] - set to false to enable Delta Changes API (requires Changes API, forces cloning)\n     * @param {boolean} [options.clone=false] - specify whether inserts and queries clone to/from user\n     * @param {boolean} [options.serializableIndexes=true] - converts date values on binary indexed property values are serializable\n     * @param {string} [options.cloneMethod=\"deep\"] - the clone method\n     * @param {number} [options.transactional=false] - ?\n     * @param {number} [options.ttl=] - age of document (in ms.) before document is considered aged/stale.\n     * @param {number} [options.ttlInterval=] - time interval for clearing out 'aged' documents; not set by default\n     * @param {string} [options.unindexedSortComparator=\"js\"] \"js\", \"abstract\", \"abstract-date\", \"loki\" or other registered comparator name\n     * @param {string} [options.defaultLokiOperatorPackage=\"js\"] \"js\", \"loki\", \"comparator\" (or user defined) query ops package\n     * @param {FullTextSearch.FieldOptions} [options.fullTextSearch=] - the full-text search options\n     * @see {@link Loki#addCollection} for normal creation of collections\n     */\n    constructor(name, options = {}) {\n        super();\n        // the data held by the collection\n        this._data = [];\n        // index of id\n        this._idIndex = [];\n        // user defined indexes\n        this._rangedIndexes = {};\n        // loki obj map\n        this._lokimap = {};\n        // default comparator name to use for unindexed sorting\n        this._unindexedSortComparator = \"js\";\n        // default LokiOperatorPackage ('default' uses fastest 'javascript' comparisons)\n        this._defaultLokiOperatorPackage = \"js\";\n        /**\n         * Unique constraints contain duplicate object references, so they are not persisted.\n         * We will keep track of properties which have unique constraints applied here, and regenerate on load.\n         */\n        this._constraints = { unique: {} };\n        /**\n         * Transforms will be used to store frequently used query chains as a series of steps which itself can be stored along\n         * with the database.\n         */\n        this._transforms = {};\n        /**\n         * In autosave scenarios we will use collection level dirty flags to determine whether save is needed.\n         * currently, if any collection is dirty we will autosave the whole database if autosave is configured.\n         * Defaulting to true since this is called from addCollection and adding a collection should trigger save.\n         */\n        this._dirty = true;\n        // private holder for cached data\n        this._cached = null;\n        /**\n         * Name of path of used nested properties.\n         */\n        this._nestedProperties = [];\n        /**\n         * Option to activate a cleaner daemon - clears \"aged\" documents at set intervals.\n         */\n        this._ttl = {\n            age: null,\n            ttlInterval: null,\n            daemon: null\n        };\n        // currentMaxId - change manually at your own peril!\n        this._maxId = 0;\n        this._dynamicViews = [];\n        /**\n         * Changes are tracked by collection and aggregated by the db.\n         */\n        this._changes = [];\n        /**\n         * stages: a map of uniquely identified 'stages', which hold copies of objects to be\n         * manipulated without affecting the data in the original collection\n         */\n        this._stages = {};\n        this._commitLog = [];\n        // Consistency checks.\n        if (options && options.disableMeta === true) {\n            if (options.disableChangesApi === false) {\n                throw new Error(\"disableMeta option cannot be passed as true when disableChangesApi is passed as false\");\n            }\n            if (options.disableDeltaChangesApi === false) {\n                throw new Error(\"disableMeta option cannot be passed as true when disableDeltaChangesApi is passed as false\");\n            }\n            if (typeof options.ttl === \"number\" && options.ttl > 0) {\n                throw new Error(\"disableMeta option cannot be passed as true when ttl is enabled\");\n            }\n        }\n        // the name of the collection\n        this.name = name;\n        /* OPTIONS */\n        this._unindexedSortComparator = options.unindexedSortComparator || \"js\";\n        this._defaultLokiOperatorPackage = options.defaultLokiOperatorPackage || \"js\";\n        // exact match and unique constraints\n        if (options.unique !== undefined) {\n            if (!Array.isArray(options.unique)) {\n                options.unique = [options.unique];\n            }\n            options.unique.forEach((prop) => {\n                this._constraints.unique[prop] = new UniqueIndex(prop);\n            });\n        }\n        // Full text search\n        if (common_plugin[\"a\" /* PLUGINS */][\"FullTextSearch\"] !== undefined) {\n            this._fullTextSearch = options.fullTextSearch !== undefined\n                ? new (common_plugin[\"a\" /* PLUGINS */][\"FullTextSearch\"])(options.fullTextSearch) : null;\n        }\n        else {\n            this._fullTextSearch = null;\n        }\n        // .\n        this._transactional = options.transactional !== undefined ? options.transactional : false;\n        // .\n        this._cloneObjects = options.clone !== undefined ? options.clone : false;\n        // .\n        this._asyncListeners = options.asyncListeners !== undefined ? options.asyncListeners : false;\n        // .\n        this._disableMeta = options.disableMeta !== undefined ? options.disableMeta : false;\n        // .\n        this._disableChangesApi = options.disableChangesApi !== undefined ? options.disableChangesApi : true;\n        // .\n        this._disableDeltaChangesApi = options.disableDeltaChangesApi !== undefined ? options.disableDeltaChangesApi : true;\n        // .\n        this._cloneMethod = options.cloneMethod !== undefined ? options.cloneMethod : \"deep\";\n        if (this._disableChangesApi) {\n            this._disableDeltaChangesApi = true;\n        }\n        // .\n        this._serializableIndexes = options.serializableIndexes !== undefined ? options.serializableIndexes : true;\n        // .\n        if (options.nestedProperties != undefined) {\n            for (let i = 0; i < options.nestedProperties.length; i++) {\n                const nestedProperty = options.nestedProperties[i];\n                if (typeof nestedProperty === \"string\") {\n                    this._nestedProperties.push({ name: nestedProperty, path: nestedProperty.split(\".\") });\n                }\n                else {\n                    this._nestedProperties.push(nestedProperty);\n                }\n            }\n        }\n        this.setTTL(options.ttl || -1, options.ttlInterval);\n        // events\n        this._events = {\n            \"insert\": [],\n            \"update\": [],\n            \"pre-insert\": [],\n            \"pre-update\": [],\n            \"close\": [],\n            \"flushbuffer\": [],\n            \"error\": [],\n            \"delete\": [],\n            \"warning\": []\n        };\n        // initialize the id index\n        this._ensureId();\n        let rangedIndexes = options.rangedIndexes || {};\n        for (let ri in rangedIndexes) {\n            // Todo: any way to type annotate this as typesafe generic?\n            this.ensureRangedIndex(ri, rangedIndexes[ri].indexTypeName, rangedIndexes[ri].comparatorName);\n        }\n        this.setChangesApi(this._disableChangesApi, this._disableDeltaChangesApi);\n        // for de-serialization purposes\n        this.flushChanges();\n    }\n    toJSON() {\n        return {\n            name: this.name,\n            unindexedSortComparator: this._unindexedSortComparator,\n            defaultLokiOperatorPackage: this._defaultLokiOperatorPackage,\n            _dynamicViews: this._dynamicViews,\n            uniqueNames: Object.keys(this._constraints.unique),\n            transforms: this._transforms,\n            rangedIndexes: this._rangedIndexes,\n            _data: this._data,\n            idIndex: this._idIndex,\n            maxId: this._maxId,\n            _dirty: this._dirty,\n            _nestedProperties: this._nestedProperties,\n            transactional: this._transactional,\n            asyncListeners: this._asyncListeners,\n            disableMeta: this._disableMeta,\n            disableChangesApi: this._disableChangesApi,\n            disableDeltaChangesApi: this._disableDeltaChangesApi,\n            cloneObjects: this._cloneObjects,\n            cloneMethod: this._cloneMethod,\n            changes: this._changes,\n            _fullTextSearch: this._fullTextSearch\n        };\n    }\n    static fromJSONObject(obj, options) {\n        // instantiate collection with options needed by constructor\n        let coll = new collection_Collection(obj.name, {\n            disableChangesApi: obj.disableChangesApi,\n            disableDeltaChangesApi: obj.disableDeltaChangesApi,\n            unindexedSortComparator: obj.unindexedSortComparator,\n            defaultLokiOperatorPackage: obj.defaultLokiOperatorPackage\n        });\n        coll._transactional = obj.transactional;\n        coll._asyncListeners = obj.asyncListeners;\n        coll._disableMeta = obj.disableMeta;\n        coll._disableChangesApi = obj.disableChangesApi;\n        coll._cloneObjects = obj.cloneObjects;\n        coll._cloneMethod = obj.cloneMethod || \"deep\";\n        coll._changes = obj.changes;\n        coll._nestedProperties = obj._nestedProperties;\n        coll._rangedIndexes = obj.rangedIndexes || {};\n        coll._dirty = (options && options.retainDirtyFlags === true) ? obj._dirty : false;\n        function makeLoader(coll) {\n            const collOptions = options[coll.name];\n            if (collOptions.proto) {\n                const inflater = collOptions.inflate || ((src, dest) => {\n                    for (let prop in src) {\n                        dest[prop] = src[prop];\n                    }\n                });\n                return (data) => {\n                    const collObj = new (collOptions.proto)();\n                    inflater(data, collObj);\n                    return collObj;\n                };\n            }\n            return collOptions.inflate;\n        }\n        // load each element individually\n        if (options && options[obj.name] !== undefined) {\n            let loader = makeLoader(obj);\n            for (let j = 0; j < obj._data.length; j++) {\n                coll._data[j] = coll._defineNestedProperties(loader(obj._data[j]));\n                // regenerate lokimap\n                coll._lokimap[coll._data[j].$loki] = coll._data[j];\n            }\n        }\n        else {\n            for (let j = 0; j < obj._data.length; j++) {\n                coll._data[j] = coll._defineNestedProperties(obj._data[j]);\n                // regenerate lokimap\n                coll._lokimap[coll._data[j].$loki] = coll._data[j];\n            }\n        }\n        coll._maxId = (obj.maxId === undefined) ? 0 : obj.maxId;\n        coll._idIndex = obj.idIndex;\n        if (obj.transforms !== undefined) {\n            coll._transforms = obj.transforms;\n        }\n        // inflate rangedindexes\n        for (let ri in obj.rangedIndexes) {\n            // shortcut reference to serialized meta\n            let sri = obj.rangedIndexes[ri];\n            // lookup index factory function in map based on index type name\n            let rif = ranged_indexes[\"a\" /* RangedIndexFactoryMap */][sri.indexTypeName];\n            // lookup comparator function in map based on comparator name\n            let ricmp = comparators[\"a\" /* ComparatorMap */][sri.comparatorName];\n            // using index type (from meta), index factory and comparator... create instance of ranged index\n            let rii = rif(ri, ricmp);\n            // now ask new index instance to inflate from plain object\n            rii.restore(sri.index);\n            // attach class instance to our collection's ranged index's (index) instance property\n            coll._rangedIndexes[ri].index = rii;\n        }\n        coll._ensureId();\n        // regenerate unique indexes\n        if (obj.uniqueNames !== undefined) {\n            for (let j = 0; j < obj.uniqueNames.length; j++) {\n                coll.ensureUniqueIndex(obj.uniqueNames[j]);\n            }\n        }\n        // in case they are loading a database created before we added dynamic views, handle undefined\n        if (obj._dynamicViews !== undefined) {\n            // reinflate DynamicViews and attached ResultSets\n            for (let idx = 0; idx < obj._dynamicViews.length; idx++) {\n                coll._dynamicViews.push(dynamic_view_DynamicView.fromJSONObject(coll, obj._dynamicViews[idx]));\n            }\n        }\n        if (obj._fullTextSearch) {\n            coll._fullTextSearch = common_plugin[\"a\" /* PLUGINS */][\"FullTextSearch\"].fromJSONObject(obj._fullTextSearch, options.fullTextSearch);\n        }\n        return coll;\n    }\n    /**\n     * Adds a named collection transform to the collection\n     * @param {string} name - name to associate with transform\n     * @param {array} transform - an array of transformation 'step' objects to save into the collection\n     */\n    addTransform(name, transform) {\n        if (this._transforms[name] !== undefined) {\n            throw new Error(\"a transform by that name already exists\");\n        }\n        this._transforms[name] = transform;\n    }\n    /**\n     * Retrieves a named transform from the collection.\n     * @param {string} name - name of the transform to lookup.\n     */\n    getTransform(name) {\n        return this._transforms[name];\n    }\n    /**\n     * Updates a named collection transform to the collection\n     * @param {string} name - name to associate with transform\n     * @param {object} transform - a transformation object to save into collection\n     */\n    setTransform(name, transform) {\n        this._transforms[name] = transform;\n    }\n    /**\n     * Removes a named collection transform from the collection\n     * @param {string} name - name of collection transform to remove\n     */\n    removeTransform(name) {\n        delete this._transforms[name];\n    }\n    /*----------------------------+\n     | TTL                        |\n     +----------------------------*/\n    setTTL(age, interval) {\n        if (age < 0) {\n            clearInterval(this._ttl.daemon);\n        }\n        else {\n            this._ttl.age = age;\n            this._ttl.ttlInterval = interval;\n            this._ttl.daemon = setInterval(() => {\n                const now = Date.now();\n                const toRemove = this.chain().where((member) => {\n                    const timestamp = member.meta.updated || member.meta.created;\n                    const diff = now - timestamp;\n                    return this._ttl.age < diff;\n                });\n                toRemove.remove();\n            }, interval);\n        }\n    }\n    /*----------------------------+\n     | INDEXING                   |\n     +----------------------------*/\n    /**\n     * Create a row filter that covers all documents in the collection.\n     */\n    _prepareFullDocIndex() {\n        const indexes = new Array(this._data.length);\n        for (let i = 0; i < indexes.length; i++) {\n            indexes[i] = i;\n        }\n        return indexes;\n    }\n    /**\n     * Ensure rangedIndex of a field.\n     * @param field\n     * @param indexTypeName\n     * @param comparatorName\n     */\n    ensureIndex(field, indexTypeName, comparatorName) {\n        this.ensureRangedIndex(field, indexTypeName, comparatorName);\n    }\n    /**\n     * Ensure rangedIndex of a field.\n     * @param field Property to create an index on (need to look into contraining on keyof T)\n     * @param indexTypeName Name of IndexType factory within (global?) hashmap to create IRangedIndex from\n     * @param comparatorName Name of Comparator within (global?) hashmap\n     */\n    ensureRangedIndex(field, indexTypeName, comparatorName) {\n        indexTypeName = indexTypeName || \"avl\";\n        comparatorName = comparatorName || \"loki\";\n        if (!ranged_indexes[\"a\" /* RangedIndexFactoryMap */][indexTypeName]) {\n            throw new Error(\"ensureRangedIndex: Unknown range index type\");\n        }\n        if (!comparators[\"a\" /* ComparatorMap */][comparatorName]) {\n            throw new Error(\"ensureRangedIndex: Unknown comparator\");\n        }\n        let rif = ranged_indexes[\"a\" /* RangedIndexFactoryMap */][indexTypeName];\n        let comparator = comparators[\"a\" /* ComparatorMap */][comparatorName];\n        this._rangedIndexes[field] = {\n            index: rif(field, comparator),\n            indexTypeName: indexTypeName,\n            comparatorName: comparatorName\n        };\n        let rii = this._rangedIndexes[field].index;\n        for (let i = 0; i < this._data.length; i++) {\n            rii.insert(this._data[i].$loki, this._data[i][field]);\n        }\n    }\n    ensureUniqueIndex(field) {\n        let index = new UniqueIndex(field);\n        // if index already existed, (re)loading it will likely cause collisions, rebuild always\n        this._constraints.unique[field] = index;\n        for (let i = 0; i < this._data.length; i++) {\n            index.set(this._data[i].$loki, this._data[i][field]);\n        }\n        return index;\n    }\n    /**\n     * Quickly determine number of documents in collection (or query)\n     * @param {object} query - (optional) query object to count results of\n     * @returns {number} number of documents in the collection\n     */\n    count(query) {\n        if (!query) {\n            return this._data.length;\n        }\n        return this.chain().find(query)._filteredRows.length;\n    }\n    /**\n     * Rebuild idIndex\n     */\n    _ensureId() {\n        this._idIndex = [];\n        for (let i = 0; i < this._data.length; i++) {\n            this._idIndex.push(this._data[i].$loki);\n        }\n    }\n    /**\n     * Add a dynamic view to the collection\n     * @param {string} name - name of dynamic view to add\n     * @param {object} options - (optional) options to configure dynamic view with\n     * @param {boolean} [options.persistent=false] - indicates if view is to main internal results array in 'resultdata'\n     * @param {string} [options.sortPriority=SortPriority.PASSIVE] - the sort priority\n     * @param {number} options.minRebuildInterval - minimum rebuild interval (need clarification to docs here)\n     * @returns {DynamicView} reference to the dynamic view added\n     **/\n    addDynamicView(name, options) {\n        const dv = new dynamic_view_DynamicView(this, name, options);\n        this._dynamicViews.push(dv);\n        return dv;\n    }\n    /**\n     * Remove a dynamic view from the collection\n     * @param {string} name - name of dynamic view to remove\n     **/\n    removeDynamicView(name) {\n        for (let idx = 0; idx < this._dynamicViews.length; idx++) {\n            if (this._dynamicViews[idx].name === name) {\n                this._dynamicViews.splice(idx, 1);\n            }\n        }\n    }\n    /**\n     * Look up dynamic view reference from within the collection\n     * @param {string} name - name of dynamic view to retrieve reference of\n     * @returns {DynamicView} A reference to the dynamic view with that name\n     **/\n    getDynamicView(name) {\n        for (let idx = 0; idx < this._dynamicViews.length; idx++) {\n            if (this._dynamicViews[idx].name === name) {\n                return this._dynamicViews[idx];\n            }\n        }\n        return null;\n    }\n    /**\n     * Applies a 'mongo-like' find query object and passes all results to an update function.\n     * @param {object} filterObject - the 'mongo-like' query object\n     * @param {function} updateFunction - the update function\n     */\n    findAndUpdate(filterObject, updateFunction) {\n        this.chain().find(filterObject).update(updateFunction);\n    }\n    /**\n     * Applies a 'mongo-like' find query object removes all documents which match that filter.\n     * @param {object} filterObject - 'mongo-like' query object\n     */\n    findAndRemove(filterObject) {\n        this.chain().find(filterObject).remove();\n    }\n    insert(doc) {\n        if (!Array.isArray(doc)) {\n            return this.insertOne(doc);\n        }\n        // holder to the clone of the object inserted if collections is set to clone objects\n        let obj;\n        let results = [];\n        this.emit(\"pre-insert\", doc);\n        for (let i = 0; i < doc.length; i++) {\n            obj = this.insertOne(doc[i], true);\n            if (!obj) {\n                return undefined;\n            }\n            results.push(obj);\n        }\n        // at the 'batch' level, if clone option is true then emitted docs are clones\n        this.emit(\"insert\", results);\n        // if clone option is set, clone return values\n        results = this._cloneObjects ? clone(results, this._cloneMethod) : results;\n        return results.length === 1 ? results[0] : results;\n    }\n    /**\n     * Adds a single object, ensures it has meta properties, clone it if necessary, etc.\n     * @param {object} doc - the document to be inserted\n     * @param {boolean} bulkInsert - quiet pre-insert and insert event emits\n     * @returns {object} document or 'undefined' if there was a problem inserting it\n     */\n    insertOne(doc, bulkInsert = false) {\n        let err = null;\n        let returnObj;\n        if (typeof doc !== \"object\") {\n            err = new TypeError(\"Document needs to be an object\");\n        }\n        else if (doc === null) {\n            err = new TypeError(\"Object cannot be null\");\n        }\n        if (err !== null) {\n            this.emit(\"error\", err);\n            throw err;\n        }\n        // if configured to clone, do so now... otherwise just use same obj reference\n        const obj = this._defineNestedProperties(this._cloneObjects ? clone(doc, this._cloneMethod) : doc);\n        if (!this._disableMeta && obj.meta === undefined) {\n            obj.meta = {\n                version: 0,\n                revision: 0,\n                created: 0\n            };\n        }\n        // both 'pre-insert' and 'insert' events are passed internal data reference even when cloning\n        // insert needs internal reference because that is where loki itself listens to add meta\n        if (!bulkInsert) {\n            this.emit(\"pre-insert\", obj);\n        }\n        if (!this._add(obj)) {\n            return undefined;\n        }\n        // update meta and store changes if ChangesAPI is enabled\n        // (moved from \"insert\" event listener to allow internal reference to be used)\n        if (this._disableChangesApi) {\n            this._insertMeta(obj);\n        }\n        else {\n            this._insertMetaWithChange(obj);\n        }\n        // if cloning is enabled, emit insert event with clone of new object\n        returnObj = this._cloneObjects ? clone(obj, this._cloneMethod) : obj;\n        if (!bulkInsert) {\n            this.emit(\"insert\", returnObj);\n        }\n        return returnObj;\n    }\n    /**\n     * Refers nested properties of an object to the root of it.\n     * @param {T} data - the object\n     * @returns {T & TNested} the object with nested properties\n     * @hidden\n     */\n    _defineNestedProperties(data) {\n        for (let i = 0; i < this._nestedProperties.length; i++) {\n            const name = this._nestedProperties[i].name;\n            const path = this._nestedProperties[i].path;\n            Object.defineProperty(data, name, {\n                get() {\n                    // Get the value of the nested property.\n                    const array = [];\n                    if (getNestedPropertyValue(this, path, array)) {\n                        return array;\n                    }\n                    else {\n                        return array[0];\n                    }\n                },\n                set(val) {\n                    // Set the value of the nested property.\n                    path.slice(0, path.length - 1).reduce((obj, part) => (obj && obj[part]) ? obj[part] : null, this)[path[path.length - 1]] = val;\n                },\n                enumerable: false,\n                configurable: true\n            });\n        }\n        return data;\n    }\n    /**\n     * Empties the collection.\n     * @param {boolean} [removeIndices=false] - remove indices\n     */\n    clear({ removeIndices: removeIndices = false } = {}) {\n        this._data = [];\n        this._idIndex = [];\n        this._cached = null;\n        this._maxId = 0;\n        this._dynamicViews = [];\n        this._dirty = true;\n        // if removing indices entirely\n        if (removeIndices === true) {\n            this._rangedIndexes = {};\n            this._constraints = {\n                unique: {}\n            };\n        }\n        // clear indices but leave definitions in place\n        else {\n            // re-instance ranged indexes\n            for (let ri in this._rangedIndexes) {\n                this.ensureRangedIndex(ri, this._rangedIndexes[ri].indexTypeName, this._rangedIndexes[ri].comparatorName);\n            }\n            // clear entire unique indices definition\n            const uniqueNames = Object.keys(this._constraints.unique);\n            for (let i = 0; i < uniqueNames.length; i++) {\n                this._constraints.unique[uniqueNames[i]].clear();\n            }\n        }\n        if (this._fullTextSearch !== null) {\n            this._fullTextSearch.clear();\n        }\n    }\n    /**\n     * Updates an object and notifies collection that the document has changed.\n     * @param {object} doc - document to update within the collection\n     */\n    update(doc) {\n        if (Array.isArray(doc)) {\n            for (let i = 0; i < doc.length; i++) {\n                this.update(doc[i]);\n            }\n            return;\n        }\n        // Verify object is a properly formed document.\n        if (doc.$loki === undefined) {\n            throw new Error(\"Trying to update unsynced document. Please save the document first by using insert() or addMany()\");\n        }\n        try {\n            this.startTransaction();\n            const arr = this.get(doc.$loki, true);\n            if (!arr) {\n                throw new Error(\"Trying to update a document not in collection.\");\n            }\n            // ref to existing obj\n            let oldInternal = arr[0]; // -internal- obj ref\n            let position = arr[1]; // position in data array\n            // ref to new internal obj\n            // if configured to clone, do so now... otherwise just use same obj reference\n            let newInternal = this._defineNestedProperties(this._cloneObjects || !this._disableDeltaChangesApi ? clone(doc, this._cloneMethod) : doc);\n            this.emit(\"pre-update\", doc);\n            Object.keys(this._constraints.unique).forEach((key) => {\n                this._constraints.unique[key].update(newInternal.$loki, newInternal[key]);\n            });\n            // operate the update\n            this._data[position] = newInternal;\n            this._lokimap[doc.$loki] = newInternal;\n            // now that we can efficiently determine the data[] position of newly added document,\n            // submit it for all registered DynamicViews to evaluate for inclusion/exclusion\n            for (let idx = 0; idx < this._dynamicViews.length; idx++) {\n                this._dynamicViews[idx]._evaluateDocument(position, false);\n            }\n            // Notify all ranged indexes of (possible) value update\n            for (let ri in this._rangedIndexes) {\n                this._rangedIndexes[ri].index.update(doc.$loki, doc[ri]);\n            }\n            this._idIndex[position] = newInternal.$loki;\n            // FullTextSearch.\n            if (this._fullTextSearch !== null) {\n                this._fullTextSearch.updateDocument(doc, position);\n            }\n            this.commit();\n            this._dirty = true; // for autosave scenarios\n            // update meta and store changes if ChangesAPI is enabled\n            if (this._disableChangesApi) {\n                this._updateMeta(newInternal);\n            }\n            else {\n                this._updateMetaWithChange(newInternal, oldInternal);\n            }\n            let returnObj = newInternal;\n            // if cloning is enabled, emit 'update' event and return with clone of new object\n            if (this._cloneObjects) {\n                returnObj = clone(newInternal, this._cloneMethod);\n            }\n            this.emit(\"update\", returnObj, oldInternal);\n        }\n        catch (err) {\n            this.rollback();\n            this.emit(\"error\", err);\n            throw (err); // re-throw error so user does not think it succeeded\n        }\n    }\n    /**\n     * Add object to collection\n     */\n    _add(obj) {\n        // if parameter isn't object exit with throw\n        if (\"object\" !== typeof obj) {\n            throw new TypeError(\"Object being added needs to be an object\");\n        }\n        // if object you are adding already has id column it is either already in the collection\n        // or the object is carrying its own 'id' property.  If it also has a meta property,\n        // then this is already in collection so throw error, otherwise rename to originalId and continue adding.\n        if (obj[\"$loki\"] !== undefined) {\n            throw new Error(\"Document is already in collection, please use update()\");\n        }\n        /*\n         * try adding object to collection\n         */\n        try {\n            this.startTransaction();\n            this._maxId++;\n            if (isNaN(this._maxId)) {\n                this._maxId = (this._data[this._data.length - 1].$loki + 1);\n            }\n            const newDoc = obj;\n            newDoc.$loki = this._maxId;\n            if (!this._disableMeta) {\n                newDoc.meta.version = 0;\n            }\n            const constrUnique = this._constraints.unique;\n            for (const key in constrUnique) {\n                if (constrUnique[key] !== undefined) {\n                    constrUnique[key].set(newDoc.$loki, newDoc[key]);\n                }\n            }\n            // add new obj id to idIndex\n            this._idIndex.push(newDoc.$loki);\n            // update lokimap\n            this._lokimap[newDoc.$loki] = newDoc;\n            // add the object\n            this._data.push(newDoc);\n            const addedPos = this._data.length - 1;\n            // now that we can efficiently determine the data[] position of newly added document,\n            // submit it for all registered DynamicViews to evaluate for inclusion/exclusion\n            const dvlen = this._dynamicViews.length;\n            for (let i = 0; i < dvlen; i++) {\n                this._dynamicViews[i]._evaluateDocument(addedPos, true);\n            }\n            // add id/val kvp to ranged index\n            for (let ri in this._rangedIndexes) {\n                // ensure Dates are converted to unix epoch time if serializableIndexes is true\n                if (this._serializableIndexes && newDoc[ri] instanceof Date) {\n                    newDoc[ri] = newDoc[ri].getTime();\n                }\n                this._rangedIndexes[ri].index.insert(obj[\"$loki\"], obj[ri]);\n            }\n            // FullTextSearch.\n            if (this._fullTextSearch !== null) {\n                this._fullTextSearch.addDocument(newDoc, addedPos);\n            }\n            this.commit();\n            this._dirty = true; // for autosave scenarios\n            return (this._cloneObjects) ? (clone(newDoc, this._cloneMethod)) : (newDoc);\n        }\n        catch (err) {\n            this.rollback();\n            this.emit(\"error\", err);\n            throw (err); // re-throw error so user does not think it succeeded\n        }\n    }\n    /**\n     * Applies a filter function and passes all results to an update function.\n     * @param {function} filterFunction - the filter function\n     * @param {function} updateFunction - the update function\n     */\n    updateWhere(filterFunction, updateFunction) {\n        const results = this.where(filterFunction);\n        try {\n            for (let i = 0; i < results.length; i++) {\n                this.update(updateFunction(results[i]));\n            }\n        }\n        catch (err) {\n            this.rollback();\n            throw err;\n        }\n    }\n    /**\n     * Remove all documents matching supplied filter function.\n     * @param {function} filterFunction - the filter function\n     */\n    removeWhere(filterFunction) {\n        this.remove(this._data.filter(filterFunction));\n    }\n    removeDataOnly() {\n        this.remove(this._data.slice());\n    }\n    /**\n     * Remove a document from the collection\n     * @param {number|object} doc - document to remove from collection\n     */\n    remove(doc) {\n        if (typeof doc === \"number\") {\n            doc = this.get(doc);\n        }\n        if (Array.isArray(doc)) {\n            let k = 0;\n            const len = doc.length;\n            for (k; k < len; k++) {\n                this.remove(doc[k]);\n            }\n            return;\n        }\n        if (doc.$loki === undefined) {\n            throw new Error(\"Object is not a document stored in the collection\");\n        }\n        try {\n            this.startTransaction();\n            const arr = this.get(doc.$loki, true);\n            const position = arr[1];\n            // already converted but let's narrow to make typescript happy\n            let aDoc = (typeof doc === \"number\") ? this.get(doc) : doc;\n            Object.keys(this._constraints.unique).forEach((key) => {\n                if (key in aDoc) {\n                    this._constraints.unique[key].remove(aDoc.$loki);\n                }\n            });\n            // now that we can efficiently determine the data[] position of newly added document,\n            // submit it for all registered DynamicViews to remove\n            for (let idx = 0; idx < this._dynamicViews.length; idx++) {\n                this._dynamicViews[idx]._removeDocument(position);\n            }\n            this._data.splice(position, 1);\n            // remove id from idIndex\n            this._idIndex.splice(position, 1);\n            // remove from lokimap\n            delete this._lokimap[doc.$loki];\n            // remove id/val kvp from binary tree index\n            for (let ri in this._rangedIndexes) {\n                this._rangedIndexes[ri].index.remove(doc.$loki);\n            }\n            // FullTextSearch.\n            if (this._fullTextSearch !== null) {\n                this._fullTextSearch.removeDocument(doc, position);\n            }\n            this.commit();\n            this._dirty = true; // for autosave scenarios\n            if (!this._disableChangesApi) {\n                this._createChange(this.name, \"R\", arr[0]);\n            }\n            this.emit(\"delete\", arr[0]);\n            delete doc.$loki;\n            delete doc.meta;\n        }\n        catch (err) {\n            this.rollback();\n            this.emit(\"error\", err);\n            throw err;\n        }\n    }\n    /*------------+\n     | Change API |\n     +------------*/\n    /**\n     * Returns all changes.\n     * @returns {Collection.Change[]}\n     */\n    getChanges() {\n        return this._changes;\n    }\n    /**\n     * Enables/disables changes api.\n     * @param {boolean} disableChangesApi\n     * @param {boolean} disableDeltaChangesApi\n     */\n    setChangesApi(disableChangesApi, disableDeltaChangesApi = true) {\n        this._disableChangesApi = disableChangesApi;\n        this._disableDeltaChangesApi = disableChangesApi ? true : disableDeltaChangesApi;\n    }\n    /**\n     * Clears all the changes.\n     */\n    flushChanges() {\n        this._changes = [];\n    }\n    _getObjectDelta(oldObject, newObject) {\n        const propertyNames = newObject !== null && typeof newObject === \"object\" ? Object.keys(newObject) : null;\n        if (propertyNames && propertyNames.length && [\"string\", \"boolean\", \"number\"].indexOf(typeof (newObject)) < 0) {\n            const delta = {};\n            for (let i = 0; i < propertyNames.length; i++) {\n                const propertyName = propertyNames[i];\n                if (newObject.hasOwnProperty(propertyName)) {\n                    if (!oldObject.hasOwnProperty(propertyName) || this._constraints.unique[propertyName] !== undefined\n                        || propertyName === \"$loki\" || propertyName === \"meta\") {\n                        delta[propertyName] = newObject[propertyName];\n                    }\n                    else {\n                        const propertyDelta = this._getObjectDelta(oldObject[propertyName], newObject[propertyName]);\n                        if (propertyDelta !== undefined && propertyDelta !== {}) {\n                            delta[propertyName] = propertyDelta;\n                        }\n                    }\n                }\n            }\n            return Object.keys(delta).length === 0 ? undefined : delta;\n        }\n        else {\n            return oldObject === newObject ? undefined : newObject;\n        }\n    }\n    /**\n     * Compare changed object (which is a forced clone) with existing object and return the delta\n     */\n    _getChangeDelta(obj, old) {\n        if (old) {\n            return this._getObjectDelta(old, obj);\n        }\n        else {\n            return JSON.parse(JSON.stringify(obj));\n        }\n    }\n    /**\n     * Creates a clone of the current status of an object and associates operation and collection name,\n     * so the parent db can aggregate and generate a changes object for the entire db\n     */\n    _createChange(name, op, obj, old) {\n        this._changes.push({\n            name,\n            operation: op,\n            obj: op === \"U\" && !this._disableDeltaChangesApi\n                ? this._getChangeDelta(obj, old)\n                : JSON.parse(JSON.stringify(obj))\n        });\n    }\n    _createInsertChange(obj) {\n        this._createChange(this.name, \"I\", obj);\n    }\n    _createUpdateChange(obj, old) {\n        this._createChange(this.name, \"U\", obj, old);\n    }\n    _insertMetaWithChange(obj) {\n        this._insertMeta(obj);\n        this._createInsertChange(obj);\n    }\n    _updateMetaWithChange(obj, old) {\n        this._updateMeta(obj);\n        this._createUpdateChange(obj, old);\n    }\n    _insertMeta(obj) {\n        if (this._disableMeta) {\n            return;\n        }\n        if (!obj.meta) {\n            obj.meta = {\n                version: 0,\n                revision: 0,\n                created: 0\n            };\n        }\n        obj.meta.created = (new Date()).getTime();\n        obj.meta.revision = 0;\n    }\n    _updateMeta(obj) {\n        if (this._disableMeta) {\n            return;\n        }\n        obj.meta.updated = (new Date()).getTime();\n        obj.meta.revision += 1;\n    }\n    get(id, returnPosition = false) {\n        if (!returnPosition) {\n            let doc = this._lokimap[id];\n            if (doc === undefined)\n                return null;\n            return doc;\n        }\n        const data = this._idIndex;\n        let max = data.length - 1;\n        let min = 0;\n        let mid = (min + max) >> 1;\n        id = typeof id === \"number\" ? id : parseInt(id, 10);\n        if (isNaN(id)) {\n            throw new TypeError(\"Passed id is not an integer\");\n        }\n        while (data[min] < data[max]) {\n            mid = (min + max) >> 1;\n            if (data[mid] < id) {\n                min = mid + 1;\n            }\n            else {\n                max = mid;\n            }\n        }\n        if (max === min && data[min] === id) {\n            if (returnPosition) {\n                return [this._data[min], min];\n            }\n            return this._data[min];\n        }\n        return null;\n    }\n    /**\n     * Retrieve doc by Unique index\n     * @param {string} field - name of uniquely indexed property to use when doing lookup\n     * @param {any} value - unique value to search for\n     * @returns {object} document matching the value passed\n     */\n    by(field, value) {\n        // for least amount of overhead, we will directly\n        // access index rather than use find codepath\n        let lokiId = this._constraints.unique[field].get(value);\n        if (!this._cloneObjects) {\n            return this._lokimap[lokiId];\n        }\n        else {\n            return clone(this._lokimap[lokiId], this._cloneMethod);\n        }\n    }\n    /**\n     * Find one object by index property, by property equal to value\n     * @param {object} query - query object used to perform search with\n     * @returns {(object|null)} First matching document, or null if none\n     */\n    findOne(query) {\n        query = query || {};\n        // Instantiate ResultSet and exec find op passing firstOnly = true param\n        const result = this.chain().find(query, true).data();\n        if (Array.isArray(result) && result.length === 0) {\n            return null;\n        }\n        else {\n            if (!this._cloneObjects) {\n                return result[0];\n            }\n            else {\n                return clone(result[0], this._cloneMethod);\n            }\n        }\n    }\n    /**\n     * Chain method, used for beginning a series of chained find() and/or view() operations\n     * on a collection.\n     *\n     * @param {array} transform - Ordered array of transform step objects similar to chain\n     * @param {object} parameters - Object containing properties representing parameters to substitute\n     * @returns {ResultSet} (this) ResultSet, or data array if any map or join functions where called\n     */\n    chain(transform, parameters) {\n        const rs = new result_set_ResultSet(this);\n        if (transform === undefined) {\n            return rs;\n        }\n        return rs.transform(transform, parameters);\n    }\n    /**\n     * Find method, api is similar to mongodb.\n     * for more complex queries use [chain()]{@link Collection#chain} or [where()]{@link Collection#where}.\n     * @example {@tutorial Query Examples}\n     * @param {object} query - 'mongo-like' query object\n     * @returns {array} Array of matching documents\n     */\n    find(query) {\n        return this.chain().find(query).data();\n    }\n    /**\n     * Find object by unindexed field by property equal to value,\n     * simply iterates and returns the first element matching the query\n     */\n    findOneUnindexed(prop, value) {\n        let i = this._data.length;\n        let doc;\n        while (i--) {\n            if (this._data[i][prop] === value) {\n                doc = this._data[i];\n                return doc;\n            }\n        }\n        return null;\n    }\n    /**\n     * Transaction methods\n     */\n    /**\n     * start the transation\n     */\n    startTransaction() {\n        if (this._transactional) {\n            // backup any ranged indexes\n            let rib = {};\n            for (let ri in this._rangedIndexes) {\n                rib[ri].indexTypeName = this._rangedIndexes[ri].indexTypeName;\n                rib[ri].comparatorName = this._rangedIndexes[ri].comparatorName;\n                rib[ri].index = this._rangedIndexes[ri].index.backup();\n            }\n            this._cached = {\n                index: this._idIndex,\n                data: clone(this._data, this._cloneMethod),\n                rangedIndexes: rib,\n            };\n            // propagate startTransaction to dynamic views\n            for (let idx = 0; idx < this._dynamicViews.length; idx++) {\n                this._dynamicViews[idx].startTransaction();\n            }\n        }\n    }\n    /**\n     * Commit the transaction.\n     */\n    commit() {\n        if (this._transactional) {\n            this._cached = null;\n            // propagate commit to dynamic views\n            for (let idx = 0; idx < this._dynamicViews.length; idx++) {\n                this._dynamicViews[idx].commit();\n            }\n        }\n    }\n    /**\n     * Rollback the transaction.\n     */\n    rollback() {\n        if (this._transactional) {\n            if (this._cached !== null) {\n                this._idIndex = this._cached.index;\n                this._data = this._cached.data;\n                for (let i = 0; i < this._data.length; i++) {\n                    this._data[i] = this._defineNestedProperties(this._data[i]);\n                }\n                // restore ranged indexes\n                for (let ri in this._cached.rangedIndexes) {\n                    // shortcut reference to serialized meta\n                    let sri = this._cached.rangedIndexes[ri];\n                    // lookup index factory function in map based on index type name\n                    let rif = ranged_indexes[\"a\" /* RangedIndexFactoryMap */][sri.indexTypeName];\n                    // lookup comparator function in map based on comparator name\n                    let ricmp = comparators[\"a\" /* ComparatorMap */][sri.comparatorName];\n                    // using index type (from meta), index factory and comparator... create instance of ranged index\n                    let rii = rif(ri, ricmp);\n                    // now ask new index instance to inflate from plain object\n                    rii.restore(sri.index);\n                    // attach class instance to our collection's ranged index's (index) instance property\n                    this._rangedIndexes[ri].index = rii;\n                }\n                // propagate rollback to dynamic views\n                for (let idx = 0; idx < this._dynamicViews.length; idx++) {\n                    this._dynamicViews[idx].rollback();\n                }\n            }\n        }\n    }\n    /**\n     * Query the collection by supplying a javascript filter function.\n     * @example\n     * let results = coll.where(function(obj) {\n       *   return obj.legs === 8;\n       * });\n     * @param {function} fun - filter function to run against all collection docs\n     * @returns {array} all documents which pass your filter function\n     */\n    where(fun) {\n        return this.chain().where(fun).data();\n    }\n    /**\n     * Map Reduce operation\n     * @param {function} mapFunction - function to use as map function\n     * @param {function} reduceFunction - function to use as reduce function\n     * @returns {data} The result of your mapReduce operation\n     */\n    mapReduce(mapFunction, reduceFunction) {\n        return reduceFunction(this._data.map(mapFunction));\n    }\n    /**\n     * Join two collections on specified properties\n     * @param {array} joinData - array of documents to 'join' to this collection\n     * @param {string} leftJoinProp - property name in collection\n     * @param {string} rightJoinProp - property name in joinData\n     * @param {function} mapFun - (Optional) map function to use\n     * @param dataOptions - options to data() before input to your map function\n     * @param [dataOptions.removeMeta] - allows removing meta before calling mapFun\n     * @param [dataOptions.forceClones] - forcing the return of cloned objects to your map object\n     * @param [dataOptions.forceCloneMethod] - allows overriding the default or collection specified cloning method\n     * @returns {ResultSet} Result of the mapping operation\n     */\n    eqJoin(joinData, leftJoinProp, rightJoinProp, mapFun, dataOptions) {\n        return new result_set_ResultSet(this).eqJoin(joinData, leftJoinProp, rightJoinProp, mapFun, dataOptions);\n    }\n    /* ------ STAGING API -------- */\n    /**\n     * (Staging API) create a stage and/or retrieve it\n     */\n    getStage(name) {\n        if (!this._stages[name]) {\n            this._stages[name] = {};\n        }\n        return this._stages[name];\n    }\n    /**\n     * a collection of objects recording the changes applied through a commmitStage\n     */\n    /**\n     * (Staging API) create a copy of an object and insert it into a stage\n     */\n    stage(stageName, obj) {\n        const copy = JSON.parse(JSON.stringify(obj));\n        this.getStage(stageName)[obj.$loki] = copy;\n        return copy;\n    }\n    /**\n     * (Staging API) re-attach all objects to the original collection, so indexes and views can be rebuilt\n     * then create a message to be inserted in the commitlog\n     * @param {string} stageName - name of stage\n     * @param {string} message\n     */\n    commitStage(stageName, message) {\n        const stage = this.getStage(stageName);\n        const timestamp = new Date().getTime();\n        for (const prop in stage) {\n            this.update(stage[prop]);\n            this._commitLog.push({\n                timestamp,\n                message,\n                data: JSON.parse(JSON.stringify(stage[prop]))\n            });\n        }\n        this._stages[stageName] = {};\n    }\n    /**\n     * Returns all values of a field.\n     * @param {string} field - the field name\n     * @return {any}: the array of values\n     */\n    extract(field) {\n        const result = [];\n        for (let i = 0; i < this._data.length; i++) {\n            result.push(this._data[i][field]);\n        }\n        return result;\n    }\n    /**\n     * Finds the minimum value of a field.\n     * @param {string} field - the field name\n     * @return {number} the minimum value\n     */\n    min(field) {\n        return Math.min.apply(null, this.extractNumerical(field));\n    }\n    /**\n     * Finds the maximum value of a field.\n     * @param {string} field - the field name\n     * @return {number} the maximum value\n     */\n    max(field) {\n        return Math.max.apply(null, this.extractNumerical(field));\n    }\n    /**\n     * Finds the minimum value and its index of a field.\n     * @param {string} field - the field name\n     * @return {object} - index and value\n     */\n    minRecord(field) {\n        const result = {\n            index: 0,\n            value: 0\n        };\n        if (this._data.length === 0) {\n            result.index = null;\n            result.value = null;\n            return result;\n        }\n        result.index = this._data[0].$loki;\n        result.value = parseFloat(this._data[0][field]);\n        for (let i = 1; i < this._data.length; i++) {\n            const val = parseFloat(this._data[i][field]);\n            if (result.value > val) {\n                result.value = val;\n                result.index = this._data[i].$loki;\n            }\n        }\n        return result;\n    }\n    /**\n     * Finds the maximum value and its index of a field.\n     * @param {string} field - the field name\n     * @return {object} - index and value\n     */\n    maxRecord(field) {\n        const result = {\n            index: 0,\n            value: 0\n        };\n        if (this._data.length === 0) {\n            result.index = null;\n            result.value = null;\n            return result;\n        }\n        result.index = this._data[0].$loki;\n        result.value = parseFloat(this._data[0][field]);\n        for (let i = 1; i < this._data.length; i++) {\n            const val = parseFloat(this._data[i][field]);\n            if (result.value < val) {\n                result.value = val;\n                result.index = this._data[i].$loki;\n            }\n        }\n        return result;\n    }\n    /**\n     * Returns all values of a field as numbers (if possible).\n     * @param {string} field - the field name\n     * @return {number[]} - the number array\n     */\n    extractNumerical(field) {\n        return this.extract(field).map(parseFloat).filter(Number).filter((n) => !(isNaN(n)));\n    }\n    /**\n     * Calculates the average numerical value of a field\n     * @param {string} field - the field name\n     * @returns {number} average of property in all docs in the collection\n     */\n    avg(field) {\n        return average(this.extractNumerical(field));\n    }\n    /**\n     * Calculate the standard deviation of a field.\n     * @param {string} field - the field name\n     * @return {number} the standard deviation\n     */\n    stdDev(field) {\n        return standardDeviation(this.extractNumerical(field));\n    }\n    /**\n     * Calculates the mode of a field.\n     * @param {string} field - the field name\n     * @return {number} the mode\n     */\n    mode(field) {\n        const dict = {};\n        const data = this.extractNumerical(field);\n        let mode = data[0];\n        let maxCount = -Infinity;\n        for (let i = 0; i < data.length; i++) {\n            const el = data[i];\n            if (dict[el]) {\n                dict[el]++;\n            }\n            else {\n                dict[el] = 1;\n            }\n            if (dict[el] > maxCount) {\n                mode = el;\n                maxCount = dict[el];\n            }\n        }\n        return mode;\n    }\n    /**\n     * Calculates the median of a field.\n     * @param {string} field - the field name\n     * @return {number} the median\n     */\n    median(field) {\n        const values = this.extractNumerical(field);\n        values.sort((a, b) => a - b);\n        const half = Math.floor(values.length / 2);\n        if (values.length % 2) {\n            return values[half];\n        }\n        else {\n            return (values[half - 1] + values[half]) / 2.0;\n        }\n    }\n}\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n\n// CONCATENATED MODULE: ./packages/loki/src/avl_index.ts\n/**\n * LokiDB AVL Balanced Binary Tree Index implementation.\n * To support duplicates, we use siblings (array) in tree nodes.\n * Basic AVL components guided by William Fiset tutorials at :\n * https://github.com/williamfiset/data-structures/blob/master/com/williamfiset/datastructures/balancedtree/AVLTreeRecursive.java\n * https://www.youtube.com/watch?v=g4y2h70D6Nk&list=PLDV1Zeh2NRsD06x59fxczdWLhDDszUHKt\n */\nclass AvlTreeIndex {\n    /**\n     * Initializes index with property name and a comparer function.\n     */\n    constructor(name, comparator) {\n        this.nodes = {};\n        this.apex = null;\n        this.name = name;\n        this.comparator = comparator;\n    }\n    backup() {\n        let result = new AvlTreeIndex(this.name, this.comparator);\n        result.nodes = JSON.parse(JSON.stringify(this.nodes));\n        result.apex = this.apex;\n        return result;\n    }\n    restore(tree) {\n        this.name = tree.name;\n        this.comparator = tree.comparator;\n        this.nodes = JSON.parse(JSON.stringify(tree.nodes));\n        this.apex = tree.apex;\n    }\n    /**\n     * Used for inserting a new value into the BinaryTreeIndex\n     * @param id Unique Id (such as $loki) to associate with value\n     * @param val Value to be indexed and inserted into binary tree\n     */\n    insert(id, val) {\n        if (id <= 0) {\n            throw new Error(\"avl index ids are required to be numbers greater than zero\");\n        }\n        let node = this.nodes[id] = {\n            id: id,\n            value: val,\n            parent: null,\n            balance: 0,\n            height: 0,\n            left: null,\n            right: null,\n            siblings: []\n        };\n        if (!this.apex) {\n            this.apex = id;\n            return;\n        }\n        this.insertNode(this.nodes[this.apex], node);\n    }\n    /**\n     * Recursively inserts a treenode and re-balances if needed.\n     * @param current\n     * @param node\n     */\n    insertNode(current, node) {\n        switch (this.comparator(node.value, current.value)) {\n            case 0:\n                // eq\n                current.siblings.push(node.id);\n                node.parent = current.id;\n                break;\n            case 1:\n                // gt\n                if (current.right) {\n                    this.insertNode(this.nodes[current.right], node);\n                    this.updateBalance(current);\n                }\n                else {\n                    current.right = node.id;\n                    node.parent = current.id;\n                    this.updateBalance(current);\n                }\n                break;\n            case -1:\n                // lt\n                if (current.left) {\n                    this.insertNode(this.nodes[current.left], node);\n                    this.updateBalance(current);\n                }\n                else {\n                    current.left = node.id;\n                    node.parent = current.id;\n                    this.updateBalance(current);\n                }\n                break;\n            default: throw new Error(\"Invalid comparator result\");\n        }\n        if (current.balance < -1) {\n            if (current.left === null) {\n                throw new Error(\"insertNode.balance() : left child should not be null\");\n            }\n            if (this.nodes[current.left].balance <= 0) {\n                this.leftLeftCase(current);\n            }\n            else {\n                this.leftRightCase(current);\n            }\n        }\n        if (current.balance > 1) {\n            if (current.right === null) {\n                throw new Error(\"insertNode.balance() : right child should not be null\");\n            }\n            if (this.nodes[current.right].balance >= 0) {\n                this.rightRightCase(current);\n            }\n            else {\n                this.rightLeftCase(current);\n            }\n        }\n        return current.height;\n    }\n    /**\n     * Updates height and balance (calculation) for tree node\n     * @param node\n     */\n    updateBalance(node) {\n        let hl = node.left ? this.nodes[node.left].height : -1;\n        let hr = node.right ? this.nodes[node.right].height : -1;\n        //node.height = 1 + Math.max(hl, hr);\n        node.height = (hl > hr) ? 1 + hl : 1 + hr;\n        node.balance = hr - hl;\n    }\n    /**\n     * Balance the 'double left-heavy' condition\n     * @param node\n     */\n    leftLeftCase(node) {\n        return this.rotateRight(node);\n    }\n    /**\n     * Balance the '(parent) left heavy, (child) right heavy' condition\n     * @param node\n     */\n    leftRightCase(node) {\n        if (!node.left) {\n            throw new Error(\"leftRightCase: left child not set\");\n        }\n        node.left = this.rotateLeft(this.nodes[node.left]).id;\n        return this.rotateRight(node);\n    }\n    /**\n     * Balance the 'double right-heavy' condition\n     * @param node\n     */\n    rightRightCase(node) {\n        return this.rotateLeft(node);\n    }\n    /**\n     * Balance the '(parent) right heavy, (child) left heavy' condition\n     * @param node\n     */\n    rightLeftCase(node) {\n        if (!node.right) {\n            throw new Error(\"rightLeftCase: right child not set\");\n        }\n        node.right = this.rotateRight(this.nodes[node.right]).id;\n        return this.rotateLeft(node);\n    }\n    /**\n     * Left rotation of node. Swaps right child into current location.\n     * @param node\n     */\n    rotateLeft(node) {\n        if (!node.right) {\n            throw new Error(\"rotateLeft: right child was unavailable.\");\n        }\n        let parent = (node.parent) ? this.nodes[node.parent] : null;\n        let right = this.nodes[node.right];\n        // assume rights (old) left branch as our (new) right branch\n        node.right = right.left;\n        if (node.right) {\n            this.nodes[node.right].parent = node.id;\n        }\n        // right will be new parent to node and assume old node's parent\n        right.left = node.id;\n        right.parent = node.parent;\n        node.parent = right.id;\n        // remap parent child pointer to right\n        if (parent) {\n            if (parent.left === node.id) {\n                parent.left = right.id;\n            }\n            else if (parent.right === node.id) {\n                parent.right = right.id;\n            }\n            else {\n                throw new Error(\"rotateLeft() : attempt to remap parent back to child failed... not found\");\n            }\n        }\n        else {\n            if (this.apex !== node.id) {\n                throw new Error(\"rightRotate expecting parentless node to be apex\");\n            }\n            this.apex = right.id;\n        }\n        // recalculate height and balance for swapped nodes\n        this.updateBalance(node);\n        this.updateBalance(right);\n        return right;\n    }\n    /**\n     * Right rotation of node. Swaps left child into current location.\n     * @param node\n     */\n    rotateRight(node) {\n        if (!node.left) {\n            throw new Error(\"rotateRight : left child unavailable\");\n        }\n        let parent = (node.parent) ? this.nodes[node.parent] : null;\n        let left = this.nodes[node.left];\n        // assume left's (old) right branch as our (new) left branch\n        node.left = left.right;\n        if (left.right) {\n            this.nodes[left.right].parent = node.id;\n        }\n        // 'node' will be right child of left\n        left.right = node.id;\n        left.parent = node.parent;\n        node.parent = left.id;\n        if (parent) {\n            if (parent.left === node.id) {\n                parent.left = left.id;\n            }\n            else {\n                parent.right = left.id;\n            }\n        }\n        else {\n            if (this.apex !== node.id) {\n                throw new Error(\"rightRotate expecting parentless node to be apex\");\n            }\n            this.apex = left.id;\n        }\n        // recalculate height and balance for swapped nodes\n        this.updateBalance(node);\n        this.updateBalance(left);\n        return left;\n    }\n    /**\n     * Diagnostic method for examining tree contents and structure\n     * @param node\n     */\n    getValuesAsTree(node) {\n        if (this.apex === null)\n            return null;\n        node = node || this.nodes[this.apex];\n        return {\n            id: node.id,\n            val: node.value,\n            siblings: node.siblings,\n            balance: node.balance,\n            height: node.height,\n            left: node.left ? this.getValuesAsTree(this.nodes[node.left]) : null,\n            right: node.right ? this.getValuesAsTree(this.nodes[node.right]) : null,\n        };\n    }\n    /**\n     * Updates a value, possibly relocating it, within binary tree\n     * @param id Unique Id (such as $loki) to associate with value\n     * @param val New value to be indexed within binary tree\n     */\n    update(id, val) {\n        let node = this.nodes[id];\n        let cmp = this.comparator(node.value, val);\n        // if the value did not change, or changed to value considered equal to itself, return.\n        if (cmp === 0)\n            return;\n        this.remove(id);\n        this.insert(id, val);\n    }\n    /**\n     * Removes a value from the binary tree index\n     * @param id\n     */\n    remove(id) {\n        if (!this.apex) {\n            throw new Error(\"remove() : attempting remove when tree has no apex\");\n        }\n        this.removeNode(this.nodes[this.apex], id);\n    }\n    /**\n     * Recursive node removal and rebalancer\n     * @param node\n     * @param val\n     */\n    removeNode(node, id) {\n        if (!this.nodes[id]) {\n            throw new Error(\"removeNode: attempting to remove a node which is not in hashmap\");\n        }\n        let val = this.nodes[id].value;\n        switch (this.comparator(val, node.value)) {\n            case 0:\n                // eq - handle siblings if present\n                if (node.siblings.length > 0) {\n                    // if node to remove is alpha sibling...\n                    if (node.id === id) {\n                        // get first sibling as replacement\n                        let alphaSiblingId = node.siblings.shift();\n                        let alphaSibling = this.nodes[alphaSiblingId];\n                        // remap all properties but id and value from node onto alphasibling\n                        alphaSibling.parent = node.parent;\n                        this.updateChildLink(node.parent, id, alphaSiblingId);\n                        if (node.left) {\n                            this.nodes[node.left].parent = alphaSiblingId;\n                        }\n                        if (node.right) {\n                            this.nodes[node.right].parent = alphaSiblingId;\n                        }\n                        alphaSibling.left = node.left;\n                        alphaSibling.right = node.right;\n                        alphaSibling.siblings = node.siblings;\n                        alphaSibling.height = node.height;\n                        alphaSibling.balance = node.balance;\n                        if (this.apex === id) {\n                            this.apex = alphaSiblingId;\n                        }\n                        // parent all remaining siblings alphaSibling (new parent)\n                        for (let si of alphaSibling.siblings) {\n                            this.nodes[si].parent = alphaSiblingId;\n                        }\n                        // delete old node from nodes and return\n                        delete this.nodes[id];\n                        return;\n                    }\n                    // else we are inner sibling\n                    else {\n                        let idx = node.siblings.indexOf(id);\n                        if (idx === -1) {\n                            throw new Error(\"Unable to remove sibling from parented sibling\");\n                        }\n                        node.siblings.splice(idx, 1);\n                        delete this.nodes[id];\n                        return;\n                    }\n                }\n                // else we have no siblings, node will be removed\n                else {\n                    // if node to delete has no children\n                    if (!node.left && !node.right) {\n                        // if we have a parent, remove us from either left or right child link\n                        this.updateChildLink(node.parent, node.id, null);\n                        delete this.nodes[id];\n                        if (id === this.apex) {\n                            this.apex = null;\n                        }\n                        return;\n                    }\n                    // if node to delete has only one child we can do simple copy/replace\n                    if (!node.left || !node.right) {\n                        if (node.left) {\n                            this.promoteChild(node, this.nodes[node.left]);\n                            if (this.apex === id) {\n                                this.apex = node.left;\n                            }\n                        }\n                        if (node.right) {\n                            this.promoteChild(node, this.nodes[node.right]);\n                            if (this.apex === id) {\n                                this.apex = node.right;\n                            }\n                        }\n                        return;\n                    }\n                    // node to delete has two children, need swap with inorder successor\n                    // use find inorder successor by default\n                    this.promoteSuccessor(node);\n                    return;\n                }\n            case 1:\n                // gt - search right branch\n                if (!node.right) {\n                    throw new Error(\"removeNode: Unable to find value in tree\");\n                }\n                this.removeNode(this.nodes[node.right], id);\n                break;\n            case -1:\n                // lt - search left branch\n                if (!node.left) {\n                    throw new Error(\"removeNode: Unable to find value in tree\");\n                }\n                this.removeNode(this.nodes[node.left], id);\n                break;\n        }\n        this.updateBalance(node);\n        if (node.balance < -1) {\n            if (node.left === null) {\n                throw new Error(\"insertNode.balance() : left child should not be null\");\n            }\n            if (this.nodes[node.left].balance <= 0) {\n                this.leftLeftCase(node);\n            }\n            else {\n                this.leftRightCase(node);\n            }\n        }\n        if (node.balance > 1) {\n            if (node.right === null) {\n                throw new Error(\"insertNode.balance() : right child should not be null\");\n            }\n            if (this.nodes[node.right].balance >= 0) {\n                this.rightRightCase(node);\n            }\n            else {\n                this.rightLeftCase(node);\n            }\n        }\n    }\n    /**\n     * Utility method for updating a parent's child link when it changes\n     * @param parentId\n     * @param oldChildId\n     * @param newChildId\n     */\n    updateChildLink(parentId, oldChildId, newChildId) {\n        if (parentId === null)\n            return;\n        let parent = this.nodes[parentId];\n        if (parent.left === oldChildId) {\n            parent.left = newChildId;\n        }\n        else if (parent.right === oldChildId) {\n            parent.right = newChildId;\n        }\n    }\n    /**\n     * When removing a parent with only child, this does simple remap of child to grandParent.\n     * @param grandParent New parent of 'child'.\n     * @param parent Node being removed.\n     * @param child Node to reparent to grandParent.\n     */\n    promoteChild(parent, child) {\n        let gpId = parent.parent;\n        if (gpId) {\n            let gp = this.nodes[gpId];\n            if (gp.left === parent.id) {\n                gp.left = child.id;\n            }\n            else if (gp.right === parent.id) {\n                gp.right = child.id;\n            }\n        }\n        // remap (grand) child's parent pointer to grandparent (new parent) or null if new apex\n        child.parent = gpId;\n        // remove parent from bst hashmap\n        delete this.nodes[parent.id];\n        return;\n    }\n    /**\n     * Finds a successor to a node and replaces that node with it.\n     * @param node\n     */\n    promoteSuccessor(node) {\n        let oldId = node.id;\n        // assume successor/right branch (for now)\n        if (!node.right || !node.left) {\n            throw new Error(\"promoteSuccessor() : node to replace does not have two children\");\n        }\n        let successor = null;\n        let glsId;\n        let glsValue;\n        let glsSiblings;\n        // if tree is already left heavy,\n        // let's replace with predecessor (greatest val in left branch)\n        if (node.balance < 0) {\n            let lchild = this.nodes[node.left];\n            successor = this.findGreaterLeaf(lchild);\n            glsId = successor.id;\n            glsValue = successor.value;\n            glsSiblings = successor.siblings;\n            successor.siblings = [];\n            this.removeNode(lchild, glsId);\n        }\n        // otherwise the tree is either balanced or right heavy,\n        // so let's use sucessor (least value in right branch)\n        else {\n            let rchild = this.nodes[node.right];\n            successor = this.findLesserLeaf(rchild);\n            glsId = successor.id;\n            glsValue = successor.value;\n            glsSiblings = successor.siblings;\n            // dont leave any siblings when we (temporarily) 'remove' or they will assume ownership of old node\n            successor.siblings = [];\n            this.removeNode(rchild, glsId);\n        }\n        // update any parent pointers to node being replaced\n        if (node.parent) {\n            let p = this.nodes[node.parent];\n            if (p.left === oldId)\n                p.left = glsId;\n            if (p.right === oldId)\n                p.right = glsId;\n        }\n        // update any child points to node being replaced\n        if (node.left)\n            this.nodes[node.left].parent = glsId;\n        if (node.right)\n            this.nodes[node.right].parent = glsId;\n        // update (reuse) node instance id and value with that of successor\n        node.id = glsId;\n        node.value = glsValue;\n        node.siblings = glsSiblings;\n        // update hashmap\n        this.nodes[glsId] = node;\n        delete this.nodes[oldId];\n        // if old was apex, update apex to point to successor\n        if (this.apex === oldId)\n            this.apex = glsId;\n        this.updateBalance(node);\n    }\n    /**\n     * Utility method for finding In-Order predecessor to the provided node\n     * @param node Parent node to find leaf node of greatest 'value'\n    */\n    findGreaterLeaf(node) {\n        if (!node.right) {\n            return node;\n        }\n        let result = this.findGreaterLeaf(this.nodes[node.right]);\n        return result ? result : node;\n    }\n    /**\n     * Utility method for finding In-Order successor to the provided node\n     * @param node Parent Node to find leaf node of least 'value'\n     */\n    findLesserLeaf(node) {\n        if (!node.left) {\n            return node;\n        }\n        let result = this.findLesserLeaf(this.nodes[node.left]);\n        return result ? result : node;\n    }\n    /**\n     *  Interface method to support ranged queries.  Results sorted by index property.\n     * @param range Options for ranged request.\n     */\n    rangeRequest(range) {\n        if (!this.apex)\n            return [];\n        // if requesting all id's sorted by their value\n        if (!range) {\n            return this.collateIds(this.nodes[this.apex]);\n        }\n        if (range.op === \"$eq\") {\n            let match = this.locate(this.nodes[this.apex], range.val);\n            if (match === null) {\n                return [];\n            }\n            if (match.siblings.length) {\n                return [match.id, ...match.siblings];\n            }\n            return [match.id];\n        }\n        let result = this.collateRequest(this.nodes[this.apex], range);\n        return result;\n    }\n    /**\n     * Implements ranged request operations.\n     * @param node\n     * @param range\n     */\n    collateRequest(node, range) {\n        let result = [];\n        if (range.op === \"$eq\") {\n            // we use locate instead for $eq range requests\n            throw new Error(\"collateRequest does not support $eq range request\");\n        }\n        let cmp1 = this.comparator(node.value, range.val);\n        let cmp2 = 0;\n        if (range.op === \"$between\") {\n            if (range.high === null || range.high === undefined) {\n                throw new Error(\"collateRequest: $between request missing high range value\");\n            }\n            cmp2 = this.comparator(node.value, range.high);\n        }\n        if (node.left) {\n            switch (range.op) {\n                case \"$lt\":\n                case \"$lte\":\n                    result = this.collateRequest(this.nodes[node.left], range);\n                    break;\n                case \"$gt\":\n                case \"$gte\":\n                    // if the current node is still greater than compare value,\n                    // it's possible left child will be too\n                    if (cmp1 === 1) {\n                        result = this.collateRequest(this.nodes[node.left], range);\n                    }\n                    break;\n                case \"$between\":\n                    // only pursue left path if current node greater than (low) range val\n                    if (cmp1 === 1) {\n                        result = this.collateRequest(this.nodes[node.left], range);\n                    }\n                    break;\n                default: break;\n            }\n        }\n        if (!range) {\n            result.push(node.id);\n            result.push(...node.siblings);\n        }\n        else {\n            switch (range.op) {\n                case \"$lt\":\n                    if (cmp1 === -1) {\n                        result.push(node.id);\n                        result.push(...node.siblings);\n                    }\n                    break;\n                case \"$lte\":\n                    if (cmp1 === -1 || cmp1 === 0) {\n                        result.push(node.id);\n                        result.push(...node.siblings);\n                    }\n                    break;\n                case \"$gt\":\n                    if (cmp1 === 1) {\n                        result.push(node.id);\n                        result.push(...node.siblings);\n                    }\n                    break;\n                case \"$gte\":\n                    if (cmp1 === 1 || cmp1 === 0) {\n                        result.push(node.id);\n                        result.push(...node.siblings);\n                    }\n                    break;\n                case \"$between\":\n                    if (cmp1 >= 0 && cmp2 <= 0) {\n                        result.push(node.id);\n                        result.push(...node.siblings);\n                    }\n                    break;\n                default: break;\n            }\n        }\n        if (node.right) {\n            if (!range) {\n                result.push(...this.collateRequest(this.nodes[node.right], range));\n            }\n            else {\n                switch (range.op) {\n                    case \"$lt\":\n                    case \"$lte\":\n                        // if the current node is still less than compare value,\n                        // it's possible right child will be too\n                        if (cmp1 === -1) {\n                            result.push(...this.collateRequest(this.nodes[node.right], range));\n                        }\n                        break;\n                    case \"$gt\":\n                    case \"$gte\":\n                        result.push(...this.collateRequest(this.nodes[node.right], range));\n                        break;\n                    case \"$between\":\n                        // only pursue right path if current node less than (high) range val\n                        if (cmp2 === -1) {\n                            result.push(...this.collateRequest(this.nodes[node.right], range));\n                        }\n                        break;\n                    default: break;\n                }\n            }\n        }\n        return result;\n    }\n    /**\n     * Used on a branch node to return an array of id within that branch, sorted by their value\n     * @param node\n     */\n    collateIds(node) {\n        let result = [];\n        // debug diagnostic\n        if (!node) {\n            return [];\n        }\n        if (node.left) {\n            result = this.collateIds(this.nodes[node.left]);\n        }\n        result.push(node.id);\n        result.push(...node.siblings);\n        if (node.right) {\n            result.push(...this.collateIds(this.nodes[node.right]));\n        }\n        return result;\n    }\n    /**\n     * Traverses tree to a node matching the provided value.\n     * @param node\n     * @param val\n     */\n    /*\n    private locate(node: TreeNode<T>, val: any): TreeNode<T> {\n       switch (this.comparator.compare(val, node.value)) {\n          case 0: return node;\n          case 1:\n             if (!node.right) {\n                return null;\n             }\n  \n             return this.locate(this.nodes[node.right], val);\n          case -1:\n             if (!node.left) {\n                return null;\n             }\n  \n             return this.locate(this.nodes[node.left], val);\n       }\n    }\n    */\n    /**\n     * Inline/Non-recusive 'single value' ($eq) lookup.\n     * Traverses tree to a node matching the provided value.\n     * @param node\n     * @param val\n     */\n    locate(node, val) {\n        while (node !== null) {\n            switch (this.comparator(val, node.value)) {\n                case 0: return node;\n                case 1:\n                    if (!node.right) {\n                        return null;\n                    }\n                    node = this.nodes[node.right];\n                    break;\n                case -1:\n                    if (!node.left) {\n                        return null;\n                    }\n                    node = this.nodes[node.left];\n                    break;\n            }\n        }\n        return null;\n    }\n    /**\n     * Index integrity check (IRangedIndex interface function)\n     */\n    validateIndex() {\n        // handle null apex condition and verify empty tree and nodes\n        if (!this.apex) {\n            if (Object.keys(this.nodes).length !== 0) {\n                return false;\n            }\n            return true;\n        }\n        // ensure apex has no parent\n        if (this.nodes[this.apex].parent !== null) {\n            return false;\n        }\n        // high level verification - retrieve all node ids ordered by their values\n        let result = this.collateIds(this.nodes[this.apex]);\n        let nc = Object.keys(this.nodes).length;\n        // verify the inorder traversal returned same number of elements as nodes hashmap\n        if (result.length !== nc) {\n            return false;\n        }\n        // if only one result\n        if (result.length === 1) {\n            if (this.nodes[result[0]].parent !== null)\n                return false;\n            if (this.nodes[result[0]].left !== null)\n                return false;\n            if (this.nodes[result[0]].right !== null)\n                return false;\n            return true;\n        }\n        // iterate results and ensure next value is greater or equal to current\n        for (let i = 0; i < result.length - 1; i++) {\n            if (this.comparator(this.nodes[result[i]].value, this.nodes[result[i + 1]].value) === 1) {\n                return false;\n            }\n        }\n        return this.validateNode(this.nodes[this.apex]);\n    }\n    /**\n     * Recursive Node validation routine\n     * @param node\n     */\n    validateNode(node) {\n        // should never have parent or child pointers reference self\n        if ([node.parent, node.left, node.right].indexOf(node.id) !== -1) {\n            return false;\n        }\n        // validate height and balance\n        let hl = (node.left) ? this.nodes[node.left].height : -1;\n        let hr = (node.right) ? this.nodes[node.right].height : -1;\n        let eh = 1 + Math.max(hl, hr);\n        if (node.height !== eh) {\n            return false;\n        }\n        if (node.balance !== hr - hl) {\n            return false;\n        }\n        // verify any siblings parent back to self\n        if (node.siblings.length > 0) {\n            for (let sid of node.siblings) {\n                if (this.nodes[sid].parent !== node.id)\n                    return false;\n            }\n        }\n        // if there is a left child, verify it parents to self and recurse it\n        if (node.left) {\n            if (this.nodes[node.left].parent !== node.id) {\n                return false;\n            }\n            if (!this.validateNode(this.nodes[node.left])) {\n                return false;\n            }\n        }\n        // if there is a right child, verify it parents to self and recurse it\n        if (node.right) {\n            if (this.nodes[node.right].parent !== node.id) {\n                return false;\n            }\n            if (!this.validateNode(this.nodes[node.right])) {\n                return false;\n            }\n        }\n        return true;\n    }\n}\n\n// CONCATENATED MODULE: ./packages/loki/src/ranged_indexes.ts\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return RangedIndexFactoryMap; });\n\n/** Map/Register of named factory functions returning IRangedIndex instances */\nlet RangedIndexFactoryMap = {\n    \"avl\": (name, comparator) => { return new AvlTreeIndex(name, comparator); }\n};\n\n\n/***/ }),\n/* 5 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return LokiEventEmitter; });\n/**\n * LokiEventEmitter is a minimalist version of EventEmitter. It enables any\n * constructor that inherits EventEmitter to emit events and trigger\n * listeners that have been added to the event through the on(event, callback) method\n *\n * @constructor LokiEventEmitter\n */\nclass LokiEventEmitter {\n    constructor() {\n        /**\n         * A map, with each property being an array of callbacks.\n         */\n        this._events = {};\n        /**\n         * Determines whether or not the callbacks associated with each event should happen in an async fashion or not.\n         * Default is false, which means events are synchronous\n         */\n        this._asyncListeners = false;\n    }\n    /**\n     * Adds a listener to the queue of callbacks associated to an event\n     * @param {string|string[]} eventName - the name(s) of the event(s) to listen to\n     * @param {function} listener - callback function of listener to attach\n     * @returns {int} the index of the callback in the array of listeners for a particular event\n     */\n    on(eventName, listener) {\n        let event;\n        if (Array.isArray(eventName)) {\n            eventName.forEach((currentEventName) => {\n                this.on(currentEventName, listener);\n            });\n            return listener;\n        }\n        event = this._events[eventName];\n        if (!event) {\n            event = this._events[eventName] = [];\n        }\n        event.push(listener);\n        return listener;\n    }\n    /**\n     * Emits a particular event\n     * with the option of passing optional parameters which are going to be processed by the callback\n     * provided signatures match (i.e. if passing emit(event, arg0, arg1) the listener should take two parameters)\n     * @param {string} eventName - the name of the event\n     * @param {object} data - optional object passed with the event\n     */\n    emit(eventName, ...data) {\n        if (eventName && this._events[eventName]) {\n            this._events[eventName].forEach((listener) => {\n                if (this._asyncListeners) {\n                    setTimeout(() => {\n                        listener(...data);\n                    }, 1);\n                }\n                else {\n                    listener(...data);\n                }\n            });\n        }\n    }\n    /**\n     * Alias of EventEmitter.on().\n     */\n    addListener(eventName, listener) {\n        return this.on(eventName, listener);\n    }\n    /**\n     * Removes the listener at position 'index' from the event 'eventName'\n     * @param {string|string[]} eventName - the name(s) of the event(s) which the listener is attached to\n     * @param {function} listener - the listener callback function to remove from emitter\n     */\n    removeListener(eventName, listener) {\n        if (Array.isArray(eventName)) {\n            eventName.forEach((currentEventName) => {\n                this.removeListener(currentEventName, listener);\n            });\n        }\n        if (this._events[eventName]) {\n            const listeners = this._events[eventName];\n            listeners.splice(listeners.indexOf(listener), 1);\n        }\n    }\n}\n\n\n/***/ }),\n/* 6 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return Loki; });\n/* harmony import */ var _event_emitter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);\n/* harmony import */ var _collection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3);\n/* harmony import */ var _common_plugin__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1);\n/* harmony import */ var _comparators__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(0);\n/* harmony import */ var _ranged_indexes__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4);\n/* harmony import */ var _operator_packages__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(2);\n\n\n\n\n\n\nfunction getENV() {\n    if (global !== undefined && (global[\"android\"] || global[\"NSObject\"])) {\n        return \"NATIVESCRIPT\";\n    }\n    const isNode = global !== undefined && ({}).toString.call(global.process) === \"[object process]\";\n    if (isNode) {\n        if (global[\"window\"]) {\n            return \"NODEJS\"; //node-webkit\n        }\n        else {\n            return \"NODEJS\";\n        }\n    }\n    if (document !== undefined) {\n        if (document.URL.indexOf(\"http://\") === -1 && document.URL.indexOf(\"https://\") === -1) {\n            return \"CORDOVA\";\n        }\n        return \"BROWSER\";\n    }\n    const isBrowser = window !== undefined && ({}).toString.call(window) === \"[object Window]\";\n    if (isBrowser) {\n        return \"BROWSER\";\n    }\n    throw SyntaxError(\"Unknown environment...\");\n}\nclass Loki extends _event_emitter__WEBPACK_IMPORTED_MODULE_0__[/* LokiEventEmitter */ \"a\"] {\n    /**\n     * Constructs the main database class.\n     * @param {string} filename - name of the file to be saved to\n     * @param {object} [options={}] - options\n     * @param {Loki.Environment} [options.env] - the javascript environment\n     * @param {Loki.SerializationMethod} [options.serializationMethod=NORMAL] - the serialization method\n     * @param {string} [options.destructureDelimiter=\"$<\\n\"] - string delimiter used for destructured serialization\n     * @param {IComparatorMap} [options.comparatorMap] allows injecting or overriding registered comparators\n     * @param {IRangedIndexFactoryMap} [options.rangedIndexFactoryMap] allows injecting or overriding registered ranged index factories\n     * @param {ILokiOperatorPackageMap} [options.lokiOperatorPackageMap] allows injecting or overriding registered loki operator packages\n     */\n    constructor(filename = \"loki.db\", options = {}) {\n        super();\n        // persist version of code which created the database to the database.\n        // could use for upgrade scenarios\n        this.databaseVersion = 1.5; // TODO\n        this.engineVersion = 1.5;\n        // persistenceMethod could be 'fs', 'localStorage', or 'adapter'\n        // this is optional option param, otherwise environment detection will be used\n        // if user passes their own adapter we will force this method to 'adapter' later, so no need to pass method option.\n        this._persistenceMethod = null;\n        // retain reference to optional (non-serializable) persistenceAdapter 'instance'\n        this._persistenceAdapter = null;\n        // flags used to throttle saves\n        this._throttledSaves = true;\n        this._throttledSaveRunning = null;\n        this._throttledSavePending = null;\n        // autosave support (disabled by default)\n        this._autosave = false;\n        this._autosaveInterval = 5000;\n        this._autosaveRunning = false;\n        this._autosaveHandler = Promise.resolve();\n        this.filename = filename;\n        this._collections = [];\n        ({\n            serializationMethod: this._serializationMethod = \"normal\",\n            destructureDelimiter: this._destructureDelimiter = \"$<\\n\",\n            env: this._env = getENV()\n        } = options);\n        this._events = {\n            \"init\": [],\n            \"loaded\": [],\n            \"flushChanges\": [],\n            \"close\": [],\n            \"changes\": [],\n            \"warning\": []\n        };\n        // allow users to inject their own comparators\n        if (options.comparatorMap) {\n            for (let c in options.comparatorMap) {\n                _comparators__WEBPACK_IMPORTED_MODULE_3__[/* ComparatorMap */ \"a\"][c] = options.comparatorMap[c];\n            }\n        }\n        // allow users to register their own rangedIndex factory functions\n        if (options.rangedIndexFactoryMap) {\n            for (let rif in options.rangedIndexFactoryMap) {\n                _ranged_indexes__WEBPACK_IMPORTED_MODULE_4__[/* RangedIndexFactoryMap */ \"a\"][rif] = options.rangedIndexFactoryMap[rif];\n            }\n        }\n        // allow users to register their own LokiOperatorPackages or inject functionality within existing ones\n        if (options.lokiOperatorPackageMap) {\n            for (let lop in options.lokiOperatorPackageMap) {\n                _operator_packages__WEBPACK_IMPORTED_MODULE_5__[/* LokiOperatorPackageMap */ \"a\"][lop] = options.lokiOperatorPackageMap[lop];\n            }\n        }\n        this.on(\"init\", this.clearChanges);\n    }\n    /**\n     * configures options related to database persistence.\n     *\n     * @param {Loki.PersistenceOptions} [options={}] - options\n     * @param {adapter} [options.adapter=auto] - an instance of a loki persistence adapter\n     * @param {boolean} [options.autosave=false] - enables autosave\n     * @param {int} [options.autosaveInterval=5000] - time interval (in milliseconds) between saves (if dirty)\n     * @param {boolean} [options.autoload=false] - enables autoload on loki instantiation\n     * @param {object} options.inflate - options that are passed to loadDatabase if autoload enabled\n     * @param {boolean} [options.throttledSaves=true] - if true, it batches multiple calls to to saveDatabase reducing number of\n     *   disk I/O operations and guaranteeing proper serialization of the calls. Default value is true.\n     * @param {Loki.PersistenceMethod} options.persistenceMethod - a persistence method which should be used (FS_STORAGE, LOCAL_STORAGE...)\n     * @returns {Promise} a Promise that resolves after initialization and (if enabled) autoloading the database\n     */\n    initializePersistence(options = {}) {\n        let loaded = this._autosaveDisable();\n        ({\n            autosave: this._autosave = false,\n            autosaveInterval: this._autosaveInterval = 5000,\n            persistenceMethod: this._persistenceMethod,\n            // TODO\n            //inflate: this.options.inflate,\n            throttledSaves: this._throttledSaves = true\n        } = options);\n        const DEFAULT_PERSISTENCE = {\n            \"NODEJS\": [\"fs-storage\"],\n            \"BROWSER\": [\"local-storage\", \"indexed-storage\"],\n            \"CORDOVA\": [\"local-storage\", \"indexed-storage\"],\n            \"MEMORY\": [\"memory-storage\"]\n        };\n        const PERSISTENCE_METHODS = {\n            \"fs-storage\": _common_plugin__WEBPACK_IMPORTED_MODULE_2__[/* PLUGINS */ \"a\"][\"FSStorage\"],\n            \"local-storage\": _common_plugin__WEBPACK_IMPORTED_MODULE_2__[/* PLUGINS */ \"a\"][\"LocalStorage\"],\n            \"indexed-storage\": _common_plugin__WEBPACK_IMPORTED_MODULE_2__[/* PLUGINS */ \"a\"][\"IndexedStorage\"],\n            \"memory-storage\": _common_plugin__WEBPACK_IMPORTED_MODULE_2__[/* PLUGINS */ \"a\"][\"MemoryStorage\"]\n        };\n        // process the options\n        if (this._persistenceMethod !== undefined) {\n            // check if the specified persistence method is known\n            if (typeof (PERSISTENCE_METHODS[this._persistenceMethod]) === \"function\") {\n                this._persistenceAdapter = new (PERSISTENCE_METHODS[this._persistenceMethod]);\n            }\n            else {\n                throw Error(\"Unknown persistence method.\");\n            }\n        }\n        // if user passes adapter, set persistence mode to adapter and retain persistence adapter instance\n        if (options.adapter !== undefined) {\n            this._persistenceMethod = \"adapter\";\n            this._persistenceAdapter = options.adapter;\n        }\n        // if by now there is no adapter specified by user nor derived from persistenceMethod: use sensible defaults\n        if (this._persistenceAdapter === null) {\n            let possiblePersistenceMethods = DEFAULT_PERSISTENCE[this._env];\n            if (possiblePersistenceMethods) {\n                for (let i = 0; i < possiblePersistenceMethods.length; i++) {\n                    if (PERSISTENCE_METHODS[possiblePersistenceMethods[i]]) {\n                        this._persistenceMethod = possiblePersistenceMethods[i];\n                        this._persistenceAdapter = new (PERSISTENCE_METHODS[possiblePersistenceMethods[i]]);\n                        break;\n                    }\n                }\n            }\n        }\n        // if they want to load database on loki instantiation, now is a good time to load... after adapter set and before\n        // possible autosave initiation\n        if (options.autoload) {\n            loaded = loaded.then(() => this._loadDatabase(options.inflate, true));\n        }\n        return loaded.then(() => {\n            this._autosaveEnable();\n        });\n    }\n    /**\n     * Copies 'this' database into a new Loki instance. Object references are shared to make lightweight.\n     * @param {object} options - options\n     * @param {boolean} options.removeNonSerializable - nulls properties not safe for serialization.\n     */\n    copy(options = {}) {\n        const databaseCopy = new Loki(this.filename, { env: this._env });\n        // currently inverting and letting loadJSONObject do most of the work\n        databaseCopy.loadJSONObject(this, {\n            retainDirtyFlags: true\n        });\n        // since our toJSON is not invoked for reference database adapters, this will let us mimic\n        if (options.removeNonSerializable) {\n            databaseCopy._persistenceAdapter = null;\n            for (let idx = 0; idx < databaseCopy._collections.length; idx++) {\n                databaseCopy._collections[idx]._constraints = null;\n                databaseCopy._collections[idx]._ttl = null;\n            }\n        }\n        return databaseCopy;\n    }\n    /**\n     * Adds a collection to the database.\n     * @param {string} name - name of collection to add\n     * @param {object} [options={}] - options to configure collection with.\n     * @param {array} [options.unique=[]] - array of property names to define unique constraints for\n     * @param {array} [options.exact=[]] - array of property names to define exact constraints for\n     * @param {array} [options.indices=[]] - array property names to define binary indexes for\n     * @param {boolean} [options.asyncListeners=false] - whether listeners are called asynchronously\n     * @param {boolean} [options.disableMeta=false] - set to true to disable meta property on documents\n     * @param {boolean} [options.disableChangesApi=true] - set to false to enable Changes Api\n     * @param {boolean} [options.disableDeltaChangesApi=true] - set to false to enable Delta Changes API (requires Changes API, forces cloning)\n     * @param {boolean} [options.clone=false] - specify whether inserts and queries clone to/from user\n     * @param {string} [options.cloneMethod=CloneMethod.DEEP] - the clone method\n     * @param {number} [options.ttl=] - age of document (in ms.) before document is considered aged/stale\n     * @param {number} [options.ttlInterval=] - time interval for clearing out 'aged' documents; not set by default\n     * @returns {Collection} a reference to the collection which was just added\n     */\n    addCollection(name, options = {}) {\n        // Return an existing collection if a collection with the same name already exists.\n        for (let i = 0; i < this._collections.length; i++) {\n            if (this._collections[i].name === name) {\n                return this._collections[i];\n            }\n        }\n        // Create a new collection otherwise.\n        const collection = new _collection__WEBPACK_IMPORTED_MODULE_1__[/* Collection */ \"a\"](name, options);\n        this._collections.push(collection);\n        return collection;\n    }\n    loadCollection(collection) {\n        if (!collection.name) {\n            throw new Error(\"Collection must have a name property to be loaded\");\n        }\n        this._collections.push(collection);\n    }\n    /**\n     * Retrieves reference to a collection by name.\n     * @param {string} name - name of collection to look up\n     * @returns {Collection} Reference to collection in database by that name, or null if not found\n     */\n    getCollection(name) {\n        for (let i = 0; i < this._collections.length; i++) {\n            if (this._collections[i].name === name) {\n                return this._collections[i];\n            }\n        }\n        // no such collection\n        this.emit(\"warning\", \"collection \" + name + \" not found\");\n        return null;\n    }\n    /**\n     * Renames an existing loki collection\n     * @param {string} oldName - name of collection to rename\n     * @param {string} newName - new name of collection\n     * @returns {Collection} reference to the newly renamed collection\n     */\n    renameCollection(oldName, newName) {\n        const c = this.getCollection(oldName);\n        if (c) {\n            c.name = newName;\n        }\n        return c;\n    }\n    listCollections() {\n        const colls = [];\n        for (let i = 0; i < this._collections.length; i++) {\n            colls.push({\n                name: this._collections[i].name,\n                count: this._collections[i].count()\n            });\n        }\n        return colls;\n    }\n    /**\n     * Removes a collection from the database.\n     * @param {string} collectionName - name of collection to remove\n     */\n    removeCollection(collectionName) {\n        for (let i = 0; i < this._collections.length; i++) {\n            if (this._collections[i].name === collectionName) {\n                const tmpcol = new _collection__WEBPACK_IMPORTED_MODULE_1__[/* Collection */ \"a\"](collectionName, {});\n                const curcol = this._collections[i];\n                for (const prop in curcol) {\n                    if (curcol[prop] !== undefined && tmpcol[prop] !== undefined) {\n                        curcol[prop] = tmpcol[prop];\n                    }\n                }\n                this._collections.splice(i, 1);\n                return;\n            }\n        }\n    }\n    /**\n     * Serialize database to a string which can be loaded via {@link Loki#loadJSON}\n     *\n     * @returns {string} Stringified representation of the loki database.\n     */\n    serialize(options = {}) {\n        if (options.serializationMethod === undefined) {\n            options.serializationMethod = this._serializationMethod;\n        }\n        switch (options.serializationMethod) {\n            case \"normal\":\n                return JSON.stringify(this);\n            case \"pretty\":\n                return JSON.stringify(this, null, 2);\n            case \"destructured\":\n                return this.serializeDestructured(); // use default options\n            default:\n                return JSON.stringify(this);\n        }\n    }\n    // alias of serialize\n    toJSON() {\n        return {\n            _env: this._env,\n            _serializationMethod: this._serializationMethod,\n            _autosave: this._autosave,\n            _autosaveInterval: this._autosaveInterval,\n            _collections: this._collections,\n            databaseVersion: this.databaseVersion,\n            engineVersion: this.engineVersion,\n            filename: this.filename,\n            _persistenceAdapter: this._persistenceAdapter,\n            _persistenceMethod: this._persistenceMethod,\n            _throttledSaves: this._throttledSaves\n        };\n    }\n    /**\n     * Database level destructured JSON serialization routine to allow alternate serialization methods.\n     * Internally, Loki supports destructuring via loki \"serializationMethod' option and\n     * the optional LokiPartitioningAdapter class. It is also available if you wish to do\n     * your own structured persistence or data exchange.\n     *\n     * @param {object} options - output format options for use externally to loki\n     * @param {boolean} [options.partitioned=false] - whether db and each collection are separate\n     * @param {int} options.partition - can be used to only output an individual collection or db (-1)\n     * @param {boolean} [options.delimited=true] - whether subitems are delimited or subarrays\n     * @param {string} options.delimiter - override default delimiter\n     *\n     * @returns {string|Array} A custom, restructured aggregation of independent serializations.\n     */\n    serializeDestructured(options = {}) {\n        if (options.partitioned === undefined) {\n            options.partitioned = false;\n        }\n        if (options.delimited === undefined) {\n            options.delimited = true;\n        }\n        if (options.delimiter === undefined) {\n            options.delimiter = this._destructureDelimiter;\n        }\n        // 'partitioned' along with 'partition' of 0 or greater is a request for single collection serialization\n        if (options.partitioned === true && options.partition !== undefined && options.partition >= 0) {\n            return this.serializeCollection({\n                delimited: options.delimited,\n                delimiter: options.delimiter,\n                collectionIndex: options.partition\n            });\n        }\n        // not just an individual collection, so we will need to serialize db container via shallow copy\n        let dbcopy = new Loki(this.filename);\n        dbcopy.loadJSONObject(this);\n        for (let idx = 0; idx < dbcopy._collections.length; idx++) {\n            dbcopy._collections[idx]._data = [];\n        }\n        // if we -only- wanted the db container portion, return it now\n        if (options.partitioned === true && options.partition === -1) {\n            // since we are deconstructing, override serializationMethod to normal for here\n            return dbcopy.serialize({\n                serializationMethod: \"normal\"\n            });\n        }\n        // at this point we must be deconstructing the entire database\n        // start by pushing db serialization into first array element\n        const reconstruct = [];\n        reconstruct.push(dbcopy.serialize({\n            serializationMethod: \"normal\"\n        }));\n        dbcopy = null;\n        // push collection data into subsequent elements\n        for (let idx = 0; idx < this._collections.length; idx++) {\n            let result = this.serializeCollection({\n                delimited: options.delimited,\n                delimiter: options.delimiter,\n                collectionIndex: idx\n            });\n            // NDA : Non-Delimited Array : one iterable concatenated array with empty string collection partitions\n            if (options.partitioned === false && options.delimited === false) {\n                if (!Array.isArray(result)) {\n                    throw new Error(\"a nondelimited, non partitioned collection serialization did not return an expected array\");\n                }\n                // Array.concat would probably duplicate memory overhead for copying strings.\n                // Instead copy each individually, and clear old value after each copy.\n                // Hopefully this will allow g.c. to reduce memory pressure, if needed.\n                for (let sidx = 0; sidx < result.length; sidx++) {\n                    reconstruct.push(result[sidx]);\n                    result[sidx] = null;\n                }\n                reconstruct.push(\"\");\n            }\n            else {\n                reconstruct.push(result);\n            }\n        }\n        // Reconstruct / present results according to four combinations : D, DA, NDA, NDAA\n        if (options.partitioned) {\n            // DA : Delimited Array of strings [0] db [1] collection [n] collection { partitioned: true, delimited: true }\n            // useful for simple future adaptations of existing persistence adapters to save collections separately\n            if (options.delimited) {\n                return reconstruct;\n            }\n            // NDAA : Non-Delimited Array with subArrays. db at [0] and collection subarrays at [n] { partitioned: true, delimited : false }\n            // This format might be the most versatile for 'rolling your own' partitioned sync or save.\n            // Memory overhead can be reduced by specifying a specific partition, but at this code path they did not, so its all.\n            else {\n                return reconstruct;\n            }\n        }\n        else {\n            // D : one big Delimited string { partitioned: false, delimited : true }\n            // This is the method Loki will use internally if 'destructured'.\n            // Little memory overhead improvements but does not require multiple asynchronous adapter call scheduling\n            if (options.delimited) {\n                // indicate no more collections\n                reconstruct.push(\"\");\n                return reconstruct.join(options.delimiter);\n            }\n            // NDA : Non-Delimited Array : one iterable array with empty string collection partitions { partitioned: false, delimited: false }\n            // This format might be best candidate for custom synchronous syncs or saves\n            else {\n                // indicate no more collections\n                reconstruct.push(\"\");\n                return reconstruct;\n            }\n        }\n    }\n    /**\n     * Collection level utility method to serialize a collection in a 'destructured' format\n     *\n     * @param {object} options - used to determine output of method\n     * @param {int} options.delimited - whether to return single delimited string or an array\n     * @param {string} options.delimiter - (optional) if delimited, this is delimiter to use\n     * @param {int} options.collectionIndex -  specify which collection to serialize data for\n     *\n     * @returns {string|array} A custom, restructured aggregation of independent serializations for a single collection.\n     */\n    serializeCollection(options = {}) {\n        if (options.delimited === undefined) {\n            options.delimited = true;\n        }\n        if (options.collectionIndex === undefined) {\n            throw new Error(\"serializeCollection called without 'collectionIndex' option\");\n        }\n        const doccount = this._collections[options.collectionIndex].count();\n        let resultlines = [];\n        for (let docidx = 0; docidx < doccount; docidx++) {\n            resultlines.push(JSON.stringify(this._collections[options.collectionIndex]._data[docidx]));\n        }\n        // D and DA\n        if (options.delimited) {\n            // indicate no more documents in collection (via empty delimited string)\n            resultlines.push(\"\");\n            return resultlines.join(options.delimiter);\n        }\n        else {\n            // NDAA and NDA\n            return resultlines;\n        }\n    }\n    /**\n     * Database level destructured JSON deserialization routine to minimize memory overhead.\n     * Internally, Loki supports destructuring via loki \"serializationMethod' option and\n     * the optional LokiPartitioningAdapter class. It is also available if you wish to do\n     * your own structured persistence or data exchange.\n     *\n     * @param {string|array} destructuredSource - destructured json or array to deserialize from\n     * @param {object} options - source format options\n     * @param {boolean} [options.partitioned=false] - whether db and each collection are separate\n     * @param {int} options.partition - can be used to deserialize only a single partition\n     * @param {boolean} [options.delimited=true] - whether subitems are delimited or subarrays\n     * @param {string} options.delimiter - override default delimiter\n     *\n     * @returns {object|array} An object representation of the deserialized database, not yet applied to 'this' db or document array\n     */\n    deserializeDestructured(destructuredSource, options = {}) {\n        if (options.partitioned === undefined) {\n            options.partitioned = false;\n        }\n        if (options.delimited === undefined) {\n            options.delimited = true;\n        }\n        if (options.delimiter === undefined) {\n            options.delimiter = this._destructureDelimiter;\n        }\n        // Partitioned\n        // DA : Delimited Array of strings [0] db [1] collection [n] collection { partitioned: true, delimited: true }\n        // NDAA : Non-Delimited Array with subArrays. db at [0] and collection subarrays at [n] { partitioned: true, delimited : false }\n        // -or- single partition\n        if (options.partitioned) {\n            // handle single partition\n            if (options.partition !== undefined) {\n                // db only\n                if (options.partition === -1) {\n                    return JSON.parse(destructuredSource[0]);\n                }\n                // single collection, return doc array\n                return this.deserializeCollection(destructuredSource[options.partition + 1], options);\n            }\n            // Otherwise we are restoring an entire partitioned db\n            const cdb = JSON.parse(destructuredSource[0]);\n            const collCount = cdb._collections.length;\n            for (let collIndex = 0; collIndex < collCount; collIndex++) {\n                // attach each collection docarray to container collection data, add 1 to collection array index since db is at 0\n                cdb._collections[collIndex]._data = this.deserializeCollection(destructuredSource[collIndex + 1], options);\n            }\n            return cdb;\n        }\n        // Non-Partitioned\n        // D : one big Delimited string { partitioned: false, delimited : true }\n        // NDA : Non-Delimited Array : one iterable array with empty string collection partitions { partitioned: false, delimited: false }\n        let workarray = [];\n        // D\n        if (options.delimited) {\n            workarray = destructuredSource.split(options.delimiter);\n            destructuredSource = null; // lower memory pressure\n            if (workarray.length === 0) {\n                return null;\n            }\n        }\n        // NDA\n        else {\n            workarray = destructuredSource;\n        }\n        // first line is database and collection shells\n        const cdb = JSON.parse(workarray[0]);\n        const collCount = cdb._collections.length;\n        workarray[0] = null;\n        let collIndex = 0;\n        let lineIndex = 1;\n        let done = false;\n        while (!done) {\n            // empty string indicates either end of collection or end of file\n            if (workarray[lineIndex] === \"\") {\n                // if no more collections to load into, we are done\n                if (++collIndex > collCount) {\n                    done = true;\n                }\n            }\n            else {\n                cdb._collections[collIndex]._data.push(JSON.parse(workarray[lineIndex]));\n            }\n            // lower memory pressure and advance iterator\n            workarray[lineIndex++] = null;\n        }\n        return cdb;\n    }\n    /**\n     * Collection level utility function to deserializes a destructured collection.\n     *\n     * @param {string|string[]} destructuredSource - destructured representation of collection to inflate\n     * @param {object} options - used to describe format of destructuredSource input\n     * @param {int} [options.delimited=false] - whether source is delimited string or an array\n     * @param {string} options.delimiter - if delimited, this is delimiter to use (if other than default)\n     *\n     * @returns {Array} an array of documents to attach to collection.data.\n     */\n    deserializeCollection(destructuredSource, options = {}) {\n        if (options.partitioned === undefined) {\n            options.partitioned = false;\n        }\n        if (options.delimited === undefined) {\n            options.delimited = true;\n        }\n        if (options.delimiter === undefined) {\n            options.delimiter = this._destructureDelimiter;\n        }\n        let workarray = [];\n        if (options.delimited) {\n            workarray = destructuredSource.split(options.delimiter);\n            workarray.pop();\n        }\n        else {\n            workarray = destructuredSource;\n        }\n        for (let idx = 0; idx < workarray.length; idx++) {\n            workarray[idx] = JSON.parse(workarray[idx]);\n        }\n        return workarray;\n    }\n    /**\n     * Inflates a loki database from a serialized JSON string\n     *\n     * @param {string} serializedDb - a serialized loki database string\n     * @param {object} options - apply or override collection level settings\n     * @param {boolean} options.retainDirtyFlags - whether collection dirty flags will be preserved\n     */\n    loadJSON(serializedDb, options) {\n        let dbObject;\n        if (serializedDb.length === 0) {\n            dbObject = {};\n        }\n        else {\n            // using option defined in instantiated db not what was in serialized db\n            switch (this._serializationMethod) {\n                case \"normal\":\n                case \"pretty\":\n                    dbObject = JSON.parse(serializedDb);\n                    break;\n                case \"destructured\":\n                    dbObject = this.deserializeDestructured(serializedDb);\n                    break;\n                default:\n                    dbObject = JSON.parse(serializedDb);\n                    break;\n            }\n        }\n        this.loadJSONObject(dbObject, options);\n    }\n    loadJSONObject(dbObject, options = {}) {\n        const len = dbObject._collections ? dbObject._collections.length : 0;\n        this.filename = dbObject.filename;\n        this._collections = [];\n        for (let i = 0; i < len; ++i) {\n            this._collections.push(_collection__WEBPACK_IMPORTED_MODULE_1__[/* Collection */ \"a\"].fromJSONObject(dbObject._collections[i], options));\n        }\n    }\n    /**\n     * Emits the close event. In autosave scenarios, if the database is dirty, this will save and disable timer.\n     * Does not actually destroy the db.\n     *\n     * @returns {Promise} a Promise that resolves after closing the database succeeded\n     */\n    close() {\n        // for autosave scenarios, we will let close perform final save (if dirty)\n        // For web use, you might call from window.onbeforeunload to shutdown database, saving pending changes\n        if (this._autosave) {\n            return this._autosaveDisable()\n                .then(() => {\n                if (this._autosaveDirty()) {\n                    return this.saveDatabase();\n                }\n                return Promise.resolve();\n            });\n        }\n        return Promise.resolve().then(() => {\n            this.emit(\"close\");\n        });\n    }\n    /**-------------------------+\n     | Changes API               |\n     +--------------------------*/\n    /**\n     * The Changes API enables the tracking the changes occurred in the collections since the beginning of the session,\n     * so it's possible to create a differential dataset for synchronization purposes (possibly to a remote db)\n     */\n    /**\n     * (Changes API) : takes all the changes stored in each\n     * collection and creates a single array for the entire database. If an array of names\n     * of collections is passed then only the included collections will be tracked.\n     *\n     * @param {Array} [arrayOfCollectionNames=] - array of collection names. No arg means all collections are processed.\n     * @returns {Array} array of changes\n     * @see private method _createChange() in Collection\n     */\n    generateChangesNotification(arrayOfCollectionNames) {\n        let changes = [];\n        const selectedCollections = arrayOfCollectionNames\n            || this._collections.map((coll) => coll.name);\n        this._collections.forEach((coll) => {\n            if (selectedCollections.indexOf(coll.name) !== -1) {\n                changes = changes.concat(coll.getChanges());\n            }\n        });\n        return changes;\n    }\n    /**\n     * (Changes API) - stringify changes for network transmission\n     * @returns {string} string representation of the changes\n     */\n    serializeChanges(collectionNamesArray) {\n        return JSON.stringify(this.generateChangesNotification(collectionNamesArray));\n    }\n    /**\n     * (Changes API) : clears all the changes in all collections.\n     */\n    clearChanges() {\n        this._collections.forEach((coll) => {\n            if (coll.flushChanges) {\n                coll.flushChanges();\n            }\n        });\n    }\n    /**\n     * Wait for throttledSaves to complete and invoke your callback when drained or duration is met.\n     *\n     * @param {object} options - configuration options\n     * @param {boolean} [options.recursiveWait=true] - if after queue is drained, another save was kicked off, wait for it\n     * @param {boolean} [options.recursiveWaitLimit=false] - limit our recursive waiting to a duration\n     * @param {number} [options.recursiveWaitLimitDuration=2000] - cutoff in ms to stop recursively re-draining\n     * @param {Date} [options.started=now()] - the start time of the recursive wait duration\n     * @returns {Promise} a Promise that resolves when save queue is drained, it is passed a sucess parameter value\n     */\n    throttledSaveDrain(options = {}) {\n        const now = (new Date()).getTime();\n        if (!this._throttledSaves) {\n            return Promise.resolve();\n        }\n        if (options.recursiveWait === undefined) {\n            options.recursiveWait = true;\n        }\n        if (options.recursiveWaitLimit === undefined) {\n            options.recursiveWaitLimit = false;\n        }\n        if (options.recursiveWaitLimitDuration === undefined) {\n            options.recursiveWaitLimitDuration = 2000;\n        }\n        if (options.started === undefined) {\n            options.started = new Date();\n        }\n        // if save is pending\n        if (this._throttledSaves && this._throttledSaveRunning !== null) {\n            // if we want to wait until we are in a state where there are no pending saves at all\n            if (options.recursiveWait) {\n                // queue the following meta callback for when it completes\n                return Promise.resolve(Promise.all([this._throttledSaveRunning, this._throttledSavePending])).then(() => {\n                    if (this._throttledSaveRunning !== null || this._throttledSavePending !== null) {\n                        if (options.recursiveWaitLimit && (now - options.started.getTime() > options.recursiveWaitLimitDuration)) {\n                            return Promise.reject({});\n                        }\n                        return this.throttledSaveDrain(options);\n                    }\n                    else {\n                        return Promise.resolve();\n                    }\n                });\n            }\n            // just notify when current queue is depleted\n            else {\n                return Promise.resolve(this._throttledSaveRunning);\n            }\n        }\n        // no save pending, just callback\n        else {\n            return Promise.resolve();\n        }\n    }\n    /**\n     * Internal load logic, decoupled from throttling/contention logic\n     *\n     * @param {object} options - an object containing inflation options for each collection\n     * @param {boolean} ignore_not_found - does not raise an error if database is not found\n     * @returns {Promise} a Promise that resolves after the database is loaded\n     */\n    _loadDatabase(options = {}, ignore_not_found = false) {\n        // the persistenceAdapter should be present if all is ok, but check to be sure.\n        if (this._persistenceAdapter === null) {\n            return Promise.reject(new Error(\"persistenceAdapter not configured\"));\n        }\n        return Promise.resolve(this._persistenceAdapter.loadDatabase(this.filename))\n            .then((dbString) => {\n            if (typeof (dbString) === \"string\") {\n                this.loadJSON(dbString, options);\n                this.emit(\"load\", this);\n                // if adapter has returned a js object (other than null or error) attempt to load from JSON object\n            }\n            else if (typeof (dbString) === \"object\" && dbString !== null && !(dbString instanceof Error)) {\n                this.loadJSONObject(dbString, options);\n                this.emit(\"load\", this);\n            }\n            else {\n                throw dbString;\n            }\n        }).catch(e => {\n            if (e instanceof Error) {\n                throw e;\n            }\n            else if (e != null) {\n                throw new TypeError(\"The persistence adapter did not load a serialized DB string or object.\");\n            }\n            else if (!ignore_not_found) {\n                throw new Error(\"Database not found.\");\n            }\n        });\n    }\n    /**\n     * Handles manually loading from an adapter storage (such as fs-storage)\n     *    This method utilizes loki configuration options (if provided) to determine which\n     *    persistence method to use, or environment detection (if configuration was not provided).\n     *    To avoid contention with any throttledSaves, we will drain the save queue first.\n     *\n     * If you are configured with autosave, you do not need to call this method yourself.\n     *\n     * @param {object} [options={}] - if throttling saves and loads, this controls how we drain save queue before loading\n     * @param {boolean} [options.recursiveWait=true] wait recursively until no saves are queued\n     * @param {boolean} [options.recursiveWaitLimit=false] limit our recursive waiting to a duration\n     * @param {number} [options.recursiveWaitLimitDelay=2000] cutoff in ms to stop recursively re-draining\n     * @param {Date} [options.started=now()] - the start time of the recursive wait duration\n     * @returns {Promise} a Promise that resolves after the database is loaded\n     */\n    loadDatabase(options = {}) {\n        // if throttling disabled, just call internal\n        if (!this._throttledSaves) {\n            return this._loadDatabase(options);\n        }\n        // try to drain any pending saves in the queue to lock it for loading\n        return this.throttledSaveDrain(options).then(() => {\n            // pause/throttle saving until loading is done\n            this._throttledSaveRunning = this._loadDatabase(options).then(() => {\n                // now that we are finished loading, if no saves were throttled, disable flag\n                this._throttledSaveRunning = null;\n            });\n            return this._throttledSaveRunning;\n        }, () => {\n            throw new Error(\"Unable to pause save throttling long enough to read database\");\n        });\n    }\n    _saveDatabase() {\n        // the persistenceAdapter should be present if all is ok, but check to be sure.\n        if (this._persistenceAdapter === null) {\n            return Promise.reject(new Error(\"persistenceAdapter not configured\"));\n        }\n        // check if the adapter is requesting (and supports) a 'reference' mode export\n        if (this._persistenceAdapter.mode === \"reference\" && typeof this._persistenceAdapter.exportDatabase === \"function\") {\n            // filename may seem redundant but loadDatabase will need to expect this same filename\n            return Promise.resolve(this._persistenceAdapter.exportDatabase(this.filename, this.copy({ removeNonSerializable: true })))\n                .then(() => {\n                this._autosaveClearFlags();\n                this.emit(\"save\");\n            });\n        }\n        // otherwise just pass the serialized database to adapter\n        // persistenceAdapter might be asynchronous, so we must clear `dirty` immediately\n        // or autosave won't work if an update occurs between here and the callback\n        this._autosaveClearFlags();\n        return Promise.resolve(this._persistenceAdapter.saveDatabase(this.filename, this.serialize()))\n            .then(() => {\n            this.emit(\"save\");\n        });\n    }\n    /**\n     * Handles manually saving to an adapter storage (such as fs-storage)\n     *    This method utilizes loki configuration options (if provided) to determine which\n     *    persistence method to use, or environment detection (if configuration was not provided).\n     *\n     * If you are configured with autosave, you do not need to call this method yourself.\n     *\n     * @returns {Promise} a Promise that resolves after the database is persisted\n     */\n    saveDatabase() {\n        if (!this._throttledSaves) {\n            return this._saveDatabase();\n        }\n        // if the db save is currently running, a new promise for a next db save is created\n        // all calls to save db will get this new promise which will be processed right after\n        // the current db save is finished\n        if (this._throttledSaveRunning !== null && this._throttledSavePending === null) {\n            this._throttledSavePending = Promise.resolve(this._throttledSaveRunning).then(() => {\n                this._throttledSaveRunning = null;\n                this._throttledSavePending = null;\n                return this.saveDatabase();\n            });\n        }\n        if (this._throttledSavePending !== null) {\n            return this._throttledSavePending;\n        }\n        this._throttledSaveRunning = this._saveDatabase().then(() => {\n            this._throttledSaveRunning = null;\n        });\n        return this._throttledSaveRunning;\n    }\n    /**\n     * Handles deleting a database from the underlying storage adapter\n     *\n     * @returns {Promise} a Promise that resolves after the database is deleted\n     */\n    deleteDatabase() {\n        // the persistenceAdapter should be present if all is ok, but check to be sure.\n        if (this._persistenceAdapter === null) {\n            return Promise.reject(new Error(\"persistenceAdapter not configured\"));\n        }\n        return Promise.resolve(this._persistenceAdapter.deleteDatabase(this.filename));\n    }\n    /****************\n     * Autosave API\n     ****************/\n    /**\n     * Check whether any collections are \"dirty\" meaning we need to save the (entire) database\n     * @returns {boolean} - true if database has changed since last autosave, otherwise false\n     */\n    _autosaveDirty() {\n        for (let idx = 0; idx < this._collections.length; idx++) {\n            if (this._collections[idx]._dirty) {\n                return true;\n            }\n        }\n        return false;\n    }\n    /**\n     * Resets dirty flags on all collections.\n     */\n    _autosaveClearFlags() {\n        for (let idx = 0; idx < this._collections.length; idx++) {\n            this._collections[idx]._dirty = false;\n        }\n    }\n    /**\n     * Starts periodically saves to the underlying storage adapter.\n     */\n    _autosaveEnable() {\n        if (!this._autosave || this._autosaveRunning) {\n            return;\n        }\n        this._autosaveRunning = true;\n        const interval = setInterval(() => {\n            if (!this._autosaveRunning) {\n                clearInterval(interval);\n            }\n            else if (this._autosaveDirty()) {\n                this._autosaveHandler = this._autosaveHandler\n                    .then(() => {\n                    return this.saveDatabase();\n                });\n            }\n        }, this._autosaveInterval);\n    }\n    /**\n     * Stops the autosave interval timer.\n     */\n    _autosaveDisable() {\n        this._autosaveRunning = false;\n        return this._autosaveHandler;\n    }\n}\n\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(7)))\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports) {\n\nvar g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n\n/***/ }),\n/* 8 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n__webpack_require__.r(__webpack_exports__);\n/* harmony import */ var _loki__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);\n/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, \"Loki\", function() { return _loki__WEBPACK_IMPORTED_MODULE_0__[\"a\"]; });\n\n/* harmony import */ var _collection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3);\n/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, \"Collection\", function() { return _collection__WEBPACK_IMPORTED_MODULE_1__[\"a\"]; });\n\n\n\n_loki__WEBPACK_IMPORTED_MODULE_0__[/* Loki */ \"a\"][\"Collection\"] = _collection__WEBPACK_IMPORTED_MODULE_1__[/* Collection */ \"a\"];\n\n/* harmony default export */ __webpack_exports__[\"default\"] = (_loki__WEBPACK_IMPORTED_MODULE_0__[/* Loki */ \"a\"]);\n\n\n/***/ })\n/******/ ]);\n});\n//# sourceMappingURL=lokidb.loki.js.map","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"@lokidb/full-text-search\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"@lokidb/full-text-search\"] = factory();\n\telse\n\t\t{ root[\"@lokidb/full-text-search\"] = factory(); root[\"LokiFullTextSearch\"] = root[\"@lokidb/full-text-search\"].default; }\n})(typeof self !== 'undefined' ? self : this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \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 = 1);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return PLUGINS; });\nfunction getGlobal() {\n    let glob;\n    (function (global) {\n        glob = global;\n    })(global !== undefined && global || this);\n    return glob;\n}\nfunction create() {\n    const global = getGlobal();\n    const sym = Symbol.for(\"LOKI\");\n    if (global[sym] === undefined) {\n        global[sym] = {};\n    }\n    return global[sym];\n}\n/**\n * @hidden\n */\nconst PLUGINS = create();\n\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(2)))\n\n/***/ }),\n/* 1 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n__webpack_require__.r(__webpack_exports__);\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/analyzer/tokenizer.ts\n/**\n * Splits a string at whitespace characters into tokens.\n * @param {string} value - the string\n * @returns {string[]} - the tokens\n */\nfunction whitespaceTokenizer(value) {\n    return value.split(/[\\s]+/);\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/analyzer/token_filter.ts\n/**\n * Converts a token to lowercase.\n * @param {string} token - the token\n * @returns {string} - the lowercased token\n */\nfunction lowercaseTokenFilter(token) {\n    return token.toLowerCase();\n}\n/**\n * Converts a token to uppercase.\n * @param {string} token - the token\n * @returns {string} - the uppercased token\n */\nfunction uppercaseTokenFilter(token) {\n    return token.toUpperCase();\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/analyzer/analyzer.ts\n\n\n/**\n * Analyzes a given string.\n * @param {Analyzer} analyzer - the analyzer\n * @param {string} str - the string\n * @returns {string[]} - the tokens\n */\nfunction analyze(analyzer, str) {\n    if (analyzer.char_filter) {\n        for (let j = 0; j < analyzer.char_filter.length; j++) {\n            str = analyzer.char_filter[j](str);\n        }\n    }\n    const tokens = analyzer.tokenizer(str);\n    if (analyzer.token_filter) {\n        for (let i = 0; i < tokens.length; i++) {\n            for (let k = 0; k < analyzer.token_filter.length; k++) {\n                tokens[i] = analyzer.token_filter[k](tokens[i], i, tokens);\n            }\n        }\n    }\n    // Remove empty tokens.\n    return tokens.filter((token) => token);\n}\n/**\n * An analyzer with the whitespace tokenizer and the lowercase token filter.\n */\nclass analyzer_StandardAnalyzer {\n    constructor() {\n        this.tokenizer = whitespaceTokenizer;\n        this.token_filter = [lowercaseTokenFilter];\n    }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/inverted_index.ts\n\n/**\n * Converts a string into an array of code points.\n * @param str - the string\n * @returns {number[]} to code points\n * @hidden\n */\nfunction toCodePoints(str) {\n    const r = [];\n    for (let i = 0; i < str.length;) {\n        const chr = str.charCodeAt(i++);\n        if (chr >= 0xD800 && chr <= 0xDBFF) {\n            // surrogate pair\n            const low = str.charCodeAt(i++);\n            r.push(0x10000 + ((chr - 0xD800) << 10) | (low - 0xDC00));\n        }\n        else {\n            // ordinary character\n            r.push(chr);\n        }\n    }\n    return r;\n}\n/**\n * Inverted index class handles featured text search for specific document fields.\n * @hidden\n */\nclass inverted_index_InvertedIndex {\n    /**\n     * @param {boolean} [options.store=true] - inverted index will be stored at serialization rather than rebuilt on load\n     * @param {boolean} [options.optimizeChanges=true] - flag to store additional metadata inside the index for better\n     *  performance if an existing field is updated or removed\n     * @param {Analyzer} [options.analyzer=] - the analyzer of this inverted index\n     */\n    constructor(options = {}) {\n        this.docCount = 0;\n        this.docStore = new Map();\n        this.totalFieldLength = 0;\n        this.root = new Map();\n        ({\n            store: this._store = true,\n            optimizeChanges: this._optimizeChanges = true,\n            analyzer: this.analyzer = new analyzer_StandardAnalyzer()\n        } = options);\n    }\n    /**\n     * Adds defined fields of a document to the inverted index.\n     * @param {string} field - the field to add\n     * @param {number} docId - the doc id of the field\n     */\n    insert(field, docId) {\n        if (this.docStore.has(docId)) {\n            throw Error(\"Field already added.\");\n        }\n        // Tokenize document field.\n        const fieldTokens = analyze(this.analyzer, field);\n        if (fieldTokens.length == 0) {\n            // Add empty field at least to document store for query 'exists'.\n            this.docStore.set(docId, { fieldLength: 0 });\n            return;\n        }\n        this.totalFieldLength += fieldTokens.length;\n        this.docCount += 1;\n        this.docStore.set(docId, { fieldLength: fieldTokens.length });\n        // Holds references to each index of a document.\n        const indexRef = [];\n        if (this._optimizeChanges) {\n            Object.defineProperties(this.docStore.get(docId), {\n                indexRef: { enumerable: false, configurable: true, writable: true, value: indexRef }\n            });\n        }\n        // Iterate over all unique field terms.\n        for (const token of new Set(fieldTokens)) {\n            // Calculate term frequency.\n            let tf = 0;\n            for (let j = 0; j < fieldTokens.length; j++) {\n                if (fieldTokens[j] === token) {\n                    ++tf;\n                }\n            }\n            // Add term to index tree.\n            let branch = this.root;\n            for (const c of toCodePoints(token)) {\n                let child = branch.get(c);\n                if (child === undefined) {\n                    child = new Map();\n                    if (this._optimizeChanges) {\n                        child.pa = branch;\n                    }\n                    branch.set(c, child);\n                }\n                branch = child;\n            }\n            // Add term info to index leaf.\n            if (branch.dc === undefined) {\n                branch.dc = new Map();\n                branch.df = 0;\n            }\n            branch.dc.set(docId, tf);\n            branch.df += 1;\n            // Store index leaf for deletion.\n            indexRef.push(branch);\n        }\n    }\n    /**\n     * Removes all relevant terms of a document from the inverted index.\n     * @param {number} docId - the document.\n     */\n    remove(docId) {\n        if (!this.docStore.has(docId)) {\n            return;\n        }\n        const docStore = this.docStore.get(docId);\n        // Remove document.\n        this.docStore.delete(docId);\n        if (docStore.fieldLength === 0) {\n            return;\n        }\n        this.docCount -= 1;\n        // Reduce total field length.\n        this.totalFieldLength -= docStore.fieldLength;\n        if (this._optimizeChanges) {\n            // Iterate over all term references.\n            // Remove docId from docs and decrement document frequency.\n            const indexRef = docStore.indexRef;\n            for (let j = 0; j < indexRef.length; j++) {\n                let index = indexRef[j];\n                index.df -= 1;\n                index.dc.delete(docId);\n                // Check if no document is left for current tree.\n                if (index.df === 0) {\n                    // Delete unused meta data of branch.\n                    delete index.df;\n                    delete index.dc;\n                    // Check for sub branches.\n                    if (index.size !== 0) {\n                        continue;\n                    }\n                    // Delete term branch if not used anymore.\n                    do {\n                        // Go tree upwards.\n                        const parent = index.pa;\n                        // Delete parent reference for preventing memory leak (cycle reference).\n                        delete index.pa;\n                        // Iterate over all children.\n                        for (const key of parent.keys()) {\n                            // Remove previous child form parent.\n                            if (parent.get(key) === index) {\n                                parent.delete(key);\n                                break;\n                            }\n                        }\n                        index = parent;\n                    } while (index.pa !== undefined && index.size === 0 && index.df === undefined);\n                }\n            }\n        }\n        else {\n            this._remove(this.root, docId);\n        }\n    }\n    /**\n     * Gets the term index of a term.\n     * @param {string} term - the term\n     * @param {object} root - the term index to start from\n     * @param {number} start - the position of the term string to start from\n     * @return {object} - The term index or null if the term is not in the term tree.\n     */\n    static getTermIndex(term, root, start = 0) {\n        if (start >= term.length) {\n            return null;\n        }\n        for (let i = start; i < term.length; i++) {\n            let child = root.get(term[i]);\n            if (child === undefined) {\n                return null;\n            }\n            root = child;\n        }\n        return root;\n    }\n    /**\n     * Extends a term index to all available term leafs.\n     * @param {object} idx - the term index to start from\n     * @param {number[]} [term=[]] - the current term\n     * @param {Array} termIndices - all extended indices with their term\n     * @returns {Array} - Array with term indices and extension\n     */\n    static extendTermIndex(idx, term = [], termIndices = []) {\n        if (idx.df !== undefined) {\n            termIndices.push({ index: idx, term: term.slice() });\n        }\n        term.push(0);\n        for (const child of idx) {\n            term[term.length - 1] = child[0];\n            inverted_index_InvertedIndex.extendTermIndex(child[1], term, termIndices);\n        }\n        term.pop();\n        return termIndices;\n    }\n    /**\n     * Serialize the inverted index.\n     * @returns {{docStore: *, _fields: *, index: *}}\n     */\n    toJSON() {\n        if (this._store) {\n            return {\n                _store: true,\n                _optimizeChanges: this._optimizeChanges,\n                docCount: this.docCount,\n                docStore: [...this.docStore],\n                totalFieldLength: this.totalFieldLength,\n                root: inverted_index_InvertedIndex._serializeIndex(this.root)\n            };\n        }\n        return {\n            _store: false,\n            _optimizeChanges: this._optimizeChanges,\n        };\n    }\n    /**\n     * Deserialize the inverted index.\n     * @param {{docStore: *, _fields: *, index: *}} serialized - The serialized inverted index.\n     * @param {Analyzer} analyzer[undefined] - an analyzer\n     */\n    static fromJSONObject(serialized, analyzer) {\n        const invIdx = new inverted_index_InvertedIndex({\n            store: serialized._store,\n            optimizeChanges: serialized._optimizeChanges,\n            analyzer: analyzer\n        });\n        if (serialized._store) {\n            invIdx.docCount = serialized.docCount;\n            invIdx.docStore = new Map(serialized.docStore);\n            invIdx.totalFieldLength = serialized.totalFieldLength;\n            invIdx.root = inverted_index_InvertedIndex._deserializeIndex(serialized.root);\n        }\n        if (invIdx._optimizeChanges) {\n            invIdx._regenerate(invIdx.root, null);\n        }\n        return invIdx;\n    }\n    static _serializeIndex(idx) {\n        const serialized = {};\n        if (idx.dc !== undefined) {\n            serialized.d = { df: idx.df, dc: [...idx.dc] };\n        }\n        if (idx.size === 0) {\n            return serialized;\n        }\n        const keys = [];\n        const values = [];\n        for (const child of idx) {\n            keys.push(child[0]);\n            values.push(inverted_index_InvertedIndex._serializeIndex(child[1]));\n        }\n        serialized.k = keys;\n        serialized.v = values;\n        return serialized;\n    }\n    static _deserializeIndex(serialized) {\n        const idx = new Map();\n        if (serialized.k !== undefined) {\n            for (let i = 0; i < serialized.k.length; i++) {\n                idx.set(serialized.k[i], inverted_index_InvertedIndex._deserializeIndex(serialized.v[i]));\n            }\n        }\n        if (serialized.d !== undefined) {\n            idx.df = serialized.d.df;\n            idx.dc = new Map(serialized.d.dc);\n        }\n        return idx;\n    }\n    /**\n     * Set parent of to each index and regenerate the indexRef.\n     * @param {Index} index - the index\n     * @param {Index} parent - the parent\n     */\n    _regenerate(index, parent) {\n        // Set parent.\n        if (parent !== null) {\n            index.pa = parent;\n        }\n        // Iterate over subtree.\n        for (const child of index.values()) {\n            this._regenerate(child, index);\n        }\n        if (index.dc !== undefined) {\n            // Get documents of term.\n            for (const docId of index.dc.keys()) {\n                // Get document store at specific document/field.\n                const ref = this.docStore.get(docId);\n                if (ref.indexRef === undefined) {\n                    Object.defineProperties(ref, {\n                        indexRef: { enumerable: false, configurable: true, writable: true, value: [] }\n                    });\n                }\n                // Set reference to term index.\n                ref.indexRef.push(index);\n            }\n        }\n    }\n    /**\n     * Iterate over the whole inverted index and remove the document.\n     * Delete branch if not needed anymore.\n     * Function is needed if index is used without optimization.\n     * @param {Index} idx - the index\n     * @param {number} docId - the doc id\n     * @returns {boolean} true if index is empty\n     */\n    _remove(idx, docId) {\n        for (const child of idx) {\n            // Checkout branch.\n            if (this._remove(child[1], docId)) {\n                idx.delete(child[0]);\n            }\n        }\n        // Remove docId from docs and decrement document frequency.\n        if (idx.df !== undefined) {\n            if (idx.dc.has(docId)) {\n                idx.df -= 1;\n                idx.dc.delete(docId);\n                // Delete unused meta data of branch.\n                if (idx.df === 0) {\n                    delete idx.df;\n                    delete idx.dc;\n                }\n            }\n        }\n        return idx.size === 0 && idx.dc === undefined;\n    }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/scorer.ts\n/**\n * @hidden\n */\nclass Scorer {\n    constructor(invIdxs) {\n        this._cache = {};\n        this._invIdxs = invIdxs;\n    }\n    setDirty() {\n        this._cache = {};\n    }\n    score(fieldName, boost, termIdx, doScoring, queryResults, term, df = 0) {\n        if (termIdx === null || termIdx.dc === undefined) {\n            return;\n        }\n        const idf = this._idf(fieldName, df || termIdx.df);\n        for (const [docId, tf] of termIdx.dc) {\n            if (!queryResults.has(docId)) {\n                queryResults.set(docId, []);\n            }\n            if (doScoring === true) {\n                // BM25 scoring.\n                queryResults.get(docId).push({ tf, idf, boost, fieldName, term });\n            }\n            else if (doScoring === false) {\n                // Constant scoring.\n                queryResults.set(docId, [{ boost }]);\n            }\n            else {\n                // Zero scoring.\n                queryResults.set(docId, [{ boost: 0 }]);\n            }\n        }\n    }\n    scoreConstant(boost, docId, queryResults) {\n        if (!queryResults.has(docId)) {\n            queryResults.set(docId, []);\n        }\n        queryResults.get(docId).push({ boost });\n        return queryResults;\n    }\n    finalScore(query, queryResults) {\n        const finalResult = {};\n        const k1 = query.bm25 !== undefined ? query.bm25.k1 : 1.2;\n        const b = query.bm25 !== undefined ? query.bm25.b : 0.75;\n        const explain = query.explain !== undefined ? query.explain : false;\n        for (const [docId, result] of queryResults) {\n            let docScore = 0;\n            let docExplanation = [];\n            for (let i = 0; i < result.length; i++) {\n                const queryResult = result[i];\n                let score = 0;\n                if (queryResult.tf !== undefined) {\n                    // BM25 scoring.\n                    const tf = queryResult.tf;\n                    const fieldLength = Scorer._calculateFieldLength(this._invIdxs[queryResult.fieldName].docStore.get(docId)\n                        .fieldLength);\n                    const avgFieldLength = this._avgFieldLength(queryResult.fieldName);\n                    const tfNorm = (tf * (k1 + 1)) / (tf + k1 * (1 - b + b * (fieldLength / avgFieldLength)));\n                    score = queryResult.idf * tfNorm * queryResult.boost;\n                    if (explain) {\n                        docExplanation.push({\n                            boost: queryResult.boost,\n                            score: score,\n                            docID: docId,\n                            fieldName: queryResult.fieldName,\n                            index: String.fromCharCode(...queryResult.term),\n                            idf: queryResult.idf,\n                            tfNorm: tfNorm,\n                            tf: tf,\n                            fieldLength: fieldLength,\n                            avgFieldLength: avgFieldLength,\n                        });\n                    }\n                }\n                else {\n                    // Constant scoring.\n                    score = queryResult.boost;\n                    if (explain) {\n                        docExplanation.push({\n                            boost: queryResult.boost,\n                            score: score\n                        });\n                    }\n                }\n                docScore += score;\n            }\n            if (explain) {\n                finalResult[docId] = {\n                    score: docScore,\n                    explanation: docExplanation\n                };\n            }\n            else {\n                finalResult[docId] = {\n                    score: docScore\n                };\n            }\n        }\n        return finalResult;\n    }\n    static _calculateFieldLength(fieldLength) {\n        // Dummy function to be compatible to lucene in unit tests.\n        return fieldLength;\n    }\n    _getCache(fieldName) {\n        if (this._cache[fieldName] === undefined) {\n            const avgFieldLength = this._invIdxs[fieldName].totalFieldLength / this._invIdxs[fieldName].docCount;\n            this._cache[fieldName] = { idfs: {}, avgFieldLength };\n        }\n        return this._cache[fieldName];\n    }\n    /**\n     * Returns the idf by either calculate it or use a cached one.\n     * @param {string} fieldName - the name of the field\n     * @param {number} docFreq - the doc frequency of the term\n     * @returns {number} the idf\n     * @private\n     */\n    _idf(fieldName, docFreq) {\n        const cache = this._getCache(fieldName);\n        if (cache.idfs[docFreq] !== undefined) {\n            return cache.idfs[docFreq];\n        }\n        return cache.idfs[docFreq] = Math.log(1 + (this._invIdxs[fieldName].docCount - docFreq + 0.5) / (docFreq + 0.5));\n    }\n    _avgFieldLength(fieldName) {\n        return this._getCache(fieldName).avgFieldLength;\n    }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/run_automaton.ts\n/**\n * From org/apache/lucene/util/automaton/RunAutomaton.java\n * @hidden\n */\nclass RunAutomaton {\n    constructor(automaton) {\n        const size = automaton.getNumStates();\n        this._points = automaton.getStartPoints();\n        this._accept = new Array(size);\n        this._transitions = new Array(size * this._points.length);\n        for (let n = 0; n < size; n++) {\n            this._accept[n] = automaton.isAccept(n);\n            for (let c = 0; c < this._points.length; c++) {\n                // assert dest === -1 || dest < size;\n                this._transitions[n * this._points.length + c] = automaton.step(n, this._points[c]);\n            }\n        }\n        this._classmap = new Array(256 /* alphaSize */);\n        for (let i = 0, j = 0; j < this._classmap.length; j++) {\n            if (i + 1 < this._points.length && j === this._points[i + 1]) {\n                i++;\n            }\n            this._classmap[j] = i;\n        }\n    }\n    getCharClass(c) {\n        // binary search\n        let a = 0;\n        let b = this._points.length;\n        while (b - a > 1) {\n            const d = (a + b) >>> 1;\n            if (this._points[d] > c) {\n                b = d;\n            }\n            else if (this._points[d] < c) {\n                a = d;\n            }\n            else {\n                return d;\n            }\n        }\n        return a;\n    }\n    step(state, c) {\n        if (c >= this._classmap.length) {\n            return this._transitions[state * this._points.length + this.getCharClass(c)];\n        }\n        else {\n            return this._transitions[state * this._points.length + this._classmap[c]];\n        }\n    }\n    isAccept(state) {\n        return this._accept[state];\n    }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/automaton.ts\n/**\n * @type {number}\n * @hidden\n */\nconst MIN_CODE_POINT = 0;\n/**\n * @type {number}\n * @hidden\n */\nconst MAX_CODE_POINT = 1114111;\nfunction sortByDestMinMax(a, b) {\n    if (a[0] < b[0]) {\n        return -1;\n    }\n    else if (a[0] > b[0]) {\n        return 1;\n    }\n    if (a[1] < b[1]) {\n        return -1;\n    }\n    else if (a[1] > b[1]) {\n        return 1;\n    }\n    if (a[2] < b[2]) {\n        return -1;\n    }\n    else if (a[2] > b[2]) {\n        return 1;\n    }\n    return 0;\n}\nfunction sortByMinMaxDest(a, b) {\n    if (a[1] < b[1]) {\n        return -1;\n    }\n    else if (a[1] > b[1]) {\n        return 1;\n    }\n    if (a[2] < b[2]) {\n        return -1;\n    }\n    else if (a[2] > b[2]) {\n        return 1;\n    }\n    if (a[0] < b[0]) {\n        return -1;\n    }\n    else if (a[0] > b[0]) {\n        return 1;\n    }\n    return 0;\n}\n/**\n * From org/apache/lucene/util/automaton/Automaton.java\n * @hidden\n */\nclass Automaton {\n    constructor() {\n        this._stateTransitions = [];\n        this._stateTransitions = [];\n        this._accept = new Set();\n        this._nextState = 0;\n        this._currState = -1;\n        // this.deterministic = true;\n        this._transitions = {};\n    }\n    isAccept(n) {\n        return this._accept.has(n);\n    }\n    createState() {\n        return this._nextState++;\n    }\n    setAccept(state, accept) {\n        if (accept) {\n            this._accept.add(state);\n        }\n        else {\n            this._accept.delete(state);\n        }\n    }\n    finishState() {\n        if (this._currState !== -1) {\n            this._finishCurrentState();\n            this._currState = -1;\n        }\n    }\n    _finishCurrentState() {\n        // Sort all transitions.\n        this._stateTransitions.sort(sortByDestMinMax);\n        let upto = 0;\n        let p = [-1, -1, -1];\n        for (let i = 0, len = this._stateTransitions.length; i < len; i++) {\n            let t = this._stateTransitions[i];\n            if (p[0] === t[0]) {\n                if (t[1] <= p[2] + 1) {\n                    if (t[2] > p[2]) {\n                        p[2] = t[2];\n                    }\n                }\n                else {\n                    if (p[0] !== -1) {\n                        this._stateTransitions[upto][0] = p[0];\n                        this._stateTransitions[upto][1] = p[1];\n                        this._stateTransitions[upto][2] = p[2];\n                        upto++;\n                    }\n                    p[1] = t[1];\n                    p[2] = t[2];\n                }\n            }\n            else {\n                if (p[0] !== -1) {\n                    this._stateTransitions[upto][0] = p[0];\n                    this._stateTransitions[upto][1] = p[1];\n                    this._stateTransitions[upto][2] = p[2];\n                    upto++;\n                }\n                p[0] = t[0];\n                p[1] = t[1];\n                p[2] = t[2];\n            }\n        }\n        if (p[0] !== -1) {\n            // Last transition\n            this._stateTransitions[upto][0] = p[0];\n            this._stateTransitions[upto][1] = p[1];\n            this._stateTransitions[upto][2] = p[2];\n            upto++;\n        }\n        this._transitions[this._currState] = this._stateTransitions.slice(0, upto).sort(sortByMinMaxDest);\n        // if (this.deterministic && upto > 1) {\n        //   let lastMax = this.stateTransitions[0][2];\n        //   for (let i = 1; i < upto; i++) {\n        //     let min = this.stateTransitions[i][1];\n        //     if (min <= lastMax) {\n        //       this.deterministic = false;\n        //       break;\n        //     }\n        //     lastMax = this.stateTransitions[i][2];\n        //   }\n        // }\n        this._stateTransitions = [];\n    }\n    getStartPoints() {\n        const pointset = new Set();\n        pointset.add(MIN_CODE_POINT);\n        const states = Object.keys(this._transitions);\n        for (let i = 0; i < states.length; i++) {\n            let trans = this._transitions[states[i]];\n            for (let j = 0; j < trans.length; j++) {\n                let tran = trans[j];\n                pointset.add(tran[1]);\n                if (tran[2] < MAX_CODE_POINT) {\n                    pointset.add(tran[2] + 1);\n                }\n            }\n        }\n        return Array.from(pointset).sort((a, b) => a - b);\n    }\n    step(state, label) {\n        let trans = this._transitions[state];\n        if (trans) {\n            for (let i = 0; i < trans.length; i++) {\n                let tran = trans[i];\n                if (tran[1] <= label && label <= tran[2]) {\n                    return tran[0];\n                }\n            }\n        }\n        return -1;\n    }\n    getNumStates() {\n        return this._nextState;\n    }\n    addTransition(source, dest, min, max) {\n        if (this._currState !== source) {\n            if (this._currState !== -1) {\n                this._finishCurrentState();\n            }\n            this._currState = source;\n        }\n        this._stateTransitions.push([dest, min, max]);\n    }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/long.ts\n/**\n * Class supports 64Bit integer operations.\n * A cut-down version of dcodeIO/long.js.\n * @hidden\n */\nclass Long {\n    constructor(low = 0, high = 0) {\n        this._low = low;\n        this._high = high;\n    }\n    /**\n     * Returns this long with bits arithmetically shifted to the right by the given amount.\n     * @param {number} numBits - number of bits\n     * @returns {Long} the long\n     */\n    shiftRight(numBits) {\n        if ((numBits &= 63) === 0)\n            return this;\n        else if (numBits < 32)\n            return new Long((this._low >>> numBits) | (this._high << (32 - numBits)), this._high >> numBits);\n        else\n            return new Long((this._high >> (numBits - 32)), this._high >= 0 ? 0 : -1);\n    }\n    /**\n     * Returns this long with bits arithmetically shifted to the left by the given amount.\n     * @param {number} numBits - number of bits\n     * @returns {Long} the long\n     */\n    shiftLeft(numBits) {\n        if ((numBits &= 63) === 0)\n            return this;\n        else if (numBits < 32)\n            return new Long(this._low << numBits, (this._high << numBits) | (this._low >>> (32 - numBits)));\n        else\n            return new Long(0, this._low << (numBits - 32));\n    }\n    /**\n     * Returns the bitwise AND of this Long and the specified.\n     * @param {Long} other - the other Long\n     * @returns {Long} the long\n     */\n    and(other) {\n        return new Long(this._low & other._low, this._high & other._high);\n    }\n    /**\n     * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\n     * @returns {number}\n     */\n    toInt() {\n        return this._low;\n    }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/parametric_description.ts\n\nconst MASKS = [new Long(0x1), new Long(0x3), new Long(0x7), new Long(0xf),\n    new Long(0x1f), new Long(0x3f), new Long(0x7f), new Long(0xff),\n    new Long(0x1ff), new Long(0x3ff), new Long(0x7ff), new Long(0xfff),\n    new Long(0x1fff), new Long(0x3fff), new Long(0x7fff), new Long(0xffff),\n    new Long(0xf, 0x1fff), new Long(0xf, 0x3fff), new Long(0xf, 0x7fff), new Long(0xf, 0xffff),\n    new Long(0xff, 0x1fff), new Long(0xff, 0x3fff), new Long(0xff, 0x7fff), new Long(0xff, 0xffff),\n    new Long(0xfff, 0x1fff), new Long(0xfff, 0x3fff), new Long(0xfff, 0x7fff), new Long(0xfff, 0xffff),\n    new Long(0xffff, 0x1fff), new Long(0xffff, 0x3fff), new Long(0xffff, 0x7fff), new Long(0xffff, 0xffff),\n    new Long(0xfffff, 0x1fff), new Long(0xfffff, 0x3fff), new Long(0xfffff, 0x7fff), new Long(0xfffff, 0xffff),\n    new Long(0xffffff, 0x1fff), new Long(0xffffff, 0x3fff), new Long(0xffffff, 0x7fff), new Long(0xffffff, 0xffff),\n    new Long(0xfffffff, 0x1fff), new Long(0xfffffff, 0x3fff), new Long(0xfffffff, 0x7fff), new Long(0xfffffff, 0xffff),\n    new Long(0xffffffff, 0x1fff), new Long(0xffffffff, 0x3fff), new Long(0xffffffff, 0x7fff), new Long(0xffffffff, 0xffff),\n    new Long(0xfffffffff, 0x1fff), new Long(0xfffffffff, 0x3fff), new Long(0xfffffffff, 0x7fff), new Long(0xfffffffff, 0xffff),\n    new Long(0xffffffffff, 0x1fff), new Long(0xffffffffff, 0x3fff), new Long(0xffffffffff, 0x7fff), new Long(0xffffffffff, 0xffff),\n    new Long(0xfffffffffff, 0x1fff), new Long(0xfffffffffff, 0x3fff), new Long(0xfffffffffff, 0x7fff), new Long(0xfffffffffff, 0xffff),\n    new Long(0xffffffffffff, 0x1fff), new Long(0xffffffffffff, 0x3fff), new Long(0xffffffffffff, 0x7fff)];\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java#ParametricDescription\n * @hidden\n */\nclass ParametricDescription {\n    constructor(w, n, minErrors) {\n        this._w = w;\n        this._n = n;\n        this._minErrors = minErrors;\n    }\n    /**\n     * Return the number of states needed to compute a Levenshtein DFA\n     */\n    size() {\n        return this._minErrors.length * (this._w + 1);\n    }\n    /**\n     * Returns true if the <code>state</code> in any Levenshtein DFA is an accept state (final state).\n     */\n    isAccept(absState) {\n        // decode absState -> state, offset\n        let state = Math.floor(absState / (this._w + 1));\n        let offset = absState % (this._w + 1);\n        //assert offset >= 0;\n        return this._w - offset + this._minErrors[state] <= this._n;\n    }\n    /**\n     * Returns the position in the input word for a given <code>state</code>.\n     * This is the minimal boundary for the state.\n     */\n    getPosition(absState) {\n        return absState % (this._w + 1);\n    }\n    static unpack(data, index, bitsPerValue) {\n        const bitLoc = bitsPerValue * index;\n        const dataLoc = (bitLoc >> 6);\n        const bitStart = (bitLoc & 63);\n        if (bitStart + bitsPerValue <= 64) {\n            // not split\n            return data[dataLoc].shiftRight(bitStart).and(MASKS[bitsPerValue - 1]).toInt();\n        }\n        else {\n            // split\n            const part = 64 - bitStart;\n            return (data[dataLoc].shiftRight(bitStart).and(MASKS[part - 1])).toInt()\n                + (data[1 + dataLoc].and(MASKS[bitsPerValue - part - 1]).shiftLeft(part)).toInt();\n        }\n    }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/lev1t_parametric_description.ts\n\n\n// 1 vectors; 2 states per vector; array length = 2\nconst toStates0 = [new Long(0x2)];\nconst offsetIncrs0 = [new Long(0x0)];\n// 2 vectors; 3 states per vector; array length = 6\nconst toStates1 = [new Long(0xa43)];\nconst offsetIncrs1 = [new Long(0x38)];\n// 4 vectors; 6 states per vector; array length = 24\nconst toStates2 = [new Long(0x82140003, 0x34534914), new Long(0x6d)];\nconst offsetIncrs2 = [new Long(0x55a20000, 0x5555)];\n// 8 vectors; 6 states per vector; array length = 48\nconst toStates3 = [new Long(0x900C0003, 0x21520854), new Long(0x4534916d, 0x5b4d19a2), new Long(0xda34)];\nconst offsetIncrs3 = [new Long(0x20fc0000, 0x5555ae0a), new Long(0x55555555)];\n// state map\n//   0 -> [(0, 0)]\n//   1 -> [(0, 1)]\n//   2 -> [(0, 1), (1, 1)]\n//   3 -> [(0, 1), (2, 1)]\n//   4 -> [t(0, 1), (0, 1), (1, 1), (2, 1)]\n//   5 -> [(0, 1), (1, 1), (2, 1)]\n/**\n * From org/apache/lucene/util/automaton/Lev1TParametricDescription.java\n * @hidden\n */\nclass lev1t_parametric_description_Lev1TParametricDescription extends ParametricDescription {\n    constructor(w) {\n        super(w, 1, [0, 1, 0, -1, -1, -1]);\n    }\n    transition(absState, position, vector) {\n        // null absState should never be passed in\n        //assert absState != -1;\n        // decode absState -> state, offset\n        let state = Math.floor(absState / (this._w + 1));\n        let offset = absState % (this._w + 1);\n        //assert offset >= 0;\n        if (position === this._w) {\n            if (state < 2) {\n                const loc = vector * 2 + state;\n                offset += ParametricDescription.unpack(offsetIncrs0, loc, 1);\n                state = ParametricDescription.unpack(toStates0, loc, 2) - 1;\n            }\n        }\n        else if (position === this._w - 1) {\n            if (state < 3) {\n                const loc = vector * 3 + state;\n                offset += ParametricDescription.unpack(offsetIncrs1, loc, 1);\n                state = ParametricDescription.unpack(toStates1, loc, 2) - 1;\n            }\n        }\n        else if (position === this._w - 2) {\n            if (state < 6) {\n                const loc = vector * 6 + state;\n                offset += ParametricDescription.unpack(offsetIncrs2, loc, 2);\n                state = ParametricDescription.unpack(toStates2, loc, 3) - 1;\n            }\n        }\n        else {\n            if (state < 6) {\n                const loc = vector * 6 + state;\n                offset += ParametricDescription.unpack(offsetIncrs3, loc, 2);\n                state = ParametricDescription.unpack(toStates3, loc, 3) - 1;\n            }\n        }\n        if (state === -1) {\n            // null state\n            return -1;\n        }\n        else {\n            // translate back to abs\n            return state * (this._w + 1) + offset;\n        }\n    }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/lev2t_parametric_description.ts\n\n\n// 1 vectors; 3 states per vector; array length = 3\nconst lev2t_parametric_description_toStates0 = /*2 bits per value */ [\n    new Long(0x23)\n];\nconst lev2t_parametric_description_offsetIncrs0 = /*1 bits per value */ [\n    new Long(0x0)\n];\n// 2 vectors; 5 states per vector; array length = 10\nconst lev2t_parametric_description_toStates1 = /*3 bits per value */ [\n    new Long(0x13688b44)\n];\nconst lev2t_parametric_description_offsetIncrs1 = /*1 bits per value */ [\n    new Long(0x3e0)\n];\n// 4 vectors; 13 states per vector; array length = 52\nconst lev2t_parametric_description_toStates2 = /*4 bits per value */ [\n    new Long(0x5200b504, 0x60dbb0b0), new Long(0x27062227, 0x52332176), new Long(0x14323235, 0x23555432), new Long(0x4354)\n];\nconst lev2t_parametric_description_offsetIncrs2 = /*2 bits per value */ [\n    new Long(0x00002000, 0x555080a8), new Long(0x55555555, 0x55)\n];\n// 8 vectors; 28 states per vector; array length = 224\nconst lev2t_parametric_description_toStates3 = /*5 bits per value */ [\n    new Long(0x40059404, 0xe701c029), new Long(0x00a50000, 0xa0101620), new Long(0xa1416288, 0xb02c8c40), new Long(0x310858c0, 0xa821032),\n    new Long(0x0d28b201, 0x31442398), new Long(0x847788e0, 0x5281e528), new Long(0x08c2280e, 0xa23980d3), new Long(0xa962278c, 0x1e3294b1),\n    new Long(0x2288e528, 0x8c41309e), new Long(0x021aca21, 0x11444409), new Long(0x86b1086b, 0x11a46248), new Long(0x1d6240c4, 0x2a625894),\n    new Long(0x489074ad, 0x5024a50b), new Long(0x520c411a, 0x14821aca), new Long(0x0b594a44, 0x5888b589), new Long(0xc411a465, 0x941d6520),\n    new Long(0xad6a62d4, 0x8b589075), new Long(0x1a5055a4)\n];\nconst lev2t_parametric_description_offsetIncrs3 = /*2 bits per value */ [\n    new Long(0x00002000, 0x30c302), new Long(0xc3fc333c, 0x2a0030f3), new Long(0x8282a820, 0x233a0032), new Long(0x32b283a8, 0x55555555),\n    new Long(0x55555555, 0x55555555), new Long(0x55555555, 0x55555555), new Long(0x55555555, 0x55555555)\n];\n// 16 vectors; 45 states per vector; array length = 720\nconst toStates4 = /*6 bits per value */ [\n    new Long(0x002c5004, 0x3801450), new Long(0x00000e38, 0xc500014b), new Long(0x51401402, 0x514), new Long(0x0),\n    new Long(0x14010000, 0x518000b), new Long(0x28e20230, 0x9f1c208), new Long(0x830a70c2, 0x219f0df0), new Long(0x08208200, 0x82000082),\n    new Long(0x60800800, 0x8050501), new Long(0x02602643, 0x30820986), new Long(0x50508064, 0x45640142), new Long(0x20000831, 0x8500514),\n    new Long(0x85002082, 0x41405820), new Long(0x0990c201, 0x45618098), new Long(0x50a01051, 0x8316d0c), new Long(0x050df0e0, 0x21451420),\n    new Long(0x14508214, 0xd142140), new Long(0x50821c60, 0x3c21c018), new Long(0xcb142087, 0x1cb1403), new Long(0x1851822c, 0x80082145),\n    new Long(0x20800020, 0x200208), new Long(0x87180345, 0xd0061820), new Long(0x24976b09, 0xcb0a81cb), new Long(0x624709d1, 0x8b1a60e),\n    new Long(0x82249089, 0x2490820), new Long(0x00d2c024, 0xc31421c6), new Long(0x15454423, 0x3c314515), new Long(0xc21cb140, 0x31853c22),\n    new Long(0x2c208214, 0x4514500b), new Long(0x508b0051, 0x8718034), new Long(0x5108f0c5, 0xb2cb4551), new Long(0x1cb0a810, 0xe824715d),\n    new Long(0x908b0e60, 0x1422cb14), new Long(0xc02cb145, 0x30812c22), new Long(0x0cb1420c, 0x84202202), new Long(0x20ce0850, 0x5c20ce08),\n    new Long(0x8b0d70c2, 0x20820820), new Long(0x14214208, 0x42085082), new Long(0x50830c20, 0x9208340), new Long(0x13653592, 0xc6134dc6),\n    new Long(0x6dc4db4d, 0xd309341c), new Long(0x54d34d34, 0x6424d908), new Long(0x030814c2, 0x92072c22), new Long(0x24a30930, 0x4220724b),\n    new Long(0x25c920e2, 0x2470d720), new Long(0x975c9082, 0x92c92d70), new Long(0x04924e08, 0xcb0880c2), new Long(0xc24c2481, 0x45739728),\n    new Long(0xda6174da, 0xc6da4db5), new Long(0x5d30971d, 0x4b5d35d7), new Long(0x93825ce2, 0x1030815c), new Long(0x020cb145, 0x51442051),\n    new Long(0x2c220e2c, 0xc538210e), new Long(0x52cb0d70, 0x8514214), new Long(0x85145142, 0x204b0850), new Long(0x4051440c, 0x92156083),\n    new Long(0xa60e6595, 0x4d660e4d), new Long(0x1c6dc658, 0x94d914e4), new Long(0x1454d365, 0x82642659), new Long(0x51030813, 0x2892072c),\n    new Long(0xcb2ca30b, 0xe2c22072), new Long(0x20538910, 0x452c70d7), new Long(0x708e3891, 0x8b2cb2d), new Long(0xc204b24e, 0x81cb1440),\n    new Long(0x28c2ca24, 0xda44e38e), new Long(0x85d660e4, 0x1dc6da65), new Long(0x8e5d914e, 0xe2cb5d33), new Long(0x38938238)\n];\nconst offsetIncrs4 = /*3 bits per value */ [\n    new Long(0x00080000, 0x30020000), new Long(0x20c060), new Long(0x04000000, 0x81490000), new Long(0x10824824, 0x40249241),\n    new Long(0x60002082, 0xdb6030c3), new Long(0x301b0d80, 0x6c36c06c), new Long(0x000db0db, 0xb01861b0), new Long(0x9188e06d, 0x1b703620),\n    new Long(0x06d86db7, 0x8009200), new Long(0x02402490, 0x4920c24), new Long(0x08249009, 0x490002), new Long(0x28124804, 0x49081281),\n    new Long(0x124a44a2, 0x34800104), new Long(0x0d24020c, 0xc3093090), new Long(0x24c24d24, 0x40009a09), new Long(0x9201061a, 0x4984a06),\n    new Long(0x71269262, 0x494d0492), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249),\n    new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924),\n    new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492),\n    new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249),\n    new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x2492)\n];\n// 32 vectors; 45 states per vector; array length = 1440\nconst toStates5 = /*6 bits per value */ [\n    new Long(0x002c5004, 0x3801450), new Long(0x00000e38, 0xc500014b), new Long(0x51401402, 0x514), new Long(0x0),\n    new Long(0x14010000, 0x514000b), new Long(0x038e00e0, 0x550000), new Long(0x0600b180, 0x26451850), new Long(0x08208208, 0x82082082),\n    new Long(0x40820820, 0x2c500), new Long(0x808c0146, 0x70820a38), new Long(0x9c30827c, 0xc37c20c2), new Long(0x20800867, 0x208208),\n    new Long(0x02002080, 0xb1401020), new Long(0x00518000, 0x828e2023), new Long(0x209f1c20, 0x830a70c), new Long(0x853df0df, 0x51451450),\n    new Long(0x14508214, 0x16142142), new Long(0x30805050, 0x60260264), new Long(0x43082098, 0x25050806), new Long(0x14564014, 0x42000083),\n    new Long(0x20850051, 0x8500208), new Long(0x14140582, 0x80990c20), new Long(0x08261809, 0x82019202), new Long(0x90060941, 0x8920519),\n    new Long(0xc22cb242, 0x22492492), new Long(0x0162492c, 0x43080505), new Long(0x86026026, 0x80414515), new Long(0xc5b43142, 0x37c38020),\n    new Long(0x14508014, 0x42085085), new Long(0x50850051, 0x1414058), new Long(0x980990c2, 0x51456180), new Long(0x0c50a010, 0xe008316d),\n    new Long(0x508b21f0, 0x2c52cb2c), new Long(0xc22cb249, 0x600d2c92), new Long(0x1850821c, 0x873c21c0), new Long(0x03cb1420, 0x2c01cb14),\n    new Long(0x45185182, 0x20800821), new Long(0x08208000, 0x45002002), new Long(0x20871803, 0x8700614), new Long(0x050821cf, 0x740500f5),\n    new Long(0x18609000, 0x934d9646), new Long(0x30824d30, 0x4c24d34d), new Long(0xc600d642, 0x1860821), new Long(0x25dac274, 0xc2a072c9),\n    new Long(0x91c27472, 0x2c698398), new Long(0x89242242, 0x92420820), new Long(0x34b00900, 0x82087180), new Long(0xb09d0061, 0x1cb24976),\n    new Long(0x9d1cb0a8, 0x60e62470), new Long(0x1574ce3e, 0xd31455d7), new Long(0x25c25d74, 0x1c600d38), new Long(0x423c3142, 0x51515454),\n    new Long(0x1403c314, 0xc22c21cb), new Long(0x21431853, 0xb2c208), new Long(0x05145145, 0x34508b0), new Long(0x0c508718, 0x5515108f),\n    new Long(0xf2051454, 0x8740500), new Long(0x0618f090, 0xe2534d92), new Long(0x6592c238, 0x49382659), new Long(0x21c600d6, 0x4423c314),\n    new Long(0xcb2d1545, 0x72c2a042), new Long(0xa091c574, 0x422c3983), new Long(0x508b2c52, 0xb2c514), new Long(0x8034b08b, 0xf0c50871),\n    new Long(0x45515108, 0xa810b2cb), new Long(0x715d1cb0, 0x2260e824), new Long(0x8e2d74ce, 0xe6592c53), new Long(0x38938238, 0x420c3081),\n    new Long(0x22020cb1, 0x8508420), new Long(0xce0820ce, 0x70c25c20), new Long(0x08208b0d, 0x42082082), new Long(0x50821421, 0xc204208),\n    new Long(0x832c5083, 0x21080880), new Long(0x0838c214, 0xa5083882), new Long(0xa9c39430, 0xaaaaaaaa), new Long(0x9fa9faaa, 0x1aaa7eaa),\n    new Long(0x1420c308, 0x824820d0), new Long(0x84d94d64, 0x7184d371), new Long(0x1b7136d3, 0x34c24d07), new Long(0x1534d34d, 0x99093642),\n    new Long(0x30c20530, 0x8340508), new Long(0x53592092, 0x34dc6136), new Long(0x4db4dc61, 0xa479c6dc), new Long(0x4924924a, 0x920a9f92),\n    new Long(0x8192a82a, 0x72c22030), new Long(0x30930920, 0x724b24a), new Long(0x920e2422, 0xd72025c), new Long(0xc9082247, 0x92d70975),\n    new Long(0x24e0892c, 0x880c2049), new Long(0xc2481cb0, 0x2c928c24), new Long(0x89088749, 0x80a52488), new Long(0xaac74394, 0x6a861b2a),\n    new Long(0xab27b278, 0x81b2ca6), new Long(0x072c2203, 0xa3093092), new Long(0x6915ce5c, 0xd76985d3), new Long(0x771b6936, 0x5d74c25c),\n    new Long(0x892d74d7, 0x724e0973), new Long(0x0880c205, 0x4c2481cb), new Long(0x739728c2, 0x6174da45), new Long(0xda4db5da, 0x4aa175c6),\n    new Long(0x86486186, 0x6a869b27), new Long(0x308186ca, 0xcb14510), new Long(0x44205102, 0x220e2c51), new Long(0x38210e2c, 0xcb0d70c5),\n    new Long(0x51421452, 0x14514208), new Long(0x4b085085, 0x51440c20), new Long(0x1440832c, 0xcb145108), new Long(0x488b0888, 0x94316208),\n    new Long(0x9f7e79c3, 0xfaaa7dfa), new Long(0x7ea7df7d, 0x30819ea), new Long(0x20d01451, 0x65648558), new Long(0x93698399, 0x96135983),\n    new Long(0x39071b71, 0xd9653645), new Long(0x96451534, 0x4e09909), new Long(0x051440c2, 0x21560834), new Long(0x60e65959, 0xd660e4da),\n    new Long(0xc6dc6584, 0x9207e979), new Long(0xdf924820, 0xa82a8207), new Long(0x103081a6, 0x892072c5), new Long(0xb2ca30b2, 0x2c22072c),\n    new Long(0x0538910e, 0x52c70d72), new Long(0x08e38914, 0x8b2cb2d7), new Long(0x204b24e0, 0x1cb1440c), new Long(0x8c2ca248, 0x874b2cb2),\n    new Long(0x24488b08, 0x43948162), new Long(0x9b1f7e77, 0x9e786aa6), new Long(0xeca6a9e7, 0x51030819), new Long(0x2892072c, 0x8e38a30b),\n    new Long(0x83936913, 0x69961759), new Long(0x4538771b, 0x74ce3976), new Long(0x08e38b2d, 0xc204e24e), new Long(0x81cb1440, 0x28c2ca24),\n    new Long(0xda44e38e, 0x85d660e4), new Long(0x75c6da65, 0x698607e9), new Long(0x99e7864a, 0xa6ca6aa6)\n];\nconst offsetIncrs5 = /*3 bits per value */ [\n    new Long(0x00080000, 0x30020000), new Long(0x20c060), new Long(0x04000000, 0x1000000), new Long(0x50603018, 0xdb6db6db),\n    new Long(0x00002db6, 0xa4800002), new Long(0x41241240, 0x12492088), new Long(0x00104120, 0x40000100), new Long(0x92092052, 0x2492c420),\n    new Long(0x096592d9, 0xc30d800), new Long(0xc36036d8, 0xb01b0c06), new Long(0x6c36db0d, 0x186c0003), new Long(0xb01b6c06, 0xad860361),\n    new Long(0x5b6dd6dd, 0x360001b7), new Long(0x0db6030c, 0xc412311c), new Long(0xb6e36e06, 0xdb0d), new Long(0xdb01861b, 0x9188e06),\n    new Long(0x71b72b62, 0x6dd6db), new Long(0x00800920, 0x40240249), new Long(0x904920c2, 0x20824900), new Long(0x40049000, 0x12012480),\n    new Long(0xa4906120, 0x5524ad4a), new Long(0x02480015, 0x40924020), new Long(0x48409409, 0x92522512), new Long(0x24000820, 0x49201001),\n    new Long(0x204a04a0, 0x29128924), new Long(0x00055549, 0x900830d2), new Long(0x24c24034, 0x934930c), new Long(0x02682493, 0x4186900),\n    new Long(0x61201a48, 0x9a498612), new Long(0x355249d4, 0xc348001), new Long(0x940d2402, 0x24c40930), new Long(0x0924e24d, 0x1a40009a),\n    new Long(0x06920106, 0x6204984a), new Long(0x92712692, 0x92494d54), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924),\n    new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492),\n    new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249),\n    new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924),\n    new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492),\n    new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249),\n    new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924),\n    new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492),\n    new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924)\n];\n// state map\n//   0 -> [(0, 0)]\n//   1 -> [(0, 2)]\n//   2 -> [(0, 1)]\n//   3 -> [(0, 1), (1, 1)]\n//   4 -> [(0, 2), (1, 2)]\n//   5 -> [t(0, 2), (0, 2), (1, 2), (2, 2)]\n//   6 -> [(0, 2), (2, 1)]\n//   7 -> [(0, 1), (2, 2)]\n//   8 -> [(0, 2), (2, 2)]\n//   9 -> [(0, 1), (1, 1), (2, 1)]\n//   10 -> [(0, 2), (1, 2), (2, 2)]\n//   11 -> [(0, 1), (2, 1)]\n//   12 -> [t(0, 1), (0, 1), (1, 1), (2, 1)]\n//   13 -> [(0, 2), (1, 2), (2, 2), (3, 2)]\n//   14 -> [t(0, 2), (0, 2), (1, 2), (2, 2), (3, 2)]\n//   15 -> [(0, 2), t(1, 2), (1, 2), (2, 2), (3, 2)]\n//   16 -> [(0, 2), (2, 1), (3, 1)]\n//   17 -> [(0, 1), t(1, 2), (2, 2), (3, 2)]\n//   18 -> [(0, 2), (3, 2)]\n//   19 -> [(0, 2), (1, 2), t(1, 2), (2, 2), (3, 2)]\n//   20 -> [t(0, 2), (0, 2), (1, 2), (3, 1)]\n//   21 -> [(0, 1), (1, 1), (3, 2)]\n//   22 -> [(0, 2), (2, 2), (3, 2)]\n//   23 -> [(0, 2), (1, 2), (3, 1)]\n//   24 -> [(0, 2), (1, 2), (3, 2)]\n//   25 -> [(0, 1), (2, 2), (3, 2)]\n//   26 -> [(0, 2), (3, 1)]\n//   27 -> [(0, 1), (3, 2)]\n//   28 -> [(0, 2), (2, 1), (4, 2)]\n//   29 -> [(0, 2), t(1, 2), (1, 2), (2, 2), (3, 2), (4, 2)]\n//   30 -> [(0, 2), (1, 2), (4, 2)]\n//   31 -> [(0, 2), (1, 2), (3, 2), (4, 2)]\n//   32 -> [(0, 2), (2, 2), (3, 2), (4, 2)]\n//   33 -> [(0, 2), (1, 2), t(2, 2), (2, 2), (3, 2), (4, 2)]\n//   34 -> [(0, 2), (1, 2), (2, 2), t(2, 2), (3, 2), (4, 2)]\n//   35 -> [(0, 2), (3, 2), (4, 2)]\n//   36 -> [(0, 2), t(2, 2), (2, 2), (3, 2), (4, 2)]\n//   37 -> [t(0, 2), (0, 2), (1, 2), (2, 2), (4, 2)]\n//   38 -> [(0, 2), (1, 2), (2, 2), (4, 2)]\n//   39 -> [t(0, 2), (0, 2), (1, 2), (2, 2), (3, 2), (4, 2)]\n//   40 -> [(0, 2), (1, 2), (2, 2), (3, 2), (4, 2)]\n//   41 -> [(0, 2), (4, 2)]\n//   42 -> [t(0, 2), (0, 2), (1, 2), (2, 2), t(2, 2), (3, 2), (4, 2)]\n//   43 -> [(0, 2), (2, 2), (4, 2)]\n//   44 -> [(0, 2), (1, 2), t(1, 2), (2, 2), (3, 2), (4, 2)]\n/**\n * From org/apache/lucene/util/automaton/Lev2TParametricDescription.java\n * @hidden\n */\nclass lev2t_parametric_description_Lev2TParametricDescription extends ParametricDescription {\n    constructor(w) {\n        super(w, 2, [0, 2, 1, 0, 1, 0, -1, 0, 0, -1, 0, -1, -1, -1, -1, -1, -2, -1, -1, -1, -2, -1, -1, -2, -1, -1, -2, -1, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2]);\n    }\n    transition(absState, position, vector) {\n        // null absState should never be passed in\n        // assert absState != -1;\n        // decode absState -> state, offset\n        let state = Math.floor(absState / (this._w + 1));\n        let offset = absState % (this._w + 1);\n        // assert offset >= 0;\n        if (position === this._w) {\n            if (state < 3) {\n                const loc = vector * 3 + state;\n                offset += ParametricDescription.unpack(lev2t_parametric_description_offsetIncrs0, loc, 1);\n                state = ParametricDescription.unpack(lev2t_parametric_description_toStates0, loc, 2) - 1;\n            }\n        }\n        else if (position === this._w - 1) {\n            if (state < 5) {\n                const loc = vector * 5 + state;\n                offset += ParametricDescription.unpack(lev2t_parametric_description_offsetIncrs1, loc, 1);\n                state = ParametricDescription.unpack(lev2t_parametric_description_toStates1, loc, 3) - 1;\n            }\n        }\n        else if (position === this._w - 2) {\n            if (state < 13) {\n                const loc = vector * 13 + state;\n                offset += ParametricDescription.unpack(lev2t_parametric_description_offsetIncrs2, loc, 2);\n                state = ParametricDescription.unpack(lev2t_parametric_description_toStates2, loc, 4) - 1;\n            }\n        }\n        else if (position === this._w - 3) {\n            if (state < 28) {\n                const loc = vector * 28 + state;\n                offset += ParametricDescription.unpack(lev2t_parametric_description_offsetIncrs3, loc, 2);\n                state = ParametricDescription.unpack(lev2t_parametric_description_toStates3, loc, 5) - 1;\n            }\n        }\n        else if (position === this._w - 4) {\n            if (state < 45) {\n                const loc = vector * 45 + state;\n                offset += ParametricDescription.unpack(offsetIncrs4, loc, 3);\n                state = ParametricDescription.unpack(toStates4, loc, 6) - 1;\n            }\n        }\n        else {\n            if (state < 45) {\n                const loc = vector * 45 + state;\n                offset += ParametricDescription.unpack(offsetIncrs5, loc, 3);\n                state = ParametricDescription.unpack(toStates5, loc, 6) - 1;\n            }\n        }\n        if (state === -1) {\n            // null state\n            return -1;\n        }\n        else {\n            // translate back to abs\n            return state * (this._w + 1) + offset;\n        }\n    }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/levenshtein_automata.ts\n\n\n\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java\n * @hidden\n */\nclass levenshtein_automata_LevenshteinAutomata {\n    constructor(input, editDistance) {\n        this._word = input;\n        this._editDistance = editDistance;\n        this._alphabet = [...new Set(this._word)].sort((a, b) => a - b);\n        this._numRanges = 0;\n        this._rangeLower = new Array(this._alphabet.length + 2);\n        this._rangeUpper = new Array(this._alphabet.length + 2);\n        // calculate the unicode range intervals that exclude the alphabet\n        // these are the ranges for all unicode characters not in the alphabet\n        let lower = 0;\n        for (let i = 0; i < this._alphabet.length; i++) {\n            const higher = this._alphabet[i];\n            if (higher > lower) {\n                this._rangeLower[this._numRanges] = lower;\n                this._rangeUpper[this._numRanges] = higher - 1;\n                this._numRanges++;\n            }\n            lower = higher + 1;\n        }\n        /* add the final endpoint */\n        if (lower <= MAX_CODE_POINT) {\n            this._rangeLower[this._numRanges] = lower;\n            this._rangeUpper[this._numRanges] = MAX_CODE_POINT;\n            this._numRanges++;\n        }\n        if (editDistance === 1) {\n            this._description = new lev1t_parametric_description_Lev1TParametricDescription(input.length);\n        }\n        else {\n            this._description = new lev2t_parametric_description_Lev2TParametricDescription(input.length);\n        }\n    }\n    /**\n     * Transforms the NDFA to a DFA.\n     * @returns {Automaton}\n     */\n    toAutomaton() {\n        let automat = new Automaton();\n        const range = 2 * this._editDistance + 1;\n        // the number of states is based on the length of the word and the edit distance\n        const numStates = this._description.size();\n        // Prefix is not needed to be handled by the automaton.\n        // stateOffset = 0;\n        automat.createState();\n        // create all states, and mark as accept states if appropriate\n        for (let i = 1; i < numStates; i++) {\n            let state = automat.createState();\n            automat.setAccept(state, this._description.isAccept(i));\n        }\n        for (let k = 0; k < numStates; k++) {\n            const xpos = this._description.getPosition(k);\n            if (xpos < 0) {\n                continue;\n            }\n            const end = xpos + Math.min(this._word.length - xpos, range);\n            for (let x = 0; x < this._alphabet.length; x++) {\n                const ch = this._alphabet[x];\n                const cvec = this._getVector(ch, xpos, end);\n                const dest = this._description.transition(k, xpos, cvec);\n                if (dest >= 0) {\n                    automat.addTransition(k, dest, ch, ch);\n                }\n            }\n            const dest = this._description.transition(k, xpos, 0);\n            if (dest >= 0) {\n                for (let r = 0; r < this._numRanges; r++) {\n                    automat.addTransition(k, dest, this._rangeLower[r], this._rangeUpper[r]);\n                }\n            }\n        }\n        // assert automat.deterministic;\n        automat.finishState();\n        return automat;\n    }\n    _getVector(x, pos, end) {\n        let vector = 0;\n        for (let i = pos; i < end; i++) {\n            vector <<= 1;\n            if (this._word[i] === x) {\n                vector |= 1;\n            }\n        }\n        return vector;\n    }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/index_searcher.ts\n\n\n\n\n\nfunction calculateMinShouldMatch(optionalClauseCount, spec) {\n    if (spec === undefined) {\n        return 1;\n    }\n    if (typeof spec === \"number\") {\n        return (spec < 0) ? optionalClauseCount + spec : spec;\n    }\n    let result = optionalClauseCount;\n    if (spec.includes(\"<\")) {\n        // Parse conditional minimumShouldMatch.;\n        for (const s of spec.split(\" \")) {\n            const parts = s.split(\"<\");\n            const upperBound = parseInt(parts[0]);\n            if (optionalClauseCount <= upperBound) {\n                return result;\n            }\n            else {\n                result = calculateMinShouldMatch(optionalClauseCount, parts[1]);\n            }\n        }\n        return result;\n    }\n    if (spec.includes(\"%\")) {\n        // Parse percentage.\n        const percent = parseInt(spec.slice(0, -1));\n        const calc = (result * percent) * (1 / 100);\n        result = (calc < 0) ? result + Math.ceil(calc) : Math.floor(calc);\n    }\n    else {\n        const calc = parseInt(spec);\n        result = (calc < 0) ? result + calc : calc;\n    }\n    return (result < 1) ? 1 : result;\n}\n/**\n * @hidden\n */\nclass index_searcher_IndexSearcher {\n    /**\n     * Constructs an index searcher.\n     * @param {Dict<InvertedIndex>} invIdxs - the inverted indexes\n     * @param {Set<number>} docs - the ids of the documents\n     */\n    constructor(invIdxs, docs) {\n        this._invIdxs = invIdxs;\n        this._docs = docs;\n        this._scorer = new Scorer(this._invIdxs);\n    }\n    search(query) {\n        let queryResults = this._recursive(query.query, true);\n        // Do final scoring.\n        if (query.calculate_scoring !== undefined ? query.calculate_scoring : true) {\n            return this._scorer.finalScore(query, queryResults);\n        }\n        const result = {};\n        for (const key of queryResults.keys()) {\n            result[key] = { score: 1 };\n        }\n        return result;\n    }\n    setDirty() {\n        this._scorer.setDirty();\n    }\n    _recursive(query, doScoring) {\n        let queryResults = new Map();\n        const boost = query.boost !== undefined ? query.boost : 1;\n        const fieldName = query.field !== undefined ? query.field : null;\n        let root = null;\n        let analyzer = null;\n        if (this._invIdxs[fieldName] !== undefined) {\n            root = this._invIdxs[fieldName].root;\n            analyzer = this._invIdxs[fieldName].analyzer;\n        }\n        switch (query.type) {\n            case \"bool\": {\n                queryResults = null;\n                if (query.must !== undefined) {\n                    queryResults = this._getUnique(query.must, doScoring, queryResults);\n                }\n                if (query.filter !== undefined) {\n                    queryResults = this._getUnique(query.filter, null, queryResults);\n                }\n                if (query.should !== undefined) {\n                    const shouldDocs = this._getAll(query.should, doScoring);\n                    let empty = false;\n                    if (queryResults === null) {\n                        empty = true;\n                        queryResults = new Map();\n                    }\n                    const msm = Math.max(1, calculateMinShouldMatch(query.should.length, query.minimum_should_match));\n                    if (empty && msm === 1) {\n                        // Take all documents.\n                        queryResults = shouldDocs;\n                    }\n                    else {\n                        // Remove documents with fewer matches.\n                        for (const [docId, res] of shouldDocs) {\n                            if (res.length >= msm) {\n                                if (queryResults.has(docId)) {\n                                    queryResults.get(docId).push(...res);\n                                }\n                                else if (empty) {\n                                    queryResults.set(docId, res);\n                                }\n                                else {\n                                    queryResults.delete(docId);\n                                }\n                            }\n                        }\n                    }\n                }\n                // Match all documents if must/filter/should is not defined.\n                if (queryResults === null) {\n                    queryResults = this._recursive({ type: \"match_all\" }, false);\n                }\n                if (query.not !== undefined) {\n                    let notDocs = this._getAll(query.not, null);\n                    // Remove all matching documents.\n                    for (const docId of notDocs.keys()) {\n                        if (queryResults.has(docId)) {\n                            queryResults.delete(docId);\n                        }\n                    }\n                }\n                // Boost query results afterwards.\n                if (boost !== 1) {\n                    for (const [_, result] of queryResults) {\n                        for (let i = 0; i < result.length; i++) {\n                            result[i].boost *= boost;\n                        }\n                    }\n                }\n                break;\n            }\n            case \"term\": {\n                const cps = toCodePoints(query.value);\n                let termIdx = inverted_index_InvertedIndex.getTermIndex(cps, root);\n                this._scorer.score(fieldName, boost, termIdx, doScoring, queryResults, cps);\n                break;\n            }\n            case \"terms\": {\n                for (let i = 0; i < query.value.length; i++) {\n                    const cps = toCodePoints(query.value[i]);\n                    let termIdx = inverted_index_InvertedIndex.getTermIndex(cps, root);\n                    this._scorer.score(fieldName, boost, termIdx, doScoring, queryResults, cps);\n                }\n                break;\n            }\n            case \"fuzzy\": {\n                const [f, idf] = fuzzySearch(query, root);\n                for (let i = 0; i < f.length; i++) {\n                    this._scorer.score(fieldName, boost * f[i].boost, f[i].index, doScoring, queryResults, f[i].term, idf);\n                }\n                break;\n            }\n            case \"wildcard\": {\n                const enableScoring = query.enable_scoring !== undefined ? query.enable_scoring : false;\n                const w = wildcardSearch(query, root);\n                for (let i = 0; i < w.length; i++) {\n                    this._scorer.score(fieldName, boost, w[i].index, doScoring && enableScoring, queryResults, w[i].term);\n                }\n                break;\n            }\n            case \"match_all\": {\n                for (let docId of this._docs) {\n                    this._scorer.scoreConstant(boost, docId, queryResults);\n                }\n                break;\n            }\n            case \"constant_score\": {\n                let tmpQueryResults = this._getAll(query.filter, false);\n                // Add to each document a constant score.\n                for (const docId of tmpQueryResults.keys()) {\n                    this._scorer.scoreConstant(boost, docId, queryResults);\n                }\n                break;\n            }\n            case \"prefix\": {\n                const enableScoring = query.enable_scoring !== undefined ? query.enable_scoring : false;\n                const cps = toCodePoints(query.value);\n                const termIdx = inverted_index_InvertedIndex.getTermIndex(cps, root);\n                if (termIdx !== null) {\n                    const termIdxs = inverted_index_InvertedIndex.extendTermIndex(termIdx);\n                    for (let i = 0; i < termIdxs.length; i++) {\n                        this._scorer.score(fieldName, boost, termIdxs[i].index, doScoring && enableScoring, queryResults, [...cps, ...termIdxs[i].term]);\n                    }\n                }\n                break;\n            }\n            case \"exists\": {\n                if (root !== null) {\n                    for (const docId of this._invIdxs[fieldName].docStore.keys()) {\n                        this._scorer.scoreConstant(boost, docId, queryResults);\n                    }\n                }\n                break;\n            }\n            case \"match\": {\n                const terms = analyze(analyzer, query.value);\n                const operator = query.operator !== undefined ? query.operator : \"or\";\n                const boolQuery = { type: \"bool\" };\n                const subQueries = [];\n                if (operator === \"or\") {\n                    if (query.minimum_should_match !== undefined) {\n                        boolQuery.minimum_should_match = query.minimum_should_match;\n                    }\n                    // Create a should query.\n                    boolQuery.should = subQueries;\n                }\n                else {\n                    // Create a must query.\n                    boolQuery.must = subQueries;\n                }\n                boolQuery.boost = boost;\n                if (query.fuzziness !== undefined) {\n                    let prefixLength = query.prefix_length !== undefined ? query.prefix_length : 2;\n                    let extended = query.extended !== undefined ? query.extended : false;\n                    // Add each fuzzy.\n                    for (let i = 0; i < terms.length; i++) {\n                        subQueries.push({\n                            type: \"fuzzy\", field: fieldName, value: terms[i], fuzziness: query.fuzziness,\n                            prefix_length: prefixLength, extended: extended\n                        });\n                    }\n                }\n                else {\n                    // Add each term.\n                    for (let i = 0; i < terms.length; i++) {\n                        subQueries.push({ type: \"term\", field: fieldName, value: terms[i] });\n                    }\n                }\n                queryResults = this._recursive(boolQuery, doScoring);\n                break;\n            }\n            default:\n                break;\n        }\n        return queryResults;\n    }\n    _getUnique(queries, doScoring, queryResults) {\n        if (queries.length === 0) {\n            return queryResults;\n        }\n        for (let i = 0; i < queries.length; i++) {\n            let currDocs = this._recursive(queries[i], doScoring);\n            if (queryResults === null) {\n                queryResults = this._recursive(queries[0], doScoring);\n                continue;\n            }\n            for (const docId of queryResults.keys()) {\n                if (!currDocs.has(docId)) {\n                    queryResults.delete(docId);\n                }\n                else {\n                    queryResults.get(docId).push(...currDocs.get(docId));\n                }\n            }\n        }\n        return queryResults;\n    }\n    _getAll(queries, doScoring, queryResults = new Map()) {\n        for (let i = 0; i < queries.length; i++) {\n            let currDocs = this._recursive(queries[i], doScoring);\n            for (const docId of currDocs.keys()) {\n                if (!queryResults.has(docId)) {\n                    queryResults.set(docId, currDocs.get(docId));\n                }\n                else {\n                    queryResults.get(docId).push(...currDocs.get(docId));\n                }\n            }\n        }\n        return queryResults;\n    }\n}\n/**\n * Calculates the levenshtein distance. Specialized version.\n * Copyright Kigiri: https://github.com/kigiri\n *           Milot Mirdita: https://github.com/milot-mirdita\n *           Toni Neubert:  https://github.com/Viatorus/\n * @param {string} a - a string\n * @param {string} b - a string\n */\nfunction calculateLevenshteinDistance(a, b) {\n    let i;\n    let j;\n    let prev;\n    let val;\n    const row = Array(a.length + 1);\n    // init the row\n    for (i = 0; i <= a.length; i++) {\n        row[i] = i;\n    }\n    // fill in the rest\n    for (i = 1; i <= b.length; i++) {\n        prev = i;\n        for (j = 1; j <= a.length; j++) {\n            if (b[i - 1] === a[j - 1]) { // match\n                val = row[j - 1];\n            }\n            else {\n                val = Math.min(row[j - 1] + 1, // substitution\n                Math.min(prev + 1, // insertion\n                row[j] + 1)); // deletion\n                // transposition\n                if (i > 1 && j > 1 && b[i - 2] === a[j - 1] && a[j - 2] === b[i - 1]) {\n                    val = Math.min(val, row[j - 1] - (a[j - 1] === b[i - 1] ? 1 : 0));\n                }\n            }\n            row[j - 1] = prev;\n            prev = val;\n        }\n        row[a.length] = prev;\n    }\n    return row[a.length];\n}\n/**\n * Performs a fuzzy search.\n * @param {FuzzyQuery} query - the fuzzy query\n * @param {Index} root - the root index\n * @returns {[FuzzyResult, number]} - the fuzzy results and the maximum df\n */\nfunction fuzzySearch(query, root) {\n    let value = toCodePoints(query.value);\n    let fuzziness = query.fuzziness !== undefined ? query.fuzziness : \"AUTO\";\n    if (fuzziness === \"AUTO\") {\n        if (value.length <= 2) {\n            fuzziness = 0;\n        }\n        else if (value.length <= 5) {\n            fuzziness = 1;\n        }\n        else {\n            fuzziness = 2;\n        }\n    }\n    let prefixLength = query.prefix_length !== undefined ? query.prefix_length : 0;\n    let extended = query.extended !== undefined ? query.extended : false;\n    // Do just a prefix search if zero fuzziness.\n    if (fuzziness === 0) {\n        prefixLength = value.length;\n    }\n    let result = [];\n    let startIdx = root;\n    let prefix = value.slice(0, prefixLength);\n    let fuzzy = value;\n    let df = 0;\n    // Perform a prefix search.\n    if (prefixLength !== 0) {\n        startIdx = inverted_index_InvertedIndex.getTermIndex(prefix, startIdx);\n        fuzzy = fuzzy.slice(prefixLength);\n    }\n    // No startIdx found.\n    if (startIdx === null) {\n        return [result, df];\n    }\n    // Fuzzy is not necessary anymore, because prefix search includes the whole query value.\n    if (fuzzy.length === 0) {\n        if (extended) {\n            // Add all terms down the index.\n            const all = inverted_index_InvertedIndex.extendTermIndex(startIdx);\n            for (let i = 0; i < all.length; i++) {\n                result.push({ index: all[i].index, term: all[i].term, boost: 1 });\n                df = Math.max(df, all[i].index.df);\n            }\n        }\n        else if (startIdx.dc !== undefined) {\n            // Add prefix search result.\n            result.push({ index: startIdx, term: value, boost: 1 });\n            df = startIdx.df;\n        }\n        return [result, df];\n    }\n    // The matching term.\n    const term = [0];\n    // Create an automaton from the fuzzy.\n    const automaton = new RunAutomaton(new levenshtein_automata_LevenshteinAutomata(fuzzy, fuzziness).toAutomaton());\n    function determineEditDistance(state, term, fuzzy) {\n        // Check how many edits this fuzzy can still do.\n        let ed = 0;\n        state = automaton.step(state, 0);\n        if (state !== -1 && automaton.isAccept(state)) {\n            ed++;\n            state = automaton.step(state, 0);\n            if (state !== -1 && automaton.isAccept(state)) {\n                ed++;\n            }\n            // Special handling for smaller terms.\n            if (term.length < fuzzy.length) {\n                if (ed !== fuzziness) {\n                    return calculateLevenshteinDistance(term, fuzzy);\n                }\n                // Include the term and fuzzy length.\n                ed -= fuzzy.length - term.length;\n            }\n        }\n        return fuzziness - ed;\n    }\n    function recursive(state, key, idx) {\n        term[term.length - 1] = key;\n        // Check the current key of term with the automaton.\n        state = automaton.step(state, key);\n        if (state === -1) {\n            return;\n        }\n        if (automaton.isAccept(state)) {\n            if (extended) {\n                // Add all terms down the index.\n                const all = inverted_index_InvertedIndex.extendTermIndex(idx);\n                for (let i = 0; i < all.length; i++) {\n                    result.push({ index: all[i].index, term: all[i].term, boost: 1 });\n                    df = Math.max(df, all[i].index.df);\n                }\n                return;\n            }\n            else if (idx.df !== undefined) {\n                // Calculate boost.\n                const distance = determineEditDistance(state, term, fuzzy);\n                const boost = Math.max(0, 1 - distance / Math.min(prefix.length + term.length, value.length));\n                result.push({ index: idx, term: [...prefix, ...term], boost });\n                df = Math.max(df, idx.df);\n            }\n        }\n        term.push(0);\n        for (const child of idx) {\n            recursive(state, child[0], child[1]);\n        }\n        term.pop();\n    }\n    for (const child of startIdx) {\n        recursive(0, child[0], child[1]);\n    }\n    return [result, df];\n}\n/**\n * Performs a wildcard search.\n * @param {WildcardQuery} query - the wildcard query\n * @param {Index} root - the root index\n * @returns {Array} - the results\n */\nfunction wildcardSearch(query, root) {\n    let wildcard = toCodePoints(query.value);\n    let result = [];\n    function recursive(index, idx = 0, term = [], escaped = false) {\n        if (index === null) {\n            return;\n        }\n        if (idx === wildcard.length) {\n            if (index.df !== undefined) {\n                result.push({ index: index, term: term.slice() });\n            }\n            return;\n        }\n        // Escaped character.\n        if (!escaped && wildcard[idx] === 92 /* \\ */) {\n            recursive(index, idx + 1, term, true);\n        }\n        else if (!escaped && wildcard[idx] === 63 /* ? */) {\n            for (const child of index) {\n                recursive(child[1], idx + 1, [...term, child[0]]);\n            }\n        }\n        else if (!escaped && wildcard[idx] === 42 /* * */) {\n            // Check if asterisk is last wildcard character\n            if (idx + 1 === wildcard.length) {\n                const all = inverted_index_InvertedIndex.extendTermIndex(index);\n                for (let i = 0; i < all.length; i++) {\n                    recursive(all[i].index, idx + 1, [...term, ...all[i].term]);\n                }\n            }\n            else {\n                // Iterate over the whole tree.\n                recursive(index, idx + 1, term, false);\n                const indices = [{ index: index, term: [] }];\n                do {\n                    const index = indices.pop();\n                    for (const child of index.index) {\n                        recursive(child[1], idx + 1, [...term, ...index.term, child[0]]);\n                        indices.push({ index: child[1], term: [...index.term, child[0]] });\n                    }\n                } while (indices.length !== 0);\n            }\n        }\n        else {\n            recursive(inverted_index_InvertedIndex.getTermIndex([wildcard[idx]], index), idx + 1, [...term, wildcard[idx]]);\n        }\n    }\n    recursive(root);\n    return result;\n}\n\n// EXTERNAL MODULE: ./packages/common/plugin.ts\nvar common_plugin = __webpack_require__(0);\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/full_text_search.ts\n\n\n\nclass full_text_search_FullTextSearch {\n    /**\n     * Initialize the full-text search for the given fields.\n     * @param {object[]} fieldOptions - the field options\n     * @param {string} fieldOptions.field - the name of the property field\n     * @param {boolean=true} fieldOptions.store - flag to indicate if the full-text search should be stored on serialization or\n     *  rebuild on deserialization\n     * @param {boolean=true} fieldOptions.optimizeChanges - flag to optimize updating and deleting of documents\n     *    (requires more memory but performs faster)\n     * @param {Analyzer} fieldOptions.analyzer - an analyzer for the field\n     * @param {string} [id] - the property name of the document index\n     */\n    constructor(fieldOptions = [], id) {\n        this._invIdxs = {};\n        // Create an inverted index for each field.\n        for (let i = 0; i < fieldOptions.length; i++) {\n            let fieldOption = fieldOptions[i];\n            this._invIdxs[fieldOption.field] = new inverted_index_InvertedIndex(fieldOption);\n        }\n        this._id = id;\n        this._docs = new Set();\n        this._idxSearcher = new index_searcher_IndexSearcher(this._invIdxs, this._docs);\n    }\n    /**\n     * Registers the full-text search as plugin.\n     */\n    static register() {\n        common_plugin[\"a\" /* PLUGINS */][\"FullTextSearch\"] = full_text_search_FullTextSearch;\n    }\n    addDocument(doc, id = doc[this._id]) {\n        let fieldNames = Object.keys(this._invIdxs);\n        for (let i = 0, fieldName; i < fieldNames.length, fieldName = fieldNames[i]; i++) {\n            let field = doc[fieldName];\n            // Skip null and undefined.\n            if (field === null || field === undefined) {\n                continue;\n            }\n            if (typeof field !== \"string\") {\n                // Convert number to string.\n                if (typeof field === \"number\") {\n                    field = field.toString();\n                }\n                else {\n                    throw TypeError(\"Unsupported field type for full text search.\");\n                }\n            }\n            this._invIdxs[fieldName].insert(field, id);\n        }\n        this._docs.add(id);\n        this._idxSearcher.setDirty();\n    }\n    removeDocument(doc, id = doc[this._id]) {\n        let fieldNames = Object.keys(this._invIdxs);\n        for (let i = 0; i < fieldNames.length; i++) {\n            this._invIdxs[fieldNames[i]].remove(id);\n        }\n        this._docs.delete(id);\n        this._idxSearcher.setDirty();\n    }\n    updateDocument(doc, id = doc[this._id]) {\n        this.removeDocument(doc, id);\n        this.addDocument(doc, id);\n    }\n    clear() {\n        for (let id of this._docs) {\n            this.removeDocument(null, id);\n        }\n    }\n    search(query) {\n        return this._idxSearcher.search(query);\n    }\n    toJSON() {\n        let serialized = { id: this._id, ii: {} };\n        let fieldNames = Object.keys(this._invIdxs);\n        for (let i = 0; i < fieldNames.length; i++) {\n            const fieldName = fieldNames[i];\n            serialized.ii[fieldName] = this._invIdxs[fieldName].toJSON();\n        }\n        return serialized;\n    }\n    static fromJSONObject(serialized, analyzers = {}) {\n        let fts = new full_text_search_FullTextSearch([], serialized.id);\n        let fieldNames = Object.keys(serialized.ii);\n        for (let i = 0; i < fieldNames.length; i++) {\n            const fieldName = fieldNames[i];\n            fts._invIdxs[fieldName] = inverted_index_InvertedIndex.fromJSONObject(serialized.ii[fieldName], analyzers[fieldName]);\n        }\n        return fts;\n    }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/index.ts\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"FullTextSearch\", function() { return full_text_search_FullTextSearch; });\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"analyze\", function() { return analyze; });\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"StandardAnalyzer\", function() { return analyzer_StandardAnalyzer; });\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"whitespaceTokenizer\", function() { return whitespaceTokenizer; });\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"lowercaseTokenFilter\", function() { return lowercaseTokenFilter; });\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"uppercaseTokenFilter\", function() { return uppercaseTokenFilter; });\n\n\n\n\nfull_text_search_FullTextSearch[\"Analyzer\"] = {};\nfull_text_search_FullTextSearch[\"Analyzer\"][\"analyze\"] = analyze;\nfull_text_search_FullTextSearch[\"Analyzer\"][\"StandardAnalyzer\"] = analyzer_StandardAnalyzer;\nfull_text_search_FullTextSearch[\"Tokenizer\"] = {};\nfull_text_search_FullTextSearch[\"Tokenizer\"][\"whitespaceTokenizer\"] = whitespaceTokenizer;\nfull_text_search_FullTextSearch[\"TokenFilter\"] = {};\nfull_text_search_FullTextSearch[\"TokenFilter\"][\"lowercaseTokenFilter\"] = lowercaseTokenFilter;\nfull_text_search_FullTextSearch[\"TokenFilter\"][\"uppercaseTokenFilter\"] = uppercaseTokenFilter;\n\n/* harmony default export */ var src = __webpack_exports__[\"default\"] = (full_text_search_FullTextSearch);\n\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports) {\n\nvar g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n\n/***/ })\n/******/ ]);\n});\n//# sourceMappingURL=lokidb.full-text-search.js.map","import QueryBuilder from './query-builder'\nimport Loki from '@lokidb/loki'\nimport LokiFullTextSearch from '@lokidb/full-text-search'\n\nLokiFullTextSearch.register()\n\nconst dirs = [\"/\"]\n  let db, items\n\nconst $content = function () {\n  let options = {}\n  const paths = []\n  Array.from(arguments).forEach((argument) => {\n    if (typeof argument === 'string') {\n      paths.push(argument)\n    } else if (typeof argument === 'object') {\n      options = argument\n    }\n  })\n\n  const { text = false, deep = false } = options\n\n  const path = `/${paths.join('/').replace(/\\/+/g, '/')}`\n  const isDir = !path || !!dirs.find(dir => dir === path)\n  // Look for dir or path\n  const query = isDir ? { dir: deep ? { $regex: new RegExp(`^${path}`) } : path } : { path }\n  // Postprocess to get only first result (findOne)\n  const postprocess = isDir ? [] : [data => data[0]]\n\n  return new QueryBuilder({\n    query: items.chain().find(query, !isDir),\n    path,\n    postprocess,\n    text\n  }, {\n    fullTextSearchFields: [\"title\",\"description\",\"slug\",\"text\"]\n  })\n}\n\nexport default (database) => {\n  db = new Loki('content.db')\n  db.loadJSONObject(database)\n  items = db.getCollection('items')\n\n  return $content\n}\n"],"sourceRoot":""}