@nodetool-ai/sandbox-runtime 0.0.0-stage → 0.8.9-beta.2

package/vendor/quickjs/createVirtualFileSystem.js

@@ -0,0 +1,191 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as memfsPkg from 'memfs';
+import assertModule from './modules/assert.js';
+import bufferModule from './modules/buffer.js';
+import eventModule from './modules/events.js';
+import fsModule from './modules/fs.js';
+import fsPromisesModule from './modules/fs_promises.js';
+import moduleModule from './modules/module.js';
+import compatibilityHeaders from './modules/nodeCompatibility/headers.js';
+import compatibilityRequest from './modules/nodeCompatibility/request.js';
+import compatibilityResponse from './modules/nodeCompatibility/response.js';
+import pathModule from './modules/path.js';
+import processModule from './modules/process.js';
+import punycodeModule from './modules/punycode.js';
+import queryStringModule from './modules/querystring.js';
+import stringDecoderModule from './modules/string_decoder.js';
+import timersModule from './modules/timers.js';
+import timersPromisesModule from './modules/timers_promises.js';
+import urlModule from './modules/url.js';
+import utilModule from './modules/util.js';
+const getCurrentDirname = () => {
+    if (typeof __dirname !== 'undefined') {
+        return __dirname;
+    }
+    const stack = new Error().stack ?? '';
+    const stackUrl = stack.match(/(file:\/\/[^\s)]+createVirtualFileSystem\.[cm]?js)/)?.[1];
+    if (stackUrl) {
+        return fileURLToPath(new URL('.', stackUrl));
+    }
+    return process.cwd();
+};
+const memfsCompat = memfsPkg;
+const getMemfs = () => (memfsCompat.memfs ?? memfsCompat.default?.memfs ?? memfsCompat.default);
+/**
+ * Create the virtual file system for the sandbox
+ * Creates a node_modules folder with packages and ensures the src folder
+ *
+ * @param runtimeOptions
+ * @returns filesystem fs and volume vol
+ */
+export const createVirtualFileSystem = (runtimeOptions = {}) => {
+    const customFileSystem = runtimeOptions.mountFs;
+    // setup node_modules folder
+    const virtualFS = {
+        '/': {
+            ...customFileSystem,
+            src: {
+                // biome-ignore lint/complexity/useLiteralKeys: ok here
+                ...(customFileSystem?.['src'] ? customFileSystem?.['src'] : {}),
+            },
+            node_modules: {
+                ...runtimeOptions?.nodeModules,
+                '@node_compatibility': {
+                    headers: compatibilityHeaders,
+                    request: compatibilityRequest,
+                    response: compatibilityResponse,
+                },
+                assert: {
+                    'index.js': assertModule,
+                },
+                async_hooks: {
+                    'index.js': "throw new Error('module async_hooks not implemented')",
+                },
+                buffer: {
+                    'index.js': bufferModule,
+                },
+                child_process: {
+                    'index.js': "throw new Error('module child_process not implemented')",
+                },
+                cluster: {
+                    'index.js': "throw new Error('module cluster not implemented')",
+                },
+                console: {
+                    'index.js': "throw new Error('module console not implemented')",
+                },
+                crypto: {
+                    'index.js': "throw new Error('module crypto not implemented')",
+                },
+                dgram: {
+                    'index.js': "throw new Error('module dgram not implemented')",
+                },
+                dns: {
+                    'index.js': "throw new Error('module dns not implemented')",
+                },
+                domain: {
+                    'index.js': "throw new Error('module domain not implemented')",
+                },
+                events: {
+                    'index.js': eventModule,
+                },
+                fs: {
+                    'index.js': fsModule,
+                    promises: {
+                        'index.js': fsPromisesModule,
+                    },
+                },
+                http: {
+                    'index.js': "throw new Error('module http not implemented')",
+                },
+                http2: {
+                    'index.js': "throw new Error('module http2 not implemented')",
+                },
+                https: {
+                    'index.js': "throw new Error('module https not implemented')",
+                },
+                inspector: {
+                    'index.js': "throw new Error('module inspector not implemented')",
+                },
+                module: {
+                    'index.js': moduleModule,
+                },
+                net: {
+                    'index.js': "throw new Error('module net not implemented')",
+                },
+                os: {
+                    'index.js': "throw new Error('module os not implemented')",
+                },
+                path: {
+                    'index.js': pathModule,
+                },
+                perf_hooks: {
+                    'index.js': "throw new Error('module perf_hooks not implemented')",
+                },
+                process: {
+                    'index.js': processModule,
+                },
+                punycode: {
+                    'index.js': punycodeModule,
+                },
+                querystring: {
+                    'index.js': queryStringModule,
+                },
+                readline: {
+                    'index.js': "throw new Error('module readline not implemented')",
+                },
+                repl: {
+                    'index.js': "throw new Error('module repl not implemented')",
+                },
+                stream: {
+                    'index.js': "throw new Error('module stream not implemented')",
+                },
+                string_decoder: {
+                    'index.js': stringDecoderModule,
+                },
+                timers: {
+                    'index.js': timersModule,
+                    promises: {
+                        'index.js': timersPromisesModule,
+                    },
+                },
+                tls: {
+                    'index.js': "throw new Error('module tls not implemented')",
+                },
+                trace_events: {
+                    'index.js': "throw new Error('module trace_events not implemented')",
+                },
+                tty: {
+                    'index.js': "throw new Error('module tty not implemented')",
+                },
+                url: {
+                    'index.js': urlModule,
+                },
+                util: {
+                    'index.js': utilModule,
+                },
+                v8: {
+                    'index.js': "throw new Error('module v8 not implemented')",
+                },
+                vm: {
+                    'index.js': "throw new Error('module vm not implemented')",
+                },
+                worker_threads: {
+                    'index.js': "throw new Error('module worker_threads not implemented')",
+                },
+                zlib: {
+                    'index.js': "throw new Error('module zlib not implemented')",
+                },
+            },
+        },
+    };
+    if (runtimeOptions.enableTestUtils) {
+        const currentDirname = getCurrentDirname();
+        virtualFS['/'].node_modules.test = {
+            'index.js': readFileSync(join(currentDirname, 'modules', 'build', 'test-lib.js')),
+        };
+    }
+    const { vol, fs } = getMemfs()(virtualFS, '/');
+    return { vol, fs };
+};

