@ls-stack/utils 3.62.0 → 3.65.0

package/dist/arrayUtils.cjs

@@ -31,6 +31,7 @@ __export(arrayUtils_exports, {
   hasDuplicates: () => hasDuplicates,
   intersperse: () => intersperse,
   isInArray: () => isInArray,
+  isInArrayWithoutNarrowing: () => isInArrayWithoutNarrowing,
   looseIsInArray: () => looseIsInArray,
   rejectArrayUndefinedValues: () => rejectArrayUndefinedValues,
   rejectDuplicates: () => rejectDuplicates,
@@ -106,6 +107,9 @@ function isInArray(value, oneOf) {
   }
   return false;
 }
+function isInArrayWithoutNarrowing(value, oneOf) {
+  return oneOf.includes(value);
+}
 function looseIsInArray(value, array) {
   return array.includes(value);
 }
@@ -215,6 +219,7 @@ function repeat(value, count, separator) {
   hasDuplicates,
   intersperse,
   isInArray,
+  isInArrayWithoutNarrowing,
   looseIsInArray,
   rejectArrayUndefinedValues,
   rejectDuplicates,

package/dist/arrayUtils.d.cts

@@ -76,6 +76,7 @@ declare function arrayWithPrevAndIndex<T>(array: T[]): {
     index: number;
 }[];
 declare function isInArray<T, const U extends T>(value: T, oneOf: readonly U[]): value is U;
+declare function isInArrayWithoutNarrowing<T, const U extends T>(value: T, oneOf: readonly U[]): boolean;
 declare function looseIsInArray(value: unknown, array: readonly unknown[]): boolean;
 declare function findAfterIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
 declare function findBeforeIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
@@ -167,4 +168,4 @@ declare function intersperse<T, I>(array: T[], separator: I): (T | I)[];
  */
 declare function repeat<T>(value: T, count: number, separator?: T): T[];
 
-export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, intersperse, isInArray, looseIsInArray, rejectArrayUndefinedValues, rejectDuplicates, repeat, sortBy, truncateArray };
+export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, intersperse, isInArray, isInArrayWithoutNarrowing, looseIsInArray, rejectArrayUndefinedValues, rejectDuplicates, repeat, sortBy, truncateArray };

package/dist/arrayUtils.d.ts

@@ -76,6 +76,7 @@ declare function arrayWithPrevAndIndex<T>(array: T[]): {
     index: number;
 }[];
 declare function isInArray<T, const U extends T>(value: T, oneOf: readonly U[]): value is U;
+declare function isInArrayWithoutNarrowing<T, const U extends T>(value: T, oneOf: readonly U[]): boolean;
 declare function looseIsInArray(value: unknown, array: readonly unknown[]): boolean;
 declare function findAfterIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
 declare function findBeforeIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
@@ -167,4 +168,4 @@ declare function intersperse<T, I>(array: T[], separator: I): (T | I)[];
  */
 declare function repeat<T>(value: T, count: number, separator?: T): T[];
 
-export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, intersperse, isInArray, looseIsInArray, rejectArrayUndefinedValues, rejectDuplicates, repeat, sortBy, truncateArray };
+export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, intersperse, isInArray, isInArrayWithoutNarrowing, looseIsInArray, rejectArrayUndefinedValues, rejectDuplicates, repeat, sortBy, truncateArray };

package/dist/arrayUtils.js

@@ -10,13 +10,14 @@ import {
   hasDuplicates,
   intersperse,
   isInArray,
+  isInArrayWithoutNarrowing,
   looseIsInArray,
   rejectArrayUndefinedValues,
   rejectDuplicates,
   repeat,
   sortBy,
   truncateArray
-} from "./chunk-GVIDV772.js";
+} from "./chunk-WFQJUJTC.js";
 import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";
 export {
@@ -31,6 +32,7 @@ export {
   hasDuplicates,
   intersperse,
   isInArray,
+  isInArrayWithoutNarrowing,
   looseIsInArray,
   rejectArrayUndefinedValues,
   rejectDuplicates,

package/dist/{chunk-2LO5FYP5.js → chunk-MI4UE2PQ.js}

@@ -1,6 +1,6 @@
 import {
   sortBy
-} from "./chunk-GVIDV772.js";
+} from "./chunk-WFQJUJTC.js";
 import {
   isPlainObject
 } from "./chunk-JF2MDHOJ.js";

package/dist/{chunk-GVIDV772.js → chunk-WFQJUJTC.js}

@@ -60,6 +60,9 @@ function isInArray(value, oneOf) {
   }
   return false;
 }
+function isInArrayWithoutNarrowing(value, oneOf) {
+  return oneOf.includes(value);
+}
 function looseIsInArray(value, array) {
   return array.includes(value);
 }
