{"version":3,"file":"@orchidjs-BHPRxGz6.js","sources":["../../../../../shared/node_modules/@orchidjs/unicode-variants/dist/esm/regex.js","../../../../../shared/node_modules/@orchidjs/unicode-variants/dist/esm/strings.js","../../../../../shared/node_modules/@orchidjs/unicode-variants/dist/esm/index.js","../../../../../shared/node_modules/@orchidjs/sifter/dist/esm/utils.js","../../../../../shared/node_modules/@orchidjs/sifter/dist/esm/sifter.js"],"sourcesContent":["/**\n * Convert array of strings to a regular expression\n *\tex ['ab','a'] => (?:ab|a)\n * \tex ['a','b'] => [ab]\n */\nexport const arrayToPattern = (chars) => {\n    chars = chars.filter(Boolean);\n    if (chars.length < 2) {\n        return chars[0] || '';\n    }\n    return (maxValueLength(chars) == 1) ? '[' + chars.join('') + ']' : '(?:' + chars.join('|') + ')';\n};\nexport const sequencePattern = (array) => {\n    if (!hasDuplicates(array)) {\n        return array.join('');\n    }\n    let pattern = '';\n    let prev_char_count = 0;\n    const prev_pattern = () => {\n        if (prev_char_count > 1) {\n            pattern += '{' + prev_char_count + '}';\n        }\n    };\n    array.forEach((char, i) => {\n        if (char === array[i - 1]) {\n            prev_char_count++;\n            return;\n        }\n        prev_pattern();\n        pattern += char;\n        prev_char_count = 1;\n    });\n    prev_pattern();\n    return pattern;\n};\n/**\n * Convert array of strings to a regular expression\n *\tex ['ab','a'] => (?:ab|a)\n * \tex ['a','b'] => [ab]\n */\nexport const setToPattern = (chars) => {\n    let array = Array.from(chars);\n    return arrayToPattern(array);\n};\n/**\n * https://stackoverflow.com/questions/7376598/in-javascript-how-do-i-check-if-an-array-has-duplicate-values\n */\nexport const hasDuplicates = (array) => {\n    return (new Set(array)).size !== array.length;\n};\n/**\n * https://stackoverflow.com/questions/63006601/why-does-u-throw-an-invalid-escape-error\n */\nexport const escape_regex = (str) => {\n    return (str + '').replace(/([\\$\\(\\)\\*\\+\\.\\?\\[\\]\\^\\{\\|\\}\\\\])/gu, '\\\\$1');\n};\n/**\n * Return the max length of array values\n */\nexport const maxValueLength = (array) => {\n    return array.reduce((longest, value) => Math.max(longest, unicodeLength(value)), 0);\n};\nexport const unicodeLength = (str) => {\n    return Array.from(str).length;\n};\n//# sourceMappingURL=regex.js.map","/**\n * Get all possible combinations of substrings that add up to the given string\n * https://stackoverflow.com/questions/30169587/find-all-the-combination-of-substrings-that-add-up-to-the-given-string\n */\nexport const allSubstrings = (input) => {\n    if (input.length === 1)\n        return [[input]];\n    let result = [];\n    const start = input.substring(1);\n    const suba = allSubstrings(start);\n    suba.forEach(function (subresult) {\n        let tmp = subresult.slice(0);\n        tmp[0] = input.charAt(0) + tmp[0];\n        result.push(tmp);\n        tmp = subresult.slice(0);\n        tmp.unshift(input.charAt(0));\n        result.push(tmp);\n    });\n    return result;\n};\n//# sourceMappingURL=strings.js.map","import { setToPattern, arrayToPattern, escape_regex, sequencePattern } from \"./regex.js\";\nimport { allSubstrings } from \"./strings.js\";\nexport const code_points = [[0, 65535]];\nconst accent_pat = '[\\u0300-\\u036F\\u{b7}\\u{2be}\\u{2bc}]';\nexport let unicode_map;\nlet multi_char_reg;\nconst max_char_length = 3;\nconst latin_convert = {};\nconst latin_condensed = {\n    '/': '⁄∕',\n    '0': '߀',\n    \"a\": \"ⱥɐɑ\",\n    \"aa\": \"ꜳ\",\n    \"ae\": \"æǽǣ\",\n    \"ao\": \"ꜵ\",\n    \"au\": \"ꜷ\",\n    \"av\": \"ꜹꜻ\",\n    \"ay\": \"ꜽ\",\n    \"b\": \"ƀɓƃ\",\n    \"c\": \"ꜿƈȼↄ\",\n    \"d\": \"đɗɖᴅƌꮷԁɦ\",\n    \"e\": \"ɛǝᴇɇ\",\n    \"f\": \"ꝼƒ\",\n    \"g\": \"ǥɠꞡᵹꝿɢ\",\n    \"h\": \"ħⱨⱶɥ\",\n    \"i\": \"ɨı\",\n    \"j\": \"ɉȷ\",\n    \"k\": \"ƙⱪꝁꝃꝅꞣ\",\n    \"l\": \"łƚɫⱡꝉꝇꞁɭ\",\n    \"m\": \"ɱɯϻ\",\n    \"n\": \"ꞥƞɲꞑᴎлԉ\",\n    \"o\": \"øǿɔɵꝋꝍᴑ\",\n    \"oe\": \"œ\",\n    \"oi\": \"ƣ\",\n    \"oo\": \"ꝏ\",\n    \"ou\": \"ȣ\",\n    \"p\": \"ƥᵽꝑꝓꝕρ\",\n    \"q\": \"ꝗꝙɋ\",\n    \"r\": \"ɍɽꝛꞧꞃ\",\n    \"s\": \"ßȿꞩꞅʂ\",\n    \"t\": \"ŧƭʈⱦꞇ\",\n    \"th\": \"þ\",\n    \"tz\": \"ꜩ\",\n    \"u\": \"ʉ\",\n    \"v\": \"ʋꝟʌ\",\n    \"vy\": \"ꝡ\",\n    \"w\": \"ⱳ\",\n    \"y\": \"ƴɏỿ\",\n    \"z\": \"ƶȥɀⱬꝣ\",\n    \"hv\": \"ƕ\"\n};\nfor (let latin in latin_condensed) {\n    let unicode = latin_condensed[latin] || '';\n    for (let i = 0; i < unicode.length; i++) {\n        let char = unicode.substring(i, i + 1);\n        latin_convert[char] = latin;\n    }\n}\nconst convert_pat = new RegExp(Object.keys(latin_convert).join('|') + '|' + accent_pat, 'gu');\n/**\n * Initialize the unicode_map from the give code point ranges\n */\nexport const initialize = (_code_points) => {\n    if (unicode_map !== undefined)\n        return;\n    unicode_map = generateMap(_code_points || code_points);\n};\n/**\n * Helper method for normalize a string\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\n */\nexport const normalize = (str, form = 'NFKD') => str.normalize(form);\n/**\n * Remove accents without reordering string\n * calling str.normalize('NFKD') on \\u{594}\\u{595}\\u{596} becomes \\u{596}\\u{594}\\u{595}\n * via https://github.com/krisk/Fuse/issues/133#issuecomment-318692703\n */\nexport const asciifold = (str) => {\n    return Array.from(str).reduce(\n    /**\n     * @param {string} result\n     * @param {string} char\n     */\n    (result, char) => {\n        return result + _asciifold(char);\n    }, '');\n};\nexport const _asciifold = (str) => {\n    str = normalize(str)\n        .toLowerCase()\n        .replace(convert_pat, (/** @type {string} */ char) => {\n        return latin_convert[char] || '';\n    });\n    //return str;\n    return normalize(str, 'NFC');\n};\n/**\n * Generate a list of unicode variants from the list of code points\n */\nexport function* generator(code_points) {\n    for (const [code_point_min, code_point_max] of code_points) {\n        for (let i = code_point_min; i <= code_point_max; i++) {\n            let composed = String.fromCharCode(i);\n            let folded = asciifold(composed);\n            if (folded == composed.toLowerCase()) {\n                continue;\n            }\n            // skip when folded is a string longer than 3 characters long\n            // bc the resulting regex patterns will be long\n            // eg:\n            // folded صلى الله عليه وسلم length 18 code point 65018\n            // folded جل جلاله length 8 code point 65019\n            if (folded.length > max_char_length) {\n                continue;\n            }\n            if (folded.length == 0) {\n                continue;\n            }\n            yield { folded: folded, composed: composed, code_point: i };\n        }\n    }\n}\n/**\n * Generate a unicode map from the list of code points\n */\nexport const generateSets = (code_points) => {\n    const unicode_sets = {};\n    const addMatching = (folded, to_add) => {\n        /** @type {Set<string>} */\n        const folded_set = unicode_sets[folded] || new Set();\n        const patt = new RegExp('^' + setToPattern(folded_set) + '$', 'iu');\n        if (to_add.match(patt)) {\n            return;\n        }\n        folded_set.add(escape_regex(to_add));\n        unicode_sets[folded] = folded_set;\n    };\n    for (let value of generator(code_points)) {\n        addMatching(value.folded, value.folded);\n        addMatching(value.folded, value.composed);\n    }\n    return unicode_sets;\n};\n/**\n * Generate a unicode map from the list of code points\n * ae => (?:(?:ae|Æ|Ǽ|Ǣ)|(?:A|Ⓐ|Ａ...)(?:E|ɛ|Ⓔ...))\n */\nexport const generateMap = (code_points) => {\n    const unicode_sets = generateSets(code_points);\n    const unicode_map = {};\n    let multi_char = [];\n    for (let folded in unicode_sets) {\n        let set = unicode_sets[folded];\n        if (set) {\n            unicode_map[folded] = setToPattern(set);\n        }\n        if (folded.length > 1) {\n            multi_char.push(escape_regex(folded));\n        }\n    }\n    multi_char.sort((a, b) => b.length - a.length);\n    const multi_char_patt = arrayToPattern(multi_char);\n    multi_char_reg = new RegExp('^' + multi_char_patt, 'u');\n    return unicode_map;\n};\n/**\n * Map each element of an array from its folded value to all possible unicode matches\n */\nexport const mapSequence = (strings, min_replacement = 1) => {\n    let chars_replaced = 0;\n    strings = strings.map((str) => {\n        if (unicode_map[str]) {\n            chars_replaced += str.length;\n        }\n        return unicode_map[str] || str;\n    });\n    if (chars_replaced >= min_replacement) {\n        return sequencePattern(strings);\n    }\n    return '';\n};\n/**\n * Convert a short string and split it into all possible patterns\n * Keep a pattern only if min_replacement is met\n *\n * 'abc'\n * \t\t=> [['abc'],['ab','c'],['a','bc'],['a','b','c']]\n *\t\t=> ['abc-pattern','ab-c-pattern'...]\n */\nexport const substringsToPattern = (str, min_replacement = 1) => {\n    min_replacement = Math.max(min_replacement, str.length - 1);\n    return arrayToPattern(allSubstrings(str).map((sub_pat) => {\n        return mapSequence(sub_pat, min_replacement);\n    }));\n};\n/**\n * Convert an array of sequences into a pattern\n * [{start:0,end:3,length:3,substr:'iii'}...] => (?:iii...)\n */\nconst sequencesToPattern = (sequences, all = true) => {\n    let min_replacement = sequences.length > 1 ? 1 : 0;\n    return arrayToPattern(sequences.map((sequence) => {\n        let seq = [];\n        const len = all ? sequence.length() : sequence.length() - 1;\n        for (let j = 0; j < len; j++) {\n            seq.push(substringsToPattern(sequence.substrs[j] || '', min_replacement));\n        }\n        return sequencePattern(seq);\n    }));\n};\n/**\n * Return true if the sequence is already in the sequences\n */\nconst inSequences = (needle_seq, sequences) => {\n    for (const seq of sequences) {\n        if (seq.start != needle_seq.start || seq.end != needle_seq.end) {\n            continue;\n        }\n        if (seq.substrs.join('') !== needle_seq.substrs.join('')) {\n            continue;\n        }\n        let needle_parts = needle_seq.parts;\n        const filter = (part) => {\n            for (const needle_part of needle_parts) {\n                if (needle_part.start === part.start && needle_part.substr === part.substr) {\n                    return false;\n                }\n                if (part.length == 1 || needle_part.length == 1) {\n                    continue;\n                }\n                // check for overlapping parts\n                // a = ['::=','==']\n                // b = ['::','===']\n                // a = ['r','sm']\n                // b = ['rs','m']\n                if (part.start < needle_part.start && part.end > needle_part.start) {\n                    return true;\n                }\n                if (needle_part.start < part.start && needle_part.end > part.start) {\n                    return true;\n                }\n            }\n            return false;\n        };\n        let filtered = seq.parts.filter(filter);\n        if (filtered.length > 0) {\n            continue;\n        }\n        return true;\n    }\n    return false;\n};\nclass Sequence {\n    parts;\n    substrs;\n    start;\n    end;\n    constructor() {\n        this.parts = [];\n        this.substrs = [];\n        this.start = 0;\n        this.end = 0;\n    }\n    add(part) {\n        if (part) {\n            this.parts.push(part);\n            this.substrs.push(part.substr);\n            this.start = Math.min(part.start, this.start);\n            this.end = Math.max(part.end, this.end);\n        }\n    }\n    last() {\n        return this.parts[this.parts.length - 1];\n    }\n    length() {\n        return this.parts.length;\n    }\n    clone(position, last_piece) {\n        let clone = new Sequence();\n        let parts = JSON.parse(JSON.stringify(this.parts));\n        let last_part = parts.pop();\n        for (const part of parts) {\n            clone.add(part);\n        }\n        let last_substr = last_piece.substr.substring(0, position - last_part.start);\n        let clone_last_len = last_substr.length;\n        clone.add({ start: last_part.start, end: last_part.start + clone_last_len, length: clone_last_len, substr: last_substr });\n        return clone;\n    }\n}\n/**\n * Expand a regular expression pattern to include unicode variants\n * \teg /a/ becomes /aⓐａẚàáâầấẫẩãāăằắẵẳȧǡäǟảåǻǎȁȃạậặḁąⱥɐɑAⒶＡÀÁÂẦẤẪẨÃĀĂẰẮẴẲȦǠÄǞẢÅǺǍȀȂẠẬẶḀĄȺⱯ/\n *\n * Issue:\n *  ﺊﺋ [ 'ﺊ = \\\\u{fe8a}', 'ﺋ = \\\\u{fe8b}' ]\n *\tbecomes:\tئئ [ 'ي = \\\\u{64a}', 'ٔ = \\\\u{654}', 'ي = \\\\u{64a}', 'ٔ = \\\\u{654}' ]\n *\n *\tİIJ = IIJ = ⅡJ\n *\n * \t1/2/4\n */\nexport const getPattern = (str) => {\n    initialize();\n    str = asciifold(str);\n    let pattern = '';\n    let sequences = [new Sequence()];\n    for (let i = 0; i < str.length; i++) {\n        let substr = str.substring(i);\n        let match = substr.match(multi_char_reg);\n        const char = str.substring(i, i + 1);\n        const match_str = match ? match[0] : null;\n        // loop through sequences\n        // add either the char or multi_match\n        let overlapping = [];\n        let added_types = new Set();\n        for (const sequence of sequences) {\n            const last_piece = sequence.last();\n            if (!last_piece || last_piece.length == 1 || last_piece.end <= i) {\n                // if we have a multi match\n                if (match_str) {\n                    const len = match_str.length;\n                    sequence.add({ start: i, end: i + len, length: len, substr: match_str });\n                    added_types.add('1');\n                }\n                else {\n                    sequence.add({ start: i, end: i + 1, length: 1, substr: char });\n                    added_types.add('2');\n                }\n            }\n            else if (match_str) {\n                let clone = sequence.clone(i, last_piece);\n                const len = match_str.length;\n                clone.add({ start: i, end: i + len, length: len, substr: match_str });\n                overlapping.push(clone);\n            }\n            else {\n                // don't add char\n                // adding would create invalid patterns: 234 => [2,34,4]\n                added_types.add('3');\n            }\n        }\n        // if we have overlapping\n        if (overlapping.length > 0) {\n            // ['ii','iii'] before ['i','i','iii']\n            overlapping = overlapping.sort((a, b) => {\n                return a.length() - b.length();\n            });\n            for (let clone of overlapping) {\n                // don't add if we already have an equivalent sequence\n                if (inSequences(clone, sequences)) {\n                    continue;\n                }\n                sequences.push(clone);\n            }\n            continue;\n        }\n        // if we haven't done anything unique\n        // clean up the patterns\n        // helps keep patterns smaller\n        // if str = 'r₨㎧aarss', pattern will be 446 instead of 655\n        if (i > 0 && added_types.size == 1 && !added_types.has('3')) {\n            pattern += sequencesToPattern(sequences, false);\n            let new_seq = new Sequence();\n            const old_seq = sequences[0];\n            if (old_seq) {\n                new_seq.add(old_seq.last());\n            }\n            sequences = [new_seq];\n        }\n    }\n    pattern += sequencesToPattern(sequences, true);\n    return pattern;\n};\nexport { escape_regex };\n//# sourceMappingURL=index.js.map","import { asciifold } from '@orchidjs/unicode-variants';\n/**\n * A property getter resolving dot-notation\n * @param  {Object}  obj     The root object to fetch property on\n * @param  {String}  name    The optionally dotted property name to fetch\n * @return {Object}          The resolved property value\n */\nexport const getAttr = (obj, name) => {\n    if (!obj)\n        return;\n    return obj[name];\n};\n/**\n * A property getter resolving dot-notation\n * @param  {Object}  obj     The root object to fetch property on\n * @param  {String}  name    The optionally dotted property name to fetch\n * @return {Object}          The resolved property value\n */\nexport const getAttrNesting = (obj, name) => {\n    if (!obj)\n        return;\n    var part, names = name.split(\".\");\n    while ((part = names.shift()) && (obj = obj[part]))\n        ;\n    return obj;\n};\n/**\n * Calculates how close of a match the\n * given value is against a search token.\n *\n */\nexport const scoreValue = (value, token, weight) => {\n    var score, pos;\n    if (!value)\n        return 0;\n    value = value + '';\n    if (token.regex == null)\n        return 0;\n    pos = value.search(token.regex);\n    if (pos === -1)\n        return 0;\n    score = token.string.length / value.length;\n    if (pos === 0)\n        score += 0.5;\n    return score * weight;\n};\n/**\n * Cast object property to an array if it exists and has a value\n *\n */\nexport const propToArray = (obj, key) => {\n    var value = obj[key];\n    if (typeof value == 'function')\n        return value;\n    if (value && !Array.isArray(value)) {\n        obj[key] = [value];\n    }\n};\n/**\n * Iterates over arrays and hashes.\n *\n * ```\n * iterate(this.items, function(item, id) {\n *    // invoked for each item\n * });\n * ```\n *\n */\nexport const iterate = (object, callback) => {\n    if (Array.isArray(object)) {\n        object.forEach(callback);\n    }\n    else {\n        for (var key in object) {\n            if (object.hasOwnProperty(key)) {\n                callback(object[key], key);\n            }\n        }\n    }\n};\nexport const cmp = (a, b) => {\n    if (typeof a === 'number' && typeof b === 'number') {\n        return a > b ? 1 : (a < b ? -1 : 0);\n    }\n    a = asciifold(a + '').toLowerCase();\n    b = asciifold(b + '').toLowerCase();\n    if (a > b)\n        return 1;\n    if (b > a)\n        return -1;\n    return 0;\n};\n//# sourceMappingURL=utils.js.map","/**\n * sifter.js\n * Copyright (c) 2013–2020 Brian Reavis & contributors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this\n * file except in compliance with the License. You may obtain a copy of the License at:\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF\n * ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n *\n * @author Brian Reavis <brian@thirdroute.com>\n */\nimport { scoreValue, getAttr, getAttrNesting, propToArray, iterate, cmp } from \"./utils.js\";\nimport { getPattern, escape_regex } from '@orchidjs/unicode-variants';\nclass Sifter {\n    items; // []|{};\n    settings;\n    /**\n     * Textually searches arrays and hashes of objects\n     * by property (or multiple properties). Designed\n     * specifically for autocomplete.\n     *\n     */\n    constructor(items, settings) {\n        this.items = items;\n        this.settings = settings || { diacritics: true };\n    }\n    ;\n    /**\n     * Splits a search string into an array of individual\n     * regexps to be used to match results.\n     *\n     */\n    tokenize(query, respect_word_boundaries, weights) {\n        if (!query || !query.length)\n            return [];\n        const tokens = [];\n        const words = query.split(/\\s+/);\n        var field_regex;\n        if (weights) {\n            field_regex = new RegExp('^(' + Object.keys(weights).map(escape_regex).join('|') + ')\\:(.*)$');\n        }\n        words.forEach((word) => {\n            let field_match;\n            let field = null;\n            let regex = null;\n            // look for \"field:query\" tokens\n            if (field_regex && (field_match = word.match(field_regex))) {\n                field = field_match[1];\n                word = field_match[2];\n            }\n            if (word.length > 0) {\n                if (this.settings.diacritics) {\n                    regex = getPattern(word) || null;\n                }\n                else {\n                    regex = escape_regex(word);\n                }\n                if (regex && respect_word_boundaries)\n                    regex = \"\\\\b\" + regex;\n            }\n            tokens.push({\n                string: word,\n                regex: regex ? new RegExp(regex, 'iu') : null,\n                field: field,\n            });\n        });\n        return tokens;\n    }\n    ;\n    /**\n     * Returns a function to be used to score individual results.\n     *\n     * Good matches will have a higher score than poor matches.\n     * If an item is not a match, 0 will be returned by the function.\n     *\n     * @returns {T.ScoreFn}\n     */\n    getScoreFunction(query, options) {\n        var search = this.prepareSearch(query, options);\n        return this._getScoreFunction(search);\n    }\n    /**\n     * @returns {T.ScoreFn}\n     *\n     */\n    _getScoreFunction(search) {\n        const tokens = search.tokens, token_count = tokens.length;\n        if (!token_count) {\n            return function () { return 0; };\n        }\n        const fields = search.options.fields, weights = search.weights, field_count = fields.length, getAttrFn = search.getAttrFn;\n        if (!field_count) {\n            return function () { return 1; };\n        }\n        /**\n         * Calculates the score of an object\n         * against the search query.\n         *\n         */\n        const scoreObject = (function () {\n            if (field_count === 1) {\n                return function (token, data) {\n                    const field = fields[0].field;\n                    return scoreValue(getAttrFn(data, field), token, weights[field] || 1);\n                };\n            }\n            return function (token, data) {\n                var sum = 0;\n                // is the token specific to a field?\n                if (token.field) {\n                    const value = getAttrFn(data, token.field);\n                    if (!token.regex && value) {\n                        sum += (1 / field_count);\n                    }\n                    else {\n                        sum += scoreValue(value, token, 1);\n                    }\n                }\n                else {\n                    iterate(weights, (weight, field) => {\n                        sum += scoreValue(getAttrFn(data, field), token, weight);\n                    });\n                }\n                return sum / field_count;\n            };\n        })();\n        if (token_count === 1) {\n            return function (data) {\n                return scoreObject(tokens[0], data);\n            };\n        }\n        if (search.options.conjunction === 'and') {\n            return function (data) {\n                var score, sum = 0;\n                for (let token of tokens) {\n                    score = scoreObject(token, data);\n                    if (score <= 0)\n                        return 0;\n                    sum += score;\n                }\n                return sum / token_count;\n            };\n        }\n        else {\n            return function (data) {\n                var sum = 0;\n                iterate(tokens, (token) => {\n                    sum += scoreObject(token, data);\n                });\n                return sum / token_count;\n            };\n        }\n    }\n    ;\n    /**\n     * Returns a function that can be used to compare two\n     * results, for sorting purposes. If no sorting should\n     * be performed, `null` will be returned.\n     *\n     * @return function(a,b)\n     */\n    getSortFunction(query, options) {\n        var search = this.prepareSearch(query, options);\n        return this._getSortFunction(search);\n    }\n    _getSortFunction(search) {\n        var implicit_score, sort_flds = [];\n        const self = this, options = search.options, sort = (!search.query && options.sort_empty) ? options.sort_empty : options.sort;\n        if (typeof sort == 'function') {\n            return sort.bind(this);\n        }\n        /**\n         * Fetches the specified sort field value\n         * from a search result item.\n         *\n         */\n        const get_field = function (name, result) {\n            if (name === '$score')\n                return result.score;\n            return search.getAttrFn(self.items[result.id], name);\n        };\n        // parse options\n        if (sort) {\n            for (let s of sort) {\n                if (search.query || s.field !== '$score') {\n                    sort_flds.push(s);\n                }\n            }\n        }\n        // the \"$score\" field is implied to be the primary\n        // sort field, unless it's manually specified\n        if (search.query) {\n            implicit_score = true;\n            for (let fld of sort_flds) {\n                if (fld.field === '$score') {\n                    implicit_score = false;\n                    break;\n                }\n            }\n            if (implicit_score) {\n                sort_flds.unshift({ field: '$score', direction: 'desc' });\n            }\n            // without a search.query, all items will have the same score\n        }\n        else {\n            sort_flds = sort_flds.filter((fld) => fld.field !== '$score');\n        }\n        // build function\n        const sort_flds_count = sort_flds.length;\n        if (!sort_flds_count) {\n            return null;\n        }\n        return function (a, b) {\n            var result, field;\n            for (let sort_fld of sort_flds) {\n                field = sort_fld.field;\n                let multiplier = sort_fld.direction === 'desc' ? -1 : 1;\n                result = multiplier * cmp(get_field(field, a), get_field(field, b));\n                if (result)\n                    return result;\n            }\n            return 0;\n        };\n    }\n    ;\n    /**\n     * Parses a search query and returns an object\n     * with tokens and fields ready to be populated\n     * with results.\n     *\n     */\n    prepareSearch(query, optsUser) {\n        const weights = {};\n        var options = Object.assign({}, optsUser);\n        propToArray(options, 'sort');\n        propToArray(options, 'sort_empty');\n        // convert fields to new format\n        if (options.fields) {\n            propToArray(options, 'fields');\n            const fields = [];\n            options.fields.forEach((field) => {\n                if (typeof field == 'string') {\n                    field = { field: field, weight: 1 };\n                }\n                fields.push(field);\n                weights[field.field] = ('weight' in field) ? field.weight : 1;\n            });\n            options.fields = fields;\n        }\n        return {\n            options: options,\n            query: query.toLowerCase().trim(),\n            tokens: this.tokenize(query, options.respect_word_boundaries, weights),\n            total: 0,\n            items: [],\n            weights: weights,\n            getAttrFn: (options.nesting) ? getAttrNesting : getAttr,\n        };\n    }\n    ;\n    /**\n     * Searches through all items and returns a sorted array of matches.\n     *\n     */\n    search(query, options) {\n        var self = this, score, search;\n        search = this.prepareSearch(query, options);\n        options = search.options;\n        query = search.query;\n        // generate result scoring function\n        const fn_score = options.score || self._getScoreFunction(search);\n        // perform search and sort\n        if (query.length) {\n            iterate(self.items, (item, id) => {\n                score = fn_score(item);\n                if (options.filter === false || score > 0) {\n                    search.items.push({ 'score': score, 'id': id });\n                }\n            });\n        }\n        else {\n            iterate(self.items, (_, id) => {\n                search.items.push({ 'score': 1, 'id': id });\n            });\n        }\n        const fn_sort = self._getSortFunction(search);\n        if (fn_sort)\n            search.items.sort(fn_sort);\n        // apply limits\n        search.total = search.items.length;\n        if (typeof options.limit === 'number') {\n            search.items = search.items.slice(0, options.limit);\n        }\n        return search;\n    }\n    ;\n}\nexport { Sifter, scoreValue, getAttr, getAttrNesting, propToArray, iterate, cmp, getPattern };\nexport * from \"./types.js\";\n//# sourceMappingURL=sifter.js.map"],"names":["arrayToPattern","chars","maxValueLength","sequencePattern","array","hasDuplicates","pattern","prev_char_count","prev_pattern","char","i","setToPattern","escape_regex","str","longest","value","unicodeLength","allSubstrings","input","result","start","subresult","tmp","code_points","accent_pat","unicode_map","multi_char_reg","max_char_length","latin_convert","latin_condensed","latin","unicode","convert_pat","initialize","_code_points","generateMap","normalize","form","asciifold","_asciifold","generator","code_point_min","code_point_max","composed","folded","generateSets","unicode_sets","addMatching","to_add","folded_set","patt","multi_char","set","a","b","multi_char_patt","mapSequence","strings","min_replacement","chars_replaced","substringsToPattern","sub_pat","sequencesToPattern","sequences","all","sequence","seq","len","j","inSequences","needle_seq","needle_parts","filter","part","needle_part","Sequence","__publicField","position","last_piece","clone","parts","last_part","last_substr","clone_last_len","getPattern","match","match_str","overlapping","added_types","new_seq","old_seq","getAttr","obj","name","getAttrNesting","names","scoreValue","token","weight","score","pos","propToArray","key","iterate","object","callback","cmp","Sifter","items","settings","query","respect_word_boundaries","weights","tokens","words","field_regex","word","field_match","field","regex","options","search","token_count","fields","field_count","getAttrFn","scoreObject","data","sum","implicit_score","sort_flds","self","sort","get_field","s","fld","sort_fld","optsUser","fn_score","item","id","_","fn_sort"],"mappings":"oKAKO,MAAMA,EAAkBC,IAC3BA,EAAQA,EAAM,OAAO,OAAO,EACxBA,EAAM,OAAS,EACRA,EAAM,CAAC,GAAK,GAEfC,EAAeD,CAAK,GAAK,EAAK,IAAMA,EAAM,KAAK,EAAE,EAAI,IAAM,MAAQA,EAAM,KAAK,GAAG,EAAI,KAEpFE,EAAmBC,GAAU,CACtC,GAAI,CAACC,EAAcD,CAAK,EACpB,OAAOA,EAAM,KAAK,EAAE,EAExB,IAAIE,EAAU,GACVC,EAAkB,EACtB,MAAMC,EAAe,IAAM,CACnBD,EAAkB,IAClBD,GAAW,IAAMC,EAAkB,IAE1C,EACD,OAAAH,EAAM,QAAQ,CAACK,EAAMC,IAAM,CACvB,GAAID,IAASL,EAAMM,EAAI,CAAC,EAAG,CACvBH,IACA,MACZ,CACQC,EAAc,EACdF,GAAWG,EACXF,EAAkB,CAC1B,CAAK,EACDC,EAAc,EACPF,CACX,EAMaK,EAAgBV,GAAU,CACnC,IAAIG,EAAQ,MAAM,KAAKH,CAAK,EAC5B,OAAOD,EAAeI,CAAK,CAC/B,EAIaC,EAAiBD,GAClB,IAAI,IAAIA,CAAK,EAAG,OAASA,EAAM,OAK9BQ,EAAgBC,IACjBA,EAAM,IAAI,QAAQ,qCAAsC,MAAM,EAK7DX,EAAkBE,GACpBA,EAAM,OAAO,CAACU,EAASC,IAAU,KAAK,IAAID,EAASE,EAAcD,CAAK,CAAC,EAAG,CAAC,EAEzEC,EAAiBH,GACnB,MAAM,KAAKA,CAAG,EAAE,OC3DdI,EAAiBC,GAAU,CACpC,GAAIA,EAAM,SAAW,EACjB,MAAO,CAAC,CAACA,CAAK,CAAC,EACnB,IAAIC,EAAS,CAAE,EACf,MAAMC,EAAQF,EAAM,UAAU,CAAC,EAE/B,OADaD,EAAcG,CAAK,EAC3B,QAAQ,SAAUC,EAAW,CAC9B,IAAIC,EAAMD,EAAU,MAAM,CAAC,EAC3BC,EAAI,CAAC,EAAIJ,EAAM,OAAO,CAAC,EAAII,EAAI,CAAC,EAChCH,EAAO,KAAKG,CAAG,EACfA,EAAMD,EAAU,MAAM,CAAC,EACvBC,EAAI,QAAQJ,EAAM,OAAO,CAAC,CAAC,EAC3BC,EAAO,KAAKG,CAAG,CACvB,CAAK,EACMH,CACX,ECjBaI,EAAc,CAAC,CAAC,EAAG,KAAK,CAAC,EAChCC,EAAa,WACZ,IAAIC,EACPC,EACJ,MAAMC,EAAkB,EAClBC,EAAgB,CAAE,EAClBC,EAAkB,CACpB,IAAK,KACL,EAAK,IACL,EAAK,MACL,GAAM,IACN,GAAM,MACN,GAAM,IACN,GAAM,IACN,GAAM,KACN,GAAM,IACN,EAAK,MACL,EAAK,OACL,EAAK,WACL,EAAK,OACL,EAAK,KACL,EAAK,SACL,EAAK,OACL,EAAK,KACL,EAAK,KACL,EAAK,SACL,EAAK,WACL,EAAK,MACL,EAAK,UACL,EAAK,UACL,GAAM,IACN,GAAM,IACN,GAAM,IACN,GAAM,IACN,EAAK,SACL,EAAK,MACL,EAAK,QACL,EAAK,QACL,EAAK,QACL,GAAM,IACN,GAAM,IACN,EAAK,IACL,EAAK,MACL,GAAM,IACN,EAAK,IACL,EAAK,MACL,EAAK,QACL,GAAM,GACV,EACA,QAASC,KAASD,EAAiB,CAC/B,IAAIE,EAAUF,EAAgBC,CAAK,GAAK,GACxC,QAASpB,EAAI,EAAGA,EAAIqB,EAAQ,OAAQrB,IAAK,CACrC,IAAID,EAAOsB,EAAQ,UAAUrB,EAAGA,EAAI,CAAC,EACrCkB,EAAcnB,CAAI,EAAIqB,CAC9B,CACA,CACA,MAAME,EAAc,IAAI,OAAO,OAAO,KAAKJ,CAAa,EAAE,KAAK,GAAG,EAAI,IAAMJ,EAAY,IAAI,EAI/ES,EAAcC,GAAiB,CACpCT,IAAgB,SAEpBA,EAAcU,EAA4BZ,CAAW,EACzD,EAKaa,EAAY,CAACvB,EAAKwB,EAAO,SAAWxB,EAAI,UAAUwB,CAAI,EAMtDC,EAAazB,GACf,MAAM,KAAKA,CAAG,EAAE,OAKvB,CAACM,EAAQV,IACEU,EAASoB,EAAW9B,CAAI,EAChC,EAAE,EAEI8B,EAAc1B,IACvBA,EAAMuB,EAAUvB,CAAG,EACd,YAAW,EACX,QAAQmB,EAAoCvB,GACtCmB,EAAcnB,CAAI,GAAK,EACjC,EAEM2B,EAAUvB,EAAK,KAAK,GAKxB,SAAU2B,EAAUjB,EAAa,CACpC,SAAW,CAACkB,EAAgBC,CAAc,IAAKnB,EAC3C,QAASb,EAAI+B,EAAgB/B,GAAKgC,EAAgBhC,IAAK,CACnD,IAAIiC,EAAW,OAAO,aAAajC,CAAC,EAChCkC,EAASN,EAAUK,CAAQ,EAC3BC,GAAUD,EAAS,gBAQnBC,EAAO,OAASjB,GAGhBiB,EAAO,QAAU,IAGrB,KAAM,CAAE,OAAQA,EAAQ,SAAUD,EAAU,WAAYjC,CAAG,GACvE,CAEA,CAIO,MAAMmC,EAAgBtB,GAAgB,CACzC,MAAMuB,EAAe,CAAE,EACjBC,EAAc,CAACH,EAAQI,IAAW,CAEpC,MAAMC,EAAaH,EAAaF,CAAM,GAAK,IAAI,IACzCM,EAAO,IAAI,OAAO,IAAMvC,EAAasC,CAAU,EAAI,IAAK,IAAI,EAC9DD,EAAO,MAAME,CAAI,IAGrBD,EAAW,IAAIrC,EAAaoC,CAAM,CAAC,EACnCF,EAAaF,CAAM,EAAIK,EAC1B,EACD,QAASlC,KAASyB,EAAUjB,CAAW,EACnCwB,EAAYhC,EAAM,OAAQA,EAAM,MAAM,EACtCgC,EAAYhC,EAAM,OAAQA,EAAM,QAAQ,EAE5C,OAAO+B,CACX,EAKaX,EAAeZ,GAAgB,CACxC,MAAMuB,EAAeD,EAAatB,CAAW,EACvCE,EAAc,CAAE,EACtB,IAAI0B,EAAa,CAAE,EACnB,QAASP,KAAUE,EAAc,CAC7B,IAAIM,EAAMN,EAAaF,CAAM,EACzBQ,IACA3B,EAAYmB,CAAM,EAAIjC,EAAayC,CAAG,GAEtCR,EAAO,OAAS,GAChBO,EAAW,KAAKvC,EAAagC,CAAM,CAAC,CAEhD,CACIO,EAAW,KAAK,CAACE,EAAGC,IAAMA,EAAE,OAASD,EAAE,MAAM,EAC7C,MAAME,EAAkBvD,EAAemD,CAAU,EACjD,OAAAzB,EAAiB,IAAI,OAAO,IAAM6B,EAAiB,GAAG,EAC/C9B,CACX,EAIa+B,EAAc,CAACC,EAASC,EAAkB,IAAM,CACzD,IAAIC,EAAiB,EAOrB,OANAF,EAAUA,EAAQ,IAAK5C,IACfY,EAAYZ,CAAG,IACf8C,GAAkB9C,EAAI,QAEnBY,EAAYZ,CAAG,GAAKA,EAC9B,EACG8C,GAAkBD,EACXvD,EAAgBsD,CAAO,EAE3B,EACX,EASaG,EAAsB,CAAC/C,EAAK6C,EAAkB,KACvDA,EAAkB,KAAK,IAAIA,EAAiB7C,EAAI,OAAS,CAAC,EACnDb,EAAeiB,EAAcJ,CAAG,EAAE,IAAKgD,GACnCL,EAAYK,EAASH,CAAe,CAC9C,CAAC,GAMAI,EAAqB,CAACC,EAAWC,EAAM,KAAS,CAClD,IAAIN,EAAkBK,EAAU,OAAS,EAAI,EAAI,EACjD,OAAO/D,EAAe+D,EAAU,IAAKE,GAAa,CAC9C,IAAIC,EAAM,CAAE,EACZ,MAAMC,EAAMH,EAAMC,EAAS,OAAM,EAAKA,EAAS,OAAM,EAAK,EAC1D,QAASG,EAAI,EAAGA,EAAID,EAAKC,IACrBF,EAAI,KAAKN,EAAoBK,EAAS,QAAQG,CAAC,GAAK,GAAIV,CAAe,CAAC,EAE5E,OAAOvD,EAAgB+D,CAAG,CAClC,CAAK,CAAC,CACN,EAIMG,EAAc,CAACC,EAAYP,IAAc,CAC3C,UAAWG,KAAOH,EAAW,CAIzB,GAHIG,EAAI,OAASI,EAAW,OAASJ,EAAI,KAAOI,EAAW,KAGvDJ,EAAI,QAAQ,KAAK,EAAE,IAAMI,EAAW,QAAQ,KAAK,EAAE,EACnD,SAEJ,IAAIC,EAAeD,EAAW,MAC9B,MAAME,EAAUC,GAAS,CACrB,UAAWC,KAAeH,EAAc,CACpC,GAAIG,EAAY,QAAUD,EAAK,OAASC,EAAY,SAAWD,EAAK,OAChE,MAAO,GAEX,GAAI,EAAAA,EAAK,QAAU,GAAKC,EAAY,QAAU,KAQ1CD,EAAK,MAAQC,EAAY,OAASD,EAAK,IAAMC,EAAY,OAGzDA,EAAY,MAAQD,EAAK,OAASC,EAAY,IAAMD,EAAK,OACzD,MAAO,EAE3B,CACY,MAAO,EACV,EAED,GAAI,EADWP,EAAI,MAAM,OAAOM,CAAM,EACzB,OAAS,GAGtB,MAAO,EACf,CACI,MAAO,EACX,EACA,MAAMG,CAAS,CAKX,aAAc,CAJdC,EAAA,cACAA,EAAA,gBACAA,EAAA,cACAA,EAAA,YAEI,KAAK,MAAQ,CAAE,EACf,KAAK,QAAU,CAAE,EACjB,KAAK,MAAQ,EACb,KAAK,IAAM,CACnB,CACI,IAAIH,EAAM,CACFA,IACA,KAAK,MAAM,KAAKA,CAAI,EACpB,KAAK,QAAQ,KAAKA,EAAK,MAAM,EAC7B,KAAK,MAAQ,KAAK,IAAIA,EAAK,MAAO,KAAK,KAAK,EAC5C,KAAK,IAAM,KAAK,IAAIA,EAAK,IAAK,KAAK,GAAG,EAElD,CACI,MAAO,CACH,OAAO,KAAK,MAAM,KAAK,MAAM,OAAS,CAAC,CAC/C,CACI,QAAS,CACL,OAAO,KAAK,MAAM,MAC1B,CACI,MAAMI,EAAUC,EAAY,CACxB,IAAIC,EAAQ,IAAIJ,EACZK,EAAQ,KAAK,MAAM,KAAK,UAAU,KAAK,KAAK,CAAC,EAC7CC,EAAYD,EAAM,IAAK,EAC3B,UAAWP,KAAQO,EACfD,EAAM,IAAIN,CAAI,EAElB,IAAIS,EAAcJ,EAAW,OAAO,UAAU,EAAGD,EAAWI,EAAU,KAAK,EACvEE,EAAiBD,EAAY,OACjC,OAAAH,EAAM,IAAI,CAAE,MAAOE,EAAU,MAAO,IAAKA,EAAU,MAAQE,EAAgB,OAAQA,EAAgB,OAAQD,CAAW,CAAE,EACjHH,CACf,CACA,CAaO,MAAMK,EAAcvE,GAAQ,CAC/BoB,EAAY,EACZpB,EAAMyB,EAAUzB,CAAG,EACnB,IAAIP,EAAU,GACVyD,EAAY,CAAC,IAAIY,CAAU,EAC/B,QAASjE,EAAI,EAAGA,EAAIG,EAAI,OAAQH,IAAK,CAEjC,IAAI2E,EADSxE,EAAI,UAAUH,CAAC,EACT,MAAMgB,CAAc,EACvC,MAAMjB,EAAOI,EAAI,UAAUH,EAAGA,EAAI,CAAC,EAC7B4E,EAAYD,EAAQA,EAAM,CAAC,EAAI,KAGrC,IAAIE,EAAc,CAAE,EAChBC,EAAc,IAAI,IACtB,UAAWvB,KAAYF,EAAW,CAC9B,MAAMe,EAAab,EAAS,KAAM,EAClC,GAAI,CAACa,GAAcA,EAAW,QAAU,GAAKA,EAAW,KAAOpE,EAE3D,GAAI4E,EAAW,CACX,MAAMnB,EAAMmB,EAAU,OACtBrB,EAAS,IAAI,CAAE,MAAOvD,EAAG,IAAKA,EAAIyD,EAAK,OAAQA,EAAK,OAAQmB,CAAS,CAAE,EACvEE,EAAY,IAAI,GAAG,CACvC,MAEoBvB,EAAS,IAAI,CAAE,MAAOvD,EAAG,IAAKA,EAAI,EAAG,OAAQ,EAAG,OAAQD,CAAI,CAAE,EAC9D+E,EAAY,IAAI,GAAG,UAGlBF,EAAW,CAChB,IAAIP,EAAQd,EAAS,MAAMvD,EAAGoE,CAAU,EACxC,MAAMX,EAAMmB,EAAU,OACtBP,EAAM,IAAI,CAAE,MAAOrE,EAAG,IAAKA,EAAIyD,EAAK,OAAQA,EAAK,OAAQmB,CAAS,CAAE,EACpEC,EAAY,KAAKR,CAAK,CACtC,MAIgBS,EAAY,IAAI,GAAG,CAEnC,CAEQ,GAAID,EAAY,OAAS,EAAG,CAExBA,EAAcA,EAAY,KAAK,CAAClC,EAAGC,IACxBD,EAAE,SAAWC,EAAE,OAAQ,CACjC,EACD,QAASyB,KAASQ,EAEVlB,EAAYU,EAAOhB,CAAS,GAGhCA,EAAU,KAAKgB,CAAK,EAExB,QACZ,CAKQ,GAAIrE,EAAI,GAAK8E,EAAY,MAAQ,GAAK,CAACA,EAAY,IAAI,GAAG,EAAG,CACzDlF,GAAWwD,EAAmBC,EAAW,EAAK,EAC9C,IAAI0B,EAAU,IAAId,EAClB,MAAMe,EAAU3B,EAAU,CAAC,EACvB2B,GACAD,EAAQ,IAAIC,EAAQ,MAAM,EAE9B3B,EAAY,CAAC0B,CAAO,CAChC,CACA,CACI,OAAAnF,GAAWwD,EAAmBC,EAAW,EAAI,EACtCzD,CACX,EC9WaqF,EAAU,CAACC,EAAKC,IAAS,CAClC,GAAKD,EAEL,OAAOA,EAAIC,CAAI,CACnB,EAOaC,EAAiB,CAACF,EAAKC,IAAS,CACzC,GAAKD,EAGL,SADInB,EAAMsB,EAAQF,EAAK,MAAM,GAAG,GACxBpB,EAAOsB,EAAM,MAAO,KAAMH,EAAMA,EAAInB,CAAI,IAC5C,CACJ,OAAOmB,EACX,EAMaI,EAAa,CAACjF,EAAOkF,EAAOC,IAAW,CAChD,IAAIC,EAAOC,EAOX,MANI,CAACrF,IAELA,EAAQA,EAAQ,GACZkF,EAAM,OAAS,QAEnBG,EAAMrF,EAAM,OAAOkF,EAAM,KAAK,EAC1BG,IAAQ,IACD,GACXD,EAAQF,EAAM,OAAO,OAASlF,EAAM,OAChCqF,IAAQ,IACRD,GAAS,IACNA,EAAQD,EACnB,EAKaG,EAAc,CAACT,EAAKU,IAAQ,CACrC,IAAIvF,EAAQ6E,EAAIU,CAAG,EACnB,GAAI,OAAOvF,GAAS,WAChB,OAAOA,EACPA,GAAS,CAAC,MAAM,QAAQA,CAAK,IAC7B6E,EAAIU,CAAG,EAAI,CAACvF,CAAK,EAEzB,EAWawF,EAAU,CAACC,EAAQC,IAAa,CACzC,GAAI,MAAM,QAAQD,CAAM,EACpBA,EAAO,QAAQC,CAAQ,MAGvB,SAASH,KAAOE,EACRA,EAAO,eAAeF,CAAG,GACzBG,EAASD,EAAOF,CAAG,EAAGA,CAAG,CAIzC,EACaI,EAAM,CAACrD,EAAGC,IACf,OAAOD,GAAM,UAAY,OAAOC,GAAM,SAC/BD,EAAIC,EAAI,EAAKD,EAAIC,EAAI,GAAK,GAErCD,EAAIf,EAAUe,EAAI,EAAE,EAAE,YAAa,EACnCC,EAAIhB,EAAUgB,EAAI,EAAE,EAAE,YAAa,EAC/BD,EAAIC,EACG,EACPA,EAAID,EACG,GACJ,GCzEX,MAAMsD,EAAO,CAST,YAAYC,EAAOC,EAAU,CAR7BjC,EAAA,cACAA,EAAA,iBAQI,KAAK,MAAQgC,EACb,KAAK,SAAWC,GAAY,CAAE,WAAY,EAAM,CACxD,CAOI,SAASC,EAAOC,EAAyBC,EAAS,CAC9C,GAAI,CAACF,GAAS,CAACA,EAAM,OACjB,MAAO,CAAE,EACb,MAAMG,EAAS,CAAE,EACXC,EAAQJ,EAAM,MAAM,KAAK,EAC/B,IAAIK,EACJ,OAAIH,IACAG,EAAc,IAAI,OAAO,KAAO,OAAO,KAAKH,CAAO,EAAE,IAAIpG,CAAY,EAAE,KAAK,GAAG,EAAI,SAAU,GAEjGsG,EAAM,QAASE,GAAS,CACpB,IAAIC,EACAC,EAAQ,KACRC,EAAQ,KAERJ,IAAgBE,EAAcD,EAAK,MAAMD,CAAW,KACpDG,EAAQD,EAAY,CAAC,EACrBD,EAAOC,EAAY,CAAC,GAEpBD,EAAK,OAAS,IACV,KAAK,SAAS,WACdG,EAAQnC,EAAWgC,CAAI,GAAK,KAG5BG,EAAQ3G,EAAawG,CAAI,EAEzBG,GAASR,IACTQ,EAAQ,MAAQA,IAExBN,EAAO,KAAK,CACR,OAAQG,EACR,MAAOG,EAAQ,IAAI,OAAOA,EAAO,IAAI,EAAI,KACzC,MAAOD,CACvB,CAAa,CACb,CAAS,EACML,CACf,CAUI,iBAAiBH,EAAOU,EAAS,CAC7B,IAAIC,EAAS,KAAK,cAAcX,EAAOU,CAAO,EAC9C,OAAO,KAAK,kBAAkBC,CAAM,CAC5C,CAKI,kBAAkBA,EAAQ,CACtB,MAAMR,EAASQ,EAAO,OAAQC,EAAcT,EAAO,OACnD,GAAI,CAACS,EACD,OAAO,UAAY,CAAE,MAAO,EAAI,EAEpC,MAAMC,EAASF,EAAO,QAAQ,OAAQT,EAAUS,EAAO,QAASG,EAAcD,EAAO,OAAQE,EAAYJ,EAAO,UAChH,GAAI,CAACG,EACD,OAAO,UAAY,CAAE,MAAO,EAAI,EAOpC,MAAME,EAAe,UAAY,CAC7B,OAAIF,IAAgB,EACT,SAAU3B,EAAO8B,EAAM,CAC1B,MAAMT,EAAQK,EAAO,CAAC,EAAE,MACxB,OAAO3B,EAAW6B,EAAUE,EAAMT,CAAK,EAAGrB,EAAOe,EAAQM,CAAK,GAAK,CAAC,CACvE,EAEE,SAAUrB,EAAO8B,EAAM,CAC1B,IAAIC,EAAM,EAEV,GAAI/B,EAAM,MAAO,CACb,MAAMlF,EAAQ8G,EAAUE,EAAM9B,EAAM,KAAK,EACrC,CAACA,EAAM,OAASlF,EAChBiH,GAAQ,EAAIJ,EAGZI,GAAOhC,EAAWjF,EAAOkF,EAAO,CAAC,CAEzD,MAEoBM,EAAQS,EAAS,CAACd,EAAQoB,IAAU,CAChCU,GAAOhC,EAAW6B,EAAUE,EAAMT,CAAK,EAAGrB,EAAOC,CAAM,CAC/E,CAAqB,EAEL,OAAO8B,EAAMJ,CAChB,CACb,EAAY,EACJ,OAAIF,IAAgB,EACT,SAAUK,EAAM,CACnB,OAAOD,EAAYb,EAAO,CAAC,EAAGc,CAAI,CACrC,EAEDN,EAAO,QAAQ,cAAgB,MACxB,SAAUM,EAAM,CACnB,IAAI5B,EAAO6B,EAAM,EACjB,QAAS/B,KAASgB,EAAQ,CAEtB,GADAd,EAAQ2B,EAAY7B,EAAO8B,CAAI,EAC3B5B,GAAS,EACT,MAAO,GACX6B,GAAO7B,CAC3B,CACgB,OAAO6B,EAAMN,CAChB,EAGM,SAAUK,EAAM,CACnB,IAAIC,EAAM,EACV,OAAAzB,EAAQU,EAAShB,GAAU,CACvB+B,GAAOF,EAAY7B,EAAO8B,CAAI,CAClD,CAAiB,EACMC,EAAMN,CAChB,CAEb,CASI,gBAAgBZ,EAAOU,EAAS,CAC5B,IAAIC,EAAS,KAAK,cAAcX,EAAOU,CAAO,EAC9C,OAAO,KAAK,iBAAiBC,CAAM,CAC3C,CACI,iBAAiBA,EAAQ,CACrB,IAAIQ,EAAgBC,EAAY,CAAE,EAClC,MAAMC,EAAO,KAAMX,EAAUC,EAAO,QAASW,EAAQ,CAACX,EAAO,OAASD,EAAQ,WAAcA,EAAQ,WAAaA,EAAQ,KACzH,GAAI,OAAOY,GAAQ,WACf,OAAOA,EAAK,KAAK,IAAI,EAOzB,MAAMC,EAAY,SAAUxC,EAAM1E,EAAQ,CACtC,OAAI0E,IAAS,SACF1E,EAAO,MACXsG,EAAO,UAAUU,EAAK,MAAMhH,EAAO,EAAE,EAAG0E,CAAI,CACtD,EAED,GAAIuC,EACA,QAASE,KAAKF,GACNX,EAAO,OAASa,EAAE,QAAU,WAC5BJ,EAAU,KAAKI,CAAC,EAM5B,GAAIb,EAAO,MAAO,CACdQ,EAAiB,GACjB,QAASM,KAAOL,EACZ,GAAIK,EAAI,QAAU,SAAU,CACxBN,EAAiB,GACjB,KACpB,CAEgBA,GACAC,EAAU,QAAQ,CAAE,MAAO,SAAU,UAAW,OAAQ,CAGxE,MAEYA,EAAYA,EAAU,OAAQK,GAAQA,EAAI,QAAU,QAAQ,EAIhE,OADwBL,EAAU,OAI3B,SAAU7E,EAAGC,EAAG,CACnB,IAAInC,EAAQmG,EACZ,QAASkB,KAAYN,EAIjB,GAHAZ,EAAQkB,EAAS,MAEjBrH,GADiBqH,EAAS,YAAc,OAAS,GAAK,GAChC9B,EAAI2B,EAAUf,EAAOjE,CAAC,EAAGgF,EAAUf,EAAOhE,CAAC,CAAC,EAC9DnC,EACA,OAAOA,EAEf,MAAO,EACV,EAZU,IAanB,CAQI,cAAc2F,EAAO2B,EAAU,CAC3B,MAAMzB,EAAU,CAAE,EAClB,IAAIQ,EAAU,OAAO,OAAO,CAAA,EAAIiB,CAAQ,EAIxC,GAHApC,EAAYmB,EAAS,MAAM,EAC3BnB,EAAYmB,EAAS,YAAY,EAE7BA,EAAQ,OAAQ,CAChBnB,EAAYmB,EAAS,QAAQ,EAC7B,MAAMG,EAAS,CAAE,EACjBH,EAAQ,OAAO,QAASF,GAAU,CAC1B,OAAOA,GAAS,WAChBA,EAAQ,CAAE,MAAOA,EAAO,OAAQ,CAAG,GAEvCK,EAAO,KAAKL,CAAK,EACjBN,EAAQM,EAAM,KAAK,EAAK,WAAYA,EAASA,EAAM,OAAS,CAC5E,CAAa,EACDE,EAAQ,OAASG,CAC7B,CACQ,MAAO,CACH,QAASH,EACT,MAAOV,EAAM,YAAa,EAAC,KAAM,EACjC,OAAQ,KAAK,SAASA,EAAOU,EAAQ,wBAAyBR,CAAO,EACrE,MAAO,EACP,MAAO,CAAE,EACT,QAASA,EACT,UAAYQ,EAAQ,QAAW1B,EAAiBH,CACnD,CACT,CAMI,OAAOmB,EAAOU,EAAS,CACnB,IAAIW,EAAO,KAAMhC,EAAOsB,EACxBA,EAAS,KAAK,cAAcX,EAAOU,CAAO,EAC1CA,EAAUC,EAAO,QACjBX,EAAQW,EAAO,MAEf,MAAMiB,EAAWlB,EAAQ,OAASW,EAAK,kBAAkBV,CAAM,EAE3DX,EAAM,OACNP,EAAQ4B,EAAK,MAAO,CAACQ,EAAMC,IAAO,CAC9BzC,EAAQuC,EAASC,CAAI,GACjBnB,EAAQ,SAAW,IAASrB,EAAQ,IACpCsB,EAAO,MAAM,KAAK,CAAE,MAAStB,EAAO,GAAMyC,EAAI,CAElE,CAAa,EAGDrC,EAAQ4B,EAAK,MAAO,CAACU,EAAGD,IAAO,CAC3BnB,EAAO,MAAM,KAAK,CAAE,MAAS,EAAG,GAAMmB,EAAI,CAC1D,CAAa,EAEL,MAAME,EAAUX,EAAK,iBAAiBV,CAAM,EAC5C,OAAIqB,GACArB,EAAO,MAAM,KAAKqB,CAAO,EAE7BrB,EAAO,MAAQA,EAAO,MAAM,OACxB,OAAOD,EAAQ,OAAU,WACzBC,EAAO,MAAQA,EAAO,MAAM,MAAM,EAAGD,EAAQ,KAAK,GAE/CC,CACf,CAEA","x_google_ignoreList":[0,1,2,3,4]}