socket-function 1.1.49 → 1.2.1

package/require/require.d.ts

@@ -1,4 +1,4 @@
-/// <reference path="../src/src.d.ts" />
+/// <reference types="socket-function/src/src" />
 declare global {
     var onProgressHandler: undefined | ((progress: {
         type: string;

package/src/JSONLACKS/dist/JSONLACKS.ts.cache

@@ -0,0 +1,469 @@
+"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";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+exports.JSONLACKS = void 0;
+const measure_1 = require("../profiling/measure");
+const fs_1 = __importDefault(require("fs"));
+const JSONLACKS_generated_js_1 = __importDefault(require("./JSONLACKS.generated.js"));
+const misc_1 = require("../misc");
+const types_1 = require("../types");
+const batching_1 = require("../batching");
+const SERIALIZE_OBJECT_BATCH_COUNT = 1000;
+const PARSE_BYTE_CHUNK_SIZE = 1024 * 1024 * 10;
+// Supports json and also:
+//  - Non quoted field names "{ x: 1 }"?
+//  - Trailing commas
+//      NOTE: Comma only syntax is not supported, ex, "[,,]", which is an array of length 2 in javascript
+//  - Comments on input, but not on output
+//  - References
+//  - Buffers (just Buffers, not typed arrays)
+// The stringify function always creates valid json, as the syntax for references and buffers
+//  will just be special property names and values.
+// NOTE: We don't support Date serialization. Never store Dates, store "number".
+class JSONLACKS {
+    static stringify(obj, config) {
+        let serialized = JSONLACKS.escapeSpecialObjects(obj, config);
+        return JSON.stringify(serialized);
+    }
+    /** Is useful when serializing an array to a file with one object per line */
+    static async stringifyFile(obj, config) {
+        let serialized = JSONLACKS.escapeSpecialObjects(obj, config);
+        let buffers = [];
+        for (let i = 0; i < serialized.length; i += SERIALIZE_OBJECT_BATCH_COUNT) {
+            let str = serialized.slice(i, i + SERIALIZE_OBJECT_BATCH_COUNT).map(x => JSON.stringify(x) + "\n").join("");
+            buffers.push(Buffer.from(str));
+            await (0, batching_1.delay)("immediate");
+        }
+        // Break up into chunks, as string => Buffer i
+        return Buffer.concat(buffers);
+    }
+    static stringifyFileSync(obj, config) {
+        let serialized = JSONLACKS.escapeSpecialObjects(obj, config);
+        let buffers = [];
+        for (let i = 0; i < serialized.length; i += SERIALIZE_OBJECT_BATCH_COUNT) {
+            let str = serialized.slice(i, i + SERIALIZE_OBJECT_BATCH_COUNT).map(x => JSON.stringify(x) + "\n").join("");
+            buffers.push(Buffer.from(str));
+        }
+        // Break up into chunks, as string => Buffer i
+        return Buffer.concat(buffers);
+    }
+    // TIMING: Seems to be about 40X slower than JSON.parse unless extended is set to false,
+    //  then it is about 2X slower (although it depends on the size and complexity of the objects!)
+    static parse(text, config, hydrateState) {
+        var _a;
+        // Empty string should parse to SOMETHING
+        if (text.trim() === "")
+            return undefined;
+        let obj;
+        let extendedParsing = (_a = config === null || config === void 0 ? void 0 : config.extended) !== null && _a !== void 0 ? _a : JSONLACKS.EXTENDED_PARSER;
+        if (extendedParsing) {
+            obj = JSONLACKS_generated_js_1.default.parse(text);
+        }
+        else {
+            try {
+                obj = JSON.parse(text);
+            }
+            catch (_b) {
+                obj = JSONLACKS_generated_js_1.default.parse(text);
+            }
+        }
+        return JSONLACKS.hydrateSpecialObjects(obj, hydrateState, config);
+    }
+    static async parseLines(buffer, config) {
+        let output = [];
+        let pos = 0;
+        let hydrateState = {
+            references: new Map(),
+            visited: new Set(),
+        };
+        function parseChunk() {
+            let start = pos;
+            let lastNewLine = 0;
+            while (pos < buffer.length && (!lastNewLine || (pos - start) < PARSE_BYTE_CHUNK_SIZE)) {
+                let byte = buffer[pos];
+                if (byte === 10) {
+                    lastNewLine = pos;
+                }
+                pos++;
+            }
+            if (pos === buffer.length) {
+                lastNewLine = pos;
+            }
+            pos = lastNewLine + 1;
+            let text = buffer.slice(start, lastNewLine).toString("utf8");
+            let lines = text
+                .replaceAll("\r", "")
+                .split("\n")
+                .filter(x => x && !x.startsWith("//"));
+            let linesJSON = "[";
+            for (let i = 0; i < lines.length; i++) {
+                if (i !== 0)
+                    linesJSON += ",";
+                linesJSON += lines[i];
+            }
+            linesJSON += "]";
+            if (config === null || config === void 0 ? void 0 : config.discardMissingReferences) {
+                try {
+                    let parts = JSONLACKS.parse(linesJSON, config, hydrateState);
+                    for (let part of parts) {
+                        output.push(part);
+                    }
+                }
+                catch (e) {
+                    if (!e.message.includes("Reference to undefined id")) {
+                        throw e;
+                    }
+                    for (let line of lines) {
+                        try {
+                            let part = JSONLACKS.parse(line, config, hydrateState);
+                            output.push(part);
+                        }
+                        catch (e) {
+                            if (!e.message.includes("Reference to undefined id")) {
+                                throw e;
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                let parts = JSONLACKS.parse(linesJSON, config, hydrateState);
+                for (let part of parts) {
+                    output.push(part);
+                }
+            }
+        }
+        while (pos < buffer.length) {
+            parseChunk();
+            // Wait, to allow other thread to do work. We wait a long time... because we parse 10MB at once,
+            //  so... this gives us 2s of delay per 1GB of parsing, which should only be a fraction of our parse time
+            if (pos < buffer.length) {
+                await (0, batching_1.delay)(20);
+            }
+        }
+        return output;
+    }
+    static escapeSpecialObjects(obj, config) {
+        // I think iterating twice for references is the fastest way to do it?
+        let objects = new Set();
+        // NOTE: Use unique values for references, to allow concatenating files without having to
+        //  deal with escaping references.
+        let refPrefix = Date.now() + Math.random() + "";
+        let nextRefId = 0;
+        function getNextRefKey() {
+            return refPrefix + "_" + nextRefId++;
+        }
+        let refObjects = new Map();
+        findReferences(obj);
+        function findReferences(obj) {
+            if (!(0, types_1.canHaveChildren)(obj))
+                return;
+            if (refObjects.has(obj))
+                return;
+            if (objects.has(obj)) {
+                let refKey = getNextRefKey();
+                refObjects.set(obj, refKey);
+                return;
+            }
+            objects.add(obj);
+            for (let key in obj) {
+                findReferences(obj[key]);
+            }
+        }
+        let refsSeen = new Set();
+        return iterate(obj);
+        function iterate(obj, refHandled) {
+            if (!(0, types_1.canHaveChildren)(obj))
+                return obj;
+            if (!refHandled) {
+                let refKey = refObjects.get(obj);
+                if (refKey) {
+                    if (refsSeen.has(obj)) {
+                        return {
+                            [JSONLACKS.LACKS_KEY]: "ref",
+                            id: refKey,
+                        };
+                    }
+                    refsSeen.add(obj);
+                    return {
+                        [JSONLACKS.LACKS_KEY]: "define",
+                        id: refKey,
+                        value: iterate(obj, true),
+                    };
+                }
+            }
+            if (JSONLACKS.LACKS_KEY in obj) {
+                let restOfObj = { ...obj };
+                let escapedValue = restOfObj[JSONLACKS.LACKS_KEY];
+                delete restOfObj[JSONLACKS.LACKS_KEY];
+                return {
+                    [JSONLACKS.LACKS_KEY]: "removedSpecialKey",
+                    escapedValue: iterate(escapedValue),
+                    restOfObj: iterate(restOfObj),
+                };
+            }
+            if (obj instanceof Buffer) {
+                return {
+                    [JSONLACKS.LACKS_KEY]: "Buffer",
+                    data: obj.toString("base64"),
+                };
+            }
+            let cloned = config === null || config === void 0 ? void 0 : config.allowObjectMutation;
+            function cloneObj() {
+                if (cloned)
+                    return;
+                cloned = true;
+                if (Array.isArray(obj)) {
+                    obj = [...obj];
+                }
+                else {
+                    obj = { ...obj };
+                }
+            }
+            ;
+            for (let key in obj) {
+                let originalValue = obj[key];
+                let value = iterate(originalValue);
+                if (value !== originalValue) {
+                    cloneObj();
+                    obj[key] = value;
+                }
+            }
+            return obj;
+        }
+    }
+    static hydrateSpecialObjects(obj, hydrateState, config) {
+        let references = (hydrateState === null || hydrateState === void 0 ? void 0 : hydrateState.references) || new Map();
+        let visited = (hydrateState === null || hydrateState === void 0 ? void 0 : hydrateState.visited) || new Set();
+        return iterate(obj);
+        function iterate(obj) {
+            if (!(0, types_1.canHaveChildren)(obj))
+                return obj;
+            if (visited.has(obj))
+                return obj;
+            visited.add(obj);
+            let type = obj[JSONLACKS.LACKS_KEY];
+            if (!type) {
+                for (let key in obj) {
+                    let originalValue = obj[key];
+                    let value = iterate(originalValue);
+                    if (value !== originalValue) {
+                        obj[key] = value;
+                    }
+                }
+                return obj;
+            }
+            if (type === "removedSpecialKey") {
+                let restOfObj = iterate(obj.restOfObj);
+                let escapedValue = iterate(obj.escapedValue);
+                return { ...restOfObj, [JSONLACKS.LACKS_KEY]: escapedValue };
+            }
+            if (type === "Buffer") {
+                return Buffer.from(obj.data, "base64");
+            }
+            if (type === "define") {
+                references.set(obj.id, iterate(obj.value));
+                return obj.value;
+            }
+            if (type === "ref") {
+                let id = obj.id;
+                if (!JSONLACKS.IGNORE_MISSING_REFERENCES && !references.has(id)) {
+                    throw new Error(`Reference to undefined id "${id}"`);
+                }
+                return references.get(id);
+            }
+            throw new Error(`Unknown lacks type "${type}"`);
+        }
+    }
+}
+exports.JSONLACKS = JSONLACKS;
+JSONLACKS.LACKS_KEY = "__JSONLACKS__98cfb4a05fa34d828661cae15b8779ce__";
+/** If set to true parses non-quoted field names, comments, trailing commas, etc */
+JSONLACKS.EXTENDED_PARSER = false;
+JSONLACKS.IGNORE_MISSING_REFERENCES = false;
+async function benchmark() {
+    const loops = 1000 * 100;
+    let inputs = [];
+    for (let i = 0; i < loops; i++) {
+        inputs.push(JSON.stringify({
+            i,
+            hello_there: i,
+            example: 5,
+            list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+        }) + " ");
+    }
+    JSON.parse(inputs[0]);
+    JSONLACKS_generated_js_1.default.parse(inputs[0]);
+    (0, measure_1.measureCodeSync)(function measure() {
+        (0, measure_1.measureBlock)(function JSON_PARSE() {
+            for (let i = 0; i < loops; i++) {
+                JSON.parse(inputs[i]);
+            }
+        });
+        (0, measure_1.measureBlock)(function JSON_PARSE_FREEZE() {
+            for (let i = 0; i < loops; i++) {
+                let obj = JSON.parse(inputs[i]);
+                (0, misc_1.recursiveFreeze)(obj);
+            }
+        });
+        (0, measure_1.measureBlock)(function EXTENDED_PARSE() {
+            for (let i = 0; i < loops; i++) {
+                JSONLACKS_generated_js_1.default.parse(inputs[i]);
+            }
+        });
+        (0, measure_1.measureBlock)(function JSONLACKS_PARSE() {
+            for (let i = 0; i < loops; i++) {
+                JSONLACKS.parse(inputs[i]);
+            }
+        });
+        (0, measure_1.measureBlock)(function JSONLACKS_PARSE_SIMPLE() {
+            for (let i = 0; i < loops; i++) {
+                JSONLACKS.parse(inputs[i], { extended: false });
+            }
+        });
+    }, {
+        thresholdInTable: 0
+    });
+}
+//benchmark().catch(console.error).finally(() => process.exit());
+async function testJSONLACKS() {
+    {
+        let obj = {};
+        let str = JSONLACKS.stringify({
+            a: obj,
+            b: obj,
+        });
+        let parsed = JSONLACKS.parse(str);
+        if (parsed.a !== parsed.b) {
+            throw new Error("Failed to maintain references");
+        }
+        if (typeof parsed.a !== "object") {
+            throw new Error("Object become corrupted");
+        }
+    }
+    // Test LACKS_KEY is escaped correctly
+    {
+        let obj = { [JSONLACKS.LACKS_KEY]: "hello" };
+        let str = JSONLACKS.stringify(obj);
+        let parsed = JSONLACKS.parse(str);
+        if (JSON.stringify(obj) !== JSON.stringify(parsed)) {
+            throw new Error("Failed to escape LACKS_KEY");
+        }
+    }
+    // Test buffers are preserved
+    {
+        let obj = { a: Buffer.from("hello") };
+        let str = JSONLACKS.stringify(obj);
+        let parsed = JSONLACKS.parse(str);
+        if (obj.a.toString() !== parsed.a.toString()) {
+            throw new Error(`Failed to preserve buffers`);
+        }
+    }
+    // Test references 2
+    {
+        let base = {};
+        let arr = [base, base];
+        let obj = { x: arr, y: arr };
+        let result = JSONLACKS.parse(JSONLACKS.stringify(obj), { extended: false });
+        if (JSON.stringify(result) !== JSON.stringify(obj)) {
+            throw new Error(`Corrupted values, expected ${JSON.stringify(obj)}, got ${JSON.stringify(result)}`);
+        }
+        if (result.x !== result.y) {
+            throw new Error(`Failed to maintain references`);
+        }
+        if (result.x[0] !== result.x[1]) {
+            throw new Error(`Failed to maintain references`);
+        }
+    }
+}
+//testJSONLACKS().catch(console.error).finally(() => process.exit());
+async function generateAndVerifyParser() {
+    const pegjs = await Promise.resolve().then(() => __importStar(require("pegjs")));
+    var grammar = fs_1.default.readFileSync(__dirname + "/JSONLACKS.pegjs", "utf8");
+    var parserSource = pegjs.generate(grammar, { output: "source", format: "commonjs" });
+    fs_1.default.writeFileSync(__dirname + "/JSONLACKS.generated.js", parserSource);
+    var module = { exports: {} };
+    eval(parserSource);
+    const parser = module.exports;
+    function verify(text, forcedObj) {
+        var parsed = parser.parse(text);
+        var result = JSON.stringify(parsed);
+        let realResult = forcedObj !== null && forcedObj !== void 0 ? forcedObj : JSON.stringify(eval("(" + text + ")"));
+        if (result !== realResult) {
+            throw new Error(`Failed to parse: ${text} should be ${realResult}, was ${result}`);
+        }
+        console.log("Parsed correctly: ", text);
+    }
+    verify(`
+    {
+        "hello_there": 1,
+    }
+    `);
+    verify(`
+    {
+        hello_there: 1,
+    }
+    `);
+    verify(`
+    {
+        hello_there: 1,
+        more: 1,
+    }
+    `);
+    verify(`{ list: [1,], }`);
+    verify(`{ list: [1,], list2: [1,], }`);
+    verify(`{ /* test */ list: [1,], list2: [1,], }`);
+    verify(`{ /* test */ /* test 2 */ list: [1,], list2: [1,], }`);
+    verify(`
+    {
+        /* test */
+        /* test 2 */
+        list: [1,],
+        // Single line comment
+        list2: [1,],
+        // list3: [3],
+    }
+    `);
+    // Multiline double quote strings
+    verify(`
+    {
+        value: "a
+b"
+    }
+    `, JSON.stringify({ value: "a\nb" }));
+    // Single quotes
+    verify(`
+    {
+        value: 'a'
+    }
+    `);
+    verify(`undefined`);
+}
+//generateAndVerifyParser().catch(console.error).finally(() => process.exit());
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"JSONLACKS.js","sourceRoot":"","sources":["JSONLACKS.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { enableMeasurements, measureBlock, measureCode, measureCodeSync, measureFnc } from \"../profiling/measure\";\n// enableMeasurements();\n\nimport debugbreak from \"debugbreak\";\nimport fs from \"fs\";\n\nimport parser from \"./JSONLACKS.generated.js\";\nimport { recursiveFreeze } from \"../misc\";\nimport { canHaveChildren } from \"../types\";\nimport { delay } from \"../batching\";\n\nconst SERIALIZE_OBJECT_BATCH_COUNT = 1000;\nconst PARSE_BYTE_CHUNK_SIZE = 1024 * 1024 * 10;\n\nexport interface JSONLACKS_ParseConfig {\n    // Defaults to true. Enables parsing of:\n    //  - Trailing commas\n    //  - Non-quoted field names (ex, \"{ x: 1 }\")\n    //  - Comments (strips them, but doesn't throw)\n    extended?: boolean;\n    discardMissingReferences?: boolean;\n}\nexport interface JSONLACKS_StringifyConfig {\n    // If specified, we are allowed to mutate the provided object. Speeds up serialization.\n    allowObjectMutation?: boolean;\n}\n\ninterface HydrateState {\n    references: Map<string, unknown>,\n    visited: Set<unknown>,\n}\n\n// Supports json and also:\n//  - Non quoted field names \"{ x: 1 }\"?\n//  - Trailing commas\n//      NOTE: Comma only syntax is not supported, ex, \"[,,]\", which is an array of length 2 in javascript\n//  - Comments on input, but not on output\n//  - References\n//  - Buffers (just Buffers, not typed arrays)\n// The stringify function always creates valid json, as the syntax for references and buffers\n//  will just be special property names and values.\n// NOTE: We don't support Date serialization. Never store Dates, store \"number\".\nexport class JSONLACKS {\n    public static readonly LACKS_KEY = \"__JSONLACKS__98cfb4a05fa34d828661cae15b8779ce__\";\n\n    /** If set to true parses non-quoted field names, comments, trailing commas, etc */\n    public static EXTENDED_PARSER = false;\n    public static IGNORE_MISSING_REFERENCES = false;\n\n    public static stringify(obj: unknown, config?: JSONLACKS_StringifyConfig): string {\n        let serialized = JSONLACKS.escapeSpecialObjects(obj, config);\n        return JSON.stringify(serialized);\n    }\n    /** Is useful when serializing an array to a file with one object per line */\n    public static async stringifyFile(obj: unknown[], config?: JSONLACKS_StringifyConfig): Promise<Buffer> {\n        let serialized = JSONLACKS.escapeSpecialObjects(obj, config) as unknown[];\n        let buffers: Buffer[] = [];\n        for (let i = 0; i < serialized.length; i += SERIALIZE_OBJECT_BATCH_COUNT) {\n            let str = serialized.slice(i, i + SERIALIZE_OBJECT_BATCH_COUNT).map(x => JSON.stringify(x) + \"\\n\").join(\"\");\n            buffers.push(Buffer.from(str));\n            await delay(\"immediate\");\n        }\n        // Break up into chunks, as string => Buffer i\n        return Buffer.concat(buffers);\n    }\n    public static stringifyFileSync(obj: unknown[], config?: JSONLACKS_StringifyConfig): Buffer {\n        let serialized = JSONLACKS.escapeSpecialObjects(obj, config) as unknown[];\n        let buffers: Buffer[] = [];\n        for (let i = 0; i < serialized.length; i += SERIALIZE_OBJECT_BATCH_COUNT) {\n            let str = serialized.slice(i, i + SERIALIZE_OBJECT_BATCH_COUNT).map(x => JSON.stringify(x) + \"\\n\").join(\"\");\n            buffers.push(Buffer.from(str));\n        }\n        // Break up into chunks, as string => Buffer i\n        return Buffer.concat(buffers);\n    }\n    // TIMING: Seems to be about 40X slower than JSON.parse unless extended is set to false,\n    //  then it is about 2X slower (although it depends on the size and complexity of the objects!)\n    public static parse<T>(text: string, config?: JSONLACKS_ParseConfig, hydrateState?: HydrateState): T {\n        // Empty string should parse to SOMETHING\n        if (text.trim() === \"\") return undefined as T;\n        let obj: unknown;\n\n        let extendedParsing = config?.extended ?? JSONLACKS.EXTENDED_PARSER;\n\n        if (extendedParsing) {\n            obj = parser.parse(text);\n        } else {\n            try {\n                obj = JSON.parse(text);\n            } catch {\n                obj = parser.parse(text);\n            }\n        }\n\n        return JSONLACKS.hydrateSpecialObjects(obj, hydrateState, config) as T;\n    }\n    public static async parseLines<T>(buffer: Buffer, config?: JSONLACKS_ParseConfig): Promise<T[]> {\n        let output: T[] = [];\n        let pos = 0;\n        let hydrateState: HydrateState = {\n            references: new Map(),\n            visited: new Set(),\n        };\n        function parseChunk() {\n            let start = pos;\n            let lastNewLine = 0;\n            while (pos < buffer.length && (!lastNewLine || (pos - start) < PARSE_BYTE_CHUNK_SIZE)) {\n                let byte = buffer[pos];\n                if (byte === 10) {\n                    lastNewLine = pos;\n                }\n                pos++;\n            }\n            if (pos === buffer.length) {\n                lastNewLine = pos;\n            }\n            pos = lastNewLine + 1;\n\n            let text = buffer.slice(start, lastNewLine).toString(\"utf8\");\n            let lines = text\n                .replaceAll(\"\\r\", \"\")\n                .split(\"\\n\")\n                .filter(x => x && !x.startsWith(\"//\"))\n                ;\n            let linesJSON = \"[\";\n            for (let i = 0; i < lines.length; i++) {\n                if (i !== 0) linesJSON += \",\";\n                linesJSON += lines[i];\n            }\n            linesJSON += \"]\";\n            if (config?.discardMissingReferences) {\n                try {\n                    let parts = JSONLACKS.parse(linesJSON, config, hydrateState) as T[];\n                    for (let part of parts) {\n                        output.push(part);\n                    }\n                } catch (e: any) {\n                    if (!e.message.includes(\"Reference to undefined id\")) {\n                        throw e;\n                    }\n                    for (let line of lines) {\n                        try {\n                            let part = JSONLACKS.parse(line, config, hydrateState) as T;\n                            output.push(part);\n                        } catch (e: any) {\n                            if (!e.message.includes(\"Reference to undefined id\")) {\n                                throw e;\n                            }\n                        }\n                    }\n                }\n            } else {\n                let parts = JSONLACKS.parse(linesJSON, config, hydrateState) as T[];\n                for (let part of parts) {\n                    output.push(part);\n                }\n            }\n        }\n        while (pos < buffer.length) {\n            parseChunk();\n            // Wait, to allow other thread to do work. We wait a long time... because we parse 10MB at once,\n            //  so... this gives us 2s of delay per 1GB of parsing, which should only be a fraction of our parse time\n            if (pos < buffer.length) {\n                await delay(20);\n            }\n        }\n        return output;\n    }\n\n    private static escapeSpecialObjects(obj: unknown, config?: JSONLACKS_StringifyConfig): unknown {\n        // I think iterating twice for references is the fastest way to do it?\n        let objects = new Set<unknown>();\n        // NOTE: Use unique values for references, to allow concatenating files without having to\n        //  deal with escaping references.\n        let refPrefix = Date.now() + Math.random() + \"\";\n        let nextRefId = 0;\n        function getNextRefKey() {\n            return refPrefix + \"_\" + nextRefId++;\n        }\n        let refObjects = new Map<unknown, string>();\n        findReferences(obj);\n        function findReferences(obj: unknown) {\n            if (!canHaveChildren(obj)) return;\n            if (refObjects.has(obj)) return;\n            if (objects.has(obj)) {\n                let refKey = getNextRefKey();\n                refObjects.set(obj, refKey);\n                return;\n            }\n            objects.add(obj);\n            for (let key in obj) {\n                findReferences(obj[key]);\n            }\n        }\n\n        let refsSeen = new Set<unknown>();\n        return iterate(obj);\n        function iterate(obj: unknown, refHandled?: boolean): unknown {\n            if (!canHaveChildren(obj)) return obj;\n            if (!refHandled) {\n                let refKey = refObjects.get(obj);\n                if (refKey) {\n                    if (refsSeen.has(obj)) {\n                        return {\n                            [JSONLACKS.LACKS_KEY]: \"ref\",\n                            id: refKey,\n                        };\n                    }\n                    refsSeen.add(obj);\n                    return {\n                        [JSONLACKS.LACKS_KEY]: \"define\",\n                        id: refKey,\n                        value: iterate(obj, true),\n                    };\n                }\n            }\n\n            if (JSONLACKS.LACKS_KEY in obj) {\n                let restOfObj = { ...obj };\n                let escapedValue = restOfObj[JSONLACKS.LACKS_KEY];\n                delete restOfObj[JSONLACKS.LACKS_KEY];\n                return {\n                    [JSONLACKS.LACKS_KEY]: \"removedSpecialKey\",\n                    escapedValue: iterate(escapedValue),\n                    restOfObj: iterate(restOfObj),\n                };\n            }\n\n            if (obj instanceof Buffer) {\n                return {\n                    [JSONLACKS.LACKS_KEY]: \"Buffer\",\n                    data: obj.toString(\"base64\"),\n                };\n            }\n\n            let cloned = config?.allowObjectMutation;\n            function cloneObj() {\n                if (cloned) return;\n                cloned = true;\n                if (Array.isArray(obj)) {\n                    obj = [...obj];\n                } else {\n                    obj = { ...obj as any };\n                }\n            };\n            for (let key in obj) {\n                let originalValue = obj[key];\n                let value = iterate(originalValue);\n                if (value !== originalValue) {\n                    cloneObj();\n                    obj[key] = value;\n                }\n            }\n            return obj;\n        }\n    }\n\n    private static hydrateSpecialObjects(obj: unknown, hydrateState?: HydrateState, config?: JSONLACKS_ParseConfig): unknown {\n        let references = hydrateState?.references || new Map<string, unknown>();\n        let visited = hydrateState?.visited || new Set<unknown>();\n        return iterate(obj);\n        function iterate(obj: unknown) {\n            if (!canHaveChildren(obj)) return obj;\n            if (visited.has(obj)) return obj;\n            visited.add(obj);\n            let type = obj[JSONLACKS.LACKS_KEY];\n            if (!type) {\n                for (let key in obj) {\n                    let originalValue = obj[key];\n                    let value = iterate(originalValue);\n                    if (value !== originalValue) {\n                        obj[key] = value;\n                    }\n                }\n                return obj;\n            }\n            if (type === \"removedSpecialKey\") {\n                let restOfObj = iterate(obj.restOfObj) as any;\n                let escapedValue = iterate(obj.escapedValue) as any;\n                return { ...restOfObj, [JSONLACKS.LACKS_KEY]: escapedValue };\n            }\n            if (type === \"Buffer\") {\n                return Buffer.from(obj.data as string, \"base64\");\n            }\n            if (type === \"define\") {\n                references.set(obj.id as string, iterate(obj.value));\n                return obj.value;\n            }\n            if (type === \"ref\") {\n                let id = obj.id as string;\n                if (!JSONLACKS.IGNORE_MISSING_REFERENCES && !references.has(id)) {\n                    throw new Error(`Reference to undefined id \"${id}\"`);\n                }\n                return references.get(id);\n            }\n            throw new Error(`Unknown lacks type \"${type}\"`);\n        }\n    }\n}\n\nasync function benchmark() {\n    const loops = 1000 * 100;\n    let inputs: string[] = [];\n    for (let i = 0; i < loops; i++) {\n        inputs.push(JSON.stringify({\n            i,\n            hello_there: i,\n            example: 5,\n            list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],\n        }) + \" \");\n    }\n    JSON.parse(inputs[0]);\n    parser.parse(inputs[0]);\n\n    measureCodeSync(function measure() {\n        measureBlock(function JSON_PARSE() {\n            for (let i = 0; i < loops; i++) {\n                JSON.parse(inputs[i]);\n            }\n        });\n        measureBlock(function JSON_PARSE_FREEZE() {\n            for (let i = 0; i < loops; i++) {\n                let obj = JSON.parse(inputs[i]);\n                recursiveFreeze(obj);\n            }\n        });\n\n        measureBlock(function EXTENDED_PARSE() {\n            for (let i = 0; i < loops; i++) {\n                parser.parse(inputs[i]);\n            }\n        });\n\n        measureBlock(function JSONLACKS_PARSE() {\n            for (let i = 0; i < loops; i++) {\n                JSONLACKS.parse(inputs[i]);\n            }\n        });\n        measureBlock(function JSONLACKS_PARSE_SIMPLE() {\n            for (let i = 0; i < loops; i++) {\n                JSONLACKS.parse(inputs[i], { extended: false });\n            }\n        });\n\n    }, {\n        thresholdInTable: 0\n    });\n\n}\n//benchmark().catch(console.error).finally(() => process.exit());\n\n\nasync function testJSONLACKS() {\n    {\n        let obj = {};\n        let str = JSONLACKS.stringify({\n            a: obj,\n            b: obj,\n        });\n        let parsed = JSONLACKS.parse(str) as any;\n        if (parsed.a !== parsed.b) {\n            throw new Error(\"Failed to maintain references\");\n        }\n        if (typeof parsed.a !== \"object\") {\n            throw new Error(\"Object become corrupted\");\n        }\n    }\n\n    // Test LACKS_KEY is escaped correctly\n    {\n        let obj = { [JSONLACKS.LACKS_KEY]: \"hello\" };\n        let str = JSONLACKS.stringify(obj);\n        let parsed = JSONLACKS.parse(str) as any;\n        if (JSON.stringify(obj) !== JSON.stringify(parsed)) {\n            throw new Error(\"Failed to escape LACKS_KEY\");\n        }\n    }\n    // Test buffers are preserved\n    {\n        let obj = { a: Buffer.from(\"hello\") };\n        let str = JSONLACKS.stringify(obj);\n        let parsed = JSONLACKS.parse(str) as any;\n        if (obj.a.toString() !== parsed.a.toString()) {\n            throw new Error(`Failed to preserve buffers`);\n        }\n    }\n\n    // Test references 2\n    {\n        let base = {};\n        let arr = [base, base];\n        let obj = { x: arr, y: arr };\n        let result = JSONLACKS.parse(JSONLACKS.stringify(obj), { extended: false }) as typeof obj;\n        if (JSON.stringify(result) !== JSON.stringify(obj)) {\n            throw new Error(`Corrupted values, expected ${JSON.stringify(obj)}, got ${JSON.stringify(result)}`);\n        }\n        if (result.x !== result.y) {\n            throw new Error(`Failed to maintain references`);\n        }\n        if (result.x[0] !== result.x[1]) {\n            throw new Error(`Failed to maintain references`);\n        }\n    }\n}\n//testJSONLACKS().catch(console.error).finally(() => process.exit());\n\nasync function generateAndVerifyParser() {\n    const pegjs = await import(\"pegjs\");\n\n    var grammar = fs.readFileSync(__dirname + \"/JSONLACKS.pegjs\", \"utf8\");\n    var parserSource = pegjs.generate(grammar, { output: \"source\", format: \"commonjs\" });\n    fs.writeFileSync(__dirname + \"/JSONLACKS.generated.js\", parserSource);\n\n    var module = { exports: {} };\n    eval(parserSource);\n    const parser = module.exports as any;\n    function verify(text: string, forcedObj?: unknown) {\n        var parsed = parser.parse(text);\n        var result = JSON.stringify(parsed);\n        let realResult = forcedObj ?? JSON.stringify(eval(\"(\" + text + \")\"));\n        if (result !== realResult) {\n            throw new Error(`Failed to parse: ${text} should be ${realResult}, was ${result}`);\n        }\n        console.log(\"Parsed correctly: \", text);\n    }\n\n    verify(`\n    {\n        \"hello_there\": 1,\n    }\n    `);\n    verify(`\n    {\n        hello_there: 1,\n    }\n    `);\n    verify(`\n    {\n        hello_there: 1,\n        more: 1,\n    }\n    `);\n    verify(`{ list: [1,], }`);\n    verify(`{ list: [1,], list2: [1,], }`);\n\n    verify(`{ /* test */ list: [1,], list2: [1,], }`);\n    verify(`{ /* test */ /* test 2 */ list: [1,], list2: [1,], }`);\n    verify(`\n    {\n        /* test */\n        /* test 2 */\n        list: [1,],\n        // Single line comment\n        list2: [1,],\n        // list3: [3],\n    }\n    `);\n    // Multiline double quote strings\n    verify(`\n    {\n        value: \"a\nb\"\n    }\n    `, JSON.stringify({ value: \"a\\nb\" }));\n\n    // Single quotes\n    verify(`\n    {\n        value: 'a'\n    }\n    `);\n    verify(`undefined`);\n}\n//generateAndVerifyParser().catch(console.error).finally(() => process.exit());"]}
+ /* _JS_SOURCE_HASH = "1ed5449cbb7f4a390b58c0657e5b462d47e1493ed0d92180605b08712028c036"; */

package/src/callManager.d.ts

@@ -1,4 +1,4 @@
-/// <reference path="../hot/HotReloadController.d.ts" />
+/// <reference types="socket-function/hot/hotreloadcontroller" />
 import { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
 export declare function getCallFlags(call: CallType): FunctionFlags | undefined;
 export declare function shouldCompressCall(call: CallType): boolean | "LZ4" | undefined;