sliftutils 0.9.0 → 0.11.0

package/bundler/dist/bundleRequire.ts.cache

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.bundleRequire = void 0;
+function bundleRequire(config) {
+    globalThis.process = globalThis.process || {
+        env: {
+            NODE_ENV: "production",
+        },
+        versions: {},
+        on: () => { },
+    };
+    globalThis.window = globalThis.window || globalThis;
+    globalThis.global = globalThis.global || globalThis;
+    globalThis.setImmediate = globalThis.setImmediate || globalThis.setTimeout;
+    globalThis.BOOTED_EDGE_NODE = undefined;
+    let 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 () { },
+            Writable: function () { },
+        },
+        timers: {
+            // TODO: Add all members of timers
+            setImmediate: globalThis.setImmediate,
+        },
+        child_process: {},
+        events: class EventEmitter {
+        },
+    };
+    // If is nodeJs
+    let allBuiltInModules = new Set();
+    // Electron 
+    allBuiltInModules.add("electron");
+    allBuiltInModules.add("original-fs");
+    allBuiltInModules.add("vscode");
+    if (typeof document === "undefined" && typeof require !== "undefined") {
+        // Change the builts ins to use the actual built ins!
+        let { builtinModules } = require("node:module");
+        for (let key of builtinModules) {
+            allBuiltInModules.add(key);
+        }
+    }
+    for (let key of allBuiltInModules) {
+        Object.defineProperty(builtInModuleExports, key, {
+            get() {
+                return require(key);
+            },
+        });
+    }
+    // Just path.resolve (but needs to be reimplemented, because we can't use imports)
+    function pathResolve(...paths) {
+        // Start with empty path segments array
+        let segments = [];
+        let isWindowsPath = false;
+        paths = paths.map(x => x.replace(/\\/g, "/"));
+        // Process each path argument
+        for (const path of paths) {
+            // Check for Windows drive letter (e.g., C:/)
+            if (/^[A-Za-z]:/.test(path)) {
+                isWindowsPath = true;
+                // Remove drive letter for processing
+                const withoutDrive = path.slice(2);
+                if (withoutDrive.startsWith("/")) {
+                    segments = [path.slice(0, 2)]; // Keep drive letter and reset segments
+                }
+                else {
+                    // If no leading slash, keep current segments (relative to current drive path)
+                    if (segments.length === 0 || !segments[0].match(/^[A-Za-z]:/)) {
+                        segments = [path.slice(0, 2)];
+                    }
+                }
+                // Add the rest of the path parts
+                segments.push(...withoutDrive.split("/").filter(x => x));
+                continue;
+            }
+            // If absolute path, reset segments but keep drive letter if present
+            if (path.startsWith("/")) {
+                if (isWindowsPath && segments.length > 0 && segments[0].match(/^[A-Za-z]:/)) {
+                    const drive = segments[0];
+                    segments = [drive];
+                }
+                else {
+                    segments = [];
+                }
+            }
+            // Split path into segments and process each
+            const pathParts = path.split("/").filter(x => x);
+            for (const part of pathParts) {
+                if (part === "..") {
+                    // Don't pop off the drive letter
+                    if (segments.length > (isWindowsPath ? 1 : 0)) {
+                        segments.pop();
+                    }
+                }
+                else if (part !== ".") {
+                    // Add segment if not current directory marker
+                    segments.push(part);
+                }
+            }
+        }
+        // Combine segments into final path
+        let result = segments.join("/");
+        if (!isWindowsPath) {
+            result = "/" + result;
+        }
+        return result;
+    }
+    function dirname(path) {
+        return path.split("/").slice(0, -1).join("/");
+    }
+    const requireCache = {};
+    let rootModule = createModule({
+        parentModule: undefined,
+        resolveAbsolutePath: config.rootPath + "/rootPlaceholder",
+    });
+    globalThis.require = rootModule.require;
+    function createModule(config) {
+        var _a;
+        const { parentModule, resolveAbsolutePath } = config;
+        let cached = requireCache[resolveAbsolutePath];
+        if (cached) {
+            return cached;
+        }
+        let serialized = (_a = globalThis.registeredModules) === null || _a === void 0 ? void 0 : _a[resolveAbsolutePath];
+        let newModule = {
+            id: resolveAbsolutePath,
+            filename: resolveAbsolutePath,
+            exports: {},
+            parent: parentModule,
+            children: [],
+            isPreloading: false,
+            loaded: false,
+            path: dirname(resolveAbsolutePath),
+            paths: (serialized === null || serialized === void 0 ? void 0 : serialized.paths) || [],
+            require,
+            load,
+        };
+        newModule.exports.default = newModule.exports;
+        if (parentModule) {
+            parentModule.children.push(newModule);
+        }
+        for (let [key, value] of Object.entries((serialized === null || serialized === void 0 ? void 0 : serialized.moduleFields) || {})) {
+            if (key in newModule)
+                continue;
+            newModule[key] = value;
+        }
+        resolve.paths = (request) => [];
+        requireCache[newModule.id] = newModule;
+        require.resolve = resolve;
+        require.cache = requireCache;
+        require.main = newModule;
+        require.extensions = "extension not implemented yet";
+        // Resolves file extensions
+        function innerResolve(path) {
+            var _a;
+            let candidates = [
+                path,
+                path + ".js",
+                path + ".ts",
+                path + ".tsx",
+            ];
+            for (let candidate of candidates) {
+                let registered = (_a = globalThis.registeredModules) === null || _a === void 0 ? void 0 : _a[candidate];
+                if (registered) {
+                    return registered.id;
+                }
+            }
+            return path;
+        }
+        function resolve(path) {
+            var _a;
+            path = path.replace(/\\/g, "/");
+            if (path.startsWith(".")) {
+                return innerResolve(pathResolve(newModule.path, path));
+            }
+            // We need to search all paths
+            for (let searchRoot of (serialized === null || serialized === void 0 ? void 0 : serialized.paths) || []) {
+                let candidate = innerResolve(pathResolve(searchRoot, path));
+                let registered = (_a = globalThis.registeredModules) === null || _a === void 0 ? void 0 : _a[candidate];
+                if (registered) {
+                    return registered.id;
+                }
+            }
+            // It is probably "fs" or something like that
+            return path;
+            // debugger;
+            // throw new Error(`Module ${path} not found`);
+        }
+        function require(path) {
+            if (path in builtInModuleExports) {
+                return builtInModuleExports[path];
+            }
+            let resolved = resolve(path);
+            let subModule = createModule({
+                parentModule: newModule,
+                resolveAbsolutePath: resolved,
+            });
+            subModule.load(newModule.filename);
+            return subModule.exports;
+        }
+        function load() {
+            var _a;
+            if (newModule.loaded)
+                return;
+            // NOTE: Set loaded immediately, in case we have a circular dependency
+            newModule.loaded = true;
+            if (serialized) {
+                serialized.moduleFnc(newModule.exports, require, newModule, newModule.filename, newModule.path);
+            }
+            else {
+                // If we are being imported by the root module, we need to throw an error
+                if (!((_a = config.parentModule) === null || _a === void 0 ? void 0 : _a.parent)) {
+                    debugger;
+                    throw new Error(`Could not find required module ${JSON.stringify(config.resolveAbsolutePath)}, have ${JSON.stringify(Object.keys(globalThis.registeredModules || {}))}`);
+                }
+                newModule.exports = new Proxy({}, {
+                    get(target, property) {
+                        if (property === "__esModule")
+                            return undefined;
+                        if (property === "default")
+                            return newModule.exports;
+                        console.warn(`Module ${newModule.filename} is not available (are you missing "module.allowclient = true"?). Tried to access ${String(property)}.`);
+                        return undefined;
+                    },
+                });
+            }
+        }
+        return newModule;
+    }
+}
+exports.bundleRequire = bundleRequire;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundleRequire.js","sourceRoot":"","sources":["bundleRequire.ts"],"names":[],"mappings":"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","sourcesContent":["import { SerializedModule } from \"./bundleWrapper\";\n\n// Sets globalThis.require = ..., utilizing registeredModules (from bundleWrapper.ts) when require is called\nexport interface BundleRequireConfig {\n    rootPath: string;\n}\nexport function bundleRequire(config: BundleRequireConfig) {\n    globalThis.process = globalThis.process || {\n        env: {\n            NODE_ENV: \"production\",\n        },\n        versions: {},\n        on: () => { },\n    };\n    (globalThis as any).window = (globalThis as any).window || globalThis;\n    (globalThis as any).global = (globalThis as any).global || globalThis;\n    (globalThis as any).setImmediate = (globalThis as any).setImmediate || globalThis.setTimeout;\n\n    (globalThis as any).BOOTED_EDGE_NODE = undefined;\n\n    let builtInModuleExports: { [key: string]: unknown } = {\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            Writable: function () { },\n        },\n        timers: {\n            // TODO: Add all members of timers\n            setImmediate: globalThis.setImmediate,\n        },\n        child_process: {},\n        events: class EventEmitter { },\n    };\n    // If is nodeJs\n    let allBuiltInModules = new Set<string>();\n    // Electron \n    allBuiltInModules.add(\"electron\");\n    allBuiltInModules.add(\"original-fs\");\n    allBuiltInModules.add(\"vscode\");\n    if (typeof document === \"undefined\" && typeof require !== \"undefined\") {\n        // Change the builts ins to use the actual built ins!\n        let { builtinModules } = require(\"node:module\");\n        for (let key of builtinModules) {\n            allBuiltInModules.add(key);\n        }\n    }\n    for (let key of allBuiltInModules) {\n        Object.defineProperty(builtInModuleExports, key, {\n            get() {\n                return require(key);\n            },\n        });\n    }\n\n    // Just path.resolve (but needs to be reimplemented, because we can't use imports)\n    function pathResolve(...paths: string[]): string {\n        // Start with empty path segments array\n        let segments: string[] = [];\n        let isWindowsPath = false;\n\n        paths = paths.map(x => x.replace(/\\\\/g, \"/\"));\n\n        // Process each path argument\n        for (const path of paths) {\n            // Check for Windows drive letter (e.g., C:/)\n            if (/^[A-Za-z]:/.test(path)) {\n                isWindowsPath = true;\n                // Remove drive letter for processing\n                const withoutDrive = path.slice(2);\n                if (withoutDrive.startsWith(\"/\")) {\n                    segments = [path.slice(0, 2)]; // Keep drive letter and reset segments\n                } else {\n                    // If no leading slash, keep current segments (relative to current drive path)\n                    if (segments.length === 0 || !segments[0].match(/^[A-Za-z]:/)) {\n                        segments = [path.slice(0, 2)];\n                    }\n                }\n                // Add the rest of the path parts\n                segments.push(...withoutDrive.split(\"/\").filter(x => x));\n                continue;\n            }\n\n            // If absolute path, reset segments but keep drive letter if present\n            if (path.startsWith(\"/\")) {\n                if (isWindowsPath && segments.length > 0 && segments[0].match(/^[A-Za-z]:/)) {\n                    const drive = segments[0];\n                    segments = [drive];\n                } else {\n                    segments = [];\n                }\n            }\n\n            // Split path into segments and process each\n            const pathParts = path.split(\"/\").filter(x => x);\n            for (const part of pathParts) {\n                if (part === \"..\") {\n                    // Don't pop off the drive letter\n                    if (segments.length > (isWindowsPath ? 1 : 0)) {\n                        segments.pop();\n                    }\n                } else if (part !== \".\") {\n                    // Add segment if not current directory marker\n                    segments.push(part);\n                }\n            }\n        }\n\n        // Combine segments into final path\n        let result = segments.join(\"/\");\n        if (!isWindowsPath) {\n            result = \"/\" + result;\n        }\n        return result;\n    }\n    function dirname(path: string): string {\n        return path.split(\"/\").slice(0, -1).join(\"/\");\n    }\n\n    const requireCache: { [id: string]: NodeJS.Module } = {};\n\n    let rootModule = createModule({\n        parentModule: undefined,\n        resolveAbsolutePath: config.rootPath + \"/rootPlaceholder\",\n    });\n    globalThis.require = rootModule.require as any;\n\n    function createModule(config: {\n        parentModule: NodeJS.Module | undefined;\n        resolveAbsolutePath: string;\n    }): NodeJS.Module {\n        const { parentModule, resolveAbsolutePath } = config;\n        let cached = requireCache[resolveAbsolutePath];\n        if (cached) {\n            return cached;\n        }\n        let serialized = globalThis.registeredModules?.[resolveAbsolutePath];\n\n        let newModule: NodeJS.Module = {\n            id: resolveAbsolutePath,\n            filename: resolveAbsolutePath,\n            exports: {},\n            parent: parentModule,\n            children: [],\n            isPreloading: false,\n            loaded: false,\n            path: dirname(resolveAbsolutePath),\n            paths: serialized?.paths || [],\n            require,\n            load,\n        } as any;\n        newModule.exports.default = newModule.exports;\n        if (parentModule) {\n            parentModule.children.push(newModule);\n        }\n        for (let [key, value] of Object.entries(serialized?.moduleFields || {})) {\n            if (key in newModule) continue;\n            (newModule as any)[key] = value;\n        }\n        resolve.paths = (request: string) => [];\n\n        requireCache[newModule.id] = newModule;\n        require.resolve = resolve;\n        require.cache = requireCache;\n        require.main = newModule;\n        require.extensions = \"extension not implemented yet\" as any;\n\n        // Resolves file extensions\n        function innerResolve(path: string): string {\n            let candidates = [\n                path,\n                path + \".js\",\n                path + \".ts\",\n                path + \".tsx\",\n            ];\n            for (let candidate of candidates) {\n                let registered = globalThis.registeredModules?.[candidate];\n                if (registered) {\n                    return registered.id;\n                }\n            }\n            return path;\n        }\n\n        function resolve(path: string): string {\n            path = path.replace(/\\\\/g, \"/\");\n            if (path.startsWith(\".\")) {\n                return innerResolve(pathResolve(newModule.path, path));\n            }\n            // We need to search all paths\n            for (let searchRoot of serialized?.paths || []) {\n                let candidate = innerResolve(pathResolve(searchRoot, path));\n                let registered = globalThis.registeredModules?.[candidate];\n                if (registered) {\n                    return registered.id;\n                }\n            }\n            // It is probably \"fs\" or something like that\n            return path;\n            // debugger;\n            // throw new Error(`Module ${path} not found`);\n        }\n\n        function require(path: string) {\n            if (path in builtInModuleExports) {\n                return builtInModuleExports[path as keyof typeof builtInModuleExports];\n            }\n            let resolved = resolve(path);\n            let subModule = createModule({\n                parentModule: newModule,\n                resolveAbsolutePath: resolved,\n            }) as any;\n            subModule.load(newModule.filename);\n            return subModule.exports;\n        }\n\n        function load() {\n            if (newModule.loaded) return;\n            // NOTE: Set loaded immediately, in case we have a circular dependency\n            newModule.loaded = true;\n\n            if (serialized) {\n                serialized.moduleFnc(newModule.exports, require, newModule, newModule.filename, newModule.path);\n            } else {\n                // If we are being imported by the root module, we need to throw an error\n                if (!config.parentModule?.parent) {\n                    debugger;\n                    throw new Error(`Could not find required module ${JSON.stringify(config.resolveAbsolutePath)}, have ${JSON.stringify(Object.keys(globalThis.registeredModules || {}))}`);\n                }\n                newModule.exports = new Proxy(\n                    {},\n                    {\n                        get(target, property) {\n                            if (property === \"__esModule\") return undefined;\n                            if (property === \"default\") return newModule.exports;\n\n                            console.warn(\n                                `Module ${newModule.filename} is not available (are you missing \"module.allowclient = true\"?). Tried to access ${String(property)}.`\n                            );\n                            return undefined;\n                        },\n                    }\n                );\n            }\n        }\n\n        return newModule;\n    }\n}"]}
+ /* _JS_SOURCE_HASH = "7144df5a853f20363fe51f587a13defe1e11289175c78caf38c4a00ae9846bb1"; */

