data-structure-typed 1.18.5 → 1.18.7

package/dist/data-structures/interfaces/binary-tree.d.ts

@@ -1,27 +1,6 @@
-import { BinaryTreeNodeId } from '../types';
-import { FamilyPosition } from '../binary-tree';
-export interface IBinaryTreeNode<T, FAMILY extends IBinaryTreeNode<T, FAMILY>> {
-    _createNode(id: BinaryTreeNodeId, val: T | null, count?: number): FAMILY | null;
-    get id(): BinaryTreeNodeId;
-    set id(v: BinaryTreeNodeId);
-    get val(): T;
-    set val(v: T);
-    get left(): FAMILY | null | undefined;
-    set left(v: FAMILY | null | undefined);
-    get right(): FAMILY | null | undefined;
-    set right(v: FAMILY | null | undefined);
-    get parent(): FAMILY | null | undefined;
-    set parent(v: FAMILY | null | undefined);
-    get familyPosition(): FamilyPosition;
-    set familyPosition(v: FamilyPosition);
-    get count(): number;
-    set count(v: number);
-    get height(): number;
-    set height(v: number);
-    _createNode(id: BinaryTreeNodeId, val: T | null, count?: number): FAMILY | null;
-    swapLocation(swapNode: FAMILY): FAMILY;
-    clone(): FAMILY | null;
+import { BinaryTreeNode } from '../binary-tree';
+import { IAbstractBinaryTree, IAbstractBinaryTreeNode } from './abstract-binary-tree';
+export interface IBinaryTreeNode<T, FAMILY extends IBinaryTreeNode<T, FAMILY>> extends IAbstractBinaryTreeNode<T, FAMILY> {
 }
-export interface IBinaryTree<N extends IBinaryTreeNode<N['val'], N>> {
-    _createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> extends IAbstractBinaryTree<N> {
 }

package/dist/data-structures/interfaces/bst.d.ts

@@ -1 +1,18 @@
-export {};
+import { BSTNode } from '../binary-tree';
+import { IBinaryTree, IBinaryTreeNode } from './binary-tree';
+import { BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName } from '../types';
+export interface IBSTNode<T, FAMILY extends IBSTNode<T, FAMILY>> extends IBinaryTreeNode<T, FAMILY> {
+    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
+}
+export interface IBST<N extends BSTNode<N['val'], N>> extends IBinaryTree<N> {
+    createNode(id: BinaryTreeNodeId, val?: N['val'] | null, count?: number): N;
+    add(id: BinaryTreeNodeId, val: N['val'] | null, count: number): N | null;
+    get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
+    lastKey(): BinaryTreeNodeId;
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
+    lesserSum(id: BinaryTreeNodeId, propertyName?: BinaryTreeNodePropertyName): number;
+    allGreaterNodesAdd(node: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    balance(): boolean;
+    isAVLBalanced(): boolean;
+}

package/dist/data-structures/interfaces/directed-graph.d.ts

@@ -1,9 +1,12 @@
 import { VertexId } from '../types';
-export interface IDirectedGraph<V, E> {
+import { IAbstractGraph } from './abstract-graph';
+export interface IDirectedGraph<V, E> extends IAbstractGraph<V, E> {
     incomingEdgesOf(vertex: V): E[];
     outgoingEdgesOf(vertex: V): E[];
     inDegreeOf(vertexOrId: V | VertexId): number;
     outDegreeOf(vertexOrId: V | VertexId): number;
     getEdgeSrc(e: E): V | null;
     getEdgeDest(e: E): V | null;
+    removeEdgeSrcToDest(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    removeEdgesBetween(v1: V | VertexId, v2: V | VertexId): E[];
 }

package/dist/data-structures/interfaces/index.d.ts

@@ -1,4 +1,4 @@
-export * from './binary-tree';
+export * from './abstract-binary-tree';
 export * from './bst';
 export * from './avl-tree';
 export * from './segment-tree';

package/dist/data-structures/interfaces/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./binary-tree"), exports);
+__exportStar(require("./abstract-binary-tree"), exports);
 __exportStar(require("./bst"), exports);
 __exportStar(require("./avl-tree"), exports);
 __exportStar(require("./segment-tree"), exports);

package/dist/data-structures/interfaces/rb-tree.d.ts

@@ -0,0 +1,9 @@
+import { RBTreeNode } from '../binary-tree';
+import { IBST, IBSTNode } from './bst';
+import { BinaryTreeNodeId } from '../types';
+export interface IRBTreeNode<T, FAMILY extends IRBTreeNode<T, FAMILY>> extends IBSTNode<T, FAMILY> {
+    createNode(id: BinaryTreeNodeId, val?: T | null, count?: number): FAMILY;
+}
+export interface IRBTree<N extends RBTreeNode<N['val'], N>> extends IBST<N> {
+    createNode(id: BinaryTreeNodeId, val?: N | null, count?: number): N;
+}

package/dist/data-structures/interfaces/rb-tree.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/interfaces/undirected-graph.d.ts

@@ -1,2 +1,5 @@
-export interface IUNDirectedGraph<V, E> {
+import { VertexId } from '../types';
+import { IAbstractGraph } from './abstract-graph';
+export interface IUNDirectedGraph<V, E> extends IAbstractGraph<V, E> {
+    removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null;
 }

package/dist/data-structures/types/abstract-binary-tree.d.ts

@@ -0,0 +1,32 @@
+import { AbstractBinaryTreeNode } from '../binary-tree';
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
+export declare enum LoopType {
+    ITERATIVE = "ITERATIVE",
+    RECURSIVE = "RECURSIVE"
+}
+export declare enum FamilyPosition {
+    ROOT = 0,
+    LEFT = 1,
+    RIGHT = 2
+}
+export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
+export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
+export type DFSOrderPattern = 'in' | 'pre' | 'post';
+export type BinaryTreeNodeId = number;
+export type BinaryTreeDeletedResult<N> = {
+    deleted: N | null | undefined;
+    needBalanced: N | null;
+};
+export type AbstractBinaryTreeNodeProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeId;
+export type AbstractBinaryTreeNodeProperties<N extends AbstractBinaryTreeNode<N['val'], N>> = AbstractBinaryTreeNodeProperty<N>[];
+export type AbstractRecursiveBinaryTreeNode<T> = AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AbstractBinaryTreeOptions = {
+    loopType?: LoopType;
+    autoIncrementId?: boolean;
+    isDuplicatedVal?: boolean;
+};

package/dist/data-structures/types/abstract-binary-tree.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FamilyPosition = exports.LoopType = void 0;
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
+var LoopType;
+(function (LoopType) {
+    LoopType["ITERATIVE"] = "ITERATIVE";
+    LoopType["RECURSIVE"] = "RECURSIVE";
+})(LoopType || (exports.LoopType = LoopType = {}));
+/* This enumeration defines the position of a node within a family tree composed of three associated nodes, where 'root' represents the root node of the family tree, 'left' represents the left child node, and 'right' represents the right child node. */
+var FamilyPosition;
+(function (FamilyPosition) {
+    FamilyPosition[FamilyPosition["ROOT"] = 0] = "ROOT";
+    FamilyPosition[FamilyPosition["LEFT"] = 1] = "LEFT";
+    FamilyPosition[FamilyPosition["RIGHT"] = 2] = "RIGHT";
+})(FamilyPosition || (exports.FamilyPosition = FamilyPosition = {}));

package/dist/data-structures/types/avl-tree.d.ts

@@ -1,6 +1,4 @@
 import { AVLTreeNode } from '../binary-tree';
-export type AVLTreeDeleted<N> = {
-    deleted: N | null;
-    needBalanced: N | null;
-};
+import { BSTOptions } from './bst';
 export type RecursiveAVLTreeNode<T> = AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeOptions = BSTOptions & {};

package/dist/data-structures/types/binary-tree.d.ts

@@ -1,12 +1,4 @@
 import { BinaryTreeNode } from '../binary-tree';
-export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
-export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
-export type DFSOrderPattern = 'in' | 'pre' | 'post';
-export type BinaryTreeNodeId = number;
-export type BinaryTreeDeleted<N> = {
-    deleted: N | null | undefined;
-    needBalanced: N | null;
-};
-export type ResultByProperty<N extends BinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeId;
-export type ResultsByProperty<N extends BinaryTreeNode<N['val'], N>> = ResultByProperty<N>[];
+import { AbstractBinaryTreeOptions } from './abstract-binary-tree';
 export type RecursiveBinaryTreeNode<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BinaryTreeOptions = AbstractBinaryTreeOptions & {};

package/dist/data-structures/types/bst.d.ts

@@ -1,8 +1,13 @@
 import { BSTNode } from '../binary-tree';
-import type { BinaryTreeNodeId } from './binary-tree';
+import type { BinaryTreeOptions } from './binary-tree';
+import { BinaryTreeNodeId } from './abstract-binary-tree';
 export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
-export type BSTDeletedResult<N extends BSTNode<N['val'], N>> = {
-    deleted: N | null;
-    needBalanced: N | null;
-};
 export type RecursiveBSTNode<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BSTOptions = BinaryTreeOptions & {
+    comparator?: BSTComparator;
+};
+export declare enum CP {
+    lt = "lt",
+    eq = "eq",
+    gt = "gt"
+}

package/dist/data-structures/types/bst.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CP = void 0;
+var CP;
+(function (CP) {
+    CP["lt"] = "lt";
+    CP["eq"] = "eq";
+    CP["gt"] = "gt";
+})(CP || (exports.CP = CP = {}));

package/dist/data-structures/types/helpers.d.ts

@@ -0,0 +1,8 @@
+export type IdObject = {
+    id: number;
+} & {
+    [key: string]: any;
+};
+export type KeyValObject = {
+    [key: string]: any;
+};

package/dist/data-structures/types/helpers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/types/index.d.ts

@@ -4,9 +4,12 @@ export * from './avl-tree';
 export * from './segment-tree';
 export * from './tree-multiset';
 export * from './abstract-graph';
+export * from './abstract-binary-tree';
+export * from './rb-tree';
 export * from './directed-graph';
 export * from './priority-queue';
 export * from './heap';
 export * from './singly-linked-list';
 export * from './doubly-linked-list';
 export * from './navigator';
+export * from './helpers';

package/dist/data-structures/types/index.js

@@ -20,9 +20,12 @@ __exportStar(require("./avl-tree"), exports);
 __exportStar(require("./segment-tree"), exports);
 __exportStar(require("./tree-multiset"), exports);
 __exportStar(require("./abstract-graph"), exports);
+__exportStar(require("./abstract-binary-tree"), exports);
+__exportStar(require("./rb-tree"), exports);
 __exportStar(require("./directed-graph"), exports);
 __exportStar(require("./priority-queue"), exports);
 __exportStar(require("./heap"), exports);
 __exportStar(require("./singly-linked-list"), exports);
 __exportStar(require("./doubly-linked-list"), exports);
 __exportStar(require("./navigator"), exports);
+__exportStar(require("./helpers"), exports);

package/dist/data-structures/types/rb-tree.d.ts

@@ -0,0 +1,6 @@
+import { BinaryTreeOptions } from './binary-tree';
+export declare enum RBColor {
+    RED = "RED",
+    BLACK = "BLACK"
+}
+export type RBTreeOptions = BinaryTreeOptions & {};

package/dist/data-structures/types/rb-tree.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RBColor = void 0;
+var RBColor;
+(function (RBColor) {
+    RBColor["RED"] = "RED";
+    RBColor["BLACK"] = "BLACK";
+})(RBColor || (exports.RBColor = RBColor = {}));

package/dist/data-structures/types/tree-multiset.d.ts

@@ -1,4 +1,6 @@
-export type TreeMultiSetDeletedResult<N> = {
-    deleted: N | null;
-    needBalanced: N | null;
+import { BSTOptions } from './bst';
+import { TreeMultiSetNode } from '../binary-tree';
+export type RecursiveTreeMultiSetNode<T> = TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type TreeMultiSetOptions = Omit<BSTOptions, 'isDuplicatedVal'> & {
+    isDuplicatedVal: true;
 };

package/dist/utils/utils.js

@@ -149,3 +149,65 @@ var trampolineAsync = function (fn) {
     }, { cont: cont });
 };
 exports.trampolineAsync = trampolineAsync;
+// export class AutoPruneMap<K, V> extends Map<K, V> {
+//
+//     private _proxySet: Set<V>;
+//     get proxySet(): Set<V> {
+//         return this._proxySet;
+//     }
+//
+//     set proxySet(value: Set<V>) {
+//         this._proxySet = value;
+//     }
+//
+//     private _isEmptyArrayAllowed: boolean;
+//
+//     get isEmptyArrayAllowed(): boolean {
+//         return this._isEmptyArrayAllowed;
+//     }
+//
+//     set isEmptyArrayAllowed(value: boolean) {
+//         this._isEmptyArrayAllowed = value;
+//     }
+//
+//     constructor(isEmptyArrayAllowed: boolean = false) {
+//         super();
+//         this._isEmptyArrayAllowed = isEmptyArrayAllowed;
+//         this._proxySet = new Set<V>();
+//     }
+//
+//     set(key: K, value: V): this {
+//         if (Array.isArray(value) && !this.proxySet.has(value)) {
+//             if(!this.isEmptyArrayAllowed && value.length === 0) return this;
+//             value = this.createArrayProxy(value, key);
+//             if (!this.proxySet.has(value)) this.proxySet.add(value);
+//         }
+//         super.set(key, value);
+//         return this;
+//     }
+//
+//     private createArrayProxy(array: V & any[], key: K) {
+//         const that = this;
+//         const proxyHandler: ProxyHandler<V & any[]> = {
+//             set(target: any, property: PropertyKey, value: any): boolean {
+//                 const result = Reflect.set(target, property, value);
+//                 that.checkAndDeleteEmptyArray(key);
+//                 return result;
+//             },
+//             deleteProperty(target: any, property: PropertyKey): boolean {
+//                 const result = Reflect.deleteProperty(target, property);
+//                 that.checkAndDeleteEmptyArray(key);
+//                 return result;
+//             },
+//         }
+//         return new Proxy(array, proxyHandler);
+//     }
+//
+//     private checkAndDeleteEmptyArray(key: K): void {
+//         const value = this.get(key);
+//
+//         if (Array.isArray(value) && value.length === 0) {
+//             super.delete(key);
+//         }
+//     }
+// }