tree-multimap-typed 2.4.1 → 2.4.3

package/dist/types/data-structures/binary-tree/tree-map.d.ts

@@ -185,4 +185,14 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      * @param options Inclusive/exclusive bounds (defaults to inclusive).
      */
     rangeSearch(range: [K, K], options?: TreeMapRangeOptions): Array<[K, V | undefined]>;
+    /**
+     * Creates a shallow clone of this map.
+     * @remarks Time O(n log n), Space O(n)
+     * @example
+     * const original = new TreeMap([['a', 1], ['b', 2]]);
+     * const copy = original.clone();
+     * copy.set('c', 3);
+     * original.has('c'); // false (original unchanged)
+     */
+    clone(): TreeMap<K, V>;
 }

package/dist/types/data-structures/binary-tree/tree-set.d.ts

@@ -178,4 +178,14 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      * @param options Inclusive/exclusive bounds (defaults to inclusive).
      */
     rangeSearch(range: [K, K], options?: TreeSetRangeOptions): K[];
+    /**
+     * Creates a shallow clone of this set.
+     * @remarks Time O(n log n), Space O(n)
+     * @example
+     * const original = new TreeSet([1, 2, 3]);
+     * const copy = original.clone();
+     * copy.add(4);
+     * original.has(4); // false (original unchanged)
+     */
+    clone(): TreeSet<K>;
 }

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

@@ -12077,6 +12077,21 @@ var treeMultimapTyped = (() => {
       }
       return out;
     }
+    /**
+     * Creates a shallow clone of this set.
+     * @remarks Time O(n log n), Space O(n)
+     * @example
+     * const original = new TreeSet([1, 2, 3]);
+     * const copy = original.clone();
+     * copy.add(4);
+     * original.has(4); // false (original unchanged)
+     */
+    clone() {
+      return new _TreeSet2(this, {
+        comparator: __privateGet(this, _isDefaultComparator) ? void 0 : __privateGet(this, _userComparator),
+        isMapMode: __privateGet(this, _core).isMapMode
+      });
+    }
   };
   _core = /* @__PURE__ */ new WeakMap();
   _isDefaultComparator = /* @__PURE__ */ new WeakMap();
@@ -12896,6 +12911,21 @@ var treeMultimapTyped = (() => {
       }
       return out;
     }
+    /**
+     * Creates a shallow clone of this map.
+     * @remarks Time O(n log n), Space O(n)
+     * @example
+     * const original = new TreeMap([['a', 1], ['b', 2]]);
+     * const copy = original.clone();
+     * copy.set('c', 3);
+     * original.has('c'); // false (original unchanged)
+     */
+    clone() {
+      return new _TreeMap2(this, {
+        comparator: __privateGet(this, _isDefaultComparator3) ? void 0 : __privateGet(this, _userComparator2),
+        isMapMode: __privateGet(this, _core3).isMapMode
+      });
+    }
   };
   _core3 = /* @__PURE__ */ new WeakMap();
   _isDefaultComparator3 = /* @__PURE__ */ new WeakMap();
@@ -14252,20 +14282,17 @@ var treeMultimapTyped = (() => {
       prefix = this._caseProcess(prefix);
       const words = [];
       let found = 0;
-      function dfs(node, word) {
-        for (const char of node.children.keys()) {
-          const charNode = node.children.get(char);
-          if (charNode !== void 0) {
-            dfs(charNode, word.concat(char));
-          }
+      const dfs = /* @__PURE__ */ __name((node, word) => {
+        for (const [char, childNode] of node.children) {
+          if (found >= max) return;
+          dfs(childNode, word + char);
         }
         if (node.isEnd) {
-          if (found > max - 1) return;
+          if (found >= max) return;
           words.push(word);
           found++;
         }
-      }
-      __name(dfs, "dfs");
+      }, "dfs");
       let startNode = this.root;
       if (prefix) {
         for (const c of prefix) {