socket-function 1.1.48 → 1.2.0

package/src/dist/bits.ts.cache

@@ -0,0 +1,121 @@
+"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.getTimeUnique = exports.getBufferFraction = exports.getBufferInt = exports.getShortNumber = exports.xor64BitsSafe = exports.setLowHighUint32Safe = exports.setLowHighUint32 = exports.getLowUint32 = exports.getHighUint32 = exports.addEpsilons = exports.minusEpsilon = void 0;
+/** Subtracts the smallest possible value from a number (a double). This makes it possible to convert an exclusive range end
+ *      to an inclusive range end, which is sometimes required (as in, < x is the same as <= minusEpsilon(x)).
+ */
+function minusEpsilon(value) {
+    let high = getHighUint32(value);
+    let low = getLowUint32(value);
+    if (low === 0) {
+        low = 2 ** 32 - 1;
+        high--;
+    }
+    else {
+        low--;
+    }
+    return setLowHighUint32(low, high);
+}
+exports.minusEpsilon = minusEpsilon;
+const maxUint32 = 2 ** 32 - 1;
+function addEpsilons(value, count) {
+    let high = getHighUint32(value);
+    let low = getLowUint32(value);
+    low += count;
+    if (low < 0) {
+        low += maxUint32;
+        high++;
+    }
+    else if (low > maxUint32) {
+        low -= maxUint32;
+        high--;
+    }
+    return setLowHighUint32(low, high);
+}
+exports.addEpsilons = addEpsilons;
+let conversionBuffer = new Float64Array(1);
+let conversionUint8Buffer = new Uint8Array(conversionBuffer.buffer);
+let conversionUint32Buffer = new Uint32Array(conversionBuffer.buffer);
+function getHighUint32(num) {
+    conversionBuffer[0] = num;
+    return conversionUint32Buffer[1];
+}
+exports.getHighUint32 = getHighUint32;
+function getLowUint32(num) {
+    conversionBuffer[0] = num;
+    return conversionUint32Buffer[0];
+}
+exports.getLowUint32 = getLowUint32;
+/** IMPORTANT! Beware of comparisons with 64 bit numbers. getFloat64_fromBytes(4294136438, 168) !== getFloat64_fromBytes(4294136438, 168).
+ *      USE is64BitEqual instead, OR, ensure the 2 highest bits are always 0.
+ */
+function setLowHighUint32(low, high) {
+    conversionUint32Buffer[0] = low;
+    conversionUint32Buffer[1] = high;
+    return conversionBuffer[0];
+}
+exports.setLowHighUint32 = setLowHighUint32;
+/** Adds protection against NaN values, changing the result if it would be NaN. This is because NaN values will compare to be not equal even if they are equal in certain cases, and in other cases, they'll always be equal, even if their bits are not equal.
+    - This means this is not a reversible operation. However, in a lot of cases, that doesn't matter.
+*/
+function setLowHighUint32Safe(low, high) {
+    conversionUint32Buffer[0] = low;
+    // Prevent NaN by not setting all the exponent bits to 1
+    conversionUint32Buffer[1] = high & 0xBFFFFFFF;
+    return conversionBuffer[0];
+}
+exports.setLowHighUint32Safe = setLowHighUint32Safe;
+// NOTE: Not reversible, see setLowHighUint32Safe
+function xor64BitsSafe(a, b) {
+    let high = getHighUint32(a);
+    let low = getLowUint32(a);
+    let high2 = getHighUint32(b);
+    let low2 = getLowUint32(b);
+    return setLowHighUint32Safe(low ^ low2, high ^ high2);
+}
+exports.xor64BitsSafe = xor64BitsSafe;
+// Gets bits that can be stored in a number. Specifically, the first 62 bits,
+//  as 64 bits will not compare correctly when treated as a double.
+function getShortNumber(buffer) {
+    let high = buffer.readUInt32BE(0) & 0x3FFFFFFF;
+    let low = buffer.readUInt32BE(4);
+    return setLowHighUint32(low, high);
+}
+exports.getShortNumber = getShortNumber;
+/* Returns a number between 0 and 2**48 */
+function getBufferInt(buffer) {
+    let num = 0;
+    for (let i = 0; i < Math.min(buffer.length, 6); i++) {
+        num = num * 256 + buffer[i];
+    }
+    return num;
+}
+exports.getBufferInt = getBufferInt;
+const intMax = 2 ** 48;
+/** Returns a number between 0 (inclusive) and 1 (exclusive) */
+function getBufferFraction(buffer) {
+    let int = getBufferInt(buffer);
+    return int / intMax;
+}
+exports.getBufferFraction = getBufferFraction;
+/*
+export function numberToBase64(num: number): string {
+    conversionBuffer[0] = num;
+    return Buffer.from(conversionBuffer.buffer).toString("base64");
+}
+export function numberFromBase64(base64: string) {
+    return new Float64Array(Buffer.from(base64, "base64"))[0];
+}
+*/
+let prevTime = 0;
+function getTimeUnique() {
+    let time = Date.now();
+    if (time <= prevTime) {
+        time = addEpsilons(prevTime, 1);
+    }
+    prevTime = time;
+    return time;
+}
+exports.getTimeUnique = getTimeUnique;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bits.js","sourceRoot":"","sources":["bits.ts"],"names":[],"mappings":";;;AACA;;GAEG;AACH,SAAgB,YAAY,CAAC,KAAa;IACtC,IAAI,IAAI,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;IAChC,IAAI,GAAG,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;IAE9B,IAAI,GAAG,KAAK,CAAC,EAAE,CAAC;QACZ,GAAG,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAClB,IAAI,EAAE,CAAC;IACX,CAAC;SAAM,CAAC;QACJ,GAAG,EAAE,CAAC;IACV,CAAC;IAED,OAAO,gBAAgB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AACvC,CAAC;AAZD,oCAYC;AACD,MAAM,SAAS,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAC9B,SAAgB,WAAW,CAAC,KAAa,EAAE,KAAa;IACpD,IAAI,IAAI,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;IAChC,IAAI,GAAG,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;IAE9B,GAAG,IAAI,KAAK,CAAC;IACb,IAAI,GAAG,GAAG,CAAC,EAAE,CAAC;QACV,GAAG,IAAI,SAAS,CAAC;QACjB,IAAI,EAAE,CAAC;IACX,CAAC;SAAM,IAAI,GAAG,GAAG,SAAS,EAAE,CAAC;QACzB,GAAG,IAAI,SAAS,CAAC;QACjB,IAAI,EAAE,CAAC;IACX,CAAC;IAED,OAAO,gBAAgB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AACvC,CAAC;AAdD,kCAcC;AAED,IAAI,gBAAgB,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC;AAC3C,IAAI,qBAAqB,GAAG,IAAI,UAAU,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;AACpE,IAAI,sBAAsB,GAAG,IAAI,WAAW,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;AACtE,SAAgB,aAAa,CAAC,GAAW;IACrC,gBAAgB,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;IAC1B,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC;AACrC,CAAC;AAHD,sCAGC;AACD,SAAgB,YAAY,CAAC,GAAW;IACpC,gBAAgB,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;IAC1B,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC;AACrC,CAAC;AAHD,oCAGC;AAED;;GAEG;AACH,SAAgB,gBAAgB,CAAC,GAAW,EAAE,IAAY;IACtD,sBAAsB,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;IAChC,sBAAsB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACjC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAC/B,CAAC;AAJD,4CAIC;AAED;;EAEE;AACF,SAAgB,oBAAoB,CAAC,GAAW,EAAE,IAAY;IAC1D,sBAAsB,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;IAChC,wDAAwD;IACxD,sBAAsB,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,UAAU,CAAC;IAC9C,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAC/B,CAAC;AALD,oDAKC;AAED,iDAAiD;AACjD,SAAgB,aAAa,CAAC,CAAS,EAAE,CAAS;IAC9C,IAAI,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;IAC5B,IAAI,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IAC1B,IAAI,KAAK,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;IAC7B,IAAI,IAAI,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IAC3B,OAAO,oBAAoB,CAAC,GAAG,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,CAAC,CAAC;AAC1D,CAAC;AAND,sCAMC;AAED,6EAA6E;AAC7E,mEAAmE;AACnE,SAAgB,cAAc,CAAC,MAAc;IACzC,IAAI,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;IAC/C,IAAI,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IACjC,OAAO,gBAAgB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AACvC,CAAC;AAJD,wCAIC;AACD,0CAA0C;AAC1C,SAAgB,YAAY,CAAC,MAAc;IACvC,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAClD,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAChC,CAAC;IACD,OAAO,GAAG,CAAC;AACf,CAAC;AAND,oCAMC;AACD,MAAM,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC;AACvB,+DAA+D;AAC/D,SAAgB,iBAAiB,CAAC,MAAc;IAC5C,IAAI,GAAG,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;IAC/B,OAAO,GAAG,GAAG,MAAM,CAAC;AACxB,CAAC;AAHD,8CAGC;AAED;;;;;;;;EAQE;AAGF,IAAI,QAAQ,GAAG,CAAC,CAAC;AACjB,SAAgB,aAAa;IACzB,IAAI,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACtB,IAAI,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnB,IAAI,GAAG,WAAW,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IACpC,CAAC;IACD,QAAQ,GAAG,IAAI,CAAC;IAChB,OAAO,IAAI,CAAC;AAChB,CAAC;AAPD,sCAOC","sourcesContent":["\n/** Subtracts the smallest possible value from a number (a double). This makes it possible to convert an exclusive range end\n *      to an inclusive range end, which is sometimes required (as in, < x is the same as <= minusEpsilon(x)).\n */\nexport function minusEpsilon(value: number) {\n    let high = getHighUint32(value);\n    let low = getLowUint32(value);\n\n    if (low === 0) {\n        low = 2 ** 32 - 1;\n        high--;\n    } else {\n        low--;\n    }\n\n    return setLowHighUint32(low, high);\n}\nconst maxUint32 = 2 ** 32 - 1;\nexport function addEpsilons(value: number, count: number) {\n    let high = getHighUint32(value);\n    let low = getLowUint32(value);\n\n    low += count;\n    if (low < 0) {\n        low += maxUint32;\n        high++;\n    } else if (low > maxUint32) {\n        low -= maxUint32;\n        high--;\n    }\n\n    return setLowHighUint32(low, high);\n}\n\nlet conversionBuffer = new Float64Array(1);\nlet conversionUint8Buffer = new Uint8Array(conversionBuffer.buffer);\nlet conversionUint32Buffer = new Uint32Array(conversionBuffer.buffer);\nexport function getHighUint32(num: number): number {\n    conversionBuffer[0] = num;\n    return conversionUint32Buffer[1];\n}\nexport function getLowUint32(num: number): number {\n    conversionBuffer[0] = num;\n    return conversionUint32Buffer[0];\n}\n\n/** IMPORTANT! Beware of comparisons with 64 bit numbers. getFloat64_fromBytes(4294136438, 168) !== getFloat64_fromBytes(4294136438, 168).\n *      USE is64BitEqual instead, OR, ensure the 2 highest bits are always 0.\n */\nexport function setLowHighUint32(low: number, high: number): number {\n    conversionUint32Buffer[0] = low;\n    conversionUint32Buffer[1] = high;\n    return conversionBuffer[0];\n}\n\n/** Adds protection against NaN values, changing the result if it would be NaN. This is because NaN values will compare to be not equal even if they are equal in certain cases, and in other cases, they'll always be equal, even if their bits are not equal.\n    - This means this is not a reversible operation. However, in a lot of cases, that doesn't matter. \n*/\nexport function setLowHighUint32Safe(low: number, high: number): number {\n    conversionUint32Buffer[0] = low;\n    // Prevent NaN by not setting all the exponent bits to 1\n    conversionUint32Buffer[1] = high & 0xBFFFFFFF;\n    return conversionBuffer[0];\n}\n\n// NOTE: Not reversible, see setLowHighUint32Safe\nexport function xor64BitsSafe(a: number, b: number): number {\n    let high = getHighUint32(a);\n    let low = getLowUint32(a);\n    let high2 = getHighUint32(b);\n    let low2 = getLowUint32(b);\n    return setLowHighUint32Safe(low ^ low2, high ^ high2);\n}\n\n// Gets bits that can be stored in a number. Specifically, the first 62 bits,\n//  as 64 bits will not compare correctly when treated as a double.\nexport function getShortNumber(buffer: Buffer): number {\n    let high = buffer.readUInt32BE(0) & 0x3FFFFFFF;\n    let low = buffer.readUInt32BE(4);\n    return setLowHighUint32(low, high);\n}\n/* Returns a number between 0 and 2**48 */\nexport function getBufferInt(buffer: Buffer): number {\n    let num = 0;\n    for (let i = 0; i < Math.min(buffer.length, 6); i++) {\n        num = num * 256 + buffer[i];\n    }\n    return num;\n}\nconst intMax = 2 ** 48;\n/** Returns a number between 0 (inclusive) and 1 (exclusive) */\nexport function getBufferFraction(buffer: Buffer): number {\n    let int = getBufferInt(buffer);\n    return int / intMax;\n}\n\n/*\nexport function numberToBase64(num: number): string {\n    conversionBuffer[0] = num;\n    return Buffer.from(conversionBuffer.buffer).toString(\"base64\");\n}\nexport function numberFromBase64(base64: string) {\n    return new Float64Array(Buffer.from(base64, \"base64\"))[0];\n}\n*/\n\n\nlet prevTime = 0;\nexport function getTimeUnique() {\n    let time = Date.now();\n    if (time <= prevTime) {\n        time = addEpsilons(prevTime, 1);\n    }\n    prevTime = time;\n    return time;\n}"]}
+ /* _JS_SOURCE_HASH = "6fd551828fef1e8f457b997ea04889957872cb51682949d9912465695bb77ef6"; */

package/src/dist/buffers.ts.cache

@@ -0,0 +1,76 @@
+"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.asFloat64MaybeCopy = exports.asInt32 = exports.asUint32 = exports.asFloat32 = exports.asFloat64 = exports.asBuffer = exports.cloneBuffer = void 0;
+const types_1 = require("./types");
+function cloneBuffer(data) {
+    let newBuffer = Buffer.alloc(data.length);
+    data.copy(newBuffer);
+    return newBuffer;
+}
+exports.cloneBuffer = cloneBuffer;
+function asBuffer(data) {
+    if (!data)
+        return data;
+    if (data instanceof Buffer)
+        return data;
+    if (!(0, types_1.canHaveChildren)(data))
+        return data;
+    if (!("buffer" in data) || !("byteOffset" in data) || !("byteLength" in data)) {
+        return Buffer.from(data);
+    }
+    let result = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    return result;
+}
+exports.asBuffer = asBuffer;
+function asFloat64(data) {
+    if (data.length % 8 !== 0) {
+        throw new Error(`Data is not 8 count aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 8 !== 0) {
+        throw new Error(`Data is not 8 byte aligned, received offset of ${data.byteOffset}`);
+    }
+    return new Float64Array(data.buffer, data.byteOffset, Math.floor(data.length / 8));
+}
+exports.asFloat64 = asFloat64;
+function asFloat32(data) {
+    if (data.length % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
+    }
+    return new Float32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
+}
+exports.asFloat32 = asFloat32;
+function asUint32(data) {
+    if (data.length % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
+    }
+    return new Uint32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
+}
+exports.asUint32 = asUint32;
+function asInt32(data) {
+    if (data.length % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
+    }
+    return new Int32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
+}
+exports.asInt32 = asInt32;
+function asFloat64MaybeCopy(data) {
+    if (data.length % 8 !== 0) {
+        throw new Error(`Data is not 8 count aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 8 !== 0) {
+        return asFloat64(cloneBuffer(data));
+    }
+    return new Float64Array(data.buffer, data.byteOffset, Math.floor(data.length / 8));
+}
+exports.asFloat64MaybeCopy = asFloat64MaybeCopy;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "5d67435fc79be050d69cf9b1ce1c39b5d7911a52ee00e73af54477e9fe10f566"; */

package/src/dist/caching.ts.cache

@@ -0,0 +1,302 @@
+"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.externalCache = exports.cacheShallowConfigArgEqual = exports.cacheJSONArgsEqual = exports.cacheArgsEqual = exports.cacheArrayEqual = exports.cacheList = exports.cacheWeak = exports.cacheLimited = exports.cache = exports.cacheEmptyArray = exports.lazy = void 0;
+const misc_1 = require("./misc");
+const types_1 = require("./types");
+function lazy(factory) {
+    let value = undefined;
+    function get() {
+        if (!value) {
+            value = { value: factory() };
+        }
+        return value.value;
+    }
+    ;
+    get.reset = () => {
+        value = undefined;
+    };
+    get.set = (newValue) => {
+        value = { value: newValue };
+    };
+    return get;
+}
+exports.lazy = lazy;
+// NOTE: Empty arrays are so common, that it is useful to represent them as the same
+//  emtpy array, to increase cache hit rates.
+const emptyArray = [];
+function cacheEmptyArray(array) {
+    if (array.length === 0)
+        return emptyArray;
+    return array;
+}
+exports.cacheEmptyArray = cacheEmptyArray;
+function cache(getValue) {
+    let startingCalculating = new Set();
+    let values = new Map();
+    function cache(input, ...untracked) {
+        let key = input;
+        if (values.has(key)) {
+            return values.get(key);
+        }
+        if (startingCalculating.has(key)) {
+            // TODO: Fix the types here, by throwing, and then for the cases
+            //  that don't throw, make our output type include undefined
+            return undefined;
+        }
+        startingCalculating.add(key);
+        let value = getValue(input, ...untracked);
+        values.set(key, value);
+        return value;
+    }
+    cache.clear = (key) => {
+        values.delete(key);
+        startingCalculating.delete(key);
+    };
+    cache.forceSet = (key, value) => {
+        values.set(key, value);
+        startingCalculating.add(key);
+    };
+    cache.getAllKeys = () => {
+        return [...values.keys()];
+    };
+    cache.get = (key) => {
+        return values.get(key);
+    };
+    cache.clearAll = () => {
+        values.clear();
+        startingCalculating.clear();
+    };
+    return cache;
+}
+exports.cache = cache;
+/** Makes a cache that limits the number of entries, allowing you to put arbitrary data in it
+ *      without worrying about leaking memory
+  */
+function cacheLimited(
+// NOTE: We can't calculate what limit should be based on comparing the evaluation time
+//  and the time to compare against the values. Because, even if finding a match takes far longer than
+//  calculating, keeping a consistent output can save (a considerable amount of) time in downstream caches.
+maxCount, getValue) {
+    let startingCalculating = new Set();
+    let values = new Map();
+    function get(input) {
+        let key = input;
+        if (values.has(key)) {
+            return values.get(key);
+        }
+        if (startingCalculating.has(key)) {
+            throw new Error(`Cyclic access in cache`);
+        }
+        startingCalculating.add(key);
+        // Clear when it gets too big. This is kind of like a worse
+        //  least recently used cache, because entries that are accessed
+        //  often will quickly get put back in. This is effective as long
+        //  as accesses take similar amounts of time. If there is a very slow
+        //  and very commonly accessed value, it could be evicted by many very
+        //  fast accesses, which would be unfortunate.
+        if (values.size >= maxCount) {
+            values.clear();
+            startingCalculating.clear();
+        }
+        let value = getValue(input);
+        values.set(key, value);
+        return value;
+    }
+    get["forceSet"] = (key, value) => {
+        values.set(key, value);
+        startingCalculating.add(key);
+    };
+    get["clearKey"] = (key) => {
+        values.delete(key);
+        startingCalculating.delete(key);
+    };
+    get["clear"] = () => {
+        values.clear();
+        startingCalculating.clear();
+    };
+    return get;
+}
+exports.cacheLimited = cacheLimited;
+function cacheWeak(getValue) {
+    let state = {
+        startingCalculating: new WeakSet(),
+        values: new WeakMap(),
+    };
+    return (input) => {
+        let key = input;
+        if (state.values.has(key)) {
+            return state.values.get(key);
+        }
+        if (state.startingCalculating.has(key)) {
+            throw new Error(`Cyclic access in cacheWeak`);
+        }
+        state.startingCalculating.add(key);
+        let value = getValue(input);
+        state.values.set(key, value);
+        return value;
+    };
+}
+exports.cacheWeak = cacheWeak;
+// A list cache, which... maybe faster than a Map?
+function cacheList(getLength, getValue) {
+    let state = {
+        cache: [],
+        length: undefined,
+        getLength,
+    };
+    function get(i) {
+        let cache = state.cache;
+        let length = state.length;
+        if (length === undefined) {
+            length = state.length = state.getLength();
+        }
+        if (i < 0 || i >= length) {
+            throw new Error(`Index out of bounds`);
+        }
+        if (!(i in cache)) {
+            cache[i] = getValue(i);
+        }
+        return cache[i];
+    }
+    ;
+    return get;
+}
+exports.cacheList = cacheList;
+function cacheArrayEqualCleanup(state) {
+    state.cache = [];
+}
+/** A cache half way between caching based on === and caching based on hash. Caches
+ *      based on arrayEqual, which does === on all values in an array. Requires localized
+ *      caching (as the comparisons don't scale with many candidates, unlike hashing),
+ *      however works with non trival transformations (ex, resolving many persisted overrides
+ *      to get a value), unlike cache().
+ *  Also, limits itself, more of a performance optimization than memory optimization, as it scales
+ *      very poorly with the number of candidates.
+ *
+ *  TIMING: About 6us with limit = 100, array size = 294, and the cache being full.
+ */
+function cacheArrayEqual(map, limit = 10) {
+    let state = { cache: [] };
+    function isMatch(lhs, rhs) {
+        if (lhs === rhs) {
+            return true;
+        }
+        if (lhs === undefined || rhs === undefined) {
+            return false;
+        }
+        if ((0, misc_1.arrayEqual)(lhs, rhs)) {
+            return true;
+        }
+        return false;
+    }
+    return Object.assign((input) => {
+        let cache = state.cache;
+        for (let obj of cache) {
+            if (isMatch(obj.input, input)) {
+                return obj.output;
+            }
+        }
+        let output = map(input);
+        cache.unshift({ input, output });
+        while (cache.length > limit) {
+            cache.pop();
+        }
+        return output;
+    }, {
+        clear(array) {
+            for (let i = state.cache.length - 1; i >= 0; i--) {
+                if (isMatch(state.cache[i].input, array)) {
+                    state.cache.splice(i, 1);
+                }
+            }
+        },
+        clearAll() {
+            state.cache = [];
+        },
+    });
+}
+exports.cacheArrayEqual = cacheArrayEqual;
+/** Caches when arguments are ===. See cacheArrayEqual */
+function cacheArgsEqual(fnc, limit = 10) {
+    let cache = cacheArrayEqual(function cacheArgsEqual(args) {
+        return fnc(...args);
+    }, limit);
+    return Object.assign(((...args) => {
+        return cache(args);
+    }), {
+        clear(...args) {
+            cache.clear(args);
+        },
+    });
+}
+exports.cacheArgsEqual = cacheArgsEqual;
+function cacheJSONArgsEqual(fnc, limit = 10) {
+    let cache = cacheLimited(limit, (argsJSON) => {
+        return fnc(...JSON.parse(argsJSON));
+    });
+    return Object.assign(((...args) => {
+        return cache(JSON.stringify(args));
+    }), {
+        clear(...args) {
+            cache.clearKey(JSON.stringify(args));
+        },
+        clearAll() {
+            cache.clear();
+        }
+    });
+}
+exports.cacheJSONArgsEqual = cacheJSONArgsEqual;
+function cacheShallowConfigArgEqual(fnc, limit = 10) {
+    let cache = cacheArrayEqual((kvpsFlat) => {
+        output.missCount++;
+        let arg;
+        if (kvpsFlat.length === 1) {
+            arg = kvpsFlat[0];
+        }
+        else {
+            let kvps = [];
+            for (let i = 0; i < kvpsFlat.length; i += 2) {
+                kvps.push([kvpsFlat[i], kvpsFlat[i + 1]]);
+            }
+            arg = Object.fromEntries(kvps);
+        }
+        return fnc(arg);
+    }, limit);
+    function getKVPs(configArg) {
+        if (!(0, types_1.canHaveChildren)(configArg) || Array.isArray(configArg)) {
+            return [configArg];
+        }
+        let keys = Object.keys(configArg);
+        keys.sort();
+        return keys.flatMap(key => [key, configArg[key]]);
+    }
+    let output = Object.assign(((configArg) => {
+        output.callCount++;
+        return cache(getKVPs(configArg));
+    }), {
+        clear(configArg) {
+            cache.clear(getKVPs(configArg));
+        },
+        clearAll() {
+            cache.clearAll();
+        },
+        callCount: 0,
+        missCount: 0,
+    });
+    return output;
+}
+exports.cacheShallowConfigArgEqual = cacheShallowConfigArgEqual;
+function externalCache() {
+    let values = new Map();
+    return {
+        get: (key) => {
+            return values.get(key);
+        },
+        set: (key, value) => {
+            values.set(key, value);
+        },
+    };
+}
+exports.externalCache = externalCache;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"caching.js","sourceRoot":"","sources":["caching.ts"],"names":[],"mappings":"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","sourcesContent":["import { arrayEqual } from \"./misc\";\nimport { AnyFunction, Args, canHaveChildren } from \"./types\";\n\nexport function lazy<T>(factory: () => T) {\n    let value: { value: T } | undefined = undefined;\n    function get() {\n        if (!value) {\n            value = { value: factory() };\n        }\n        return value.value;\n    };\n    get.reset = () => {\n        value = undefined;\n    };\n    get.set = (newValue: T) => {\n        value = { value: newValue };\n    };\n    return get;\n}\n\n// NOTE: The reason we need to periodically clear, is because sometimes a very small\n//      part of a large payload (ex, persisted overrides) is cached, which then results\n//      in the whole payload being cached, which results in a lot of memory being used.\n\n// IMPORTANT! The cleanup functions CANNOT close upon anything, or else they will cause leaks!\n//  All data they use should be in data.\ninterface CleanupFnc<T extends object> {\n    (data: T): void;\n}\n\n\n// NOTE: Empty arrays are so common, that it is useful to represent them as the same\n//  emtpy array, to increase cache hit rates.\nconst emptyArray: any[] = [];\nexport function cacheEmptyArray<T>(array: T[]): T[] {\n    if (array.length === 0) return emptyArray;\n    return array;\n}\n\nexport function cache<Output, Key, Untracked extends unknown[]>(\n    getValue: (key: Key, ...untracked: Untracked) => Output\n): {\n    (key: Key, ...untracked: Untracked): Output;\n    // NOTE: If you want to clear all, just make a new cache!\n    clear(key: Key): void;\n    clearAll(): void;\n    forceSet(key: Key, value: Output): void;\n    getAllKeys(): Key[];\n    get(key: Key): Output | undefined;\n} {\n    let startingCalculating = new Set<Key>();\n    let values = new Map<Key, Output>();\n    function cache(input: Key, ...untracked: Untracked) {\n        let key = input;\n        if (values.has(key)) {\n            return values.get(key) as any;\n        }\n        if (startingCalculating.has(key)) {\n            // TODO: Fix the types here, by throwing, and then for the cases\n            //  that don't throw, make our output type include undefined\n            return undefined;\n        }\n        startingCalculating.add(key);\n        let value = getValue(input, ...untracked);\n        values.set(key, value);\n        return value;\n    }\n    cache.clear = (key: Key) => {\n        values.delete(key);\n        startingCalculating.delete(key);\n    };\n    cache.forceSet = (key: Key, value: Output) => {\n        values.set(key, value);\n        startingCalculating.add(key);\n    };\n    cache.getAllKeys = () => {\n        return [...values.keys()];\n    };\n    cache.get = (key: Key) => {\n        return values.get(key);\n    };\n    cache.clearAll = () => {\n        values.clear();\n        startingCalculating.clear();\n    };\n    return cache;\n}\n\n\n/** Makes a cache that limits the number of entries, allowing you to put arbitrary data in it\n *      without worrying about leaking memory\n  */\nexport function cacheLimited<Output, Key>(\n    // NOTE: We can't calculate what limit should be based on comparing the evaluation time\n    //  and the time to compare against the values. Because, even if finding a match takes far longer than\n    //  calculating, keeping a consistent output can save (a considerable amount of) time in downstream caches.\n    maxCount: number,\n    getValue: (key: Key) => Output\n) {\n    let startingCalculating = new Set<Key>();\n    let values = new Map<Key, Output>();\n    function get(input: Key): Output {\n        let key = input;\n        if (values.has(key)) {\n            return values.get(key) as any;\n        }\n        if (startingCalculating.has(key)) {\n            throw new Error(`Cyclic access in cache`);\n        }\n        startingCalculating.add(key);\n\n        // Clear when it gets too big. This is kind of like a worse\n        //  least recently used cache, because entries that are accessed\n        //  often will quickly get put back in. This is effective as long\n        //  as accesses take similar amounts of time. If there is a very slow\n        //  and very commonly accessed value, it could be evicted by many very\n        //  fast accesses, which would be unfortunate.\n        if (values.size >= maxCount) {\n            values.clear();\n            startingCalculating.clear();\n        }\n\n        let value = getValue(input);\n        values.set(key, value);\n        return value;\n    }\n    get[\"forceSet\"] = (key: Key, value: Output) => {\n        values.set(key, value);\n        startingCalculating.add(key);\n    };\n    get[\"clearKey\"] = (key: Key) => {\n        values.delete(key);\n        startingCalculating.delete(key);\n    };\n    get[\"clear\"] = () => {\n        values.clear();\n        startingCalculating.clear();\n    };\n\n    return get;\n}\n\nexport function cacheWeak<Output, Key extends object>(getValue: (key: Key) => Output): (key: Key) => Output {\n    let state = {\n        startingCalculating: new WeakSet<Key>(),\n        values: new WeakMap<Key, Output>(),\n    };\n\n    return (input) => {\n        let key = input;\n        if (state.values.has(key)) {\n            return state.values.get(key) as any;\n        }\n        if (state.startingCalculating.has(key)) {\n            throw new Error(`Cyclic access in cacheWeak`);\n        }\n        state.startingCalculating.add(key);\n        let value = getValue(input);\n        state.values.set(key, value);\n        return value;\n    };\n}\n\n// A list cache, which... maybe faster than a Map?\nexport function cacheList<Value>(\n    getLength: () => number,\n    getValue: (index: number) => Value,\n): { (index: number): Value; } {\n    let state = {\n        cache: [] as Value[],\n        length: undefined as undefined | number,\n        getLength,\n    };\n    function get(i: number) {\n        let cache = state.cache;\n        let length = state.length;\n        if (length === undefined) {\n            length = state.length = state.getLength();\n        }\n        if (i < 0 || i >= length) {\n            throw new Error(`Index out of bounds`);\n        }\n        if (!(i in cache)) {\n            cache[i] = getValue(i);\n        }\n        return cache[i];\n    };\n    return get;\n}\n\nfunction cacheArrayEqualCleanup(state: any) {\n    state.cache = [];\n}\n\n/** A cache half way between caching based on === and caching based on hash. Caches\n *      based on arrayEqual, which does === on all values in an array. Requires localized\n *      caching (as the comparisons don't scale with many candidates, unlike hashing),\n *      however works with non trival transformations (ex, resolving many persisted overrides\n *      to get a value), unlike cache().\n *  Also, limits itself, more of a performance optimization than memory optimization, as it scales\n *      very poorly with the number of candidates.\n *  \n *  TIMING: About 6us with limit = 100, array size = 294, and the cache being full.\n */\nexport function cacheArrayEqual<Input extends unknown[] | undefined, Output>(\n    map: (arrays: Input) => Output,\n    limit = 10\n): {\n    (array: Input): Output;\n    clear(array: Input): void;\n    clearAll(): void;\n} {\n    let state: {\n        cache: {\n            input: Input;\n            output: Output;\n        }[]\n    } = { cache: [] };\n    function isMatch(lhs: Input, rhs: Input) {\n        if (lhs === rhs) {\n            return true;\n        }\n        if (lhs === undefined || rhs === undefined) {\n            return false;\n        }\n        if (arrayEqual(lhs, rhs)) {\n            return true;\n        }\n        return false;\n    }\n    return Object.assign(\n        (input: Input) => {\n            let cache = state.cache;\n            for (let obj of cache) {\n                if (isMatch(obj.input, input)) {\n                    return obj.output;\n                }\n            }\n            let output = map(input);\n            cache.unshift({ input, output });\n            while (cache.length > limit) {\n                cache.pop();\n            }\n            return output;\n        },\n        {\n            clear(array: Input) {\n                for (let i = state.cache.length - 1; i >= 0; i--) {\n                    if (isMatch(state.cache[i].input, array)) {\n                        state.cache.splice(i, 1);\n                    }\n                }\n            },\n            clearAll() {\n                state.cache = [];\n            },\n        }\n    );\n}\n\n/** Caches when arguments are ===. See cacheArrayEqual */\nexport function cacheArgsEqual<Fnc extends AnyFunction>(\n    fnc: Fnc,\n    limit = 10\n): Fnc & { clear(...args: Args<Fnc>): void } {\n    let cache = cacheArrayEqual(function cacheArgsEqual(args: unknown[]) {\n        return fnc(...args);\n    }, limit);\n    return Object.assign(\n        ((...args: unknown[]) => {\n            return cache(args);\n        }) as Fnc,\n        {\n            clear(...args: unknown[]) {\n                cache.clear(args);\n            },\n        }\n    );\n}\n\nexport function cacheJSONArgsEqual<Fnc extends AnyFunction>(\n    fnc: Fnc,\n    limit = 10\n) {\n    let cache = cacheLimited(limit, (argsJSON: string) => {\n        return fnc(...JSON.parse(argsJSON));\n    });\n    return Object.assign(\n        ((...args: unknown[]) => {\n            return cache(JSON.stringify(args));\n        }) as Fnc,\n        {\n            clear(...args: unknown[]) {\n                cache.clearKey(JSON.stringify(args));\n            },\n            clearAll() {\n                cache.clear();\n            }\n        }\n    );\n}\n\nexport function cacheShallowConfigArgEqual<Fnc extends AnyFunction>(\n    fnc: Fnc,\n    limit = 10\n): Fnc & {\n    clear(configObj: Args<Fnc>[0]): void;\n    clearAll(): void;\n} {\n    let cache = cacheArrayEqual((kvpsFlat: unknown[]) => {\n        output.missCount++;\n        let arg: any;\n        if (kvpsFlat.length === 1) {\n            arg = kvpsFlat[0];\n        } else {\n            let kvps: [unknown, unknown][] = [];\n            for (let i = 0; i < kvpsFlat.length; i += 2) {\n                kvps.push([kvpsFlat[i], kvpsFlat[i + 1]]);\n            }\n            arg = Object.fromEntries(kvps);\n        }\n        return fnc(arg);\n    }, limit);\n    function getKVPs(configArg: object) {\n        if (!canHaveChildren(configArg) || Array.isArray(configArg)) {\n            return [configArg];\n        }\n        let keys = Object.keys(configArg);\n        keys.sort();\n        return keys.flatMap(key => [key, configArg[key]]);\n    }\n    let output = Object.assign(\n        ((configArg: object) => {\n            output.callCount++;\n            return cache(getKVPs(configArg));\n        }) as Fnc,\n        {\n            clear(configArg: object) {\n                cache.clear(getKVPs(configArg));\n            },\n            clearAll() {\n                cache.clearAll();\n            },\n            callCount: 0,\n            missCount: 0,\n        }\n    );\n    return output;\n}\n\n\nexport function externalCache<Key, Value>(): {\n    get: (key: Key) => Value | undefined;\n    set: (key: Key, value: Value) => void;\n} {\n    let values = new Map<Key, Value>();\n    return {\n        get: (key) => {\n            return values.get(key);\n        },\n        set: (key, value) => {\n            values.set(key, value);\n        },\n    };\n}"]}
+ /* _JS_SOURCE_HASH = "cfc19e21a28cd6de3caf3ba9b26f13ac0c827759c8cb633634a3990212104ec4"; */