data-structure-typed 1.40.0-rc → 1.41.0

package/lib/data-structures/hash/coordinate-set.d.ts

@@ -1,37 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export declare class CoordinateSet extends Set<any> {
-    constructor(joint?: string);
-    protected _joint: string;
-    get joint(): string;
-    /**
-     * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
-     * joining its elements with a specified separator.
-     * @param {number[]} value - The parameter "value" is an array of numbers.
-     * @returns The overridden `has` method is returning the result of calling the `has` method of the superclass, passing
-     * in the joined value as an argument.
-     */
-    has(value: number[]): boolean;
-    /**
-     * The "add" function overrides the parent class's "add" function by joining the elements of the input array with a
-     * specified delimiter before calling the parent class's "add" function.
-     * @param {number[]} value - An array of numbers
-     * @returns The overridden `add` method is returning the result of calling the `add` method of the superclass
-     * (`super.add`) with the joined string representation of the `value` array (`value.join(this._joint)`).
-     */
-    add(value: number[]): this;
-    /**
-     * The function overrides the delete method and deletes an element from a Set by joining the elements of the input
-     * array with a specified joint and then calling the delete method of the parent class.
-     * @param {number[]} value - An array of numbers
-     * @returns The `delete` method is returning the result of calling the `delete` method of the superclass, with the
-     * `value` array joined together using the `_joint` property.
-     */
-    delete(value: number[]): boolean;
-    protected _setJoint(v: string): void;
-}

package/lib/data-structures/hash/coordinate-set.js

@@ -1,51 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export class CoordinateSet extends Set {
-    constructor(joint) {
-        super();
-        this._joint = '_';
-        if (joint !== undefined)
-            this._joint = joint;
-    }
-    get joint() {
-        return this._joint;
-    }
-    /**
-     * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
-     * joining its elements with a specified separator.
-     * @param {number[]} value - The parameter "value" is an array of numbers.
-     * @returns The overridden `has` method is returning the result of calling the `has` method of the superclass, passing
-     * in the joined value as an argument.
-     */
-    has(value) {
-        return super.has(value.join(this._joint));
-    }
-    /**
-     * The "add" function overrides the parent class's "add" function by joining the elements of the input array with a
-     * specified delimiter before calling the parent class's "add" function.
-     * @param {number[]} value - An array of numbers
-     * @returns The overridden `add` method is returning the result of calling the `add` method of the superclass
-     * (`super.add`) with the joined string representation of the `value` array (`value.join(this._joint)`).
-     */
-    add(value) {
-        return super.add(value.join(this._joint));
-    }
-    /**
-     * The function overrides the delete method and deletes an element from a Set by joining the elements of the input
-     * array with a specified joint and then calling the delete method of the parent class.
-     * @param {number[]} value - An array of numbers
-     * @returns The `delete` method is returning the result of calling the `delete` method of the superclass, with the
-     * `value` array joined together using the `_joint` property.
-     */
-    delete(value) {
-        return super.delete(value.join(this._joint));
-    }
-    _setJoint(v) {
-        this._joint = v;
-    }
-}

package/lib/data-structures/hash/hash-map.d.ts

