first commit

node_modules/fast-unique-numbers/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Christoph Guttandin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/fast-unique-numbers/README.md

@@ -0,0 +1,51 @@
+# fast-unique-numbers
+
+**A module to create a set of unique numbers as fast as possible.**
+
+[![version](https://img.shields.io/npm/v/fast-unique-numbers.svg?style=flat-square)](https://www.npmjs.com/package/fast-unique-numbers)
+
+This module is meant to create unique numbers within a given [Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) or [Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set). To achieve that as fast as possible the resulting set of numbers will only contain integers. Additionally only small integers will be used for as long as possible. Small integers can be stored more efficiently by JavaScript engines like [SpiderMonkey](https://spidermonkey.dev/) or [V8](https://v8.dev).
+
+To verify the expected perfomance benefit an expectation test is used to make sure small integers do actually perform better in Chromium based browsers, Firefox and when using Node.js.
+
+## Usage
+
+This module is available on [npm](https://www.npmjs.com/package/fast-unique-numbers) and can be
+installed by running the following command:
+
+```shell
+npm install fast-unique-numbers
+```
+
+This module exports two functions.
+
+### addUniqueNumber()
+
+This function takes a `Set` of numbers as argument and appends a new unique number to it. It also returns that number.
+
+```js
+import { addUniqueNumber } from 'fast-unique-numbers';
+
+const set = new Set([1, 4, 8]);
+const uniqueNumber = addUniqueNumber(set);
+
+console.log(uniqueNumber); // 3
+console.log(set); // Set(4) { 1, 4, 8, 3 }
+```
+
+### generateUniqueNumber()
+
+This function can be used to generate a unique number which is not yet present in the given `Set` or is no key in the given `Map`. The resulting number gets not appended. It only gets returned.
+
+```js
+import { generateUniqueNumber } from 'fast-unique-numbers';
+
+const map = new Map([
+    [1, 'something'],
+    [4, 'something else']
+]);
+
+const uniqueNumber = generateUniqueNumber(map);
+
+console.log(uniqueNumber); // 2
+```

node_modules/fast-unique-numbers/build/es2019/factories/add-unique-number.d.ts

@@ -0,0 +1,3 @@
+import { TAddUniqueNumberFactory } from '../types';
+export declare const createAddUniqueNumber: TAddUniqueNumberFactory;
+//# sourceMappingURL=add-unique-number.d.ts.map

node_modules/fast-unique-numbers/build/es2019/factories/add-unique-number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-unique-number.d.ts","sourceRoot":"","sources":["../../../src/factories/add-unique-number.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAEnD,eAAO,MAAM,qBAAqB,EAAE,uBAQnC,CAAC"}

node_modules/fast-unique-numbers/build/es2019/factories/add-unique-number.js

@@ -0,0 +1,8 @@
+export const createAddUniqueNumber = (generateUniqueNumber) => {
+    return (set) => {
+        const number = generateUniqueNumber(set);
+        set.add(number);
+        return number;
+    };
+};
+//# sourceMappingURL=add-unique-number.js.map

node_modules/fast-unique-numbers/build/es2019/factories/add-unique-number.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-unique-number.js","sourceRoot":"","sources":["../../../src/factories/add-unique-number.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,qBAAqB,GAA4B,CAAC,oBAAoB,EAAE,EAAE;IACnF,OAAO,CAAC,GAAG,EAAE,EAAE;QACX,MAAM,MAAM,GAAG,oBAAoB,CAAC,GAAG,CAAC,CAAC;QAEzC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAEhB,OAAO,MAAM,CAAC;IAClB,CAAC,CAAC;AACN,CAAC,CAAC"}

node_modules/fast-unique-numbers/build/es2019/factories/cache.d.ts

@@ -0,0 +1,3 @@
+import { TCacheFactory } from '../types';
+export declare const createCache: TCacheFactory;
+//# sourceMappingURL=cache.d.ts.map

node_modules/fast-unique-numbers/build/es2019/factories/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/factories/cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,eAAO,MAAM,WAAW,EAAE,aAMzB,CAAC"}

node_modules/fast-unique-numbers/build/es2019/factories/cache.js

@@ -0,0 +1,7 @@
+export const createCache = (lastNumberWeakMap) => {
+    return (collection, nextNumber) => {
+        lastNumberWeakMap.set(collection, nextNumber);
+        return nextNumber;
+    };
+};
+//# sourceMappingURL=cache.js.map

node_modules/fast-unique-numbers/build/es2019/factories/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../src/factories/cache.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAkB,CAAC,iBAAiB,EAAE,EAAE;IAC5D,OAAO,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE;QAC9B,iBAAiB,CAAC,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QAE9C,OAAO,UAAU,CAAC;IACtB,CAAC,CAAC;AACN,CAAC,CAAC"}

node_modules/fast-unique-numbers/build/es2019/factories/generate-unique-number.d.ts

@@ -0,0 +1,3 @@
+import { TGenerateUniqueNumberFactory } from '../types';
+export declare const createGenerateUniqueNumber: TGenerateUniqueNumberFactory;
+//# sourceMappingURL=generate-unique-number.d.ts.map

node_modules/fast-unique-numbers/build/es2019/factories/generate-unique-number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-unique-number.d.ts","sourceRoot":"","sources":["../../../src/factories/generate-unique-number.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,UAAU,CAAC;AAUxD,eAAO,MAAM,0BAA0B,EAAE,4BA4CxC,CAAC"}

node_modules/fast-unique-numbers/build/es2019/factories/generate-unique-number.js

@@ -0,0 +1,46 @@
+/*
+ * The value of the constant Number.MAX_SAFE_INTEGER equals (2 ** 53 - 1) but it
+ * is fairly new.
+ */
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER === undefined ? 9007199254740991 : Number.MAX_SAFE_INTEGER;
+const TWO_TO_THE_POWER_OF_TWENTY_NINE = 536870912;
+const TWO_TO_THE_POWER_OF_THIRTY = TWO_TO_THE_POWER_OF_TWENTY_NINE * 2;
+export const createGenerateUniqueNumber = (cache, lastNumberWeakMap) => {
+    return (collection) => {
+        const lastNumber = lastNumberWeakMap.get(collection);
+        /*
+         * Let's try the cheapest algorithm first. It might fail to produce a new
+         * number, but it is so cheap that it is okay to take the risk. Just
+         * increase the last number by one or reset it to 0 if we reached the upper
+         * bound of SMIs (which stands for small integers). When the last number is
+         * unknown it is assumed that the collection contains zero based consecutive
+         * numbers.
+         */
+        let nextNumber = lastNumber === undefined ? collection.size : lastNumber < TWO_TO_THE_POWER_OF_THIRTY ? lastNumber + 1 : 0;
+        if (!collection.has(nextNumber)) {
+            return cache(collection, nextNumber);
+        }
+        /*
+         * If there are less than half of 2 ** 30 numbers stored in the collection,
+         * the chance to generate a new random number in the range from 0 to 2 ** 30
+         * is at least 50%. It's benifitial to use only SMIs because they perform
+         * much better in any environment based on V8.
+         */
+        if (collection.size < TWO_TO_THE_POWER_OF_TWENTY_NINE) {
+            while (collection.has(nextNumber)) {
+                nextNumber = Math.floor(Math.random() * TWO_TO_THE_POWER_OF_THIRTY);
+            }
+            return cache(collection, nextNumber);
+        }
+        // Quickly check if there is a theoretical chance to generate a new number.
+        if (collection.size > MAX_SAFE_INTEGER) {
+            throw new Error('Congratulations, you created a collection of unique numbers which uses all available integers!');
+        }
+        // Otherwise use the full scale of safely usable integers.
+        while (collection.has(nextNumber)) {
+            nextNumber = Math.floor(Math.random() * MAX_SAFE_INTEGER);
+        }
+        return cache(collection, nextNumber);
+    };
+};
+//# sourceMappingURL=generate-unique-number.js.map

node_modules/fast-unique-numbers/build/es2019/factories/generate-unique-number.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-unique-number.js","sourceRoot":"","sources":["../../../src/factories/generate-unique-number.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC;AAC5G,MAAM,+BAA+B,GAAG,SAAS,CAAC;AAClD,MAAM,0BAA0B,GAAG,+BAA+B,GAAG,CAAC,CAAC;AAEvE,MAAM,CAAC,MAAM,0BAA0B,GAAiC,CAAC,KAAK,EAAE,iBAAiB,EAAE,EAAE;IACjG,OAAO,CAAC,UAAU,EAAE,EAAE;QAClB,MAAM,UAAU,GAAG,iBAAiB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAErD;;;;;;;WAOG;QACH,IAAI,UAAU,GAAG,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,GAAG,0BAA0B,CAAC,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAE3H,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;YAC9B,OAAO,KAAK,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QACzC,CAAC;QAED;;;;;WAKG;QACH,IAAI,UAAU,CAAC,IAAI,GAAG,+BAA+B,EAAE,CAAC;YACpD,OAAO,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;gBAChC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,0BAA0B,CAAC,CAAC;YACxE,CAAC;YAED,OAAO,KAAK,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QACzC,CAAC;QAED,2EAA2E;QAC3E,IAAI,UAAU,CAAC,IAAI,GAAG,gBAAgB,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,gGAAgG,CAAC,CAAC;QACtH,CAAC;QAED,0DAA0D;QAC1D,OAAO,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;YAChC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,gBAAgB,CAAC,CAAC;QAC9D,CAAC;QAED,OAAO,KAAK,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IACzC,CAAC,CAAC;AACN,CAAC,CAAC"}

node_modules/fast-unique-numbers/build/es2019/module.d.ts

@@ -0,0 +1,5 @@
+export * from './types/index';
+declare const generateUniqueNumber: import("./types/generate-unique-number-function").TGenerateUniqueNumberFunction;
+declare const addUniqueNumber: import("./types/add-unique-number-function").TAddUniqueNumberFunction;
+export { addUniqueNumber, generateUniqueNumber };
+//# sourceMappingURL=module.d.ts.map

node_modules/fast-unique-numbers/build/es2019/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/module.ts"],"names":[],"mappings":"AAQA,cAAc,eAAe,CAAC;AAK9B,QAAA,MAAM,oBAAoB,iFAA0D,CAAC;AACrF,QAAA,MAAM,eAAe,uEAA8C,CAAC;AAEpE,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,CAAC"}

node_modules/fast-unique-numbers/build/es2019/module.js

@@ -0,0 +1,14 @@
+import { createAddUniqueNumber } from './factories/add-unique-number';
+import { createCache } from './factories/cache';
+import { createGenerateUniqueNumber } from './factories/generate-unique-number';
+/*
+ * @todo Explicitly referencing the barrel file seems to be necessary when enabling the
+ * isolatedModules compiler option.
+ */
+export * from './types/index';
+const LAST_NUMBER_WEAK_MAP = new WeakMap();
+const cache = createCache(LAST_NUMBER_WEAK_MAP);
+const generateUniqueNumber = createGenerateUniqueNumber(cache, LAST_NUMBER_WEAK_MAP);
+const addUniqueNumber = createAddUniqueNumber(generateUniqueNumber);
+export { addUniqueNumber, generateUniqueNumber };
+//# sourceMappingURL=module.js.map

node_modules/fast-unique-numbers/build/es2019/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../src/module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAEhF;;;GAGG;AACH,cAAc,eAAe,CAAC;AAE9B,MAAM,oBAAoB,GAAG,IAAI,OAAO,EAA0C,CAAC;AAEnF,MAAM,KAAK,GAAG,WAAW,CAAC,oBAAoB,CAAC,CAAC;AAChD,MAAM,oBAAoB,GAAG,0BAA0B,CAAC,KAAK,EAAE,oBAAoB,CAAC,CAAC;AACrF,MAAM,eAAe,GAAG,qBAAqB,CAAC,oBAAoB,CAAC,CAAC;AAEpE,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,CAAC"}

node_modules/fast-unique-numbers/build/es2019/types/add-unique-number-factory.d.ts

@@ -0,0 +1,4 @@
+import { TAddUniqueNumberFunction } from './add-unique-number-function';
+import { TGenerateUniqueNumberFunction } from './generate-unique-number-function';
+export type TAddUniqueNumberFactory = (generateUniqueNumber: TGenerateUniqueNumberFunction) => TAddUniqueNumberFunction;
+//# sourceMappingURL=add-unique-number-factory.d.ts.map

node_modules/fast-unique-numbers/build/es2019/types/add-unique-number-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-unique-number-factory.d.ts","sourceRoot":"","sources":["../../../src/types/add-unique-number-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AAElF,MAAM,MAAM,uBAAuB,GAAG,CAAC,oBAAoB,EAAE,6BAA6B,KAAK,wBAAwB,CAAC"}

node_modules/fast-unique-numbers/build/es2019/types/add-unique-number-factory.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=add-unique-number-factory.js.map

node_modules/fast-unique-numbers/build/es2019/types/add-unique-number-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-unique-number-factory.js","sourceRoot":"","sources":["../../../src/types/add-unique-number-factory.ts"],"names":[],"mappings":""}

node_modules/fast-unique-numbers/build/es2019/types/add-unique-number-function.d.ts

@@ -0,0 +1,2 @@
+export type TAddUniqueNumberFunction = (set: Set<number>) => number;
+//# sourceMappingURL=add-unique-number-function.d.ts.map

node_modules/fast-unique-numbers/build/es2019/types/add-unique-number-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-unique-number-function.d.ts","sourceRoot":"","sources":["../../../src/types/add-unique-number-function.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,wBAAwB,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC"}

node_modules/fast-unique-numbers/build/es2019/types/add-unique-number-function.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=add-unique-number-function.js.map

node_modules/fast-unique-numbers/build/es2019/types/add-unique-number-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-unique-number-function.js","sourceRoot":"","sources":["../../../src/types/add-unique-number-function.ts"],"names":[],"mappings":""}

node_modules/fast-unique-numbers/build/es2019/types/cache-factory.d.ts

@@ -0,0 +1,3 @@
+import { TCacheFunction } from './cache-function';
+export type TCacheFactory = (lastNumberWeakMap: WeakMap<Map<number, any> | Set<number>, number>) => TCacheFunction;
+//# sourceMappingURL=cache-factory.d.ts.map

node_modules/fast-unique-numbers/build/es2019/types/cache-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-factory.d.ts","sourceRoot":"","sources":["../../../src/types/cache-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,MAAM,MAAM,aAAa,GAAG,CAAC,iBAAiB,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,KAAK,cAAc,CAAC"}

node_modules/fast-unique-numbers/build/es2019/types/cache-factory.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cache-factory.js.map

node_modules/fast-unique-numbers/build/es2019/types/cache-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-factory.js","sourceRoot":"","sources":["../../../src/types/cache-factory.ts"],"names":[],"mappings":""}

node_modules/fast-unique-numbers/build/es2019/types/cache-function.d.ts

@@ -0,0 +1,2 @@
+export type TCacheFunction = (collection: Map<number, any> | Set<number>, nextNumber: number) => number;
+//# sourceMappingURL=cache-function.d.ts.map

node_modules/fast-unique-numbers/build/es2019/types/cache-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-function.d.ts","sourceRoot":"","sources":["../../../src/types/cache-function.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC"}

node_modules/fast-unique-numbers/build/es2019/types/cache-function.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cache-function.js.map

node_modules/fast-unique-numbers/build/es2019/types/cache-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-function.js","sourceRoot":"","sources":["../../../src/types/cache-function.ts"],"names":[],"mappings":""}

node_modules/fast-unique-numbers/build/es2019/types/generate-unique-number-factory.d.ts

@@ -0,0 +1,4 @@
+import { TCacheFunction } from './cache-function';
+import { TGenerateUniqueNumberFunction } from './generate-unique-number-function';
+export type TGenerateUniqueNumberFactory = (cache: TCacheFunction, lastNumberWeakMap: WeakMap<Map<number, any> | Set<number>, number>) => TGenerateUniqueNumberFunction;
+//# sourceMappingURL=generate-unique-number-factory.d.ts.map

node_modules/fast-unique-numbers/build/es2019/types/generate-unique-number-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-unique-number-factory.d.ts","sourceRoot":"","sources":["../../../src/types/generate-unique-number-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AAElF,MAAM,MAAM,4BAA4B,GAAG,CACvC,KAAK,EAAE,cAAc,EACrB,iBAAiB,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,KACjE,6BAA6B,CAAC"}

node_modules/fast-unique-numbers/build/es2019/types/generate-unique-number-factory.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-unique-number-factory.js.map

node_modules/fast-unique-numbers/build/es2019/types/generate-unique-number-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-unique-number-factory.js","sourceRoot":"","sources":["../../../src/types/generate-unique-number-factory.ts"],"names":[],"mappings":""}

node_modules/fast-unique-numbers/build/es2019/types/generate-unique-number-function.d.ts

@@ -0,0 +1,2 @@
+export type TGenerateUniqueNumberFunction = (collection: Map<number, any> | Set<number>) => number;
+//# sourceMappingURL=generate-unique-number-function.d.ts.map

node_modules/fast-unique-numbers/build/es2019/types/generate-unique-number-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-unique-number-function.d.ts","sourceRoot":"","sources":["../../../src/types/generate-unique-number-function.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,6BAA6B,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC"}

node_modules/fast-unique-numbers/build/es2019/types/generate-unique-number-function.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-unique-number-function.js.map

node_modules/fast-unique-numbers/build/es2019/types/generate-unique-number-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-unique-number-function.js","sourceRoot":"","sources":["../../../src/types/generate-unique-number-function.ts"],"names":[],"mappings":""}

node_modules/fast-unique-numbers/build/es2019/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './add-unique-number-factory';
+export * from './add-unique-number-function';
+export * from './cache-factory';
+export * from './cache-function';
+export * from './generate-unique-number-factory';
+export * from './generate-unique-number-function';
+//# sourceMappingURL=index.d.ts.map

node_modules/fast-unique-numbers/build/es2019/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC"}

node_modules/fast-unique-numbers/build/es2019/types/index.js

@@ -0,0 +1,7 @@
+export * from './add-unique-number-factory';
+export * from './add-unique-number-function';
+export * from './cache-factory';
+export * from './cache-function';
+export * from './generate-unique-number-factory';
+export * from './generate-unique-number-function';
+//# sourceMappingURL=index.js.map

node_modules/fast-unique-numbers/build/es2019/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC"}

node_modules/fast-unique-numbers/build/es5/bundle.js

@@ -0,0 +1,76 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.fastUniqueNumbers = {}));
+})(this, (function (exports) { 'use strict';
+
+    var createAddUniqueNumber = function createAddUniqueNumber(generateUniqueNumber) {
+      return function (set) {
+        var number = generateUniqueNumber(set);
+        set.add(number);
+        return number;
+      };
+    };
+
+    var createCache = function createCache(lastNumberWeakMap) {
+      return function (collection, nextNumber) {
+        lastNumberWeakMap.set(collection, nextNumber);
+        return nextNumber;
+      };
+    };
+
+    /*
+     * The value of the constant Number.MAX_SAFE_INTEGER equals (2 ** 53 - 1) but it
+     * is fairly new.
+     */
+    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER === undefined ? 9007199254740991 : Number.MAX_SAFE_INTEGER;
+    var TWO_TO_THE_POWER_OF_TWENTY_NINE = 536870912;
+    var TWO_TO_THE_POWER_OF_THIRTY = TWO_TO_THE_POWER_OF_TWENTY_NINE * 2;
+    var createGenerateUniqueNumber = function createGenerateUniqueNumber(cache, lastNumberWeakMap) {
+      return function (collection) {
+        var lastNumber = lastNumberWeakMap.get(collection);
+        /*
+         * Let's try the cheapest algorithm first. It might fail to produce a new
+         * number, but it is so cheap that it is okay to take the risk. Just
+         * increase the last number by one or reset it to 0 if we reached the upper
+         * bound of SMIs (which stands for small integers). When the last number is
+         * unknown it is assumed that the collection contains zero based consecutive
+         * numbers.
+         */
+        var nextNumber = lastNumber === undefined ? collection.size : lastNumber < TWO_TO_THE_POWER_OF_THIRTY ? lastNumber + 1 : 0;
+        if (!collection.has(nextNumber)) {
+          return cache(collection, nextNumber);
+        }
+        /*
+         * If there are less than half of 2 ** 30 numbers stored in the collection,
+         * the chance to generate a new random number in the range from 0 to 2 ** 30
+         * is at least 50%. It's benifitial to use only SMIs because they perform
+         * much better in any environment based on V8.
+         */
+        if (collection.size < TWO_TO_THE_POWER_OF_TWENTY_NINE) {
+          while (collection.has(nextNumber)) {
+            nextNumber = Math.floor(Math.random() * TWO_TO_THE_POWER_OF_THIRTY);
+          }
+          return cache(collection, nextNumber);
+        }
+        // Quickly check if there is a theoretical chance to generate a new number.
+        if (collection.size > MAX_SAFE_INTEGER) {
+          throw new Error('Congratulations, you created a collection of unique numbers which uses all available integers!');
+        }
+        // Otherwise use the full scale of safely usable integers.
+        while (collection.has(nextNumber)) {
+          nextNumber = Math.floor(Math.random() * MAX_SAFE_INTEGER);
+        }
+        return cache(collection, nextNumber);
+      };
+    };
+
+    var LAST_NUMBER_WEAK_MAP = new WeakMap();
+    var cache = createCache(LAST_NUMBER_WEAK_MAP);
+    var generateUniqueNumber = createGenerateUniqueNumber(cache, LAST_NUMBER_WEAK_MAP);
+    var addUniqueNumber = createAddUniqueNumber(generateUniqueNumber);
+
+    exports.addUniqueNumber = addUniqueNumber;
+    exports.generateUniqueNumber = generateUniqueNumber;
+
+}));