@@ -164,6 +167,7 @@ export {
   arrayWithPrev,
   arrayWithPrevAndIndex,
   isInArray,
+  isInArrayWithoutNarrowing,
   looseIsInArray,
   findAfterIndex,
   findBeforeIndex,

package/dist/{chunk-SGRS4OEE.js → chunk-ZXIKIA5B.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-GMJTLFM6.js";
 import {
   sortBy
-} from "./chunk-GVIDV772.js";
+} from "./chunk-WFQJUJTC.js";
 
 // src/objUtils.ts
 import { Result } from "t-result";

package/dist/concurrentCalls.js

@@ -1,15 +1,15 @@
 import {
   truncateString
 } from "./chunk-BM4PYVOX.js";
-import {
-  safeJsonStringify
-} from "./chunk-VAAMRG4K.js";
 import {
   sleep
 } from "./chunk-5DZT3Z5Z.js";
+import {
+  safeJsonStringify
+} from "./chunk-VAAMRG4K.js";
 import {
   truncateArray
-} from "./chunk-GVIDV772.js";
+} from "./chunk-WFQJUJTC.js";
 import {
   invariant
 } from "./chunk-C2SVCIWE.js";

package/dist/filterObjectOrArrayKeys.js

@@ -1,7 +1,7 @@
 import {
   filterObjectOrArrayKeys
-} from "./chunk-2LO5FYP5.js";
-import "./chunk-GVIDV772.js";
+} from "./chunk-MI4UE2PQ.js";
+import "./chunk-WFQJUJTC.js";
 import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";
 export {

package/dist/keyedMap.cjs

@@ -0,0 +1,224 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/keyedMap.ts
+var keyedMap_exports = {};
+__export(keyedMap_exports, {
+  CompositeKeyMap: () => CompositeKeyMap,
+  KeyedMap: () => KeyedMap
+});
+module.exports = __toCommonJS(keyedMap_exports);
+
+// src/typeGuards.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/assertions.ts
+var isObject2 = isObject;
+
+// src/getCompositeKey.ts
+function getCompositeKey(input, maxSortingDepth = 3) {
+  if (typeof input === "string") return `"${input}`;
+  if (!input || typeof input !== "object") return `$${input}`;
+  return stringifyCompact(input, maxSortingDepth, 0, /* @__PURE__ */ new WeakSet());
+}
+function stringifyCompact(input, maxSortingDepth, depth, refs) {
+  const isJsObj = input && typeof input === "object";
+  if (isJsObj) {
+    if (refs.has(input)) {
+      throw new Error("Circular reference detected");
+    }
+    refs.add(input);
+  }
+  let result;
+  if (Array.isArray(input)) {
+    result = "[";
+    for (const v of input) {
+      if (result.length > 1) result += ",";
+      result += stringifyCompact(v, maxSortingDepth, depth + 1, refs);
+    }
+    result += "]";
+  } else if (isObject2(input)) {
+    let entries = Object.entries(input);
+    if (entries.length === 0) {
+      result = "{}";
+    } else {
+      if (depth < maxSortingDepth) {
+        entries = entries.sort(
+          ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+        );
+      }
+      result = "{";
+      for (const [k, v] of entries) {
+        if (v === void 0) continue;
+        if (result.length > 1) result += ",";
+        result += `${k}:${stringifyCompact(v, maxSortingDepth, depth + 1, refs)}`;
+      }
+      result += "}";
+    }
+  } else {
+    result = JSON.stringify(input);
+  }
+  if (isJsObj) {
+    refs.delete(input);
+  }
+  return result;
+}
+
+// src/keyedMap.ts
+var KeyedMap = class {
+  map;
+  getKey;
+  /**
+   * @param getKey - Function to compute an internal key from the external key
+   * @param entries - Optional initial entries to add to the map
+   */
+  constructor(getKey, entries) {
+    this.getKey = getKey;
+    this.map = /* @__PURE__ */ new Map();
+    if (entries) {
+      for (const [key, value] of entries) {
+        this.set(key, value);
+      }
+    }
+  }
+  /** The number of entries in the map */
+  get size() {
+    return this.map.size;
+  }
+  /** Sets a value for the given key. If the key exists, replaces both key and value. */
+  set(key, value) {
+    const internalKey = this.getKey(key);
+    this.map.set(internalKey, { key, value });
+    return this;
+  }
+  /** Sets multiple entries at once. */
+  setMultiple(entries) {
+    for (const [key, value] of entries) {
+      this.set(key, value);
+    }
+    return this;
+  }
+  /** Gets the value for the given key, or undefined if not found. */
+  get(key) {
+    const internalKey = this.getKey(key);
+    return this.map.get(internalKey)?.value;
+  }
+  /** Checks if the map contains the given key. */
+  has(key) {
+    const internalKey = this.getKey(key);
+    return this.map.has(internalKey);
+  }
+  /** Removes the entry for the given key. Returns true if the entry was removed. */
+  delete(key) {
+    const internalKey = this.getKey(key);
+    return this.map.delete(internalKey);
+  }
+  /** Removes multiple entries. Returns the number of entries removed. */
+  deleteMultiple(keys) {
+    let count = 0;
+    for (const key of keys) {
+      if (this.delete(key)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /** Removes all entries from the map. */
+  clear() {
+    this.map.clear();
+  }
+  /** Executes a callback for each entry in the map. */
+  forEach(callback, thisArg) {
+    for (const { key, value } of this.map.values()) {
+      callback.call(thisArg, value, key, this);
+    }
+  }
+  /** Finds the first entry matching the predicate. */
+  find(predicate) {
+    for (const { key, value } of this.map.values()) {
+      if (predicate(value, key)) {
+        return { key, value };
+      }
+    }
+    return void 0;
+  }
+  /** Gets the value for the given key, or throws if not found. */
+  getOrThrow(key) {
+    const value = this.get(key);
+    if (value === void 0 && !this.has(key)) {
+      throw new Error(`Key not found in KeyedMap`);
+    }
+    return value;
+  }
+  /** Gets the value for the given key, or inserts and returns the fallback value. */
+  getOrInsert(key, fallback) {
+    if (!this.has(key)) {
+      this.set(key, fallback());
+    }
+    return this.getOrThrow(key);
+  }
+  /** Returns values that match the predicate. */
+  toFilteredValues(predicate) {
+    const values = [];
+    for (const { key, value } of this.map.values()) {
+      if (predicate(value, key)) {
+        values.push(value);
+      }
+    }
+    return values;
+  }
+  /** Returns all values as an array. */
+  toValues() {
+    return [...this.values()];
+  }
+  /** Returns all keys as an array. */
+  toKeys() {
+    return [...this.keys()];
+  }
+  *keys() {
+    for (const { key } of this.map.values()) {
+      yield key;
+    }
+  }
+  *values() {
+    for (const { value } of this.map.values()) {
+      yield value;
+    }
+  }
+  *entries() {
+    for (const { key, value } of this.map.values()) {
+      yield [key, value];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+var CompositeKeyMap = class extends KeyedMap {
+  constructor(entries) {
+    super(getCompositeKey, entries);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompositeKeyMap,
+  KeyedMap
+});

package/dist/keyedMap.d.cts

@@ -0,0 +1,75 @@
+/**
+ * A Map implementation that uses a custom key function to determine key equality.
+ * Keys with the same computed internal key are considered equal.
+ *
+ * @example
+ *   const map = new KeyedMap<{ x: number; y: number }, string, string>(
+ *     (key) => `${key.x},${key.y}`,
+ *   );
+ *   map.set({ x: 1, y: 2 }, 'point A');
+ *   map.get({ x: 1, y: 2 }); // 'point A' (different object, same computed key)
+ *
+ * @template K - The type of the external key
+ * @template V - The type of the value
+ * @template InternalKey - The type of the internal key used for comparison
+ */
+declare class KeyedMap<K, V, InternalKey = string> {
+    private map;
+    private getKey;
+    /**
+     * @param getKey - Function to compute an internal key from the external key
+     * @param entries - Optional initial entries to add to the map
+     */
+    constructor(getKey: (key: K) => InternalKey, entries?: Iterable<[K, V]>);
+    /** The number of entries in the map */
+    get size(): number;
+    /** Sets a value for the given key. If the key exists, replaces both key and value. */
+    set(key: K, value: V): this;
+    /** Sets multiple entries at once. */
+    setMultiple(entries: Iterable<[K, V]>): this;
+    /** Gets the value for the given key, or undefined if not found. */
+    get(key: K): V | undefined;
+    /** Checks if the map contains the given key. */
+    has(key: K): boolean;
+    /** Removes the entry for the given key. Returns true if the entry was removed. */
+    delete(key: K): boolean;
+    /** Removes multiple entries. Returns the number of entries removed. */
+    deleteMultiple(keys: Iterable<K>): number;
+    /** Removes all entries from the map. */
+    clear(): void;
+    /** Executes a callback for each entry in the map. */
+    forEach(callback: (value: V, key: K, map: KeyedMap<K, V, InternalKey>) => void, thisArg?: unknown): void;
+    /** Finds the first entry matching the predicate. */
+    find(predicate: (value: V, key: K) => boolean): {
+        key: K;
+        value: V;
+    } | undefined;
+    /** Gets the value for the given key, or throws if not found. */
+    getOrThrow(key: K): V;
+    /** Gets the value for the given key, or inserts and returns the fallback value. */
+    getOrInsert(key: K, fallback: () => V): V;
+    /** Returns values that match the predicate. */
+    toFilteredValues(predicate: (value: V, key: K) => boolean): V[];
+    /** Returns all values as an array. */
+    toValues(): V[];
+    /** Returns all keys as an array. */
+    toKeys(): K[];
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}
+/**
+ * A Map that compares keys by value instead of reference.
+ * Uses `getCompositeKey` to generate a stable string key for any value.
+ *
+ * @example
+ *   const map = new CompositeKeyMap<{ x: number; y: number }, string>();
+ *   map.set({ x: 1, y: 2 }, 'point A');
+ *   map.get({ x: 1, y: 2 }); // 'point A' (different object, same value)
+ */
+declare class CompositeKeyMap<K, V> extends KeyedMap<K, V, string> {
+    constructor(entries?: Iterable<[K, V]>);
+}
+
+export { CompositeKeyMap, KeyedMap };

package/dist/keyedMap.d.ts

@@ -0,0 +1,75 @@
+/**
+ * A Map implementation that uses a custom key function to determine key equality.
+ * Keys with the same computed internal key are considered equal.
+ *
+ * @example
+ *   const map = new KeyedMap<{ x: number; y: number }, string, string>(
+ *     (key) => `${key.x},${key.y}`,
+ *   );
+ *   map.set({ x: 1, y: 2 }, 'point A');
+ *   map.get({ x: 1, y: 2 }); // 'point A' (different object, same computed key)
+ *
+ * @template K - The type of the external key
+ * @template V - The type of the value
+ * @template InternalKey - The type of the internal key used for comparison
+ */
+declare class KeyedMap<K, V, InternalKey = string> {
+    private map;
+    private getKey;
+    /**
+     * @param getKey - Function to compute an internal key from the external key
+     * @param entries - Optional initial entries to add to the map
+     */
+    constructor(getKey: (key: K) => InternalKey, entries?: Iterable<[K, V]>);
+    /** The number of entries in the map */
+    get size(): number;
+    /** Sets a value for the given key. If the key exists, replaces both key and value. */
+    set(key: K, value: V): this;
+    /** Sets multiple entries at once. */
+    setMultiple(entries: Iterable<[K, V]>): this;
+    /** Gets the value for the given key, or undefined if not found. */
+    get(key: K): V | undefined;
+    /** Checks if the map contains the given key. */
+    has(key: K): boolean;
+    /** Removes the entry for the given key. Returns true if the entry was removed. */
+    delete(key: K): boolean;
+    /** Removes multiple entries. Returns the number of entries removed. */
+    deleteMultiple(keys: Iterable<K>): number;
+    /** Removes all entries from the map. */
+    clear(): void;
+    /** Executes a callback for each entry in the map. */
+    forEach(callback: (value: V, key: K, map: KeyedMap<K, V, InternalKey>) => void, thisArg?: unknown): void;
+    /** Finds the first entry matching the predicate. */
+    find(predicate: (value: V, key: K) => boolean): {
+        key: K;
+        value: V;
+    } | undefined;
+    /** Gets the value for the given key, or throws if not found. */
+    getOrThrow(key: K): V;
+    /** Gets the value for the given key, or inserts and returns the fallback value. */
+    getOrInsert(key: K, fallback: () => V): V;
+    /** Returns values that match the predicate. */
+    toFilteredValues(predicate: (value: V, key: K) => boolean): V[];
+    /** Returns all values as an array. */
+    toValues(): V[];
+    /** Returns all keys as an array. */
+    toKeys(): K[];
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}
+/**
+ * A Map that compares keys by value instead of reference.
+ * Uses `getCompositeKey` to generate a stable string key for any value.
+ *
+ * @example
+ *   const map = new CompositeKeyMap<{ x: number; y: number }, string>();
+ *   map.set({ x: 1, y: 2 }, 'point A');
+ *   map.get({ x: 1, y: 2 }); // 'point A' (different object, same value)
+ */
+declare class CompositeKeyMap<K, V> extends KeyedMap<K, V, string> {
+    constructor(entries?: Iterable<[K, V]>);
+}
+
+export { CompositeKeyMap, KeyedMap };

package/dist/keyedMap.js

@@ -0,0 +1,145 @@
+import {
+  getCompositeKey
+} from "./chunk-6FIBVC2P.js";
+import "./chunk-C2SVCIWE.js";
+import "./chunk-JF2MDHOJ.js";
+
+// src/keyedMap.ts
+var KeyedMap = class {
+  map;
+  getKey;
+  /**
+   * @param getKey - Function to compute an internal key from the external key
+   * @param entries - Optional initial entries to add to the map
+   */
+  constructor(getKey, entries) {
+    this.getKey = getKey;
+    this.map = /* @__PURE__ */ new Map();
+    if (entries) {
+      for (const [key, value] of entries) {
+        this.set(key, value);
+      }
+    }
+  }
+  /** The number of entries in the map */
+  get size() {
+    return this.map.size;
+  }
+  /** Sets a value for the given key. If the key exists, replaces both key and value. */
+  set(key, value) {
+    const internalKey = this.getKey(key);
+    this.map.set(internalKey, { key, value });
+    return this;
+  }
+  /** Sets multiple entries at once. */
+  setMultiple(entries) {
+    for (const [key, value] of entries) {
+      this.set(key, value);
+    }
+    return this;
+  }
+  /** Gets the value for the given key, or undefined if not found. */
+  get(key) {
+    const internalKey = this.getKey(key);
+    return this.map.get(internalKey)?.value;
+  }
+  /** Checks if the map contains the given key. */
+  has(key) {
+    const internalKey = this.getKey(key);
+    return this.map.has(internalKey);
+  }
+  /** Removes the entry for the given key. Returns true if the entry was removed. */
+  delete(key) {
+    const internalKey = this.getKey(key);
+    return this.map.delete(internalKey);
+  }
+  /** Removes multiple entries. Returns the number of entries removed. */
+  deleteMultiple(keys) {
+    let count = 0;
+    for (const key of keys) {
+      if (this.delete(key)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /** Removes all entries from the map. */
+  clear() {
+    this.map.clear();
+  }
+  /** Executes a callback for each entry in the map. */
+  forEach(callback, thisArg) {
+    for (const { key, value } of this.map.values()) {
+      callback.call(thisArg, value, key, this);
+    }
+  }
+  /** Finds the first entry matching the predicate. */
+  find(predicate) {
+    for (const { key, value } of this.map.values()) {
+      if (predicate(value, key)) {
+        return { key, value };
+      }
+    }
+    return void 0;
+  }
+  /** Gets the value for the given key, or throws if not found. */
+  getOrThrow(key) {
+    const value = this.get(key);
+    if (value === void 0 && !this.has(key)) {
+      throw new Error(`Key not found in KeyedMap`);
+    }
+    return value;
+  }
+  /** Gets the value for the given key, or inserts and returns the fallback value. */
+  getOrInsert(key, fallback) {
+    if (!this.has(key)) {
+      this.set(key, fallback());
+    }
+    return this.getOrThrow(key);
+  }
+  /** Returns values that match the predicate. */
+  toFilteredValues(predicate) {
+    const values = [];
+    for (const { key, value } of this.map.values()) {
+      if (predicate(value, key)) {
+        values.push(value);
+      }
+    }
+    return values;
+  }
+  /** Returns all values as an array. */
+  toValues() {
+    return [...this.values()];
+  }
+  /** Returns all keys as an array. */
+  toKeys() {
+    return [...this.keys()];
+  }
+  *keys() {
+    for (const { key } of this.map.values()) {
+      yield key;
+    }
+  }
+  *values() {
+    for (const { value } of this.map.values()) {
+      yield value;
+    }
+  }
+  *entries() {
+    for (const { key, value } of this.map.values()) {
+      yield [key, value];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+var CompositeKeyMap = class extends KeyedMap {
+  constructor(entries) {
+    super(getCompositeKey, entries);
+  }
+};
+export {
+  CompositeKeyMap,
+  KeyedMap
+};

package/dist/keyedSet.cjs

@@ -0,0 +1,205 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/keyedSet.ts
+var keyedSet_exports = {};
+__export(keyedSet_exports, {
+  CompositeKeySet: () => CompositeKeySet,
+  KeyedSet: () => KeyedSet
+});
+module.exports = __toCommonJS(keyedSet_exports);
+
+// src/typeGuards.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/assertions.ts
+var isObject2 = isObject;
+
+// src/getCompositeKey.ts
+function getCompositeKey(input, maxSortingDepth = 3) {
+  if (typeof input === "string") return `"${input}`;
+  if (!input || typeof input !== "object") return `$${input}`;
+  return stringifyCompact(input, maxSortingDepth, 0, /* @__PURE__ */ new WeakSet());
+}
+function stringifyCompact(input, maxSortingDepth, depth, refs) {
+  const isJsObj = input && typeof input === "object";
+  if (isJsObj) {
+    if (refs.has(input)) {
+      throw new Error("Circular reference detected");
+    }
+    refs.add(input);
+  }
+  let result;
+  if (Array.isArray(input)) {
+    result = "[";
+    for (const v of input) {
+      if (result.length > 1) result += ",";
+      result += stringifyCompact(v, maxSortingDepth, depth + 1, refs);
+    }
+    result += "]";
+  } else if (isObject2(input)) {
+    let entries = Object.entries(input);
+    if (entries.length === 0) {
+      result = "{}";
+    } else {
+      if (depth < maxSortingDepth) {
+        entries = entries.sort(
+          ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+        );
+      }
+      result = "{";
+      for (const [k, v] of entries) {
+        if (v === void 0) continue;
+        if (result.length > 1) result += ",";
+        result += `${k}:${stringifyCompact(v, maxSortingDepth, depth + 1, refs)}`;
+      }
+      result += "}";
+    }
+  } else {
+    result = JSON.stringify(input);
+  }
+  if (isJsObj) {
+    refs.delete(input);
+  }
+  return result;
+}
+
+// src/keyedSet.ts
+var KeyedSet = class {
+  map;
+  getKey;
+  /**
+   * @param getKey - Function to extract a unique key from each item
+   * @param iterable - Optional initial items to add to the set
+   */
+  constructor(getKey, iterable) {
+    this.getKey = getKey;
+    this.map = /* @__PURE__ */ new Map();
+    if (iterable) {
+      for (const item of iterable) {
+        this.add(item);
+      }
+    }
+  }
+  /** The number of items in the set */
+  get size() {
+    return this.map.size;
+  }
+  /**
+   * Adds an item to the set. If an item with the same key exists, it will be
+   * replaced.
+   */
+  add(item) {
+    const key = this.getKey(item);
+    this.map.set(key, item);
+    return this;
+  }
+  /** Adds multiple items to the set. */
+  addMultiple(items) {
+    for (const item of items) {
+      this.add(item);
+    }
+    return this;
+  }
+  /** Checks if an item with the same key exists in the set. */
+  has(item) {
+    const key = this.getKey(item);
+    return this.map.has(key);
+  }
+  /** Checks if an item with the given key exists in the set. */
+  hasKey(key) {
+    return this.map.has(key);
+  }
+  /** Gets an item by its key, or undefined if not found. */
+  getByKey(key) {
+    return this.map.get(key);
+  }
+  /**
+   * Removes an item from the set by computing its key. Returns true if the item
+   * was removed.
+   */
+  delete(item) {
+    const key = this.getKey(item);
+    return this.map.delete(key);
+  }
+  /** Removes an item by its key. Returns true if the item was removed. */
+  deleteByKey(key) {
+    return this.map.delete(key);
+  }
+  /** Removes multiple items from the set. Returns the number of items removed. */
+  deleteMultiple(items) {
+    let count = 0;
+    for (const item of items) {
+      if (this.delete(item)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /** Removes multiple items by their keys. Returns the number of items removed. */
+  deleteMultipleByKeys(keys) {
+    let count = 0;
+    for (const key of keys) {
+      if (this.deleteByKey(key)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /** Removes all items from the set. */
+  clear() {
+    this.map.clear();
+  }
+  /** Executes a callback for each item in the set. */
+  forEach(callback, thisArg) {
+    for (const value of this.map.values()) {
+      callback.call(thisArg, value, value, this);
+    }
+  }
+  *values() {
+    yield* this.map.values();
+  }
+  *keys() {
+    yield* this.map.values();
+  }
+  *entries() {
+    for (const value of this.map.values()) {
+      yield [value, value];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  /** Returns all items as an array. */
+  toArray() {
+    return [...this.map.values()];
+  }
+};
+var CompositeKeySet = class extends KeyedSet {
+  constructor(iterable) {
+    super(getCompositeKey, iterable);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompositeKeySet,
+  KeyedSet
+});

package/dist/keyedSet.d.cts

@@ -0,0 +1,76 @@
+/**
+ * A Set implementation that uses a custom key function to determine uniqueness.
+ * Items with the same key are considered equal, and adding a duplicate replaces
+ * the existing item.
+ *
+ * @example
+ *   const set = new KeyedSet<{ id: number; name: string }, number>(
+ *     (item) => item.id,
+ *   );
+ *   set.add({ id: 1, name: 'one' });
+ *   set.add({ id: 1, name: 'replaced' }); // replaces previous item
+ *   set.getByKey(1); // { id: 1, name: 'replaced' }
+ *
+ * @template T - The type of items stored in the set
+ * @template K - The type of the key extracted from items
+ */
+declare class KeyedSet<T, K = string> {
+    private map;
+    private getKey;
+    /**
+     * @param getKey - Function to extract a unique key from each item
+     * @param iterable - Optional initial items to add to the set
+     */
+    constructor(getKey: (item: T) => K, iterable?: Iterable<T>);
+    /** The number of items in the set */
+    get size(): number;
+    /**
+     * Adds an item to the set. If an item with the same key exists, it will be
+     * replaced.
+     */
+    add(item: T): this;
+    /** Adds multiple items to the set. */
+    addMultiple(items: Iterable<T>): this;
+    /** Checks if an item with the same key exists in the set. */
+    has(item: T): boolean;
+    /** Checks if an item with the given key exists in the set. */
+    hasKey(key: K): boolean;
+    /** Gets an item by its key, or undefined if not found. */
+    getByKey(key: K): T | undefined;
+    /**
+     * Removes an item from the set by computing its key. Returns true if the item
+     * was removed.
+     */
+    delete(item: T): boolean;
+    /** Removes an item by its key. Returns true if the item was removed. */
+    deleteByKey(key: K): boolean;
+    /** Removes multiple items from the set. Returns the number of items removed. */
+    deleteMultiple(items: Iterable<T>): number;
+    /** Removes multiple items by their keys. Returns the number of items removed. */
+    deleteMultipleByKeys(keys: Iterable<K>): number;
+    /** Removes all items from the set. */
+    clear(): void;
+    /** Executes a callback for each item in the set. */
+    forEach(callback: (value: T, value2: T, set: KeyedSet<T, K>) => void, thisArg?: unknown): void;
+    values(): IterableIterator<T>;
+    keys(): IterableIterator<T>;
+    entries(): IterableIterator<[T, T]>;
+    [Symbol.iterator](): IterableIterator<T>;
+    /** Returns all items as an array. */
+    toArray(): T[];
+}
+/**
+ * A Set that compares items by value instead of reference. Uses
+ * `getCompositeKey` to generate a stable string key for any value.
+ *
+ * @example
+ *   const set = new ValueSet<{ x: number; y: number }>();
+ *   set.add({ x: 1, y: 2 });
+ *   set.add({ x: 1, y: 2 }); // ignored, same value already exists
+ *   set.size; // 1
+ */
+declare class CompositeKeySet<T> extends KeyedSet<T, string> {
+    constructor(iterable?: Iterable<T>);
+}
+
+export { CompositeKeySet, KeyedSet };

package/dist/keyedSet.d.ts

@@ -0,0 +1,76 @@
+/**
+ * A Set implementation that uses a custom key function to determine uniqueness.
+ * Items with the same key are considered equal, and adding a duplicate replaces
+ * the existing item.
+ *
+ * @example
+ *   const set = new KeyedSet<{ id: number; name: string }, number>(
+ *     (item) => item.id,
+ *   );
+ *   set.add({ id: 1, name: 'one' });
+ *   set.add({ id: 1, name: 'replaced' }); // replaces previous item
+ *   set.getByKey(1); // { id: 1, name: 'replaced' }
+ *
+ * @template T - The type of items stored in the set
+ * @template K - The type of the key extracted from items
+ */
+declare class KeyedSet<T, K = string> {
+    private map;
+    private getKey;
+    /**
+     * @param getKey - Function to extract a unique key from each item
+     * @param iterable - Optional initial items to add to the set
+     */
+    constructor(getKey: (item: T) => K, iterable?: Iterable<T>);
+    /** The number of items in the set */
+    get size(): number;
+    /**
+     * Adds an item to the set. If an item with the same key exists, it will be
+     * replaced.
+     */
+    add(item: T): this;
+    /** Adds multiple items to the set. */
+    addMultiple(items: Iterable<T>): this;
+    /** Checks if an item with the same key exists in the set. */
+    has(item: T): boolean;
+    /** Checks if an item with the given key exists in the set. */
+    hasKey(key: K): boolean;
+    /** Gets an item by its key, or undefined if not found. */
+    getByKey(key: K): T | undefined;
+    /**
+     * Removes an item from the set by computing its key. Returns true if the item
+     * was removed.
+     */
+    delete(item: T): boolean;
+    /** Removes an item by its key. Returns true if the item was removed. */
+    deleteByKey(key: K): boolean;
+    /** Removes multiple items from the set. Returns the number of items removed. */
+    deleteMultiple(items: Iterable<T>): number;
+    /** Removes multiple items by their keys. Returns the number of items removed. */
+    deleteMultipleByKeys(keys: Iterable<K>): number;
+    /** Removes all items from the set. */
+    clear(): void;
+    /** Executes a callback for each item in the set. */
+    forEach(callback: (value: T, value2: T, set: KeyedSet<T, K>) => void, thisArg?: unknown): void;
+    values(): IterableIterator<T>;
+    keys(): IterableIterator<T>;
+    entries(): IterableIterator<[T, T]>;
+    [Symbol.iterator](): IterableIterator<T>;
+    /** Returns all items as an array. */
+    toArray(): T[];
+}
+/**
+ * A Set that compares items by value instead of reference. Uses
+ * `getCompositeKey` to generate a stable string key for any value.
+ *
+ * @example
+ *   const set = new ValueSet<{ x: number; y: number }>();
+ *   set.add({ x: 1, y: 2 });
+ *   set.add({ x: 1, y: 2 }); // ignored, same value already exists
+ *   set.size; // 1
+ */
+declare class CompositeKeySet<T> extends KeyedSet<T, string> {
+    constructor(iterable?: Iterable<T>);
+}
+
+export { CompositeKeySet, KeyedSet };

package/dist/keyedSet.js

@@ -0,0 +1,126 @@
+import {
+  getCompositeKey
+} from "./chunk-6FIBVC2P.js";
+import "./chunk-C2SVCIWE.js";
+import "./chunk-JF2MDHOJ.js";
+
+// src/keyedSet.ts
+var KeyedSet = class {
+  map;
+  getKey;
+  /**
+   * @param getKey - Function to extract a unique key from each item
+   * @param iterable - Optional initial items to add to the set
+   */
+  constructor(getKey, iterable) {
+    this.getKey = getKey;
+    this.map = /* @__PURE__ */ new Map();
+    if (iterable) {
+      for (const item of iterable) {
+        this.add(item);
+      }
+    }
+  }
+  /** The number of items in the set */
+  get size() {
+    return this.map.size;
+  }
+  /**
+   * Adds an item to the set. If an item with the same key exists, it will be
+   * replaced.
+   */
+  add(item) {
+    const key = this.getKey(item);
+    this.map.set(key, item);
+    return this;
+  }
+  /** Adds multiple items to the set. */
+  addMultiple(items) {
+    for (const item of items) {
+      this.add(item);
+    }
+    return this;
+  }
+  /** Checks if an item with the same key exists in the set. */
+  has(item) {
+    const key = this.getKey(item);
+    return this.map.has(key);
+  }
+  /** Checks if an item with the given key exists in the set. */
+  hasKey(key) {
+    return this.map.has(key);
+  }
+  /** Gets an item by its key, or undefined if not found. */
+  getByKey(key) {
+    return this.map.get(key);
+  }
+  /**
+   * Removes an item from the set by computing its key. Returns true if the item
+   * was removed.
+   */
+  delete(item) {
+    const key = this.getKey(item);
+    return this.map.delete(key);
+  }
+  /** Removes an item by its key. Returns true if the item was removed. */
+  deleteByKey(key) {
+    return this.map.delete(key);
+  }
+  /** Removes multiple items from the set. Returns the number of items removed. */
+  deleteMultiple(items) {
+    let count = 0;
+    for (const item of items) {
+      if (this.delete(item)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /** Removes multiple items by their keys. Returns the number of items removed. */
+  deleteMultipleByKeys(keys) {
+    let count = 0;
+    for (const key of keys) {
+      if (this.deleteByKey(key)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /** Removes all items from the set. */
+  clear() {
+    this.map.clear();
+  }
+  /** Executes a callback for each item in the set. */
+  forEach(callback, thisArg) {
+    for (const value of this.map.values()) {
+      callback.call(thisArg, value, value, this);
+    }
+  }
+  *values() {
+    yield* this.map.values();
+  }
+  *keys() {
+    yield* this.map.values();
+  }
+  *entries() {
+    for (const value of this.map.values()) {
+      yield [value, value];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  /** Returns all items as an array. */
+  toArray() {
+    return [...this.map.values()];
+  }
+};
+var CompositeKeySet = class extends KeyedSet {
+  constructor(iterable) {
+    super(getCompositeKey, iterable);
+  }
+};
+export {
+  CompositeKeySet,
+  KeyedSet
+};

package/dist/objUtils.js

@@ -14,9 +14,9 @@ import {
   pick,
   rejectObjUndefinedValues,
   sortObjectKeys
-} from "./chunk-SGRS4OEE.js";
+} from "./chunk-ZXIKIA5B.js";
 import "./chunk-GMJTLFM6.js";
-import "./chunk-GVIDV772.js";
+import "./chunk-WFQJUJTC.js";
 import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";
 export {

package/dist/serializeXML.js

@@ -1,6 +1,6 @@
 import {
   filterAndMap
-} from "./chunk-GVIDV772.js";
+} from "./chunk-WFQJUJTC.js";
 import "./chunk-C2SVCIWE.js";
 import {
   isTruthy

package/dist/testUtils.js

@@ -4,11 +4,11 @@ import {
 import {
   omit,
   pick
-} from "./chunk-SGRS4OEE.js";
+} from "./chunk-ZXIKIA5B.js";
 import "./chunk-GMJTLFM6.js";
 import {
   filterObjectOrArrayKeys
-} from "./chunk-2LO5FYP5.js";
+} from "./chunk-MI4UE2PQ.js";
 import "./chunk-IATIXMCE.js";
 import {
   deepEqual
@@ -26,7 +26,7 @@ import "./chunk-BM4PYVOX.js";
 import {
   arrayWithPrevAndIndex,
   filterAndMap
-} from "./chunk-GVIDV772.js";
+} from "./chunk-WFQJUJTC.js";
 import {
   isObject
 } from "./chunk-C2SVCIWE.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Universal TypeScript utilities for browser and Node.js",
-  "version": "3.62.0",
+  "version": "3.65.0",
   "license": "MIT",
   "files": [
     "dist",
@@ -120,6 +120,10 @@
       "import": "./dist/keepPrevIfUnchanged.js",
       "require": "./dist/keepPrevIfUnchanged.cjs"
     },
+    "./keyedMap": {
+      "import": "./dist/keyedMap.js",
+      "require": "./dist/keyedMap.cjs"
+    },
     "./levenshtein": {
       "import": "./dist/levenshtein.js",
       "require": "./dist/levenshtein.cjs"
@@ -176,6 +180,10 @@
       "import": "./dist/serializeXML.js",
       "require": "./dist/serializeXML.cjs"
     },
+    "./keyedSet": {
+      "import": "./dist/keyedSet.js",
+      "require": "./dist/keyedSet.cjs"
+    },
     "./shallowEqual": {
       "import": "./dist/shallowEqual.js",
       "require": "./dist/shallowEqual.cjs"