@tspro/ts-utils-lib 1.19.0 → 1.19.1

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [1.19.1] - 2025-10-27
+## Fixed
+- Forgot to export `DefaultArray`, `SetBase`, `Set1` and `DeepSet`.
+
 ## [1.19.0] - 2025-10-27
 ### Added
 - SignedIndexArray.toArray(), IndexArray.toArray(), IndexArray.length;

package/dist/index.d.mts

@@ -1057,6 +1057,59 @@ declare class SignedIndexArray<VALUE> implements KVComponent<[number], VALUE> {
     toString(): string;
 }
 
+/**
+ * `DefaultArray` is an array list where every index is guaranteed to have a value.
+ * There are no undefineds unless that is part of the value type.
+ * When you create `DefaultArray` you give a default value. For example if you
+ * delete an index then that index is set to the default value.
+ */
+declare class DefaultArray<VALUE> implements KVComponent<[number], VALUE> {
+    readonly defaultValue: VALUE;
+    private data;
+    constructor(values: Iterable<VALUE>, defaultValue: VALUE);
+    constructor(length: number, defaultValue: VALUE);
+    get size(): number;
+    get length(): number;
+    private assertId;
+    isEmpty(): boolean;
+    isDefault(id: number): boolean;
+    isSet(id: number): boolean;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    has(id: number): boolean;
+    set(id: number, value: VALUE): VALUE;
+    get(id: number): VALUE;
+    getOrDefault(id: number, defaultValue: VALUE): VALUE;
+    getOrCreate(id: number, value: VALUE): VALUE;
+    getOrCreate(id: number, creator: () => VALUE): VALUE;
+    delete(id: number): boolean;
+    clear(empty?: boolean): void;
+    forEach(callbackfn: (value: VALUE, id: number, arr: DefaultArray<VALUE>) => void, thisArg?: any): void;
+    indices(): IterableIterator<number>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[number, VALUE]>;
+    indicesArray(): number[];
+    valuesArray(): VALUE[];
+    entriesArray(): [number, VALUE][];
+    kvKeys(): IterableIterator<[number]>;
+    kvValues(): IterableIterator<VALUE>;
+    kvEntries(): IterableIterator<[[number], VALUE]>;
+    [Symbol.iterator](): IterableIterator<[number, VALUE]>;
+    clone(): this;
+    merge(other: DefaultArray<VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, id: number) => VALUE): this;
+    some(fn: (value: VALUE, id: number) => boolean): boolean;
+    every(fn: (value: VALUE, key1: number) => boolean): boolean;
+    filter<S extends VALUE>(predicate: (value: VALUE, id: number, array: DefaultArray<VALUE>) => value is S): DefaultArray<S>;
+    filter(predicate: (value: VALUE, id: number, array: DefaultArray<VALUE>) => unknown): DefaultArray<VALUE>;
+    reduce(fn: (acc: VALUE, value: VALUE, id: number) => VALUE): VALUE;
+    reduce<R>(fn: (acc: R, value: VALUE, id: number) => R, init: R): R;
+    mapToArray<R>(fn: (value: VALUE, key1: number) => R): R[];
+    map<R = VALUE>(fn: (value: VALUE, key1: number) => R, defaultValue: R): DefaultArray<R>;
+    equals(other: DefaultArray<VALUE>): boolean;
+    equals(other: DefaultArray<VALUE>, eq: (a: VALUE, b: VALUE) => boolean): boolean;
+    toArray(): VALUE[];
+    toString(): string;
+}
+
 /**
  * A Map implementation mapping a single key to a value.
  */
@@ -1189,6 +1242,79 @@ declare class Map3<KEY1, KEY2, KEY3, VALUE> implements KVComponent<[KEY1, KEY2,
     toString(): string;
 }
 
