socket-function 1.1.49 → 1.2.0

package/require/dist/RequireController.ts.cache

@@ -0,0 +1,386 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.RequireController = exports.allowAllNodeModules = exports.setRequireBootRequire = exports.getIsAllowClient = exports.lazyImport = void 0;
+const fs_1 = __importDefault(require("fs"));
+const SocketFunction_1 = require("../SocketFunction");
+const callHTTPHandler_1 = require("../src/callHTTPHandler");
+const misc_1 = require("../src/misc");
+const zlib_1 = __importDefault(require("zlib"));
+const caching_1 = require("../src/caching");
+const createSingleton_1 = require("../src/createSingleton");
+const require_1 = require("./require");
+const path_1 = __importDefault(require("path"));
+const extMapper_1 = require("./extMapper");
+const COMPRESS_CACHE_SIZE = 1024 * 1024 * 128;
+module.allowclient = true;
+/** Imports it, serverside, delayed. For dynamic imports, which we need to include once, but don't want to include
+ *      immediately (due to cyclic issues), and isn't included initially.
+ */
+function lazyImport(getModule) {
+    if (!(0, misc_1.isNode)())
+        return;
+    // Import it, asynchronously, so it isn't preloaded, but it is available for clientside imports.
+    //  NOTE: We track delayed imports (somewhere), and don't preload them by default in RequireController.
+    void Promise.resolve().then(() => getModule());
+}
+exports.lazyImport = lazyImport;
+let nextModuleSeqNum = 1;
+const requireSeqNumProcessId = "requireSeqNumProcessId_" + Date.now() + "_" + Math.random();
+const BEFORE_ENTRY_TEMPLATE = "<!-- BEFORE_ENTRY_TEMPLATE -->";
+const ENTRY_TEMPLATE = "<!-- ENTRY_TEMPLATE -->";
+const resolvedHTMLFile = (0, caching_1.lazy)(() => {
+    const bufferShim = fs_1.default.readFileSync(__dirname + "/buffer.js").toString();
+    return fs_1.default.readFileSync(__dirname + "/require.html").toString()
+        .replace(BEFORE_ENTRY_TEMPLATE, `
+                <script>${bufferShim}</script>
+                <script>(${require_1.requireMain.toString()})()</script>
+
+                ${BEFORE_ENTRY_TEMPLATE}
+            `);
+});
+// All of these are mutated by the static helpers below (injectHTMLBeforeStartup, addStaticRoot,
+//  addMapGetModules), which callers invoke on RequireController. But only the first-registered
+//  copy's controller actually serves requireHTML/getModules, and it reads these vars. So they must
+//  be shared across copies, or a caller using a different copy would add (ex) before-entry HTML
+//  that the serving controller never reads. See createSingleton.
+const beforeEntryText = (0, createSingleton_1.createSingleton)("RequireController.beforeEntryText", 1, () => []).get();
+function injectHTMLBeforeStartup(text) {
+    beforeEntryText.push(text);
+}
+const staticRoots = (0, createSingleton_1.createSingleton)("RequireController.staticRoots", 1, () => []).get();
+function addStaticRoot(root) {
+    if (!root.endsWith("/")) {
+        root += "/";
+    }
+    staticRoots.push(root);
+}
+const mapGetModules = (0, createSingleton_1.createSingleton)("RequireController.mapGetModules", 1, () => []).get();
+function addMapGetModules(remap) {
+    mapGetModules.push({ remap });
+}
+class RequireControllerBase {
+    constructor() {
+        this.rootResolvePath = "";
+    }
+    async requireHTML(config) {
+        let { requireCalls, cacheTime } = config || {};
+        let httpRequest = (0, callHTTPHandler_1.getCurrentHTTPRequest)();
+        let headers = {
+            "Content-Type": "text/html"
+        };
+        if (cacheTime) {
+            headers["Cache-Control"] = `max-age=${Math.floor(cacheTime / 1000)}`;
+        }
+        if (httpRequest) {
+            let urlObj = new URL("https://" + httpRequest.headers.host + httpRequest.url);
+            if (urlObj.pathname !== "/" && staticRoots.length > 0) {
+                if (urlObj.pathname.includes("..")) {
+                    throw new Error(`Invalid path, may not have ".." in the path, ${urlObj.pathname}`);
+                }
+                let result;
+                for (let root of staticRoots) {
+                    let resolved = root + urlObj.pathname;
+                    if (fs_1.default.existsSync(resolved)) {
+                        let rootResolved = path_1.default.resolve(resolved);
+                        let finalResolved = path_1.default.resolve(rootResolved);
+                        if (!finalResolved.startsWith(rootResolved)) {
+                            throw new Error(`Invalid access, did not stay in namespace: ${JSON.stringify(rootResolved)}, but escaped: ${JSON.stringify(finalResolved)}`);
+                        }
+                        result = await fs_1.default.promises.readFile(resolved);
+                        break;
+                    }
+                }
+                if (result) {
+                    let contentType = (0, extMapper_1.getContentTypeFromBuffer)(result);
+                    if (!contentType) {
+                        let ext = path_1.default.extname(urlObj.pathname);
+                        contentType = (0, extMapper_1.getExtContentType)(ext);
+                    }
+                    headers["Content-Type"] = contentType;
+                    return (0, callHTTPHandler_1.setHTTPResultHeaders)(result, headers);
+                }
+                return (0, callHTTPHandler_1.setHTTPResultHeaders)(Buffer.from(`Static file not found, ${urlObj.pathname}, have static roots: ${JSON.stringify(staticRoots)}`), headers);
+            }
+        }
+        if (!this.rootResolvePath) {
+            let dir = path_1.default.resolve(".");
+            dir = dir.replaceAll("\\", "/");
+            this.rootResolvePath = dir;
+        }
+        let result = resolvedHTMLFile();
+        if (beforeEntryText.length > 0) {
+            let resolved = [];
+            for (let text of beforeEntryText) {
+                if (typeof text === "string") {
+                    resolved.push(text);
+                }
+                else {
+                    resolved.push(await text());
+                }
+            }
+            result = result.replace(BEFORE_ENTRY_TEMPLATE, resolved.join("\n"));
+        }
+        if (requireCalls) {
+            async function requireAll(calls) {
+                // NOTE: awaiting isn't just for better and consistent load order, it also greatly improves load efficiency,
+                //  as parallel calls can't know what files will be loaded, so there is a lot of duplicate loading. Loading
+                //  1 at a time allows require to efficiently require only files that previous imports haven't loaded.
+                for (let call of calls) {
+                    try {
+                        await require(call);
+                    }
+                    catch (e) {
+                        // Detach the error so we can continue
+                        setTimeout(() => { throw e; });
+                    }
+                }
+            }
+            result = result.replace(ENTRY_TEMPLATE, `<script>\n(${requireAll.toString()})(${JSON.stringify(requireCalls)});\n</script>`);
+        }
+        else {
+            result = result.replace(ENTRY_TEMPLATE, "");
+        }
+        return (0, callHTTPHandler_1.setHTTPResultHeaders)(Buffer.from(result), headers);
+    }
+    async getModules(pathRequests, alreadyHave, config) {
+        var _a;
+        let httpRequest = (0, callHTTPHandler_1.getCurrentHTTPRequest)();
+        let seqNums = {};
+        if ((alreadyHave === null || alreadyHave === void 0 ? void 0 : alreadyHave.requireSeqNumProcessId) === requireSeqNumProcessId) {
+            for (let { s, e } of alreadyHave.seqNumRanges) {
+                if (e === undefined) {
+                    e = s + 1;
+                }
+                for (let i = s; i < e; i++) {
+                    seqNums[i] = 1;
+                }
+            }
+        }
+        let modules = Object.create(null);
+        function addModule(module, rootImport = false) {
+            var _a;
+            if (!rootImport && module.lazyload)
+                return;
+            if (!module.requireControllerSeqNum) {
+                module.requireControllerSeqNum = nextModuleSeqNum++;
+            }
+            if (seqNums[module.requireControllerSeqNum]) {
+                return;
+            }
+            if (module.filename in modules)
+                return;
+            // TODO: Remove unused exports. We know why the module is being requested, so we can
+            //  actually very effectively know which exports it has which will never be used.
+            //  - Of course, we would need to make the module specially, so if any new modules
+            //      use it we can know... what was removed? It becomes complicated with
+            //      lazy modules, but... it is still very important.
+            // IMPORTANT! Use module.filename, to strip the ".CLIENT_NAMEPSACE" extension
+            modules[module.filename] = {
+                originalId: module.id,
+                filename: module.filename,
+                // NOTE: Due to recursive sets of allowclient, it is very possible for allowclient && serveronly to be set.
+                allowclient: getIsAllowClient(module),
+                serveronly: module.serveronly,
+                requests: Object.create(null),
+                seqNum: module.requireControllerSeqNum,
+                size: module.size,
+                version: module.version,
+                asyncRequests: module.asyncRequires || {},
+                flags: {},
+            };
+            let flags = modules[module.filename].flags;
+            for (let [flag, value] of Object.entries(module)) {
+                if (value === true) {
+                    flags[flag] = value;
+                }
+            }
+            let moduleObj = modules[module.filename];
+            if (moduleObj.allowclient) {
+                moduleObj.source = module.moduleContents;
+                if (module.filename.endsWith(".json") && !moduleObj.source) {
+                    moduleObj.source = module.moduleContents = fs_1.default.readFileSync(module.filename).toString();
+                }
+            }
+            // NOTE: Iterate on children even if it isn't allowed client, as the module may have children
+            //  that are allowed clientside, and that have side-effects! (Mostly for static resources)
+            //  - Surprisingly, this only increases the returned size by about 8% (probably more like 16%
+            //      if we turn source maps off), so... it's fine. And with compression most of the extra
+            //      size will go away, as paths are highly repetitive.
+            //      - And now it increases the size by much less, as we ignore any subtree which are entirely
+            //          not allowed on the client.
+            for (let request in module.requires) {
+                let requireResolvedPath = module.requires[request];
+                let requiredModule = require.cache[requireResolvedPath];
+                if (requiredModule) {
+                    // Only include synchronous modules. BUT, DO include the requests, so when/if the request is made
+                    //  it can be resolved correctly.
+                    if (!((_a = module.asyncRequires) === null || _a === void 0 ? void 0 : _a[request])) {
+                        addModule(requiredModule);
+                    }
+                    moduleObj.requests[request] = requiredModule.filename;
+                }
+                else {
+                    moduleObj.requests[request] = "";
+                }
+            }
+        }
+        let searchPaths = [];
+        {
+            searchPaths.push(this.rootResolvePath);
+            let pathParts = this.rootResolvePath.replaceAll("\\", "/").split("/");
+            for (let i = 0; i < pathParts.length; i++) {
+                // Skip empty path parts, to preventing the case where the path ends
+                //  with a /, which would result in "D:/test//node_modules"
+                if (!pathParts[i])
+                    continue;
+                searchPaths.push(pathParts.slice(0, i + 1).join("/") + "/node_modules");
+            }
+        }
+        let requestsResolvedPaths = [];
+        for (let pathRequest of pathRequests) {
+            let resolvedPath = "";
+            try {
+                resolvedPath = require.resolve(pathRequest, { paths: searchPaths });
+            }
+            catch (_b) { }
+            requestsResolvedPaths.push(resolvedPath);
+            function createNotFoundModule(error) {
+                console.warn(error);
+                return {
+                    exports: {},
+                    children: [],
+                    filename: resolvedPath,
+                    id: resolvedPath,
+                    isPreloading: false,
+                    require: null,
+                    loaded: true,
+                    load: null,
+                    parent: undefined,
+                    path: "",
+                    paths: [],
+                    requires: {},
+                    asyncRequires: {},
+                    allowclient: true,
+                    moduleContents: `console.warn(${JSON.stringify(error)})`,
+                };
+            }
+            // TODO: We could use import() here... but that would only make the root call asynchronous,
+            //  which wouldn't prevent synchronous blocking by that much anyway...
+            //require(rootPath);
+            let clientModule = require.cache[resolvedPath];
+            if (!clientModule) {
+                // NOTE: Root requires will be asynchronous, so throwing should be just as good as
+                //  warning, except throwing can be caught and retried on another server.
+                throw new Error(`Module ${pathRequest} (resolved to ${JSON.stringify(resolvedPath)}) was not included serverside. Resolved from root dir ${JSON.stringify(this.rootResolvePath)} (set by call to setRequireBootRequire), resolve search paths: ${JSON.stringify(searchPaths)})}`);
+            }
+            if (!clientModule.allowclient) {
+                clientModule = createNotFoundModule(`Module ${pathRequest} (resolved to ${resolvedPath}) is not allowed clientside (set module.allowclient in it, or call setFlag when it is imported).`);
+            }
+            addModule(clientModule, true);
+        }
+        let result = { requestsResolvedPaths, modules, requireSeqNumProcessId };
+        for (let remap of mapGetModules) {
+            result = await remap.remap(result, [pathRequests, alreadyHave, config]);
+        }
+        // NOTE: Handling compression ourself allows us to efficiently cache (otherwise caching would require
+        //      hashing the output, which takes almost as long as compression!)
+        if (httpRequest && SocketFunction_1.SocketFunction.HTTP_COMPRESS && ((_a = httpRequest.headers["accept-encoding"]) === null || _a === void 0 ? void 0 : _a.includes("gzip"))) {
+            let simplifiedResult = {
+                ...result,
+                modules: Object.entries(result.modules).map(x => {
+                    var _a;
+                    return [x[0], {
+                            filename: x[1].filename,
+                            version: x[1].version,
+                            sourceLength: (_a = x[1].source) === null || _a === void 0 ? void 0 : _a.length,
+                        }];
+                }),
+            };
+            let key = (0, misc_1.sha256Hash)(JSON.stringify(simplifiedResult));
+            let uncompressedBuffer = Buffer.from(JSON.stringify(result));
+            let buffer = await compressCached(key, () => uncompressedBuffer);
+            (0, callHTTPHandler_1.setHTTPResultHeaders)(buffer, {
+                "Content-Type": "application/json",
+                "Content-Encoding": "gzip",
+                "Content-Length": buffer.length.toString(),
+                "X-Uncompressed-Content-Length": uncompressedBuffer.length.toString(),
+            });
+            return buffer;
+        }
+        return result;
+    }
+}
+let compressCacheSize = 0;
+let compressCache = new Map();
+async function compressCached(bufferKey, buffer) {
+    let cached = compressCache.get(bufferKey);
+    if (!cached) {
+        cached = await new Promise((resolve, reject) => {
+            zlib_1.default.gzip(buffer(), {}, (err, result) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(result);
+                }
+            });
+        });
+        compressCacheSize += cached.length;
+        // TODO: Make the cache LRU eviction, instead of just resetting it
+        if (compressCacheSize > COMPRESS_CACHE_SIZE) {
+            compressCache.clear();
+            compressCacheSize = cached.length;
+        }
+        compressCache.set(bufferKey, cached);
+    }
+    return cached;
+}
+function getIsAllowClient(module) {
+    if (module.serveronly)
+        return false;
+    // IMPORTANT! We do not allow everything in node modules by default, as most things in node modules, you don't want to import client-side, and it will break if you import it client-side. Many of these are imported, but will never end up being called client-side, so it's fine to exclude them.
+    if (allowAllNodeModulesFlag.get().value && module.filename.includes("node_modules")) {
+        return true;
+    }
+    return module.allowclient;
+}
+exports.getIsAllowClient = getIsAllowClient;
+// Shared across copies of this package, so the registered controller and rootResolvePath (set by
+//  setRequireBootRequire) are the same instance everyone reads/writes. See createSingleton.
+const baseController = (0, createSingleton_1.createSingleton)("RequireController.baseController", 1, () => new RequireControllerBase()).get();
+/** @deprecated, not needed, as this defaults to ".", which is a lot easier to reason about anyways. */
+function setRequireBootRequire(dir) {
+    dir = path_1.default.resolve(dir);
+    dir = dir.replaceAll("\\", "/");
+    if (!dir.endsWith("/")) {
+        dir += "/";
+    }
+    baseController.rootResolvePath = dir;
+}
+exports.setRequireBootRequire = setRequireBootRequire;
+// Shared across copies, so calling allowAllNodeModules() on any copy is seen by the serving
+//  controller's getIsAllowClient. See createSingleton.
+const allowAllNodeModulesFlag = (0, createSingleton_1.createSingleton)("RequireController.allowAllNodeModules", 1, () => ({ value: false }));
+function allowAllNodeModules() {
+    allowAllNodeModulesFlag.get().value = true;
+}
+exports.allowAllNodeModules = allowAllNodeModules;
+exports.RequireController = SocketFunction_1.SocketFunction.register("RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d", baseController, () => ({
+    getModules: {},
+    requireHTML: {},
+    bufferJS: {},
+    requireJS: {},
+}), undefined, {
+    noAutoExpose: true,
+    statics: {
+        injectHTMLBeforeStartup,
+        addMapGetModules,
+        addStaticRoot,
+        allowAllNodeModules,
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RequireController.js","sourceRoot":"","sources":["RequireController.ts"],"names":[],"mappings":"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","sourcesContent":["/// <reference path=\"../../typenode/index.d.ts\" />\nimport debugbreak from \"debugbreak\";\nimport fs from \"fs\";\nimport { SocketFunction } from \"../SocketFunction\";\nimport { getCurrentHTTPRequest, setHTTPResultHeaders } from \"../src/callHTTPHandler\";\nimport { formatNumberSuffixed, isNode, isNodeTrue, sha256Hash, sha256HashPromise } from \"../src/misc\";\nimport zlib from \"zlib\";\nimport { cacheLimited, lazy } from \"../src/caching\";\nimport { createSingleton } from \"../src/createSingleton\";\nimport { formatNumber } from \"../src/formatting/format\";\nimport { requireMain } from \"./require\";\nimport path from \"path\";\nimport { getContentTypeFromBuffer, getExtContentType } from \"./extMapper\";\n\nconst COMPRESS_CACHE_SIZE = 1024 * 1024 * 128;\n\nmodule.allowclient = true;\n\ndeclare global {\n    namespace NodeJS {\n        interface Module {\n            /** Indicates the module is allowed clientside.\n             *  NOTE: Set with `module.allowclient = true`. HOWEVER, access via getIsAllowClient, which will check \n             */\n            allowclient?: boolean;\n\n            /** Causes the module to not preload, requiring `await import()` for it to load correctly\n             *      - Shouldn't be set recursively, otherwise nested packages will break.\n             */\n            lazyload?: boolean;\n\n            /** Indicates the module is definitely not allowed clientside */\n            serveronly?: boolean;\n\n            // TODO: Move seqNum into the actual compilation, and make it increment,\n            //  so the clientside can properly handle race conditions during hot reloading.\n            //  And... maybe it is useful in other cases?\n            /** Used internally by RequireController */\n            requireControllerSeqNum?: number;\n\n            // Times are both unique (two modules evaluated at the same Date.now() will have different values).\n            evalStartTime?: number;\n            evalEndTime?: number;\n\n            /** (Presently only called by require.js)\n             *      Called on require calls, to allow providers to create custom exports depending on the caller.\n             *          - Mostly used to allow functions to know the calling module.\n             */\n            remapExports?: (exports: { [key: string]: unknown }, callerModule: NodeJS.Module) => { [key: string]: unknown };\n\n            /** Only set if clientside (and allowed clientside) */\n            source?: string;\n        }\n    }\n    interface Window {\n        clientsideBootTime: number;\n    }\n    var suppressUnexpectedModuleWarning: number | undefined;\n}\n\n/** Imports it, serverside, delayed. For dynamic imports, which we need to include once, but don't want to include\n *      immediately (due to cyclic issues), and isn't included initially.\n */\nexport function lazyImport(getModule: () => Promise<unknown>) {\n    if (!isNode()) return;\n    // Import it, asynchronously, so it isn't preloaded, but it is available for clientside imports.\n    //  NOTE: We track delayed imports (somewhere), and don't preload them by default in RequireController.\n    void Promise.resolve().then(() => getModule());\n}\n\n\nlet nextModuleSeqNum = 1;\n\nconst requireSeqNumProcessId = \"requireSeqNumProcessId_\" + Date.now() + \"_\" + Math.random();\n\nconst BEFORE_ENTRY_TEMPLATE = \"<!-- BEFORE_ENTRY_TEMPLATE -->\";\nconst ENTRY_TEMPLATE = \"<!-- ENTRY_TEMPLATE -->\";\n\nconst resolvedHTMLFile = lazy(() => {\n    const bufferShim = fs.readFileSync(__dirname + \"/buffer.js\").toString();\n    return fs.readFileSync(__dirname + \"/require.html\").toString()\n        .replace(BEFORE_ENTRY_TEMPLATE,\n            `\n                <script>${bufferShim}</script>\n                <script>(${requireMain.toString()})()</script>\n\n                ${BEFORE_ENTRY_TEMPLATE}\n            `\n        );\n});\n\n// All of these are mutated by the static helpers below (injectHTMLBeforeStartup, addStaticRoot,\n//  addMapGetModules), which callers invoke on RequireController. But only the first-registered\n//  copy's controller actually serves requireHTML/getModules, and it reads these vars. So they must\n//  be shared across copies, or a caller using a different copy would add (ex) before-entry HTML\n//  that the serving controller never reads. See createSingleton.\nconst beforeEntryText = createSingleton(\"RequireController.beforeEntryText\", 1, () => [] as (string | (() => Promise<string>))[]).get();\nfunction injectHTMLBeforeStartup(text: string | (() => Promise<string>)) {\n    beforeEntryText.push(text);\n}\nconst staticRoots = createSingleton(\"RequireController.staticRoots\", 1, () => [] as string[]).get();\nfunction addStaticRoot(root: string) {\n    if (!root.endsWith(\"/\")) {\n        root += \"/\";\n    }\n    staticRoots.push(root);\n}\n\ntype GetModulesResult = ReturnType<RequireControllerBase[\"getModules\"]> extends Promise<infer T> ? T : never;\nexport type GetModulesArgs = Parameters<RequireControllerBase[\"getModules\"]>;\nconst mapGetModules = createSingleton(\"RequireController.mapGetModules\", 1, () => [] as {\n    remap(result: GetModulesResult, args: GetModulesArgs): Promise<GetModulesResult>\n}[]).get();\nfunction addMapGetModules(remap: typeof mapGetModules[number][\"remap\"]) {\n    mapGetModules.push({ remap });\n}\n\nclass RequireControllerBase {\n    public rootResolvePath = \"\";\n\n    public async requireHTML(config?: {\n        requireCalls?: string[];\n        cacheTime?: number;\n    }): Promise<Buffer> {\n        let { requireCalls, cacheTime } = config || {};\n        let httpRequest = getCurrentHTTPRequest();\n        let headers: Record<string, string> = {\n            \"Content-Type\": \"text/html\"\n        };\n        if (cacheTime) {\n            headers[\"Cache-Control\"] = `max-age=${Math.floor(cacheTime / 1000)}`;\n        }\n        if (httpRequest) {\n            let urlObj = new URL(\"https://\" + httpRequest.headers.host + httpRequest.url);\n            if (urlObj.pathname !== \"/\" && staticRoots.length > 0) {\n                if (urlObj.pathname.includes(\"..\")) {\n                    throw new Error(`Invalid path, may not have \"..\" in the path, ${urlObj.pathname}`);\n                }\n\n\n                let result: Buffer | undefined;\n                for (let root of staticRoots) {\n                    let resolved = root + urlObj.pathname;\n                    if (fs.existsSync(resolved)) {\n                        let rootResolved = path.resolve(resolved);\n                        let finalResolved = path.resolve(rootResolved);\n                        if (!finalResolved.startsWith(rootResolved)) {\n                            throw new Error(`Invalid access, did not stay in namespace: ${JSON.stringify(rootResolved)}, but escaped: ${JSON.stringify(finalResolved)}`);\n                        }\n                        result = await fs.promises.readFile(resolved);\n                        break;\n                    }\n                }\n                if (result) {\n                    let contentType = getContentTypeFromBuffer(result);\n                    if (!contentType) {\n                        let ext = path.extname(urlObj.pathname);\n                        contentType = getExtContentType(ext);\n                    }\n                    headers[\"Content-Type\"] = contentType;\n                    return setHTTPResultHeaders(result, headers);\n                }\n\n                return setHTTPResultHeaders(Buffer.from(`Static file not found, ${urlObj.pathname}, have static roots: ${JSON.stringify(staticRoots)}`), headers);\n            }\n\n        }\n        if (!this.rootResolvePath) {\n            let dir = path.resolve(\".\");\n            dir = dir.replaceAll(\"\\\\\", \"/\");\n            this.rootResolvePath = dir;\n        }\n        let result = resolvedHTMLFile();\n        if (beforeEntryText.length > 0) {\n            let resolved: string[] = [];\n            for (let text of beforeEntryText) {\n                if (typeof text === \"string\") {\n                    resolved.push(text);\n                } else {\n                    resolved.push(await text());\n                }\n            }\n            result = result.replace(BEFORE_ENTRY_TEMPLATE, resolved.join(\"\\n\"));\n        }\n        if (requireCalls) {\n            async function requireAll(calls: string[]) {\n                // NOTE: awaiting isn't just for better and consistent load order, it also greatly improves load efficiency,\n                //  as parallel calls can't know what files will be loaded, so there is a lot of duplicate loading. Loading\n                //  1 at a time allows require to efficiently require only files that previous imports haven't loaded.\n                for (let call of calls) {\n                    try {\n                        await require(call);\n                    } catch (e) {\n                        // Detach the error so we can continue\n                        setTimeout(() => { throw e; });\n                    }\n                }\n            }\n            result = result.replace(ENTRY_TEMPLATE, `<script>\\n(${requireAll.toString()})(${JSON.stringify(requireCalls)});\\n</script>`);\n        } else {\n            result = result.replace(ENTRY_TEMPLATE, \"\");\n        }\n        return setHTTPResultHeaders(Buffer.from(result), headers);\n    }\n\n    public async getModules(\n        pathRequests: string[],\n        alreadyHave?: {\n            requireSeqNumProcessId: string;\n            // NOTE: Highly optimized, as otherwise this can easily be KBs (I was seeing 9KB),\n            //  which is uploaded, and so can be quite slow on slow connections.\n            seqNumRanges: {\n                s: number;\n                // undefined means s + 1 (so just a single number)\n                e?: number;\n            }[];\n        },\n        config?: {}\n    ): Promise<{\n        requestsResolvedPaths: string[];\n        modules: {\n            [resolvedPath: string]: SerializedModule;\n        };\n        requireSeqNumProcessId: string;\n    }> {\n        let httpRequest = getCurrentHTTPRequest();\n\n        let seqNums: { [seqNum: number]: 1 } = {};\n        if (alreadyHave?.requireSeqNumProcessId === requireSeqNumProcessId) {\n            for (let { s, e } of alreadyHave.seqNumRanges) {\n                if (e === undefined) {\n                    e = s + 1;\n                }\n                for (let i = s; i < e; i++) {\n                    seqNums[i] = 1;\n                }\n            }\n        }\n\n        let modules: {\n            [resolvedPath: string]: SerializedModule;\n        } = Object.create(null);\n        function addModule(module: NodeJS.Module, rootImport = false) {\n            if (!rootImport && module.lazyload) return;\n            if (!module.requireControllerSeqNum) {\n                module.requireControllerSeqNum = nextModuleSeqNum++;\n            }\n            if (seqNums[module.requireControllerSeqNum]) {\n                return;\n            }\n            if (module.filename in modules) return;\n\n            // TODO: Remove unused exports. We know why the module is being requested, so we can\n            //  actually very effectively know which exports it has which will never be used.\n            //  - Of course, we would need to make the module specially, so if any new modules\n            //      use it we can know... what was removed? It becomes complicated with\n            //      lazy modules, but... it is still very important.\n\n            // IMPORTANT! Use module.filename, to strip the \".CLIENT_NAMEPSACE\" extension\n            modules[module.filename] = {\n                originalId: module.id,\n                filename: module.filename,\n                // NOTE: Due to recursive sets of allowclient, it is very possible for allowclient && serveronly to be set.\n                allowclient: getIsAllowClient(module),\n                serveronly: module.serveronly,\n                requests: Object.create(null),\n                seqNum: module.requireControllerSeqNum,\n                size: module.size,\n                version: module.version,\n                asyncRequests: module.asyncRequires || {},\n                flags: {},\n            };\n            let flags = modules[module.filename].flags!;\n            for (let [flag, value] of Object.entries(module)) {\n                if (value === true) {\n                    flags[flag] = value;\n                }\n            }\n            let moduleObj = modules[module.filename];\n            if (moduleObj.allowclient) {\n                moduleObj.source = module.moduleContents;\n                if (module.filename.endsWith(\".json\") && !moduleObj.source) {\n                    moduleObj.source = module.moduleContents = fs.readFileSync(module.filename).toString();\n                }\n            }\n\n            // NOTE: Iterate on children even if it isn't allowed client, as the module may have children\n            //  that are allowed clientside, and that have side-effects! (Mostly for static resources)\n            //  - Surprisingly, this only increases the returned size by about 8% (probably more like 16%\n            //      if we turn source maps off), so... it's fine. And with compression most of the extra\n            //      size will go away, as paths are highly repetitive.\n            //      - And now it increases the size by much less, as we ignore any subtree which are entirely\n            //          not allowed on the client.\n            for (let request in module.requires) {\n\n                let requireResolvedPath = module.requires[request];\n                let requiredModule = require.cache[requireResolvedPath];\n\n                if (requiredModule) {\n                    // Only include synchronous modules. BUT, DO include the requests, so when/if the request is made\n                    //  it can be resolved correctly.\n                    if (!module.asyncRequires?.[request]) {\n                        addModule(requiredModule);\n                    }\n                    moduleObj.requests[request] = requiredModule.filename;\n                } else {\n                    moduleObj.requests[request] = \"\";\n                }\n            }\n        }\n\n        let searchPaths: string[] = [];\n        {\n            searchPaths.push(this.rootResolvePath);\n            let pathParts = this.rootResolvePath.replaceAll(\"\\\\\", \"/\").split(\"/\");\n            for (let i = 0; i < pathParts.length; i++) {\n                // Skip empty path parts, to preventing the case where the path ends\n                //  with a /, which would result in \"D:/test//node_modules\"\n                if (!pathParts[i]) continue;\n                searchPaths.push(pathParts.slice(0, i + 1).join(\"/\") + \"/node_modules\");\n            }\n        }\n\n\n        let requestsResolvedPaths: string[] = [];\n        for (let pathRequest of pathRequests) {\n            let resolvedPath = \"\";\n            try {\n                resolvedPath = require.resolve(pathRequest, { paths: searchPaths });\n            } catch { }\n            requestsResolvedPaths.push(resolvedPath);\n\n            function createNotFoundModule(error: string): NodeJS.Module {\n                console.warn(error);\n                return {\n                    exports: {},\n                    children: [],\n                    filename: resolvedPath,\n                    id: resolvedPath,\n                    isPreloading: false,\n                    require: null as any,\n                    loaded: true,\n                    load: null as any,\n                    parent: undefined,\n                    path: \"\",\n                    paths: [],\n                    requires: {},\n                    asyncRequires: {},\n                    allowclient: true,\n                    moduleContents: `console.warn(${JSON.stringify(error)})`,\n                };\n            }\n\n            // TODO: We could use import() here... but that would only make the root call asynchronous,\n            //  which wouldn't prevent synchronous blocking by that much anyway...\n            //require(rootPath);\n            let clientModule = require.cache[resolvedPath];\n            if (!clientModule) {\n                // NOTE: Root requires will be asynchronous, so throwing should be just as good as\n                //  warning, except throwing can be caught and retried on another server.\n                throw new Error(`Module ${pathRequest} (resolved to ${JSON.stringify(resolvedPath)}) was not included serverside. Resolved from root dir ${JSON.stringify(this.rootResolvePath)} (set by call to setRequireBootRequire), resolve search paths: ${JSON.stringify(searchPaths)})}`);\n            }\n            if (!clientModule.allowclient) {\n                clientModule = createNotFoundModule(`Module ${pathRequest} (resolved to ${resolvedPath}) is not allowed clientside (set module.allowclient in it, or call setFlag when it is imported).`);\n            }\n\n            addModule(clientModule, true);\n        }\n\n        let result: GetModulesResult = { requestsResolvedPaths, modules, requireSeqNumProcessId };\n        for (let remap of mapGetModules) {\n            result = await remap.remap(result, [pathRequests, alreadyHave, config]);\n        }\n\n        // NOTE: Handling compression ourself allows us to efficiently cache (otherwise caching would require\n        //      hashing the output, which takes almost as long as compression!)\n        if (httpRequest && SocketFunction.HTTP_COMPRESS && httpRequest.headers[\"accept-encoding\"]?.includes(\"gzip\")) {\n            let simplifiedResult = {\n                ...result,\n                modules: Object.entries(result.modules).map(x => [x[0], {\n                    filename: x[1].filename,\n                    version: x[1].version,\n                    sourceLength: x[1].source?.length,\n                }]),\n            };\n            let key = sha256Hash(JSON.stringify(simplifiedResult));\n            let uncompressedBuffer = Buffer.from(JSON.stringify(result));\n            let buffer = await compressCached(key, () => uncompressedBuffer);\n            setHTTPResultHeaders(buffer, {\n                \"Content-Type\": \"application/json\",\n                \"Content-Encoding\": \"gzip\",\n                \"Content-Length\": buffer.length.toString(),\n                \"X-Uncompressed-Content-Length\": uncompressedBuffer.length.toString(),\n            });\n            return buffer as any;\n        }\n\n        return result;\n    }\n}\n\nlet compressCacheSize = 0;\nlet compressCache = new Map<string, Buffer>();\nasync function compressCached(bufferKey: string, buffer: () => Buffer): Promise<Buffer> {\n    let cached = compressCache.get(bufferKey);\n    if (!cached) {\n        cached = await new Promise<Buffer>((resolve, reject) => {\n            zlib.gzip(buffer(), {}, (err, result) => {\n                if (err) {\n                    reject(err);\n                } else {\n                    resolve(result);\n                }\n            });\n        });\n        compressCacheSize += cached.length;\n        // TODO: Make the cache LRU eviction, instead of just resetting it\n        if (compressCacheSize > COMPRESS_CACHE_SIZE) {\n            compressCache.clear();\n            compressCacheSize = cached.length;\n        }\n        compressCache.set(bufferKey, cached);\n    }\n    return cached;\n}\n\nexport function getIsAllowClient(module: NodeJS.Module) {\n    if (module.serveronly) return false;\n    // IMPORTANT! We do not allow everything in node modules by default, as most things in node modules, you don't want to import client-side, and it will break if you import it client-side. Many of these are imported, but will never end up being called client-side, so it's fine to exclude them.\n    if (allowAllNodeModulesFlag.get().value && module.filename.includes(\"node_modules\")) {\n        return true;\n    }\n    return module.allowclient;\n}\n\ntype ClientRemapCallback = (args: GetModulesArgs) => Promise<GetModulesArgs>;\ndeclare global {\n    /** Must be set clientside BEFORE requests are made (so you likely want to use RequireController.addMapGetModules\n     *      to inject code that will use this) */\n    var remapImportRequestsClientside: undefined | ClientRemapCallback[];\n}\n\n// Shared across copies of this package, so the registered controller and rootResolvePath (set by\n//  setRequireBootRequire) are the same instance everyone reads/writes. See createSingleton.\nconst baseController = createSingleton(\"RequireController.baseController\", 1, () => new RequireControllerBase()).get();\n/** @deprecated, not needed, as this defaults to \".\", which is a lot easier to reason about anyways. */\nexport function setRequireBootRequire(dir: string) {\n    dir = path.resolve(dir);\n    dir = dir.replaceAll(\"\\\\\", \"/\");\n    if (!dir.endsWith(\"/\")) {\n        dir += \"/\";\n    }\n    baseController.rootResolvePath = dir;\n}\n\n// Shared across copies, so calling allowAllNodeModules() on any copy is seen by the serving\n//  controller's getIsAllowClient. See createSingleton.\nconst allowAllNodeModulesFlag = createSingleton(\"RequireController.allowAllNodeModules\", 1, () => ({ value: false }));\nexport function allowAllNodeModules() {\n    allowAllNodeModulesFlag.get().value = true;\n}\n\nexport const RequireController = SocketFunction.register(\n    \"RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d\",\n    baseController,\n    () => ({\n        getModules: {},\n        requireHTML: {},\n        bufferJS: {},\n        requireJS: {},\n    }),\n    undefined,\n    {\n        noAutoExpose: true,\n        statics: {\n            injectHTMLBeforeStartup,\n            addMapGetModules,\n            addStaticRoot,\n            allowAllNodeModules,\n        }\n    }\n);"]}
+ /* _JS_SOURCE_HASH = "19bae7930752fabf466cb7a4d149ff9607f66a4131c1b0fcff934a65b9b703fa"; */

package/require/dist/compileFlags.ts.cache

@@ -0,0 +1,41 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.setFlag = exports.forceModule = void 0;
+/// <reference path="./RequireController.ts" />
+module.allowclient = true;
+/**
+ *      Adds a global function setFlag(require, "typescript", flag) which sets a flag on the client
+ *          - Ex, setFlag(require, "typescript", "allowclient") so allowclient = true on the typescript module.
+ *          - Passing true as the fourth argument sets it recursively
+ */
+// We need at least 1 export, to force this to be treated like a module
+exports.forceModule = true;
+function setRecursive(bangPart, module) {
+    let m = module;
+    m.recursiveBangs = m.recursiveBangs || {};
+    if (m.recursiveBangs[bangPart])
+        return;
+    m.recursiveBangs[bangPart] = true;
+    Object.assign(module, { [bangPart]: true });
+    for (let child of module.children) {
+        setRecursive(bangPart, child);
+    }
+}
+globalThis.setFlag = setFlag;
+function setFlag(require, request, flag, recursive) {
+    let resolvedPath = require.resolve(request);
+    let module = require.cache[resolvedPath];
+    if (!module) {
+        console.warn(`setFlag cannot resolve module ${request}`);
+        return;
+    }
+    if (recursive) {
+        setRecursive(flag, module);
+    }
+    else {
+        module[flag] = true;
+    }
+}
+exports.setFlag = setFlag;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "0380e764f1bc13438253f0f07261ad82643382d968e7f2c9cf03511cfafa7697"; */