package/bundler/dist/bundleWrapper.ts.cache

@@ -0,0 +1,101 @@
+"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.wrapModule = void 0;
+const caching_1 = require("socket-function/src/caching");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const getPackageJsonPath = (0, caching_1.cache)((directory) => {
+    if (!directory.includes("/") && !directory.includes("\\")) {
+        return undefined;
+    }
+    let packageJsonPath = path_1.default.resolve(directory, "package.json");
+    if (fs_1.default.existsSync(packageJsonPath)) {
+        return packageJsonPath;
+    }
+    return getPackageJsonPath(path_1.default.dirname(directory));
+});
+const getMainPath = (0, caching_1.cache)((directory) => {
+    let packageJsonPath = getPackageJsonPath(directory);
+    if (!packageJsonPath)
+        return undefined;
+    let packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf8"));
+    let dir = path_1.default.dirname(packageJsonPath);
+    let mainName = packageJson.main;
+    if (!mainName) {
+        if (fs_1.default.existsSync(path_1.default.resolve(dir, "index.js"))) {
+            mainName = "index.js";
+        }
+        else if (fs_1.default.existsSync(path_1.default.resolve(dir, "index.ts"))) {
+            mainName = "index.ts";
+        }
+        else if (fs_1.default.existsSync(path_1.default.resolve(dir, "index.tsx"))) {
+            mainName = "index.tsx";
+        }
+        else {
+            mainName = "index.js";
+        }
+    }
+    let mainPath = path_1.default.resolve(dir, mainName);
+    return mainPath;
+});
+// Wraps the module so it registers itself when the returned code is evaluated
+//  - See https://nodejs.org/api/modules.html#the-module-wrapper
+function wrapModule(module) {
+    let contents = module.moduleContents || "/* No contents */";
+    // NOTE: debugName only matters during module evaluation. After that the sourcemap should work.
+    let debugName = module.filename
+        .replace(/\\/g, "/")
+        .split("/")
+        .slice(-1)[0]
+        .replace(/\./g, "_")
+        .replace(/[^a-zA-Z_]/g, "");
+    let wrapped = `(function ${debugName}(exports, require, module, __filename, __dirname) { ${contents}
+    })`;
+    let moduleFields = {};
+    for (let [key, value] of Object.entries(module)) {
+        if (typeof value === "function")
+            continue;
+        if (typeof value === "boolean") {
+            moduleFields[key] = value;
+        }
+        else if (typeof value === "string" && value.length < 150) {
+            moduleFields[key] = value;
+        }
+        else if (typeof value === "number") {
+            moduleFields[key] = value;
+        }
+    }
+    let isModuleMain;
+    let dirname = path_1.default.dirname(module.filename);
+    let packageJsonPath = getPackageJsonPath(dirname);
+    if (packageJsonPath) {
+        let mainPath = getMainPath(dirname);
+        if ((mainPath === null || mainPath === void 0 ? void 0 : mainPath.replaceAll("\\", "/")) === module.filename.replaceAll("\\", "/")) {
+            // Then we are the main of the module
+            isModuleMain = path_1.default.dirname(packageJsonPath).replaceAll("\\", "/");
+        }
+    }
+    // NOTE: We can't have new lines, or they break source maps
+    let objWrapped = `{`
+        + ` id: ${JSON.stringify(module.id.replaceAll("\\", "/"))},`
+        + ` filename: ${JSON.stringify(module.filename.replaceAll("\\", "/"))},`
+        + ` isModuleMain: ${JSON.stringify(isModuleMain)},`
+        + ` paths: ${JSON.stringify(module.paths.map(p => p.replaceAll("\\", "/")))},`
+        + ` moduleFields: ${JSON.stringify(moduleFields)},`
+        + ` moduleFnc: ${wrapped}`
+        + ` }`;
+    function initModule(serialized) {
+        globalThis.registeredModules = globalThis.registeredModules || {};
+        globalThis.registeredModules[serialized.id] = serialized;
+        if (serialized.isModuleMain) {
+            globalThis.registeredModules[serialized.isModuleMain] = serialized;
+        }
+    }
+    return `;(${initModule.toString().replaceAll("\n", " ")})(${objWrapped});`;
+}
+exports.wrapModule = wrapModule;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundleWrapper.js","sourceRoot":"","sources":["bundleWrapper.ts"],"names":[],"mappings":"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","sourcesContent":["import { cache } from \"socket-function/src/caching\";\nimport path from \"path\";\nimport fs from \"fs\";\n\nconst getPackageJsonPath = cache((directory: string): string | undefined => {\n    if (!directory.includes(\"/\") && !directory.includes(\"\\\\\")) {\n        return undefined;\n    }\n    let packageJsonPath = path.resolve(directory, \"package.json\");\n    if (fs.existsSync(packageJsonPath)) {\n        return packageJsonPath;\n    }\n    return getPackageJsonPath(path.dirname(directory));\n});\nconst getMainPath = cache((directory: string): string | undefined => {\n    let packageJsonPath = getPackageJsonPath(directory);\n    if (!packageJsonPath) return undefined;\n    let packageJson = JSON.parse(fs.readFileSync(packageJsonPath, \"utf8\"));\n    let dir = path.dirname(packageJsonPath);\n    let mainName = packageJson.main;\n    if (!mainName) {\n        if (fs.existsSync(path.resolve(dir, \"index.js\"))) {\n            mainName = \"index.js\";\n        } else if (fs.existsSync(path.resolve(dir, \"index.ts\"))) {\n            mainName = \"index.ts\";\n        } else if (fs.existsSync(path.resolve(dir, \"index.tsx\"))) {\n            mainName = \"index.tsx\";\n        } else {\n            mainName = \"index.js\";\n        }\n    }\n    let mainPath = path.resolve(dir, mainName);\n    return mainPath;\n});\n\n\n// Wraps the module so it registers itself when the returned code is evaluated\n//  - See https://nodejs.org/api/modules.html#the-module-wrapper\nexport function wrapModule(module: NodeJS.Module): string {\n    let contents = (module as any).moduleContents || \"/* No contents */\";\n\n    // NOTE: debugName only matters during module evaluation. After that the sourcemap should work.\n    let debugName = module.filename\n        .replace(/\\\\/g, \"/\")\n        .split(\"/\")\n        .slice(-1)[0]\n        .replace(/\\./g, \"_\")\n        .replace(/[^a-zA-Z_]/g, \"\");\n\n    let wrapped = `(function ${debugName}(exports, require, module, __filename, __dirname) { ${contents}\n    })`;\n\n    let moduleFields: { [flag: string]: unknown; } = {};\n    for (let [key, value] of Object.entries(module)) {\n        if (typeof value === \"function\") continue;\n        if (typeof value === \"boolean\") {\n            moduleFields[key] = value;\n        } else if (typeof value === \"string\" && value.length < 150) {\n            moduleFields[key] = value;\n        } else if (typeof value === \"number\") {\n            moduleFields[key] = value;\n        }\n    }\n\n    let isModuleMain: string | undefined;\n    let dirname = path.dirname(module.filename);\n    let packageJsonPath = getPackageJsonPath(dirname);\n    if (packageJsonPath) {\n        let mainPath = getMainPath(dirname);\n        if (mainPath?.replaceAll(\"\\\\\", \"/\") === module.filename.replaceAll(\"\\\\\", \"/\")) {\n            // Then we are the main of the module\n            isModuleMain = path.dirname(packageJsonPath).replaceAll(\"\\\\\", \"/\");\n        }\n    }\n\n    // NOTE: We can't have new lines, or they break source maps\n    let objWrapped = `{`\n        + ` id: ${JSON.stringify(module.id.replaceAll(\"\\\\\", \"/\"))},`\n        + ` filename: ${JSON.stringify(module.filename.replaceAll(\"\\\\\", \"/\"))},`\n        + ` isModuleMain: ${JSON.stringify(isModuleMain)},`\n        + ` paths: ${JSON.stringify(module.paths.map(p => p.replaceAll(\"\\\\\", \"/\")))},`\n        + ` moduleFields: ${JSON.stringify(moduleFields)},`\n        + ` moduleFnc: ${wrapped}`\n        + ` }`;\n\n    function initModule(serialized: SerializedModule) {\n        globalThis.registeredModules = globalThis.registeredModules || {};\n        globalThis.registeredModules[serialized.id] = serialized;\n        if (serialized.isModuleMain) {\n            globalThis.registeredModules[serialized.isModuleMain] = serialized;\n        }\n    }\n\n    return `;(${initModule.toString().replaceAll(\"\\n\", \" \")})(${objWrapped});`;\n}\n\ndeclare global {\n    var registeredModules: { [id: string]: SerializedModule; } | undefined;\n}\n\nexport interface SerializedModule {\n    id: string;\n    filename: string;\n\n    // The main main we represent. Ex, \"/ai3/node_modules/typesafecss\"\n    isModuleMain?: string;\n\n    // Paths which the require function searches for non-relative imports\n    paths: string[];\n\n    // Fields to be set on the module, when it is created\n    moduleFields: { [flag: string]: unknown; };\n\n    moduleFnc: (exports: any, require: any, module: any, __filename: string, __dirname: string) => unknown;\n}"]}
+ /* _JS_SOURCE_HASH = "b3ee411148a95aa3c28256d9bbad02bf05f4c4c841569662d2cbc9515ffce7f1"; */

