fast-equals 5.3.4 → 5.4.1

package/dist/es/internalTypes.d.mts

@@ -1,174 +0,0 @@
-/**
- * Cache used to store references to objects, used for circular
- * reference checks.
- */
-export interface Cache<Key extends object, Value> {
-  delete(key: Key): boolean;
-  get(key: Key): Value | undefined;
-  set(key: Key, value: any): any;
-}
-export interface State<Meta> {
-  /**
-   * Cache used to identify circular references
-   */
-  readonly cache: Cache<any, any> | undefined;
-  /**
-   * Method used to determine equality of nested value.
-   */
-  readonly equals: InternalEqualityComparator<Meta>;
-  /**
-   * Additional value that can be used for comparisons.
-   */
-  meta: Meta;
-  /**
-   * Whether the equality comparison is strict, meaning it matches
-   * all properties (including symbols and non-enumerable properties)
-   * with equal shape of descriptors.
-   */
-  readonly strict: boolean;
-}
-export interface CircularState<Meta> extends State<Meta> {
-  readonly cache: Cache<any, any>;
-}
-export interface DefaultState<Meta> extends State<Meta> {
-  readonly cache: undefined;
-}
-export interface Dictionary<Value = any> {
-  [key: string | symbol]: Value;
-  $$typeof?: any;
-}
-export interface ComparatorConfig<Meta> {
-  /**
-   * Whether the arrays passed are equal in value. In strict mode, this includes
-   * additional properties added to the array.
-   */
-  areArraysEqual: TypeEqualityComparator<any, Meta>;
-  /**
-   * Whether the dates passed are equal in value.
-   */
-  areDatesEqual: TypeEqualityComparator<any, Meta>;
-  /**
-   * Whether the errors passed are equal in value.
-   */
-  areErrorsEqual: TypeEqualityComparator<any, Meta>;
-  /**
-   * Whether the functions passed are equal in value.
-   */
-  areFunctionsEqual: TypeEqualityComparator<any, Meta>;
-  /**
-   * Whether the maps passed are equal in value. In strict mode, this includes
-   * additional properties added to the map.
-   */
-  areMapsEqual: TypeEqualityComparator<any, Meta>;
-  /**
-   * Whether the numbers passed are equal in value.
-   */
-  areNumbersEqual: TypeEqualityComparator<any, Meta>;
-  /**
-   * Whether the objects passed are equal in value. In strict mode, this includes
-   * non-enumerable properties added to the map, as well as symbol properties.
-   */
-  areObjectsEqual: TypeEqualityComparator<any, Meta>;
-  /**
-   * Whether the primitive wrappers passed are equal in value.
-   */
-  arePrimitiveWrappersEqual: TypeEqualityComparator<any, Meta>;
-  /**
-   * Whether the regexps passed are equal in value.
-   */
-  areRegExpsEqual: TypeEqualityComparator<any, Meta>;
-  /**
-   * Whether the sets passed are equal in value. In strict mode, this includes
-   * additional properties added to the set.
-   */
-  areSetsEqual: TypeEqualityComparator<any, Meta>;
-  /**
-   * Whether the typed arrays passed are equal in value. In strict mode, this includes
-   * additional properties added to the typed array.
-   */
-  areTypedArraysEqual: TypeEqualityComparator<any, Meta>;
-  /**
-   * Whether the URLs passed are equal in value.
-   */
-  areUrlsEqual: TypeEqualityComparator<any, Meta>;
-  /**
-   * Whether two values with unknown `@@toStringTag` are equal in value. This comparator is
-   * called when no other comparator applies.
-   *
-   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag
-   */
-  unknownTagComparators: Record<string, TypeEqualityComparator<any, Meta>> | undefined;
-}
-export type CreateCustomComparatorConfig<Meta> = (config: ComparatorConfig<Meta>) => Partial<ComparatorConfig<Meta>>;
-export type CreateState<Meta> = () => {
-  cache?: Cache<any, any> | undefined;
-  meta?: Meta;
-};
-export type EqualityComparator<Meta> = <A, B>(a: A, b: B, state: State<Meta>) => boolean;
-export type AnyEqualityComparator<Meta> = (a: any, b: any, state: State<Meta>) => boolean;
-export type EqualityComparatorCreator<Meta> = (fn: EqualityComparator<Meta>) => InternalEqualityComparator<Meta>;
-export type InternalEqualityComparator<Meta> = (
-  a: any,
-  b: any,
-  indexOrKeyA: any,
-  indexOrKeyB: any,
-  parentA: any,
-  parentB: any,
-  state: State<Meta>,
-) => boolean;
-export type PrimitiveWrapper = Boolean | Number | String;
-/**
- * Type which encompasses possible instances of TypedArray
- * classes.
- *
- * **NOTE**: This does not include `BigInt64Array` and
- * `BitUint64Array` because those are part of ES2020 and
- * not supported by certain TS configurations. If using
- * either in `areTypedArraysEqual`, you can cast the
- * instance as `TypedArray` and it will work as expected,
- * because runtime checks will still work for those classes.
- */
-export type TypedArray =
-  | Float32Array
-  | Float64Array
-  | Int8Array
-  | Int16Array
-  | Int32Array
-  | Uint16Array
-  | Uint32Array
-  | Uint8Array
-  | Uint8ClampedArray;
-export type TypeEqualityComparator<Type, Meta = undefined> = (a: Type, b: Type, state: State<Meta>) => boolean;
-export interface CustomEqualCreatorOptions<Meta> {
-  /**
-   * Whether circular references should be supported. It causes the
-   * comparison to be slower, but for objects that have circular references
-   * it is required to avoid stack overflows.
-   */
-  circular?: boolean;
-  /**
-   * Create a custom configuration of type-specific equality comparators.
-   * This receives the default configuration, which allows either replacement
-   * or supersetting of the default methods.
-   */
-  createCustomConfig?: CreateCustomComparatorConfig<Meta>;
-  /**
-   * Create a custom internal comparator, which is used as an override to the
-   * default entry point for nested value equality comparisons. This is often
-   * used for doing custom logic for specific types (such as handling a specific
-   * class instance differently than other objects) or to incorporate `meta` in
-   * the comparison. See the recipes for examples.
-   */
-  createInternalComparator?: (compare: EqualityComparator<Meta>) => InternalEqualityComparator<Meta>;
-  /**
-   * Create a custom `state` object passed between the methods. This allows for
-   * custom `cache` and/or `meta` values to be used.
-   */
-  createState?: CreateState<Meta>;
-  /**
-   * Whether the equality comparison is strict, meaning it matches
-   * all properties (including symbols and non-enumerable properties)
-   * with equal shape of descriptors.
-   */
-  strict?: boolean;
-}