package/vendor/quickjs/index.d.ts

@@ -0,0 +1,77 @@
+/**
+ * QuickJS sandbox for JavaScript/Typescript applications
+ *
+ * This TypeScript package allows you to safely execute JavaScript code within a WebAssembly sandbox using the QuickJS engine.
+ * Perfect for isolating and running untrusted code securely, it leverages the lightweight and fast QuickJS engine compiled to WebAssembly, providing a robust environment for code execution.
+ *
+ * @author Sebastian Wessel
+ * @copyright Sebastian Wessel
+ * @license MIT
+ * @link https://sebastianwessel.github.io/quickjs/
+ * @link https://github.com/sebastianwessel/quickjs
+ *
+ * @example
+ * ```typescript
+ * import { type SandboxOptions, loadQuickJs } from '@sebastianwessel/quickjs'
+ *
+ * // General setup like loading and init of the QuickJS wasm
+ * // It is a ressource intensive job and should be done only once if possible
+ * const { runSandboxed } = await loadQuickJs(variant)
+ *
+ * const options: SandboxOptions = {
+ *   allowFetch: true, // inject fetch and allow the code to fetch data
+ *   allowFs: true, // mount a virtual file system and provide node:fs module
+ *   env: {
+ *     MY_ENV_VAR: 'env var value',
+ *   },
+ * }
+ *
+ * const code = `
+ * import { join } from 'path'
+ *
+ * const fn = async ()=>{
+ *   console.log(join('src','dist')) // logs "src/dist" on host system
+ *
+ *   console.log(env.MY_ENV_VAR) // logs "env var value" on host system
+ *
+ *   const url = new URL('https://example.com')
+ *
+ *   const f = await fetch(url)
+ *
+ *   return f.text()
+ * }
+ *
+ * export default await fn()
+ * `
+ *
+ * const result = await runSandboxed(async ({ evalCode }) => evalCode(code), options)
+ *
+ * console.log(result) // { ok: true, data: '<!doctype html>\n<html>\n[....]</html>\n' }
+ * ```
+ *
+ *
+ * @module
+ */
+export * from './adapter/fetch.js';
+export * from './createVirtualFileSystem.js';
+export * from './loadAsyncQuickJs.js';
+export * from './loadQuickJs.js';
+export * from './sandbox/asyncVersion/getAsyncModuleLoader.js';
+export * from './sandbox/asyncVersion/modulePathNormalizerAsync.js';
+export * from './sandbox/expose/expose.js';
+export * from './sandbox/handleToNative/handleToNative.js';
+export * from './sandbox/handleToNative/serializer/index.js';
+export * from './sandbox/syncVersion/getModuleLoader.js';
+export * from './sandbox/syncVersion/modulePathNormalizer.js';
+export * from './types/CodeFunctionInput.js';
+export * from './types/ErrorResponse.js';
+export * from './types/LoadQuickJsOptions.js';
+export * from './types/OkResponse.js';
+export * from './types/OkResponseCheck.js';
+export * from './types/Prettify.js';
+export * from './types/RuntimeOptions.js';
+export * from './types/SandboxEvalCode.js';
+export * from './types/SandboxFunction.js';
+export * from './types/SandboxOptions.js';
+export * from './types/SandboxValidateCode.js';
+export * from './types/Serializer.js';