node_modules/fast-unique-numbers/build/node/factories/add-unique-number.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAddUniqueNumber = void 0;
+const createAddUniqueNumber = generateUniqueNumber => {
+  return set => {
+    const number = generateUniqueNumber(set);
+    set.add(number);
+    return number;
+  };
+};
+exports.createAddUniqueNumber = createAddUniqueNumber;

node_modules/fast-unique-numbers/build/node/factories/cache.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCache = void 0;
+const createCache = lastNumberWeakMap => {
+  return (collection, nextNumber) => {
+    lastNumberWeakMap.set(collection, nextNumber);
+    return nextNumber;
+  };
+};
+exports.createCache = createCache;

node_modules/fast-unique-numbers/build/node/factories/generate-unique-number.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createGenerateUniqueNumber = void 0;
+/*
+ * The value of the constant Number.MAX_SAFE_INTEGER equals (2 ** 53 - 1) but it
+ * is fairly new.
+ */
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER === undefined ? 9007199254740991 : Number.MAX_SAFE_INTEGER;
+const TWO_TO_THE_POWER_OF_TWENTY_NINE = 536870912;
+const TWO_TO_THE_POWER_OF_THIRTY = TWO_TO_THE_POWER_OF_TWENTY_NINE * 2;
+const createGenerateUniqueNumber = (cache, lastNumberWeakMap) => {
+  return collection => {
+    const lastNumber = lastNumberWeakMap.get(collection);
+    /*
+     * Let's try the cheapest algorithm first. It might fail to produce a new
+     * number, but it is so cheap that it is okay to take the risk. Just
+     * increase the last number by one or reset it to 0 if we reached the upper
+     * bound of SMIs (which stands for small integers). When the last number is
+     * unknown it is assumed that the collection contains zero based consecutive
+     * numbers.
+     */
+    let nextNumber = lastNumber === undefined ? collection.size : lastNumber < TWO_TO_THE_POWER_OF_THIRTY ? lastNumber + 1 : 0;
+    if (!collection.has(nextNumber)) {
+      return cache(collection, nextNumber);
+    }
+    /*
+     * If there are less than half of 2 ** 30 numbers stored in the collection,
+     * the chance to generate a new random number in the range from 0 to 2 ** 30
+     * is at least 50%. It's benifitial to use only SMIs because they perform
+     * much better in any environment based on V8.
+     */
+    if (collection.size < TWO_TO_THE_POWER_OF_TWENTY_NINE) {
+      while (collection.has(nextNumber)) {
+        nextNumber = Math.floor(Math.random() * TWO_TO_THE_POWER_OF_THIRTY);
+      }
+      return cache(collection, nextNumber);
+    }
+    // Quickly check if there is a theoretical chance to generate a new number.
+    if (collection.size > MAX_SAFE_INTEGER) {
+      throw new Error('Congratulations, you created a collection of unique numbers which uses all available integers!');
+    }
+    // Otherwise use the full scale of safely usable integers.
+    while (collection.has(nextNumber)) {
+      nextNumber = Math.floor(Math.random() * MAX_SAFE_INTEGER);
+    }
+    return cache(collection, nextNumber);
+  };
+};
+exports.createGenerateUniqueNumber = createGenerateUniqueNumber;

