@blackglory/structures 0.11.1 → 0.11.3

package/dist/es2018/index.umd.js

@@ -677,146 +677,8 @@
         arr.splice(0, startIndex);
     }
 
-    class Emitter {
-        constructor() {
-            this.map = new Map();
-        }
-        get [Symbol.toStringTag]() {
-            return this.constructor.name;
-        }
-        on(event, listener) {
-            if (!this.map.has(event)) {
-                this.map.set(event, new Set());
-            }
-            const set = this.map.get(event);
-            set.add(handler);
-            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 (!this.map.has(event))
-                return;
-            this.map.get(event).forEach(cb => cb(...args));
-        }
-    }
-
-    class HashMap {
-        constructor(hash) {
-            this.hash = hash;
-            this.map = new Map();
-        }
-        get [Symbol.toStringTag]() {
-            return this.constructor.name;
-        }
-        get size() {
-            return this.map.size;
-        }
-        set(key, value) {
-            this.map.set(this.hash(key), value);
-            return this;
-        }
-        has(key) {
-            return this.map.has(this.hash(key));
-        }
-        get(key) {
-            return this.map.get(this.hash(key));
-        }
-        delete(key) {
-            return this.map.delete(this.hash(key));
-        }
-        clear() {
-            this.map.clear();
-        }
-    }
-
-    class HashSet {
-        constructor(hash) {
-            this.hash = hash;
-            this.map = new Map();
-        }
-        get [Symbol.toStringTag]() {
-            return this.constructor.name;
-        }
-        get size() {
-            return this.map.size;
-        }
-        [Symbol.iterator]() {
-            return this.map.values();
-        }
-        add(value) {
-            this.map.set(this.hash(value), value);
-            return this;
-        }
-        delete(value) {
-            return this.map.delete(this.hash(value));
-        }
-        has(value) {
-            return this.map.has(this.hash(value));
-        }
-        clear() {
-            this.map.clear();
-        }
-        values() {
-            return this.map.values();
-        }
-    }
-
-    class Queue {
-        constructor() {
-            this.items = [];
-        }
-        get [Symbol.toStringTag]() {
-            return this.constructor.name;
-        }
-        get size() {
-            return this.items.length;
-        }
-        empty() {
-            this.items.length = 0;
-        }
-        enqueue(...items) {
-            this.items.push(...items);
-        }
-        dequeue() {
-            return this.items.shift();
-        }
-        remove(item) {
-            let index;
-            while ((index = this.items.indexOf(item)) >= 0) {
-                this.items.splice(index, 1);
-            }
-        }
-    }
-
     var es2018$6 = {};
 
-    var customError = {};
-
-    var es2018$5 = {};
-
-    var middleware = {};
-
-    var chunkAsync = {};
-
-    var es2018$4 = {};
-
     var go$1 = {};
 
     go$1.go = void 0;
@@ -844,11 +706,11 @@
 
     var goMacrotask$1 = {};
 
-    var es2018$3 = {};
+    var es2018$5 = {};
 
     var exponentialBackoff = {};
 
-    var es2018$2 = {};
+    var es2018$4 = {};
 
     var random$1 = {};
 
@@ -892,10 +754,10 @@
     	__exportStar(randomInt$1, exports);
     	__exportStar(randomIntInclusive$1, exports);
     	
-    } (es2018$2));
+    } (es2018$4));
 
     exponentialBackoff.calculateExponentialBackoffTimeout = void 0;
-    const extra_rand_1 = es2018$2;
+    const extra_rand_1 = es2018$4;
     function calculateExponentialBackoffTimeout({ baseTimeout, retries, maxTimeout = Infinity, factor = 2, jitter = true }) {
         const timeout = Math.min(factor ** retries * baseTimeout, maxTimeout);
         if (jitter) {
@@ -1010,10 +872,10 @@
     	__exportStar(setTimeoutLoop$1, exports);
     	__exportStar(setDynamicTimeoutLoop$1, exports);
     	
-    } (es2018$3));
+    } (es2018$5));
 
     goMacrotask$1.goMacrotask = void 0;
