nlptoolkit-datastructure 1.0.7 → 1.0.9

package/dist/Stack.js

@@ -1,35 +1,48 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stack = void 0;
+/**
+ * Stack is a list data structure consisting of many elements. There are two types of operations defined for the
+ * elements of the stack: Adding an element to the stack (push) and removing an element from the stack (pop). In a
+ * stack, to be popped element is always the last pushed element. Also, when an element is pushed on to the stack, it
+ * is placed on top of the stack (at the end of the list).
+ * @param T Type of the data stored in the stack node.
+ */
+class Stack {
+    list = [];
+    constructor() {
     }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports"], factory);
+    /**
+     * When we push an element on top of the stack, we only need to increase the field top by 1 and place the new
+     * element on this new position. If the stack is full before this push operation, we can not push.
+     * @param item Item to insert.
+     */
+    push(item) {
+        this.list.push(item);
     }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.Stack = void 0;
-    class Stack {
-        constructor() {
-            this.list = [];
+    /**
+     * When we remove an element from the stack (the function also returns that removed element), we need to be careful
+     * if the stack was empty or not. If the stack is not empty, the topmost element of the stack is returned and the
+     * field top is decreased by 1. If the stack is empty, the function will return null.
+     * @return The removed element
+     */
+    pop() {
+        let item = this.list.pop();
+        if (item == undefined) {
+            return null;
         }
-        push(item) {
-            this.list.push(item);
-        }
-        pop() {
-            let item = this.list.pop();
-            if (item == undefined) {
-                return null;
-            }
-            else {
-                return item;
-            }
-        }
-        isEmpty() {
-            return this.list.length == 0;
+        else {
+            return item;
         }
     }
-    exports.Stack = Stack;
-});
+    /**
+     * The function checks whether an array-implemented stack is empty or not. The function returns true if the stack is
+     * empty, false otherwise.
+     * @return True if the stack is empty, false otherwise.
+     */
+    isEmpty() {
+        return this.list.length == 0;
+    }
+}
+exports.Stack = Stack;
 //# sourceMappingURL=Stack.js.map

package/dist/Stack.js.map

@@ -1 +1 @@
-{"version":3,"file":"Stack.js","sourceRoot":"","sources":["../source/Stack.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,MAAa,KAAK;QAId;YAFQ,SAAI,GAAc,EAAE,CAAA;QAG5B,CAAC;QAEM,IAAI,CAAC,IAAO;YACf,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;QAEM,GAAG;YACN,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAA;YAC1B,IAAI,IAAI,IAAI,SAAS,EAAC;gBAClB,OAAO,IAAI,CAAA;aACd;iBAAM;gBACH,OAAO,IAAI,CAAA;aACd;QACL,CAAC;QAEM,OAAO;YACV,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,CAAA;QAChC,CAAC;KAGJ;IAzBD,sBAyBC"}
+{"version":3,"file":"Stack.js","sourceRoot":"","sources":["../source/Stack.ts"],"names":[],"mappings":";;;AAAA;;;;;;GAMG;AACH,MAAa,KAAK;IAEN,IAAI,GAAc,EAAE,CAAA;IAE5B;IACA,CAAC;IAED;;;;OAIG;IACI,IAAI,CAAC,IAAO;QACf,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;IAED;;;;;OAKG;IACI,GAAG;QACN,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAA;QAC1B,IAAI,IAAI,IAAI,SAAS,EAAC,CAAC;YACnB,OAAO,IAAI,CAAA;QACf,CAAC;aAAM,CAAC;YACJ,OAAO,IAAI,CAAA;QACf,CAAC;IACL,CAAC;IAED;;;;OAIG;IACI,OAAO;QACV,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,CAAA;IAChC,CAAC;CAGJ;AAzCD,sBAyCC"}

package/dist/heap/Heap.d.ts

@@ -1,14 +1,67 @@
+/**
+ * <p>The heap data structure is a binary tree structure consisting of N elements. It shows the basic properties of the
+ * binary tree data structure. The heap has a root node and each node of it has at most two child nodes
+ * (left and right). The root node of the tree is shown at the top, and its branches grow not to up but to down manner.
+ * </p>
+ *
+ * <p>In a heap, if the maximum element is in the root node and all nodes are smaller than its descendants, then this heap
+ * is called max-heap, if the minimum element is in the root node and all nodes are larger than its descendants, then
+ * this heap is called min-heap.</p>
+ * @param T Type of the data stored in the heap node.
+ */
 export declare class Heap<T> {
     private readonly array;
     protected comparator: (item1: T, item2: T) => number;
     private count;
     private n;
+    /**
+     * Constructor of the heap. According to the comparator, the heap could be min or max heap.
+     * @param N Maximum number of elements in the heap.
+     * @param comparator Comparator function to compare two elements.
+     */
     constructor(N: number, comparator: (item1: T, item2: T) => number);
     compare(data1: T, data2: T): number;
+    /**
+     * Checks if the heap is empty or not.
+     * @return True if the heap is empty, false otherwise.
+     */
     isEmpty(): boolean;
+    /**
+     * Swaps two heap nodes in the heap given their indexes.
+     * @param index1 Index of the first node to swap.
+     * @param index2 Index of the second node to swap.
+     */
     private swapNode;
+    /**
+     * The function percolates down from a node of the tree to restore the max-heap property. Left or right children are
+     * checked, if one of them is larger than the current element of the heap, the iteration continues. The iteration is,
+     * determining the largest one of the node's children and switching that node's value with the current node's value.
+     * We need to check if current node's left and right children exist or not. These checks are done with for the left
+     * child and with for the right child.
+     * @param no Index of the starting node to restore the max-heap property.
+     */
     protected percolateDown(no: number): void;
+    /**
+     * The function percolates up from a node of the tree to restore the max-heap property. As long as the max-heap
+     * property is corrupted, the parent and its child switch their values. We need to pay attention that, the
+     * calculated index of the parent must be a valid number. In other words, while going upper levels,we need to see
+     * that we can not go up if we are at the root of the tree.
+     * @param no Index of the starting node to restore the max-heap property.
+     */
     protected percolateUp(no: number): void;
+    /**
+     * The function will return the first element, therefore the first element is stored in the variable, and the first
+     * element of the heap is set to the last element of the heap. After that, in order to restore the max-heap
+     * property, we percolate down the tree using the function. As a last step, the number of element in the heap is
+     * decremented by one.
+     * @return The first element
+     */
     delete(): T;
+    /**
+     * The insertion of a new element to the heap, proceeds from the leaf nodes to the root node. First the new element
+     * is added to the end of the heap, then as long as the max-heap property is corrupted, the new element switches
+     * place with its parent.
+     * @param data New element to be inserted.
+     */
     insert(data: T): void;
 }

package/dist/heap/Heap.js

@@ -1,77 +1,124 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Heap = void 0;
+const HeapNode_1 = require("./HeapNode");
+/**
+ * <p>The heap data structure is a binary tree structure consisting of N elements. It shows the basic properties of the
+ * binary tree data structure. The heap has a root node and each node of it has at most two child nodes
+ * (left and right). The root node of the tree is shown at the top, and its branches grow not to up but to down manner.
+ * </p>
+ *
+ * <p>In a heap, if the maximum element is in the root node and all nodes are smaller than its descendants, then this heap
+ * is called max-heap, if the minimum element is in the root node and all nodes are larger than its descendants, then
+ * this heap is called min-heap.</p>
+ * @param T Type of the data stored in the heap node.
+ */
+class Heap {
+    array;
+    comparator;
+    count;
+    n;
+    /**
+     * Constructor of the heap. According to the comparator, the heap could be min or max heap.
+     * @param N Maximum number of elements in the heap.
+     * @param comparator Comparator function to compare two elements.
+     */
+    constructor(N, comparator) {
+        this.comparator = comparator;
+        this.array = new Array();
+        this.count = 0;
+        this.n = N;
+        for (let i = 0; i < N; i++) {
+            this.array.push();
+        }
     }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./HeapNode"], factory);
+    compare(data1, data2) {
+        return 0;
     }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.Heap = void 0;
-    const HeapNode_1 = require("./HeapNode");
-    class Heap {
-        constructor(N, comparator) {
-            this.comparator = comparator;
-            this.array = new Array();
-            this.count = 0;
-            this.n = N;
-            for (let i = 0; i < N; i++) {
-                this.array.push();
-            }
-        }
-        compare(data1, data2) {
-            return 0;
-        }
-        isEmpty() {
-            return this.count == 0;
-        }
-        swapNode(index1, index2) {
-            let tmp = this.array[index1];
-            this.array[index1] = this.array[index2];
-            this.array[index2] = tmp;
-        }
-        percolateDown(no) {
-            let left = 2 * no + 1;
-            let right = 2 * no + 2;
-            while ((left < this.count && this.compare(this.array[no].getData(), this.array[left].getData()) < 0) ||
-                (right < this.count && this.compare(this.array[no].getData(), this.array[right].getData()) < 0)) {
-                if (right >= this.count || this.compare(this.array[left].getData(), this.array[right].getData()) > 0) {
-                    this.swapNode(no, left);
-                    no = left;
-                }
-                else {
-                    this.swapNode(no, right);
-                    no = right;
-                }
-                left = 2 * no + 1;
-                right = 2 * no + 2;
+    /**
+     * Checks if the heap is empty or not.
+     * @return True if the heap is empty, false otherwise.
+     */
+    isEmpty() {
+        return this.count == 0;
+    }
+    /**
+     * Swaps two heap nodes in the heap given their indexes.
+     * @param index1 Index of the first node to swap.
+     * @param index2 Index of the second node to swap.
+     */
+    swapNode(index1, index2) {
+        let tmp = this.array[index1];
+        this.array[index1] = this.array[index2];
+        this.array[index2] = tmp;
+    }
+    /**
+     * The function percolates down from a node of the tree to restore the max-heap property. Left or right children are
+     * checked, if one of them is larger than the current element of the heap, the iteration continues. The iteration is,
+     * determining the largest one of the node's children and switching that node's value with the current node's value.
+     * We need to check if current node's left and right children exist or not. These checks are done with for the left
+     * child and with for the right child.
+     * @param no Index of the starting node to restore the max-heap property.
+     */
+    percolateDown(no) {
+        let left = 2 * no + 1;
+        let right = 2 * no + 2;
+        while ((left < this.count && this.compare(this.array[no].getData(), this.array[left].getData()) < 0) ||
+            (right < this.count && this.compare(this.array[no].getData(), this.array[right].getData()) < 0)) {
+            if (right >= this.count || this.compare(this.array[left].getData(), this.array[right].getData()) > 0) {
+                this.swapNode(no, left);
+                no = left;
             }
-        }
-        percolateUp(no) {
-            let parent = Math.floor((no - 1) / 2);
-            while (parent >= 0 && this.compare(this.array[parent].getData(), this.array[no].getData()) < 0) {
-                this.swapNode(parent, no);
-                no = parent;
-                parent = Math.floor((no - 1) / 2);
+            else {
+                this.swapNode(no, right);
+                no = right;
             }
+            left = 2 * no + 1;
+            right = 2 * no + 2;
         }
-        delete() {
-            let tmp = this.array[0];
-            this.array[0] = this.array[this.count - 1];
-            this.percolateDown(0);
-            this.count = this.count - 1;
-            return tmp.getData();
+    }
+    /**
+     * The function percolates up from a node of the tree to restore the max-heap property. As long as the max-heap
+     * property is corrupted, the parent and its child switch their values. We need to pay attention that, the
+     * calculated index of the parent must be a valid number. In other words, while going upper levels,we need to see
+     * that we can not go up if we are at the root of the tree.
+     * @param no Index of the starting node to restore the max-heap property.
+     */
+    percolateUp(no) {
+        let parent = Math.floor((no - 1) / 2);
+        while (parent >= 0 && this.compare(this.array[parent].getData(), this.array[no].getData()) < 0) {
+            this.swapNode(parent, no);
+            no = parent;
+            parent = Math.floor((no - 1) / 2);
         }
-        insert(data) {
-            if (this.count < this.n) {
-                this.count = this.count + 1;
-            }
-            this.array[this.count - 1] = new HeapNode_1.HeapNode(data);
-            this.percolateUp(this.count - 1);
+    }
+    /**
+     * The function will return the first element, therefore the first element is stored in the variable, and the first
+     * element of the heap is set to the last element of the heap. After that, in order to restore the max-heap
+     * property, we percolate down the tree using the function. As a last step, the number of element in the heap is
+     * decremented by one.
+     * @return The first element
+     */
+    delete() {
+        let tmp = this.array[0];
+        this.array[0] = this.array[this.count - 1];
+        this.percolateDown(0);
+        this.count = this.count - 1;
+        return tmp.getData();
+    }
+    /**
+     * The insertion of a new element to the heap, proceeds from the leaf nodes to the root node. First the new element
+     * is added to the end of the heap, then as long as the max-heap property is corrupted, the new element switches
+     * place with its parent.
+     * @param data New element to be inserted.
+     */
+    insert(data) {
+        if (this.count < this.n) {
+            this.count = this.count + 1;
         }
+        this.array[this.count - 1] = new HeapNode_1.HeapNode(data);
+        this.percolateUp(this.count - 1);
     }
-    exports.Heap = Heap;
-});
+}
+exports.Heap = Heap;
 //# sourceMappingURL=Heap.js.map

package/dist/heap/Heap.js.map

@@ -1 +1 @@
-{"version":3,"file":"Heap.js","sourceRoot":"","sources":["../../source/heap/Heap.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Heap.js","sourceRoot":"","sources":["../../source/heap/Heap.ts"],"names":[],"mappings":";;;AAAA,yCAAoC;AAEpC;;;;;;;;;;GAUG;AACH,MAAa,IAAI;IAEI,KAAK,CAAoB;IAChC,UAAU,CAAiC;IAC7C,KAAK,CAAQ;IACb,CAAC,CAAQ;IAEjB;;;;OAIG;IACH,YAAY,CAAS,EAAE,UAA0C;QAC7D,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,EAAe,CAAA;QACrC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAA;QACd,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;QACV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAC,CAAC;YACxB,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAA;QACrB,CAAC;IACL,CAAC;IAED,OAAO,CAAC,KAAQ,EAAE,KAAQ;QACtB,OAAO,CAAC,CAAC;IACb,CAAC;IAED;;;OAGG;IACI,OAAO;QACV,OAAO,IAAI,CAAC,KAAK,IAAI,CAAC,CAAA;IAC1B,CAAC;IAED;;;;OAIG;IACK,QAAQ,CAAC,MAAc,EAAE,MAAc;QAC3C,IAAI,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;QAC5B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;QACvC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,GAAG,CAAA;IAC5B,CAAC;IAED;;;;;;;OAOG;IACO,aAAa,CAAC,EAAU;QAC9B,IAAI,IAAI,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;QACrB,IAAI,KAAK,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;QACtB,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;YACpG,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YAC9F,IAAI,KAAK,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;gBACnG,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;gBACvB,EAAE,GAAG,IAAI,CAAA;YACb,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,CAAA;gBACxB,EAAE,GAAG,KAAK,CAAA;YACd,CAAC;YACD,IAAI,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;YACjB,KAAK,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;QACtB,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACO,WAAW,CAAC,EAAU;QAC5B,IAAI,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;QACrC,OAAO,MAAM,IAAI,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAC,CAAC;YAC5F,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,CAAA;YACzB,EAAE,GAAG,MAAM,CAAA;YACX,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;QACrC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACI,MAAM;QACT,IAAI,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QACvB,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAA;QAC1C,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAA;QACrB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,CAAC,CAAA;QAC3B,OAAO,GAAG,CAAC,OAAO,EAAE,CAAA;IACxB,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,IAAO;QACjB,IAAI,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,CAAC,CAAA;QAC/B,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,IAAI,mBAAQ,CAAI,IAAI,CAAC,CAAA;QAClD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAA;IACpC,CAAC;CAEJ;AAnHD,oBAmHC"}

package/dist/heap/HeapNode.d.ts

@@ -1,5 +1,13 @@
 export declare class HeapNode<T> {
     data: T;
+    /**
+     * Constructor of HeapNode.
+     * @param data Data to be stored in the heap node.
+     */
     constructor(data: T);
+    /**
+     * Mutator of the data field
+     * @return Data
+     */
     getData(): T;
 }

package/dist/heap/HeapNode.js

@@ -1,23 +1,22 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeapNode = void 0;
+class HeapNode {
+    data;
+    /**
+     * Constructor of HeapNode.
+     * @param data Data to be stored in the heap node.
+     */
+    constructor(data) {
+        this.data = data;
     }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports"], factory);
+    /**
+     * Mutator of the data field
+     * @return Data
+     */
+    getData() {
+        return this.data;
     }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.HeapNode = void 0;
-    class HeapNode {
-        constructor(data) {
-            this.data = data;
-        }
-        getData() {
-            return this.data;
-        }
-    }
-    exports.HeapNode = HeapNode;
-});
+}
+exports.HeapNode = HeapNode;
 //# sourceMappingURL=HeapNode.js.map

package/dist/heap/HeapNode.js.map

@@ -1 +1 @@
-{"version":3,"file":"HeapNode.js","sourceRoot":"","sources":["../../source/heap/HeapNode.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,MAAa,QAAQ;QAIjB,YAAY,IAAO;YACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QACpB,CAAC;QAEM,OAAO;YACV,OAAO,IAAI,CAAC,IAAI,CAAA;QACpB,CAAC;KAEJ;IAZD,4BAYC"}
+{"version":3,"file":"HeapNode.js","sourceRoot":"","sources":["../../source/heap/HeapNode.ts"],"names":[],"mappings":";;;AAAA,MAAa,QAAQ;IAEjB,IAAI,CAAI;IAER;;;OAGG;IACH,YAAY,IAAO;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IACpB,CAAC;IAED;;;OAGG;IACI,OAAO;QACV,OAAO,IAAI,CAAC,IAAI,CAAA;IACpB,CAAC;CAEJ;AApBD,4BAoBC"}

package/dist/heap/MaxHeap.js

@@ -1,24 +1,14 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxHeap = void 0;
+const Heap_1 = require("./Heap");
+class MaxHeap extends Heap_1.Heap {
+    constructor(N, comparator) {
+        super(N, comparator);
     }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./Heap"], factory);
+    compare(data1, data2) {
+        return this.comparator(data1, data2);
     }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.MaxHeap = void 0;
-    const Heap_1 = require("./Heap");
-    class MaxHeap extends Heap_1.Heap {
-        constructor(N, comparator) {
-            super(N, comparator);
-        }
-        compare(data1, data2) {
-            return this.comparator(data1, data2);
-        }
-    }
-    exports.MaxHeap = MaxHeap;
-});
+}
+exports.MaxHeap = MaxHeap;
 //# sourceMappingURL=MaxHeap.js.map

package/dist/heap/MaxHeap.js.map

@@ -1 +1 @@
-{"version":3,"file":"MaxHeap.js","sourceRoot":"","sources":["../../source/heap/MaxHeap.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,iCAA4B;IAG5B,MAAa,OAAW,SAAQ,WAAO;QAEnC,YAAY,CAAS,EAAE,UAA0C;YAC7D,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAA;QACxB,CAAC;QAED,OAAO,CAAC,KAAQ,EAAE,KAAQ;YACtB,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QACxC,CAAC;KAEJ;IAVD,0BAUC"}
+{"version":3,"file":"MaxHeap.js","sourceRoot":"","sources":["../../source/heap/MaxHeap.ts"],"names":[],"mappings":";;;AAAA,iCAA4B;AAE5B,MAAa,OAAW,SAAQ,WAAO;IAEnC,YAAY,CAAS,EAAE,UAA0C;QAC7D,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAA;IACxB,CAAC;IAED,OAAO,CAAC,KAAQ,EAAE,KAAQ;QACtB,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;IACxC,CAAC;CAEJ;AAVD,0BAUC"}

package/dist/heap/MinHeap.js

@@ -1,24 +1,14 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinHeap = void 0;
+const Heap_1 = require("./Heap");
+class MinHeap extends Heap_1.Heap {
+    constructor(N, comparator) {
+        super(N, comparator);
     }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./Heap"], factory);
+    compare(data1, data2) {
+        return -this.comparator(data1, data2);
     }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.MinHeap = void 0;
-    const Heap_1 = require("./Heap");
-    class MinHeap extends Heap_1.Heap {
-        constructor(N, comparator) {
-            super(N, comparator);
-        }
-        compare(data1, data2) {
-            return -this.comparator(data1, data2);
-        }
-    }
-    exports.MinHeap = MinHeap;
-});
+}
+exports.MinHeap = MinHeap;
 //# sourceMappingURL=MinHeap.js.map

package/dist/heap/MinHeap.js.map

@@ -1 +1 @@
-{"version":3,"file":"MinHeap.js","sourceRoot":"","sources":["../../source/heap/MinHeap.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,iCAA4B;IAE5B,MAAa,OAAW,SAAQ,WAAO;QAEnC,YAAY,CAAS,EAAE,UAA0C;YAC7D,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAA;QACxB,CAAC;QAED,OAAO,CAAC,KAAQ,EAAE,KAAQ;YACtB,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QACzC,CAAC;KAEJ;IAVD,0BAUC"}
+{"version":3,"file":"MinHeap.js","sourceRoot":"","sources":["../../source/heap/MinHeap.ts"],"names":[],"mappings":";;;AAAA,iCAA4B;AAE5B,MAAa,OAAW,SAAQ,WAAO;IAEnC,YAAY,CAAS,EAAE,UAA0C;QAC7D,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAA;IACxB,CAAC;IAED,OAAO,CAAC,KAAQ,EAAE,KAAQ;QACtB,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;IACzC,CAAC;CAEJ;AAVD,0BAUC"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./CounterHashMap";
+export * from "./LRUCache";
+export * from "./Stack";
+export * from "./tree/BTree";
+export * from "./tree/BTreeNode";
+export * from "./tree/AvlTree";
+export * from "./tree/AvlTreeNode";
+export * from "./tree/Tree";
+export * from "./tree/TreeNode";

package/dist/index.js

@@ -0,0 +1,26 @@
+"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("./CounterHashMap"), exports);
+__exportStar(require("./LRUCache"), exports);
+__exportStar(require("./Stack"), exports);
+__exportStar(require("./tree/BTree"), exports);
+__exportStar(require("./tree/BTreeNode"), exports);
+__exportStar(require("./tree/AvlTree"), exports);
+__exportStar(require("./tree/AvlTreeNode"), exports);
+__exportStar(require("./tree/Tree"), exports);
+__exportStar(require("./tree/TreeNode"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,mDAAgC;AAChC,6CAA0B;AAC1B,0CAAuB;AACvB,+CAA4B;AAC5B,mDAAgC;AAChC,iDAA8B;AAC9B,qDAAkC;AAClC,8CAA2B;AAC3B,kDAA+B"}