@@ -1,56 +0,0 @@
-import { HashFunction } from '../../types';
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export declare class HashMap<K, V> {
-    get hashFn(): HashFunction<K>;
-    set hashFn(value: HashFunction<K>);
-    get table(): Array<Array<[K, V]>>;
-    set table(value: Array<Array<[K, V]>>);
-    get capacityMultiplier(): number;
-    set capacityMultiplier(value: number);
-    get loadFactor(): number;
-    set loadFactor(value: number);
-    get initialCapacity(): number;
-    set initialCapacity(value: number);
-    get size(): number;
-    set size(value: number);
-    private _initialCapacity;
-    private _loadFactor;
-    private _capacityMultiplier;
-    private _size;
-    private _table;
-    private _hashFn;
-    /**
-     * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
-     * multiplier, size, table array, and hash function.
-     * @param [initialCapacity=16] - The initial capacity is the initial size of the hash table. It determines the number of
-     * buckets or slots available for storing key-value pairs. The default value is 16.
-     * @param [loadFactor=0.75] - The load factor is a measure of how full the hash table can be before it is resized. It is
-     * a value between 0 and 1, where 1 means the hash table is completely full and 0 means it is completely empty. When the
-     * load factor is reached, the hash table will
-     * @param [hashFn] - The `hashFn` parameter is an optional parameter that represents the hash function used to calculate
-     * the index of a key in the hash table. If a custom hash function is not provided, a default hash function is used. The
-     * default hash function converts the key to a string, calculates the sum of the
-     */
-    constructor(initialCapacity?: number, loadFactor?: number, hashFn?: HashFunction<K>);
-    private _hash;
-    /**
-     * 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;
-    set(key: K, value: V): void;
-    get(key: K): V | undefined;
-    remove(key: K): void;
-    entries(): IterableIterator<[K, V]>;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-    clear(): void;
-    isEmpty(): boolean;
-}

package/lib/data-structures/hash/hash-map.js

@@ -1,167 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export class HashMap {
-    get hashFn() {
-        return this._hashFn;
-    }
-    set hashFn(value) {
-        this._hashFn = value;
-    }
-    get table() {
-        return this._table;
-    }
-    set table(value) {
-        this._table = value;
-    }
-    get capacityMultiplier() {
-        return this._capacityMultiplier;
-    }
-    set capacityMultiplier(value) {
-        this._capacityMultiplier = value;
-    }
-    get loadFactor() {
-        return this._loadFactor;
-    }
-    set loadFactor(value) {
-        this._loadFactor = value;
-    }
-    get initialCapacity() {
-        return this._initialCapacity;
-    }
-    set initialCapacity(value) {
-        this._initialCapacity = value;
-    }
-    get size() {
-        return this._size;
-    }
-    set size(value) {
-        this._size = value;
-    }
-    /**
-     * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
-     * multiplier, size, table array, and hash function.
-     * @param [initialCapacity=16] - The initial capacity is the initial size of the hash table. It determines the number of
-     * buckets or slots available for storing key-value pairs. The default value is 16.
-     * @param [loadFactor=0.75] - The load factor is a measure of how full the hash table can be before it is resized. It is
-     * a value between 0 and 1, where 1 means the hash table is completely full and 0 means it is completely empty. When the
-     * load factor is reached, the hash table will
-     * @param [hashFn] - The `hashFn` parameter is an optional parameter that represents the hash function used to calculate
-     * the index of a key in the hash table. If a custom hash function is not provided, a default hash function is used. The
-     * default hash function converts the key to a string, calculates the sum of the
-     */
-    constructor(initialCapacity = 16, loadFactor = 0.75, hashFn) {
-        this._initialCapacity = initialCapacity;
-        this._loadFactor = loadFactor;
-        this._capacityMultiplier = 2;
-        this._size = 0;
-        this._table = new Array(initialCapacity);
-        this._hashFn =
-            hashFn ||
-                ((key) => {
-                    const strKey = String(key);
-                    let hash = 0;
-                    for (let i = 0; i < strKey.length; i++) {
-                        hash += strKey.charCodeAt(i);
-                    }
-                    return hash % this.table.length;
-                });
-    }
-    _hash(key) {
-        return this._hashFn(key);
-    }
-    /**
-     * 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.
-     */
-    resizeTable(newCapacity) {
-        const newTable = new Array(newCapacity);
-        for (const bucket of this._table) {
-            // Note that this is this._table
-            if (bucket) {
-                for (const [key, value] of bucket) {
-                    const newIndex = this._hash(key) % newCapacity;
-                    if (!newTable[newIndex]) {
-                        newTable[newIndex] = [];
-                    }
-                    newTable[newIndex].push([key, value]);
-                }
-            }
-        }
-        this._table = newTable; // Again, here is this._table
-    }
-    set(key, value) {
-        const loadFactor = this.size / this.table.length;
-        if (loadFactor >= this.loadFactor) {
-            this.resizeTable(this.table.length * this.capacityMultiplier);
-        }
-        const index = this._hash(key);
-        if (!this.table[index]) {
-            this.table[index] = [];
-        }
-        // Check if the key already exists in the bucket
-        for (let i = 0; i < this.table[index].length; i++) {
-            if (this.table[index][i][0] === key) {
-                this.table[index][i][1] = value;
-                return;
-            }
-        }
-        this.table[index].push([key, value]);
-        this.size++;
-    }
-    get(key) {
-        const index = this._hash(key);
-        if (!this.table[index]) {
-            return undefined;
-        }
-        for (const [k, v] of this.table[index]) {
-            if (k === key) {
-                return v;
-            }
-        }
-        return undefined;
-    }
-    remove(key) {
-        const index = this._hash(key);
-        if (!this.table[index]) {
-            return;
-        }
-        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--;
-                // Check if the table needs to be resized down
-                const loadFactor = this.size / this.table.length;
-                if (loadFactor < this.loadFactor / this.capacityMultiplier) {
-                    this.resizeTable(this.table.length / this.capacityMultiplier);
-                }
-                return;
-            }
-        }
-    }
-    *entries() {
-        for (const bucket of this.table) {
-            if (bucket) {
-                for (const [key, value] of bucket) {
-                    yield [key, value];
-                }
-            }
-        }
-    }
-    [Symbol.iterator]() {
-        return this.entries();
-    }
-    clear() {
-        this.size = 0;
-        this.table = new Array(this.initialCapacity);
-    }
-    isEmpty() {
-        return this.size === 0;
-    }
-}

