effect 3.14.3 → 3.14.4

package/dist/esm/HashSet.js

@@ -33,14 +33,14 @@
  *
  * ## Performance Characteristics
  *
- * - **Lookup** operations ({@linkcode HashSet.has}): **`O(1)`** average time
+ * - **Lookup** operations ({@link module:HashSet.has}): **`O(1)`** average time
  *   complexity
- * - **Insertion** operations ({@linkcode HashSet.add}): **`O(1)`** average time
+ * - **Insertion** operations ({@link module:HashSet.add}): **`O(1)`** average time
  *   complexity
- * - **Removal** operations ({@linkcode HashSet.remove}): **`O(1)`** average time
- *   complexity
- * - **Set** operations ({@linkcode HashSet.union},
- *   {@linkcode HashSet.intersection}): **`O(n)`** where n is the size of the
+ * - **Removal** operations ({@link module:HashSet.remove}): **`O(1)`** average
+ *   time complexity
+ * - **Set** operations ({@link module:HashSet.union},
+ *   {@link module:HashSet.intersection}): **`O(n)`** where n is the size of the
  *   smaller set
  * - **Iteration**: **`O(n)`** where n is the size of the set
  *
@@ -53,40 +53,40 @@
  *
  * ## Operations Reference
  *
- * | Category     | Operation                        | Description                                 | Complexity |
- * | ------------ | -------------------------------- | ------------------------------------------- | ---------- |
- * | constructors | {@linkcode HashSet.empty}        | Creates an empty HashSet                    | O(1)       |
- * | constructors | {@linkcode HashSet.fromIterable} | Creates a HashSet from an iterable          | O(n)       |
- * | constructors | {@linkcode HashSet.make}         | Creates a HashSet from multiple values      | O(n)       |
- * |              |                                  |                                             |            |
- * | elements     | {@linkcode HashSet.has}          | Checks if a value exists in the set         | O(1) avg   |
- * | elements     | {@linkcode HashSet.some}         | Checks if any element satisfies a predicate | O(n)       |
- * | elements     | {@linkcode HashSet.every}        | Checks if all elements satisfy a predicate  | O(n)       |
- * | elements     | {@linkcode HashSet.isSubset}     | Checks if a set is a subset of another      | O(n)       |
- * |              |                                  |                                             |            |
- * | getters      | {@linkcode HashSet.values}       | Gets an iterator of all values              | O(1)       |
- * | getters      | {@linkcode HashSet.toValues}     | Gets an array of all values                 | O(n)       |
- * | getters      | {@linkcode HashSet.size}         | Gets the number of elements                 | O(1)       |
- * |              |                                  |                                             |            |
- * | mutations    | {@linkcode HashSet.add}          | Adds a value to the set                     | O(1) avg   |
- * | mutations    | {@linkcode HashSet.remove}       | Removes a value from the set                | O(1) avg   |
- * | mutations    | {@linkcode HashSet.toggle}       | Toggles a value's presence                  | O(1) avg   |
- * |              |                                  |                                             |            |
- * | operations   | {@linkcode HashSet.difference}   | Computes set difference (A - B)             | O(n)       |
- * | operations   | {@linkcode HashSet.intersection} | Computes set intersection (A ∩ B)           | O(n)       |
- * | operations   | {@linkcode HashSet.union}        | Computes set union (A ∪ B)                  | O(n)       |
- * |              |                                  |                                             |            |
- * | mapping      | {@linkcode HashSet.map}          | Transforms each element                     | O(n)       |
- * |              |                                  |                                             |            |
- * | sequencing   | {@linkcode HashSet.flatMap}      | Transforms and flattens elements            | O(n)       |
- * |              |                                  |                                             |            |
- * | traversing   | {@linkcode HashSet.forEach}      | Applies a function to each element          | O(n)       |
- * |              |                                  |                                             |            |
- * | folding      | {@linkcode HashSet.reduce}       | Reduces the set to a single value           | O(n)       |
- * |              |                                  |                                             |            |
- * | filtering    | {@linkcode HashSet.filter}       | Keeps elements that satisfy a predicate     | O(n)       |
- * |              |                                  |                                             |            |
- * | partitioning | {@linkcode HashSet.partition}    | Splits into two sets by a predicate         | O(n)       |
+ * | Category     | Operation                           | Description                                 | Complexity |
+ * | ------------ | ----------------------------------- | ------------------------------------------- | ---------- |
+ * | constructors | {@link module:HashSet.empty}        | Creates an empty HashSet                    | O(1)       |
+ * | constructors | {@link module:HashSet.fromIterable} | Creates a HashSet from an iterable          | O(n)       |
+ * | constructors | {@link module:HashSet.make}         | Creates a HashSet from multiple values      | O(n)       |
+ * |              |                                     |                                             |            |
+ * | elements     | {@link module:HashSet.has}          | Checks if a value exists in the set         | O(1) avg   |
+ * | elements     | {@link module:HashSet.some}         | Checks if any element satisfies a predicate | O(n)       |
+ * | elements     | {@link module:HashSet.every}        | Checks if all elements satisfy a predicate  | O(n)       |
+ * | elements     | {@link module:HashSet.isSubset}     | Checks if a set is a subset of another      | O(n)       |
+ * |              |                                     |                                             |            |
+ * | getters      | {@link module:HashSet.values}       | Gets an iterator of all values              | O(1)       |
+ * | getters      | {@link module:HashSet.toValues}     | Gets an array of all values                 | O(n)       |
+ * | getters      | {@link module:HashSet.size}         | Gets the number of elements                 | O(1)       |
+ * |              |                                     |                                             |            |
+ * | mutations    | {@link module:HashSet.add}          | Adds a value to the set                     | O(1) avg   |
+ * | mutations    | {@link module:HashSet.remove}       | Removes a value from the set                | O(1) avg   |
+ * | mutations    | {@link module:HashSet.toggle}       | Toggles a value's presence                  | O(1) avg   |
+ * |              |                                     |                                             |            |
+ * | operations   | {@link module:HashSet.difference}   | Computes set difference (A - B)             | O(n)       |
+ * | operations   | {@link module:HashSet.intersection} | Computes set intersection (A ∩ B)           | O(n)       |
+ * | operations   | {@link module:HashSet.union}        | Computes set union (A ∪ B)                  | O(n)       |
+ * |              |                                     |                                             |            |
+ * | mapping      | {@link module:HashSet.map}          | Transforms each element                     | O(n)       |
+ * |              |                                     |                                             |            |
+ * | sequencing   | {@link module:HashSet.flatMap}      | Transforms and flattens elements            | O(n)       |
+ * |              |                                     |                                             |            |
+ * | traversing   | {@link module:HashSet.forEach}      | Applies a function to each element          | O(n)       |
+ * |              |                                     |                                             |            |
+ * | folding      | {@link module:HashSet.reduce}       | Reduces the set to a single value           | O(n)       |
+ * |              |                                     |                                             |            |
+ * | filtering    | {@link module:HashSet.filter}       | Keeps elements that satisfy a predicate     | O(n)       |
+ * |              |                                     |                                             |            |
+ * | partitioning | {@link module:HashSet.partition}    | Splits into two sets by a predicate         | O(n)       |
  *
  * ## Notes
  *
