@pnpm/exe 12.9.0 → 12.9.1

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

@@ -1,39 +0,0 @@
-import { wrapInstanceExports } from "./wasi/util.mjs";
-import { _WebAssembly } from "./webassembly.mjs";
-function checkWebAssemblyFunction() {
-    const WebAssemblyFunction = _WebAssembly.Function;
-    if (typeof WebAssemblyFunction !== 'function') {
-        throw new Error('WebAssembly.Function is not supported in this environment.' +
-            ' If you are using V8 based browser like Chrome, try to specify' +
-            ' --js-flags="--wasm-staging --experimental-wasm-stack-switching"');
-    }
-    return WebAssemblyFunction;
-}
-/** @public */
-export function wrapAsyncImport(f, parameterType, returnType) {
-    const WebAssemblyFunction = checkWebAssemblyFunction();
-    if (typeof f !== 'function') {
-        throw new TypeError('Function required');
-    }
-    const parameters = parameterType.slice(0);
-    parameters.unshift('externref');
-    return new WebAssemblyFunction({ parameters, results: returnType }, f, { suspending: 'first' });
-}
-/** @public */
-export function wrapAsyncExport(f) {
-    const WebAssemblyFunction = checkWebAssemblyFunction();
-    if (typeof f !== 'function') {
-        throw new TypeError('Function required');
-    }
-    return new WebAssemblyFunction({ parameters: [...WebAssemblyFunction.type(f).parameters.slice(1)], results: ['externref'] }, f, { promising: 'first' });
-}
-/** @public */
-export function wrapExports(exports, needWrap) {
-    return wrapInstanceExports(exports, (exportValue, name) => {
-        let ignore = typeof exportValue !== 'function';
-        if (Array.isArray(needWrap)) {
-            ignore = ignore || (needWrap.indexOf(name) === -1);
-        }
-        return ignore ? exportValue : wrapAsyncExport(exportValue);
-    });
-}

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

@@ -1,89 +0,0 @@
-import { _WebAssembly } from "./webassembly.mjs";
-import { Asyncify } from "./asyncify.mjs";
-function validateImports(imports) {
-    if (imports && typeof imports !== 'object') {
-        throw new TypeError('imports must be an object or undefined');
-    }
-}
-function fetchWasm(urlOrBuffer, imports) {
-    if (typeof wx !== 'undefined' && typeof __wxConfig !== 'undefined') {
-        return _WebAssembly.instantiate(urlOrBuffer, imports);
-    }
-    return fetch(urlOrBuffer)
-        .then(response => response.arrayBuffer())
-        .then(buffer => _WebAssembly.instantiate(buffer, imports));
-}
-/** @public */
-export function load(wasmInput, imports) {
-    validateImports(imports);
-    imports = imports !== null && imports !== void 0 ? imports : {};
-    let source;
-    if (wasmInput instanceof ArrayBuffer || ArrayBuffer.isView(wasmInput)) {
-        return _WebAssembly.instantiate(wasmInput, imports);
-    }
-    if (wasmInput instanceof _WebAssembly.Module) {
-        return _WebAssembly.instantiate(wasmInput, imports).then((instance) => {
-            return { instance, module: wasmInput };
-        });
-    }
-    if (typeof wasmInput !== 'string' && !(wasmInput instanceof URL)) {
-        throw new TypeError('Invalid source');
-    }
-    if (typeof _WebAssembly.instantiateStreaming === 'function') {
-        let responsePromise;
-        try {
-            responsePromise = fetch(wasmInput);
-            source = _WebAssembly.instantiateStreaming(responsePromise, imports).catch(() => {
-                return fetchWasm(wasmInput, imports);
-            });
-        }
-        catch (_) {
-            source = fetchWasm(wasmInput, imports);
-        }
-    }
-    else {
-        source = fetchWasm(wasmInput, imports);
-    }
-    return source;
-}
-/** @public */
-export function asyncifyLoad(asyncify, urlOrBuffer, imports) {
-    validateImports(imports);
-    imports = imports !== null && imports !== void 0 ? imports : {};
-    const asyncifyHelper = new Asyncify();
-    imports = asyncifyHelper.wrapImports(imports);
-    return load(urlOrBuffer, imports).then(source => {
-        var _a;
-        const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
-        return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
-    });
-}
-/** @public */
-export function loadSync(wasmInput, imports) {
-    validateImports(imports);
-    imports = imports !== null && imports !== void 0 ? imports : {};
-    let module;
-    if ((wasmInput instanceof ArrayBuffer) || ArrayBuffer.isView(wasmInput)) {
-        module = new _WebAssembly.Module(wasmInput);
-    }
-    else if (wasmInput instanceof WebAssembly.Module) {
-        module = wasmInput;
-    }
-    else {
-        throw new TypeError('Invalid source');
-    }
-    const instance = new _WebAssembly.Instance(module, imports);
-    const source = { instance, module };
-    return source;
-}
-/** @public */
-export function asyncifyLoadSync(asyncify, buffer, imports) {
-    var _a;
-    validateImports(imports);
-    imports = imports !== null && imports !== void 0 ? imports : {};
-    const asyncifyHelper = new Asyncify();
-    imports = asyncifyHelper.wrapImports(imports);
-    const source = loadSync(buffer, imports);
-    const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
-    return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
-}

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