package/lib/data-structures/hash/hash-table.d.ts

@@ -1,106 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export declare class HashTableNode<K, V> {
-    key: K;
-    val: V;
-    next: HashTableNode<K, V> | null;
-    constructor(key: K, val: V);
-}
-import { HashFunction } from '../../types';
-export declare class HashTable<K, V> {
-    get hashFn(): HashFunction<K>;
-    set hashFn(value: HashFunction<K>);
-    get buckets(): Array<HashTableNode<K, V> | null>;
-    set buckets(value: Array<HashTableNode<K, V> | null>);
-    get capacity(): number;
-    set capacity(value: number);
-    private static readonly DEFAULT_CAPACITY;
-    private static readonly LOAD_FACTOR;
-    private _capacity;
-    private _size;
-    private _buckets;
-    private _hashFn;
-    constructor(capacity?: number, hashFn?: HashFunction<K>);
-    /**
-     * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
-     * capacity of the data structure.
-     * @param {K} key - The `key` parameter is the input value that needs to be hashed. It can be of any type, but in this
-     * code snippet, it is checked whether the key is a string or an object. If it is a string, the `_murmurStringHashFn`
-     * function is used to
-     * @returns the hash value of the key modulo the capacity of the data structure.
-     */
-    protected _defaultHashFn(key: K): number;
-    /**
-     * The `_multiplicativeStringHashFn` function calculates a hash value for a given string key using the multiplicative
-     * string hash function.
-     * @param {K} key - The `key` parameter is the input value for which we want to calculate the hash. It can be of any
-     * type, as it is generic (`K`). The function converts the `key` to a string using the `String()` function.
-     * @returns a number, which is the result of the multiplicative string hash function applied to the input key.
-     */
-    protected _multiplicativeStringHashFn<K>(key: K): number;
-    /**
-     * The function `_murmurStringHashFn` calculates a hash value for a given string key using the MurmurHash algorithm.
-     * @param {K} key - The `key` parameter is the input value for which you want to calculate the hash. It can be of any
-     * type, but it will be converted to a string using the `String()` function before calculating the hash.
-     * @returns a number, which is the hash value calculated for the given key.
-     */
-    protected _murmurStringHashFn<K>(key: K): number;
-    /**
-     * The _hash function takes a key and returns a number.
-     * @param {K} key - The parameter "key" is of type K, which represents the type of the key that will be hashed.
-     * @returns The hash function is returning a number.
-     */
-    protected _hash(key: K): number;
-    /**
-     * The function calculates a hash value for a given string using the djb2 algorithm.
-     * @param {string} key - The `key` parameter in the `stringHash` function is a string value that represents the input for
-     * which we want to calculate the hash value.
-     * @returns a number, which is the hash value of the input string.
-     */
-    protected _stringHash(key: string): number;
-    /**
-     * The function `_objectHash` takes a key and returns a hash value, using a custom hash function for objects.
-     * @param {K} key - The parameter "key" is of type "K", which means it can be any type. It could be a string, number,
-     * boolean, object, or any other type of value. The purpose of the objectHash function is to generate a hash value for
-     * the key, which can be used for
-     * @returns a number, which is the hash value of the key.
-     */
-    protected _objectHash(key: K): number;
-    /**
-     * 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
-     * table. It is of type K, which is a generic type representing the key's data type.
-     * @param {V} val - The parameter `val` represents the value that you want to associate with the given key in the hash
-     * table.
-     * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
-     * value.
-     */
-    set(key: K, val: V): void;
-    /**
-     * The `get` function retrieves the value associated with a given key from a hash table.
-     * @param {K} key - The `key` parameter represents the key of the element that we want to retrieve from the data
-     * structure.
-     * @returns The method is returning the value associated with the given key if it exists in the hash table. If the key is
-     * not found, it returns `undefined`.
-     */
-    get(key: K): V | undefined;
-    /**
-     * The remove function removes a key-value pair from a hash table.
-     * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
-     * table.
-     * @returns Nothing is being returned. The `remove` method has a return type of `void`, which means it does not return
-     * any value.
-     */
-    remove(key: K): void;
-    /**
-     * The `expand` function increases the capacity of a hash table by creating a new array of buckets with double the
-     * capacity and rehashing all the existing key-value pairs into the new buckets.
-     */
-    protected _expand(): void;
-    get size(): number;
-}

