npm - ts-data-forge - Versions diffs - 14.6.1 → 14.6.3 - Mend

ts-data-forge 14.6.1 → 14.6.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (420) hide show

package/dist/collections/iset-mapped.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"iset-mapped.mjs","sources":["../../src/collections/iset-mapped.mts"],"sourcesContent":["/* eslint-disable unicorn/prefer-iterator-to-array-at-end /\nimport {\n type FixedLengthTuple,\n type ReadonlyRecord,\n type WidenLiteral,\n} from 'ts-type-forge';\nimport { asUint32 } from '../number/index.mjs';\nimport { unknownToString } from '../others/index.mjs';\nimport { type MapSetKeyType, type SizeType } from '../types.mjs';\n\n/\n Interface for an immutable set with custom element mapping and membership\n * testing.\n \n ISetMapped allows you to use complex objects as set elements by providing\n * transformation functions that convert between your custom element type `K`\n * and a primitive `MapSetKeyType` `KM` that can be efficiently stored in\n * JavaScript's native Set. This enables set operations on complex elements\n * while maintaining type safety and immutability.\n \n Key Features:\n \n - Custom Element Types: Use any type as set elements by providing\n * `toKey`/`fromKey` functions\n * - Immutable: All operations return new instances, preserving immutability\n * - Set Operations: Full support for union, intersection, difference,\n * subset/superset checks\n * - Type Safe: Full TypeScript support with generic element types\n \n Performance Characteristics:\n \n - has: O(1) average case (plus element transformation overhead)\n * - add/delete: O(n) due to copying for immutability (plus element\n * transformation overhead)\n * - set operations (union, intersection, difference): O(n)\n * - map/filter operations: O(n)\n * - iteration: O(n) (plus element transformation overhead)\n \n @template K The type of the custom elements in the set.\n * @template KM The type of the mapped primitive keys (string, number, etc.).\n /\ntype ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{\n /\n Creates a new ISetMapped instance.\n \n @param iterable An iterable of elements.\n * @param toKey A function that converts an element of type `K` to `KM`.\n * @param fromKey A function that converts a mapped key of type `KM` back to\n * `K`.\n /\n new (iterable: Iterable<K>, toKey: (a: K) => KM, fromKey: (k: KM) => K): void;\n\n // Getting information\n\n /\n The number of elements in the set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 points: readonly Point[] = [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ] as const;\n \n const set = ISetMapped.create<Point, string>(points, toKey, fromKey);\n \n assert.isTrue(set.size === 2);\n * ```\n /\n size: SizeType.Arr;\n\n /\n Checks if the set is empty.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 empty = ISetMapped.create<Point, string>([], toKey, fromKey);\n \n const points = ISetMapped.create<Point, string>(\n * [{ x: 1, tag: 'a' }],\n * toKey,\n * fromKey,\n * );\n \n assert.isTrue(empty.isEmpty);\n \n assert.isFalse(points.isEmpty);\n * ```\n /\n isEmpty: boolean;\n\n /\n Checks if an element exists in the set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [{ x: 1, tag: 'a' }],\n * toKey,\n * fromKey,\n * );\n \n assert.isTrue(set.has({ x: 1, tag: 'a' }));\n \n assert.isFalse(set.has({ x: 2, tag: 'b' }));\n * ```\n \n @param key The element to check.\n * @returns `true` if the element exists, `false` otherwise.\n /\n has: (key: K \| (WidenLiteral<K> & {})) => boolean;\n\n // Reducing a value\n\n /\n Checks if all elements in the set satisfy a type predicate. Narrows the\n * type of elements in the set if the predicate returns true for all\n * elements.\n \n \n * @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [\n * { x: 2, tag: 'even' },\n * { x: 4, tag: 'even' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const allEven = set.every((point) => point.x % 2 === 0);\n \n const narrowed = set.every(\n * (point): point is Readonly<{ x: 2 \| 4; tag: 'even' }> =>\n * point.x % 2 === 0,\n * );\n \n assert.isTrue(allEven);\n \n assert.isTrue(narrowed);\n * ```\n \n @template L The narrowed type of the elements.\n * @param predicate A function to test each element.\n * @returns `true` if all elements satisfy the predicate, `false` otherwise.\n /\n every: ((predicate: (key: K) => boolean) => boolean) &\n (<L extends K>(\n predicate: (key: K) => key is L,\n ) => this is ISetMapped<L, KM>);\n\n /\n Checks if at least one element in the set satisfies a predicate.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 5, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n assert.isTrue(set.some((point) => point.x > 4));\n \n assert.isFalse(set.some((point) => point.x > 10));\n * ```\n \n @param predicate A function to test each element.\n * @returns `true` if at least one element satisfies the predicate, `false`\n * otherwise.\n /\n some: (predicate: (key: K) => boolean) => boolean;\n\n // Mutation\n\n /\n Adds an element to the set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 = ISetMapped.create<Point, string>(\n * [{ x: 1, tag: 'a' }],\n * toKey,\n * fromKey,\n * );\n \n const withNew = base.add({ x: 2, tag: 'b' });\n \n const unchanged = base.add({ x: 1, tag: 'a' });\n \n assert.deepStrictEqual(Array.from(withNew), [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ]);\n \n assert.isTrue(unchanged === base);\n * ```\n \n @param key The element to add.\n * @returns A new ISetMapped instance with the element added.\n /\n add: (key: K) => ISetMapped<K, KM>;\n\n /\n Deletes an element from the set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const withoutSecond = base.delete({ x: 2, tag: 'b' });\n \n const unchanged = base.delete({ x: 3, tag: 'c' });\n \n assert.deepStrictEqual(Array.from(withoutSecond), [{ x: 1, tag: 'a' }]);\n \n assert.isTrue(unchanged === base);\n * ```\n \n @param key The element to delete.\n * @returns A new ISetMapped instance without the specified element.\n /\n delete: (key: K) => ISetMapped<K, KM>;\n\n /\n Applies a series of mutations to the set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const actions: readonly Readonly<\n * { type: 'add'; key: Point } \| { type: 'delete'; key: Point }\n * >[] = [\n * { type: 'add', key: { x: 3, tag: 'c' } },\n * { type: 'delete', key: { x: 1, tag: 'a' } },\n * ] as const;\n \n const mutated = base.withMutations(actions);\n \n assert.deepStrictEqual(Array.from(mutated), [\n * { x: 2, tag: 'b' },\n * { x: 3, tag: 'c' },\n * ]);\n \n assert.deepStrictEqual(Array.from(base), [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ]);\n * ```\n \n @param actions An array of mutation actions (add or delete).\n * @returns A new ISetMapped instance with all mutations applied.\n /\n withMutations: (\n actions: readonly Readonly<\n { type: 'add'; key: K } \| { type: 'delete'; key: K }\n >[],\n ) => ISetMapped<K, KM>;\n\n // Sequence algorithms\n\n /\n Maps the elements of the set to new elements. Note: The element type `K`\n * cannot be changed because `toKey` and `fromKey` would become unusable if\n * the mapped type `KM` changes.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const shifted = set.map((point) => ({\n * x: point.x + 10,\n * tag: point.tag.toUpperCase(),\n * }));\n \n assert.deepStrictEqual(Array.from(shifted), [\n * { x: 11, tag: 'A' },\n * { x: 12, tag: 'B' },\n * ]);\n * ```\n \n @param mapFn A function that maps an element to a new element of the same\n * type `K`.\n * @returns A new ISetMapped instance with mapped elements.\n /\n map: (mapFn: (key: K) => K) => ISetMapped<K, KM>;\n\n /\n Filters the elements of the set based on a predicate.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * { x: 3, tag: 'c' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const evenPoints = set.filter((point) => point.x % 2 === 0);\n \n assert.deepStrictEqual(Array.from(evenPoints), [{ x: 2, tag: 'b' }]);\n * ```\n \n @param predicate A function to test each element.\n * @returns A new ISetMapped instance with elements that satisfy the\n * predicate.\n /\n filter: (predicate: (value: K) => boolean) => ISetMapped<K, KM>;\n\n /\n Filters the elements of the set by excluding elements for which the\n * predicate returns true.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const withoutEven = set.filterNot((point) => point.x % 2 === 0);\n \n assert.deepStrictEqual(Array.from(withoutEven), [{ x: 1, tag: 'a' }]);\n * ```\n \n @param predicate A function to test each element.\n * @returns A new ISetMapped instance with elements for which the predicate\n * returned `false`.\n /\n filterNot: (predicate: (key: K) => boolean) => ISetMapped<K, KM>;\n\n // Side effects\n\n /\n Executes a callback function for each element in the set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const mut_collected: Point[] = [];\n \n set.forEach((point) => {\n * mut_collected.push(point);\n * });\n \n assert.deepStrictEqual(mut_collected, [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ]);\n * ```\n \n @param callbackfn A function to execute for each element.\n /\n forEach: (callbackfn: (key: K) => void) => void;\n\n // Comparison\n\n /\n Checks if this set is a subset of another set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 subset = ISetMapped.create<Point, string>(\n * [{ x: 1, tag: 'a' }],\n * toKey,\n * fromKey,\n * );\n \n const superset = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n assert.isTrue(subset.isSubsetOf(superset));\n \n assert.isFalse(superset.isSubsetOf(subset));\n * ```\n \n @param set The other set.\n * @returns `true` if this set is a subset of the other set, `false`\n * otherwise.\n /\n isSubsetOf: (set: ISetMapped<K, KM>) => boolean;\n\n /\n Checks if this set is a superset of another set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 superset = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const subset = ISetMapped.create<Point, string>(\n * [{ x: 2, tag: 'b' }],\n * toKey,\n * fromKey,\n * );\n \n assert.isTrue(superset.isSupersetOf(subset));\n \n assert.isFalse(subset.isSupersetOf(superset));\n * ```\n \n @param set The other set.\n * @returns `true` if this set is a superset of the other set, `false`\n * otherwise.\n /\n isSupersetOf: (set: ISetMapped<K, KM>) => boolean;\n\n /\n Returns a new set with elements that are in this set but not in another\n * set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 left = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * { x: 3, tag: 'c' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const right = ISetMapped.create<Point, string>(\n * [{ x: 2, tag: 'b' }],\n * toKey,\n * fromKey,\n * );\n \n const difference = left.subtract(right);\n \n assert.deepStrictEqual(Array.from(difference), [\n * { x: 1, tag: 'a' },\n * { x: 3, tag: 'c' },\n * ]);\n * ```\n \n @param set The other set.\n * @returns A new ISetMapped instance representing the set difference.\n /\n subtract: (set: ISetMapped<K, KM>) => ISetMapped<K, KM>;\n\n /\n Returns a new set with elements that are common to both this set and\n * another set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 left = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const right = ISetMapped.create<Point, string>(\n * [{ x: 2, tag: 'b' }],\n * toKey,\n * fromKey,\n * );\n \n const intersection = left.intersect(right);\n \n assert.deepStrictEqual(Array.from(intersection), [{ x: 2, tag: 'b' }]);\n * ```\n \n @param set The other set.\n * @returns A new ISetMapped instance representing the set intersection.\n /\n intersect: (set: ISetMapped<K, KM>) => ISetMapped<K, KM>;\n\n /\n Returns a new set with all elements from both this set and another set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 left = ISetMapped.create<Point, string>(\n * [{ x: 1, tag: 'a' }],\n * toKey,\n * fromKey,\n * );\n \n const right = ISetMapped.create<Point, string>(\n * [{ x: 2, tag: 'b' }],\n * toKey,\n * fromKey,\n * );\n \n const combined = left.union(right);\n \n assert.deepStrictEqual(Array.from(combined), [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ]);\n * ```\n \n @param set The other set.\n * @returns A new ISetMapped instance representing the set union.\n /\n union: (set: ISetMapped<K, KM>) => ISetMapped<K, KM>;\n\n // Iterators\n\n /\n Returns an iterator for the elements in the set (alias for values).\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n assert.deepStrictEqual(Array.from(set.keys()), [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ]);\n * ```\n \n @returns An iterable iterator of elements.\n /\n keys: () => IterableIterator<K>;\n\n /\n Returns an iterator for the elements in the set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n assert.deepStrictEqual(Array.from(set.values()), [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ]);\n * ```\n \n @returns An iterable iterator of elements.\n /\n values: () => IterableIterator<K>;\n\n /\n Returns an iterator for the entries (element-element pairs) in the set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n assert.deepStrictEqual(Array.from(set.entries()), [\n * [\n * { x: 1, tag: 'a' },\n * { x: 1, tag: 'a' },\n * ],\n * [\n * { x: 2, tag: 'b' },\n * { x: 2, tag: 'b' },\n * ],\n * ]);\n * ```\n \n @returns An iterable iterator of entries.\n /\n entries: () => IterableIterator<FixedLengthTuple<2, K>>;\n\n // Conversion\n\n /\n Converts the elements of the set to an array.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n assert.deepStrictEqual(set.toArray(), [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ]);\n * ```\n \n @returns A readonly array of elements.\n /\n toArray: () => readonly K[];\n\n /\n Returns the underlying readonly JavaScript Set of mapped keys.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [{ x: 1, tag: 'a' }],\n * toKey,\n * fromKey,\n * );\n \n const raw = set.toRawSet();\n \n assert.isTrue(isSet(raw));\n \n assert.isTrue(raw.has(toKey({ x: 1, tag: 'a' })));\n * ```\n \n @returns The raw ReadonlySet instance.\n /\n toRawSet: () => ReadonlySet<KM>;\n}>;\n\n/\n Represents an immutable set with custom element transformation and\n * high-performance operations.\n \n ISetMapped is a specialized persistent data structure that enables using\n * complex objects as set elements while maintaining the performance benefits of\n * JavaScript's native Set. It achieves this by requiring bidirectional\n * transformation functions that convert between your custom element type and a\n * primitive type that can be efficiently stored and compared for uniqueness.\n \n Key Features:\n \n - Complex Elements: Use objects, arrays, or any custom type as set elements\n * - Immutable: All mutation operations return new instances\n * - Type Safe: Full TypeScript support with compile-time element type\n * checking\n * - Bidirectional: Maintains ability to reconstruct original elements from\n * mapped keys\n * - Set Algebra: Complete support for mathematical set operations\n \n Use Cases:\n \n - Sets of entities with complex identifiers\n * - Deduplication of objects based on specific properties\n * - Performance-critical sets with non-primitive elements\n * - Mathematical set operations on complex data structures\n \n @template K The type of the custom elements in the set.\n * @template KM The type of the mapped primitive keys (string, number, etc.).\n /\nexport type ISetMapped<K, KM extends MapSetKeyType> = Iterable<K> &\n Readonly<ISetMappedInterface<K, KM>>;\n\n/* Provides utility functions for ISetMapped. /\nexport namespace ISetMapped {\n /\n Creates a new ISetMapped instance with custom element transformation\n * functions.\n \n This factory function creates an immutable set that can use complex objects\n * as elements by providing bidirectional transformation functions. The\n * `toKey` function converts your custom element type to a primitive type that\n * can be efficiently stored, while `fromKey` reconstructs the original\n * element type for iteration and access.\n \n Performance: O(n) where n is the number of elements in the iterable.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n assert.deepStrictEqual(Array.from(set), [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ]);\n * ```\n \n @template K The type of the custom elements.\n * @template KM The type of the mapped primitive keys.\n * @param iterable An iterable of elements using the custom element type.\n * @param toKey A function that converts a custom element `K` to a primitive\n * key `KM`. This function must be deterministic and produce unique values\n * for unique elements.\n * @param fromKey A function that converts a primitive key `KM` back to the\n * custom element `K`. This should be the inverse of `toKey`.\n * @returns A new ISetMapped instance containing all unique elements from the\n * iterable.\n /\n export const create = <K, KM extends MapSetKeyType>(\n iterable: Iterable<K>,\n toKey: (a: K) => KM,\n fromKey: (k: KM) => K,\n ): ISetMapped<K, KM> => new ISetMappedClass<K, KM>(iterable, toKey, fromKey);\n\n /\n Checks if two ISetMapped instances are structurally equal.\n \n Two ISetMapped instances are considered equal if they have the same size\n * and contain exactly the same elements. The comparison is performed on the\n * underlying mapped keys, so the transformation functions themselves don't\n * need to be identical. Elements are compared based on their mapped key\n * representations.\n \n Performance: O(n) where n is the size of the smaller set.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const second = ISetMapped.create<Point, string>(\n * [\n * { x: 2, tag: 'b' },\n * { x: 1, tag: 'a' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const third = ISetMapped.create<Point, string>(\n * [{ x: 3, tag: 'c' }],\n * toKey,\n * fromKey,\n * );\n \n assert.isTrue(ISetMapped.equal(first, second));\n \n assert.isFalse(ISetMapped.equal(first, third));\n * ```\n \n @template K The type of the custom elements.\n * @template KM The type of the mapped primitive keys.\n * @param a The first ISetMapped instance to compare.\n * @param b The second ISetMapped instance to compare.\n * @returns `true` if the sets contain exactly the same elements, `false`\n * otherwise.\n /\n export const equal = <K, KM extends MapSetKeyType>(\n a: ISetMapped<K, KM>,\n b: ISetMapped<K, KM>,\n ): boolean => a.size === b.size && a.every((e) => b.has(e));\n\n /\n Computes the difference between two ISetMapped instances.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 previous = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const current = ISetMapped.create<Point, string>(\n * [\n * { x: 2, tag: 'b' },\n * { x: 3, tag: 'c' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const { added, deleted } = ISetMapped.diff(previous, current);\n \n assert.deepStrictEqual(Array.from(added), [{ x: 3, tag: 'c' }]);\n \n assert.deepStrictEqual(Array.from(deleted), [{ x: 1, tag: 'a' }]);\n * ```\n \n @template K The type of the elements.\n * @template KM The type of the mapped keys.\n * @param oldSet The original set.\n * @param newSet The new set.\n * @returns An object containing sets of added and deleted elements.\n /\n export const diff = <K, KM extends MapSetKeyType>(\n oldSet: ISetMapped<K, KM>,\n newSet: ISetMapped<K, KM>,\n ): ReadonlyRecord<'added' \| 'deleted', ISetMapped<K, KM>> =>\n ({\n deleted: oldSet.subtract(newSet),\n added: newSet.subtract(oldSet),\n }) as const;\n\n /\n Computes the intersection of two ISetMapped instances.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 left = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const right = ISetMapped.create<Point, string>(\n * [{ x: 2, tag: 'b' }],\n * toKey,\n * fromKey,\n * );\n \n const overlap = ISetMapped.intersection(left, right);\n \n assert.deepStrictEqual(Array.from(overlap), [{ x: 2, tag: 'b' }]);\n * ```\n \n @template K The type of the elements.\n * @template KM The type of the mapped keys.\n * @param a The first set.\n * @param b The second set.\n * @returns A new ISetMapped instance representing the intersection.\n /\n export const intersection = <K, KM extends MapSetKeyType>(\n a: ISetMapped<K, KM>,\n b: ISetMapped<K, KM>,\n ): ISetMapped<K, KM> => a.intersect(b);\n\n /\n Computes the union of two ISetMapped instances.\n \n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 left = ISetMapped.create<Point, string>(\n * [{ x: 1, tag: 'a' }],\n * toKey,\n * fromKey,\n * );\n \n const right = ISetMapped.create<Point, string>(\n * [{ x: 2, tag: 'b' }],\n * toKey,\n * fromKey,\n * );\n \n const combined = ISetMapped.union(left, right);\n \n assert.deepStrictEqual(Array.from(combined), [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ]);\n * ```\n \n @template K The type of the elements.\n * @template KM The type of the mapped keys.\n * @param a The first set.\n * @param b The second set.\n * @returns A new ISetMapped instance representing the union.\n /\n export const union = <K, KM extends MapSetKeyType>(\n a: ISetMapped<K, KM>,\n b: ISetMapped<K, KM>,\n ): ISetMapped<K, KM> => a.union(b);\n}\n\n/\n Internal class implementation for ISetMapped providing immutable set\n * operations with element transformation.\n \n This class implements the ISetMapped interface by maintaining a JavaScript\n * Set with primitive keys internally while exposing an API that works with\n * custom element types. The transformation between custom and primitive\n * elements is handled transparently through the provided `toKey` and `fromKey`\n * functions.\n \n Implementation Details:\n \n - Uses ReadonlySet<KM> internally where KM is the primitive key type\n * - Stores transformation functions for bidirectional element 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 elements.\n * @template KM The type of the mapped primitive keys.\n * @implements ISetMapped\n * @implements Iterable\n * @internal This class should not be used directly. Use ISetMapped.create() instead.\n /\nclass ISetMappedClass<K, KM extends MapSetKeyType>\n implements ISetMapped<K, KM>, Iterable<K>\n{\n readonly #set: ReadonlySet<KM>;\n readonly #toKey: (a: K) => KM;\n readonly #fromKey: (k: KM) => K;\n readonly #showNotFoundMessage: boolean;\n\n /\n Constructs an ISetMappedClass instance with custom element transformation.\n \n @param iterable An iterable of elements using the custom element type K.\n * @param toKey A function that converts a custom element K to a primitive key\n * KM. Must be deterministic and produce unique values for unique elements.\n * @param fromKey A function that converts a primitive key KM back to the\n * custom element 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 elements. Useful for debugging. Defaults to\n * false for production use.\n * @internal Use ISetMapped.create() instead of calling this constructor directly.\n /\n constructor(\n iterable: Iterable<K>,\n toKey: (a: K) => KM,\n fromKey: (k: KM) => K,\n showNotFoundMessage: boolean = false,\n ) {\n this.#set = new Set(Array.from(iterable, toKey));\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.#set.size);\n }\n\n /* @inheritdoc /\n get isEmpty(): boolean {\n return this.size === 0;\n }\n\n /* @inheritdoc /\n has(key: K \| (WidenLiteral<K> & {})): boolean {\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n return this.#set.has(this.#toKey(key as K));\n }\n\n /* @inheritdoc /\n every<L extends K>(\n predicate: (key: K) => key is L,\n ): this is ISetMapped<L, KM>;\n\n /* @inheritdoc /\n every(predicate: (key: K) => boolean): boolean;\n\n /* @inheritdoc /\n every(predicate: (key: K) => boolean): boolean {\n for (const key of this.values()) {\n if (!predicate(key)) return false;\n }\n\n return true;\n }\n\n /* @inheritdoc /\n some(predicate: (key: K) => boolean): boolean {\n for (const key of this.values()) {\n if (predicate(key)) return true;\n }\n\n return false;\n }\n\n /* @inheritdoc /\n add(key: K): ISetMapped<K, KM> {\n if (this.has(key)) return this;\n\n return ISetMapped.create(\n [...this.#set, this.#toKey(key)].map(this.#fromKey),\n this.#toKey,\n this.#fromKey,\n );\n }\n\n /* @inheritdoc /\n delete(key: K): ISetMapped<K, KM> {\n if (!this.has(key)) {\n if (this.#showNotFoundMessage) {\n console.warn(\n `ISetMapped.delete: key not found: ${unknownToString(this.#toKey(key))}`,\n );\n }\n\n return this;\n }\n\n const keyMapped = this.#toKey(key);\n\n return ISetMapped.create(\n Array.from(this.#set)\n .filter((k) => !Object.is(k, keyMapped))\n .map(this.#fromKey),\n this.#toKey,\n this.#fromKey,\n );\n }\n\n /* @inheritdoc /\n withMutations(\n actions: readonly Readonly<\n { type: 'add'; key: K } \| { type: 'delete'; key: K }\n >[],\n ): ISetMapped<K, KM> {\n const mut_result = new Set<KM>(this.#set);\n\n const updateFn = (\n action: Readonly<{ type: 'add'; key: K } \| { type: 'delete'; key: K }>,\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 'add':\n mut_result.add(key);\n\n break;\n }\n };\n\n for (const action of actions) {\n updateFn(action);\n }\n\n return ISetMapped.create<K, KM>(\n Array.from(mut_result, this.#fromKey),\n this.#toKey,\n this.#fromKey,\n );\n }\n\n /* @inheritdoc /\n map(mapFn: (key: K) => K): ISetMapped<K, KM> {\n return ISetMapped.create(\n this.toArray().map(mapFn),\n this.#toKey,\n this.#fromKey,\n );\n }\n\n /* @inheritdoc /\n filter(predicate: (key: K) => boolean): ISetMapped<K, KM> {\n return ISetMapped.create(\n this.toArray().filter(predicate),\n this.#toKey,\n this.#fromKey,\n );\n }\n\n /* @inheritdoc /\n filterNot(predicate: (key: K) => boolean): ISetMapped<K, KM> {\n return ISetMapped.create(\n this.toArray().filter((k) => !predicate(k)),\n this.#toKey,\n this.#fromKey,\n );\n }\n\n /* @inheritdoc /\n forEach(callbackfn: (key: K) => void): void {\n for (const km of this.#set) {\n callbackfn(this.#fromKey(km));\n }\n }\n\n /* @inheritdoc /\n isSubsetOf(set: ISetMapped<K, KM>): boolean {\n return this.every((k) => set.has(k));\n }\n\n /* @inheritdoc /\n isSupersetOf(set: ISetMapped<K, KM>): boolean {\n return set.every((k) => this.has(k));\n }\n\n /* @inheritdoc /\n subtract(set: ISetMapped<K, KM>): ISetMapped<K, KM> {\n return ISetMapped.create(\n this.toArray().filter((k) => !set.has(k)),\n this.#toKey,\n this.#fromKey,\n );\n }\n\n /* @inheritdoc /\n intersect(set: ISetMapped<K, KM>): ISetMapped<K, KM> {\n return ISetMapped.create(\n this.toArray().filter((k) => set.has(k)),\n this.#toKey,\n this.#fromKey,\n );\n }\n\n /* @inheritdoc /\n union(set: ISetMapped<K, KM>): ISetMapped<K, KM> {\n return ISetMapped.create(\n [...this.values(), ...set.values()],\n this.#toKey,\n this.#fromKey,\n );\n }\n\n /\n @example\n \n ```ts\n * type Point = Readonly<{ x: number; tag: string }>;\n \n const toKey = (point: Point) => JSON.stringify(point);\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 set = ISetMapped.create<Point, string>(\n * [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ],\n * toKey,\n * fromKey,\n * );\n \n const collected = Array.from(set);\n \n assert.deepStrictEqual(collected, [\n * { x: 1, tag: 'a' },\n * { x: 2, tag: 'b' },\n * ]);\n * ```\n \n @inheritdoc\n /\n [Symbol.iterator](): Iterator<K> {\n for (const k of this.keys()) {\n yield k;\n }\n }\n\n /** @inheritdoc /\n keys(): IterableIterator<K> {\n for (const km of this.#set) {\n yield this.#fromKey(km);\n }\n }\n\n /** @inheritdoc /\n values(): IterableIterator<K> {\n for (const km of this.#set) {\n // JavaScript Set's values() is an alias for keys()\n yield this.#fromKey(km);\n }\n }\n\n /** @inheritdoc /\n entries(): IterableIterator<FixedLengthTuple<2, K>> {\n for (const km of this.#set) {\n // JavaScript Set's entries() yields [value, value]\n const a = this.#fromKey(km);\n\n yield [a, a];\n }\n }\n\n /** @inheritdoc /\n toArray(): readonly K[] {\n return Array.from(this.values());\n }\n\n /* @inheritdoc */\n toRawSet(): ReadonlySet<KM> {\n return this.#set;\n }\n}\n"],"names":["ISetMapped"],"mappings":"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"}
1	+ {"version":3,"file":"iset-mapped.mjs","sourceRoot":"","sources":["../../src/collections/iset-mapped.mts"],"names":[],"mappings":"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"}