node_modules/fast-unique-numbers/build/node/module.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  addUniqueNumber: true,
+  generateUniqueNumber: true
+};
+exports.generateUniqueNumber = exports.addUniqueNumber = void 0;
+var _addUniqueNumber = require("./factories/add-unique-number");
+var _cache = require("./factories/cache");
+var _generateUniqueNumber = require("./factories/generate-unique-number");
+var _index = require("./types/index");
+Object.keys(_index).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _index[key];
+    }
+  });
+});
+/*
+ * @todo Explicitly referencing the barrel file seems to be necessary when enabling the
+ * isolatedModules compiler option.
+ */
+
+const LAST_NUMBER_WEAK_MAP = new WeakMap();
+const cache = (0, _cache.createCache)(LAST_NUMBER_WEAK_MAP);
+const generateUniqueNumber = exports.generateUniqueNumber = (0, _generateUniqueNumber.createGenerateUniqueNumber)(cache, LAST_NUMBER_WEAK_MAP);
+const addUniqueNumber = exports.addUniqueNumber = (0, _addUniqueNumber.createAddUniqueNumber)(generateUniqueNumber);

node_modules/fast-unique-numbers/build/node/types/add-unique-number-factory.js

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

node_modules/fast-unique-numbers/build/node/types/add-unique-number-function.js

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

