data-structure-typed 2.5.0 → 2.5.2

package/dist/esm/hash.mjs

@@ -0,0 +1,1307 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/data-structures/base/iterable-entry-base.ts
+var IterableEntryBase = class {
+  static {
+    __name(this, "IterableEntryBase");
+  }
+  /**
+   * Default iterator yielding `[key, value]` entries.
+   * @returns Iterator of `[K, V]`.
+   * @remarks Time O(n) to iterate, Space O(1)
+   */
+  *[Symbol.iterator](...args) {
+    yield* this._getIterator(...args);
+  }
+  /**
+   * Iterate over `[key, value]` pairs (may yield `undefined` values).
+   * @returns Iterator of `[K, V | undefined]`.
+   * @remarks Time O(n), Space O(1)
+   */
+  *entries() {
+    for (const item of this) {
+      yield item;
+    }
+  }
+  /**
+   * Iterate over keys only.
+   * @returns Iterator of keys.
+   * @remarks Time O(n), Space O(1)
+   */
+  *keys() {
+    for (const item of this) {
+      yield item[0];
+    }
+  }
+  /**
+   * Iterate over values only.
+   * @returns Iterator of values.
+   * @remarks Time O(n), Space O(1)
+   */
+  *values() {
+    for (const item of this) {
+      yield item[1];
+    }
+  }
+  /**
+   * Test whether all entries satisfy the predicate.
+   * @param predicate - `(key, value, index, self) => boolean`.
+   * @param thisArg - Optional `this` for callback.
+   * @returns `true` if all pass; otherwise `false`.
+   * @remarks Time O(n), Space O(1)
+   */
+  every(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (!predicate.call(thisArg, item[1], item[0], index++, this)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Test whether any entry satisfies the predicate.
+   * @param predicate - `(key, value, index, self) => boolean`.
+   * @param thisArg - Optional `this` for callback.
+   * @returns `true` if any passes; otherwise `false`.
+   * @remarks Time O(n), Space O(1)
+   */
+  some(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (predicate.call(thisArg, item[1], item[0], index++, this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Visit each entry, left-to-right.
+   * @param callbackfn - `(key, value, index, self) => void`.
+   * @param thisArg - Optional `this` for callback.
+   * @remarks Time O(n), Space O(1)
+   */
+  forEach(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      callbackfn.call(thisArg, value, key, index++, this);
+    }
+  }
+  /**
+   * Find the first entry that matches a predicate.
+   * @param callbackfn - `(key, value, index, self) => boolean`.
+   * @param thisArg - Optional `this` for callback.
+   * @returns Matching `[key, value]` or `undefined`.
+   * @remarks Time O(n), Space O(1)
+   */
+  find(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      if (callbackfn.call(thisArg, value, key, index++, this)) return item;
+    }
+    return;
+  }
+  /**
+   * Whether the given key exists.
+   * @param key - Key to test.
+   * @returns `true` if found; otherwise `false`.
+   * @remarks Time O(n) generic, Space O(1)
+   */
+  has(key) {
+    for (const item of this) {
+      const [itemKey] = item;
+      if (itemKey === key) return true;
+    }
+    return false;
+  }
+  /**
+   * Whether there exists an entry with the given value.
+   * @param value - Value to test.
+   * @returns `true` if found; otherwise `false`.
+   * @remarks Time O(n), Space O(1)
+   */
+  hasValue(value) {
+    for (const [, elementValue] of this) {
+      if (elementValue === value) return true;
+    }
+    return false;
+  }
+  /**
+   * Get the value under a key.
+   * @param key - Key to look up.
+   * @returns Value or `undefined`.
+   * @remarks Time O(n) generic, Space O(1)
+   */
+  get(key) {
+    for (const item of this) {
+      const [itemKey, value] = item;
+      if (itemKey === key) return value;
+    }
+    return;
+  }
+  /**
+   * Reduce entries into a single accumulator.
+   * @param callbackfn - `(acc, value, key, index, self) => acc`.
+   * @param initialValue - Initial accumulator.
+   * @returns Final accumulator.
+   * @remarks Time O(n), Space O(1)
+   */
+  reduce(callbackfn, initialValue) {
+    let accumulator = initialValue;
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      accumulator = callbackfn(accumulator, value, key, index++, this);
+    }
+    return accumulator;
+  }
+  /**
+   * Converts data structure to `[key, value]` pairs.
+   * @returns Array of entries.
+   * @remarks Time O(n), Space O(n)
+   */
+  toArray() {
+    return [...this];
+  }
+  /**
+   * Visualize the iterable as an array of `[key, value]` pairs (or a custom string).
+   * @returns Array of entries (default) or a string.
+   * @remarks Time O(n), Space O(n)
+   */
+  toVisual() {
+    return [...this];
+  }
+  /**
+   * Print a human-friendly representation to the console.
+   * @remarks Time O(n), Space O(n)
+   */
+  print() {
+    console.log(this.toVisual());
+  }
+};
+
+// src/common/error.ts
+function raise(ErrorClass, message) {
+  throw new ErrorClass(message);
+}
+__name(raise, "raise");
+var ERR = {
+  // Range / index
+  indexOutOfRange: /* @__PURE__ */ __name((index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`, "indexOutOfRange"),
+  invalidIndex: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`, "invalidIndex"),
+  // Type / argument
+  invalidArgument: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidArgument"),
+  comparatorRequired: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`, "comparatorRequired"),
+  invalidKey: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidKey"),
+  notAFunction: /* @__PURE__ */ __name((name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`, "notAFunction"),
+  invalidEntry: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`, "invalidEntry"),
+  invalidNaN: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`, "invalidNaN"),
+  invalidDate: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`, "invalidDate"),
+  reduceEmpty: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`, "reduceEmpty"),
+  callbackReturnType: /* @__PURE__ */ __name((expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`, "callbackReturnType"),
+  // State / operation
+  invalidOperation: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidOperation"),
+  // Matrix
+  matrixDimensionMismatch: /* @__PURE__ */ __name((op) => `Matrix: Dimensions must be compatible for ${op}.`, "matrixDimensionMismatch"),
+  matrixSingular: /* @__PURE__ */ __name(() => "Matrix: Singular matrix, inverse does not exist.", "matrixSingular"),
+  matrixNotSquare: /* @__PURE__ */ __name(() => "Matrix: Must be square for inversion.", "matrixNotSquare"),
+  matrixNotRectangular: /* @__PURE__ */ __name(() => "Matrix: Must be rectangular for transposition.", "matrixNotRectangular"),
+  matrixRowMismatch: /* @__PURE__ */ __name((expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`, "matrixRowMismatch"),
+  // Order statistic
+  orderStatisticNotEnabled: /* @__PURE__ */ __name((method, ctx) => `${ctx ? ctx + ": " : ""}${method}() requires enableOrderStatistic: true.`, "orderStatisticNotEnabled")
+};
+
+// src/utils/utils.ts
+var rangeCheck = /* @__PURE__ */ __name((index, min, max, message) => {
+  if (index < min || index > max) {
+    throw new RangeError(message ?? `Index ${index} is out of range [${min}, ${max}].`);
+  }
+}, "rangeCheck");
+var isWeakKey = /* @__PURE__ */ __name((input) => {
+  const inputType = typeof input;
+  return inputType === "object" && input !== null || inputType === "function";
+}, "isWeakKey");
+
+// src/data-structures/hash/hash-map.ts
+var HashMap = class extends IterableEntryBase {
+  static {
+    __name(this, "HashMap");
+  }
+  /**
+   * Create a HashMap and optionally bulk-insert entries.
+   * @remarks Time O(N), Space O(N)
+   * @param [entryOrRawElements] - Iterable of entries or raw elements to insert.
+   * @param [options] - Options: hash function and optional record-to-entry converter.
+   * @returns New HashMap instance.
+   */
+  constructor(entryOrRawElements = [], options) {
+    super();
+    if (options) {
+      const { hashFn, toEntryFn } = options;
+      if (hashFn) this._hashFn = hashFn;
+      if (toEntryFn) this._toEntryFn = toEntryFn;
+    }
+    if (entryOrRawElements) this.setMany(entryOrRawElements);
+  }
+  _store = {};
+  /**
+   * Get the internal store for non-object keys.
+   * @remarks Time O(1), Space O(1)
+   * @returns Internal record of string→{key,value}.
+   */
+  get store() {
+    return this._store;
+  }
+  _objMap = /* @__PURE__ */ new Map();
+  /**
+   * Get the internal Map used for object/function keys.
+   * @remarks Time O(1), Space O(1)
+   * @returns Map of object→value.
+   */
+  get objMap() {
+    return this._objMap;
+  }
+  _toEntryFn;
+  /**
+   * Get the raw→entry converter function if present.
+   * @remarks Time O(1), Space O(1)
+   * @returns Converter function or undefined.
+   */
+  get toEntryFn() {
+    return this._toEntryFn;
+  }
+  _size = 0;
+  /**
+   * Get the number of distinct keys stored.
+   * @remarks Time O(1), Space O(1)
+   * @returns Current size.
+   */
+  get size() {
+    return this._size;
+  }
+  _hashFn = /* @__PURE__ */ __name((key) => String(key), "_hashFn");
+  /**
+   * Get the current hash function for non-object keys.
+   * @remarks Time O(1), Space O(1)
+   * @returns Hash function.
+   */
+  get hashFn() {
+    return this._hashFn;
+  }
+  /**
+    * Check whether the map is empty.
+    * @remarks Time O(1), Space O(1)
+    * @returns True if size is 0.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check if empty
+  *  const map = new HashMap();
+  *     console.log(map.isEmpty()); // true;
+    */
+  isEmpty() {
+    return this._size === 0;
+  }
+  /**
+    * Remove all entries and reset counters.
+    * @remarks Time O(N), Space O(1)
+    * @returns void
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove all entries
+  *  const map = new HashMap<string, number>([['a', 1], ['b', 2]]);
+  *     map.clear();
+  *     console.log(map.isEmpty()); // true;
+    */
+  clear() {
+    this._store = {};
+    this._objMap.clear();
+    this._size = 0;
+  }
+  /**
+   * Type guard: check if a raw value is a [key, value] entry.
+   * @remarks Time O(1), Space O(1)
+   * @returns True if the value is a 2-tuple.
+   */
+  isEntry(rawElement) {
+    return Array.isArray(rawElement) && rawElement.length === 2;
+  }
+  /**
+    * Insert or replace a single entry.
+    * @remarks Time O(1), Space O(1)
+    * @param key - Key.
+    * @param value - Value.
+    * @returns True when the operation succeeds.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // basic HashMap creation and set operation
+  *  // Create a simple HashMap with key-value pairs
+  *     const map = new HashMap<number, string>([
+  *       [1, 'one'],
+  *       [2, 'two'],
+  *       [3, 'three']
+  *     ]);
+  *
+  *     // Verify size
+  *     console.log(map.size); // 3;
+  *
+  *     // Set a new key-value pair
+  *     map.set(4, 'four');
+  *     console.log(map.size); // 4;
+  *
+  *     // Verify entries
+  *     console.log([...map.entries()]); // length: 4;
+    */
+  set(key, value) {
+    if (this._isObjKey(key)) {
+      if (!this.objMap.has(key)) this._size++;
+      this.objMap.set(key, value);
+    } else {
+      const strKey = this._getNoObjKey(key);
+      if (this.store[strKey] === void 0) this._size++;
+      this._store[strKey] = { key, value };
+    }
+    return true;
+  }
+  /**
+    * Insert many entries from an iterable.
+    * @remarks Time O(N), Space O(N)
+    * @param entryOrRawElements - Iterable of entries or raw elements to insert.
+    * @returns Array of per-entry results.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Add multiple entries
+  *  const map = new HashMap<string, number>();
+  *     map.setMany([['a', 1], ['b', 2], ['c', 3]]);
+  *     console.log(map.size); // 3;
+    */
+  setMany(entryOrRawElements) {
+    const results = [];
+    for (const rawEle of entryOrRawElements) {
+      let key, value;
+      if (this.isEntry(rawEle)) [key, value] = rawEle;
+      else if (this._toEntryFn) [key, value] = this._toEntryFn(rawEle);
+      if (key !== void 0 && value !== void 0) results.push(this.set(key, value));
+    }
+    return results;
+  }
+  /**
+    * Get the value for a key.
+    * @remarks Time O(1), Space O(1)
+    * @param key - Key to look up.
+    * @returns Value or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // HashMap get and has operations
+  *  const map = new HashMap<string, number>([
+  *       ['apple', 1],
+  *       ['banana', 2],
+  *       ['cherry', 3]
+  *     ]);
+  *
+  *     // Check if key exists
+  *     console.log(map.has('apple')); // true;
+  *     console.log(map.has('date')); // false;
+  *
+  *     // Get value by key
+  *     console.log(map.get('banana')); // 2;
+  *     console.log(map.get('grape')); // undefined;
+  *
+  *     // Get all keys and values
+  *     const keys = [...map.keys()];
+  *     const values = [...map.values()];
+  *     console.log(keys); // contains 'apple';
+  *     console.log(values); // contains 3;
+    */
+  get(key) {
+    if (this._isObjKey(key)) return this.objMap.get(key);
+    const strKey = this._getNoObjKey(key);
+    return this._store[strKey]?.value;
+  }
+  /**
+    * Check if a key exists.
+    * @remarks Time O(1), Space O(1)
+    * @param key - Key to test.
+    * @returns True if present.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check key existence
+  *  const map = new HashMap<string, number>([['a', 1], ['b', 2]]);
+  *
+  *     console.log(map.has('a')); // true;
+  *     console.log(map.has('z')); // false;
+    */
+  has(key) {
+    if (this._isObjKey(key)) return this.objMap.has(key);
+    const strKey = this._getNoObjKey(key);
+    return strKey in this.store;
+  }
+  /**
+    * Delete an entry by key.
+    * @remarks Time O(1), Space O(1)
+    * @param key - Key to delete.
+    * @returns True if the key was found and removed.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove entries by key
+  *  const map = new HashMap<string, number>([['x', 10], ['y', 20], ['z', 30]]);
+  *
+  *     console.log(map.delete('y')); // true;
+  *     console.log(map.has('y')); // false;
+  *     console.log(map.size); // 2;
+    */
+  delete(key) {
+    if (this._isObjKey(key)) {
+      if (this.objMap.has(key)) this._size--;
+      return this.objMap.delete(key);
+    }
+    const strKey = this._getNoObjKey(key);
+    if (strKey in this.store) {
+      delete this.store[strKey];
+      this._size--;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Replace the hash function and rehash the non-object store.
+   * @remarks Time O(N), Space O(N)
+   * @param fn - New hash function for non-object keys.
+   * @returns This map instance.
+   */
+  setHashFn(fn) {
+    if (this._hashFn === fn) return this;
+    this._hashFn = fn;
+    this._rehashNoObj();
+    return this;
+  }
+  /**
+    * Deep clone this map, preserving hashing behavior.
+    * @remarks Time O(N), Space O(N)
+    * @returns A new map with the same content.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Create independent copy
+  *  const map = new HashMap<string, number>([['a', 1]]);
+  *     const copy = map.clone();
+  *     copy.set('a', 99);
+  *     console.log(map.get('a')); // 1;
+    */
+  clone() {
+    const opts = { hashFn: this._hashFn, toEntryFn: this._toEntryFn };
+    return this._createLike(this, opts);
+  }
+  /**
+    * Map values to a new map with the same keys.
+    * @remarks Time O(N), Space O(N)
+    * @template VM
+    * @param callbackfn - Mapping function (key, value, index, map) → newValue.
+    * @param [thisArg] - Value for `this` inside the callback.
+    * @returns A new map with transformed values.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Transform all values
+  *  const prices = new HashMap<string, number>([['apple', 1], ['banana', 2]]);
+  *
+  *     const doubled = prices.map(v => (v ?? 0) * 2);
+  *     console.log(doubled.get('apple')); // 2;
+  *     console.log(doubled.get('banana')); // 4;
+    */
+  map(callbackfn, thisArg) {
+    const out = this._createLike();
+    let index = 0;
+    for (const [key, value] of this) out.set(key, callbackfn.call(thisArg, value, key, index++, this));
+    return out;
+  }
+  /**
+    * Filter entries into a new map.
+    * @remarks Time O(N), Space O(N)
+    * @param predicate - Predicate (key, value, index, map) → boolean.
+    * @param [thisArg] - Value for `this` inside the predicate.
+    * @returns A new map containing entries that satisfied the predicate.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // HashMap iteration and filter operations
+  *  const map = new HashMap<number, string>([
+  *       [1, 'Alice'],
+  *       [2, 'Bob'],
+  *       [3, 'Charlie'],
+  *       [4, 'Diana'],
+  *       [5, 'Eve']
+  *     ]);
+  *
+  *     // Iterate through entries
+  *     const entries: [number, string][] = [];
+  *     for (const [key, value] of map) {
+  *       entries.push([key, value]);
+  *     }
+  *     console.log(entries); // length: 5;
+  *
+  *     // Filter operation (for iteration with collection methods)
+  *     const filtered = [...map].filter(([key]) => key > 2);
+  *     console.log(filtered.length); // 3;
+  *
+  *     // Map operation
+  *     const values = [...map.values()].map(v => v.length);
+  *     console.log(values); // contains 3; // 'Bob', 'Eve'
+  *     console.log(values); // contains 7;
+    */
+  filter(predicate, thisArg) {
+    const out = this._createLike();
+    let index = 0;
+    for (const [key, value] of this) if (predicate.call(thisArg, value, key, index++, this)) out.set(key, value);
+    return out;
+  }
+  /**
+   * (Protected) Create a like-kind instance and seed it from an iterable.
+   * @remarks Time O(N), Space O(N)
+   * @template TK
+   * @template TV
+   * @template TR
+   * @param [entries] - Iterable used to seed the new map.
+   * @param [options] - Options forwarded to the constructor.
+   * @returns A like-kind map instance.
+   */
+  _createLike(entries = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(entries, options);
+  }
+  _rehashNoObj() {
+    const fresh = {};
+    for (const { key, value } of Object.values(this._store)) {
+      const sk = this._getNoObjKey(key);
+      fresh[sk] = { key, value };
+    }
+    this._store = fresh;
+  }
+  *_getIterator() {
+    for (const node of Object.values(this.store)) yield [node.key, node.value];
+    for (const node of this.objMap) yield node;
+  }
+  _isObjKey(key) {
+    const keyType = typeof key;
+    return (keyType === "object" || keyType === "function") && key !== null;
+  }
+  _getNoObjKey(key) {
+    const keyType = typeof key;
+    let strKey;
+    if (keyType !== "string" && keyType !== "number" && keyType !== "symbol") {
+      strKey = this._hashFn(key);
+    } else {
+      if (keyType === "number") {
+        strKey = key;
+      } else {
+        strKey = key;
+      }
+    }
+    return strKey;
+  }
+};
+var LinkedHashMap = class extends IterableEntryBase {
+  static {
+    __name(this, "LinkedHashMap");
+  }
+  _sentinel;
+  /**
+   * Create a LinkedHashMap and optionally bulk-insert entries.
+   * @remarks Time O(N), Space O(N)
+   * @param [entryOrRawElements] - Iterable of entries or raw elements to insert.
+   * @param [options] - Options: hash functions and optional record-to-entry converter.
+   * @returns New LinkedHashMap instance.
+   */
+  constructor(entryOrRawElements = [], options) {
+    super();
+    this._sentinel = {};
+    this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
+    if (options) {
+      const { hashFn, objHashFn, toEntryFn } = options;
+      if (hashFn) this._hashFn = hashFn;
+      if (objHashFn) this._objHashFn = objHashFn;
+      if (toEntryFn) this._toEntryFn = toEntryFn;
+    }
+    if (entryOrRawElements) this.setMany(entryOrRawElements);
+  }
+  _hashFn = /* @__PURE__ */ __name((key) => String(key), "_hashFn");
+  get hashFn() {
+    return this._hashFn;
+  }
+  _objHashFn = /* @__PURE__ */ __name((key) => key, "_objHashFn");
+  /**
+   * Get the hash function for object/weak keys.
+   * @remarks Time O(1), Space O(1)
+   * @returns Object-hash function.
+   */
+  get objHashFn() {
+    return this._objHashFn;
+  }
+  _noObjMap = {};
+  /**
+   * Get the internal record for non-object keys.
+   * @remarks Time O(1), Space O(1)
+   * @returns Record of hash→node.
+   */
+  get noObjMap() {
+    return this._noObjMap;
+  }
+  _objMap = /* @__PURE__ */ new WeakMap();
+  get objMap() {
+    return this._objMap;
+  }
+  _head;
+  /**
+   * Get the head node (first entry) sentinel link.
+   * @remarks Time O(1), Space O(1)
+   * @returns Head node or sentinel.
+   */
+  get head() {
+    return this._head;
+  }
+  _tail;
+  /**
+   * Get the tail node (last entry) sentinel link.
+   * @remarks Time O(1), Space O(1)
+   * @returns Tail node or sentinel.
+   */
+  get tail() {
+    return this._tail;
+  }
+  _toEntryFn = /* @__PURE__ */ __name((rawElement) => {
+    if (this.isEntry(rawElement)) {
+      return rawElement;
+    }
+    raise(TypeError, ERR.invalidArgument("If elements do not adhere to [key, value], provide options.toEntryFn to transform raw records.", "HashMap"));
+  }, "_toEntryFn");
+  get toEntryFn() {
+    return this._toEntryFn;
+  }
+  _size = 0;
+  get size() {
+    return this._size;
+  }
+  /**
+   * Get the first [key, value] pair.
+   * @remarks Time O(1), Space O(1)
+   * @returns First entry or undefined when empty.
+   */
+  get first() {
+    if (this._size === 0) return;
+    return [this.head.key, this.head.value];
+  }
+  /**
+   * Get the last [key, value] pair.
+   * @remarks Time O(1), Space O(1)
+   * @returns Last entry or undefined when empty.
+   */
+  get last() {
+    if (this._size === 0) return;
+    return [this.tail.key, this.tail.value];
+  }
+  /**
+   * Iterate from head → tail.
+   * @remarks Time O(N), Space O(1)
+   * @returns Iterator of [key, value].
+   */
+  *begin() {
+    let node = this.head;
+    while (node !== this._sentinel) {
+      yield [node.key, node.value];
+      node = node.next;
+    }
+  }
+  /**
+   * Iterate from tail → head.
+   * @remarks Time O(N), Space O(1)
+   * @returns Iterator of [key, value].
+   */
+  *reverseBegin() {
+    let node = this.tail;
+    while (node !== this._sentinel) {
+      yield [node.key, node.value];
+      node = node.prev;
+    }
+  }
+  /**
+   * Insert or replace a single entry; preserves insertion order.
+   * @remarks Time O(1), Space O(1)
+   * @param key - Key.
+   * @param [value] - Value.
+   * @returns True when the operation succeeds.
+   */
+  set(key, value) {
+    let node;
+    const isNewKey = !this.has(key);
+    if (isWeakKey(key)) {
+      const hash = this._objHashFn(key);
+      node = this.objMap.get(hash);
+      if (!node && isNewKey) {
+        node = { key: hash, value, prev: this.tail, next: this._sentinel };
+        this.objMap.set(hash, node);
+      } else if (node) {
+        node.value = value;
+      }
+    } else {
+      const hash = this._hashFn(key);
+      node = this.noObjMap[hash];
+      if (!node && isNewKey) {
+        this.noObjMap[hash] = node = { key, value, prev: this.tail, next: this._sentinel };
+      } else if (node) {
+        node.value = value;
+      }
+    }
+    if (node && isNewKey) {
+      if (this._size === 0) {
+        this._head = node;
+        this._sentinel.next = node;
+      } else {
+        this.tail.next = node;
+        node.prev = this.tail;
+      }
+      this._tail = node;
+      this._sentinel.prev = node;
+      this._size++;
+    }
+    return true;
+  }
+  setMany(entryOrRawElements) {
+    const results = [];
+    for (const rawEle of entryOrRawElements) {
+      let key, value;
+      if (this.isEntry(rawEle)) [key, value] = rawEle;
+      else if (this._toEntryFn) [key, value] = this._toEntryFn(rawEle);
+      if (key !== void 0 && value !== void 0) results.push(this.set(key, value));
+    }
+    return results;
+  }
+  has(key) {
+    if (isWeakKey(key)) {
+      const hash2 = this._objHashFn(key);
+      return this.objMap.has(hash2);
+    }
+    const hash = this._hashFn(key);
+    return hash in this.noObjMap;
+  }
+  get(key) {
+    if (isWeakKey(key)) {
+      const hash2 = this._objHashFn(key);
+      const node2 = this.objMap.get(hash2);
+      return node2 ? node2.value : void 0;
+    }
+    const hash = this._hashFn(key);
+    const node = this.noObjMap[hash];
+    return node ? node.value : void 0;
+  }
+  /**
+   * Get the value at a given index in insertion order.
+   * @remarks Time O(N), Space O(1)
+   * @param index - Zero-based index.
+   * @returns Value at the index.
+   */
+  at(index) {
+    rangeCheck(index, 0, this._size - 1);
+    let node = this.head;
+    while (index--) node = node.next;
+    return node.value;
+  }
+  delete(key) {
+    let node;
+    if (isWeakKey(key)) {
+      const hash = this._objHashFn(key);
+      node = this.objMap.get(hash);
+      if (!node) return false;
+      this.objMap.delete(hash);
+    } else {
+      const hash = this._hashFn(key);
+      node = this.noObjMap[hash];
+      if (!node) return false;
+      delete this.noObjMap[hash];
+    }
+    return this._deleteNode(node);
+  }
+  /**
+   * Delete the first entry that matches a predicate.
+   * @remarks Time O(N), Space O(1)
+   * @param predicate - Function (key, value, index, map) → boolean to decide deletion.
+   * @returns True if an entry was removed.
+   */
+  deleteWhere(predicate) {
+    let node = this._head;
+    let i = 0;
+    while (node !== this._sentinel) {
+      const cur = node;
+      node = node.next;
+      if (predicate(cur.key, cur.value, i++, this)) {
+        const keyToCheck = cur.key;
+        if (isWeakKey(keyToCheck)) {
+          this._objMap.delete(keyToCheck);
+        } else {
+          const hash = this._hashFn(cur.key);
+          delete this._noObjMap[hash];
+        }
+        return this._deleteNode(cur);
+      }
+    }
+    return false;
+  }
+  /**
+   * Delete the entry at a given index.
+   * @remarks Time O(N), Space O(1)
+   * @param index - Zero-based index.
+   * @returns True if removed.
+   */
+  deleteAt(index) {
+    rangeCheck(index, 0, this._size - 1);
+    let node = this.head;
+    while (index--) node = node.next;
+    return this._deleteNode(node);
+  }
+  isEmpty() {
+    return this._size === 0;
+  }
+  isEntry(rawElement) {
+    return Array.isArray(rawElement) && rawElement.length === 2;
+  }
+  clear() {
+    this._noObjMap = {};
+    this._size = 0;
+    this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
+  }
+  clone() {
+    const opts = { hashFn: this._hashFn, objHashFn: this._objHashFn };
+    return this._createLike(this, opts);
+  }
+  filter(predicate, thisArg) {
+    const out = this._createLike();
+    let index = 0;
+    for (const [key, value] of this) {
+      if (predicate.call(thisArg, value, key, index, this)) out.set(key, value);
+      index++;
+    }
+    return out;
+  }
+  /**
+   * Map each entry to a new [key, value] pair and preserve order.
+   * @remarks Time O(N), Space O(N)
+   * @template MK
+   * @template MV
+   * @param callback - Mapping function (key, value, index, map) → [newKey, newValue].
+   * @param [thisArg] - Value for `this` inside the callback.
+   * @returns A new map of the same class with transformed entries.
+   */
+  map(callback, thisArg) {
+    const out = this._createLike();
+    let index = 0;
+    for (const [key, value] of this) {
+      const [newKey, newValue] = callback.call(thisArg, value, key, index, this);
+      out.set(newKey, newValue);
+      index++;
+    }
+    return out;
+  }
+  *_getIterator() {
+    let node = this.head;
+    while (node !== this._sentinel) {
+      yield [node.key, node.value];
+      node = node.next;
+    }
+  }
+  _deleteNode(node) {
+    const key = node.key;
+    if (isWeakKey(key)) {
+      this._objMap.delete(key);
+    } else {
+      const hash = this._hashFn(key);
+      delete this._noObjMap[hash];
+    }
+    const { prev, next } = node;
+    prev.next = next;
+    next.prev = prev;
+    if (node === this.head) this._head = next;
+    if (node === this.tail) this._tail = prev;
+    this._size -= 1;
+    return true;
+  }
+  _createLike(entries = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(entries, options);
+  }
+};
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+
+export { HashMap, LinkedHashMap };
+//# sourceMappingURL=hash.mjs.map
+//# sourceMappingURL=hash.mjs.map