effect 4.0.0-beta.102 → 4.0.0-beta.103

package/dist/Equivalence.d.ts

@@ -14,18 +14,18 @@ import * as Reducer from "./Reducer.ts";
  *
  * **Example** (Defining simple number equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Equivalence } from "effect"
  *
  * const numberEq: Equivalence.Equivalence<number> = (a, b) => a === b
  *
- * console.log(numberEq(1, 1)) // true
- * console.log(numberEq(1, 2)) // false
+ * numberEq(1, 1) // => true
+ * numberEq(1, 2) // => false
  * ```
  *
  * **Example** (Defining custom object equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Equivalence } from "effect"
  *
  * interface Point {
@@ -36,12 +36,12 @@ import * as Reducer from "./Reducer.ts";
  * const pointEq: Equivalence.Equivalence<Point> = (a, b) =>
  *   a.x === b.x && a.y === b.y
  *
- * console.log(pointEq({ x: 1, y: 2 }, { x: 1, y: 2 })) // true
+ * pointEq({ x: 1, y: 2 }, { x: 1, y: 2 }) // => true
  * ```
  *
  * @see {@link make}
  * @see {@link strictEqual}
- * @category type class
+ * @category models
  * @since 2.0.0
  */
 export type Equivalence<in A> = (self: A, that: A) => boolean;
@@ -59,7 +59,7 @@ export type Equivalence<in A> = (self: A, that: A) => boolean;
  *
  * **Example** (Type-level usage)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Equivalence, HKT } from "effect"
  *
  * // Used internally for type-level computations
@@ -75,7 +75,7 @@ export type Equivalence<in A> = (self: A, that: A) => boolean;
  *
  * @see {@link Equivalence}
  * @see {@link TypeLambda}
