@pnpm/exe 12.9.0 → 12.9.1

package/dist/wasm/node_modules/@tybys/wasm-util/lib/mjs/wasi/index.mjs

@@ -1,186 +0,0 @@
-import { WASI as WASIPreview1 } from "./preview1.mjs";
-import { validateObject, validateArray, validateBoolean, validateFunction, validateUndefined, validateString } from "./util.mjs";
-// eslint-disable-next-line spaced-comment
-const kEmptyObject = /*#__PURE__*/ Object.freeze(/*#__PURE__*/ Object.create(null));
-const kExitCode = Symbol('kExitCode');
-const kSetMemory = Symbol('kSetMemory');
-const kStarted = Symbol('kStarted');
-const kInstance = Symbol('kInstance');
-const kBindingName = Symbol('kBindingName');
-function validateOptions(options) {
-    var _a;
-    validateObject(options, 'options');
-    let _WASI;
-    if (options.version !== undefined) {
-        validateString(options.version, 'options.version');
-        switch (options.version) {
-            case 'unstable':
-                _WASI = WASIPreview1;
-                this[kBindingName] = 'wasi_unstable';
-                break;
-            case 'preview1':
-                _WASI = WASIPreview1;
-                this[kBindingName] = 'wasi_snapshot_preview1';
-                break;
-            default:
-                throw new TypeError(`unsupported WASI version "${options.version}"`);
-        }
-    }
-    else {
-        _WASI = WASIPreview1;
-        this[kBindingName] = 'wasi_snapshot_preview1';
-    }
-    if (options.args !== undefined) {
-        validateArray(options.args, 'options.args');
-    }
-    const args = ((_a = options.args) !== null && _a !== void 0 ? _a : []).map(String);
-    const env = [];
-    if (options.env !== undefined) {
-        validateObject(options.env, 'options.env');
-        Object.entries(options.env).forEach(({ 0: key, 1: value }) => {
-            if (value !== undefined) {
-                env.push(`${key}=${value}`);
-            }
-        });
-    }
-    const preopens = [];
-    if (options.preopens !== undefined) {
-        validateObject(options.preopens, 'options.preopens');
-        Object.entries(options.preopens).forEach(({ 0: key, 1: value }) => preopens.push({ mappedPath: String(key), realPath: String(value) }));
-    }
-    if (preopens.length > 0) {
-        if (options.fs === undefined) {
-            throw new Error('filesystem is disabled, can not preopen directory');
-        }
-        try {
-            validateObject(options.fs, 'options.fs');
-        }
-        catch (_) {
-            throw new TypeError('Node.js fs like implementation is not provided');
-        }
-    }
-    // if (options.filesystem !== undefined) {
-    //   validateObject(options.filesystem, 'options.filesystem')
-    //   validateString(options.filesystem.type, 'options.filesystem.type')
-    //   if (options.filesystem.type !== 'memfs' && options.filesystem.type !== 'file-system-access-api') {
-    //     throw new Error(`Filesystem type ${(options.filesystem as any).type as string} is not supported, only "memfs" and "file-system-access-api" is supported currently`)
-    //   }
-    //   try {
-    //     validateObject(options.filesystem.fs, 'options.filesystem.fs')
-    //   } catch (_) {
-    //     throw new Error('Node.js fs like implementation is not provided')
-    //   }
-    // }
-    if (options.print !== undefined)
-        validateFunction(options.print, 'options.print');
-    if (options.printErr !== undefined)
-        validateFunction(options.printErr, 'options.printErr');
-    if (options.returnOnExit !== undefined) {
-        validateBoolean(options.returnOnExit, 'options.returnOnExit');
-    }
-    // const { stdin = 0, stdout = 1, stderr = 2 } = options
-    // validateInt32(stdin, 'options.stdin', 0)
-    // validateInt32(stdout, 'options.stdout', 0)
-    // validateInt32(stderr, 'options.stderr', 0)
-    // const stdio = [stdin, stdout, stderr] as const
-    const stdio = [0, 1, 2];
-    return {
-        args,
-        env,
-        preopens,
-        stdio,
-        _WASI
-    };
-}
-function initWASI(setMemory, wrap) {
-    this[kSetMemory] = setMemory;
-    this.wasiImport = wrap;
-    this[kStarted] = false;
-    this[kExitCode] = 0;
-    this[kInstance] = undefined;
-}
-/** @public */
-export class WASI {
-    constructor(options = kEmptyObject) {
-        const { args, env, preopens, stdio, _WASI } = validateOptions.call(this, options);
-        const wrap = _WASI.createSync(args, env, preopens, stdio, options.fs, options.print, options.printErr);
-        const setMemory = wrap._setMemory;
-        delete wrap._setMemory;
-        initWASI.call(this, setMemory, wrap);
-        if (options.returnOnExit) {
-            wrap.proc_exit = wasiReturnOnProcExit.bind(this);
-        }
-    }
-    finalizeBindings(instance, _a) {
-        var _b;
-        var { memory = (_b = instance === null || instance === void 0 ? void 0 : instance.exports) === null || _b === void 0 ? void 0 : _b.memory } = _a === void 0 ? {} : _a;
-        if (this[kStarted]) {
-            throw new Error('WASI instance has already started');
-        }
-        validateObject(instance, 'instance');
-        validateObject(instance.exports, 'instance.exports');
-        this[kSetMemory](memory);
-        this[kInstance] = instance;
-        this[kStarted] = true;
-    }
-    // Must not export _initialize, must export _start
-    start(instance) {
-        this.finalizeBindings(instance);
-        const { _start, _initialize } = this[kInstance].exports;
-        validateFunction(_start, 'instance.exports._start');
-        validateUndefined(_initialize, 'instance.exports._initialize');
-        let ret;
-        try {
-            ret = _start();
-        }
-        catch (err) {
-            if (err !== kExitCode) {
-                throw err;
-            }
-        }
-        if (ret instanceof Promise) {
-            return ret.then(() => this[kExitCode], (err) => {
-                if (err !== kExitCode) {
-                    throw err;
-                }
-                return this[kExitCode];
-            });
-        }
-        return this[kExitCode];
-    }
-    // Must not export _start, may optionally export _initialize
-    initialize(instance) {
-        this.finalizeBindings(instance);
-        const { _start, _initialize } = this[kInstance].exports;
-        validateUndefined(_start, 'instance.exports._start');
-        if (_initialize !== undefined) {
-            validateFunction(_initialize, 'instance.exports._initialize');
-            return _initialize();
-        }
-    }
-    getImportObject() {
-        return { [this[kBindingName]]: this.wasiImport };
-    }
-}
-function wasiReturnOnProcExit(rval) {
-    this[kExitCode] = rval;
-    // eslint-disable-next-line @typescript-eslint/no-throw-literal
-    throw kExitCode;
-}
-/** @public */
-export async function createAsyncWASI(options = kEmptyObject) {
-    const _this = Object.create(WASI.prototype);
-    const { args, env, preopens, stdio, _WASI } = validateOptions.call(_this, options);
-    if (options.asyncify !== undefined) {
-        validateObject(options.asyncify, 'options.asyncify');
-        validateFunction(options.asyncify.wrapImportFunction, 'options.asyncify.wrapImportFunction');
-    }
-    const wrap = await _WASI.createAsync(args, env, preopens, stdio, options.fs, options.print, options.printErr, options.asyncify);
-    const setMemory = wrap._setMemory;
-    delete wrap._setMemory;
-    initWASI.call(_this, setMemory, wrap);
-    if (options.returnOnExit) {
-        wrap.proc_exit = wasiReturnOnProcExit.bind(_this);
-    }
-    return _this;
-}