+/**
+ * An abstract base class implementation of a Set data structure.
+ */
+declare abstract class SetBase<VALUE, CLS extends SetBase<VALUE, CLS> = any> implements KVComponent<[VALUE], VALUE> {
+    protected data: Set<VALUE>;
+    constructor(entries?: Iterable<VALUE>);
+    protected abstract valueEquals(a: VALUE, b: VALUE): boolean;
+    protected abstract createEmpty<R = VALUE>(): SetBase<R, any>;
+    protected abstract getName(): string;
+    has(value: VALUE): boolean;
+    add(value: VALUE): VALUE;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    set(key: VALUE, value: VALUE): void;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    get(key: VALUE): VALUE | undefined;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    getOrDefault(key: VALUE, defaultValue: VALUE): VALUE;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    getOrCreate(key: VALUE, value: VALUE): VALUE;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    getOrCreate(key: VALUE, creator: () => VALUE): VALUE;
+    delete(value: VALUE): boolean;
+    clear(): void;
+    get size(): number;
+    isEmpty(): boolean;
+    forEach(callbackfn: (value: VALUE, set1: SetBase<VALUE>) => void, thisArg?: any): void;
+    keys(): IterableIterator<VALUE>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[VALUE, VALUE]>;
+    kvKeys(): IterableIterator<[VALUE]>;
+    kvValues(): IterableIterator<VALUE>;
+    kvEntries(): IterableIterator<[[VALUE], VALUE]>;
+    [Symbol.iterator](): IterableIterator<VALUE>;
+    clone(): SetBase<VALUE>;
+    merge(other: SetBase<VALUE>): this;
+    some(fn: (value: VALUE) => boolean): boolean;
+    every(fn: (value: VALUE) => boolean): boolean;
+    filter<R extends VALUE>(predicate: (value: VALUE, set1: SetBase<VALUE, any>) => value is R): SetBase<R, any>;
+    filter(predicate: (value: VALUE, set1: SetBase<VALUE>) => unknown): SetBase<VALUE, any>;
+    reduce(fn: (acc: VALUE, value: VALUE) => VALUE): VALUE;
+    reduce<R = VALUE>(fn: (acc: R, value: VALUE) => R, init: R): R;
+    mapValues<R = VALUE>(fn: (value: VALUE) => R): SetBase<R, any>;
+    mapToArray<R = VALUE>(fn: (value: VALUE) => R): R[];
+    map<R = VALUE>(fn: (value: VALUE) => R): SetBase<R, any>;
+    toSet(): Set<VALUE>;
+    toArray(): VALUE[];
+    toString(): string;
+}
+/**
+ * A simple Set data structure. Comparison of values is done
+ * using === operator (e.g. "a" === "a", but [1, 2] !== [1, 2]).
+ */
+declare class Set1<VALUE> extends SetBase<VALUE, Set1<VALUE>> {
+    constructor();
+    constructor(set: SetBase<VALUE>);
+    constructor(entries: Iterable<VALUE>);
+    protected createEmpty<R = VALUE>(): Set1<R>;
+    protected valueEquals(a: VALUE, b: VALUE): boolean;
+    protected getName(): string;
+}
+/**
+ * A simple Set data structure, where comparison of values is done
+ * using deep equality (e.g. "a" === "a" and also [1, 2] === [1, 2]).
+ */
+declare class DeepSet<VALUE> extends SetBase<VALUE, DeepSet<VALUE>> {
+    constructor();
+    constructor(set: SetBase<VALUE>);
+    constructor(entries: Iterable<VALUE>);
+    protected createEmpty<R = VALUE>(): DeepSet<R>;
+    protected valueEquals(a: VALUE, b: VALUE): boolean;
+    protected getName(): string;
+}
+
 /**
  * Wrapper class of a key-value container that contain array values.
  */
@@ -1270,4 +1396,4 @@ declare class SmallIntCache<VALUE> {
     clear(): void;
 }
 
-export { index$7 as Assert, cookies as Cookies, device as Device, DivRect, Guard, IndexArray, type KVComponent, LRUCache, Map1, Map2, Map3, MultiContainer, SignedIndexArray, SmallIntCache, Stack, index as Utils, Vec, Vec2, asMulti };
+export { index$7 as Assert, cookies as Cookies, DeepSet, DefaultArray, device as Device, DivRect, Guard, IndexArray, type KVComponent, LRUCache, Map1, Map2, Map3, MultiContainer, Set1, SetBase, SignedIndexArray, SmallIntCache, Stack, index as Utils, Vec, Vec2, asMulti };

package/dist/index.d.ts

@@ -1057,6 +1057,59 @@ declare class SignedIndexArray<VALUE> implements KVComponent<[number], VALUE> {
     toString(): string;
 }
 