@@ -284,7 +284,7 @@ export const isHashSet = HS.isHashSet;
  * ) // Output: [1, 2]
  * ```
  *
- * @see Other `HashSet` constructors are {@link make} {@link fromIterable}
+ * @see Other `HashSet` constructors are {@link module:HashSet.make} {@link module:HashSet.fromIterable}
  */
 export const empty = HS.empty;
 /**
@@ -295,9 +295,10 @@ export const empty = HS.empty;
  * @memberof HashSet
  * @since 2.0.0
  * @category constructors
- * @example Creating a HashSet from an {@link Array}
+ * @example
  *
  * ```ts
+ * // Creating a HashSet from an Array
  * import { HashSet, pipe } from "effect"
  *
  * console.log(
@@ -309,9 +310,10 @@ export const empty = HS.empty;
  * ) // Output: [1, 2, 3, 4, 5]
  * ```
  *
- * @example Creating a HashSet from a {@link Set}
+ * @example
  *
  * ```ts
+ * // Creating a HashSet from a Set
  * import { HashSet, pipe } from "effect"
  *
  * console.log(
@@ -323,9 +325,10 @@ export const empty = HS.empty;
  * ) // Output: ["apple", "banana", "orange"]
  * ```
  *
- * @example Creating a HashSet from a {@link Generator}
+ * @example
  *
  * ```ts
