ts-data-forge 8.0.0 → 9.0.1

package/dist/collections/iset.mjs

@@ -37,333 +37,167 @@ import '../number/refined-number-utils.mjs';
 import '@sindresorhus/is';
 import { unknownToString } from '../others/unknown-to-string.mjs';
 
-/** Provides utility functions for ISet. */
 var ISet;
-(function (ISet) {
-    /**
-     * Creates a new ISet instance from an iterable of elements.
-     *
-     * This factory function accepts any iterable of elements, including arrays,
-     * JavaScript Sets, other ISets, or custom iterables. Duplicate elements in
-     * the input iterable will be automatically deduplicated in the resulting
-     * set.
-     *
-     * **Performance:** O(n) where n is the number of elements in the iterable.
-     *
-     * @example
-     *
-     * ```ts
-     * const set = ISet.create(['a', 'a', 'b']);
-     *
-     * assert.deepStrictEqual(Array.from(set), ['a', 'b']);
-     * ```
-     *
-     * @template K The type of the elements. Must extend MapSetKeyType.
-     * @param iterable An iterable of elements (e.g., Array, Set, ISet, etc.)
-     * @returns A new ISet instance containing all unique elements from the
-     *   iterable.
-     */
-    ISet.create = (iterable) => new ISetClass(iterable);
-    /**
-     * Checks if two ISet instances are structurally equal.
-     *
-     * Two ISets are considered equal if they have the same size and contain
-     * exactly the same elements. The order of elements does not matter for
-     * equality comparison since sets are unordered collections. Elements are
-     * compared using JavaScript's `===` operator.
-     *
-     * **Performance:** O(n) where n is the size of the smaller set.
-     *
-     * @example
-     *
-     * ```ts
-     * const first = ISet.create<number>([1, 2]);
-     *
-     * const second = ISet.create<number>([2, 1]);
-     *
-     * const third = ISet.create<number>([1, 3]);
-     *
-     * assert.isTrue(ISet.equal(first, second));
-     *
-     * assert.isFalse(ISet.equal(first, third));
-     * ```
-     *
-     * @template K The type of the elements.
-     * @param a The first ISet instance to compare.
-     * @param b The second ISet instance to compare.
-     * @returns `true` if the sets contain exactly the same elements, `false`
-     *   otherwise.
-     */
-    ISet.equal = (a, b) => a.size === b.size && a.every((e) => b.has(e));
-    /**
-     * Computes the difference between two ISet instances, identifying added and
-     * deleted elements.
-     *
-     * This function performs a set difference operation to determine what
-     * elements were added and what elements were deleted when transitioning from
-     * the old set to the new set. This is useful for change detection, state
-     * management, and synchronization scenarios.
-     *
-     * **Performance:** O(n + m) where n and m are the sizes of the old and new
-     * sets respectively.
-     *
-     * @example
-     *
-     * ```ts
-     * const previous = ISet.create<string>(['draft', 'review']);
-     *
-     * const current = ISet.create<string>(['review', 'published']);
-     *
-     * const { added, deleted } = ISet.diff(previous, current);
-     *
-     * assert.deepStrictEqual(Array.from(added), ['published']);
-     *
-     * assert.deepStrictEqual(Array.from(deleted), ['draft']);
-     * ```
-     *
-     * @template K The type of the elements.
-     * @param oldSet The original set representing the previous state.
-     * @param newSet The new set representing the current state.
-     * @returns An object with `added` and `deleted` properties, each containing
-     *   an ISet of elements that were added or removed respectively.
-     */
-    ISet.diff = (oldSet, newSet) => ({
-        deleted: oldSet.subtract(newSet),
-        added: newSet.subtract(oldSet),
-    });
-    /**
-     * Computes the intersection of two ISet instances.
-     *
-     * Returns a new set containing only the elements that are present in both
-     * input sets. This operation is commutative: `intersection(a, b) ===
-     * intersection(b, a)`.
-     *
-     * **Performance:** O(min(n, m)) where n and m are the sizes of the input
-     * sets.
-     *
-     * @example
-     *
-     * ```ts
-     * const left = ISet.create<number>([1, 2, 3]);
-     *
-     * const right = ISet.create<number>([2, 4]);
-     *
-     * const overlap = ISet.intersection(left, right);
-     *
-     * assert.deepStrictEqual(Array.from(overlap), [2]);
-     * ```
-     *
-     * @template K The type of the elements.
-     * @param a The first set.
-     * @param b The second set.
-     * @returns A new ISet instance containing elements common to both sets.
-     */
-    ISet.intersection = (a, b) => a.intersect(b);
-    /**
-     * Computes the union of two ISet instances.
-     *
-     * Returns a new set containing all elements that are present in either input
-     * set. Duplicate elements are automatically handled since sets only contain
-     * unique values. This operation is commutative: `union(a, b) === union(b,
-     * a)`.
-     *
-     * **Performance:** O(n + m) where n and m are the sizes of the input sets.
-     *
-     * @example
-     *
-     * ```ts
-     * const numbers = ISet.create([1, 2]);
-     *
-     * const words = ISet.create(['one', 'two']);
-     *
-     * const union = ISet.union(numbers, words);
-     *
-     * assert.deepStrictEqual(Array.from(union), [1, 2, 'one', 'two']);
-     * ```
-     *
-     * @template K1 The type of elements in the first set.
-     * @template K2 The type of elements in the second set.
-     * @param a The first set.
-     * @param b The second set.
-     * @returns A new ISet instance containing all elements from both sets.
-     */
-    ISet.union = (a, b) => a.union(b);
+((ISet2) => {
+  ISet2.create = (iterable) => new ISetClass(iterable);
+  ISet2.equal = (a, b) => a.size === b.size && a.every((e) => b.has(e));
+  ISet2.diff = (oldSet, newSet) => ({
+    deleted: oldSet.subtract(newSet),
+    added: newSet.subtract(oldSet)
+  });
+  ISet2.intersection = (a, b) => a.intersect(b);
+  ISet2.union = (a, b) => a.union(b);
 })(ISet || (ISet = {}));
-/**
- * Internal class implementation for ISet providing immutable set operations.
- *
- * This class implements the ISet interface using JavaScript's native Set as the
- * underlying storage mechanism for optimal performance. All mutation operations
- * create new instances rather than modifying the existing set, ensuring
- * immutability.
- *
- * **Implementation Details:**
- *
- * - Uses ReadonlySet<K> internally for type safety and performance
- * - Implements copy-on-write semantics for efficiency
- * - Provides optional debug messaging for development
- *
- * @template K The type of the elements. Must extend MapSetKeyType.
- * @implements ISet
- * @implements Iterable
- * @internal This class should not be used directly. Use ISet.create() instead.
- */
 class ISetClass {
-    #set;
-    #showNotFoundMessage;
-    /**
-     * Constructs an ISetClass instance with the given elements.
-     *
-     * @param iterable An iterable of elements to populate the set.
-     * @param showNotFoundMessage Whether to log warning messages when operations
-     *   are performed on non-existent elements. Useful for debugging. Defaults to
-     *   false for production use.
-     * @internal Use ISet.create() instead of calling this constructor directly.
-     */
-    constructor(iterable, showNotFoundMessage = false) {
-        this.#set = new Set(iterable);
-        this.#showNotFoundMessage = showNotFoundMessage;
-    }
-    /** @inheritdoc */
-    get size() {
-        return asUint32(this.#set.size);
-    }
-    /** @inheritdoc */
-    get isEmpty() {
-        return this.size === 0;
-    }
-    /** @inheritdoc */
-    has(key) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        return this.#set.has(key);
-    }
-    /** @inheritdoc */
-    every(predicate) {
-        for (const key of this.values()) {
-            if (!predicate(key))
-                return false;
-        }
-        return true;
-    }
-    /** @inheritdoc */
-    some(predicate) {
-        for (const key of this.values()) {
-            if (predicate(key))
-                return true;
-        }
-        return false;
-    }
-    /** @inheritdoc */
-    add(key) {
-        if (this.has(key))
-            return this;
-        return ISet.create([...this.#set, key]);
-    }
-    /** @inheritdoc */
-    delete(key) {
-        if (!this.has(key)) {
-            if (this.#showNotFoundMessage) {
-                const keyStr = unknownToString(key);
-                console.warn(`ISet.delete: key not found: ${keyStr}`);
-            }
-            return this;
-        }
-        return ISet.create(Array.from(this.#set).filter((k) => !Object.is(k, key)));
-    }
-    /** @inheritdoc */
-    withMutations(actions) {
-        const mut_result = new Set(this.#set);
-        const updateFn = (action) => {
-            switch (action.type) {
-                case 'delete':
-                    mut_result.delete(action.key);
-                    break;
-                case 'add':
-                    mut_result.add(action.key);
-                    break;
-            }
-        };
-        for (const action of actions) {
-            updateFn(action);
-        }
-        return ISet.create(mut_result);
-    }
-    /** @inheritdoc */
-    map(mapFn) {
-        return ISet.create(this.toArray().map(mapFn));
-    }
-    /** @inheritdoc */
-    filter(predicate) {
-        return ISet.create(this.toArray().filter(predicate));
-    }
-    /** @inheritdoc */
-    filterNot(predicate) {
-        return ISet.create(this.toArray().filter((e) => !predicate(e)));
-    }
-    /** @inheritdoc */
-    forEach(callbackfn) {
-        for (const v of this.#set) {
-            callbackfn(v);
-        }
-    }
-    /** @inheritdoc */
-    isSubsetOf(set) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        return this.every((k) => set.has(k));
-    }
-    /** @inheritdoc */
-    isSupersetOf(set) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        return set.every((k) => this.has(k));
-    }
-    /** @inheritdoc */
-    subtract(set) {
-        return ISet.create(this.toArray().filter((k) => !set.has(k)));
-    }
-    /** @inheritdoc */
-    intersect(set) {
-        return ISet.create(this.toArray().filter((k) => set.has(k)));
-    }
-    /** @inheritdoc */
-    union(set) {
-        return ISet.create([...this, ...set]);
-    }
-    /**
-     * @example
-     *
-     * ```ts
-     * const set = ISet.create(['first', 'second']);
-     *
-     * const collected = Array.from(set);
-     *
-     * assert.deepStrictEqual(collected, ['first', 'second']);
-     * ```
-     *
-     * @inheritdoc
-     */
-    [Symbol.iterator]() {
-        return this.#set[Symbol.iterator]();
-    }
-    /** @inheritdoc */
-    keys() {
-        return this.#set.keys();
-    }
-    /** @inheritdoc */
-    values() {
-        return this.#set.values();
-    }
-    /** @inheritdoc */
-    entries() {
-        return this.#set.entries();
-    }
-    /** @inheritdoc */
-    toArray() {
-        return Array.from(this.values());
-    }
-    /** @inheritdoc */
-    toRawSet() {
-        return this.#set;
-    }
+  #set;
+  #showNotFoundMessage;
+  /**
+   * Constructs an ISetClass instance with the given elements.
+   *
+   * @param iterable An iterable of elements to populate the set.
+   * @param showNotFoundMessage Whether to log warning messages when operations
+   *   are performed on non-existent elements. Useful for debugging. Defaults to
+   *   false for production use.
+   * @internal Use ISet.create() instead of calling this constructor directly.
+   */
+  constructor(iterable, showNotFoundMessage = false) {
+    this.#set = new Set(iterable);
+    this.#showNotFoundMessage = showNotFoundMessage;
+  }
+  /** @inheritdoc */
+  get size() {
+    return asUint32(this.#set.size);
+  }
+  /** @inheritdoc */
+  get isEmpty() {
+    return this.size === 0;
+  }
+  /** @inheritdoc */
+  has(key) {
+    return this.#set.has(key);
+  }
+  /** @inheritdoc */
+  every(predicate) {
+    for (const key of this.values()) {
+      if (!predicate(key)) return false;
+    }
+    return true;
+  }
+  /** @inheritdoc */
+  some(predicate) {
+    for (const key of this.values()) {
+      if (predicate(key)) return true;
+    }
+    return false;
+  }
+  /** @inheritdoc */
+  add(key) {
+    if (this.has(key)) return this;
+    return ISet.create([...this.#set, key]);
+  }
+  /** @inheritdoc */
+  delete(key) {
+    if (!this.has(key)) {
+      if (this.#showNotFoundMessage) {
+        const keyStr = unknownToString(key);
+        console.warn(`ISet.delete: key not found: ${keyStr}`);
+      }
+      return this;
+    }
+    return ISet.create(Array.from(this.#set).filter((k) => !Object.is(k, key)));
+  }
+  /** @inheritdoc */
+  withMutations(actions) {
+    const mut_result = new Set(this.#set);
+    const updateFn = (action) => {
+      switch (action.type) {
+        case "delete":
+          mut_result.delete(action.key);
+          break;
+        case "add":
+          mut_result.add(action.key);
+          break;
+      }
+    };
+    for (const action of actions) {
+      updateFn(action);
+    }
+    return ISet.create(mut_result);
+  }
+  /** @inheritdoc */
+  map(mapFn) {
+    return ISet.create(this.toArray().map(mapFn));
+  }
+  /** @inheritdoc */
+  filter(predicate) {
+    return ISet.create(this.toArray().filter(predicate));
+  }
+  /** @inheritdoc */
+  filterNot(predicate) {
+    return ISet.create(this.toArray().filter((e) => !predicate(e)));
+  }
+  /** @inheritdoc */
+  forEach(callbackfn) {
+    for (const v of this.#set) {
+      callbackfn(v);
+    }
+  }
+  /** @inheritdoc */
+  isSubsetOf(set) {
+    return this.every((k) => set.has(k));
+  }
+  /** @inheritdoc */
+  isSupersetOf(set) {
+    return set.every((k) => this.has(k));
+  }
+  /** @inheritdoc */
+  subtract(set) {
+    return ISet.create(this.toArray().filter((k) => !set.has(k)));
+  }
+  /** @inheritdoc */
+  intersect(set) {
+    return ISet.create(this.toArray().filter((k) => set.has(k)));
+  }
+  /** @inheritdoc */
+  union(set) {
+    return ISet.create([...this, ...set]);
+  }
+  /**
+   * @example
+   *
+   * ```ts
+   * const set = ISet.create(['first', 'second']);
+   *
+   * const collected = Array.from(set);
+   *
+   * assert.deepStrictEqual(collected, ['first', 'second']);
+   * ```
+   *
+   * @inheritdoc
+   */
+  [Symbol.iterator]() {
+    return this.#set[Symbol.iterator]();
+  }
+  /** @inheritdoc */
+  keys() {
+    return this.#set.keys();
+  }
+  /** @inheritdoc */
+  values() {
+    return this.#set.values();
+  }
+  /** @inheritdoc */
+  entries() {
+    return this.#set.entries();
+  }
+  /** @inheritdoc */
+  toArray() {
+    return Array.from(this.values());
+  }
+  /** @inheritdoc */
+  toRawSet() {
+    return this.#set;
+  }
 }
 
 export { ISet };

package/dist/collections/iset.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"iset.mjs","sources":["../../src/collections/iset.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"iset.mjs","sources":["../../src/collections/iset.mts"],"sourcesContent":["/* eslint-disable unicorn/prefer-iterator-to-array-at-end */\nimport { type ReadonlyRecord, type WidenLiteral } from 'ts-type-forge';\nimport { asUint32 } from '../number/index.mjs';\nimport { unknownToString } from '../others/index.mjs';\nimport { type MapSetKeyType, type SizeType } from '../types.mjs';\n\n/**\n * Interface for an immutable set with membership testing and set operation\n * support.\n *\n * This interface defines all methods and properties available on ISet\n * instances. All operations that modify the set return new ISet instances,\n * preserving immutability. The underlying implementation uses JavaScript's\n * native Set but creates copies on mutations to maintain immutability.\n *\n * **Immutability Guarantees:**\n *\n * - All mutation operations (add, delete) return new ISet instances\n * - Original ISet instances are never modified\n * - Safe for concurrent access and functional programming patterns\n *\n * **Performance Characteristics:**\n *\n * - has: O(1) average case\n * - add/delete: O(n) due to copying for immutability\n * - set operations (union, intersection, difference): O(n)\n * - map/filter operations: O(n)\n * - iteration: O(n)\n *\n * @template K The type of the elements in the set. Must extend MapSetKeyType\n *   (string, number, boolean, etc.)\n */\ntype ISetInterface<K extends MapSetKeyType> = Readonly<{\n  // Getting information\n\n  /**\n   * The number of elements in the set.\n   *\n   * @example\n   *\n   * ```ts\n   * const set = ISet.create([1, 2, 3]);\n   *\n   * assert.isTrue(set.size === 3);\n   * ```\n   */\n  size: SizeType.Arr;\n\n  /**\n   * Checks if the set is empty.\n   *\n   * @example\n   *\n   * ```ts\n   * const emptySet = ISet.create<number>([]);\n   *\n   * const filledSet = ISet.create([1, 2]);\n   *\n   * assert.isTrue(emptySet.isEmpty);\n   *\n   * assert.isFalse(filledSet.isEmpty);\n   * ```\n   */\n  isEmpty: boolean;\n\n  /**\n   * Checks if an element exists in the set. Allows for wider literal types for\n   * keys during checking.\n   *\n   * @example\n   *\n   * ```ts\n   * const set = ISet.create(['apple', 'banana']);\n   *\n   * assert.isTrue(set.has('apple'));\n   *\n   * assert.isFalse(set.has('cherry'));\n   * ```\n   *\n   * @param key The element to check.\n   * @returns `true` if the element exists, `false` otherwise.\n   */\n  has: (key: K | (WidenLiteral<K> & {})) => boolean;\n\n  // Reducing a value\n\n  /**\n   * Checks if all elements in the set satisfy a predicate. Also supports a\n   * type predicate overload that narrows the type of elements in the set if\n   * the predicate returns true for all elements.\n   *\n   * @example\n   *\n   * ```ts\n   * const numbers = ISet.create([2, 4, 6]);\n   *\n   * const allEven = numbers.every((value) => value % 2 === 0);\n   *\n   * const narrowed = numbers.every(\n   *   (value): value is 2 | 4 | 6 => value % 2 === 0,\n   * );\n   *\n   * assert.isTrue(allEven);\n   *\n   * assert.isTrue(narrowed);\n   * ```\n   *\n   * @template L The narrowed type of the elements.\n   * @param predicate A function to test each element.\n   * @returns `true` if all elements satisfy the predicate, `false` otherwise.\n   */\n  every: ((predicate: (key: K) => boolean) => boolean) &\n    (<L extends K>(predicate: (key: K) => key is L) => this is ISet<L>);\n\n  /**\n   * Checks if at least one element in the set satisfies a predicate.\n   *\n   * @example\n   *\n   * ```ts\n   * const numbers = ISet.create([1, 3, 5]);\n   *\n   * assert.isTrue(numbers.some((value) => value > 4));\n   *\n   * assert.isFalse(numbers.some((value) => value > 10));\n   * ```\n   *\n   * @param predicate A function to test each element.\n   * @returns `true` if at least one element satisfies the predicate, `false`\n   *   otherwise.\n   */\n  some: (predicate: (key: K) => boolean) => boolean;\n\n  // Mutation\n\n  /**\n   * Adds an element to the set.\n   *\n   * @example\n   *\n   * ```ts\n   * const base = ISet.create<number>([1, 2]);\n   *\n   * const withThree = base.add(3);\n   *\n   * const unchanged = base.add(2);\n   *\n   * assert.deepStrictEqual(Array.from(withThree), [1, 2, 3]);\n   *\n   * assert.isTrue(unchanged === base);\n   * ```\n   *\n   * @param key The element to add.\n   * @returns A new ISet instance with the element added.\n   */\n  add: (key: K) => ISet<K>;\n\n  /**\n   * Deletes an element from the set.\n   *\n   * @example\n   *\n   * ```ts\n   * const base = ISet.create<number>([1, 2, 3]);\n   *\n   * const withoutTwo = base.delete(2);\n   *\n   * const unchanged = base.delete(4);\n   *\n   * assert.deepStrictEqual(Array.from(withoutTwo), [1, 3]);\n   *\n   * assert.isTrue(unchanged === base);\n   * ```\n   *\n   * @param key The element to delete.\n   * @returns A new ISet instance without the specified element.\n   */\n  delete: (key: K) => ISet<K>;\n\n  /**\n   * Applies a series of mutations to the set.\n   *\n   * @example\n   *\n   * ```ts\n   * const base = ISet.create<string>(['a', 'b']);\n   *\n   * const actions: readonly Readonly<\n   *   { type: 'add'; key: string } | { type: 'delete'; key: string }\n   * >[] = [\n   *   { type: 'add', key: 'c' },\n   *   { type: 'delete', key: 'a' },\n   * ] as const;\n   *\n   * const mutated = base.withMutations(actions);\n   *\n   * assert.deepStrictEqual(Array.from(mutated), ['b', 'c']);\n   *\n   * assert.deepStrictEqual(Array.from(base), ['a', 'b']);\n   * ```\n   *\n   * @param actions An array of mutation actions (add or delete).\n   * @returns A new ISet instance with all mutations applied.\n   */\n  withMutations: (\n    actions: readonly Readonly<\n      { type: 'add'; key: K } | { type: 'delete'; key: K }\n    >[],\n  ) => ISet<K>;\n\n  // Sequence algorithms\n\n  /**\n   * Maps the elements of the set to new elements.\n   *\n   * @example\n   *\n   * ```ts\n   * const letters = ISet.create(['a', 'b']);\n   *\n   * const upper = letters.map((value) => value.toUpperCase());\n   *\n   * assert.deepStrictEqual(Array.from(upper), ['A', 'B']);\n   * ```\n   *\n   * @template K2 The type of the new elements.\n   * @param mapFn A function that maps an element to a new element.\n   * @returns A new ISet instance with mapped elements.\n   */\n  map: <K2 extends MapSetKeyType>(mapFn: (key: K) => K2) => ISet<K2>;\n\n  /**\n   * Filters the elements of the set based on a predicate. Also supports a type\n   * predicate overload that narrows the type of elements in the resulting set.\n   *\n   * @example\n   *\n   * ```ts\n   * const letters = ISet.create(['apple', 'bee', 'cat']);\n   *\n   * const shortWords = letters.filter((value) => value.length <= 3);\n   *\n   * const narrowed = letters.filter(\n   *   (value): value is 'bee' | 'cat' => value.length === 3,\n   * );\n   *\n   * assert.deepStrictEqual(Array.from(shortWords), ['bee', 'cat']);\n   *\n   * assert.deepStrictEqual(Array.from(narrowed), ['bee', 'cat']);\n   * ```\n   *\n   * @template K2 The narrowed type of the elements.\n   * @param predicate A function to test each element.\n   * @returns A new ISet instance with elements that satisfy the predicate.\n   */\n  filter: (<K2 extends K>(predicate: (key: K) => key is K2) => ISet<K2>) &\n    ((predicate: (key: K) => boolean) => ISet<K>);\n\n  /**\n   * Filters the elements of the set by excluding elements for which the\n   * predicate returns true.\n   *\n   * @example\n   *\n   * ```ts\n   * const numbers = ISet.create([1, 2, 3, 4]);\n   *\n   * const withoutEven = numbers.filterNot((value) => value % 2 === 0);\n   *\n   * assert.deepStrictEqual(Array.from(withoutEven), [1, 3]);\n   * ```\n   *\n   * @param predicate A function to test each element.\n   * @returns A new ISet instance with elements for which the predicate returned\n   *   `false`.\n   */\n  filterNot: (predicate: (key: K) => boolean) => ISet<K>;\n\n  // Set operations\n\n  /**\n   * Checks if this set is a subset of another set.\n   *\n   * @example\n   *\n   * ```ts\n   * const subset = ISet.create<number>([1, 2]);\n   *\n   * const superset = ISet.create<number>([1, 2, 3]);\n   *\n   * assert.isTrue(subset.isSubsetOf(superset));\n   *\n   * assert.isFalse(superset.isSubsetOf(subset));\n   * ```\n   *\n   * @param set The other set.\n   * @returns `true` if this set is a subset of the other set, `false`\n   *   otherwise.\n   */\n  isSubsetOf: (set: ISet<WidenLiteral<K>>) => boolean;\n\n  /**\n   * Checks if this set is a superset of another set.\n   *\n   * @example\n   *\n   * ```ts\n   * const superset = ISet.create<string>(['a', 'b', 'c']);\n   *\n   * const subset = ISet.create<string>(['a', 'c']);\n   *\n   * assert.isTrue(superset.isSupersetOf(subset));\n   *\n   * assert.isFalse(subset.isSupersetOf(superset));\n   * ```\n   *\n   * @param set The other set.\n   * @returns `true` if this set is a superset of the other set, `false`\n   *   otherwise.\n   */\n  isSupersetOf: (set: ISet<WidenLiteral<K>>) => boolean;\n\n  /**\n   * Returns a new set with elements that are in this set but not in another\n   * set.\n   *\n   * @example\n   *\n   * ```ts\n   * const all = ISet.create<number>([1, 2, 3, 4]);\n   *\n   * const toRemove = ISet.create<number>([2, 4]);\n   *\n   * const difference = all.subtract(toRemove);\n   *\n   * assert.deepStrictEqual(Array.from(difference), [1, 3]);\n   * ```\n   *\n   * @param set The other set.\n   * @returns A new ISet instance representing the set difference.\n   */\n  subtract: (set: ISet<K>) => ISet<K>;\n\n  /**\n   * Returns a new set with elements that are common to both this set and\n   * another set.\n   *\n   * @example\n   *\n   * ```ts\n   * const left = ISet.create<string>(['x', 'y']);\n   *\n   * const right = ISet.create<string>(['y', 'z']);\n   *\n   * const shared = left.intersect(right);\n   *\n   * assert.deepStrictEqual(Array.from(shared), ['y']);\n   * ```\n   *\n   * @param set The other set.\n   * @returns A new ISet instance representing the set intersection.\n   */\n  intersect: (set: ISet<K>) => ISet<K>;\n\n  /**\n   * Returns a new set with all elements from both this set and another set.\n   *\n   * @example\n   *\n   * ```ts\n   * const numbers = ISet.create([1, 2]);\n   *\n   * const letters = ISet.create(['a', 'b']);\n   *\n   * const combined = numbers.union(letters);\n   *\n   * assert.deepStrictEqual(Array.from(combined), [1, 2, 'a', 'b']);\n   * ```\n   *\n   * @template K2 The type of elements in the other set.\n   * @param set The other set.\n   * @returns A new ISet instance representing the set union.\n   */\n  union: <K2 extends MapSetKeyType>(set: ISet<K2>) => ISet<K | K2>;\n\n  // Side effects\n\n  /**\n   * Executes a callback function for each element in the set.\n   *\n   * @example\n   *\n   * ```ts\n   * const set = ISet.create(['alpha', 'beta']);\n   *\n   * const mut_collected: string[] = [];\n   *\n   * set.forEach((value) => {\n   *   mut_collected.push(value);\n   * });\n   *\n   * assert.deepStrictEqual(mut_collected, ['alpha', 'beta']);\n   * ```\n   *\n   * @param callbackfn A function to execute for each element.\n   */\n  forEach: (callbackfn: (key: K) => void) => void;\n\n  // Iterators\n\n  /**\n   * Returns an iterator for the elements in the set (alias for values).\n   *\n   * @example\n   *\n   * ```ts\n   * const set = ISet.create([1, 2]);\n   *\n   * const keys = Array.from(set.keys());\n   *\n   * assert.deepStrictEqual(keys, [1, 2]);\n   * ```\n   *\n   * @returns An iterable iterator of elements.\n   */\n  keys: () => IterableIterator<K>;\n\n  /**\n   * Returns an iterator for the elements in the set.\n   *\n   * @example\n   *\n   * ```ts\n   * const set = ISet.create(['x', 'y']);\n   *\n   * const values = Array.from(set.values());\n   *\n   * assert.deepStrictEqual(values, ['x', 'y']);\n   * ```\n   *\n   * @returns An iterable iterator of elements.\n   */\n  values: () => IterableIterator<K>;\n\n  /**\n   * Returns an iterator for the entries (element-element pairs) in the set.\n   *\n   * @example\n   *\n   * ```ts\n   * const set = ISet.create(['red', 'blue']);\n   *\n   * const entries = Array.from(set.entries());\n   *\n   * assert.deepStrictEqual(entries, [\n   *   ['red', 'red'],\n   *   ['blue', 'blue'],\n   * ]);\n   * ```\n   *\n   * @returns An iterable iterator of entries.\n   */\n  entries: () => IterableIterator<readonly [K, K]>;\n\n  // Conversion\n\n  /**\n   * Converts the elements of the set to an array.\n   *\n   * @example\n   *\n   * ```ts\n   * const set = ISet.create(['north', 'south']);\n   *\n   * assert.deepStrictEqual(set.toArray(), ['north', 'south']);\n   * ```\n   *\n   * @returns A readonly array of elements.\n   */\n  toArray: () => readonly K[];\n\n  /**\n   * Returns the underlying readonly JavaScript Set.\n   *\n   * @example\n   *\n   * ```ts\n   * const set = ISet.create(['alpha']);\n   *\n   * const raw = set.toRawSet();\n   *\n   * assert.isTrue(isSet(raw));\n   *\n   * assert.isTrue(raw.has('alpha'));\n   * ```\n   *\n   * @returns The raw ReadonlySet instance.\n   */\n  toRawSet: () => ReadonlySet<K>;\n}>;\n\n/**\n * Represents an immutable set with high-performance operations and\n * comprehensive set algebra support.\n *\n * ISet is a persistent data structure that provides all the functionality of\n * JavaScript's Set while maintaining immutability. All operations that would\n * normally mutate the set instead return new ISet instances, making it safe for\n * functional programming and concurrent access.\n *\n * **Key Features:**\n *\n * - **Immutable**: All mutation operations return new instances\n * - **Set Operations**: Full support for union, intersection, difference,\n *   subset/superset checks\n * - **Type Safe**: Full TypeScript support with generic element types\n * - **Iterable**: Implements standard JavaScript iteration protocols\n * - **Functional**: Rich API for map, filter, and functional composition\n *\n * **When to Use:**\n *\n * - Managing collections of unique values with immutability guarantees\n * - Set algebra operations (unions, intersections, differences)\n * - Membership testing with O(1) performance\n * - Functional programming patterns requiring immutable collections\n *\n * @template K The type of the elements in the set. Must extend MapSetKeyType.\n */\nexport type ISet<K extends MapSetKeyType> = Iterable<K> & ISetInterface<K>;\n\n/** Provides utility functions for ISet. */\nexport namespace ISet {\n  /**\n   * Creates a new ISet instance from an iterable of elements.\n   *\n   * This factory function accepts any iterable of elements, including arrays,\n   * JavaScript Sets, other ISets, or custom iterables. Duplicate elements in\n   * the input iterable will be automatically deduplicated in the resulting\n   * set.\n   *\n   * **Performance:** O(n) where n is the number of elements in the iterable.\n   *\n   * @example\n   *\n   * ```ts\n   * const set = ISet.create(['a', 'a', 'b']);\n   *\n   * assert.deepStrictEqual(Array.from(set), ['a', 'b']);\n   * ```\n   *\n   * @template K The type of the elements. Must extend MapSetKeyType.\n   * @param iterable An iterable of elements (e.g., Array, Set, ISet, etc.)\n   * @returns A new ISet instance containing all unique elements from the\n   *   iterable.\n   */\n  export const create = <K extends MapSetKeyType>(\n    iterable: Iterable<K>,\n  ): ISet<K> => new ISetClass<K>(iterable);\n\n  /**\n   * Checks if two ISet instances are structurally equal.\n   *\n   * Two ISets are considered equal if they have the same size and contain\n   * exactly the same elements. The order of elements does not matter for\n   * equality comparison since sets are unordered collections. Elements are\n   * compared using JavaScript's `===` operator.\n   *\n   * **Performance:** O(n) where n is the size of the smaller set.\n   *\n   * @example\n   *\n   * ```ts\n   * const first = ISet.create<number>([1, 2]);\n   *\n   * const second = ISet.create<number>([2, 1]);\n   *\n   * const third = ISet.create<number>([1, 3]);\n   *\n   * assert.isTrue(ISet.equal(first, second));\n   *\n   * assert.isFalse(ISet.equal(first, third));\n   * ```\n   *\n   * @template K The type of the elements.\n   * @param a The first ISet instance to compare.\n   * @param b The second ISet instance to compare.\n   * @returns `true` if the sets contain exactly the same elements, `false`\n   *   otherwise.\n   */\n  export const equal = <K extends MapSetKeyType>(\n    a: ISet<K>,\n    b: ISet<K>,\n  ): boolean => a.size === b.size && a.every((e) => b.has(e));\n\n  /**\n   * Computes the difference between two ISet instances, identifying added and\n   * deleted elements.\n   *\n   * This function performs a set difference operation to determine what\n   * elements were added and what elements were deleted when transitioning from\n   * the old set to the new set. This is useful for change detection, state\n   * management, and synchronization scenarios.\n   *\n   * **Performance:** O(n + m) where n and m are the sizes of the old and new\n   * sets respectively.\n   *\n   * @example\n   *\n   * ```ts\n   * const previous = ISet.create<string>(['draft', 'review']);\n   *\n   * const current = ISet.create<string>(['review', 'published']);\n   *\n   * const { added, deleted } = ISet.diff(previous, current);\n   *\n   * assert.deepStrictEqual(Array.from(added), ['published']);\n   *\n   * assert.deepStrictEqual(Array.from(deleted), ['draft']);\n   * ```\n   *\n   * @template K The type of the elements.\n   * @param oldSet The original set representing the previous state.\n   * @param newSet The new set representing the current state.\n   * @returns An object with `added` and `deleted` properties, each containing\n   *   an ISet of elements that were added or removed respectively.\n   */\n  export const diff = <K extends MapSetKeyType>(\n    oldSet: ISet<K>,\n    newSet: ISet<K>,\n  ): ReadonlyRecord<'added' | 'deleted', ISet<K>> =>\n    ({\n      deleted: oldSet.subtract(newSet),\n      added: newSet.subtract(oldSet),\n    }) as const;\n\n  /**\n   * Computes the intersection of two ISet instances.\n   *\n   * Returns a new set containing only the elements that are present in both\n   * input sets. This operation is commutative: `intersection(a, b) ===\n   * intersection(b, a)`.\n   *\n   * **Performance:** O(min(n, m)) where n and m are the sizes of the input\n   * sets.\n   *\n   * @example\n   *\n   * ```ts\n   * const left = ISet.create<number>([1, 2, 3]);\n   *\n   * const right = ISet.create<number>([2, 4]);\n   *\n   * const overlap = ISet.intersection(left, right);\n   *\n   * assert.deepStrictEqual(Array.from(overlap), [2]);\n   * ```\n   *\n   * @template K The type of the elements.\n   * @param a The first set.\n   * @param b The second set.\n   * @returns A new ISet instance containing elements common to both sets.\n   */\n  export const intersection = <K extends MapSetKeyType>(\n    a: ISet<K>,\n    b: ISet<K>,\n  ): ISet<K> => a.intersect(b);\n\n  /**\n   * Computes the union of two ISet instances.\n   *\n   * Returns a new set containing all elements that are present in either input\n   * set. Duplicate elements are automatically handled since sets only contain\n   * unique values. This operation is commutative: `union(a, b) === union(b,\n   * a)`.\n   *\n   * **Performance:** O(n + m) where n and m are the sizes of the input sets.\n   *\n   * @example\n   *\n   * ```ts\n   * const numbers = ISet.create([1, 2]);\n   *\n   * const words = ISet.create(['one', 'two']);\n   *\n   * const union = ISet.union(numbers, words);\n   *\n   * assert.deepStrictEqual(Array.from(union), [1, 2, 'one', 'two']);\n   * ```\n   *\n   * @template K1 The type of elements in the first set.\n   * @template K2 The type of elements in the second set.\n   * @param a The first set.\n   * @param b The second set.\n   * @returns A new ISet instance containing all elements from both sets.\n   */\n  export const union = <K1 extends MapSetKeyType, K2 extends MapSetKeyType>(\n    a: ISet<K1>,\n    b: ISet<K2>,\n  ): ISet<K1 | K2> => a.union(b);\n}\n\n/**\n * Internal class implementation for ISet providing immutable set operations.\n *\n * This class implements the ISet interface using JavaScript's native Set as the\n * underlying storage mechanism for optimal performance. All mutation operations\n * create new instances rather than modifying the existing set, ensuring\n * immutability.\n *\n * **Implementation Details:**\n *\n * - Uses ReadonlySet<K> internally for type safety and performance\n * - Implements copy-on-write semantics for efficiency\n * - Provides optional debug messaging for development\n *\n * @template K The type of the elements. Must extend MapSetKeyType.\n * @implements ISet\n * @implements Iterable\n * @internal This class should not be used directly. Use ISet.create() instead.\n */\nclass ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {\n  readonly #set: ReadonlySet<K>;\n  readonly #showNotFoundMessage: boolean;\n\n  /**\n   * Constructs an ISetClass instance with the given elements.\n   *\n   * @param iterable An iterable of elements to populate the set.\n   * @param showNotFoundMessage Whether to log warning messages when operations\n   *   are performed on non-existent elements. Useful for debugging. Defaults to\n   *   false for production use.\n   * @internal Use ISet.create() instead of calling this constructor directly.\n   */\n  constructor(iterable: Iterable<K>, showNotFoundMessage: boolean = false) {\n    this.#set = new Set(iterable);\n\n    this.#showNotFoundMessage = showNotFoundMessage;\n  }\n\n  /** @inheritdoc */\n  get size(): SizeType.Arr {\n    return asUint32(this.#set.size);\n  }\n\n  /** @inheritdoc */\n  get isEmpty(): boolean {\n    return this.size === 0;\n  }\n\n  /** @inheritdoc */\n  has(key: K | (WidenLiteral<K> & {})): boolean {\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return this.#set.has(key as K);\n  }\n\n  /** @inheritdoc */\n  every<L extends K>(predicate: (key: K) => key is L): this is ISet<L>;\n\n  /** @inheritdoc */\n  every(predicate: (key: K) => boolean): boolean;\n\n  /** @inheritdoc */\n  every(predicate: (key: K) => boolean): boolean {\n    for (const key of this.values()) {\n      if (!predicate(key)) return false;\n    }\n\n    return true;\n  }\n\n  /** @inheritdoc */\n  some(predicate: (key: K) => boolean): boolean {\n    for (const key of this.values()) {\n      if (predicate(key)) return true;\n    }\n\n    return false;\n  }\n\n  /** @inheritdoc */\n  add(key: K): ISet<K> {\n    if (this.has(key)) return this;\n\n    return ISet.create([...this.#set, key]);\n  }\n\n  /** @inheritdoc */\n  delete(key: K): ISet<K> {\n    if (!this.has(key)) {\n      if (this.#showNotFoundMessage) {\n        const keyStr = unknownToString(key);\n\n        console.warn(`ISet.delete: key not found: ${keyStr}`);\n      }\n\n      return this;\n    }\n\n    return ISet.create(Array.from(this.#set).filter((k) => !Object.is(k, key)));\n  }\n\n  /** @inheritdoc */\n  withMutations(\n    actions: readonly Readonly<\n      { type: 'add'; key: K } | { type: 'delete'; key: K }\n    >[],\n  ): ISet<K> {\n    const mut_result = new Set<K>(this.#set);\n\n    const updateFn = (\n      action: Readonly<{ type: 'add'; key: K } | { type: 'delete'; key: K }>,\n    ): void => {\n      switch (action.type) {\n        case 'delete':\n          mut_result.delete(action.key);\n\n          break;\n\n        case 'add':\n          mut_result.add(action.key);\n\n          break;\n      }\n    };\n\n    for (const action of actions) {\n      updateFn(action);\n    }\n\n    return ISet.create(mut_result);\n  }\n\n  /** @inheritdoc */\n  map<K2 extends MapSetKeyType>(mapFn: (key: K) => K2): ISet<K2> {\n    return ISet.create(this.toArray().map(mapFn));\n  }\n\n  /** @inheritdoc */\n  filter<K2 extends K>(predicate: (key: K) => key is K2): ISet<K2>;\n\n  /** @inheritdoc */\n  filter(predicate: (key: K) => boolean): ISet<K>;\n\n  /** @inheritdoc */\n  filter(predicate: (key: K) => boolean): ISet<K> {\n    return ISet.create(this.toArray().filter(predicate));\n  }\n\n  /** @inheritdoc */\n  filterNot(predicate: (key: K) => boolean): ISet<K> {\n    return ISet.create(this.toArray().filter((e) => !predicate(e)));\n  }\n\n  /** @inheritdoc */\n  forEach(callbackfn: (key: K) => void): void {\n    for (const v of this.#set) {\n      callbackfn(v);\n    }\n  }\n\n  /** @inheritdoc */\n  isSubsetOf(set: ISet<WidenLiteral<K>>): boolean {\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return this.every((k) => set.has(k as WidenLiteral<K>));\n  }\n\n  /** @inheritdoc */\n  isSupersetOf(set: ISet<WidenLiteral<K>>): boolean {\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return set.every((k) => this.has(k as K));\n  }\n\n  /** @inheritdoc */\n  subtract(set: ISet<K>): ISet<K> {\n    return ISet.create(this.toArray().filter((k) => !set.has(k)));\n  }\n\n  /** @inheritdoc */\n  intersect(set: ISet<K>): ISet<K> {\n    return ISet.create(this.toArray().filter((k) => set.has(k)));\n  }\n\n  /** @inheritdoc */\n  union<K2 extends MapSetKeyType>(set: ISet<K2>): ISet<K | K2> {\n    return ISet.create([...this, ...set]);\n  }\n\n  /**\n   * @example\n   *\n   * ```ts\n   * const set = ISet.create(['first', 'second']);\n   *\n   * const collected = Array.from(set);\n   *\n   * assert.deepStrictEqual(collected, ['first', 'second']);\n   * ```\n   *\n   * @inheritdoc\n   */\n  [Symbol.iterator](): Iterator<K> {\n    return this.#set[Symbol.iterator]();\n  }\n\n  /** @inheritdoc */\n  keys(): IterableIterator<K> {\n    return this.#set.keys();\n  }\n\n  /** @inheritdoc */\n  values(): IterableIterator<K> {\n    return this.#set.values();\n  }\n\n  /** @inheritdoc */\n  entries(): IterableIterator<readonly [K, K]> {\n    return this.#set.entries();\n  }\n\n  /** @inheritdoc */\n  toArray(): readonly K[] {\n    return Array.from(this.values());\n  }\n\n  /** @inheritdoc */\n  toRawSet(): ReadonlySet<K> {\n    return this.#set;\n  }\n}\n"],"names":["ISet"],"mappings":"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"}

package/dist/collections/queue.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"queue.d.mts","sourceRoot":"","sources":["../../src/collections/queue.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGnD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC;IAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,OAAO,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC;IAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CAC7B,CAAC,CAAC;AAoKH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAG,gBAAgB,SAAS,CAAC,EAAE,KAAG,KAAK,CAAC,CAAC,CACpC,CAAC"}
+{"version":3,"file":"queue.d.mts","sourceRoot":"","sources":["../../src/collections/queue.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGnD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC;IAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,OAAO,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC;IAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CAC7B,CAAC,CAAC;AAoKH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,kBAAmB,SAAS,CAAC,EAAE,KAAG,KAAK,CAAC,CAAC,CACpC,CAAC"}