package/dist/collections/iset.mjs CHANGED Viewed

@@ -1,204 +1,331 @@
-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';
-import '@sindresorhus/is';
-import { unknownToString } from '../others/unknown-to-string.mjs';
-var ISet;
-((ISet2) => {
-  ISet2.create = (iterable) => new ISetClass(iterable);
-  ISet2.equal = (a, b) => a.size === b.size && a.every((e) => b.has(e));
-  ISet2.diff = (oldSet, newSet) => ({
-    deleted: oldSet.subtract(newSet),
-    added: newSet.subtract(oldSet)
-  });
-  ISet2.intersection = (a, b) => a.intersect(b);
-  ISet2.union = (a, b) => a.union(b);
+import { asUint32 } from '../number/index.mjs';
+import { unknownToString } from '../others/index.mjs';
+export var ISet;
+(function (ISet) {
+    ISet.create = (iterable) => new ISetClass(iterable);
+    ISet.equal = (a, b) => a.size === b.size && a.every((e) => b.has(e));
+    ISet.diff = (oldSet, newSet) => ({
+        deleted: oldSet.subtract(newSet),
+        added: newSet.subtract(oldSet),
+    });
+    ISet.intersection = (a, b) => a.intersect(b);
+    ISet.union = (a, b) => a.union(b);
 })(ISet || (ISet = {}));
 class ISetClass {
-  #set;
-  #showNotFoundMessage;
-  /**
-   * Constructs an ISetClass instance with the given elements.
-   *
-   * @param iterable An iterable of elements to populate the set.
-   * @param showNotFoundMessage Whether to log warning messages when operations
-   *   are performed on non-existent elements. Useful for debugging. Defaults to
-   *   false for production use.
-   * @internal Use ISet.create() instead of calling this constructor directly.
-   */
-  constructor(iterable, showNotFoundMessage = false) {
-    this.#set = new Set(iterable);
-    this.#showNotFoundMessage = showNotFoundMessage;
-  }
-  /** @inheritdoc */
-  get size() {
-    return asUint32(this.#set.size);
-  }
-  /** @inheritdoc */
-  get isEmpty() {
-    return this.size === 0;
-  }
-  /** @inheritdoc */
-  has(key) {
-    return this.#set.has(key);
-  }
-  /** @inheritdoc */
-  every(predicate) {
-    for (const key of this.values()) {
-      if (!predicate(key)) return false;
-    }
-    return true;
-  }
-  /** @inheritdoc */
-  some(predicate) {
-    for (const key of this.values()) {
-      if (predicate(key)) return true;
-    }
-    return false;
-  }
-  /** @inheritdoc */
-  add(key) {
-    if (this.has(key)) return this;
-    return ISet.create([...this.#set, key]);
-  }
-  /** @inheritdoc */
-  delete(key) {
-    if (!this.has(key)) {
-      if (this.#showNotFoundMessage) {
-        const keyStr = unknownToString(key);
-        console.warn(`ISet.delete: key not found: ${keyStr}`);
-      }
-      return this;
-    }
-    return ISet.create(Array.from(this.#set).filter((k) => !Object.is(k, key)));
-  }
-  /** @inheritdoc */
-  withMutations(actions) {
-    const mut_result = new Set(this.#set);
-    const updateFn = (action) => {
-      switch (action.type) {
-        case "delete":
-          mut_result.delete(action.key);
-          break;
-        case "add":
-          mut_result.add(action.key);
-          break;
-      }
-    };
-    for (const action of actions) {
-      updateFn(action);
-    }
-    return ISet.create(mut_result);
-  }
-  /** @inheritdoc */
-  map(mapFn) {
-    return ISet.create(this.toArray().map(mapFn));
-  }
-  /** @inheritdoc */
-  filter(predicate) {
-    return ISet.create(this.toArray().filter(predicate));
-  }
-  /** @inheritdoc */
-  filterNot(predicate) {
-    return ISet.create(this.toArray().filter((e) => !predicate(e)));
-  }
-  /** @inheritdoc */
-  forEach(callbackfn) {
-    for (const v of this.#set) {
-      callbackfn(v);
-    }
-  }
-  /** @inheritdoc */
-  isSubsetOf(set) {
-    return this.every((k) => set.has(k));
-  }
-  /** @inheritdoc */
-  isSupersetOf(set) {
-    return set.every((k) => this.has(k));
-  }
-  /** @inheritdoc */
-  subtract(set) {
-    return ISet.create(this.toArray().filter((k) => !set.has(k)));
-  }
-  /** @inheritdoc */
-  intersect(set) {
-    return ISet.create(this.toArray().filter((k) => set.has(k)));
-  }
-  /** @inheritdoc */
-  union(set) {
-    return ISet.create([...this, ...set]);
-  }
-  /**
-   * @example
-   *
-   * ```ts
-   * const set = ISet.create(['first', 'second']);
-   *
-   * const collected = Array.from(set);
-   *
-   * assert.deepStrictEqual(collected, ['first', 'second']);
-   * ```
-   *
-   * @inheritdoc
-   */
-  [Symbol.iterator]() {
-    return this.#set[Symbol.iterator]();
-  }
-  /** @inheritdoc */
-  keys() {
-    return this.#set.keys();
-  }
-  /** @inheritdoc */
-  values() {
-    return this.#set.values();
-  }
-  /** @inheritdoc */
-  entries() {
-    return this.#set.entries();
-  }
-  /** @inheritdoc */
-  toArray() {
-    return Array.from(this.values());
-  }
-  /** @inheritdoc */
-  toRawSet() {
-    return this.#set;
-  }
-}
+    #set;
+    #showNotFoundMessage;
+    constructor(iterable, showNotFoundMessage = false) {
+        this.#set = new Set(iterable);
+        this.#showNotFoundMessage = showNotFoundMessage;
+    }
+    get size() {
+        return asUint32(this.#set.size);
+    }
+    get isEmpty() {
+        return this.size === 0;
+    }
+    has(key) {
+        return this.#set.has(key);
+    }
+    every(predicate) {
+        for (const key of this.values()) {
+            if (!predicate(key))
+                return false;
+        }
+        return true;
+    }
+    some(predicate) {
+        for (const key of this.values()) {
+            if (predicate(key))
+                return true;
+        }
+        return false;
+    }
+    add(key) {
+        if (this.has(key))
+            return this;
+        return ISet.create([...this.#set, key]);
+    }
+    delete(key) {
+        if (!this.has(key)) {
+            if (this.#showNotFoundMessage) {
+                const keyStr = unknownToString(key);
+                console.warn(`ISet.delete: key not found: ${keyStr}`);
+            }
+            return this;
+        }
+        return ISet.create(Array.from(this.#set).filter((k) => !Object.is(k, key)));
+    }
+    withMutations(actions) {
+        const mut_result = new Set(this.#set);
+        const updateFn = (action) => {
+            switch (action.type) {
+                case 'delete':
+                    mut_result.delete(action.key);
+                    break;
+                case 'add':
+                    mut_result.add(action.key);
+                    break;
+            }
+        };
+        for (const action of actions) {
+            updateFn(action);
+        }
+        return ISet.create(mut_result);
+    }
+    map(mapFn) {
+        return ISet.create(this.toArray().map(mapFn));
+    }
+    filter(predicate) {
+        return ISet.create(this.toArray().filter(predicate));
+    }
+    filterNot(predicate) {
+        return ISet.create(this.toArray().filter((e) => !predicate(e)));
+    }
+    forEach(callbackfn) {
+        for (const v of this.#set) {
+            callbackfn(v);
+        }
+    }
+    isSubsetOf(set) {
+        return this.every((k) => set.has(k));
+    }
+    isSupersetOf(set) {
+        return set.every((k) => this.has(k));
+    }
+    subtract(set) {
+        return ISet.create(this.toArray().filter((k) => !set.has(k)));
+    }
+    intersect(set) {
+        return ISet.create(this.toArray().filter((k) => set.has(k)));
+    }
+    union(set) {
+        return ISet.create([...this, ...set]);
+    }
-export { ISet };
-//# sourceMappingURL=iset.mjs.map
+    [Symbol.iterator]() {
+        return this.#set[Symbol.iterator]();
+    }
+    keys() {
+        return this.#set.keys();
+    }
+    values() {
+        return this.#set.values();
+    }
+    entries() {
+        return this.#set.entries();
+    }
+    toArray() {
+        return Array.from(this.values());
+    }
+    toRawSet() {
+        return this.#set;
+    }
+}
+//# sourceMappingURL=iset.mjs.map