package/vendor/quickjs/index.js

@@ -0,0 +1,77 @@
+/**
+ * QuickJS sandbox for JavaScript/Typescript applications
+ *
+ * This TypeScript package allows you to safely execute JavaScript code within a WebAssembly sandbox using the QuickJS engine.
+ * Perfect for isolating and running untrusted code securely, it leverages the lightweight and fast QuickJS engine compiled to WebAssembly, providing a robust environment for code execution.
+ *
+ * @author Sebastian Wessel
+ * @copyright Sebastian Wessel
+ * @license MIT
+ * @link https://sebastianwessel.github.io/quickjs/
+ * @link https://github.com/sebastianwessel/quickjs
+ *
+ * @example
+ * ```typescript
+ * import { type SandboxOptions, loadQuickJs } from '@sebastianwessel/quickjs'
+ *
+ * // General setup like loading and init of the QuickJS wasm
+ * // It is a ressource intensive job and should be done only once if possible
+ * const { runSandboxed } = await loadQuickJs(variant)
+ *
+ * const options: SandboxOptions = {
+ *   allowFetch: true, // inject fetch and allow the code to fetch data
+ *   allowFs: true, // mount a virtual file system and provide node:fs module
+ *   env: {
+ *     MY_ENV_VAR: 'env var value',
+ *   },
+ * }
+ *
+ * const code = `
+ * import { join } from 'path'
+ *
+ * const fn = async ()=>{
+ *   console.log(join('src','dist')) // logs "src/dist" on host system
+ *
+ *   console.log(env.MY_ENV_VAR) // logs "env var value" on host system
+ *
+ *   const url = new URL('https://example.com')
+ *
+ *   const f = await fetch(url)
+ *
+ *   return f.text()
+ * }
+ *
+ * export default await fn()
+ * `
+ *
+ * const result = await runSandboxed(async ({ evalCode }) => evalCode(code), options)
+ *
+ * console.log(result) // { ok: true, data: '<!doctype html>\n<html>\n[....]</html>\n' }
+ * ```
+ *
+ *
+ * @module
+ */
+export * from './adapter/fetch.js';
+export * from './createVirtualFileSystem.js';
+export * from './loadAsyncQuickJs.js';
+export * from './loadQuickJs.js';
+export * from './sandbox/asyncVersion/getAsyncModuleLoader.js';
+export * from './sandbox/asyncVersion/modulePathNormalizerAsync.js';
+export * from './sandbox/expose/expose.js';
+export * from './sandbox/handleToNative/handleToNative.js';
+export * from './sandbox/handleToNative/serializer/index.js';
+export * from './sandbox/syncVersion/getModuleLoader.js';
+export * from './sandbox/syncVersion/modulePathNormalizer.js';
+export * from './types/CodeFunctionInput.js';
+export * from './types/ErrorResponse.js';
+export * from './types/LoadQuickJsOptions.js';
+export * from './types/OkResponse.js';
+export * from './types/OkResponseCheck.js';
+export * from './types/Prettify.js';
+export * from './types/RuntimeOptions.js';
+export * from './types/SandboxEvalCode.js';
+export * from './types/SandboxFunction.js';
+export * from './types/SandboxOptions.js';
+export * from './types/SandboxValidateCode.js';
+export * from './types/Serializer.js';