node_modules/fast-unique-numbers/build/node/types/cache-factory.js

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

node_modules/fast-unique-numbers/build/node/types/cache-function.js

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

node_modules/fast-unique-numbers/build/node/types/generate-unique-number-factory.js

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

node_modules/fast-unique-numbers/build/node/types/generate-unique-number-function.js

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

node_modules/fast-unique-numbers/build/node/types/index.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _addUniqueNumberFactory = require("./add-unique-number-factory");
+Object.keys(_addUniqueNumberFactory).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _addUniqueNumberFactory[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _addUniqueNumberFactory[key];
+    }
+  });
+});
+var _addUniqueNumberFunction = require("./add-unique-number-function");
+Object.keys(_addUniqueNumberFunction).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _addUniqueNumberFunction[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _addUniqueNumberFunction[key];
+    }
+  });
+});
+var _cacheFactory = require("./cache-factory");
+Object.keys(_cacheFactory).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _cacheFactory[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cacheFactory[key];
+    }
+  });
+});
+var _cacheFunction = require("./cache-function");
+Object.keys(_cacheFunction).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _cacheFunction[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cacheFunction[key];
+    }
+  });
+});
+var _generateUniqueNumberFactory = require("./generate-unique-number-factory");
+Object.keys(_generateUniqueNumberFactory).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _generateUniqueNumberFactory[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generateUniqueNumberFactory[key];
+    }
+  });
+});
+var _generateUniqueNumberFunction = require("./generate-unique-number-function");
+Object.keys(_generateUniqueNumberFunction).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _generateUniqueNumberFunction[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generateUniqueNumberFunction[key];
+    }
+  });
+});

