{"version":3,"sources":["webpack://search-example-site/./node_modules/cdn-static-database/es/cdn-static-database.js"],"names":["instance","_excluded$3","_excluded2$2","id_counter$3","NgramIndice","_temp","_ref","_ref$id","id","_ref$gramLen","gramLen","_ref$actuationLimit","actuationLimit","_ref$toLowcase","toLowcase","_ref$actuationLimitAu","actuationLimitAuto","_ref$isLoaded","isLoaded","stem","_ref$stopWords","stopWords","Set","load","this","indices","Map","nGram","options","stemmer","newStemmer","_proto","prototype","add","key","value","_this","tokens","Array","isArray","forEach","v","push","apply","tokenizr","token","index","get","set","serializeOptions","_this$options","serializeData","_this2","_this$options2","preTokenizr","postTokenizr","toLowerCase","split","filter","has","map","flatMap","word","_load","_callee","_await$this$options$l","data","_context","prev","next","abrupt","sent","Error","stop","arguments","getIndices","operator","preFilter","_preFilter","_callee2","_temp2","_this3","_ref2$operator","countResults","_context2","count","_x5","_x6","find","_find","_callee3","_temp3","_this4","_ref3$operator","preResult","_context3","undefined","postFilter","_x7","_x8","_this$options3","l","getLimit","length","entries","_ref4","_ref5","autoLimit","tokensLength","limit","serialize","deserialize","spread","chunkSize","_this5","_this$options4","result","size","keys","splice","findAll","_findAll","_callee4","_temp4","_this6","_ref6$operator","list","combineWeights","_context4","Promise","all","indice","reduce","sum","weights","_x9","_x10","_x11","getIndiceChunks","_temp5","_ref7","_ref7$operator","traceId","slice","concat","i","debug","$subResult","then","cursorAll","_temp6","_ref9","_this7","_ref8","_ref8$operator","copyIndices","$promises","bind","subResult","alreadyGiveIds","never","Symbol","asyncIterator","_next","_callee5","_await$Promise$race","res","_context5","console","race","weight","r","delete","reverse","done","sort","a","b","_excluded$2","_excluded2$1","id_counter$2","SimpleIndice","_load2","_callee6","_context6","getIndicesFullScanOr","RegExp","test","getIndicesFullScanAnd","cond","k","some","ids","every","_preFilter2","_callee7","_ref2","_ref2$sort","t","_context7","values","_x12","_x13","_find2","_callee8","_ref3","_ref3$sort","_context8","_x14","_x15","_findAll2","_callee9","_ref5$operator","_ref5$sort","_context9","_x16","_x17","_x18","_this8","_ref6","_ref6$sort","_ref6$chunkSize","indiceIndex","_next2","_callee10","currentChunkSize","_value","_context10","Math","min","Range","left","right","fromKeys","indexes","_indexes$reduce","val","match","source","ignoreCase","toString","m","startsWith","lt","gt","_excluded$1","id_counter$1","RangeLinearIndice","_ref$chunkSize","_a","self","testIndice","_deserialize","_ref3$","lazy","indiceDeserialize","filterIndicesByWeight","_load3","_callee11","_context11","_ref4$","_find3","_callee12","_context12","w","_x19","_x20","cursor","_ref13","iterator","_ref9$operator","_ref9$sort","load$","isFound","_find4","_callee13","filteredIndices","_context13","_ref10","_ref11","_ref12","_next3","_callee14","_context14","_excluded","_excluded2","id_counter","TextLexIndice","_ref$algoritm","algoritm","_load4","_callee15","_context15","_preFilter3","_callee16","_context16","_x21","_x22","_find5","_callee17","_context17","_x23","_x24","_findAll3","_callee18","_context18","_x25","_x26","_x27","_next4","_callee19","_context19","getNext","traceIteratorId","_combineAsyncIterable","_callee20","iterable","asyncIterators","currentTraceIteratorId","results","nextPromises","_yield$_awaitAsyncGen","_iterator","_step","_step$value","_index","_context20","from","o","return","finish","intersectAsyncIterable","_x3","_x4","_intersectAsyncIterable","_callee21","combineResults","_yield$_awaitAsyncGen2","combineResult","subResults","_loop","_iterator2","_step2","_iterator3","_step3","_step3$value","_index2","_context21","fill","_","c","comparableOperators","logicalOperators","PoisonPillow","reqId","Db","schema","customOperators","operators","path","buildIndexSearch","criteria","skip","context","_ref2$isRoot","isRoot","_ref2$caches","caches","sortIndices","subIterables","greed","_Object$entries$_i","_Object$entries","_i","order","warn","Object","_loop2","_Object$entries2$_i","_Object$entries2","_i2","subIt","subCriteria","isAnd","it","_greed","missed","paths","sIs","_x","_x2","combineAsyncIterable","fullTextIndice","pop","isOperator","indiceOptions","exists","op","isObject","_indiceOptions","_exists","simpleIterable","indiceCursor","subGreed","subIterable","_ref14","subPaths","_ref15","_ref16","onlySortIndices","_ref17","sortedIterable","_ref18","missedAll","greedAll","_find6","_callee22","primaryIndice","search","query","isEnough","_iteratorAbruptCompletion","_didIteratorError","_iteratorError","_iterator5","_step5","_iterator6","_step6","_value3","_iteratorAbruptCompletion2","_didIteratorError2","_iteratorError2","_ids","subIds","searchIds","_values","_i3","_arr","_values2","_iterator7","_step7","_value2","_context22","t0","t1","_x28","_x29","_x30","_x31","lockCursorSuccess","lockCursorError","_hasNext","cursorQueue","cursorSuccess","lockCreator","suc","err","getCursor","cursorError","promise","lockCursor","cursorCreator","matchResultHandler","_matchResultHandler","_callee23","_context23","_x32","_callee24","_iteratorAbruptCompletion3","_didIteratorError3","_iteratorError3","_iterator8","_step8","_iterator9","_step9","_value6","_iteratorAbruptCompletion4","_didIteratorError4","_iteratorError4","_iterator4","_step4","_ids2","_values3","_i4","_arr2","_value4","_values4","_iterator10","_step10","_value5","_context24","t2","e","start","Date","getTime","end","hasNext","_ref20","_ref19","_ref19$operator","_ref19$sort","idAttr","_next5","_callee25","_await$getNext","_context25","Schema","fs","normalize","isPathAbsolute","charAt","isAbsolute","trailingSlash","substr","parts","allowAboveRoot","up","last","unshift","normalizeArray","p","join","call","TypeError","xs","f","str","len","global$1","g","window","lookup","revLookup","Arr","Uint8Array","inited","init","code","charCodeAt","encodeChunk","uint8","tmp","num","output","fromByteArray","extraBytes","maxChunkLength","len2","read","buffer","offset","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","d","s","NaN","Infinity","pow","write","rt","abs","isNaN","floor","log","LN2","isArray$1","arr","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","__proto__","arg","encodingOrOffset","allocUnsafe","ArrayBuffer","array","byteOffset","byteLength","fromArrayLike","fromArrayBuffer","string","encoding","isEncoding","actual","fromString","obj","internalIsBuffer","checked","copy","type","fromObject","assertSize","_isBuffer","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","n","bidirectionalIndexOf","dir","arrayIndexOf","indexOf","lastIndexOf","indexSize","arrLength","valLength","String","buf","readUInt16BE","foundIndex","found","j","hexWrite","Number","remaining","strLen","parsed","parseInt","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","latin1Write","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","decodeCodePointsArray","poolSize","_augment","alloc","allocUnsafeSlow","isBuffer","isFastBuffer","readFloatLE","isSlowBuffer","compare","x","y","pos","swap16","swap32","swap64","equals","inspect","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","ret","out","toHex","bytes","checkOffset","ext","checkInt","max","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","subarray","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","INVALID_BASE64_RE","leadSurrogate","b64","placeHolders","L","toByteArray","trim","replace","stringtrim","base64clean","src","dst","constructor","defaultSetTimout","defaultClearTimeout","cachedSetTimeout","cachedClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","noop","on","addListener","once","off","removeListener","removeAllListeners","emit","performance","performanceNow","now","mozNow","msNow","oNow","webkitNow","startTime","process","nextTick","args","title","browser","env","argv","version","versions","binding","name","cwd","chdir","umask","hrtime","previousTimestamp","clocktime","seconds","nanoseconds","platform","release","config","uptime","inherits$1","create","ctor","superCtor","super_","enumerable","writable","configurable","TempCtor","formatRegExp","format","isString","objects","JSON","stringify","isNull","debugEnviron","debugs","opts","ctx","seen","stylize","stylizeNoColor","depth","colors","isBoolean","showHidden","_extend","isUndefined","customInspect","stylizeWithColor","formatValue","styleType","style","styles","recurseTimes","isFunction","primitive","simple","isNumber","formatPrimitive","visibleKeys","hash","idx","arrayToHash","getOwnPropertyNames","isError","formatError","isRegExp","isDate","base","braces","toUTCString","hasOwnProperty","formatProperty","formatArray","cur","reduceToSingleString","desc","getOwnPropertyDescriptor","line","ar","re","objectToString","pad","months","timestamp","time","getHours","getMinutes","getSeconds","getDate","getMonth","origin","prop","util","inherits","maybeBuf","isPrimitive","isSymbol","isNullOrUndefined","deprecate","fn","msg","noDeprecation","warned","throwDeprecation","traceDeprecation","trace","error","debuglog","NODE_DEBUG","toUpperCase","saveSharedIndices","_saveSharedIndices","_callee26","publicPath","writeFile","mkdir","_context26","promisify","_x33","_x34","restoreSharedIndices$1","_restoreSharedIndices","_callee28","deserializeShared","readFile","jsonRaw","json","_context28","_load5","_callee27","_context27","parse","_x38","_x35","_x36","_x37","restoreSharedIndices","_restoreSharedIndices2","_callee31","baseUrl","loadChunk","_context31","_loadChunk","_callee29","response","_context29","fetch","_x40","_load6","_callee30","_context30","method","credentials","mode","_x41","_x39"],"mappings":"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","file":"7de720de-8990c2ea1212b5f66835.js","sourcesContent":["import _asyncToGenerator from \"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/esm/asyncToGenerator\";\nimport _toConsumableArray from \"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/esm/toConsumableArray\";\nimport _regeneratorRuntime from \"/opt/buildhome/repo/node_modules/@babel/runtime/regenerator\";\nimport \"core-js/modules/es.array.flat-map.js\";\nimport \"core-js/modules/es.array.unscopables.flat-map.js\";\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\nimport _createClass from '@babel/runtime/helpers/esm/createClass';\nimport nGram from 'n-gram';\nimport { newStemmer } from 'snowball-stemmers';\nimport log$1 from 'loglevel';\nimport _objectSpread from '@babel/runtime/helpers/esm/objectSpread2';\nimport _objectDestructuringEmpty from '@babel/runtime/helpers/esm/objectDestructuringEmpty';\nimport _createForOfIteratorHelperLoose from '@babel/runtime/helpers/esm/createForOfIteratorHelperLoose';\nimport _asyncIterator from '@babel/runtime/helpers/esm/asyncIterator';\nimport mingo from 'mingo';\nimport { isArray as isArray$2, isOperator, isObject as isObject$1 } from 'mingo/util';\nimport _awaitAsyncGenerator from '@babel/runtime/helpers/esm/awaitAsyncGenerator';\nimport _wrapAsyncGenerator from '@babel/runtime/helpers/esm/wrapAsyncGenerator';\nvar instance = log$1.noConflict();\nvar _excluded$3 = [\"load\", \"stopWords\"],\n    _excluded2$2 = [\"id\"];\nvar CHUNK_SIZE_DEFAULT$2 = 100;\nvar AUTO_LIMIT_FIND_PERCENT = 40;\nvar id_counter$3 = 1;\n\nvar NgramIndice = /*#__PURE__*/function () {\n  function NgramIndice(_temp) {\n    var _ref = _temp === void 0 ? {} : _temp,\n        _ref$id = _ref.id,\n        id = _ref$id === void 0 ? \"\" + id_counter$3++ : _ref$id,\n        _ref$gramLen = _ref.gramLen,\n        gramLen = _ref$gramLen === void 0 ? 3 : _ref$gramLen,\n        _ref$actuationLimit = _ref.actuationLimit,\n        actuationLimit = _ref$actuationLimit === void 0 ? 2 : _ref$actuationLimit,\n        _ref$toLowcase = _ref.toLowcase,\n        toLowcase = _ref$toLowcase === void 0 ? true : _ref$toLowcase,\n        _ref$actuationLimitAu = _ref.actuationLimitAuto,\n        actuationLimitAuto = _ref$actuationLimitAu === void 0 ? false : _ref$actuationLimitAu,\n        _ref$isLoaded = _ref.isLoaded,\n        isLoaded = _ref$isLoaded === void 0 ? true : _ref$isLoaded,\n        stem = _ref.stem,\n        _ref$stopWords = _ref.stopWords,\n        stopWords = _ref$stopWords === void 0 ? new Set() : _ref$stopWords,\n        load = _ref.load;\n\n    this.indices = new Map();\n    this.nGram = nGram(gramLen);\n    this.options = {\n      gramLen: gramLen,\n      actuationLimit: actuationLimit,\n      toLowcase: toLowcase,\n      actuationLimitAuto: actuationLimitAuto,\n      isLoaded: isLoaded,\n      stem: stem,\n      stopWords: stopWords,\n      id: id,\n      load: load\n    };\n    this.stemmer = stem ? newStemmer(stem) : null;\n    return this;\n  }\n\n  var _proto = NgramIndice.prototype;\n\n  _proto.add = function add(key, value) {\n    var _this = this;\n\n    var tokens = [];\n\n    if (Array.isArray(value)) {\n      value.forEach(function (v) {\n        return tokens.push.apply(tokens, _toConsumableArray(_this.tokenizr(v)));\n      });\n    } else {\n      tokens.push.apply(tokens, _toConsumableArray(this.tokenizr(value)));\n    }\n\n    tokens.forEach(function (token) {\n      var index = _this.indices.get(token) || [];\n      index.push(key);\n\n      _this.indices.set(token, index);\n    });\n  };\n\n  _proto.serializeOptions = function serializeOptions() {\n    var _this$options = this.options;\n    _this$options.load;\n\n    var stopWords = _this$options.stopWords,\n        options = _objectWithoutPropertiesLoose(_this$options, _excluded$3);\n\n    if (stopWords) {\n      options.stopWords = _toConsumableArray(stopWords);\n    }\n\n    return options;\n  };\n\n  _proto.serializeData = function serializeData() {\n    return _toConsumableArray(this.indices);\n  };\n\n  _proto.tokenizr = function tokenizr(value) {\n    var _this2 = this;\n\n    var _this$options2 = this.options,\n        preTokenizr = _this$options2.preTokenizr,\n        postTokenizr = _this$options2.postTokenizr;\n    var v = preTokenizr ? preTokenizr(value) : value;\n    v = this.options.toLowcase ? v.toLowerCase() : v;\n    var tokens = v // eslint-disable-next-line no-useless-escape\n    .split(/[ \\,\\.]/).filter(function (v) {\n      return !_this2.options.stopWords || !_this2.options.stopWords.has(v);\n    }).map(function (v) {\n      return _this2.stemmer ? _this2.stemmer.stem(v) : v;\n    }).flatMap(function (word) {\n      return _this2.nGram(word);\n    });\n    return postTokenizr ? postTokenizr(value, tokens) : tokens;\n  };\n\n  _proto.load = /*#__PURE__*/function () {\n    var _load = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n      var _await$this$options$l, data;\n\n      return _regeneratorRuntime.wrap(function _callee$(_context) {\n        while (1) {\n          switch (_context.prev = _context.next) {\n            case 0:\n              if (!this.options.isLoaded) {\n                _context.next = 4;\n                break;\n              }\n\n              return _context.abrupt(\"return\");\n\n            case 4:\n              if (!this.options.load) {\n                _context.next = 13;\n                break;\n              }\n\n              _context.next = 7;\n              return this.options.load(this.options);\n\n            case 7:\n              _await$this$options$l = _context.sent;\n              data = _await$this$options$l.data;\n              this.indices = new Map(data);\n              this.options.isLoaded = true;\n              _context.next = 14;\n              break;\n\n            case 13:\n              throw Error(\"option load doesn't implemented\");\n\n            case 14:\n            case \"end\":\n              return _context.stop();\n          }\n        }\n      }, _callee, this);\n    }));\n\n    function load() {\n      return _load.apply(this, arguments);\n    }\n\n    return load;\n  }();\n\n  _proto.getIndices = function getIndices(token, operator) {\n    return this.indices.get(token);\n  };\n\n  _proto.preFilter = /*#__PURE__*/function () {\n    var _preFilter = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(tokens, _temp2) {\n      var _this3, _ref2, _ref2$operator, operator, countResults;\n\n      return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n        while (1) {\n          switch (_context2.prev = _context2.next) {\n            case 0:\n              _this3 = this;\n              _ref2 = _temp2 === void 0 ? {} : _temp2, _ref2$operator = _ref2.operator, operator = _ref2$operator === void 0 ? '$eq' : _ref2$operator;\n              countResults = new Map();\n              _context2.next = 5;\n              return this.load();\n\n            case 5:\n              tokens.forEach(function (token) {\n                var indices = _this3.getIndices(token, operator);\n\n                if (indices) {\n                  indices.forEach(function (id) {\n                    var count = countResults.get(id) || 0;\n                    countResults.set(id, count + 1);\n                  });\n                }\n              });\n              return _context2.abrupt(\"return\", countResults);\n\n            case 7:\n            case \"end\":\n              return _context2.stop();\n          }\n        }\n      }, _callee2, this);\n    }));\n\n    function preFilter(_x5, _x6) {\n      return _preFilter.apply(this, arguments);\n    }\n\n    return preFilter;\n  }();\n\n  _proto.find = /*#__PURE__*/function () {\n    var _find = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(value, _temp3) {\n      var _this4, _ref3, _ref3$operator, operator, tokens, preResult;\n\n      return _regeneratorRuntime.wrap(function _callee3$(_context3) {\n        while (1) {\n          switch (_context3.prev = _context3.next) {\n            case 0:\n              _this4 = this;\n              _ref3 = _temp3 === void 0 ? {} : _temp3, _ref3$operator = _ref3.operator, operator = _ref3$operator === void 0 ? '$eq' : _ref3$operator;\n              tokens = [];\n\n              if (value !== undefined) {\n                tokens = Array.isArray(value) ? value.flatMap(function (v) {\n                  return _this4.tokenizr(v);\n                }) : this.tokenizr(value);\n              }\n\n              _context3.next = 6;\n              return this.preFilter(tokens, {\n                operator: operator\n              });\n\n            case 6:\n              preResult = _context3.sent;\n              return _context3.abrupt(\"return\", this.postFilter(preResult, tokens));\n\n            case 8:\n            case \"end\":\n              return _context3.stop();\n          }\n        }\n      }, _callee3, this);\n    }));\n\n    function find(_x7, _x8) {\n      return _find.apply(this, arguments);\n    }\n\n    return find;\n  }();\n\n  _proto.postFilter = function postFilter(countResults, tokens) {\n    var _this$options3 = this.options,\n        actuationLimitAuto = _this$options3.actuationLimitAuto,\n        actuationLimit = _this$options3.actuationLimit;\n    var l = this.getLimit(actuationLimitAuto, tokens.length, actuationLimit);\n\n    var results = _toConsumableArray(countResults.entries()).filter(function (_ref4) {\n      _ref4[0];\n      var count = _ref4[1];\n      return count >= l;\n    }).map(function (_ref5) {\n      var id = _ref5[0];\n      return id;\n    });\n\n    return results;\n  };\n\n  _proto.getLimit = function getLimit(autoLimit, tokensLength, limit) {\n    return autoLimit ? tokensLength * AUTO_LIMIT_FIND_PERCENT / 100 : limit;\n  };\n\n  _proto.serialize = function serialize() {\n    return {\n      data: this.serializeData(),\n      options: this.serializeOptions()\n    };\n  };\n\n  NgramIndice.deserialize = function deserialize(data, options) {\n    if (!options) {\n      options = data;\n      data = null;\n    }\n\n    if (options && options.stopWords) {\n      options.stopWords = new Set(options.stopWords);\n    }\n\n    var index = new NgramIndice(options);\n\n    if (data) {\n      index.indices = data;\n    }\n\n    return index;\n  };\n\n  _proto.spread = function spread(chunkSize) {\n    var _this5 = this;\n\n    if (chunkSize === void 0) {\n      chunkSize = CHUNK_SIZE_DEFAULT$2;\n    }\n\n    var _this$options4 = this.options;\n    _this$options4.id;\n\n    var options = _objectWithoutPropertiesLoose(_this$options4, _excluded2$2);\n\n    var result = [];\n    var size = 0;\n    var map = new Map();\n    this.keys.forEach(function (key) {\n      var value = _toConsumableArray(_this5.indices.get(key));\n\n      if (size + value.length <= chunkSize) {\n        size = size + value.length;\n        map.set(key, value);\n      } else {\n        while (value.length) {\n          map.set(key, value.splice(0, chunkSize - size));\n          result.push(NgramIndice.deserialize(map, options));\n          size = 0;\n          map = new Map();\n        }\n      }\n    });\n\n    if (size != 0) {\n      result.push(NgramIndice.deserialize(map, options));\n    }\n\n    return result;\n  };\n\n  _proto.findAll = /*#__PURE__*/function () {\n    var _findAll = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(indices, value, _temp4) {\n      var _this6, _ref6, _ref6$operator, operator, tokens, list, combineWeights;\n\n      return _regeneratorRuntime.wrap(function _callee4$(_context4) {\n        while (1) {\n          switch (_context4.prev = _context4.next) {\n            case 0:\n              _this6 = this;\n              _ref6 = _temp4 === void 0 ? {} : _temp4, _ref6$operator = _ref6.operator, operator = _ref6$operator === void 0 ? '$eq' : _ref6$operator;\n              tokens = Array.isArray(value) ? value.flatMap(function (v) {\n                return _this6.tokenizr(v);\n              }) : this.tokenizr(value);\n              _context4.next = 5;\n              return Promise.all(indices.map(function (indice) {\n                return indice.preFilter(tokens, {\n                  operator: operator\n                });\n              }));\n\n            case 5:\n              list = _context4.sent;\n              combineWeights = list.reduce(function (sum, weights) {\n                weights.forEach(function (value, key) {\n                  var count = sum.get(key) || 0;\n                  sum.set(key, count + value);\n                });\n                return sum;\n              }, new Map());\n              return _context4.abrupt(\"return\", this.postFilter(combineWeights, tokens));\n\n            case 8:\n            case \"end\":\n              return _context4.stop();\n          }\n        }\n      }, _callee4, this);\n    }));\n\n    function findAll(_x9, _x10, _x11) {\n      return _findAll.apply(this, arguments);\n    }\n\n    return findAll;\n  }();\n\n  _proto.getIndiceChunks = function getIndiceChunks(indices, tokens, _temp5) {\n    var _ref7 = _temp5 === void 0 ? {} : _temp5,\n        _ref7$operator = _ref7.operator,\n        operator = _ref7$operator === void 0 ? '$eq' : _ref7$operator,\n        traceId = _ref7.traceId;\n\n    var CHUNK_SIZE = 5;\n    var length = indices.length;\n    var slice = [].concat(_toConsumableArray(indices.splice(0, CHUNK_SIZE)), _toConsumableArray(indices.splice(-CHUNK_SIZE)));\n    slice.forEach(function (indice, i) {\n      instance.debug(\"[\" + traceId + \"]\", \"Loading simple indice search id: \" + indice.id + \", loading \" + (i + 1) + \"/\" + length + \"  suggestions chunk\");\n    });\n    return slice.map(function (indice) {\n      return indice.preFilter(tokens, {\n        operator: operator\n      });\n    }).map(function ($subResult, index) {\n      return $subResult.then(function (result) {\n        return {\n          index: index,\n          result: result\n        };\n      });\n    });\n  };\n\n  _proto.cursorAll = function cursorAll(indices, value, _temp6) {\n    var _this7 = this,\n        _ref9;\n\n    var _ref8 = _temp6 === void 0 ? {} : _temp6,\n        _ref8$operator = _ref8.operator,\n        operator = _ref8$operator === void 0 ? '$eq' : _ref8$operator,\n        traceId = _ref8.traceId;\n\n    var tokens = Array.isArray(value) ? value.flatMap(function (v) {\n      return _this7.tokenizr(v);\n    }) : this.tokenizr(value);\n\n    var copyIndices = _toConsumableArray(indices);\n\n    var $promises = this.getIndiceChunks(copyIndices, tokens, {\n      operator: operator,\n      traceId: traceId\n    });\n    var count = $promises.length;\n    instance.debug(\"[\" + traceId + \"]\", \"Cursor all n-gram indice value: \" + value + \" operator \" + operator + \", tokens:\", tokens);\n    var postFilter = this.postFilter,\n        getIndiceChunks = this.getIndiceChunks;\n    postFilter = postFilter.bind(this);\n    getIndiceChunks = getIndiceChunks.bind(this);\n    var subResult = [];\n    var combineWeights = new Map();\n    var alreadyGiveIds = new Set();\n    var never = new Promise(function () {// do nothing.\n    });\n    var i = 1;\n    return _ref9 = {}, _ref9[Symbol.asyncIterator] = function () {\n      return {\n        next: function () {\n          var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {\n            var _await$Promise$race, index, res;\n\n            return _regeneratorRuntime.wrap(function _callee5$(_context5) {\n              while (1) {\n                switch (_context5.prev = _context5.next) {\n                  case 0:\n                    subResult = [];\n\n                  case 1:\n                    if (!(count > 0 || copyIndices.length > 0)) {\n                      _context5.next = 19;\n                      break;\n                    }\n\n                    if (count === 0) {\n                      $promises = getIndiceChunks(copyIndices, tokens, {\n                        operator: operator,\n                        traceId: traceId\n                      });\n                      console.debug('n-gram chunk', $promises.length, copyIndices.length, i++);\n                      count = $promises.length;\n                    }\n\n                    _context5.next = 5;\n                    return Promise.race($promises);\n\n                  case 5:\n                    _await$Promise$race = _context5.sent;\n                    index = _await$Promise$race.index;\n                    res = _await$Promise$race.result;\n                    count--;\n                    $promises[index] = never;\n                    res.forEach(function (weight, key) {\n                      var value = combineWeights.get(key) || 0;\n                      combineWeights.set(key, weight + value);\n                    }, new Map());\n                    subResult = postFilter(combineWeights, tokens);\n                    subResult = subResult.filter(function (r) {\n                      return !alreadyGiveIds.has(r);\n                    });\n                    subResult.forEach(function (r) {\n                      alreadyGiveIds.add(r);\n                      combineWeights.delete(r);\n                      return r;\n                    });\n                    subResult.reverse();\n\n                    if (!subResult.length) {\n                      _context5.next = 17;\n                      break;\n                    }\n\n                    return _context5.abrupt(\"return\", {\n                      done: false,\n                      value: subResult\n                    });\n\n                  case 17:\n                    _context5.next = 1;\n                    break;\n\n                  case 19:\n                    return _context5.abrupt(\"return\", {\n                      done: true,\n                      value: undefined\n                    });\n\n                  case 20:\n                  case \"end\":\n                    return _context5.stop();\n                }\n              }\n            }, _callee5);\n          }));\n\n          function next() {\n            return _next.apply(this, arguments);\n          }\n\n          return next;\n        }()\n      };\n    }, _ref9;\n  };\n\n  _createClass(NgramIndice, [{\n    key: \"keys\",\n    get: function get() {\n      var keys = _toConsumableArray(this.indices.keys());\n\n      keys.sort(function (a, b) {\n        if (a === b) {\n          return 0;\n        }\n\n        return a < b ? -1 : 1;\n      });\n      return keys;\n    }\n  }, {\n    key: \"id\",\n    get: function get() {\n      return this.options.id;\n    }\n  }]);\n\n  return NgramIndice;\n}();\n\nvar _excluded$2 = [\"load\"],\n    _excluded2$1 = [\"id\"];\nvar CHUNK_SIZE_DEFAULT$1 = 100;\nvar id_counter$2 = 1;\n\nvar SimpleIndice = /*#__PURE__*/function () {\n  function SimpleIndice(_temp) {\n    var _ref = _temp === void 0 ? {} : _temp,\n        _ref$id = _ref.id,\n        id = _ref$id === void 0 ? \"\" + id_counter$2++ : _ref$id,\n        _ref$isLoaded = _ref.isLoaded,\n        isLoaded = _ref$isLoaded === void 0 ? true : _ref$isLoaded,\n        load = _ref.load;\n\n    this.indices = new Map();\n    this.options = {\n      isLoaded: isLoaded,\n      id: id,\n      load: load\n    };\n    return this;\n  }\n\n  var _proto = SimpleIndice.prototype;\n\n  _proto.add = function add(key, value) {\n    var _this = this;\n\n    var tokens = [];\n\n    if (Array.isArray(value)) {\n      tokens.push.apply(tokens, _toConsumableArray(value));\n    } else {\n      tokens.push(value);\n    }\n\n    tokens.forEach(function (token) {\n      var indice = _this.indices.get(token) || [];\n      indice.push(key);\n\n      _this.indices.set(token, indice);\n    });\n  };\n\n  _proto.serializeOptions = function serializeOptions() {\n    var _this$options = this.options;\n    _this$options.load;\n\n    var options = _objectWithoutPropertiesLoose(_this$options, _excluded$2);\n\n    return options;\n  };\n\n  _proto.serializeData = function serializeData() {\n    return _toConsumableArray(this.indices);\n  };\n\n  _proto.tokenizr = function tokenizr(value) {\n    return [value];\n  };\n\n  _proto.load = /*#__PURE__*/function () {\n    var _load2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {\n      var _await$this$options$l, data;\n\n      return _regeneratorRuntime.wrap(function _callee6$(_context6) {\n        while (1) {\n          switch (_context6.prev = _context6.next) {\n            case 0:\n              if (!this.options.isLoaded) {\n                _context6.next = 4;\n                break;\n              }\n\n              return _context6.abrupt(\"return\");\n\n            case 4:\n              if (!this.options.load) {\n                _context6.next = 13;\n                break;\n              }\n\n              _context6.next = 7;\n              return this.options.load(this.options);\n\n            case 7:\n              _await$this$options$l = _context6.sent;\n              data = _await$this$options$l.data;\n              this.indices = new Map(data);\n              this.options.isLoaded = true;\n              _context6.next = 14;\n              break;\n\n            case 13:\n              throw Error(\"option load doesn't implemented\");\n\n            case 14:\n            case \"end\":\n              return _context6.stop();\n          }\n        }\n      }, _callee6, this);\n    }));\n\n    function load() {\n      return _load2.apply(this, arguments);\n    }\n\n    return load;\n  }();\n\n  _proto.getIndices = function getIndices(tokens, operator, sort) {\n    var _this2 = this;\n\n    if (sort === void 0) {\n      sort = 1;\n    }\n\n    switch (operator) {\n      case '$lte':\n        {\n          return this.getIndicesFullScanOr(tokens, function (a, b) {\n            return a <= b;\n          }, sort);\n        }\n\n      case '$lt':\n        {\n          return this.getIndicesFullScanOr(tokens, function (a, b) {\n            return a < b;\n          }, sort);\n        }\n\n      case '$gte':\n        {\n          return this.getIndicesFullScanOr(tokens, function (a, b) {\n            return a >= b;\n          }, sort);\n        }\n\n      case '$gt':\n        {\n          return this.getIndicesFullScanOr(tokens, function (a, b) {\n            return a > b;\n          }, sort);\n        }\n\n      case '$regex':\n        {\n          return this.getIndicesFullScanOr(tokens, function (a, b) {\n            var regexp = b instanceof RegExp ? b : new RegExp(\"\" + b);\n            return regexp.test(\"\" + a);\n          }, sort);\n        }\n\n      case '$nin':\n      case '$ne':\n        {\n          return this.getIndicesFullScanAnd(tokens, function (a, b) {\n            return a != b;\n          }, sort);\n        }\n\n      case '$eq':\n      case '$in':\n      default:\n        return tokens.reduce(function (sum, token) {\n          var r = _this2.indices.get(token);\n\n          if (r) {\n            sum.push.apply(sum, _toConsumableArray(r));\n          }\n\n          return sum;\n        }, []);\n    }\n  };\n\n  _proto.getIndicesFullScanOr = function getIndicesFullScanOr(tokens, cond, sort) {\n    var _this3 = this;\n\n    if (sort === void 0) {\n      sort = 1;\n    }\n\n    var keys = this.keys;\n\n    if (sort === -1) {\n      keys.reverse();\n    }\n\n    return keys.reduce(function (sum, k) {\n      if (tokens.some(function (token) {\n        return cond(k, token);\n      })) {\n        var ids = _this3.indices.get(k);\n\n        sum.push.apply(sum, _toConsumableArray(ids));\n      }\n\n      return sum;\n    }, []);\n  };\n\n  _proto.getIndicesFullScanAnd = function getIndicesFullScanAnd(tokens, cond, sort) {\n    var _this4 = this;\n\n    if (sort === void 0) {\n      sort = 1;\n    }\n\n    var keys = this.keys;\n\n    if (sort === -1) {\n      keys.reverse();\n    }\n\n    return keys.reduce(function (sum, k) {\n      if (tokens.every(function (token) {\n        return cond(k, token);\n      })) {\n        var ids = _this4.indices.get(k);\n\n        sum.push.apply(sum, _toConsumableArray(ids));\n      }\n\n      return sum;\n    }, []);\n  };\n\n  _proto.preFilter = /*#__PURE__*/function () {\n    var _preFilter2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(tokens, _temp2) {\n      var _ref2, _ref2$operator, operator, _ref2$sort, sort, countResults, t, indices, v;\n\n      return _regeneratorRuntime.wrap(function _callee7$(_context7) {\n        while (1) {\n          switch (_context7.prev = _context7.next) {\n            case 0:\n              _ref2 = _temp2 === void 0 ? {} : _temp2, _ref2$operator = _ref2.operator, operator = _ref2$operator === void 0 ? '$eq' : _ref2$operator, _ref2$sort = _ref2.sort, sort = _ref2$sort === void 0 ? 1 : _ref2$sort;\n              countResults = new Map();\n              _context7.next = 4;\n              return this.load();\n\n            case 4:\n              t = _toConsumableArray(tokens);\n              t.sort(function (a, b) {\n                if (a === b) {\n                  return 0;\n                }\n\n                return (a < b ? 1 : -1) * sort;\n              });\n              indices = this.getIndices(t, operator, sort);\n\n              if (indices) {\n                indices.forEach(function (id) {\n                  var count = countResults.get(id) || 0;\n                  countResults.set(id, count + 1);\n                });\n              }\n\n              if (tokens.length) {\n                _context7.next = 12;\n                break;\n              }\n\n              v = _toConsumableArray(this.indices.values());\n\n              if (sort === -1) {\n                v.reverse();\n              }\n\n              return _context7.abrupt(\"return\", new Map(v.flatMap(function (indice) {\n                return indice;\n              }).map(function (indice) {\n                return [indice, 1];\n              })));\n\n            case 12:\n              return _context7.abrupt(\"return\", countResults);\n\n            case 13:\n            case \"end\":\n              return _context7.stop();\n          }\n        }\n      }, _callee7, this);\n    }));\n\n    function preFilter(_x12, _x13) {\n      return _preFilter2.apply(this, arguments);\n    }\n\n    return preFilter;\n  }();\n\n  _proto.find = /*#__PURE__*/function () {\n    var _find2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(value, _temp3) {\n      var _this5, _ref3, _ref3$operator, operator, _ref3$sort, sort, tokens, preResult;\n\n      return _regeneratorRuntime.wrap(function _callee8$(_context8) {\n        while (1) {\n          switch (_context8.prev = _context8.next) {\n            case 0:\n              _this5 = this;\n              _ref3 = _temp3 === void 0 ? {} : _temp3, _ref3$operator = _ref3.operator, operator = _ref3$operator === void 0 ? '$eq' : _ref3$operator, _ref3$sort = _ref3.sort, sort = _ref3$sort === void 0 ? 1 : _ref3$sort;\n              tokens = [];\n\n              if (value !== undefined) {\n                tokens = Array.isArray(value) ? value.flatMap(function (v) {\n                  return _this5.tokenizr(v);\n                }) : this.tokenizr(value);\n              }\n\n              _context8.next = 6;\n              return this.preFilter(tokens, {\n                operator: operator,\n                sort: sort\n              });\n\n            case 6:\n              preResult = _context8.sent;\n              return _context8.abrupt(\"return\", this.postFilter(preResult, tokens));\n\n            case 8:\n            case \"end\":\n              return _context8.stop();\n          }\n        }\n      }, _callee8, this);\n    }));\n\n    function find(_x14, _x15) {\n      return _find2.apply(this, arguments);\n    }\n\n    return find;\n  }();\n\n  _proto.postFilter = function postFilter(countResults, tokens) {\n    var results = _toConsumableArray(countResults.entries()).map(function (_ref4) {\n      var id = _ref4[0];\n      return id;\n    });\n\n    return results;\n  };\n\n  _proto.serialize = function serialize() {\n    return {\n      data: this.serializeData(),\n      options: this.serializeOptions()\n    };\n  };\n\n  SimpleIndice.deserialize = function deserialize(data, options) {\n    if (!options) {\n      options = data;\n      data = null;\n    }\n\n    var index = new SimpleIndice(options);\n\n    if (data) {\n      index.indices = data;\n    }\n\n    return index;\n  };\n\n  _proto.spread = function spread(chunkSize) {\n    var _this6 = this;\n\n    if (chunkSize === void 0) {\n      chunkSize = CHUNK_SIZE_DEFAULT$1;\n    }\n\n    var _this$options2 = this.options;\n    _this$options2.id;\n\n    var options = _objectWithoutPropertiesLoose(_this$options2, _excluded2$1);\n\n    var result = [];\n    var size = 0;\n    var map = new Map();\n    this.keys.forEach(function (key) {\n      var value = _toConsumableArray(_this6.indices.get(key));\n\n      if (size + value.length <= chunkSize) {\n        size = size + value.length;\n        map.set(key, value);\n      } else {\n        while (value.length) {\n          map.set(key, value.splice(0, chunkSize - size));\n          result.push(SimpleIndice.deserialize(map, options));\n          size = 0;\n          map = new Map();\n        }\n      }\n    });\n\n    if (size != 0) {\n      result.push(SimpleIndice.deserialize(map, options));\n    }\n\n    return result;\n  };\n\n  _proto.findAll = /*#__PURE__*/function () {\n    var _findAll2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9(indices, value, _temp4) {\n      var _this7, _ref5, _ref5$operator, operator, _ref5$sort, sort, tokens, list, combineWeights;\n\n      return _regeneratorRuntime.wrap(function _callee9$(_context9) {\n        while (1) {\n          switch (_context9.prev = _context9.next) {\n            case 0:\n              _this7 = this;\n              _ref5 = _temp4 === void 0 ? {} : _temp4, _ref5$operator = _ref5.operator, operator = _ref5$operator === void 0 ? '$eq' : _ref5$operator, _ref5$sort = _ref5.sort, sort = _ref5$sort === void 0 ? 1 : _ref5$sort;\n              tokens = [];\n\n              if (value !== undefined) {\n                tokens = Array.isArray(value) ? value.flatMap(function (v) {\n                  return _this7.tokenizr(v);\n                }) : this.tokenizr(value);\n              }\n\n              _context9.next = 6;\n              return Promise.all(indices.map(function (indice) {\n                return indice.preFilter(tokens, {\n                  operator: operator,\n                  sort: sort\n                });\n              }));\n\n            case 6:\n              list = _context9.sent;\n              combineWeights = list.reduce(function (sum, weights) {\n                weights.forEach(function (value, key) {\n                  var count = sum.get(key) || 0;\n                  sum.set(key, count + value);\n                });\n                return sum;\n              }, new Map());\n              return _context9.abrupt(\"return\", this.postFilter(combineWeights, tokens));\n\n            case 9:\n            case \"end\":\n              return _context9.stop();\n          }\n        }\n      }, _callee9, this);\n    }));\n\n    function findAll(_x16, _x17, _x18) {\n      return _findAll2.apply(this, arguments);\n    }\n\n    return findAll;\n  }();\n\n  _proto.cursorAll = function cursorAll(indices, value, _temp5) {\n    var _this8 = this,\n        _ref7;\n\n    var _ref6 = _temp5 === void 0 ? {} : _temp5,\n        _ref6$operator = _ref6.operator,\n        operator = _ref6$operator === void 0 ? '$eq' : _ref6$operator,\n        _ref6$sort = _ref6.sort,\n        sort = _ref6$sort === void 0 ? 1 : _ref6$sort,\n        _ref6$chunkSize = _ref6.chunkSize,\n        chunkSize = _ref6$chunkSize === void 0 ? 20 : _ref6$chunkSize,\n        traceId = _ref6.traceId;\n\n    var tokens = [];\n\n    if (value !== undefined) {\n      tokens = Array.isArray(value) ? value.flatMap(function (v) {\n        return _this8.tokenizr(v);\n      }) : this.tokenizr(value);\n    }\n\n    instance.debug(\"[\" + traceId + \"]\", \"Cursor all simple indice value: \" + (value ? 'value' : '') + \" operator \" + operator + \", tokens:\", tokens);\n    var result = null;\n    var indiceIndex = 0;\n    var data = new Map();\n    return _ref7 = {}, _ref7[Symbol.asyncIterator] = function () {\n      return {\n        next: function () {\n          var _next2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {\n            var currentChunkSize, _value;\n\n            return _regeneratorRuntime.wrap(function _callee10$(_context10) {\n              while (1) {\n                switch (_context10.prev = _context10.next) {\n                  case 0:\n                    if (!(indiceIndex === 0 && !result && indiceIndex <= indices.length - 1)) {\n                      _context10.next = 6;\n                      break;\n                    }\n\n                    _context10.next = 3;\n                    return indices[indiceIndex].preFilter(tokens, {\n                      operator: operator,\n                      sort: sort\n                    });\n\n                  case 3:\n                    data = _context10.sent;\n                    result = _toConsumableArray(data.keys());\n                    result.reverse();\n\n                  case 6:\n                    if (!(!(result === null || result === void 0 ? void 0 : result.length) && indiceIndex < indices.length - 1)) {\n                      _context10.next = 15;\n                      break;\n                    }\n\n                    indiceIndex++;\n                    _context10.next = 10;\n                    return indices[indiceIndex].preFilter(tokens, {\n                      operator: operator,\n                      sort: sort\n                    });\n\n                  case 10:\n                    data = _context10.sent;\n                    result = _toConsumableArray(data.keys());\n                    result.reverse();\n                    _context10.next = 6;\n                    break;\n\n                  case 15:\n                    if (!(result && result.length)) {\n                      _context10.next = 21;\n                      break;\n                    }\n\n                    currentChunkSize = Math.min(chunkSize, result.length);\n                    _value = result.splice(-currentChunkSize, currentChunkSize);\n                    return _context10.abrupt(\"return\", {\n                      done: false,\n                      value: _value\n                    });\n\n                  case 21:\n                    return _context10.abrupt(\"return\", {\n                      done: true,\n                      value: undefined\n                    });\n\n                  case 22:\n                  case \"end\":\n                    return _context10.stop();\n                }\n              }\n            }, _callee10);\n          }));\n\n          function next() {\n            return _next2.apply(this, arguments);\n          }\n\n          return next;\n        }()\n      };\n    }, _ref7;\n  };\n\n  _createClass(SimpleIndice, [{\n    key: \"keys\",\n    get: function get() {\n      var keys = _toConsumableArray(this.indices.keys());\n\n      keys.sort(function (a, b) {\n        if (a === b) {\n          return 0;\n        }\n\n        return a < b ? -1 : 1;\n      });\n      return keys;\n    }\n  }, {\n    key: \"id\",\n    get: function get() {\n      return this.options.id;\n    }\n  }]);\n\n  return SimpleIndice;\n}();\n\nvar Range = /*#__PURE__*/function () {\n  function Range(left, right) {\n    this.left = left;\n    this.right = right;\n  }\n\n  Range.fromKeys = function fromKeys(indexes) {\n    var _indexes$reduce = indexes.reduce(function (sum, val) {\n      var left = sum.left === null ? val : sum.left;\n      var right = sum.right === null ? val : sum.right;\n      return {\n        left: left > val ? val : left,\n        right: right < val ? val : right\n      };\n    }, {\n      left: null,\n      right: null\n    }),\n        left = _indexes$reduce.left,\n        right = _indexes$reduce.right;\n\n    return new Range(left, right);\n  };\n\n  var _proto = Range.prototype;\n\n  _proto.has = function has(token) {\n    return token >= this.left && token <= this.right;\n  };\n\n  _proto.match = function match(token) {\n    var source;\n    var ignoreCase = false;\n\n    if (token instanceof RegExp) {\n      source = token.source;\n      ignoreCase = token.ignoreCase;\n    } else {\n      source = (\"\" + token).toString();\n    }\n\n    var match = source.match(/\\^([\\w\\d]+)/);\n\n    if (!match) {\n      return false;\n    }\n\n    var m = ignoreCase ? match[1].toLowerCase() : match[1];\n    var left = ignoreCase ? (\"\" + this.left).toLowerCase() : \"\" + this.left;\n    var right = ignoreCase ? (\"\" + this.right).toLowerCase() : \"\" + this.right;\n    var result = (m >= left || left.startsWith(m)) && (m <= right || right.startsWith(m));\n    return result;\n  };\n\n  _proto.lt = function lt(token) {\n    return token >= this.right || this.has(token);\n  };\n\n  _proto.gt = function gt(token) {\n    return token <= this.left || this.has(token);\n  };\n\n  _proto.test = function test(token, operator) {\n    switch (operator) {\n      case '$eq':\n      case '$in':\n        return this.has(token);\n\n      case '$nin':\n      case '$ne':\n        return true;\n\n      case '$lt':\n      case '$lte':\n        return this.lt(token);\n\n      case '$gt':\n      case '$gte':\n        return this.gt(token);\n\n      case '$regex':\n        return this.match(token);\n\n      default:\n        return this.has(token);\n    }\n  };\n\n  return Range;\n}();\n\nvar _excluded$1 = [\"load\"];\nvar DEFAULT_CHUNK_ZIZE = 2000;\nvar id_counter$1 = 1;\n\nvar RangeLinearIndice = /*#__PURE__*/function () {\n  function RangeLinearIndice(_ref) {\n    var indice = _ref.indice,\n        _ref$chunkSize = _ref.chunkSize,\n        chunkSize = _ref$chunkSize === void 0 ? DEFAULT_CHUNK_ZIZE : _ref$chunkSize,\n        _ref$id = _ref.id,\n        id = _ref$id === void 0 ? \"\" + id_counter$1++ : _ref$id,\n        _ref$isLoaded = _ref.isLoaded,\n        isLoaded = _ref$isLoaded === void 0 ? true : _ref$isLoaded,\n        load = _ref.load;\n    this.indices = new Map();\n\n    if (indice) {\n      this.indice = indice;\n      this.indices = new Map(indice.spread(chunkSize).map(function (indice) {\n        return [Range.fromKeys(indice.keys), indice];\n      }));\n    }\n\n    this.options = {\n      id: id,\n      isLoaded: isLoaded,\n      load: load\n    };\n  }\n\n  var _proto = RangeLinearIndice.prototype;\n\n  _proto.serialize = function serialize() {\n    return {\n      data: this.serializeData(),\n      options: this.serializeOptions()\n    };\n  };\n\n  _proto.serializeData = function serializeData() {\n    return _toConsumableArray(this.indices).map(function (_ref2, i) {\n      var filter = _ref2[0],\n          indice = _ref2[1];\n      return [[filter.left, filter.right], indice.id];\n    });\n  };\n\n  _proto.serializeOptions = function serializeOptions() {\n    var _a;\n\n    var _this$options = this.options;\n    _this$options.load;\n\n    var options = _objectWithoutPropertiesLoose(_this$options, _excluded$1);\n\n    return {\n      self: options,\n      spread: _objectSpread(_objectSpread({}, (_a = this.indice) === null || _a === void 0 ? void 0 : _a.serializeOptions()), {}, {\n        isLoaded: false\n      })\n    };\n  };\n\n  _proto.testIndice = function testIndice(key, value) {\n    if (key !== '$regex') {\n      return true;\n    }\n\n    var source;\n\n    if (value instanceof RegExp) {\n      source = value.source;\n    }\n\n    source = value.toString();\n    return !!source.match(/\\^[\\w\\d]+/);\n  };\n\n  RangeLinearIndice.deserialize = function deserialize(data, options, _deserialize) {\n    var indices = new Map(data.map(function (_ref3) {\n      var _ref3$ = _ref3[0],\n          left = _ref3$[0],\n          right = _ref3$[1],\n          id = _ref3[1];\n      return [new Range(left, right), _deserialize(_objectSpread(_objectSpread({}, options.spread), {}, {\n        id: id\n      }))];\n    }));\n    var indice = new RangeLinearIndice(_objectSpread({}, options.self));\n    indice.indices = indices;\n    indice.indice = _deserialize(_objectSpread({}, options.spread));\n    return indice;\n  };\n\n  RangeLinearIndice.lazy = function lazy(options, deserialize) {\n    var indice = new RangeLinearIndice(_objectSpread(_objectSpread({}, options), {}, {\n      isLoaded: false\n    }));\n    indice.indiceDeserialize = deserialize;\n    return indice;\n  };\n\n  _proto.filterIndicesByWeight = function filterIndicesByWeight(weight, tokens) {\n    return !!weight || !tokens.length;\n  };\n\n  _proto.load = /*#__PURE__*/function () {\n    var _load3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11() {\n      var _this, _await$this$options$l, data, options, indices;\n\n      return _regeneratorRuntime.wrap(function _callee11$(_context11) {\n        while (1) {\n          switch (_context11.prev = _context11.next) {\n            case 0:\n              _this = this;\n\n              if (!this.options.isLoaded) {\n                _context11.next = 5;\n                break;\n              }\n\n              return _context11.abrupt(\"return\");\n\n            case 5:\n              if (!this.options.load) {\n                _context11.next = 19;\n                break;\n              }\n\n              if (this.indiceDeserialize) {\n                _context11.next = 8;\n                break;\n              }\n\n              throw Error(\"deserialzed doesn't set\");\n\n            case 8:\n              _context11.next = 10;\n              return this.options.load(this.options);\n\n            case 10:\n              _await$this$options$l = _context11.sent;\n              data = _await$this$options$l.data;\n              options = _await$this$options$l.options;\n              indices = new Map(data.map(function (_ref4) {\n                var _ref4$ = _ref4[0],\n                    left = _ref4$[0],\n                    right = _ref4$[1],\n                    id = _ref4[1];\n                return [new Range(left, right), _this.indiceDeserialize(_objectSpread(_objectSpread({}, options.spread), {}, {\n                  id: id\n                }))];\n              }));\n              this.indices = indices;\n              this.indice = this.indiceDeserialize(_objectSpread({}, options.spread));\n              this.options.isLoaded = true;\n              _context11.next = 20;\n              break;\n\n            case 19:\n              throw Error(\"option load doesn't implemented\");\n\n            case 20:\n            case \"end\":\n              return _context11.stop();\n          }\n        }\n      }, _callee11, this);\n    }));\n\n    function load() {\n      return _load3.apply(this, arguments);\n    }\n\n    return load;\n  }();\n\n  _proto.find = /*#__PURE__*/function () {\n    var _find3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee12(value, _temp) {\n      var _this2, _ref5, _ref5$operator, operator, _ref5$sort, sort, indice, tokens, indices;\n\n      return _regeneratorRuntime.wrap(function _callee12$(_context12) {\n        while (1) {\n          switch (_context12.prev = _context12.next) {\n            case 0:\n              _this2 = this;\n              _ref5 = _temp === void 0 ? {} : _temp, _ref5$operator = _ref5.operator, operator = _ref5$operator === void 0 ? '$eq' : _ref5$operator, _ref5$sort = _ref5.sort, sort = _ref5$sort === void 0 ? 1 : _ref5$sort;\n              _context12.next = 4;\n              return this.load();\n\n            case 4:\n              indice = this.indice;\n\n              if (indice) {\n                _context12.next = 7;\n                break;\n              }\n\n              throw new Error(\"Spread indice doesn't initialized\");\n\n            case 7:\n              tokens = [];\n\n              if (value !== undefined) {\n                tokens = Array.isArray(value) ? value.flatMap(function (v) {\n                  return indice.tokenizr(v);\n                }) : indice.tokenizr(value);\n              }\n\n              indices = _toConsumableArray(this.indices).map(function (_ref6) {\n                var filter = _ref6[0],\n                    indice = _ref6[1];\n                var weight = tokens.reduce(function (w, token) {\n                  return filter.test(token, operator) ? 1 + w : w;\n                }, 0);\n                return [weight, indice];\n              }).filter(function (_ref7) {\n                var weight = _ref7[0];\n                return _this2.filterIndicesByWeight(weight, tokens);\n              }).map(function (_ref8) {\n                _ref8[0];\n                var indice = _ref8[1];\n                return indice;\n              });\n\n              if (sort === -1) {\n                indices.reverse();\n              }\n\n              return _context12.abrupt(\"return\", indice.findAll(indices, value, {\n                operator: operator,\n                sort: sort\n              }));\n\n            case 12:\n            case \"end\":\n              return _context12.stop();\n          }\n        }\n      }, _callee12, this);\n    }));\n\n    function find(_x19, _x20) {\n      return _find3.apply(this, arguments);\n    }\n\n    return find;\n  }();\n\n  _proto.cursor = function cursor(value, _temp2) {\n    var _this3 = this,\n        _ref13;\n\n    var _ref9 = _temp2 === void 0 ? {} : _temp2,\n        _ref9$operator = _ref9.operator,\n        operator = _ref9$operator === void 0 ? '$eq' : _ref9$operator,\n        _ref9$sort = _ref9.sort,\n        sort = _ref9$sort === void 0 ? 1 : _ref9$sort,\n        traceId = _ref9.traceId;\n\n    var load$ = this.load();\n    load$.then(function () {\n      instance.debug(\"[\" + traceId + \"]\", 'Loaded range indice id:', _this3.id);\n    });\n    var cursor;\n    var iterator;\n    var isFound = false;\n\n    var find = /*#__PURE__*/function () {\n      var _find4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee13() {\n        var indice, indices, tokens, filteredIndices;\n        return _regeneratorRuntime.wrap(function _callee13$(_context13) {\n          while (1) {\n            switch (_context13.prev = _context13.next) {\n              case 0:\n                indice = _this3.indice, indices = _this3.indices;\n\n                if (!isFound) {\n                  _context13.next = 3;\n                  break;\n                }\n\n                return _context13.abrupt(\"return\");\n\n              case 3:\n                instance.debug(\"[\" + traceId + \"]\", 'Start searching by range indice id:', _this3.id);\n\n                if (indice) {\n                  _context13.next = 6;\n                  break;\n                }\n\n                throw new Error(\"Spread indice doesn't initialized\");\n\n              case 6:\n                tokens = [];\n\n                if (value !== undefined) {\n                  tokens = Array.isArray(value) ? value.flatMap(function (v) {\n                    return indice.tokenizr(v);\n                  }) : indice.tokenizr(value);\n                }\n\n                filteredIndices = _toConsumableArray(indices).map(function (_ref10) {\n                  var filter = _ref10[0],\n                      indice = _ref10[1];\n                  var weight = tokens.reduce(function (w, token) {\n                    return filter.test(token, operator) ? 1 + w : w;\n                  }, 0);\n\n                  if (weight) {\n                    instance.debug(\"[\" + traceId + \"]\", \"Select to use chunk range indice id: '\" + _this3.options.id + \": \" + indice.id + \"' range: [\" + filter.left + \", \" + filter.right + \"]\");\n                  }\n\n                  return [weight, indice];\n                }).filter(function (_ref11) {\n                  var weight = _ref11[0];\n                  return _this3.filterIndicesByWeight(weight, tokens);\n                }).map(function (_ref12) {\n                  _ref12[0];\n                  var indice = _ref12[1];\n                  return indice;\n                });\n\n                if (sort === -1) {\n                  filteredIndices.reverse();\n                }\n\n                instance.debug(\"[\" + traceId + \"]\", 'Finish searching by range indice id:', _this3.id);\n                cursor = indice.cursorAll(filteredIndices, value, {\n                  operator: operator,\n                  sort: sort,\n                  traceId: traceId\n                });\n                isFound = true;\n                iterator = cursor[Symbol.asyncIterator]();\n\n              case 14:\n              case \"end\":\n                return _context13.stop();\n            }\n          }\n        }, _callee13);\n      }));\n\n      function find() {\n        return _find4.apply(this, arguments);\n      }\n\n      return find;\n    }();\n\n    return _ref13 = {}, _ref13[Symbol.asyncIterator] = function () {\n      return {\n        next: function () {\n          var _next3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee14() {\n            return _regeneratorRuntime.wrap(function _callee14$(_context14) {\n              while (1) {\n                switch (_context14.prev = _context14.next) {\n                  case 0:\n                    _context14.next = 2;\n                    return load$;\n\n                  case 2:\n                    _context14.next = 4;\n                    return find();\n\n                  case 4:\n                    _context14.next = 6;\n                    return iterator.next();\n\n                  case 6:\n                    return _context14.abrupt(\"return\", _context14.sent);\n\n                  case 7:\n                  case \"end\":\n                    return _context14.stop();\n                }\n              }\n            }, _callee14);\n          }));\n\n          function next() {\n            return _next3.apply(this, arguments);\n          }\n\n          return next;\n        }()\n      };\n    }, _ref13;\n  };\n\n  _createClass(RangeLinearIndice, [{\n    key: \"id\",\n    get: function get() {\n      return this.options.id;\n    }\n  }]);\n\n  return RangeLinearIndice;\n}();\n\nvar _excluded = [\"load\", \"stopWords\"],\n    _excluded2 = [\"id\"];\nvar CHUNK_SIZE_DEFAULT = 100;\nvar id_counter = 1;\n\nvar TextLexIndice = /*#__PURE__*/function () {\n  function TextLexIndice(_temp) {\n    var _ref = _temp === void 0 ? {} : _temp,\n        _ref$id = _ref.id,\n        id = _ref$id === void 0 ? \"\" + id_counter++ : _ref$id,\n        _ref$isLoaded = _ref.isLoaded,\n        isLoaded = _ref$isLoaded === void 0 ? true : _ref$isLoaded,\n        _ref$algoritm = _ref.algoritm,\n        algoritm = _ref$algoritm === void 0 ? 'english' : _ref$algoritm,\n        load = _ref.load;\n\n    this.indices = new Map();\n    this.options = {\n      isLoaded: isLoaded,\n      algoritm: algoritm,\n      id: id,\n      load: load\n    };\n    this.stemmer = newStemmer(algoritm);\n    return this;\n  }\n\n  var _proto = TextLexIndice.prototype;\n\n  _proto.add = function add(key, value) {\n    var _this = this;\n\n    var tokens = [];\n\n    if (Array.isArray(value)) {\n      value.forEach(function (v) {\n        return tokens.push.apply(tokens, _toConsumableArray(_this.tokenizr(v)));\n      });\n    } else {\n      tokens.push.apply(tokens, _toConsumableArray(this.tokenizr(value)));\n    }\n\n    tokens.forEach(function (token) {\n      var indice = _this.indices.get(token) || [];\n      indice.push(key);\n\n      _this.indices.set(token, indice);\n    });\n  };\n\n  _proto.serializeOptions = function serializeOptions() {\n    var _this$options = this.options;\n    _this$options.load;\n\n    var stopWords = _this$options.stopWords,\n        options = _objectWithoutPropertiesLoose(_this$options, _excluded);\n\n    if (stopWords) {\n      options.stopWords = _toConsumableArray(stopWords);\n    }\n\n    return options;\n  };\n\n  _proto.serializeData = function serializeData() {\n    return _toConsumableArray(this.indices);\n  };\n\n  _proto.tokenizr = function tokenizr(value) {\n    var _this2 = this;\n\n    return value.toLowerCase().split(/[ \\,\\.]/) // eslint-disable-line no-useless-escape\n    .filter(function (v) {\n      return !_this2.options.stopWords || !_this2.options.stopWords.has(v);\n    }).map(function (v) {\n      return _this2.stemmer.stem(v);\n    });\n  };\n\n  _proto.load = /*#__PURE__*/function () {\n    var _load4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee15() {\n      var _await$this$options$l, data;\n\n      return _regeneratorRuntime.wrap(function _callee15$(_context15) {\n        while (1) {\n          switch (_context15.prev = _context15.next) {\n            case 0:\n              if (!this.options.isLoaded) {\n                _context15.next = 4;\n                break;\n              }\n\n              return _context15.abrupt(\"return\");\n\n            case 4:\n              if (!this.options.load) {\n                _context15.next = 13;\n                break;\n              }\n\n              _context15.next = 7;\n              return this.options.load(this.options);\n\n            case 7:\n              _await$this$options$l = _context15.sent;\n              data = _await$this$options$l.data;\n              this.indices = new Map(data);\n              this.options.isLoaded = true;\n              _context15.next = 14;\n              break;\n\n            case 13:\n              throw Error(\"option load doesn't implemented\");\n\n            case 14:\n            case \"end\":\n              return _context15.stop();\n          }\n        }\n      }, _callee15, this);\n    }));\n\n    function load() {\n      return _load4.apply(this, arguments);\n    }\n\n    return load;\n  }();\n\n  _proto.getIndices = function getIndices(tokens) {\n    var _this3 = this;\n\n    return tokens.reduce(function (sum, token) {\n      var r = _this3.indices.get(token);\n\n      if (r) {\n        sum.push.apply(sum, _toConsumableArray(r));\n      }\n\n      return sum;\n    }, []);\n  } // eslint-disable-next-line no-empty-pattern\n  ;\n\n  _proto.preFilter = /*#__PURE__*/function () {\n    var _preFilter3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee16(tokens, _temp2) {\n      var _ref2, countResults, indices, v;\n\n      return _regeneratorRuntime.wrap(function _callee16$(_context16) {\n        while (1) {\n          switch (_context16.prev = _context16.next) {\n            case 0:\n              _ref2 = _temp2 === void 0 ? {} : _temp2;\n\n              _objectDestructuringEmpty(_ref2);\n\n              countResults = new Map();\n              _context16.next = 5;\n              return this.load();\n\n            case 5:\n              indices = this.getIndices(tokens);\n\n              if (indices) {\n                indices.forEach(function (id) {\n                  var count = countResults.get(id) || 0;\n                  countResults.set(id, count + 1);\n                });\n              }\n\n              if (tokens.length) {\n                _context16.next = 10;\n                break;\n              }\n\n              v = _toConsumableArray(this.indices.values());\n              return _context16.abrupt(\"return\", new Map(v.flatMap(function (indice) {\n                return indice;\n              }).map(function (indice) {\n                return [indice, 1];\n              })));\n\n            case 10:\n              return _context16.abrupt(\"return\", countResults);\n\n            case 11:\n            case \"end\":\n              return _context16.stop();\n          }\n        }\n      }, _callee16, this);\n    }));\n\n    function preFilter(_x21, _x22) {\n      return _preFilter3.apply(this, arguments);\n    }\n\n    return preFilter;\n  }();\n\n  _proto.find = /*#__PURE__*/function () {\n    var _find5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee17(value, _temp3) {\n      var _this4, _ref3, _ref3$operator, operator, _ref3$sort, sort, tokens, preResult;\n\n      return _regeneratorRuntime.wrap(function _callee17$(_context17) {\n        while (1) {\n          switch (_context17.prev = _context17.next) {\n            case 0:\n              _this4 = this;\n              _ref3 = _temp3 === void 0 ? {} : _temp3, _ref3$operator = _ref3.operator, operator = _ref3$operator === void 0 ? '$eq' : _ref3$operator, _ref3$sort = _ref3.sort, sort = _ref3$sort === void 0 ? 1 : _ref3$sort;\n              tokens = [];\n\n              if (value !== undefined) {\n                tokens = Array.isArray(value) ? value.flatMap(function (v) {\n                  return _this4.tokenizr(v);\n                }) : this.tokenizr(value);\n              }\n\n              _context17.next = 6;\n              return this.preFilter(tokens, {\n                operator: operator,\n                sort: sort\n              });\n\n            case 6:\n              preResult = _context17.sent;\n              return _context17.abrupt(\"return\", this.postFilter(preResult));\n\n            case 8:\n            case \"end\":\n              return _context17.stop();\n          }\n        }\n      }, _callee17, this);\n    }));\n\n    function find(_x23, _x24) {\n      return _find5.apply(this, arguments);\n    }\n\n    return find;\n  }();\n\n  _proto.postFilter = function postFilter(countResults) {\n    var results = _toConsumableArray(countResults.entries()).map(function (_ref4) {\n      var id = _ref4[0];\n      return id;\n    });\n\n    return results;\n  };\n\n  _proto.serialize = function serialize() {\n    return {\n      data: this.serializeData(),\n      options: this.serializeOptions()\n    };\n  };\n\n  TextLexIndice.deserialize = function deserialize(data, options) {\n    if (!options) {\n      options = data;\n      data = null;\n    }\n\n    if (options && options.stopWords) {\n      options.stopWords = new Set(options.stopWords);\n    }\n\n    var index = new TextLexIndice(options);\n\n    if (data) {\n      index.indices = data;\n    }\n\n    return index;\n  };\n\n  _proto.spread = function spread(chunkSize) {\n    var _this5 = this;\n\n    if (chunkSize === void 0) {\n      chunkSize = CHUNK_SIZE_DEFAULT;\n    }\n\n    var _this$options2 = this.options;\n    _this$options2.id;\n\n    var options = _objectWithoutPropertiesLoose(_this$options2, _excluded2);\n\n    var result = [];\n    var size = 0;\n    var map = new Map();\n    this.keys.forEach(function (key) {\n      var value = _toConsumableArray(_this5.indices.get(key));\n\n      if (size + value.length <= chunkSize) {\n        size = size + value.length;\n        map.set(key, value);\n      } else {\n        while (value.length) {\n          map.set(key, value.splice(0, chunkSize - size));\n          result.push(TextLexIndice.deserialize(map, options));\n          size = 0;\n          map = new Map();\n        }\n      }\n    });\n\n    if (size != 0) {\n      result.push(TextLexIndice.deserialize(map, options));\n    }\n\n    return result;\n  };\n\n  _proto.findAll = /*#__PURE__*/function () {\n    var _findAll3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee18(indices, value, _temp4) {\n      var _this6, _ref5, _ref5$operator, operator, _ref5$sort, sort, tokens, list, combineWeights;\n\n      return _regeneratorRuntime.wrap(function _callee18$(_context18) {\n        while (1) {\n          switch (_context18.prev = _context18.next) {\n            case 0:\n              _this6 = this;\n              _ref5 = _temp4 === void 0 ? {} : _temp4, _ref5$operator = _ref5.operator, operator = _ref5$operator === void 0 ? '$eq' : _ref5$operator, _ref5$sort = _ref5.sort, sort = _ref5$sort === void 0 ? 1 : _ref5$sort;\n              tokens = [];\n\n              if (value !== undefined) {\n                tokens = Array.isArray(value) ? value.flatMap(function (v) {\n                  return _this6.tokenizr(v);\n                }) : this.tokenizr(value);\n              }\n\n              _context18.next = 6;\n              return Promise.all(indices.map(function (indice) {\n                return indice.preFilter(tokens, {\n                  operator: operator,\n                  sort: sort\n                });\n              }));\n\n            case 6:\n              list = _context18.sent;\n              combineWeights = list.reduce(function (sum, weights) {\n                weights.forEach(function (value, key) {\n                  var count = sum.get(key) || 0;\n                  sum.set(key, count + value);\n                });\n                return sum;\n              }, new Map());\n              return _context18.abrupt(\"return\", this.postFilter(combineWeights));\n\n            case 9:\n            case \"end\":\n              return _context18.stop();\n          }\n        }\n      }, _callee18, this);\n    }));\n\n    function findAll(_x25, _x26, _x27) {\n      return _findAll3.apply(this, arguments);\n    }\n\n    return findAll;\n  }();\n\n  _proto.cursorAll = function cursorAll(indices, value, _temp5) {\n    var _this7 = this,\n        _ref7;\n\n    var _ref6 = _temp5 === void 0 ? {} : _temp5,\n        _ref6$operator = _ref6.operator,\n        operator = _ref6$operator === void 0 ? '$eq' : _ref6$operator,\n        _ref6$sort = _ref6.sort,\n        sort = _ref6$sort === void 0 ? 1 : _ref6$sort,\n        _ref6$chunkSize = _ref6.chunkSize,\n        chunkSize = _ref6$chunkSize === void 0 ? 20 : _ref6$chunkSize,\n        traceId = _ref6.traceId;\n\n    var tokens = [];\n\n    if (value !== undefined) {\n      tokens = Array.isArray(value) ? value.flatMap(function (v) {\n        return _this7.tokenizr(v);\n      }) : this.tokenizr(value);\n    }\n\n    instance.debug(\"[\" + traceId + \"]\", \"Cursor all simple indice id: \" + this.options.id + \" value: \" + value + \" operator \" + operator + \", tokens:\", tokens);\n    var result = null;\n    var indiceIndex = 0;\n    var data = new Map();\n    return _ref7 = {}, _ref7[Symbol.asyncIterator] = function () {\n      return {\n        next: function () {\n          var _next4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee19() {\n            var currentChunkSize, _value;\n\n            return _regeneratorRuntime.wrap(function _callee19$(_context19) {\n              while (1) {\n                switch (_context19.prev = _context19.next) {\n                  case 0:\n                    if (!(indiceIndex === 0 && !result && indiceIndex <= indices.length - 1)) {\n                      _context19.next = 6;\n                      break;\n                    }\n\n                    _context19.next = 3;\n                    return indices[indiceIndex].preFilter(tokens, {\n                      operator: operator,\n                      sort: sort\n                    });\n\n                  case 3:\n                    data = _context19.sent;\n                    result = _toConsumableArray(data.keys());\n                    result.reverse();\n\n                  case 6:\n                    if (!(!(result === null || result === void 0 ? void 0 : result.length) && indiceIndex < indices.length - 1)) {\n                      _context19.next = 15;\n                      break;\n                    }\n\n                    indiceIndex++;\n                    _context19.next = 10;\n                    return indices[indiceIndex].preFilter(tokens, {\n                      operator: operator,\n                      sort: sort\n                    });\n\n                  case 10:\n                    data = _context19.sent;\n                    result = _toConsumableArray(data.keys());\n                    result.reverse();\n                    _context19.next = 6;\n                    break;\n\n                  case 15:\n                    if (!(result && result.length)) {\n                      _context19.next = 21;\n                      break;\n                    }\n\n                    currentChunkSize = Math.min(chunkSize, result.length);\n                    _value = result.splice(-currentChunkSize, currentChunkSize);\n                    return _context19.abrupt(\"return\", {\n                      done: false,\n                      value: _value\n                    });\n\n                  case 21:\n                    return _context19.abrupt(\"return\", {\n                      done: true,\n                      value: undefined\n                    });\n\n                  case 22:\n                  case \"end\":\n                    return _context19.stop();\n                }\n              }\n            }, _callee19);\n          }));\n\n          function next() {\n            return _next4.apply(this, arguments);\n          }\n\n          return next;\n        }()\n      };\n    }, _ref7;\n  };\n\n  _createClass(TextLexIndice, [{\n    key: \"keys\",\n    get: function get() {\n      var keys = _toConsumableArray(this.indices.keys());\n\n      keys.sort(function (a, b) {\n        if (a === b) {\n          return 0;\n        }\n\n        return a < b ? -1 : 1;\n      });\n      return keys;\n    }\n  }, {\n    key: \"id\",\n    get: function get() {\n      return this.options.id;\n    }\n  }]);\n\n  return TextLexIndice;\n}();\n\nfunction getNext(asyncIterator, index) {\n  return asyncIterator.next().then(function (result) {\n    return {\n      index: index,\n      result: result\n    };\n  });\n}\n\nvar never = new Promise(function () {// do nothing\n});\nvar traceIteratorId = 1;\n\nfunction combineAsyncIterable(_x, _x2) {\n  return _combineAsyncIterable.apply(this, arguments);\n}\n\nfunction _combineAsyncIterable() {\n  _combineAsyncIterable = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee20(iterable, traceId) {\n    var asyncIterators, currentTraceIteratorId, results, count, nextPromises, _yield$_awaitAsyncGen, index, result, _iterator, _step, _step$value, _index, iterator;\n\n    return _regeneratorRuntime.wrap(function _callee20$(_context20) {\n      while (1) {\n        switch (_context20.prev = _context20.next) {\n          case 0:\n            asyncIterators = Array.from(iterable, function (o) {\n              return o[Symbol.asyncIterator]();\n            });\n            currentTraceIteratorId = traceIteratorId++;\n            results = [];\n            count = asyncIterators.length;\n            nextPromises = asyncIterators.map(getNext);\n            _context20.prev = 5;\n\n          case 6:\n            if (!count) {\n              _context20.next = 24;\n              break;\n            }\n\n            _context20.next = 9;\n            return _awaitAsyncGenerator(Promise.race(nextPromises));\n\n          case 9:\n            _yield$_awaitAsyncGen = _context20.sent;\n            index = _yield$_awaitAsyncGen.index;\n            result = _yield$_awaitAsyncGen.result;\n\n            if (!result.done) {\n              _context20.next = 18;\n              break;\n            }\n\n            nextPromises[index] = never;\n            results[index] = result.value;\n            count--;\n            _context20.next = 22;\n            break;\n\n          case 18:\n            nextPromises[index] = getNext(asyncIterators[index], index);\n\n            if (asyncIterators.length > 1) {\n              instance.debug(\"[\" + traceId + \"][\" + currentTraceIteratorId + \"]\", \"Result combined indices:\", result.value);\n            }\n\n            _context20.next = 22;\n            return result.value;\n\n          case 22:\n            _context20.next = 6;\n            break;\n\n          case 24:\n            _context20.prev = 24;\n\n            for (_iterator = _createForOfIteratorHelperLoose(asyncIterators.entries()); !(_step = _iterator()).done;) {\n              _step$value = _step.value, _index = _step$value[0], iterator = _step$value[1];\n              if (nextPromises[_index] != never && iterator.return != null) iterator.return();\n            } // no await here - see https://github.com/tc39/proposal-async-iteration/issues/126\n\n\n            return _context20.finish(24);\n\n          case 27:\n            return _context20.abrupt(\"return\", results);\n\n          case 28:\n          case \"end\":\n            return _context20.stop();\n        }\n      }\n    }, _callee20, null, [[5,, 24, 27]]);\n  }));\n  return _combineAsyncIterable.apply(this, arguments);\n}\n\nfunction intersectAsyncIterable(_x3, _x4) {\n  return _intersectAsyncIterable.apply(this, arguments);\n}\n\nfunction _intersectAsyncIterable() {\n  _intersectAsyncIterable = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee21(iterable, traceId) {\n    var currentTraceIteratorId, asyncIterators, results, count, combineResults, nextPromises, _yield$_awaitAsyncGen2, index, result, combineResult, subResults, _loop, _iterator2, _step2, _iterator3, _step3, _step3$value, _index2, iterator;\n\n    return _regeneratorRuntime.wrap(function _callee21$(_context21) {\n      while (1) {\n        switch (_context21.prev = _context21.next) {\n          case 0:\n            currentTraceIteratorId = traceIteratorId++;\n            asyncIterators = Array.from(iterable, function (o) {\n              return o[Symbol.asyncIterator]();\n            });\n            results = [];\n            count = asyncIterators.length;\n            combineResults = new Map(new Array(count).fill(undefined).map(function (_, i) {\n              return [i, new Set()];\n            }));\n            nextPromises = asyncIterators.map(getNext);\n            _context21.prev = 6;\n\n          case 7:\n            if (!count) {\n              _context21.next = 30;\n              break;\n            }\n\n            _context21.next = 10;\n            return _awaitAsyncGenerator(Promise.race(nextPromises));\n\n          case 10:\n            _yield$_awaitAsyncGen2 = _context21.sent;\n            index = _yield$_awaitAsyncGen2.index;\n            result = _yield$_awaitAsyncGen2.result;\n\n            if (!result.done) {\n              _context21.next = 19;\n              break;\n            }\n\n            nextPromises[index] = never;\n            results[index] = result.value; //what's return is question\n\n            count--;\n            _context21.next = 28;\n            break;\n\n          case 19:\n            combineResult = combineResults.get(index);\n            nextPromises[index] = getNext(asyncIterators[index], index);\n            subResults = [];\n\n            _loop = function _loop() {\n              var v = _step2.value;\n\n              if (combineResult) {\n                combineResult.add(v);\n              }\n\n              if (iterable.length === 1) {\n                subResults.push(v);\n              } else if (_toConsumableArray(combineResults.values()).every(function (c) {\n                return c.has(v);\n              })) {\n                _toConsumableArray(combineResults.values()).forEach(function (c) {\n                  return c.delete(v);\n                });\n\n                subResults.push(v);\n              }\n            };\n\n            for (_iterator2 = _createForOfIteratorHelperLoose(result.value); !(_step2 = _iterator2()).done;) {\n              _loop();\n            }\n\n            if (!subResults.length) {\n              _context21.next = 28;\n              break;\n            }\n\n            if (asyncIterators.length > 1) {\n              instance.debug(\"[\" + traceId + \"][\" + currentTraceIteratorId + \"]\", \"Result intersect indices:\", subResults);\n            }\n\n            _context21.next = 28;\n            return subResults;\n\n          case 28:\n            _context21.next = 7;\n            break;\n\n          case 30:\n            _context21.prev = 30;\n\n            for (_iterator3 = _createForOfIteratorHelperLoose(asyncIterators.entries()); !(_step3 = _iterator3()).done;) {\n              _step3$value = _step3.value, _index2 = _step3$value[0], iterator = _step3$value[1];\n              if (nextPromises[_index2] != never && iterator.return != null) iterator.return();\n            } // no await here - see https://github.com/tc39/proposal-async-iteration/issues/126\n\n\n            return _context21.finish(30);\n\n          case 33:\n            return _context21.abrupt(\"return\", results);\n\n          case 34:\n          case \"end\":\n            return _context21.stop();\n        }\n      }\n    }, _callee21, null, [[6,, 30, 33]]);\n  }));\n  return _intersectAsyncIterable.apply(this, arguments);\n}\n\nvar comparableOperators = new Set(['$eq', '$gt', '$gte', '$in', '$lt', '$lte', '$ne', '$nin', '$regex']);\nvar logicalOperators = new Set(['$and', '$or']);\n\nfunction PoisonPillow() {// hello tslint\n}\n\nvar reqId = 1;\n\nvar Db = /*#__PURE__*/function () {\n  function Db(schema) {\n    this.customOperators = new Set([]);\n    this.schema = schema;\n    var operators = this.schema.indices.map(function (_ref) {\n      var path = _ref.path;\n      return path;\n    }).filter(function (path) {\n      return path && path.startsWith('$');\n    }).filter(function (path) {\n      return !comparableOperators.has(path);\n    }).filter(function (path) {\n      return !logicalOperators.has(path);\n    });\n    this.customOperators = new Set(operators);\n  }\n\n  var _proto = Db.prototype;\n\n  _proto.buildIndexSearch = function buildIndexSearch(criteria, sort, skip, limit, context) {\n    var _this = this;\n\n    var _ref2 = context || {},\n        _ref2$isRoot = _ref2.isRoot,\n        isRoot = _ref2$isRoot === void 0 ? true : _ref2$isRoot,\n        _ref2$caches = _ref2.caches,\n        caches = _ref2$caches === void 0 ? new Map() : _ref2$caches,\n        traceId = _ref2.traceId;\n\n    var indices = new Map();\n    var sortIndices = new Map();\n    var subIterables = [];\n\n    if (isRoot) {\n      instance.debug(\"[\" + traceId + \"]\", 'Start building query plan', 'criteria:', criteria, 'sort:', sort || {});\n    } else if (context === null || context === void 0 ? void 0 : context.path) {\n      instance.debug(\"[\" + traceId + \"]\", \"Build nested query path: '\" + (context === null || context === void 0 ? void 0 : context.path) + \"', criteria:\", criteria);\n    } else {\n      instance.debug(\"[\" + traceId + \"]\", \"Build nested query, criteria:\", criteria);\n    }\n\n    var greed = false;\n\n    if (sort) {\n      greed = true;\n\n      if (isRoot) {\n        instance.debug(\"[\" + traceId + \"]\", 'Find sorting', sort);\n      }\n\n      var _loop = function _loop() {\n        var _Object$entries$_i = _Object$entries[_i],\n            key = _Object$entries$_i[0],\n            order = _Object$entries$_i[1];\n\n        var indice = _this.schema.indices.find(function (o) {\n          return o.path === key;\n        });\n\n        if (indice) {\n          sortIndices.set(indice.indice, _objectSpread(_objectSpread({}, indice), {}, {\n            order: order\n          }));\n          greed = false;\n        } else if (isRoot) {\n          instance.warn(\"[\" + traceId + \"]\", 'Find missed index sorting, is slow for big collections', sort);\n        }\n      };\n\n      for (var _i = 0, _Object$entries = Object.entries(sort); _i < _Object$entries.length; _i++) {\n        _loop();\n      }\n    }\n\n    var _loop2 = function _loop2() {\n      var _Object$entries2$_i = _Object$entries2[_i2],\n          key = _Object$entries2$_i[0],\n          value = _Object$entries2$_i[1];\n\n      if (logicalOperators.has(key) && isArray$2(value)) {\n        instance.debug(\"[\" + traceId + \"]\", \"Build nested query join by operator: \" + key);\n        var subIt = value.map(function (subCriteria) {\n          return _this.buildIndexSearch(subCriteria, sort, skip, limit, {\n            indices: indices,\n            isRoot: false,\n            caches: caches,\n            traceId: traceId\n          });\n        });\n        var isAnd = key === '$and';\n        var result = subIt.map(function (it) {\n          return it();\n        });\n\n        var _greed = isAnd ? result.every(function (_ref3) {\n          var greed = _ref3.greed;\n          return greed;\n        }) : result.some(function (_ref4) {\n          var greed = _ref4.greed;\n          return greed;\n        });\n\n        var missed = isAnd ? result.every(function (_ref5) {\n          var missed = _ref5.missed;\n          return missed;\n        }) : result.some(function (_ref6) {\n          var missed = _ref6.missed;\n          return missed;\n        });\n        var results = result.map(function (_ref7) {\n          var result = _ref7.result;\n          return result;\n        });\n        var paths = new Set(_toConsumableArray(result.reduce(function (sum, _ref8) {\n          var paths = _ref8.paths;\n          paths.forEach(function (path) {\n            sum.set(path, (sum.get(path) || 0) + 1);\n          });\n          return sum;\n        }, new Map()).entries()).filter(function (_ref9) {\n          var count = _ref9[1];\n          return isAnd || count === result.length;\n        }).map(function (_ref10) {\n          var path = _ref10[0];\n          return path;\n        }));\n        var sIs = isAnd ? intersectAsyncIterable(results, traceId) : combineAsyncIterable(results, traceId);\n        subIterables.push(function () {\n          return {\n            caches: caches,\n            result: sIs,\n            greed: _greed,\n            missed: missed,\n            paths: paths\n          };\n        });\n      } else if (_this.customOperators.has(key)) {\n        instance.debug(\"[\" + traceId + \"]\", \"Build query with custom operator: {\" + key + \": \" + value + \"}\");\n\n        var fullTextIndice = _this.schema.indices.filter(function (i) {\n          return i.path === key;\n        }).pop();\n\n        if (fullTextIndice) {\n          instance.debug(\"[\" + traceId + \"]\", 'Select to use custom indice', \"path: \" + fullTextIndice.path);\n          indices.set(fullTextIndice.indice, _objectSpread(_objectSpread({}, fullTextIndice), {}, {\n            value: value\n          }));\n        }\n\n        delete criteria[key];\n      } else if (isOperator(key)) {\n        var indiceOptions = _this.schema.indices.find(function (o) {\n          return _this.testIndice(o, key, value, context === null || context === void 0 ? void 0 : context.path);\n        });\n\n        if (indiceOptions) {\n          var exists = sortIndices.get(indiceOptions.indice);\n\n          if (!exists) {\n            instance.debug(\"[\" + traceId + \"]\", 'Select to use indice', \"path: \" + indiceOptions.path);\n          } else {\n            instance.debug(\"[\" + traceId + \"]\", 'Select to use sorting indice', \"path: \" + indiceOptions.path + \", predicate: \" + key + \", order: \" + exists.order + \", value: \", value);\n          }\n\n          indices.set(indiceOptions.indice, _objectSpread(_objectSpread(_objectSpread({}, exists || {}), indiceOptions), {}, {\n            value: value,\n            op: key\n          }));\n        }\n      } else if (isObject$1(value)) {\n        subIterables.push(_this.buildIndexSearch(value, sort, skip, limit, {\n          path: key,\n          indices: indices,\n          isRoot: false,\n          caches: caches,\n          traceId: traceId\n        }));\n      } else {\n        var _indiceOptions = _this.schema.indices.find(function (o) {\n          return o.path === key;\n        });\n\n        if (_indiceOptions) {\n          var _exists = sortIndices.get(_indiceOptions.indice) || {};\n\n          indices.set(_indiceOptions.indice, _objectSpread(_objectSpread(_objectSpread({}, _exists), _indiceOptions), {}, {\n            value: value,\n            op: '$eq'\n          }));\n        }\n      }\n    };\n\n    for (var _i2 = 0, _Object$entries2 = Object.entries(criteria); _i2 < _Object$entries2.length; _i2++) {\n      _loop2();\n    }\n\n    return function () {\n      var values = _toConsumableArray(indices.values());\n\n      var simpleIterable = values.map(function (_ref11) {\n        var indice = _ref11.indice,\n            value = _ref11.value,\n            order = _ref11.order,\n            op = _ref11.op;\n        return _this.indiceCursor(indice, value, caches, {\n          sort: order,\n          operator: op,\n          chunkSize: (limit || 0) + (skip || 0),\n          traceId: traceId\n        });\n      });\n      var subResult = subIterables.map(function (it) {\n        return it();\n      });\n      var subGreed = subResult.every(function (_ref12) {\n        var greed = _ref12.greed;\n        return greed;\n      });\n      var missed = subResult.every(function (_ref13) {\n        var missed = _ref13.missed;\n        return missed;\n      });\n      var subIterable = subResult.map(function (_ref14) {\n        var result = _ref14.result;\n        return result;\n      });\n      var subPaths = subResult.reduce(function (sum, _ref15) {\n        var paths = _ref15.paths;\n        paths.forEach(function (path) {\n          return sum.add(path);\n        });\n        return sum;\n      }, new Set());\n      var paths = new Set([].concat(_toConsumableArray(values.map(function (_ref16) {\n        var path = _ref16.path;\n        return path;\n      })), _toConsumableArray(subPaths)));\n\n      var onlySortIndices = _toConsumableArray(sortIndices.values()).filter(function (_ref17) {\n        var path = _ref17.path;\n        return !paths.has(path) && isRoot;\n      });\n\n      var sortedIterable = onlySortIndices.map(function (_ref18) {\n        var indice = _ref18.indice,\n            value = _ref18.value,\n            order = _ref18.order,\n            op = _ref18.op;\n        return _this.indiceCursor(indice, value, caches, {\n          sort: order,\n          traceId: traceId,\n          operator: op,\n          chunkSize: (limit || 0) + (skip || 0)\n        });\n      });\n      var missedAll = !sortedIterable.length && !indices.size && missed;\n      var greedAll = greed && subGreed;\n\n      if (isRoot) {\n        onlySortIndices.forEach(function (indiceOptions) {\n          instance.debug(\"[\" + traceId + \"]\", 'Select to use sorting indice', \"path: \" + indiceOptions.path + \", order: \" + indiceOptions.order);\n        });\n        instance.debug(\"[\" + traceId + \"]\", 'Finish building query plan.', \"Search will be \" + (greedAll ? 'full scan' : 'used indices'), (missedAll ? 'by primary indice' : 'by secondary indices') + \".\");\n      }\n\n      return {\n        result: intersectAsyncIterable([].concat(_toConsumableArray(simpleIterable), _toConsumableArray(sortedIterable), _toConsumableArray(subIterable)), traceId),\n        greed: greedAll,\n        missed: missedAll,\n        paths: paths,\n        caches: caches\n      };\n    };\n  };\n\n  _proto.find = /*#__PURE__*/function () {\n    var _find6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee22(criteria, sort, skip, limit) {\n      var traceId, chunkSize, primaryIndice, search, result, query, i, caches, isEnough, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, values, _iterator5, _step5, value, ids, _iterator6, _step6, _value3, _iteratorAbruptCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, _ids, subIds, searchIds, _values, _i3, _arr, _value, _values2, _iterator7, _step7, _value2, res;\n\n      return _regeneratorRuntime.wrap(function _callee22$(_context22) {\n        while (1) {\n          switch (_context22.prev = _context22.next) {\n            case 0:\n              if (skip === void 0) {\n                skip = 0;\n              }\n\n              traceId = reqId++;\n              chunkSize = limit || 20;\n              primaryIndice = this.schema.primaryIndice;\n              search = this.buildIndexSearch(criteria, sort, skip, limit, {\n                traceId: traceId\n              })();\n              result = [];\n              query = new mingo.Query(criteria);\n              i = 0;\n              caches = search.caches.values();\n\n              isEnough = function isEnough() {\n                return limit && i === limit + skip && !search.greed;\n              };\n\n              if (!search.missed) {\n                _context22.next = 50;\n                break;\n              }\n\n              _iteratorAbruptCompletion = false;\n              _didIteratorError = false;\n              _context22.prev = 13;\n              _iterator = _asyncIterator(primaryIndice.cursor(undefined, {\n                traceId: traceId\n              }));\n\n            case 15:\n              _context22.next = 17;\n              return _iterator.next();\n\n            case 17:\n              if (!(_iteratorAbruptCompletion = !(_step = _context22.sent).done)) {\n                _context22.next = 32;\n                break;\n              }\n\n              values = _step.value;\n              _iterator5 = _createForOfIteratorHelperLoose(values);\n\n            case 20:\n              if ((_step5 = _iterator5()).done) {\n                _context22.next = 29;\n                break;\n              }\n\n              value = _step5.value;\n\n              if (!query.test(value)) {\n                _context22.next = 27;\n                break;\n              }\n\n              i++;\n\n              if (i > skip || search.greed) {\n                result.push(value);\n              }\n\n              if (!isEnough()) {\n                _context22.next = 27;\n                break;\n              }\n\n              return _context22.abrupt(\"break\", 29);\n\n            case 27:\n              _context22.next = 20;\n              break;\n\n            case 29:\n              _iteratorAbruptCompletion = false;\n              _context22.next = 15;\n              break;\n\n            case 32:\n              _context22.next = 38;\n              break;\n\n            case 34:\n              _context22.prev = 34;\n              _context22.t0 = _context22[\"catch\"](13);\n              _didIteratorError = true;\n              _iteratorError = _context22.t0;\n\n            case 38:\n              _context22.prev = 38;\n              _context22.prev = 39;\n\n              if (!(_iteratorAbruptCompletion && _iterator.return != null)) {\n                _context22.next = 43;\n                break;\n              }\n\n              _context22.next = 43;\n              return _iterator.return();\n\n            case 43:\n              _context22.prev = 43;\n\n              if (!_didIteratorError) {\n                _context22.next = 46;\n                break;\n              }\n\n              throw _iteratorError;\n\n            case 46:\n              return _context22.finish(43);\n\n            case 47:\n              return _context22.finish(38);\n\n            case 48:\n              _context22.next = 126;\n              break;\n\n            case 50:\n              ids = [];\n              _iterator6 = _createForOfIteratorHelperLoose(caches);\n\n            case 52:\n              if ((_step6 = _iterator6()).done) {\n                _context22.next = 62;\n                break;\n              }\n\n              _value3 = _step6.value;\n\n              if (!query.test(_value3)) {\n                _context22.next = 60;\n                break;\n              }\n\n              i++;\n\n              if (i > skip || search.greed) {\n                result.push(_value3);\n              }\n\n              if (!isEnough()) {\n                _context22.next = 60;\n                break;\n              }\n\n              ids = [];\n              return _context22.abrupt(\"break\", 62);\n\n            case 60:\n              _context22.next = 52;\n              break;\n\n            case 62:\n              if (isEnough()) {\n                _context22.next = 126;\n                break;\n              }\n\n              _iteratorAbruptCompletion2 = false;\n              _didIteratorError2 = false;\n              _context22.prev = 65;\n              _iterator2 = _asyncIterator(search.result);\n\n            case 67:\n              _context22.next = 69;\n              return _iterator2.next();\n\n            case 69:\n              if (!(_iteratorAbruptCompletion2 = !(_step2 = _context22.sent).done)) {\n                _context22.next = 96;\n                break;\n              }\n\n              subIds = _step2.value;\n\n              (_ids = ids).push.apply(_ids, _toConsumableArray(subIds));\n\n              searchIds = ids.filter(function (id) {\n                return !search.caches.has(id);\n              });\n\n              if (!(searchIds.length >= chunkSize)) {\n                _context22.next = 93;\n                break;\n              }\n\n            case 74:\n              if (!(searchIds.length >= chunkSize)) {\n                _context22.next = 92;\n                break;\n              }\n\n              _context22.next = 77;\n              return primaryIndice.find(searchIds.splice(0, chunkSize));\n\n            case 77:\n              _values = _context22.sent;\n              _i3 = 0, _arr = _toConsumableArray(_values);\n\n            case 79:\n              if (!(_i3 < _arr.length)) {\n                _context22.next = 90;\n                break;\n              }\n\n              _value = _arr[_i3];\n\n              if (!query.test(_value)) {\n                _context22.next = 87;\n                break;\n              }\n\n              i++;\n\n              if (i > skip || search.greed) {\n                result.push(_value);\n              }\n\n              if (!isEnough()) {\n                _context22.next = 87;\n                break;\n              }\n\n              ids = [];\n              return _context22.abrupt(\"break\", 96);\n\n            case 87:\n              _i3++;\n              _context22.next = 79;\n              break;\n\n            case 90:\n              _context22.next = 74;\n              break;\n\n            case 92:\n              ids = [];\n\n            case 93:\n              _iteratorAbruptCompletion2 = false;\n              _context22.next = 67;\n              break;\n\n            case 96:\n              _context22.next = 102;\n              break;\n\n            case 98:\n              _context22.prev = 98;\n              _context22.t1 = _context22[\"catch\"](65);\n              _didIteratorError2 = true;\n              _iteratorError2 = _context22.t1;\n\n            case 102:\n              _context22.prev = 102;\n              _context22.prev = 103;\n\n              if (!(_iteratorAbruptCompletion2 && _iterator2.return != null)) {\n                _context22.next = 107;\n                break;\n              }\n\n              _context22.next = 107;\n              return _iterator2.return();\n\n            case 107:\n              _context22.prev = 107;\n\n              if (!_didIteratorError2) {\n                _context22.next = 110;\n                break;\n              }\n\n              throw _iteratorError2;\n\n            case 110:\n              return _context22.finish(107);\n\n            case 111:\n              return _context22.finish(102);\n\n            case 112:\n              if (!ids.length) {\n                _context22.next = 126;\n                break;\n              }\n\n              _context22.next = 115;\n              return primaryIndice.find(ids);\n\n            case 115:\n              _values2 = _context22.sent;\n              _iterator7 = _createForOfIteratorHelperLoose(_values2);\n\n            case 117:\n              if ((_step7 = _iterator7()).done) {\n                _context22.next = 126;\n                break;\n              }\n\n              _value2 = _step7.value;\n\n              if (!query.test(_value2)) {\n                _context22.next = 124;\n                break;\n              }\n\n              i++;\n\n              if (i > skip || search.greed) {\n                result.push(_value2);\n              }\n\n              if (!isEnough()) {\n                _context22.next = 124;\n                break;\n              }\n\n              return _context22.abrupt(\"break\", 126);\n\n            case 124:\n              _context22.next = 117;\n              break;\n\n            case 126:\n              res = new mingo.Query({}).find(result);\n\n              if (sort && search.greed) {\n                res = res.sort(sort);\n              }\n\n              if (limit && search.greed) {\n                res = res.limit(limit);\n              }\n\n              if (skip && search.greed) {\n                res = res.skip(skip);\n              }\n\n              return _context22.abrupt(\"return\", res.all());\n\n            case 131:\n            case \"end\":\n              return _context22.stop();\n          }\n        }\n      }, _callee22, this, [[13, 34, 38, 48], [39,, 43, 47], [65, 98, 102, 112], [103,, 107, 111]]);\n    }));\n\n    function find(_x28, _x29, _x30, _x31) {\n      return _find6.apply(this, arguments);\n    }\n\n    return find;\n  }();\n\n  _proto.cursor = function cursor(criteria, sort, skip, limit) {\n    if (skip === void 0) {\n      skip = 0;\n    }\n\n    var traceId = reqId++;\n    var chunkSize = limit || 20;\n    var primaryIndice = this.schema.primaryIndice;\n    var search = this.buildIndexSearch(criteria, sort, skip, limit, {\n      traceId: traceId\n    })();\n    var result = [];\n    var query = new mingo.Query(criteria);\n    var i = 0;\n    var caches = search.caches.values();\n\n    var isEnough = function isEnough() {\n      return limit && i === limit + skip && !search.greed;\n    };\n\n    var _hasNext = true;\n    var cursorQueue = [];\n\n    var cursorSuccess = function cursorSuccess(res) {\n      return cursorQueue[cursorQueue.length - 1].cursorSuccess(res);\n    };\n\n    var cursorError = function cursorError(e) {\n      return cursorQueue[cursorQueue.length - 1].cursorError(e);\n    };\n\n    var lockCursorSuccess;\n    var lockCursorError;\n\n    var lockCreator = function lockCreator() {\n      return new Promise(function (suc, err) {\n        lockCursorSuccess = suc;\n        lockCursorError = err;\n      });\n    };\n\n    var cursorCreator = function cursorCreator() {\n      var cursorSuccess, cursorError;\n      var promise = new Promise(function (suc, err) {\n        cursorSuccess = function cursorSuccess(res) {\n          lockCursor = lockCreator();\n          cursorQueue.pop();\n\n          if (cursorQueue.length) {\n            lockCursorSuccess();\n          }\n\n          suc(res);\n        };\n\n        cursorError = function cursorError() {\n          cursorQueue.pop();\n          err();\n        };\n      });\n      return {\n        promise: promise,\n        cursorSuccess: cursorSuccess,\n        cursorError: cursorError\n      };\n    };\n\n    var getCursor = function getCursor() {\n      cursorQueue.push(cursorCreator());\n\n      if (cursorQueue.length === 1) {\n        lockCursorSuccess();\n      }\n\n      return cursorQueue[cursorQueue.length - 1];\n    };\n\n    var matchResultHandler = /*#__PURE__*/function () {\n      var _matchResultHandler = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee23(value) {\n        return _regeneratorRuntime.wrap(function _callee23$(_context23) {\n          while (1) {\n            switch (_context23.prev = _context23.next) {\n              case 0:\n                if (!query.test(value)) {\n                  _context23.next = 9;\n                  break;\n                }\n\n                i++;\n\n                if (i > skip) {\n                  result.push(value);\n                }\n\n                if (!isEnough()) {\n                  _context23.next = 9;\n                  break;\n                }\n\n                cursorSuccess(result);\n                result = [];\n                i = skip;\n                _context23.next = 9;\n                return lockCursor;\n\n              case 9:\n              case \"end\":\n                return _context23.stop();\n            }\n          }\n        }, _callee23);\n      }));\n\n      function matchResultHandler(_x32) {\n        return _matchResultHandler.apply(this, arguments);\n      }\n\n      return matchResultHandler;\n    }();\n\n    var lockCursor = lockCreator();\n\n    if (search.greed) {\n      throw new Error('Unsuported greed cursor yet. Please add indice');\n    }\n\n    _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee24() {\n      var _iteratorAbruptCompletion3, _didIteratorError3, _iteratorError3, _iterator3, _step3, values, _iterator8, _step8, value, ids, _iterator9, _step9, _value6, _iteratorAbruptCompletion4, _didIteratorError4, _iteratorError4, _iterator4, _step4, _ids2, subIds, searchIds, _values3, _i4, _arr2, _value4, _values4, _iterator10, _step10, _value5;\n\n      return _regeneratorRuntime.wrap(function _callee24$(_context24) {\n        while (1) {\n          switch (_context24.prev = _context24.next) {\n            case 0:\n              _context24.next = 2;\n              return lockCursor;\n\n            case 2:\n              lockCursor = lockCreator();\n              _context24.prev = 3;\n\n              if (!search.missed) {\n                _context24.next = 41;\n                break;\n              }\n\n              _iteratorAbruptCompletion3 = false;\n              _didIteratorError3 = false;\n              _context24.prev = 7;\n              _iterator3 = _asyncIterator(primaryIndice.cursor(undefined, {\n                traceId: traceId\n              }));\n\n            case 9:\n              _context24.next = 11;\n              return _iterator3.next();\n\n            case 11:\n              if (!(_iteratorAbruptCompletion3 = !(_step3 = _context24.sent).done)) {\n                _context24.next = 23;\n                break;\n              }\n\n              values = _step3.value;\n              _iterator8 = _createForOfIteratorHelperLoose(values);\n\n            case 14:\n              if ((_step8 = _iterator8()).done) {\n                _context24.next = 20;\n                break;\n              }\n\n              value = _step8.value;\n              _context24.next = 18;\n              return matchResultHandler(value);\n\n            case 18:\n              _context24.next = 14;\n              break;\n\n            case 20:\n              _iteratorAbruptCompletion3 = false;\n              _context24.next = 9;\n              break;\n\n            case 23:\n              _context24.next = 29;\n              break;\n\n            case 25:\n              _context24.prev = 25;\n              _context24.t0 = _context24[\"catch\"](7);\n              _didIteratorError3 = true;\n              _iteratorError3 = _context24.t0;\n\n            case 29:\n              _context24.prev = 29;\n              _context24.prev = 30;\n\n              if (!(_iteratorAbruptCompletion3 && _iterator3.return != null)) {\n                _context24.next = 34;\n                break;\n              }\n\n              _context24.next = 34;\n              return _iterator3.return();\n\n            case 34:\n              _context24.prev = 34;\n\n              if (!_didIteratorError3) {\n                _context24.next = 37;\n                break;\n              }\n\n              throw _iteratorError3;\n\n            case 37:\n              return _context24.finish(34);\n\n            case 38:\n              return _context24.finish(29);\n\n            case 39:\n              _context24.next = 102;\n              break;\n\n            case 41:\n              ids = [];\n              _iterator9 = _createForOfIteratorHelperLoose(caches);\n\n            case 43:\n              if ((_step9 = _iterator9()).done) {\n                _context24.next = 49;\n                break;\n              }\n\n              _value6 = _step9.value;\n              _context24.next = 47;\n              return matchResultHandler(_value6);\n\n            case 47:\n              _context24.next = 43;\n              break;\n\n            case 49:\n              if (isEnough()) {\n                _context24.next = 102;\n                break;\n              }\n\n              _iteratorAbruptCompletion4 = false;\n              _didIteratorError4 = false;\n              _context24.prev = 52;\n              _iterator4 = _asyncIterator(search.result);\n\n            case 54:\n              _context24.next = 56;\n              return _iterator4.next();\n\n            case 56:\n              if (!(_iteratorAbruptCompletion4 = !(_step4 = _context24.sent).done)) {\n                _context24.next = 79;\n                break;\n              }\n\n              subIds = _step4.value;\n\n              (_ids2 = ids).push.apply(_ids2, _toConsumableArray(subIds));\n\n              searchIds = ids.filter(function (id) {\n                return !search.caches.has(id);\n              });\n\n              if (!(searchIds.length >= chunkSize)) {\n                _context24.next = 76;\n                break;\n              }\n\n            case 61:\n              if (!(searchIds.length >= chunkSize)) {\n                _context24.next = 75;\n                break;\n              }\n\n              _context24.next = 64;\n              return primaryIndice.find(searchIds.splice(0, chunkSize));\n\n            case 64:\n              _values3 = _context24.sent;\n              _i4 = 0, _arr2 = _toConsumableArray(_values3);\n\n            case 66:\n              if (!(_i4 < _arr2.length)) {\n                _context24.next = 73;\n                break;\n              }\n\n              _value4 = _arr2[_i4];\n              _context24.next = 70;\n              return matchResultHandler(_value4);\n\n            case 70:\n              _i4++;\n              _context24.next = 66;\n              break;\n\n            case 73:\n              _context24.next = 61;\n              break;\n\n            case 75:\n              ids = [];\n\n            case 76:\n              _iteratorAbruptCompletion4 = false;\n              _context24.next = 54;\n              break;\n\n            case 79:\n              _context24.next = 85;\n              break;\n\n            case 81:\n              _context24.prev = 81;\n              _context24.t1 = _context24[\"catch\"](52);\n              _didIteratorError4 = true;\n              _iteratorError4 = _context24.t1;\n\n            case 85:\n              _context24.prev = 85;\n              _context24.prev = 86;\n\n              if (!(_iteratorAbruptCompletion4 && _iterator4.return != null)) {\n                _context24.next = 90;\n                break;\n              }\n\n              _context24.next = 90;\n              return _iterator4.return();\n\n            case 90:\n              _context24.prev = 90;\n\n              if (!_didIteratorError4) {\n                _context24.next = 93;\n                break;\n              }\n\n              throw _iteratorError4;\n\n            case 93:\n              return _context24.finish(90);\n\n            case 94:\n              return _context24.finish(85);\n\n            case 95:\n              if (!ids.length) {\n                _context24.next = 100;\n                break;\n              }\n\n              _context24.next = 98;\n              return primaryIndice.find(ids);\n\n            case 98:\n              _values4 = _context24.sent;\n\n              for (_iterator10 = _createForOfIteratorHelperLoose(_values4); !(_step10 = _iterator10()).done;) {\n                _value5 = _step10.value;\n\n                if (query.test(_value5)) {\n                  i++;\n\n                  if (i > skip) {\n                    result.push(_value5);\n                  }\n                }\n              }\n\n            case 100:\n              cursorSuccess(result);\n              result = [];\n\n            case 102:\n              _context24.next = 108;\n              break;\n\n            case 104:\n              _context24.prev = 104;\n              _context24.t2 = _context24[\"catch\"](3);\n\n              if (_context24.t2 instanceof PoisonPillow) {\n                _context24.next = 108;\n                break;\n              }\n\n              throw _context24.t2;\n\n            case 108:\n              _context24.prev = 108;\n              lockCursorSuccess();\n              _hasNext = false;\n              return _context24.finish(108);\n\n            case 112:\n            case \"end\":\n              return _context24.stop();\n          }\n        }\n      }, _callee24, null, [[3, 104, 108, 112], [7, 25, 29, 39], [30,, 34, 38], [52, 81, 85, 95], [86,, 90, 94]]);\n    }))();\n\n    return {\n      next: function next() {\n        if (!_hasNext) {\n          cursorError('End of list');\n        }\n\n        var cursor = getCursor();\n        var start = new Date().getTime();\n        cursor.promise.then(function () {\n          var end = new Date().getTime();\n          instance.debug(\"[\" + traceId + \"]\", \"Time next is \" + (end - start));\n        });\n        return cursor.promise;\n      },\n      hasNext: function hasNext() {\n        return _hasNext;\n      },\n      finish: function finish() {\n        lockCursorError(new PoisonPillow());\n      }\n    };\n  };\n\n  _proto.indiceCursor = function indiceCursor(indice, value, caches, _temp) {\n    var _ref20;\n\n    var _ref19 = _temp === void 0 ? {} : _temp,\n        _ref19$operator = _ref19.operator,\n        operator = _ref19$operator === void 0 ? '$eq' : _ref19$operator,\n        _ref19$sort = _ref19.sort,\n        sort = _ref19$sort === void 0 ? 1 : _ref19$sort,\n        traceId = _ref19.traceId;\n\n    var idAttr = this.schema.idAttr;\n\n    if (this.schema.primaryIndice !== indice) {\n      var _iterator11 = indice.cursor(value, {\n        operator: operator,\n        sort: sort,\n        traceId: traceId\n      });\n\n      return _iterator11;\n    }\n\n    var iterator = this.schema.primaryIndice.cursor(value, {\n      operator: operator,\n      sort: sort,\n      traceId: traceId\n    });\n    return _ref20 = {}, _ref20[Symbol.asyncIterator] = function () {\n      return {\n        next: function () {\n          var _next5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee25() {\n            var _await$getNext, result;\n\n            return _regeneratorRuntime.wrap(function _callee25$(_context25) {\n              while (1) {\n                switch (_context25.prev = _context25.next) {\n                  case 0:\n                    _context25.next = 2;\n                    return getNext(iterator[Symbol.asyncIterator](), 0);\n\n                  case 2:\n                    _await$getNext = _context25.sent;\n                    result = _await$getNext.result;\n\n                    if (result.done) {\n                      _context25.next = 9;\n                      break;\n                    }\n\n                    result.value.forEach(function (it) {\n                      return caches.set(it[idAttr], it);\n                    });\n                    return _context25.abrupt(\"return\", {\n                      done: false,\n                      value: result.value.map(function (it) {\n                        return it[idAttr];\n                      })\n                    });\n\n                  case 9:\n                    return _context25.abrupt(\"return\", {\n                      done: true,\n                      value: undefined\n                    });\n\n                  case 10:\n                  case \"end\":\n                    return _context25.stop();\n                }\n              }\n            }, _callee25);\n          }));\n\n          function next() {\n            return _next5.apply(this, arguments);\n          }\n\n          return next;\n        }()\n      };\n    }, _ref20;\n  };\n\n  _proto.testIndice = function testIndice(options, key, value, path) {\n    var pathEqual = options.path === path;\n    return pathEqual && options.indice.testIndice(key, value);\n  };\n\n  return Db;\n}();\n\nvar Schema = function Schema(idAttr, primaryIndice, indices) {\n  this.indices = [].concat(_toConsumableArray(indices), [{\n    indice: primaryIndice,\n    path: idAttr\n  }]);\n  this.primaryIndice = primaryIndice;\n  this.idAttr = idAttr;\n};\n\nvar fs = {}; // Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\n\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  } // if the path is allowed to go above the root, restore leading ..s\n\n\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n} // Split a filename into [root, dir, basename, ext], unix version\n// posix version\n\n\nfunction normalize(path) {\n  var isPathAbsolute = isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/'; // Normalize the path\n\n  path = normalizeArray(filter(path.split('/'), function (p) {\n    return !!p;\n  }), !isPathAbsolute).join('/');\n\n  if (!path && !isPathAbsolute) {\n    path = '.';\n  }\n\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isPathAbsolute ? '/' : '') + path;\n}\n\nfunction isAbsolute(path) {\n  return path.charAt(0) === '/';\n} // posix version\n\n\nfunction join() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return normalize(filter(paths, function (p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n\n    return p;\n  }).join('/'));\n} // path.relative(from, to)\n\n\nfunction filter(xs, f) {\n  if (xs.filter) return xs.filter(f);\n  var res = [];\n\n  for (var i = 0; i < xs.length; i++) {\n    if (f(xs[i], i, xs)) res.push(xs[i]);\n  }\n\n  return res;\n} // String.prototype.substr - negative index don't work in IE8\n\n\nvar substr = 'ab'.substr(-1) === 'b' ? function (str, start, len) {\n  return str.substr(start, len);\n} : function (str, start, len) {\n  if (start < 0) start = str.length + start;\n  return str.substr(start, len);\n};\nvar global$1 = typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {};\nvar lookup = [];\nvar revLookup = [];\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;\nvar inited = false;\n\nfunction init() {\n  inited = true;\n  var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\n  for (var i = 0, len = code.length; i < len; ++i) {\n    lookup[i] = code[i];\n    revLookup[code.charCodeAt(i)] = i;\n  }\n\n  revLookup['-'.charCodeAt(0)] = 62;\n  revLookup['_'.charCodeAt(0)] = 63;\n}\n\nfunction toByteArray(b64) {\n  if (!inited) {\n    init();\n  }\n\n  var i, j, l, tmp, placeHolders, arr;\n  var len = b64.length;\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4');\n  } // the number of equal signs (place holders)\n  // if there are two placeholders, than the two characters before it\n  // represent one byte\n  // if there is only one, then the three characters before it represent 2 bytes\n  // this is just a cheap hack to not do indexOf twice\n\n\n  placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0; // base64 is 4/3 + up to two characters of the original data\n\n  arr = new Arr(len * 3 / 4 - placeHolders); // if there are placeholders, only get up to the last complete 4 chars\n\n  l = placeHolders > 0 ? len - 4 : len;\n  var L = 0;\n\n  for (i = 0, j = 0; i < l; i += 4, j += 3) {\n    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];\n    arr[L++] = tmp >> 16 & 0xFF;\n    arr[L++] = tmp >> 8 & 0xFF;\n    arr[L++] = tmp & 0xFF;\n  }\n\n  if (placeHolders === 2) {\n    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;\n    arr[L++] = tmp & 0xFF;\n  } else if (placeHolders === 1) {\n    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;\n    arr[L++] = tmp >> 8 & 0xFF;\n    arr[L++] = tmp & 0xFF;\n  }\n\n  return arr;\n}\n\nfunction tripletToBase64(num) {\n  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F];\n}\n\nfunction encodeChunk(uint8, start, end) {\n  var tmp;\n  var output = [];\n\n  for (var i = start; i < end; i += 3) {\n    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + uint8[i + 2];\n    output.push(tripletToBase64(tmp));\n  }\n\n  return output.join('');\n}\n\nfunction fromByteArray(uint8) {\n  if (!inited) {\n    init();\n  }\n\n  var tmp;\n  var len = uint8.length;\n  var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes\n\n  var output = '';\n  var parts = [];\n  var maxChunkLength = 16383; // must be multiple of 3\n  // go through the array every three bytes, we'll deal with trailing stuff later\n\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));\n  } // pad the end with zeros, but make sure to not forget the extra bytes\n\n\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1];\n    output += lookup[tmp >> 2];\n    output += lookup[tmp << 4 & 0x3F];\n    output += '==';\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1];\n    output += lookup[tmp >> 10];\n    output += lookup[tmp >> 4 & 0x3F];\n    output += lookup[tmp << 2 & 0x3F];\n    output += '=';\n  }\n\n  parts.push(output);\n  return parts.join('');\n}\n\nfunction read(buffer, offset, isLE, mLen, nBytes) {\n  var e, m;\n  var eLen = nBytes * 8 - mLen - 1;\n  var eMax = (1 << eLen) - 1;\n  var eBias = eMax >> 1;\n  var nBits = -7;\n  var i = isLE ? nBytes - 1 : 0;\n  var d = isLE ? -1 : 1;\n  var s = buffer[offset + i];\n  i += d;\n  e = s & (1 << -nBits) - 1;\n  s >>= -nBits;\n  nBits += eLen;\n\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & (1 << -nBits) - 1;\n  e >>= -nBits;\n  nBits += mLen;\n\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias;\n  } else if (e === eMax) {\n    return m ? NaN : (s ? -1 : 1) * Infinity;\n  } else {\n    m = m + Math.pow(2, mLen);\n    e = e - eBias;\n  }\n\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\n}\n\nfunction write(buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c;\n  var eLen = nBytes * 8 - mLen - 1;\n  var eMax = (1 << eLen) - 1;\n  var eBias = eMax >> 1;\n  var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;\n  var i = isLE ? 0 : nBytes - 1;\n  var d = isLE ? 1 : -1;\n  var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;\n  value = Math.abs(value);\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0;\n    e = eMax;\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2);\n\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--;\n      c *= 2;\n    }\n\n    if (e + eBias >= 1) {\n      value += rt / c;\n    } else {\n      value += rt * Math.pow(2, 1 - eBias);\n    }\n\n    if (value * c >= 2) {\n      e++;\n      c /= 2;\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0;\n      e = eMax;\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen);\n      e = e + eBias;\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\n      e = 0;\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = e << mLen | m;\n  eLen += mLen;\n\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128;\n}\n\nvar toString = {}.toString;\n\nvar isArray$1 = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n\n\nvar INSPECT_MAX_BYTES = 50;\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\n\nBuffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined ? global$1.TYPED_ARRAY_SUPPORT : true;\n\nfunction kMaxLength() {\n  return Buffer.TYPED_ARRAY_SUPPORT ? 0x7fffffff : 0x3fffffff;\n}\n\nfunction createBuffer(that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length');\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length);\n    that.__proto__ = Buffer.prototype;\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length);\n    }\n\n    that.length = length;\n  }\n\n  return that;\n}\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\n\nfunction Buffer(arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length);\n  } // Common case.\n\n\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error('If encoding is specified then the first argument must be a string');\n    }\n\n    return allocUnsafe(this, arg);\n  }\n\n  return from(this, arg, encodingOrOffset, length);\n}\n\nBuffer.poolSize = 8192; // not used by this implementation\n// TODO: Legacy, not needed anymore. Remove in next major version.\n\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype;\n  return arr;\n};\n\nfunction from(that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number');\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length);\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset);\n  }\n\n  return fromObject(that, value);\n}\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\n\n\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length);\n};\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype;\n  Buffer.__proto__ = Uint8Array;\n}\n\nfunction assertSize(size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number');\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative');\n  }\n}\n\nfunction alloc(that, size, fill, encoding) {\n  assertSize(size);\n\n  if (size <= 0) {\n    return createBuffer(that, size);\n  }\n\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string' ? createBuffer(that, size).fill(fill, encoding) : createBuffer(that, size).fill(fill);\n  }\n\n  return createBuffer(that, size);\n}\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\n\n\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding);\n};\n\nfunction allocUnsafe(that, size) {\n  assertSize(size);\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);\n\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0;\n    }\n  }\n\n  return that;\n}\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\n\n\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size);\n};\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\n\n\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size);\n};\n\nfunction fromString(that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8';\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding');\n  }\n\n  var length = byteLength(string, encoding) | 0;\n  that = createBuffer(that, length);\n  var actual = that.write(string, encoding);\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual);\n  }\n\n  return that;\n}\n\nfunction fromArrayLike(that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0;\n  that = createBuffer(that, length);\n\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255;\n  }\n\n  return that;\n}\n\nfunction fromArrayBuffer(that, array, byteOffset, length) {\n  array.byteLength; // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds');\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds');\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array);\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset);\n  } else {\n    array = new Uint8Array(array, byteOffset, length);\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array;\n    that.__proto__ = Buffer.prototype;\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array);\n  }\n\n  return that;\n}\n\nfunction fromObject(that, obj) {\n  if (internalIsBuffer(obj)) {\n    var len = checked(obj.length) | 0;\n    that = createBuffer(that, len);\n\n    if (that.length === 0) {\n      return that;\n    }\n\n    obj.copy(that, 0, 0, len);\n    return that;\n  }\n\n  if (obj) {\n    if (typeof ArrayBuffer !== 'undefined' && obj.buffer instanceof ArrayBuffer || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0);\n      }\n\n      return fromArrayLike(that, obj);\n    }\n\n    if (obj.type === 'Buffer' && isArray$1(obj.data)) {\n      return fromArrayLike(that, obj.data);\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.');\n}\n\nfunction checked(length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' + 'size: 0x' + kMaxLength().toString(16) + ' bytes');\n  }\n\n  return length | 0;\n}\n\nBuffer.isBuffer = isBuffer$1;\n\nfunction internalIsBuffer(b) {\n  return !!(b != null && b._isBuffer);\n}\n\nBuffer.compare = function compare(a, b) {\n  if (!internalIsBuffer(a) || !internalIsBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers');\n  }\n\n  if (a === b) return 0;\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) return -1;\n  if (y < x) return 1;\n  return 0;\n};\n\nBuffer.isEncoding = function isEncoding(encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true;\n\n    default:\n      return false;\n  }\n};\n\nBuffer.concat = function concat(list, length) {\n  if (!isArray$1(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers');\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0);\n  }\n\n  var i;\n\n  if (length === undefined) {\n    length = 0;\n\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length;\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length);\n  var pos = 0;\n\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i];\n\n    if (!internalIsBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers');\n    }\n\n    buf.copy(buffer, pos);\n    pos += buf.length;\n  }\n\n  return buffer;\n};\n\nfunction byteLength(string, encoding) {\n  if (internalIsBuffer(string)) {\n    return string.length;\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength;\n  }\n\n  if (typeof string !== 'string') {\n    string = '' + string;\n  }\n\n  var len = string.length;\n  if (len === 0) return 0; // Use a for loop to avoid recursion\n\n  var loweredCase = false;\n\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len;\n\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length;\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2;\n\n      case 'hex':\n        return len >>> 1;\n\n      case 'base64':\n        return base64ToBytes(string).length;\n\n      default:\n        if (loweredCase) return utf8ToBytes(string).length; // assume utf8\n\n        encoding = ('' + encoding).toLowerCase();\n        loweredCase = true;\n    }\n  }\n}\n\nBuffer.byteLength = byteLength;\n\nfunction slowToString(encoding, start, end) {\n  var loweredCase = false; // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n\n  if (start === undefined || start < 0) {\n    start = 0;\n  } // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n\n\n  if (start > this.length) {\n    return '';\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length;\n  }\n\n  if (end <= 0) {\n    return '';\n  } // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n\n\n  end >>>= 0;\n  start >>>= 0;\n\n  if (end <= start) {\n    return '';\n  }\n\n  if (!encoding) encoding = 'utf8';\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end);\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end);\n\n      case 'ascii':\n        return asciiSlice(this, start, end);\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end);\n\n      case 'base64':\n        return base64Slice(this, start, end);\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end);\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);\n        encoding = (encoding + '').toLowerCase();\n        loweredCase = true;\n    }\n  }\n} // The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\n\n\nBuffer.prototype._isBuffer = true;\n\nfunction swap(b, n, m) {\n  var i = b[n];\n  b[n] = b[m];\n  b[m] = i;\n}\n\nBuffer.prototype.swap16 = function swap16() {\n  var len = this.length;\n\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits');\n  }\n\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1);\n  }\n\n  return this;\n};\n\nBuffer.prototype.swap32 = function swap32() {\n  var len = this.length;\n\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits');\n  }\n\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3);\n    swap(this, i + 1, i + 2);\n  }\n\n  return this;\n};\n\nBuffer.prototype.swap64 = function swap64() {\n  var len = this.length;\n\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits');\n  }\n\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7);\n    swap(this, i + 1, i + 6);\n    swap(this, i + 2, i + 5);\n    swap(this, i + 3, i + 4);\n  }\n\n  return this;\n};\n\nBuffer.prototype.toString = function toString() {\n  var length = this.length | 0;\n  if (length === 0) return '';\n  if (arguments.length === 0) return utf8Slice(this, 0, length);\n  return slowToString.apply(this, arguments);\n};\n\nBuffer.prototype.equals = function equals(b) {\n  if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer');\n  if (this === b) return true;\n  return Buffer.compare(this, b) === 0;\n};\n\nBuffer.prototype.inspect = function inspect() {\n  var str = '';\n  var max = INSPECT_MAX_BYTES;\n\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');\n    if (this.length > max) str += ' ... ';\n  }\n\n  return '<Buffer ' + str + '>';\n};\n\nBuffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {\n  if (!internalIsBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer');\n  }\n\n  if (start === undefined) {\n    start = 0;\n  }\n\n  if (end === undefined) {\n    end = target ? target.length : 0;\n  }\n\n  if (thisStart === undefined) {\n    thisStart = 0;\n  }\n\n  if (thisEnd === undefined) {\n    thisEnd = this.length;\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index');\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0;\n  }\n\n  if (thisStart >= thisEnd) {\n    return -1;\n  }\n\n  if (start >= end) {\n    return 1;\n  }\n\n  start >>>= 0;\n  end >>>= 0;\n  thisStart >>>= 0;\n  thisEnd >>>= 0;\n  if (this === target) return 0;\n  var x = thisEnd - thisStart;\n  var y = end - start;\n  var len = Math.min(x, y);\n  var thisCopy = this.slice(thisStart, thisEnd);\n  var targetCopy = target.slice(start, end);\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i];\n      y = targetCopy[i];\n      break;\n    }\n  }\n\n  if (x < y) return -1;\n  if (y < x) return 1;\n  return 0;\n}; // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\n\n\nfunction bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1; // Normalize byteOffset\n\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset;\n    byteOffset = 0;\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff;\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000;\n  }\n\n  byteOffset = +byteOffset; // Coerce to Number.\n\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : buffer.length - 1;\n  } // Normalize byteOffset: negative offsets start from the end of the buffer\n\n\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset;\n\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1;else byteOffset = buffer.length - 1;\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0;else return -1;\n  } // Normalize val\n\n\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding);\n  } // Finally, search either indexOf (if dir is true) or lastIndexOf\n\n\n  if (internalIsBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1;\n    }\n\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir);\n  } else if (typeof val === 'number') {\n    val = val & 0xFF; // Search for a byte value [0-255]\n\n    if (Buffer.TYPED_ARRAY_SUPPORT && typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);\n      }\n    }\n\n    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);\n  }\n\n  throw new TypeError('val must be string, number or Buffer');\n}\n\nfunction arrayIndexOf(arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1;\n  var arrLength = arr.length;\n  var valLength = val.length;\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase();\n\n    if (encoding === 'ucs2' || encoding === 'ucs-2' || encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1;\n      }\n\n      indexSize = 2;\n      arrLength /= 2;\n      valLength /= 2;\n      byteOffset /= 2;\n    }\n  }\n\n  function read(buf, i) {\n    if (indexSize === 1) {\n      return buf[i];\n    } else {\n      return buf.readUInt16BE(i * indexSize);\n    }\n  }\n\n  var i;\n\n  if (dir) {\n    var foundIndex = -1;\n\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i;\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex;\n        foundIndex = -1;\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;\n\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true;\n\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false;\n          break;\n        }\n      }\n\n      if (found) return i;\n    }\n  }\n\n  return -1;\n}\n\nBuffer.prototype.includes = function includes(val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1;\n};\n\nBuffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true);\n};\n\nBuffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false);\n};\n\nfunction hexWrite(buf, string, offset, length) {\n  offset = Number(offset) || 0;\n  var remaining = buf.length - offset;\n\n  if (!length) {\n    length = remaining;\n  } else {\n    length = Number(length);\n\n    if (length > remaining) {\n      length = remaining;\n    }\n  } // must be an even number of digits\n\n\n  var strLen = string.length;\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string');\n\n  if (length > strLen / 2) {\n    length = strLen / 2;\n  }\n\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16);\n    if (isNaN(parsed)) return i;\n    buf[offset + i] = parsed;\n  }\n\n  return i;\n}\n\nfunction utf8Write(buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);\n}\n\nfunction asciiWrite(buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length);\n}\n\nfunction latin1Write(buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length);\n}\n\nfunction base64Write(buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length);\n}\n\nfunction ucs2Write(buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);\n}\n\nBuffer.prototype.write = function write(string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8';\n    length = this.length;\n    offset = 0; // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset;\n    length = this.length;\n    offset = 0; // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0;\n\n    if (isFinite(length)) {\n      length = length | 0;\n      if (encoding === undefined) encoding = 'utf8';\n    } else {\n      encoding = length;\n      length = undefined;\n    } // legacy write(string, encoding, offset, length) - remove in v0.13\n\n  } else {\n    throw new Error('Buffer.write(string, encoding, offset[, length]) is no longer supported');\n  }\n\n  var remaining = this.length - offset;\n  if (length === undefined || length > remaining) length = remaining;\n\n  if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds');\n  }\n\n  if (!encoding) encoding = 'utf8';\n  var loweredCase = false;\n\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length);\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length);\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length);\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length);\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length);\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length);\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);\n        encoding = ('' + encoding).toLowerCase();\n        loweredCase = true;\n    }\n  }\n};\n\nBuffer.prototype.toJSON = function toJSON() {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  };\n};\n\nfunction base64Slice(buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return fromByteArray(buf);\n  } else {\n    return fromByteArray(buf.slice(start, end));\n  }\n}\n\nfunction utf8Slice(buf, start, end) {\n  end = Math.min(buf.length, end);\n  var res = [];\n  var i = start;\n\n  while (i < end) {\n    var firstByte = buf[i];\n    var codePoint = null;\n    var bytesPerSequence = firstByte > 0xEF ? 4 : firstByte > 0xDF ? 3 : firstByte > 0xBF ? 2 : 1;\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint;\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte;\n          }\n\n          break;\n\n        case 2:\n          secondByte = buf[i + 1];\n\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | secondByte & 0x3F;\n\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint;\n            }\n          }\n\n          break;\n\n        case 3:\n          secondByte = buf[i + 1];\n          thirdByte = buf[i + 2];\n\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | thirdByte & 0x3F;\n\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint;\n            }\n          }\n\n          break;\n\n        case 4:\n          secondByte = buf[i + 1];\n          thirdByte = buf[i + 2];\n          fourthByte = buf[i + 3];\n\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | fourthByte & 0x3F;\n\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint;\n            }\n          }\n\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD;\n      bytesPerSequence = 1;\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000;\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800);\n      codePoint = 0xDC00 | codePoint & 0x3FF;\n    }\n\n    res.push(codePoint);\n    i += bytesPerSequence;\n  }\n\n  return decodeCodePointsArray(res);\n} // Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\n\n\nvar MAX_ARGUMENTS_LENGTH = 0x1000;\n\nfunction decodeCodePointsArray(codePoints) {\n  var len = codePoints.length;\n\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints); // avoid extra slice()\n  } // Decode in chunks to avoid \"call stack size exceeded\".\n\n\n  var res = '';\n  var i = 0;\n\n  while (i < len) {\n    res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));\n  }\n\n  return res;\n}\n\nfunction asciiSlice(buf, start, end) {\n  var ret = '';\n  end = Math.min(buf.length, end);\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F);\n  }\n\n  return ret;\n}\n\nfunction latin1Slice(buf, start, end) {\n  var ret = '';\n  end = Math.min(buf.length, end);\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i]);\n  }\n\n  return ret;\n}\n\nfunction hexSlice(buf, start, end) {\n  var len = buf.length;\n  if (!start || start < 0) start = 0;\n  if (!end || end < 0 || end > len) end = len;\n  var out = '';\n\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i]);\n  }\n\n  return out;\n}\n\nfunction utf16leSlice(buf, start, end) {\n  var bytes = buf.slice(start, end);\n  var res = '';\n\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);\n  }\n\n  return res;\n}\n\nBuffer.prototype.slice = function slice(start, end) {\n  var len = this.length;\n  start = ~~start;\n  end = end === undefined ? len : ~~end;\n\n  if (start < 0) {\n    start += len;\n    if (start < 0) start = 0;\n  } else if (start > len) {\n    start = len;\n  }\n\n  if (end < 0) {\n    end += len;\n    if (end < 0) end = 0;\n  } else if (end > len) {\n    end = len;\n  }\n\n  if (end < start) end = start;\n  var newBuf;\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end);\n    newBuf.__proto__ = Buffer.prototype;\n  } else {\n    var sliceLen = end - start;\n    newBuf = new Buffer(sliceLen, undefined);\n\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start];\n    }\n  }\n\n  return newBuf;\n};\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\n\n\nfunction checkOffset(offset, ext, length) {\n  if (offset % 1 !== 0 || offset < 0) throw new RangeError('offset is not uint');\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length');\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n  var val = this[offset];\n  var mul = 1;\n  var i = 0;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul;\n  }\n\n  return val;\n};\n\nBuffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length);\n  }\n\n  var val = this[offset + --byteLength];\n  var mul = 1;\n\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul;\n  }\n\n  return val;\n};\n\nBuffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length);\n  return this[offset];\n};\n\nBuffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  return this[offset] | this[offset + 1] << 8;\n};\n\nBuffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  return this[offset] << 8 | this[offset + 1];\n};\n\nBuffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 0x1000000;\n};\n\nBuffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] * 0x1000000 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);\n};\n\nBuffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n  var val = this[offset];\n  var mul = 1;\n  var i = 0;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul;\n  }\n\n  mul *= 0x80;\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\n  return val;\n};\n\nBuffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n  var i = byteLength;\n  var mul = 1;\n  var val = this[offset + --i];\n\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul;\n  }\n\n  mul *= 0x80;\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\n  return val;\n};\n\nBuffer.prototype.readInt8 = function readInt8(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length);\n  if (!(this[offset] & 0x80)) return this[offset];\n  return (0xff - this[offset] + 1) * -1;\n};\n\nBuffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  var val = this[offset] | this[offset + 1] << 8;\n  return val & 0x8000 ? val | 0xFFFF0000 : val;\n};\n\nBuffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  var val = this[offset + 1] | this[offset] << 8;\n  return val & 0x8000 ? val | 0xFFFF0000 : val;\n};\n\nBuffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;\n};\n\nBuffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];\n};\n\nBuffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return read(this, offset, true, 23, 4);\n};\n\nBuffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return read(this, offset, false, 23, 4);\n};\n\nBuffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length);\n  return read(this, offset, true, 52, 8);\n};\n\nBuffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length);\n  return read(this, offset, false, 52, 8);\n};\n\nfunction checkInt(buf, value, offset, ext, max, min) {\n  if (!internalIsBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance');\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds');\n  if (offset + ext > buf.length) throw new RangeError('Index out of range');\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1;\n    checkInt(this, value, offset, byteLength, maxBytes, 0);\n  }\n\n  var mul = 1;\n  var i = 0;\n  this[offset] = value & 0xFF;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = value / mul & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1;\n    checkInt(this, value, offset, byteLength, maxBytes, 0);\n  }\n\n  var i = byteLength - 1;\n  var mul = 1;\n  this[offset + i] = value & 0xFF;\n\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = value / mul & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);\n  this[offset] = value & 0xff;\n  return offset + 1;\n};\n\nfunction objectWriteUInt16(buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1;\n\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & 0xff << 8 * (littleEndian ? i : 1 - i)) >>> (littleEndian ? i : 1 - i) * 8;\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n  } else {\n    objectWriteUInt16(this, value, offset, true);\n  }\n\n  return offset + 2;\n};\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 8;\n    this[offset + 1] = value & 0xff;\n  } else {\n    objectWriteUInt16(this, value, offset, false);\n  }\n\n  return offset + 2;\n};\n\nfunction objectWriteUInt32(buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1;\n\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = value >>> (littleEndian ? i : 3 - i) * 8 & 0xff;\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = value >>> 24;\n    this[offset + 2] = value >>> 16;\n    this[offset + 1] = value >>> 8;\n    this[offset] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, true);\n  }\n\n  return offset + 4;\n};\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 24;\n    this[offset + 1] = value >>> 16;\n    this[offset + 2] = value >>> 8;\n    this[offset + 3] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, false);\n  }\n\n  return offset + 4;\n};\n\nBuffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1);\n    checkInt(this, value, offset, byteLength, limit - 1, -limit);\n  }\n\n  var i = 0;\n  var mul = 1;\n  var sub = 0;\n  this[offset] = value & 0xFF;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1;\n    }\n\n    this[offset + i] = (value / mul >> 0) - sub & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1);\n    checkInt(this, value, offset, byteLength, limit - 1, -limit);\n  }\n\n  var i = byteLength - 1;\n  var mul = 1;\n  var sub = 0;\n  this[offset + i] = value & 0xFF;\n\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1;\n    }\n\n    this[offset + i] = (value / mul >> 0) - sub & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);\n  if (value < 0) value = 0xff + value + 1;\n  this[offset] = value & 0xff;\n  return offset + 1;\n};\n\nBuffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n  } else {\n    objectWriteUInt16(this, value, offset, true);\n  }\n\n  return offset + 2;\n};\n\nBuffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 8;\n    this[offset + 1] = value & 0xff;\n  } else {\n    objectWriteUInt16(this, value, offset, false);\n  }\n\n  return offset + 2;\n};\n\nBuffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n    this[offset + 2] = value >>> 16;\n    this[offset + 3] = value >>> 24;\n  } else {\n    objectWriteUInt32(this, value, offset, true);\n  }\n\n  return offset + 4;\n};\n\nBuffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\n  if (value < 0) value = 0xffffffff + value + 1;\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 24;\n    this[offset + 1] = value >>> 16;\n    this[offset + 2] = value >>> 8;\n    this[offset + 3] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, false);\n  }\n\n  return offset + 4;\n};\n\nfunction checkIEEE754(buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range');\n  if (offset < 0) throw new RangeError('Index out of range');\n}\n\nfunction writeFloat(buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4);\n  }\n\n  write(buf, value, offset, littleEndian, 23, 4);\n  return offset + 4;\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert);\n};\n\nBuffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert);\n};\n\nfunction writeDouble(buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8);\n  }\n\n  write(buf, value, offset, littleEndian, 52, 8);\n  return offset + 8;\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert);\n};\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert);\n}; // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\n\n\nBuffer.prototype.copy = function copy(target, targetStart, start, end) {\n  if (!start) start = 0;\n  if (!end && end !== 0) end = this.length;\n  if (targetStart >= target.length) targetStart = target.length;\n  if (!targetStart) targetStart = 0;\n  if (end > 0 && end < start) end = start; // Copy 0 bytes; we're done\n\n  if (end === start) return 0;\n  if (target.length === 0 || this.length === 0) return 0; // Fatal error conditions\n\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds');\n  }\n\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds');\n  if (end < 0) throw new RangeError('sourceEnd out of bounds'); // Are we oob?\n\n  if (end > this.length) end = this.length;\n\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start;\n  }\n\n  var len = end - start;\n  var i;\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start];\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start];\n    }\n  } else {\n    Uint8Array.prototype.set.call(target, this.subarray(start, start + len), targetStart);\n  }\n\n  return len;\n}; // Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\n\n\nBuffer.prototype.fill = function fill(val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start;\n      start = 0;\n      end = this.length;\n    } else if (typeof end === 'string') {\n      encoding = end;\n      end = this.length;\n    }\n\n    if (val.length === 1) {\n      var code = val.charCodeAt(0);\n\n      if (code < 256) {\n        val = code;\n      }\n    }\n\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string');\n    }\n\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding);\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255;\n  } // Invalid ranges are not set to a default, so can range check early.\n\n\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index');\n  }\n\n  if (end <= start) {\n    return this;\n  }\n\n  start = start >>> 0;\n  end = end === undefined ? this.length : end >>> 0;\n  if (!val) val = 0;\n  var i;\n\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val;\n    }\n  } else {\n    var bytes = internalIsBuffer(val) ? val : utf8ToBytes(new Buffer(val, encoding).toString());\n    var len = bytes.length;\n\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len];\n    }\n  }\n\n  return this;\n}; // HELPER FUNCTIONS\n// ================\n\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g;\n\nfunction base64clean(str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, ''); // Node converts strings with length < 2 to ''\n\n  if (str.length < 2) return ''; // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n\n  while (str.length % 4 !== 0) {\n    str = str + '=';\n  }\n\n  return str;\n}\n\nfunction stringtrim(str) {\n  if (str.trim) return str.trim();\n  return str.replace(/^\\s+|\\s+$/g, '');\n}\n\nfunction toHex(n) {\n  if (n < 16) return '0' + n.toString(16);\n  return n.toString(16);\n}\n\nfunction utf8ToBytes(string, units) {\n  units = units || Infinity;\n  var codePoint;\n  var length = string.length;\n  var leadSurrogate = null;\n  var bytes = [];\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i); // is surrogate component\n\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n          continue;\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n          continue;\n        } // valid lead\n\n\n        leadSurrogate = codePoint;\n        continue;\n      } // 2 leads in a row\n\n\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n        leadSurrogate = codePoint;\n        continue;\n      } // valid surrogate pair\n\n\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n    }\n\n    leadSurrogate = null; // encode utf8\n\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break;\n      bytes.push(codePoint);\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break;\n      bytes.push(codePoint >> 0x6 | 0xC0, codePoint & 0x3F | 0x80);\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break;\n      bytes.push(codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break;\n      bytes.push(codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n    } else {\n      throw new Error('Invalid code point');\n    }\n  }\n\n  return bytes;\n}\n\nfunction asciiToBytes(str) {\n  var byteArray = [];\n\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF);\n  }\n\n  return byteArray;\n}\n\nfunction utf16leToBytes(str, units) {\n  var c, hi, lo;\n  var byteArray = [];\n\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break;\n    c = str.charCodeAt(i);\n    hi = c >> 8;\n    lo = c % 256;\n    byteArray.push(lo);\n    byteArray.push(hi);\n  }\n\n  return byteArray;\n}\n\nfunction base64ToBytes(str) {\n  return toByteArray(base64clean(str));\n}\n\nfunction blitBuffer(src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if (i + offset >= dst.length || i >= src.length) break;\n    dst[i + offset] = src[i];\n  }\n\n  return i;\n}\n\nfunction isnan(val) {\n  return val !== val; // eslint-disable-line no-self-compare\n} // the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence\n// The _isBuffer check is for Safari 5-7 support, because it's missing\n// Object.prototype.constructor. Remove this eventually\n\n\nfunction isBuffer$1(obj) {\n  return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj));\n}\n\nfunction isFastBuffer(obj) {\n  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj);\n} // For Node v0.10 support. Remove this eventually.\n\n\nfunction isSlowBuffer(obj) {\n  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0));\n} // based off https://github.com/defunctzombie/node-process/blob/master/browser.js\n\n\nfunction defaultSetTimout() {\n  throw new Error('setTimeout has not been defined');\n}\n\nfunction defaultClearTimeout() {\n  throw new Error('clearTimeout has not been defined');\n}\n\nvar cachedSetTimeout = defaultSetTimout;\nvar cachedClearTimeout = defaultClearTimeout;\n\nif (typeof global$1.setTimeout === 'function') {\n  cachedSetTimeout = setTimeout;\n}\n\nif (typeof global$1.clearTimeout === 'function') {\n  cachedClearTimeout = clearTimeout;\n}\n\nfunction runTimeout(fun) {\n  if (cachedSetTimeout === setTimeout) {\n    //normal enviroments in sane situations\n    return setTimeout(fun, 0);\n  } // if setTimeout wasn't available but was latter defined\n\n\n  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n    cachedSetTimeout = setTimeout;\n    return setTimeout(fun, 0);\n  }\n\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedSetTimeout(fun, 0);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n      return cachedSetTimeout.call(null, fun, 0);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n      return cachedSetTimeout.call(this, fun, 0);\n    }\n  }\n}\n\nfunction runClearTimeout(marker) {\n  if (cachedClearTimeout === clearTimeout) {\n    //normal enviroments in sane situations\n    return clearTimeout(marker);\n  } // if clearTimeout wasn't available but was latter defined\n\n\n  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n    cachedClearTimeout = clearTimeout;\n    return clearTimeout(marker);\n  }\n\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedClearTimeout(marker);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n      return cachedClearTimeout.call(null, marker);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n      // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n      return cachedClearTimeout.call(this, marker);\n    }\n  }\n}\n\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n  if (!draining || !currentQueue) {\n    return;\n  }\n\n  draining = false;\n\n  if (currentQueue.length) {\n    queue = currentQueue.concat(queue);\n  } else {\n    queueIndex = -1;\n  }\n\n  if (queue.length) {\n    drainQueue();\n  }\n}\n\nfunction drainQueue() {\n  if (draining) {\n    return;\n  }\n\n  var timeout = runTimeout(cleanUpNextTick);\n  draining = true;\n  var len = queue.length;\n\n  while (len) {\n    currentQueue = queue;\n    queue = [];\n\n    while (++queueIndex < len) {\n      if (currentQueue) {\n        currentQueue[queueIndex].run();\n      }\n    }\n\n    queueIndex = -1;\n    len = queue.length;\n  }\n\n  currentQueue = null;\n  draining = false;\n  runClearTimeout(timeout);\n}\n\nfunction nextTick(fun) {\n  var args = new Array(arguments.length - 1);\n\n  if (arguments.length > 1) {\n    for (var i = 1; i < arguments.length; i++) {\n      args[i - 1] = arguments[i];\n    }\n  }\n\n  queue.push(new Item(fun, args));\n\n  if (queue.length === 1 && !draining) {\n    runTimeout(drainQueue);\n  }\n} // v8 likes predictible objects\n\n\nfunction Item(fun, array) {\n  this.fun = fun;\n  this.array = array;\n}\n\nItem.prototype.run = function () {\n  this.fun.apply(null, this.array);\n};\n\nvar title = 'browser';\nvar platform = 'browser';\nvar browser = true;\nvar env = {};\nvar argv = [];\nvar version = ''; // empty string to avoid regexp issues\n\nvar versions = {};\nvar release = {};\nvar config = {};\n\nfunction noop() {}\n\nvar on = noop;\nvar addListener = noop;\nvar once = noop;\nvar off = noop;\nvar removeListener = noop;\nvar removeAllListeners = noop;\nvar emit = noop;\n\nfunction binding(name) {\n  throw new Error('process.binding is not supported');\n}\n\nfunction cwd() {\n  return '/';\n}\n\nfunction chdir(dir) {\n  throw new Error('process.chdir is not supported');\n}\n\nfunction umask() {\n  return 0;\n} // from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js\n\n\nvar performance = global$1.performance || {};\n\nvar performanceNow = performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow || function () {\n  return new Date().getTime();\n}; // generate timestamp or delta\n// see http://nodejs.org/api/process.html#process_process_hrtime\n\n\nfunction hrtime(previousTimestamp) {\n  var clocktime = performanceNow.call(performance) * 1e-3;\n  var seconds = Math.floor(clocktime);\n  var nanoseconds = Math.floor(clocktime % 1 * 1e9);\n\n  if (previousTimestamp) {\n    seconds = seconds - previousTimestamp[0];\n    nanoseconds = nanoseconds - previousTimestamp[1];\n\n    if (nanoseconds < 0) {\n      seconds--;\n      nanoseconds += 1e9;\n    }\n  }\n\n  return [seconds, nanoseconds];\n}\n\nvar startTime = new Date();\n\nfunction uptime() {\n  var currentTime = new Date();\n  var dif = currentTime - startTime;\n  return dif / 1000;\n}\n\nvar browser$1 = {\n  nextTick: nextTick,\n  title: title,\n  browser: browser,\n  env: env,\n  argv: argv,\n  version: version,\n  versions: versions,\n  on: on,\n  addListener: addListener,\n  once: once,\n  off: off,\n  removeListener: removeListener,\n  removeAllListeners: removeAllListeners,\n  emit: emit,\n  binding: binding,\n  cwd: cwd,\n  chdir: chdir,\n  umask: umask,\n  hrtime: hrtime,\n  platform: platform,\n  release: release,\n  config: config,\n  uptime: uptime\n};\nvar process = browser$1;\nvar inherits;\n\nif (typeof Object.create === 'function') {\n  inherits = function inherits(ctor, superCtor) {\n    // implementation from standard node.js 'util' module\n    ctor.super_ = superCtor;\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  inherits = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor;\n\n    var TempCtor = function TempCtor() {};\n\n    TempCtor.prototype = superCtor.prototype;\n    ctor.prototype = new TempCtor();\n    ctor.prototype.constructor = ctor;\n  };\n}\n\nvar inherits$1 = inherits;\nvar formatRegExp = /%[sdj%]/g;\n\nfunction format(f) {\n  if (!isString(f)) {\n    var objects = [];\n\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function (x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n\n    switch (x) {\n      case '%s':\n        return String(args[i++]);\n\n      case '%d':\n        return Number(args[i++]);\n\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n\n      default:\n        return x;\n    }\n  });\n\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n\n  return str;\n} // Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\n\n\nfunction deprecate(fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global$1.process)) {\n    return function () {\n      return deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n\n      warned = true;\n    }\n\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\nvar debugs = {};\nvar debugEnviron;\n\nfunction debuglog(set) {\n  if (isUndefined(debugEnviron)) debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = 0;\n\n      debugs[set] = function () {\n        var msg = format.apply(null, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function () {};\n    }\n  }\n\n  return debugs[set];\n}\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n\n/* legacy: obj, showHidden, depth, colors*/\n\n\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  }; // legacy...\n\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    _extend(ctx, opts);\n  } // set default options\n\n\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n} // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\n\n\ninspect.colors = {\n  'bold': [1, 22],\n  'italic': [3, 23],\n  'underline': [4, 24],\n  'inverse': [7, 27],\n  'white': [37, 39],\n  'grey': [90, 39],\n  'black': [30, 39],\n  'blue': [34, 39],\n  'cyan': [36, 39],\n  'green': [32, 39],\n  'magenta': [35, 39],\n  'red': [31, 39],\n  'yellow': [33, 39]\n}; // Don't use 'blue' not visible on cmd.exe\n\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return \"\\x1B[\" + inspect.colors[style][0] + 'm' + str + \"\\x1B[\" + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\nfunction arrayToHash(array) {\n  var hash = {};\n  array.forEach(function (val, idx) {\n    hash[val] = true;\n  });\n  return hash;\n}\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect && value && isFunction(value.inspect) && // Filter out the util module, it's inspect function is special\n  value.inspect !== inspect && // Also filter out any prototype objects using the circular check.\n  !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n\n    return ret;\n  } // Primitive types cannot have properties\n\n\n  var primitive = formatPrimitive(ctx, value);\n\n  if (primitive) {\n    return primitive;\n  } // Look up the keys of the object.\n\n\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  } // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n\n\n  if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  } // Some type of object without properties can be shortcutted.\n\n\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '',\n      array = false,\n      braces = ['{', '}']; // Make Array say that they are Array\n\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  } // Make functions say that they are functions\n\n\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  } // Make RegExps say that they are RegExps\n\n\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  } // Make dates with properties first say the date\n\n\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  } // Make error with message first say the error\n\n\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n  var output;\n\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function (key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n  return reduceToSingleString(output, base, braces);\n}\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value)) return ctx.stylize('undefined', 'undefined');\n\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '').replace(/'/g, \"\\\\'\").replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n\n  if (isNumber(value)) return ctx.stylize('' + value, 'number');\n  if (isBoolean(value)) return ctx.stylize('' + value, 'boolean'); // For some reason typeof null is \"object\", so special case here.\n\n  if (isNull(value)) return ctx.stylize('null', 'null');\n}\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n\n  keys.forEach(function (key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));\n    }\n  });\n  return output;\n}\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || {\n    value: value[key]\n  };\n\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function (line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function (line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n\n    name = JSON.stringify('' + key);\n\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\").replace(/\\\\\"/g, '\"').replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\nfunction reduceToSingleString(output, base, braces) {\n  var length = output.reduce(function (prev, cur) {\n    if (cur.indexOf('\\n') >= 0) ;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] + (base === '' ? '' : base + '\\n ') + ' ' + output.join(',\\n  ') + ' ' + braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n} // NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\n\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\n\nfunction isNull(arg) {\n  return arg === null;\n}\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\n\nfunction isError(e) {\n  return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);\n}\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isPrimitive(arg) {\n  return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || typeof arg === 'symbol' || // ES6 symbol\n  typeof arg === 'undefined';\n}\n\nfunction isBuffer(maybeBuf) {\n  return Buffer.isBuffer(maybeBuf);\n}\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']; // 26 Feb 16:19:34\n\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n} // log is just a thin wrapper to console.log that prepends a timestamp\n\n\nfunction log() {\n  console.log('%s - %s', timestamp(), format.apply(null, arguments));\n}\n\nfunction _extend(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n  var keys = Object.keys(add);\n  var i = keys.length;\n\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n\n  return origin;\n}\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nvar util = {\n  inherits: inherits$1,\n  _extend: _extend,\n  log: log,\n  isBuffer: isBuffer,\n  isPrimitive: isPrimitive,\n  isFunction: isFunction,\n  isError: isError,\n  isDate: isDate,\n  isObject: isObject,\n  isRegExp: isRegExp,\n  isUndefined: isUndefined,\n  isSymbol: isSymbol,\n  isString: isString,\n  isNumber: isNumber,\n  isNullOrUndefined: isNullOrUndefined,\n  isNull: isNull,\n  isBoolean: isBoolean,\n  isArray: isArray,\n  inspect: inspect,\n  deprecate: deprecate,\n  format: format,\n  debuglog: debuglog\n};\n\nvar saveSharedIndices = /*#__PURE__*/function () {\n  var _saveSharedIndices = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee26(indice, publicPath) {\n    var writeFile, mkdir, exists, dir, existDir, _iterator, _step, _step$value, v;\n\n    return _regeneratorRuntime.wrap(function _callee26$(_context26) {\n      while (1) {\n        switch (_context26.prev = _context26.next) {\n          case 0:\n            if (publicPath === void 0) {\n              publicPath = '.';\n            }\n\n            writeFile = util.promisify(fs.writeFile);\n            mkdir = util.promisify(fs.mkdir);\n            exists = util.promisify(fs.exists);\n            dir = join(publicPath, indice.id);\n            _context26.next = 7;\n            return exists(dir);\n\n          case 7:\n            existDir = _context26.sent;\n\n            if (existDir) {\n              _context26.next = 11;\n              break;\n            }\n\n            _context26.next = 11;\n            return mkdir(dir);\n\n          case 11:\n            _context26.next = 13;\n            return writeFile(join(dir, 'index.json'), JSON.stringify(indice.serialize()));\n\n          case 13:\n            _iterator = _createForOfIteratorHelperLoose(indice.indices);\n\n          case 14:\n            if ((_step = _iterator()).done) {\n              _context26.next = 22;\n              break;\n            }\n\n            _step$value = _step.value;\n            _step$value[0];\n            v = _step$value[1];\n            _context26.next = 20;\n            return writeFile(join(dir, \"chunk_\" + v.id + \".json\"), JSON.stringify({\n              data: v.serializeData(),\n              options: {\n                id: v.id\n              }\n            }));\n\n          case 20:\n            _context26.next = 14;\n            break;\n\n          case 22:\n          case \"end\":\n            return _context26.stop();\n        }\n      }\n    }, _callee26);\n  }));\n\n  function saveSharedIndices(_x33, _x34) {\n    return _saveSharedIndices.apply(this, arguments);\n  }\n\n  return saveSharedIndices;\n}();\n\nvar restoreSharedIndices$1 = /*#__PURE__*/function () {\n  var _restoreSharedIndices = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee28(id, deserializeShared, deserialize) {\n    var readFile, load, jsonRaw, json;\n    return _regeneratorRuntime.wrap(function _callee28$(_context28) {\n      while (1) {\n        switch (_context28.prev = _context28.next) {\n          case 0:\n            readFile = util.promisify(fs.readFile);\n\n            load = /*#__PURE__*/function () {\n              var _load5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee27(options) {\n                return _regeneratorRuntime.wrap(function _callee27$(_context27) {\n                  while (1) {\n                    switch (_context27.prev = _context27.next) {\n                      case 0:\n                        _context27.t0 = JSON;\n                        _context27.next = 3;\n                        return readFile(\"./\" + id + \"/chunk_\" + options.id + \".json\");\n\n                      case 3:\n                        _context27.t1 = _context27.sent.toString();\n                        return _context27.abrupt(\"return\", _context27.t0.parse.call(_context27.t0, _context27.t1));\n\n                      case 5:\n                      case \"end\":\n                        return _context27.stop();\n                    }\n                  }\n                }, _callee27);\n              }));\n\n              function load(_x38) {\n                return _load5.apply(this, arguments);\n              }\n\n              return load;\n            }();\n\n            _context28.next = 4;\n            return readFile(\"./\" + id + \"/index.json\");\n\n          case 4:\n            jsonRaw = _context28.sent;\n            json = JSON.parse(jsonRaw.toString());\n            return _context28.abrupt(\"return\", deserializeShared(json.data, json.options, function (options) {\n              return deserialize(_objectSpread(_objectSpread({}, options), {}, {\n                load: load\n              }));\n            }));\n\n          case 7:\n          case \"end\":\n            return _context28.stop();\n        }\n      }\n    }, _callee28);\n  }));\n\n  function restoreSharedIndices(_x35, _x36, _x37) {\n    return _restoreSharedIndices.apply(this, arguments);\n  }\n\n  return restoreSharedIndices;\n}();\n\nvar restoreSharedIndices = /*#__PURE__*/function () {\n  var _restoreSharedIndices2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee31(_ref) {\n    var id, baseUrl, deserialize, deserializeShared, loadChunk, load;\n    return _regeneratorRuntime.wrap(function _callee31$(_context31) {\n      while (1) {\n        switch (_context31.prev = _context31.next) {\n          case 0:\n            id = _ref.id, baseUrl = _ref.baseUrl, deserialize = _ref.deserialize, deserializeShared = _ref.deserializeShared;\n\n            loadChunk = /*#__PURE__*/function () {\n              var _loadChunk = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee29(options) {\n                var response;\n                return _regeneratorRuntime.wrap(function _callee29$(_context29) {\n                  while (1) {\n                    switch (_context29.prev = _context29.next) {\n                      case 0:\n                        _context29.next = 2;\n                        return fetch(baseUrl + \"/\" + id + \"/chunk_\" + options.id + \".json\");\n\n                      case 2:\n                        response = _context29.sent;\n                        return _context29.abrupt(\"return\", response.json());\n\n                      case 4:\n                      case \"end\":\n                        return _context29.stop();\n                    }\n                  }\n                }, _callee29);\n              }));\n\n              function loadChunk(_x40) {\n                return _loadChunk.apply(this, arguments);\n              }\n\n              return loadChunk;\n            }();\n\n            load = /*#__PURE__*/function () {\n              var _load6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee30(options) {\n                var response;\n                return _regeneratorRuntime.wrap(function _callee30$(_context30) {\n                  while (1) {\n                    switch (_context30.prev = _context30.next) {\n                      case 0:\n                        _context30.next = 2;\n                        return fetch(baseUrl + \"/\" + id + \"/index.json\", {\n                          method: 'GET',\n                          credentials: 'include',\n                          mode: 'no-cors'\n                        });\n\n                      case 2:\n                        response = _context30.sent;\n                        return _context30.abrupt(\"return\", response.json());\n\n                      case 4:\n                      case \"end\":\n                        return _context30.stop();\n                    }\n                  }\n                }, _callee30);\n              }));\n\n              function load(_x41) {\n                return _load6.apply(this, arguments);\n              }\n\n              return load;\n            }();\n\n            return _context31.abrupt(\"return\", deserializeShared({\n              id: id,\n              load: load\n            }, function (options) {\n              return deserialize(_objectSpread(_objectSpread({}, options), {}, {\n                load: loadChunk\n              }));\n            }));\n\n          case 4:\n          case \"end\":\n            return _context31.stop();\n        }\n      }\n    }, _callee31);\n  }));\n\n  function restoreSharedIndices(_x39) {\n    return _restoreSharedIndices2.apply(this, arguments);\n  }\n\n  return restoreSharedIndices;\n}();\n\nexport { Db, NgramIndice, RangeLinearIndice, Schema, SimpleIndice, TextLexIndice, instance as log, restoreSharedIndices$1 as restoreSharedIndices, restoreSharedIndices as restoreSharedIndicesBrowser, saveSharedIndices };"],"sourceRoot":""}