{"version":3,"file":"smart-array-filter.min.js","sources":["../node_modules/lodash.escaperegexp/index.js","../lib-esm/match/recursiveMatch.js","../lib-esm/match/nativeMatch.js","../lib-esm/match/match.js","../lib-esm/utils/charSplit.js","../lib-esm/utils/getCheckNumber.js","../lib-esm/utils/getCheckString.js","../lib-esm/utils/convertKeywordToCriterion.js","../lib-esm/index.js","../lib-esm/utils/ensureObjectOfRegExps.js"],"sourcesContent":["/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/6.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g,\n    reHasRegExpChar = RegExp(reRegExpChar.source);\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n  // Exit early for strings to avoid a performance hit in some environments.\n  if (typeof value == 'string') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return symbolToString ? symbolToString.call(value) : '';\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n  return value == null ? '' : baseToString(value);\n}\n\n/**\n * Escapes the `RegExp` special characters \"^\", \"$\", \"\\\", \".\", \"*\", \"+\",\n * \"?\", \"(\", \")\", \"[\", \"]\", \"{\", \"}\", and \"|\" in `string`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to escape.\n * @returns {string} Returns the escaped string.\n * @example\n *\n * _.escapeRegExp('[lodash](https://lodash.com/)');\n * // => '\\[lodash\\]\\(https://lodash\\.com/\\)'\n */\nfunction escapeRegExp(string) {\n  string = toString(string);\n  return (string && reHasRegExpChar.test(string))\n    ? string.replace(reRegExpChar, '\\\\$&')\n    : string;\n}\n\nmodule.exports = escapeRegExp;\n","import nativeMatch from './nativeMatch';\n/**\n * RecursiveMatch.\n *\n * @param element - String | number | Record<string, string>.\n * @param criterion - Criterion.\n * @param keys - String[].\n * @param options - Object.\n * @param options.ignorePaths - RegExp[].\n * @returns Boolean.\n */\nexport default function recursiveMatch(element, criterion, keys, options) {\n    if (typeof element === 'object') {\n        if (Array.isArray(element)) {\n            for (const elm of element) {\n                if (recursiveMatch(elm, criterion, keys, options)) {\n                    return true;\n                }\n            }\n        }\n        else {\n            for (const i in element) {\n                keys.push(i);\n                const didMatch = recursiveMatch(element[i], criterion, keys, options);\n                keys.pop();\n                if (didMatch)\n                    return true;\n            }\n        }\n    }\n    else if (criterion.type === 'exists') {\n        // we check for the presence of a key (jpath)\n        if (criterion.key.test(keys.join('.'))) {\n            return !!element;\n        }\n        else {\n            return false;\n        }\n    }\n    else {\n        // need to check if keys match\n        const joinedKeys = keys.join('.');\n        for (const ignorePath of options.ignorePaths) {\n            if (ignorePath.test(joinedKeys))\n                return false;\n        }\n        if (options.includePaths) {\n            let included = false;\n            for (const includePath of options.includePaths) {\n                if (includePath.test(joinedKeys)) {\n                    included = true;\n                    break;\n                }\n            }\n            if (!included)\n                return false;\n        }\n        if (criterion.key) {\n            if (!criterion.key.test(joinedKeys))\n                return false;\n        }\n        return nativeMatch(element, criterion);\n    }\n    return false;\n}\n//# sourceMappingURL=recursiveMatch.js.map","/**\n * NativeMatch.\n *\n * @param element - String|number.\n * @param keyword - Criterion.\n * @returns Boolean.\n */\nexport default function nativeMatch(element, keyword) {\n    if (typeof element === 'string') {\n        return keyword.checkString(element);\n    }\n    else if (typeof element === 'number') {\n        return keyword.checkNumber(element);\n    }\n    else {\n        return false;\n    }\n}\n//# sourceMappingURL=nativeMatch.js.map","import recursiveMatch from './recursiveMatch';\n/**\n * Match.\n *\n * @param element - String | number | Record<string, string>.\n * @param criteria - Criterion[].\n * @param predicate - String.\n * @param options - Object.\n * @param options.ignorePaths - RegExp[].\n * @param options.pathAlias - Record<string, string|RegExp>s.\n * @returns Boolean.\n */\nexport default function match(element, criteria, predicate, options) {\n    if (criteria.length) {\n        let found = false;\n        for (const criterion of criteria) {\n            // match XOR negate\n            if (recursiveMatch(element, criterion, [], options)\n                ? !criterion.negate\n                : criterion.negate) {\n                if (predicate === 'OR') {\n                    return true;\n                }\n                found = true;\n            }\n            else if (predicate === 'AND') {\n                return false;\n            }\n        }\n        return found;\n    }\n    return true;\n}\n//# sourceMappingURL=match.js.map","/**\n * We split a string into an array of strings except if it in single or double quotes.\n * @param string\n * @param char\n * @returns\n */\nexport default function charSplit(string, delimiter) {\n    const results = [];\n    let inQuotes = false;\n    let start = 0;\n    let quote = '';\n    for (let i = 0; i < string.length; i++) {\n        const char = string[i];\n        if (inQuotes) {\n            if (char === quote) {\n                inQuotes = false;\n                quote = '';\n            }\n        }\n        else if (char === '\"' || char === \"'\") {\n            inQuotes = true;\n            quote = char;\n        }\n        else if (char.match(delimiter) && !inQuotes) {\n            results.push(string.slice(start, i).trim());\n            start = i + 1;\n        }\n        if (i === string.length - 1) {\n            results.push(string.slice(start).trim());\n        }\n    }\n    return results\n        .map((result) => {\n        if (result.startsWith('\"') && result.endsWith('\"')) {\n            return result.slice(1, -1);\n        }\n        if (result.startsWith(\"'\") && result.endsWith(\"'\")) {\n            return result.slice(1, -1);\n        }\n        return result;\n    })\n        .filter((result) => result);\n}\n//# sourceMappingURL=charSplit.js.map","const operators = {\n    '<': function lt(values) {\n        const value = Number(values[0]);\n        return (number) => {\n            return number < value;\n        };\n    },\n    '<=': function lte(values) {\n        const value = Number(values[0]);\n        return (number) => {\n            return number <= value;\n        };\n    },\n    '=': function equal(values) {\n        const possibleNumbers = values[0]\n            .split(',')\n            .filter((item) => item)\n            .map(Number);\n        return (number) => {\n            for (let i = 0; i < possibleNumbers.length; i++) {\n                if (number === possibleNumbers[i]) {\n                    return true;\n                }\n            }\n            return false;\n        };\n    },\n    '>=': function gte(values) {\n        const value = Number(values[0]);\n        return (number) => {\n            return number >= value;\n        };\n    },\n    '>': function gt(values) {\n        const value = Number(values[0]);\n        return (number) => {\n            return number > value;\n        };\n    },\n    '..': function range(values) {\n        const valueLow = Number(values[0]);\n        const valueHigh = Number(values[1]);\n        return (number) => number >= valueLow && number <= valueHigh;\n    },\n};\n/**\n * @internal\n */\nexport default function getCheckNumber(keyword) {\n    const { values, operator } = splitNumberOperator(keyword);\n    const checkOperator = operators[operator];\n    if (!checkOperator) {\n        throw new Error(`unknown operator ${operator}`);\n    }\n    return checkOperator(values);\n}\n/**\n * @internal\n */\nexport function splitNumberOperator(keyword) {\n    const match = /^\\s*\\(?\\s*(?<startOperator><=|>=|<|=|>|\\.\\.\\s*)?\\s*(?<firstValue>-?\\d*\\.?\\d+)\\s*(?:(?<afterDots>\\.\\.)\\s*(?<secondValue>-?\\d*\\.?\\d*))?\\s*\\)?\\s*$/.exec(keyword);\n    if (!match) {\n        return {\n            operator: '=',\n            values: [keyword],\n        };\n    }\n    if (!match.groups) {\n        throw new Error('unreachable');\n    }\n    const { startOperator, firstValue, afterDots, secondValue } = match.groups;\n    let operator = startOperator;\n    let values = firstValue ? [firstValue] : [];\n    // ..12\n    if (startOperator === '..') {\n        operator = '<=';\n    }\n    // 12..\n    else if (!startOperator && afterDots && !secondValue) {\n        operator = '>=';\n    }\n    // 12..14\n    else if (afterDots) {\n        operator = '..';\n    }\n    if (secondValue) {\n        values.push(secondValue);\n    }\n    return {\n        values,\n        operator: operator || '=',\n    };\n}\n//# sourceMappingURL=getCheckNumber.js.map","import escapeRegExp from 'lodash.escaperegexp';\nimport charSplit from './charSplit';\nconst operators = {\n    '<': function lt(query) {\n        return (string) => {\n            return string < query[0];\n        };\n    },\n    '<=': function lte(query) {\n        return (string) => {\n            return string <= query[0];\n        };\n    },\n    '=': function equal(query, insensitive) {\n        const possibilities = charSplit(query[0], ',')\n            .filter((item) => item)\n            .map((string) => new RegExp(`^${escapeRegExp(string)}$`, insensitive));\n        return (string) => {\n            for (const possibility of possibilities) {\n                if (possibility.test(string)) {\n                    return true;\n                }\n            }\n            return false;\n        };\n    },\n    '~': function fuzzy(query, insensitive) {\n        const possibilities = charSplit(query[0], ',')\n            .filter((item) => item)\n            .map((string) => new RegExp(escapeRegExp(string), insensitive));\n        return (string) => {\n            for (const possibility of possibilities) {\n                if (possibility.test(string)) {\n                    return true;\n                }\n            }\n            return false;\n        };\n    },\n    '>=': function lge(query) {\n        return (string) => {\n            return string >= query[0];\n        };\n    },\n    '>': function lg(query) {\n        return (string) => {\n            return string > query[0];\n        };\n    },\n    '..': function range(query) {\n        return (string) => {\n            return string >= query[0] && string <= query[1];\n        };\n    },\n};\n/**\n * GetCheckString.\n *\n * @param keyword - String.\n * @param insensitive - String.\n * @returns CheckString. (string)=>boolean.\n */\nexport default function getCheckString(keyword, insensitive) {\n    const { values, operator } = splitStringOperator(keyword);\n    const operatorCheck = operators[operator];\n    if (!operatorCheck) {\n        throw new Error(`unreachable unknown operator ${operator}`);\n    }\n    return operatorCheck(values, insensitive);\n}\n/**\n * @internal\n */\nexport function splitStringOperator(keyword) {\n    const parts = keyword.split('..');\n    const match = /^\\s*\\(?(?<operator><=|<|=|>=|>)?\\s*(?<value>\\S*)\\s*\\)?$/.exec(parts[0]);\n    if (!match) {\n        // Should never happen\n        return {\n            operator: '~',\n            values: [keyword],\n        };\n    }\n    if (!match.groups) {\n        throw new Error('unreachable');\n    }\n    let { operator, value } = match.groups;\n    let secondQuery = parts[1]?.trim();\n    let values = [value];\n    if (parts.length > 1) {\n        operator = '..';\n        if (!secondQuery) {\n            operator = '>=';\n        }\n        else if (!value) {\n            values = [secondQuery];\n            operator = '<=';\n        }\n        else {\n            values.push(secondQuery);\n        }\n    }\n    return {\n        operator: operator || '~',\n        values,\n    };\n}\n//# sourceMappingURL=getCheckString.js.map","import escapeRegExp from 'lodash.escaperegexp';\nimport getCheckNumber from './getCheckNumber';\nimport getCheckString from './getCheckString';\n/**\n * @internal\n */\nexport function convertKeywordToCriterion(keyword, options = {\n    pathAlias: {},\n}) {\n    const { caseSensitive, pathAlias } = options;\n    const regexpFlags = caseSensitive ? '' : 'i';\n    let negate = false;\n    if (keyword.startsWith('-')) {\n        negate = true;\n        keyword = keyword.substring(1);\n    }\n    const colon = keyword.indexOf(':');\n    if (colon > -1) {\n        const value = keyword.substring(colon + 1);\n        if (colon > 0) {\n            const key = keyword.substring(0, colon);\n            if (key === 'is') {\n                // a property path exists\n                return {\n                    type: 'exists',\n                    negate,\n                    key: new RegExp(`(^|\\\\.)${escapeRegExp(value)}(\\\\.|$)`, regexpFlags),\n                };\n            }\n            else {\n                return {\n                    type: 'matches',\n                    negate,\n                    key: pathAlias[key]\n                        ? pathAlias[key]\n                        : new RegExp(`(^|\\\\.)${escapeRegExp(key)}(\\\\.|$)`, regexpFlags),\n                    checkNumber: getCheckNumber(value),\n                    checkString: getCheckString(value, regexpFlags),\n                };\n            }\n        }\n    }\n    return {\n        type: 'matches',\n        negate,\n        checkNumber: getCheckNumber(keyword),\n        checkString: getCheckString(keyword, regexpFlags),\n    };\n}\nexport function convertKeywordsToCriteria(keywords, options = {\n    pathAlias: {},\n}) {\n    return keywords.map((keyword) => {\n        return convertKeywordToCriterion(keyword, options);\n    });\n}\n//# sourceMappingURL=convertKeywordToCriterion.js.map","import escapeRegExp from 'lodash.escaperegexp';\nimport match from './match/match';\nimport charSplit from './utils/charSplit';\nimport { convertKeywordsToCriteria } from './utils/convertKeywordToCriterion';\nimport ensureObjectOfRegExps from './utils/ensureObjectOfRegExps';\n/**\n *\n * Filter.\n *\n * @param data - Array to filter.\n * @param [options={}] - Object.\n * @param [options.limit=Infinity] - Maximum number of results.\n * @param [options.caseSensitive=false] - By default we ignore case.\n * @param [options.ignorePaths=[]] - Array of jpath to ignore.\n * @param [options.includePaths] - Array of jpath to allow, default everything.\n * @param [options.pathAlias={}] - Key (string), value (string of regexp).\n * @param [options.keywords=[]] - List of keywords used to filter the array.\n * @param [options.index=false] - Returns the indices in the array that match.\n * @param [options.predicate='AND'] - Could be either AND or OR.\n * @returns String[] | number[].\n */\nexport function filter(data, options = {}) {\n    let { index = false, predicate = 'AND', ignorePaths: ignorePathsOption = [], includePaths: includePathsOption, pathAlias: pathAliasOption = {}, } = options;\n    const limit = options.limit ? options.limit : Infinity;\n    const insensitive = options.caseSensitive ? '' : 'i';\n    let keywords = options.keywords || [];\n    const pathAlias = ensureObjectOfRegExps(pathAliasOption, { insensitive });\n    const ignorePaths = ignorePathsOption.map((path) => typeof path === 'string'\n        ? new RegExp(`(^|\\\\.)${escapeRegExp(path)}(\\\\.|$)`, insensitive)\n        : path);\n    const includePaths = includePathsOption\n        ? includePathsOption.map((path) => typeof path === 'string'\n            ? new RegExp(`(^|\\\\.)${escapeRegExp(path)}(\\\\.|$)`, insensitive)\n            : path)\n        : undefined;\n    if (typeof keywords === 'string') {\n        keywords = charSplit(keywords, /[ \\t\\r\\n]/);\n    }\n    const criteria = convertKeywordsToCriteria(keywords, {\n        caseSensitive: options.caseSensitive,\n        pathAlias,\n    });\n    let matched = 0;\n    if (index) {\n        const result = [];\n        for (let i = 0; i < data.length && matched < limit; i++) {\n            if (match(data[i], criteria, predicate, {\n                ignorePaths,\n                includePaths,\n                pathAlias,\n            })) {\n                matched = result.push(i);\n            }\n        }\n        return result;\n    }\n    else {\n        const result = [];\n        for (let i = 0; i < data.length && matched < limit; i++) {\n            if (match(data[i], criteria, predicate, {\n                ignorePaths,\n                includePaths,\n                pathAlias,\n            })) {\n                matched = result.push(data[i]);\n            }\n        }\n        return result;\n    }\n}\n//# sourceMappingURL=index.js.map","import escapeRegExp from 'lodash.escaperegexp';\n/**\n * EnsureObjectOfRegExps.\n *\n * @param object  - { [index: string]: string|RegExp }.\n * @param options - Object.\n * @param options.insensitive - String.\n * @returns - Record<string, string|RegExp>.\n */\nexport default function ensureObjectOfRegExps(object, options) {\n    const { insensitive } = options;\n    const toReturn = {};\n    for (const [key, value] of Object.entries(object)) {\n        if (value instanceof RegExp) {\n            toReturn[key] = value;\n        }\n        else {\n            toReturn[key] = new RegExp(`(^|\\\\.)${escapeRegExp(value)}(\\\\.|$)`, insensitive);\n        }\n    }\n    return toReturn;\n}\n//# sourceMappingURL=ensureObjectOfRegExps.js.map"],"names":["INFINITY","symbolTag","reRegExpChar","reHasRegExpChar","RegExp","source","freeGlobal","global","Object","freeSelf","self","root","Function","objectToString","prototype","toString","Symbol","symbolProto","undefined","symbolToString","baseToString","value","isObjectLike","call","isSymbol","result","string","test","replace","recursiveMatch","element","criterion","keys","options","type","key","join","joinedKeys","ignorePath","ignorePaths","includePaths","included","includePath","keyword","checkString","checkNumber","nativeMatch","Array","isArray","elm","i","push","didMatch","pop","match","criteria","predicate","length","found","negate","charSplit","delimiter","results","inQuotes","start","quote","char","slice","trim","map","startsWith","endsWith","filter","operators","values","Number","number","possibleNumbers","split","item","valueLow","valueHigh","getCheckNumber","operator","exec","groups","Error","startOperator","firstValue","afterDots","secondValue","splitNumberOperator","checkOperator","query","insensitive","possibilities","escapeRegExp","possibility","getCheckString","parts","secondQuery","splitStringOperator","operatorCheck","convertKeywordsToCriteria","keywords","arguments","pathAlias","caseSensitive","regexpFlags","substring","colon","indexOf","convertKeywordToCriterion","data","index","ignorePathsOption","includePathsOption","pathAliasOption","limit","Infinity","object","toReturn","entries","ensureObjectOfRegExps","path","matched"],"mappings":"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"}