+ * // Creating a HashSet from a Generator
  * import { HashSet } from "effect"
  *
  * // Generator functions return iterables
@@ -344,9 +347,10 @@ export const empty = HS.empty;
  * // Outputs: [0, 1, 2, 3, 5, 8, 13, 21, 34] but in unsorted order
  * ```
  *
- * @example Creating a HashSet from another {@link HashSet}
+ * @example
  *
  * ```ts
+ * //  Creating a HashSet from another HashSet
  * import { HashSet, pipe } from "effect"
  *
  * console.log(
@@ -359,10 +363,10 @@ export const empty = HS.empty;
  * ) // Output: [1, 2, 3, 4]
  * ```
  *
- * @example Creating a HashSet from other Effect's data structures like
- * {@link Chunk}
+ * @example
  *
  * ```ts
+ * // Creating a HashSet from other Effect's data structures like Chunk
  * import { Chunk, HashSet, pipe } from "effect"
  *
  * console.log(
@@ -374,7 +378,7 @@ export const empty = HS.empty;
  * ) // Outputs: [1, 2, 3, 4]
  * ```
  *
- * @see Other `HashSet` constructors are {@link empty} {@link make}
+ * @see Other `HashSet` constructors are {@link module:HashSet.empty} {@link module:HashSet.make}
  */
 export const fromIterable = HS.fromIterable;
 /**
@@ -462,7 +466,7 @@ export const fromIterable = HS.fromIterable;
  * )
  * ```
  *
