data-structure-typed 1.46.2 → 1.46.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.46.2",
+  "version": "1.46.3",
   "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",
@@ -22,7 +22,7 @@
     "test:unit": "jest --runInBand",
     "test": "npm run test:unit",
     "test:integration": "npm run update:subs && jest --config jest.integration.config.js",
-    "test:perf": "ts-node test/performance/reportor.ts",
+    "test:perf": "npm run build:cjs && npm run build:mjs && ts-node test/performance/reportor.ts",
     "check": "tsc --noEmit",
     "check:circular-refs": "dependency-cruiser src",
     "lint:src": "eslint --fix 'src/**/*.{js,ts}'",
@@ -32,6 +32,7 @@
     "format:src": "prettier --write 'src/**/*.{js,ts}'",
     "format:test": "prettier --write 'test/**/*.{js,ts}'",
     "format": "npm run format:src && npm run format:test",
+    "check:exist-latest": "sh scripts/check_exist_remotely.sh",
     "ci": "env && git fetch --tags && npm run inspect && npm run lint && npm run build && npm run test:unit && npm run changelog",
     "update:subs": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed data-structure-typed --save-dev",
     "install:all-subs": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multimap-typed trie-typed undirected-graph-typed queue-typed --save-dev",
@@ -40,7 +41,7 @@
     "copy:to-subs": "sh scripts/copy_to_all_subs.sh",
     "publish:subs": "npm run copy:to-subs && sh scripts/publish_all_subs.sh",
     "publish:docs": "sh scripts/publish_docs.sh",
