ts-data-forge 9.0.0 → 10.0.0

package/dist/collections/imap-mapped.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"imap-mapped.mjs","sources":["../../src/collections/imap-mapped.mts"],"sourcesContent":[null],"names":["Optional.isSome","Optional.none","Optional.some","Optional.isNone"],"mappings":"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"}
+{"version":3,"file":"imap-mapped.mjs","sources":["../../src/collections/imap-mapped.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 } from '../others/index.mjs';\nimport { type MapSetKeyType, type SizeType } from '../types.mjs';\n\n/**\n * Interface for an immutable map with custom key mapping and lookup operations.\n *\n * IMapMapped allows you to use complex objects as keys by providing\n * transformation functions that convert between your custom key type `K` and a\n * primitive `MapSetKeyType` `KM` that can be efficiently stored in JavaScript's\n * native Map. This enables operations on maps with complex keys while\n * maintaining type safety and immutability.\n *\n * **Key Features:**\n *\n * - **Custom Key Types**: Use any type as keys by providing `toKey`/`fromKey`\n *   functions\n * - **Immutable**: All operations return new instances, preserving immutability\n * - **Type Safe**: Full TypeScript support with generic key/value types\n *\n * **Performance Characteristics:**\n *\n * - get/has: O(1) average case (plus key transformation overhead)\n * - set/delete: O(n) due to copying for immutability (plus key transformation\n *   overhead)\n * - map/filter operations: O(n)\n * - iteration: O(n) (plus key transformation overhead)\n *\n * @template K The type of the custom keys in the map.\n * @template V The type of the values in the map.\n * @template KM The type of the mapped primitive keys (string, number, etc.).\n */\ntype IMapMappedInterface<K, V, KM extends MapSetKeyType> = Readonly<{\n  // Getting information\n\n  /**\n   * The number of elements in the map.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.isTrue(map.size === 2);\n   * ```\n   */\n  size: SizeType.Arr;\n\n  /**\n   * Checks if a key exists in the map.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [[{ x: 1, y: 2 }, 'A']],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.isTrue(map.has({ x: 1, y: 2 }));\n   *\n   * assert.isFalse(map.has({ x: 3, y: 4 }));\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   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [[{ x: 1, y: 2 }, 'A']],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.deepStrictEqual(map.get({ x: 1, y: 2 }), Optional.some('A'));\n   *\n   * assert.deepStrictEqual(map.get({ x: 0, y: 0 }), 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   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, number, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 2],\n   *     [{ x: 1, y: 0 }, 4],\n   *   ],\n   *   toKey,\n   *   fromKey,\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 IMapMapped<K, W, KM>);\n\n  /**\n   * Checks if at least one element in the map satisfies a predicate.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, number, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 3],\n   *     [{ x: 1, y: 0 }, 7],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.isTrue(map.some((value) => value > 5));\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   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const original = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const withoutRight = original.delete({ x: 1, y: 0 });\n   *\n   * assert.deepStrictEqual(\n   *   original.get({ x: 1, y: 0 }),\n   *   Optional.some('right'),\n   * );\n   *\n   * assert.deepStrictEqual(withoutRight.get({ x: 1, y: 0 }), Optional.none);\n   *\n   * assert.isTrue(original.size === 2);\n   *\n   * assert.isTrue(withoutRight.size === 1);\n   * ```\n   *\n   * @param key The key to delete.\n   * @returns A new IMapMapped instance without the specified key.\n   */\n  delete: (key: K) => IMapMapped<K, V, KM>;\n\n  /**\n   * Sets a key-value pair in the map.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const base = IMapMapped.create<Point, string, string>(\n   *   [[{ x: 0, y: 0 }, 'origin']],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const updated = base.set({ x: 0, y: 0 }, 'home');\n   *\n   * const extended = base.set({ x: 1, y: 0 }, 'right');\n   *\n   * assert.deepStrictEqual(base.get({ x: 0, y: 0 }), Optional.some('origin'));\n   *\n   * assert.deepStrictEqual(updated.get({ x: 0, y: 0 }), Optional.some('home'));\n   *\n   * assert.deepStrictEqual(\n   *   extended.get({ x: 1, y: 0 }),\n   *   Optional.some('right'),\n   * );\n   * ```\n   *\n   * @param key The key to set.\n   * @param value The value to associate with the key.\n   * @returns A new IMapMapped instance with the specified key-value pair.\n   */\n  set: (key: K, value: V) => IMapMapped<K, V, KM>;\n\n  /**\n   * Updates the value associated with a key using an updater function.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const scores = IMapMapped.create<Point, number, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 10],\n   *     [{ x: 1, y: 0 }, 8],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const boosted = scores.update({ x: 0, y: 0 }, (value) => value + 5);\n   *\n   * const unchanged = scores.update({ x: 9, y: 9 }, (value) => value + 1);\n   *\n   * assert.deepStrictEqual(boosted.get({ x: 0, y: 0 }), Optional.some(15));\n   *\n   * assert.deepStrictEqual(scores.get({ x: 0, y: 0 }), 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 IMapMapped instance with the updated value.\n   */\n  update: (key: K, updater: (value: V) => V) => IMapMapped<K, V, KM>;\n\n  /**\n   * Applies a series of mutations to the map.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const base = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const mutated = base.withMutations([\n   *   { type: 'set', key: { x: 2, y: 0 }, value: 'far' },\n   *   { type: 'update', key: { x: 1, y: 0 }, updater: (v) => v.toUpperCase() },\n   *   { type: 'delete', key: { x: 0, y: 0 } },\n   * ]);\n   *\n   * assert.deepStrictEqual(mutated.get({ x: 2, y: 0 }), Optional.some('far'));\n   *\n   * assert.deepStrictEqual(mutated.get({ x: 1, y: 0 }), Optional.some('RIGHT'));\n   *\n   * assert.deepStrictEqual(mutated.get({ x: 0, y: 0 }), Optional.none);\n   *\n   * assert.deepStrictEqual(base.get({ x: 1, y: 0 }), Optional.some('right'));\n   * ```\n   *\n   * @param actions An array of mutation actions (delete, set, or update).\n   * @returns A new IMapMapped 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  ) => IMapMapped<K, V, KM>;\n\n  // Sequence algorithms\n\n  /**\n   * Maps the values of the map to new values.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, number, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 1],\n   *     [{ x: 1, y: 0 }, 2],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const doubled = map.map((value) => value * 2);\n   *\n   * assert.deepStrictEqual(Array.from(doubled), [\n   *   [{ x: 0, y: 0 }, 2],\n   *   [{ x: 1, y: 0 }, 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 IMapMapped instance with mapped values.\n   */\n  map: <V2>(mapFn: (value: V, key: K) => V2) => IMapMapped<K, V2, KM>;\n\n  /**\n   * Maps the keys of the map to new keys. Note: The key type cannot be changed\n   * because `toKey` and `fromKey` would become unusable.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const shifted = map.mapKeys((p) => ({ x: p.x + 10, y: p.y + 10 }));\n   *\n   * assert.deepStrictEqual(Array.from(shifted), [\n   *   [{ x: 10, y: 10 }, 'origin'],\n   *   [{ x: 11, y: 10 }, 'right'],\n   * ]);\n   * ```\n   *\n   * @param mapFn A function that maps a key to a new key of the same type.\n   * @returns A new IMapMapped instance with mapped keys.\n   */\n  mapKeys: (mapFn: (key: K) => K) => IMapMapped<K, V, KM>;\n\n  /**\n   * Maps the entries (key-value pairs) of the map to new entries.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, number, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 1],\n   *     [{ x: 1, y: 0 }, 2],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const labeled = map.mapEntries(([key, value]) => [key, `value=${value}`]);\n   *\n   * assert.deepStrictEqual(Array.from(labeled), [\n   *   [{ x: 0, y: 0 }, 'value=1'],\n   *   [{ x: 1, y: 0 }, 'value=2'],\n   * ]);\n   * ```\n   *\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 (key must remain\n   *   the same type).\n   * @returns A new IMapMapped instance with mapped entries.\n   */\n  mapEntries: <V2>(\n    mapFn: (entry: readonly [K, V]) => readonly [K, V2],\n  ) => IMapMapped<K, V2, KM>;\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   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const mut_entries: (readonly [Point, string])[] = [];\n   *\n   * map.forEach((value, key) => {\n   *   mut_entries.push([key, value]);\n   * });\n   *\n   * assert.deepStrictEqual(mut_entries, [\n   *   [{ x: 0, y: 0 }, 'origin'],\n   *   [{ x: 1, y: 0 }, 'right'],\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   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const keys = Array.from(map.keys());\n   *\n   * assert.deepStrictEqual(keys, [\n   *   { x: 0, y: 0 },\n   *   { x: 1, y: 0 },\n   * ]);\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   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const values = Array.from(map.values());\n   *\n   * assert.deepStrictEqual(values, ['origin', 'right']);\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   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const entries = Array.from(map.entries());\n   *\n   * assert.deepStrictEqual(entries, [\n   *   [{ x: 0, y: 0 }, 'origin'],\n   *   [{ x: 1, y: 0 }, 'right'],\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   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.deepStrictEqual(map.toKeysArray(), [\n   *   { x: 0, y: 0 },\n   *   { x: 1, y: 0 },\n   * ]);\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   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.deepStrictEqual(map.toValuesArray(), ['origin', 'right']);\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   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.deepStrictEqual(map.toEntriesArray(), [\n   *   [{ x: 0, y: 0 }, 'origin'],\n   *   [{ x: 1, y: 0 }, 'right'],\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   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.deepStrictEqual(map.toArray(), [\n   *   [{ x: 0, y: 0 }, 'origin'],\n   *   [{ x: 1, y: 0 }, 'right'],\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   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [[{ x: 1, y: 2 }, 'A']],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const raw = map.toRawMap();\n   *\n   * assert.isTrue(isMap(raw));\n   *\n   * assert.isTrue(raw.get(toKey({ x: 1, y: 2 })) === 'A');\n   * ```\n   *\n   * @returns The raw ReadonlyMap instance.\n   */\n  toRawMap: () => ReadonlyMap<KM, V>;\n}>;\n\n/**\n * Represents an immutable map with custom key transformation and\n * high-performance operations.\n *\n * IMapMapped is a specialized persistent data structure that enables using\n * complex objects as map keys while maintaining the performance benefits of\n * JavaScript's native Map. It achieves this by requiring bidirectional\n * transformation functions that convert between your custom key type and a\n * primitive type that can be efficiently stored and compared.\n *\n * **Key Features:**\n *\n * - **Complex Keys**: Use objects, arrays, or any custom type as map keys\n * - **Immutable**: All mutation operations return new instances\n * - **Type Safe**: Full TypeScript support with compile-time key/value type\n *   checking\n * - **Bidirectional**: Maintains ability to reconstruct original keys from mapped\n *   keys\n *\n * **Use Cases:**\n *\n * - Maps with composite keys (e.g., coordinates, user IDs with metadata)\n * - Caching with complex cache keys\n * - State management where entities have multi-part identifiers\n * - Performance-critical maps with non-primitive keys\n *\n * @template K The type of the custom keys in the map.\n * @template V The type of the values in the map.\n * @template KM The type of the mapped primitive keys (string, number, etc.).\n */\nexport type IMapMapped<K, V, KM extends MapSetKeyType> = Iterable<\n  readonly [K, V]\n> &\n  IMapMappedInterface<K, V, KM>;\n\n/** Provides utility functions for IMapMapped. */\nexport namespace IMapMapped {\n  /**\n   * Creates a new IMapMapped instance with custom key transformation functions.\n   *\n   * This factory function creates an immutable map that can use complex objects\n   * as keys by providing bidirectional transformation functions. The `toKey`\n   * function converts your custom key type to a primitive type that can be\n   * efficiently stored, while `fromKey` reconstructs the original key type for\n   * iteration and access.\n   *\n   * **Performance:** O(n) where n is the number of entries in the iterable.\n   *\n   * @template K The type of the custom keys.\n   * @template V The type of the values.\n   * @template KM The type of the mapped primitive keys.\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.isTrue(map.size === 2);\n   *\n   * assert.deepStrictEqual(map.get({ x: 0, y: 0 }), Optional.some('origin'));\n   * ```\n   *\n   * @param iterable An iterable of key-value pairs using the custom key type.\n   * @param toKey A function that converts a custom key `K` to a primitive key\n   *   `KM`. This function must be deterministic and produce unique values for\n   *   unique keys.\n   * @param fromKey A function that converts a primitive key `KM` back to the\n   *   custom key `K`. This should be the inverse of `toKey`.\n   * @returns A new IMapMapped instance containing all entries from the\n   *   iterable.\n   */\n  export const create = <K, V, KM extends MapSetKeyType>(\n    iterable: Iterable<readonly [K, V]>,\n    toKey: (a: K) => KM,\n    fromKey: (k: KM) => K,\n  ): IMapMapped<K, V, KM> =>\n    new IMapMappedClass<K, V, KM>(iterable, toKey, fromKey);\n\n  /**\n   * Checks if two IMapMapped instances are structurally equal.\n   *\n   * Two IMapMapped instances are considered equal if they have the same size\n   * and contain exactly the same key-value pairs. The comparison is performed\n   * on the underlying mapped keys and values, so the transformation functions\n   * themselves don't need to be identical. Values are compared using\n   * JavaScript's `===` operator.\n   *\n   * **Performance:** O(n) where n is the size of the smaller map.\n   *\n   * @template K The type of the custom keys.\n   * @template V The type of the values.\n   * @template KM The type of the mapped primitive keys.\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const first = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const second = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 1, y: 0 }, 'right'],\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const third = IMapMapped.create<Point, string, string>(\n   *   [[{ x: 0, y: 0 }, 'different']],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.isTrue(IMapMapped.equal(first, second));\n   *\n   * assert.isFalse(IMapMapped.equal(first, third));\n   * ```\n   *\n   * @param a The first IMapMapped instance to compare.\n   * @param b The second IMapMapped 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, V, KM extends MapSetKeyType>(\n    a: IMapMapped<K, V, KM>,\n    b: IMapMapped<K, V, KM>,\n  ): boolean =>\n    a.size === b.size &&\n    a.every(\n      (v, k) =>\n        pipe(b.get(k)).map((bv) => Optional.isSome(bv) && bv.value === v).value,\n    );\n}\n\n/**\n * Internal class implementation for IMapMapped providing immutable map\n * operations with key transformation.\n *\n * This class implements the IMapMapped interface by maintaining a JavaScript\n * Map with primitive keys internally while exposing an API that works with\n * custom key types. The transformation between custom and primitive keys is\n * handled transparently through the provided `toKey` and `fromKey` functions.\n *\n * **Implementation Details:**\n *\n * - Uses ReadonlyMap<KM, V> internally where KM is the primitive key type\n * - Stores transformation functions for bidirectional key conversion\n * - Implements copy-on-write semantics for efficiency\n * - Provides optional debug messaging for development\n *\n * @template K The type of the custom keys.\n * @template V The type of the values.\n * @template KM The type of the mapped primitive keys.\n * @implements IMapMapped\n * @implements Iterable\n * @internal This class should not be used directly. Use IMapMapped.create() instead.\n */\nclass IMapMappedClass<K, V, KM extends MapSetKeyType>\n  implements IMapMapped<K, V, KM>, Iterable<readonly [K, V]>\n{\n  readonly #map: ReadonlyMap<KM, V>;\n  readonly #toKey: (a: K) => KM;\n  readonly #fromKey: (k: KM) => K;\n  readonly #showNotFoundMessage: boolean;\n\n  /**\n   * Constructs an IMapMappedClass instance with custom key transformation.\n   *\n   * @param iterable An iterable of key-value pairs using the custom key type K.\n   * @param toKey A function that converts a custom key K to a primitive key KM.\n   *   Must be deterministic and produce unique values for unique keys.\n   * @param fromKey A function that converts a primitive key KM back to the\n   *   custom key K. Should be the inverse of the toKey function.\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 IMapMapped.create() instead of calling this constructor directly.\n   */\n  constructor(\n    iterable: Iterable<readonly [K, V]>,\n    toKey: (a: K) => KM,\n    fromKey: (k: KM) => K,\n    showNotFoundMessage: boolean = false,\n  ) {\n    this.#map = new Map(Array.from(iterable, ([k, v]) => [toKey(k), v]));\n\n    this.#toKey = toKey;\n\n    this.#fromKey = fromKey;\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\n    return this.#map.has(this.#toKey(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 @typescript-eslint/no-non-null-assertion, total-functions/no-unsafe-type-assertion\n    return Optional.some(this.#map.get(this.#toKey(key as K))!);\n  }\n\n  /** @inheritdoc */\n  every<W extends V>(\n    predicate: (value: V, key: K) => value is W,\n  ): this is IMapMapped<K, W, KM>;\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): IMapMapped<K, V, KM> {\n    if (!this.has(key)) {\n      if (this.#showNotFoundMessage) {\n        console.warn(\n          `IMapMapped.delete: key not found: ${String(this.#toKey(key))}`,\n        );\n      }\n\n      return this;\n    }\n\n    const keyMapped = this.#toKey(key);\n\n    return IMapMapped.create(\n      Array.from(this.#map)\n        .filter(([km]) => !Object.is(km, keyMapped))\n        .map(([km, v]) => tp(this.#fromKey(km), v)),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  set(key: K, value: V): IMapMapped<K, V, KM> {\n    const curr = this.get(key);\n\n    if (Optional.isSome(curr) && value === curr.value) return this;\n\n    const keyMapped = this.#toKey(key);\n\n    if (!this.has(key)) {\n      return IMapMapped.create(\n        [...this.#map, tp(keyMapped, value)].map(([km, v]) =>\n          tp(this.#fromKey(km), v),\n        ),\n        this.#toKey,\n        this.#fromKey,\n      );\n    }\n\n    return IMapMapped.create(\n      Array.from(this.#map, ([km, v]) =>\n        tp(this.#fromKey(km), Object.is(km, keyMapped) ? value : v),\n      ),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  update(key: K, updater: (value: V) => V): IMapMapped<K, V, KM> {\n    const curr = this.get(key);\n\n    if (Optional.isNone(curr)) {\n      if (this.#showNotFoundMessage) {\n        console.warn(\n          `IMapMapped.update: key not found: ${String(this.#toKey(key))}`,\n        );\n      }\n\n      return this;\n    }\n\n    const keyMapped = this.#toKey(key);\n\n    return IMapMapped.create(\n      Array.from(this.#map, ([km, v]) =>\n        tp(\n          this.#fromKey(km),\n          Object.is(km, keyMapped) ? updater(curr.value) : v,\n        ),\n      ),\n      this.#toKey,\n      this.#fromKey,\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  ): IMapMapped<K, V, KM> {\n    const mut_result = new Map<KM, 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      const key = this.#toKey(action.key);\n\n      switch (action.type) {\n        case 'delete':\n          mut_result.delete(key);\n\n          break;\n\n        case 'set':\n          mut_result.set(key, action.value);\n\n          break;\n\n        case 'update': {\n          const curr = mut_result.get(key);\n\n          if (!mut_result.has(key) || curr === undefined) {\n            if (this.#showNotFoundMessage) {\n              console.warn(\n                `IMapMapped.withMutations::update: key not found: ${String(key)}`,\n              );\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 IMapMapped.create<K, V, KM>(\n      Array.from(mut_result, ([k, v]) => [this.#fromKey(k), v]),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  map<V2>(mapFn: (value: V, key: K) => V2): IMapMapped<K, V2, KM> {\n    return IMapMapped.create(\n      this.toArray().map(([k, v]) => tp(k, mapFn(v, k))),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  mapKeys(mapFn: (key: K) => K): IMapMapped<K, V, KM> {\n    return IMapMapped.create(\n      this.toArray().map(([k, v]) => tp(mapFn(k), v)),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  mapEntries<V2>(\n    mapFn: (entry: readonly [K, V]) => readonly [K, V2],\n  ): IMapMapped<K, V2, KM> {\n    return IMapMapped.create(\n      this.toArray().map(mapFn),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  forEach(callbackfn: (value: V, key: K) => void): void {\n    for (const [km, value] of this.#map) {\n      callbackfn(value, this.#fromKey(km));\n    }\n  }\n\n  /**\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; y: number }>;\n   *\n   * const toKey = (p: Point) => JSON.stringify(p);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const map = IMapMapped.create<Point, string, string>(\n   *   [\n   *     [{ x: 0, y: 0 }, 'origin'],\n   *     [{ x: 1, y: 0 }, 'right'],\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const collected = Array.from(map);\n   *\n   * assert.deepStrictEqual(collected, [\n   *   [{ x: 0, y: 0 }, 'origin'],\n   *   [{ x: 1, y: 0 }, 'right'],\n   * ]);\n   * ```\n   *\n   * @inheritdoc\n   */\n  *[Symbol.iterator](): Iterator<readonly [K, V]> {\n    for (const e of this.entries()) {\n      yield e;\n    }\n  }\n\n  /** @inheritdoc */\n  *keys(): IterableIterator<K> {\n    for (const km of this.#map.keys()) {\n      yield this.#fromKey(km);\n    }\n  }\n\n  /** @inheritdoc */\n  values(): IterableIterator<V> {\n    return this.#map.values();\n  }\n\n  /** @inheritdoc */\n  *entries(): IterableIterator<readonly [K, V]> {\n    for (const [km, v] of this.#map) {\n      yield [this.#fromKey(km), v];\n    }\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<KM, V> {\n    return this.#map;\n  }\n}\n"],"names":["IMapMapped","Optional.isSome","Optional.none","Optional.some","Optional.isNone"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAozBO,IAAU;AAAA,CAAV,CAAUA,WAAAA,KAAV;AAgDE,EAAMA,WAAAA,CAAA,MAAA,GAAS,CACpB,QAAA,EACA,KAAA,EACA,YAEA,IAAI,eAAA,CAA0B,QAAA,EAAU,KAAA,EAAO,OAAO,CAAA;AA4DjD,EAAMA,WAAAA,CAAA,QAAQ,CACnB,CAAA,EACA,MAEA,CAAA,CAAE,IAAA,KAAS,CAAA,CAAE,IAAA,IACb,CAAA,CAAE,KAAA;AAAA,IACA,CAAC,CAAA,EAAG,CAAA,KACF,KAAK,CAAA,CAAE,GAAA,CAAI,CAAC,CAAC,CAAA,CAAE,IAAI,CAAC,EAAA,KAAOC,MAAS,CAAO,EAAE,KAAK,EAAA,CAAG,KAAA,KAAU,CAAC,CAAA,CAAE;AAAA,GACtE;AAAA,CAAA,EAzHa,UAAA,KAAA,UAAA,GAAA,EAAA,CAAA,CAAA;AAmJjB,MAAM,eAAA,CAEN;AAAA,EACW,IAAA;AAAA,EACA,MAAA;AAAA,EACA,QAAA;AAAA,EACA,oBAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeT,WAAA,CACE,QAAA,EACA,KAAA,EACA,OAAA,EACA,sBAA+B,KAAA,EAC/B;AACA,IAAA,IAAA,CAAK,OAAO,IAAI,GAAA,CAAI,KAAA,CAAM,IAAA,CAAK,UAAU,CAAC,CAAC,CAAA,EAAG,CAAC,MAAM,CAAC,KAAA,CAAM,CAAC,CAAA,EAAG,CAAC,CAAC,CAAC,CAAA;AAEnE,IAAA,IAAA,CAAK,MAAA,GAAS,KAAA;AAEd,IAAA,IAAA,CAAK,QAAA,GAAW,OAAA;AAEhB,IAAA,IAAA,CAAK,oBAAA,GAAuB,mBAAA;AAAA,EAC9B;AAAA;AAAA,EAGA,IAAI,IAAA,GAAqB;AACvB,IAAA,OAAO,QAAA,CAAS,IAAA,CAAK,IAAA,CAAK,IAAI,CAAA;AAAA,EAChC;AAAA;AAAA,EAGA,IAAI,GAAA,EAA0C;AAE5C,IAAA,OAAO,KAAK,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,MAAA,CAAO,GAAQ,CAAC,CAAA;AAAA,EAC5C;AAAA;AAAA,EAGA,IAAI,GAAA,EAA8C;AAChD,IAAA,IAAI,CAAC,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA,SAAUC,IAAS;AAGpC,IAAA,OAAOC,KAAc,IAAA,CAAK,IAAA,CAAK,IAAI,IAAA,CAAK,MAAA,CAAO,GAAQ,CAAC,CAAE,CAAA;AAAA,EAC5D;AAAA;AAAA,EAWA,MAAM,SAAA,EAAmD;AACvD,IAAA,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,CAAA,IAAK,IAAA,CAAK,SAAQ,EAAG;AACnC,MAAA,IAAI,CAAC,SAAA,CAAU,CAAA,EAAG,CAAC,GAAG,OAAO,KAAA;AAAA,IAC/B;AAEA,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA,EAGA,KAAK,SAAA,EAAmD;AACtD,IAAA,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,CAAA,IAAK,IAAA,CAAK,SAAQ,EAAG;AACnC,MAAA,IAAI,SAAA,CAAU,CAAA,EAAG,CAAC,CAAA,EAAG,OAAO,IAAA;AAAA,IAC9B;AAEA,IAAA,OAAO,KAAA;AAAA,EACT;AAAA;AAAA,EAGA,OAAO,GAAA,EAA8B;AACnC,IAAA,IAAI,CAAC,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA,EAAG;AAClB,MAAA,IAAI,KAAK,oBAAA,EAAsB;AAC7B,QAAA,OAAA,CAAQ,IAAA;AAAA,UACN,qCAAqC,MAAA,CAAO,IAAA,CAAK,MAAA,CAAO,GAAG,CAAC,CAAC,CAAA;AAAA,SAC/D;AAAA,MACF;AAEA,MAAA,OAAO,IAAA;AAAA,IACT;AAEA,IAAA,MAAM,SAAA,GAAY,IAAA,CAAK,MAAA,CAAO,GAAG,CAAA;AAEjC,IAAA,OAAO,UAAA,CAAW,MAAA;AAAA,MAChB,KAAA,CAAM,IAAA,CAAK,IAAA,CAAK,IAAI,CAAA,CACjB,MAAA,CAAO,CAAC,CAAC,EAAE,CAAA,KAAM,CAAC,MAAA,CAAO,EAAA,CAAG,EAAA,EAAI,SAAS,CAAC,CAAA,CAC1C,GAAA,CAAI,CAAC,CAAC,EAAA,EAAI,CAAC,CAAA,KAAM,EAAA,CAAG,IAAA,CAAK,QAAA,CAAS,EAAE,CAAA,EAAG,CAAC,CAAC,CAAA;AAAA,MAC5C,IAAA,CAAK,MAAA;AAAA,MACL,IAAA,CAAK;AAAA,KACP;AAAA,EACF;AAAA;AAAA,EAGA,GAAA,CAAI,KAAQ,KAAA,EAAgC;AAC1C,IAAA,MAAM,IAAA,GAAO,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA;AAEzB,IAAA,IAAIF,MAAS,CAAO,IAAI,KAAK,KAAA,KAAU,IAAA,CAAK,OAAO,OAAO,IAAA;AAE1D,IAAA,MAAM,SAAA,GAAY,IAAA,CAAK,MAAA,CAAO,GAAG,CAAA;AAEjC,IAAA,IAAI,CAAC,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA,EAAG;AAClB,MAAA,OAAO,UAAA,CAAW,MAAA;AAAA,QAChB,CAAC,GAAG,IAAA,CAAK,IAAA,EAAM,GAAG,SAAA,EAAW,KAAK,CAAC,CAAA,CAAE,GAAA;AAAA,UAAI,CAAC,CAAC,EAAA,EAAI,CAAC,CAAA,KAC9C,GAAG,IAAA,CAAK,QAAA,CAAS,EAAE,CAAA,EAAG,CAAC;AAAA,SACzB;AAAA,QACA,IAAA,CAAK,MAAA;AAAA,QACL,IAAA,CAAK;AAAA,OACP;AAAA,IACF;AAEA,IAAA,OAAO,UAAA,CAAW,MAAA;AAAA,MAChB,KAAA,CAAM,IAAA;AAAA,QAAK,IAAA,CAAK,IAAA;AAAA,QAAM,CAAC,CAAC,EAAA,EAAI,CAAC,CAAA,KAC3B,GAAG,IAAA,CAAK,QAAA,CAAS,EAAE,CAAA,EAAG,OAAO,EAAA,CAAG,EAAA,EAAI,SAAS,CAAA,GAAI,QAAQ,CAAC;AAAA,OAC5D;AAAA,MACA,IAAA,CAAK,MAAA;AAAA,MACL,IAAA,CAAK;AAAA,KACP;AAAA,EACF;AAAA;AAAA,EAGA,MAAA,CAAO,KAAQ,OAAA,EAAgD;AAC7D,IAAA,MAAM,IAAA,GAAO,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA;AAEzB,IAAA,IAAIG,MAAS,CAAO,IAAI,CAAA,EAAG;AACzB,MAAA,IAAI,KAAK,oBAAA,EAAsB;AAC7B,QAAA,OAAA,CAAQ,IAAA;AAAA,UACN,qCAAqC,MAAA,CAAO,IAAA,CAAK,MAAA,CAAO,GAAG,CAAC,CAAC,CAAA;AAAA,SAC/D;AAAA,MACF;AAEA,MAAA,OAAO,IAAA;AAAA,IACT;AAEA,IAAA,MAAM,SAAA,GAAY,IAAA,CAAK,MAAA,CAAO,GAAG,CAAA;AAEjC,IAAA,OAAO,UAAA,CAAW,MAAA;AAAA,MAChB,KAAA,CAAM,IAAA;AAAA,QAAK,IAAA,CAAK,IAAA;AAAA,QAAM,CAAC,CAAC,EAAA,EAAI,CAAC,CAAA,KAC3B,EAAA;AAAA,UACE,IAAA,CAAK,SAAS,EAAE,CAAA;AAAA,UAChB,MAAA,CAAO,GAAG,EAAA,EAAI,SAAS,IAAI,OAAA,CAAQ,IAAA,CAAK,KAAK,CAAA,GAAI;AAAA;AACnD,OACF;AAAA,MACA,IAAA,CAAK,MAAA;AAAA,MACL,IAAA,CAAK;AAAA,KACP;AAAA,EACF;AAAA;AAAA,EAGA,cACE,OAAA,EAKsB;AACtB,IAAA,MAAM,UAAA,GAAa,IAAI,GAAA,CAAW,IAAA,CAAK,IAAI,CAAA;AAE3C,IAAA,MAAM,QAAA,GAAW,CACf,MAAA,KAKS;AACT,MAAA,MAAM,GAAA,GAAM,IAAA,CAAK,MAAA,CAAO,MAAA,CAAO,GAAG,CAAA;AAElC,MAAA,QAAQ,OAAO,IAAA;AAAM,QACnB,KAAK,QAAA;AACH,UAAA,UAAA,CAAW,OAAO,GAAG,CAAA;AAErB,UAAA;AAAA,QAEF,KAAK,KAAA;AACH,UAAA,UAAA,CAAW,GAAA,CAAI,GAAA,EAAK,MAAA,CAAO,KAAK,CAAA;AAEhC,UAAA;AAAA,QAEF,KAAK,QAAA,EAAU;AACb,UAAA,MAAM,IAAA,GAAO,UAAA,CAAW,GAAA,CAAI,GAAG,CAAA;AAE/B,UAAA,IAAI,CAAC,UAAA,CAAW,GAAA,CAAI,GAAG,CAAA,IAAK,SAAS,MAAA,EAAW;AAC9C,YAAA,IAAI,KAAK,oBAAA,EAAsB;AAC7B,cAAA,OAAA,CAAQ,IAAA;AAAA,gBACN,CAAA,iDAAA,EAAoD,MAAA,CAAO,GAAG,CAAC,CAAA;AAAA,eACjE;AAAA,YACF;AAEA,YAAA;AAAA,UACF;AAEA,UAAA,UAAA,CAAW,GAAA,CAAI,GAAA,EAAK,MAAA,CAAO,OAAA,CAAQ,IAAI,CAAC,CAAA;AAExC,UAAA;AAAA,QACF;AAAA;AACF,IACF,CAAA;AAEA,IAAA,KAAA,MAAW,UAAU,OAAA,EAAS;AAC5B,MAAA,QAAA,CAAS,MAAM,CAAA;AAAA,IACjB;AAEA,IAAA,OAAO,UAAA,CAAW,MAAA;AAAA,MAChB,KAAA,CAAM,IAAA,CAAK,UAAA,EAAY,CAAC,CAAC,CAAA,EAAG,CAAC,CAAA,KAAM,CAAC,IAAA,CAAK,QAAA,CAAS,CAAC,CAAA,EAAG,CAAC,CAAC,CAAA;AAAA,MACxD,IAAA,CAAK,MAAA;AAAA,MACL,IAAA,CAAK;AAAA,KACP;AAAA,EACF;AAAA;AAAA,EAGA,IAAQ,KAAA,EAAwD;AAC9D,IAAA,OAAO,UAAA,CAAW,MAAA;AAAA,MAChB,IAAA,CAAK,OAAA,EAAQ,CAAE,GAAA,CAAI,CAAC,CAAC,CAAA,EAAG,CAAC,CAAA,KAAM,GAAG,CAAA,EAAG,KAAA,CAAM,CAAA,EAAG,CAAC,CAAC,CAAC,CAAA;AAAA,MACjD,IAAA,CAAK,MAAA;AAAA,MACL,IAAA,CAAK;AAAA,KACP;AAAA,EACF;AAAA;AAAA,EAGA,QAAQ,KAAA,EAA4C;AAClD,IAAA,OAAO,UAAA,CAAW,MAAA;AAAA,MAChB,IAAA,CAAK,OAAA,EAAQ,CAAE,GAAA,CAAI,CAAC,CAAC,CAAA,EAAG,CAAC,CAAA,KAAM,EAAA,CAAG,KAAA,CAAM,CAAC,CAAA,EAAG,CAAC,CAAC,CAAA;AAAA,MAC9C,IAAA,CAAK,MAAA;AAAA,MACL,IAAA,CAAK;AAAA,KACP;AAAA,EACF;AAAA;AAAA,EAGA,WACE,KAAA,EACuB;AACvB,IAAA,OAAO,UAAA,CAAW,MAAA;AAAA,MAChB,IAAA,CAAK,OAAA,EAAQ,CAAE,GAAA,CAAI,KAAK,CAAA;AAAA,MACxB,IAAA,CAAK,MAAA;AAAA,MACL,IAAA,CAAK;AAAA,KACP;AAAA,EACF;AAAA;AAAA,EAGA,QAAQ,UAAA,EAA8C;AACpD,IAAA,KAAA,MAAW,CAAC,EAAA,EAAI,KAAK,CAAA,IAAK,KAAK,IAAA,EAAM;AACnC,MAAA,UAAA,CAAW,KAAA,EAAO,IAAA,CAAK,QAAA,CAAS,EAAE,CAAC,CAAA;AAAA,IACrC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgCA,EAAE,MAAA,CAAO,QAAQ,CAAA,GAA+B;AAC9C,IAAA,KAAA,MAAW,CAAA,IAAK,IAAA,CAAK,OAAA,EAAQ,EAAG;AAC9B,MAAA,MAAM,CAAA;AAAA,IACR;AAAA,EACF;AAAA;AAAA,EAGA,CAAC,IAAA,GAA4B;AAC3B,IAAA,KAAA,MAAW,EAAA,IAAM,IAAA,CAAK,IAAA,CAAK,IAAA,EAAK,EAAG;AACjC,MAAA,MAAM,IAAA,CAAK,SAAS,EAAE,CAAA;AAAA,IACxB;AAAA,EACF;AAAA;AAAA,EAGA,MAAA,GAA8B;AAC5B,IAAA,OAAO,IAAA,CAAK,KAAK,MAAA,EAAO;AAAA,EAC1B;AAAA;AAAA,EAGA,CAAC,OAAA,GAA6C;AAC5C,IAAA,KAAA,MAAW,CAAC,EAAA,EAAI,CAAC,CAAA,IAAK,KAAK,IAAA,EAAM;AAC/B,MAAA,MAAM,CAAC,IAAA,CAAK,QAAA,CAAS,EAAE,GAAG,CAAC,CAAA;AAAA,IAC7B;AAAA,EACF;AAAA;AAAA,EAGA,WAAA,GAA4B;AAC1B,IAAA,OAAO,KAAA,CAAM,IAAA,CAAK,IAAA,CAAK,IAAA,EAAM,CAAA;AAAA,EAC/B;AAAA;AAAA,EAGA,aAAA,GAA8B;AAC5B,IAAA,OAAO,KAAA,CAAM,IAAA,CAAK,IAAA,CAAK,MAAA,EAAQ,CAAA;AAAA,EACjC;AAAA;AAAA,EAGA,cAAA,GAA+C;AAC7C,IAAA,OAAO,KAAA,CAAM,IAAA,CAAK,IAAA,CAAK,OAAA,EAAS,CAAA;AAAA,EAClC;AAAA;AAAA,EAGA,OAAA,GAAwC;AACtC,IAAA,OAAO,KAAA,CAAM,IAAA,CAAK,IAAA,CAAK,OAAA,EAAS,CAAA;AAAA,EAClC;AAAA;AAAA,EAGA,QAAA,GAA+B;AAC7B,IAAA,OAAO,IAAA,CAAK,IAAA;AAAA,EACd;AACF;;;;"}

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

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

package/dist/collections/imap.mjs

@@ -43,287 +43,202 @@ import '../number/enum/uint8.mjs';
 import '../number/num.mjs';
 import '../number/refined-number-utils.mjs';
 
-/** Provides utility functions for IMap. */
 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) => isSome(v2) && v2.value === v).value);
+((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
+  );
 })(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) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        return this.#map.has(key);
-    }
-    /** @inheritdoc */
-    get(key) {
-        if (!this.has(key))
-            return none;
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-non-null-assertion
-        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)) {
+  #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 (!mut_result.has(key) || curr === void 0) {
             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; // 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 (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 (!mut_result.has(key) || curr === undefined) {
-                        if (this.#showNotFoundMessage) {
-                            const keyStr = unknownToString(key);
-                            console.warn(`IMap.withMutations: key not found: ${keyStr}`);
-                        }
-                        break;
-                    }
-                    mut_result.set(key, action.updater(curr));
-                    break;
-                }
+              const keyStr = unknownToString(key);
+              console.warn(`IMap.withMutations: key not found: ${keyStr}`);
             }
-        };
-        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);
+            break;
+          }
+          mut_result.set(key, action.updater(curr));
+          break;
         }
-    }
-    /**
-     * @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;
-    }
+      }
+    };
+    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;
+  }
 }
 
 export { IMap };