@blackglory/structures 0.5.0 → 0.6.1

package/dist/es2018/index.umd.js

@@ -4,48 +4,17 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Structures = {}));
 })(this, (function (exports) { 'use strict';
 
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    function __classPrivateFieldGet(receiver, state, kind, f) {
-        if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-    }
-
-    function __classPrivateFieldSet(receiver, state, value, kind, f) {
-        if (kind === "m") throw new TypeError("Private method is not writable");
-        if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-    }
-
-    var _Box_value;
     class Box {
         constructor(value) {
-            _Box_value.set(this, void 0);
-            __classPrivateFieldSet(this, _Box_value, value, "f");
+            this.value = value;
         }
         set(value) {
-            __classPrivateFieldSet(this, _Box_value, value, "f");
+            this.value = value;
         }
         get() {
-            return __classPrivateFieldGet(this, _Box_value, "f");
+            return this.value;
         }
     }
-    _Box_value = new WeakMap();
 
     function convertConsToArray([value, next]) {
         if (next === null)
@@ -56,127 +25,130 @@
         return [value, next.length ? convertArrayToCons(next) : null];
     }
 
-    var _Emitter_map;
     class Emitter {
         constructor() {
-            _Emitter_map.set(this, new Map());
+            this.map = new Map();
         }
-        get [(_Emitter_map = new WeakMap(), Symbol.toStringTag)]() {
+        get [Symbol.toStringTag]() {
             return this.constructor.name;
         }
-        /**
-         * The same handler will only be registered once.
-         */
-        on(event, handler) {
-            if (!__classPrivateFieldGet(this, _Emitter_map, "f").has(event)) {
-                __classPrivateFieldGet(this, _Emitter_map, "f").set(event, new Set());
+        on(event, listener) {
+            if (!this.map.has(event)) {
+                this.map.set(event, new Set());
             }
-            const set = __classPrivateFieldGet(this, _Emitter_map, "f").get(event);
+            const set = this.map.get(event);
             set.add(handler);
-        }
-        off(event, handler) {
-            if (!__classPrivateFieldGet(this, _Emitter_map, "f").has(event))
-                return;
-            const handlers = __classPrivateFieldGet(this, _Emitter_map, "f").get(event);
-            handlers.delete(handler);
-            if (handlers.size === 0) {
-                __classPrivateFieldGet(this, _Emitter_map, "f").delete(event);
+            return () => {
+                if (!this.map.has(event))
+                    return;
+                const handlers = this.map.get(event);
+                handlers.delete(handler);
+                if (handlers.size === 0) {
+                    this.map.delete(event);
+                }
+            };
+            function handler(...args) {
+                listener(...args);
             }
         }
+        once(event, listener) {
+            const removeListener = this.on(event, (...args) => {
+                listener(...args);
+                removeListener();
+            });
+            return removeListener;
+        }
         emit(event, ...args) {
-            if (!__classPrivateFieldGet(this, _Emitter_map, "f").has(event))
+            if (!this.map.has(event))
                 return;
-            __classPrivateFieldGet(this, _Emitter_map, "f").get(event).forEach(cb => cb(...args));
+            this.map.get(event).forEach(cb => cb(...args));
         }
     }
 
-    var _HashMap_map;
     class HashMap {
         constructor(hash) {
             this.hash = hash;
-            _HashMap_map.set(this, new Map());
+            this.map = new Map();
         }
-        get [(_HashMap_map = new WeakMap(), Symbol.toStringTag)]() {
+        get [Symbol.toStringTag]() {
             return this.constructor.name;
         }
         get size() {
-            return __classPrivateFieldGet(this, _HashMap_map, "f").size;
+            return this.map.size;
         }
         set(key, value) {
-            __classPrivateFieldGet(this, _HashMap_map, "f").set(this.hash(key), value);
+            this.map.set(this.hash(key), value);
             return this;
         }
         has(key) {
-            return __classPrivateFieldGet(this, _HashMap_map, "f").has(this.hash(key));
+            return this.map.has(this.hash(key));
         }
         get(key) {
-            return __classPrivateFieldGet(this, _HashMap_map, "f").get(this.hash(key));
+            return this.map.get(this.hash(key));
         }
         delete(key) {
-            return __classPrivateFieldGet(this, _HashMap_map, "f").delete(this.hash(key));
+            return this.map.delete(this.hash(key));
         }
         clear() {
-            __classPrivateFieldGet(this, _HashMap_map, "f").clear();
+            this.map.clear();
         }
     }
 
-    var _HashSet_map;
     class HashSet {
         constructor(hash) {
             this.hash = hash;
-            _HashSet_map.set(this, new Map());
+            this.map = new Map();
         }
-        get [(_HashSet_map = new WeakMap(), Symbol.toStringTag)]() {
+        get [Symbol.toStringTag]() {
             return this.constructor.name;
         }
         get size() {
-            return __classPrivateFieldGet(this, _HashSet_map, "f").size;
+            return this.map.size;
         }
         [Symbol.iterator]() {
-            return __classPrivateFieldGet(this, _HashSet_map, "f").values();
+            return this.map.values();
         }
         add(value) {
-            __classPrivateFieldGet(this, _HashSet_map, "f").set(this.hash(value), value);
+            this.map.set(this.hash(value), value);
             return this;
         }
         delete(value) {
-            return __classPrivateFieldGet(this, _HashSet_map, "f").delete(this.hash(value));
+            return this.map.delete(this.hash(value));
         }
         has(value) {
-            return __classPrivateFieldGet(this, _HashSet_map, "f").has(this.hash(value));
+            return this.map.has(this.hash(value));
         }
         clear() {
-            __classPrivateFieldGet(this, _HashSet_map, "f").clear();
+            this.map.clear();
         }
         values() {
-            return __classPrivateFieldGet(this, _HashSet_map, "f").values();
+            return this.map.values();
         }
     }
 
-    var _Queue_items;
     class Queue {
         constructor() {
-            _Queue_items.set(this, []);
+            this.items = [];
         }
-        get [(_Queue_items = new WeakMap(), Symbol.toStringTag)]() {
+        get [Symbol.toStringTag]() {
             return this.constructor.name;
         }
         get size() {
-            return __classPrivateFieldGet(this, _Queue_items, "f").length;
+            return this.items.length;
         }
         empty() {
-            __classPrivateFieldGet(this, _Queue_items, "f").length = 0;
+            this.items.length = 0;
         }
         enqueue(...items) {
-            __classPrivateFieldGet(this, _Queue_items, "f").push(...items);
+            this.items.push(...items);
         }
         dequeue() {
-            return __classPrivateFieldGet(this, _Queue_items, "f").shift();
+            return this.items.shift();
         }
         remove(item) {
             let index;
-            while ((index = __classPrivateFieldGet(this, _Queue_items, "f").indexOf(item)) >= 0) {
-                __classPrivateFieldGet(this, _Queue_items, "f").splice(index, 1);
+            while ((index = this.items.indexOf(item)) >= 0) {
+                this.items.splice(index, 1);
             }
         }
     }
@@ -7122,61 +7094,59 @@
     	
     } (es2018$4));
 
-    var _LRUMap_limit, _LRUMap_map;
     class LRUMap {
         constructor(limit) {
-            _LRUMap_limit.set(this, void 0);
-            _LRUMap_map.set(this, new Map());
+            this.map = new Map();
             es2018$d.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
             es2018$d.assert(limit > 0, 'The parameter limit must be a positive value');
-            __classPrivateFieldSet(this, _LRUMap_limit, limit, "f");
+            this.limit = limit;
         }
-        get [(_LRUMap_limit = new WeakMap(), _LRUMap_map = new WeakMap(), Symbol.toStringTag)]() {
+        get [Symbol.toStringTag]() {
             return this.constructor.name;
         }
         get size() {
-            return __classPrivateFieldGet(this, _LRUMap_map, "f").size;
+            return this.map.size;
         }
         set(key, value) {
-            if (__classPrivateFieldGet(this, _LRUMap_map, "f").has(key)) {
+            if (this.map.has(key)) {
                 this.updateItem(key, value);
             }
             else {
-                if (__classPrivateFieldGet(this, _LRUMap_map, "f").size === __classPrivateFieldGet(this, _LRUMap_limit, "f")) {
-                    __classPrivateFieldGet(this, _LRUMap_map, "f").delete(this.getColdestKey());
+                if (this.map.size === this.limit) {
+                    this.map.delete(this.getColdestKey());
                 }
-                __classPrivateFieldGet(this, _LRUMap_map, "f").set(key, value);
+                this.map.set(key, value);
             }
             return this;
         }
         has(key) {
-            return __classPrivateFieldGet(this, _LRUMap_map, "f").has(key);
+            return this.map.has(key);
         }
         get(key) {
             if (!this.has(key))
                 return undefined;
-            const value = __classPrivateFieldGet(this, _LRUMap_map, "f").get(key);
+            const value = this.map.get(key);
             this.updateItem(key, value);
             return value;
         }
         delete(key) {
-            return __classPrivateFieldGet(this, _LRUMap_map, "f").delete(key);
+            return this.map.delete(key);
         }
         clear() {
-            __classPrivateFieldGet(this, _LRUMap_map, "f").clear();
+            this.map.clear();
         }
         /**
          * Reinsert the item.
          */
         updateItem(key, value) {
-            __classPrivateFieldGet(this, _LRUMap_map, "f").delete(key);
-            __classPrivateFieldGet(this, _LRUMap_map, "f").set(key, value);
+            this.map.delete(key);
+            this.map.set(key, value);
         }
         /**
          * Return the earliest key inserted in the Map
          */
         getColdestKey() {
-            return es2018$4.first(__classPrivateFieldGet(this, _LRUMap_map, "f").keys());
+            return es2018$4.first(this.map.keys());
         }
     }
 
@@ -7348,36 +7318,34 @@
     	
     } (es2018$1));
 
-    var _ExpirableMap_map, _ExpirableMap_cancelClearTimeout;
     class ExpirableMap {
         constructor() {
-            _ExpirableMap_map.set(this, new Map());
-            _ExpirableMap_cancelClearTimeout.set(this, void 0);
+            this.map = new Map();
             /**
              * 按过期时间升序排列所有项目的元数据
              */
             this.itemMetadataSortedByExpirationTime = [];
         }
-        get [(_ExpirableMap_map = new WeakMap(), _ExpirableMap_cancelClearTimeout = new WeakMap(), Symbol.toStringTag)]() {
+        get [Symbol.toStringTag]() {
             return this.constructor.name;
         }
         get size() {
-            return __classPrivateFieldGet(this, _ExpirableMap_map, "f").size;
+            return this.map.size;
         }
         set(key, value, maxAge) {
-            __classPrivateFieldGet(this, _ExpirableMap_map, "f").set(key, value);
+            this.map.set(key, value);
             this.removeItemMetadata(key);
             this.addItemMetadata(key, Date.now() + maxAge);
             return this;
         }
         has(key) {
-            return __classPrivateFieldGet(this, _ExpirableMap_map, "f").has(key);
+            return this.map.has(key);
         }
         get(key) {
-            return __classPrivateFieldGet(this, _ExpirableMap_map, "f").get(key);
+            return this.map.get(key);
         }
         delete(key) {
-            const exists = __classPrivateFieldGet(this, _ExpirableMap_map, "f").delete(key);
+            const exists = this.map.delete(key);
             if (exists) {
                 const index = this.itemMetadataSortedByExpirationTime.findIndex(x => x.key === key);
                 this.itemMetadataSortedByExpirationTime.splice(index, 1);
@@ -7390,8 +7358,8 @@
         }
         clear() {
             var _a;
-            __classPrivateFieldGet(this, _ExpirableMap_map, "f").clear();
-            (_a = __classPrivateFieldGet(this, _ExpirableMap_cancelClearTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.map.clear();
+            (_a = this.cancelClearTimeout) === null || _a === void 0 ? void 0 : _a.call(this);
             this.itemMetadataSortedByExpirationTime = [];
         }
         addItemMetadata(key, expirationTime) {
@@ -7428,11 +7396,11 @@
             const expiredItemKeys = indexOfFirstUnexpired >= 0
                 ? this.itemMetadataSortedByExpirationTime.splice(0, indexOfFirstUnexpired)
                 : this.itemMetadataSortedByExpirationTime.splice(0, this.itemMetadataSortedByExpirationTime.length);
-            expiredItemKeys.forEach(x => __classPrivateFieldGet(this, _ExpirableMap_map, "f").delete(x.key));
+            expiredItemKeys.forEach(x => this.map.delete(x.key));
         }
         rescheduleClearTimeout() {
             var _a;
-            (_a = __classPrivateFieldGet(this, _ExpirableMap_cancelClearTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_a = this.cancelClearTimeout) === null || _a === void 0 ? void 0 : _a.call(this);
             if (this.itemMetadataSortedByExpirationTime.length > 0) {
                 const item = this.itemMetadataSortedByExpirationTime[0];
                 if (Number.isFinite(item.expirationTime)) {
@@ -7440,59 +7408,56 @@
                         this.clearExpiredItems(Date.now());
                         this.rescheduleClearTimeout();
                     });
-                    __classPrivateFieldSet(this, _ExpirableMap_cancelClearTimeout, () => {
+                    this.cancelClearTimeout = () => {
                         cancel();
-                        __classPrivateFieldSet(this, _ExpirableMap_cancelClearTimeout, undefined, "f");
-                    }, "f");
+                        this.cancelClearTimeout = undefined;
+                    };
                 }
             }
         }
     }
 
-    var _TLRUMap_limit, _TLRUMap_map, _TLRUMap_cancelClearTimeout;
     /**
      * TLRUMap = LRUMap + ExpirableMap
      */
     class TLRUMap {
         constructor(limit) {
-            _TLRUMap_limit.set(this, void 0);
-            _TLRUMap_map.set(this, new Map());
-            _TLRUMap_cancelClearTimeout.set(this, void 0);
+            this.map = new Map();
             /**
              * 按过期时间升序排列所有项目的元数据
              */
             this.itemMetadataSortedByExpirationTime = [];
             es2018$d.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
             es2018$d.assert(limit > 0, 'The parameter limit must be a positive value');
-            __classPrivateFieldSet(this, _TLRUMap_limit, limit, "f");
+            this.limit = limit;
         }
-        get [(_TLRUMap_limit = new WeakMap(), _TLRUMap_map = new WeakMap(), _TLRUMap_cancelClearTimeout = new WeakMap(), Symbol.toStringTag)]() {
+        get [Symbol.toStringTag]() {
             return this.constructor.name;
         }
         get size() {
-            return __classPrivateFieldGet(this, _TLRUMap_map, "f").size;
+            return this.map.size;
         }
         set(key, value, maxAge) {
-            if (__classPrivateFieldGet(this, _TLRUMap_map, "f").has(key)) {
+            if (this.map.has(key)) {
                 this.updateItem(key, value);
                 this.removeItemMetadata(key);
                 this.addItemMetadata(key, Date.now() + maxAge);
             }
             else {
-                if (__classPrivateFieldGet(this, _TLRUMap_map, "f").size === __classPrivateFieldGet(this, _TLRUMap_limit, "f")) {
-                    __classPrivateFieldGet(this, _TLRUMap_map, "f").delete(this.getColdestKey());
+                if (this.map.size === this.limit) {
+                    this.map.delete(this.getColdestKey());
                 }
-                __classPrivateFieldGet(this, _TLRUMap_map, "f").set(key, value);
+                this.map.set(key, value);
                 this.addItemMetadata(key, Date.now() + maxAge);
             }
             return this;
         }
         has(key) {
-            return __classPrivateFieldGet(this, _TLRUMap_map, "f").has(key);
+            return this.map.has(key);
         }
         get(key) {
             if (this.has(key)) {
-                const value = __classPrivateFieldGet(this, _TLRUMap_map, "f").get(key);
+                const value = this.map.get(key);
                 this.updateItem(key, value);
                 return value;
             }
@@ -7501,7 +7466,7 @@
             }
         }
         delete(key) {
-            const result = __classPrivateFieldGet(this, _TLRUMap_map, "f").delete(key);
+            const result = this.map.delete(key);
             if (result) {
                 const index = this.itemMetadataSortedByExpirationTime.findIndex(x => x.key === key);
                 this.itemMetadataSortedByExpirationTime.splice(index, 1);
@@ -7514,16 +7479,16 @@
         }
         clear() {
             var _a;
-            __classPrivateFieldGet(this, _TLRUMap_map, "f").clear();
-            (_a = __classPrivateFieldGet(this, _TLRUMap_cancelClearTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.map.clear();
+            (_a = this.cancelClearTimeout) === null || _a === void 0 ? void 0 : _a.call(this);
             this.itemMetadataSortedByExpirationTime = [];
         }
         /**
          * 重新插入项目, 这会使项目置于#map迭代器的末端.
          */
         updateItem(key, value) {
-            __classPrivateFieldGet(this, _TLRUMap_map, "f").delete(key);
-            __classPrivateFieldGet(this, _TLRUMap_map, "f").set(key, value);
+            this.map.delete(key);
+            this.map.set(key, value);
         }
         addItemMetadata(key, expirationTime) {
             for (let i = 0; i < this.itemMetadataSortedByExpirationTime.length; i++) {
@@ -7559,11 +7524,11 @@
             const expiredItemKeys = indexOfFirstUnexpiredItem >= 0
                 ? this.itemMetadataSortedByExpirationTime.splice(0, indexOfFirstUnexpiredItem)
                 : this.itemMetadataSortedByExpirationTime.splice(0, this.itemMetadataSortedByExpirationTime.length);
-            expiredItemKeys.forEach(x => __classPrivateFieldGet(this, _TLRUMap_map, "f").delete(x.key));
+            expiredItemKeys.forEach(x => this.map.delete(x.key));
         }
         rescheduleClearTimeout() {
             var _a;
-            (_a = __classPrivateFieldGet(this, _TLRUMap_cancelClearTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_a = this.cancelClearTimeout) === null || _a === void 0 ? void 0 : _a.call(this);
             if (this.itemMetadataSortedByExpirationTime.length > 0) {
                 const item = this.itemMetadataSortedByExpirationTime[0];
                 if (Number.isFinite(item.expirationTime)) {
@@ -7571,10 +7536,10 @@
                         this.clearExpiredItems(Date.now());
                         this.rescheduleClearTimeout();
                     });
-                    __classPrivateFieldSet(this, _TLRUMap_cancelClearTimeout, () => {
+                    this.cancelClearTimeout = () => {
                         cancel();
-                        __classPrivateFieldSet(this, _TLRUMap_cancelClearTimeout, undefined, "f");
-                    }, "f");
+                        this.cancelClearTimeout = undefined;
+                    };
                 }
             }
         }
@@ -7582,11 +7547,10 @@
          * Return the earliest key inserted in the Map
          */
         getColdestKey() {
-            return es2018$4.first(__classPrivateFieldGet(this, _TLRUMap_map, "f").keys());
+            return es2018$4.first(this.map.keys());
         }
     }
 
-    var _TrieMap_root;
     class TrieNode {
         constructor(value) {
             this.value = value;
@@ -7595,13 +7559,31 @@
     }
     class TrieMap {
         constructor() {
-            _TrieMap_root.set(this, new TrieNode());
+            this.root = new TrieNode();
         }
-        get [(_TrieMap_root = new WeakMap(), Symbol.toStringTag)]() {
+        get [Symbol.toStringTag]() {
             return this.constructor.name;
         }
+        *entries() {
+            yield* dfs(this.root, []);
+            function* dfs(node, paths) {
+                for (const [path, childNode] of node.children) {
+                    const newPaths = [...paths, path];
+                    if (es2018$2.isntUndefined(childNode.value)) {
+                        yield [newPaths, childNode.value];
+                    }
+                    yield* dfs(childNode, newPaths);
+                }
+            }
+        }
+        keys() {
+            return es2018$4.map(this.entries(), ([key]) => key);
+        }
+        values() {
+            return es2018$4.map(this.entries(), ([_, value]) => value);
+        }
         set(key, value) {
-            let node = __classPrivateFieldGet(this, _TrieMap_root, "f");
+            let node = this.root;
             for (const part of key) {
                 if (!node.children.has(part)) {
                     node.children.set(part, new TrieNode());
@@ -7612,7 +7594,7 @@
             return this;
         }
         has(key) {
-            let node = __classPrivateFieldGet(this, _TrieMap_root, "f");
+            let node = this.root;
             for (const part of key) {
                 if (node.children.has(part)) {
                     node = node.children.get(part);
@@ -7624,7 +7606,7 @@
             return node.value !== undefined;
         }
         get(key) {
-            let node = __classPrivateFieldGet(this, _TrieMap_root, "f");
+            let node = this.root;
             for (const part of key) {
                 if (node.children.has(part)) {
                     node = node.children.get(part);
@@ -7637,7 +7619,7 @@
         }
         delete(key) {
             const parentNodes = [];
-            let node = __classPrivateFieldGet(this, _TrieMap_root, "f");
+            let node = this.root;
             for (const part of key) {
                 if (node.children.has(part)) {
                     parentNodes.push(node);
@@ -7660,18 +7642,16 @@
         }
     }
 
-    var _FiniteStateMachine_state;
     class FiniteStateMachine {
         constructor(schema, initialState) {
             this.schema = schema;
-            _FiniteStateMachine_state.set(this, void 0);
-            __classPrivateFieldSet(this, _FiniteStateMachine_state, initialState, "f");
+            this._state = initialState;
         }
         get state() {
-            return __classPrivateFieldGet(this, _FiniteStateMachine_state, "f");
+            return this._state;
         }
         matches(state) {
-            return __classPrivateFieldGet(this, _FiniteStateMachine_state, "f") === state;
+            return this._state === state;
         }
         can(event) {
             return event in this.schema[this.state];
@@ -7681,14 +7661,13 @@
          */
         send(event) {
             if (this.can(event)) {
-                __classPrivateFieldSet(this, _FiniteStateMachine_state, this.schema[this.state][event], "f");
+                this._state = this.schema[this.state][event];
             }
             else {
                 throw new BadEventError(this.state, event);
             }
         }
     }
-    _FiniteStateMachine_state = new WeakMap();
     class BadEventError extends es2018$d.CustomError {
         constructor(state, event) {
             super(`State ${state} cannot react to event ${event}`);