@@ -1,28 +0,0 @@
-import { _WebAssembly } from "./webassembly.mjs";
-/** @public */
-export const WebAssemblyMemory = /*#__PURE__*/ (function () { return _WebAssembly.Memory; })();
-/** @public */
-export class Memory extends WebAssemblyMemory {
-    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-    constructor(descriptor) {
-        super(descriptor);
-    }
-    get HEAP8() { return new Int8Array(super.buffer); }
-    get HEAPU8() { return new Uint8Array(super.buffer); }
-    get HEAP16() { return new Int16Array(super.buffer); }
-    get HEAPU16() { return new Uint16Array(super.buffer); }
-    get HEAP32() { return new Int32Array(super.buffer); }
-    get HEAPU32() { return new Uint32Array(super.buffer); }
-    get HEAP64() { return new BigInt64Array(super.buffer); }
-    get HEAPU64() { return new BigUint64Array(super.buffer); }
-    get HEAPF32() { return new Float32Array(super.buffer); }
-    get HEAPF64() { return new Float64Array(super.buffer); }
-    get view() { return new DataView(super.buffer); }
-}
-/** @public */
-export function extendMemory(memory) {
-    if (Object.getPrototypeOf(memory) === _WebAssembly.Memory.prototype) {
-        Object.setPrototypeOf(memory, Memory.prototype);
-    }
-    return memory;
-}

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

