effect 4.0.0-beta.70 → 4.0.0-beta.72

package/dist/Equivalence.d.ts

@@ -5,13 +5,12 @@ import * as Reducer from "./Reducer.ts";
  *
  * **When to use**
  *
- * - Use as a type annotation for equivalence functions
+ * Use as a type annotation for equivalence functions
  * - Use when implementing custom equivalence logic
  * - Use when working with collection operations that require equivalence relations
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs or have side effects
  * - Returns `boolean`: `true` if values are equivalent, `false` otherwise
  * - Must satisfy reflexive, symmetric, and transitive properties
  *
@@ -53,7 +52,7 @@ export type Equivalence<in A> = (self: A, that: A) => boolean;
  *
  * **When to use**
  *
- * - Rarely needed in application code
+ * Use when rarely needed in application code
  * - Use primarily for internal type system operations and HKT (Higher-Kinded Types) abstractions
  * - Use when working with generic type constructors that require type lambdas
  *
@@ -91,13 +90,12 @@ export interface EquivalenceTypeLambda extends TypeLambda {
  *
  * **When to use**
  *
- * - Use when you need a custom equivalence that is not just strict equality
+ * Use when you need a custom equivalence that is not just strict equality
  * - Use when creating equivalences for complex types with custom comparison logic
  * - Use when you want the performance benefit of reference equality optimization
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - First checks reference equality (`===`) for performance; if values are identical, returns `true` without calling the function
  * - Falls back to the provided equivalence function if values are not the same reference
  * - The provided function must satisfy reflexive, symmetric, and transitive properties
@@ -141,14 +139,13 @@ export declare const make: <A>(isEquivalent: (self: A, that: A) => boolean) => E
  *
  * **When to use**
  *
- * - Use for primitive types where `===` is appropriate
+ * Use when you need primitive types where `===` is appropriate
  * - Use when you need reference equality for objects
  * - Use as a building block for more complex equivalences via {@link mapInput} or {@link combine}
  * - Use when performance is critical and you do not need structural equality
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Uses JavaScript's strict equality operator (`===`)
  * - For primitives: compares values directly
  * - For objects: compares by reference, so only the same object instance is equivalent
@@ -182,13 +179,17 @@ export declare const make: <A>(isEquivalent: (self: A, that: A) => boolean) => E
  * ```
  *
  * @see {@link make}
- * @see {@link Equal} for structural equality
+ * @see `Equal` for structural equality
  * @category constructors
  * @since 4.0.0
  */
 export declare const strictEqual: <A>() => Equivalence<A>;
 /**
- * An `Equivalence` instance for strings using strict equality (`===`).
+ * Equivalence instance for strings using strict equality (`===`).
+ *
+ * **When to use**
+ *
+ * Use when an API needs an `Equivalence` instance for string equality.
  *
  * **Example** (Comparing strings)
  *
@@ -204,7 +205,12 @@ export declare const strictEqual: <A>() => Equivalence<A>;
  */
 export declare const String: Equivalence<string>;
 /**
- * An `Equivalence` instance for numbers.
+ * Equivalence instance for numbers.
+ *
+ * **When to use**
+ *
+ * Use when an API needs an `Equivalence` instance for numeric equality where
+ * `NaN` equals `NaN`.
  *
  * **Details**
  *
@@ -225,7 +231,11 @@ export declare const String: Equivalence<string>;
  */
 export declare const Number: Equivalence<number>;
 /**
- * An `Equivalence` instance for booleans using strict equality (`===`).
+ * Equivalence instance for booleans using strict equality (`===`).
+ *
+ * **When to use**
+ *
+ * Use when an API needs an `Equivalence` instance for boolean equality.
  *
  * **Example** (Comparing booleans)
  *
@@ -241,7 +251,11 @@ export declare const Number: Equivalence<number>;
  */
 export declare const Boolean: Equivalence<boolean>;
 /**
- * An `Equivalence` instance for bigints using strict equality (`===`).
+ * Equivalence instance for bigints using strict equality (`===`).
+ *
+ * **When to use**
+ *
+ * Use when an API needs an `Equivalence` instance for `bigint` equality.
  *
  * **Example** (Comparing bigints)
  *
@@ -261,13 +275,12 @@ export declare const BigInt: Equivalence<bigint>;
  *
  * **When to use**
  *
- * - Use when you need to combine exactly two equivalences
+ * Use when you need to combine exactly two equivalences
  * - Use when building complex equivalences from simpler ones
  * - Use when you want both conditions to be satisfied
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Returns `true` only if both equivalences return `true`
  * - Short-circuits: if the first equivalence returns `false`, the second is not called
  * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
@@ -313,13 +326,12 @@ export declare const combine: {
      *
      * **When to use**
      *
-     * - Use when you need to combine exactly two equivalences
+     * Use when you need to combine exactly two equivalences
      * - Use when building complex equivalences from simpler ones
      * - Use when you want both conditions to be satisfied
      *
      * **Details**
      *
-     * - Does not mutate inputs
      * - Returns `true` only if both equivalences return `true`
      * - Short-circuits: if the first equivalence returns `false`, the second is not called
      * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
@@ -365,13 +377,12 @@ export declare const combine: {
      *
      * **When to use**
      *
-     * - Use when you need to combine exactly two equivalences
+     * Use when you need to combine exactly two equivalences
      * - Use when building complex equivalences from simpler ones
      * - Use when you want both conditions to be satisfied
      *
      * **Details**
      *
-     * - Does not mutate inputs
      * - Returns `true` only if both equivalences return `true`
      * - Short-circuits: if the first equivalence returns `false`, the second is not called
      * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
@@ -418,14 +429,13 @@ export declare const combine: {
  *
  * **When to use**
  *
- * - Use when you need to combine three or more equivalences
+ * Use when you need to combine three or more equivalences
  * - Use when you have a dynamic collection of equivalences to combine
  * - Use when building equivalences from arrays or iterables
  * - Prefer this over multiple `combine` calls when you have many equivalences
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Returns `true` only if all equivalences in the collection return `true`
  * - Short-circuits: stops at the first equivalence that returns `false`
  * - Empty collections return an equivalence that always returns `true`
@@ -486,14 +496,13 @@ export declare const combineAll: <A>(collection: Iterable<Equivalence<A>>) => Eq
  *
  * **When to use**
  *
- * - Use when you need an equivalence for a complex type based on a single property
+ * Use when you need an equivalence for a complex type based on a single property
  * - Use when you want to normalize values before comparison, such as case-insensitive strings
  * - Use when creating equivalences that focus on specific fields of objects
  * - Use as a building block for creating equivalences via {@link combine} or {@link combineAll}
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Applies the transformation function to both values before comparing
  * - The transformation function should be pure and have no side effects
  * - The resulting equivalence compares the transformed values using the provided equivalence
@@ -549,14 +558,13 @@ export declare const mapInput: {
      *
      * **When to use**
      *
-     * - Use when you need an equivalence for a complex type based on a single property
+     * Use when you need an equivalence for a complex type based on a single property
      * - Use when you want to normalize values before comparison, such as case-insensitive strings
      * - Use when creating equivalences that focus on specific fields of objects
      * - Use as a building block for creating equivalences via {@link combine} or {@link combineAll}
      *
      * **Details**
      *
-     * - Does not mutate inputs
      * - Applies the transformation function to both values before comparing
      * - The transformation function should be pure and have no side effects
      * - The resulting equivalence compares the transformed values using the provided equivalence
@@ -612,14 +620,13 @@ export declare const mapInput: {
      *
      * **When to use**
      *
-     * - Use when you need an equivalence for a complex type based on a single property
+     * Use when you need an equivalence for a complex type based on a single property
      * - Use when you want to normalize values before comparison, such as case-insensitive strings
      * - Use when creating equivalences that focus on specific fields of objects
      * - Use as a building block for creating equivalences via {@link combine} or {@link combineAll}
      *
      * **Details**
      *
-     * - Does not mutate inputs
      * - Applies the transformation function to both values before comparing
      * - The transformation function should be pure and have no side effects
      * - The resulting equivalence compares the transformed values using the provided equivalence
@@ -676,14 +683,13 @@ export declare const mapInput: {
  *
  * **When to use**
  *
- * - Use when comparing tuples with different types at each position
+ * Use when comparing tuples with different types at each position
  * - Use when you need different equivalence logic for each tuple element
  * - Use when working with fixed-length tuples instead of arrays
  * - Prefer this over `Array` when you have a known tuple structure with different types
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Requires tuples to have the same length; different lengths are never equivalent
  * - Applies each equivalence to the corresponding element position
  * - Returns `true` only if all elements are equivalent according to their respective equivalences
@@ -729,8 +735,6 @@ export declare const mapInput: {
  * ) // true
  * ```
  *
- * @see {@link Array_}
- * @see {@link Struct}
  * @category combinators
  * @since 4.0.0
  */
@@ -747,14 +751,13 @@ export {
  *
  * **When to use**
  *
- * - Use when comparing arrays with homogeneous element types
+ * Use when comparing arrays with homogeneous element types
  * - Use when all elements should use the same equivalence logic
  * - Use when working with variable-length arrays instead of fixed tuples
  * - Prefer this over `Tuple` when you have arrays of the same type
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Requires arrays to have the same length; different lengths are never equivalent
  * - Compares elements positionally, such as index `0` with index `0`
  * - Returns `true` only if all corresponding elements are equivalent
@@ -800,14 +803,13 @@ Array_ as Array };
  *
  * **When to use**
  *
- * - Use when comparing objects with known, fixed property names
+ * Use when comparing objects with known, fixed property names
  * - Use when you need different equivalence logic for different properties
  * - Use when working with struct or interface types with specific fields
  * - Prefer this over `Record` when you have a fixed set of known properties
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Compares only the properties specified in the struct definition
  * - Properties not in the struct are ignored
  * - Returns `true` only if all specified properties are equivalent according to their equivalences
@@ -874,14 +876,13 @@ export declare function Struct<R extends Record<string, Equivalence<any>>>(field
  *
  * **When to use**
  *
- * - Use when comparing objects with dynamic or unknown property names
+ * Use when comparing objects with dynamic or unknown property names
  * - Use when all property values should use the same equivalence logic
  * - Use when working with record or dictionary types
  * - Prefer this over `Struct` when you have variable properties or need to compare all properties uniformly
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Compares all properties present in both objects
  * - Requires both objects to have the same set of keys; different keys result in `false`
  * - All property values must be equivalent according to the provided equivalence
@@ -921,8 +922,6 @@ export declare function Struct<R extends Record<string, Equivalence<any>>>(field
  * console.log(numberRecordEq(scores1, scores3)) // false
  * ```
  *
- * @see {@link Struct}
- * @see {@link Array_}
  * @category combinators
  * @since 4.0.0
  */
@@ -932,7 +931,7 @@ export declare function Record<A>(value: Equivalence<A>): Equivalence<Record<Pro
  *
  * **When to use**
  *
- * - Use when you need to combine multiple equivalences from a collection using reducer patterns
+ * Use when you need to combine multiple equivalences from a collection using reducer patterns
  * - Use when implementing fold operations over collections of equivalences
  * - Use when working with reducers that operate on equivalences
  *
@@ -968,7 +967,11 @@ export declare function Record<A>(value: Equivalence<A>): Equivalence<Record<Pro
  */
 export declare function makeReducer<A>(): Reducer.Reducer<Equivalence<A>>;
 /**
- * An `Equivalence` instance for `Date` objects that compares their `getTime()` values using `Equivalence.Number`.
+ * Equivalence instance for `Date` objects that compares their `getTime()` values using `Equivalence.Number`.
+ *
+ * **When to use**
+ *
+ * Use when comparing `Date` values by their millisecond timestamp.
  *
  * **Details**
  *
@@ -1004,9 +1007,9 @@ export declare function makeReducer<A>(): Reducer.Reducer<Equivalence<A>>;
  * console.log(Equivalence.Date(d1, d2)) // true (same time value)
  * ```
  *
- * @see {@link Number}
- * @see {@link mapInput}
- * @see {@link strictEqual}
+ * @see {@link Number} for the numeric equivalence applied to each `Date#getTime()` result
+ * @see {@link mapInput} for deriving an equivalence by mapping inputs before comparison
+ * @see {@link strictEqual} for reference equality when two values must be the same object
  * @category instances
  * @since 2.0.0
  */

package/dist/Equivalence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Equivalence.d.ts","sourceRoot":"","sources":["../src/Equivalence.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Equivalence.d.ts","sourceRoot":"","sources":["../src/Equivalence.ts"],"names":[],"mappings":"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"}

package/dist/Equivalence.js

@@ -45,9 +45,9 @@
  *
  * ## See also
  *
- * - {@link Equal} - For structural equality (can convert to Equivalence)
- * - {@link Array_.dedupeWith} - Remove duplicates using an equivalence
- * - {@link Chunk} - Collections that use equivalences for operations
+ * - `Equal` - For structural equality (can convert to Equivalence)
+ * - `Array.dedupeWith` - Remove duplicates using an equivalence
+ * - `Chunk` - Collections that use equivalences for operations
  *
  * @since 2.0.0
  */
@@ -58,13 +58,12 @@ import * as Reducer from "./Reducer.js";
  *
  * **When to use**
  *
- * - Use when you need a custom equivalence that is not just strict equality
+ * Use when you need a custom equivalence that is not just strict equality
  * - Use when creating equivalences for complex types with custom comparison logic
  * - Use when you want the performance benefit of reference equality optimization
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - First checks reference equality (`===`) for performance; if values are identical, returns `true` without calling the function
  * - Falls back to the provided equivalence function if values are not the same reference
  * - The provided function must satisfy reflexive, symmetric, and transitive properties
@@ -109,14 +108,13 @@ const isStrictEquivalent = (x, y) => x === y;
  *
  * **When to use**
  *
- * - Use for primitive types where `===` is appropriate
+ * Use when you need primitive types where `===` is appropriate
  * - Use when you need reference equality for objects
  * - Use as a building block for more complex equivalences via {@link mapInput} or {@link combine}
  * - Use when performance is critical and you do not need structural equality
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Uses JavaScript's strict equality operator (`===`)
  * - For primitives: compares values directly
  * - For objects: compares by reference, so only the same object instance is equivalent
@@ -150,13 +148,17 @@ const isStrictEquivalent = (x, y) => x === y;
  * ```
  *
  * @see {@link make}
- * @see {@link Equal} for structural equality
+ * @see `Equal` for structural equality
  * @category constructors
  * @since 4.0.0
  */
 export const strictEqual = () => isStrictEquivalent;
 /**
- * An `Equivalence` instance for strings using strict equality (`===`).
+ * Equivalence instance for strings using strict equality (`===`).
+ *
+ * **When to use**
+ *
+ * Use when an API needs an `Equivalence` instance for string equality.
  *
  * **Example** (Comparing strings)
  *
@@ -172,7 +174,12 @@ export const strictEqual = () => isStrictEquivalent;
  */
 export const String = isStrictEquivalent;
 /**
- * An `Equivalence` instance for numbers.
+ * Equivalence instance for numbers.
+ *
+ * **When to use**
+ *
+ * Use when an API needs an `Equivalence` instance for numeric equality where
+ * `NaN` equals `NaN`.
  *
  * **Details**
  *
@@ -193,7 +200,11 @@ export const String = isStrictEquivalent;
  */
 export const Number = /*#__PURE__*/make((self, that) => globalThis.Number.isNaN(self) && globalThis.Number.isNaN(that));
 /**
- * An `Equivalence` instance for booleans using strict equality (`===`).
+ * Equivalence instance for booleans using strict equality (`===`).
+ *
+ * **When to use**
+ *
+ * Use when an API needs an `Equivalence` instance for boolean equality.
  *
  * **Example** (Comparing booleans)
  *
@@ -209,7 +220,11 @@ export const Number = /*#__PURE__*/make((self, that) => globalThis.Number.isNaN(
  */
 export const Boolean = isStrictEquivalent;
 /**
- * An `Equivalence` instance for bigints using strict equality (`===`).
+ * Equivalence instance for bigints using strict equality (`===`).
+ *
+ * **When to use**
+ *
+ * Use when an API needs an `Equivalence` instance for `bigint` equality.
  *
  * **Example** (Comparing bigints)
  *
@@ -229,13 +244,12 @@ export const BigInt = isStrictEquivalent;
  *
  * **When to use**
  *
- * - Use when you need to combine exactly two equivalences
+ * Use when you need to combine exactly two equivalences
  * - Use when building complex equivalences from simpler ones
  * - Use when you want both conditions to be satisfied
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Returns `true` only if both equivalences return `true`
  * - Short-circuits: if the first equivalence returns `false`, the second is not called
  * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
@@ -281,14 +295,13 @@ export const combine = /*#__PURE__*/dual(2, (self, that) => make((x, y) => self(
  *
  * **When to use**
  *
- * - Use when you need to combine three or more equivalences
+ * Use when you need to combine three or more equivalences
  * - Use when you have a dynamic collection of equivalences to combine
  * - Use when building equivalences from arrays or iterables
  * - Prefer this over multiple `combine` calls when you have many equivalences
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Returns `true` only if all equivalences in the collection return `true`
  * - Short-circuits: stops at the first equivalence that returns `false`
  * - Empty collections return an equivalence that always returns `true`
@@ -356,14 +369,13 @@ export const combineAll = collection => make((x, y) => {
  *
  * **When to use**
  *
- * - Use when you need an equivalence for a complex type based on a single property
+ * Use when you need an equivalence for a complex type based on a single property
  * - Use when you want to normalize values before comparison, such as case-insensitive strings
  * - Use when creating equivalences that focus on specific fields of objects
  * - Use as a building block for creating equivalences via {@link combine} or {@link combineAll}
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Applies the transformation function to both values before comparing
  * - The transformation function should be pure and have no side effects
  * - The resulting equivalence compares the transformed values using the provided equivalence
@@ -419,14 +431,13 @@ export const mapInput = /*#__PURE__*/dual(2, (self, f) => make((x, y) => self(f(
  *
  * **When to use**
  *
- * - Use when comparing tuples with different types at each position
+ * Use when comparing tuples with different types at each position
  * - Use when you need different equivalence logic for each tuple element
  * - Use when working with fixed-length tuples instead of arrays
  * - Prefer this over `Array` when you have a known tuple structure with different types
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Requires tuples to have the same length; different lengths are never equivalent
  * - Applies each equivalence to the corresponding element position
  * - Returns `true` only if all elements are equivalent according to their respective equivalences
@@ -472,8 +483,6 @@ export const mapInput = /*#__PURE__*/dual(2, (self, f) => make((x, y) => self(f(
  * ) // true
  * ```
  *
- * @see {@link Array_}
- * @see {@link Struct}
  * @category combinators
  * @since 4.0.0
  */
@@ -508,14 +517,13 @@ export {
  *
  * **When to use**
  *
- * - Use when comparing arrays with homogeneous element types
+ * Use when comparing arrays with homogeneous element types
  * - Use when all elements should use the same equivalence logic
  * - Use when working with variable-length arrays instead of fixed tuples
  * - Prefer this over `Tuple` when you have arrays of the same type
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Requires arrays to have the same length; different lengths are never equivalent
  * - Compares elements positionally, such as index `0` with index `0`
  * - Returns `true` only if all corresponding elements are equivalent
@@ -561,14 +569,13 @@ Array_ as Array };
  *
  * **When to use**
  *
- * - Use when comparing objects with known, fixed property names
+ * Use when comparing objects with known, fixed property names
  * - Use when you need different equivalence logic for different properties
  * - Use when working with struct or interface types with specific fields
  * - Prefer this over `Record` when you have a fixed set of known properties
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Compares only the properties specified in the struct definition
  * - Properties not in the struct are ignored
  * - Returns `true` only if all specified properties are equivalent according to their equivalences
@@ -641,14 +648,13 @@ export function Struct(fields) {
  *
  * **When to use**
  *
- * - Use when comparing objects with dynamic or unknown property names
+ * Use when comparing objects with dynamic or unknown property names
  * - Use when all property values should use the same equivalence logic
  * - Use when working with record or dictionary types
  * - Prefer this over `Struct` when you have variable properties or need to compare all properties uniformly
  *
  * **Details**
  *
- * - Does not mutate inputs
  * - Compares all properties present in both objects
  * - Requires both objects to have the same set of keys; different keys result in `false`
  * - All property values must be equivalent according to the provided equivalence
@@ -688,8 +694,6 @@ export function Struct(fields) {
  * console.log(numberRecordEq(scores1, scores3)) // false
  * ```
  *
- * @see {@link Struct}
- * @see {@link Array_}
  * @category combinators
  * @since 4.0.0
  */
@@ -711,7 +715,7 @@ export function Record(value) {
  *
  * **When to use**
  *
- * - Use when you need to combine multiple equivalences from a collection using reducer patterns
+ * Use when you need to combine multiple equivalences from a collection using reducer patterns
  * - Use when implementing fold operations over collections of equivalences
  * - Use when working with reducers that operate on equivalences
  *
@@ -749,7 +753,11 @@ export function makeReducer() {
   return Reducer.make(combine, () => true, combineAll);
 }
 /**
- * An `Equivalence` instance for `Date` objects that compares their `getTime()` values using `Equivalence.Number`.
+ * Equivalence instance for `Date` objects that compares their `getTime()` values using `Equivalence.Number`.
+ *
+ * **When to use**
+ *
+ * Use when comparing `Date` values by their millisecond timestamp.
  *
  * **Details**
  *
@@ -785,9 +793,9 @@ export function makeReducer() {
  * console.log(Equivalence.Date(d1, d2)) // true (same time value)
  * ```
  *
- * @see {@link Number}
- * @see {@link mapInput}
- * @see {@link strictEqual}
+ * @see {@link Number} for the numeric equivalence applied to each `Date#getTime()` result
+ * @see {@link mapInput} for deriving an equivalence by mapping inputs before comparison
+ * @see {@link strictEqual} for reference equality when two values must be the same object
  * @category instances
  * @since 2.0.0
  */

package/dist/Equivalence.js.map

@@ -1 +1 @@
-{"version":3,"file":"Equivalence.js","names":["dual","Reducer","make","isEquivalent","self","that","isStrictEquivalent","x","y","strictEqual","String","Number","globalThis","isNaN","Boolean","BigInt","combine","combineAll","collection","equivalence","mapInput","f","Tuple","elements","length","i","Array_","item","Array","Struct","fields","keys","Reflect","ownKeys","key","Record","value","selfKeys","thatKeys","Object","hasOwn","makeReducer","Date","d","getTime"],"sources":["../src/Equivalence.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"Equivalence.js","names":["dual","Reducer","make","isEquivalent","self","that","isStrictEquivalent","x","y","strictEqual","String","Number","globalThis","isNaN","Boolean","BigInt","combine","combineAll","collection","equivalence","mapInput","f","Tuple","elements","length","i","Array_","item","Array","Struct","fields","keys","Reflect","ownKeys","key","Record","value","selfKeys","thatKeys","Object","hasOwn","makeReducer","Date","d","getTime"],"sources":["../src/Equivalence.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}