binary-tree-typed 2.5.0 → 2.5.1

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

@@ -784,6 +784,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Track queue length
     *  const q = new Queue<number>();
@@ -810,6 +831,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // View the front element
     *  const q = new Queue<string>(['first', 'second', 'third']);
@@ -852,6 +894,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Queue for...of iteration and isEmpty check
     *  const queue = new Queue<string>(['A', 'B', 'C', 'D']);
@@ -890,6 +953,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic Queue creation and push operation
     *  // Create a simple Queue with initial values
@@ -935,6 +1019,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Queue shift and peek operations
     *  const queue = new Queue<number>([10, 20, 30, 40]);
@@ -970,6 +1075,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove specific element
     *  const q = new Queue<number>([1, 2, 3, 2]);
@@ -998,6 +1124,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Access element by index
     *  const q = new Queue<string>(['a', 'b', 'c']);
@@ -1067,6 +1214,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all elements
     *  const q = new Queue<number>([1, 2, 3]);
@@ -1089,6 +1257,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Reclaim unused memory
     *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1134,6 +1323,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Create independent copy
     *  const q = new Queue<number>([1, 2, 3]);
@@ -1163,6 +1373,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter elements
     *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1196,6 +1427,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform elements
     *  const q = new Queue<number>([1, 2, 3]);
@@ -1676,6 +1928,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Add a single node
     *  const tree = new BinaryTree<number>();
@@ -1706,6 +1979,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic BinaryTree creation and insertion
     *  // Create a BinaryTree with entries
@@ -1788,6 +2082,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Bulk add
     *  const tree = new BinaryTree<number>();
@@ -1806,6 +2121,27 @@ 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 +2181,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Combine trees
     *  const t1 = new BinaryTree<number>([1, 2]);
@@ -1883,6 +2240,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove a node
     *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -1999,6 +2377,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get node by key
     *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'child']]);
@@ -2033,6 +2432,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Retrieve value by key
     *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'left'], [3, 'right']]);
@@ -2070,6 +2490,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all nodes
     *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2094,6 +2535,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check empty
     *  console.log(new BinaryTree().isEmpty()); // true;
@@ -2127,6 +2589,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check BST property
     *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2187,6 +2670,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get depth of a node
     *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -2224,6 +2728,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get tree height
     *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -2677,6 +3202,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Deep copy
     *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2705,6 +3251,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter nodes by condition
     *  const tree = new BinaryTree<number>([1, 2, 3, 4]);
@@ -2737,6 +3304,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform to new tree
     *  const tree = new BinaryTree<number, number>([[1, 10], [2, 20]]);
@@ -2794,6 +3382,27 @@ var binaryTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Display tree
     *  const tree = new BinaryTree<number>([1, 2, 3]);