package/dist/es/utils.d.mts

@@ -1,33 +0,0 @@
-import type { AnyEqualityComparator, Dictionary, State, TypeEqualityComparator } from './internalTypes.d.mts';
-/**
- * Combine two comparators into a single comparators.
- */
-export declare function combineComparators<Meta>(
-  comparatorA: AnyEqualityComparator<Meta>,
-  comparatorB: AnyEqualityComparator<Meta>,
-): <A, B>(a: A, b: B, state: State<Meta>) => boolean;
-/**
- * Wrap the provided `areItemsEqual` method to manage the circular state, allowing
- * for circular references to be safely included in the comparison without creating
- * stack overflows.
- */
-export declare function createIsCircular<AreItemsEqual extends TypeEqualityComparator<any, any>>(
-  areItemsEqual: AreItemsEqual,
-): AreItemsEqual;
-/**
- * Get the `@@toStringTag` of the value, if it exists.
- */
-export declare function getShortTag(value: any): string | undefined;
-/**
- * Get the properties to strictly examine, which include both own properties that are
- * not enumerable and symbol properties.
- */
-export declare function getStrictProperties(object: Dictionary): Array<string | symbol>;
-/**
- * Whether the object contains the property passed as an own property.
- */
-export declare const hasOwn: (o: object, v: PropertyKey) => boolean;
-/**
- * Whether the values passed are strictly equal or both NaN.
- */
-export declare function sameValueZeroEqual(a: any, b: any): boolean;