node_modules/fast-unique-numbers/package.json

@@ -0,0 +1,94 @@
+{
+    "author": "Christoph Guttandin",
+    "browser": "build/es5/bundle.js",
+    "bugs": {
+        "url": "https://github.com/chrisguttandin/fast-unique-numbers/issues"
+    },
+    "config": {
+        "commitizen": {
+            "path": "cz-conventional-changelog"
+        }
+    },
+    "dependencies": {
+        "@babel/runtime": "^7.23.8",
+        "tslib": "^2.6.2"
+    },
+    "description": "A module to create a set of unique numbers as fast as possible.",
+    "devDependencies": {
+        "@babel/cli": "^7.23.4",
+        "@babel/core": "^7.23.7",
+        "@babel/plugin-external-helpers": "^7.23.3",
+        "@babel/plugin-transform-runtime": "^7.23.7",
+        "@babel/preset-env": "^7.23.8",
+        "@babel/register": "^7.23.7",
+        "@commitlint/cli": "^17.8.0",
+        "@commitlint/config-angular": "^17.8.0",
+        "@rollup/plugin-babel": "^6.0.4",
+        "chai": "^4.3.10",
+        "commitizen": "^4.3.0",
+        "cz-conventional-changelog": "^3.3.0",
+        "eslint": "^8.56.0",
+        "eslint-config-holy-grail": "^57.2.27",
+        "grunt": "^1.6.1",
+        "grunt-cli": "^1.4.3",
+        "grunt-sh": "^0.2.1",
+        "husky": "^8.0.3",
+        "karma": "^6.4.2",
+        "karma-browserstack-launcher": "^1.6.0",
+        "karma-chrome-launcher": "^3.2.0",
+        "karma-firefox-launcher": "^2.1.2",
+        "karma-mocha": "^2.0.1",
+        "karma-sinon-chai": "^2.0.2",
+        "karma-webkit-launcher": "^2.4.0",
+        "karma-webpack": "^5.0.0",
+        "lint-staged": "^15.2.0",
+        "load-grunt-config": "^4.0.1",
+        "mocha": "^10.2.0",
+        "prettier": "^3.2.2",
+        "rimraf": "^5.0.5",
+        "rollup": "^4.9.5",
+        "sinon": "^17.0.1",
+        "sinon-chai": "^3.7.0",
+        "tinybench": "^2.6.0",
+        "ts-loader": "^9.5.1",
+        "tsconfig-holy-grail": "^14.0.8",
+        "tslint": "^6.1.3",
+        "tslint-config-holy-grail": "^55.0.5",
+        "typescript": "^5.3.3",
+        "webpack": "^5.89.0"
+    },
+    "engines": {
+        "node": ">=16.1.0"
+    },
+    "files": [
+        "build/es2019/",
+        "build/es5/",
+        "build/node/",
+        "src/"
+    ],
+    "homepage": "https://github.com/chrisguttandin/fast-unique-numbers",
+    "keywords": [
+        "performance",
+        "speed"
+    ],
+    "license": "MIT",
+    "main": "build/node/module.js",
+    "module": "build/es2019/module.js",
+    "name": "fast-unique-numbers",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/chrisguttandin/fast-unique-numbers.git"
+    },
+    "scripts": {
+        "build": "rimraf build/* && tsc --project src/tsconfig.json && rollup --config config/rollup/bundle.mjs && babel ./build/es2019 --config-file ./config/babel/build.json --out-dir ./build/node",
+        "lint": "npm run lint:config && npm run lint:src && npm run lint:test",
+        "lint:config": "eslint --config config/eslint/config.json --ext .js --report-unused-disable-directives config/",
+        "lint:src": "tslint --config config/tslint/src.json --project src/tsconfig.json src/*.ts src/**/*.ts",
+        "lint:test": "eslint --config config/eslint/test.json --ext .js --report-unused-disable-directives test/",
+        "prepare": "husky install",
+        "prepublishOnly": "npm run build",
+        "test": "grunt lint && grunt test"
+    },
+    "types": "build/es2019/module.d.ts",
+    "version": "8.0.13"
+}