package/lib/data-structures/hash/hash-table.js

@@ -1,240 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export class HashTableNode {
-    constructor(key, val) {
-        this.key = key;
-        this.val = val;
-        this.next = null;
-    }
-}
-export class HashTable {
-    get hashFn() {
-        return this._hashFn;
-    }
-    set hashFn(value) {
-        this._hashFn = value;
-    }
-    get buckets() {
-        return this._buckets;
-    }
-    set buckets(value) {
-        this._buckets = value;
-    }
-    get capacity() {
-        return this._capacity;
-    }
-    set capacity(value) {
-        this._capacity = value;
-    }
-    constructor(capacity = HashTable.DEFAULT_CAPACITY, hashFn) {
-        this._hashFn = hashFn || this._defaultHashFn;
-        this._capacity = Math.max(capacity, HashTable.DEFAULT_CAPACITY);
-        this._size = 0;
-        this._buckets = new Array(this._capacity).fill(null);
-    }
-    /**
-     * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
-     * capacity of the data structure.
-     * @param {K} key - The `key` parameter is the input value that needs to be hashed. It can be of any type, but in this
-     * code snippet, it is checked whether the key is a string or an object. If it is a string, the `_murmurStringHashFn`
-     * function is used to
-     * @returns the hash value of the key modulo the capacity of the data structure.
-     */
-    _defaultHashFn(key) {
-        // Can be replaced with other hash functions as needed
-        const hashValue = typeof key === 'string' ? this._murmurStringHashFn(key) : this._objectHash(key);
-        return hashValue % this._capacity;
-    }
-    /**
-     * The `_multiplicativeStringHashFn` function calculates a hash value for a given string key using the multiplicative
-     * string hash function.
-     * @param {K} key - The `key` parameter is the input value for which we want to calculate the hash. It can be of any
-     * type, as it is generic (`K`). The function converts the `key` to a string using the `String()` function.
-     * @returns a number, which is the result of the multiplicative string hash function applied to the input key.
-     */
-    _multiplicativeStringHashFn(key) {
-        const keyString = String(key);
-        let hash = 0;
-        for (let i = 0; i < keyString.length; i++) {
-            const charCode = keyString.charCodeAt(i);
-            // Some constants for adjusting the hash function
-            const A = 0.618033988749895;
-            const M = 1 << 30; // 2^30
-            hash = (hash * A + charCode) % M;
-        }
-        return Math.abs(hash); // Take absolute value to ensure non-negative numbers
-    }
-    /**
-     * The function `_murmurStringHashFn` calculates a hash value for a given string key using the MurmurHash algorithm.
-     * @param {K} key - The `key` parameter is the input value for which you want to calculate the hash. It can be of any
-     * type, but it will be converted to a string using the `String()` function before calculating the hash.
-     * @returns a number, which is the hash value calculated for the given key.
-     */
-    _murmurStringHashFn(key) {
-        const keyString = String(key);
-        const seed = 0;
-        let hash = seed;
-        for (let i = 0; i < keyString.length; i++) {
-            const char = keyString.charCodeAt(i);
-            hash = (hash ^ char) * 0x5bd1e995;
-            hash = (hash ^ (hash >>> 15)) * 0x27d4eb2d;
-            hash = hash ^ (hash >>> 15);
-        }
-        return Math.abs(hash);
-    }
-    /**
-     * The _hash function takes a key and returns a number.
-     * @param {K} key - The parameter "key" is of type K, which represents the type of the key that will be hashed.
-     * @returns The hash function is returning a number.
-     */
-    _hash(key) {
-        return this.hashFn(key);
-    }
-    /**
-     * The function calculates a hash value for a given string using the djb2 algorithm.
-     * @param {string} key - The `key` parameter in the `stringHash` function is a string value that represents the input for
-     * which we want to calculate the hash value.
-     * @returns a number, which is the hash value of the input string.
-     */
-    _stringHash(key) {
-        let hash = 0;
-        for (let i = 0; i < key.length; i++) {
-            hash = (hash * 31 + key.charCodeAt(i)) & 0xffffffff;
-        }
-        return hash;
-    }
-    /**
-     * The function `_objectHash` takes a key and returns a hash value, using a custom hash function for objects.
-     * @param {K} key - The parameter "key" is of type "K", which means it can be any type. It could be a string, number,
-     * boolean, object, or any other type of value. The purpose of the objectHash function is to generate a hash value for
-     * the key, which can be used for
-     * @returns a number, which is the hash value of the key.
-     */
-    _objectHash(key) {
-        // If the key is an object, you can write a custom hash function
-        // For example, convert the object's properties to a string and use string hashing
-        // This is just an example; you should write a specific object hash function as needed
-        return this._stringHash(JSON.stringify(key));
-    }
-    /**
-     * 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
-     * table. It is of type K, which is a generic type representing the key's data type.
-     * @param {V} val - The parameter `val` represents the value that you want to associate with the given key in the hash
-     * table.
-     * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
-     * value.
-     */
-    set(key, val) {
-        const index = this._hash(key);
-        const newNode = new HashTableNode(key, val);
-        if (!this._buckets[index]) {
-            this._buckets[index] = newNode;
-        }
-        else {
-            // Handle collisions, consider using open addressing, etc.
-            let currentNode = this._buckets[index];
-            while (currentNode) {
-                if (currentNode.key === key) {
-                    // If the key already exists, update the value
-                    currentNode.val = val;
-                    return;
-                }
-                if (!currentNode.next) {
-                    break;
-                }
-                currentNode = currentNode.next;
-            }
-            // Add to the end of the linked list
-            currentNode.next = newNode;
-        }
-        this._size++;
-        // If the load factor is too high, resize the hash table
-        if (this._size / this._capacity >= HashTable.LOAD_FACTOR) {
-            this._expand();
-        }
-    }
-    /**
-     * The `get` function retrieves the value associated with a given key from a hash table.
-     * @param {K} key - The `key` parameter represents the key of the element that we want to retrieve from the data
-     * structure.
-     * @returns The method is returning the value associated with the given key if it exists in the hash table. If the key is
-     * not found, it returns `undefined`.
-     */
-    get(key) {
-        const index = this._hash(key);
-        let currentNode = this._buckets[index];
-        while (currentNode) {
-            if (currentNode.key === key) {
-                return currentNode.val;
-            }
-            currentNode = currentNode.next;
-        }
-        return undefined; // Key not found
-    }
-    /**
-     * The remove function removes a key-value pair from a hash table.
-     * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
-     * table.
-     * @returns Nothing is being returned. The `remove` method has a return type of `void`, which means it does not return
-     * any value.
-     */
-    remove(key) {
-        const index = this._hash(key);
-        let currentNode = this._buckets[index];
-        let prevNode = null;
-        while (currentNode) {
-            if (currentNode.key === key) {
-                if (prevNode) {
-                    prevNode.next = currentNode.next;
-                }
-                else {
-                    this._buckets[index] = currentNode.next;
-                }
-                this._size--;
-                currentNode.next = null; // Release memory
-                return;
-            }
-            prevNode = currentNode;
-            currentNode = currentNode.next;
-        }
-    }
-    /**
-     * The `expand` function increases the capacity of a hash table by creating a new array of buckets with double the
-     * capacity and rehashing all the existing key-value pairs into the new buckets.
-     */
-    _expand() {
-        const newCapacity = this._capacity * 2;
-        const newBuckets = new Array(newCapacity).fill(null);
-        for (const bucket of this._buckets) {
-            let currentNode = bucket;
-            while (currentNode) {
-                const newIndex = this._hash(currentNode.key);
-                const newNode = new HashTableNode(currentNode.key, currentNode.val);
-                if (!newBuckets[newIndex]) {
-                    newBuckets[newIndex] = newNode;
-                }
-                else {
-                    let currentNewNode = newBuckets[newIndex];
-                    while (currentNewNode.next) {
-                        currentNewNode = currentNewNode.next;
-                    }
-                    currentNewNode.next = newNode;
-                }
-                currentNode = currentNode.next;
-            }
-        }
-        this._buckets = newBuckets;
-        this._capacity = newCapacity;
-    }
-    get size() {
-        return this._size;
-    }
-}
-HashTable.DEFAULT_CAPACITY = 16;
-HashTable.LOAD_FACTOR = 0.75;

package/lib/data-structures/hash/index.d.ts

@@ -1,7 +0,0 @@
-export * from './hash-table';
-export * from './coordinate-map';
-export * from './coordinate-set';
-export * from './pair';
-export * from './tree-map';
-export * from './tree-set';
-export * from './hash-map';

package/lib/data-structures/hash/index.js

@@ -1,7 +0,0 @@
-export * from './hash-table';
-export * from './coordinate-map';
-export * from './coordinate-set';
-export * from './pair';
-export * from './tree-map';
-export * from './tree-set';
-export * from './hash-map';

package/lib/data-structures/hash/pair.d.ts

@@ -1,2 +0,0 @@
-export declare class Pair {
-}

package/lib/data-structures/hash/pair.js

@@ -1,2 +0,0 @@
-export class Pair {
-}