+/**
+ * `DefaultArray` is an array list where every index is guaranteed to have a value.
+ * There are no undefineds unless that is part of the value type.
+ * When you create `DefaultArray` you give a default value. For example if you
+ * delete an index then that index is set to the default value.
+ */
+declare class DefaultArray<VALUE> implements KVComponent<[number], VALUE> {
+    readonly defaultValue: VALUE;
+    private data;
+    constructor(values: Iterable<VALUE>, defaultValue: VALUE);
+    constructor(length: number, defaultValue: VALUE);
+    get size(): number;
+    get length(): number;
+    private assertId;
+    isEmpty(): boolean;
+    isDefault(id: number): boolean;
+    isSet(id: number): boolean;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    has(id: number): boolean;
+    set(id: number, value: VALUE): VALUE;
+    get(id: number): VALUE;
+    getOrDefault(id: number, defaultValue: VALUE): VALUE;
+    getOrCreate(id: number, value: VALUE): VALUE;
+    getOrCreate(id: number, creator: () => VALUE): VALUE;
+    delete(id: number): boolean;
+    clear(empty?: boolean): void;
+    forEach(callbackfn: (value: VALUE, id: number, arr: DefaultArray<VALUE>) => void, thisArg?: any): void;
+    indices(): IterableIterator<number>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[number, VALUE]>;
+    indicesArray(): number[];
+    valuesArray(): VALUE[];
+    entriesArray(): [number, VALUE][];
+    kvKeys(): IterableIterator<[number]>;
+    kvValues(): IterableIterator<VALUE>;
+    kvEntries(): IterableIterator<[[number], VALUE]>;
+    [Symbol.iterator](): IterableIterator<[number, VALUE]>;
+    clone(): this;
+    merge(other: DefaultArray<VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, id: number) => VALUE): this;
+    some(fn: (value: VALUE, id: number) => boolean): boolean;
+    every(fn: (value: VALUE, key1: number) => boolean): boolean;
+    filter<S extends VALUE>(predicate: (value: VALUE, id: number, array: DefaultArray<VALUE>) => value is S): DefaultArray<S>;
+    filter(predicate: (value: VALUE, id: number, array: DefaultArray<VALUE>) => unknown): DefaultArray<VALUE>;
+    reduce(fn: (acc: VALUE, value: VALUE, id: number) => VALUE): VALUE;
+    reduce<R>(fn: (acc: R, value: VALUE, id: number) => R, init: R): R;
+    mapToArray<R>(fn: (value: VALUE, key1: number) => R): R[];
+    map<R = VALUE>(fn: (value: VALUE, key1: number) => R, defaultValue: R): DefaultArray<R>;
+    equals(other: DefaultArray<VALUE>): boolean;
+    equals(other: DefaultArray<VALUE>, eq: (a: VALUE, b: VALUE) => boolean): boolean;
+    toArray(): VALUE[];
+    toString(): string;
+}
+
 /**
  * A Map implementation mapping a single key to a value.
  */
@@ -1189,6 +1242,79 @@ declare class Map3<KEY1, KEY2, KEY3, VALUE> implements KVComponent<[KEY1, KEY2,
     toString(): string;
 }
 
+/**
+ * An abstract base class implementation of a Set data structure.
+ */
+declare abstract class SetBase<VALUE, CLS extends SetBase<VALUE, CLS> = any> implements KVComponent<[VALUE], VALUE> {
+    protected data: Set<VALUE>;
+    constructor(entries?: Iterable<VALUE>);
+    protected abstract valueEquals(a: VALUE, b: VALUE): boolean;
+    protected abstract createEmpty<R = VALUE>(): SetBase<R, any>;
+    protected abstract getName(): string;
+    has(value: VALUE): boolean;
+    add(value: VALUE): VALUE;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    set(key: VALUE, value: VALUE): void;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    get(key: VALUE): VALUE | undefined;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    getOrDefault(key: VALUE, defaultValue: VALUE): VALUE;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    getOrCreate(key: VALUE, value: VALUE): VALUE;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    getOrCreate(key: VALUE, creator: () => VALUE): VALUE;
+    delete(value: VALUE): boolean;
+    clear(): void;
+    get size(): number;
+    isEmpty(): boolean;
+    forEach(callbackfn: (value: VALUE, set1: SetBase<VALUE>) => void, thisArg?: any): void;
+    keys(): IterableIterator<VALUE>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[VALUE, VALUE]>;
+    kvKeys(): IterableIterator<[VALUE]>;
+    kvValues(): IterableIterator<VALUE>;
+    kvEntries(): IterableIterator<[[VALUE], VALUE]>;
+    [Symbol.iterator](): IterableIterator<VALUE>;
+    clone(): SetBase<VALUE>;
+    merge(other: SetBase<VALUE>): this;
+    some(fn: (value: VALUE) => boolean): boolean;
+    every(fn: (value: VALUE) => boolean): boolean;
+    filter<R extends VALUE>(predicate: (value: VALUE, set1: SetBase<VALUE, any>) => value is R): SetBase<R, any>;
+    filter(predicate: (value: VALUE, set1: SetBase<VALUE>) => unknown): SetBase<VALUE, any>;
+    reduce(fn: (acc: VALUE, value: VALUE) => VALUE): VALUE;
+    reduce<R = VALUE>(fn: (acc: R, value: VALUE) => R, init: R): R;
+    mapValues<R = VALUE>(fn: (value: VALUE) => R): SetBase<R, any>;
+    mapToArray<R = VALUE>(fn: (value: VALUE) => R): R[];
+    map<R = VALUE>(fn: (value: VALUE) => R): SetBase<R, any>;
+    toSet(): Set<VALUE>;
+    toArray(): VALUE[];
+    toString(): string;
+}
+/**
+ * A simple Set data structure. Comparison of values is done
+ * using === operator (e.g. "a" === "a", but [1, 2] !== [1, 2]).
+ */
+declare class Set1<VALUE> extends SetBase<VALUE, Set1<VALUE>> {
+    constructor();
+    constructor(set: SetBase<VALUE>);
+    constructor(entries: Iterable<VALUE>);
+    protected createEmpty<R = VALUE>(): Set1<R>;
+    protected valueEquals(a: VALUE, b: VALUE): boolean;
+    protected getName(): string;
+}
+/**
+ * A simple Set data structure, where comparison of values is done
+ * using deep equality (e.g. "a" === "a" and also [1, 2] === [1, 2]).
+ */
+declare class DeepSet<VALUE> extends SetBase<VALUE, DeepSet<VALUE>> {
+    constructor();
+    constructor(set: SetBase<VALUE>);
+    constructor(entries: Iterable<VALUE>);
+    protected createEmpty<R = VALUE>(): DeepSet<R>;
+    protected valueEquals(a: VALUE, b: VALUE): boolean;
+    protected getName(): string;
+}
+
 /**
  * Wrapper class of a key-value container that contain array values.
  */
