data-structure-typed 1.39.6 → 1.40.0

package/dist/mjs/data-structures/hash/coordinate-set.js

@@ -48,8 +48,5 @@ class CoordinateSet extends Set {
     delete(value) {
         return super.delete(value.join(this._joint));
     }
-    _setJoint(v) {
-        this._joint = v;
-    }
 }
 exports.CoordinateSet = CoordinateSet;

package/dist/mjs/data-structures/hash/hash-map.d.ts

@@ -20,24 +20,18 @@ export declare class HashMap<K, V> {
      * default hash function converts the key to a string, calculates the sum of the
      */
     constructor(initialCapacity?: number, loadFactor?: number, hashFn?: HashFunction<K>);
-    private _initialCapacity;
+    protected _initialCapacity: number;
     get initialCapacity(): number;
-    set initialCapacity(value: number);
-    private _loadFactor;
+    protected _loadFactor: number;
     get loadFactor(): number;
-    set loadFactor(value: number);
-    private _capacityMultiplier;
+    protected _capacityMultiplier: number;
     get capacityMultiplier(): number;
-    set capacityMultiplier(value: number);
-    private _size;
+    protected _size: number;
     get size(): number;
-    set size(value: number);
-    private _table;
+    protected _table: Array<Array<[K, V]>>;
     get table(): Array<Array<[K, V]>>;
-    set table(value: Array<Array<[K, V]>>);
-    private _hashFn;
+    protected _hashFn: HashFunction<K>;
     get hashFn(): HashFunction<K>;
-    set hashFn(value: HashFunction<K>);
     set(key: K, value: V): void;
     get(key: K): V | undefined;
     delete(key: K): void;
@@ -45,12 +39,12 @@ export declare class HashMap<K, V> {
     [Symbol.iterator](): IterableIterator<[K, V]>;
     clear(): void;
     isEmpty(): boolean;
-    private _hash;
+    protected _hash(key: K): number;
     /**
      * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
      * rehashing the key-value pairs from the old table into the new table.
      * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
      * the number of buckets that the new table should have.
      */
-    private resizeTable;
+    protected resizeTable(newCapacity: number): void;
 }

package/dist/mjs/data-structures/hash/hash-map.js

@@ -42,44 +42,26 @@ class HashMap {
     get initialCapacity() {
         return this._initialCapacity;
     }
-    set initialCapacity(value) {
-        this._initialCapacity = value;
-    }
     _loadFactor;
     get loadFactor() {
         return this._loadFactor;
     }
-    set loadFactor(value) {
-        this._loadFactor = value;
-    }
     _capacityMultiplier;
     get capacityMultiplier() {
         return this._capacityMultiplier;
     }
-    set capacityMultiplier(value) {
-        this._capacityMultiplier = value;
-    }
     _size;
     get size() {
         return this._size;
     }
-    set size(value) {
-        this._size = value;
-    }
     _table;
     get table() {
         return this._table;
     }
-    set table(value) {
-        this._table = value;
-    }
     _hashFn;
     get hashFn() {
         return this._hashFn;
     }
-    set hashFn(value) {
-        this._hashFn = value;
-    }
     set(key, value) {
         const loadFactor = this.size / this.table.length;
         if (loadFactor >= this.loadFactor) {
@@ -97,7 +79,7 @@ class HashMap {
             }
         }
         this.table[index].push([key, value]);
-        this.size++;
+        this._size++;
     }
     get(key) {
         const index = this._hash(key);
@@ -119,7 +101,7 @@ class HashMap {
         for (let i = 0; i < this.table[index].length; i++) {
             if (this.table[index][i][0] === key) {
                 this.table[index].splice(i, 1);
-                this.size--;
+                this._size--;
                 // Check if the table needs to be resized down
                 const loadFactor = this.size / this.table.length;
                 if (loadFactor < this.loadFactor / this.capacityMultiplier) {
@@ -142,8 +124,8 @@ class HashMap {
         return this.entries();
     }
     clear() {
-        this.size = 0;
-        this.table = new Array(this.initialCapacity);
+        this._size = 0;
+        this._table = new Array(this.initialCapacity);
     }
     isEmpty() {
         return this.size === 0;

package/dist/mjs/data-structures/hash/hash-table.d.ts

@@ -13,20 +13,17 @@ export declare class HashTableNode<K, V> {
 }
 import { HashFunction } from '../../types';
 export declare class HashTable<K, V> {
-    private static readonly DEFAULT_CAPACITY;
-    private static readonly LOAD_FACTOR;
+    protected static readonly DEFAULT_CAPACITY = 16;
+    protected static readonly LOAD_FACTOR = 0.75;
     constructor(capacity?: number, hashFn?: HashFunction<K>);
-    private _capacity;
+    protected _capacity: number;
     get capacity(): number;
-    set capacity(value: number);
-    private _size;
+    protected _size: number;
     get size(): number;
-    private _buckets;
+    protected _buckets: Array<HashTableNode<K, V> | null>;
     get buckets(): Array<HashTableNode<K, V> | null>;
-    set buckets(value: Array<HashTableNode<K, V> | null>);
-    private _hashFn;
+    protected _hashFn: HashFunction<K>;
     get hashFn(): HashFunction<K>;
-    set hashFn(value: HashFunction<K>);
     /**
      * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
      * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash

package/dist/mjs/data-structures/hash/hash-table.js

@@ -32,9 +32,6 @@ class HashTable {
     get capacity() {
         return this._capacity;
     }
-    set capacity(value) {
-        this._capacity = value;
-    }
     _size;
     get size() {
         return this._size;
@@ -43,16 +40,10 @@ class HashTable {
     get buckets() {
         return this._buckets;
     }
-    set buckets(value) {
-        this._buckets = value;
-    }
     _hashFn;
     get hashFn() {
         return this._hashFn;
     }
-    set hashFn(value) {
-        this._hashFn = value;
-    }
     /**
      * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
      * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash

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

@@ -6,12 +6,14 @@
  */
 import type { Comparator, DFSOrderPattern } from '../../types';
 export declare class Heap<E = any> {
-    protected nodes: E[];
-    protected readonly comparator: Comparator<E>;
     constructor(options: {
         comparator: Comparator<E>;
         nodes?: E[];
     });
+    protected _nodes: E[];
+    get nodes(): E[];
+    protected _comparator: Comparator<E>;
+    get comparator(): Comparator<E>;
     /**
      * Get the size (number of elements) of the heap.
      */
@@ -123,11 +125,15 @@ export declare class FibonacciHeapNode<E> {
     constructor(element: E, degree?: number);
 }
 export declare class FibonacciHeap<E> {
-    root?: FibonacciHeapNode<E>;
-    size: number;
-    protected min?: FibonacciHeapNode<E>;
-    protected readonly comparator: Comparator<E>;
     constructor(comparator?: Comparator<E>);
+    protected _root?: FibonacciHeapNode<E>;
+    get root(): FibonacciHeapNode<E> | undefined;
+    protected _size: number;
+    get size(): number;
+    protected _min?: FibonacciHeapNode<E>;
+    get min(): FibonacciHeapNode<E> | undefined;
+    protected _comparator: Comparator<E>;
+    get comparator(): Comparator<E>;
     /**
      * Get the size (number of elements) of the heap.
      * @returns {number} The size of the heap.  Returns 0 if the heap is empty. Returns -1 if the heap is invalid.

package/dist/mjs/data-structures/heap/heap.js

@@ -8,15 +8,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FibonacciHeap = exports.FibonacciHeapNode = exports.Heap = void 0;
 class Heap {
-    nodes = [];
-    comparator;
     constructor(options) {
-        this.comparator = options.comparator;
+        this._comparator = options.comparator;
         if (options.nodes && options.nodes.length > 0) {
-            this.nodes = options.nodes;
+            this._nodes = options.nodes;
             this.fix();
         }
     }
+    _nodes = [];
+    get nodes() {
+        return this._nodes;
+    }
+    _comparator;
+    get comparator() {
+        return this._comparator;
+    }
     /**
      * Get the size (number of elements) of the heap.
      */
@@ -98,14 +104,14 @@ class Heap {
      * Reset the nodes of the heap. Make the nodes empty.
      */
     clear() {
-        this.nodes = [];
+        this._nodes = [];
     }
     /**
      * Clear and add nodes of the heap
      * @param nodes
      */
     refill(nodes) {
-        this.nodes = nodes;
+        this._nodes = nodes;
         this.fix();
     }
     /**
@@ -162,7 +168,7 @@ class Heap {
      */
     clone() {
         const clonedHeap = new Heap({ comparator: this.comparator });
-        clonedHeap.nodes = [...this.nodes];
+        clonedHeap._nodes = [...this.nodes];
         return clonedHeap;
     }
     /**
@@ -245,25 +251,37 @@ class FibonacciHeapNode {
 }
 exports.FibonacciHeapNode = FibonacciHeapNode;
 class FibonacciHeap {
-    root;
-    size = 0;
-    min;
-    comparator;
     constructor(comparator) {
         this.clear();
-        this.comparator = comparator || this.defaultComparator;
+        this._comparator = comparator || this.defaultComparator;
         if (typeof this.comparator !== 'function') {
             throw new Error('FibonacciHeap constructor: given comparator should be a function.');
         }
     }
+    _root;
+    get root() {
+        return this._root;
+    }
+    _size = 0;
+    get size() {
+        return this._size;
+    }
+    _min;
+    get min() {
+        return this._min;
+    }
+    _comparator;
+    get comparator() {
+        return this._comparator;
+    }
     /**
      * Get the size (number of elements) of the heap.
      * @returns {number} The size of the heap.  Returns 0 if the heap is empty. Returns -1 if the heap is invalid.
      */
     clear() {
-        this.root = undefined;
-        this.min = undefined;
-        this.size = 0;
+        this._root = undefined;
+        this._min = undefined;
+        this._size = 0;
     }
     /**
      * O(1) time operation.
@@ -286,9 +304,9 @@ class FibonacciHeap {
         node.right = node;
         this.mergeWithRoot(node);
         if (!this.min || this.comparator(node.element, this.min.element) <= 0) {
-            this.min = node;
+            this._min = node;
         }
-        this.size++;
+        this._size++;
         return this;
     }
     /**
@@ -368,14 +386,14 @@ class FibonacciHeap {
         }
         this.removeFromRoot(z);
         if (z === z.right) {
-            this.min = undefined;
-            this.root = undefined;
+            this._min = undefined;
+            this._root = undefined;
         }
         else {
-            this.min = z.right;
+            this._min = z.right;
             this.consolidate();
         }
-        this.size--;
+        this._size--;
         return z.element;
     }
     /**
@@ -400,10 +418,10 @@ class FibonacciHeap {
         }
         // Update the minimum node
         if (!this.min || (heapToMerge.min && this.comparator(heapToMerge.min.element, this.min.element) < 0)) {
-            this.min = heapToMerge.min;
+            this._min = heapToMerge.min;
         }
         // Update the size
-        this.size += heapToMerge.size;
+        this._size += heapToMerge.size;
         // Clear the heap that was merged
         heapToMerge.clear();
     }
@@ -434,7 +452,7 @@ class FibonacciHeap {
      */
     mergeWithRoot(node) {
         if (!this.root) {
-            this.root = node;
+            this._root = node;
         }
         else {
             node.right = this.root.right;
@@ -451,7 +469,7 @@ class FibonacciHeap {
      */
     removeFromRoot(node) {
         if (this.root === node)
-            this.root = node.right;
+            this._root = node.right;
         if (node.left)
             node.left.right = node.right;
         if (node.right)
@@ -499,7 +517,7 @@ class FibonacciHeap {
         }
         for (let i = 0; i < this.size; i++) {
             if (A[i] && this.comparator(A[i].element, this.min.element) <= 0) {
-                this.min = A[i];
+                this._min = A[i];
             }
         }
     }

package/dist/mjs/data-structures/linked-list/doubly-linked-list.d.ts

@@ -6,34 +6,26 @@
  * @license MIT License
  */
 export declare class DoublyLinkedListNode<E = any> {
+    value: E;
+    next: DoublyLinkedListNode<E> | null;
+    prev: DoublyLinkedListNode<E> | null;
     /**
      * The constructor function initializes the value, next, and previous properties of an object.
      * @param {E} value - The "value" parameter is the value that will be stored in the node. It can be of any data type, as it
      * is defined as a generic type "E".
      */
     constructor(value: E);
-    private _value;
-    get value(): E;
-    set value(value: E);
-    private _next;
-    get next(): DoublyLinkedListNode<E> | null;
-    set next(value: DoublyLinkedListNode<E> | null);
-    private _prev;
-    get prev(): DoublyLinkedListNode<E> | null;
-    set prev(value: DoublyLinkedListNode<E> | null);
 }
 export declare class DoublyLinkedList<E = any> {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
     constructor();
-    private _head;
+    protected _head: DoublyLinkedListNode<E> | null;
     get head(): DoublyLinkedListNode<E> | null;
-    set head(value: DoublyLinkedListNode<E> | null);
-    private _tail;
+    protected _tail: DoublyLinkedListNode<E> | null;
     get tail(): DoublyLinkedListNode<E> | null;
-    set tail(value: DoublyLinkedListNode<E> | null);
-    private _length;
+    protected _length: number;
     get length(): number;
     get size(): number;
     /**

package/dist/mjs/data-structures/linked-list/doubly-linked-list.js

@@ -9,36 +9,18 @@ exports.DoublyLinkedList = exports.DoublyLinkedListNode = void 0;
  * @license MIT License
  */
 class DoublyLinkedListNode {
+    value;
+    next;
+    prev;
     /**
      * The constructor function initializes the value, next, and previous properties of an object.
      * @param {E} value - The "value" parameter is the value that will be stored in the node. It can be of any data type, as it
      * is defined as a generic type "E".
      */
     constructor(value) {
-        this._value = value;
-        this._next = null;
-        this._prev = null;
-    }
-    _value;
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
-    }
-    _next;
-    get next() {
-        return this._next;
-    }
-    set next(value) {
-        this._next = value;
-    }
-    _prev;
-    get prev() {
-        return this._prev;
-    }
-    set prev(value) {
-        this._prev = value;
+        this.value = value;
+        this.next = null;
+        this.prev = null;
     }
 }
 exports.DoublyLinkedListNode = DoublyLinkedListNode;
@@ -55,16 +37,10 @@ class DoublyLinkedList {
     get head() {
         return this._head;
     }
-    set head(value) {
-        this._head = value;
-    }
     _tail;
     get tail() {
         return this._tail;
     }
-    set tail(value) {
-        this._tail = value;
-    }
     _length;
     get length() {
         return this._length;
@@ -92,13 +68,13 @@ class DoublyLinkedList {
     push(value) {
         const newNode = new DoublyLinkedListNode(value);
         if (!this.head) {
-            this.head = newNode;
-            this.tail = newNode;
+            this._head = newNode;
+            this._tail = newNode;
         }
         else {
             newNode.prev = this.tail;
             this.tail.next = newNode;
-            this.tail = newNode;
+            this._tail = newNode;
         }
         this._length++;
     }
@@ -119,11 +95,11 @@ class DoublyLinkedList {
             return undefined;
         const removedNode = this.tail;
         if (this.head === this.tail) {
-            this.head = null;
-            this.tail = null;
+            this._head = null;
+            this._tail = null;
         }
         else {
-            this.tail = removedNode.prev;
+            this._tail = removedNode.prev;
             this.tail.next = null;
         }
         this._length--;
@@ -147,11 +123,11 @@ class DoublyLinkedList {
             return undefined;
         const removedNode = this.head;
         if (this.head === this.tail) {
-            this.head = null;
-            this.tail = null;
+            this._head = null;
+            this._tail = null;
         }
         else {
-            this.head = removedNode.next;
+            this._head = removedNode.next;
             this.head.prev = null;
         }
         this._length--;
@@ -173,13 +149,13 @@ class DoublyLinkedList {
     unshift(value) {
         const newNode = new DoublyLinkedListNode(value);
         if (!this.head) {
-            this.head = newNode;
-            this.tail = newNode;
+            this._head = newNode;
+            this._tail = newNode;
         }
         else {
             newNode.next = this.head;
             this.head.prev = newNode;
-            this.head = newNode;
+            this._head = newNode;
         }
         this._length++;
     }
@@ -312,7 +288,7 @@ class DoublyLinkedList {
             newNode.next = existingNode;
             existingNode.prev = newNode;
             if (existingNode === this.head) {
-                this.head = newNode;
+                this._head = newNode;
             }
             this._length++;
             return true;
@@ -474,7 +450,7 @@ class DoublyLinkedList {
      */
     reverse() {
         let current = this.head;
-        [this.head, this.tail] = [this.tail, this.head];
+        [this._head, this._tail] = [this.tail, this.head];
         while (current) {
             const next = current.next;
             [current.prev, current.next] = [current.next, current.prev];
@@ -576,7 +552,7 @@ class DoublyLinkedList {
             newNode.prev = existingNode;
             existingNode.next = newNode;
             if (existingNode === this.tail) {
-                this.tail = newNode;
+                this._tail = newNode;
             }
             this._length++;
             return true;

package/dist/mjs/data-structures/linked-list/singly-linked-list.d.ts

@@ -6,31 +6,25 @@
  * @license MIT License
  */
 export declare class SinglyLinkedListNode<E = any> {
+    value: E;
+    next: SinglyLinkedListNode<E> | null;
     /**
      * The constructor function initializes an instance of a class with a given value and sets the next property to null.
      * @param {E} value - The "value" parameter is of type E, which means it can be any data type. It represents the value that
      * will be stored in the node of a linked list.
      */
     constructor(value: E);
-    private _value;
-    get value(): E;
-    set value(value: E);
-    private _next;
-    get next(): SinglyLinkedListNode<E> | null;
-    set next(value: SinglyLinkedListNode<E> | null);
 }
 export declare class SinglyLinkedList<E = any> {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
     constructor();
-    private _head;
+    protected _head: SinglyLinkedListNode<E> | null;
     get head(): SinglyLinkedListNode<E> | null;
-    set head(value: SinglyLinkedListNode<E> | null);
-    private _tail;
+    protected _tail: SinglyLinkedListNode<E> | null;
     get tail(): SinglyLinkedListNode<E> | null;
-    set tail(value: SinglyLinkedListNode<E> | null);
-    private _length;
+    protected _length: number;
     get length(): number;
     /**
      * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given