-    "publish:all": "npm run ci && npm publish && npm run publish:docs && npm view data-structure-typed@ && npm run publish:subs"
+    "publish:all": "npm run ci && npm publish && npm run publish:docs && npm run check:exist-latest && npm run publish:subs"
   },
   "repository": {
     "type": "git",

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

@@ -6,127 +6,8 @@
  * @license MIT License
  */
 
-import { isObjOrFunc, rangeCheck, throwRangeError } from '../../utils';
-import { HashMapLinkedNode, IterableWithSizeOrLength, IterateDirection } from '../../types';
-
-/**
- * Because the implementation of HashMap relies on JavaScript's built-in objects and arrays,
- * these underlying structures have already dealt with dynamic expansion and hash collisions.
- * Therefore, there is no need for additional logic to handle these issues.
- */
-export class HashMapIterator<K, V> {
-  readonly hashMap: HashMap<K, V>;
-  readonly iterateDirection: IterateDirection;
-  protected _node: HashMapLinkedNode<K, V>;
-  protected readonly _sentinel: HashMapLinkedNode<K, V>;
-
-  /**
-   * This is a constructor function for a linked list iterator in a HashMap data structure.
-   * @param node - The `node` parameter is a reference to a `HashMapLinkedNode` object. This object
-   * represents a node in a linked list used in a hash map data structure. It contains a key-value pair
-   * and references to the previous and next nodes in the linked list.
-   * @param sentinel - The `sentinel` parameter is a reference to a special node in a linked list. It
-   * is used to mark the beginning or end of the list and is typically used in data structures like
-   * hash maps or linked lists to simplify operations and boundary checks.
-   * @param hashMap - A HashMap object that stores key-value pairs.
-   * @param {IterateDirection} iterateDirection - The `iterateDirection` parameter is an optional
-   * parameter that specifies the direction in which the iterator should iterate over the elements of
-   * the HashMap. It can take one of the following values:
-   * @returns The constructor does not return anything. It is used to initialize the properties and
-   * methods of the object being created.
-   */
-  constructor(
-    node: HashMapLinkedNode<K, V>,
-    sentinel: HashMapLinkedNode<K, V>,
-    hashMap: HashMap<K, V>,
-    iterateDirection: IterateDirection = IterateDirection.DEFAULT
-  ) {
-    this._node = node;
-    this._sentinel = sentinel;
-    this.iterateDirection = iterateDirection;
-
-    if (this.iterateDirection === IterateDirection.DEFAULT) {
-      this.prev = function () {
-        if (this._node.prev === this._sentinel) {
-          throwRangeError();
-        }
-        this._node = this._node.prev;
-        return this;
-      };
-      this.next = function () {
-        if (this._node === this._sentinel) {
-          throwRangeError();
-        }
-        this._node = this._node.next;
-        return this;
-      };
-    } else {
-      this.prev = function () {
-        if (this._node.next === this._sentinel) {
-          throwRangeError();
-        }
-        this._node = this._node.next;
-        return this;
-      };
-      this.next = function () {
-        if (this._node === this._sentinel) {
-          throwRangeError();
-        }
-        this._node = this._node.prev;
-        return this;
-      };
-    }
-    this.hashMap = hashMap;
-  }
-
-  /**
-   * The above function returns a Proxy object that allows access to the key and value of a node in a
-   * data structure.
-   * @returns The code is returning a Proxy object.
-   */
-  get current() {
-    if (this._node === this._sentinel) {
-      throwRangeError();
-    }
-
-    return new Proxy(<[K, V]>(<unknown>[]), {
-      get: (target, prop: '0' | '1') => {
-        if (prop === '0') return this._node.key;
-        else if (prop === '1') return this._node.value;
-        target[0] = this._node.key;
-        target[1] = this._node.value;
-        return target[prop];
-      },
-      set: (_, prop: '1', newValue: V) => {
-        if (prop !== '1') {
-          throw new TypeError(`prop should be string '1'`);
-        }
-        this._node.value = newValue;
-        return true;
-      }
-    });
-  }
-
-  /**
-   * The function checks if a node is accessible.
-   * @returns a boolean value indicating whether the `_node` is not equal to the `_sentinel`.
-   */
-  isAccessible() {
-    return this._node !== this._sentinel;
-  }
-
-  prev() {
-    return this;
-  }
-
-  next() {
-    return this;
-  }
-
-  clone() {
-    return new HashMapIterator<K, V>(this._node, this._sentinel, this.hashMap, this.iterateDirection)
-  }
-}
+import { isObjOrFunc, rangeCheck } from '../../utils';
+import { HashMapLinkedNode, IterableWithSizeOrLength } from '../../types';
 
 export class HashMap<K = any, V = any> {
   readonly OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
@@ -158,53 +39,6 @@ export class HashMap<K = any, V = any> {
     return this._size;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns a new iterator object for a HashMap.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get begin() {
-    return new HashMapIterator<K, V>(this._head, this._sentinel, this);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns a new HashMapIterator object with the _sentinel value as both the start and
-   * end values.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get end() {
-    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
-   * a HashMap in reverse order.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get reverseBegin() {
-    return new HashMapIterator<K, V>(this._tail, this._sentinel, this, IterateDirection.REVERSE);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
-   * HashMap in reverse order.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get reverseEnd() {
-    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this, IterateDirection.REVERSE);
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -231,6 +65,29 @@ export class HashMap<K = any, V = any> {
     return <[K, V]>[this._tail.key, this._tail.value];
   }
 
+  /**
+   * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
+   */
+  * begin() {
+    let node = this._head;
+    while (node !== this._sentinel) {
+      yield [node.key, node.value];
+      node = node.next;
+    }
+  }
+
+  /**
+   * The function `reverseBegin()` iterates over a linked list in reverse order, yielding each node's
+   * key and value.
+   */
+  * reverseBegin() {
+    let node = this._tail;
+    while (node !== this._sentinel) {
+      yield [node.key, node.value];
+      node = node.prev;
+    }
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -332,34 +189,6 @@ export class HashMap<K = any, V = any> {
     return <[K, V]>[node.key, node.value];
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `getIterator` returns a new instance of `HashMapIterator` based on the provided key
-   * and whether it is an object key or not.
-   * @param {K} key - The `key` parameter is the key used to retrieve the iterator from the HashMap. It
-   * can be of any type, depending on how the HashMap is implemented.
-   * @param {boolean} [isObjectKey] - The `isObjectKey` parameter is an optional boolean parameter that
-   * indicates whether the `key` parameter is an object key. If `isObjectKey` is `true`, it means that
-   * the `key` parameter is an object and needs to be handled differently. If `isObjectKey` is `false`
-   * @returns a new instance of the `HashMapIterator` class.
-   */
-  getIterator(key: K, isObjectKey?: boolean) {
-    let node: HashMapLinkedNode<K, V>;
-    if (isObjectKey) {
-      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
-      if (index === undefined) {
-        node = this._sentinel;
-      } else {
-        node = this._nodes[index];
-      }
-    } else {
-      node = this._orgMap[<string>(<unknown>key)] || this._sentinel;
-    }
-    return new HashMapIterator<K, V>(node, this._sentinel, this);
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

package/src/data-structures/queue/deque.ts

@@ -7,8 +7,8 @@
  */
 
 
-import { IterableWithSizeOrLength, IterateDirection } from "../../types";
-import { calcMinUnitsRequired, rangeCheck, throwRangeError } from "../../utils";
+import { IterableWithSizeOrLength } from "../../types";
+import { calcMinUnitsRequired, rangeCheck } from "../../utils";
 
 /**
  * Deque can provide random access with O(1) time complexity
@@ -17,89 +17,6 @@ import { calcMinUnitsRequired, rangeCheck, throwRangeError } from "../../utils";
  * Deque is implemented using a dynamic array. Inserting or deleting beyond both ends of the array may require moving elements or reallocating space.
  */
 
-export class DequeIterator<E> {
-  iterateDirection: IterateDirection;
-
-  index: number;
-  readonly deque: Deque<E>;
-
-  /**
-   * The constructor initializes the index, iterate direction, and prev/next functions for a
-   * DequeIterator object.
-   * @param {number} index - The index parameter represents the current index position of the iterator
-   * within the deque. It is a number that indicates the position of the element that the iterator is
-   * currently pointing to.
-   * @param deque - The `deque` parameter is an instance of the `Deque` class. It represents a
-   * double-ended queue data structure, which allows elements to be added or removed from both ends.
-   * @param iterateDirection - The `iterateDirection` parameter is an optional parameter that specifies
-   * the direction in which the iterator should iterate over the elements of the `deque`. It has a
-   * default value of `IterateDirection.DEFAULT`.
-   * @returns The constructor is not returning anything. It is used to initialize the properties of the
-   * object being created.
-   */
-  constructor(index: number, deque: Deque<E>, iterateDirection = IterateDirection.DEFAULT) {
-    this.index = index;
-    this.iterateDirection = iterateDirection;
-    if (this.iterateDirection === IterateDirection.DEFAULT) {
-      this.prev = function () {
-        if (this.index === 0) {
-          throwRangeError();
-        }
-        this.index -= 1;
-        return this;
-      };
-      this.next = function () {
-        if (this.index === this.deque.size) {
-          throwRangeError();
-        }
-        this.index += 1;
-        return this;
-      };
-    } else {
-      this.prev = function () {
-        if (this.index === this.deque.size - 1) {
-          throwRangeError();
-        }
-        this.index += 1;
-        return this;
-      };
-      this.next = function () {
-        if (this.index === -1) {
-          throwRangeError();
-        }
-        this.index -= 1;
-        return this;
-      };
-    }
-    this.deque = deque;
-  }
-
-  get current() {
-    return this.deque.getAt(this.index);
-  }
-
-  set current(newElement: E) {
-    this.deque.setAt(this.index, newElement);
-  }
-
-  isAccessible() {
-    return this.index !== this.deque.size;
-  }
-
-  prev(): DequeIterator<E> {
-    return this;
-  }
-
-  next(): DequeIterator<E> {
-    return this;
-  }
-
-  clone() {
-    return new DequeIterator<E>(this.index, this.deque, this.iterateDirection);
-  }
-
-}
-
 export class Deque<E> {
   protected _bucketFirst = 0;
   protected _firstInBucket = 0;
@@ -123,7 +40,7 @@ export class Deque<E> {
     if ('length' in elements) {
       if (elements.length instanceof Function) _size = elements.length(); else _size = elements.length;
     } else {
-      if (elements.size instanceof Function) _size = elements.size();else _size = elements.size;
+      if (elements.size instanceof Function) _size = elements.size(); else _size = elements.size;
     }
 
     this._bucketSize = bucketSize;
@@ -245,38 +162,26 @@ export class Deque<E> {
   }
 
   /**
-   * The `begin()` function returns a new iterator for a deque starting from the first element.
-   * @returns A new instance of the DequeIterator class is being returned.
-   */
-  begin() {
-    return new DequeIterator<E>(0, this);
-  }
-
-  /**
-   * The `end()` function returns a new `DequeIterator` object with the size and reference to the
-   * current deque.
-   * @returns A new instance of the DequeIterator class is being returned.
+   * The below function is a generator that yields elements from a collection one by one.
    */
-  end() {
-    return new DequeIterator<E>(this.size, this);
-  }
-
-  /**
-   * The reverseBegin function returns a new DequeIterator object that starts at the last element of
-   * the deque and iterates in reverse direction.
-   * @returns A new instance of the DequeIterator class is being returned.
-   */
-  reverseBegin() {
-    return new DequeIterator<E>(this.size - 1, this, IterateDirection.REVERSE);
+  * begin(): Generator<E> {
+    let index = 0;
+    while (index < this.size) {
+      yield this.getAt(index);
+      index++;
+    }
   }
 
   /**
-   * The reverseEnd() function returns a new DequeIterator object that iterates over the elements of a
-   * Deque in reverse order.
-   * @returns A new instance of the DequeIterator class is being returned.
+   * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
+   * the last element.
    */
-  reverseEnd() {
-    return new DequeIterator<E>(-1, this, IterateDirection.REVERSE);
+  * reverseBegin(): Generator<E> {
+    let index = this.size - 1;
+    while (index >= 0) {
+      yield this.getAt(index);
+      index--;
+    }
   }
 
   /**
@@ -431,7 +336,7 @@ export class Deque<E> {
    * @returns The element at the specified position in the data structure is being returned.
    */
   getAt(pos: number): E {
-    rangeCheck!(pos, 0, this.size - 1);
+    rangeCheck(pos, 0, this.size - 1);
     const {
       bucketIndex,
       indexInBucket
@@ -456,7 +361,7 @@ export class Deque<E> {
    * position in the data structure.
    */
   setAt(pos: number, element: E) {
-    rangeCheck!(pos, 0, this.size - 1);
+    rangeCheck(pos, 0, this.size - 1);
     const {
       bucketIndex,
       indexInBucket
@@ -486,7 +391,7 @@ export class Deque<E> {
    */
   insertAt(pos: number, element: E, num = 1) {
     const length = this.size;
-    rangeCheck!(pos, 0, length);
+    rangeCheck(pos, 0, length);
     if (pos === 0) {
       while (num--) this.unshift(element);
     } else if (pos === this.size) {
@@ -550,7 +455,7 @@ export class Deque<E> {
    * @returns The size of the data structure after the deletion operation is performed.
    */
   deleteAt(pos: number) {
-    rangeCheck!(pos, 0, this.size - 1);
+    rangeCheck(pos, 0, this.size - 1);
     if (pos === 0) this.shift();
     else if (pos === this.size - 1) this.pop();
     else {
@@ -605,50 +510,6 @@ export class Deque<E> {
     return this.size;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function deletes an element from a deque using an iterator and returns the next iterator.
-   * @param iter - The parameter `iter` is of type `DequeIterator<E>`. It represents an iterator object
-   * that is used to iterate over elements in a deque (double-ended queue).
-   * @returns the updated iterator after deleting an element from the deque.
-   */
-  deleteByIterator(iter: DequeIterator<E>) {
-    const index = iter.index;
-    this.deleteAt(index);
-    iter = iter.next();
-    return iter;
-  }
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function `findIterator` searches for an element in a deque and returns an iterator pointing to
-   * the element if found, otherwise it returns an iterator pointing to the end of the deque.
-   * @param {E} element - The `element` parameter is the element that you want to find in the deque.
-   * @returns The method `findIterator(element: E)` returns a `DequeIterator<E>` object.
-   */
-  findIterator(element: E) {
-    for (let i = 0; i < this.size; ++i) {
-      if (this.getAt(i) === element) {
-        return new DequeIterator<E>(i, this);
-      }
-    }
-    return this.end();
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)

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

@@ -5,42 +5,42 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { TEN_THOUSAND } = magnitude;
+const { MILLION } = magnitude;
 
-suite.add(`${TEN_THOUSAND.toLocaleString()} set`, () => {
+suite.add(`${MILLION.toLocaleString()} set`, () => {
   const hm = new HashMap<number, number>();
 
-  for (let i = 0; i < TEN_THOUSAND; i++) {
+  for (let i = 0; i < MILLION; i++) {
     hm.set(i, i);
   }
 });
 if (isCompetitor) {
-  suite.add(`${TEN_THOUSAND.toLocaleString()} CPT set`, () => {
+  suite.add(`${MILLION.toLocaleString()} CPT set`, () => {
     const hm = new CHashMap<number, number>();
 
-    for (let i = 0; i < TEN_THOUSAND; i++) {
+    for (let i = 0; i < MILLION; i++) {
       hm.setElement(i, i);
     }
   });
 }
-suite.add(`${TEN_THOUSAND.toLocaleString()} set & get`, () => {
+suite.add(`${MILLION.toLocaleString()} set & get`, () => {
   const hm = new HashMap<number, number>();
 
-  for (let i = 0; i < TEN_THOUSAND; i++) {
+  for (let i = 0; i < MILLION; i++) {
     hm.set(i, i);
   }
-  for (let i = 0; i < TEN_THOUSAND; i++) {
+  for (let i = 0; i < MILLION; i++) {
     hm.get(i);
   }
 });
 if (isCompetitor) {
-  suite.add(`${TEN_THOUSAND.toLocaleString()} CPT set & get`, () => {
+  suite.add(`${MILLION.toLocaleString()} CPT set & get`, () => {
     const hm = new CHashMap<number, number>();
 
-    for (let i = 0; i < TEN_THOUSAND; i++) {
+    for (let i = 0; i < MILLION; i++) {
       hm.setElement(i, i);
     }
-    for (let i = 0; i < TEN_THOUSAND; i++) {
+    for (let i = 0; i < MILLION; i++) {
       hm.getElementByKey(i);
     }
   });

package/test/performance/reportor.ts

@@ -25,17 +25,20 @@ const reportDistPath = path.join(parentDirectory, 'benchmark');
 
 const testDir = path.join(__dirname, 'data-structures');
 const allFiles = fastGlob.sync(path.join(testDir, '**', '*.test.ts'));
-let testFiles: string[] = [];
+let testFiles: string[];
+
+let isIndividual = false;
 if (args.length > 0) {
   console.log(`arguments: ${args.join(' ')}`)
 
   testFiles = allFiles.filter(file =>
     args.every(word => file.includes(word))
   );
-
+  isIndividual = true;
   console.log(`${testFiles.map(file => coloredLabeled('Matched', file)).join(`
 `)}`);
 } else {
+  isIndividual = false;
   testFiles = allFiles;
 }
 
@@ -129,7 +132,7 @@ const composeReport = () => {
   html += `</div>
                     </body>
                   </html>`;
-  replaceMarkdownContent(
+  if (!isIndividual) replaceMarkdownContent(
     '[//]: # (No deletion!!! Start of Replace Section)', // Start tag
     '[//]: # (No deletion!!! End of Replace Section)', // end identifier
     htmlTables // New content to be inserted

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

@@ -172,15 +172,14 @@ describe('HashMap', () => {
     stdMap.forEach((value, key) => {
       if (index === 0) {
         expect(hashMap.first).toEqual([key, value]);
-        expect(hashMap.begin.current[0]).toEqual(key);
+        expect(hashMap.begin().next().value).toEqual([key, value]);
       } else if (index === hashMap.size - 1) {
         expect(hashMap.last).toEqual([key, value]);
-        expect(hashMap.reverseBegin.current[0]).toEqual(key);
+        expect(hashMap.reverseBegin().next().value).toEqual([key, value]);
       } else if (index <= 1000) {
         expect(hashMap.getAt(index)).toEqual([key, value]);
       }
       expect(hashMap.get(key)).toEqual(value);
-      expect(hashMap.getIterator(key).current[1]).toEqual(value);
       index++;
     });
   }
@@ -210,8 +209,8 @@ describe('HashMap', () => {
   test('should iterate correctly with reverse iterators', () => {
     hashMap.set('key1', 'value1');
     hashMap.set('key2', 'value2');
-    const iterator = hashMap.reverseBegin;
-    expect(iterator.next().current).toEqual(['key1', 'value1']);
+    const iterator = hashMap.reverseBegin();
+    expect(iterator.next().value).toEqual(['key2', 'value2']);
   });
 
   test('should return the last element', () => {

package/test/unit/data-structures/queue/deque.test.ts

@@ -419,4 +419,32 @@ describe('Deque', () => {
     expect(deque.indexOf(2)).toBe(1);
     expect(deque.indexOf(4)).toBe(-1);
   });
+
+
+  //Test begin method
+  describe('begin()', () => {
+    it('should return an iterator at the beginning of the deque', () => {
+      deque.push(1);
+      deque.push(2);
+      deque.push(3);
+
+      const iterator = deque.begin();
+
+      expect(iterator.next().value).toBe(1);
+    });
+  });
+
+  // Test the reverse Begin method
+  describe('reverseBegin()', () => {
+    it('should return a reverse iterator at the beginning of the deque', () => {
+      deque.push(1);
+      deque.push(2);
+      deque.push(3);
+
+      const iterator = deque.reverseBegin();
+
+      expect(iterator.next().value).toBe(3);
+    });
+  });
+
 });