heap-typed 1.48.1 → 1.48.2

package/dist/data-structures/queue/queue.js

@@ -1,45 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = exports.LinkedListQueue = void 0;
+exports.LinkedListQueue = exports.Queue = void 0;
 /**
  * @license MIT
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 const linked_list_1 = require("../linked-list");
-class LinkedListQueue extends linked_list_1.SinglyLinkedList {
-    /**
-     * The enqueue function adds a value to the end of an array.
-     * @param {E} value - The value parameter represents the value that you want to add to the queue.
-     */
-    enqueue(value) {
-        this.push(value);
-    }
-    /**
-     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
-     * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
-     */
-    dequeue() {
-        return this.shift();
-    }
-    /**
-     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-     */
-    getFirst() {
-        var _a;
-        return (_a = this.head) === null || _a === void 0 ? void 0 : _a.value;
-    }
-    /**
-     * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-     */
-    peek() {
-        return this.getFirst();
-    }
-}
-exports.LinkedListQueue = LinkedListQueue;
-class Queue {
+const base_1 = require("../base");
+class Queue extends base_1.IterableElementBase {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
      * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
@@ -47,6 +16,7 @@ class Queue {
      * initialized as an empty array.
      */
     constructor(elements) {
+        super();
         this._nodes = elements || [];
         this._offset = 0;
     }
@@ -268,31 +238,6 @@ class Queue {
     print() {
         console.log([...this]);
     }
-    *[Symbol.iterator]() {
-        for (const item of this.nodes) {
-            yield item;
-        }
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `forEach` function iterates over each element in a deque and applies a callback function to
-     * each element.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * deque. It takes three parameters:
-     */
-    forEach(callback) {
-        let index = 0;
-        for (const el of this) {
-            callback(el, index, this);
-            index++;
-        }
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -301,18 +246,23 @@ class Queue {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `filter` function creates a new deque containing only the elements that satisfy the given
-     * predicate function.
-     * @param predicate - The `predicate` parameter is a function that takes three arguments: `element`,
-     * `index`, and `deque`.
-     * @returns The `filter` method is returning a new `Queue` object that contains only the elements
-     * that satisfy the given `predicate` function.
-     */
-    filter(predicate) {
+     * The `filter` function creates a new `Queue` object containing elements from the original `Queue`
+     * that satisfy a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * the current element being iterated over, the index of the current element, and the queue itself.
+     * It should return a boolean value indicating whether the element should be included in the filtered
+     * queue or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `Queue` object that contains the elements that
+     * satisfy the given predicate function.
+     */
+    filter(predicate, thisArg) {
         const newDeque = new Queue([]);
         let index = 0;
         for (const el of this) {
-            if (predicate(el, index, this)) {
+            if (predicate.call(thisArg, el, index, this)) {
                 newDeque.push(el);
             }
             index++;
@@ -327,28 +277,65 @@ class Queue {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function takes a callback function and applies it to each element in the deque,
-     * returning a new deque with the results.
-     * @param callback - The `callback` parameter is a function that takes three arguments:
-     * @returns The `map` method is returning a new `Queue` object with the transformed elements.
-     */
-    map(callback) {
+     * The `map` function takes a callback function and applies it to each element in the queue,
+     * returning a new queue with the results.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * queue. It takes three arguments: the current element, the index of the current element, and the
+     * queue itself. The callback function should return a new value that will be added to the new queue.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `map` function is returning a new `Queue` object with the transformed elements.
+     */
+    map(callback, thisArg) {
         const newDeque = new Queue([]);
         let index = 0;
         for (const el of this) {
-            newDeque.push(callback(el, index, this));
+            newDeque.push(callback.call(thisArg, el, index, this));
             index++;
         }
         return newDeque;
     }
-    reduce(callback, initialValue) {
-        let accumulator = initialValue;
-        let index = 0;
-        for (const el of this) {
-            accumulator = callback(accumulator, el, index, this);
-            index++;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    *_getIterator() {
+        for (const item of this.nodes) {
+            yield item;
         }
-        return accumulator;
     }
 }
 exports.Queue = Queue;
+class LinkedListQueue extends linked_list_1.SinglyLinkedList {
+    /**
+     * The enqueue function adds a value to the end of an array.
+     * @param {E} value - The value parameter represents the value that you want to add to the queue.
+     */
+    enqueue(value) {
+        this.push(value);
+    }
+    /**
+     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
+     * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
+     */
+    dequeue() {
+        return this.shift();
+    }
+    /**
+     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     */
+    getFirst() {
+        var _a;
+        return (_a = this.head) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    /**
+     * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     */
+    peek() {
+        return this.getFirst();
+    }
+}
+exports.LinkedListQueue = LinkedListQueue;

package/dist/data-structures/stack/stack.d.ts

@@ -1,9 +1,11 @@
+import { IterableElementBase } from "../base";
+import { ElementCallback } from "../../types";
 /**
  * @license MIT
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-export declare class Stack<E = any> {
+export declare class Stack<E = any> extends IterableElementBase<E> {
     /**
      * The constructor initializes an array of elements, which can be provided as an optional parameter.
      * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
@@ -104,17 +106,48 @@ export declare class Stack<E = any> {
      */
     clone(): Stack<E>;
     /**
-     * Custom iterator for the Stack class.
-     * @returns An iterator object.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    [Symbol.iterator](): Generator<E, void, unknown>;
     /**
-     * Applies a function to each element of the stack.
-     * @param {function(E): void} callback - A function to apply to each element.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new stack containing elements from the original stack that satisfy
+     * a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * the current element being iterated over, the index of the current element, and the stack itself.
+     * It should return a boolean value indicating whether the element should be included in the filtered
+     * stack or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `Stack` object that contains the elements that
+     * satisfy the given predicate function.
+     */
+    filter(predicate: ElementCallback<E, boolean>, thisArg?: any): Stack<E>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    forEach(callback: (element: E, index: number, stack: this) => void): void;
-    filter(predicate: (element: E, index: number, stack: this) => boolean): Stack<E>;
-    map<T>(callback: (element: E, index: number, stack: this) => T): Stack<T>;
-    reduce<T>(callback: (accumulator: T, element: E, index: number, stack: this) => T, initialValue: T): T;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function takes a callback function and applies it to each element in the stack,
+     * returning a new stack with the results.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the stack. It takes three arguments:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `map` method is returning a new `Stack` object.
+     */
+    map<T>(callback: ElementCallback<E, T>, thisArg?: any): Stack<T>;
     print(): void;
+    /**
+     * Custom iterator for the Stack class.
+     * @returns An iterator object.
+     */
+    protected _getIterator(): Generator<E, void, unknown>;
 }

package/dist/data-structures/stack/stack.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stack = void 0;
+const base_1 = require("../base");
 /**
  * @license MIT
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-class Stack {
+class Stack extends base_1.IterableElementBase {
     /**
      * The constructor initializes an array of elements, which can be provided as an optional parameter.
      * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
@@ -14,6 +15,7 @@ class Stack {
      * is provided and is an array, it is assigned to the `_elements
      */
     constructor(elements) {
+        super();
         this._elements = [];
         if (elements) {
             for (const el of elements) {
@@ -138,56 +140,73 @@ class Stack {
         return new Stack(this.elements.slice());
     }
     /**
-     * Custom iterator for the Stack class.
-     * @returns An iterator object.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    *[Symbol.iterator]() {
-        for (let i = 0; i < this.elements.length; i++) {
-            yield this.elements[i];
-        }
-    }
     /**
-     * Applies a function to each element of the stack.
-     * @param {function(E): void} callback - A function to apply to each element.
-     */
-    forEach(callback) {
-        let index = 0;
-        for (const el of this) {
-            callback(el, index, this);
-            index++;
-        }
-    }
-    filter(predicate) {
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new stack containing elements from the original stack that satisfy
+     * a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * the current element being iterated over, the index of the current element, and the stack itself.
+     * It should return a boolean value indicating whether the element should be included in the filtered
+     * stack or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `Stack` object that contains the elements that
+     * satisfy the given predicate function.
+     */
+    filter(predicate, thisArg) {
         const newStack = new Stack();
         let index = 0;
         for (const el of this) {
-            if (predicate(el, index, this)) {
+            if (predicate.call(thisArg, el, index, this)) {
                 newStack.push(el);
             }
             index++;
         }
         return newStack;
     }
-    map(callback) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function takes a callback function and applies it to each element in the stack,
+     * returning a new stack with the results.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the stack. It takes three arguments:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `map` method is returning a new `Stack` object.
+     */
+    map(callback, thisArg) {
         const newStack = new Stack();
         let index = 0;
         for (const el of this) {
-            newStack.push(callback(el, index, this));
+            newStack.push(callback.call(thisArg, el, index, this));
             index++;
         }
         return newStack;
     }
-    reduce(callback, initialValue) {
-        let accumulator = initialValue;
-        let index = 0;
-        for (const el of this) {
-            accumulator = callback(accumulator, el, index, this);
-            index++;
-        }
-        return accumulator;
-    }
     print() {
         console.log([...this]);
     }
+    /**
+     * Custom iterator for the Stack class.
+     * @returns An iterator object.
+     */
+    *_getIterator() {
+        for (let i = 0; i < this.elements.length; i++) {
+            yield this.elements[i];
+        }
+    }
 }
 exports.Stack = Stack;

package/dist/data-structures/trie/trie.d.ts

@@ -5,6 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+import { IterableElementBase } from "../base";
+import { ElementCallback } from "../../types";
 /**
  * TrieNode represents a node in the Trie data structure. It holds a character key, a map of children nodes,
  * and a flag indicating whether it's the end of a word.
@@ -18,7 +20,7 @@ export declare class TrieNode {
 /**
  * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
  */
-export declare class Trie {
+export declare class Trie extends IterableElementBase<string> {
     constructor(words?: string[], caseSensitive?: boolean);
     protected _size: number;
     get size(): number;
@@ -142,12 +144,45 @@ export declare class Trie {
      * @returns {string[]} an array of strings.
      */
     getWords(prefix?: string, max?: number, isAllWhenEmptyPrefix?: boolean): string[];
-    [Symbol.iterator](): IterableIterator<string>;
-    forEach(callback: (word: string, index: number, trie: this) => void): void;
-    filter(predicate: (word: string, index: number, trie: this) => boolean): string[];
-    map(callback: (word: string, index: number, trie: this) => string): Trie;
-    reduce<T>(callback: (accumulator: T, word: string, index: number, trie: this) => T, initialValue: T): T;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function takes a predicate function and returns a new array containing all the
+     * elements for which the predicate function returns true.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * `word`, `index`, and `this`. It should return a boolean value indicating whether the current
+     * element should be included in the filtered results or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+     * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
+     * @returns The `filter` method is returning an array of strings (`string[]`).
+     */
+    filter(predicate: ElementCallback<string, boolean>, thisArg?: any): string[];
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function creates a new Trie by applying a callback function to each element in the Trie.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * Trie. It takes three arguments: the current element in the Trie, the index of the current element,
+     * and the Trie itself. The callback function should return a new value for the element.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `map` function is returning a new Trie object.
+     */
+    map(callback: ElementCallback<string, string>, thisArg?: any): Trie;
     print(): void;
+    protected _getIterator(): IterableIterator<string>;
     /**
      * Time Complexity: O(M), where M is the length of the input string.
      * Space Complexity: O(1) - Constant space.

package/dist/data-structures/trie/trie.js

@@ -8,6 +8,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trie = exports.TrieNode = void 0;
+const base_1 = require("../base");
 /**
  * TrieNode represents a node in the Trie data structure. It holds a character key, a map of children nodes,
  * and a flag indicating whether it's the end of a word.
@@ -23,8 +24,9 @@ exports.TrieNode = TrieNode;
 /**
  * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
  */
-class Trie {
+class Trie extends base_1.IterableElementBase {
     constructor(words, caseSensitive = true) {
+        super();
         this._root = new TrieNode('');
         this._caseSensitive = caseSensitive;
         this._size = 0;
@@ -317,56 +319,75 @@ class Trie {
             dfs(startNode, prefix);
         return words;
     }
-    *[Symbol.iterator]() {
-        function* _dfs(node, path) {
-            if (node.isEnd) {
-                yield path;
-            }
-            for (const [char, childNode] of node.children) {
-                yield* _dfs(childNode, path + char);
-            }
-        }
-        yield* _dfs(this.root, '');
-    }
-    forEach(callback) {
-        let index = 0;
-        for (const word of this) {
-            callback(word, index, this);
-            index++;
-        }
-    }
-    filter(predicate) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function takes a predicate function and returns a new array containing all the
+     * elements for which the predicate function returns true.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * `word`, `index`, and `this`. It should return a boolean value indicating whether the current
+     * element should be included in the filtered results or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+     * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
+     * @returns The `filter` method is returning an array of strings (`string[]`).
+     */
+    filter(predicate, thisArg) {
         const results = [];
         let index = 0;
         for (const word of this) {
-            if (predicate(word, index, this)) {
+            if (predicate.call(thisArg, word, index, this)) {
                 results.push(word);
             }
             index++;
         }
         return results;
     }
-    map(callback) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function creates a new Trie by applying a callback function to each element in the Trie.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * Trie. It takes three arguments: the current element in the Trie, the index of the current element,
+     * and the Trie itself. The callback function should return a new value for the element.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `map` function is returning a new Trie object.
+     */
+    map(callback, thisArg) {
         const newTrie = new Trie();
         let index = 0;
         for (const word of this) {
-            newTrie.add(callback(word, index, this));
+            newTrie.add(callback.call(thisArg, word, index, this));
             index++;
         }
         return newTrie;
     }
-    reduce(callback, initialValue) {
-        let accumulator = initialValue;
-        let index = 0;
-        for (const word of this) {
-            accumulator = callback(accumulator, word, index, this);
-            index++;
-        }
-        return accumulator;
-    }
     print() {
         console.log([...this]);
     }
+    *_getIterator() {
+        function* _dfs(node, path) {
+            if (node.isEnd) {
+                yield path;
+            }
+            for (const [char, childNode] of node.children) {
+                yield* _dfs(childNode, path + char);
+            }
+        }
+        yield* _dfs(this.root, '');
+    }
     /**
      * Time Complexity: O(M), where M is the length of the input string.
      * Space Complexity: O(1) - Constant space.

package/dist/types/data-structures/base/base.d.ts

@@ -0,0 +1,5 @@
+import { IterableElementBase, IterablePairBase } from "../../../data-structures";
+export type PairCallback<K, V, R> = (value: V, key: K, index: number, container: IterablePairBase<K, V>) => R;
+export type ElementCallback<V, R> = (element: V, index: number, container: IterableElementBase<V>) => R;
+export type ReducePairCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, container: IterablePairBase<K, V>) => R;
+export type ReduceElementCallback<V, R> = (accumulator: R, element: V, index: number, container: IterableElementBase<V>) => R;

package/dist/types/data-structures/base/base.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/data-structures/base/index.d.ts

@@ -0,0 +1 @@
+export * from './base';

package/dist/types/data-structures/base/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base"), exports);

package/dist/types/data-structures/index.d.ts

@@ -9,3 +9,4 @@ export * from './queue';
 export * from './stack';
 export * from './tree';
 export * from './trie';
+export * from './base';

package/dist/types/data-structures/index.js

@@ -25,3 +25,4 @@ __exportStar(require("./queue"), exports);
 __exportStar(require("./stack"), exports);
 __exportStar(require("./tree"), exports);
 __exportStar(require("./trie"), exports);
+__exportStar(require("./base"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heap-typed",
-  "version": "1.48.1",
+  "version": "1.48.2",
   "description": "Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -131,6 +131,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.48.1"
+    "data-structure-typed": "^1.48.2"
   }
 }

package/src/data-structures/base/index.ts

@@ -0,0 +1 @@
+export * from './iterable-base';