node_modules/fast-unique-numbers/src/factories/add-unique-number.ts

@@ -0,0 +1,11 @@
+import { TAddUniqueNumberFactory } from '../types';
+
+export const createAddUniqueNumber: TAddUniqueNumberFactory = (generateUniqueNumber) => {
+    return (set) => {
+        const number = generateUniqueNumber(set);
+
+        set.add(number);
+
+        return number;
+    };
+};

node_modules/fast-unique-numbers/src/factories/cache.ts

@@ -0,0 +1,9 @@
+import { TCacheFactory } from '../types';
+
+export const createCache: TCacheFactory = (lastNumberWeakMap) => {
+    return (collection, nextNumber) => {
+        lastNumberWeakMap.set(collection, nextNumber);
+
+        return nextNumber;
+    };
+};

node_modules/fast-unique-numbers/src/factories/generate-unique-number.ts

@@ -0,0 +1,55 @@
+import { TGenerateUniqueNumberFactory } from '../types';
+
+/*
+ * The value of the constant Number.MAX_SAFE_INTEGER equals (2 ** 53 - 1) but it
+ * is fairly new.
+ */
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER === undefined ? 9007199254740991 : Number.MAX_SAFE_INTEGER;
+const TWO_TO_THE_POWER_OF_TWENTY_NINE = 536870912;
+const TWO_TO_THE_POWER_OF_THIRTY = TWO_TO_THE_POWER_OF_TWENTY_NINE * 2;
+
+export const createGenerateUniqueNumber: TGenerateUniqueNumberFactory = (cache, lastNumberWeakMap) => {
+    return (collection) => {
+        const lastNumber = lastNumberWeakMap.get(collection);
+
+        /*
+         * Let's try the cheapest algorithm first. It might fail to produce a new
+         * number, but it is so cheap that it is okay to take the risk. Just
+         * increase the last number by one or reset it to 0 if we reached the upper
+         * bound of SMIs (which stands for small integers). When the last number is
+         * unknown it is assumed that the collection contains zero based consecutive
+         * numbers.
+         */
+        let nextNumber = lastNumber === undefined ? collection.size : lastNumber < TWO_TO_THE_POWER_OF_THIRTY ? lastNumber + 1 : 0;
+
+        if (!collection.has(nextNumber)) {
+            return cache(collection, nextNumber);
+        }
+
+        /*
+         * If there are less than half of 2 ** 30 numbers stored in the collection,
+         * the chance to generate a new random number in the range from 0 to 2 ** 30
+         * is at least 50%. It's benifitial to use only SMIs because they perform
+         * much better in any environment based on V8.
+         */
+        if (collection.size < TWO_TO_THE_POWER_OF_TWENTY_NINE) {
+            while (collection.has(nextNumber)) {
+                nextNumber = Math.floor(Math.random() * TWO_TO_THE_POWER_OF_THIRTY);
+            }
+
+            return cache(collection, nextNumber);
+        }
+
+        // Quickly check if there is a theoretical chance to generate a new number.
+        if (collection.size > MAX_SAFE_INTEGER) {
+            throw new Error('Congratulations, you created a collection of unique numbers which uses all available integers!');
+        }
+
+        // Otherwise use the full scale of safely usable integers.
+        while (collection.has(nextNumber)) {
+            nextNumber = Math.floor(Math.random() * MAX_SAFE_INTEGER);
+        }
+
+        return cache(collection, nextNumber);
+    };
+};

