data-structure-typed 1.51.3 → 1.51.4

package/dist/umd/data-structure-typed.js

@@ -165,6 +165,7 @@ var dataStructureTyped = (() => {
     rangeCheck: () => rangeCheck,
     roundFixed: () => roundFixed,
     throwRangeError: () => throwRangeError,
+    toBinaryString: () => toBinaryString,
     toThunk: () => toThunk,
     trampoline: () => trampoline,
     trampolineAsync: () => trampolineAsync,
@@ -711,6 +712,13 @@ var dataStructureTyped = (() => {
     return Math.round(num * multiplier) / multiplier;
   };
 
+  // src/utils/number.ts
+  function toBinaryString(num, digit = 32) {
+    let binaryString = (num >>> 0).toString(2);
+    binaryString = binaryString.padStart(digit, "0");
+    return binaryString;
+  }
+
   // src/data-structures/hash/hash-map.ts
   var HashMap = class _HashMap extends IterableEntryBase {
     /**
@@ -7891,9 +7899,9 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     isRealNode(node) {
-      if (!this.isNode(node))
+      if (node === this.NIL || node === null || node === void 0)
         return false;
-      return node !== this.NIL;
+      return this.isNode(node);
     }
     /**
      * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
@@ -12489,112 +12497,6 @@ var dataStructureTyped = (() => {
     }
   };
 
-  // src/data-structures/tree/tree.ts
-  var TreeNode = class _TreeNode {
-    /**
-     * The constructor function initializes a TreeNode object with a key, optional value, and optional
-     * children.
-     * @param {string} key - A string representing the key of the tree node.
-     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
-     * value associated with the node. If no value is provided, it defaults to `undefined`.
-     * @param {TreeNode<V>[]} [children] - The `children` parameter is an optional array of `TreeNode<V>`
-     * objects. It represents the child nodes of the current node. If no children are provided, the
-     * default value is an empty array.
-     */
-    constructor(key, value, children) {
-      __publicField(this, "_key");
-      __publicField(this, "_value");
-      __publicField(this, "_children");
-      this._key = key;
-      this._value = value || void 0;
-      this._children = children || [];
-    }
-    /**
-     * The function returns the value of the protected variable _key.
-     * @returns The value of the `_key` property, which is a string.
-     */
-    get key() {
-      return this._key;
-    }
-    /**
-     * The above function sets the value of a protected variable called "key".
-     * @param {string} value - The value parameter is a string that represents the value to be assigned
-     * to the key.
-     */
-    set key(value) {
-      this._key = value;
-    }
-    /**
-     * The function returns the value stored in a variable, or undefined if the variable is empty.
-     * @returns The value of the variable `_value` is being returned.
-     */
-    get value() {
-      return this._value;
-    }
-    /**
-     * The function sets the value of a variable.
-     * @param {V | undefined} value - The parameter "value" is of type "V | undefined", which means it
-     * can accept a value of type "V" or it can be undefined.
-     */
-    set value(value) {
-      this._value = value;
-    }
-    /**
-     * The function returns an array of TreeNode objects or undefined.
-     * @returns The `children` property is being returned. It is of type `TreeNode<V>[] | undefined`,
-     * which means it can either be an array of `TreeNode<V>` objects or `undefined`.
-     */
-    get children() {
-      return this._children;
-    }
-    /**
-     * The function sets the value of the children property of a TreeNode object.
-     * @param {TreeNode<V>[] | undefined} value - The value parameter is of type TreeNode<V>[] |
-     * undefined. This means that it can accept an array of TreeNode objects or undefined.
-     */
-    set children(value) {
-      this._children = value;
-    }
-    /**
-     * The function `addChildren` adds one or more child nodes to the current node.
-     * @param {TreeNode<V> | TreeNode<V>[]} children - The `children` parameter can be either a single
-     * `TreeNode<V>` object or an array of `TreeNode<V>` objects.
-     */
-    addChildren(children) {
-      if (!this._children) {
-        this._children = [];
-      }
-      if (children instanceof _TreeNode) {
-        this._children.push(children);
-      } else {
-        this._children = this._children.concat(children);
-      }
-    }
-    /**
-     * The function `getHeight()` calculates the maximum depth of a tree structure by performing a
-     * breadth-first search.
-     * @returns the maximum depth or height of the tree.
-     */
-    getHeight() {
-      let maxDepth = 0;
-      if (this) {
-        const bfs = (node, level) => {
-          if (level > maxDepth) {
-            maxDepth = level;
-          }
-          const { _children } = node;
-          if (_children) {
-            for (let i = 0, len = _children.length; i < len; i++) {
-              bfs(_children[i], level + 1);
-            }
-          }
-        };
-        bfs(this, 0);
-      }
-      return maxDepth;
-    }
-  };
-
   // src/data-structures/priority-queue/priority-queue.ts
   var PriorityQueue = class extends Heap {
     /**
@@ -13717,6 +13619,112 @@ var dataStructureTyped = (() => {
       return str;
     }
   };
+
+  // src/data-structures/tree/tree.ts
+  var TreeNode = class _TreeNode {
+    /**
+     * The constructor function initializes a TreeNode object with a key, optional value, and optional
+     * children.
+     * @param {string} key - A string representing the key of the tree node.
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+     * value associated with the node. If no value is provided, it defaults to `undefined`.
+     * @param {TreeNode<V>[]} [children] - The `children` parameter is an optional array of `TreeNode<V>`
+     * objects. It represents the child nodes of the current node. If no children are provided, the
+     * default value is an empty array.
+     */
+    constructor(key, value, children) {
+      __publicField(this, "_key");
+      __publicField(this, "_value");
+      __publicField(this, "_children");
+      this._key = key;
+      this._value = value || void 0;
+      this._children = children || [];
+    }
+    /**
+     * The function returns the value of the protected variable _key.
+     * @returns The value of the `_key` property, which is a string.
+     */
+    get key() {
+      return this._key;
+    }
+    /**
+     * The above function sets the value of a protected variable called "key".
+     * @param {string} value - The value parameter is a string that represents the value to be assigned
+     * to the key.
+     */
+    set key(value) {
+      this._key = value;
+    }
+    /**
+     * The function returns the value stored in a variable, or undefined if the variable is empty.
+     * @returns The value of the variable `_value` is being returned.
+     */
+    get value() {
+      return this._value;
+    }
+    /**
+     * The function sets the value of a variable.
+     * @param {V | undefined} value - The parameter "value" is of type "V | undefined", which means it
+     * can accept a value of type "V" or it can be undefined.
+     */
+    set value(value) {
+      this._value = value;
+    }
+    /**
+     * The function returns an array of TreeNode objects or undefined.
+     * @returns The `children` property is being returned. It is of type `TreeNode<V>[] | undefined`,
+     * which means it can either be an array of `TreeNode<V>` objects or `undefined`.
+     */
+    get children() {
+      return this._children;
+    }
+    /**
+     * The function sets the value of the children property of a TreeNode object.
+     * @param {TreeNode<V>[] | undefined} value - The value parameter is of type TreeNode<V>[] |
+     * undefined. This means that it can accept an array of TreeNode objects or undefined.
+     */
+    set children(value) {
+      this._children = value;
+    }
+    /**
+     * The function `addChildren` adds one or more child nodes to the current node.
+     * @param {TreeNode<V> | TreeNode<V>[]} children - The `children` parameter can be either a single
+     * `TreeNode<V>` object or an array of `TreeNode<V>` objects.
+     */
+    addChildren(children) {
+      if (!this._children) {
+        this._children = [];
+      }
+      if (children instanceof _TreeNode) {
+        this._children.push(children);
+      } else {
+        this._children = this._children.concat(children);
+      }
+    }
+    /**
+     * The function `getHeight()` calculates the maximum depth of a tree structure by performing a
+     * breadth-first search.
+     * @returns the maximum depth or height of the tree.
+     */
+    getHeight() {
+      let maxDepth = 0;
+      if (this) {
+        const bfs = (node, level) => {
+          if (level > maxDepth) {
+            maxDepth = level;
+          }
+          const { _children } = node;
+          if (_children) {
+            for (let i = 0, len = _children.length; i < len; i++) {
+              bfs(_children[i], level + 1);
+            }
+          }
+        };
+        bfs(this, 0);
+      }
+      return maxDepth;
+    }
+  };
   return __toCommonJS(src_exports);
 })();
 /**