- * @see Other `HashSet` constructors are {@linkcode fromIterable} {@linkcode empty}
+ * @see Other `HashSet` constructors are {@link module:HashSet.fromIterable} {@link module:HashSet.empty}
  */
 export const make = HS.make;
 /**
@@ -473,9 +477,10 @@ export const make = HS.make;
  * @memberof HashSet
  * @since 2.0.0
  * @category elements
- * @example **syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * // with `data-last`, a.k.a. `pipeable` API
@@ -489,7 +494,7 @@ export const make = HS.make;
  * ```
  *
  * @returns A `boolean` signaling the presence of the value in the HashSet
- * @see Other `HashSet` elements are {@link some} {@link every} {@link isSubset}
+ * @see Other `HashSet` elements are {@link module:HashSet.some} {@link module:HashSet.every} {@link module:HashSet.isSubset}
  */
 export const has = HS.has;
 /**
@@ -500,9 +505,10 @@ export const has = HS.has;
  * @memberof HashSet
  * @since 2.0.0
  * @category elements
- * @example **syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * const set: HashSet.HashSet<number> = HashSet.make(0, 1, 2)
@@ -520,7 +526,7 @@ export const has = HS.has;
  * HashSet.some(set, (n) => n > 0) // true
  * ```
  *
- * @see Other `HashSet` elements are {@link has} {@link every} {@link isSubset}
+ * @see Other `HashSet` elements are {@link module:HashSet.has} {@link module:HashSet.every} {@link module:HashSet.isSubset}
  */
 export const some = HS.some;
 /**
@@ -532,9 +538,10 @@ export const some = HS.some;
  * @memberof HashSet
  * @since 2.0.0
  * @category elements
- * @example **syntax** with {@link Refinement}
+ * @example
  *
  * ```ts
+ * // Syntax with Refinement
  * import { HashSet, pipe, Predicate } from "effect"
  *
  * const numberOrString = HashSet.make(1, "1", "one", "uno")
@@ -556,9 +563,10 @@ export const some = HS.some;
  * ) // HashSet.HashSet<string>
  * ```
  *
- * @example **syntax** with {@link Predicate}
+ * @example
  *
  * ```ts
+ * // Syntax with Predicate
  * import { HashSet, pipe } from "effect"
  *
  * const set = HashSet.make(1, 2, 3)
@@ -578,7 +586,7 @@ export const some = HS.some;
  *
  * @returns A boolean once it has evaluated that whole collection fulfill the
  *   Predicate function
- * @see Other `HashSet` elements are {@link has} {@link some} {@link isSubset}
+ * @see Other `HashSet` elements are {@link module:HashSet.has} {@link module:HashSet.some} {@link module:HashSet.isSubset}
  */
 export const every = HS.every;
 /**
@@ -592,9 +600,10 @@ export const every = HS.every;
  * @memberof HashSet
  * @since 2.0.0
  * @category elements
- * @example **Syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * const set1 = HashSet.make(0, 1)
@@ -614,7 +623,7 @@ export const every = HS.every;
  * HashSet.isSubset(set1, set3) // true)
  * ```
  *
- * @see Other `HashSet` elements are {@link has} {@link some} {@link every}
+ * @see Other `HashSet` elements are {@link module:HashSet.has} {@link module:HashSet.some} {@link module:HashSet.every}
  */
 export const isSubset = HS.isSubset;
 /**
@@ -640,7 +649,7 @@ export const isSubset = HS.isSubset;
  * }
  * ```
  *
- * @see Other `HashSet` getters are {@link toValues} {@link size}
+ * @see Other `HashSet` getters are {@link module:HashSet.toValues} {@link module:HashSet.size}
  */
 export const values = HS.values;
 /**
@@ -666,7 +675,7 @@ export const values = HS.values;
  * )
  * ```
  *
- * @see Other `HashSet` getters are {@link values} {@link size}
+ * @see Other `HashSet` getters are {@link module:HashSet.values} {@link module:HashSet.size}
  */
 export const toValues = self => Array.from(values(self));
 /**
@@ -691,7 +700,7 @@ export const toValues = self => Array.from(values(self));
  * )
  * ```
  *
- * @see Other `HashSet` getters are {@link values} {@link toValues}
+ * @see Other `HashSet` getters are {@link module:HashSet.values} {@link module:HashSet.toValues}
  */
 export const size = HS.size;
 /**
@@ -738,7 +747,7 @@ export const size = HS.size;
  * console.log(HashSet.toValues(mutableSet).sort((a, b) => a - b)) // [0, 1, 2, 3, ...rest]
  * ```
  *
- * @see Other `HashSet` mutations are {@link add} {@link remove} {@link toggle} {@link endMutation} {@link mutate}
+ * @see Other `HashSet` mutations are {@link module:HashSet.add} {@link module:HashSet.remove} {@link module:HashSet.toggle} {@link module:HashSet.endMutation} {@link module:HashSet.mutate}
  */
 export const beginMutation = HS.beginMutation;
 /**
@@ -785,21 +794,22 @@ export const beginMutation = HS.beginMutation;
  * assert.deepStrictEqual(HashSet.toValues(newSet).sort(), [1, 2, 3, 4])
  * ```
  *
- * @see Other `HashSet` mutations are {@linkcode HashSet.add} {@linkcode HashSet.remove} {@linkcode HashSet.toggle} {@linkcode HashSet.beginMutation} {@linkcode HashSet.mutate}
+ * @see Other `HashSet` mutations are {@link module:HashSet.add} {@link module:HashSet.remove} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.mutate}
  */
 export const endMutation = HS.endMutation;
 /**
  * Mutates the `HashSet` within the context of the provided function.
  *
  * You can consider it a functional abstraction on top of the lower-level
- * mutation primitives of {@linkcode HashSet.beginMutation} `->` `mutable
- * context` `->` {@linkcode HashSet.endMutation}.
+ * mutation primitives of {@link module:HashSet.beginMutation} `->` `mutable
+ * context` `->` {@link HashSet.endMutation}.
  *
  * @memberof HashSet
  * @since 2.0.0
- * @example **Syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * // with data-last, a.k.a. pipeable API
@@ -826,7 +836,7 @@ export const endMutation = HS.endMutation;
  * })
  * ```
  *
- * @see Other `HashSet` mutations are {@linkcode HashSet.add} {@linkcode HashSet.remove} {@linkcode HashSet.toggle} {@linkcode HashSet.beginMutation} {@linkcode HashSet.endMutation}
+ * @see Other `HashSet` mutations are {@link module:HashSet.add} {@link module:HashSet.remove} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation}
  */
 export const mutate = HS.mutate;
 /**
@@ -843,9 +853,10 @@ export const mutate = HS.mutate;
  * with the added value.
  * @memberof HashSet
  * @since 2.0.0
- * @example **Syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * // with data-last, a.k.a. pipeable API
@@ -858,7 +869,7 @@ export const mutate = HS.mutate;
  * HashSet.add(HashSet.empty(), 0)
  * ```
  *
- * @see Other `HashSet` mutations are {@link remove} {@link toggle} {@link beginMutation} {@link endMutation} {@link mutate}
+ * @see Other `HashSet` mutations are {@link module:HashSet.remove} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation} {@link module:HashSet.mutate}
  */
 export const add = HS.add;
 /**
@@ -868,9 +879,10 @@ export const add = HS.add;
  *
  * @memberof HashSet
  * @since 2.0.0
- * @example **Syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * // with `data-last`, a.k.a. `pipeable` API
@@ -883,7 +895,7 @@ export const add = HS.add;
  * HashSet.remove(HashSet.make(0, 1, 2), 0)
  * ```
  *
- * @see Other `HashSet` mutations are {@link add} {@link toggle} {@link beginMutation} {@link endMutation} {@link mutate}
+ * @see Other `HashSet` mutations are {@link module:HashSet.add} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation} {@link module:HashSet.mutate}
  */
 export const remove = HS.remove;
 /**
@@ -899,9 +911,10 @@ export const remove = HS.remove;
  *
  * @memberof HashSet
  * @since 2.0.0
- * @example **Syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * // with data-last, a.k.a. pipeable API
@@ -914,7 +927,7 @@ export const remove = HS.remove;
  * HashSet.difference(HashSet.make(1, 2, 3), HashSet.make(3, 4, 5))
  * ```
  *
- * @see Other `HashSet` operations are {@link intersection} {@link union}
+ * @see Other `HashSet` operations are {@link module:HashSet.intersection} {@link module:HashSet.union}
  */
 export const difference = HS.difference;
 /**
@@ -929,9 +942,10 @@ export const difference = HS.difference;
  *
  * @memberof HashSet
  * @since 2.0.0
- * @example **Syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * // with data-last, a.k.a. pipeable API
@@ -944,7 +958,7 @@ export const difference = HS.difference;
  * HashSet.intersection(HashSet.make(1, 2, 3), HashSet.make(2, 3, 4))
  * ```
  *
- * @see Other `HashSet` operations are {@link difference} {@link union}
+ * @see Other `HashSet` operations are {@link module:HashSet.difference} {@link module:HashSet.union}
  */
 export const intersection = HS.intersection;
 /**
@@ -958,9 +972,10 @@ export const intersection = HS.intersection;
  *
  * @memberof HashSet
  * @since 2.0.0
- * @example **Syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * // with data-last, a.k.a. pipeable API
@@ -973,7 +988,7 @@ export const intersection = HS.intersection;
  * HashSet.union(HashSet.make(1, 2, 3), HashSet.make(3, 4, 5))
  * ```
  *
- * @see Other `HashSet` operations are {@link difference} {@link intersection}
+ * @see Other `HashSet` operations are {@link module:HashSet.difference} {@link module:HashSet.intersection}
  */
 export const union = HS.union;
 /**
@@ -985,9 +1000,10 @@ export const union = HS.union;
  *
  * @memberof HashSet
  * @since 2.0.0
- * @example **Syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * // with `data-last`, a.k.a. `pipeable` API
@@ -1002,7 +1018,7 @@ export const union = HS.union;
  *
  * @returns A new `HashSet` where the toggled value is being either added or
  *   removed based on the initial `HashSet` state.
- * @see Other `HashSet` mutations are {@link add} {@link remove} {@link beginMutation} {@link endMutation} {@link mutate}
+ * @see Other `HashSet` mutations are {@link module:HashSet.add} {@link module:HashSet.remove} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation} {@link module:HashSet.mutate}
  */
 export const toggle = HS.toggle;
 /**
@@ -1013,9 +1029,10 @@ export const toggle = HS.toggle;
  * @memberof HashSet
  * @since 2.0.0
  * @category mapping
- * @example **Syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * // with `data-last`, a.k.a. `pipeable` API
@@ -1040,9 +1057,10 @@ export const map = HS.map;
  * @memberof HashSet
  * @since 2.0.0
  * @category sequencing
- * @example **Syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * // with `data-last`, a.k.a. `pipeable` API
@@ -1070,9 +1088,10 @@ export const flatMap = HS.flatMap;
  * @memberof HashSet
  * @since 2.0.0
  * @category traversing
- * @example **Syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * // with `data-last`, a.k.a. `pipeable` API
@@ -1094,9 +1113,10 @@ export const forEach = HS.forEach;
  * @memberof HashSet
  * @since 2.0.0
  * @category folding
- * @example **Syntax**
+ * @example
  *
  * ```ts
+ * // Syntax
  * import { HashSet, pipe } from "effect"
  *
  * const sum = (a: number, b: number): number => a + b
@@ -1120,9 +1140,10 @@ export const reduce = HS.reduce;
  * @memberof HashSet
  * @since 2.0.0
  * @category filtering
- * @example **Syntax** with {@link Predicate}
+ * @example
  *
  * ```ts
+ * // Syntax with  Predicate
  * import { HashSet, type Predicate, pipe } from "effect"
  *
  * const filterPositiveNumbers: Predicate.Predicate<number> = (n) => n > 0
@@ -1140,9 +1161,10 @@ export const reduce = HS.reduce;
  * HashSet.filter(HashSet.make(-2, -1, 0, 1, 2), filterPositiveNumbers)
  * ```
  *
- * @example **Syntax** with {@link Refinement}
+ * @example
  *
  * ```ts
+ * /// Syntax with Refinement
  * import { HashSet, pipe } from "effect"
  *
  * const stringRefinement = (value: unknown): value is string =>
@@ -1178,9 +1200,10 @@ export const filter = HS.filter;
  * @memberof HashSet
  * @since 2.0.0
  * @category partitioning
- * @example **Syntax** with {@link Predicate}
+ * @example
  *
  * ```ts
+ * // Syntax with Predicate
  * import { HashSet, pipe, Predicate } from "effect"
  *
  * // with `data-last`, a.k.a. `pipeable` API
@@ -1198,9 +1221,10 @@ export const filter = HS.filter;
  * HashSet.partition(HashSet.make(0, 1, 2, 3, 4, 5), (n) => n % 2 === 0)
  * ```
  *
- * @example **Syntax** with {@link Refinement}
+ * @example
  *
  * ```ts
+ * // Syntax with Refinement
  * import { HashSet, pipe, Predicate } from "effect"
  *
  * const stringRefinement: Predicate.Refinement<string | number, string> = (

package/dist/esm/HashSet.js.map

@@ -1 +1 @@
-{"version":3,"file":"HashSet.js","names":["HS","TypeId","HashSetTypeId","isHashSet","empty","fromIterable","make","has","some","every","isSubset","values","toValues","self","Array","from","size","beginMutation","endMutation","mutate","add","remove","difference","intersection","union","toggle","map","flatMap","forEach","reduce","filter","partition"],"sources":["../../src/HashSet.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"HashSet.js","names":["HS","TypeId","HashSetTypeId","isHashSet","empty","fromIterable","make","has","some","every","isSubset","values","toValues","self","Array","from","size","beginMutation","endMutation","mutate","add","remove","difference","intersection","union","toggle","map","flatMap","forEach","reduce","filter","partition"],"sources":["../../src/HashSet.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}