socket-function 1.1.49 → 1.2.1

package/src/dist/misc.ts.cache

@@ -0,0 +1,499 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.watchSlowPromise = exports.errorToWarning = exports.timeoutToUndefinedSilent = exports.timeoutToUndefined = exports.timeoutToError = exports.removeFromSortedList = exports.insertIntoSortedList = exports.compareArray = exports.compare = exports.binarySearchIndex = exports.binarySearchBasic2 = exports.binarySearchBasic = exports.QueueLimited = exports.getRootDomain = exports.sort = exports.keys = exports.entries = exports.last = exports.arrayFromOrderObject = exports.nextId = exports.throttleFunction = exports.promiseObj = exports.PromiseObj = exports.deepCloneJSON = exports.keyByArray = exports.keyBy = exports.getStringKeys = exports.getKeys = exports.isBufferType = exports.recursiveFreeze = exports.list = exports.formatNumberSuffixed = exports.isNodeTrue = exports.isNode = exports.arrayEqual = exports.sha256BufferPromise = exports.sha256HashPromise = exports.sha256HashBuffer = exports.sha256Hash = exports.convertErrorStackToError = exports.timeInYear = exports.timeInWeek = exports.timeInDay = exports.timeInHour = exports.timeInMinute = exports.timeInSecond = void 0;
+const types_1 = require("./types");
+const format_1 = require("./formatting/format");
+const batching_1 = require("./batching");
+const logColors_1 = require("./formatting/logColors");
+exports.timeInSecond = 1000;
+exports.timeInMinute = exports.timeInSecond * 60;
+exports.timeInHour = exports.timeInMinute * 60;
+exports.timeInDay = exports.timeInHour * 24;
+exports.timeInWeek = exports.timeInDay * 7;
+exports.timeInYear = exports.timeInDay * 365;
+function convertErrorStackToError(error) {
+    let errorObj = new Error();
+    errorObj.stack = String(error);
+    errorObj.message = String(error).split("\n")[0].slice("Error: ".length);
+    return errorObj;
+}
+exports.convertErrorStackToError = convertErrorStackToError;
+function sha256Hash(buffer) {
+    return require("crypto").createHash("sha256").update(buffer).digest("hex");
+}
+exports.sha256Hash = sha256Hash;
+function sha256HashBuffer(buffer) {
+    return require("crypto").createHash("sha256").update(buffer).digest();
+}
+exports.sha256HashBuffer = sha256HashBuffer;
+/** Async, but works both clientside and serverside. */
+async function sha256HashPromise(buffer) {
+    if (isNode()) {
+        return require("crypto").createHash("sha256").update(buffer).digest("hex");
+    }
+    else {
+        let buf = await window.crypto.subtle.digest("SHA-256", buffer);
+        return Buffer.from(buf).toString("hex");
+    }
+}
+exports.sha256HashPromise = sha256HashPromise;
+async function sha256BufferPromise(buffer) {
+    if (isNode()) {
+        return require("crypto").createHash("sha256").update(buffer).digest();
+    }
+    else {
+        let buf = await window.crypto.subtle.digest("SHA-256", buffer);
+        return Buffer.from(buf);
+    }
+}
+exports.sha256BufferPromise = sha256BufferPromise;
+function arrayEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+exports.arrayEqual = arrayEqual;
+function isNode() {
+    return typeof document === "undefined" && typeof globalThis.WorkerGlobalScope === "undefined";
+}
+exports.isNode = isNode;
+function isNodeTrue() {
+    return isNode();
+}
+exports.isNodeTrue = isNodeTrue;
+function formatNumberSuffixed(count) {
+    return (0, format_1.formatNumber)(count);
+}
+exports.formatNumberSuffixed = formatNumberSuffixed;
+function list(count) {
+    let arr = [];
+    for (let i = 0; i < count; i++) {
+        arr.push(i);
+    }
+    return arr;
+}
+exports.list = list;
+function recursiveFreeze(obj) {
+    if (!(0, types_1.canHaveChildren)(obj))
+        return obj;
+    let visited = new Set();
+    function iterate(obj) {
+        if (!(0, types_1.canHaveChildren)(obj))
+            return;
+        if (visited.has(obj))
+            return;
+        visited.add(obj);
+        if (ArrayBuffer.isView(obj))
+            return;
+        Object.freeze(obj);
+        let keys = getKeys(obj);
+        for (let key of keys) {
+            iterate(obj[key]);
+        }
+    }
+    iterate(obj);
+    return obj;
+}
+exports.recursiveFreeze = recursiveFreeze;
+function isBufferType(obj) {
+    if (typeof obj !== "object")
+        return false;
+    if (!obj)
+        return false;
+    if (ArrayBuffer.isView(obj))
+        return true;
+    if (obj instanceof ArrayBuffer)
+        return true;
+    if (global.SharedArrayBuffer && obj instanceof global.SharedArrayBuffer)
+        return true;
+    return false;
+}
+exports.isBufferType = isBufferType;
+function getKeys(obj) {
+    if (typeof obj !== "object" && typeof obj !== "function" || obj === null) {
+        return [];
+    }
+    if (obj instanceof MessagePort) {
+        return [];
+    }
+    let keyArray;
+    if (isBufferType(obj)) {
+        keyArray = [];
+    }
+    else if (Array.isArray(obj)) {
+        // NOTE: We convert the indexes to strings, because that is what javascript does,
+        //  and differing from it causes regressions that we simply cannot rectify (it breaks hashing
+        //  consistency).
+        keyArray = Array(obj.length).fill(0).map((x, i) => String(i));
+    }
+    else {
+        keyArray = Object.keys(obj);
+    }
+    for (let symbol of Object.getOwnPropertySymbols(obj)) {
+        let key = Symbol.keyFor(symbol);
+        if (key) {
+            keyArray.push(symbol);
+        }
+    }
+    return keyArray;
+}
+exports.getKeys = getKeys;
+function getStringKeys(obj) {
+    return Object.keys(obj);
+}
+exports.getStringKeys = getStringKeys;
+function keyBy(arr, getKey) {
+    let map = new Map();
+    for (let item of arr) {
+        map.set(getKey(item), item);
+    }
+    return map;
+}
+exports.keyBy = keyBy;
+function keyByArray(arr, getKey) {
+    let map = new Map();
+    for (let item of arr) {
+        let key = getKey(item);
+        let arr = map.get(key);
+        if (!arr) {
+            arr = [];
+            map.set(key, arr);
+        }
+        arr.push(item);
+    }
+    return map;
+}
+exports.keyByArray = keyByArray;
+function deepCloneJSON(obj) {
+    if (obj === undefined)
+        return obj;
+    let str = JSON.stringify(obj);
+    // It is possible for an object to not be defined, but return undefined when JSON.stringified,
+    //  via overriding the toJSON method.
+    if (str === undefined)
+        return undefined;
+    return JSON.parse(str);
+}
+exports.deepCloneJSON = deepCloneJSON;
+class PromiseObj {
+    constructor() {
+        this.resolve = (value) => {
+            this.resolveCalled = true;
+            if (typeof value === "object" && value !== null && value instanceof Promise) {
+                value.then(value => this.value = { value }, error => this.value = { error });
+            }
+            else {
+                this.value = { value };
+            }
+            this.baseResolve(value);
+        };
+        this.reject = (error) => {
+            this.baseReject(error);
+        };
+        this.promise = new Promise((resolve, reject) => {
+            this.baseResolve = resolve;
+            this.baseReject = reject;
+        });
+        this.promise.then(value => this.value = { value }, error => this.value = { error });
+    }
+}
+exports.PromiseObj = PromiseObj;
+function promiseObj() {
+    return new PromiseObj();
+}
+exports.promiseObj = promiseObj;
+// Allows an immediate call, then delays the next call until the first call finishes + delay
+//  - Drops all but the latest call, but only resolves the promises return to all
+//      calls once the latest call finishes.
+//  - Esentially the same as saying "don't run this function too often, don't run it in parallel,
+//      and don't let functions runs be too close together".
+function throttleFunction(delay, fnc) {
+    let nextAllowedCall = 0;
+    let pendingArgs = undefined;
+    function doCall(args, promiseObj) {
+        try {
+            let result = fnc(...args);
+            promiseObj.resolve(result);
+            if (result instanceof Promise) {
+                // NOTE: The caller should handle the promise. If not, they probably
+                //  want the unresolved promise rejection, so they can handle it properly.
+                void result.finally(() => {
+                    nextAllowedCall = Date.now() + delay;
+                    runNextCall();
+                });
+            }
+            else {
+                nextAllowedCall = Date.now() + delay;
+                runNextCall();
+            }
+        }
+        catch (e) {
+            promiseObj.reject(e);
+            nextAllowedCall = Date.now() + delay;
+            runNextCall();
+        }
+    }
+    function runNextCall() {
+        if (nextAllowedCall === Number.POSITIVE_INFINITY)
+            return;
+        if (!pendingArgs)
+            return;
+        let time = Date.now();
+        if (time > nextAllowedCall) {
+            // Set nextAllowedCall to infinity, to prevent new calls from running
+            //  until doCall finishes.
+            nextAllowedCall = Number.POSITIVE_INFINITY;
+            // Delay, so we don't turn a series of sequential calls to a series of nested calls
+            //  (which will cause a stack overflow)
+            setTimeout(() => {
+                let args = pendingArgs;
+                pendingArgs = undefined;
+                if (!args) {
+                    nextAllowedCall = 0;
+                    console.warn(`Impossible, pendingArgs was reset when we shouldn't have even been in a call`);
+                    return;
+                }
+                doCall(args.args, args.promiseObj);
+            }, 0);
+        }
+        else {
+            setTimeout(runNextCall, nextAllowedCall - time);
+        }
+    }
+    return function (...args) {
+        if (pendingArgs) {
+            pendingArgs.args = args;
+            return pendingArgs.promiseObj.promise;
+        }
+        pendingArgs = { args, promiseObj: promiseObj() };
+        runNextCall();
+        return pendingArgs.promiseObj.promise;
+    };
+}
+exports.throttleFunction = throttleFunction;
+function nextId() {
+    return Date.now() + "_" + Math.random();
+}
+exports.nextId = nextId;
+function arrayFromOrderObject(obj) {
+    if (Array.isArray(obj))
+        return obj.slice();
+    return Object.entries(obj).sort((a, b) => +a[0] - +b[0]).map(x => x[1]).filter(x => x !== undefined && x !== null);
+}
+exports.arrayFromOrderObject = arrayFromOrderObject;
+function last(arr) {
+    return arr[arr.length - 1];
+}
+exports.last = last;
+function entries(obj) {
+    return Object.entries(obj);
+}
+exports.entries = entries;
+function keys(obj) {
+    return Object.keys(obj);
+}
+exports.keys = keys;
+function sort(arr, sortKey) {
+    if (arr.length <= 1)
+        return arr;
+    arr.sort((a, b) => compare(sortKey(a), sortKey(b)));
+    return arr;
+}
+exports.sort = sort;
+function getRootDomain(hostname) {
+    if (hostname.startsWith("https://")) {
+        hostname = hostname.slice("https://".length);
+    }
+    hostname = hostname.split("/")[0];
+    let parts = hostname.split(".");
+    hostname = parts.slice(-2).join(".");
+    hostname = hostname.split(":")[0];
+    return hostname;
+}
+exports.getRootDomain = getRootDomain;
+class QueueLimited {
+    constructor(maxCount) {
+        this.maxCount = maxCount;
+        this.items = [];
+        this.nextIndex = 0;
+    }
+    push(item) {
+        this.items[this.nextIndex] = item;
+        this.nextIndex = (this.nextIndex + 1) % this.maxCount;
+    }
+    getAllUnordered() {
+        return this.items;
+    }
+    reset() {
+        this.items = [];
+        this.nextIndex = 0;
+    }
+    clear() {
+        this.reset();
+    }
+    getOldest() {
+        if (this.items.length === 0)
+            return undefined;
+        let index = this.nextIndex - 1;
+        if (index === -1) {
+            index += this.maxCount;
+        }
+        return this.items[index];
+    }
+}
+exports.QueueLimited = QueueLimited;
+function binarySearchBasic(array, getVal, searchValue) {
+    return binarySearchIndex(array.length, i => compare(getVal(array[i]), searchValue));
+}
+exports.binarySearchBasic = binarySearchBasic;
+function binarySearchBasic2(array, getVal, searchValue) {
+    return binarySearchIndex(array.length, i => compare(getVal(array[i]), getVal(searchValue)));
+}
+exports.binarySearchBasic2 = binarySearchBasic2;
+/**
+ *  Searches indexes, allowing you to query structures that aren't arrays. To search an array, use:
+ *      `binarySearchIndex(array.length, i => compare(array[i], searchValue))`
+ *
+ *      NOTE: If there are duplicates, returns the first match.
+ *
+ *      NOTE: If the value can't be found, returns the bitwise negation of the index where it should be inserted.
+ *
+ *      NOTE: With `if (index < 0) index = ~index;` you will get an index of the value >= the target value.
+ */
+function binarySearchIndex(listCount, compare) {
+    if (listCount === 0) {
+        return ~0;
+    }
+    let min = 0;
+    let max = listCount - 1;
+    while (min < max) {
+        let fingerIndex = Math.floor((max + min) / 2);
+        let comparisonValue = compare(fingerIndex);
+        if (comparisonValue < 0) {
+            min = fingerIndex + 1;
+        }
+        else {
+            max = fingerIndex;
+        }
+    }
+    let comparison = compare(min);
+    if (comparison === 0)
+        return min;
+    if (comparison > 0)
+        return ~min;
+    return ~(min + 1);
+}
+exports.binarySearchIndex = binarySearchIndex;
+function compare(lhs, rhs) {
+    if (typeof lhs !== typeof rhs) {
+        return compare(typeof lhs, typeof rhs);
+    }
+    if (lhs === rhs)
+        return 0;
+    if (lhs === null && rhs !== null)
+        return -1;
+    if (lhs !== null && rhs === null)
+        return 1;
+    if (typeof lhs === "number") {
+        if (Number.isNaN(lhs)) {
+            if (Number.isNaN(rhs))
+                return 0;
+            return -1;
+        }
+        else {
+            if (Number.isNaN(rhs))
+                return +1;
+        }
+    }
+    if (lhs < rhs)
+        return -1;
+    return 1;
+}
+exports.compare = compare;
+function compareArray(lhs, rhs) {
+    for (let i = 0; i < Math.min(lhs.length, rhs.length); i++) {
+        let comparison = compare(lhs[i], rhs[i]);
+        if (comparison !== 0)
+            return comparison;
+    }
+    return lhs.length - rhs.length;
+}
+exports.compareArray = compareArray;
+function insertIntoSortedList(list, map, element) {
+    let searchValue = map(element);
+    let index = binarySearchIndex(list.length, i => compare(map(list[i]), searchValue));
+    if (index < 0)
+        index = ~index;
+    list.splice(index, 0, element);
+}
+exports.insertIntoSortedList = insertIntoSortedList;
+function removeFromSortedList(list, map, searchValue) {
+    let index = binarySearchIndex(list.length, i => compare(map(list[i]), searchValue));
+    if (index < 0)
+        return;
+    list.splice(index, 1);
+}
+exports.removeFromSortedList = removeFromSortedList;
+function timeoutToError(time, p, err) {
+    return new Promise((resolve, reject) => {
+        let timeout = setTimeout(() => reject(err()), time);
+        p.then(resolve, reject).finally(() => clearTimeout(timeout));
+    });
+}
+exports.timeoutToError = timeoutToError;
+// NOTE: Both errors and timeouts are converted to undefined
+function timeoutToUndefined(time, p) {
+    return new Promise((resolve, reject) => {
+        let timeout = setTimeout(() => {
+            console.error(`timeoutToUndefined timed out after ${time}`);
+            resolve(undefined);
+        }, time);
+        p.then(resolve, (err) => {
+            console.error(`timeoutToUndefined error: ${err.stack}`);
+            resolve(undefined);
+        }).finally(() => clearTimeout(timeout));
+    });
+}
+exports.timeoutToUndefined = timeoutToUndefined;
+function timeoutToUndefinedSilent(time, p) {
+    return new Promise((resolve, reject) => {
+        let timeout = setTimeout(() => {
+            resolve(undefined);
+        }, time);
+        p.then(resolve, (err) => {
+            resolve(undefined);
+        }).finally(() => clearTimeout(timeout));
+    });
+}
+exports.timeoutToUndefinedSilent = timeoutToUndefinedSilent;
+function errorToWarning(promise) {
+    // Return the promise, so they can wait if they want, but have the return type be void,
+    //  so that they don't have to await it.
+    return promise.catch(e => {
+        console.warn(e.stack);
+        return undefined;
+    });
+}
+exports.errorToWarning = errorToWarning;
+function watchSlowPromise(title, promise, config) {
+    let { interval = 5000 } = config || {};
+    let fulfilled = false;
+    void promise.finally(() => fulfilled = true);
+    let startTime = Date.now();
+    void (async () => {
+        while (true) {
+            await (0, batching_1.delay)(interval);
+            if (fulfilled)
+                break;
+            console.log(`${(0, logColors_1.yellow)(`Slow promise running for ${(0, format_1.formatTime)(Date.now() - startTime)}`)} | ${title}`);
+        }
+    })();
+    return promise;
+}
+exports.watchSlowPromise = watchSlowPromise;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"misc.js","sourceRoot":"","sources":["misc.ts"],"names":[],"mappings":"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","sourcesContent":["import { canHaveChildren, MaybePromise } from \"./types\";\nimport { formatNumber, formatTime } from \"./formatting/format\";\nimport { delay } from \"./batching\";\nimport { yellow } from \"./formatting/logColors\";\n\nexport const timeInSecond = 1000;\nexport const timeInMinute = timeInSecond * 60;\nexport const timeInHour = timeInMinute * 60;\nexport const timeInDay = timeInHour * 24;\nexport const timeInWeek = timeInDay * 7;\nexport const timeInYear = timeInDay * 365;\n\nexport type Watchable<T> = (callback: (value: T) => void) => MaybePromise<void>;\n\nexport function convertErrorStackToError(error: string): Error {\n    let errorObj = new Error();\n    errorObj.stack = String(error);\n    errorObj.message = String(error).split(\"\\n\")[0].slice(\"Error: \".length);\n    return errorObj;\n}\n\n\nexport function sha256Hash(buffer: Buffer | string): string {\n    return require(\"crypto\").createHash(\"sha256\").update(buffer).digest(\"hex\");\n}\nexport function sha256HashBuffer(buffer: Buffer | string): Buffer {\n    return require(\"crypto\").createHash(\"sha256\").update(buffer).digest();\n}\n/** Async, but works both clientside and serverside. */\nexport async function sha256HashPromise(buffer: Buffer) {\n    if (isNode()) {\n        return require(\"crypto\").createHash(\"sha256\").update(buffer).digest(\"hex\");\n    } else {\n        let buf = await window.crypto.subtle.digest(\"SHA-256\", buffer);\n        return Buffer.from(buf).toString(\"hex\");\n    }\n}\nexport async function sha256BufferPromise(buffer: Buffer): Promise<Buffer> {\n    if (isNode()) {\n        return require(\"crypto\").createHash(\"sha256\").update(buffer).digest();\n    } else {\n        let buf = await window.crypto.subtle.digest(\"SHA-256\", buffer);\n        return Buffer.from(buf);\n    }\n}\n\n\nexport function arrayEqual(a: { [key: number]: unknown; length: number }, b: { [key: number]: unknown; length: number },) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n        if (a[i] !== b[i]) return false;\n    }\n    return true;\n}\nexport function isNode() {\n    return typeof document === \"undefined\" && typeof (globalThis as any).WorkerGlobalScope === \"undefined\";\n}\n\nexport function isNodeTrue() {\n    return isNode() as true;\n}\n\nexport function formatNumberSuffixed(count: number): string {\n    return formatNumber(count);\n}\n\nexport function list(count: number) {\n    let arr: number[] = [];\n    for (let i = 0; i < count; i++) {\n        arr.push(i);\n    }\n    return arr;\n}\n\nexport function recursiveFreeze<T>(obj: T): T {\n    if (!canHaveChildren(obj)) return obj;\n    let visited = new Set<unknown>();\n    function iterate(obj: unknown) {\n        if (!canHaveChildren(obj)) return;\n        if (visited.has(obj)) return;\n        visited.add(obj);\n        if (ArrayBuffer.isView(obj)) return;\n        Object.freeze(obj);\n        let keys = getKeys(obj);\n        for (let key of keys) {\n            iterate(obj[key]);\n        }\n    }\n    iterate(obj);\n    return obj;\n}\nexport type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;\nexport type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;\nexport function isBufferType(obj: unknown): obj is BufferType {\n    if (typeof obj !== \"object\") return false;\n    if (!obj) return false;\n    if (ArrayBuffer.isView(obj)) return true;\n    if (obj instanceof ArrayBuffer) return true;\n    if (global.SharedArrayBuffer && obj instanceof global.SharedArrayBuffer) return true;\n    return false;\n}\nexport function getKeys(obj: unknown) {\n    if (typeof obj !== \"object\" && typeof obj !== \"function\" || obj === null) {\n        return [];\n    }\n    if (obj instanceof MessagePort) {\n        return [];\n    }\n    let keyArray: PropertyKey[];\n    if (isBufferType(obj)) {\n        keyArray = [];\n    } else if (Array.isArray(obj)) {\n        // NOTE: We convert the indexes to strings, because that is what javascript does,\n        //  and differing from it causes regressions that we simply cannot rectify (it breaks hashing\n        //  consistency).\n        keyArray = Array(obj.length).fill(0).map((x, i) => String(i));\n    } else {\n        keyArray = Object.keys(obj);\n    }\n    for (let symbol of Object.getOwnPropertySymbols(obj)) {\n        let key = Symbol.keyFor(symbol);\n        if (key) {\n            keyArray.push(symbol);\n        }\n    }\n    return keyArray;\n}\nexport function getStringKeys<T extends {}>(obj: T): ((keyof T) & string)[] {\n    return Object.keys(obj) as any;\n}\n\nexport function keyBy<T, K>(arr: T[], getKey: (value: T) => K): Map<K, T> {\n    let map = new Map<K, T>();\n    for (let item of arr) {\n        map.set(getKey(item), item);\n    }\n    return map;\n}\nexport function keyByArray<T, K>(arr: T[], getKey: (value: T) => K): Map<K, T[]> {\n    let map = new Map<K, T[]>();\n    for (let item of arr) {\n        let key = getKey(item);\n        let arr = map.get(key);\n        if (!arr) {\n            arr = [];\n            map.set(key, arr);\n        }\n        arr.push(item);\n    }\n    return map;\n}\n\nexport function deepCloneJSON<T>(obj: T): T {\n    if (obj === undefined) return obj;\n    let str = JSON.stringify(obj);\n    // It is possible for an object to not be defined, but return undefined when JSON.stringified,\n    //  via overriding the toJSON method.\n    if (str === undefined) return undefined as any;\n    return JSON.parse(str);\n}\n\nexport class PromiseObj<T = void> {\n    public promise: Promise<T>;\n    public value: { value?: T; error?: string } | undefined;\n    /** Resolve called does not mean the value is ready, as it may be resolved with a promise. */\n    public resolveCalled?: boolean;\n\n    public resolve = (value: T | Promise<T>) => {\n        this.resolveCalled = true;\n        if (typeof value === \"object\" && value !== null && value instanceof Promise) {\n            value.then(\n                value => this.value = { value },\n                error => this.value = { error },\n            );\n        } else {\n            this.value = { value };\n        }\n        this.baseResolve(value);\n    };\n    public reject = (error: any) => {\n        this.baseReject(error);\n    };\n\n    private baseResolve!: (value: T | Promise<T>) => void;\n    private baseReject!: (error: any) => void;\n    constructor() {\n        this.promise = new Promise<T>((resolve, reject) => {\n            this.baseResolve = resolve;\n            this.baseReject = reject;\n        });\n        this.promise.then(\n            value => this.value = { value },\n            error => this.value = { error }\n        );\n    }\n}\n\nexport function promiseObj<T = void>(): PromiseObj<T> {\n    return new PromiseObj<T>();\n}\n\n// Allows an immediate call, then delays the next call until the first call finishes + delay\n//  - Drops all but the latest call, but only resolves the promises return to all\n//      calls once the latest call finishes.\n//  - Esentially the same as saying \"don't run this function too often, don't run it in parallel,\n//      and don't let functions runs be too close together\".\nexport function throttleFunction<Args extends any[]>(\n    delay: number,\n    fnc: (...args: Args) => MaybePromise<void>\n): (...args: Args) => Promise<void> {\n    let nextAllowedCall = 0;\n    let pendingArgs: { args: Args; promiseObj: PromiseObj<void> } | undefined = undefined;\n    function doCall(args: Args, promiseObj: PromiseObj<void>) {\n        try {\n            let result = fnc(...args);\n            promiseObj.resolve(result);\n            if (result instanceof Promise) {\n                // NOTE: The caller should handle the promise. If not, they probably\n                //  want the unresolved promise rejection, so they can handle it properly.\n                void result.finally(() => {\n                    nextAllowedCall = Date.now() + delay;\n                    runNextCall();\n                });\n            } else {\n                nextAllowedCall = Date.now() + delay;\n                runNextCall();\n            }\n        } catch (e: any) {\n            promiseObj.reject(e);\n            nextAllowedCall = Date.now() + delay;\n            runNextCall();\n        }\n    }\n    function runNextCall() {\n        if (nextAllowedCall === Number.POSITIVE_INFINITY) return;\n        if (!pendingArgs) return;\n        let time = Date.now();\n        if (time > nextAllowedCall) {\n            // Set nextAllowedCall to infinity, to prevent new calls from running\n            //  until doCall finishes.\n            nextAllowedCall = Number.POSITIVE_INFINITY;\n            // Delay, so we don't turn a series of sequential calls to a series of nested calls\n            //  (which will cause a stack overflow)\n            setTimeout(() => {\n                let args = pendingArgs;\n                pendingArgs = undefined;\n                if (!args) {\n                    nextAllowedCall = 0;\n                    console.warn(`Impossible, pendingArgs was reset when we shouldn't have even been in a call`);\n                    return;\n                }\n                doCall(args.args, args.promiseObj);\n            }, 0);\n        } else {\n            setTimeout(runNextCall, nextAllowedCall - time);\n        }\n    }\n    return function (...args: Args): Promise<void> {\n        if (pendingArgs) {\n            pendingArgs.args = args;\n            return pendingArgs.promiseObj.promise;\n        }\n        pendingArgs = { args, promiseObj: promiseObj() };\n        runNextCall();\n        return pendingArgs.promiseObj.promise;\n    };\n}\n\n\nexport function nextId() {\n    return Date.now() + \"_\" + Math.random();\n}\n\nexport function arrayFromOrderObject<T>(obj: { [order: number]: T }): T[] {\n    if (Array.isArray(obj)) return obj.slice();\n    return Object.entries(obj).sort((a, b) => +a[0] - +b[0]).map(x => x[1]).filter(x => x !== undefined && x !== null);\n}\n\nexport function last<T>(arr: T[]): T | undefined {\n    return arr[arr.length - 1];\n}\n\nexport type ObjectValues<T> = T[keyof T];\nexport function entries<Obj extends { [key: string]: unknown }>(obj: Obj): [keyof Obj, ObjectValues<Obj>][] {\n    return Object.entries(obj) as any;\n}\n\nexport function keys<Obj extends { [key: string]: unknown }>(obj: Obj): (keyof Obj)[] {\n    return Object.keys(obj) as any;\n}\n\nexport function sort<T>(arr: T[], sortKey: (obj: T) => unknown) {\n    if (arr.length <= 1) return arr;\n    arr.sort((a, b) => compare(sortKey(a), sortKey(b)));\n    return arr;\n}\n\nexport function getRootDomain(hostname: string) {\n    if (hostname.startsWith(\"https://\")) {\n        hostname = hostname.slice(\"https://\".length);\n    }\n    hostname = hostname.split(\"/\")[0];\n    let parts = hostname.split(\".\");\n    hostname = parts.slice(-2).join(\".\");\n    hostname = hostname.split(\":\")[0];\n    return hostname;\n}\n\nexport class QueueLimited<T> {\n    private items: T[] = [];\n    private nextIndex = 0;\n    constructor(private readonly maxCount: number) { }\n\n    public push(item: T): void {\n        this.items[this.nextIndex] = item;\n        this.nextIndex = (this.nextIndex + 1) % this.maxCount;\n    }\n\n    public getAllUnordered(): T[] {\n        return this.items;\n    }\n    public reset(): void {\n        this.items = [];\n        this.nextIndex = 0;\n    }\n    public clear(): void {\n        this.reset();\n    }\n    public getOldest(): T | undefined {\n        if (this.items.length === 0) return undefined;\n        let index = this.nextIndex - 1;\n\n        if (index === -1) {\n            index += this.maxCount;\n        }\n        return this.items[index];\n    }\n}\n\n\nexport function binarySearchBasic<T, V>(array: T[], getVal: (val: T) => V, searchValue: V): number {\n    return binarySearchIndex(array.length, i => compare(getVal(array[i]), searchValue));\n}\nexport function binarySearchBasic2<T, V>(array: T[], getVal: (val: T) => V, searchValue: T): number {\n    return binarySearchIndex(array.length, i => compare(getVal(array[i]), getVal(searchValue)));\n}\n\n/**\n *  Searches indexes, allowing you to query structures that aren't arrays. To search an array, use:\n *      `binarySearchIndex(array.length, i => compare(array[i], searchValue))`\n * \n *      NOTE: If there are duplicates, returns the first match.\n * \n *      NOTE: If the value can't be found, returns the bitwise negation of the index where it should be inserted.\n * \n *      NOTE: With `if (index < 0) index = ~index;` you will get an index of the value >= the target value.\n */\nexport function binarySearchIndex(listCount: number, compare: (lhsIndex: number) => number): number {\n    if (listCount === 0) {\n        return ~0;\n    }\n    let min = 0;\n    let max = listCount - 1;\n    while (min < max) {\n        let fingerIndex = Math.floor((max + min) / 2);\n        let comparisonValue = compare(fingerIndex);\n        if (comparisonValue < 0) {\n            min = fingerIndex + 1;\n        } else {\n            max = fingerIndex;\n        }\n    }\n    let comparison = compare(min);\n    if (comparison === 0) return min;\n    if (comparison > 0) return ~min;\n    return ~(min + 1);\n}\n\nexport function compare(lhs: unknown, rhs: unknown): number {\n    if (typeof lhs !== typeof rhs) {\n        return compare(typeof lhs, typeof rhs);\n    }\n    if (lhs === rhs) return 0;\n    if (lhs === null && rhs !== null) return -1;\n    if (lhs !== null && rhs === null) return 1;\n    if (typeof lhs === \"number\") {\n        if (Number.isNaN(lhs)) {\n            if (Number.isNaN(rhs)) return 0;\n            return -1;\n        } else {\n            if (Number.isNaN(rhs)) return +1;\n        }\n    }\n    if (lhs as any < (rhs as any)) return -1;\n    return 1;\n}\nexport function compareArray(lhs: unknown[], rhs: unknown[]): number {\n    for (let i = 0; i < Math.min(lhs.length, rhs.length); i++) {\n        let comparison = compare(lhs[i], rhs[i]);\n        if (comparison !== 0) return comparison;\n    }\n    return lhs.length - rhs.length;\n}\n\nexport function insertIntoSortedList<T>(list: T[], map: (val: T) => string | number, element: T) {\n    let searchValue = map(element);\n    let index = binarySearchIndex(list.length, i => compare(map(list[i]), searchValue));\n    if (index < 0) index = ~index;\n    list.splice(index, 0, element);\n}\nexport function removeFromSortedList<T>(list: T[], map: (val: T) => string | number, searchValue: string | number) {\n    let index = binarySearchIndex(list.length, i => compare(map(list[i]), searchValue));\n    if (index < 0) return;\n    list.splice(index, 1);\n}\n\n\n\nexport function timeoutToError<T>(time: number, p: Promise<T>, err: () => Error) {\n    return new Promise<T>((resolve, reject) => {\n        let timeout = setTimeout(() => reject(err()), time);\n        p.then(resolve, reject).finally(() => clearTimeout(timeout));\n    });\n}\n\n// NOTE: Both errors and timeouts are converted to undefined\nexport function timeoutToUndefined<T>(time: number, p: Promise<T>) {\n    return new Promise<T | undefined>((resolve, reject) => {\n        let timeout = setTimeout(() => {\n            console.error(`timeoutToUndefined timed out after ${time}`);\n            resolve(undefined);\n        }, time);\n        p.then(resolve,\n            (err) => {\n                console.error(`timeoutToUndefined error: ${err.stack}`);\n                resolve(undefined);\n            }\n        ).finally(() => clearTimeout(timeout));\n    });\n}\nexport function timeoutToUndefinedSilent<T>(time: number, p: Promise<T>) {\n    return new Promise<T | undefined>((resolve, reject) => {\n        let timeout = setTimeout(() => {\n            resolve(undefined);\n        }, time);\n        p.then(\n            resolve,\n            (err) => {\n                resolve(undefined);\n            }\n        ).finally(() => clearTimeout(timeout));\n    });\n}\n\nexport function errorToWarning<T>(promise: Promise<T>): void {\n    // Return the promise, so they can wait if they want, but have the return type be void,\n    //  so that they don't have to await it.\n    return promise.catch(e => {\n        console.warn(e.stack);\n        return undefined as any;\n    }) as any;\n}\n\nexport function watchSlowPromise<T>(title: string, promise: Promise<T>, config?: {\n    interval?: number;\n}) {\n    let { interval = 5000 } = config || {};\n    let fulfilled = false;\n    void promise.finally(() => fulfilled = true);\n    let startTime = Date.now();\n    void (async () => {\n        while (true) {\n            await delay(interval);\n            if (fulfilled) break;\n            console.log(`${yellow(`Slow promise running for ${formatTime(Date.now() - startTime)}`)} | ${title}`);\n        }\n    })();\n    return promise;\n}"]}
+ /* _JS_SOURCE_HASH = "53986ed7b2bcd5f583771ff74fa1d2b1df2d2371b10f1edadc84d3a96872c75d"; */