package/vendor/quickjs/loadAsyncQuickJs.d.ts

@@ -0,0 +1,12 @@
+import type { LoadAsyncQuickJsOptions } from './types/LoadQuickJsOptions.js';
+import type { AsyncSandboxFunction } from './types/SandboxFunction.js';
+import type { SandboxAsyncOptions } from './types/SandboxOptions.js';
+/**
+ * Loads the QuickJS async module and returns a sandbox execution function.
+ * @param variant - Options for loading the QuickJS module. Defaults to '@jitl/quickjs-ng-wasmfile-release-asyncify'.
+ * @returns An object containing the runSandboxed function and the loaded module.
+ */
+export declare const loadAsyncQuickJs: (variant: LoadAsyncQuickJsOptions) => Promise<{
+    runSandboxed: <T>(sandboxedFunction: AsyncSandboxFunction<T>, sandboxOptions?: SandboxAsyncOptions) => Promise<T>;
+    module: import("quickjs-emscripten-core").QuickJSAsyncWASMModule;
+}>;

package/vendor/quickjs/loadAsyncQuickJs.js

@@ -0,0 +1,66 @@
+import { newQuickJSAsyncWASMModuleFromVariant, Scope, shouldInterruptAfterDeadline } from 'quickjs-emscripten-core';
+import { executeAsyncSandboxFunction } from './sandbox/asyncVersion/executeAsyncSandboxFunction.js';
+import { getAsyncModuleLoader } from './sandbox/asyncVersion/getAsyncModuleLoader.js';
+import { modulePathNormalizerAsync } from './sandbox/asyncVersion/modulePathNormalizerAsync.js';
+import { prepareAsyncNodeCompatibility } from './sandbox/asyncVersion/prepareAsyncNodeCompatibility.js';
+import { prepareAsyncSandbox } from './sandbox/asyncVersion/prepareAsyncSandbox.js';
+import { setupFileSystem } from './sandbox/setupFileSystem.js';
+/**
+ * Loads the QuickJS async module and returns a sandbox execution function.
+ * @param variant - Options for loading the QuickJS module. Defaults to '@jitl/quickjs-ng-wasmfile-release-asyncify'.
+ * @returns An object containing the runSandboxed function and the loaded module.
+ */
+export const loadAsyncQuickJs = async (variant) => {
+    const module = await newQuickJSAsyncWASMModuleFromVariant(variant);
+    /**
+     * Provides a new sandbox and executes the given function.
+     * When the function has been finished, the sandbox gets disposed and can longer be used.
+     *
+     * @param sandboxedFunction
+     * @param sandboxOptions
+     * @returns
+     */
+    const runSandboxed = async (sandboxedFunction, sandboxOptions = {}) => {
+        const scope = new Scope();
+        let ctx;
+        try {
+            ctx = scope.manage(module.newContext());
+            if (sandboxOptions.executionTimeout) {
+                ctx.runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + sandboxOptions.executionTimeout));
+            }
+            if (sandboxOptions.maxStackSize) {
+                ctx.runtime.setMaxStackSize(sandboxOptions.maxStackSize);
+            }
+            if (sandboxOptions.memoryLimit) {
+                ctx.runtime.setMemoryLimit(sandboxOptions.memoryLimit);
+            }
+            // Virtual File System,
+            const fs = setupFileSystem(sandboxOptions);
+            const transpileFile = (value) => value;
+            // JS Module Loader
+            const moduleLoader = sandboxOptions.getModuleLoader
+                ? sandboxOptions.getModuleLoader(fs, sandboxOptions)
+                : getAsyncModuleLoader(fs, sandboxOptions);
+            ctx.runtime.setModuleLoader(moduleLoader, sandboxOptions.modulePathNormalizer ?? modulePathNormalizerAsync);
+            // Register Globals to be more Node.js compatible
+            await prepareAsyncNodeCompatibility(ctx, sandboxOptions);
+            // Prepare the Sandbox
+            // Expose Data and Functions to Client
+            prepareAsyncSandbox(ctx, scope, sandboxOptions, fs);
+            // Run the given Function
+            const result = await executeAsyncSandboxFunction({
+                ctx,
+                fs,
+                scope,
+                sandboxOptions,
+                sandboxedFunction,
+                transpileFile,
+            });
+            return result;
+        }
+        finally {
+            scope.dispose();
+        }
+    };
+    return { runSandboxed, module };
+};