@@ -1270,4 +1396,4 @@ declare class SmallIntCache<VALUE> {
     clear(): void;
 }
 
-export { index$7 as Assert, cookies as Cookies, device as Device, DivRect, Guard, IndexArray, type KVComponent, LRUCache, Map1, Map2, Map3, MultiContainer, SignedIndexArray, SmallIntCache, Stack, index as Utils, Vec, Vec2, asMulti };
+export { index$7 as Assert, cookies as Cookies, DeepSet, DefaultArray, device as Device, DivRect, Guard, IndexArray, type KVComponent, LRUCache, Map1, Map2, Map3, MultiContainer, Set1, SetBase, SignedIndexArray, SmallIntCache, Stack, index as Utils, Vec, Vec2, asMulti };

package/dist/index.js

@@ -1,4 +1,4 @@
-/* TsUtilsLib v1.19.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
+/* TsUtilsLib v1.19.1 | (c) 2023 PahkaSoft | Licensed under the MIT License */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -25,6 +25,8 @@ var index_exports = {};
 __export(index_exports, {
   Assert: () => assert_exports,
   Cookies: () => cookies_exports,
+  DeepSet: () => DeepSet,
+  DefaultArray: () => DefaultArray,
   Device: () => device_exports,
   DivRect: () => DivRect,
   Guard: () => guard_exports,
@@ -34,6 +36,8 @@ __export(index_exports, {
   Map2: () => Map2,
   Map3: () => Map3,
   MultiContainer: () => MultiContainer,
+  Set1: () => Set1,
+  SetBase: () => SetBase,
   SignedIndexArray: () => SignedIndexArray,
   SmallIntCache: () => SmallIntCache,
   Stack: () => Stack,
@@ -2613,6 +2617,209 @@ var SignedIndexArray = class _SignedIndexArray {
   }
 };
 
+// src/core/default-array.ts
+var DefaultArray = class _DefaultArray {
+  constructor(lengthOrValues, defaultValue) {
+    this.defaultValue = defaultValue;
+    __publicField(this, "data");
+    if (typeof lengthOrValues === "number") {
+      this.data = Array(lengthOrValues).fill(defaultValue);
+    } else {
+      this.data = Array.from(lengthOrValues).map(
+        (v) => v === void 0 ? defaultValue : v
+      );
+    }
+  }
+  get size() {
+    return this.data.length;
+  }
+  get length() {
+    return this.data.length;
+  }
+  assertId(id) {
+    if (id < 0 || id >= this.data.length)
+      throw new RangeError(`DefaultArray: Index ${id} out of range`);
+    return id;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  isDefault(id) {
+    return this.data[this.assertId(id)] === this.defaultValue;
+  }
+  isSet(id) {
+    return this.data[this.assertId(id)] !== this.defaultValue;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  has(id) {
+    return this.isSet(id);
+  }
+  set(id, value) {
+    return this.data[this.assertId(id)] = value;
+  }
+  get(id) {
+    return this.data[this.assertId(id)];
+  }
+  getOrDefault(id, defaultValue) {
+    let value = this.get(id);
+    return value === this.defaultValue ? defaultValue : value;
+  }
+  getOrCreate(id, creatorOrValue) {
+    if (!this.has(id)) {
+      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(id, value);
+      return value;
+    }
+    return this.get(id);
+  }
+  delete(id) {
+    this.assertId(id);
+    if (this.data[id] === this.defaultValue) return false;
+    this.data[id] = this.defaultValue;
+    return true;
+  }
+  clear(empty = false) {
+    if (empty)
+      this.data = [];
+    else
+      this.data.fill(this.defaultValue);
+  }
+  forEach(callbackfn, thisArg) {
+    for (const [id, value] of this.entries()) {
+      callbackfn.call(thisArg, value, id, this);
+    }
+  }
+  *indices() {
+    yield* this.data.keys();
+  }
+  *values() {
+    yield* this.data.values();
+  }
+  *entries() {
+    yield* this.data.entries();
+  }
+  indicesArray() {
+    return [...this.indices()];
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  *kvKeys() {
+    for (const id of this.indices()) {
+      yield [id];
+    }
+  }
+  *kvValues() {
+    for (const value of this.values()) {
+      yield value;
+    }
+  }
+  *kvEntries() {
+    for (const [id, value] of this.entries()) {
+      yield [[id], value];
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* this.entries();
+  }
+  clone() {
+    const ctor = this.constructor;
+    const clone = new ctor(this.length, this.defaultValue);
+    clone.data = this.data.slice();
+    return clone;
+  }
+  merge(other, conflictResolver) {
+    if (this.constructor !== other.constructor)
+      throw new Error(`Cannot merge DefaultArray: different classes (${this.constructor.name} vs ${other.constructor.name})`);
+    if (this.defaultValue !== other.defaultValue)
+      throw new Error(`Cannot merge DefaultArray: different defaultValue (${this.defaultValue} vs ${other.defaultValue})`);
+    for (const [id, value] of other.entries()) {
+      if (this.isDefault(id))
+        this.set(id, value);
+      else if (conflictResolver)
+        this.set(id, conflictResolver(this.get(id), value, id));
+      else
+        this.set(id, value);
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [id, value] of this.entries()) {
+      if (fn(value, id)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [id, value] of this.entries()) {
+      if (!fn(value, id)) return false;
+    }
+    return true;
+  }
+  filter(predicate) {
+    const result = new this.constructor(this.length, this.defaultValue);
+    for (const [id, value] of this.entries()) {
+      if (predicate(value, id, this)) result.set(id, value);
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.entries();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty DefaultArray with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value[1];
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const [id, value] = current.value;
+      acc = fn(acc, value, id);
+    }
+    return acc;
+  }
+  mapToArray(fn) {
+    let result = [];
+    for (const [id, value] of this.entries()) {
+      result.push(fn(value, id));
+    }
+    return result;
+  }
+  map(fn, defaultValue) {
+    let result = new _DefaultArray(this.data.length, defaultValue);
+    for (let id = 0; id < this.data.length; id++) {
+      result.data[id] = fn(this.data[id], id);
+    }
+    return result;
+  }
+  equals(other, eq2) {
+    if (this.size !== other.size) return false;
+    eq2 ?? (eq2 = (a, b) => a === b);
+    for (let id = 0; id < this.data.length; ++id) {
+      if (!eq2(this.data[id], other.data[id])) return false;
+    }
+    return true;
+  }
+  toArray() {
+    return this.valuesArray();
+  }
+  toString() {
+    const entries = this.entriesArray().map(([id, v]) => `${formatValue(id)}: ${formatValue(v)}`).join(", ");
+    return `DefaultArray[ ${entries} ]`.replaceAll("  ", " ");
+  }
+};
+
 // src/core/map1.ts
 var Map1 = class _Map1 {
   constructor(entries) {
@@ -3196,6 +3403,204 @@ var Map3 = class _Map3 {
   }
 };
 
+// src/core/set.ts
+var SetBase = class {
+  constructor(entries) {
+    __publicField(this, "data");
+    this.data = new Set(entries ?? []);
+  }
+  has(value) {
+    return this.some((v) => this.valueEquals(v, value));
+  }
+  add(value) {
+    if (!this.has(value))
+      this.data.add(value);
+    return value;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  set(key, value) {
+    if (!this.valueEquals(key, value))
+      throw new TypeError("SetBase.set() requires key === value.");
+    this.add(value);
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  get(key) {
+    return this.has(key) ? key : void 0;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  getOrDefault(key, defaultValue) {
+    return this.get(key) ?? defaultValue;
+  }
+  getOrCreate(key, creatorOrValue) {
+    if (!this.has(key)) {
+      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(key, value);
+      return value;
+    }
+    return this.get(key);
+  }
+  delete(value) {
+    if (!this.has(value)) return false;
+    for (const v of this.values()) {
+      if (this.valueEquals(v, value)) {
+        this.data.delete(v);
+        return true;
+      }
+    }
+    return false;
+  }
+  clear() {
+    this.data.clear();
+  }
+  get size() {
+    return this.data.size;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  forEach(callbackfn, thisArg) {
+    this.data.forEach((value) => callbackfn.call(thisArg, value, this));
+  }
+  *keys() {
+    yield* this.data.keys();
+  }
+  *values() {
+    yield* this.data.values();
+  }
+  *entries() {
+    yield* this.data.entries();
+  }
+  *kvKeys() {
+    for (const key of this.keys()) {
+      yield [key];
+    }
+  }
+  *kvValues() {
+    for (const el of this.values()) {
+      yield el;
+    }
+  }
+  *kvEntries() {
+    for (const [key, el] of this.entries()) {
+      yield [[key], el];
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* this.values();
+  }
+  clone() {
+    const result = this.createEmpty();
+    for (const v of this.values()) result.add(v);
+    return result;
+  }
+  merge(other) {
+    for (const value of other.values()) {
+      this.add(value);
+    }
+    return this;
+  }
+  some(fn) {
+    for (const value of this.data) {
+      if (fn(value)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const value of this.data) {
+      if (!fn(value)) return false;
+    }
+    return true;
+  }
+  filter(predicate) {
+    const result = this.createEmpty();
+    for (const value of this.data)
+      if (predicate(value, this)) result.add(value);
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.values();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty SetBase with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value;
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const value = current.value;
+      acc = fn(acc, value);
+    }
+    return acc;
+  }
+  mapValues(fn) {
+    let result = this.createEmpty();
+    for (const value of this.data) {
+      result.add(fn(value));
+    }
+    return result;
+  }
+  mapToArray(fn) {
+    let result = [];
+    for (const value of this.values()) {
+      result.push(fn(value));
+    }
+    return result;
+  }
+  map(fn) {
+    let result = this.createEmpty();
+    for (const value of this.values()) {
+      result.add(fn(value));
+    }
+    return result;
+  }
+  toSet() {
+    return new Set(this.data);
+  }
+  toArray() {
+    return [...this.values()];
+  }
+  toString() {
+    return `${this.getName()}(${this.size})${formatValue([...this.data])}`.replaceAll("  ", " ");
+  }
+};
+var Set1 = class _Set1 extends SetBase {
+  constructor(entries) {
+    super(entries);
+  }
+  createEmpty() {
+    return new _Set1();
+  }
+  valueEquals(a, b) {
+    return a === b;
+  }
+  getName() {
+    return "Set1";
+  }
+};
+var DeepSet = class _DeepSet extends SetBase {
+  constructor(entries) {
+    super(entries);
+  }
+  createEmpty() {
+    return new _DeepSet();
+  }
+  valueEquals(a, b) {
+    return isDeepEqual2(a, b);
+  }
+  getName() {
+    return "DeepSet";
+  }
+};
+
 // src/core/multi-container.ts
 var MultiContainer = class {
   constructor(base) {
@@ -3345,6 +3750,8 @@ var SmallIntCache = class {
 0 && (module.exports = {
   Assert,
   Cookies,
+  DeepSet,
+  DefaultArray,
   Device,
   DivRect,
   Guard,
@@ -3354,6 +3761,8 @@ var SmallIntCache = class {
   Map2,
   Map3,
   MultiContainer,
+  Set1,
+  SetBase,
   SignedIndexArray,
   SmallIntCache,
   Stack,

package/dist/index.mjs

@@ -1,4 +1,4 @@
-/* TsUtilsLib v1.19.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
+/* TsUtilsLib v1.19.1 | (c) 2023 PahkaSoft | Licensed under the MIT License */
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
@@ -2576,6 +2576,209 @@ var SignedIndexArray = class _SignedIndexArray {
   }
 };
 
+// src/core/default-array.ts
+var DefaultArray = class _DefaultArray {
+  constructor(lengthOrValues, defaultValue) {
+    this.defaultValue = defaultValue;
+    __publicField(this, "data");
+    if (typeof lengthOrValues === "number") {
+      this.data = Array(lengthOrValues).fill(defaultValue);
+    } else {
+      this.data = Array.from(lengthOrValues).map(
+        (v) => v === void 0 ? defaultValue : v
+      );
+    }
+  }
+  get size() {
+    return this.data.length;
+  }
+  get length() {
+    return this.data.length;
+  }
+  assertId(id) {
+    if (id < 0 || id >= this.data.length)
+      throw new RangeError(`DefaultArray: Index ${id} out of range`);
+    return id;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  isDefault(id) {
+    return this.data[this.assertId(id)] === this.defaultValue;
+  }
+  isSet(id) {
+    return this.data[this.assertId(id)] !== this.defaultValue;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  has(id) {
+    return this.isSet(id);
+  }
+  set(id, value) {
+    return this.data[this.assertId(id)] = value;
+  }
+  get(id) {
+    return this.data[this.assertId(id)];
+  }
+  getOrDefault(id, defaultValue) {
+    let value = this.get(id);
+    return value === this.defaultValue ? defaultValue : value;
+  }
+  getOrCreate(id, creatorOrValue) {
+    if (!this.has(id)) {
+      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(id, value);
+      return value;
+    }
+    return this.get(id);
+  }
+  delete(id) {
+    this.assertId(id);
+    if (this.data[id] === this.defaultValue) return false;
+    this.data[id] = this.defaultValue;
+    return true;
+  }
+  clear(empty = false) {
+    if (empty)
+      this.data = [];
+    else
+      this.data.fill(this.defaultValue);
+  }
+  forEach(callbackfn, thisArg) {
+    for (const [id, value] of this.entries()) {
+      callbackfn.call(thisArg, value, id, this);
+    }
+  }
+  *indices() {
+    yield* this.data.keys();
+  }
+  *values() {
+    yield* this.data.values();
+  }
+  *entries() {
+    yield* this.data.entries();
+  }
+  indicesArray() {
+    return [...this.indices()];
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  *kvKeys() {
+    for (const id of this.indices()) {
+      yield [id];
+    }
+  }
+  *kvValues() {
+    for (const value of this.values()) {
+      yield value;
+    }
+  }
+  *kvEntries() {
+    for (const [id, value] of this.entries()) {
+      yield [[id], value];
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* this.entries();
+  }
+  clone() {
+    const ctor = this.constructor;
+    const clone = new ctor(this.length, this.defaultValue);
+    clone.data = this.data.slice();
+    return clone;
+  }
+  merge(other, conflictResolver) {
+    if (this.constructor !== other.constructor)
+      throw new Error(`Cannot merge DefaultArray: different classes (${this.constructor.name} vs ${other.constructor.name})`);
+    if (this.defaultValue !== other.defaultValue)
+      throw new Error(`Cannot merge DefaultArray: different defaultValue (${this.defaultValue} vs ${other.defaultValue})`);
+    for (const [id, value] of other.entries()) {
+      if (this.isDefault(id))
+        this.set(id, value);
+      else if (conflictResolver)
+        this.set(id, conflictResolver(this.get(id), value, id));
+      else
+        this.set(id, value);
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [id, value] of this.entries()) {
+      if (fn(value, id)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [id, value] of this.entries()) {
+      if (!fn(value, id)) return false;
+    }
+    return true;
+  }
+  filter(predicate) {
+    const result = new this.constructor(this.length, this.defaultValue);
+    for (const [id, value] of this.entries()) {
+      if (predicate(value, id, this)) result.set(id, value);
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.entries();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty DefaultArray with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value[1];
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const [id, value] = current.value;
+      acc = fn(acc, value, id);
+    }
+    return acc;
+  }
+  mapToArray(fn) {
+    let result = [];
+    for (const [id, value] of this.entries()) {
+      result.push(fn(value, id));
+    }
+    return result;
+  }
+  map(fn, defaultValue) {
+    let result = new _DefaultArray(this.data.length, defaultValue);
+    for (let id = 0; id < this.data.length; id++) {
+      result.data[id] = fn(this.data[id], id);
+    }
+    return result;
+  }
+  equals(other, eq2) {
+    if (this.size !== other.size) return false;
+    eq2 ?? (eq2 = (a, b) => a === b);
+    for (let id = 0; id < this.data.length; ++id) {
+      if (!eq2(this.data[id], other.data[id])) return false;
+    }
+    return true;
+  }
+  toArray() {
+    return this.valuesArray();
+  }
+  toString() {
+    const entries = this.entriesArray().map(([id, v]) => `${formatValue(id)}: ${formatValue(v)}`).join(", ");
+    return `DefaultArray[ ${entries} ]`.replaceAll("  ", " ");
+  }
+};
+
 // src/core/map1.ts
 var Map1 = class _Map1 {
   constructor(entries) {
@@ -3159,6 +3362,204 @@ var Map3 = class _Map3 {
   }
 };
 
+// src/core/set.ts
+var SetBase = class {
+  constructor(entries) {
+    __publicField(this, "data");
+    this.data = new Set(entries ?? []);
+  }
+  has(value) {
+    return this.some((v) => this.valueEquals(v, value));
+  }
+  add(value) {
+    if (!this.has(value))
+      this.data.add(value);
+    return value;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  set(key, value) {
+    if (!this.valueEquals(key, value))
+      throw new TypeError("SetBase.set() requires key === value.");
+    this.add(value);
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  get(key) {
+    return this.has(key) ? key : void 0;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  getOrDefault(key, defaultValue) {
+    return this.get(key) ?? defaultValue;
+  }
+  getOrCreate(key, creatorOrValue) {
+    if (!this.has(key)) {
+      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(key, value);
+      return value;
+    }
+    return this.get(key);
+  }
+  delete(value) {
+    if (!this.has(value)) return false;
+    for (const v of this.values()) {
+      if (this.valueEquals(v, value)) {
+        this.data.delete(v);
+        return true;
+      }
+    }
+    return false;
+  }
+  clear() {
+    this.data.clear();
+  }
+  get size() {
+    return this.data.size;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  forEach(callbackfn, thisArg) {
+    this.data.forEach((value) => callbackfn.call(thisArg, value, this));
+  }
+  *keys() {
+    yield* this.data.keys();
+  }
+  *values() {
+    yield* this.data.values();
+  }
+  *entries() {
+    yield* this.data.entries();
+  }
+  *kvKeys() {
+    for (const key of this.keys()) {
+      yield [key];
+    }
+  }
+  *kvValues() {
+    for (const el of this.values()) {
+      yield el;
+    }
+  }
+  *kvEntries() {
+    for (const [key, el] of this.entries()) {
+      yield [[key], el];
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* this.values();
+  }
+  clone() {
+    const result = this.createEmpty();
+    for (const v of this.values()) result.add(v);
+    return result;
+  }
+  merge(other) {
+    for (const value of other.values()) {
+      this.add(value);
+    }
+    return this;
+  }
+  some(fn) {
+    for (const value of this.data) {
+      if (fn(value)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const value of this.data) {
+      if (!fn(value)) return false;
+    }
+    return true;
+  }
+  filter(predicate) {
+    const result = this.createEmpty();
+    for (const value of this.data)
+      if (predicate(value, this)) result.add(value);
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.values();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty SetBase with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value;
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const value = current.value;
+      acc = fn(acc, value);
+    }
+    return acc;
+  }
+  mapValues(fn) {
+    let result = this.createEmpty();
+    for (const value of this.data) {
+      result.add(fn(value));
+    }
+    return result;
+  }
+  mapToArray(fn) {
+    let result = [];
+    for (const value of this.values()) {
+      result.push(fn(value));
+    }
+    return result;
+  }
+  map(fn) {
+    let result = this.createEmpty();
+    for (const value of this.values()) {
+      result.add(fn(value));
+    }
+    return result;
+  }
+  toSet() {
+    return new Set(this.data);
+  }
+  toArray() {
+    return [...this.values()];
+  }
+  toString() {
+    return `${this.getName()}(${this.size})${formatValue([...this.data])}`.replaceAll("  ", " ");
+  }
+};
+var Set1 = class _Set1 extends SetBase {
+  constructor(entries) {
+    super(entries);
+  }
+  createEmpty() {
+    return new _Set1();
+  }
+  valueEquals(a, b) {
+    return a === b;
+  }
+  getName() {
+    return "Set1";
+  }
+};
+var DeepSet = class _DeepSet extends SetBase {
+  constructor(entries) {
+    super(entries);
+  }
+  createEmpty() {
+    return new _DeepSet();
+  }
+  valueEquals(a, b) {
+    return isDeepEqual2(a, b);
+  }
+  getName() {
+    return "DeepSet";
+  }
+};
+
 // src/core/multi-container.ts
 var MultiContainer = class {
   constructor(base) {
@@ -3307,6 +3708,8 @@ var SmallIntCache = class {
 export {
   assert_exports as Assert,
   cookies_exports as Cookies,
+  DeepSet,
+  DefaultArray,
   device_exports as Device,
   DivRect,
   guard_exports as Guard,
@@ -3316,6 +3719,8 @@ export {
   Map2,
   Map3,
   MultiContainer,
+  Set1,
+  SetBase,
   SignedIndexArray,
   SmallIntCache,
   Stack,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tspro/ts-utils-lib",
-    "version": "1.19.0",
+    "version": "1.19.1",
     "author": "PahkaSoft",
     "license": "MIT",
     "private": false,