ts-data-forge 14.6.1 → 14.6.2

package/dist/collections/imap.mjs

@@ -1,245 +1,286 @@
-import { isSome } from '../functional/optional/impl/optional-is-some.mjs';
-import { none } from '../functional/optional/impl/optional-none.mjs';
-import { some } from '../functional/optional/impl/optional-some.mjs';
-import { isNone } from '../functional/optional/impl/optional-is-none.mjs';
-import '@sindresorhus/is';
-import { tp } from '../others/tuple.mjs';
-import { unknownToString } from '../others/unknown-to-string.mjs';
-import { pipe } from '../functional/pipe.mjs';
-import '../number/branded-types/finite-number.mjs';
-import '../number/branded-types/int.mjs';
-import '../number/branded-types/int16.mjs';
-import '../number/branded-types/int32.mjs';
-import '../number/branded-types/negative-finite-number.mjs';
-import '../number/branded-types/negative-int.mjs';
-import '../number/branded-types/negative-safe-int.mjs';
-import '../number/branded-types/non-negative-finite-number.mjs';
-import '../number/branded-types/non-negative-int16.mjs';
-import '../number/branded-types/non-negative-int32.mjs';
-import '../number/branded-types/non-positive-finite-number.mjs';
-import '../number/branded-types/non-positive-int.mjs';
-import '../number/branded-types/non-positive-safe-int.mjs';
-import '../number/branded-types/non-zero-finite-number.mjs';
-import '../number/branded-types/non-zero-int.mjs';
-import '../number/branded-types/non-zero-int16.mjs';
-import '../number/branded-types/non-zero-int32.mjs';
-import '../number/branded-types/non-zero-safe-int.mjs';
-import '../number/branded-types/non-zero-uint16.mjs';
-import '../number/branded-types/non-zero-uint32.mjs';
-import '../number/branded-types/positive-finite-number.mjs';
-import '../number/branded-types/positive-int.mjs';
-import '../number/branded-types/positive-int16.mjs';
-import '../number/branded-types/positive-int32.mjs';
-import '../number/branded-types/positive-safe-int.mjs';
-import '../number/branded-types/positive-uint16.mjs';
-import '../number/branded-types/positive-uint32.mjs';
-import '../number/branded-types/safe-int.mjs';
-import '../number/branded-types/safe-uint.mjs';
-import '../number/branded-types/uint.mjs';
-import '../number/branded-types/uint16.mjs';
-import { asUint32 } from '../number/branded-types/uint32.mjs';
-import '../number/enum/int8.mjs';
-import '../number/enum/uint8.mjs';
-import '../number/num.mjs';
-import '../number/refined-number-utils.mjs';
-
-var IMap;
-((IMap2) => {
-  IMap2.create = (iterable) => new IMapClass(iterable);
-  IMap2.equal = (a, b) => a.size === b.size && a.every(
-    (v, k) => pipe(b.get(k)).map((v2) => isSome(v2) && v2.value === v).value
-  );
+import { Optional, pipe } from '../functional/index.mjs';
+import { asUint32 } from '../number/index.mjs';
+import { tp, unknownToString } from '../others/index.mjs';
+/** Provides utility functions for IMap. */
+export var IMap;
+(function (IMap) {
+    /**
+     * Creates a new IMap instance from an iterable of key-value pairs.
+     *
+     * This factory function accepts any iterable of [key, value] tuples,
+     * including arrays, JavaScript Maps, other IMaps, or custom iterables. The
+     * resulting IMap will contain all the entries from the input iterable.
+     *
+     * **Performance:** O(n) where n is the number of entries in the iterable.
+     *
+     * @example
+     *
+     * ```ts
+     * const map = IMap.create<string, number | string>([
+     *   ['id', 1],
+     *   ['status', 'active'],
+     * ]);
+     *
+     * assert.isTrue(map.size === 2);
+     *
+     * assert.deepStrictEqual(map.get('status'), Optional.some('active'));
+     * ```
+     *
+     * @template K The type of the keys. Must extend MapSetKeyType.
+     * @template V The type of the values.
+     * @param iterable An iterable of key-value pairs (e.g., Array, Map, IMap,
+     *   etc.)
+     * @returns A new IMap instance containing all entries from the iterable.
+     */
+    IMap.create = (iterable) => new IMapClass(iterable);
+    /**
+     * Checks if two IMap instances are structurally equal.
+     *
+     * Two IMaps are considered equal if they have the same size and contain
+     * exactly the same key-value pairs. The order of entries does not matter for
+     * equality comparison. Values are compared using JavaScript's `===`
+     * operator.
+     *
+     * **Performance:** O(n) where n is the size of the smaller map.
+     *
+     * @example
+     *
+     * ```ts
+     * const first = IMap.create<'a' | 'b', number>([
+     *   ['a', 1],
+     *   ['b', 2],
+     * ]);
+     *
+     * const second = IMap.create<'a' | 'b', number>([
+     *   ['b', 2],
+     *   ['a', 1],
+     * ]);
+     *
+     * const third = IMap.create<'a' | 'b', number>([
+     *   ['a', 1],
+     *   ['b', 3],
+     * ]);
+     *
+     * assert.isTrue(IMap.equal(first, second));
+     *
+     * assert.isFalse(IMap.equal(first, third));
+     * ```
+     *
+     * @template K The type of the keys.
+     * @template V The type of the values.
+     * @param a The first IMap instance to compare.
+     * @param b The second IMap instance to compare.
+     * @returns `true` if the maps contain exactly the same key-value pairs,
+     *   `false` otherwise.
+     */
+    IMap.equal = (a, b) => a.size === b.size &&
+        a.every((v, k) => pipe(b.get(k)).map((v2) => Optional.isSome(v2) && v2.value === v).value);
 })(IMap || (IMap = {}));
+/**
+ * Internal class implementation for IMap providing immutable map operations.
+ *
+ * This class implements the IMap interface using JavaScript's native Map as the
+ * underlying storage mechanism for optimal performance. All mutation operations
+ * create new instances rather than modifying the existing map, ensuring
+ * immutability.
+ *
+ * **Implementation Details:**
+ *
+ * - Uses Map<K, V> 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 keys. Must extend MapSetKeyType.
+ * @template V The type of the values.
+ * @implements IMap
+ * @implements Iterable
+ * @internal This class should not be used directly. Use IMap.create() instead.
+ */
 class IMapClass {
-  #map;
-  #showNotFoundMessage;
-  /**
-   * Constructs an IMapClass instance with the given entries.
-   *
-   * @param iterable An iterable of key-value pairs to populate the map.
-   * @param showNotFoundMessage Whether to log warning messages when operations
-   *   are performed on non-existent keys. Useful for debugging. Defaults to
-   *   false for production use.
-   * @internal Use IMap.create() instead of calling this constructor directly.
-   */
-  constructor(iterable, showNotFoundMessage = false) {
-    this.#map = new Map(iterable);
-    this.#showNotFoundMessage = showNotFoundMessage;
-  }
-  /** @inheritdoc */
-  get size() {
-    return asUint32(this.#map.size);
-  }
-  /** @inheritdoc */
-  has(key) {
-    return this.#map.has(key);
-  }
-  /** @inheritdoc */
-  get(key) {
-    if (!this.has(key)) return none;
-    return some(this.#map.get(key));
-  }
-  /** @inheritdoc */
-  every(predicate) {
-    for (const [k, v] of this.entries()) {
-      if (!predicate(v, k)) return false;
-    }
-    return true;
-  }
-  /** @inheritdoc */
-  some(predicate) {
-    for (const [k, v] of this.entries()) {
-      if (predicate(v, k)) return true;
-    }
-    return false;
-  }
-  /** @inheritdoc */
-  delete(key) {
-    if (!this.has(key)) {
-      if (this.#showNotFoundMessage) {
-        const keyStr = unknownToString(key);
-        console.warn(`IMap.delete: key not found: ${keyStr}`);
-      }
-      return this;
-    }
-    return IMap.create(
-      Array.from(this.#map).filter(([k]) => !Object.is(k, key))
-    );
-  }
-  /** @inheritdoc */
-  set(key, value) {
-    const curr = this.get(key);
-    if (isSome(curr) && value === curr.value) return this;
-    if (!this.has(key)) {
-      return IMap.create([...this.#map, tp(key, value)]);
-    }
-    return IMap.create(
-      Array.from(this.#map, ([k, v]) => tp(k, Object.is(k, key) ? value : v))
-    );
-  }
-  /** @inheritdoc */
-  update(key, updater) {
-    const curr = this.get(key);
-    if (isNone(curr)) {
-      if (this.#showNotFoundMessage) {
-        const keyStr = unknownToString(key);
-        console.warn(`IMap.update: key not found: ${keyStr}`);
-      }
-      return this;
-    }
-    return IMap.create(
-      Array.from(
-        this.#map,
-        ([k, v]) => tp(k, Object.is(k, key) ? updater(curr.value) : v)
-      )
-    );
-  }
-  /** @inheritdoc */
-  withMutations(actions) {
-    const mut_result = new Map(this.#map);
-    const updateFn = (action) => {
-      switch (action.type) {
-        case "delete":
-          mut_result.delete(action.key);
-          break;
-        case "set":
-          mut_result.set(action.key, action.value);
-          break;
-        case "update": {
-          const { key } = action;
-          const curr = mut_result.get(key);
-          if (curr === void 0 || !mut_result.has(key)) {
+    #map;
+    #showNotFoundMessage;
+    /**
+     * Constructs an IMapClass instance with the given entries.
+     *
+     * @param iterable An iterable of key-value pairs to populate the map.
+     * @param showNotFoundMessage Whether to log warning messages when operations
+     *   are performed on non-existent keys. Useful for debugging. Defaults to
+     *   false for production use.
+     * @internal Use IMap.create() instead of calling this constructor directly.
+     */
+    constructor(iterable, showNotFoundMessage = false) {
+        this.#map = new Map(iterable);
+        this.#showNotFoundMessage = showNotFoundMessage;
+    }
+    /** @inheritdoc */
+    get size() {
+        return asUint32(this.#map.size);
+    }
+    /** @inheritdoc */
+    has(key) {
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unnecessary-type-assertion -- unnecessary only under the strict standard library; the stock one types `has` as taking exactly `K`
+        return this.#map.has(key);
+    }
+    /** @inheritdoc */
+    get(key) {
+        if (!this.has(key))
+            return Optional.none;
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-non-null-assertion
+        return Optional.some(this.#map.get(key));
+    }
+    /** @inheritdoc */
+    every(predicate) {
+        for (const [k, v] of this.entries()) {
+            if (!predicate(v, k))
+                return false;
+        }
+        return true;
+    }
+    /** @inheritdoc */
+    some(predicate) {
+        for (const [k, v] of this.entries()) {
+            if (predicate(v, k))
+                return true;
+        }
+        return false;
+    }
+    /** @inheritdoc */
+    delete(key) {
+        if (!this.has(key)) {
             if (this.#showNotFoundMessage) {
-              const keyStr = unknownToString(key);
-              console.warn(`IMap.withMutations: key not found: ${keyStr}`);
+                const keyStr = unknownToString(key);
+                console.warn(`IMap.delete: key not found: ${keyStr}`);
+            }
+            return this;
+        }
+        return IMap.create(Array.from(this.#map).filter(([k]) => !Object.is(k, key)));
+    }
+    /** @inheritdoc */
+    set(key, value) {
+        const curr = this.get(key);
+        if (Optional.isSome(curr) && value === curr.value)
+            return this; // has no changes
+        if (!this.has(key)) {
+            return IMap.create([...this.#map, tp(key, value)]);
+        }
+        return IMap.create(Array.from(this.#map, ([k, v]) => tp(k, Object.is(k, key) ? value : v)));
+    }
+    /** @inheritdoc */
+    update(key, updater) {
+        const curr = this.get(key);
+        if (Optional.isNone(curr)) {
+            if (this.#showNotFoundMessage) {
+                const keyStr = unknownToString(key);
+                console.warn(`IMap.update: key not found: ${keyStr}`);
+            }
+            return this;
+        }
+        return IMap.create(Array.from(this.#map, ([k, v]) => tp(k, Object.is(k, key) ? updater(curr.value) : v)));
+    }
+    /** @inheritdoc */
+    withMutations(actions) {
+        const mut_result = new Map(this.#map);
+        const updateFn = (action) => {
+            switch (action.type) {
+                case 'delete':
+                    mut_result.delete(action.key);
+                    break;
+                case 'set':
+                    mut_result.set(action.key, action.value);
+                    break;
+                case 'update': {
+                    const { key } = action;
+                    const curr = mut_result.get(key);
+                    if (curr === undefined || !mut_result.has(key)) {
+                        if (this.#showNotFoundMessage) {
+                            const keyStr = unknownToString(key);
+                            console.warn(`IMap.withMutations: key not found: ${keyStr}`);
+                        }
+                        break;
+                    }
+                    mut_result.set(key, action.updater(curr));
+                    break;
+                }
             }
-            break;
-          }
-          mut_result.set(key, action.updater(curr));
-          break;
+        };
+        for (const action of actions) {
+            updateFn(action);
+        }
+        return IMap.create(mut_result);
+    }
+    /** @inheritdoc */
+    map(mapFn) {
+        return IMap.create(this.toArray().map(([k, v]) => tp(k, mapFn(v, k))));
+    }
+    /** @inheritdoc */
+    mapKeys(mapFn) {
+        return IMap.create(this.toArray().map(([k, v]) => tp(mapFn(k), v)));
+    }
+    /** @inheritdoc */
+    mapEntries(mapFn) {
+        return IMap.create(this.toArray().map(mapFn));
+    }
+    /** @inheritdoc */
+    forEach(callbackfn) {
+        for (const [key, value] of this.#map) {
+            callbackfn(value, key);
         }
-      }
-    };
-    for (const action of actions) {
-      updateFn(action);
-    }
-    return IMap.create(mut_result);
-  }
-  /** @inheritdoc */
-  map(mapFn) {
-    return IMap.create(this.toArray().map(([k, v]) => tp(k, mapFn(v, k))));
-  }
-  /** @inheritdoc */
-  mapKeys(mapFn) {
-    return IMap.create(this.toArray().map(([k, v]) => tp(mapFn(k), v)));
-  }
-  /** @inheritdoc */
-  mapEntries(mapFn) {
-    return IMap.create(this.toArray().map(mapFn));
-  }
-  /** @inheritdoc */
-  forEach(callbackfn) {
-    for (const [key, value] of this.#map) {
-      callbackfn(value, key);
-    }
-  }
-  /**
-   * @example
-   *
-   * ```ts
-   * const entries = [
-   *   ['first', 1],
-   *   ['second', 2],
-   * ] as const satisfies readonly (readonly [string, number])[];
-   *
-   * const map = IMap.create(entries);
-   *
-   * const collected = Array.from(map);
-   *
-   * assert.deepStrictEqual(collected, [
-   *   ['first', 1],
-   *   ['second', 2],
-   * ]);
-   * ```
-   *
-   * @inheritdoc
-   */
-  [Symbol.iterator]() {
-    return this.#map[Symbol.iterator]();
-  }
-  /** @inheritdoc */
-  keys() {
-    return this.#map.keys();
-  }
-  /** @inheritdoc */
-  values() {
-    return this.#map.values();
-  }
-  /** @inheritdoc */
-  entries() {
-    return this.#map.entries();
-  }
-  /** @inheritdoc */
-  toKeysArray() {
-    return Array.from(this.keys());
-  }
-  /** @inheritdoc */
-  toValuesArray() {
-    return Array.from(this.values());
-  }
-  /** @inheritdoc */
-  toEntriesArray() {
-    return Array.from(this.entries());
-  }
-  /** @inheritdoc */
-  toArray() {
-    return Array.from(this.entries());
-  }
-  /** @inheritdoc */
-  toRawMap() {
-    return this.#map;
-  }
+    }
+    /**
+     * @example
+     *
+     * ```ts
+     * const entries = [
+     *   ['first', 1],
+     *   ['second', 2],
+     * ] as const satisfies readonly (readonly [string, number])[];
+     *
+     * const map = IMap.create(entries);
+     *
+     * const collected = Array.from(map);
+     *
+     * assert.deepStrictEqual(collected, [
+     *   ['first', 1],
+     *   ['second', 2],
+     * ]);
+     * ```
+     *
+     * @inheritdoc
+     */
+    [Symbol.iterator]() {
+        return this.#map[Symbol.iterator]();
+    }
+    /** @inheritdoc */
+    keys() {
+        return this.#map.keys();
+    }
+    /** @inheritdoc */
+    values() {
+        return this.#map.values();
+    }
+    /** @inheritdoc */
+    entries() {
+        return this.#map.entries();
+    }
+    /** @inheritdoc */
+    toKeysArray() {
+        return Array.from(this.keys());
+    }
+    /** @inheritdoc */
+    toValuesArray() {
+        return Array.from(this.values());
+    }
+    /** @inheritdoc */
+    toEntriesArray() {
+        return Array.from(this.entries());
+    }
+    /** @inheritdoc */
+    toArray() {
+        return Array.from(this.entries());
+    }
+    /** @inheritdoc */
+    toRawMap() {
+        return this.#map;
+    }
 }
-
-export { IMap };
-//# sourceMappingURL=imap.mjs.map
+//# sourceMappingURL=imap.mjs.map

package/dist/collections/imap.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"imap.mjs","sources":["../../src/collections/imap.mts"],"sourcesContent":["/* eslint-disable unicorn/prefer-iterator-to-array-at-end */\nimport { type WidenLiteral } from 'ts-type-forge';\nimport { Optional, pipe } from '../functional/index.mjs';\nimport { asUint32 } from '../number/index.mjs';\nimport { tp, unknownToString } from '../others/index.mjs';\nimport { type MapSetKeyType, type SizeType } from '../types.mjs';\n\n/**\n * Interface for an immutable map with lookup operations and functional\n * programming patterns.\n *\n * This interface defines all methods and properties available on IMap\n * instances. All operations that modify the map return new IMap instances,\n * preserving immutability. The underlying implementation uses JavaScript's\n * native Map but creates copies on mutations to maintain immutability.\n *\n * **Immutability Guarantees:**\n *\n * - All mutation operations (set, delete, update) return new IMap instances\n * - Original IMap instances are never modified\n * - Safe for concurrent access and functional programming patterns\n *\n * **Performance Characteristics:**\n *\n * - get/has: O(1) average case\n * - set/delete: O(n) due to copying for immutability\n * - map/filter operations: O(n)\n * - iteration: O(n)\n *\n * @template K The type of the keys in the map. Must extend MapSetKeyType\n *   (string, number, boolean, etc.)\n * @template V The type of the values in the map.\n */\ntype IMapInterface<K extends MapSetKeyType, V> = Readonly<{\n  // Getting information\n\n  /**\n   * The number of elements in the map.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['a', 1],\n   *   ['b', 2],\n   * ] as const satisfies readonly (readonly [string, number])[];\n   *\n   * const map = IMap.create(entries);\n   *\n   * assert.isTrue(map.size === 2);\n   * ```\n   */\n  size: SizeType.Arr;\n\n  /**\n   * Checks if a key exists in the map. Allows for wider literal types for keys\n   * during checking.\n   *\n   * @example\n   *\n   * ```ts\n   * const map = IMap.create<'id' | 'enabled', number | boolean>([\n   *   ['id', 42],\n   *   ['enabled', true],\n   * ]);\n   *\n   * assert.isTrue(map.has('id'));\n   *\n   * assert.isFalse(map.has('missing'));\n   * ```\n   *\n   * @param key The key to check.\n   * @returns `true` if the key exists, `false` otherwise.\n   */\n  has: (key: K | (WidenLiteral<K> & {})) => boolean;\n\n  /**\n   * Retrieves the value associated with a key.\n   *\n   * @example\n   *\n   * ```ts\n   * const map = IMap.create([['user', { id: 1 }]]);\n   *\n   * assert.deepStrictEqual(map.get('user'), Optional.some({ id: 1 }));\n   *\n   * assert.deepStrictEqual(map.get('missing'), Optional.none);\n   * ```\n   *\n   * @param key The key to retrieve.\n   * @returns The value associated with the key wrapped with `Optional.some`, or\n   *   `Optional.none` if the key does not exist.\n   */\n  get: (key: K | (WidenLiteral<K> & {})) => Optional<V>;\n\n  // Reducing a value\n\n  /**\n   * Checks if all elements in the map satisfy a predicate. Also supports a\n   * type predicate overload that narrows the type of values in the map if the\n   * predicate returns true for all elements.\n   *\n   * @example\n   *\n   * ```ts\n   * const map = IMap.create([\n   *   ['a', 2],\n   *   ['b', 4],\n   * ]);\n   *\n   * const allEven = map.every((value) => value % 2 === 0);\n   *\n   * const isNarrowed = map.every((value): value is 2 | 4 => value % 2 === 0);\n   *\n   * assert.isTrue(allEven);\n   *\n   * assert.isTrue(isNarrowed);\n   * ```\n   *\n   * @template W The narrowed type of the values.\n   * @param predicate A function to test each key-value pair.\n   * @returns `true` if all elements satisfy the predicate, `false` otherwise.\n   */\n  every: ((predicate: (value: V, key: K) => boolean) => boolean) &\n    (<W extends V>(\n      predicate: (value: V, key: K) => value is W,\n    ) => this is IMap<K, W>);\n\n  /**\n   * Checks if at least one element in the map satisfies a predicate.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['alice', 3],\n   *   ['bob', 5],\n   * ] as const satisfies readonly (readonly [string, number])[];\n   *\n   * const map = IMap.create(entries);\n   *\n   * assert.isTrue(map.some((value) => value > 4));\n   *\n   * assert.isFalse(map.some((value) => value > 10));\n   * ```\n   *\n   * @param predicate A function to test each key-value pair.\n   * @returns `true` if at least one element satisfies the predicate, `false`\n   *   otherwise.\n   */\n  some: (predicate: (value: V, key: K) => boolean) => boolean;\n\n  // Mutation\n\n  /**\n   * Deletes a key-value pair from the map.\n   *\n   * @example\n   *\n   * ```ts\n   * const original = IMap.create([\n   *   ['a', 1],\n   *   ['b', 2],\n   * ]);\n   *\n   * const withoutB = original.delete('b');\n   *\n   * assert.deepStrictEqual(original.get('b'), Optional.some(2));\n   *\n   * assert.deepStrictEqual(withoutB.get('b'), Optional.none);\n   *\n   * assert.isTrue(original.size === 2);\n   *\n   * assert.isTrue(withoutB.size === 1);\n   * ```\n   *\n   * @param key The key to delete.\n   * @returns A new IMap instance without the specified key.\n   */\n  delete: (key: K) => IMap<K, V>;\n\n  /**\n   * Sets a key-value pair in the map.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [['count', 1]] as const satisfies readonly (readonly [\n   *   'count' | 'status',\n   *   number | string,\n   * ])[];\n   *\n   * const base = IMap.create<'count' | 'status', number | string>(entries);\n   *\n   * const updated = base.set('count', 2);\n   *\n   * const extended = base.set('status', 'ok');\n   *\n   * assert.deepStrictEqual(base.get('count'), Optional.some(1));\n   *\n   * assert.deepStrictEqual(updated.get('count'), Optional.some(2));\n   *\n   * assert.deepStrictEqual(extended.get('status'), Optional.some('ok'));\n   * ```\n   *\n   * @param key The key to set.\n   * @param value The value to associate with the key.\n   * @returns A new IMap instance with the specified key-value pair.\n   */\n  set: (key: K, value: V) => IMap<K, V>;\n\n  /**\n   * Updates the value associated with a key using an updater function.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['alice', 10],\n   *   ['bob', 8],\n   * ] as const satisfies readonly (readonly [\n   *   'alice' | 'bob' | 'charlie',\n   *   number,\n   * ])[];\n   *\n   * const scores = IMap.create<'alice' | 'bob' | 'charlie', number>(entries);\n   *\n   * const boosted = scores.update('alice', (value) => value + 5);\n   *\n   * const unchanged = scores.update('charlie', (value) => value + 1);\n   *\n   * assert.deepStrictEqual(boosted.get('alice'), Optional.some(15));\n   *\n   * assert.deepStrictEqual(scores.get('alice'), Optional.some(10));\n   *\n   * assert.isTrue(unchanged === scores);\n   * ```\n   *\n   * @param key The key whose value to update.\n   * @param updater A function that takes the current value and returns the new\n   *   value.\n   * @returns A new IMap instance with the updated value.\n   */\n  update: (key: K, updater: (value: V) => V) => IMap<K, V>;\n\n  /**\n   * Applies a series of mutations to the map.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['a', 1],\n   *   ['b', 2],\n   * ] as const satisfies readonly (readonly ['a' | 'b' | 'c', number])[];\n   *\n   * const base = IMap.create<'a' | 'b' | 'c', number>(entries);\n   *\n   * const actions: readonly Readonly<\n   *   | { type: 'set'; key: 'c'; value: number }\n   *   | { type: 'update'; key: 'b'; updater: (value: number) => number }\n   *   | { type: 'delete'; key: 'a' }\n   * >[] = [\n   *   { type: 'set', key: 'c', value: 3 },\n   *   { type: 'update', key: 'b', updater: (value) => value * 10 },\n   *   { type: 'delete', key: 'a' },\n   * ] as const;\n   *\n   * const mutated = base.withMutations(actions);\n   *\n   * assert.deepStrictEqual(mutated.get('c'), Optional.some(3));\n   *\n   * assert.deepStrictEqual(mutated.get('b'), Optional.some(20));\n   *\n   * assert.deepStrictEqual(mutated.get('a'), Optional.none);\n   *\n   * assert.deepStrictEqual(base.get('b'), Optional.some(2));\n   * ```\n   *\n   * @param actions An array of mutation actions (delete, set, or update).\n   * @returns A new IMap instance with all mutations applied.\n   */\n  withMutations: (\n    actions: readonly Readonly<\n      | { type: 'delete'; key: K }\n      | { type: 'set'; key: K; value: V }\n      | { type: 'update'; key: K; updater: (value: V) => V }\n    >[],\n  ) => IMap<K, V>;\n\n  // Sequence algorithms\n\n  /**\n   * Maps the values of the map to new values.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['a', 1],\n   *   ['b', 2],\n   * ] as const satisfies readonly (readonly [string, number])[];\n   *\n   * const map = IMap.create(entries);\n   *\n   * const doubled = map.map((value) => value * 2);\n   *\n   * assert.deepStrictEqual(Array.from(doubled), [\n   *   ['a', 2],\n   *   ['b', 4],\n   * ]);\n   * ```\n   *\n   * @template V2 The type of the new values.\n   * @param mapFn A function that maps a value and key to a new value.\n   * @returns A new IMap instance with mapped values.\n   */\n  map: <V2>(mapFn: (value: V, key: K) => V2) => IMap<K, V2>;\n\n  /**\n   * Maps the keys of the map to new keys.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['first', 1],\n   *   ['second', 2],\n   * ] as const satisfies readonly (readonly [string, number])[];\n   *\n   * const map = IMap.create(entries);\n   *\n   * const upperKeys = map.mapKeys((key) => key.toUpperCase());\n   *\n   * assert.deepStrictEqual(Array.from(upperKeys), [\n   *   ['FIRST', 1],\n   *   ['SECOND', 2],\n   * ]);\n   * ```\n   *\n   * @template K2 The type of the new keys.\n   * @param mapFn A function that maps a key to a new key.\n   * @returns A new IMap instance with mapped keys and original values.\n   */\n  mapKeys: <K2 extends MapSetKeyType>(mapFn: (key: K) => K2) => IMap<K2, V>;\n\n  /**\n   * Maps the entries (key-value pairs) of the map to new entries.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['a', 1],\n   *   ['b', 2],\n   * ] as const satisfies readonly (readonly [string, number])[];\n   *\n   * const map = IMap.create(entries);\n   *\n   * const swapped = map.mapEntries(\n   *   ([key, value]) => [value, key] satisfies readonly [number, string],\n   * );\n   *\n   * assert.deepStrictEqual(Array.from(swapped), [\n   *   [1, 'a'],\n   *   [2, 'b'],\n   * ]);\n   * ```\n   *\n   * @template K2 The type of the new keys in the entries.\n   * @template V2 The type of the new values in the entries.\n   * @param mapFn A function that maps an entry to a new entry.\n   * @returns A new IMap instance with mapped entries.\n   */\n  mapEntries: <K2 extends MapSetKeyType, V2>(\n    mapFn: (entry: readonly [K, V]) => readonly [K2, V2],\n  ) => IMap<K2, V2>;\n\n  // Side effects\n\n  /**\n   * Executes a callback function for each key-value pair in the map.\n   *\n   * @example\n   *\n   * ```ts\n   * const map = IMap.create([\n   *   ['a', 1],\n   *   ['b', 2],\n   * ]);\n   *\n   * const mut_entries: (readonly [string, number])[] = [];\n   *\n   * map.forEach((value, key) => {\n   *   mut_entries.push([key, value]);\n   * });\n   *\n   * assert.deepStrictEqual(mut_entries, [\n   *   ['a', 1],\n   *   ['b', 2],\n   * ]);\n   * ```\n   *\n   * @param callbackfn A function to execute for each element.\n   */\n  forEach: (callbackfn: (value: V, key: K) => void) => void;\n\n  // Iterators\n\n  /**\n   * Returns an iterator for the keys in the map.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['a', 1],\n   *   ['b', 2],\n   * ] as const satisfies readonly (readonly [string, number])[];\n   *\n   * const map = IMap.create(entries);\n   *\n   * const keys = Array.from(map.keys());\n   *\n   * assert.deepStrictEqual(keys, ['a', 'b']);\n   * ```\n   *\n   * @returns An iterable iterator of keys.\n   */\n  keys: () => IterableIterator<K>;\n\n  /**\n   * Returns an iterator for the values in the map.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['a', 1],\n   *   ['b', 2],\n   * ] as const satisfies readonly (readonly [string, number])[];\n   *\n   * const map = IMap.create(entries);\n   *\n   * const values = Array.from(map.values());\n   *\n   * assert.deepStrictEqual(values, [1, 2]);\n   * ```\n   *\n   * @returns An iterable iterator of values.\n   */\n  values: () => IterableIterator<V>;\n\n  /**\n   * Returns an iterator for the entries (key-value pairs) in the map.\n   *\n   * @example\n   *\n   * ```ts\n   * const map = IMap.create([\n   *   ['a', 1],\n   *   ['b', 2],\n   * ]);\n   *\n   * const entries = Array.from(map.entries());\n   *\n   * assert.deepStrictEqual(entries, [\n   *   ['a', 1],\n   *   ['b', 2],\n   * ]);\n   * ```\n   *\n   * @returns An iterable iterator of entries.\n   */\n  entries: () => IterableIterator<readonly [K, V]>;\n\n  // Conversion\n\n  /**\n   * Converts the keys of the map to an array.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['x', 10],\n   *   ['y', 20],\n   * ] as const satisfies readonly (readonly [string, number])[];\n   *\n   * const map = IMap.create(entries);\n   *\n   * assert.deepStrictEqual(map.toKeysArray(), ['x', 'y']);\n   * ```\n   *\n   * @returns A readonly array of keys.\n   */\n  toKeysArray: () => readonly K[];\n\n  /**\n   * Converts the values of the map to an array.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['x', 10],\n   *   ['y', 20],\n   * ] as const satisfies readonly (readonly [string, number])[];\n   *\n   * const map = IMap.create(entries);\n   *\n   * assert.deepStrictEqual(map.toValuesArray(), [10, 20]);\n   * ```\n   *\n   * @returns A readonly array of values.\n   */\n  toValuesArray: () => readonly V[];\n\n  /**\n   * Converts the entries (key-value pairs) of the map to an array.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['a', 1],\n   *   ['b', 2],\n   * ] as const satisfies readonly (readonly [string, number])[];\n   *\n   * const map = IMap.create(entries);\n   *\n   * assert.deepStrictEqual(map.toEntriesArray(), [\n   *   ['a', 1],\n   *   ['b', 2],\n   * ]);\n   * ```\n   *\n   * @returns A readonly array of entries.\n   */\n  toEntriesArray: () => readonly (readonly [K, V])[];\n\n  /**\n   * Converts the map to an array of entries (key-value pairs). Alias for\n   * `toEntriesArray`.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['k1', 'v1'],\n   *   ['k2', 'v2'],\n   * ] as const satisfies readonly FixedLengthTuple<2, string>[];\n   *\n   * const map = IMap.create(entries);\n   *\n   * assert.deepStrictEqual(map.toArray(), [\n   *   ['k1', 'v1'],\n   *   ['k2', 'v2'],\n   * ]);\n   * ```\n   *\n   * @returns A readonly array of entries.\n   */\n  toArray: () => readonly (readonly [K, V])[];\n\n  /**\n   * Returns the underlying readonly JavaScript Map.\n   *\n   * @example\n   *\n   * ```ts\n   * const entries = [['key', 1]] as const satisfies readonly (readonly [\n   *   string,\n   *   number,\n   * ])[];\n   *\n   * const map = IMap.create(entries);\n   *\n   * const raw = map.toRawMap();\n   *\n   * assert.isTrue(isMap(raw));\n   *\n   * assert.isTrue(raw.get('key') === 1);\n   * ```\n   *\n   * @returns The raw ReadonlyMap instance.\n   */\n  toRawMap: () => ReadonlyMap<K, V>;\n}>;\n\n/**\n * Represents an immutable map with high-performance operations and functional\n * programming support.\n *\n * IMap is a persistent data structure that provides all the functionality of\n * JavaScript's Map while maintaining immutability. All operations that would\n * normally mutate the map instead return new IMap 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 * - **Type Safe**: Full TypeScript support with generic key/value types\n * - **Iterable**: Implements standard JavaScript iteration protocols\n * - **Functional**: Rich API for map, filter, reduce-style operations\n *\n * **When to Use:**\n *\n * - State management in functional applications\n * - Caching with immutable guarantees\n * - Data structures that need to be shared across components\n * - When you need Map functionality but want immutability\n *\n * @template K The type of the keys in the map. Must extend MapSetKeyType.\n * @template V The type of the values in the map.\n */\nexport type IMap<K extends MapSetKeyType, V> = Iterable<readonly [K, V]> &\n  IMapInterface<K, V>;\n\n/** Provides utility functions for IMap. */\nexport namespace IMap {\n  /**\n   * Creates a new IMap instance from an iterable of key-value pairs.\n   *\n   * This factory function accepts any iterable of [key, value] tuples,\n   * including arrays, JavaScript Maps, other IMaps, or custom iterables. The\n   * resulting IMap will contain all the entries from the input iterable.\n   *\n   * **Performance:** O(n) where n is the number of entries in the iterable.\n   *\n   * @example\n   *\n   * ```ts\n   * const map = IMap.create<string, number | string>([\n   *   ['id', 1],\n   *   ['status', 'active'],\n   * ]);\n   *\n   * assert.isTrue(map.size === 2);\n   *\n   * assert.deepStrictEqual(map.get('status'), Optional.some('active'));\n   * ```\n   *\n   * @template K The type of the keys. Must extend MapSetKeyType.\n   * @template V The type of the values.\n   * @param iterable An iterable of key-value pairs (e.g., Array, Map, IMap,\n   *   etc.)\n   * @returns A new IMap instance containing all entries from the iterable.\n   */\n  export const create = <K extends MapSetKeyType, V>(\n    iterable: Iterable<readonly [K, V]>,\n  ): IMap<K, V> => new IMapClass<K, V>(iterable);\n\n  /**\n   * Checks if two IMap instances are structurally equal.\n   *\n   * Two IMaps are considered equal if they have the same size and contain\n   * exactly the same key-value pairs. The order of entries does not matter for\n   * equality comparison. Values are compared using JavaScript's `===`\n   * operator.\n   *\n   * **Performance:** O(n) where n is the size of the smaller map.\n   *\n   * @example\n   *\n   * ```ts\n   * const first = IMap.create<'a' | 'b', number>([\n   *   ['a', 1],\n   *   ['b', 2],\n   * ]);\n   *\n   * const second = IMap.create<'a' | 'b', number>([\n   *   ['b', 2],\n   *   ['a', 1],\n   * ]);\n   *\n   * const third = IMap.create<'a' | 'b', number>([\n   *   ['a', 1],\n   *   ['b', 3],\n   * ]);\n   *\n   * assert.isTrue(IMap.equal(first, second));\n   *\n   * assert.isFalse(IMap.equal(first, third));\n   * ```\n   *\n   * @template K The type of the keys.\n   * @template V The type of the values.\n   * @param a The first IMap instance to compare.\n   * @param b The second IMap instance to compare.\n   * @returns `true` if the maps contain exactly the same key-value pairs,\n   *   `false` otherwise.\n   */\n  export const equal = <K extends MapSetKeyType, V>(\n    a: IMap<K, V>,\n    b: IMap<K, V>,\n  ): boolean =>\n    a.size === b.size &&\n    a.every(\n      (v, k) =>\n        pipe(b.get(k)).map((v2) => Optional.isSome(v2) && v2.value === v).value,\n    );\n}\n\n/**\n * Internal class implementation for IMap providing immutable map operations.\n *\n * This class implements the IMap interface using JavaScript's native Map as the\n * underlying storage mechanism for optimal performance. All mutation operations\n * create new instances rather than modifying the existing map, ensuring\n * immutability.\n *\n * **Implementation Details:**\n *\n * - Uses Map<K, V> 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 keys. Must extend MapSetKeyType.\n * @template V The type of the values.\n * @implements IMap\n * @implements Iterable\n * @internal This class should not be used directly. Use IMap.create() instead.\n */\nclass IMapClass<K extends MapSetKeyType, V>\n  implements IMap<K, V>, Iterable<readonly [K, V]>\n{\n  readonly #map: ReadonlyMap<K, V>;\n  readonly #showNotFoundMessage: boolean;\n\n  /**\n   * Constructs an IMapClass instance with the given entries.\n   *\n   * @param iterable An iterable of key-value pairs to populate the map.\n   * @param showNotFoundMessage Whether to log warning messages when operations\n   *   are performed on non-existent keys. Useful for debugging. Defaults to\n   *   false for production use.\n   * @internal Use IMap.create() instead of calling this constructor directly.\n   */\n  constructor(\n    iterable: Iterable<readonly [K, V]>,\n    showNotFoundMessage: boolean = false,\n  ) {\n    this.#map = new Map(iterable);\n\n    this.#showNotFoundMessage = showNotFoundMessage;\n  }\n\n  /** @inheritdoc */\n  get size(): SizeType.Arr {\n    return asUint32(this.#map.size);\n  }\n\n  /** @inheritdoc */\n  has(key: K | (WidenLiteral<K> & {})): boolean {\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unnecessary-type-assertion -- unnecessary only under the strict standard library; the stock one types `has` as taking exactly `K`\n    return this.#map.has(key as K);\n  }\n\n  /** @inheritdoc */\n  get(key: K | (WidenLiteral<K> & {})): Optional<V> {\n    if (!this.has(key)) return Optional.none;\n\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-non-null-assertion\n    return Optional.some(this.#map.get(key as K)!);\n  }\n\n  /** @inheritdoc */\n  every<W extends V>(\n    predicate: (value: V, key: K) => value is W,\n  ): this is IMap<K, W>;\n\n  /** @inheritdoc */\n  every(predicate: (value: V, key: K) => boolean): boolean;\n\n  /** @inheritdoc */\n  every(predicate: (value: V, key: K) => boolean): boolean {\n    for (const [k, v] of this.entries()) {\n      if (!predicate(v, k)) return false;\n    }\n\n    return true;\n  }\n\n  /** @inheritdoc */\n  some(predicate: (value: V, key: K) => boolean): boolean {\n    for (const [k, v] of this.entries()) {\n      if (predicate(v, k)) return true;\n    }\n\n    return false;\n  }\n\n  /** @inheritdoc */\n  delete(key: K): IMap<K, V> {\n    if (!this.has(key)) {\n      if (this.#showNotFoundMessage) {\n        const keyStr = unknownToString(key);\n\n        console.warn(`IMap.delete: key not found: ${keyStr}`);\n      }\n\n      return this;\n    }\n\n    return IMap.create(\n      Array.from(this.#map).filter(([k]) => !Object.is(k, key)),\n    );\n  }\n\n  /** @inheritdoc */\n  set(key: K, value: V): IMap<K, V> {\n    const curr = this.get(key);\n\n    if (Optional.isSome(curr) && value === curr.value) return this; // has no changes\n\n    if (!this.has(key)) {\n      return IMap.create([...this.#map, tp(key, value)]);\n    }\n\n    return IMap.create(\n      Array.from(this.#map, ([k, v]) => tp(k, Object.is(k, key) ? value : v)),\n    );\n  }\n\n  /** @inheritdoc */\n  update(key: K, updater: (value: V) => V): IMap<K, V> {\n    const curr = this.get(key);\n\n    if (Optional.isNone(curr)) {\n      if (this.#showNotFoundMessage) {\n        const keyStr = unknownToString(key);\n\n        console.warn(`IMap.update: key not found: ${keyStr}`);\n      }\n\n      return this;\n    }\n\n    return IMap.create(\n      Array.from(this.#map, ([k, v]) =>\n        tp(k, Object.is(k, key) ? updater(curr.value) : v),\n      ),\n    );\n  }\n\n  /** @inheritdoc */\n  withMutations(\n    actions: readonly Readonly<\n      | { type: 'delete'; key: K }\n      | { type: 'set'; key: K; value: V }\n      | { type: 'update'; key: K; updater: (value: V) => V }\n    >[],\n  ): IMap<K, V> {\n    const mut_result = new Map<K, V>(this.#map);\n\n    const updateFn = (\n      action: Readonly<\n        | { type: 'delete'; key: K }\n        | { type: 'set'; key: K; value: V }\n        | { type: 'update'; key: K; updater: (value: V) => V }\n      >,\n    ): void => {\n      switch (action.type) {\n        case 'delete':\n          mut_result.delete(action.key);\n\n          break;\n\n        case 'set':\n          mut_result.set(action.key, action.value);\n\n          break;\n\n        case 'update': {\n          const { key } = action;\n\n          const curr = mut_result.get(key);\n\n          if (curr === undefined || !mut_result.has(key)) {\n            if (this.#showNotFoundMessage) {\n              const keyStr = unknownToString(key);\n\n              console.warn(`IMap.withMutations: key not found: ${keyStr}`);\n            }\n\n            break;\n          }\n\n          mut_result.set(key, action.updater(curr));\n\n          break;\n        }\n      }\n    };\n\n    for (const action of actions) {\n      updateFn(action);\n    }\n\n    return IMap.create(mut_result);\n  }\n\n  /** @inheritdoc */\n  map<V2>(mapFn: (value: V, key: K) => V2): IMap<K, V2> {\n    return IMap.create(this.toArray().map(([k, v]) => tp(k, mapFn(v, k))));\n  }\n\n  /** @inheritdoc */\n  mapKeys<K2 extends MapSetKeyType>(mapFn: (key: K) => K2): IMap<K2, V> {\n    return IMap.create(this.toArray().map(([k, v]) => tp(mapFn(k), v)));\n  }\n\n  /** @inheritdoc */\n  mapEntries<K2 extends MapSetKeyType, V2>(\n    mapFn: (entry: readonly [K, V]) => readonly [K2, V2],\n  ): IMap<K2, V2> {\n    return IMap.create(this.toArray().map(mapFn));\n  }\n\n  /** @inheritdoc */\n  forEach(callbackfn: (value: V, key: K) => void): void {\n    for (const [key, value] of this.#map) {\n      callbackfn(value, key);\n    }\n  }\n\n  /**\n   * @example\n   *\n   * ```ts\n   * const entries = [\n   *   ['first', 1],\n   *   ['second', 2],\n   * ] as const satisfies readonly (readonly [string, number])[];\n   *\n   * const map = IMap.create(entries);\n   *\n   * const collected = Array.from(map);\n   *\n   * assert.deepStrictEqual(collected, [\n   *   ['first', 1],\n   *   ['second', 2],\n   * ]);\n   * ```\n   *\n   * @inheritdoc\n   */\n  [Symbol.iterator](): Iterator<readonly [K, V]> {\n    return this.#map[Symbol.iterator]();\n  }\n\n  /** @inheritdoc */\n  keys(): IterableIterator<K> {\n    return this.#map.keys();\n  }\n\n  /** @inheritdoc */\n  values(): IterableIterator<V> {\n    return this.#map.values();\n  }\n\n  /** @inheritdoc */\n  entries(): IterableIterator<readonly [K, V]> {\n    return this.#map.entries();\n  }\n\n  /** @inheritdoc */\n  toKeysArray(): readonly K[] {\n    return Array.from(this.keys());\n  }\n\n  /** @inheritdoc */\n  toValuesArray(): readonly V[] {\n    return Array.from(this.values());\n  }\n\n  /** @inheritdoc */\n  toEntriesArray(): readonly (readonly [K, V])[] {\n    return Array.from(this.entries());\n  }\n\n  /** @inheritdoc */\n  toArray(): readonly (readonly [K, V])[] {\n    return Array.from(this.entries());\n  }\n\n  /** @inheritdoc */\n  toRawMap(): ReadonlyMap<K, V> {\n    return this.#map;\n  }\n}\n"],"names":["IMap","Optional.isSome","Optional.none","Optional.some","Optional.isNone"],"mappings":"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"}
+{"version":3,"file":"imap.mjs","sourceRoot":"","sources":["../../src/collections/imap.mts"],"names":[],"mappings":"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"}

package/dist/collections/index.mjs

@@ -1,7 +1,7 @@
-export { IMapMapped } from './imap-mapped.mjs';
-export { IMap } from './imap.mjs';
-export { ISetMapped } from './iset-mapped.mjs';
-export { ISet } from './iset.mjs';
-export { createQueue } from './queue.mjs';
-export { createStack } from './stack.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './imap-mapped.mjs';
+export * from './imap.mjs';
+export * from './iset-mapped.mjs';
+export * from './iset.mjs';
+export * from './queue.mjs';
+export * from './stack.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/collections/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/collections/index.mts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}