binary-tree-typed 2.5.0 → 2.5.2

package/dist/umd/binary-tree-typed.js

@@ -27,7 +27,8 @@ var binaryTreeTyped = (() => {
     BinaryTreeNode: () => BinaryTreeNode,
     DFSOperation: () => DFSOperation,
     ERR: () => ERR,
-    Range: () => Range
+    Range: () => Range,
+    raise: () => raise
   });
 
   // src/utils/utils.ts
@@ -81,6 +82,57 @@ var binaryTreeTyped = (() => {
     return (...args) => trampoline(fn(...args));
   }
 
+  // src/common/error.ts
+  function raise(ErrorClass, message) {
+    throw new ErrorClass(message);
+  }
+  var ERR = {
+    // Range / index
+    indexOutOfRange: (index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`,
+    invalidIndex: (ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`,
+    // Type / argument
+    invalidArgument: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    comparatorRequired: (ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`,
+    invalidKey: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    notAFunction: (name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`,
+    invalidEntry: (ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`,
+    invalidNaN: (ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`,
+    invalidDate: (ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`,
+    reduceEmpty: (ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`,
+    callbackReturnType: (expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`,
+    // State / operation
+    invalidOperation: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    // Matrix
+    matrixDimensionMismatch: (op) => `Matrix: Dimensions must be compatible for ${op}.`,
+    matrixSingular: () => "Matrix: Singular matrix, inverse does not exist.",
+    matrixNotSquare: () => "Matrix: Must be square for inversion.",
+    matrixNotRectangular: () => "Matrix: Must be rectangular for transposition.",
+    matrixRowMismatch: (expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`,
+    // Order statistic
+    orderStatisticNotEnabled: (method, ctx) => `${ctx ? ctx + ": " : ""}${method}() requires enableOrderStatistic: true.`
+  };
+
+  // src/common/index.ts
+  var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
+    DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
+    DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
+    return DFSOperation2;
+  })(DFSOperation || {});
+  var Range = class {
+    constructor(low, high, includeLow = true, includeHigh = true) {
+      this.low = low;
+      this.high = high;
+      this.includeLow = includeLow;
+      this.includeHigh = includeHigh;
+    }
+    // Determine whether a key is within the range
+    isInRange(key, comparator) {
+      const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+      const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+      return lowCheck && highCheck;
+    }
+  };
+
   // src/data-structures/base/iterable-element-base.ts
   var IterableElementBase = class {
     /**
@@ -103,7 +155,7 @@ var binaryTreeTyped = (() => {
       if (options) {
         const { toElementFn } = options;
         if (typeof toElementFn === "function") this._toElementFn = toElementFn;
-        else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+        else if (toElementFn) raise(TypeError, "toElementFn must be a function type");
       }
     }
     /**
@@ -259,7 +311,7 @@ var binaryTreeTyped = (() => {
         acc = initialValue;
       } else {
         const first = iter.next();
-        if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
+        if (first.done) raise(TypeError, "Reduce of empty structure with no initial value");
         acc = first.value;
         index = 1;
       }
@@ -491,52 +543,6 @@ var binaryTreeTyped = (() => {
     }
   };
 
-  // src/common/error.ts
-  var ERR = {
-    // Range / index
-    indexOutOfRange: (index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`,
-    invalidIndex: (ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`,
-    // Type / argument
-    invalidArgument: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
-    comparatorRequired: (ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`,
-    invalidKey: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
-    notAFunction: (name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`,
-    invalidEntry: (ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`,
-    invalidNaN: (ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`,
-    invalidDate: (ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`,
-    reduceEmpty: (ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`,
-    callbackReturnType: (expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`,
-    // State / operation
-    invalidOperation: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
-    // Matrix
-    matrixDimensionMismatch: (op) => `Matrix: Dimensions must be compatible for ${op}.`,
-    matrixSingular: () => "Matrix: Singular matrix, inverse does not exist.",
-    matrixNotSquare: () => "Matrix: Must be square for inversion.",
-    matrixNotRectangular: () => "Matrix: Must be rectangular for transposition.",
-    matrixRowMismatch: (expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`
-  };
-
-  // src/common/index.ts
-  var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
-    DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
-    DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
-    return DFSOperation2;
-  })(DFSOperation || {});
-  var Range = class {
-    constructor(low, high, includeLow = true, includeHigh = true) {
-      this.low = low;
-      this.high = high;
-      this.includeLow = includeLow;
-      this.includeHigh = includeHigh;
-    }
-    // Determine whether a key is within the range
-    isInRange(key, comparator) {
-      const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
-      const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
-      return lowCheck && highCheck;
-    }
-  };
-
   // src/data-structures/base/iterable-entry-base.ts
   var IterableEntryBase = class {
     /**
@@ -784,6 +790,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Track queue length
     *  const q = new Queue<number>();
@@ -810,6 +840,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // View the front element
     *  const q = new Queue<string>(['first', 'second', 'third']);
@@ -852,6 +906,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Queue for...of iteration and isEmpty check
     *  const queue = new Queue<string>(['A', 'B', 'C', 'D']);
@@ -890,6 +968,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic Queue creation and push operation
     *  // Create a simple Queue with initial values
@@ -935,6 +1037,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Queue shift and peek operations
     *  const queue = new Queue<number>([10, 20, 30, 40]);
@@ -970,6 +1096,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove specific element
     *  const q = new Queue<number>([1, 2, 3, 2]);
@@ -998,27 +1148,51 @@ var binaryTreeTyped = (() => {
       
       
       
-       * @example
-    * // Access element by index
-    *  const q = new Queue<string>(['a', 'b', 'c']);
-    *     console.log(q.at(0)); // 'a';
-    *     console.log(q.at(2)); // 'c';
-      */
-    at(index) {
-      if (index < 0 || index >= this.length) return void 0;
-      return this._elements[this._offset + index];
-    }
-    /**
-     * Delete the element at a given index.
-     * @remarks Time O(N), Space O(1)
-     * @param index - Zero-based index from the front.
-     * @returns Removed element or undefined.
-     */
-    deleteAt(index) {
-      if (index < 0 || index >= this.length) return void 0;
-      const gi = this._offset + index;
-      const [deleted] = this.elements.splice(gi, 1);
-      return deleted;
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Access element by index
+    *  const q = new Queue<string>(['a', 'b', 'c']);
+    *     console.log(q.at(0)); // 'a';
+    *     console.log(q.at(2)); // 'c';
+      */
+    at(index) {
+      if (index < 0 || index >= this.length) return void 0;
+      return this._elements[this._offset + index];
+    }
+    /**
+     * Delete the element at a given index.
+     * @remarks Time O(N), Space O(1)
+     * @param index - Zero-based index from the front.
+     * @returns Removed element or undefined.
+     */
+    deleteAt(index) {
+      if (index < 0 || index >= this.length) return void 0;
+      const gi = this._offset + index;
+      const [deleted] = this.elements.splice(gi, 1);
+      return deleted;
     }
     /**
      * Insert a new element at a given index.
@@ -1067,6 +1241,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all elements
     *  const q = new Queue<number>([1, 2, 3]);
@@ -1089,6 +1287,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Reclaim unused memory
     *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1134,6 +1356,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Create independent copy
     *  const q = new Queue<number>([1, 2, 3]);
@@ -1163,6 +1409,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter elements
     *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1196,6 +1466,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform elements
     *  const q = new Queue<number>([1, 2, 3]);
@@ -1460,7 +1754,7 @@ var binaryTreeTyped = (() => {
         if (isMapMode !== void 0) this._isMapMode = isMapMode;
         if (isDuplicate !== void 0) this._isDuplicate = isDuplicate;
         if (typeof toEntryFn === "function") this._toEntryFn = toEntryFn;
-        else if (toEntryFn) throw new TypeError(ERR.notAFunction("toEntryFn", "BinaryTree"));
+        else if (toEntryFn) raise(TypeError, ERR.notAFunction("toEntryFn", "BinaryTree"));
       }
       if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
     }
@@ -1676,6 +1970,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Add a single node
     *  const tree = new BinaryTree<number>();
@@ -1706,6 +2024,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic BinaryTree creation and insertion
     *  // Create a BinaryTree with entries
@@ -1788,6 +2130,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Bulk add
     *  const tree = new BinaryTree<number>();
@@ -1806,6 +2172,30 @@ var binaryTreeTyped = (() => {
       * @returns An array of booleans indicating the success of each individual `set` operation.
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Set multiple entries
     *  const tree = new BinaryTree<number, string>();
@@ -1845,6 +2235,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Combine trees
     *  const t1 = new BinaryTree<number>([1, 2]);
@@ -1883,6 +2297,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove a node
     *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -1999,6 +2437,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get node by key
     *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'child']]);
@@ -2033,6 +2495,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Retrieve value by key
     *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'left'], [3, 'right']]);
@@ -2070,6 +2556,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all nodes
     *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2094,6 +2604,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check empty
     *  console.log(new BinaryTree().isEmpty()); // true;
@@ -2127,6 +2661,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check BST property
     *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2187,6 +2745,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get depth of a node
     *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -2224,6 +2806,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get tree height
     *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -2677,6 +3283,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Deep copy
     *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2705,6 +3335,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter nodes by condition
     *  const tree = new BinaryTree<number>([1, 2, 3, 4]);
@@ -2737,6 +3391,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform to new tree
     *  const tree = new BinaryTree<number, number>([[1, 10], [2, 20]]);
@@ -2794,6 +3472,30 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Display tree
     *  const tree = new BinaryTree<number>([1, 2, 3]);