linked-list-typed 1.49.4 → 1.49.6

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

@@ -1,6 +1,4 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MatrixNTI2D = void 0;
 /**
  * data-structure-typed
  *
@@ -8,21 +6,408 @@ exports.MatrixNTI2D = void 0;
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-// todo need to be improved
-class MatrixNTI2D {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Matrix = void 0;
+class Matrix {
     /**
-     * The constructor creates a matrix with the specified number of rows and columns, and initializes all elements to a
-     * given initial value or 0 if not provided.
-     * @param options - An object containing the following properties:
+     * The constructor function initializes a matrix object with the provided data and options, or with
+     * default values if no options are provided.
+     * @param {number[][]} data - A 2D array of numbers representing the data for the matrix.
+     * @param [options] - The `options` parameter is an optional object that can contain the following
+     * properties:
      */
-    constructor(options) {
-        const { row, col, initialVal } = options;
-        this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
+    constructor(data, options) {
+        var _a, _b, _c;
+        this._rows = 0;
+        this._cols = 0;
+        if (options) {
+            const { rows, cols, addFn, subtractFn, multiplyFn } = options;
+            if (typeof rows === 'number' && rows > 0)
+                this._rows = rows;
+            else
+                this._rows = data.length;
+            if (typeof cols === 'number' && cols > 0)
+                this._cols = cols;
+            else
+                this._cols = ((_a = data[0]) === null || _a === void 0 ? void 0 : _a.length) || 0;
+            if (addFn)
+                this._addFn = addFn;
+            if (subtractFn)
+                this._subtractFn = subtractFn;
+            if (multiplyFn)
+                this._multiplyFn = multiplyFn;
+        }
+        else {
+            this._rows = data.length;
+            this._cols = (_c = (_b = data[0]) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
+        }
+        if (data.length > 0) {
+            this._data = data;
+        }
+        else {
+            this._data = [];
+            for (let i = 0; i < this.rows; i++) {
+                this._data[i] = new Array(this.cols).fill(0);
+            }
+        }
+    }
+    get rows() {
+        return this._rows;
+    }
+    get cols() {
+        return this._cols;
+    }
+    get data() {
+        return this._data;
+    }
+    get addFn() {
+        return this._addFn;
+    }
+    get subtractFn() {
+        return this._subtractFn;
     }
-    /* The `toArray` method returns the matrix as a two-dimensional array. It converts the internal representation of the
-    matrix, which is an array of arrays, into a format that is more commonly used in JavaScript. */
-    toArray() {
-        return this._matrix;
+    get multiplyFn() {
+        return this._multiplyFn;
+    }
+    /**
+     * The `get` function returns the value at the specified row and column index if it is a valid index.
+     * @param {number} row - The `row` parameter represents the row index of the element you want to
+     * retrieve from the data array.
+     * @param {number} col - The parameter "col" represents the column number of the element you want to
+     * retrieve from the data array.
+     * @returns The `get` function returns a number if the provided row and column indices are valid.
+     * Otherwise, it returns `undefined`.
+     */
+    get(row, col) {
+        if (this.isValidIndex(row, col)) {
+            return this.data[row][col];
+        }
+    }
+    /**
+     * The set function updates the value at a specified row and column in a two-dimensional array.
+     * @param {number} row - The "row" parameter represents the row index of the element in a
+     * two-dimensional array or matrix. It specifies the row where the value will be set.
+     * @param {number} col - The "col" parameter represents the column index of the element in a
+     * two-dimensional array.
+     * @param {number} value - The value parameter represents the number that you want to set at the
+     * specified row and column in the data array.
+     * @returns a boolean value. It returns true if the index (row, col) is valid and the value is
+     * successfully set in the data array. It returns false if the index is invalid and the value is not
+     * set.
+     */
+    set(row, col, value) {
+        if (this.isValidIndex(row, col)) {
+            this.data[row][col] = value;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * The function checks if the dimensions of the given matrix match the dimensions of the current
+     * matrix.
+     * @param {Matrix} matrix - The parameter `matrix` is of type `Matrix`.
+     * @returns a boolean value.
+     */
+    isMatchForCalculate(matrix) {
+        return this.rows === matrix.rows && this.cols === matrix.cols;
+    }
+    /**
+     * The `add` function adds two matrices together, returning a new matrix with the result.
+     * @param {Matrix} matrix - The `matrix` parameter is an instance of the `Matrix` class.
+     * @returns The `add` method returns a new `Matrix` object that represents the result of adding the
+     * current matrix with the provided `matrix` parameter.
+     */
+    add(matrix) {
+        if (!this.isMatchForCalculate(matrix)) {
+            throw new Error('Matrix dimensions must match for addition.');
+        }
+        const resultData = [];
+        for (let i = 0; i < this.rows; i++) {
+            resultData[i] = [];
+            for (let j = 0; j < this.cols; j++) {
+                const a = this.get(i, j), b = matrix.get(i, j);
+                if (a !== undefined && b !== undefined) {
+                    const added = this._addFn(a, b);
+                    if (added) {
+                        resultData[i][j] = added;
+                    }
+                }
+            }
+        }
+        return new Matrix(resultData, {
+            rows: this.rows,
+            cols: this.cols,
+            addFn: this.addFn,
+            subtractFn: this.subtractFn,
+            multiplyFn: this.multiplyFn
+        });
+    }
+    /**
+     * The `subtract` function performs element-wise subtraction between two matrices and returns a new
+     * matrix with the result.
+     * @param {Matrix} matrix - The `matrix` parameter is an instance of the `Matrix` class. It
+     * represents the matrix that you want to subtract from the current matrix.
+     * @returns a new Matrix object with the result of the subtraction operation.
+     */
+    subtract(matrix) {
+        if (!this.isMatchForCalculate(matrix)) {
+            throw new Error('Matrix dimensions must match for subtraction.');
+        }
+        const resultData = [];
+        for (let i = 0; i < this.rows; i++) {
+            resultData[i] = [];
+            for (let j = 0; j < this.cols; j++) {
+                const a = this.get(i, j), b = matrix.get(i, j);
+                if (a !== undefined && b !== undefined) {
+                    const subtracted = this._subtractFn(a, b);
+                    if (subtracted) {
+                        resultData[i][j] = subtracted;
+                    }
+                }
+            }
+        }
+        return new Matrix(resultData, {
+            rows: this.rows,
+            cols: this.cols,
+            addFn: this.addFn,
+            subtractFn: this.subtractFn,
+            multiplyFn: this.multiplyFn
+        });
+    }
+    /**
+     * The `multiply` function performs matrix multiplication between two matrices and returns the result
+     * as a new matrix.
+     * @param {Matrix} matrix - The `matrix` parameter is an instance of the `Matrix` class.
+     * @returns a new Matrix object.
+     */
+    multiply(matrix) {
+        if (this.cols !== matrix.rows) {
+            throw new Error('Matrix dimensions must be compatible for multiplication (A.cols = B.rows).');
+        }
+        const resultData = [];
+        for (let i = 0; i < this.rows; i++) {
+            resultData[i] = [];
+            for (let j = 0; j < matrix.cols; j++) {
+                let sum;
+                for (let k = 0; k < this.cols; k++) {
+                    const a = this.get(i, k), b = matrix.get(k, j);
+                    if (a !== undefined && b !== undefined) {
+                        const multiplied = this.multiplyFn(a, b);
+                        if (multiplied !== undefined) {
+                            sum = this.addFn(sum, multiplied);
+                        }
+                    }
+                }
+                if (sum !== undefined)
+                    resultData[i][j] = sum;
+            }
+        }
+        return new Matrix(resultData, {
+            rows: this.rows,
+            cols: matrix.cols,
+            addFn: this.addFn,
+            subtractFn: this.subtractFn,
+            multiplyFn: this.multiplyFn
+        });
+    }
+    /**
+     * The transpose function takes a matrix and returns a new matrix that is the transpose of the
+     * original matrix.
+     * @returns The transpose() function returns a new Matrix object with the transposed data.
+     */
+    transpose() {
+        if (this.data.some(row => row.length !== this.rows)) {
+            throw new Error('Matrix must be rectangular for transposition.');
+        }
+        const resultData = [];
+        for (let j = 0; j < this.cols; j++) {
+            resultData[j] = [];
+            for (let i = 0; i < this.rows; i++) {
+                const trans = this.get(i, j);
+                if (trans !== undefined)
+                    resultData[j][i] = trans;
+            }
+        }
+        return new Matrix(resultData, {
+            rows: this.cols,
+            cols: this.rows,
+            addFn: this.addFn,
+            subtractFn: this.subtractFn,
+            multiplyFn: this.multiplyFn
+        });
+    }
+    /**
+     * The `inverse` function calculates the inverse of a square matrix using Gaussian elimination.
+     * @returns a Matrix object, which represents the inverse of the original matrix.
+     */
+    inverse() {
+        var _a;
+        // Check if the matrix is square
+        if (this.rows !== this.cols) {
+            throw new Error('Matrix must be square for inversion.');
+        }
+        // Create an augmented matrix [this | I]
+        const augmentedMatrixData = [];
+        for (let i = 0; i < this.rows; i++) {
+            augmentedMatrixData[i] = this.data[i].slice(); // Copy the original matrix
+            for (let j = 0; j < this.cols; j++) {
+                augmentedMatrixData[i][this.cols + j] = i === j ? 1 : 0; // Append the identity matrix
+            }
+        }
+        const augmentedMatrix = new Matrix(augmentedMatrixData, {
+            rows: this.rows,
+            cols: this.cols * 2,
+            addFn: this.addFn,
+            subtractFn: this.subtractFn,
+            multiplyFn: this.multiplyFn
+        });
+        // Apply Gaussian elimination to transform the left half into the identity matrix
+        for (let i = 0; i < this.rows; i++) {
+            // Find pivot
+            let pivotRow = i;
+            while (pivotRow < this.rows && augmentedMatrix.get(pivotRow, i) === 0) {
+                pivotRow++;
+            }
+            if (pivotRow === this.rows) {
+                // Matrix is singular, and its inverse does not exist
+                throw new Error('Matrix is singular, and its inverse does not exist.');
+            }
+            // Swap rows to make the pivot the current row
+            augmentedMatrix._swapRows(i, pivotRow);
+            // Scale the pivot row to make the pivot element 1
+            const pivotElement = (_a = augmentedMatrix.get(i, i)) !== null && _a !== void 0 ? _a : 1;
+            if (pivotElement === 0) {
+                // Handle division by zero
+                throw new Error('Matrix is singular, and its inverse does not exist (division by zero).');
+            }
+            augmentedMatrix._scaleRow(i, 1 / pivotElement);
+            // Eliminate other rows to make elements in the current column zero
+            for (let j = 0; j < this.rows; j++) {
+                if (j !== i) {
+                    let factor = augmentedMatrix.get(j, i);
+                    if (factor === undefined)
+                        factor = 0;
+                    augmentedMatrix._addScaledRow(j, i, -factor);
+                }
+            }
+        }
+        // Extract the right half of the augmented matrix as the inverse
+        const inverseData = [];
+        for (let i = 0; i < this.rows; i++) {
+            inverseData[i] = augmentedMatrix.data[i].slice(this.cols);
+        }
+        return new Matrix(inverseData, {
+            rows: this.rows,
+            cols: this.cols,
+            addFn: this.addFn,
+            subtractFn: this.subtractFn,
+            multiplyFn: this.multiplyFn
+        });
+    }
+    /**
+     * The dot function calculates the dot product of two matrices and returns a new matrix.
+     * @param {Matrix} matrix - The `matrix` parameter is an instance of the `Matrix` class.
+     * @returns a new Matrix object.
+     */
+    dot(matrix) {
+        if (this.cols !== matrix.rows) {
+            throw new Error('Number of columns in the first matrix must be equal to the number of rows in the second matrix for dot product.');
+        }
+        const resultData = [];
+        for (let i = 0; i < this.rows; i++) {
+            resultData[i] = [];
+            for (let j = 0; j < matrix.cols; j++) {
+                let sum;
+                for (let k = 0; k < this.cols; k++) {
+                    const a = this.get(i, k), b = matrix.get(k, j);
+                    if (a !== undefined && b !== undefined) {
+                        const multiplied = this.multiplyFn(a, b);
+                        if (multiplied !== undefined) {
+                            sum = this.addFn(sum, multiplied);
+                        }
+                    }
+                }
+                if (sum !== undefined)
+                    resultData[i][j] = sum;
+            }
+        }
+        return new Matrix(resultData, {
+            rows: this.rows,
+            cols: matrix.cols,
+            addFn: this.addFn,
+            subtractFn: this.subtractFn,
+            multiplyFn: this.multiplyFn
+        });
+    }
+    _addFn(a, b) {
+        if (a === undefined)
+            return b;
+        return a + b;
+    }
+    _subtractFn(a, b) {
+        return a - b;
+    }
+    _multiplyFn(a, b) {
+        return a * b;
+    }
+    /**
+     * The function checks if a given row and column index is valid within a specified range.
+     * @param {number} row - The `row` parameter represents the row index of a two-dimensional array or
+     * matrix. It is a number that indicates the specific row in the matrix.
+     * @param {number} col - The "col" parameter represents the column index in a two-dimensional array
+     * or grid. It is used to check if the given column index is valid within the bounds of the grid.
+     * @returns A boolean value is being returned.
+     */
+    isValidIndex(row, col) {
+        return row >= 0 && row < this.rows && col >= 0 && col < this.cols;
+    }
+    /**
+     * The function `_swapRows` swaps the positions of two rows in an array.
+     * @param {number} row1 - The `row1` parameter is the index of the first row that you want to swap.
+     * @param {number} row2 - The `row2` parameter is the index of the second row that you want to swap
+     * with the first row.
+     */
+    _swapRows(row1, row2) {
+        const temp = this.data[row1];
+        this.data[row1] = this.data[row2];
+        this.data[row2] = temp;
+    }
+    /**
+     * The function scales a specific row in a matrix by a given scalar value.
+     * @param {number} row - The `row` parameter represents the index of the row in the matrix that you
+     * want to scale. It is a number that indicates the position of the row within the matrix.
+     * @param {number} scalar - The scalar parameter is a number that is used to multiply each element in
+     * a specific row of a matrix.
+     */
+    _scaleRow(row, scalar) {
+        for (let j = 0; j < this.cols; j++) {
+            let multiplied = this.multiplyFn(this.data[row][j], scalar);
+            if (multiplied === undefined)
+                multiplied = 0;
+            this.data[row][j] = multiplied;
+        }
+    }
+    /**
+     * The function `_addScaledRow` multiplies a row in a matrix by a scalar value and adds it to another
+     * row.
+     * @param {number} targetRow - The targetRow parameter represents the index of the row in which the
+     * scaled values will be added.
+     * @param {number} sourceRow - The sourceRow parameter represents the index of the row from which the
+     * values will be scaled and added to the targetRow.
+     * @param {number} scalar - The scalar parameter is a number that is used to scale the values in the
+     * source row before adding them to the target row.
+     */
+    _addScaledRow(targetRow, sourceRow, scalar) {
+        for (let j = 0; j < this.cols; j++) {
+            let multiplied = this.multiplyFn(this.data[sourceRow][j], scalar);
+            if (multiplied === undefined)
+                multiplied = 0;
+            const scaledValue = multiplied;
+            let added = this.addFn(this.data[targetRow][j], scaledValue);
+            if (added === undefined)
+                added = 0;
+            this.data[targetRow][j] = added;
+        }
     }
 }
-exports.MatrixNTI2D = MatrixNTI2D;
+exports.Matrix = Matrix;

package/dist/data-structures/queue/deque.d.ts

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback, IterableWithSizeOrLength } from "../../types";
-import { IterableElementBase } from "../base";
+import type { ElementCallback, IterableWithSizeOrLength } from '../../types';
+import { IterableElementBase } from '../base';
 /**
  * 1. Operations at Both Ends: Supports adding and removing elements at both the front and back of the queue. This allows it to be used as a stack (last in, first out) and a queue (first in, first out).
  * 2. Efficient Random Access: Being based on an array, it offers fast random access capability, allowing constant time access to any element.

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

@@ -20,7 +20,7 @@ class Deque extends base_1.IterableElementBase {
      * @param bucketSize - The `bucketSize` parameter is the maximum number of elements that can be
      * stored in each bucket. It determines the size of each bucket in the data structure.
      */
-    constructor(elements = [], bucketSize = (1 << 12)) {
+    constructor(elements = [], bucketSize = 1 << 12) {
         super();
         this._bucketFirst = 0;
         this._firstInBucket = 0;
@@ -49,7 +49,7 @@ class Deque extends base_1.IterableElementBase {
         }
         const needBucketNum = (0, utils_1.calcMinUnitsRequired)(_size, this._bucketSize);
         this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);
-        this._firstInBucket = this._lastInBucket = (this._bucketSize - _size % this._bucketSize) >> 1;
+        this._firstInBucket = this._lastInBucket = (this._bucketSize - (_size % this._bucketSize)) >> 1;
         for (const element of elements) {
             this.push(element);
         }
@@ -101,8 +101,7 @@ class Deque extends base_1.IterableElementBase {
                 this._bucketLast = 0;
                 this._lastInBucket = 0;
             }
-            if (this._bucketLast === this._bucketFirst &&
-                this._lastInBucket === this._firstInBucket)
+            if (this._bucketLast === this._bucketFirst && this._lastInBucket === this._firstInBucket)
                 this._reallocate();
         }
         this._size += 1;
@@ -168,8 +167,7 @@ class Deque extends base_1.IterableElementBase {
                 this._bucketFirst = this._bucketCount - 1;
                 this._firstInBucket = this._bucketSize - 1;
             }
-            if (this._bucketFirst === this._bucketLast &&
-                this._firstInBucket === this._lastInBucket)
+            if (this._bucketFirst === this._bucketLast && this._firstInBucket === this._lastInBucket)
                 this._reallocate();
         }
         this._size += 1;
@@ -768,7 +766,7 @@ class Deque extends base_1.IterableElementBase {
         if (bucketIndex >= this._bucketCount) {
             bucketIndex -= this._bucketCount;
         }
-        indexInBucket = (overallIndex + 1) % this._bucketSize - 1;
+        indexInBucket = ((overallIndex + 1) % this._bucketSize) - 1;
         if (indexInBucket < 0) {
             indexInBucket = this._bucketSize - 1;
         }

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

@@ -4,7 +4,7 @@
  * @class
  */
 import type { ElementCallback } from '../../types';
-import { IterableElementBase } from "../base";
+import { IterableElementBase } from '../base';
 import { SinglyLinkedList } from '../linked-list';
 /**
  * 1. First In, First Out (FIFO): The core feature of a queue is its first in, first out nature. The element added to the queue first will be the one to be removed first.

package/dist/interfaces/binary-tree.d.ts

@@ -1,9 +1,9 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNExemplar } from '../types';
+import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, KeyOrNodeOrEntry } from '../types';
 export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTreeNested<K, V, N>> {
     createNode(key: K, value?: N['value']): N;
     createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
-    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
-    addMany(nodes: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
+    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count?: number): boolean;
+    addMany(nodes: Iterable<KeyOrNodeOrEntry<K, V, N>>, values?: Iterable<V | undefined>): boolean[];
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<N>[];
 }

package/dist/types/common.d.ts

@@ -1,6 +1,6 @@
 export declare enum BSTVariant {
-    MIN = "MIN",
-    MAX = "MAX"
+    STANDARD = "STANDARD",
+    INVERSE = "INVERSE"
 }
 export declare enum CP {
     lt = "lt",
@@ -44,7 +44,7 @@ export type BinaryTreePrintOptions = {
 };
 export type BTNEntry<K, V> = [K | null | undefined, V | undefined];
 export type BTNKeyOrNode<K, N> = K | null | undefined | N;
-export type BTNExemplar<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
+export type KeyOrNodeOrEntry<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
 export type BTNodePureKeyOrNode<K, N> = K | N;
 export type BTNodePureExemplar<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>;
 export type BSTNKeyOrNode<K, N> = K | undefined | N;

package/dist/types/common.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FamilyPosition = exports.IterationType = exports.CP = exports.BSTVariant = void 0;
 var BSTVariant;
 (function (BSTVariant) {
-    BSTVariant["MIN"] = "MIN";
-    BSTVariant["MAX"] = "MAX";
+    BSTVariant["STANDARD"] = "STANDARD";
+    BSTVariant["INVERSE"] = "INVERSE";
 })(BSTVariant = exports.BSTVariant || (exports.BSTVariant = {}));
 var CP;
 (function (CP) {

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

@@ -1,4 +1,4 @@
-import { IterableElementBase, IterableEntryBase } from "../../../data-structures";
+import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
 export type EntryCallback<K, V, R> = (value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;
 export type ElementCallback<V, R> = (element: V, index: number, container: IterableElementBase<V>) => R;
 export type ReduceEntryCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;

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

@@ -1,4 +1,4 @@
-import { Comparator } from "../../common";
+import { Comparator } from '../../common';
 export type HeapOptions<T> = {
     comparator: Comparator<T>;
 };

package/dist/types/data-structures/priority-queue/priority-queue.d.ts

@@ -1,2 +1,2 @@
-import { HeapOptions } from "../heap";
+import { HeapOptions } from '../heap';
 export type PriorityQueueOptions<T> = HeapOptions<T> & {};

package/dist/utils/utils.d.ts

@@ -22,3 +22,4 @@ export declare const rangeCheck: (index: number, min: number, max: number, messa
 export declare const throwRangeError: (message?: string) => void;
 export declare const isWeakKey: (input: unknown) => input is object;
 export declare const calcMinUnitsRequired: (totalQuantity: number, unitSize: number) => number;
+export declare const roundFixed: (num: number, digit?: number) => number;

package/dist/utils/utils.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calcMinUnitsRequired = exports.isWeakKey = exports.throwRangeError = exports.rangeCheck = exports.getMSB = exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = exports.arrayRemove = exports.uuidV4 = void 0;
+exports.roundFixed = exports.calcMinUnitsRequired = exports.isWeakKey = exports.throwRangeError = exports.rangeCheck = exports.getMSB = exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = exports.arrayRemove = exports.uuidV4 = void 0;
 const uuidV4 = function () {
     return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
         const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
@@ -87,3 +87,8 @@ const isWeakKey = (input) => {
 exports.isWeakKey = isWeakKey;
 const calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
 exports.calcMinUnitsRequired = calcMinUnitsRequired;
+const roundFixed = (num, digit = 10) => {
+    const multiplier = Math.pow(10, digit);
+    return Math.round(num * multiplier) / multiplier;
+};
+exports.roundFixed = roundFixed;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-list-typed",
-  "version": "1.49.4",
+  "version": "1.49.6",
   "description": "Linked List, Doubly Linked List, Singly Linked List. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -66,6 +66,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.49.4"
+    "data-structure-typed": "^1.49.5"
   }
 }

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

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