- * @category type lambdas
+ * @category utility types
  * @since 2.0.0
  */
 export interface EquivalenceTypeLambda extends TypeLambda {
@@ -98,30 +98,30 @@ export interface EquivalenceTypeLambda extends TypeLambda {
  *
  * **Example** (Case-insensitive string equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const caseInsensitive = Equivalence.make<string>((a, b) =>
  *   a.toLowerCase() === b.toLowerCase()
  * )
  *
- * console.log(caseInsensitive("Hello", "HELLO")) // true
- * console.log(caseInsensitive("foo", "bar")) // false
+ * caseInsensitive("Hello", "HELLO") // => true
+ * caseInsensitive("foo", "bar") // => false
  *
  * // Same reference optimization
  * const str = "test"
- * console.log(caseInsensitive(str, str)) // true (fast path)
+ * caseInsensitive(str, str) // => true
  * ```
  *
  * **Example** (Comparing numbers with tolerance)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const tolerance = Equivalence.make<number>((a, b) => Math.abs(a - b) < 0.0001)
  *
- * console.log(tolerance(1.0, 1.001)) // false
- * console.log(tolerance(1.0, 1.00001)) // true
+ * tolerance(1.0, 1.001) // => false
+ * tolerance(1.0, 1.00001) // => true
  * ```
  *
  * @see {@link strictEqual}
@@ -150,26 +150,26 @@ export declare const make: <A>(isEquivalent: (self: A, that: A) => boolean) => E
  *
  * **Example** (Comparing primitive types)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const strictEq = Equivalence.strictEqual<number>()
  *
- * console.log(strictEq(1, 1)) // true
- * console.log(strictEq(1, 2)) // false
- * console.log(strictEq(NaN, NaN)) // false (NaN !== NaN)
+ * strictEq(1, 1) // => true
+ * strictEq(1, 2) // => false
+ * strictEq(NaN, NaN) // => false
  * ```
  *
  * **Example** (Comparing objects by reference)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const obj = { value: 42 }
  * const strictObjEq = Equivalence.strictEqual<typeof obj>()
  *
- * console.log(strictObjEq(obj, obj)) // true
- * console.log(strictObjEq(obj, { value: 42 })) // false (different references)
+ * strictObjEq(obj, obj) // => true
+ * strictObjEq(obj, { value: 42 }) // => false
  * ```
  *
  * @see {@link make}
@@ -187,11 +187,11 @@ export declare const strictEqual: <A>() => Equivalence<A>;
  *
  * **Example** (Comparing strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
- * console.log(Equivalence.String("hello", "hello")) // true
- * console.log(Equivalence.String("hello", "world")) // false
+ * Equivalence.String("hello", "hello") // => true
+ * Equivalence.String("hello", "world") // => false
  * ```
  *
  * @category instances
@@ -207,12 +207,12 @@ export declare const String: Equivalence<string>;
  *
  * **Example** (Comparing numbers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
- * console.log(Equivalence.Number(1, 1)) // true
- * console.log(Equivalence.Number(1, 2)) // false
- * console.log(Equivalence.Number(NaN, NaN)) // true
+ * Equivalence.Number(1, 1) // => true
+ * Equivalence.Number(1, 2) // => false
+ * Equivalence.Number(NaN, NaN) // => true
  * ```
  *
  * @category instances
@@ -228,11 +228,11 @@ export declare const Number: Equivalence<number>;
  *
  * **Example** (Comparing booleans)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
- * console.log(Equivalence.Boolean(true, true)) // true
- * console.log(Equivalence.Boolean(true, false)) // false
+ * Equivalence.Boolean(true, true) // => true
+ * Equivalence.Boolean(true, false) // => false
  * ```
  *
  * @category instances
@@ -248,11 +248,11 @@ export declare const Boolean: Equivalence<boolean>;
  *
  * **Example** (Comparing bigints)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
- * console.log(Equivalence.BigInt(1n, 1n)) // true
- * console.log(Equivalence.BigInt(1n, 2n)) // false
+ * Equivalence.BigInt(1n, 1n) // => true
+ * Equivalence.BigInt(1n, 2n) // => false
  * ```
  *
  * @category instances
@@ -275,7 +275,7 @@ export declare const BigInt: Equivalence<bigint>;
  *
  * **Example** (Combining name and age equivalences)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * interface Person {
@@ -299,8 +299,8 @@ export declare const BigInt: Equivalence<bigint>;
  * const person2 = { name: "Alice", age: 30 }
  * const person3 = { name: "Alice", age: 31 }
  *
- * console.log(personEquivalence(person1, person2)) // true
- * console.log(personEquivalence(person1, person3)) // false (different age)
+ * personEquivalence(person1, person2) // => true
+ * personEquivalence(person1, person3) // => false
  * ```
  *
  * @see {@link combineAll}
@@ -325,7 +325,7 @@ export declare const combine: {
      *
      * **Example** (Combining name and age equivalences)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Equivalence } from "effect"
      *
      * interface Person {
@@ -349,8 +349,8 @@ export declare const combine: {
      * const person2 = { name: "Alice", age: 30 }
      * const person3 = { name: "Alice", age: 31 }
      *
-     * console.log(personEquivalence(person1, person2)) // true
-     * console.log(personEquivalence(person1, person3)) // false (different age)
+     * personEquivalence(person1, person2) // => true
+     * personEquivalence(person1, person3) // => false
      * ```
      *
      * @see {@link combineAll}
@@ -375,7 +375,7 @@ export declare const combine: {
      *
      * **Example** (Combining name and age equivalences)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Equivalence } from "effect"
      *
      * interface Person {
@@ -399,8 +399,8 @@ export declare const combine: {
      * const person2 = { name: "Alice", age: 30 }
      * const person3 = { name: "Alice", age: 31 }
      *
-     * console.log(personEquivalence(person1, person2)) // true
-     * console.log(personEquivalence(person1, person3)) // false (different age)
+     * personEquivalence(person1, person2) // => true
+     * personEquivalence(person1, person3) // => false
      * ```
      *
      * @see {@link combineAll}
@@ -427,7 +427,7 @@ export declare const combine: {
  *
  * **Example** (Combining multiple field equivalences)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * interface Point3D {
@@ -455,18 +455,18 @@ export declare const combine: {
  * const point2 = { x: 1, y: 2, z: 3 }
  * const point3 = { x: 1, y: 2, z: 4 }
  *
- * console.log(point3DEq(point1, point2)) // true
- * console.log(point3DEq(point1, point3)) // false (different z)
+ * point3DEq(point1, point2) // => true
+ * point3DEq(point1, point3) // => false
  * ```
  *
  * **Example** (Handling empty collections)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * // Empty collection always returns true
  * const alwaysEq = Equivalence.combineAll([])
- * console.log(alwaysEq("anything", "else")) // true
+ * alwaysEq("anything", "else") // => true
  * ```
  *
  * @see {@link combine}
@@ -493,7 +493,7 @@ export declare const combineAll: <A>(collection: Iterable<Equivalence<A>>) => Eq
  *
  * **Example** (Deriving equivalence from an object property)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * interface User {
@@ -512,13 +512,13 @@ export declare const combineAll: <A>(collection: Iterable<Equivalence<A>>) => Eq
  * const user2 = { id: 1, name: "Alice Smith", email: "alice.smith@example.com" }
  * const user3 = { id: 2, name: "Bob", email: "bob@example.com" }
  *
- * console.log(userByIdEq(user1, user2)) // true (same ID)
- * console.log(userByIdEq(user1, user3)) // false (different ID)
+ * userByIdEq(user1, user2) // => true
+ * userByIdEq(user1, user3) // => false
  * ```
  *
  * **Example** (Case-insensitive string equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const caseInsensitiveEq = Equivalence.mapInput(
@@ -526,8 +526,8 @@ export declare const combineAll: <A>(collection: Iterable<Equivalence<A>>) => Eq
  *   (s: string) => s.toLowerCase()
  * )
  *
- * console.log(caseInsensitiveEq("Hello", "HELLO")) // true
- * console.log(caseInsensitiveEq("Hello", "World")) // false
+ * caseInsensitiveEq("Hello", "HELLO") // => true
+ * caseInsensitiveEq("Hello", "World") // => false
  * ```
  *
  * @see {@link combine}
@@ -554,7 +554,7 @@ export declare const mapInput: {
      *
      * **Example** (Deriving equivalence from an object property)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Equivalence } from "effect"
      *
      * interface User {
@@ -573,13 +573,13 @@ export declare const mapInput: {
      * const user2 = { id: 1, name: "Alice Smith", email: "alice.smith@example.com" }
      * const user3 = { id: 2, name: "Bob", email: "bob@example.com" }
      *
-     * console.log(userByIdEq(user1, user2)) // true (same ID)
-     * console.log(userByIdEq(user1, user3)) // false (different ID)
+     * userByIdEq(user1, user2) // => true
+     * userByIdEq(user1, user3) // => false
      * ```
      *
      * **Example** (Case-insensitive string equivalence)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Equivalence } from "effect"
      *
      * const caseInsensitiveEq = Equivalence.mapInput(
@@ -587,8 +587,8 @@ export declare const mapInput: {
      *   (s: string) => s.toLowerCase()
      * )
      *
-     * console.log(caseInsensitiveEq("Hello", "HELLO")) // true
-     * console.log(caseInsensitiveEq("Hello", "World")) // false
+     * caseInsensitiveEq("Hello", "HELLO") // => true
+     * caseInsensitiveEq("Hello", "World") // => false
      * ```
      *
      * @see {@link combine}
@@ -615,7 +615,7 @@ export declare const mapInput: {
      *
      * **Example** (Deriving equivalence from an object property)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Equivalence } from "effect"
      *
      * interface User {
@@ -634,13 +634,13 @@ export declare const mapInput: {
      * const user2 = { id: 1, name: "Alice Smith", email: "alice.smith@example.com" }
      * const user3 = { id: 2, name: "Bob", email: "bob@example.com" }
      *
-     * console.log(userByIdEq(user1, user2)) // true (same ID)
-     * console.log(userByIdEq(user1, user3)) // false (different ID)
+     * userByIdEq(user1, user2) // => true
+     * userByIdEq(user1, user3) // => false
      * ```
      *
      * **Example** (Case-insensitive string equivalence)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Equivalence } from "effect"
      *
      * const caseInsensitiveEq = Equivalence.mapInput(
@@ -648,8 +648,8 @@ export declare const mapInput: {
      *   (s: string) => s.toLowerCase()
      * )
      *
-     * console.log(caseInsensitiveEq("Hello", "HELLO")) // true
-     * console.log(caseInsensitiveEq("Hello", "World")) // false
+     * caseInsensitiveEq("Hello", "HELLO") // => true
+     * caseInsensitiveEq("Hello", "World") // => false
      * ```
      *
      * @see {@link combine}
@@ -677,7 +677,7 @@ export declare const mapInput: {
  *
  * **Example** (Comparing homogeneous tuples)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const stringTupleEq = Equivalence.Tuple([
@@ -690,13 +690,13 @@ export declare const mapInput: {
  * const tuple2 = ["hello", "world", "test"] as const
  * const tuple3 = ["hello", "world", "different"] as const
  *
- * console.log(stringTupleEq(tuple1, tuple2)) // true
- * console.log(stringTupleEq(tuple1, tuple3)) // false (different third element)
+ * stringTupleEq(tuple1, tuple2) // => true
+ * stringTupleEq(tuple1, tuple3) // => false
  * ```
  *
  * **Example** (Comparing tuples with custom equivalences)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const caseInsensitive = Equivalence.mapInput(
@@ -710,9 +710,7 @@ export declare const mapInput: {
  *   caseInsensitive
  * ])
  *
- * console.log(
- *   customTupleEq(["Hello", "World", "Test"], ["HELLO", "WORLD", "TEST"])
- * ) // true
+ * customTupleEq(["Hello", "World", "Test"], ["HELLO", "WORLD", "TEST"]) // => true
  * ```
  *
  * @category combinators
@@ -743,19 +741,19 @@ export {
  *
  * **Example** (Comparing number arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const numberArrayEq = Equivalence.Array(Equivalence.strictEqual<number>())
  *
- * console.log(numberArrayEq([1, 2, 3], [1, 2, 3])) // true
- * console.log(numberArrayEq([1, 2, 3], [1, 2, 4])) // false
- * console.log(numberArrayEq([1, 2], [1, 2, 3])) // false (different length)
+ * numberArrayEq([1, 2, 3], [1, 2, 3]) // => true
+ * numberArrayEq([1, 2, 3], [1, 2, 4]) // => false
+ * numberArrayEq([1, 2], [1, 2, 3]) // => false
  * ```
  *
  * **Example** (Case-insensitive string array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const caseInsensitive = Equivalence.mapInput(
@@ -764,9 +762,9 @@ export {
  * )
  * const stringArrayEq = Equivalence.Array(caseInsensitive)
  *
- * console.log(stringArrayEq(["Hello", "World"], ["HELLO", "WORLD"])) // true
- * console.log(stringArrayEq(["Hello"], ["Hi"])) // false
- * console.log(stringArrayEq([], [])) // true (empty arrays)
+ * stringArrayEq(["Hello", "World"], ["HELLO", "WORLD"]) // => true
+ * stringArrayEq(["Hello"], ["Hi"]) // => false
+ * stringArrayEq([], []) // => true
  * ```
  *
  * @see {@link Tuple}
@@ -793,7 +791,7 @@ Array_ as Array };
  *
  * **Example** (Comparing structs with different equivalences per field)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * interface Person {
@@ -817,13 +815,13 @@ Array_ as Array };
  * const person2 = { name: "ALICE", age: 30, email: "ALICE@EXAMPLE.COM" }
  * const person3 = { name: "Alice", age: 31, email: "alice@example.com" }
  *
- * console.log(personEq(person1, person2)) // true (case-insensitive match)
- * console.log(personEq(person1, person3)) // false (different age)
+ * personEq(person1, person2) // => true
+ * personEq(person1, person3) // => false
  * ```
  *
  * **Example** (Comparing specific fields)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const nameAgeEq = Equivalence.Struct({
@@ -834,7 +832,7 @@ Array_ as Array };
  * // Only compares name and age, ignores other properties
  * const obj1 = { name: "Alice", age: 30, extra: "ignored" }
  * const obj2 = { name: "Alice", age: 30, extra: "different" }
- * console.log(nameAgeEq(obj1, obj2)) // true
+ * nameAgeEq(obj1, obj2) // => true
  * ```
  *
  * @see {@link Record}
@@ -865,7 +863,7 @@ export declare function Struct<R extends Record<string, Equivalence<any>>>(field
  *
  * **Example** (Defining records with string values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const stringRecordEq = Equivalence.Record(Equivalence.strictEqual<string>())
@@ -875,14 +873,14 @@ export declare function Struct<R extends Record<string, Equivalence<any>>>(field
  * const record3 = { a: "hello", b: "different" }
  * const record4 = { a: "hello" } // missing key 'b'
  *
- * console.log(stringRecordEq(record1, record2)) // true
- * console.log(stringRecordEq(record1, record3)) // false
- * console.log(stringRecordEq(record1, record4)) // false (different keys)
+ * stringRecordEq(record1, record2) // => true
+ * stringRecordEq(record1, record3) // => false
+ * stringRecordEq(record1, record4) // => false
  * ```
  *
  * **Example** (Defining records with number values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const numberRecordEq = Equivalence.Record(Equivalence.strictEqual<number>())
@@ -891,8 +889,8 @@ export declare function Struct<R extends Record<string, Equivalence<any>>>(field
  * const scores2 = { alice: 100, bob: 85 }
  * const scores3 = { alice: 100, bob: 90 }
  *
- * console.log(numberRecordEq(scores1, scores2)) // true
- * console.log(numberRecordEq(scores1, scores3)) // false
+ * numberRecordEq(scores1, scores2) // => true
+ * numberRecordEq(scores1, scores3) // => false
  * ```
  *
  * @category combinators
@@ -915,7 +913,7 @@ export declare function Record<A>(value: Equivalence<A>): Equivalence<Record<Pro
  *
  * **Example** (Creating a Reducer)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const reducer = Equivalence.makeReducer<number>()
@@ -926,8 +924,8 @@ export declare function Record<A>(value: Equivalence<A>): Equivalence<Record<Pro
  *
  * const combined = reducer.combineAll(equivalences)
  * // Combined equivalence requires both conditions to be true
- * console.log(combined(1, 1)) // true (strict equal)
- * console.log(combined(1, 1.5)) // false (strict equal fails)
+ * combined(1, 1) // => true
+ * combined(1, 1.5) // => false
  * ```
  *
  * @see {@link combine} Combine two equivalences
@@ -952,7 +950,7 @@ export declare function makeReducer<A>(): Reducer.Reducer<Equivalence<A>>;
  *
  * **Example** (Comparing Date values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const d1 = new Date("2020-01-01T00:00:00.000Z")
@@ -961,22 +959,22 @@ export declare function makeReducer<A>(): Reducer.Reducer<Equivalence<A>>;
  * const invalidDate1 = new Date("foo")
  * const invalidDate2 = new Date("bar")
  *
- * console.log(Equivalence.Date(d1, d2)) // true
- * console.log(Equivalence.Date(d1, d3)) // false
- * console.log(Equivalence.Date(invalidDate1, invalidDate2)) // true
- * console.log(Equivalence.Date(invalidDate1, d1)) // false
+ * Equivalence.Date(d1, d2) // => true
+ * Equivalence.Date(d1, d3) // => false
+ * Equivalence.Date(invalidDate1, invalidDate2) // => true
+ * Equivalence.Date(invalidDate1, d1) // => false
  * ```
  *
  * **Example** (Comparing reference and value equality)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence } from "effect"
  *
  * const d1 = new Date(0)
  * const d2 = new Date(0)
  *
- * console.log(d1 === d2) // false (different references)
- * console.log(Equivalence.Date(d1, d2)) // true (same time value)
+ * d1 === d2 // => false
+ * Equivalence.Date(d1, d2) // => true
  * ```
  *
  * @see {@link Number} for the numeric equivalence applied to each `Date#getTime()` result

package/dist/Equivalence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Equivalence.d.ts","sourceRoot":"","sources":["../src/Equivalence.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,MAAM,WAAW,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,CAAA;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,WAAW,qBAAsB,SAAQ,UAAU;IACvD,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAA;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,KAAG,WAAW,CAAC,CAAC,CACxC,CAAA;AAI3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,OAAO,WAAW,CAAC,CAAC,CAA4B,CAAA;AAE5E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,EAAE,WAAW,CAAC,MAAM,CAAsB,CAAA;AAE7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,EAAE,WAAW,CAAC,MAAM,CAEtC,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,OAAO,EAAE,WAAW,CAAC,OAAO,CAAsB,CAAA;AAE/D;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,EAAE,WAAW,CAAC,MAAM,CAAsB,CAAA;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,CAAA;IACnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;CACuD,CAAA;AAExH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,cAAc,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,CAAC,CAQ9E,CAAA;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2DG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,CAAA;IAChE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2DG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;CAI7D,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAgB,KAAK,CAAC,KAAK,CAAC,QAAQ,SAAS,aAAa,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,EAC1E,QAAQ,EAAE,QAAQ,GACjB,WAAW,CAAC;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,QAAQ,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CAAE,CAAC,CAY3G;AAED;;GAEG;AACH,iBAAS,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAUtE;AACD,OAAO;AACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,IAAI,KAAK,EAChB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,EAC/D,MAAM,EAAE,CAAC,GACR,WAAW,CAAC;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CAAE,CAAC,CAQ7F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAepF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,WAAW,CAAC,CAAC,qCAM5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,IAAI,EAAE,WAAW,CAAC,IAAI,CAGlC,CAAA"}
+{"version":3,"file":"Equivalence.d.ts","sourceRoot":"","sources":["../src/Equivalence.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,MAAM,WAAW,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,CAAA;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,WAAW,qBAAsB,SAAQ,UAAU;IACvD,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAA;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,KAAG,WAAW,CAAC,CAAC,CACxC,CAAA;AAI3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,OAAO,WAAW,CAAC,CAAC,CAA4B,CAAA;AAE5E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,EAAE,WAAW,CAAC,MAAM,CAAsB,CAAA;AAE7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,EAAE,WAAW,CAAC,MAAM,CAEtC,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,OAAO,EAAE,WAAW,CAAC,OAAO,CAAsB,CAAA;AAE/D;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,EAAE,WAAW,CAAC,MAAM,CAAsB,CAAA;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,CAAA;IACnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;CACuD,CAAA;AAExH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,cAAc,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,CAAC,CAQ9E,CAAA;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2DG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,CAAA;IAChE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2DG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;CAI7D,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,KAAK,CAAC,KAAK,CAAC,QAAQ,SAAS,aAAa,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,EAC1E,QAAQ,EAAE,QAAQ,GACjB,WAAW,CAAC;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,QAAQ,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CAAE,CAAC,CAY3G;AAED;;GAEG;AACH,iBAAS,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAUtE;AACD,OAAO;AACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,IAAI,KAAK,EAChB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,EAC/D,MAAM,EAAE,CAAC,GACR,WAAW,CAAC;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CAAE,CAAC,CAQ7F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAepF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,WAAW,CAAC,CAAC,qCAM5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,IAAI,EAAE,WAAW,CAAC,IAAI,CAGlC,CAAA"}