socket-function 1.1.49 → 1.2.1

package/require/dist/require.ts.cache

@@ -0,0 +1,676 @@
+"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";
+/// <reference path="../src/src.d.ts" />
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.requireMain = void 0;
+function requireMain() {
+    var _a;
+    async function requestText(endpoint, values) {
+        var _a, _b, _c;
+        let url = new URL(endpoint);
+        let json = JSON.stringify(values);
+        let response;
+        if (json.length < 6000) {
+            // NOTE: Try to use a GET, as GETs can be cached! However, if the data is too large,
+            //  we have to use a post, or else the request url will be too large
+            for (let key in values) {
+                url.searchParams.set(key, JSON.stringify(values[key]));
+            }
+            response = await fetch(url.toString(), {
+                method: "GET",
+                credentials: "include",
+            });
+        }
+        else {
+            response = await fetch(url.toString(), {
+                method: "POST",
+                body: json,
+                credentials: "include",
+            });
+        }
+        let compressionRatio = 1;
+        let uncompressedLength = response.headers.get("X-Uncompressed-Content-Length");
+        let compressedLength = response.headers.get("Content-Length");
+        if (uncompressedLength && compressedLength) {
+            compressionRatio = +uncompressedLength / +compressedLength;
+        }
+        let totalLength = +(uncompressedLength || compressedLength || 0);
+        if (totalLength) {
+            (_a = globalThis.onProgressHandler) === null || _a === void 0 ? void 0 : _a.call(globalThis, {
+                type: "Download",
+                addValue: 0,
+                addMax: Math.floor(totalLength / compressionRatio),
+            });
+        }
+        // If it's an error, set requestError
+        if (!response.ok) {
+            (_b = globalThis.onErrorHandler) === null || _b === void 0 ? void 0 : _b.call(globalThis, response.statusText);
+        }
+        // Stream it, so we can get progrss
+        let reader = response.body.getReader();
+        let result = "";
+        while (true) {
+            let { done, value } = await reader.read();
+            if (done)
+                break;
+            result += new TextDecoder().decode(value);
+            let cur = ((value === null || value === void 0 ? void 0 : value.length) || 0) / compressionRatio;
+            (_c = globalThis.onProgressHandler) === null || _c === void 0 ? void 0 : _c.call(globalThis, {
+                type: "Download",
+                addValue: cur,
+                addMax: 0,
+            });
+        }
+        return result;
+    }
+    const g = globalThis;
+    let startTime = Date.now();
+    globalThis.BOOT_TIME = startTime;
+    // Set to the first rootDomain, unless the first import does not have a domain
+    let mainRootOrigin = location.origin + location.pathname;
+    let isFirstImport = true;
+    Symbol.dispose = Symbol.dispose || Symbol("dispose");
+    Symbol.asyncDispose = Symbol.asyncDispose || Symbol("asyncDispose");
+    // Globals
+    Object.assign(window, {
+        process: {
+            argv: ((_a = window === null || window === void 0 ? void 0 : window.process) === null || _a === void 0 ? void 0 : _a.argv) || [],
+            env: {
+                // Mirror the tnode.js setting
+                NODE_ENV: "production",
+            },
+            versions: {},
+        },
+        setImmediate(callback) {
+            setTimeout(callback, 0);
+        },
+        // Ignore flags for now, even though they should work fine if we just hardcoded compileFlags.ts here.
+        setFlag() { },
+        global: window,
+    });
+    // Not real modules, as we just define their exports
+    const builtInModuleExports = {
+        worker_threads: {
+            isMainThread: true,
+        },
+        util: {
+            // https://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor
+            inherits(constructor, superConstructor) {
+                Object.setPrototypeOf(constructor.prototype, superConstructor.prototype);
+            },
+            TextDecoder: TextDecoder,
+            TextEncoder: TextEncoder,
+        },
+        buffer: { Buffer },
+        stream: {
+            // HACK: Needed to get SAX JS to work correctly.
+            Stream: function () { },
+            Transform: function () { },
+        },
+        timers: {
+            // TODO: Add all members of timers
+            setImmediate: window.setImmediate,
+        },
+        child_process: {},
+        events: {},
+    };
+    globalThis.builtInModuleExports = globalThis.builtInModuleExports || {};
+    Object.assign(globalThis.builtInModuleExports, builtInModuleExports);
+    let lastTime = 0;
+    function nextTime() {
+        let time = Date.now();
+        if (time <= lastTime) {
+            // NOTE: We SHOULD really add epsilon, but... this is a lot easier, and is close enough,
+            //  as times will never have too large of a magnitude.
+            time = lastTime + 0.01;
+        }
+        lastTime = time;
+        return time;
+    }
+    /** @type {{
+        [resolvePath: string]: {
+            // May be different then the module filename
+            filename: string;
+            // If a module is not allowed clientside it is likely requests will be empty,
+            //  to save effort parsing requests for modules that only exist to give better
+            //  error messages.
+            requests: {
+                // request => resolvedPath
+                [request: string]: string;
+            };
+            asyncRequests: { [request: string]: true };
+            // NOTE: IF !allowclient && !serveronly, it might just mean we didn't add allowclient
+            //  to the module yet. BUT, if serveronly, then we know for sure we don't want it client.
+            //  So the messages and behavior will be different.
+            allowclient?: boolean;
+            serveronly?: boolean;
+    
+            source?: string;
+        }
+    }} */
+    let serializedModules = Object.create(null);
+    let moduleCache = Object.create(null);
+    let alreadyHave;
+    let rootResolveCache = Object.create(null);
+    rootRequire.cache = moduleCache;
+    // Expose require for debugging, not so it can be called
+    g.require = rootRequire;
+    g.import = rootRequire;
+    g.r = function r(text) {
+        text = text.toLowerCase();
+        return Object.values(moduleCache).filter((x) => x.filename.toLowerCase().includes(text))[0].exports;
+    };
+    let requireBatch;
+    function rootRequire(request, batch) {
+        if (request.includes("file://")) {
+            // How does this happen? It definitely breaks things, and we could remove the file://, but... how
+            //  does it even happen?
+            debugger;
+        }
+        if (isFirstImport) {
+            isFirstImport = false;
+            if (request.startsWith("https://")) {
+                mainRootOrigin = getRootDomain(request);
+            }
+        }
+        if (!request.startsWith("https://")) {
+            request = mainRootOrigin + request;
+        }
+        if (!batch) {
+            if (request in rootResolveCache) {
+                let resolvedRequest = rootResolveCache[request];
+                if (resolvedRequest in rootRequire.cache) {
+                    return rootRequire.cache[resolvedRequest].exports;
+                }
+            }
+            if (request in rootRequire.cache) {
+                return rootRequire.cache[request].exports;
+            }
+        }
+        if (request in builtInModuleExports) {
+            return builtInModuleExports[request];
+        }
+        if (batch) {
+            if (!requireBatch) {
+                requireBatch = requireBatch || {};
+                setTimeout(() => {
+                    if (!requireBatch)
+                        throw new Error("Impossible");
+                    let requests = Object.keys(requireBatch);
+                    let callbacks = Object.values(requireBatch).reduce((a, b) => a.concat(b), []);
+                    requireBatch = undefined;
+                    void rootRequireMultiple(requests).then(() => {
+                        for (let callback of callbacks) {
+                            callback();
+                        }
+                    }, (err) => {
+                        throw err;
+                    });
+                }, 0);
+            }
+            return new Promise((resolve) => {
+                if (!requireBatch)
+                    throw new Error("Impossible");
+                requireBatch[request] = requireBatch[request] || [];
+                requireBatch[request].push(resolve);
+            });
+        }
+        else {
+            return rootRequireMultiple([request]).then((x) => x[0].exports);
+        }
+    }
+    function getRootDomain(request) {
+        let url = new URL(request);
+        let origin = url.origin;
+        // Fix stupid :443 erasure (other ports aren't erased, except 80, but we'll never use HTTP,
+        //  so that's fine).
+        {
+            let remaining = request.slice(origin.length);
+            if (remaining.startsWith(":443/")) {
+                origin += ":443";
+            }
+        }
+        return origin + "/";
+    }
+    async function rootRequireMultiple(requests) {
+        var _a, _b;
+        console.log(`%cimport(${requests.join(", ")}) at ${Date.now() - startTime}ms`, "color: orange");
+        let time = Date.now();
+        let alreadyHaveRanges;
+        if (alreadyHave) {
+            let seqNums = Object.keys(alreadyHave.seqNums).map((x) => +x);
+            seqNums.sort((a, b) => a - b);
+            let seqNumRanges = [];
+            alreadyHaveRanges = { requireSeqNumProcessId: alreadyHave.requireSeqNumProcessId, seqNumRanges };
+            for (let seqNum of seqNums) {
+                let prev = seqNumRanges[seqNumRanges.length - 1];
+                if ((prev === null || prev === void 0 ? void 0 : prev.e) === seqNum) {
+                    prev.e++;
+                }
+                else {
+                    seqNumRanges.push({ s: seqNum, e: seqNum + 1 });
+                }
+            }
+            for (let range of seqNumRanges) {
+                if (range.s + 1 === range.e) {
+                    delete range.e;
+                }
+            }
+        }
+        let domainOrigin = "";
+        let originalRequests = requests;
+        if (requests.some(x => x.startsWith("https://"))) {
+            requests = requests.map((request) => {
+                if (!request.startsWith("https://")) {
+                    throw new Error(`Mixed domains with non-domain requests is not supported presently. Requests: ${requests.join(" | ")}`);
+                }
+                let origin = getRootDomain(request);
+                if (domainOrigin && domainOrigin !== origin) {
+                    // TODO: If this happens, we can probably just split the call up into multiple calls?
+                    throw new Error(`Mixed domains in require call is not supported presently. Requests: ${requests.join(" | ")}`);
+                }
+                domainOrigin = origin;
+                // By stripping by length, we can turn https://example.com/./test => "./test"
+                //  (where as if we used pathname, it would turn into "/test"
+                return request.slice(domainOrigin.length);
+            });
+        }
+        let args = [requests, alreadyHaveRanges];
+        // We have to add hardcoded support for droppermissions, because... this call
+        //  doesn't have the conventional persisted code sending code, because... it's
+        //  all on its own.
+        let searchParams = new URLSearchParams(location.search);
+        if (searchParams.get("droppermissions") !== null) {
+            args.push(true);
+        }
+        let requestUrlBase = location.origin + location.pathname;
+        if (domainOrigin) {
+            requestUrlBase = domainOrigin;
+        }
+        let requestUrl = requestUrlBase + `?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=getModules`;
+        let remapImportRequestsClientside = globalThis.remapImportRequestsClientside;
+        if (remapImportRequestsClientside) {
+            for (let fnc of remapImportRequestsClientside) {
+                args = await fnc(args);
+            }
+        }
+        let rawText = await requestText(requestUrl, { args });
+        let resultObj;
+        try {
+            resultObj = JSON.parse(rawText);
+        }
+        catch (e) {
+            throw new Error(`require(${JSON.stringify(requests)}). Likely a permissions error, possibly fixed by restarting the local http server. Start of response was: ${JSON.stringify(rawText.slice(0, 100))}. Error is: ${e.stack}`);
+        }
+        let { modules, requestsResolvedPaths, requireSeqNumProcessId, error } = resultObj;
+        if (error) {
+            let errorObj = new Error();
+            errorObj.stack = error;
+            throw errorObj;
+        }
+        if (Object.keys(modules).length === 1 && "" in modules) {
+            debugger;
+            eval(modules[""].source || "");
+            throw new Error(`Failed to find modules for ${originalRequests.join(", ")} (mapped to ${requests.join(", ")})`);
+        }
+        if (domainOrigin) {
+            function fixDomain(request) {
+                if (!request)
+                    return request;
+                return domainOrigin + request;
+            }
+            requests = requests.map(fixDomain);
+            for (let [id, module] of Object.entries(modules)) {
+                delete modules[id];
+                modules[fixDomain(id)] = module;
+                module.filename = fixDomain(module.filename);
+                module.requests = Object.fromEntries(Object.entries(module.requests).map(([k, v]) => [k, fixDomain(v)]));
+                module.originalId = fixDomain(module.originalId);
+            }
+            requestsResolvedPaths = requestsResolvedPaths.map(fixDomain);
+        }
+        for (let i = 0; i < requests.length; i++) {
+            rootResolveCache[requests[i]] = requestsResolvedPaths[i];
+        }
+        (_a = globalThis.onProgressHandler) === null || _a === void 0 ? void 0 : _a.call(globalThis, {
+            type: "Compile",
+            addValue: 0,
+            addMax: Object.keys(modules).length,
+        });
+        // Store the function, so we only call it if it exists BEFORE we import
+        //  (which means we already have something loading, so this is likely hot reloading...)
+        let observerOnHotReload = g.observerOnHotReload;
+        setTimeout(() => {
+            if (observerOnHotReload) {
+                observerOnHotReload();
+            }
+        }, 0);
+        time = Date.now() - time;
+        let moduleCount = Object.values(modules).filter((x) => x.source).length;
+        let requireModuleCount = Object.values(modules).filter((x) => !x.source).length;
+        let dependenciesOnlyText = requireModuleCount ? ` (+${requireModuleCount} dependencies only)` : "";
+        console.log(`%cimport(${requests.join(", ")}) finished download ${time.toFixed(0)}ms, ${Math.ceil(rawText.length / 1024)}KB, ${moduleCount} modules${dependenciesOnlyText} at ${(Date.now() - startTime).toFixed(0)}ms`, "color: lightgreen");
+        if ((alreadyHave === null || alreadyHave === void 0 ? void 0 : alreadyHave.requireSeqNumProcessId) !== requireSeqNumProcessId) {
+            alreadyHave = undefined;
+        }
+        alreadyHave = alreadyHave || { requireSeqNumProcessId, seqNums: {} };
+        for (let id in modules) {
+            let module = modules[id];
+            alreadyHave.seqNums[module.seqNum] = 1;
+            serializedModules[id] = module;
+        }
+        time = Date.now();
+        let lastWaitTime = time;
+        for (let key of Object.keys(modules)) {
+            getModule(key, "preload");
+            // Wait, so we can render progress (and in generals, so the UI remains somewhat responsive)
+            if (Date.now() - lastWaitTime > 10) {
+                await new Promise(resolve => setTimeout(resolve, 0));
+                lastWaitTime = Date.now();
+            }
+        }
+        time = Date.now() - time;
+        console.log(`%cimport(${requests.join(", ")}) finished compile ${time.toFixed(0)}ms (${moduleCount} modules) at ${(Date.now() - startTime).toFixed(0)}ms`, "color: hotpink");
+        (_b = globalThis.onProgressHandler) === null || _b === void 0 ? void 0 : _b.call(globalThis, {
+            type: "Evaluate",
+            addValue: 0,
+            addMax: Object.keys(modules).length,
+        });
+        time = Date.now();
+        try {
+            return requestsResolvedPaths.map((x) => getModule(x));
+        }
+        finally {
+            time = Date.now() - time;
+            console.log(`%cimport(${requests.join(", ")}) finished evaluate ${time.toFixed(0)}ms (${moduleCount} modules) at ${(Date.now() - startTime).toFixed(0)}ms`, "color: lightblue");
+        }
+    }
+    function createRequire(module, serializedModule, asyncIsFineOuter) {
+        require.cache = moduleCache;
+        // Dynamically get folder, incase our filename changes
+        function getModuleFolder() {
+            return module.filename.replace(/\\/g, "/").split("/").slice(0, -1).join("/") + "/";
+        }
+        function resolve(request) {
+            let requests = serializedModule.requests;
+            if (request in requests) {
+                return requests[request];
+            }
+            let absolutePath = request;
+            if (absolutePath.startsWith("./") || absolutePath.startsWith("../")) {
+                let folderParts = getModuleFolder().split("/");
+                while (absolutePath.startsWith("./") || absolutePath.startsWith("../")) {
+                    if (absolutePath.startsWith("./")) {
+                        absolutePath = absolutePath.slice("./".length);
+                    }
+                    else {
+                        folderParts.pop();
+                        absolutePath = absolutePath.slice("../".length);
+                    }
+                }
+                absolutePath = folderParts.join("/") + "/" + absolutePath;
+            }
+            // Still use the same domain
+            if (!absolutePath.startsWith("https://")) {
+                absolutePath = mainRootOrigin + absolutePath;
+            }
+            return absolutePath;
+        }
+        require.resolve = resolve;
+        return require;
+        function require(request, asyncIsFine) {
+            var _a, _b;
+            if (asyncIsFineOuter) {
+                asyncIsFine = true;
+            }
+            if (typeof asyncIsFine !== "boolean") {
+                asyncIsFine = false;
+            }
+            if (request in serializedModule.asyncRequests) {
+                asyncIsFine = true;
+            }
+            if (request in builtInModuleExports) {
+                return builtInModuleExports[request];
+            }
+            let absolutePath = resolve(request);
+            let resolvedPath;
+            if (request in moduleCache) {
+                resolvedPath = request;
+            }
+            else if (absolutePath in moduleCache) {
+                resolvedPath = absolutePath;
+            }
+            else {
+                if (!(request in serializedModule.requests)) {
+                    if (!asyncIsFine && !globalThis.suppressUnexpectedModuleWarning) {
+                        console.warn(`Accessed unexpected module %c${request}%c in %c${module.id}%c\n\tTreating it as an async require.\n\tAll modules require synchronously clientside must be required serverside at a module level. Expected imports: ${Object.keys(serializedModule.requests).join(" | ")}`, "color: red", "color: unset", "color: red", "color: unset");
+                    }
+                    return rootRequire(absolutePath);
+                }
+                // Built in modules that we haven't been implemented
+                if (serializedModule.requests[request] === "") {
+                    return {};
+                }
+                resolvedPath = serializedModule.requests[request];
+            }
+            if (resolvedPath !== "NOTALLOWEDCLIENTSIDE" && !serializedModules[resolvedPath]) {
+                if (!asyncIsFine) {
+                    console.warn(`Accessed unexpected module %c${request}%c in %c${module.id}%c\n\tTreating it as an async require.\n\tAll modules require synchronously clientside must be required serverside at a module level. Expected imports: ${Object.keys(serializedModule.requests).join(" | ")}`, "color: red", "color: unset", "color: red", "color: unset");
+                }
+                return rootRequire(resolvedPath);
+            }
+            let exportsOverride;
+            if (resolvedPath === "NOTALLOWEDCLIENTSIDE" || !((_a = serializedModules[resolvedPath]) === null || _a === void 0 ? void 0 : _a.allowclient)) {
+                let childId = resolvedPath === "NOTALLOWEDCLIENTSIDE" ? request : resolvedPath;
+                if ((_b = serializedModules[resolvedPath]) === null || _b === void 0 ? void 0 : _b.serveronly) {
+                    exportsOverride = new Proxy({}, {
+                        get(target, property) {
+                            if (property === "__esModule")
+                                return undefined;
+                            // NOTE: Return a toString that evaluates to "" so we can EXPLICITLY detect non-loaded modules
+                            if (property === unloadedModule)
+                                return true;
+                            if (property === "default")
+                                return exportsOverride;
+                            throw new Error(`Module ${childId} is serverside only. Tried to access ${String(property)} from ${module.id}`);
+                        },
+                    });
+                }
+                else {
+                    exportsOverride = new Proxy({}, {
+                        get(target, property) {
+                            if (property === "__esModule")
+                                return undefined;
+                            // NOTE: Return a toString that evaluates to "" so we can EXPLICITLY detect non-loaded modules
+                            if (property === unloadedModule)
+                                return true;
+                            if (property === "default")
+                                return exportsOverride;
+                            let type = "non-whitelisted";
+                            if (!serializedModules[resolvedPath]) {
+                                type = "missing module";
+                            }
+                            console.warn(`Accessed ${type} module %c${childId}%c, specifically property %c${String(property)}%c.\n\tAdd %cmodule.allowclient = true%c to the file to allow access.\n\t(IF it is a 3rd party library, use the global "setFlag" helper (in the file you imported the module) to set properties on other modules (it can even recursively set properties)).\n\n\tFrom ${module.id}`, "color: red", "color: unset", "color: red", "color: unset", "color: red", "color: unset");
+                            return undefined;
+                        },
+                    });
+                }
+            }
+            if (resolvedPath === "NOTALLOWEDCLIENTSIDE") {
+                return exportsOverride;
+            }
+            let providerModule = getModule(resolvedPath);
+            module.children.push(providerModule);
+            if (exportsOverride !== undefined) {
+                providerModule.exports = exportsOverride;
+            }
+            let exports = providerModule.exports;
+            let remapExports = providerModule.remapExports;
+            if (remapExports && typeof remapExports === "function") {
+                exports = remapExports(exports, module);
+            }
+            return exports;
+        }
+    }
+    /** Generates the module root function, which can be called to evaluate the module,
+     *      and has code equal to contents.
+     *      - filename is just for debugging / stack traces
+     */
+    function wrapSafe(filename, contents) {
+        // TODO: Have the serverside inform us of the correct loader, or... have it actually emit a .json loader.
+        if (filename.endsWith(".json")) {
+            return (exports, require, module) => (module.exports = contents && JSON.parse(contents));
+        }
+        // NOTE: debugName only matters during module evaluation. After that the sourcemap should work.
+        let debugName = filename
+            .replace(/\\/g, "/")
+            .split("/")
+            .slice(-1)[0]
+            .replace(/\./g, "_")
+            .replace(/[^a-zA-Z_]/g, "");
+        // NOTE: eval is used instead of new Function, as new Function inject lines, which messes
+        //  up our sourcemaps.
+        // NOTE: All on one line, so we don't break sourcemaps by TOO much. We could also parse
+        //  the sourcemap and adjust it, but... it is much easier to just not change the line counts.
+        return eval(`(function ${debugName}(exports, require, module, __filename, __dirname, importDynamic) {"use strict";${contents}\n })`);
+    }
+    const unloadedModule = Symbol("unloadedModule");
+    let currentModuleEvaluationStack = [];
+    // See https://nodejs.org/api/modules.html
+    function getModule(resolvedId, preload) {
+        var _a;
+        if (resolvedId === "") {
+            return {};
+        }
+        if (resolvedId in moduleCache) {
+            let module = moduleCache[resolvedId];
+            if (!preload && !module.loaded) {
+                module.loaded = true;
+                module.load();
+            }
+            return module;
+        }
+        let serializedModule = serializedModules[resolvedId];
+        if (!serializedModule) {
+            // I can't figure out why this happens as it seems to happen very rarely and only when I'm debugging other code.
+            //  - I have had it happen immediately after starting the app. Although in theory a hot reload could have
+            //      triggered due to VS code writing to a file. 
+            //  - I've had times when it happens once after startup and then it goes away and other times where it
+            //      happens every single time and never goes away until I restart aipaint.
+            //  - Maybe it happens if we switch servers and so the root paths are different in some way?
+            debugger;
+            console.warn(`Failed to find module ${resolvedId}. The server should have given an error about this.`, serializedModules);
+        }
+        let module = Object.create(null);
+        moduleCache[resolvedId] = module;
+        module.id = resolvedId;
+        module.filename = (serializedModule === null || serializedModule === void 0 ? void 0 : serializedModule.filename) || "";
+        module.exports = {};
+        // Default default of exports to the exports itself
+        module.exports.default = module.exports;
+        module.children = [];
+        for (let key in (serializedModule === null || serializedModule === void 0 ? void 0 : serializedModule.flags) || {}) {
+            if (key === "loaded")
+                continue;
+            module[key] = true;
+        }
+        module.load = load;
+        let originalSource = (serializedModule === null || serializedModule === void 0 ? void 0 : serializedModule.source) || "";
+        let moduleFnc = wrapSafe(module.id, originalSource);
+        (_a = globalThis.onProgressHandler) === null || _a === void 0 ? void 0 : _a.call(globalThis, {
+            type: "Compile",
+            addValue: 1,
+            addMax: 0,
+        });
+        if (!preload) {
+            module.loaded = true;
+            module.load();
+        }
+        function load() {
+            var _a;
+            const serializedModule = serializedModules[resolvedId];
+            if (!serializedModule)
+                return;
+            if (!module.loaded) {
+                module.evaluateStarted = false;
+                if (alreadyHave) {
+                    delete alreadyHave.seqNums[serializedModule.seqNum];
+                }
+                // NOTE: There is almost never a way to recover from module downloading errors, so just don't catch them
+                return Promise.resolve()
+                    .then(() => rootRequire(resolvedId, true))
+                    .then(async () => {
+                    module.loaded = true;
+                    await load();
+                });
+            }
+            // Skip double loads
+            if (module.evaluateStarted)
+                return;
+            module.original = serializedModule;
+            module.requires = serializedModule.requests;
+            module.require = createRequire(module, serializedModule);
+            // TODO: Once typescript supports dynamic import, map import() to importDynamic, so it
+            //  uses our import function, instead of the built in one.
+            //  (As apparently we can't just override import on a per module basis, because
+            //      we can't have an identify called "import"... which is annoying).
+            let importDynamic = createRequire(module, serializedModule, true);
+            module.import = importDynamic;
+            let source = serializedModule.source;
+            module.allowclient = !!serializedModule.source;
+            // Import children, as the children may be allowed clientside, and may have side-effects!
+            if (!source) {
+                let requests = Object.keys(serializedModule.requests)
+                    .filter((x) => x !== "NOTALLOWEDCLIENTSIDE")
+                    .filter((x) => !(x in serializedModule.asyncRequests));
+                source = requests.map((id) => `require(${JSON.stringify(id)});\n`).join("");
+            }
+            module.size = source.length;
+            module.source = source;
+            if (source !== originalSource) {
+                originalSource = source;
+                moduleFnc = wrapSafe(module.id, originalSource);
+            }
+            let dirname = module.filename.replace(/\\/g, "/").split("/").slice(0, -1).join("/");
+            let time = Date.now();
+            currentModuleEvaluationStack.push(module.filename);
+            try {
+                module.evaluateStarted = true;
+                module.isPreloading = true;
+                module.evalStartTime = nextTime();
+                module.evalEndTime = undefined;
+                moduleFnc.call({
+                    // NOTE: Adding __importStar to the module causes typescript to use our implementation,
+                    //  which checks for unloadedModule and returns undefined in that case.
+                    __importStar(mod) {
+                        if (mod[unloadedModule])
+                            return undefined;
+                        return mod;
+                    },
+                    __importDefault(mod) {
+                        return mod.default ? mod : { default: mod };
+                    },
+                }, module.exports, 
+                // eslint-disable-next-line @typescript-eslint/unbound-method
+                module.require, module, module.filename, dirname, importDynamic);
+                module.evalEndTime = nextTime();
+                time = Date.now() - time;
+                // NOTE: This log statment is disabled as I believe it causes lag (when devtools is open).
+                //  As in, adding about 500ms to our load time, which is annoying when debugging.
+                //console.debug(`Evaluated module ${module.filename} ${Math.ceil(source.length / 1024)}KB`);
+            }
+            finally {
+                module.isPreloading = false;
+                currentModuleEvaluationStack.pop();
+                (_a = globalThis.onProgressHandler) === null || _a === void 0 ? void 0 : _a.call(globalThis, {
+                    type: "Evaluate",
+                    addValue: 1,
+                    addMax: 0,
+                });
+            }
+        }
+        return module;
+    }
+}
+exports.requireMain = requireMain;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"require.js","sourceRoot":"","sources":["require.ts"],"names":[],"mappings":"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","sourcesContent":["/// <reference path=\"../src/src.d.ts\" />\n\nimport { GetModulesArgs } from \"./RequireController\";\n\n\ndeclare global {\n    var onProgressHandler: undefined | ((progress: {\n        type: string;\n        addValue: number;\n        addMax: number;\n    }) => void);\n    var onErrorHandler: undefined | ((error: string) => void);\n\n\n    var BOOT_TIME: number;\n    var builtInModuleExports: {\n        [key: string]: unknown;\n    };\n}\n\nexport function requireMain() {\n    async function requestText(endpoint: string, values: any) {\n        let url = new URL(endpoint);\n\n        let json = JSON.stringify(values);\n        let response: Response;\n        if (json.length < 6000) {\n            // NOTE: Try to use a GET, as GETs can be cached! However, if the data is too large,\n            //  we have to use a post, or else the request url will be too large\n            for (let key in values) {\n                url.searchParams.set(key, JSON.stringify(values[key]));\n            }\n            response = await fetch(url.toString(), {\n                method: \"GET\",\n                credentials: \"include\",\n            });\n        } else {\n            response = await fetch(url.toString(), {\n                method: \"POST\",\n                body: json,\n                credentials: \"include\",\n            });\n        }\n\n        let compressionRatio = 1;\n        let uncompressedLength = response.headers.get(\"X-Uncompressed-Content-Length\");\n        let compressedLength = response.headers.get(\"Content-Length\");\n        if (uncompressedLength && compressedLength) {\n            compressionRatio = +uncompressedLength / +compressedLength;\n        }\n        let totalLength = +(uncompressedLength || compressedLength || 0);\n        if (totalLength) {\n            globalThis.onProgressHandler?.({\n                type: \"Download\",\n                addValue: 0,\n                addMax: Math.floor(totalLength / compressionRatio),\n            });\n        }\n\n        // If it's an error, set requestError\n        if (!response.ok) {\n            globalThis.onErrorHandler?.(response.statusText);\n        }\n\n        // Stream it, so we can get progrss\n        let reader = response.body!.getReader();\n        let result = \"\";\n        while (true) {\n            let { done, value } = await reader.read();\n            if (done) break;\n            result += new TextDecoder().decode(value);\n            let cur = (value?.length || 0) / compressionRatio;\n            globalThis.onProgressHandler?.({\n                type: \"Download\",\n                addValue: cur,\n                addMax: 0,\n            });\n        }\n\n        return result;\n    }\n\n    const g = globalThis as any;\n    let startTime = Date.now();\n    globalThis.BOOT_TIME = startTime;\n\n    // Set to the first rootDomain, unless the first import does not have a domain\n    let mainRootOrigin = location.origin + location.pathname;\n    let isFirstImport = true;\n\n    (Symbol as any).dispose = Symbol.dispose || Symbol(\"dispose\");\n    (Symbol as any).asyncDispose = Symbol.asyncDispose || Symbol(\"asyncDispose\");\n\n    // Globals\n    Object.assign(window, {\n        process: {\n            argv: window?.process?.argv || [],\n            env: {\n                // Mirror the tnode.js setting\n                NODE_ENV: \"production\",\n            },\n            versions: {},\n        },\n        setImmediate(callback: () => void) {\n            setTimeout(callback, 0);\n        },\n        // Ignore flags for now, even though they should work fine if we just hardcoded compileFlags.ts here.\n        setFlag() { },\n        global: window,\n    });\n\n    // Not real modules, as we just define their exports\n    const builtInModuleExports = {\n        worker_threads: {\n            isMainThread: true,\n        },\n        util: {\n            // https://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor\n            inherits(constructor: any, superConstructor: any) {\n                Object.setPrototypeOf(constructor.prototype, superConstructor.prototype);\n            },\n            TextDecoder: TextDecoder,\n            TextEncoder: TextEncoder,\n        },\n        buffer: { Buffer },\n        stream: {\n            // HACK: Needed to get SAX JS to work correctly.\n            Stream: function () { },\n            Transform: function () { },\n        },\n        timers: {\n            // TODO: Add all members of timers\n            setImmediate: window.setImmediate,\n        },\n        child_process: {},\n        events: {},\n    };\n    globalThis.builtInModuleExports = globalThis.builtInModuleExports || {};\n    Object.assign(globalThis.builtInModuleExports, builtInModuleExports);\n\n    let lastTime = 0;\n    function nextTime() {\n        let time = Date.now();\n        if (time <= lastTime) {\n            // NOTE: We SHOULD really add epsilon, but... this is a lot easier, and is close enough,\n            //  as times will never have too large of a magnitude.\n            time = lastTime + 0.01;\n        }\n        lastTime = time;\n        return time;\n    }\n\n    /** @type {{\n        [resolvePath: string]: {\n            // May be different then the module filename\n            filename: string;\n            // If a module is not allowed clientside it is likely requests will be empty,\n            //  to save effort parsing requests for modules that only exist to give better\n            //  error messages.\n            requests: {\n                // request => resolvedPath\n                [request: string]: string;\n            };\n            asyncRequests: { [request: string]: true };\n            // NOTE: IF !allowclient && !serveronly, it might just mean we didn't add allowclient\n            //  to the module yet. BUT, if serveronly, then we know for sure we don't want it client.\n            //  So the messages and behavior will be different.\n            allowclient?: boolean;\n            serveronly?: boolean;\n    \n            source?: string;\n        }\n    }} */\n    let serializedModules: { [id: string]: SerializedModule | undefined } = Object.create(null);\n\n    type ModuleType = NodeJS.Module & {\n        id: string;\n        filename: string;\n        exports: unknown;\n        children: ModuleType[];\n        flags: { [key: string]: boolean };\n        load: () => void;\n        loaded: boolean;\n        isPreloading: boolean;\n        evalStartTime: number;\n        evalEndTime: number | undefined;\n        evaluateStarted: boolean;\n        source: string;\n        allowclient: boolean;\n        size: number;\n        original: SerializedModule;\n        import: (request: string, asyncIsFine?: boolean) => unknown;\n    };\n\n    let moduleCache: { [id: string]: ModuleType } = Object.create(null);\n    let alreadyHave: {\n        requireSeqNumProcessId: string;\n        seqNums: { [seqNum: string]: true | 1 | 0 | undefined };\n    } | undefined;\n\n    let rootResolveCache = Object.create(null);\n\n    rootRequire.cache = moduleCache;\n    // Expose require for debugging, not so it can be called\n    g.require = rootRequire;\n    g.import = rootRequire;\n\n    g.r = function r(text: string) {\n        text = text.toLowerCase();\n        return Object.values(moduleCache).filter((x) => x.filename.toLowerCase().includes(text))[0].exports;\n    };\n\n    let requireBatch: { [request: string]: (() => void)[] } | undefined;\n    function rootRequire(request: string, batch?: boolean): unknown {\n        if (request.includes(\"file://\")) {\n            // How does this happen? It definitely breaks things, and we could remove the file://, but... how\n            //  does it even happen?\n            debugger;\n        }\n        if (isFirstImport) {\n            isFirstImport = false;\n            if (request.startsWith(\"https://\")) {\n                mainRootOrigin = getRootDomain(request);\n            }\n        }\n        if (!request.startsWith(\"https://\")) {\n            request = mainRootOrigin + request;\n        }\n\n        if (!batch) {\n            if (request in rootResolveCache) {\n                let resolvedRequest = rootResolveCache[request];\n                if (resolvedRequest in rootRequire.cache) {\n                    return rootRequire.cache[resolvedRequest].exports;\n                }\n            }\n\n            if (request in rootRequire.cache) {\n                return rootRequire.cache[request].exports;\n            }\n        }\n\n        if (request in builtInModuleExports) {\n            return builtInModuleExports[request as keyof typeof builtInModuleExports];\n        }\n        if (batch) {\n            if (!requireBatch) {\n                requireBatch = requireBatch || {};\n                setTimeout(() => {\n                    if (!requireBatch) throw new Error(\"Impossible\");\n                    let requests = Object.keys(requireBatch);\n                    let callbacks = Object.values(requireBatch).reduce((a, b) => a.concat(b), []);\n                    requireBatch = undefined;\n                    void rootRequireMultiple(requests).then(\n                        () => {\n                            for (let callback of callbacks) {\n                                callback();\n                            }\n                        },\n                        (err) => {\n                            throw err;\n                        }\n                    );\n                }, 0);\n            }\n            return new Promise<void>((resolve) => {\n                if (!requireBatch) throw new Error(\"Impossible\");\n                requireBatch[request] = requireBatch[request] || [];\n                requireBatch[request].push(resolve);\n            });\n        } else {\n            return rootRequireMultiple([request]).then((x) => x[0].exports);\n        }\n    }\n\n    function getRootDomain(request: string) {\n        let url = new URL(request);\n        let origin = url.origin;\n        // Fix stupid :443 erasure (other ports aren't erased, except 80, but we'll never use HTTP,\n        //  so that's fine).\n        {\n            let remaining = request.slice(origin.length);\n            if (remaining.startsWith(\":443/\")) {\n                origin += \":443\";\n            }\n        }\n        return origin + \"/\";\n    }\n\n    async function rootRequireMultiple(requests: string[]) {\n        console.log(`%cimport(${requests.join(\", \")}) at ${Date.now() - startTime}ms`, \"color: orange\");\n\n        let time = Date.now();\n\n        let alreadyHaveRanges;\n        if (alreadyHave) {\n            let seqNums = Object.keys(alreadyHave.seqNums).map((x) => +x);\n            seqNums.sort((a, b) => a - b);\n            let seqNumRanges: { s: number; e?: number }[] = [];\n            alreadyHaveRanges = { requireSeqNumProcessId: alreadyHave.requireSeqNumProcessId, seqNumRanges };\n            for (let seqNum of seqNums) {\n                let prev = seqNumRanges[seqNumRanges.length - 1];\n                if (prev?.e === seqNum) {\n                    prev.e++;\n                } else {\n                    seqNumRanges.push({ s: seqNum, e: seqNum + 1 });\n                }\n            }\n            for (let range of seqNumRanges) {\n                if (range.s + 1 === range.e) {\n                    delete range.e;\n                }\n            }\n        }\n\n        let domainOrigin = \"\";\n        let originalRequests = requests;\n        if (requests.some(x => x.startsWith(\"https://\"))) {\n            requests = requests.map((request) => {\n                if (!request.startsWith(\"https://\")) {\n                    throw new Error(`Mixed domains with non-domain requests is not supported presently. Requests: ${requests.join(\" | \")}`);\n                }\n                let origin = getRootDomain(request);\n                if (domainOrigin && domainOrigin !== origin) {\n                    // TODO: If this happens, we can probably just split the call up into multiple calls?\n                    throw new Error(`Mixed domains in require call is not supported presently. Requests: ${requests.join(\" | \")}`);\n                }\n                domainOrigin = origin;\n                // By stripping by length, we can turn https://example.com/./test => \"./test\"\n                //  (where as if we used pathname, it would turn into \"/test\"\n                return request.slice(domainOrigin.length);\n            });\n        }\n\n        let args: GetModulesArgs = [requests, alreadyHaveRanges];\n        // We have to add hardcoded support for droppermissions, because... this call\n        //  doesn't have the conventional persisted code sending code, because... it's\n        //  all on its own.\n        let searchParams = new URLSearchParams(location.search);\n        if (searchParams.get(\"droppermissions\") !== null) {\n            args.push(true);\n        }\n\n        let requestUrlBase = location.origin + location.pathname;\n        if (domainOrigin) {\n            requestUrlBase = domainOrigin;\n        }\n        let requestUrl = requestUrlBase + `?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=getModules`;\n\n        let remapImportRequestsClientside = globalThis.remapImportRequestsClientside;\n        if (remapImportRequestsClientside) {\n            for (let fnc of remapImportRequestsClientside) {\n                args = await fnc(args);\n            }\n        }\n        let rawText = await requestText(requestUrl, { args });\n        let resultObj: {\n            modules: { [id: string]: SerializedModule };\n            requestsResolvedPaths: string[];\n            requireSeqNumProcessId: string;\n            error?: string;\n        };\n        try {\n            resultObj = JSON.parse(rawText);\n        } catch (e: any) {\n            throw new Error(`require(${JSON.stringify(requests)}). Likely a permissions error, possibly fixed by restarting the local http server. Start of response was: ${JSON.stringify(rawText.slice(0, 100))}. Error is: ${e.stack}`);\n        }\n        let { modules, requestsResolvedPaths, requireSeqNumProcessId, error } = resultObj;\n\n        if (error) {\n            let errorObj = new Error();\n            errorObj.stack = error;\n            throw errorObj;\n        }\n\n\n        if (Object.keys(modules).length === 1 && \"\" in modules) {\n            debugger;\n            eval(modules[\"\"].source || \"\");\n            throw new Error(`Failed to find modules for ${originalRequests.join(\", \")} (mapped to ${requests.join(\", \")})`);\n        }\n\n\n        if (domainOrigin) {\n            function fixDomain(request: string) {\n                if (!request) return request;\n                return domainOrigin + request;\n            }\n            requests = requests.map(fixDomain);\n            for (let [id, module] of Object.entries(modules)) {\n                delete modules[id];\n                modules[fixDomain(id)] = module;\n                module.filename = fixDomain(module.filename);\n                module.requests = Object.fromEntries(Object.entries(module.requests).map(([k, v]) => [k, fixDomain(v)]));\n                module.originalId = fixDomain(module.originalId);\n            }\n            requestsResolvedPaths = requestsResolvedPaths.map(fixDomain);\n        }\n\n\n        for (let i = 0; i < requests.length; i++) {\n            rootResolveCache[requests[i]] = requestsResolvedPaths[i];\n        }\n\n        globalThis.onProgressHandler?.({\n            type: \"Compile\",\n            addValue: 0,\n            addMax: Object.keys(modules).length,\n        });\n\n        // Store the function, so we only call it if it exists BEFORE we import\n        //  (which means we already have something loading, so this is likely hot reloading...)\n        let observerOnHotReload = g.observerOnHotReload;\n        setTimeout(() => {\n            if (observerOnHotReload) {\n                observerOnHotReload();\n            }\n        }, 0);\n\n        time = Date.now() - time;\n        let moduleCount = Object.values(modules).filter((x) => x.source).length;\n        let requireModuleCount = Object.values(modules).filter((x) => !x.source).length;\n        let dependenciesOnlyText = requireModuleCount ? ` (+${requireModuleCount} dependencies only)` : \"\";\n        console.log(\n            `%cimport(${requests.join(\", \")}) finished download ${time.toFixed(0)}ms, ${Math.ceil(\n                rawText.length / 1024\n            )}KB, ${moduleCount} modules${dependenciesOnlyText} at ${(Date.now() - startTime).toFixed(0)}ms`,\n            \"color: lightgreen\"\n        );\n\n\n\n        if (alreadyHave?.requireSeqNumProcessId !== requireSeqNumProcessId) {\n            alreadyHave = undefined;\n        }\n        alreadyHave = alreadyHave || { requireSeqNumProcessId, seqNums: {} };\n\n        for (let id in modules) {\n            let module = modules[id];\n            alreadyHave.seqNums[module.seqNum] = 1;\n            serializedModules[id] = module;\n        }\n\n        time = Date.now();\n        let lastWaitTime = time;\n        for (let key of Object.keys(modules)) {\n            getModule(key, \"preload\");\n            // Wait, so we can render progress (and in generals, so the UI remains somewhat responsive)\n            if (Date.now() - lastWaitTime > 10) {\n                await new Promise(resolve => setTimeout(resolve, 0));\n                lastWaitTime = Date.now();\n            }\n        }\n\n        time = Date.now() - time;\n        console.log(\n            `%cimport(${requests.join(\", \")}) finished compile ${time.toFixed(0)}ms (${moduleCount} modules) at ${(Date.now() - startTime).toFixed(0)}ms`,\n            \"color: hotpink\"\n        );\n\n\n        globalThis.onProgressHandler?.({\n            type: \"Evaluate\",\n            addValue: 0,\n            addMax: Object.keys(modules).length,\n        });\n\n        time = Date.now();\n        try {\n            return requestsResolvedPaths.map((x) => getModule(x));\n        } finally {\n            time = Date.now() - time;\n            console.log(\n                `%cimport(${requests.join(\", \")}) finished evaluate ${time.toFixed(0)}ms (${moduleCount} modules) at ${(Date.now() - startTime).toFixed(0)}ms`,\n                \"color: lightblue\"\n            );\n        }\n    }\n\n    function createRequire(module: ModuleType, serializedModule: SerializedModule, asyncIsFineOuter?: boolean) {\n        require.cache = moduleCache;\n        // Dynamically get folder, incase our filename changes\n        function getModuleFolder() {\n            return module.filename.replace(/\\\\/g, \"/\").split(\"/\").slice(0, -1).join(\"/\") + \"/\";\n        }\n        function resolve(request: string) {\n            let requests = serializedModule.requests;\n            if (request in requests) {\n                return requests[request];\n            }\n            let absolutePath = request;\n            if (absolutePath.startsWith(\"./\") || absolutePath.startsWith(\"../\")) {\n                let folderParts = getModuleFolder().split(\"/\");\n                while (absolutePath.startsWith(\"./\") || absolutePath.startsWith(\"../\")) {\n                    if (absolutePath.startsWith(\"./\")) {\n                        absolutePath = absolutePath.slice(\"./\".length);\n                    } else {\n                        folderParts.pop();\n                        absolutePath = absolutePath.slice(\"../\".length);\n                    }\n                }\n                absolutePath = folderParts.join(\"/\") + \"/\" + absolutePath;\n            }\n            // Still use the same domain\n            if (!absolutePath.startsWith(\"https://\")) {\n                absolutePath = mainRootOrigin + absolutePath;\n            }\n            return absolutePath;\n        }\n        require.resolve = resolve;\n        return require;\n        function require(request: string, asyncIsFine?: boolean) {\n            if (asyncIsFineOuter) {\n                asyncIsFine = true;\n            }\n            if (typeof asyncIsFine !== \"boolean\") {\n                asyncIsFine = false;\n            }\n            if (request in serializedModule.asyncRequests) {\n                asyncIsFine = true;\n            }\n            if (request in builtInModuleExports) {\n                return builtInModuleExports[request as keyof typeof builtInModuleExports];\n            }\n\n            let absolutePath = resolve(request);\n\n            let resolvedPath: string | undefined;\n            if (request in moduleCache) {\n                resolvedPath = request;\n            } else if (absolutePath in moduleCache) {\n                resolvedPath = absolutePath;\n            } else {\n                if (!(request in serializedModule.requests)) {\n                    if (!asyncIsFine && !globalThis.suppressUnexpectedModuleWarning) {\n                        console.warn(\n                            `Accessed unexpected module %c${request}%c in %c${module.id}%c\\n\\tTreating it as an async require.\\n\\tAll modules require synchronously clientside must be required serverside at a module level. Expected imports: ${Object.keys(serializedModule.requests).join(\" | \")}`,\n                            \"color: red\",\n                            \"color: unset\",\n                            \"color: red\",\n                            \"color: unset\"\n                        );\n                    }\n                    return rootRequire(absolutePath);\n                }\n\n                // Built in modules that we haven't been implemented\n                if (serializedModule.requests[request] === \"\") {\n                    return {};\n                }\n\n                resolvedPath = serializedModule.requests[request];\n            }\n            if (resolvedPath !== \"NOTALLOWEDCLIENTSIDE\" && !serializedModules[resolvedPath]) {\n                if (!asyncIsFine) {\n                    console.warn(\n                        `Accessed unexpected module %c${request}%c in %c${module.id}%c\\n\\tTreating it as an async require.\\n\\tAll modules require synchronously clientside must be required serverside at a module level. Expected imports: ${Object.keys(serializedModule.requests).join(\" | \")}`,\n                        \"color: red\",\n                        \"color: unset\",\n                        \"color: red\",\n                        \"color: unset\"\n                    );\n                }\n                return rootRequire(resolvedPath);\n            }\n\n            let exportsOverride: unknown | undefined;\n            if (resolvedPath === \"NOTALLOWEDCLIENTSIDE\" || !serializedModules[resolvedPath]?.allowclient) {\n                let childId = resolvedPath === \"NOTALLOWEDCLIENTSIDE\" ? request : resolvedPath;\n                if (serializedModules[resolvedPath]?.serveronly) {\n                    exportsOverride = new Proxy(\n                        {},\n                        {\n                            get(target, property) {\n                                if (property === \"__esModule\") return undefined;\n                                // NOTE: Return a toString that evaluates to \"\" so we can EXPLICITLY detect non-loaded modules\n                                if (property === unloadedModule) return true;\n                                if (property === \"default\") return exportsOverride;\n\n                                throw new Error(\n                                    `Module ${childId} is serverside only. Tried to access ${String(property)} from ${module.id}`\n                                );\n                            },\n                        }\n                    );\n                } else {\n                    exportsOverride = new Proxy(\n                        {},\n                        {\n                            get(target, property) {\n                                if (property === \"__esModule\") return undefined;\n                                // NOTE: Return a toString that evaluates to \"\" so we can EXPLICITLY detect non-loaded modules\n                                if (property === unloadedModule) return true;\n                                if (property === \"default\") return exportsOverride;\n\n                                let type = \"non-whitelisted\";\n                                if (!serializedModules[resolvedPath!]) {\n                                    type = \"missing module\";\n                                }\n\n                                console.warn(\n                                    `Accessed ${type} module %c${childId}%c, specifically property %c${String(\n                                        property\n                                    )}%c.\\n\\tAdd %cmodule.allowclient = true%c to the file to allow access.\\n\\t(IF it is a 3rd party library, use the global \"setFlag\" helper (in the file you imported the module) to set properties on other modules (it can even recursively set properties)).\\n\\n\\tFrom ${module.id\n                                    }`,\n                                    \"color: red\",\n                                    \"color: unset\",\n                                    \"color: red\",\n                                    \"color: unset\",\n                                    \"color: red\",\n                                    \"color: unset\"\n                                );\n                                return undefined;\n                            },\n                        }\n                    );\n                }\n            }\n\n            if (resolvedPath === \"NOTALLOWEDCLIENTSIDE\") {\n                return exportsOverride;\n            }\n\n            let providerModule = getModule(resolvedPath);\n            module.children.push(providerModule);\n            if (exportsOverride !== undefined) {\n                providerModule.exports = exportsOverride;\n            }\n\n            let exports = providerModule.exports;\n            let remapExports = providerModule.remapExports;\n            if (remapExports && typeof remapExports === \"function\") {\n                exports = remapExports(exports, module);\n            }\n\n            return exports;\n        }\n    }\n\n    /** Generates the module root function, which can be called to evaluate the module,\n     *      and has code equal to contents.\n     *      - filename is just for debugging / stack traces\n     */\n    function wrapSafe(filename: string, contents: string) {\n        // TODO: Have the serverside inform us of the correct loader, or... have it actually emit a .json loader.\n        if (filename.endsWith(\".json\")) {\n            return (exports: unknown, require: unknown, module: ModuleType) => (module.exports = contents && JSON.parse(contents));\n        }\n\n        // NOTE: debugName only matters during module evaluation. After that the sourcemap should work.\n        let debugName = filename\n            .replace(/\\\\/g, \"/\")\n            .split(\"/\")\n            .slice(-1)[0]\n            .replace(/\\./g, \"_\")\n            .replace(/[^a-zA-Z_]/g, \"\");\n        // NOTE: eval is used instead of new Function, as new Function inject lines, which messes\n        //  up our sourcemaps.\n        // NOTE: All on one line, so we don't break sourcemaps by TOO much. We could also parse\n        //  the sourcemap and adjust it, but... it is much easier to just not change the line counts.\n        return eval(\n            `(function ${debugName}(exports, require, module, __filename, __dirname, importDynamic) {\"use strict\";${contents}\\n })`\n        );\n    }\n\n    const unloadedModule = Symbol(\"unloadedModule\");\n\n    let currentModuleEvaluationStack: string[] = [];\n    // See https://nodejs.org/api/modules.html\n    function getModule(resolvedId: string, preload?: \"preload\"): ModuleType {\n        if (resolvedId === \"\") {\n            return {} as ModuleType;\n        }\n        if (resolvedId in moduleCache) {\n            let module = moduleCache[resolvedId];\n            if (!preload && !module.loaded) {\n                module.loaded = true;\n                module.load();\n            }\n            return module;\n        }\n\n        let serializedModule = serializedModules[resolvedId];\n        if (!serializedModule) {\n            // I can't figure out why this happens as it seems to happen very rarely and only when I'm debugging other code.\n            //  - I have had it happen immediately after starting the app. Although in theory a hot reload could have\n            //      triggered due to VS code writing to a file. \n            //  - I've had times when it happens once after startup and then it goes away and other times where it\n            //      happens every single time and never goes away until I restart aipaint.\n            //  - Maybe it happens if we switch servers and so the root paths are different in some way?\n            debugger;\n            console.warn(`Failed to find module ${resolvedId}. The server should have given an error about this.`, serializedModules);\n        }\n\n        let module = Object.create(null) as ModuleType;\n        moduleCache[resolvedId] = module;\n        module.id = resolvedId;\n        module.filename = serializedModule?.filename || \"\";\n        module.exports = {};\n        // Default default of exports to the exports itself\n        (module.exports as any).default = module.exports;\n        module.children = [];\n        for (let key in serializedModule?.flags || {}) {\n            if (key === \"loaded\") continue;\n            (module as any)[key] = true;\n        }\n\n        module.load = load;\n\n        let originalSource = serializedModule?.source || \"\";\n        let moduleFnc = wrapSafe(module.id, originalSource);\n\n        globalThis.onProgressHandler?.({\n            type: \"Compile\",\n            addValue: 1,\n            addMax: 0,\n        });\n\n        if (!preload) {\n            module.loaded = true;\n            module.load();\n        }\n\n        function load() {\n            const serializedModule = serializedModules[resolvedId];\n            if (!serializedModule) return;\n            if (!module.loaded) {\n                module.evaluateStarted = false;\n                if (alreadyHave) {\n                    delete alreadyHave.seqNums[serializedModule.seqNum];\n                }\n                // NOTE: There is almost never a way to recover from module downloading errors, so just don't catch them\n                return Promise.resolve()\n                    .then(() => rootRequire(resolvedId, true))\n                    .then(async () => {\n                        module.loaded = true;\n                        await load();\n                    });\n            }\n\n            // Skip double loads\n            if (module.evaluateStarted) return;\n\n            module.original = serializedModule;\n\n            module.requires = serializedModule.requests;\n            module.require = createRequire(module, serializedModule) as any;\n            // TODO: Once typescript supports dynamic import, map import() to importDynamic, so it\n            //  uses our import function, instead of the built in one.\n            //  (As apparently we can't just override import on a per module basis, because\n            //      we can't have an identify called \"import\"... which is annoying).\n            let importDynamic = createRequire(module, serializedModule, true);\n            module.import = importDynamic;\n\n            let source = serializedModule.source;\n\n            module.allowclient = !!serializedModule.source;\n\n            // Import children, as the children may be allowed clientside, and may have side-effects!\n            if (!source) {\n                let requests = Object.keys(serializedModule.requests)\n                    .filter((x) => x !== \"NOTALLOWEDCLIENTSIDE\")\n                    .filter((x) => !(x in serializedModule.asyncRequests));\n                source = requests.map((id) => `require(${JSON.stringify(id)});\\n`).join(\"\");\n            }\n\n            module.size = source.length;\n            module.source = source;\n\n            if (source !== originalSource) {\n                originalSource = source;\n                moduleFnc = wrapSafe(module.id, originalSource);\n            }\n\n            let dirname = module.filename.replace(/\\\\/g, \"/\").split(\"/\").slice(0, -1).join(\"/\");\n\n            let time = Date.now();\n            currentModuleEvaluationStack.push(module.filename);\n            try {\n                module.evaluateStarted = true;\n                module.isPreloading = true;\n                module.evalStartTime = nextTime();\n                module.evalEndTime = undefined;\n                moduleFnc.call(\n                    {\n                        // NOTE: Adding __importStar to the module causes typescript to use our implementation,\n                        //  which checks for unloadedModule and returns undefined in that case.\n                        __importStar(mod: any) {\n                            if (mod[unloadedModule]) return undefined;\n                            return mod;\n                        },\n                        __importDefault(mod: any) {\n                            return mod.default ? mod : { default: mod };\n                        },\n                    },\n                    module.exports,\n                    // eslint-disable-next-line @typescript-eslint/unbound-method\n                    module.require,\n                    module,\n                    module.filename,\n                    dirname,\n                    importDynamic\n                );\n                module.evalEndTime = nextTime();\n                time = Date.now() - time;\n                // NOTE: This log statment is disabled as I believe it causes lag (when devtools is open).\n                //  As in, adding about 500ms to our load time, which is annoying when debugging.\n                //console.debug(`Evaluated module ${module.filename} ${Math.ceil(source.length / 1024)}KB`);\n            } finally {\n                module.isPreloading = false;\n                currentModuleEvaluationStack.pop();\n\n                globalThis.onProgressHandler?.({\n                    type: \"Evaluate\",\n                    addValue: 1,\n                    addMax: 0,\n                });\n            }\n        }\n\n        return module;\n    }\n}"]}
+ /* _JS_SOURCE_HASH = "15af84828acbac04ce4afc013df34adb3fef63924b44dbeeddf60bb9cf7d838b"; */