-    const extra_timers_1 = es2018$3;
+    const extra_timers_1 = es2018$5;
     function goMacrotask(fn) {
         return new Promise((resolve, reject) => {
             (0, extra_timers_1.setImmediate)(async () => {
@@ -1046,7 +908,151 @@
     	__exportStar(goMicrotask$1, exports);
     	__exportStar(goMacrotask$1, exports);
     	
-    } (es2018$4));
+    } (es2018$6));
+
+    class Emitter {
+        constructor() {
+            this.map = new Map();
+        }
+        get [Symbol.toStringTag]() {
+            return this.constructor.name;
+        }
+        on(event, listener) {
+            const set = es2018$6.go(() => {
+                const set = this.map.get(event);
+                if (set) {
+                    return set;
+                }
+                else {
+                    const set = new Set();
+                    this.map.set(event, set);
+                    return set;
+                }
+            });
+            set.add(handler);
+            return () => {
+                const handlers = this.map.get(event);
+                if (handlers) {
+                    const deleted = handlers.delete(handler);
+                    if (deleted && 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) {
+            var _a;
+            (_a = this.map.get(event)) === null || _a === void 0 ? void 0 : _a.forEach(cb => cb(...args));
+        }
+    }
+
+    class HashMap {
+        constructor(hash) {
+            this.hash = hash;
+            this.map = new Map();
+        }
+        get [Symbol.toStringTag]() {
+            return this.constructor.name;
+        }
+        get size() {
+            return this.map.size;
+        }
+        set(key, value) {
+            this.map.set(this.hash(key), value);
+            return this;
+        }
+        has(key) {
+            return this.map.has(this.hash(key));
+        }
+        get(key) {
+            return this.map.get(this.hash(key));
+        }
+        delete(key) {
+            return this.map.delete(this.hash(key));
+        }
+        clear() {
+            this.map.clear();
+        }
+    }
+
+    class HashSet {
+        constructor(hash) {
+            this.hash = hash;
+            this.map = new Map();
+        }
+        get [Symbol.toStringTag]() {
+            return this.constructor.name;
+        }
+        get size() {
+            return this.map.size;
+        }
+        [Symbol.iterator]() {
+            return this.map.values();
+        }
+        add(value) {
+            this.map.set(this.hash(value), value);
+            return this;
+        }
+        delete(value) {
+            return this.map.delete(this.hash(value));
+        }
+        has(value) {
+            return this.map.has(this.hash(value));
+        }
+        clear() {
+            this.map.clear();
+        }
+        values() {
+            return this.map.values();
+        }
+    }
+
+    class Queue {
+        constructor() {
+            this.items = [];
+        }
+        get [Symbol.toStringTag]() {
+            return this.constructor.name;
+        }
+        get size() {
+            return this.items.length;
+        }
+        empty() {
+            this.items.length = 0;
+        }
+        enqueue(...items) {
+            this.items.push(...items);
+        }
+        dequeue() {
+            return this.items.shift();
+        }
+        remove(item) {
+            let index;
+            while ((index = this.items.indexOf(item)) >= 0) {
+                this.items.splice(index, 1);
+            }
+        }
+    }
+
+    var es2018$3 = {};
+
+    var customError = {};
+
+    var es2018$2 = {};
+
+    var middleware = {};
+
+    var chunkAsync = {};
 
     var hasRequiredChunkAsync;
 
@@ -1054,7 +1060,7 @@
     	if (hasRequiredChunkAsync) return chunkAsync;
     	hasRequiredChunkAsync = 1;
     chunkAsync.chunkAsync = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const errors_1 = requireEs2018();
     	function chunkAsync$1(iterable, size) {
     	    (0, errors_1.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -1519,7 +1525,7 @@
     	if (hasRequiredChunk) return chunk;
     	hasRequiredChunk = 1;
     chunk.chunk = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const errors_1 = requireEs2018();
     	function chunk$1(iterable, size) {
     	    (0, errors_1.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -1546,7 +1552,7 @@
 
     concatAsync$1.concatAsync = void 0;
     const types_1$i = es2018$1;
-    const go_1$1 = es2018$4;
+    const go_1$1 = es2018$6;
     function concatAsync(iterable, ...otherIterables) {
         return (0, go_1$1.go)(async function* () {
             for (const iter of [iterable, ...otherIterables]) {
@@ -1568,7 +1574,7 @@
     var concat$1 = {};
 
     concat$1.concat = void 0;
-    const go_1 = es2018$4;
+    const go_1 = es2018$6;
     function concat(iterable, ...otherIterables) {
         return (0, go_1.go)(function* () {
             for (const iter of [iterable, ...otherIterables]) {
@@ -1602,7 +1608,7 @@
     	if (hasRequiredDropAsync) return dropAsync;
     	hasRequiredDropAsync = 1;
     dropAsync.dropAsync = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const utils_1 = utils;
     	const errors_1 = requireEs2018();
     	function dropAsync$1(iterable, count) {
@@ -1645,7 +1651,7 @@
     	if (hasRequiredDropRightAsync) return dropRightAsync;
     	hasRequiredDropRightAsync = 1;
     dropRightAsync.dropRightAsync = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const utils_1 = utils;
     	const errors_1 = requireEs2018();
     	function dropRightAsync$1(iterable, count) {
@@ -1681,7 +1687,7 @@
     	if (hasRequiredDropRight) return dropRight;
     	hasRequiredDropRight = 1;
     dropRight.dropRight = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const utils_1 = utils;
     	const errors_1 = requireEs2018();
     	function dropRight$1(iterable, count) {
@@ -1789,7 +1795,7 @@
     	if (hasRequiredDrop) return drop;
     	hasRequiredDrop = 1;
     drop.drop = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const utils_1 = utils;
     	const errors_1 = requireEs2018();
     	function drop$1(iterable, count) {
@@ -2052,7 +2058,7 @@
     	if (hasRequiredRepeatAsync) return repeatAsync;
     	hasRequiredRepeatAsync = 1;
     repeatAsync.repeatAsync = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const errors_1 = requireEs2018();
     	function repeatAsync$1(iterable, times) {
     	    (0, errors_1.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -2095,7 +2101,7 @@
     	if (hasRequiredRepeat) return repeat;
     	hasRequiredRepeat = 1;
     repeat.repeat = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const errors_1 = requireEs2018();
     	function repeat$1(iterable, times) {
     	    (0, errors_1.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -2138,7 +2144,7 @@
     	if (hasRequiredSliceAsync) return sliceAsync;
     	hasRequiredSliceAsync = 1;
     sliceAsync.sliceAsync = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const errors_1 = requireEs2018();
     	function sliceAsync$1(iterable, start, end = Infinity) {
     	    (0, errors_1.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -2169,7 +2175,7 @@
     	if (hasRequiredSlice) return slice;
     	hasRequiredSlice = 1;
     slice.slice = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const errors_1 = requireEs2018();
     	function slice$1(iterable, start, end = Infinity) {
     	    (0, errors_1.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -2300,7 +2306,7 @@
     	if (hasRequiredTakeAsync) return takeAsync;
     	hasRequiredTakeAsync = 1;
     takeAsync.takeAsync = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const errors_1 = requireEs2018();
     	function takeAsync$1(iterable, count) {
     	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -2329,7 +2335,7 @@
     	if (hasRequiredTakeRightAsync) return takeRightAsync;
     	hasRequiredTakeRightAsync = 1;
     takeRightAsync.takeRightAsync = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const errors_1 = requireEs2018();
     	function takeRightAsync$1(iterable, count) {
     	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -2367,7 +2373,7 @@
     	if (hasRequiredTakeRight) return takeRight;
     	hasRequiredTakeRight = 1;
     takeRight.takeRight = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const errors_1 = requireEs2018();
     	function takeRight$1(iterable, count) {
     	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -2451,7 +2457,7 @@
     	if (hasRequiredTake) return take;
     	hasRequiredTake = 1;
     take.take = void 0;
-    	const go_1 = es2018$4;
+    	const go_1 = es2018$6;
     	const errors_1 = requireEs2018();
     	function take$1(iterable, count) {
     	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -3391,7 +3397,7 @@
     var hasRequiredEs2018$1;
 
     function requireEs2018$1 () {
-    	if (hasRequiredEs2018$1) return es2018$5;
+    	if (hasRequiredEs2018$1) return es2018$2;
     	hasRequiredEs2018$1 = 1;
     	(function (exports) {
     		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -3410,8 +3416,8 @@
     		};__exportStar(requireMiddleware(), exports);
     		__exportStar(output, exports);
     		
-    } (es2018$5));
-    	return es2018$5;
+    } (es2018$2));
+    	return es2018$2;
     }
 
     var getErrorNames$1 = {};
@@ -3615,7 +3621,7 @@
     var hasRequiredEs2018;
 
     function requireEs2018 () {
-    	if (hasRequiredEs2018) return es2018$6;
+    	if (hasRequiredEs2018) return es2018$3;
     	hasRequiredEs2018 = 1;
     	(function (exports) {
     		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -3640,8 +3646,8 @@
     		__exportStar(getErrorNames$1, exports);
     		__exportStar(traverseErrorPrototypeChain$1, exports);
     		
-    } (es2018$6));
-    	return es2018$6;
+    } (es2018$3));
+    	return es2018$3;
     }
 
     var es2018Exports$1 = requireEs2018();
@@ -3790,7 +3796,7 @@
             if (this.itemMetadataSortedByExpirationTime.length > 0) {
                 const item = this.itemMetadataSortedByExpirationTime[0];
                 if (Number.isFinite(item.expirationTime)) {
-                    const cancel = es2018$3.setSchedule(item.expirationTime, () => {
+                    const cancel = es2018$5.setSchedule(item.expirationTime, () => {
                         this.clearExpiredItems(Date.now());
                         this.rescheduleClearTimeout();
                     });
@@ -3918,7 +3924,7 @@
             if (this.itemMetadataSortedByExpirationTime.length > 0) {
                 const item = this.itemMetadataSortedByExpirationTime[0];
                 if (Number.isFinite(item.expirationTime)) {
-                    const cancel = es2018$3.setSchedule(item.expirationTime, () => {
+                    const cancel = es2018$5.setSchedule(item.expirationTime, () => {
                         this.clearExpiredItems(Date.now());
                         this.rescheduleClearTimeout();
                     });