{"version":3,"sources":["jsdelivr-header.js","/npm/fast-equals@5.0.1/src/utils.ts","/npm/fast-equals@5.0.1/src/equals.ts","/npm/fast-equals@5.0.1/src/comparator.ts","/npm/fast-equals@5.0.1/src/index.ts"],"names":[],"mappings":"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","file":"/npm/fast-equals@5.0.1/dist/umd/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/fast-equals@5.0.1/dist/umd/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","import {\n  AnyEqualityComparator,\n  Cache,\n  CircularState,\n  Dictionary,\n  State,\n  TypeEqualityComparator,\n} from './internalTypes';\n\nconst { getOwnPropertyNames, getOwnPropertySymbols } = Object;\nconst { hasOwnProperty } = Object.prototype;\n\n/**\n * Combine two comparators into a single comparators.\n */\nexport function combineComparators<Meta>(\n  comparatorA: AnyEqualityComparator<Meta>,\n  comparatorB: AnyEqualityComparator<Meta>,\n) {\n  return function isEqual<A, B>(a: A, b: B, state: State<Meta>) {\n    return comparatorA(a, b, state) && comparatorB(a, b, state);\n  };\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 */\nexport function createIsCircular<\n  AreItemsEqual extends TypeEqualityComparator<any, any>,\n>(areItemsEqual: AreItemsEqual): AreItemsEqual {\n  return function isCircular(\n    a: any,\n    b: any,\n    state: CircularState<Cache<any, any>>,\n  ) {\n    if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {\n      return areItemsEqual(a, b, state);\n    }\n\n    const { cache } = state;\n\n    const cachedA = cache.get(a);\n    const cachedB = cache.get(b);\n\n    if (cachedA && cachedB) {\n      return cachedA === b && cachedB === a;\n    }\n\n    cache.set(a, b);\n    cache.set(b, a);\n\n    const result = areItemsEqual(a, b, state);\n\n    cache.delete(a);\n    cache.delete(b);\n\n    return result;\n  } as AreItemsEqual;\n}\n\n/**\n * Get the properties to strictly examine, which include both own properties that are\n * not enumerable and symbol properties.\n */\nexport function getStrictProperties(\n  object: Dictionary,\n): Array<string | symbol> {\n  return (getOwnPropertyNames(object) as Array<string | symbol>).concat(\n    getOwnPropertySymbols(object),\n  );\n}\n\n/**\n * Whether the object contains the property passed as an own property.\n */\nexport const hasOwn =\n  Object.hasOwn ||\n  ((object: Dictionary, property: number | string | symbol) =>\n    hasOwnProperty.call(object, property));\n\n/**\n * Whether the values passed are strictly equal or both NaN.\n */\nexport function sameValueZeroEqual(a: any, b: any): boolean {\n  return a || b ? a === b : a === b || (a !== a && b !== b);\n}\n","import { getStrictProperties, hasOwn, sameValueZeroEqual } from './utils';\nimport type {\n  Dictionary,\n  PrimitiveWrapper,\n  State,\n  TypedArray,\n} from './internalTypes';\n\nconst OWNER = '_owner';\n\nconst { getOwnPropertyDescriptor, keys } = Object;\n\n/**\n * Whether the arrays are equal in value.\n */\nexport function areArraysEqual(a: any[], b: any[], state: State<any>) {\n  let index = a.length;\n\n  if (b.length !== index) {\n    return false;\n  }\n\n  while (index-- > 0) {\n    if (!state.equals(a[index], b[index], index, index, a, b, state)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Whether the dates passed are equal in value.\n */\nexport function areDatesEqual(a: Date, b: Date): boolean {\n  return sameValueZeroEqual(a.getTime(), b.getTime());\n}\n\n/**\n * Whether the `Map`s are equal in value.\n */\nexport function areMapsEqual(\n  a: Map<any, any>,\n  b: Map<any, any>,\n  state: State<any>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  const matchedIndices: Record<number, true> = {};\n  const aIterable = a.entries();\n\n  let index = 0;\n  let aResult: IteratorResult<[any, any]>;\n  let bResult: IteratorResult<[any, any]>;\n\n  while ((aResult = aIterable.next())) {\n    if (aResult.done) {\n      break;\n    }\n\n    const bIterable = b.entries();\n\n    let hasMatch = false;\n    let matchIndex = 0;\n\n    while ((bResult = bIterable.next())) {\n      if (bResult.done) {\n        break;\n      }\n\n      const [aKey, aValue] = aResult.value;\n      const [bKey, bValue] = bResult.value;\n\n      if (\n        !hasMatch &&\n        !matchedIndices[matchIndex] &&\n        (hasMatch =\n          state.equals(aKey, bKey, index, matchIndex, a, b, state) &&\n          state.equals(aValue, bValue, aKey, bKey, a, b, state))\n      ) {\n        matchedIndices[matchIndex] = true;\n      }\n\n      matchIndex++;\n    }\n\n    if (!hasMatch) {\n      return false;\n    }\n\n    index++;\n  }\n\n  return true;\n}\n\n/**\n * Whether the objects are equal in value.\n */\nexport function areObjectsEqual(\n  a: Dictionary,\n  b: Dictionary,\n  state: State<any>,\n): boolean {\n  const properties = keys(a);\n\n  let index = properties.length;\n\n  if (keys(b).length !== index) {\n    return false;\n  }\n\n  let property: string;\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    property = properties[index]!;\n\n    if (\n      property === OWNER &&\n      (a.$$typeof || b.$$typeof) &&\n      a.$$typeof !== b.$$typeof\n    ) {\n      return false;\n    }\n\n    if (\n      !hasOwn(b, property) ||\n      !state.equals(a[property], b[property], property, property, a, b, state)\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Whether the objects are equal in value with strict property checking.\n */\nexport function areObjectsEqualStrict(\n  a: Dictionary,\n  b: Dictionary,\n  state: State<any>,\n): boolean {\n  const properties = getStrictProperties(a);\n\n  let index = properties.length;\n\n  if (getStrictProperties(b).length !== index) {\n    return false;\n  }\n\n  let property: string | symbol;\n  let descriptorA: ReturnType<typeof getOwnPropertyDescriptor>;\n  let descriptorB: ReturnType<typeof getOwnPropertyDescriptor>;\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    property = properties[index]!;\n\n    if (\n      property === OWNER &&\n      (a.$$typeof || b.$$typeof) &&\n      a.$$typeof !== b.$$typeof\n    ) {\n      return false;\n    }\n\n    if (!hasOwn(b, property)) {\n      return false;\n    }\n\n    if (\n      !state.equals(a[property], b[property], property, property, a, b, state)\n    ) {\n      return false;\n    }\n\n    descriptorA = getOwnPropertyDescriptor(a, property);\n    descriptorB = getOwnPropertyDescriptor(b, property);\n\n    if (\n      (descriptorA || descriptorB) &&\n      (!descriptorA ||\n        !descriptorB ||\n        descriptorA.configurable !== descriptorB.configurable ||\n        descriptorA.enumerable !== descriptorB.enumerable ||\n        descriptorA.writable !== descriptorB.writable)\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Whether the primitive wrappers passed are equal in value.\n */\nexport function arePrimitiveWrappersEqual(\n  a: PrimitiveWrapper,\n  b: PrimitiveWrapper,\n): boolean {\n  return sameValueZeroEqual(a.valueOf(), b.valueOf());\n}\n\n/**\n * Whether the regexps passed are equal in value.\n */\nexport function areRegExpsEqual(a: RegExp, b: RegExp): boolean {\n  return a.source === b.source && a.flags === b.flags;\n}\n\n/**\n * Whether the `Set`s are equal in value.\n */\nexport function areSetsEqual(\n  a: Set<any>,\n  b: Set<any>,\n  state: State<any>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  const matchedIndices: Record<number, true> = {};\n  const aIterable = a.values();\n\n  let aResult: IteratorResult<any>;\n  let bResult: IteratorResult<any>;\n\n  while ((aResult = aIterable.next())) {\n    if (aResult.done) {\n      break;\n    }\n\n    const bIterable = b.values();\n\n    let hasMatch = false;\n    let matchIndex = 0;\n\n    while ((bResult = bIterable.next())) {\n      if (bResult.done) {\n        break;\n      }\n\n      if (\n        !hasMatch &&\n        !matchedIndices[matchIndex] &&\n        (hasMatch = state.equals(\n          aResult.value,\n          bResult.value,\n          aResult.value,\n          bResult.value,\n          a,\n          b,\n          state,\n        ))\n      ) {\n        matchedIndices[matchIndex] = true;\n      }\n\n      matchIndex++;\n    }\n\n    if (!hasMatch) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Whether the TypedArray instances are equal in value.\n */\nexport function areTypedArraysEqual(a: TypedArray, b: TypedArray) {\n  let index = a.length;\n\n  if (b.length !== index) {\n    return false;\n  }\n\n  while (index-- > 0) {\n    if (a[index] !== b[index]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","import {\n  areArraysEqual as areArraysEqualDefault,\n  areDatesEqual as areDatesEqualDefault,\n  areMapsEqual as areMapsEqualDefault,\n  areObjectsEqual as areObjectsEqualDefault,\n  areObjectsEqualStrict as areObjectsEqualStrictDefault,\n  arePrimitiveWrappersEqual as arePrimitiveWrappersEqualDefault,\n  areRegExpsEqual as areRegExpsEqualDefault,\n  areSetsEqual as areSetsEqualDefault,\n  areTypedArraysEqual,\n} from './equals';\nimport { combineComparators, createIsCircular } from './utils';\nimport type {\n  ComparatorConfig,\n  CreateState,\n  CustomEqualCreatorOptions,\n  EqualityComparator,\n  InternalEqualityComparator,\n  State,\n} from './internalTypes';\n\nconst ARGUMENTS_TAG = '[object Arguments]';\nconst BOOLEAN_TAG = '[object Boolean]';\nconst DATE_TAG = '[object Date]';\nconst MAP_TAG = '[object Map]';\nconst NUMBER_TAG = '[object Number]';\nconst OBJECT_TAG = '[object Object]';\nconst REG_EXP_TAG = '[object RegExp]';\nconst SET_TAG = '[object Set]';\nconst STRING_TAG = '[object String]';\n\nconst { isArray } = Array;\nconst isTypedArray =\n  typeof ArrayBuffer === 'function' && ArrayBuffer.isView\n    ? ArrayBuffer.isView\n    : null;\nconst { assign } = Object;\nconst getTag = Object.prototype.toString.call.bind(\n  Object.prototype.toString,\n) as (a: object) => string;\n\ninterface CreateIsEqualOptions<Meta> {\n  circular: boolean;\n  comparator: EqualityComparator<Meta>;\n  createState: CreateState<Meta> | undefined;\n  equals: InternalEqualityComparator<Meta>;\n  strict: boolean;\n}\n\n/**\n * Create a comparator method based on the type-specific equality comparators passed.\n */\nexport function createEqualityComparator<Meta>({\n  areArraysEqual,\n  areDatesEqual,\n  areMapsEqual,\n  areObjectsEqual,\n  arePrimitiveWrappersEqual,\n  areRegExpsEqual,\n  areSetsEqual,\n  areTypedArraysEqual,\n}: ComparatorConfig<Meta>): EqualityComparator<Meta> {\n  /**\n   * compare the value of the two objects and return true if they are equivalent in values\n   */\n  return function comparator(a: any, b: any, state: State<Meta>): boolean {\n    // If the items are strictly equal, no need to do a value comparison.\n    if (a === b) {\n      return true;\n    }\n\n    // If the items are not non-nullish objects, then the only possibility\n    // of them being equal but not strictly is if they are both `NaN`. Since\n    // `NaN` is uniquely not equal to itself, we can use self-comparison of\n    // both objects, which is faster than `isNaN()`.\n    if (\n      a == null ||\n      b == null ||\n      typeof a !== 'object' ||\n      typeof b !== 'object'\n    ) {\n      return a !== a && b !== b;\n    }\n\n    const constructor = a.constructor;\n\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\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\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\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\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\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\n    if (constructor === Date) {\n      return areDatesEqual(a, b, state);\n    }\n\n    if (constructor === RegExp) {\n      return areRegExpsEqual(a, b, state);\n    }\n\n    if (constructor === Map) {\n      return areMapsEqual(a, b, state);\n    }\n\n    if (constructor === Set) {\n      return areSetsEqual(a, b, state);\n    }\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    const tag = getTag(a);\n\n    if (tag === DATE_TAG) {\n      return areDatesEqual(a, b, state);\n    }\n\n    if (tag === REG_EXP_TAG) {\n      return areRegExpsEqual(a, b, state);\n    }\n\n    if (tag === MAP_TAG) {\n      return areMapsEqual(a, b, state);\n    }\n\n    if (tag === SET_TAG) {\n      return areSetsEqual(a, b, state);\n    }\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 (\n        typeof a.then !== 'function' &&\n        typeof b.then !== 'function' &&\n        areObjectsEqual(a, b, state)\n      );\n    }\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\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\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/**\n * Create the configuration object used for building comparators.\n */\nexport function createEqualityComparatorConfig<Meta>({\n  circular,\n  createCustomConfig,\n  strict,\n}: CustomEqualCreatorOptions<Meta>): ComparatorConfig<Meta> {\n  let config = {\n    areArraysEqual: strict\n      ? areObjectsEqualStrictDefault\n      : areArraysEqualDefault,\n    areDatesEqual: areDatesEqualDefault,\n    areMapsEqual: strict\n      ? combineComparators(areMapsEqualDefault, areObjectsEqualStrictDefault)\n      : areMapsEqualDefault,\n    areObjectsEqual: strict\n      ? areObjectsEqualStrictDefault\n      : areObjectsEqualDefault,\n    arePrimitiveWrappersEqual: arePrimitiveWrappersEqualDefault,\n    areRegExpsEqual: areRegExpsEqualDefault,\n    areSetsEqual: strict\n      ? combineComparators(areSetsEqualDefault, areObjectsEqualStrictDefault)\n      : areSetsEqualDefault,\n    areTypedArraysEqual: strict\n      ? areObjectsEqualStrictDefault\n      : areTypedArraysEqual,\n  };\n\n  if (createCustomConfig) {\n    config = assign({}, config, createCustomConfig(config));\n  }\n\n  if (circular) {\n    const areArraysEqual = createIsCircular(config.areArraysEqual);\n    const areMapsEqual = createIsCircular(config.areMapsEqual);\n    const areObjectsEqual = createIsCircular(config.areObjectsEqual);\n    const areSetsEqual = createIsCircular(config.areSetsEqual);\n\n    config = assign({}, config, {\n      areArraysEqual,\n      areMapsEqual,\n      areObjectsEqual,\n      areSetsEqual,\n    });\n  }\n\n  return config;\n}\n\n/**\n * Default equality comparator pass-through, used as the standard `isEqual` creator for\n * use inside the built comparator.\n */\nexport function createInternalEqualityComparator<Meta>(\n  compare: EqualityComparator<Meta>,\n): InternalEqualityComparator<Meta> {\n  return function (\n    a: any,\n    b: any,\n    _indexOrKeyA: any,\n    _indexOrKeyB: any,\n    _parentA: any,\n    _parentB: any,\n    state: State<Meta>,\n  ) {\n    return compare(a, b, state);\n  };\n}\n\n/**\n * Create the `isEqual` function used by the consuming application.\n */\nexport function createIsEqual<Meta>({\n  circular,\n  comparator,\n  createState,\n  equals,\n  strict,\n}: CreateIsEqualOptions<Meta>) {\n  if (createState) {\n    return function isEqual<A, B>(a: A, b: B): boolean {\n      const { cache = circular ? new WeakMap() : undefined, meta } =\n        createState!();\n\n      return comparator(a, b, {\n        cache,\n        equals,\n        meta,\n        strict,\n      } as State<Meta>);\n    };\n  }\n\n  if (circular) {\n    return function isEqual<A, B>(a: A, b: B): boolean {\n      return comparator(a, b, {\n        cache: new WeakMap(),\n        equals,\n        meta: undefined as Meta,\n        strict,\n      } as State<Meta>);\n    };\n  }\n\n  const state = {\n    cache: undefined,\n    equals,\n    meta: undefined,\n    strict,\n  } as State<Meta>;\n\n  return function isEqual<A, B>(a: A, b: B): boolean {\n    return comparator(a, b, state);\n  };\n}\n","import {\n  createEqualityComparatorConfig,\n  createEqualityComparator,\n  createInternalEqualityComparator,\n  createIsEqual,\n} from './comparator';\nimport type { CustomEqualCreatorOptions } from './internalTypes';\nimport { sameValueZeroEqual } from './utils';\n\nexport { sameValueZeroEqual };\nexport * from './internalTypes';\n\n/**\n * Whether the items passed are deeply-equal in value.\n */\nexport const deepEqual = createCustomEqual();\n\n/**\n * Whether the items passed are deeply-equal in value based on strict comparison.\n */\nexport const strictDeepEqual = createCustomEqual({ strict: true });\n\n/**\n * Whether the items passed are deeply-equal in value, including circular references.\n */\nexport const circularDeepEqual = createCustomEqual({ circular: true });\n\n/**\n * Whether the items passed are deeply-equal in value, including circular references,\n * based on strict comparison.\n */\nexport const strictCircularDeepEqual = createCustomEqual({\n  circular: true,\n  strict: true,\n});\n\n/**\n * Whether the items passed are shallowly-equal in value.\n */\nexport const shallowEqual = createCustomEqual({\n  createInternalComparator: () => sameValueZeroEqual,\n});\n\n/**\n * Whether the items passed are shallowly-equal in value based on strict comparison\n */\nexport const strictShallowEqual = createCustomEqual({\n  strict: true,\n  createInternalComparator: () => sameValueZeroEqual,\n});\n\n/**\n * Whether the items passed are shallowly-equal in value, including circular references.\n */\nexport const circularShallowEqual = createCustomEqual({\n  circular: true,\n  createInternalComparator: () => sameValueZeroEqual,\n});\n\n/**\n * Whether the items passed are shallowly-equal in value, including circular references,\n * based on strict comparison.\n */\nexport const strictCircularShallowEqual = createCustomEqual({\n  circular: true,\n  createInternalComparator: () => sameValueZeroEqual,\n  strict: true,\n});\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 */\nexport function createCustomEqual<Meta = undefined>(\n  options: CustomEqualCreatorOptions<Meta> = {},\n) {\n  const {\n    circular = false,\n    createInternalComparator: createCustomInternalComparator,\n    createState,\n    strict = false,\n  } = options;\n\n  const config = createEqualityComparatorConfig<Meta>(options);\n  const comparator = createEqualityComparator(config);\n  const equals = createCustomInternalComparator\n    ? createCustomInternalComparator(comparator)\n    : createInternalEqualityComparator(comparator);\n\n  return createIsEqual({ circular, comparator, createState, equals, strict });\n}\n"]}