@@ -1,97 +0,0 @@
-import { WasiErrno } from "./types.mjs";
-export function strerror(errno) {
-    switch (errno) {
-        case WasiErrno.ESUCCESS: return 'Success';
-        case WasiErrno.E2BIG: return 'Argument list too long';
-        case WasiErrno.EACCES: return 'Permission denied';
-        case WasiErrno.EADDRINUSE: return 'Address in use';
-        case WasiErrno.EADDRNOTAVAIL: return 'Address not available';
-        case WasiErrno.EAFNOSUPPORT: return 'Address family not supported by protocol';
-        case WasiErrno.EAGAIN: return 'Resource temporarily unavailable';
-        case WasiErrno.EALREADY: return 'Operation already in progress';
-        case WasiErrno.EBADF: return 'Bad file descriptor';
-        case WasiErrno.EBADMSG: return 'Bad message';
-        case WasiErrno.EBUSY: return 'Resource busy';
-        case WasiErrno.ECANCELED: return 'Operation canceled';
-        case WasiErrno.ECHILD: return 'No child process';
-        case WasiErrno.ECONNABORTED: return 'Connection aborted';
-        case WasiErrno.ECONNREFUSED: return 'Connection refused';
-        case WasiErrno.ECONNRESET: return 'Connection reset by peer';
-        case WasiErrno.EDEADLK: return 'Resource deadlock would occur';
-        case WasiErrno.EDESTADDRREQ: return 'Destination address required';
-        case WasiErrno.EDOM: return 'Domain error';
-        case WasiErrno.EDQUOT: return 'Quota exceeded';
-        case WasiErrno.EEXIST: return 'File exists';
-        case WasiErrno.EFAULT: return 'Bad address';
-        case WasiErrno.EFBIG: return 'File too large';
-        case WasiErrno.EHOSTUNREACH: return 'Host is unreachable';
-        case WasiErrno.EIDRM: return 'Identifier removed';
-        case WasiErrno.EILSEQ: return 'Illegal byte sequence';
-        case WasiErrno.EINPROGRESS: return 'Operation in progress';
-        case WasiErrno.EINTR: return 'Interrupted system call';
-        case WasiErrno.EINVAL: return 'Invalid argument';
-        case WasiErrno.EIO: return 'I/O error';
-        case WasiErrno.EISCONN: return 'Socket is connected';
-        case WasiErrno.EISDIR: return 'Is a directory';
-        case WasiErrno.ELOOP: return 'Symbolic link loop';
-        case WasiErrno.EMFILE: return 'No file descriptors available';
-        case WasiErrno.EMLINK: return 'Too many links';
-        case WasiErrno.EMSGSIZE: return 'Message too large';
-        case WasiErrno.EMULTIHOP: return 'Multihop attempted';
-        case WasiErrno.ENAMETOOLONG: return 'Filename too long';
-        case WasiErrno.ENETDOWN: return 'Network is down';
-        case WasiErrno.ENETRESET: return 'Connection reset by network';
-        case WasiErrno.ENETUNREACH: return 'Network unreachable';
-        case WasiErrno.ENFILE: return 'Too many files open in system';
-        case WasiErrno.ENOBUFS: return 'No buffer space available';
-        case WasiErrno.ENODEV: return 'No such device';
-        case WasiErrno.ENOENT: return 'No such file or directory';
-        case WasiErrno.ENOEXEC: return 'Exec format error';
-        case WasiErrno.ENOLCK: return 'No locks available';
-        case WasiErrno.ENOLINK: return 'Link has been severed';
-        case WasiErrno.ENOMEM: return 'Out of memory';
-        case WasiErrno.ENOMSG: return 'No message of the desired type';
-        case WasiErrno.ENOPROTOOPT: return 'Protocol not available';
-        case WasiErrno.ENOSPC: return 'No space left on device';
-        case WasiErrno.ENOSYS: return 'Function not implemented';
-        case WasiErrno.ENOTCONN: return 'Socket not connected';
-        case WasiErrno.ENOTDIR: return 'Not a directory';
-        case WasiErrno.ENOTEMPTY: return 'Directory not empty';
-        case WasiErrno.ENOTRECOVERABLE: return 'State not recoverable';
-        case WasiErrno.ENOTSOCK: return 'Not a socket';
-        case WasiErrno.ENOTSUP: return 'Not supported';
-        case WasiErrno.ENOTTY: return 'Not a tty';
-        case WasiErrno.ENXIO: return 'No such device or address';
-        case WasiErrno.EOVERFLOW: return 'Value too large for data type';
-        case WasiErrno.EOWNERDEAD: return 'Previous owner died';
-        case WasiErrno.EPERM: return 'Operation not permitted';
-        case WasiErrno.EPIPE: return 'Broken pipe';
-        case WasiErrno.EPROTO: return 'Protocol error';
-        case WasiErrno.EPROTONOSUPPORT: return 'Protocol not supported';
-        case WasiErrno.EPROTOTYPE: return 'Protocol wrong type for socket';
-        case WasiErrno.ERANGE: return 'Result not representable';
-        case WasiErrno.EROFS: return 'Read-only file system';
-        case WasiErrno.ESPIPE: return 'Invalid seek';
-        case WasiErrno.ESRCH: return 'No such process';
-        case WasiErrno.ESTALE: return 'Stale file handle';
-        case WasiErrno.ETIMEDOUT: return 'Operation timed out';
-        case WasiErrno.ETXTBSY: return 'Text file busy';
-        case WasiErrno.EXDEV: return 'Cross-device link';
-        case WasiErrno.ENOTCAPABLE: return 'Capabilities insufficient';
-        default: return 'Unknown error';
-    }
-}
-export class WasiError extends Error {
-    constructor(message, errno) {
-        super(message);
-        this.errno = errno;
-    }
-    getErrorMessage() {
-        return strerror(this.errno);
-    }
-}
-Object.defineProperty(WasiError.prototype, 'name', {
-    configurable: true,
-    writable: true,
-    value: 'WasiError'
-});

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