package/vendor/quickjs/loadQuickJs.d.ts

@@ -0,0 +1,12 @@
+import type { LoadQuickJsOptions } from './types/LoadQuickJsOptions.js';
+import type { SandboxFunction } from './types/SandboxFunction.js';
+import type { SandboxOptions } from './types/SandboxOptions.js';
+/**
+ * Loads the QuickJS module and returns a sandbox execution function.
+ * @param variant - Options for loading the QuickJS module. Defaults to '@jitl/quickjs-ng-wasmfile-release-sync'.
+ * @returns An object containing the runSandboxed function and the loaded module.
+ */
+export declare const loadQuickJs: (variant: LoadQuickJsOptions) => Promise<{
+    runSandboxed: <T>(sandboxedFunction: SandboxFunction<T>, sandboxOptions?: SandboxOptions) => Promise<T>;
+    module: import("quickjs-emscripten-core").QuickJSWASMModule;
+}>;

package/vendor/quickjs/loadQuickJs.js

@@ -0,0 +1,73 @@
+import { newQuickJSWASMModuleFromVariant, Scope, shouldInterruptAfterDeadline } from 'quickjs-emscripten-core';
+import { rejectAndFlushPendingHostPromises } from './sandbox/expose/pendingHostPromises.js';
+import { setupFileSystem } from './sandbox/setupFileSystem.js';
+import { executeSandboxFunction } from './sandbox/syncVersion/executeSandboxFunction.js';
+import { getModuleLoader } from './sandbox/syncVersion/getModuleLoader.js';
+import { modulePathNormalizer } from './sandbox/syncVersion/modulePathNormalizer.js';
+import { prepareNodeCompatibility } from './sandbox/syncVersion/prepareNodeCompatibility.js';
+import { prepareSandbox } from './sandbox/syncVersion/prepareSandbox.js';
+/**
+ * Loads the QuickJS module and returns a sandbox execution function.
+ * @param variant - Options for loading the QuickJS module. Defaults to '@jitl/quickjs-ng-wasmfile-release-sync'.
+ * @returns An object containing the runSandboxed function and the loaded module.
+ */
+export const loadQuickJs = async (variant) => {
+    const module = await newQuickJSWASMModuleFromVariant(variant);
+    /**
+     * Provides a new sandbox and executes the given function.
+     * When the function has been finished, the sandbox gets disposed and can longer be used.
+     *
+     * @param sandboxedFunction
+     * @param sandboxOptions
+     * @returns
+     */
+    const runSandboxed = async (sandboxedFunction, sandboxOptions = {}) => {
+        const scope = new Scope();
+        let ctx;
+        try {
+            ctx = scope.manage(module.newContext());
+            if (sandboxOptions.executionTimeout) {
+                ctx.runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + sandboxOptions.executionTimeout));
+            }
+            if (sandboxOptions.maxStackSize) {
+                ctx.runtime.setMaxStackSize(sandboxOptions.maxStackSize);
+            }
+            if (sandboxOptions.memoryLimit) {
+                ctx.runtime.setMemoryLimit(sandboxOptions.memoryLimit);
+            }
+            // Virtual File System,
+            const fs = setupFileSystem(sandboxOptions);
+            const transpileFile = (value) => value;
+            // JS Module Loader
+            const moduleLoader = sandboxOptions.getModuleLoader
+                ? sandboxOptions.getModuleLoader(fs, sandboxOptions)
+                : getModuleLoader(fs, sandboxOptions);
+            ctx.runtime.setModuleLoader(moduleLoader, sandboxOptions.modulePathNormalizer ?? modulePathNormalizer);
+            // Register Globals to be more Node.js compatible
+            prepareNodeCompatibility(ctx, sandboxOptions);
+            // Prepare the Sandbox
+            // Expose Data and Functions to Client
+            prepareSandbox(ctx, scope, sandboxOptions, fs);
+            // Run the given Function
+            const result = await executeSandboxFunction({
+                ctx,
+                fs,
+                scope,
+                sandboxOptions,
+                sandboxedFunction,
+                transpileFile,
+            });
+            return result;
+        }
+        catch (error) {
+            throw error instanceof Error ? error : new Error('Internal Error');
+        }
+        finally {
+            if (ctx) {
+                await rejectAndFlushPendingHostPromises(ctx);
+            }
+            scope.dispose();
+        }
+    };
+    return { runSandboxed, module };
+};