node_modules/fast-unique-numbers/src/module.ts

@@ -0,0 +1,17 @@
+import { createAddUniqueNumber } from './factories/add-unique-number';
+import { createCache } from './factories/cache';
+import { createGenerateUniqueNumber } from './factories/generate-unique-number';
+
+/*
+ * @todo Explicitly referencing the barrel file seems to be necessary when enabling the
+ * isolatedModules compiler option.
+ */
+export * from './types/index';
+
+const LAST_NUMBER_WEAK_MAP = new WeakMap<Map<number, any> | Set<number>, number>();
+
+const cache = createCache(LAST_NUMBER_WEAK_MAP);
+const generateUniqueNumber = createGenerateUniqueNumber(cache, LAST_NUMBER_WEAK_MAP);
+const addUniqueNumber = createAddUniqueNumber(generateUniqueNumber);
+
+export { addUniqueNumber, generateUniqueNumber };

node_modules/fast-unique-numbers/src/tsconfig.json

@@ -0,0 +1,6 @@
+{
+    "compilerOptions": {
+        "isolatedModules": true
+    },
+    "extends": "tsconfig-holy-grail/src/tsconfig-universal"
+}

node_modules/fast-unique-numbers/src/types/add-unique-number-factory.ts

@@ -0,0 +1,4 @@
+import { TAddUniqueNumberFunction } from './add-unique-number-function';
+import { TGenerateUniqueNumberFunction } from './generate-unique-number-function';
+
+export type TAddUniqueNumberFactory = (generateUniqueNumber: TGenerateUniqueNumberFunction) => TAddUniqueNumberFunction;

