data-structure-typed 1.46.3 → 1.46.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.46.3",
+  "version": "1.46.4",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",

package/src/data-structures/hash/hash-map.ts

@@ -6,31 +6,41 @@
  * @license MIT License
  */
 
-import { isObjOrFunc, rangeCheck } from '../../utils';
-import { HashMapLinkedNode, IterableWithSizeOrLength } from '../../types';
+import { isWeakKey, rangeCheck } from '../../utils';
+import { HashMapLinkedNode, HashMapOptions } from '../../types';
 
 export class HashMap<K = any, V = any> {
-  readonly OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
-  protected _nodes: HashMapLinkedNode<K, V>[] = [];
-  protected _orgMap: Record<string, HashMapLinkedNode<K, V>> = {};
-  protected _head: HashMapLinkedNode<K, V>;
-  protected _tail: HashMapLinkedNode<K, V>;
-  protected readonly _sentinel: HashMapLinkedNode<K, V>;
+
+  protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>> = {};
+  protected _objMap = new WeakMap<WeakKey, HashMapLinkedNode<K, V | undefined>>();
+  protected _head: HashMapLinkedNode<K, V | undefined>;
+  protected _tail: HashMapLinkedNode<K, V | undefined>;
+  protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
+  protected _hashFn: (key: K) => string;
+  protected _objHashFn: (key: K) => WeakKey;
 
   /**
-   * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
-   * @param {Iterable<[K, V]>} elements - The `hashMap` parameter is an optional parameter of type `HashMapOptions<[K,
-   * V]>`. It is an array of key-value pairs, where each pair is represented as an array `[K, V]`. The
-   * `K` represents the type of the key and `V` represents the
+   * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
+   * @param options - The `options` parameter is an object that contains the `elements` property. The
+   * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
    */
-  constructor(elements: IterableWithSizeOrLength<[K, V]> = []) {
-    Object.setPrototypeOf(this._orgMap, null);
+  constructor(options: HashMapOptions<K, V> = {
+    elements: [],
+    hashFn: (key: K) => String(key),
+    objHashFn: (key: K) => (<WeakKey>key)
+  }) {
     this._sentinel = <HashMapLinkedNode<K, V>>{};
     this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
 
-    for (const el of elements) {
-      this.set(el[0], el[1]);
+    const { elements, hashFn, objHashFn } = options;
+    this._hashFn = hashFn;
+    this._objHashFn = objHashFn;
+    if (elements) {
+      for (const el of elements) {
+        this.set(el[0], el[1]);
+      }
     }
+
   }
 
   protected _size = 0;
@@ -98,50 +108,54 @@ export class HashMap<K = any, V = any> {
    * type, but typically it is a string or symbol.
    * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
    * value associated with the key being set in the data structure.
-   * @param {boolean} isObjectKey - A boolean flag indicating whether the key is an object key or not.
    * @returns the size of the data structure after the key-value pair has been set.
    */
-  set(key: K, value?: V, isObjectKey: boolean = isObjOrFunc(key)) {
-    let newTail;
-    if (isObjectKey) {
-      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
-      if (index !== undefined) {
-        this._nodes[<number>index].value = <V>value;
-        return this._size;
+  set(key: K, value?: V) {
+    let node;
+
+    if (isWeakKey(key)) {
+      // const hash = this._objHashFn(key);
+      const hash = key;
+      node = this._objMap.get(hash);
+
+      if (node) {
+        // If the node already exists, update its value
+        node.value = value;
+      } else {
+        // Create new node
+        node = { key: <K>hash, value, prev: this._tail, next: this._sentinel };
+
+        // Add new nodes to _objMap and linked list
+        this._objMap.set(hash, node);
       }
-      Object.defineProperty(key, this.OBJ_KEY_INDEX, {
-        value: this._nodes.length,
-        configurable: true
-      });
-      newTail = {
-        key: key,
-        value: <V>value,
-        prev: this._tail,
-        next: this._sentinel
-      };
-      this._nodes.push(newTail);
     } else {
-      const node = this._orgMap[<string>(<unknown>key)];
+      const hash = this._hashFn(key);
+      // Non-object keys are handled in the same way as the original implementation
+      node = this._noObjMap[hash];
       if (node) {
-        node.value = <V>value;
-        return this._size;
+        node.value = value;
+      } else {
+        this._noObjMap[hash] = node = {
+          key,
+          value,
+          prev: this._tail,
+          next: this._sentinel
+        };
       }
-      this._orgMap[<string>(<unknown>key)] = newTail = {
-        key: key,
-        value: <V>value,
-        prev: this._tail,
-        next: this._sentinel
-      };
     }
+
     if (this._size === 0) {
-      this._head = newTail;
-      this._sentinel.next = newTail;
+      this._head = node;
+      this._sentinel.next = node;
     } else {
-      this._tail.next = newTail;
+      this._tail.next = node;
     }
-    this._tail = newTail;
-    this._sentinel.prev = newTail;
-    return ++this._size;
+
+    this._tail = node;
+    this._sentinel.prev = node;
+    this._size++;
+
+    return this._size;
   }
 
   /**
@@ -152,21 +166,21 @@ export class HashMap<K = any, V = any> {
    * key directly or by using an index stored in the key object.
    * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
    * of any type, but typically it is a string or symbol.
-   * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
-   * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that
-   * `key` is an object key. If `isObjectKey` is `false`, it means that `key`
    * @returns The value associated with the given key is being returned. If the key is an object key,
    * the value is retrieved from the `_nodes` array using the index stored in the `OBJ_KEY_INDEX`
-   * property of the key. If the key is a string key, the value is retrieved from the `_orgMap` object
+   * property of the key. If the key is a string key, the value is retrieved from the `_noObjMap` object
    * using the key itself. If the key is not found, `undefined` is
    */
-  get(key: K, isObjectKey: boolean = isObjOrFunc(key)) {
-    if (isObjectKey) {
-      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
-      return index !== undefined ? this._nodes[index].value : undefined;
+  get(key: K): V | undefined {
+    if (isWeakKey(key)) {
+      const hash = this._objHashFn(key);
+      const node = this._objMap.get(hash);
+      return node ? node.value : undefined;
+    } else {
+      const hash = this._hashFn(key);
+      const node = this._noObjMap[hash];
+      return node ? node.value : undefined;
     }
-    const node = this._orgMap[<string>(<unknown>key)];
-    return node ? node.value : undefined;
   }
 
   /**
@@ -196,25 +210,37 @@ export class HashMap<K = any, V = any> {
    * The `delete` function removes a key-value pair from a map-like data structure.
    * @param {K} key - The `key` parameter is the key that you want to delete from the data structure.
    * It can be of any type, but typically it is a string or an object.
-   * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
-   * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that the
-   * `key` parameter is an object key. If `isObjectKey` is `false`, it means that the
    * @returns a boolean value. It returns `true` if the deletion was successful, and `false` if the key
    * was not found.
    */
-  delete(key: K, isObjectKey: boolean = isObjOrFunc(key)) {
+  delete(key: K) {
     let node;
-    if (isObjectKey) {
-      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
-      if (index === undefined) return false;
-      delete (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
-      node = this._nodes[index];
-      delete this._nodes[index];
+
+    if (isWeakKey(key)) {
+      const hash = this._objHashFn(key);
+      // Get nodes from WeakMap
+      node = this._objMap.get(hash);
+
+      if (!node) {
+        return false; // If the node does not exist, return false
+      }
+
+      // Remove nodes from WeakMap
+      this._objMap.delete(hash);
     } else {
-      node = this._orgMap[<string>(<unknown>key)];
-      if (node === undefined) return false;
-      delete this._orgMap[<string>(<unknown>key)];
+      const hash = this._hashFn(key);
+      // Get nodes from noObjMap
+      node = this._noObjMap[hash];
+
+      if (!node) {
+        return false; // If the node does not exist, return false
+      }
+
+      // Remove nodes from orgMap
+      delete this._noObjMap[hash];
     }
+
+    // Remove node from doubly linked list
     this._deleteNode(node);
     return true;
   }
@@ -257,13 +283,7 @@ export class HashMap<K = any, V = any> {
    * The `clear` function clears all the elements in a data structure and resets its properties.
    */
   clear() {
-    // const OBJ_KEY_INDEX = this.OBJ_KEY_INDEX;
-    // this._nodes.forEach(el => {
-    //   delete (<Record<symbol, number>><unknown>el.key)[OBJ_KEY_INDEX];
-    // });
-    this._nodes = [];
-    this._orgMap = {};
-    Object.setPrototypeOf(this._orgMap, null);
+    this._noObjMap = {};
     this._size = 0;
     this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
   }
@@ -286,6 +306,33 @@ export class HashMap<K = any, V = any> {
     }
   }
 
+  filter(predicate: (element: [K, V], map: HashMap<K, V>) => boolean): HashMap<K, V> {
+    const filteredMap = new HashMap<K, V>();
+    for (const [key, value] of this) {
+      if (predicate([key, value], this)) {
+        filteredMap.set(key, value);
+      }
+    }
+    return filteredMap;
+  }
+
+  map<NV>(callback: (element: [K, V], map: HashMap<K, V>) => NV): HashMap<K, NV> {
+    const mappedMap = new HashMap<K, NV>();
+    for (const [key, value] of this) {
+      const newValue = callback([key, value], this);
+      mappedMap.set(key, newValue);
+    }
+    return mappedMap;
+  }
+
+  reduce<A>(callback: (accumulator: A, element: [K, V], map: HashMap<K, V>) => A, initialValue: A): A {
+    let accumulator = initialValue;
+    for (const element of this) {
+      accumulator = callback(accumulator, element, this);
+    }
+    return accumulator;
+  }
+
   /**
    * Time Complexity: O(n), where n is the number of elements in the HashMap.
    * Space Complexity: O(1)
@@ -310,16 +357,19 @@ export class HashMap<K = any, V = any> {
    * represents a node in a linked list. It contains a key-value pair and references to the previous
    * and next nodes in the list.
    */
-  protected _deleteNode(node: HashMapLinkedNode<K, V>) {
+  protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>) {
     const { prev, next } = node;
     prev.next = next;
     next.prev = prev;
+
     if (node === this._head) {
       this._head = next;
     }
+
     if (node === this._tail) {
       this._tail = prev;
     }
+
     this._size -= 1;
   }
 }

package/src/data-structures/hash/index.ts

@@ -1,6 +1,2 @@
 export * from './hash-table';
-export * from './coordinate-map';
-export * from './coordinate-set';
-export * from './tree-map';
-export * from './tree-set';
 export * from './hash-map';

package/src/types/data-structures/hash/hash-map.ts

@@ -4,3 +4,9 @@ export type HashMapLinkedNode<K, V> = {
   next: HashMapLinkedNode<K, V>;
   prev: HashMapLinkedNode<K, V>;
 };
+
+export type HashMapOptions<K, V> = {
+  elements: Iterable<[K, V]>;
+  hashFn: (key: K) => string;
+  objHashFn: (key: K) => WeakKey
+}

package/src/types/data-structures/hash/index.ts

@@ -1,8 +1,4 @@
-export * from './coordinate-map';
-export * from './coordinate-set';
 export * from './hash-map';
 export * from './hash-table';
-export * from './tree-map';
-export * from './tree-set';
 
 export type HashFunction<K> = (key: K) => number;

package/src/utils/utils.ts

@@ -93,7 +93,7 @@ export const throwRangeError = (message = 'The value is off-limits.'): void => {
   throw new RangeError(message);
 };
 
-export const isObjOrFunc = (input: unknown): input is Record<string, unknown> | ((...args: any[]) => any) => {
+export const isWeakKey = (input: unknown): input is WeakKey => {
   const inputType = typeof input;
   return (inputType === 'object' && input !== null) || inputType === 'function';
 };

package/test/performance/data-structures/hash/hash-map.test.ts

@@ -14,6 +14,7 @@ suite.add(`${MILLION.toLocaleString()} set`, () => {
     hm.set(i, i);
   }
 });
+
 if (isCompetitor) {
   suite.add(`${MILLION.toLocaleString()} CPT set`, () => {
     const hm = new CHashMap<number, number>();
@@ -23,6 +24,19 @@ if (isCompetitor) {
     }
   });
 }
+
+suite.add(`${MILLION.toLocaleString()} Map set`, () => {
+  const hm = new Map<number, number>();
+
+  for (let i = 0; i < MILLION; i++) hm.set(i, i);
+});
+
+suite.add(`${MILLION.toLocaleString()} Set add`, () => {
+  const hs = new Set<number>();
+
+  for (let i = 0; i < MILLION; i++) hs.add(i);
+});
+
 suite.add(`${MILLION.toLocaleString()} set & get`, () => {
   const hm = new HashMap<number, number>();
 
@@ -33,6 +47,7 @@ suite.add(`${MILLION.toLocaleString()} set & get`, () => {
     hm.get(i);
   }
 });
+
 if (isCompetitor) {
   suite.add(`${MILLION.toLocaleString()} CPT set & get`, () => {
     const hm = new CHashMap<number, number>();
@@ -45,4 +60,64 @@ if (isCompetitor) {
     }
   });
 }
+
+suite.add(`${MILLION.toLocaleString()} Map set & get`, () => {
+  const hm = new Map<number, number>();
+
+  for (let i = 0; i < MILLION; i++) {
+    hm.set(i, i);
+  }
+  for (let i = 0; i < MILLION; i++) {
+    hm.get(i);
+  }
+});
+
+suite.add(`${MILLION.toLocaleString()} Set add & has`, () => {
+  const hs = new Set<number>();
+
+  for (let i = 0; i < MILLION; i++) hs.add(i);
+
+  for (let i = 0; i < MILLION; i++) hs.has(i);
+
+});
+
+suite.add(`${MILLION.toLocaleString()} ObjKey set & get`, () => {
+  const hm = new HashMap<[number, number], number>();
+  const objKeys:[number, number][] = [];
+  for (let i = 0; i < MILLION; i++) {
+    const obj: [number, number] = [i, i];
+    objKeys.push(obj)
+    hm.set(obj, i);
+  }
+  for (let i = 0; i < MILLION; i++) {
+    hm.get(objKeys[i]);
+  }
+});
+
+suite.add(`${MILLION.toLocaleString()} Map ObjKey set & get`, () => {
+  const hm = new Map<[number, number], number>();
+  const objs:[number, number][] = [];
+  for (let i = 0; i < MILLION; i++) {
+    const obj: [number, number] = [i, i];
+    objs.push(obj)
+    hm.set(obj, i);
+  }
+  for (let i = 0; i < MILLION; i++) {
+    hm.get(objs[i]);
+  }
+});
+
+suite.add(`${MILLION.toLocaleString()} Set ObjKey add & has`, () => {
+  const hs = new Set<[number, number]>();
+  const objs:[number, number][] = [];
+  for (let i = 0; i < MILLION; i++) {
+    const obj: [number, number] = [i, i];
+    objs.push(obj)
+    hs.add(obj);
+  }
+  for (let i = 0; i < MILLION; i++) {
+    hs.has(objs[i]);
+  }
+});
+
 export { suite };

package/test/unit/data-structures/hash/hash-map.test.ts

@@ -229,3 +229,35 @@ describe('HashMap', () => {
     expect(hashMap.getAt(1)).toEqual(['key2', 'value2']);
   });
 });
+
+describe('HashMap for coordinate object keys', () => {
+  const hashMap: HashMap<[number, number], number> = new HashMap();
+  const codObjs: [number, number][] = [];
+
+  test('set elements in hash map', () => {
+    for (let i = 0; i < 1000; i++) {
+      const codObj: [number, number] = [getRandomInt(-10000, 10000), i];
+      codObjs.push(codObj);
+      hashMap.set(codObj, i);
+    }
+  });
+
+  test('get elements in hash map', () => {
+    for (let i = 0; i < 1000; i++) {
+      const codObj = codObjs[i];
+      if (codObj) {
+        expect(hashMap.get(codObj)).toBe(i);
+      }
+    }
+  });
+
+  test('delete elements in hash map', () => {
+    for (let i = 0; i < 1000; i++) {
+      if (i === 500) expect(hashMap.size).toBe(500)
+      const codObj = codObjs[i];
+      if (codObj) hashMap.delete(codObj);
+    }
+    expect(hashMap.size).toBe(0);
+  });
+
+});

package/dist/cjs/data-structures/hash/coordinate-map.d.ts

@@ -1,44 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export declare class CoordinateMap<V> extends Map<any, V> {
-    constructor(joint?: string);
-    protected _joint: string;
-    get joint(): string;
-    /**
-     * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
-     * key array with a specified delimiter.
-     * @param {number[]} key - The parameter "key" is an array of numbers.
-     * @returns The `has` method is being overridden to return the result of calling the `has` method of the superclass
-     * (`super.has`) with the `key` array joined together using the `_joint` property.
-     */
-    has(key: number[]): boolean;
-    /**
-     * The function overrides the set method of a Map object to convert the key from an array to a string using a specified
-     * delimiter before calling the original set method.
-     * @param {number[]} key - The key parameter is an array of numbers.
-     * @param {V} value - The value parameter is the value that you want to associate with the specified key.
-     * @returns The `set` method is returning the result of calling the `set` method of the superclass
-     * (`super.set(key.join(this._joint), value)`).
-     */
-    set(key: number[], value: V): this;
-    /**
-     * The function overrides the get method to join the key array with a specified joint and then calls the super get
-     * method.
-     * @param {number[]} key - An array of numbers
-     * @returns The code is returning the value associated with the specified key in the map.
-     */
-    get(key: number[]): V | undefined;
-    /**
-     * The function overrides the delete method and joins the key array using a specified joint character before calling
-     * the super delete method.
-     * @param {number[]} key - An array of numbers that represents the key to be deleted.
-     * @returns The `delete` method is returning the result of calling the `delete` method on the superclass, with the
-     * `key` array joined together using the `_joint` property.
-     */
-    delete(key: number[]): boolean;
-}

package/dist/cjs/data-structures/hash/coordinate-map.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoordinateMap = void 0;
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-class CoordinateMap extends Map {
-    constructor(joint) {
-        super();
-        this._joint = '_';
-        if (joint !== undefined)
-            this._joint = joint;
-    }
-    get joint() {
-        return this._joint;
-    }
-    /**
-     * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
-     * key array with a specified delimiter.
-     * @param {number[]} key - The parameter "key" is an array of numbers.
-     * @returns The `has` method is being overridden to return the result of calling the `has` method of the superclass
-     * (`super.has`) with the `key` array joined together using the `_joint` property.
-     */
-    has(key) {
-        return super.has(key.join(this._joint));
-    }
-    /**
-     * The function overrides the set method of a Map object to convert the key from an array to a string using a specified
-     * delimiter before calling the original set method.
-     * @param {number[]} key - The key parameter is an array of numbers.
-     * @param {V} value - The value parameter is the value that you want to associate with the specified key.
-     * @returns The `set` method is returning the result of calling the `set` method of the superclass
-     * (`super.set(key.join(this._joint), value)`).
-     */
-    set(key, value) {
-        return super.set(key.join(this._joint), value);
-    }
-    /**
-     * The function overrides the get method to join the key array with a specified joint and then calls the super get
-     * method.
-     * @param {number[]} key - An array of numbers
-     * @returns The code is returning the value associated with the specified key in the map.
-     */
-    get(key) {
-        return super.get(key.join(this._joint));
-    }
-    /**
-     * The function overrides the delete method and joins the key array using a specified joint character before calling
-     * the super delete method.
-     * @param {number[]} key - An array of numbers that represents the key to be deleted.
-     * @returns The `delete` method is returning the result of calling the `delete` method on the superclass, with the
-     * `key` array joined together using the `_joint` property.
-     */
-    delete(key) {
-        return super.delete(key.join(this._joint));
-    }
-}
-exports.CoordinateMap = CoordinateMap;
-//# sourceMappingURL=coordinate-map.js.map

package/dist/cjs/data-structures/hash/coordinate-map.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"coordinate-map.js","sourceRoot":"","sources":["../../../../src/data-structures/hash/coordinate-map.ts"],"names":[],"mappings":";;;AAAA;;;;;;GAMG;AACH,MAAa,aAAiB,SAAQ,GAAW;IAC/C,YAAY,KAAc;QACxB,KAAK,EAAE,CAAC;QAIA,WAAM,GAAG,GAAG,CAAC;QAHrB,IAAI,KAAK,KAAK,SAAS;YAAE,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IAC/C,CAAC;IAID,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;;;;OAMG;IACM,GAAG,CAAC,GAAa;QACxB,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;;OAOG;IACM,GAAG,CAAC,GAAa,EAAE,KAAQ;QAClC,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;IACjD,CAAC;IAED;;;;;OAKG;IACM,GAAG,CAAC,GAAa;QACxB,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;OAMG;IACM,MAAM,CAAC,GAAa;QAC3B,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC7C,CAAC;CACF;AAvDD,sCAuDC"}

package/dist/cjs/data-structures/hash/coordinate-set.d.ts

@@ -1,36 +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;
-}