package/dist/wasm/node_modules/@tybys/wasm-util/lib/mjs/wasi/path.mjs

@@ -1,310 +0,0 @@
-import { validateString } from "./util.mjs";
-const CHAR_DOT = 46; /* . */
-const CHAR_FORWARD_SLASH = 47; /* / */
-const CHAR_BACKWARD_SLASH = 92; /* \ */
-const CHAR_COLON = 58; /* : */
-const CHAR_UPPERCASE_A = 65; /* A */
-const CHAR_UPPERCASE_Z = 90; /* Z */
-const CHAR_LOWERCASE_A = 97; /* a */
-const CHAR_LOWERCASE_Z = 122; /* z */
-function isPathSeparatorWin(code) {
-    return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
-}
-function isWindowsDeviceRoot(code) {
-    return (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) ||
-        (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z);
-}
-const _isWin32 = typeof process !== 'undefined' && process.platform === 'win32';
-/**
- * Windows variant of `resolve()`. Mirrors Node's `path.win32.resolve`
- * semantics enough for the WASI shim's needs (drive-letter absolutes
- * + UNC paths + per-drive cwd lookups via `process.env`/`process.cwd`).
- *
- * Why this is needed: on Windows, `FileDescriptor.realPath` is the
- * host realpath returned by `fs.realpathSync(realPath, 'utf8')` — the
- * backslash form `D:\…`. The POSIX-only `resolveImpl` below only
- * treats `/` as a separator, reads `D` as non-`/`, decides realPath
- * is "relative", and produces a garbage joined path. Downstream
- * `fs.openSync(garbage)` then returns `EINVAL` and the WASI caller
- * sees a permanent failure. This function gives us the correct
- * Windows-style resolution without taking a Node-only `path` import
- * (which would break browser bundles of this package).
- *
- * Cribbed from Node's `lib/path.js` `win32.resolve()` (MIT-licensed),
- * trimmed to what WASI realpath resolution actually exercises.
- */
-function resolveWin32(args) {
-    let resolvedDevice = '';
-    let resolvedTail = '';
-    let resolvedAbsolute = false;
-    for (let i = args.length - 1; i >= -1; i--) {
-        let path;
-        if (i >= 0) {
-            path = args[i];
-            validateString(path, 'path');
-            if (path.length === 0)
-                continue;
-        }
-        else if (resolvedDevice.length === 0) {
-            path = (typeof process !== 'undefined' && typeof process.cwd === 'function')
-                ? process.cwd()
-                : '';
-        }
-        else {
-            // Look up per-drive cwd via the `=X:` env var convention; fall back
-            // to the global cwd if absent.
-            const envKey = `=${resolvedDevice}`;
-            const env = (typeof process !== 'undefined') ? process.env : undefined;
-            path = (env && typeof env[envKey] === 'string')
-                ? env[envKey]
-                : (typeof process !== 'undefined' && typeof process.cwd === 'function')
-                    ? process.cwd()
-                    : '';
-            if (path === undefined ||
-                (path.slice(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() &&
-                    path.charCodeAt(2) === CHAR_BACKWARD_SLASH)) {
-                path = `${resolvedDevice}\\`;
-            }
-        }
-        const len = path.length;
-        let rootEnd = 0;
-        let device = '';
-        let isAbsolute = false;
-        const code = path.charCodeAt(0);
-        if (len === 1) {
-            if (isPathSeparatorWin(code)) {
-                rootEnd = 1;
-                isAbsolute = true;
-            }
-        }
-        else if (isPathSeparatorWin(code)) {
-            isAbsolute = true;
-            if (isPathSeparatorWin(path.charCodeAt(1))) {
-                // UNC path: `\\server\share\…`
-                let j = 2;
-                let last = j;
-                while (j < len && !isPathSeparatorWin(path.charCodeAt(j)))
-                    j++;
-                if (j < len && j !== last) {
-                    const firstPart = path.slice(last, j);
-                    last = j;
-                    while (j < len && isPathSeparatorWin(path.charCodeAt(j)))
-                        j++;
-                    if (j < len && j !== last) {
-                        last = j;
-                        while (j < len && !isPathSeparatorWin(path.charCodeAt(j)))
-                            j++;
-                        if (j === len || j !== last) {
-                            device = `\\\\${firstPart}\\${path.slice(last, j)}`;
-                            rootEnd = j;
-                        }
-                    }
-                }
-            }
-            else {
-                rootEnd = 1;
-            }
-        }
-        else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
-            device = path.slice(0, 2);
-            rootEnd = 2;
-            if (len > 2 && isPathSeparatorWin(path.charCodeAt(2))) {
-                isAbsolute = true;
-                rootEnd = 3;
-            }
-        }
-        if (device.length > 0) {
-            if (resolvedDevice.length > 0) {
-                if (device.toLowerCase() !== resolvedDevice.toLowerCase())
-                    continue;
-            }
-            else {
-                resolvedDevice = device;
-            }
-        }
-        if (resolvedAbsolute) {
-            if (resolvedDevice.length > 0)
-                break;
-        }
-        else {
-            resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`;
-            resolvedAbsolute = isAbsolute;
-            if (isAbsolute && resolvedDevice.length > 0)
-                break;
-        }
-    }
-    resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, '\\', isPathSeparatorWin);
-    return resolvedDevice + (resolvedAbsolute ? '\\' : '') + resolvedTail || '.';
-}
-function isPosixPathSeparator(code) {
-    return code === CHAR_FORWARD_SLASH;
-}
-function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
-    let res = '';
-    let lastSegmentLength = 0;
-    let lastSlash = -1;
-    let dots = 0;
-    let code = 0;
-    for (let i = 0; i <= path.length; ++i) {
-        if (i < path.length) {
-            code = path.charCodeAt(i);
-        }
-        else if (isPathSeparator(code)) {
-            break;
-        }
-        else {
-            code = CHAR_FORWARD_SLASH;
-        }
-        if (isPathSeparator(code)) {
-            if (lastSlash === i - 1 || dots === 1) {
-                // NOOP
-            }
-            else if (dots === 2) {
-                if (res.length < 2 || lastSegmentLength !== 2 ||
-                    res.charCodeAt(res.length - 1) !== CHAR_DOT ||
-                    res.charCodeAt(res.length - 2) !== CHAR_DOT) {
-                    if (res.length > 2) {
-                        const lastSlashIndex = res.lastIndexOf(separator);
-                        if (lastSlashIndex === -1) {
-                            res = '';
-                            lastSegmentLength = 0;
-                        }
-                        else {
-                            res = res.slice(0, lastSlashIndex);
-                            lastSegmentLength =
-                                res.length - 1 - res.lastIndexOf(separator);
-                        }
-                        lastSlash = i;
-                        dots = 0;
-                        continue;
-                    }
-                    else if (res.length !== 0) {
-                        res = '';
-                        lastSegmentLength = 0;
-                        lastSlash = i;
-                        dots = 0;
-                        continue;
-                    }
-                }
-                if (allowAboveRoot) {
-                    res += res.length > 0 ? `${separator}..` : '..';
-                    lastSegmentLength = 2;
-                }
-            }
-            else {
-                if (res.length > 0) {
-                    res += `${separator}${path.slice(lastSlash + 1, i)}`;
-                }
-                else {
-                    res = path.slice(lastSlash + 1, i);
-                }
-                lastSegmentLength = i - lastSlash - 1;
-            }
-            lastSlash = i;
-            dots = 0;
-        }
-        else if (code === CHAR_DOT && dots !== -1) {
-            ++dots;
-        }
-        else {
-            dots = -1;
-        }
-    }
-    return res;
-}
-export function resolve(...args) {
-    // On Windows, host paths are `D:\…` style. The POSIX-only resolver
-    // below treats `D` as a non-`/` character and produces garbage; route
-    // to the Windows-aware variant. POSIX hosts (Linux/macOS/browser)
-    // run the original code path unchanged — `_isWin32` is constant-folded
-    // away on those targets.
-    if (_isWin32)
-        return resolveWin32(args);
-    let resolvedPath = '';
-    let resolvedAbsolute = false;
-    for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-        const path = i >= 0 ? args[i] : '/';
-        validateString(path, 'path');
-        // Skip empty entries
-        if (path.length === 0) {
-            continue;
-        }
-        resolvedPath = `${path}/${resolvedPath}`;
-        resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
-    }
-    // At this point the path should be resolved to a full absolute path, but
-    // handle relative paths to be safe (might happen when process.cwd() fails)
-    // Normalize the path
-    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator);
-    if (resolvedAbsolute) {
-        return `/${resolvedPath}`;
-    }
-    return resolvedPath.length > 0 ? resolvedPath : '.';
-}
-export function relative(from, to) {
-    validateString(from, 'from');
-    validateString(to, 'to');
-    if (from === to)
-        return '';
-    // Trim leading forward slashes.
-    from = resolve(from);
-    to = resolve(to);
-    if (from === to)
-        return '';
-    const fromStart = 1;
-    const fromEnd = from.length;
-    const fromLen = fromEnd - fromStart;
-    const toStart = 1;
-    const toLen = to.length - toStart;
-    // Compare paths to find the longest common path from root
-    const length = (fromLen < toLen ? fromLen : toLen);
-    let lastCommonSep = -1;
-    let i = 0;
-    for (; i < length; i++) {
-        const fromCode = from.charCodeAt(fromStart + i);
-        if (fromCode !== to.charCodeAt(toStart + i)) {
-            break;
-        }
-        else if (fromCode === CHAR_FORWARD_SLASH) {
-            lastCommonSep = i;
-        }
-    }
-    if (i === length) {
-        if (toLen > length) {
-            if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
-                // We get here if `from` is the exact base path for `to`.
-                // For example: from='/foo/bar'; to='/foo/bar/baz'
-                return to.slice(toStart + i + 1);
-            }
-            if (i === 0) {
-                // We get here if `from` is the root
-                // For example: from='/'; to='/foo'
-                return to.slice(toStart + i);
-            }
-        }
-        else if (fromLen > length) {
-            if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
-                // We get here if `to` is the exact base path for `from`.
-                // For example: from='/foo/bar/baz'; to='/foo/bar'
-                lastCommonSep = i;
-            }
-            else if (i === 0) {
-                // We get here if `to` is the root.
-                // For example: from='/foo/bar'; to='/'
-                lastCommonSep = 0;
-            }
-        }
-    }
-    let out = '';
-    // Generate the relative path based on the path difference between `to`
-    // and `from`.
-    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
-        if (i === fromEnd ||
-            from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
-            out += out.length === 0 ? '..' : '/..';
-        }
-    }
-    // Lastly, append the rest of the destination (`to`) path that comes after
-    // the common path parts.
-    return `${out}${to.slice(toStart + lastCommonSep)}`;
-}