@blackglory/structures 0.11.1 → 0.11.2

package/dist/es2018/index.mjs

@@ -671,146 +671,8 @@ function truncateArrayRight(arr, num) {
     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;
@@ -838,11 +700,11 @@ goMicrotask$1.goMicrotask = goMicrotask;
 
 var goMacrotask$1 = {};
 
-var es2018$3 = {};
+var es2018$5 = {};
 
 var exponentialBackoff = {};
 
-var es2018$2 = {};
+var es2018$4 = {};
 
 var random$1 = {};
 
@@ -886,10 +748,10 @@ randomIntInclusive$1.randomIntInclusive = randomIntInclusive;
 	__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) {
@@ -1004,10 +866,10 @@ setDynamicTimeoutLoop$1.setDynamicTimeoutLoop = setDynamicTimeoutLoop;
 	__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 () => {
@@ -1040,7 +902,151 @@ goMacrotask$1.goMacrotask = goMacrotask;
 	__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;
 
@@ -1048,7 +1054,7 @@ function requireChunkAsync () {
 	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');
@@ -1513,7 +1519,7 @@ function requireChunk () {
 	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');
@@ -1540,7 +1546,7 @@ var concatAsync$1 = {};
 
 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]) {
@@ -1562,7 +1568,7 @@ concatAsync$1.concatAsync = concatAsync;
 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]) {
@@ -1596,7 +1602,7 @@ function requireDropAsync () {
 	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) {
@@ -1639,7 +1645,7 @@ function requireDropRightAsync () {
 	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) {
@@ -1675,7 +1681,7 @@ function requireDropRight () {
 	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) {
@@ -1783,7 +1789,7 @@ function requireDrop () {
 	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) {
@@ -2046,7 +2052,7 @@ function requireRepeatAsync () {
 	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');
@@ -2089,7 +2095,7 @@ function requireRepeat () {
 	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');
@@ -2132,7 +2138,7 @@ function requireSliceAsync () {
 	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');
@@ -2163,7 +2169,7 @@ function requireSlice () {
 	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');
@@ -2294,7 +2300,7 @@ function requireTakeAsync () {
 	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');
@@ -2323,7 +2329,7 @@ function requireTakeRightAsync () {
 	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');
@@ -2361,7 +2367,7 @@ function requireTakeRight () {
 	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');
@@ -2445,7 +2451,7 @@ function requireTake () {
 	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');
@@ -3385,7 +3391,7 @@ groupByAsync$1.groupByAsync = groupByAsync;
 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) {
@@ -3404,8 +3410,8 @@ function requireEs2018$1 () {
 		};__exportStar(requireMiddleware(), exports);
 		__exportStar(output, exports);
 		
-} (es2018$5));
-	return es2018$5;
+} (es2018$2));
+	return es2018$2;
 }
 
 var getErrorNames$1 = {};
@@ -3609,7 +3615,7 @@ assert.assert = void 0;
 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) {
@@ -3634,8 +3640,8 @@ function requireEs2018 () {
 		__exportStar(getErrorNames$1, exports);
 		__exportStar(traverseErrorPrototypeChain$1, exports);
 		
-} (es2018$6));
-	return es2018$6;
+} (es2018$3));
+	return es2018$3;
 }
 
 var es2018Exports$1 = requireEs2018();
@@ -3784,7 +3790,7 @@ class ExpirableMap {
         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();
                 });
@@ -3912,7 +3918,7 @@ class TLRUMap {
         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();
                 });