@@ -1,256 +0,0 @@
-import { WasiErrno, FileControlFlag, WasiFileType, WasiWhence } from "./types.mjs";
-import { getRights } from "./rights.mjs";
-import { WasiError } from "./error.mjs";
-export function concatBuffer(buffers, size) {
-    let total = 0;
-    if (typeof size === 'number' && size >= 0) {
-        total = size;
-    }
-    else {
-        for (let i = 0; i < buffers.length; i++) {
-            const buffer = buffers[i];
-            total += buffer.length;
-        }
-    }
-    let pos = 0;
-    const ret = new Uint8Array(total);
-    for (let i = 0; i < buffers.length; i++) {
-        const buffer = buffers[i];
-        ret.set(buffer, pos);
-        pos += buffer.length;
-    }
-    return ret;
-}
-export class FileDescriptor {
-    constructor(id, fd, path, realPath, type, rightsBase, rightsInheriting, preopen) {
-        this.id = id;
-        this.fd = fd;
-        this.path = path;
-        this.realPath = realPath;
-        this.type = type;
-        this.rightsBase = rightsBase;
-        this.rightsInheriting = rightsInheriting;
-        this.preopen = preopen;
-        this.pos = BigInt(0);
-        this.size = BigInt(0);
-    }
-    seek(offset, whence) {
-        if (whence === WasiWhence.SET) {
-            this.pos = BigInt(offset);
-        }
-        else if (whence === WasiWhence.CUR) {
-            this.pos += BigInt(offset);
-        }
-        else if (whence === WasiWhence.END) {
-            this.pos = BigInt(this.size) - BigInt(offset);
-        }
-        else {
-            throw new WasiError('Unknown whence', WasiErrno.EIO);
-        }
-        return this.pos;
-    }
-}
-export class StandardOutput extends FileDescriptor {
-    constructor(log, id, fd, path, realPath, type, rightsBase, rightsInheriting, preopen) {
-        super(id, fd, path, realPath, type, rightsBase, rightsInheriting, preopen);
-        this._log = log;
-        this._buf = null;
-    }
-    write(buffer) {
-        const originalBuffer = buffer;
-        if (this._buf) {
-            buffer = concatBuffer([this._buf, buffer]);
-            this._buf = null;
-        }
-        if (buffer.indexOf(10) === -1) {
-            this._buf = buffer;
-            return originalBuffer.byteLength;
-        }
-        let written = 0;
-        let lastBegin = 0;
-        let index;
-        while ((index = buffer.indexOf(10, written)) !== -1) {
-            const str = new TextDecoder().decode(buffer.subarray(lastBegin, index));
-            this._log(str);
-            written += index - lastBegin + 1;
-            lastBegin = index + 1;
-        }
-        if (written < buffer.length) {
-            this._buf = buffer.slice(written);
-        }
-        return originalBuffer.byteLength;
-    }
-}
-export function toFileType(stat) {
-    if (stat.isBlockDevice())
-        return WasiFileType.BLOCK_DEVICE;
-    if (stat.isCharacterDevice())
-        return WasiFileType.CHARACTER_DEVICE;
-    if (stat.isDirectory())
-        return WasiFileType.DIRECTORY;
-    if (stat.isSocket())
-        return WasiFileType.SOCKET_STREAM;
-    if (stat.isFile())
-        return WasiFileType.REGULAR_FILE;
-    if (stat.isSymbolicLink())
-        return WasiFileType.SYMBOLIC_LINK;
-    return WasiFileType.UNKNOWN;
-}
-export function toFileStat(view, buf, stat) {
-    view.setBigUint64(buf, stat.dev, true);
-    view.setBigUint64(buf + 8, stat.ino, true);
-    view.setBigUint64(buf + 16, BigInt(toFileType(stat)), true);
-    view.setBigUint64(buf + 24, stat.nlink, true);
-    view.setBigUint64(buf + 32, stat.size, true);
-    view.setBigUint64(buf + 40, stat.atimeMs * BigInt(1000000), true);
-    view.setBigUint64(buf + 48, stat.mtimeMs * BigInt(1000000), true);
-    view.setBigUint64(buf + 56, stat.ctimeMs * BigInt(1000000), true);
-}
-export class FileDescriptorTable {
-    constructor(options) {
-        this.used = 0;
-        this.size = options.size;
-        this.fds = Array(options.size);
-        this.stdio = [options.in, options.out, options.err];
-        this.print = options.print;
-        this.printErr = options.printErr;
-        this.insertStdio(options.in, 0, '<stdin>');
-        this.insertStdio(options.out, 1, '<stdout>');
-        this.insertStdio(options.err, 2, '<stderr>');
-    }
-    insertStdio(fd, expected, name) {
-        const type = WasiFileType.CHARACTER_DEVICE;
-        const { base, inheriting } = getRights(this.stdio, fd, FileControlFlag.O_RDWR, type);
-        const wrap = this.insert(fd, name, name, type, base, inheriting, 0);
-        if (wrap.id !== expected) {
-            throw new WasiError(`id: ${wrap.id} !== expected: ${expected}`, WasiErrno.EBADF);
-        }
-        return wrap;
-    }
-    insert(fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen) {
-        var _a, _b;
-        let index = -1;
-        if (this.used >= this.size) {
-            const newSize = this.size * 2;
-            this.fds.length = newSize;
-            index = this.size;
-            this.size = newSize;
-        }
-        else {
-            for (let i = 0; i < this.size; ++i) {
-                if (this.fds[i] == null) {
-                    index = i;
-                    break;
-                }
-            }
-        }
-        let entry;
-        if (mappedPath === '<stdout>') {
-            entry = new StandardOutput((_a = this.print) !== null && _a !== void 0 ? _a : console.log, index, fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen);
-        }
-        else if (mappedPath === '<stderr>') {
-            entry = new StandardOutput((_b = this.printErr) !== null && _b !== void 0 ? _b : console.error, index, fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen);
-        }
-        else {
-            entry = new FileDescriptor(index, fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen);
-        }
-        this.fds[index] = entry;
-        this.used++;
-        return entry;
-    }
-    get(id, base, inheriting) {
-        if (id >= this.size) {
-            throw new WasiError('Invalid fd', WasiErrno.EBADF);
-        }
-        const entry = this.fds[id];
-        if (!entry || entry.id !== id) {
-            throw new WasiError('Bad file descriptor', WasiErrno.EBADF);
-        }
-        /* Validate that the fd has the necessary rights. */
-        if ((~entry.rightsBase & base) !== BigInt(0) || (~entry.rightsInheriting & inheriting) !== BigInt(0)) {
-            throw new WasiError('Capabilities insufficient', WasiErrno.ENOTCAPABLE);
-        }
-        return entry;
-    }
-    remove(id) {
-        if (id >= this.size) {
-            throw new WasiError('Invalid fd', WasiErrno.EBADF);
-        }
-        const entry = this.fds[id];
-        if (!entry || entry.id !== id) {
-            throw new WasiError('Bad file descriptor', WasiErrno.EBADF);
-        }
-        this.fds[id] = undefined;
-        this.used--;
-    }
-}
-export class SyncTable extends FileDescriptorTable {
-    constructor(options) {
-        super(options);
-        this.fs = options.fs;
-    }
-    getFileTypeByFd(fd) {
-        const stats = this.fs.fstatSync(fd, { bigint: true });
-        return toFileType(stats);
-    }
-    insertPreopen(fd, mappedPath, realPath) {
-        const type = this.getFileTypeByFd(fd);
-        if (type !== WasiFileType.DIRECTORY) {
-            throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, WasiErrno.ENOTDIR);
-        }
-        const result = getRights(this.stdio, fd, 0, type);
-        return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);
-    }
-    renumber(dst, src) {
-        if (dst === src)
-            return;
-        if (dst >= this.size || src >= this.size) {
-            throw new WasiError('Invalid fd', WasiErrno.EBADF);
-        }
-        const dstEntry = this.fds[dst];
-        const srcEntry = this.fds[src];
-        if (!dstEntry || !srcEntry || dstEntry.id !== dst || srcEntry.id !== src) {
-            throw new WasiError('Invalid fd', WasiErrno.EBADF);
-        }
-        this.fs.closeSync(dstEntry.fd);
-        this.fds[dst] = this.fds[src];
-        this.fds[dst].id = dst;
-        this.fds[src] = undefined;
-        this.used--;
-    }
-}
-export class AsyncTable extends FileDescriptorTable {
-    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-    constructor(options) {
-        super(options);
-    }
-    async getFileTypeByFd(fd) {
-        const stats = await fd.stat({ bigint: true });
-        return toFileType(stats);
-    }
-    async insertPreopen(fd, mappedPath, realPath) {
-        const type = await this.getFileTypeByFd(fd);
-        if (type !== WasiFileType.DIRECTORY) {
-            throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, WasiErrno.ENOTDIR);
-        }
-        const result = getRights(this.stdio, fd.fd, 0, type);
-        return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);
-    }
-    async renumber(dst, src) {
-        if (dst === src)
-            return;
-        if (dst >= this.size || src >= this.size) {
-            throw new WasiError('Invalid fd', WasiErrno.EBADF);
-        }
-        const dstEntry = this.fds[dst];
-        const srcEntry = this.fds[src];
-        if (!dstEntry || !srcEntry || dstEntry.id !== dst || srcEntry.id !== src) {
-            throw new WasiError('Invalid fd', WasiErrno.EBADF);
-        }
-        await dstEntry.fd.close();
-        this.fds[dst] = this.fds[src];
-        this.fds[dst].id = dst;
-        this.fds[src] = undefined;
-        this.used--;
-    }
-}

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

@@ -1 +0,0 @@
-export {};