data-structure-typed 0.9.16 → 1.3.1

package/dist/data-structures/priority-queue/priority-queue.js

@@ -1,82 +1,93 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PriorityQueue = void 0;
-var PriorityQueue = /** @class */ (function () {
-    function PriorityQueue(options) {
-        this.nodes = [];
-        this._comparator = function (a, b) {
-            var aKey = a, bKey = b;
+class PriorityQueue {
+    /**
+     * The constructor initializes a priority queue with the given options, including an array of nodes and a comparator
+     * function.
+     * @param options - The `options` parameter is an object that contains the following properties:
+     */
+    constructor(options) {
+        this._nodes = [];
+        this._comparator = (a, b) => {
+            const aKey = a, bKey = b;
             return aKey - bKey;
         };
-        var nodes = options.nodes, comparator = options.comparator, _a = options.isFix, isFix = _a === void 0 ? true : _a;
+        const { nodes, comparator, isFix = true } = options;
         this._comparator = comparator;
-        if (nodes && nodes instanceof Array && nodes.length > 0) {
+        if (nodes && Array.isArray(nodes) && nodes.length > 0) {
             // TODO support distinct
-            this.nodes = Array.isArray(nodes) ? __spreadArray([], __read(nodes), false) : [];
+            this._nodes = [...nodes];
             isFix && this._fix();
         }
     }
-    Object.defineProperty(PriorityQueue.prototype, "size", {
-        get: function () {
-            return this.nodes.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    PriorityQueue.heapify = function (options) {
-        var heap = new PriorityQueue(options);
+    get nodes() {
+        return this._nodes;
+    }
+    get size() {
+        return this.nodes.length;
+    }
+    /**
+     * The `heapify` function creates a new PriorityQueue instance and fixes the heap property.
+     * @param options - The "options" parameter is an object that contains the configuration options for the PriorityQueue.
+     * It can include properties such as "comparator" which specifies the comparison function used to order the elements in
+     * the priority queue, and "initialValues" which is an array of initial values to be added to the priority
+     * @returns a new instance of the PriorityQueue class after performing the heapify operation on it.
+     */
+    static heapify(options) {
+        const heap = new PriorityQueue(options);
         heap._fix();
         return heap;
-    };
-    PriorityQueue.isPriorityQueueified = function (options) {
-        return new PriorityQueue(__assign(__assign({}, options), { isFix: true })).isValid();
-    };
-    PriorityQueue.prototype.offer = function (node) {
+    }
+    /**
+     * The function checks if a priority queue is valid by creating a new priority queue with a fix option and then calling
+     * the isValid method.
+     * @param options - An object containing options for creating a priority queue. The options object should have the
+     * following properties:
+     * @returns the result of calling the `isValid()` method on a new instance of the `PriorityQueue` class.
+     */
+    static isPriorityQueueified(options) {
+        return new PriorityQueue(Object.assign(Object.assign({}, options), { isFix: false })).isValid();
+    }
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getNodes() {
+        return this._nodes;
+    }
+    /**
+     * The "add" function adds a node to the heap and ensures that the heap property is maintained.
+     * @param {T} node - The parameter "node" is of type T, which means it can be any data type. It represents the node
+     * that needs to be added to the heap.
+     */
+    add(node) {
         this.nodes.push(node);
         this._heapifyUp(this.size - 1);
-    };
-    PriorityQueue.prototype.peek = function () {
+    }
+    /**
+     * The "has" function checks if a given node is present in the list of nodes.
+     * @param {T} node - The parameter `node` is of type `T`, which means it can be any type. It represents the node that
+     * we want to check if it exists in the `nodes` array.
+     * @returns a boolean value indicating whether the given node is included in the array of nodes.
+     */
+    has(node) {
+        return this.nodes.includes(node);
+    }
+    /**
+     * The `peek` function returns the first element of the `nodes` array if it exists, otherwise it returns `null`.
+     * @returns The `peek()` function is returning the first element (`T`) of the `nodes` array if the `size` is not zero.
+     * Otherwise, it returns `null`.
+     */
+    peek() {
         return this.size ? this.nodes[0] : null;
-    };
-    PriorityQueue.prototype.poll = function () {
+    }
+    /**
+     * The `poll` function removes and returns the top element from a heap data structure.
+     * @returns The `poll()` method returns a value of type `T` or `null`.
+     */
+    poll() {
         var _a, _b;
-        var res = null;
+        let res = null;
         if (this.size > 1) {
             this._swap(0, this.nodes.length - 1);
             res = (_a = this.nodes.pop()) !== null && _a !== void 0 ? _a : null;
@@ -86,105 +97,182 @@ var PriorityQueue = /** @class */ (function () {
             res = (_b = this.nodes.pop()) !== null && _b !== void 0 ? _b : null;
         }
         return res;
-    };
-    PriorityQueue.prototype.leaf = function () {
+    }
+    /**
+     * The `leaf` function returns the last element in the `nodes` array or `null` if the array is empty.
+     * @returns The method `leaf()` is returning the last element (`T`) in the `nodes` array if it exists. If the array is
+     * empty or the last element is `null`, then it returns `null`.
+     */
+    leaf() {
         var _a;
         return (_a = this.nodes[this.size - 1]) !== null && _a !== void 0 ? _a : null;
-    };
-    PriorityQueue.prototype.isEmpty = function () {
+    }
+    /**
+     * The function checks if the size of an object is equal to zero and returns a boolean value indicating whether the
+     * object is empty or not.
+     * @returns The method `isEmpty()` is returning a boolean value indicating whether the size of the object is equal to
+     * 0.
+     */
+    isEmpty() {
         return this.size === 0;
-    };
-    PriorityQueue.prototype.clear = function () {
-        this.nodes = [];
-    };
-    PriorityQueue.prototype.toArray = function () {
-        return __spreadArray([], __read(this.nodes), false);
-    };
-    PriorityQueue.prototype.clone = function () {
+    }
+    /**
+     * The clear function clears the nodes array.
+     */
+    clear() {
+        this._setNodes([]);
+    }
+    /**
+     * The toArray function returns an array containing all the elements in the nodes property.
+     * @returns An array of type T, which is the elements of the nodes property.
+     */
+    toArray() {
+        return [...this.nodes];
+    }
+    /**
+     * The `clone` function returns a new instance of the `PriorityQueue` class with the same nodes and comparator as the
+     * original instance.
+     * @returns The `clone()` method is returning a new instance of the `PriorityQueue` class with the same `nodes` and
+     * `comparator` properties as the original instance.
+     */
+    clone() {
         return new PriorityQueue({ nodes: this.nodes, comparator: this._comparator });
-    };
+    }
     // --- start additional methods ---
-    PriorityQueue.prototype.isValid = function () {
-        var _this = this;
-        var isValidRecursive = function (parentIndex) {
-            var isValidLeft = true;
-            var isValidRight = true;
-            if (_this._getLeft(parentIndex) !== -1) {
-                var leftChildIndex = (parentIndex * 2) + 1;
-                if (!_this._compare(parentIndex, leftChildIndex))
-                    return false;
-                isValidLeft = isValidRecursive(leftChildIndex);
+    /**
+     * The `isValid` function recursively checks if a binary tree satisfies a certain condition.
+     * @returns The function `isValid()` returns a boolean value.
+     */
+    isValid() {
+        for (let i = 0; i < this.nodes.length; i++) {
+            const leftChildIndex = this._getLeft(i);
+            const rightChildIndex = this._getRight(i);
+            if (this._isValidIndex(leftChildIndex) && !this._compare(leftChildIndex, i)) {
+                return false;
             }
-            if (_this._getRight(parentIndex) !== -1) {
-                var rightChildIndex = (parentIndex * 2) + 2;
-                if (!_this._compare(parentIndex, rightChildIndex))
-                    return false;
-                isValidRight = isValidRecursive(rightChildIndex);
+            if (this._isValidIndex(rightChildIndex) && !this._compare(rightChildIndex, i)) {
+                return false;
             }
-            return isValidLeft && isValidRight;
-        };
-        return isValidRecursive(0);
-    };
-    PriorityQueue.prototype.sort = function () {
-        var visitedNode = [];
+        }
+        return true;
+    }
+    /**
+     * O(n log n), In scenarios with smaller data sizes, heap sort is generally expected to be slower than QuickSort or MergeSort.
+     */
+    /**
+     * The function sorts the elements in a data structure and returns them in an array.
+     * Plan to support sorting of duplicate elements.
+     * @returns The `sort()` method is returning an array of type `T[]`.
+     */
+    sort() {
+        const visitedNode = [];
         while (this.size !== 0) {
-            var top = this.poll();
+            const top = this.poll();
             if (top)
                 visitedNode.push(top);
         }
         return visitedNode;
-    };
-    PriorityQueue.prototype.DFS = function (dfsMode) {
-        var _this = this;
-        var visitedNode = [];
-        var traverse = function (cur) {
+    }
+    /**
+     * The DFS function performs a depth-first search traversal on a binary tree and returns an array of visited nodes
+     * based on the specified traversal order.
+     * @param {PriorityQueueDFSOrderPattern} dfsMode - The dfsMode parameter is a string that specifies the order in which
+     * the nodes should be visited during the Depth-First Search (DFS) traversal. It can have one of the following values:
+     * @returns an array of type `(T | null)[]`.
+     */
+    DFS(dfsMode) {
+        const visitedNode = [];
+        const traverse = (cur) => {
             var _a, _b, _c;
-            var leftChildIndex = _this._getLeft(cur);
-            var rightChildIndex = _this._getRight(cur);
+            const leftChildIndex = this._getLeft(cur);
+            const rightChildIndex = this._getRight(cur);
             switch (dfsMode) {
                 case 'in':
-                    _this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
-                    visitedNode.push((_a = _this.nodes[cur]) !== null && _a !== void 0 ? _a : null);
-                    _this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
+                    this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
+                    visitedNode.push((_a = this.nodes[cur]) !== null && _a !== void 0 ? _a : null);
+                    this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
                     break;
                 case 'pre':
-                    visitedNode.push((_b = _this.nodes[cur]) !== null && _b !== void 0 ? _b : null);
-                    _this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
-                    _this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
+                    visitedNode.push((_b = this.nodes[cur]) !== null && _b !== void 0 ? _b : null);
+                    this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
+                    this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
                     break;
                 case 'post':
-                    _this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
-                    _this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
-                    visitedNode.push((_c = _this.nodes[cur]) !== null && _c !== void 0 ? _c : null);
+                    this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
+                    this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
+                    visitedNode.push((_c = this.nodes[cur]) !== null && _c !== void 0 ? _c : null);
                     break;
             }
         };
         this._isValidIndex(0) && traverse(0);
         return visitedNode;
-    };
-    PriorityQueue.prototype._compare = function (a, b) {
+    }
+    _setNodes(value) {
+        this._nodes = value;
+    }
+    /**
+     * The function compares two numbers using a custom comparator function.
+     * @param {number} a - The parameter "a" is a number that represents the index of a node in an array.
+     * @param {number} b - The parameter "b" is a number.
+     * @returns the result of the comparison between the elements at indices `a` and `b` in the `nodes` array. The
+     * comparison is done using the `_comparator` function, and if the result is greater than 0, `true` is returned,
+     * indicating that the element at index `a` is greater than the element at index `b`.
+     */
+    _compare(a, b) {
         return this._comparator(this.nodes[a], this.nodes[b]) > 0;
-    };
-    PriorityQueue.prototype._swap = function (a, b) {
-        var temp = this.nodes[a];
+    }
+    /**
+     * The function swaps two elements in an array.
+     * @param {number} a - The parameter "a" is a number that represents the index of an element in an array.
+     * @param {number} b - The parameter "b" is a number.
+     */
+    _swap(a, b) {
+        const temp = this.nodes[a];
         this.nodes[a] = this.nodes[b];
         this.nodes[b] = temp;
-    };
-    PriorityQueue.prototype._isValidIndex = function (index) {
+    }
+    /**
+     * The function checks if a given index is valid within an array.
+     * @param {number} index - The parameter "index" is of type number and represents the index value that needs to be
+     * checked for validity.
+     * @returns A boolean value indicating whether the given index is valid or not.
+     */
+    _isValidIndex(index) {
         return index > -1 && index < this.nodes.length;
-    };
-    PriorityQueue.prototype._getParent = function (child) {
+    }
+    /**
+     * The function returns the index of the parent node given the index of a child node in a binary tree.
+     * @param {number} child - The "child" parameter is a number representing the index of a child node in a binary tree.
+     * @returns the parent of the given child node.
+     */
+    _getParent(child) {
         return Math.floor((child - 1) / 2);
-    };
-    PriorityQueue.prototype._getLeft = function (parent) {
+    }
+    /**
+     * The function returns the index of the left child node in a binary tree given the index of its parent node.
+     * @param {number} parent - The parameter "parent" is a number that represents the index of a node in a binary tree.
+     * @returns the left child of a given parent node in a binary tree.
+     */
+    _getLeft(parent) {
         return (2 * parent) + 1;
-    };
-    PriorityQueue.prototype._getRight = function (parent) {
+    }
+    /**
+     * The function returns the index of the right child node in a binary tree given the index of its parent node.
+     * @param {number} parent - The parameter "parent" is a number that represents the index of a node in a binary tree.
+     * @returns the right child of a given parent node in a binary tree.
+     */
+    _getRight(parent) {
         return (2 * parent) + 2;
-    };
-    PriorityQueue.prototype._getComparedChild = function (parent) {
-        var min = parent;
-        var left = this._getLeft(parent), right = this._getRight(parent);
+    }
+    /**
+     * The function returns the index of the smallest child node of a given parent node.
+     * @param {number} parent - The parent parameter is a number that represents the index of the parent node in a binary
+     * tree.
+     * @returns the minimum value between the parent node and its left and right child nodes.
+     */
+    _getComparedChild(parent) {
+        let min = parent;
+        const left = this._getLeft(parent), right = this._getRight(parent);
         if (left < this.size && this._compare(min, left)) {
             min = left;
         }
@@ -192,26 +280,39 @@ var PriorityQueue = /** @class */ (function () {
             min = right;
         }
         return min;
-    };
-    PriorityQueue.prototype._heapifyUp = function (start) {
+    }
+    /**
+     * The function `_heapifyUp` is used to maintain the heap property by moving an element up the heap until it is in the
+     * correct position.
+     * @param {number} start - The start parameter is the index of the element that needs to be moved up in the heap.
+     */
+    _heapifyUp(start) {
         while (start > 0 && this._compare(this._getParent(start), start)) {
-            var parent = this._getParent(start);
+            const parent = this._getParent(start);
             this._swap(start, parent);
             start = parent;
         }
-    };
-    PriorityQueue.prototype._heapifyDown = function (start) {
-        var min = this._getComparedChild(start);
+    }
+    /**
+     * The function performs a heapify operation by comparing and swapping elements in a binary heap.
+     * @param {number} start - The start parameter is the index of the element in the heap from where the heapifyDown
+     * operation should start.
+     */
+    _heapifyDown(start) {
+        let min = this._getComparedChild(start);
         while (this._compare(start, min)) {
             this._swap(min, start);
             start = min;
             min = this._getComparedChild(start);
         }
-    };
-    PriorityQueue.prototype._fix = function () {
-        for (var i = Math.floor(this.size / 2); i > -1; i--)
+    }
+    /**
+     * The _fix function performs a heapify operation on the elements of the heap starting from the middle and moving
+     * towards the root.
+     */
+    _fix() {
+        for (let i = Math.floor(this.size / 2); i > -1; i--)
             this._heapifyDown(i);
-    };
-    return PriorityQueue;
-}());
+    }
+}
 exports.PriorityQueue = PriorityQueue;

package/dist/data-structures/queue/deque.d.ts

@@ -1,37 +1,165 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 import { DoublyLinkedList } from '../linked-list';
 export declare class Deque<T> extends DoublyLinkedList<T> {
 }
-export declare class ObjectDeque<T> {
-    protected _nodes: {
-        [key: number]: T;
-    };
-    protected _capacity: number;
-    protected _first: number;
-    protected _last: number;
-    protected _size: number;
+export declare class ObjectDeque<T = number> {
     constructor(capacity?: number);
-    size(): number;
-    offerFirst(value: T): void;
-    offerLast(value: T): void;
+    private _nodes;
+    get nodes(): {
+        [p: number]: T;
+    };
+    private _capacity;
+    get capacity(): number;
+    set capacity(value: number);
+    private _first;
+    get first(): number;
+    set first(value: number);
+    private _last;
+    get last(): number;
+    set last(value: number);
+    private _size;
+    get size(): number;
+    /**
+     * The "addFirst" function adds a value to the beginning of an array-like data structure.
+     * @param {T} value - The `value` parameter represents the value that you want to add to the beginning of the data
+     * structure.
+     */
+    addFirst(value: T): void;
+    /**
+     * The addLast function adds a value to the end of an array-like data structure.
+     * @param {T} value - The `value` parameter represents the value that you want to add to the end of the data structure.
+     */
+    addLast(value: T): void;
+    /**
+     * The function `pollFirst()` removes and returns the first element in a data structure.
+     * @returns The value of the first element in the data structure.
+     */
     pollFirst(): T | undefined;
+    /**
+     * The `peekFirst` function returns the first element in an array-like data structure if it exists.
+     * @returns The element at the first position of the `_nodes` array.
+     */
     peekFirst(): T | undefined;
+    /**
+     * The `pollLast()` function removes and returns the last element in a data structure.
+     * @returns The value that was removed from the data structure.
+     */
     pollLast(): T | undefined;
+    /**
+     * The `peekLast()` function returns the last element in an array-like data structure.
+     * @returns The last element in the array "_nodes" is being returned.
+     */
     peekLast(): T | undefined;
+    /**
+     * The get function returns the element at the specified index in an array-like data structure.
+     * @param {number} index - The index parameter is a number that represents the position of the element you want to
+     * retrieve from the array.
+     * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
+     * index, `null` is returned.
+     */
     get(index: number): NonNullable<T> | null;
+    /**
+     * The function checks if the size of a data structure is less than or equal to zero.
+     * @returns The method is returning a boolean value indicating whether the size of the object is less than or equal to 0.
+     */
     isEmpty(): boolean;
+    protected _seNodes(value: {
+        [p: number]: T;
+    }): void;
+    protected _setSize(value: number): void;
 }
 export declare class ArrayDeque<T> {
     protected _nodes: T[];
     get size(): number;
-    offerLast(value: T): number;
+    /**
+     * O(n) time complexity of adding at the beginning and the end
+     */
+    /**
+     * The function "addLast" adds a value to the end of an array.
+     * @param {T} value - The value parameter represents the value that you want to add to the end of the array.
+     * @returns The return value is the new length of the array after the value has been added.
+     */
+    addLast(value: T): number;
+    /**
+     * The function "pollLast" returns and removes the last element from an array, or returns null if the array is empty.
+     * @returns The method `pollLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     */
     pollLast(): T | null;
+    /**
+     * The `pollFirst` function removes and returns the first element from an array, or returns null if the array is empty.
+     * @returns The `pollFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
+     * empty.
+     */
     pollFirst(): T | null;
-    offerFirst(value: T): number;
+    /**
+     * O(n) time complexity of adding at the beginning and the end
+     */
+    /**
+     * The function "addFirst" adds a value to the beginning of an array.
+     * @param {T} value - The value parameter represents the value that you want to add to the beginning of the array.
+     * @returns The return value of the `addFirst` function is the new length of the array `_nodes` after adding the
+     * `value` at the beginning.
+     */
+    addFirst(value: T): number;
+    /**
+     * The `peekFirst` function returns the first element of an array or null if the array is empty.
+     * @returns The function `peekFirst()` is returning the first element (`T`) of the `_nodes` array. If the array is
+     * empty, it will return `null`.
+     */
     peekFirst(): T | null;
+    /**
+     * The `peekLast` function returns the last element of an array or null if the array is empty.
+     * @returns The method `peekLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     */
     peekLast(): T | null;
+    /**
+     * O(1) time complexity of obtaining the value
+     */
+    /**
+     * The get function returns the element at the specified index in an array, or null if the index is out of bounds.
+     * @param {number} index - The index parameter is a number that represents the position of the element you want to
+     * retrieve from the array.
+     * @returns The method is returning the element at the specified index in the `_nodes` array. If the element exists, it
+     * will be returned. If the element does not exist (i.e., the index is out of bounds), `null` will be returned.
+     */
     get(index: number): T | null;
+    /**
+     * The set function assigns a value to a specific index in an array.
+     * @param {number} index - The index parameter is a number that represents the position of the element in the array
+     * that you want to set a new value for.
+     * @param {T} value - The value parameter represents the new value that you want to set at the specified index in the
+     * _nodes array.
+     * @returns The value that is being set at the specified index in the `_nodes` array.
+     */
     set(index: number, value: T): T;
+    /**
+     * The insert function adds a value at a specified index in an array.
+     * @param {number} index - The index parameter specifies the position at which the value should be inserted in the
+     * array. It is a number that represents the index of the array where the value should be inserted. The index starts
+     * from 0, so the first element of the array has an index of 0, the second element has
+     * @param {T} value - The value parameter represents the value that you want to insert into the array at the specified
+     * index.
+     * @returns The splice method returns an array containing the removed elements, if any. In this case, since no elements
+     * are being removed, an empty array will be returned.
+     */
     insert(index: number, value: T): T[];
+    /**
+     * The remove function removes an element from an array at a specified index.
+     * @param {number} index - The index parameter specifies the position of the element to be removed from the array. It
+     * is a number that represents the index of the element to be removed.
+     * @returns The method is returning an array containing the removed element.
+     */
     remove(index: number): T[];
+    /**
+     * The function checks if an array called "_nodes" is empty.
+     * @returns The method `isEmpty()` is returning a boolean value. It returns `true` if the length of the `_nodes` array
+     * is 0, indicating that the array is empty. Otherwise, it returns `false`.
+     */
     isEmpty(): boolean;
 }