package/dist/umd/comparator.d.ts

@@ -1,26 +0,0 @@
-import type { ComparatorConfig, CreateState, CustomEqualCreatorOptions, EqualityComparator, InternalEqualityComparator } from './internalTypes.js';
-interface CreateIsEqualOptions<Meta> {
-    circular: boolean;
-    comparator: EqualityComparator<Meta>;
-    createState: CreateState<Meta> | undefined;
-    equals: InternalEqualityComparator<Meta>;
-    strict: boolean;
-}
-/**
- * Create a comparator method based on the type-specific equality comparators passed.
- */
-export declare function createEqualityComparator<Meta>({ areArraysEqual, areDatesEqual, areErrorsEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, areTypedArraysEqual, areUrlsEqual, unknownTagComparators, }: ComparatorConfig<Meta>): EqualityComparator<Meta>;
-/**
- * Create the configuration object used for building comparators.
- */
-export declare function createEqualityComparatorConfig<Meta>({ circular, createCustomConfig, strict, }: CustomEqualCreatorOptions<Meta>): ComparatorConfig<Meta>;
-/**
- * Default equality comparator pass-through, used as the standard `isEqual` creator for
- * use inside the built comparator.
- */
-export declare function createInternalEqualityComparator<Meta>(compare: EqualityComparator<Meta>): InternalEqualityComparator<Meta>;
-/**
- * Create the `isEqual` function used by the consuming application.
- */
-export declare function createIsEqual<Meta>({ circular, comparator, createState, equals, strict }: CreateIsEqualOptions<Meta>): <A, B>(a: A, b: B) => boolean;
-export {};

package/dist/umd/equals.d.ts

@@ -1,54 +0,0 @@
-import type { Dictionary, PrimitiveWrapper, State, TypedArray } from './internalTypes.js';
-import { sameValueZeroEqual } from './utils.js';
-/**
- * Whether the arrays are equal in value.
- */
-export declare function areArraysEqual(a: any[], b: any[], state: State<any>): boolean;
-/**
- * Whether the dates passed are equal in value.
- */
-export declare function areDatesEqual(a: Date, b: Date): boolean;
-/**
- * Whether the errors passed are equal in value.
- */
-export declare function areErrorsEqual(a: Error, b: Error): boolean;
-/**
- * Whether the functions passed are equal in value.
- */
-export declare function areFunctionsEqual(a: (...args: any[]) => any, b: (...args: any[]) => any): boolean;
-/**
- * Whether the `Map`s are equal in value.
- */
-export declare function areMapsEqual(a: Map<any, any>, b: Map<any, any>, state: State<any>): boolean;
-/**
- * Whether the numbers are equal in value.
- */
-export declare const areNumbersEqual: typeof sameValueZeroEqual;
-/**
- * Whether the objects are equal in value.
- */
-export declare function areObjectsEqual(a: Dictionary, b: Dictionary, state: State<any>): boolean;
-/**
- * Whether the objects are equal in value with strict property checking.
- */
-export declare function areObjectsEqualStrict(a: Dictionary, b: Dictionary, state: State<any>): boolean;
-/**
- * Whether the primitive wrappers passed are equal in value.
- */
-export declare function arePrimitiveWrappersEqual(a: PrimitiveWrapper, b: PrimitiveWrapper): boolean;
-/**
- * Whether the regexps passed are equal in value.
- */
-export declare function areRegExpsEqual(a: RegExp, b: RegExp): boolean;
-/**
- * Whether the `Set`s are equal in value.
- */
-export declare function areSetsEqual(a: Set<any>, b: Set<any>, state: State<any>): boolean;
-/**
- * Whether the TypedArray instances are equal in value.
- */
-export declare function areTypedArraysEqual(a: TypedArray, b: TypedArray): boolean;
-/**
- * Whether the URL instances are equal in value.
- */
-export declare function areUrlsEqual(a: URL, b: URL): boolean;