package/bundler/dist/bundler.ts.cache

@@ -0,0 +1,66 @@
+"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.extractBundleHash = exports.bundle = void 0;
+const js_sha256_1 = require("js-sha256");
+const bundleRequire_1 = require("./bundleRequire");
+const bundleWrapper_1 = require("./bundleWrapper");
+const sourceMaps_1 = require("./sourceMaps");
+const fs_1 = __importDefault(require("fs"));
+async function bundle(config) {
+    const { modules, rootPath, entryPoints } = config;
+    // NOTE: We COULD use an "index source map", which contains other sourcemaps
+    //  and gives offsets for them. However... tooling support will is better
+    //  for regular sourcemaps, and it's more flexible.
+    let inProgressSourceMap = {
+        sources: [],
+        mappings: [],
+    };
+    let code = "";
+    let curLineCount = 0;
+    for (let module of modules) {
+        if (!module)
+            continue;
+        let newCode = (0, bundleWrapper_1.wrapModule)(module);
+        let { sourceMap, code: newCode2 } = (0, sourceMaps_1.removeSourceMap)(newCode);
+        newCode = newCode2;
+        if (sourceMap) {
+            let inProgress = (0, sourceMaps_1.getInProgressSourceMap)(sourceMap);
+            for (let mapping of inProgress.mappings) {
+                mapping.generatedLine += curLineCount;
+            }
+            (0, sourceMaps_1.addToInProgressSourceMap)(inProgressSourceMap, inProgress);
+        }
+        code += newCode + "\n";
+        curLineCount += (newCode.match(/\n/g) || []).length + 1;
+    }
+    code += "\n/* Inlined buffer implementation: */\n";
+    code += `\n;\n${fs_1.default.readFileSync(__dirname + "/buffer.js").toString()}\n;\n`;
+    code += `\n;globalThis.__BUNDLE_HASH__ = ${JSON.stringify((0, js_sha256_1.sha256)(code))};`;
+    let bundleConfig = {
+        rootPath,
+    };
+    code += `;(${bundleRequire_1.bundleRequire.toString()})(${JSON.stringify(bundleConfig)});`;
+    // Delay the initial requires, so our extension can boot and we can debug startup errors
+    code += "\n;setTimeout(() => {";
+    for (let entryPoint of entryPoints) {
+        code += `\n;globalThis.require(${JSON.stringify(entryPoint)});`;
+    }
+    code += "\n;});";
+    code += "\n" + (0, sourceMaps_1.encodeSourceMapLineComment)((0, sourceMaps_1.finalizeInProgressSourceMap)(inProgressSourceMap));
+    return {
+        bundle: code,
+    };
+}
+exports.bundle = bundle;
+function extractBundleHash(code) {
+    let match = code.match(/;globalThis.__BUNDLE_HASH__ = "([^"]+)";/);
+    if (!match)
+        return undefined;
+    return match[1];
+}
+exports.extractBundleHash = extractBundleHash;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImJ1bmRsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEseUNBQW1DO0FBQ25DLG1EQUFxRTtBQUNyRSxtREFBNkM7QUFDN0MsNkNBQStLO0FBQy9LLDRDQUFvQjtBQUViLEtBQUssVUFBVSxNQUFNLENBQUMsTUFJNUI7SUFHRyxNQUFNLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBRSxXQUFXLEVBQUUsR0FBRyxNQUFNLENBQUM7SUFFbEQsNEVBQTRFO0lBQzVFLHlFQUF5RTtJQUN6RSxtREFBbUQ7SUFFbkQsSUFBSSxtQkFBbUIsR0FBd0I7UUFDM0MsT0FBTyxFQUFFLEVBQUU7UUFDWCxRQUFRLEVBQUUsRUFBRTtLQUNmLENBQUM7SUFFRixJQUFJLElBQUksR0FBRyxFQUFFLENBQUM7SUFDZCxJQUFJLFlBQVksR0FBRyxDQUFDLENBQUM7SUFDckIsS0FBSyxJQUFJLE1BQU0sSUFBSSxPQUFPLEVBQUUsQ0FBQztRQUN6QixJQUFJLENBQUMsTUFBTTtZQUFFLFNBQVM7UUFFdEIsSUFBSSxPQUFPLEdBQUcsSUFBQSwwQkFBVSxFQUFDLE1BQU0sQ0FBQyxDQUFDO1FBRWpDLElBQUksRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxHQUFHLElBQUEsNEJBQWUsRUFBQyxPQUFPLENBQUMsQ0FBQztRQUM3RCxPQUFPLEdBQUcsUUFBUSxDQUFDO1FBQ25CLElBQUksU0FBUyxFQUFFLENBQUM7WUFDWixJQUFJLFVBQVUsR0FBRyxJQUFBLG1DQUFzQixFQUFDLFNBQVMsQ0FBQyxDQUFDO1lBQ25ELEtBQUssSUFBSSxPQUFPLElBQUksVUFBVSxDQUFDLFFBQVEsRUFBRSxDQUFDO2dCQUN0QyxPQUFPLENBQUMsYUFBYSxJQUFJLFlBQVksQ0FBQztZQUMxQyxDQUFDO1lBQ0QsSUFBQSxxQ0FBd0IsRUFBQyxtQkFBbUIsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUM5RCxDQUFDO1FBRUQsSUFBSSxJQUFJLE9BQU8sR0FBRyxJQUFJLENBQUM7UUFDdkIsWUFBWSxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDO0lBQzVELENBQUM7SUFDRCxJQUFJLElBQUksMENBQTBDLENBQUM7SUFDbkQsSUFBSSxJQUFJLFFBQVEsWUFBRSxDQUFDLFlBQVksQ0FBQyxTQUFTLEdBQUcsWUFBWSxDQUFDLENBQUMsUUFBUSxFQUFFLE9BQU8sQ0FBQztJQUM1RSxJQUFJLElBQUksbUNBQW1DLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBQSxrQkFBTSxFQUFDLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQztJQUMzRSxJQUFJLFlBQVksR0FBd0I7UUFDcEMsUUFBUTtLQUNYLENBQUM7SUFDRixJQUFJLElBQUksS0FBSyw2QkFBYSxDQUFDLFFBQVEsRUFBRSxLQUFLLElBQUksQ0FBQyxTQUFTLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQztJQUMzRSx3RkFBd0Y7SUFDeEYsSUFBSSxJQUFJLHVCQUF1QixDQUFDO0lBQ2hDLEtBQUssSUFBSSxVQUFVLElBQUksV0FBVyxFQUFFLENBQUM7UUFDakMsSUFBSSxJQUFJLHlCQUF5QixJQUFJLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUM7SUFDcEUsQ0FBQztJQUNELElBQUksSUFBSSxRQUFRLENBQUM7SUFDakIsSUFBSSxJQUFJLElBQUksR0FBRyxJQUFBLHVDQUEwQixFQUFDLElBQUEsd0NBQTJCLEVBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFDO0lBQzVGLE9BQU87UUFDSCxNQUFNLEVBQUUsSUFBSTtLQUNmLENBQUM7QUFDTixDQUFDO0FBdkRELHdCQXVEQztBQU1ELFNBQWdCLGlCQUFpQixDQUFDLElBQVk7SUFDMUMsSUFBSSxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQywwQ0FBMEMsQ0FBQyxDQUFDO0lBQ25FLElBQUksQ0FBQyxLQUFLO1FBQUUsT0FBTyxTQUFTLENBQUM7SUFDN0IsT0FBTyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDcEIsQ0FBQztBQUpELDhDQUlDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgc2hhMjU2IH0gZnJvbSBcImpzLXNoYTI1NlwiO1xuaW1wb3J0IHsgYnVuZGxlUmVxdWlyZSwgQnVuZGxlUmVxdWlyZUNvbmZpZyB9IGZyb20gXCIuL2J1bmRsZVJlcXVpcmVcIjtcbmltcG9ydCB7IHdyYXBNb2R1bGUgfSBmcm9tIFwiLi9idW5kbGVXcmFwcGVyXCI7XG5pbXBvcnQgeyBhZGRUb0luUHJvZ3Jlc3NTb3VyY2VNYXAsIGVuY29kZVNvdXJjZU1hcExpbmVDb21tZW50LCBmaW5hbGl6ZUluUHJvZ3Jlc3NTb3VyY2VNYXAsIGdldEluUHJvZ3Jlc3NTb3VyY2VNYXAsIEluUHJvZ3Jlc3NTb3VyY2VNYXAsIHJlbW92ZVNvdXJjZU1hcCB9IGZyb20gXCIuL3NvdXJjZU1hcHNcIjtcbmltcG9ydCBmcyBmcm9tIFwiZnNcIjtcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGJ1bmRsZShjb25maWc6IHtcbiAgICBtb2R1bGVzOiAodHlwZW9mIHJlcXVpcmUuY2FjaGVbXCJcIl0pW107XG4gICAgcm9vdFBhdGg6IHN0cmluZztcbiAgICBlbnRyeVBvaW50czogc3RyaW5nW107XG59KTogUHJvbWlzZTx7XG4gICAgYnVuZGxlOiBzdHJpbmc7XG59PiB7XG4gICAgY29uc3QgeyBtb2R1bGVzLCByb290UGF0aCwgZW50cnlQb2ludHMgfSA9IGNvbmZpZztcblxuICAgIC8vIE5PVEU6IFdlIENPVUxEIHVzZSBhbiBcImluZGV4IHNvdXJjZSBtYXBcIiwgd2hpY2ggY29udGFpbnMgb3RoZXIgc291cmNlbWFwc1xuICAgIC8vICBhbmQgZ2l2ZXMgb2Zmc2V0cyBmb3IgdGhlbS4gSG93ZXZlci4uLiB0b29saW5nIHN1cHBvcnQgd2lsbCBpcyBiZXR0ZXJcbiAgICAvLyAgZm9yIHJlZ3VsYXIgc291cmNlbWFwcywgYW5kIGl0J3MgbW9yZSBmbGV4aWJsZS5cblxuICAgIGxldCBpblByb2dyZXNzU291cmNlTWFwOiBJblByb2dyZXNzU291cmNlTWFwID0ge1xuICAgICAgICBzb3VyY2VzOiBbXSxcbiAgICAgICAgbWFwcGluZ3M6IFtdLFxuICAgIH07XG5cbiAgICBsZXQgY29kZSA9IFwiXCI7XG4gICAgbGV0IGN1ckxpbmVDb3VudCA9IDA7XG4gICAgZm9yIChsZXQgbW9kdWxlIG9mIG1vZHVsZXMpIHtcbiAgICAgICAgaWYgKCFtb2R1bGUpIGNvbnRpbnVlO1xuXG4gICAgICAgIGxldCBuZXdDb2RlID0gd3JhcE1vZHVsZShtb2R1bGUpO1xuXG4gICAgICAgIGxldCB7IHNvdXJjZU1hcCwgY29kZTogbmV3Q29kZTIgfSA9IHJlbW92ZVNvdXJjZU1hcChuZXdDb2RlKTtcbiAgICAgICAgbmV3Q29kZSA9IG5ld0NvZGUyO1xuICAgICAgICBpZiAoc291cmNlTWFwKSB7XG4gICAgICAgICAgICBsZXQgaW5Qcm9ncmVzcyA9IGdldEluUHJvZ3Jlc3NTb3VyY2VNYXAoc291cmNlTWFwKTtcbiAgICAgICAgICAgIGZvciAobGV0IG1hcHBpbmcgb2YgaW5Qcm9ncmVzcy5tYXBwaW5ncykge1xuICAgICAgICAgICAgICAgIG1hcHBpbmcuZ2VuZXJhdGVkTGluZSArPSBjdXJMaW5lQ291bnQ7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICBhZGRUb0luUHJvZ3Jlc3NTb3VyY2VNYXAoaW5Qcm9ncmVzc1NvdXJjZU1hcCwgaW5Qcm9ncmVzcyk7XG4gICAgICAgIH1cblxuICAgICAgICBjb2RlICs9IG5ld0NvZGUgKyBcIlxcblwiO1xuICAgICAgICBjdXJMaW5lQ291bnQgKz0gKG5ld0NvZGUubWF0Y2goL1xcbi9nKSB8fCBbXSkubGVuZ3RoICsgMTtcbiAgICB9XG4gICAgY29kZSArPSBcIlxcbi8qIElubGluZWQgYnVmZmVyIGltcGxlbWVudGF0aW9uOiAqL1xcblwiO1xuICAgIGNvZGUgKz0gYFxcbjtcXG4ke2ZzLnJlYWRGaWxlU3luYyhfX2Rpcm5hbWUgKyBcIi9idWZmZXIuanNcIikudG9TdHJpbmcoKX1cXG47XFxuYDtcbiAgICBjb2RlICs9IGBcXG47Z2xvYmFsVGhpcy5fX0JVTkRMRV9IQVNIX18gPSAke0pTT04uc3RyaW5naWZ5KHNoYTI1Nihjb2RlKSl9O2A7XG4gICAgbGV0IGJ1bmRsZUNvbmZpZzogQnVuZGxlUmVxdWlyZUNvbmZpZyA9IHtcbiAgICAgICAgcm9vdFBhdGgsXG4gICAgfTtcbiAgICBjb2RlICs9IGA7KCR7YnVuZGxlUmVxdWlyZS50b1N0cmluZygpfSkoJHtKU09OLnN0cmluZ2lmeShidW5kbGVDb25maWcpfSk7YDtcbiAgICAvLyBEZWxheSB0aGUgaW5pdGlhbCByZXF1aXJlcywgc28gb3VyIGV4dGVuc2lvbiBjYW4gYm9vdCBhbmQgd2UgY2FuIGRlYnVnIHN0YXJ0dXAgZXJyb3JzXG4gICAgY29kZSArPSBcIlxcbjtzZXRUaW1lb3V0KCgpID0+IHtcIjtcbiAgICBmb3IgKGxldCBlbnRyeVBvaW50IG9mIGVudHJ5UG9pbnRzKSB7XG4gICAgICAgIGNvZGUgKz0gYFxcbjtnbG9iYWxUaGlzLnJlcXVpcmUoJHtKU09OLnN0cmluZ2lmeShlbnRyeVBvaW50KX0pO2A7XG4gICAgfVxuICAgIGNvZGUgKz0gXCJcXG47fSk7XCI7XG4gICAgY29kZSArPSBcIlxcblwiICsgZW5jb2RlU291cmNlTWFwTGluZUNvbW1lbnQoZmluYWxpemVJblByb2dyZXNzU291cmNlTWFwKGluUHJvZ3Jlc3NTb3VyY2VNYXApKTtcbiAgICByZXR1cm4ge1xuICAgICAgICBidW5kbGU6IGNvZGUsXG4gICAgfTtcbn1cblxuZGVjbGFyZSBnbG9iYWwge1xuICAgIHZhciBfX0JVTkRMRV9IQVNIX186IHN0cmluZyB8IHVuZGVmaW5lZDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGV4dHJhY3RCdW5kbGVIYXNoKGNvZGU6IHN0cmluZykge1xuICAgIGxldCBtYXRjaCA9IGNvZGUubWF0Y2goLztnbG9iYWxUaGlzLl9fQlVORExFX0hBU0hfXyA9IFwiKFteXCJdKylcIjsvKTtcbiAgICBpZiAoIW1hdGNoKSByZXR1cm4gdW5kZWZpbmVkO1xuICAgIHJldHVybiBtYXRjaFsxXTtcbn0iXX0=
+ /* _JS_SOURCE_HASH = "195272562986c65a1aea7f7f87d4635e04cfe02662426c8cdca6558ed654ea0e"; */