{"version":3,"file":"search.min.js","mappings":"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","sources":["webpack://daux.io/./node_modules/flexsearch/dist/module/async.js","webpack://daux.io/./node_modules/flexsearch/dist/module/cache.js","webpack://daux.io/./node_modules/flexsearch/dist/module/common.js","webpack://daux.io/./node_modules/flexsearch/dist/module/lang.js","webpack://daux.io/./node_modules/flexsearch/dist/module/lang/latin/default.js","webpack://daux.io/./node_modules/flexsearch/dist/module/global.js","webpack://daux.io/./node_modules/flexsearch/dist/module/preset.js","webpack://daux.io/./node_modules/flexsearch/dist/module/index.js","webpack://daux.io/./node_modules/flexsearch/dist/module/intersect.js","webpack://daux.io/./node_modules/flexsearch/dist/module/serialize.js","webpack://daux.io/./node_modules/flexsearch/dist/module/type.js","webpack://daux.io/./node_modules/flexsearch/dist/module/worker/handler.js","webpack://daux.io/./node_modules/flexsearch/dist/module/worker/index.js","webpack://daux.io/webpack/bootstrap","webpack://daux.io/webpack/runtime/define property getters","webpack://daux.io/webpack/runtime/hasOwnProperty shorthand","webpack://daux.io/./node_modules/flexsearch/dist/module/document.js","webpack://daux.io/./node_modules/preact/dist/preact.module.js","webpack://daux.io/./src/js/search/translation.js","webpack://daux.io/./src/js/search/Pagination.js","webpack://daux.io/./src/js/search/Result.js","webpack://daux.io/./src/js/search/Search.js","webpack://daux.io/./src/js/search/index.js"],"sourcesContent":["import { IndexInterface, DocumentInterface } from \"./type.js\";\n//import { promise as Promise } from \"./polyfill.js\";\nimport { is_function, is_object, is_string } from \"./common.js\";\n\nexport default function (prototype) {\n\n    register(prototype, \"add\");\n    register(prototype, \"append\");\n    register(prototype, \"search\");\n    register(prototype, \"update\");\n    register(prototype, \"remove\");\n}\n\nfunction register(prototype, key) {\n\n    prototype[key + \"Async\"] = function () {\n\n        /** @type {IndexInterface|DocumentInterface} */\n        const self = this,\n              args = /*[].slice.call*/arguments,\n              arg = args[args.length - 1];\n\n        let callback;\n\n        if (is_function(arg)) {\n\n            callback = arg;\n            delete args[args.length - 1];\n        }\n\n        const promise = new Promise(function (resolve) {\n\n            setTimeout(function () {\n\n                self.async = !0;\n                const res = self[key].apply(self, args);\n                self.async = !1;\n                resolve(res);\n            });\n        });\n\n        if (callback) {\n\n            promise.then(callback);\n            return this;\n        } else {\n\n            return promise;\n        }\n    };\n}","import { IndexInterface, DocumentInterface } from \"./type.js\";\nimport { create_object, is_object } from \"./common.js\";\n\n/**\r\n * @param {boolean|number=} limit\r\n * @constructor\r\n */\n\nfunction CacheClass(limit) {\n\n    /** @private */\n    this.limit = !0 !== limit && limit;\n\n    /** @private */\n    this.cache = create_object();\n\n    /** @private */\n    this.queue = [];\n\n    //this.clear();\n}\n\nexport default CacheClass;\n\n/**\r\n * @param {string|Object} query\r\n * @param {number|Object=} limit\r\n * @param {Object=} options\r\n * @this {IndexInterface}\r\n * @returns {Array<number|string>}\r\n */\n\nexport function searchCache(query, limit, options) {\n\n    if (is_object(query)) {\n\n        query = query.query;\n    }\n\n    let cache = this.cache.get(query);\n\n    if (!cache) {\n\n        cache = this.search(query, limit, options);\n        this.cache.set(query, cache);\n    }\n\n    return cache;\n}\n\n// CacheClass.prototype.clear = function(){\n//\n//     /** @private */\n//     this.cache = create_object();\n//\n//     /** @private */\n//     this.queue = [];\n// };\n\nCacheClass.prototype.set = function (key, value) {\n\n    if (!this.cache[key]) {\n\n        // it is just a shame that native function array.shift() performs so bad\n\n        // const length = this.queue.length;\n        //\n        // this.queue[length] = key;\n        //\n        // if(length === this.limit){\n        //\n        //     delete this.cache[this.queue.shift()];\n        // }\n\n        // the same bad performance\n\n        // this.queue.unshift(key);\n        //\n        // if(this.queue.length === this.limit){\n        //\n        //     this.queue.pop();\n        // }\n\n        // fast implementation variant\n\n        // let length = this.queue.length;\n        //\n        // if(length === this.limit){\n        //\n        //     length--;\n        //\n        //     delete this.cache[this.queue[0]];\n        //\n        //     for(let x = 0; x < length; x++){\n        //\n        //         this.queue[x] = this.queue[x + 1];\n        //     }\n        // }\n        //\n        // this.queue[length] = key;\n\n        // current fastest implementation variant\n        // theoretically that should not perform better compared to the example above\n\n        let length = this.queue.length;\n\n        if (length === this.limit) {\n\n            delete this.cache[this.queue[length - 1]];\n        } else {\n\n            length++;\n        }\n\n        for (let x = length - 1; 0 < x; x--) {\n\n            this.queue[x] = this.queue[x - 1];\n        }\n\n        this.queue[0] = key;\n    }\n\n    this.cache[key] = value;\n};\n\nCacheClass.prototype.get = function (key) {\n\n    const cache = this.cache[key];\n\n    if (this.limit && cache) {\n\n        // probably the indexOf() method performs faster when matched content is on front (left-to-right)\n        // using lastIndexOf() does not help, it performs almost slower\n\n        const pos = this.queue.indexOf(key);\n\n        // if(pos < this.queue.length - 1){\n        //\n        //     const tmp = this.queue[pos];\n        //     this.queue[pos] = this.queue[pos + 1];\n        //     this.queue[pos + 1] = tmp;\n        // }\n\n        if (pos) {\n\n            const tmp = this.queue[pos - 1];\n            this.queue[pos - 1] = this.queue[pos];\n            this.queue[pos] = tmp;\n        }\n    }\n\n    return cache;\n};\n\nCacheClass.prototype.del = function (id) {\n\n    for (let i = 0, item, key; i < this.queue.length; i++) {\n\n        key = this.queue[i];\n        item = this.cache[key];\n\n        if (item.includes(id)) {\n\n            this.queue.splice(i--, 1);\n            delete this.cache[key];\n        }\n    }\n};","export function parse_option(value, default_value) {\n\n    return \"undefined\" != typeof value ? value : default_value;\n}\n\n/**\r\n * @param {!number} count\r\n * @returns {Array<Object>}\r\n */\n\nexport function create_object_array(count) {\n\n    const array = Array(count);\n\n    for (let i = 0; i < count; i++) {\n\n        array[i] = create_object();\n    }\n\n    return array;\n}\n\nexport function create_arrays(count) {\n\n    const array = Array(count);\n\n    for (let i = 0; i < count; i++) {\n\n        array[i] = [];\n    }\n\n    return array;\n}\n\n/**\r\n * @param {!Object} obj\r\n * @returns {Array<string>}\r\n */\n\nexport function get_keys(obj) {\n\n    return Object.keys(obj);\n}\n\nexport function create_object() {\n\n    return Object.create(null);\n}\n\nexport function concat(arrays) {\n\n    return [].concat.apply([], arrays);\n}\n\nexport function sort_by_length_down(a, b) {\n\n    return b.length - a.length;\n}\n\nexport function is_array(val) {\n\n    return val.constructor === Array;\n}\n\nexport function is_string(val) {\n\n    return \"string\" == typeof val;\n}\n\nexport function is_object(val) {\n\n    return \"object\" == typeof val;\n}\n\nexport function is_function(val) {\n\n    return \"function\" == typeof val;\n}","import { IndexInterface } from \"./type.js\";\nimport { create_object, get_keys } from \"./common.js\";\n\n/**\r\n * @param {!string} str\r\n * @param {boolean|Array<string|RegExp>=} normalize\r\n * @param {boolean|string|RegExp=} split\r\n * @param {boolean=} _collapse\r\n * @returns {string|Array<string>}\r\n * @this IndexInterface\r\n */\n\nexport function pipeline(str, normalize, split, _collapse) {\n\n    if (str) {\n\n        if (normalize) {\n\n            str = replace(str, /** @type {Array<string|RegExp>} */normalize);\n        }\n\n        if (this.matcher) {\n\n            str = replace(str, this.matcher);\n        }\n\n        if (this.stemmer && 1 < str.length) {\n\n            str = replace(str, this.stemmer);\n        }\n\n        if (_collapse && 1 < str.length) {\n\n            str = collapse(str);\n        }\n\n        if (split || \"\" === split) {\n\n            const words = str.split( /** @type {string|RegExp} */split);\n\n            return this.filter ? filter(words, this.filter) : words;\n        }\n    }\n\n    return str;\n}\n\n// TODO improve normalize + remove non-delimited chars like in \"I'm\" + split on whitespace+\n\nexport const regex_whitespace = /[\\p{Z}\\p{S}\\p{P}\\p{C}]+/u;\n// https://github.com/nextapps-de/flexsearch/pull/414\n//export const regex_whitespace = /[\\s\\xA0\\u2000-\\u200B\\u2028\\u2029\\u3000\\ufeff!\"#$%&'()*+,\\-./:;<=>?@[\\\\\\]^_`{|}~]/\nconst regex_normalize = /[\\u0300-\\u036f]/g;\n\nexport function normalize(str) {\n\n    if (str.normalize) {\n\n        str = str.normalize(\"NFD\").replace(regex_normalize, \"\");\n    }\n\n    return str;\n}\n\n/**\r\n * @param {!string} str\r\n * @param {boolean|Array<string|RegExp>=} normalize\r\n * @param {boolean|string|RegExp=} split\r\n * @param {boolean=} _collapse\r\n * @returns {string|Array<string>}\r\n */\n\n// FlexSearch.prototype.pipeline = function(str, normalize, split, _collapse){\n//\n//     if(str){\n//\n//         if(normalize && str){\n//\n//             str = replace(str, /** @type {Array<string|RegExp>} */ (normalize));\n//         }\n//\n//         if(str && this.matcher){\n//\n//             str = replace(str, this.matcher);\n//         }\n//\n//         if(this.stemmer && str.length > 1){\n//\n//             str = replace(str, this.stemmer);\n//         }\n//\n//         if(_collapse && str.length > 1){\n//\n//             str = collapse(str);\n//         }\n//\n//         if(str){\n//\n//             if(split || (split === \"\")){\n//\n//                 const words = str.split(/** @type {string|RegExp} */ (split));\n//\n//                 return this.filter ? filter(words, this.filter) : words;\n//             }\n//         }\n//     }\n//\n//     return str;\n// };\n\n// export function pipeline(str, normalize, matcher, stemmer, split, _filter, _collapse){\n//\n//     if(str){\n//\n//         if(normalize && str){\n//\n//             str = replace(str, normalize);\n//         }\n//\n//         if(matcher && str){\n//\n//             str = replace(str, matcher);\n//         }\n//\n//         if(stemmer && str.length > 1){\n//\n//             str = replace(str, stemmer);\n//         }\n//\n//         if(_collapse && str.length > 1){\n//\n//             str = collapse(str);\n//         }\n//\n//         if(str){\n//\n//             if(split !== false){\n//\n//                 str = str.split(split);\n//\n//                 if(_filter){\n//\n//                     str = filter(str, _filter);\n//                 }\n//             }\n//         }\n//     }\n//\n//     return str;\n// }\n\n\n/**\r\n * @param {Array<string>} words\r\n * @returns {Object<string, string>}\r\n */\n\nexport function init_filter(words) {\n\n    const filter = create_object();\n\n    for (let i = 0, length = words.length; i < length; i++) {\n\n        filter[words[i]] = 1;\n    }\n\n    return filter;\n}\n\n/**\r\n * @param {!Object<string, string>} obj\r\n * @param {boolean} is_stemmer\r\n * @returns {Array}\r\n */\n\nexport function init_stemmer_or_matcher(obj, is_stemmer) {\n    const keys = get_keys(obj),\n          length = keys.length,\n          final = [];\n\n\n    let removal = \"\",\n        count = 0;\n\n    for (let i = 0, key, tmp; i < length; i++) {\n\n        key = keys[i];\n        tmp = obj[key];\n\n        if (tmp) {\n\n            final[count++] = regex(is_stemmer ? \"(?!\\\\b)\" + key + \"(\\\\b|_)\" : key);\n            final[count++] = tmp;\n        } else {\n\n            removal += (removal ? \"|\" : \"\") + key;\n        }\n    }\n\n    if (removal) {\n\n        final[count++] = regex(is_stemmer ? \"(?!\\\\b)(\" + removal + \")(\\\\b|_)\" : \"(\" + removal + \")\");\n        final[count] = \"\";\n    }\n\n    return final;\n}\n\n/**\r\n * @param {!string} str\r\n * @param {Array} regexp\r\n * @returns {string}\r\n */\n\nexport function replace(str, regexp) {\n\n    for (let i = 0, len = regexp.length; i < len; i += 2) {\n\n        str = str.replace(regexp[i], regexp[i + 1]);\n\n        if (!str) {\n\n            break;\n        }\n    }\n\n    return str;\n}\n\n/**\r\n * @param {!string} str\r\n * @returns {RegExp}\r\n */\n\nexport function regex(str) {\n\n    return new RegExp(str, \"g\");\n}\n\n/**\r\n * Regex: replace(/(?:(\\w)(?:\\1)*)/g, \"$1\")\r\n * @param {!string} string\r\n * @returns {string}\r\n */\n\nexport function collapse(string) {\n\n    let final = \"\",\n        prev = \"\";\n\n    for (let i = 0, len = string.length, char; i < len; i++) {\n\n        if ((char = string[i]) !== prev) {\n\n            final += prev = char;\n        }\n    }\n\n    return final;\n}\n\n// TODO using fast-swap\nexport function filter(words, map) {\n    const length = words.length,\n          filtered = [];\n\n\n    for (let i = 0, count = 0; i < length; i++) {\n\n        const word = words[i];\n\n        if (word && !map[word]) {\n\n            filtered[count++] = word;\n        }\n    }\n\n    return filtered;\n}\n\n// const chars = {a:1, e:1, i:1, o:1, u:1, y:1};\n//\n// function collapse_repeating_chars(string){\n//\n//     let collapsed_string = \"\",\n//         char_prev = \"\",\n//         char_next = \"\";\n//\n//     for(let i = 0; i < string.length; i++){\n//\n//         const char = string[i];\n//\n//         if(char !== char_prev){\n//\n//             if(i && (char === \"h\")){\n//\n//                 if((chars[char_prev] && chars[char_next]) || (char_prev === \" \")){\n//\n//                     collapsed_string += char;\n//                 }\n//             }\n//             else{\n//\n//                 collapsed_string += char;\n//             }\n//         }\n//\n//         char_next = (\n//\n//             (i === (string.length - 1)) ?\n//\n//                 \"\"\n//             :\n//                 string[i + 1]\n//         );\n//\n//         char_prev = char;\n//     }\n//\n//     return collapsed_string;\n// }","import { IndexInterface } from \"../../type.js\";\nimport { pipeline, normalize, regex_whitespace } from \"../../lang.js\";\n\nexport const rtl = /* normalize: */\n/* collapse: */ /* normalize: */ /* collapse: */ /* normalize: */ /* collapse: */\n/* normalize: */\n/* collapse: */!1;\nexport const tokenize = \"\";\nexport default {\n    encode: encode,\n    rtl: !1,\n    tokenize: \"\"\n\n    /**\r\n     * @param {string|number} str\r\n     * @this IndexInterface\r\n     */\n\n};export function encode(str) {\n\n    return pipeline.call(this,\n    /* string: */(\"\" + str).toLowerCase(), !1, /* split: */regex_whitespace, !1);\n}","export const global_lang = {};\nexport const global_charset = {};\n\n/**\r\n * @param {!string} name\r\n * @param {Object} charset\r\n */\n\nexport function registerCharset(name, charset) {\n\n  global_charset[name] = charset;\n}\n\n/**\r\n * @param {!string} name\r\n * @param {Object} lang\r\n */\n\nexport function registerLanguage(name, lang) {\n\n  global_lang[name] = lang;\n}","\nimport { is_string } from \"./common.js\";\n\n/**\r\n * @enum {Object}\r\n * @const\r\n */\n\nconst preset = {\n\n    memory: {\n        charset: \"latin:extra\",\n        //tokenize: \"strict\",\n        resolution: 3,\n        //threshold: 0,\n        minlength: 4,\n        fastupdate: /* normalize: */ /* collapse: */ /* normalize: */ /* collapse: */ /* normalize: */ /* collapse: */ /* normalize: */\n        /* collapse: */\n        /* collapse: */!1\n    },\n\n    performance: {\n        //charset: \"latin\",\n        //tokenize: \"strict\",\n        resolution: 3,\n        minlength: 3,\n        //fastupdate: true,\n        optimize: !1, //fastupdate: true,\n        context: {\n            depth: 2, resolution: 1\n            //bidirectional: false\n        }\n    },\n\n    match: {\n        charset: \"latin:extra\",\n        tokenize: \"reverse\"\n        //resolution: 9,\n        //threshold: 0\n    },\n\n    score: {\n        charset: \"latin:advanced\",\n        //tokenize: \"strict\",\n        resolution: 20,\n        minlength: 3,\n        context: {\n            depth: 3,\n            resolution: 9\n            //bidirectional: true\n        }\n    },\n\n    default: {\n        // charset: \"latin:default\",\n        // tokenize: \"strict\",\n        // resolution: 3,\n        // threshold: 0,\n        // depth: 3\n    }\n\n    // \"fast\": {\n    //     //charset: \"latin\",\n    //     //tokenize: \"strict\",\n    //     threshold: 8,\n    //     resolution: 9,\n    //     depth: 1\n    // }\n};\n\nexport default function apply_preset(options) {\n\n    if (is_string(options)) {\n\n        options = preset[options];\n    } else {\n\n        const preset = options.preset;\n\n        if (preset) {\n\n            options = Object.assign({}, preset[preset], /** @type {Object} */options);\n        }\n    }\n\n    return options;\n}","/**!\r\n * FlexSearch.js\r\n * Author and Copyright: Thomas Wilkerling\r\n * Licence: Apache-2.0\r\n * Hosted by Nextapps GmbH\r\n * https://github.com/nextapps-de/flexsearch\r\n */\n\nimport { IndexInterface } from \"./type.js\";\nimport { encode as default_encoder } from \"./lang/latin/default.js\";\nimport { create_object, create_object_array, concat, sort_by_length_down, is_array, is_string, is_object, parse_option } from \"./common.js\";\nimport { pipeline, init_stemmer_or_matcher, init_filter } from \"./lang.js\";\nimport { global_lang, global_charset } from \"./global.js\";\nimport apply_async from \"./async.js\";\nimport { intersect } from \"./intersect.js\";\nimport Cache, { searchCache } from \"./cache.js\";\nimport apply_preset from \"./preset.js\";\nimport { exportIndex, importIndex } from \"./serialize.js\";\n\n/**\r\n * @constructor\r\n * @implements IndexInterface\r\n * @param {Object=} options\r\n * @param {Object=} _register\r\n * @return {Index}\r\n */\n\nfunction Index(options, _register) {\n\n    if (!(this instanceof Index)) {\n\n        return new Index(options);\n    }\n\n    let charset, lang, tmp;\n\n    if (options) {\n\n        options = apply_preset(options);\n\n\n        charset = options.charset;\n        lang = options.lang;\n\n        if (is_string(charset)) {\n\n            if (-1 === charset.indexOf(\":\")) {\n\n                charset += \":default\";\n            }\n\n            charset = global_charset[charset];\n        }\n\n        if (is_string(lang)) {\n\n            lang = global_lang[lang];\n        }\n    } else {\n\n        options = {};\n    }\n\n    let resolution,\n        optimize,\n        context = options.context || {};\n\n    this.encode = options.encode || charset && charset.encode || default_encoder;\n    this.register = _register || create_object();\n    this.resolution = resolution = options.resolution || 9;\n    this.tokenize = tmp = charset && charset.tokenize || options.tokenize || \"strict\";\n    this.depth = \"strict\" === tmp && context.depth;\n    this.bidirectional = parse_option(context.bidirectional, /* append: */ /* skip update: */ /* skip_update: */!0);\n    this.optimize = optimize = parse_option(options.optimize, !0);\n    this.fastupdate = parse_option(options.fastupdate, !0);\n    this.minlength = options.minlength || 1;\n    this.boost = options.boost;\n\n    // when not using the memory strategy the score array should not pre-allocated to its full length\n\n    this.map = optimize ? create_object_array(resolution) : create_object();\n    this.resolution_ctx = resolution = context.resolution || 1;\n    this.ctx = optimize ? create_object_array(resolution) : create_object();\n    this.rtl = charset && charset.rtl || options.rtl;\n    this.matcher = (tmp = options.matcher || lang && lang.matcher) && init_stemmer_or_matcher(tmp, !1);\n    this.stemmer = (tmp = options.stemmer || lang && lang.stemmer) && init_stemmer_or_matcher(tmp, !0);\n    this.filter = (tmp = options.filter || lang && lang.filter) && init_filter(tmp);\n\n    this.cache = (tmp = options.cache) && new Cache(tmp);\n}\n\nexport default Index;\n\n//Index.prototype.pipeline = pipeline;\n\n/**\r\n * @param {!number|string} id\r\n * @param {!string} content\r\n */\n\nIndex.prototype.append = function (id, content) {\n\n    return this.add(id, content, !0);\n};\n\n// TODO:\n// string + number as text\n// boolean, null, undefined as ?\n\n/**\r\n * @param {!number|string} id\r\n * @param {!string} content\r\n * @param {boolean=} _append\r\n * @param {boolean=} _skip_update\r\n */\n\nIndex.prototype.add = function (id, content, _append, _skip_update) {\n\n    if (content && (id || 0 === id)) {\n\n        if (!_skip_update && !_append && this.register[id]) {\n\n            return this.update(id, content);\n        }\n\n        content = this.encode(\"\" + content);\n        const length = content.length;\n\n        if (length) {\n\n            // check context dupes to skip all contextual redundancy along a document\n\n            const dupes_ctx = create_object(),\n                  dupes = create_object(),\n                  depth = this.depth,\n                  resolution = this.resolution;\n\n\n            for (let i = 0; i < length; i++) {\n                let term = content[this.rtl ? length - 1 - i : i],\n                    term_length = term.length;\n\n\n                // skip dupes will break the context chain\n\n                if (term && term_length >= this.minlength && (depth || !dupes[term])) {\n                    let score = get_score(resolution, length, i),\n                        token = \"\";\n\n\n                    switch (this.tokenize) {\n\n                        case \"full\":\n\n                            if (2 < term_length) {\n\n                                for (let x = 0; x < term_length; x++) {\n\n                                    for (let y = term_length; y > x; y--) {\n\n                                        if (y - x >= this.minlength) {\n\n                                            const partial_score = get_score(resolution, length, i, term_length, x);\n                                            token = term.substring(x, y);\n                                            this.push_index(dupes, token, partial_score, id, _append);\n                                        }\n                                    }\n                                }\n\n                                break;\n                            }\n\n                        // fallthrough to next case when term length < 3\n\n                        case \"reverse\":\n\n                            // skip last round (this token exist already in \"forward\")\n\n                            if (1 < term_length) {\n\n                                for (let x = term_length - 1; 0 < x; x--) {\n\n                                    token = term[x] + token;\n\n                                    if (token.length >= this.minlength) {\n\n                                        const partial_score = get_score(resolution, length, i, term_length, x);\n                                        this.push_index(dupes, token, partial_score, id, _append);\n                                    }\n                                }\n\n                                token = \"\";\n                            }\n\n                        // fallthrough to next case to apply forward also\n\n                        case \"forward\":\n\n                            if (1 < term_length) {\n\n                                for (let x = 0; x < term_length; x++) {\n\n                                    token += term[x];\n\n                                    if (token.length >= this.minlength) {\n\n                                        this.push_index(dupes, token, score, id, _append);\n                                    }\n                                }\n\n                                break;\n                            }\n\n                        // fallthrough to next case when token has a length of 1\n\n                        default:\n                            // case \"strict\":\n\n                            if (this.boost) {\n\n                                score = Math.min(0 | score / this.boost(content, term, i), resolution - 1);\n                            }\n\n                            this.push_index(dupes, term, score, id, _append);\n\n                            // context is just supported by tokenizer \"strict\"\n\n                            if (depth) {\n\n                                if (1 < length && i < length - 1) {\n\n                                    // check inner dupes to skip repeating words in the current context\n\n                                    const dupes_inner = create_object(),\n                                          resolution = this.resolution_ctx,\n                                          keyword = term,\n                                          size = Math.min(depth + 1, length - i);\n\n\n                                    dupes_inner[keyword] = 1;\n\n                                    for (let x = 1; x < size; x++) {\n\n                                        term = content[this.rtl ? length - 1 - i - x : i + x];\n\n                                        if (term && term.length >= this.minlength && !dupes_inner[term]) {\n\n                                            dupes_inner[term] = 1;\n\n                                            const context_score = get_score(resolution + (length / 2 > resolution ? 0 : 1), length, i, size - 1, x - 1),\n                                                  swap = this.bidirectional && term > keyword;\n\n                                            this.push_index(dupes_ctx, swap ? keyword : term, context_score, id, _append, swap ? term : keyword);\n                                        }\n                                    }\n                                }\n                            }\n                    }\n                }\n            }\n\n            this.fastupdate || (this.register[id] = 1);\n        }\n    }\n\n    return this;\n};\n\n/**\r\n * @param {number} resolution\r\n * @param {number} length\r\n * @param {number} i\r\n * @param {number=} term_length\r\n * @param {number=} x\r\n * @returns {number}\r\n */\n\nfunction get_score(resolution, length, i, term_length, x) {\n\n    // console.log(\"resolution\", resolution);\n    // console.log(\"length\", length);\n    // console.log(\"term_length\", term_length);\n    // console.log(\"i\", i);\n    // console.log(\"x\", x);\n    // console.log((resolution - 1) / (length + (term_length || 0)) * (i + (x || 0)) + 1);\n\n    // the first resolution slot is reserved for the best match,\n    // when a query matches the first word(s).\n\n    // also to stretch score to the whole range of resolution, the\n    // calculation is shift by one and cut the floating point.\n    // this needs the resolution \"1\" to be handled additionally.\n\n    // do not stretch the resolution more than the term length will\n    // improve performance and memory, also it improves scoring in\n    // most cases between a short document and a long document\n\n    return i && 1 < resolution ? length + (term_length || 0) <= resolution ? i + (x || 0) : 0 | (resolution - 1) / (length + (term_length || 0)) * (i + (x || 0)) + 1 : 0;\n}\n\n/**\r\n * @private\r\n * @param dupes\r\n * @param value\r\n * @param score\r\n * @param id\r\n * @param {boolean=} append\r\n * @param {string=} keyword\r\n */\n\nIndex.prototype.push_index = function (dupes, value, score, id, append, keyword) {\n\n    let arr = keyword ? this.ctx : this.map;\n\n    if (!dupes[value] || keyword && !dupes[value][keyword]) {\n\n        if (this.optimize) {\n\n            arr = arr[score];\n        }\n\n        if (keyword) {\n\n            dupes = dupes[value] || (dupes[value] = create_object());\n            dupes[keyword] = 1;\n\n            arr = arr[keyword] || (arr[keyword] = create_object());\n        } else {\n\n            dupes[value] = 1;\n        }\n\n        arr = arr[value] || (arr[value] = []);\n\n        if (!this.optimize) {\n\n            arr = arr[score] || (arr[score] = []);\n        }\n\n        if (!append || !arr.includes(id)) {\n\n            arr[arr.length] = id;\n\n            // add a reference to the register for fast updates\n\n            if (this.fastupdate) {\n\n                const tmp = this.register[id] || (this.register[id] = []);\n                tmp[tmp.length] = arr;\n            }\n        }\n    }\n};\n\n/**\r\n * @param {string|Object} query\r\n * @param {number|Object=} limit\r\n * @param {Object=} options\r\n * @returns {Array<number|string>}\r\n */\n\nIndex.prototype.search = function (query, limit, options) {\n\n    if (!options) {\n\n        if (!limit && is_object(query)) {\n\n            options = /** @type {Object} */query;\n            query = options.query;\n        } else if (is_object(limit)) {\n\n            options = /** @type {Object} */limit;\n        }\n    }\n\n    let result = [],\n        length,\n        context,\n        suggest,\n        offset = 0;\n\n\n    if (options) {\n\n        query = options.query || query;\n        limit = options.limit;\n        offset = options.offset || 0;\n        context = options.context;\n        suggest = options.suggest;\n    }\n\n    if (query) {\n\n        query = /** @type {Array} */this.encode(\"\" + query);\n        length = query.length;\n\n        // TODO: solve this in one single loop below\n\n        if (1 < length) {\n            const dupes = create_object(),\n                  query_new = [];\n\n\n            for (let i = 0, count = 0, term; i < length; i++) {\n\n                term = query[i];\n\n                if (term && term.length >= this.minlength && !dupes[term]) {\n\n                    // this fast path can just apply when not in memory-optimized mode\n\n                    if (!this.optimize && !suggest && !this.map[term]) {\n\n                        // fast path \"not found\"\n\n                        return result;\n                    } else {\n\n                        query_new[count++] = term;\n                        dupes[term] = 1;\n                    }\n                }\n            }\n\n            query = query_new;\n            length = query.length;\n        }\n    }\n\n    if (!length) {\n\n        return result;\n    }\n\n    limit || (limit = 100);\n\n    let depth = this.depth && 1 < length && !1 !== context,\n        index = 0,\n        keyword;\n\n\n    if (depth) {\n\n        keyword = query[0];\n        index = 1;\n    } else {\n\n        if (1 < length) {\n\n            query.sort(sort_by_length_down);\n        }\n    }\n\n    for (let arr, term; index < length; index++) {\n\n        term = query[index];\n\n        // console.log(keyword);\n        // console.log(term);\n        // console.log(\"\");\n\n        if (depth) {\n\n            arr = this.add_result(result, suggest, limit, offset, 2 === length, term, keyword);\n\n            // console.log(arr);\n            // console.log(result);\n\n            // when suggestion enabled just forward keyword if term was found\n            // as long as the result is empty forward the pointer also\n\n            if (!suggest || !1 !== arr || !result.length) {\n\n                keyword = term;\n            }\n        } else {\n\n            arr = this.add_result(result, suggest, limit, offset, 1 === length, term);\n        }\n\n        if (arr) {\n\n            return (/** @type {Array<number|string>} */arr\n            );\n        }\n\n        // apply suggestions on last loop or fallback\n\n        if (suggest && index == length - 1) {\n\n            let length = result.length;\n\n            if (!length) {\n\n                if (depth) {\n\n                    // fallback to non-contextual search when no result was found\n\n                    depth = 0;\n                    index = -1;\n\n                    continue;\n                }\n\n                return result;\n            } else if (1 === length) {\n\n                // fast path optimization\n\n                return single_result(result[0], limit, offset);\n            }\n        }\n    }\n\n    return intersect(result, limit, offset, suggest);\n};\n\n/**\r\n * Returns an array when the result is done (to stop the process immediately),\r\n * returns false when suggestions is enabled and no result was found,\r\n * or returns nothing when a set was pushed successfully to the results\r\n *\r\n * @private\r\n * @param {Array} result\r\n * @param {Array} suggest\r\n * @param {number} limit\r\n * @param {number} offset\r\n * @param {boolean} single_term\r\n * @param {string} term\r\n * @param {string=} keyword\r\n * @return {Array<Array<string|number>>|boolean|undefined}\r\n */\n\nIndex.prototype.add_result = function (result, suggest, limit, offset, single_term, term, keyword) {\n    let word_arr = [],\n        arr = keyword ? this.ctx : this.map;\n\n\n    if (!this.optimize) {\n\n        arr = get_array(arr, term, keyword, this.bidirectional);\n    }\n\n    if (arr) {\n\n        let count = 0;\n        const arr_len = Math.min(arr.length, keyword ? this.resolution_ctx : this.resolution);\n\n        // relevance:\n        for (let x = 0, size = 0, tmp, len; x < arr_len; x++) {\n\n            tmp = arr[x];\n\n            if (tmp) {\n\n                if (this.optimize) {\n\n                    tmp = get_array(tmp, term, keyword, this.bidirectional);\n                }\n\n                if (offset) {\n\n                    if (tmp && single_term) {\n\n                        len = tmp.length;\n\n                        if (len <= offset) {\n\n                            offset -= len;\n                            tmp = null;\n                        } else {\n\n                            tmp = tmp.slice(offset);\n                            offset = 0;\n                        }\n                    }\n                }\n\n                if (tmp) {\n\n                    // keep score (sparse array):\n                    //word_arr[x] = tmp;\n\n                    // simplified score order:\n                    word_arr[count++] = tmp;\n\n                    if (single_term) {\n\n                        size += tmp.length;\n\n                        if (size >= limit) {\n\n                            // fast path optimization\n\n                            break;\n                        }\n                    }\n                }\n            }\n        }\n\n        if (count) {\n\n            if (single_term) {\n\n                // fast path optimization\n                // offset was already applied at this point\n\n                return single_result(word_arr, limit, 0);\n            }\n\n            result[result.length] = word_arr;\n            return;\n        }\n    }\n\n    // return an empty array will stop the loop,\n    // to prevent stop when using suggestions return a false value\n\n    return !suggest && word_arr;\n};\n\nfunction single_result(result, limit, offset) {\n\n    if (1 === result.length) {\n\n        result = result[0];\n    } else {\n\n        result = concat(result);\n    }\n\n    return offset || result.length > limit ? result.slice(offset, offset + limit) : result;\n}\n\nfunction get_array(arr, term, keyword, bidirectional) {\n\n    if (keyword) {\n\n        // the frequency of the starting letter is slightly less\n        // on the last half of the alphabet (m-z) in almost every latin language,\n        // so we sort downwards (https://en.wikipedia.org/wiki/Letter_frequency)\n\n        const swap = bidirectional && term > keyword;\n\n        arr = arr[swap ? term : keyword];\n        arr = arr && arr[swap ? keyword : term];\n    } else {\n\n        arr = arr[term];\n    }\n\n    return arr;\n}\n\nIndex.prototype.contain = function (id) {\n\n    return !!this.register[id];\n};\n\nIndex.prototype.update = function (id, content) {\n\n    return this.remove(id).add(id, content);\n};\n\n/**\r\n * @param {boolean=} _skip_deletion\r\n */\n\nIndex.prototype.remove = function (id, _skip_deletion) {\n\n    const refs = this.register[id];\n\n    if (refs) {\n\n        if (this.fastupdate) {\n\n            // fast updates performs really fast but did not fully cleanup the key entries\n\n            for (let i = 0, tmp; i < refs.length; i++) {\n\n                tmp = refs[i];\n                tmp.splice(tmp.indexOf(id), 1);\n            }\n        } else {\n\n            remove_index(this.map, id, this.resolution, this.optimize);\n\n            if (this.depth) {\n\n                remove_index(this.ctx, id, this.resolution_ctx, this.optimize);\n            }\n        }\n\n        _skip_deletion || delete this.register[id];\n\n        if (this.cache) {\n\n            this.cache.del(id);\n        }\n    }\n\n    return this;\n};\n\n/**\r\n * @param map\r\n * @param id\r\n * @param res\r\n * @param optimize\r\n * @param {number=} resolution\r\n * @return {number}\r\n */\n\nfunction remove_index(map, id, res, optimize, resolution) {\n\n    let count = 0;\n\n    if (is_array(map)) {\n\n        // the first array is the score array in both strategies\n\n        if (!resolution) {\n\n            resolution = Math.min(map.length, res);\n\n            for (let x = 0, arr; x < resolution; x++) {\n\n                arr = map[x];\n\n                if (arr) {\n\n                    count = remove_index(arr, id, res, optimize, resolution);\n\n                    if (!optimize && !count) {\n\n                        // when not memory optimized the score index should removed\n\n                        delete map[x];\n                    }\n                }\n            }\n        } else {\n\n            const pos = map.indexOf(id);\n\n            if (-1 !== pos) {\n\n                // fast path, when length is 1 or lower then the whole field gets deleted\n\n                if (1 < map.length) {\n\n                    map.splice(pos, 1);\n                    count++;\n                }\n            } else {\n\n                count++;\n            }\n        }\n    } else {\n\n        for (let key in map) {\n\n            count = remove_index(map[key], id, res, optimize, resolution);\n\n            if (!count) {\n\n                delete map[key];\n            }\n        }\n    }\n\n    return count;\n}\n\nIndex.prototype.searchCache = searchCache;\n\n\nIndex.prototype.export = exportIndex;\nIndex.prototype.import = importIndex;\n\n\napply_async(Index.prototype);","import { create_object, concat } from \"./common.js\";\n\n/**\r\n * Implementation based on Array.includes() provides better performance,\r\n * but it needs at least one word in the query which is less frequent.\r\n * Also on large indexes it does not scale well performance-wise.\r\n * This strategy also lacks of suggestion capabilities (matching & sorting).\r\n *\r\n * @param arrays\r\n * @param limit\r\n * @param offset\r\n * @param {boolean|Array=} suggest\r\n * @returns {Array}\r\n */\n\n// export function intersect(arrays, limit, offset, suggest) {\n//\n//     const length = arrays.length;\n//     let result = [];\n//     let check;\n//\n//     // determine shortest array and collect results\n//     // from the sparse relevance arrays\n//\n//     let smallest_size;\n//     let smallest_arr;\n//     let smallest_index;\n//\n//     for(let x = 0; x < length; x++){\n//\n//         const arr = arrays[x];\n//         const len = arr.length;\n//\n//         let size = 0;\n//\n//         for(let y = 0, tmp; y < len; y++){\n//\n//             tmp = arr[y];\n//\n//             if(tmp){\n//\n//                 size += tmp.length;\n//             }\n//         }\n//\n//         if(!smallest_size || (size < smallest_size)){\n//\n//             smallest_size = size;\n//             smallest_arr = arr;\n//             smallest_index = x;\n//         }\n//     }\n//\n//     smallest_arr = smallest_arr.length === 1 ?\n//\n//         smallest_arr[0]\n//     :\n//         concat(smallest_arr);\n//\n//     if(suggest){\n//\n//         suggest = [smallest_arr];\n//         check = create_object();\n//     }\n//\n//     let size = 0;\n//     let steps = 0;\n//\n//     // process terms in reversed order often results in better performance.\n//     // the outer loop must be the words array, using the\n//     // smallest array here disables the \"fast fail\" optimization.\n//\n//     for(let x = length - 1; x >= 0; x--){\n//\n//         if(x !== smallest_index){\n//\n//             steps++;\n//\n//             const word_arr = arrays[x];\n//             const word_arr_len = word_arr.length;\n//             const new_arr = [];\n//\n//             let count = 0;\n//\n//             for(let z = 0, id; z < smallest_arr.length; z++){\n//\n//                 id = smallest_arr[z];\n//\n//                 let found;\n//\n//                 // process relevance in forward order (direction is\n//                 // important for adding IDs during the last round)\n//\n//                 for(let y = 0; y < word_arr_len; y++){\n//\n//                     const arr = word_arr[y];\n//\n//                     if(arr.length){\n//\n//                         found = arr.includes(id);\n//\n//                         if(found){\n//\n//                             // check if in last round\n//\n//                             if(steps === length - 1){\n//\n//                                 if(offset){\n//\n//                                     offset--;\n//                                 }\n//                                 else{\n//\n//                                     result[size++] = id;\n//\n//                                     if(size === limit){\n//\n//                                         // fast path \"end reached\"\n//\n//                                         return result;\n//                                     }\n//                                 }\n//\n//                                 if(suggest){\n//\n//                                     check[id] = 1;\n//                                 }\n//                             }\n//\n//                             break;\n//                         }\n//                     }\n//                 }\n//\n//                 if(found){\n//\n//                     new_arr[count++] = id;\n//                 }\n//             }\n//\n//             if(suggest){\n//\n//                 suggest[steps] = new_arr;\n//             }\n//             else if(!count){\n//\n//                 return [];\n//             }\n//\n//             smallest_arr = new_arr;\n//         }\n//     }\n//\n//     if(suggest){\n//\n//         // needs to iterate in reverse direction\n//\n//         for(let x = suggest.length - 1, arr, len; x >= 0; x--){\n//\n//             arr = suggest[x];\n//             len = arr && arr.length;\n//\n//             if(len){\n//\n//                 for(let y = 0, id; y < len; y++){\n//\n//                     id = arr[y];\n//\n//                     if(!check[id]){\n//\n//                         check[id] = 1;\n//\n//                         if(offset){\n//\n//                             offset--;\n//                         }\n//                         else{\n//\n//                             result[size++] = id;\n//\n//                             if(size === limit){\n//\n//                                 // fast path \"end reached\"\n//\n//                                 return result;\n//                             }\n//                         }\n//                     }\n//                 }\n//             }\n//         }\n//     }\n//\n//     return result;\n// }\n\n/**\r\n * Implementation based on Object[key] provides better suggestions\r\n * capabilities and has less performance scaling issues on large indexes.\r\n *\r\n * @param arrays\r\n * @param limit\r\n * @param offset\r\n * @param {boolean|Array=} suggest\r\n * @returns {Array}\r\n */\n\nexport function intersect(arrays, limit, offset, suggest) {\n\n    const length = arrays.length;\n    let result = [],\n        check,\n        check_suggest,\n        size = 0;\n\n\n    if (suggest) {\n\n        suggest = [];\n    }\n\n    // process terms in reversed order often has advantage for the fast path \"end reached\".\n    // also a reversed order prioritize the order of words from a query.\n\n    for (let x = length - 1; 0 <= x; x--) {\n        const word_arr = arrays[x],\n              word_arr_len = word_arr.length,\n              check_new = create_object();\n\n\n        let found = !check;\n\n        // process relevance in forward order (direction is\n        // important for adding IDs during the last round)\n\n        for (let y = 0; y < word_arr_len; y++) {\n            const arr = word_arr[y],\n                  arr_len = arr.length;\n\n\n            if (arr_len) {\n\n                // loop through IDs\n\n                for (let z = 0, check_idx, id; z < arr_len; z++) {\n\n                    id = arr[z];\n\n                    if (check) {\n\n                        if (check[id]) {\n\n                            // check if in last round\n\n                            if (!x) {\n\n                                if (offset) {\n\n                                    offset--;\n                                } else {\n\n                                    result[size++] = id;\n\n                                    if (size === limit) {\n\n                                        // fast path \"end reached\"\n\n                                        return result;\n                                    }\n                                }\n                            }\n\n                            if (x || suggest) {\n\n                                check_new[id] = 1;\n                            }\n\n                            found = /* append: */ /* skip update: */ /* skip_update: */!0;\n                        }\n\n                        if (suggest) {\n\n                            check_idx = (check_suggest[id] || 0) + 1;\n                            check_suggest[id] = check_idx;\n\n                            // do not adding IDs which are already included in the result (saves one loop)\n                            // the first intersection match has the check index 2, so shift by -2\n\n                            if (check_idx < length) {\n\n                                const tmp = suggest[check_idx - 2] || (suggest[check_idx - 2] = []);\n                                tmp[tmp.length] = id;\n                            }\n                        }\n                    } else {\n\n                        // pre-fill in first round\n\n                        check_new[id] = 1;\n                    }\n                }\n            }\n        }\n\n        if (suggest) {\n\n            // re-use the first pre-filled check for suggestions\n\n            check || (check_suggest = check_new);\n        } else if (!found) {\n\n            return [];\n        }\n\n        check = check_new;\n    }\n\n    if (suggest) {\n\n        // needs to iterate in reverse direction\n\n        for (let x = suggest.length - 1, arr, len; 0 <= x; x--) {\n\n            arr = suggest[x];\n            len = arr.length;\n\n            for (let y = 0, id; y < len; y++) {\n\n                id = arr[y];\n\n                if (!check[id]) {\n\n                    if (offset) {\n\n                        offset--;\n                    } else {\n\n                        result[size++] = id;\n\n                        if (size === limit) {\n\n                            // fast path \"end reached\"\n\n                            return result;\n                        }\n                    }\n\n                    check[id] = 1;\n                }\n            }\n        }\n    }\n\n    return result;\n}\n\n/**\r\n * @param mandatory\r\n * @param arrays\r\n * @returns {Array}\r\n */\n\nexport function intersect_union(mandatory, arrays) {\n    const check = create_object(),\n          union = create_object(),\n          result = [];\n\n\n    for (let x = 0; x < mandatory.length; x++) {\n\n        check[mandatory[x]] = 1;\n    }\n\n    for (let x = 0, arr; x < arrays.length; x++) {\n\n        arr = arrays[x];\n\n        for (let y = 0, id; y < arr.length; y++) {\n\n            id = arr[y];\n\n            if (check[id]) {\n\n                if (!union[id]) {\n\n                    union[id] = 1;\n                    result[result.length] = id;\n                }\n            }\n        }\n    }\n\n    return result;\n}","// TODO return promises instead of inner await\n\nimport { IndexInterface, DocumentInterface } from \"./type.js\";\nimport { create_object, is_string } from \"./common.js\";\n\nfunction async(callback, self, field, key, index_doc, index, data, on_done) {\n\n    setTimeout(function () {\n\n        const res = callback(field ? field + \".\" + key : key, JSON.stringify(data));\n\n        // await isn't supported by ES5\n\n        if (res && res.then) {\n\n            res.then(function () {\n\n                self.export(callback, self, field, index_doc, index + 1, on_done);\n            });\n        } else {\n\n            self.export(callback, self, field, index_doc, index + 1, on_done);\n        }\n    });\n}\n\n/**\r\n * @this IndexInterface\r\n */\n\nexport function exportIndex(callback, self, field, index_doc, index, on_done) {\n\n    let return_value = /* append: */ /* skip update: */ /* skip_update: */ /* skip post-processing: */!0;\n    if ('undefined' == typeof on_done) {\n        return_value = new Promise(resolve => {\n            on_done = resolve;\n        });\n    }\n\n    let key, data;\n\n    switch (index || (index = 0)) {\n\n        case 0:\n\n            key = \"reg\";\n\n            // fastupdate isn't supported by export\n\n            if (this.fastupdate) {\n\n                data = create_object();\n\n                for (let key in this.register) {\n\n                    data[key] = 1;\n                }\n            } else {\n\n                data = this.register;\n            }\n\n            break;\n\n        case 1:\n\n            key = \"cfg\";\n            data = {\n                doc: 0,\n                opt: this.optimize ? 1 : 0\n            };\n\n            break;\n\n        case 2:\n\n            key = \"map\";\n            data = this.map;\n            break;\n\n        case 3:\n\n            key = \"ctx\";\n            data = this.ctx;\n            break;\n\n        default:\n\n            if ('undefined' == typeof field && on_done) {\n\n                on_done();\n            }\n\n            return;\n    }\n\n    async(callback, self || this, field, key, index_doc, index, data, on_done);\n\n    return return_value;\n}\n\n/**\r\n * @this IndexInterface\r\n */\n\nexport function importIndex(key, data) {\n\n    if (!data) {\n\n        return;\n    }\n\n    if (is_string(data)) {\n\n        data = JSON.parse(data);\n    }\n\n    switch (key) {\n\n        case \"cfg\":\n\n            this.optimize = !!data.opt;\n            break;\n\n        case \"reg\":\n\n            // fastupdate isn't supported by import\n\n            this.fastupdate = /* normalize: */ /* collapse: */ /* normalize: */ /* collapse: */ /* normalize: */ /* collapse: */ /* normalize: */ /* collapse: */ /* collapse: */!1;\n            this.register = data;\n            break;\n\n        case \"map\":\n\n            this.map = data;\n            break;\n\n        case \"ctx\":\n\n            this.ctx = data;\n            break;\n    }\n}\n\n/**\r\n * @this DocumentInterface\r\n */\n\nexport function exportDocument(callback, self, field, index_doc, index, on_done) {\n\n    let return_value;\n    if ('undefined' == typeof on_done) {\n        return_value = new Promise(resolve => {\n            on_done = resolve;\n        });\n    }\n\n    index || (index = 0);\n    index_doc || (index_doc = 0);\n\n    if (index_doc < this.field.length) {\n        const field = this.field[index_doc],\n              idx = this.index[field];\n\n\n        self = this;\n\n        setTimeout(function () {\n\n            if (!idx.export(callback, self, index ? field /*.replace(\":\", \"-\")*/ : \"\", index_doc, index++, on_done)) {\n\n                index_doc++;\n                index = 1;\n\n                self.export(callback, self, field, index_doc, index, on_done);\n            }\n        });\n    } else {\n\n        let key, data;\n\n        switch (index) {\n\n            case 1:\n\n                key = \"tag\";\n                data = this.tagindex;\n                field = null;\n                break;\n\n            case 2:\n\n                key = \"store\";\n                data = this.store;\n                field = null;\n                break;\n\n            // case 3:\n            //\n            //     key = \"reg\";\n            //     data = this.register;\n            //     break;\n\n            default:\n\n                on_done();\n                return;\n        }\n\n        async(callback, this, field, key, index_doc, index, data, on_done);\n    }\n\n    return return_value;\n}\n\n/**\r\n * @this DocumentInterface\r\n */\n\nexport function importDocument(key, data) {\n\n    if (!data) {\n\n        return;\n    }\n\n    if (is_string(data)) {\n\n        data = JSON.parse(data);\n    }\n\n    switch (key) {\n\n        case \"tag\":\n\n            this.tagindex = data;\n            break;\n\n        case \"reg\":\n\n            // fastupdate isn't supported by import\n\n            this.fastupdate = !1;\n            this.register = data;\n\n            for (let i = 0, index; i < this.field.length; i++) {\n\n                index = this.index[this.field[i]];\n                index.register = data;\n                index.fastupdate = !1;\n            }\n\n            break;\n\n        case \"store\":\n\n            this.store = data;\n            break;\n\n        default:\n\n            key = key.split(\".\");\n            const field = key[0];\n            key = key[1];\n\n            if (field && key) {\n\n                this.index[field].import(key, data);\n            }\n    }\n}","/**\r\n * @interface\r\n */\n\nexport function IndexInterface() {\n\n  this.cache = null;\n  this.matcher = null;\n  this.stemmer = null;\n  this.filter = null;\n}\n\n/**\r\n * @param {!string} str\r\n * @param {boolean|Array<string|RegExp>=} normalize\r\n * @param {boolean|string|RegExp=} split\r\n * @param {boolean=} collapse\r\n * @returns {string|Array<string>}\r\n */\n\n//IndexInterface.prototype.pipeline;\n\n/**\r\n * @param {!number|string} id\r\n * @param {!string} content\r\n */\n\nIndexInterface.prototype.add;\n\n/**\r\n * @param {!number|string} id\r\n * @param {!string} content\r\n */\n\nIndexInterface.prototype.append;\n\n/**\r\n * @param {!string|Object} query\r\n * @param {number|Object=} limit\r\n * @param {Object=} options\r\n * @returns {Array<number|string>}\r\n */\n\nIndexInterface.prototype.search;\n\n/**\r\n * @param {!number|string} id\r\n * @param {!string} content\r\n */\n\nIndexInterface.prototype.update;\n\n/**\r\n * @param {!number|string} id\r\n */\n\nIndexInterface.prototype.remove;\n\n/**\r\n * @interface\r\n */\n\nexport function DocumentInterface() {\n\n  this.field = null;\n\n  /** @type IndexInterface */\n  this.index = null;\n}","import Index from \"../index.js\";\n\nexport default function (data) {\n\n            data = data.data;\n\n            /** @type Index */\n            const index = self._index,\n                  args = data.args,\n                  task = data.task;\n\n\n            switch (task) {\n\n                        case \"init\":\n                                    const options = data.options || {},\n                                          factory = data.factory,\n                                          encode = options.encode;\n\n\n                                    options.cache = /* normalize: */ /* collapse: */ /* normalize: */\n\n                                    /* collapse: */ /* normalize: */ /* collapse: */ /* normalize: */ /* collapse: */ /* collapse: */!1;\n\n                                    if (encode && 0 === encode.indexOf(\"function\")) {\n                                                options.encode = Function(\"return \" + encode)();\n                                    }\n\n                                    if (factory) {\n\n                                                // export the FlexSearch global payload to \"self\"\n                                                Function(\"return \" + factory)()(self);\n\n                                                /** @type Index */\n                                                self._index = new self.FlexSearch.Index(options);\n\n                                                // destroy the exported payload\n                                                delete self.FlexSearch;\n                                    } else {\n\n                                                self._index = new Index(options);\n                                    }\n\n                                    break;\n\n                        default:\n                                    const id = data.id,\n                                          message = index[task].apply(index, args);\n\n                                    postMessage(\"search\" === task ? { id: id, msg: message } : { id: id });\n            }\n}","//import { promise as Promise } from \"../polyfill.js\";\nimport { create_object, is_function, is_object, is_string } from \"../common.js\";\nimport handler from \"./handler.js\";\n\nlet pid = 0;\n\n/**\r\n * @param {Object=} options\r\n * @constructor\r\n */\n\nfunction WorkerIndex(options) {\n\n    if (!(this instanceof WorkerIndex)) {\n\n        return new WorkerIndex(options);\n    }\n\n    let opt;\n\n    if (options) {\n\n        if (is_function(opt = options.encode)) {\n\n            options.encode = opt.toString();\n        }\n    } else {\n\n        options = {};\n    }\n\n    // the factory is the outer wrapper from the build\n    // we use \"self\" as a trap for node.js\n\n    let factory = (self || window)._factory;\n\n    if (factory) {\n\n        factory = factory.toString();\n    }\n\n    const is_node_js = \"undefined\" == typeof window && self.exports,\n          _self = this;\n\n    this.worker = create(factory, is_node_js, options.worker);\n    this.resolver = create_object();\n\n    if (!this.worker) {\n\n        return;\n    }\n\n    if (is_node_js) {\n\n        this.worker.on(\"message\", function (msg) {\n\n            _self.resolver[msg.id](msg.msg);\n            delete _self.resolver[msg.id];\n        });\n    } else {\n\n        this.worker.onmessage = function (msg) {\n\n            msg = msg.data;\n            _self.resolver[msg.id](msg.msg);\n            delete _self.resolver[msg.id];\n        };\n    }\n\n    this.worker.postMessage({\n\n        task: \"init\",\n        factory: factory,\n        options: options\n    });\n}\n\nexport default WorkerIndex;\n\nregister(\"add\");\nregister(\"append\");\nregister(\"search\");\nregister(\"update\");\nregister(\"remove\");\n\nfunction register(key) {\n\n    WorkerIndex.prototype[key] = WorkerIndex.prototype[key + \"Async\"] = function () {\n        const self = this,\n              args = [].slice.call(arguments),\n              arg = args[args.length - 1];\n\n        let callback;\n\n        if (is_function(arg)) {\n\n            callback = arg;\n            args.splice(args.length - 1, 1);\n        }\n\n        const promise = new Promise(function (resolve) {\n\n            setTimeout(function () {\n\n                self.resolver[++pid] = resolve;\n                self.worker.postMessage({\n\n                    task: key,\n                    id: pid,\n                    args: args\n                });\n            });\n        });\n\n        if (callback) {\n\n            promise.then(callback);\n            return this;\n        } else {\n\n            return promise;\n        }\n    };\n}\n\nfunction create(factory, is_node_js, worker_path) {\n\n    let worker;\n\n    try {\n\n        worker = is_node_js ? eval('new (require(\"worker_threads\")[\"Worker\"])(__dirname + \"/node/node.js\")') : factory ? new Worker(URL.createObjectURL(new Blob([\"onmessage=\" + handler.toString()], { type: \"text/javascript\" }))) : new Worker(is_string(worker_path) ? worker_path : \"worker/worker.js\", { type: \"module\" });\n    } catch (e) {}\n\n    return worker;\n}","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","/**!\r\n * FlexSearch.js\r\n * Author and Copyright: Thomas Wilkerling\r\n * Licence: Apache-2.0\r\n * Hosted by Nextapps GmbH\r\n * https://github.com/nextapps-de/flexsearch\r\n */\n\nimport Index from \"./index.js\";\nimport { DocumentInterface } from \"./type.js\";\nimport Cache, { searchCache } from \"./cache.js\";\nimport { create_object, is_array, is_string, is_object, parse_option, get_keys } from \"./common.js\";\nimport apply_async from \"./async.js\";\nimport { intersect, intersect_union } from \"./intersect.js\";\nimport { exportDocument, importDocument } from \"./serialize.js\";\nimport WorkerIndex from \"./worker/index.js\";\n\n/**\r\n * @constructor\r\n * @implements {DocumentInterface}\r\n * @param {Object=} options\r\n * @return {Document}\r\n */\n\nfunction Document(options) {\n\n    if (!(this instanceof Document)) {\n\n        return new Document(options);\n    }\n\n    const document = options.document || options.doc || options;\n    let opt;\n\n    this.tree = [];\n    this.field = [];\n    this.marker = [];\n    this.register = create_object();\n    this.key = (opt = document.key || document.id) && parse_tree(opt, this.marker) || \"id\";\n    this.fastupdate = parse_option(options.fastupdate, /* append: */ /* skip update: */ /* skip_update: */!0);\n\n    this.storetree = (opt = document.store) && !0 !== opt && [];\n    this.store = opt && create_object();\n\n\n    // TODO case-insensitive tags\n\n    this.tag = (opt = document.tag) && parse_tree(opt, this.marker);\n    this.tagindex = opt && create_object();\n\n\n    this.cache = (opt = options.cache) && new Cache(opt);\n\n    // do not apply cache again for the indexes\n\n    options.cache = !1;\n\n\n    this.worker = options.worker;\n\n\n    // this switch is used by recall of promise callbacks\n\n    this.async = !1;\n\n    /** @export */\n    this.index = parse_descriptor.call(this, options, document);\n}\n\nexport default Document;\n\n/**\r\n * @this Document\r\n */\n\nfunction parse_descriptor(options, document) {\n\n    const index = create_object();\n    let field = document.index || document.field || document;\n\n    if (is_string(field)) {\n\n        field = [field];\n    }\n\n    for (let i = 0, key, opt; i < field.length; i++) {\n\n        key = field[i];\n\n        if (!is_string(key)) {\n\n            opt = key;\n            key = key.field;\n        }\n\n        opt = is_object(opt) ? Object.assign({}, options, opt) : options;\n\n        if (this.worker) {\n\n            index[key] = new WorkerIndex(opt);\n\n            if (!index[key].worker) {\n\n                this.worker = !1;\n            }\n        }\n\n        if (!this.worker) {\n\n            index[key] = new Index(opt, this.register);\n        }\n\n        this.tree[i] = parse_tree(key, this.marker);\n        this.field[i] = key;\n    }\n\n    if (this.storetree) {\n\n        let store = document.store;\n\n        if (is_string(store)) {\n\n            store = [store];\n        }\n\n        for (let i = 0; i < store.length; i++) {\n\n            this.storetree[i] = parse_tree(store[i], this.marker);\n        }\n    }\n\n    return index;\n}\n\nfunction parse_tree(key, marker) {\n\n    const tree = key.split(\":\");\n    let count = 0;\n\n    for (let i = 0; i < tree.length; i++) {\n\n        key = tree[i];\n\n        if (0 <= key.indexOf(\"[]\")) {\n\n            key = key.substring(0, key.length - 2);\n\n            if (key) {\n\n                marker[count] = !0;\n            }\n        }\n\n        if (key) {\n\n            tree[count++] = key;\n        }\n    }\n\n    if (count < tree.length) {\n\n        tree.length = count;\n    }\n\n    return 1 < count ? tree : tree[0];\n}\n\n// TODO support generic function created from string when tree depth > 1\n\nfunction parse_simple(obj, tree) {\n\n    if (is_string(tree)) {\n\n        obj = obj[tree];\n    } else {\n\n        for (let i = 0; obj && i < tree.length; i++) {\n\n            obj = obj[tree[i]];\n        }\n    }\n\n    return obj;\n}\n\n// TODO support generic function created from string when tree depth > 1\n\nfunction store_value(obj, store, tree, pos, key) {\n\n    obj = obj[key];\n\n    // reached target field\n\n    if (pos === tree.length - 1) {\n\n        // store target value\n\n        store[key] = obj;\n    } else if (obj) {\n\n        if (is_array(obj)) {\n\n            store = store[key] = Array(obj.length);\n\n            for (let i = 0; i < obj.length; i++) {\n\n                // do not increase pos (an array is not a field)\n                store_value(obj, store, tree, pos, i);\n            }\n        } else {\n\n            store = store[key] || (store[key] = create_object());\n            key = tree[++pos];\n\n            store_value(obj, store, tree, pos, key);\n        }\n    }\n}\n\nfunction add_index(obj, tree, marker, pos, index, id, key, _append) {\n\n    obj = obj[key];\n\n    if (obj) {\n\n        // reached target field\n\n        if (pos === tree.length - 1) {\n\n            // handle target value\n\n            if (is_array(obj)) {\n\n                // append array contents so each entry gets a new scoring context\n\n                if (marker[pos]) {\n\n                    for (let i = 0; i < obj.length; i++) {\n\n                        index.add(id, obj[i], !0, !0);\n                    }\n\n                    return;\n                }\n\n                // or join array contents and use one scoring context\n\n                obj = obj.join(\" \");\n            }\n\n            index.add(id, obj, _append, !0);\n        } else {\n\n            if (is_array(obj)) {\n\n                for (let i = 0; i < obj.length; i++) {\n\n                    // do not increase index, an array is not a field\n\n                    add_index(obj, tree, marker, pos, index, id, i, _append);\n                }\n            } else {\n\n                key = tree[++pos];\n\n                add_index(obj, tree, marker, pos, index, id, key, _append);\n            }\n        }\n    }\n}\n\n/**\r\n *\r\n * @param id\r\n * @param content\r\n * @param {boolean=} _append\r\n * @returns {Document|Promise}\r\n */\n\nDocument.prototype.add = function (id, content, _append) {\n\n    if (is_object(id)) {\n\n        content = id;\n        id = parse_simple(content, this.key);\n    }\n\n    if (content && (id || 0 === id)) {\n\n        if (!_append && this.register[id]) {\n\n            return this.update(id, content);\n        }\n\n        for (let i = 0, tree, field; i < this.field.length; i++) {\n\n            field = this.field[i];\n            tree = this.tree[i];\n\n            if (is_string(tree)) {\n\n                tree = [tree];\n            }\n\n            add_index(content, tree, this.marker, 0, this.index[field], id, tree[0], _append);\n        }\n\n        if (this.tag) {\n            let tag = parse_simple(content, this.tag),\n                dupes = create_object();\n\n\n            if (is_string(tag)) {\n\n                tag = [tag];\n            }\n\n            for (let i = 0, key, arr; i < tag.length; i++) {\n\n                key = tag[i];\n\n                if (!dupes[key]) {\n\n                    dupes[key] = 1;\n                    arr = this.tagindex[key] || (this.tagindex[key] = []);\n\n                    if (!_append || !arr.includes(id)) {\n\n                        arr[arr.length] = id;\n\n                        // add a reference to the register for fast updates\n\n                        if (this.fastupdate) {\n\n                            const tmp = this.register[id] || (this.register[id] = []);\n                            tmp[tmp.length] = arr;\n                        }\n                    }\n                }\n            }\n        }\n\n        // TODO: how to handle store when appending contents?\n\n        if (this.store && (!_append || !this.store[id])) {\n\n            let store;\n\n            if (this.storetree) {\n\n                store = create_object();\n\n                for (let i = 0, tree; i < this.storetree.length; i++) {\n\n                    tree = this.storetree[i];\n\n                    if (is_string(tree)) {\n\n                        store[tree] = content[tree];\n                    } else {\n\n                        store_value(content, store, tree, 0, tree[0]);\n                    }\n                }\n            }\n\n            this.store[id] = store || content;\n        }\n    }\n\n    return this;\n};\n\nDocument.prototype.append = function (id, content) {\n\n    return this.add(id, content, !0);\n};\n\nDocument.prototype.update = function (id, content) {\n\n    return this.remove(id).add(id, content);\n};\n\nDocument.prototype.remove = function (id) {\n\n    if (is_object(id)) {\n\n        id = parse_simple(id, this.key);\n    }\n\n    if (this.register[id]) {\n\n        for (let i = 0; i < this.field.length; i++) {\n\n            // workers does not share the register\n\n            this.index[this.field[i]].remove(id, !this.worker);\n\n            if (this.fastupdate) {\n\n                // when fastupdate was enabled all ids are removed\n\n                break;\n            }\n        }\n\n        if (this.tag) {\n\n            // when fastupdate was enabled all ids are already removed\n\n            if (!this.fastupdate) {\n\n                for (let key in this.tagindex) {\n                    const tag = this.tagindex[key],\n                          pos = tag.indexOf(id);\n\n\n                    if (-1 !== pos) {\n\n                        if (1 < tag.length) {\n\n                            tag.splice(pos, 1);\n                        } else {\n\n                            delete this.tagindex[key];\n                        }\n                    }\n                }\n            }\n        }\n\n        if (this.store) {\n\n            delete this.store[id];\n        }\n\n        delete this.register[id];\n    }\n\n    return this;\n};\n\n/**\r\n * @param {!string|Object} query\r\n * @param {number|Object=} limit\r\n * @param {Object=} options\r\n * @param {Array<Array>=} _resolve For internal use only.\r\n * @returns {Promise|Array}\r\n */\n\nDocument.prototype.search = function (query, limit, options, _resolve) {\n\n    if (!options) {\n\n        if (!limit && is_object(query)) {\n\n            options = /** @type {Object} */query;\n            query = \"\";\n        } else if (is_object(limit)) {\n\n            options = /** @type {Object} */limit;\n            limit = 0;\n        }\n    }\n\n    let result = [],\n        result_field = [],\n        pluck,\n        enrich,\n        field,\n        tag,\n        bool,\n        offset,\n        count = 0;\n\n\n    if (options) {\n\n        if (is_array(options)) {\n\n            field = options;\n            options = null;\n        } else {\n\n            query = options.query || query;\n            pluck = options.pluck;\n            field = pluck || options.index || options.field /*|| (is_string(options) && [options])*/;\n            tag = options.tag;\n            enrich = this.store && options.enrich;\n            bool = \"and\" === options.bool;\n            limit = options.limit || limit || 100;\n            offset = options.offset || 0;\n\n            if (tag) {\n\n                if (is_string(tag)) {\n\n                    tag = [tag];\n                }\n\n                // when tags is used and no query was set,\n                // then just return the tag indexes\n\n                if (!query) {\n\n                    for (let i = 0, res; i < tag.length; i++) {\n\n                        res = get_tag.call(this, tag[i], limit, offset, enrich);\n\n                        if (res) {\n\n                            result[result.length] = res;\n                            count++;\n                        }\n                    }\n\n                    return count ? result : [];\n                }\n            }\n\n            if (is_string(field)) {\n\n                field = [field];\n            }\n        }\n    }\n\n    field || (field = this.field);\n    bool = bool && (1 < field.length || tag && 1 < tag.length);\n\n    const promises = !_resolve && (this.worker || this.async) && [];\n\n    // TODO solve this in one loop below\n\n    for (let i = 0, res, key, len; i < field.length; i++) {\n\n        let field_options;\n\n        key = field[i];\n\n        if (!is_string(key)) {\n\n            field_options = key;\n            key = field_options.field;\n            query = field_options.query || query;\n            limit = field_options.limit || limit;\n            enrich = field_options.enrich || enrich;\n        }\n\n        if (promises) {\n\n            promises[i] = this.index[key].searchAsync(query, limit, field_options || options);\n\n            // just collect and continue\n\n            continue;\n        } else if (_resolve) {\n\n            res = _resolve[i];\n        } else {\n\n            // inherit options also when search? it is just for laziness, Object.assign() has a cost\n\n            res = this.index[key].search(query, limit, field_options || options);\n        }\n\n        len = res && res.length;\n\n        if (tag && len) {\n\n            const arr = [];\n            let count = 0;\n\n            if (bool) {\n\n                // prepare for intersection\n\n                arr[0] = [res];\n            }\n\n            for (let y = 0, key, res; y < tag.length; y++) {\n\n                key = tag[y];\n                res = this.tagindex[key];\n                len = res && res.length;\n\n                if (len) {\n\n                    count++;\n                    arr[arr.length] = bool ? [res] : res;\n                }\n            }\n\n            if (count) {\n\n                if (bool) {\n\n                    res = intersect(arr, limit || 100, offset || 0);\n                } else {\n\n                    res = intersect_union(res, arr);\n                }\n\n                len = res.length;\n            }\n        }\n\n        if (len) {\n\n            result_field[count] = key;\n            result[count++] = res;\n        } else if (bool) {\n\n            return [];\n        }\n    }\n\n    if (promises) {\n\n        const self = this;\n\n        // anyone knows a better workaround of optionally having async promises?\n        // the promise.all() needs to be wrapped into additional promise,\n        // otherwise the recursive callback wouldn't run before return\n\n        return new Promise(function (resolve) {\n\n            Promise.all(promises).then(function (result) {\n\n                resolve(self.search(query, limit, options, result));\n            });\n        });\n    }\n\n    if (!count) {\n\n        // fast path \"not found\"\n\n        return [];\n    }\n\n    if (pluck && (!enrich || !this.store)) {\n\n        // fast path optimization\n\n        return result[0];\n    }\n\n    for (let i = 0, res; i < result_field.length; i++) {\n\n        res = result[i];\n\n        if (res.length) {\n\n            if (enrich) {\n\n                res = apply_enrich.call(this, res);\n            }\n        }\n\n        if (pluck) {\n\n            return res;\n        }\n\n        result[i] = {\n\n            field: result_field[i],\n            result: res\n        };\n    }\n\n    return result;\n};\n\n/**\r\n * @this Document\r\n */\n\nfunction get_tag(key, limit, offset) {\n    let res = this.tagindex[key],\n        len = res && res.length - offset;\n}\n\n/**\r\n * @this Document\r\n */\n\nfunction apply_enrich(res) {\n\n    const arr = Array(res.length);\n\n    for (let x = 0, id; x < res.length; x++) {\n\n        id = res[x];\n\n        arr[x] = {\n\n            id: id,\n            doc: this.store[id]\n        };\n    }\n\n    return arr;\n}\n\nDocument.prototype.contain = function (id) {\n\n    return !!this.register[id];\n};\n\nDocument.prototype.get = function (id) {\n\n    return this.store[id];\n};\n\nDocument.prototype.set = function (id, data) {\n\n    this.store[id] = data;\n    return this;\n};\n\n\nDocument.prototype.searchCache = searchCache;\n\n\nDocument.prototype.export = exportDocument;\nDocument.prototype.import = importDocument;\n\n\napply_async(Document.prototype);","var n,l,u,t,i,o,r,f,e,c,s,a,h={},p=[],v=/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i,y=Array.isArray;function d(n,l){for(var u in l)n[u]=l[u];return n}function w(n){var l=n.parentNode;l&&l.removeChild(n)}function _(l,u,t){var i,o,r,f={};for(r in u)\"key\"==r?i=u[r]:\"ref\"==r?o=u[r]:f[r]=u[r];if(arguments.length>2&&(f.children=arguments.length>3?n.call(arguments,2):t),\"function\"==typeof l&&null!=l.defaultProps)for(r in l.defaultProps)void 0===f[r]&&(f[r]=l.defaultProps[r]);return g(l,f,i,o,null)}function g(n,t,i,o,r){var f={type:n,props:t,key:i,ref:o,__k:null,__:null,__b:0,__e:null,__d:void 0,__c:null,constructor:void 0,__v:null==r?++u:r,__i:-1,__u:0};return null==r&&null!=l.vnode&&l.vnode(f),f}function m(){return{current:null}}function k(n){return n.children}function b(n,l){this.props=n,this.context=l}function x(n,l){if(null==l)return n.__?x(n.__,n.__i+1):null;for(var u;l<n.__k.length;l++)if(null!=(u=n.__k[l])&&null!=u.__e)return u.__e;return\"function\"==typeof n.type?x(n):null}function C(n){var l,u;if(null!=(n=n.__)&&null!=n.__c){for(n.__e=n.__c.base=null,l=0;l<n.__k.length;l++)if(null!=(u=n.__k[l])&&null!=u.__e){n.__e=n.__c.base=u.__e;break}return C(n)}}function M(n){(!n.__d&&(n.__d=!0)&&i.push(n)&&!P.__r++||o!==l.debounceRendering)&&((o=l.debounceRendering)||r)(P)}function P(){var n,u,t,o,r,e,c,s;for(i.sort(f);n=i.shift();)n.__d&&(u=i.length,o=void 0,e=(r=(t=n).__v).__e,c=[],s=[],t.__P&&((o=d({},r)).__v=r.__v+1,l.vnode&&l.vnode(o),O(t.__P,o,r,t.__n,t.__P.namespaceURI,32&r.__u?[e]:null,c,null==e?x(r):e,!!(32&r.__u),s),o.__v=r.__v,o.__.__k[o.__i]=o,j(c,o,s),o.__e!=e&&C(o)),i.length>u&&i.sort(f));P.__r=0}function S(n,l,u,t,i,o,r,f,e,c,s){var a,v,y,d,w,_=t&&t.__k||p,g=l.length;for(u.__d=e,$(u,l,_),e=u.__d,a=0;a<g;a++)null!=(y=u.__k[a])&&\"boolean\"!=typeof y&&\"function\"!=typeof y&&(v=-1===y.__i?h:_[y.__i]||h,y.__i=a,O(n,y,v,i,o,r,f,e,c,s),d=y.__e,y.ref&&v.ref!=y.ref&&(v.ref&&N(v.ref,null,y),s.push(y.ref,y.__c||d,y)),null==w&&null!=d&&(w=d),65536&y.__u||v.__k===y.__k?e=I(y,e,n):\"function\"==typeof y.type&&void 0!==y.__d?e=y.__d:d&&(e=d.nextSibling),y.__d=void 0,y.__u&=-196609);u.__d=e,u.__e=w}function $(n,l,u){var t,i,o,r,f,e=l.length,c=u.length,s=c,a=0;for(n.__k=[],t=0;t<e;t++)r=t+a,null!=(i=n.__k[t]=null==(i=l[t])||\"boolean\"==typeof i||\"function\"==typeof i?null:\"string\"==typeof i||\"number\"==typeof i||\"bigint\"==typeof i||i.constructor==String?g(null,i,null,null,null):y(i)?g(k,{children:i},null,null,null):void 0===i.constructor&&i.__b>0?g(i.type,i.props,i.key,i.ref?i.ref:null,i.__v):i)?(i.__=n,i.__b=n.__b+1,f=L(i,u,r,s),i.__i=f,o=null,-1!==f&&(s--,(o=u[f])&&(o.__u|=131072)),null==o||null===o.__v?(-1==f&&a--,\"function\"!=typeof i.type&&(i.__u|=65536)):f!==r&&(f==r-1?a=f-r:f==r+1?a++:f>r?s>e-r?a+=f-r:a--:f<r&&a++,f!==t+a&&(i.__u|=65536))):(o=u[r])&&null==o.key&&o.__e&&0==(131072&o.__u)&&(o.__e==n.__d&&(n.__d=x(o)),V(o,o,!1),u[r]=null,s--);if(s)for(t=0;t<c;t++)null!=(o=u[t])&&0==(131072&o.__u)&&(o.__e==n.__d&&(n.__d=x(o)),V(o,o))}function I(n,l,u){var t,i;if(\"function\"==typeof n.type){for(t=n.__k,i=0;t&&i<t.length;i++)t[i]&&(t[i].__=n,l=I(t[i],l,u));return l}n.__e!=l&&(l&&n.type&&!u.contains(l)&&(l=x(n)),u.insertBefore(n.__e,l||null),l=n.__e);do{l=l&&l.nextSibling}while(null!=l&&8===l.nodeType);return l}function H(n,l){return l=l||[],null==n||\"boolean\"==typeof n||(y(n)?n.some(function(n){H(n,l)}):l.push(n)),l}function L(n,l,u,t){var i=n.key,o=n.type,r=u-1,f=u+1,e=l[u];if(null===e||e&&i==e.key&&o===e.type&&0==(131072&e.__u))return u;if(t>(null!=e&&0==(131072&e.__u)?1:0))for(;r>=0||f<l.length;){if(r>=0){if((e=l[r])&&0==(131072&e.__u)&&i==e.key&&o===e.type)return r;r--}if(f<l.length){if((e=l[f])&&0==(131072&e.__u)&&i==e.key&&o===e.type)return f;f++}}return-1}function T(n,l,u){\"-\"===l[0]?n.setProperty(l,null==u?\"\":u):n[l]=null==u?\"\":\"number\"!=typeof u||v.test(l)?u:u+\"px\"}function A(n,l,u,t,i){var o;n:if(\"style\"===l)if(\"string\"==typeof u)n.style.cssText=u;else{if(\"string\"==typeof t&&(n.style.cssText=t=\"\"),t)for(l in t)u&&l in u||T(n.style,l,\"\");if(u)for(l in u)t&&u[l]===t[l]||T(n.style,l,u[l])}else if(\"o\"===l[0]&&\"n\"===l[1])o=l!==(l=l.replace(/(PointerCapture)$|Capture$/i,\"$1\")),l=l.toLowerCase()in n||\"onFocusOut\"===l||\"onFocusIn\"===l?l.toLowerCase().slice(2):l.slice(2),n.l||(n.l={}),n.l[l+o]=u,u?t?u.u=t.u:(u.u=e,n.addEventListener(l,o?s:c,o)):n.removeEventListener(l,o?s:c,o);else{if(\"http://www.w3.org/2000/svg\"==i)l=l.replace(/xlink(H|:h)/,\"h\").replace(/sName$/,\"s\");else if(\"width\"!=l&&\"height\"!=l&&\"href\"!=l&&\"list\"!=l&&\"form\"!=l&&\"tabIndex\"!=l&&\"download\"!=l&&\"rowSpan\"!=l&&\"colSpan\"!=l&&\"role\"!=l&&\"popover\"!=l&&l in n)try{n[l]=null==u?\"\":u;break n}catch(n){}\"function\"==typeof u||(null==u||!1===u&&\"-\"!==l[4]?n.removeAttribute(l):n.setAttribute(l,\"popover\"==l&&1==u?\"\":u))}}function F(n){return function(u){if(this.l){var t=this.l[u.type+n];if(null==u.t)u.t=e++;else if(u.t<t.u)return;return t(l.event?l.event(u):u)}}}function O(n,u,t,i,o,r,f,e,c,s){var a,h,p,v,w,_,g,m,x,C,M,P,$,I,H,L,T=u.type;if(void 0!==u.constructor)return null;128&t.__u&&(c=!!(32&t.__u),r=[e=u.__e=t.__e]),(a=l.__b)&&a(u);n:if(\"function\"==typeof T)try{if(m=u.props,x=\"prototype\"in T&&T.prototype.render,C=(a=T.contextType)&&i[a.__c],M=a?C?C.props.value:a.__:i,t.__c?g=(h=u.__c=t.__c).__=h.__E:(x?u.__c=h=new T(m,M):(u.__c=h=new b(m,M),h.constructor=T,h.render=q),C&&C.sub(h),h.props=m,h.state||(h.state={}),h.context=M,h.__n=i,p=h.__d=!0,h.__h=[],h._sb=[]),x&&null==h.__s&&(h.__s=h.state),x&&null!=T.getDerivedStateFromProps&&(h.__s==h.state&&(h.__s=d({},h.__s)),d(h.__s,T.getDerivedStateFromProps(m,h.__s))),v=h.props,w=h.state,h.__v=u,p)x&&null==T.getDerivedStateFromProps&&null!=h.componentWillMount&&h.componentWillMount(),x&&null!=h.componentDidMount&&h.__h.push(h.componentDidMount);else{if(x&&null==T.getDerivedStateFromProps&&m!==v&&null!=h.componentWillReceiveProps&&h.componentWillReceiveProps(m,M),!h.__e&&(null!=h.shouldComponentUpdate&&!1===h.shouldComponentUpdate(m,h.__s,M)||u.__v===t.__v)){for(u.__v!==t.__v&&(h.props=m,h.state=h.__s,h.__d=!1),u.__e=t.__e,u.__k=t.__k,u.__k.forEach(function(n){n&&(n.__=u)}),P=0;P<h._sb.length;P++)h.__h.push(h._sb[P]);h._sb=[],h.__h.length&&f.push(h);break n}null!=h.componentWillUpdate&&h.componentWillUpdate(m,h.__s,M),x&&null!=h.componentDidUpdate&&h.__h.push(function(){h.componentDidUpdate(v,w,_)})}if(h.context=M,h.props=m,h.__P=n,h.__e=!1,$=l.__r,I=0,x){for(h.state=h.__s,h.__d=!1,$&&$(u),a=h.render(h.props,h.state,h.context),H=0;H<h._sb.length;H++)h.__h.push(h._sb[H]);h._sb=[]}else do{h.__d=!1,$&&$(u),a=h.render(h.props,h.state,h.context),h.state=h.__s}while(h.__d&&++I<25);h.state=h.__s,null!=h.getChildContext&&(i=d(d({},i),h.getChildContext())),x&&!p&&null!=h.getSnapshotBeforeUpdate&&(_=h.getSnapshotBeforeUpdate(v,w)),S(n,y(L=null!=a&&a.type===k&&null==a.key?a.props.children:a)?L:[L],u,t,i,o,r,f,e,c,s),h.base=u.__e,u.__u&=-161,h.__h.length&&f.push(h),g&&(h.__E=h.__=null)}catch(n){if(u.__v=null,c||null!=r){for(u.__u|=c?160:32;e&&8===e.nodeType&&e.nextSibling;)e=e.nextSibling;r[r.indexOf(e)]=null,u.__e=e}else u.__e=t.__e,u.__k=t.__k;l.__e(n,u,t)}else null==r&&u.__v===t.__v?(u.__k=t.__k,u.__e=t.__e):u.__e=z(t.__e,u,t,i,o,r,f,c,s);(a=l.diffed)&&a(u)}function j(n,u,t){u.__d=void 0;for(var i=0;i<t.length;i++)N(t[i],t[++i],t[++i]);l.__c&&l.__c(u,n),n.some(function(u){try{n=u.__h,u.__h=[],n.some(function(n){n.call(u)})}catch(n){l.__e(n,u.__v)}})}function z(l,u,t,i,o,r,f,e,c){var s,a,p,v,d,_,g,m=t.props,k=u.props,b=u.type;if(\"svg\"===b?o=\"http://www.w3.org/2000/svg\":\"math\"===b?o=\"http://www.w3.org/1998/Math/MathML\":o||(o=\"http://www.w3.org/1999/xhtml\"),null!=r)for(s=0;s<r.length;s++)if((d=r[s])&&\"setAttribute\"in d==!!b&&(b?d.localName===b:3===d.nodeType)){l=d,r[s]=null;break}if(null==l){if(null===b)return document.createTextNode(k);l=document.createElementNS(o,b,k.is&&k),r=null,e=!1}if(null===b)m===k||e&&l.data===k||(l.data=k);else{if(r=r&&n.call(l.childNodes),m=t.props||h,!e&&null!=r)for(m={},s=0;s<l.attributes.length;s++)m[(d=l.attributes[s]).name]=d.value;for(s in m)if(d=m[s],\"children\"==s);else if(\"dangerouslySetInnerHTML\"==s)p=d;else if(\"key\"!==s&&!(s in k)){if(\"value\"==s&&\"defaultValue\"in k||\"checked\"==s&&\"defaultChecked\"in k)continue;A(l,s,null,d,o)}for(s in k)d=k[s],\"children\"==s?v=d:\"dangerouslySetInnerHTML\"==s?a=d:\"value\"==s?_=d:\"checked\"==s?g=d:\"key\"===s||e&&\"function\"!=typeof d||m[s]===d||A(l,s,d,m[s],o);if(a)e||p&&(a.__html===p.__html||a.__html===l.innerHTML)||(l.innerHTML=a.__html),u.__k=[];else if(p&&(l.innerHTML=\"\"),S(l,y(v)?v:[v],u,t,i,\"foreignObject\"===b?\"http://www.w3.org/1999/xhtml\":o,r,f,r?r[0]:t.__k&&x(t,0),e,c),null!=r)for(s=r.length;s--;)null!=r[s]&&w(r[s]);e||(s=\"value\",void 0!==_&&(_!==l[s]||\"progress\"===b&&!_||\"option\"===b&&_!==m[s])&&A(l,s,_,m[s],o),s=\"checked\",void 0!==g&&g!==l[s]&&A(l,s,g,m[s],o))}return l}function N(n,u,t){try{if(\"function\"==typeof n){var i=\"function\"==typeof n.__u;i&&n.__u(),i&&null==u||(n.__u=n(u))}else n.current=u}catch(n){l.__e(n,t)}}function V(n,u,t){var i,o;if(l.unmount&&l.unmount(n),(i=n.ref)&&(i.current&&i.current!==n.__e||N(i,null,u)),null!=(i=n.__c)){if(i.componentWillUnmount)try{i.componentWillUnmount()}catch(n){l.__e(n,u)}i.base=i.__P=null}if(i=n.__k)for(o=0;o<i.length;o++)i[o]&&V(i[o],u,t||\"function\"!=typeof n.type);t||null==n.__e||w(n.__e),n.__c=n.__=n.__e=n.__d=void 0}function q(n,l,u){return this.constructor(n,u)}function B(u,t,i){var o,r,f,e;l.__&&l.__(u,t),r=(o=\"function\"==typeof i)?null:i&&i.__k||t.__k,f=[],e=[],O(t,u=(!o&&i||t).__k=_(k,null,[u]),r||h,h,t.namespaceURI,!o&&i?[i]:r?null:t.firstChild?n.call(t.childNodes):null,f,!o&&i?i:r?r.__e:t.firstChild,o,e),j(f,u,e)}function D(n,l){B(n,l,D)}function E(l,u,t){var i,o,r,f,e=d({},l.props);for(r in l.type&&l.type.defaultProps&&(f=l.type.defaultProps),u)\"key\"==r?i=u[r]:\"ref\"==r?o=u[r]:e[r]=void 0===u[r]&&void 0!==f?f[r]:u[r];return arguments.length>2&&(e.children=arguments.length>3?n.call(arguments,2):t),g(l.type,e,i||l.key,o||l.ref,null)}function G(n,l){var u={__c:l=\"__cC\"+a++,__:n,Consumer:function(n,l){return n.children(l)},Provider:function(n){var u,t;return this.getChildContext||(u=[],(t={})[l]=this,this.getChildContext=function(){return t},this.componentWillUnmount=function(){u=null},this.shouldComponentUpdate=function(n){this.props.value!==n.value&&u.some(function(n){n.__e=!0,M(n)})},this.sub=function(n){u.push(n);var l=n.componentWillUnmount;n.componentWillUnmount=function(){u&&u.splice(u.indexOf(n),1),l&&l.call(n)}}),n.children}};return u.Provider.__=u.Consumer.contextType=u}n=p.slice,l={__e:function(n,l,u,t){for(var i,o,r;l=l.__;)if((i=l.__c)&&!i.__)try{if((o=i.constructor)&&null!=o.getDerivedStateFromError&&(i.setState(o.getDerivedStateFromError(n)),r=i.__d),null!=i.componentDidCatch&&(i.componentDidCatch(n,t||{}),r=i.__d),r)return i.__E=i}catch(l){n=l}throw n}},u=0,t=function(n){return null!=n&&null==n.constructor},b.prototype.setState=function(n,l){var u;u=null!=this.__s&&this.__s!==this.state?this.__s:this.__s=d({},this.state),\"function\"==typeof n&&(n=n(d({},u),this.props)),n&&d(u,n),null!=n&&this.__v&&(l&&this._sb.push(l),M(this))},b.prototype.forceUpdate=function(n){this.__v&&(this.__e=!0,n&&this.__h.push(n),M(this))},b.prototype.render=k,i=[],r=\"function\"==typeof Promise?Promise.prototype.then.bind(Promise.resolve()):setTimeout,f=function(n,l){return n.__v.__b-l.__v.__b},P.__r=0,e=0,c=F(!1),s=F(!0),a=0;export{b as Component,k as Fragment,E as cloneElement,G as createContext,_ as createElement,m as createRef,_ as h,D as hydrate,t as isValidElement,l as options,B as render,H as toChildArray};\n//# sourceMappingURL=preact.module.js.map\n","/* eslint-disable camelcase */\nconst {\n    Link_previous,\n    Link_next,\n    Search_no_results,\n    Search_one_character_or_more,\n    Search_one_result,\n    Search_results,\n    Search_should_be_x_or_more,\n    Search_too_short,\n} = window.searchTranslation;\n\nconst textLinkPrevious = Link_previous;\nconst textLinkNext = Link_next;\nconst textSearchNoResults = Search_no_results;\nconst textSearchOneCharacterOrMore = Search_one_character_or_more;\nconst textSearchOneResult = Search_one_result;\nconst textSearchResults = Search_results;\nconst textSearchShouldBeXOrMore = Search_should_be_x_or_more;\nconst textSearchTooShort = Search_too_short;\n/* eslint-enable camelcase */\n\nexport {\n    textLinkPrevious,\n    textLinkNext,\n    textSearchNoResults,\n    textSearchOneCharacterOrMore,\n    textSearchOneResult,\n    textSearchResults,\n    textSearchShouldBeXOrMore,\n    textSearchTooShort,\n};\n","import * as preact from \"preact\";\nimport { textLinkNext, textLinkPrevious } from \"./translation\";\n/** @jsx preact.h */\n\nexport default function Pagination({ counter, start, settings, onPageSelect }) {\n    const pages = Math.ceil(counter / settings.show);\n    const page = start / settings.show;\n\n    let displayedPages;\n    if (page <= 2) {\n        // Display max three pages\n        displayedPages = Math.min(pages, 3);\n    } else {\n        // Display two more pages, but don't overflow\n        displayedPages = Math.min(pages, page + 2);\n    }\n\n    const items = [];\n\n    for (let f = 0; f < displayedPages; f++) {\n        if (f === page) {\n            items.push(<li className=\"current\">{f + 1}</li>);\n        } else {\n            items.push(\n                <li>\n                    <button\n                        type=\"button\"\n                        className=\"SearchResults__footer__link\"\n                        onClick={() => onPageSelect(f * settings.show)}\n                    >\n                        {f + 1}\n                    </button>\n                </li>,\n            );\n        }\n    }\n\n    return (\n        <div className=\"SearchResults__footer\">\n            <ul className=\"SearchResults__footer__links Pager\">\n                {start > 0 && (\n                    <li className=\"Pager--prev\">\n                        <button\n                            type=\"button\"\n                            className=\"SearchResults__footer__link\"\n                            onClick={() => onPageSelect(start - settings.show)}\n                        >\n                            {textLinkPrevious}\n                        </button>\n                    </li>\n                )}\n                {items}\n                {page + 1 !== pages && (\n                    <li className=\"Pager--next\">\n                        <button\n                            type=\"button\"\n                            className=\"SearchResults__footer__link\"\n                            onClick={() => onPageSelect(start + settings.show)}\n                        >\n                            {textLinkNext}\n                        </button>\n                    </li>\n                )}\n            </ul>\n        </div>\n    );\n}\n","import * as preact from \"preact\";\n/** @jsx preact.h */\n\n// TODO :: restore highlight\n/*function highlightText(search, text) {\n    if (settings.highlightTerms) {\n        var pattern = new RegExp(\n            `(${search})`,\n            settings.highlightEveryTerm ? \"gi\" : \"i\"\n        );\n        text = text.replace(\n            pattern,\n            '<span class=\"SearchResults__highlight\">$1</span>'\n        );\n    }\n\n    return text;\n}*/\n\nexport default function Result({ settings, item }) {\n    let text;\n    if (item.text) {\n        text = item.text\n            .split(\" \")\n            .slice(0, settings.descriptiveWords)\n            .join(\" \");\n        if (\n            item.text.length < text.length &&\n            text.charAt(text.length - 1) !== \".\"\n        ) {\n            text += \" ...\";\n        }\n    }\n\n    return (\n        <div className=\"SearchResult\">\n            <div className=\"SearchResults__title\">\n                <a href={settings.base_url + item.url}>{item.title}</a>\n            </div>\n            {settings.showURL && (\n                <div className=\"SearchResults__url\">\n                    <a href={settings.base_url + item.url}>\n                        {item.url.toLowerCase().replace(/https?:\\/\\//g, \"\")}\n                    </a>\n                </div>\n            )}\n            {text && <div className=\"SearchResults__text\">{text}</div>}\n        </div>\n    );\n}\n","import * as preact from \"preact\";\n\nimport Pagination from \"./Pagination\";\nimport Result from \"./Result\";\nimport {\n    textSearchNoResults,\n    textSearchOneCharacterOrMore,\n    textSearchOneResult,\n    textSearchResults,\n    textSearchShouldBeXOrMore,\n    textSearchTooShort,\n} from \"./translation\";\n\n/** @jsx preact.h */\n\nexport default class Search extends preact.Component {\n    constructor(props) {\n        super(props);\n\n        this.state = {\n            search: this.props.settings.field.value || \"\",\n            start: 0,\n        };\n    }\n\n    // \"click\", \".SearchResults__close\"\n    handleClose = () => {\n        this.props.onClose();\n    };\n\n    scrollTop = () => {\n        if (this.resultRef) {\n            this.resultRef.scrollTop = 0;\n        }\n    };\n\n    handlePaginate = (start) => {\n        this.setState({ start }, this.scrollTop);\n    };\n\n    handleChange = (event) => {\n        this.setState({ search: event.target.value, start: 0 }, this.scrollTop);\n\n        this.props.settings.field.value = event.target.value;\n    };\n\n    getResults() {\n        const { settings } = this.props;\n        const { start } = this.state;\n\n        const warnings = [];\n        let counter = 0;\n        let results = [];\n\n        if (this.state.search.length < settings.minimumLength) {\n            warnings.push(textSearchTooShort);\n            warnings.push(\n                settings.minimumLength === 1\n                    ? textSearchOneCharacterOrMore\n                    : textSearchShouldBeXOrMore.replace(\n                          \"!min\",\n                          settings.minimumLength,\n                      ),\n            );\n\n            return { warnings, counter, results, start };\n        }\n\n        const found = Object.values(\n            this.props\n                .onSearch(this.state.search)\n                .reduce((acc, fieldResult) => {\n                    // FlexSearch returns results per field\n                    // We de-duplicate them here and have a single array of results\n                    for (const result of fieldResult.result) {\n                        if (!acc.hasOwnProperty(result.id)) {\n                            acc[result.id] = {\n                                url: result.id,\n                                title: result.doc.title,\n                                text: result.doc.text,\n                            };\n                        }\n                    }\n\n                    return acc;\n                }, {}),\n        );\n\n        counter = found.length;\n\n        if (counter === 0) {\n            warnings.push(textSearchNoResults);\n            return { warnings, counter, results, start };\n        }\n\n        if (settings.showTitleCount) {\n            this.props.onTitleChange(`(${counter})`);\n        }\n\n        results = found.filter(\n            (item, itemNumber) =>\n                itemNumber >= start && itemNumber < settings.show + start,\n        );\n\n        return { warnings, counter, results, start };\n    }\n\n    render() {\n        const { settings } = this.props;\n        const { warnings, counter, results, start } = this.getResults();\n\n        return (\n            <div>\n                <div className=\"SearchResultsBackdrop\" />\n                <div\n                    className=\"SearchResults\"\n                    ref={(el) => {\n                        this.resultRef = el;\n                    }}\n                >\n                    <input\n                        className=\"Search__field\"\n                        placeholder=\"Search...\"\n                        autoComplete=\"on\"\n                        autoSave=\"text_search\"\n                        type=\"search\"\n                        value={this.state.search}\n                        onInput={this.handleChange}\n                    />\n                    <button\n                        type=\"button\"\n                        className=\"SearchResults__close\"\n                        onClick={this.handleClose}\n                    >\n                        &times;\n                    </button>\n                    <div className=\"SearchResults__count\">\n                        {counter === 1\n                            ? textSearchOneResult\n                            : textSearchResults.replace(\"!count\", counter)}\n                    </div>\n                    {warnings.map((warning) => (\n                        <div key={warning} className=\"SearchResults__warning\">\n                            {warning}\n                        </div>\n                    ))}\n                    {results.map((result) => (\n                        <Result\n                            key={result.title}\n                            item={result}\n                            settings={settings}\n                        />\n                    ))}\n                    {counter > settings.show && (\n                        <Pagination\n                            counter={counter}\n                            start={start}\n                            settings={settings}\n                            onPageSelect={this.handlePaginate}\n                        />\n                    )}\n                </div>\n            </div>\n        );\n    }\n}\n","import Document from \"flexsearch/dist/module/document\";\nimport * as preact from \"preact\";\nimport Search from \"./Search\";\n\n/** @jsx preact.h */\n\nconst originalTitle = document.title;\n\nfunction getURLP(name) {\n    const elements = new RegExp(`[?|&]${name}=([^&;]+?)(&|#|;|$)`).exec(\n        window.location.search,\n    );\n\n    return (\n        decodeURIComponent((elements?.[1] || \"\").replace(/\\+/g, \"%20\")) || null\n    );\n}\n\nclass SearchEngine {\n    constructor(options) {\n        this.settings = {\n            field: document.getElementById(\"search_input\"),\n            form: document.getElementById(\"search_form\"),\n            show: 10,\n            showURL: true,\n            showTitleCount: true,\n            minimumLength: 3,\n            descriptiveWords: 25,\n            highlightTerms: true,\n            highlightEveryTerm: false,\n            contentLocation: \"daux_search_index.js\",\n            ...options,\n        };\n\n        this.searchIndex = {\n            pages: [],\n        };\n    }\n\n    loadData() {\n        if (!this.loadingPromise) {\n            // We do this as jsonp instead of an XHR or fetch request\n            // to be compatible with usage from filesystem\n            const po = document.createElement(\"script\");\n            po.type = \"text/javascript\";\n            po.async = true;\n            po.src = this.settings.base_url + this.settings.contentLocation;\n            const s = document.getElementsByTagName(\"script\")[0];\n            s.parentNode.insertBefore(po, s);\n\n            this.loadingPromise = new Promise((resolve) => {\n                window.load_search_index = (data) => resolve(data);\n            }).then((json) => {\n                this.searchIndex = new Document({\n                    doc: {\n                        id: \"url\",\n                        tag: \"tags\",\n                        field: [\"title\", \"text\"],\n                        store: [\"title\", \"text\"],\n                    },\n                });\n\n                let pages = json.pages;\n\n                // Only keep the pages related to the current language\n                if (window.searchLanguage) {\n                    const pagePrefix = `${window.searchLanguage}/`;\n                    pages = pages.filter(\n                        (item) => item.url.indexOf(pagePrefix) === 0,\n                    );\n                }\n\n                for (const page of pages) {\n                    this.searchIndex.add(page);\n                }\n            });\n        }\n\n        return this.loadingPromise;\n    }\n\n    run() {\n        if (getURLP(\"q\")) {\n            this.settings.field.value = getURLP(\"q\");\n\n            this.loadData().then(() => {\n                this.displaySearch();\n            });\n        }\n\n        this.settings.field.addEventListener(\"keyup\", (event) => {\n            // Start loading index once the user types text in the field, not before\n            this.loadData();\n\n            if (Number.parseInt(event.keyCode, 10) === 13) {\n                this.loadData().then(() => {\n                    this.displaySearch();\n                });\n            }\n        });\n\n        this.settings.form.addEventListener(\"submit\", (event) => {\n            event.preventDefault();\n            this.loadData().then(() => {\n                this.displaySearch();\n            });\n        });\n    }\n\n    keyUpHandler = (e) => {\n        if (e.which === 27) {\n            //escape\n            this.handleClose();\n        }\n    };\n\n    handleClose = () => {\n        document.title = originalTitle;\n\n        document.removeEventListener(\"keyup\", this.keyUpHandler);\n\n        document.body.classList.remove(\"with-search\");\n        preact.render(null, this.resultContainer);\n        this.resultContainer = null;\n    };\n\n    displaySearch() {\n        if (!this.resultContainer) {\n            this.resultContainer = document.createElement(\"div\");\n            document.body.appendChild(this.resultContainer);\n        }\n\n        document.addEventListener(\"keyup\", this.keyUpHandler);\n\n        preact.render(\n            <Search\n                onSearch={(term) =>\n                    this.searchIndex.search(term, { enrich: true })\n                }\n                onClose={this.handleClose}\n                onTitleChange={(title) => {\n                    document.title = `${title} ${originalTitle}`;\n                }}\n                settings={this.settings}\n            />,\n            this.resultContainer,\n        );\n\n        document.body.classList.add(\"with-search\");\n        document.body.scrollTop = 0;\n    }\n}\n\n// Main containers\n\nfunction search(options) {\n    const instance = new SearchEngine(options);\n    instance.run();\n}\n\n// Declare globally\nwindow.search = search;\n"],"names":["prototype","register","key","self","this","args","arguments","arg","length","callback","promise","Promise","resolve","setTimeout","async","res","apply","then","CacheClass","limit","cache","queue","searchCache","query","options","get","search","set","value","x","pos","indexOf","tmp","del","id","item","i","includes","splice","parse_option","default_value","create_object_array","count","array","Array","create_object","get_keys","obj","Object","keys","create","concat","arrays","sort_by_length_down","a","b","is_array","val","constructor","is_string","is_object","is_function","pipeline","str","normalize","split","_collapse","replace","matcher","stemmer","string","final","prev","char","len","collapse","words","filter","map","filtered","word","regex_whitespace","init_stemmer_or_matcher","is_stemmer","removal","regex","regexp","RegExp","encode","call","toLowerCase","global_lang","global_charset","preset","memory","charset","resolution","minlength","fastupdate","performance","optimize","context","depth","match","tokenize","score","default","Index","_register","lang","assign","apply_preset","bidirectional","boost","resolution_ctx","ctx","rtl","init_filter","get_score","term_length","single_result","result","offset","slice","get_array","arr","term","keyword","swap","remove_index","Math","min","append","content","add","_append","_skip_update","update","dupes_ctx","dupes","token","y","partial_score","substring","push_index","dupes_inner","size","context_score","suggest","query_new","index","sort","add_result","intersect","single_term","word_arr","arr_len","contain","remove","_skip_deletion","refs","export","import","check","check_suggest","word_arr_len","check_new","found","check_idx","z","intersect_union","mandatory","union","field","index_doc","data","on_done","JSON","stringify","exportIndex","return_value","doc","opt","importIndex","parse","exportDocument","idx","tagindex","store","importDocument","IndexInterface","_index","task","factory","Function","FlexSearch","message","postMessage","msg","pid","WorkerIndex","toString","window","_factory","is_node_js","exports","_self","worker","resolver","on","onmessage","worker_path","eval","Worker","URL","createObjectURL","Blob","type","e","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","module","__webpack_modules__","d","definition","o","defineProperty","enumerable","prop","hasOwnProperty","Document","document","tree","marker","parse_tree","storetree","tag","parse_descriptor","parse_simple","store_value","add_index","join","get_tag","apply_enrich","_resolve","pluck","enrich","bool","result_field","promises","field_options","searchAsync","all","n","l","u","t","r","f","c","s","h","p","v","isArray","w","parentNode","removeChild","_","children","defaultProps","g","props","ref","__k","__","__b","__e","__d","__c","__v","__i","__u","vnode","m","current","k","C","base","M","push","P","__r","debounceRendering","shift","__P","O","__n","namespaceURI","j","S","$","N","I","nextSibling","String","L","V","contains","insertBefore","nodeType","H","some","T","setProperty","test","A","style","cssText","addEventListener","removeEventListener","removeAttribute","setAttribute","F","event","render","contextType","__E","q","sub","state","__h","_sb","__s","getDerivedStateFromProps","componentWillMount","componentDidMount","componentWillReceiveProps","shouldComponentUpdate","forEach","componentWillUpdate","componentDidUpdate","getChildContext","getSnapshotBeforeUpdate","diffed","localName","createTextNode","createElementNS","is","childNodes","attributes","name","__html","innerHTML","unmount","componentWillUnmount","B","firstChild","D","E","G","Consumer","Provider","getDerivedStateFromError","setState","componentDidCatch","forceUpdate","bind","searchTranslation","Link_previous","Link_next","Search_no_results","Search_one_character_or_more","Search_one_result","Search_results","Search_should_be_x_or_more","Search_too_short","textLinkPrevious","textLinkNext","textSearchNoResults","textSearchOneCharacterOrMore","textSearchOneResult","textSearchResults","textSearchShouldBeXOrMore","textSearchTooShort","Pagination","displayedPages","page","items","li","className","button","onClick","onPageSelect","settings","show","counter","start","pages","ceil","div","ul","Result","text","descriptiveWords","charAt","href","base_url","url","title","showURL","Search","handleClose","onClose","scrollTop","resultRef","handlePaginate","handleChange","target","getResults","warnings","results","minimumLength","values","onSearch","reduce","acc","fieldResult","showTitleCount","onTitleChange","itemNumber","el","input","placeholder","autoComplete","autoSave","onInput","warning","preact","originalTitle","getURLP","elements","exec","location","decodeURIComponent","SearchEngine","keyUpHandler","which","body","classList","resultContainer","getElementById","form","highlightTerms","highlightEveryTerm","contentLocation","searchIndex","loadData","loadingPromise","po","createElement","src","getElementsByTagName","load_search_index","json","searchLanguage","pagePrefix","run","displaySearch","Number","parseInt","keyCode","preventDefault","appendChild"],"sourceRoot":""}