package/dist/umd/internalTypes.d.ts

@@ -1,157 +0,0 @@
-/**
- * Cache used to store references to objects, used for circular
- * reference checks.
- */
-export interface Cache<Key extends object, Value> {
-    delete(key: Key): boolean;
-    get(key: Key): Value | undefined;
-    set(key: Key, value: any): any;
-}
-export interface State<Meta> {
-    /**
-     * Cache used to identify circular references
-     */
-    readonly cache: Cache<any, any> | undefined;
-    /**
-     * Method used to determine equality of nested value.
-     */
-    readonly equals: InternalEqualityComparator<Meta>;
-    /**
-     * Additional value that can be used for comparisons.
-     */
-    meta: Meta;
-    /**
-     * Whether the equality comparison is strict, meaning it matches
-     * all properties (including symbols and non-enumerable properties)
-     * with equal shape of descriptors.
-     */
-    readonly strict: boolean;
-}
-export interface CircularState<Meta> extends State<Meta> {
-    readonly cache: Cache<any, any>;
-}
-export interface DefaultState<Meta> extends State<Meta> {
-    readonly cache: undefined;
-}
-export interface Dictionary<Value = any> {
-    [key: string | symbol]: Value;
-    $$typeof?: any;
-}
-export interface ComparatorConfig<Meta> {
-    /**
-     * Whether the arrays passed are equal in value. In strict mode, this includes
-     * additional properties added to the array.
-     */
-    areArraysEqual: TypeEqualityComparator<any, Meta>;
-    /**
-     * Whether the dates passed are equal in value.
-     */
-    areDatesEqual: TypeEqualityComparator<any, Meta>;
-    /**
-     * Whether the errors passed are equal in value.
-     */
-    areErrorsEqual: TypeEqualityComparator<any, Meta>;
-    /**
-     * Whether the functions passed are equal in value.
-     */
-    areFunctionsEqual: TypeEqualityComparator<any, Meta>;
-    /**
-     * Whether the maps passed are equal in value. In strict mode, this includes
-     * additional properties added to the map.
-     */
-    areMapsEqual: TypeEqualityComparator<any, Meta>;
-    /**
-     * Whether the numbers passed are equal in value.
-     */
-    areNumbersEqual: TypeEqualityComparator<any, Meta>;
-    /**
-     * Whether the objects passed are equal in value. In strict mode, this includes
-     * non-enumerable properties added to the map, as well as symbol properties.
-     */
-    areObjectsEqual: TypeEqualityComparator<any, Meta>;
-    /**
-     * Whether the primitive wrappers passed are equal in value.
-     */
-    arePrimitiveWrappersEqual: TypeEqualityComparator<any, Meta>;
-    /**
-     * Whether the regexps passed are equal in value.
-     */
-    areRegExpsEqual: TypeEqualityComparator<any, Meta>;
-    /**
-     * Whether the sets passed are equal in value. In strict mode, this includes
-     * additional properties added to the set.
-     */
-    areSetsEqual: TypeEqualityComparator<any, Meta>;
-    /**
-     * Whether the typed arrays passed are equal in value. In strict mode, this includes
-     * additional properties added to the typed array.
-     */
-    areTypedArraysEqual: TypeEqualityComparator<any, Meta>;
-    /**
-     * Whether the URLs passed are equal in value.
-     */
-    areUrlsEqual: TypeEqualityComparator<any, Meta>;
-    /**
-     * Whether two values with unknown `@@toStringTag` are equal in value. This comparator is
-     * called when no other comparator applies.
-     *
-     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag
-     */
-    unknownTagComparators: Record<string, TypeEqualityComparator<any, Meta>> | undefined;
-}
-export type CreateCustomComparatorConfig<Meta> = (config: ComparatorConfig<Meta>) => Partial<ComparatorConfig<Meta>>;
-export type CreateState<Meta> = () => {
-    cache?: Cache<any, any> | undefined;
-    meta?: Meta;
-};
-export type EqualityComparator<Meta> = <A, B>(a: A, b: B, state: State<Meta>) => boolean;
-export type AnyEqualityComparator<Meta> = (a: any, b: any, state: State<Meta>) => boolean;
-export type EqualityComparatorCreator<Meta> = (fn: EqualityComparator<Meta>) => InternalEqualityComparator<Meta>;
-export type InternalEqualityComparator<Meta> = (a: any, b: any, indexOrKeyA: any, indexOrKeyB: any, parentA: any, parentB: any, state: State<Meta>) => boolean;
-export type PrimitiveWrapper = Boolean | Number | String;
-/**
- * Type which encompasses possible instances of TypedArray
- * classes.
- *
- * **NOTE**: This does not include `BigInt64Array` and
- * `BitUint64Array` because those are part of ES2020 and
- * not supported by certain TS configurations. If using
- * either in `areTypedArraysEqual`, you can cast the
- * instance as `TypedArray` and it will work as expected,
- * because runtime checks will still work for those classes.
- */
-export type TypedArray = Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint16Array | Uint32Array | Uint8Array | Uint8ClampedArray;
-export type TypeEqualityComparator<Type, Meta = undefined> = (a: Type, b: Type, state: State<Meta>) => boolean;
-export interface CustomEqualCreatorOptions<Meta> {
-    /**
-     * Whether circular references should be supported. It causes the
-     * comparison to be slower, but for objects that have circular references
-     * it is required to avoid stack overflows.
-     */
-    circular?: boolean;
-    /**
-     * Create a custom configuration of type-specific equality comparators.
-     * This receives the default configuration, which allows either replacement
-     * or supersetting of the default methods.
-     */
-    createCustomConfig?: CreateCustomComparatorConfig<Meta>;
-    /**
-     * Create a custom internal comparator, which is used as an override to the
-     * default entry point for nested value equality comparisons. This is often
-     * used for doing custom logic for specific types (such as handling a specific
-     * class instance differently than other objects) or to incorporate `meta` in
-     * the comparison. See the recipes for examples.
-     */
-    createInternalComparator?: (compare: EqualityComparator<Meta>) => InternalEqualityComparator<Meta>;
-    /**
-     * Create a custom `state` object passed between the methods. This allows for
-     * custom `cache` and/or `meta` values to be used.
-     */
-    createState?: CreateState<Meta>;
-    /**
-     * Whether the equality comparison is strict, meaning it matches
-     * all properties (including symbols and non-enumerable properties)
-     * with equal shape of descriptors.
-     */
-    strict?: boolean;
-}