package/vendor/quickjs/modules/assert.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\nconst assert = {\n    fail(actual, expected, message, operator, stackStartFunction) {\n        throw new Error(message || `Expected ${actual} ${operator} ${expected}`);\n    },\n    ok(value, message) {\n        if (!value) throw new Error(message || 'Assertion failed');\n    },\n    equal(actual, expected, message) {\n        if (actual != expected) throw new Error(message || `Expected ${actual} to equal ${expected}`);\n    },\n    notEqual(actual, expected, message) {\n        if (actual == expected) throw new Error(message || `Expected ${actual} to not equal ${expected}`);\n    },\n    deepEqual(actual, expected, message) {\n        if (!isDeepEqual(actual, expected)) throw new Error(message || `Expected ${actual} to deeply equal ${expected}`);\n    },\n    notDeepEqual(actual, expected, message) {\n        if (isDeepEqual(actual, expected)) throw new Error(message || `Expected ${actual} to not deeply equal ${expected}`);\n    },\n    strictEqual(actual, expected, message) {\n        if (actual !== expected) throw new Error(message || `Expected ${actual} to strictly equal ${expected}`);\n    },\n    notStrictEqual(actual, expected, message) {\n        if (actual === expected) throw new Error(message || `Expected ${actual} to not strictly equal ${expected}`);\n    }\n};\n\nfunction isDeepEqual(a, b) {\n    if (a === b) return true;\n\n    if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) return false;\n\n    const keysA = Object.keys(a);\n    const keysB = Object.keys(b);\n\n    if (keysA.length !== keysB.length) return false;\n\n    for (const key of keysA) {\n        if (!keysB.includes(key) || !isDeepEqual(a[key], b[key])) return false;\n    }\n\n    return true;\n}\n\nexport default assert;\n";
+export default _default;

package/vendor/quickjs/modules/assert.js