node_modules/fast-unique-numbers/src/types/add-unique-number-function.ts

@@ -0,0 +1 @@
+export type TAddUniqueNumberFunction = (set: Set<number>) => number;

node_modules/fast-unique-numbers/src/types/cache-factory.ts

@@ -0,0 +1,3 @@
+import { TCacheFunction } from './cache-function';
+
+export type TCacheFactory = (lastNumberWeakMap: WeakMap<Map<number, any> | Set<number>, number>) => TCacheFunction;

node_modules/fast-unique-numbers/src/types/cache-function.ts

@@ -0,0 +1 @@
+export type TCacheFunction = (collection: Map<number, any> | Set<number>, nextNumber: number) => number;

node_modules/fast-unique-numbers/src/types/generate-unique-number-factory.ts

@@ -0,0 +1,7 @@
+import { TCacheFunction } from './cache-function';
+import { TGenerateUniqueNumberFunction } from './generate-unique-number-function';
+
+export type TGenerateUniqueNumberFactory = (
+    cache: TCacheFunction,
+    lastNumberWeakMap: WeakMap<Map<number, any> | Set<number>, number>
+) => TGenerateUniqueNumberFunction;

node_modules/fast-unique-numbers/src/types/generate-unique-number-function.ts

@@ -0,0 +1 @@
+export type TGenerateUniqueNumberFunction = (collection: Map<number, any> | Set<number>) => number;

node_modules/fast-unique-numbers/src/types/index.ts

@@ -0,0 +1,6 @@
+export * from './add-unique-number-factory';
+export * from './add-unique-number-function';
+export * from './cache-factory';
+export * from './cache-function';
+export * from './generate-unique-number-factory';
+export * from './generate-unique-number-function';