{"version":3,"file":"js/8478.653947f3.js","mappings":"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","sources":["webpack:///../node_modules/fast-equals/dist/esm/index.mjs"],"sourcesContent":["var getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n/**\n * Combine two comparators into a single comparators.\n */\nfunction combineComparators(comparatorA, comparatorB) {\n    return function isEqual(a, b, state) {\n        return comparatorA(a, b, state) && comparatorB(a, b, state);\n    };\n}\n/**\n * Wrap the provided `areItemsEqual` method to manage the circular state, allowing\n * for circular references to be safely included in the comparison without creating\n * stack overflows.\n */\nfunction createIsCircular(areItemsEqual) {\n    return function isCircular(a, b, state) {\n        if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {\n            return areItemsEqual(a, b, state);\n        }\n        var cache = state.cache;\n        var cachedA = cache.get(a);\n        var cachedB = cache.get(b);\n        if (cachedA && cachedB) {\n            return cachedA === b && cachedB === a;\n        }\n        cache.set(a, b);\n        cache.set(b, a);\n        var result = areItemsEqual(a, b, state);\n        cache.delete(a);\n        cache.delete(b);\n        return result;\n    };\n}\n/**\n * Get the `@@toStringTag` of the value, if it exists.\n */\nfunction getShortTag(value) {\n    return value != null ? value[Symbol.toStringTag] : undefined;\n}\n/**\n * Get the properties to strictly examine, which include both own properties that are\n * not enumerable and symbol properties.\n */\nfunction getStrictProperties(object) {\n    return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));\n}\n/**\n * Whether the object contains the property passed as an own property.\n */\nvar hasOwn = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\nObject.hasOwn ||\n    (function (object, property) {\n        return hasOwnProperty.call(object, property);\n    });\n/**\n * Whether the values passed are strictly equal or both NaN.\n */\nfunction sameValueZeroEqual(a, b) {\n    return a === b || (!a && !b && a !== a && b !== b);\n}\n\nvar PREACT_VNODE = '__v';\nvar PREACT_OWNER = '__o';\nvar REACT_OWNER = '_owner';\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, keys = Object.keys;\n/**\n * Whether the arrays are equal in value.\n */\nfunction areArraysEqual(a, b, state) {\n    var index = a.length;\n    if (b.length !== index) {\n        return false;\n    }\n    while (index-- > 0) {\n        if (!state.equals(a[index], b[index], index, index, a, b, state)) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Whether the dates passed are equal in value.\n */\nfunction areDatesEqual(a, b) {\n    return sameValueZeroEqual(a.getTime(), b.getTime());\n}\n/**\n * Whether the errors passed are equal in value.\n */\nfunction areErrorsEqual(a, b) {\n    return (a.name === b.name &&\n        a.message === b.message &&\n        a.cause === b.cause &&\n        a.stack === b.stack);\n}\n/**\n * Whether the functions passed are equal in value.\n */\nfunction areFunctionsEqual(a, b) {\n    return a === b;\n}\n/**\n * Whether the `Map`s are equal in value.\n */\nfunction areMapsEqual(a, b, state) {\n    var size = a.size;\n    if (size !== b.size) {\n        return false;\n    }\n    if (!size) {\n        return true;\n    }\n    var matchedIndices = new Array(size);\n    var aIterable = a.entries();\n    var aResult;\n    var bResult;\n    var index = 0;\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    while ((aResult = aIterable.next())) {\n        if (aResult.done) {\n            break;\n        }\n        var bIterable = b.entries();\n        var hasMatch = false;\n        var matchIndex = 0;\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n        while ((bResult = bIterable.next())) {\n            if (bResult.done) {\n                break;\n            }\n            if (matchedIndices[matchIndex]) {\n                matchIndex++;\n                continue;\n            }\n            var aEntry = aResult.value;\n            var bEntry = bResult.value;\n            if (state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state) &&\n                state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)) {\n                hasMatch = matchedIndices[matchIndex] = true;\n                break;\n            }\n            matchIndex++;\n        }\n        if (!hasMatch) {\n            return false;\n        }\n        index++;\n    }\n    return true;\n}\n/**\n * Whether the numbers are equal in value.\n */\nvar areNumbersEqual = sameValueZeroEqual;\n/**\n * Whether the objects are equal in value.\n */\nfunction areObjectsEqual(a, b, state) {\n    var properties = keys(a);\n    var index = properties.length;\n    if (keys(b).length !== index) {\n        return false;\n    }\n    // Decrementing `while` showed faster results than either incrementing or\n    // decrementing `for` loop and than an incrementing `while` loop. Declarative\n    // methods like `some` / `every` were not used to avoid incurring the garbage\n    // cost of anonymous callbacks.\n    while (index-- > 0) {\n        if (!isPropertyEqual(a, b, state, properties[index])) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Whether the objects are equal in value with strict property checking.\n */\nfunction areObjectsEqualStrict(a, b, state) {\n    var properties = getStrictProperties(a);\n    var index = properties.length;\n    if (getStrictProperties(b).length !== index) {\n        return false;\n    }\n    var property;\n    var descriptorA;\n    var descriptorB;\n    // Decrementing `while` showed faster results than either incrementing or\n    // decrementing `for` loop and than an incrementing `while` loop. Declarative\n    // methods like `some` / `every` were not used to avoid incurring the garbage\n    // cost of anonymous callbacks.\n    while (index-- > 0) {\n        property = properties[index];\n        if (!isPropertyEqual(a, b, state, property)) {\n            return false;\n        }\n        descriptorA = getOwnPropertyDescriptor(a, property);\n        descriptorB = getOwnPropertyDescriptor(b, property);\n        if ((descriptorA || descriptorB) &&\n            (!descriptorA ||\n                !descriptorB ||\n                descriptorA.configurable !== descriptorB.configurable ||\n                descriptorA.enumerable !== descriptorB.enumerable ||\n                descriptorA.writable !== descriptorB.writable)) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Whether the primitive wrappers passed are equal in value.\n */\nfunction arePrimitiveWrappersEqual(a, b) {\n    return sameValueZeroEqual(a.valueOf(), b.valueOf());\n}\n/**\n * Whether the regexps passed are equal in value.\n */\nfunction areRegExpsEqual(a, b) {\n    return a.source === b.source && a.flags === b.flags;\n}\n/**\n * Whether the `Set`s are equal in value.\n */\nfunction areSetsEqual(a, b, state) {\n    var size = a.size;\n    if (size !== b.size) {\n        return false;\n    }\n    if (!size) {\n        return true;\n    }\n    var matchedIndices = new Array(size);\n    var aIterable = a.values();\n    var aResult;\n    var bResult;\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    while ((aResult = aIterable.next())) {\n        if (aResult.done) {\n            break;\n        }\n        var bIterable = b.values();\n        var hasMatch = false;\n        var matchIndex = 0;\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n        while ((bResult = bIterable.next())) {\n            if (bResult.done) {\n                break;\n            }\n            if (!matchedIndices[matchIndex] &&\n                state.equals(aResult.value, bResult.value, aResult.value, bResult.value, a, b, state)) {\n                hasMatch = matchedIndices[matchIndex] = true;\n                break;\n            }\n            matchIndex++;\n        }\n        if (!hasMatch) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Whether the TypedArray instances are equal in value.\n */\nfunction areTypedArraysEqual(a, b) {\n    var index = a.length;\n    if (b.length !== index) {\n        return false;\n    }\n    while (index-- > 0) {\n        if (a[index] !== b[index]) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Whether the URL instances are equal in value.\n */\nfunction areUrlsEqual(a, b) {\n    return (a.hostname === b.hostname &&\n        a.pathname === b.pathname &&\n        a.protocol === b.protocol &&\n        a.port === b.port &&\n        a.hash === b.hash &&\n        a.username === b.username &&\n        a.password === b.password);\n}\nfunction isPropertyEqual(a, b, state, property) {\n    if ((property === REACT_OWNER ||\n        property === PREACT_OWNER ||\n        property === PREACT_VNODE) &&\n        (a.$$typeof || b.$$typeof)) {\n        return true;\n    }\n    return (hasOwn(b, property) &&\n        state.equals(a[property], b[property], property, property, a, b, state));\n}\n\nvar ARGUMENTS_TAG = '[object Arguments]';\nvar BOOLEAN_TAG = '[object Boolean]';\nvar DATE_TAG = '[object Date]';\nvar ERROR_TAG = '[object Error]';\nvar MAP_TAG = '[object Map]';\nvar NUMBER_TAG = '[object Number]';\nvar OBJECT_TAG = '[object Object]';\nvar REG_EXP_TAG = '[object RegExp]';\nvar SET_TAG = '[object Set]';\nvar STRING_TAG = '[object String]';\nvar URL_TAG = '[object URL]';\nvar isArray = Array.isArray;\nvar isTypedArray = typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function'\n    ? ArrayBuffer.isView\n    : null;\nvar assign = Object.assign;\nvar getTag = Object.prototype.toString.call.bind(Object.prototype.toString);\n/**\n * Create a comparator method based on the type-specific equality comparators passed.\n */\nfunction createEqualityComparator(_a) {\n    var areArraysEqual = _a.areArraysEqual, areDatesEqual = _a.areDatesEqual, areErrorsEqual = _a.areErrorsEqual, areFunctionsEqual = _a.areFunctionsEqual, areMapsEqual = _a.areMapsEqual, areNumbersEqual = _a.areNumbersEqual, areObjectsEqual = _a.areObjectsEqual, arePrimitiveWrappersEqual = _a.arePrimitiveWrappersEqual, areRegExpsEqual = _a.areRegExpsEqual, areSetsEqual = _a.areSetsEqual, areTypedArraysEqual = _a.areTypedArraysEqual, areUrlsEqual = _a.areUrlsEqual, unknownTagComparators = _a.unknownTagComparators;\n    /**\n     * compare the value of the two objects and return true if they are equivalent in values\n     */\n    return function comparator(a, b, state) {\n        // If the items are strictly equal, no need to do a value comparison.\n        if (a === b) {\n            return true;\n        }\n        // If either of the items are nullish and fail the strictly equal check\n        // above, then they must be unequal.\n        if (a == null || b == null) {\n            return false;\n        }\n        var type = typeof a;\n        if (type !== typeof b) {\n            return false;\n        }\n        if (type !== 'object') {\n            if (type === 'number') {\n                return areNumbersEqual(a, b, state);\n            }\n            if (type === 'function') {\n                return areFunctionsEqual(a, b, state);\n            }\n            // If a primitive value that is not strictly equal, it must be unequal.\n            return false;\n        }\n        var constructor = a.constructor;\n        // Checks are listed in order of commonality of use-case:\n        //   1. Common complex object types (plain object, array)\n        //   2. Common data values (date, regexp)\n        //   3. Less-common complex object types (map, set)\n        //   4. Less-common data values (promise, primitive wrappers)\n        // Inherently this is both subjective and assumptive, however\n        // when reviewing comparable libraries in the wild this order\n        // appears to be generally consistent.\n        // Constructors should match, otherwise there is potential for false positives\n        // between class and subclass or custom object and POJO.\n        if (constructor !== b.constructor) {\n            return false;\n        }\n        // `isPlainObject` only checks against the object's own realm. Cross-realm\n        // comparisons are rare, and will be handled in the ultimate fallback, so\n        // we can avoid capturing the string tag.\n        if (constructor === Object) {\n            return areObjectsEqual(a, b, state);\n        }\n        // `isArray()` works on subclasses and is cross-realm, so we can avoid capturing\n        // the string tag or doing an `instanceof` check.\n        if (isArray(a)) {\n            return areArraysEqual(a, b, state);\n        }\n        // `isTypedArray()` works on all possible TypedArray classes, so we can avoid\n        // capturing the string tag or comparing against all possible constructors.\n        if (isTypedArray != null && isTypedArray(a)) {\n            return areTypedArraysEqual(a, b, state);\n        }\n        // Try to fast-path equality checks for other complex object types in the\n        // same realm to avoid capturing the string tag. Strict equality is used\n        // instead of `instanceof` because it is more performant for the common\n        // use-case. If someone is subclassing a native class, it will be handled\n        // with the string tag comparison.\n        if (constructor === Date) {\n            return areDatesEqual(a, b, state);\n        }\n        if (constructor === RegExp) {\n            return areRegExpsEqual(a, b, state);\n        }\n        if (constructor === Map) {\n            return areMapsEqual(a, b, state);\n        }\n        if (constructor === Set) {\n            return areSetsEqual(a, b, state);\n        }\n        // Since this is a custom object, capture the string tag to determing its type.\n        // This is reasonably performant in modern environments like v8 and SpiderMonkey.\n        var tag = getTag(a);\n        if (tag === DATE_TAG) {\n            return areDatesEqual(a, b, state);\n        }\n        // For RegExp, the properties are not enumerable, and therefore will give false positives if\n        // tested like a standard object.\n        if (tag === REG_EXP_TAG) {\n            return areRegExpsEqual(a, b, state);\n        }\n        if (tag === MAP_TAG) {\n            return areMapsEqual(a, b, state);\n        }\n        if (tag === SET_TAG) {\n            return areSetsEqual(a, b, state);\n        }\n        if (tag === OBJECT_TAG) {\n            // The exception for value comparison is custom `Promise`-like class instances. These should\n            // be treated the same as standard `Promise` objects, which means strict equality, and if\n            // it reaches this point then that strict equality comparison has already failed.\n            return (typeof a.then !== 'function' &&\n                typeof b.then !== 'function' &&\n                areObjectsEqual(a, b, state));\n        }\n        // If a URL tag, it should be tested explicitly. Like RegExp, the properties are not\n        // enumerable, and therefore will give false positives if tested like a standard object.\n        if (tag === URL_TAG) {\n            return areUrlsEqual(a, b, state);\n        }\n        // If an error tag, it should be tested explicitly. Like RegExp, the properties are not\n        // enumerable, and therefore will give false positives if tested like a standard object.\n        if (tag === ERROR_TAG) {\n            return areErrorsEqual(a, b, state);\n        }\n        // If an arguments tag, it should be treated as a standard object.\n        if (tag === ARGUMENTS_TAG) {\n            return areObjectsEqual(a, b, state);\n        }\n        // As the penultimate fallback, check if the values passed are primitive wrappers. This\n        // is very rare in modern JS, which is why it is deprioritized compared to all other object\n        // types.\n        if (tag === BOOLEAN_TAG || tag === NUMBER_TAG || tag === STRING_TAG) {\n            return arePrimitiveWrappersEqual(a, b, state);\n        }\n        if (unknownTagComparators) {\n            var unknownTagComparator = unknownTagComparators[tag];\n            if (!unknownTagComparator) {\n                var shortTag = getShortTag(a);\n                if (shortTag) {\n                    unknownTagComparator = unknownTagComparators[shortTag];\n                }\n            }\n            // If the custom config has an unknown tag comparator that matches the captured tag or the\n            // @@toStringTag, it is the source of truth for whether the values are equal.\n            if (unknownTagComparator) {\n                return unknownTagComparator(a, b, state);\n            }\n        }\n        // If not matching any tags that require a specific type of comparison, then we hard-code false because\n        // the only thing remaining is strict equality, which has already been compared. This is for a few reasons:\n        //   - Certain types that cannot be introspected (e.g., `WeakMap`). For these types, this is the only\n        //     comparison that can be made.\n        //   - For types that can be introspected, but rarely have requirements to be compared\n        //     (`ArrayBuffer`, `DataView`, etc.), the cost is avoided to prioritize the common\n        //     use-cases (may be included in a future release, if requested enough).\n        //   - For types that can be introspected but do not have an objective definition of what\n        //     equality is (`Error`, etc.), the subjective decision is to be conservative and strictly compare.\n        // In all cases, these decisions should be reevaluated based on changes to the language and\n        // common development practices.\n        return false;\n    };\n}\n/**\n * Create the configuration object used for building comparators.\n */\nfunction createEqualityComparatorConfig(_a) {\n    var circular = _a.circular, createCustomConfig = _a.createCustomConfig, strict = _a.strict;\n    var config = {\n        areArraysEqual: strict\n            ? areObjectsEqualStrict\n            : areArraysEqual,\n        areDatesEqual: areDatesEqual,\n        areErrorsEqual: areErrorsEqual,\n        areFunctionsEqual: areFunctionsEqual,\n        areMapsEqual: strict\n            ? combineComparators(areMapsEqual, areObjectsEqualStrict)\n            : areMapsEqual,\n        areNumbersEqual: areNumbersEqual,\n        areObjectsEqual: strict\n            ? areObjectsEqualStrict\n            : areObjectsEqual,\n        arePrimitiveWrappersEqual: arePrimitiveWrappersEqual,\n        areRegExpsEqual: areRegExpsEqual,\n        areSetsEqual: strict\n            ? combineComparators(areSetsEqual, areObjectsEqualStrict)\n            : areSetsEqual,\n        areTypedArraysEqual: strict\n            ? areObjectsEqualStrict\n            : areTypedArraysEqual,\n        areUrlsEqual: areUrlsEqual,\n        unknownTagComparators: undefined,\n    };\n    if (createCustomConfig) {\n        config = assign({}, config, createCustomConfig(config));\n    }\n    if (circular) {\n        var areArraysEqual$1 = createIsCircular(config.areArraysEqual);\n        var areMapsEqual$1 = createIsCircular(config.areMapsEqual);\n        var areObjectsEqual$1 = createIsCircular(config.areObjectsEqual);\n        var areSetsEqual$1 = createIsCircular(config.areSetsEqual);\n        config = assign({}, config, {\n            areArraysEqual: areArraysEqual$1,\n            areMapsEqual: areMapsEqual$1,\n            areObjectsEqual: areObjectsEqual$1,\n            areSetsEqual: areSetsEqual$1,\n        });\n    }\n    return config;\n}\n/**\n * Default equality comparator pass-through, used as the standard `isEqual` creator for\n * use inside the built comparator.\n */\nfunction createInternalEqualityComparator(compare) {\n    return function (a, b, _indexOrKeyA, _indexOrKeyB, _parentA, _parentB, state) {\n        return compare(a, b, state);\n    };\n}\n/**\n * Create the `isEqual` function used by the consuming application.\n */\nfunction createIsEqual(_a) {\n    var circular = _a.circular, comparator = _a.comparator, createState = _a.createState, equals = _a.equals, strict = _a.strict;\n    if (createState) {\n        return function isEqual(a, b) {\n            var _a = createState(), _b = _a.cache, cache = _b === void 0 ? circular ? new WeakMap() : undefined : _b, meta = _a.meta;\n            return comparator(a, b, {\n                cache: cache,\n                equals: equals,\n                meta: meta,\n                strict: strict,\n            });\n        };\n    }\n    if (circular) {\n        return function isEqual(a, b) {\n            return comparator(a, b, {\n                cache: new WeakMap(),\n                equals: equals,\n                meta: undefined,\n                strict: strict,\n            });\n        };\n    }\n    var state = {\n        cache: undefined,\n        equals: equals,\n        meta: undefined,\n        strict: strict,\n    };\n    return function isEqual(a, b) {\n        return comparator(a, b, state);\n    };\n}\n\n/**\n * Whether the items passed are deeply-equal in value.\n */\nvar deepEqual = createCustomEqual();\n/**\n * Whether the items passed are deeply-equal in value based on strict comparison.\n */\nvar strictDeepEqual = createCustomEqual({ strict: true });\n/**\n * Whether the items passed are deeply-equal in value, including circular references.\n */\nvar circularDeepEqual = createCustomEqual({ circular: true });\n/**\n * Whether the items passed are deeply-equal in value, including circular references,\n * based on strict comparison.\n */\nvar strictCircularDeepEqual = createCustomEqual({\n    circular: true,\n    strict: true,\n});\n/**\n * Whether the items passed are shallowly-equal in value.\n */\nvar shallowEqual = createCustomEqual({\n    createInternalComparator: function () { return sameValueZeroEqual; },\n});\n/**\n * Whether the items passed are shallowly-equal in value based on strict comparison\n */\nvar strictShallowEqual = createCustomEqual({\n    strict: true,\n    createInternalComparator: function () { return sameValueZeroEqual; },\n});\n/**\n * Whether the items passed are shallowly-equal in value, including circular references.\n */\nvar circularShallowEqual = createCustomEqual({\n    circular: true,\n    createInternalComparator: function () { return sameValueZeroEqual; },\n});\n/**\n * Whether the items passed are shallowly-equal in value, including circular references,\n * based on strict comparison.\n */\nvar strictCircularShallowEqual = createCustomEqual({\n    circular: true,\n    createInternalComparator: function () { return sameValueZeroEqual; },\n    strict: true,\n});\n/**\n * Create a custom equality comparison method.\n *\n * This can be done to create very targeted comparisons in extreme hot-path scenarios\n * where the standard methods are not performant enough, but can also be used to provide\n * support for legacy environments that do not support expected features like\n * `RegExp.prototype.flags` out of the box.\n */\nfunction createCustomEqual(options) {\n    if (options === void 0) { options = {}; }\n    var _a = options.circular, circular = _a === void 0 ? false : _a, createCustomInternalComparator = options.createInternalComparator, createState = options.createState, _b = options.strict, strict = _b === void 0 ? false : _b;\n    var config = createEqualityComparatorConfig(options);\n    var comparator = createEqualityComparator(config);\n    var equals = createCustomInternalComparator\n        ? createCustomInternalComparator(comparator)\n        : createInternalEqualityComparator(comparator);\n    return createIsEqual({ circular: circular, comparator: comparator, createState: createState, equals: equals, strict: strict });\n}\n\nexport { circularDeepEqual, circularShallowEqual, createCustomEqual, deepEqual, sameValueZeroEqual, shallowEqual, strictCircularDeepEqual, strictCircularShallowEqual, strictDeepEqual, strictShallowEqual };\n//# sourceMappingURL=index.mjs.map\n"],"names":["getOwnPropertyNames","Object","getOwnPropertySymbols","hasOwnProperty","prototype","combineComparators","comparatorA","comparatorB","a","b","state","createIsCircular","areItemsEqual","cache","cachedA","get","cachedB","set","result","delete","getStrictProperties","object","concat","hasOwn","property","call","sameValueZeroEqual","getOwnPropertyDescriptor","keys","areArraysEqual","index","length","equals","areDatesEqual","getTime","areErrorsEqual","name","message","cause","stack","areFunctionsEqual","areMapsEqual","size","aResult","bResult","matchedIndices","Array","aIterable","entries","next","done","bIterable","hasMatch","matchIndex","aEntry","value","bEntry","areNumbersEqual","areObjectsEqual","properties","isPropertyEqual","areObjectsEqualStrict","descriptorA","descriptorB","configurable","enumerable","writable","arePrimitiveWrappersEqual","valueOf","areRegExpsEqual","source","flags","areSetsEqual","values","areTypedArraysEqual","areUrlsEqual","hostname","pathname","protocol","port","hash","username","password","$$typeof","isArray","isTypedArray","ArrayBuffer","isView","assign","getTag","toString","bind","deepEqual","createCustomEqual","strictDeepEqual","strict","options","compare","_a","circular","createCustomInternalComparator","createInternalComparator","createState","_b","config","createCustomConfig","unknownTagComparators","undefined","areArraysEqual$1","areMapsEqual$1","areObjectsEqual$1","areSetsEqual$1","createEqualityComparatorConfig","comparator","type","constructor","Date","RegExp","Map","Set","tag","then","unknownTagComparator","shortTag","Symbol","toStringTag","createEqualityComparator","WeakMap","meta","createIsEqual","_indexOrKeyA","_indexOrKeyB","_parentA","_parentB"],"ignoreList":[],"sourceRoot":""}