@@ -0,0 +1,47 @@
+export default `
+const assert = {
+    fail(actual, expected, message, operator, stackStartFunction) {
+        throw new Error(message || \`Expected \${actual} \${operator} \${expected}\`);
+    },
+    ok(value, message) {
+        if (!value) throw new Error(message || 'Assertion failed');
+    },
+    equal(actual, expected, message) {
+        if (actual != expected) throw new Error(message || \`Expected \${actual} to equal \${expected}\`);
+    },
+    notEqual(actual, expected, message) {
+        if (actual == expected) throw new Error(message || \`Expected \${actual} to not equal \${expected}\`);
+    },
+    deepEqual(actual, expected, message) {
+        if (!isDeepEqual(actual, expected)) throw new Error(message || \`Expected \${actual} to deeply equal \${expected}\`);
+    },
+    notDeepEqual(actual, expected, message) {
+        if (isDeepEqual(actual, expected)) throw new Error(message || \`Expected \${actual} to not deeply equal \${expected}\`);
+    },
+    strictEqual(actual, expected, message) {
+        if (actual !== expected) throw new Error(message || \`Expected \${actual} to strictly equal \${expected}\`);
+    },
+    notStrictEqual(actual, expected, message) {
+        if (actual === expected) throw new Error(message || \`Expected \${actual} to not strictly equal \${expected}\`);
+    }
+};
+
+function isDeepEqual(a, b) {
+    if (a === b) return true;
+
+    if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) return false;
+
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+
+    if (keysA.length !== keysB.length) return false;
+
+    for (const key of keysA) {
+        if (!keysB.includes(key) || !isDeepEqual(a[key], b[key])) return false;
+    }
+
+    return true;
+}
+
+export default assert;
+`;

package/vendor/quickjs/modules/buffer.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\nimport { TextEncoder, TextDecoder } from 'node:util'\n\nclass Buffer extends Uint8Array {\n  constructor(arg, encoding) {\n    if (typeof arg === 'number') {\n        super(arg);\n    } else if (typeof arg === 'string') {\n        super(Buffer._stringToBytes(arg, encoding));\n    } else if (arg instanceof ArrayBuffer) {\n        super(new Uint8Array(arg));\n    } else if (Array.isArray(arg) || arg instanceof Uint8Array) {\n        super(arg);\n    } else {\n        throw new TypeError('Invalid argument type');\n    }\n  }\n\n  static from(arg, encoding) {\n    if (typeof arg === 'string') {\n        return new Buffer(Buffer._stringToBytes(arg, encoding));\n    } else if (Array.isArray(arg) || arg instanceof Uint8Array) {\n        return new Buffer(arg);\n    } else if (arg instanceof ArrayBuffer) {\n        return new Buffer(new Uint8Array(arg));\n    } else {\n        throw new TypeError('Invalid argument type');\n    }\n  }\n\n  static alloc(size) {\n      return new Buffer(size);\n  }\n\n  static allocUnsafe(size) {\n      return new Buffer(size);\n  }\n\n  static concat(buffers, totalLength) {\n    if (!Array.isArray(buffers)) {\n        throw new TypeError('Argument must be an array of Buffers');\n    }\n    if (buffers.length === 0) {\n        return Buffer.alloc(0);\n    }\n    if (totalLength === undefined) {\n        totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);\n    }\n    const result = Buffer.allocUnsafe(totalLength);\n    let offset = 0;\n    for (const buf of buffers) {\n        result.set(buf, offset);\n        offset += buf.length;\n    }\n    return result;\n  }\n\n  toString(encoding) {\n    if (encoding === 'base64') {\n        return Buffer._bytesToBase64(this);\n    } else {\n        return Buffer._bytesToString(this, encoding);\n    }\n  }\n\n  static _stringToBytes(string, encoding) {\n    if (encoding === 'base64') {\n        return Buffer._base64ToBytes(string);\n    } else {\n        return new TextEncoder().encode(string);\n    }\n  }\n\n  static _bytesToString(bytes, encoding) {\n    if (encoding === 'utf-8' || encoding === undefined) {\n        return new TextDecoder(encoding).decode(bytes);\n    } else {\n        throw new TypeError('Unsupported encoding');\n    }\n  }\n\n  static _base64ToBytes(base64) {\n    const binaryString = atob(base64);\n    const length = binaryString.length;\n    const bytes = new Uint8Array(length);\n    for (let i = 0; i < length; i++) {\n        bytes[i] = binaryString.charCodeAt(i);\n    }\n    return bytes;\n  }\n\n  static _bytesToBase64(bytes) {\n    let binary = '';\n    for (let i = 0; i < bytes.length; i++) {\n        binary += String.fromCharCode(bytes[i]);\n    }\n    return btoa(binary);\n  }\n}\n\nglobalThis.Buffer = Buffer\n\nexport { Buffer }\n\nexport default Buffer;\n";
+export default _default;