package/dist/umd/utils.d.ts

@@ -1,28 +0,0 @@
-import type { AnyEqualityComparator, Dictionary, State, TypeEqualityComparator } from './internalTypes.js';
-/**
- * Combine two comparators into a single comparators.
- */
-export declare function combineComparators<Meta>(comparatorA: AnyEqualityComparator<Meta>, comparatorB: AnyEqualityComparator<Meta>): <A, B>(a: A, b: B, state: State<Meta>) => boolean;
-/**
- * Wrap the provided `areItemsEqual` method to manage the circular state, allowing
- * for circular references to be safely included in the comparison without creating
- * stack overflows.
- */
-export declare function createIsCircular<AreItemsEqual extends TypeEqualityComparator<any, any>>(areItemsEqual: AreItemsEqual): AreItemsEqual;
-/**
- * Get the `@@toStringTag` of the value, if it exists.
- */
-export declare function getShortTag(value: any): string | undefined;
-/**
- * Get the properties to strictly examine, which include both own properties that are
- * not enumerable and symbol properties.
- */
-export declare function getStrictProperties(object: Dictionary): Array<string | symbol>;
-/**
- * Whether the object contains the property passed as an own property.
- */
-export declare const hasOwn: (o: object, v: PropertyKey) => boolean;
-/**
- * Whether the values passed are strictly equal or both NaN.
- */
-export declare function sameValueZeroEqual(a: any, b: any): boolean;