@scelar/nodepod 1.0.1 → 1.0.2

package/dist/polyfills/constants.d.ts

@@ -0,0 +1,207 @@
+export declare const SIGKILL = 9;
+export declare const SIGTERM = 15;
+export declare const SIGINT = 2;
+export declare const SIGHUP = 1;
+export declare const SIGQUIT = 3;
+export declare const SIGABRT = 6;
+export declare const SIGALRM = 14;
+export declare const SIGUSR1 = 10;
+export declare const SIGUSR2 = 12;
+export declare const SIGPIPE = 13;
+export declare const SIGCHLD = 17;
+export declare const SIGCONT = 18;
+export declare const SIGSTOP = 19;
+export declare const SIGTSTP = 20;
+export declare const F_OK = 0;
+export declare const R_OK = 4;
+export declare const W_OK = 2;
+export declare const X_OK = 1;
+export declare const O_RDONLY = 0;
+export declare const O_WRONLY = 1;
+export declare const O_RDWR = 2;
+export declare const O_CREAT = 64;
+export declare const O_EXCL = 128;
+export declare const O_TRUNC = 512;
+export declare const O_APPEND = 1024;
+export declare const O_DIRECTORY = 65536;
+export declare const O_NOFOLLOW = 131072;
+export declare const O_SYNC = 1052672;
+export declare const S_IFMT = 61440;
+export declare const S_IFREG = 32768;
+export declare const S_IFDIR = 16384;
+export declare const S_IFCHR = 8192;
+export declare const S_IFBLK = 24576;
+export declare const S_IFIFO = 4096;
+export declare const S_IFLNK = 40960;
+export declare const S_IFSOCK = 49152;
+export declare const EACCES = -13;
+export declare const EEXIST = -17;
+export declare const EISDIR = -21;
+export declare const EMFILE = -24;
+export declare const ENOENT = -2;
+export declare const ENOTDIR = -20;
+export declare const ENOTEMPTY = -39;
+export declare const EPERM = -1;
+export declare const EBADF = -9;
+export declare const os: {
+    constants: {
+        signals: {
+            SIGKILL: number;
+            SIGTERM: number;
+            SIGINT: number;
+            SIGHUP: number;
+            SIGQUIT: number;
+            SIGABRT: number;
+            SIGALRM: number;
+            SIGUSR1: number;
+            SIGUSR2: number;
+            SIGPIPE: number;
+            SIGCHLD: number;
+            SIGCONT: number;
+            SIGSTOP: number;
+            SIGTSTP: number;
+        };
+        errno: {
+            EACCES: number;
+            EEXIST: number;
+            EISDIR: number;
+            EMFILE: number;
+            ENOENT: number;
+            ENOTDIR: number;
+            ENOTEMPTY: number;
+            EPERM: number;
+            EBADF: number;
+        };
+    };
+};
+export declare const fs: {
+    constants: {
+        F_OK: number;
+        R_OK: number;
+        W_OK: number;
+        X_OK: number;
+        O_RDONLY: number;
+        O_WRONLY: number;
+        O_RDWR: number;
+        O_CREAT: number;
+        O_EXCL: number;
+        O_TRUNC: number;
+        O_APPEND: number;
+        O_DIRECTORY: number;
+        O_NOFOLLOW: number;
+        O_SYNC: number;
+        S_IFMT: number;
+        S_IFREG: number;
+        S_IFDIR: number;
+        S_IFCHR: number;
+        S_IFBLK: number;
+        S_IFIFO: number;
+        S_IFLNK: number;
+        S_IFSOCK: number;
+    };
+};
+declare const _default: {
+    os: {
+        constants: {
+            signals: {
+                SIGKILL: number;
+                SIGTERM: number;
+                SIGINT: number;
+                SIGHUP: number;
+                SIGQUIT: number;
+                SIGABRT: number;
+                SIGALRM: number;
+                SIGUSR1: number;
+                SIGUSR2: number;
+                SIGPIPE: number;
+                SIGCHLD: number;
+                SIGCONT: number;
+                SIGSTOP: number;
+                SIGTSTP: number;
+            };
+            errno: {
+                EACCES: number;
+                EEXIST: number;
+                EISDIR: number;
+                EMFILE: number;
+                ENOENT: number;
+                ENOTDIR: number;
+                ENOTEMPTY: number;
+                EPERM: number;
+                EBADF: number;
+            };
+        };
+    };
+    fs: {
+        constants: {
+            F_OK: number;
+            R_OK: number;
+            W_OK: number;
+            X_OK: number;
+            O_RDONLY: number;
+            O_WRONLY: number;
+            O_RDWR: number;
+            O_CREAT: number;
+            O_EXCL: number;
+            O_TRUNC: number;
+            O_APPEND: number;
+            O_DIRECTORY: number;
+            O_NOFOLLOW: number;
+            O_SYNC: number;
+            S_IFMT: number;
+            S_IFREG: number;
+            S_IFDIR: number;
+            S_IFCHR: number;
+            S_IFBLK: number;
+            S_IFIFO: number;
+            S_IFLNK: number;
+            S_IFSOCK: number;
+        };
+    };
+    F_OK: number;
+    R_OK: number;
+    W_OK: number;
+    X_OK: number;
+    O_RDONLY: number;
+    O_WRONLY: number;
+    O_RDWR: number;
+    O_CREAT: number;
+    O_EXCL: number;
+    O_TRUNC: number;
+    O_APPEND: number;
+    O_DIRECTORY: number;
+    O_NOFOLLOW: number;
+    O_SYNC: number;
+    S_IFMT: number;
+    S_IFREG: number;
+    S_IFDIR: number;
+    S_IFCHR: number;
+    S_IFBLK: number;
+    S_IFIFO: number;
+    S_IFLNK: number;
+    S_IFSOCK: number;
+    EACCES: number;
+    EEXIST: number;
+    EISDIR: number;
+    EMFILE: number;
+    ENOENT: number;
+    ENOTDIR: number;
+    ENOTEMPTY: number;
+    EPERM: number;
+    EBADF: number;
+    SIGKILL: number;
+    SIGTERM: number;
+    SIGINT: number;
+    SIGHUP: number;
+    SIGQUIT: number;
+    SIGABRT: number;
+    SIGALRM: number;
+    SIGUSR1: number;
+    SIGUSR2: number;
+    SIGPIPE: number;
+    SIGCHLD: number;
+    SIGCONT: number;
+    SIGSTOP: number;
+    SIGTSTP: number;
+};
+export default _default;

package/dist/polyfills/crypto.d.ts

@@ -0,0 +1,189 @@
+import { EventEmitter } from "./events";
+export declare function randomBytes(count: number): Buffer;
+export declare function randomFillSync(target: Uint8Array | Buffer, start?: number, size?: number): Uint8Array | Buffer;
+export declare function randomUUID(): string;
+export declare function randomInt(lo: number, hi?: number): number;
+export declare function getRandomValues<T extends ArrayBufferView>(arr: T): T;
+export interface Hash {
+    update(input: string | Buffer | Uint8Array, enc?: string): Hash;
+    digestAsync(enc?: string): Promise<string | Buffer>;
+    digest(enc?: string): string | Buffer;
+}
+interface HashConstructor {
+    new (alg: string): Hash;
+    (this: any, alg: string): void;
+    prototype: any;
+}
+export declare const Hash: HashConstructor;
+export declare function createHash(alg: string): Hash;
+export declare function hash(algorithm: string, data: string | Buffer | Uint8Array, outputEncoding?: string): string | Buffer;
+export interface Hmac {
+    update(input: string | Buffer | Uint8Array, enc?: string): Hmac;
+    digestAsync(enc?: string): Promise<string | Buffer>;
+    digest(enc?: string): string | Buffer;
+}
+interface HmacConstructor {
+    new (alg: string, secret: string | Buffer): Hmac;
+    (this: any, alg: string, secret: string | Buffer): void;
+    prototype: any;
+}
+export declare const Hmac: HmacConstructor;
+export declare function createHmac(alg: string, secret: string | Buffer): Hmac;
+type BinaryInput = string | Buffer | Uint8Array;
+export declare function pbkdf2(password: BinaryInput, salt: BinaryInput, rounds: number, keyLen: number, hashName: string, cb: (err: Error | null, key: Buffer) => void): void;
+export declare function pbkdf2Sync(password: BinaryInput, salt: BinaryInput, rounds: number, keyLen: number, hashName: string): Buffer;
+export declare function scrypt(password: BinaryInput, salt: BinaryInput, keyLen: number, _opts: unknown, cb: (err: Error | null, key: Buffer) => void): void;
+export declare function scryptSync(password: BinaryInput, salt: BinaryInput, keyLen: number, _opts?: unknown): Buffer;
+type KeyMaterial = string | Buffer | KeyObject | {
+    key: string | Buffer;
+    passphrase?: string;
+};
+export declare function sign(alg: string | null | undefined, data: Buffer | Uint8Array, key: KeyMaterial, cb?: (err: Error | null, sig: Buffer) => void): Buffer | void;
+export declare function verify(alg: string | null | undefined, data: Buffer | Uint8Array, key: KeyMaterial, sig: Buffer | Uint8Array, cb?: (err: Error | null, ok: boolean) => void): boolean | void;
+export interface SignStream extends EventEmitter {
+    update(input: string | Buffer | Uint8Array, enc?: string): SignStream;
+    sign(privKey: KeyMaterial, outEnc?: string): Buffer | string;
+}
+interface SignStreamConstructor {
+    new (alg: string): SignStream;
+    (this: any, alg: string): void;
+    prototype: any;
+}
+export declare const SignStream: SignStreamConstructor;
+export interface VerifyStream extends EventEmitter {
+    update(input: string | Buffer | Uint8Array, enc?: string): VerifyStream;
+    verify(pubKey: KeyMaterial, sig: Buffer | string, sigEnc?: string): boolean;
+}
+interface VerifyStreamConstructor {
+    new (alg: string): VerifyStream;
+    (this: any, alg: string): void;
+    prototype: any;
+}
+export declare const VerifyStream: VerifyStreamConstructor;
+export declare function createSign(alg: string): SignStream;
+export declare function createVerify(alg: string): VerifyStream;
+export declare function createCipheriv(_alg: string, _key: BinaryInput, _iv: BinaryInput | null): any;
+export declare function createDecipheriv(_alg: string, _key: BinaryInput, _iv: BinaryInput | null): any;
+export interface KeyObject {
+    readonly type: string;
+    readonly asymmetricKeyType: string | undefined;
+    readonly symmetricKeySize: number | undefined;
+    export(opts?: {
+        type?: string;
+        format?: string;
+    }): Buffer | string;
+}
+interface KeyObjectConstructor {
+    new (kind: "public" | "private" | "secret", data: CryptoKey | Uint8Array, alg?: string): KeyObject;
+    (this: any, kind: "public" | "private" | "secret", data: CryptoKey | Uint8Array, alg?: string): void;
+    prototype: any;
+}
+export declare const KeyObject: KeyObjectConstructor;
+export declare function createSecretKey(key: Buffer | string, enc?: string): KeyObject;
+export declare function createPublicKey(key: KeyMaterial): KeyObject;
+export declare function createPrivateKey(key: KeyMaterial): KeyObject;
+export declare function timingSafeEqual(a: Buffer | Uint8Array, b: Buffer | Uint8Array): boolean;
+export declare function getCiphers(): string[];
+export declare function getHashes(): string[];
+export declare const constants: {
+    SSL_OP_ALL: number;
+    RSA_PKCS1_PADDING: number;
+    RSA_PKCS1_OAEP_PADDING: number;
+    RSA_PKCS1_PSS_PADDING: number;
+};
+export declare function generateKeySync(type: string, options?: {
+    length?: number;
+}): KeyObject;
+export declare function generateKeyPairSync(type: string, options?: {
+    modulusLength?: number;
+    namedCurve?: string;
+    publicKeyEncoding?: {
+        type?: string;
+        format?: string;
+    };
+    privateKeyEncoding?: {
+        type?: string;
+        format?: string;
+    };
+}): {
+    publicKey: KeyObject | string;
+    privateKey: KeyObject | string;
+};
+export declare function generatePrimeSync(size: number, _options?: {
+    bigint?: boolean;
+    safe?: boolean;
+}): Buffer | bigint;
+export declare function generatePrime(size: number, options: {
+    bigint?: boolean;
+    safe?: boolean;
+} | undefined, cb: (err: Error | null, prime: Buffer | bigint) => void): void;
+export declare function checkPrimeSync(_candidate: Buffer | bigint): boolean;
+export declare function checkPrime(candidate: Buffer | bigint, cb: (err: Error | null, result: boolean) => void): void;
+export declare function randomFill(buf: Uint8Array | Buffer, offsetOrCb: number | ((err: Error | null, buf: Uint8Array | Buffer) => void), sizeOrCb?: number | ((err: Error | null, buf: Uint8Array | Buffer) => void), cb?: (err: Error | null, buf: Uint8Array | Buffer) => void): void;
+export declare function hkdfSync(hashAlg: string, ikm: BinaryInput, salt: BinaryInput, info: BinaryInput, keyLen: number): Buffer;
+export declare function hkdf(hashAlg: string, ikm: BinaryInput, salt: BinaryInput, info: BinaryInput, keyLen: number, cb: (err: Error | null, derivedKey: Buffer) => void): void;
+export declare function getDiffieHellman(_groupName: string): any;
+export declare function createDiffieHellman(_sizeOrPrime: number | Buffer, _generator?: number | Buffer): any;
+export declare function createECDH(_curveName: string): any;
+export declare function getCurves(): string[];
+export declare function setFips(_mode: number): void;
+export declare function getFips(): number;
+export declare function secureHeapUsed(): {
+    total: number;
+    min: number;
+    used: number;
+};
+export declare const webcrypto: Crypto;
+declare const _default: {
+    randomBytes: typeof randomBytes;
+    randomFill: typeof randomFill;
+    randomFillSync: typeof randomFillSync;
+    randomUUID: typeof randomUUID;
+    randomInt: typeof randomInt;
+    getRandomValues: typeof getRandomValues;
+    createHash: typeof createHash;
+    hash: typeof hash;
+    createHmac: typeof createHmac;
+    createSign: typeof createSign;
+    createVerify: typeof createVerify;
+    createCipheriv: typeof createCipheriv;
+    createDecipheriv: typeof createDecipheriv;
+    sign: typeof sign;
+    verify: typeof verify;
+    pbkdf2: typeof pbkdf2;
+    pbkdf2Sync: typeof pbkdf2Sync;
+    scrypt: typeof scrypt;
+    scryptSync: typeof scryptSync;
+    hkdf: typeof hkdf;
+    hkdfSync: typeof hkdfSync;
+    timingSafeEqual: typeof timingSafeEqual;
+    getCiphers: typeof getCiphers;
+    getHashes: typeof getHashes;
+    getCurves: typeof getCurves;
+    constants: {
+        SSL_OP_ALL: number;
+        RSA_PKCS1_PADDING: number;
+        RSA_PKCS1_OAEP_PADDING: number;
+        RSA_PKCS1_PSS_PADDING: number;
+    };
+    KeyObject: KeyObjectConstructor;
+    createSecretKey: typeof createSecretKey;
+    createPublicKey: typeof createPublicKey;
+    createPrivateKey: typeof createPrivateKey;
+    generateKeySync: typeof generateKeySync;
+    generateKeyPairSync: typeof generateKeyPairSync;
+    generatePrimeSync: typeof generatePrimeSync;
+    generatePrime: typeof generatePrime;
+    checkPrimeSync: typeof checkPrimeSync;
+    checkPrime: typeof checkPrime;
+    createDiffieHellman: typeof createDiffieHellman;
+    getDiffieHellman: typeof getDiffieHellman;
+    createECDH: typeof createECDH;
+    setFips: typeof setFips;
+    getFips: typeof getFips;
+    secureHeapUsed: typeof secureHeapUsed;
+    webcrypto: Crypto;
+    Hash: HashConstructor;
+    Hmac: HmacConstructor;
+};
+export default _default;

package/dist/polyfills/dgram.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from "./events";
+export interface Socket extends EventEmitter {
+    bind(_port?: number, _addr?: string, _cb?: () => void): this;
+    close(_cb?: () => void): void;
+    send(_msg: Uint8Array | string, _offset?: number, _length?: number, _port?: number, _addr?: string, _cb?: (err: Error | null, bytes: number) => void): void;
+    address(): {
+        address: string;
+        family: string;
+        port: number;
+    };
+    setBroadcast(_flag: boolean): void;
+    setTTL(_ttl: number): number;
+    setMulticastTTL(_ttl: number): number;
+    setMulticastLoopback(_flag: boolean): boolean;
+    setMulticastInterface(_iface: string): void;
+    addMembership(_group: string, _iface?: string): void;
+    dropMembership(_group: string, _iface?: string): void;
+    ref(): this;
+    unref(): this;
+    setRecvBufferSize(_sz: number): void;
+    setSendBufferSize(_sz: number): void;
+    getRecvBufferSize(): number;
+    getSendBufferSize(): number;
+}
+export declare const Socket: {
+    new (): Socket;
+    prototype: any;
+};
+export declare function createSocket(_type: string | object, _cb?: (msg: Uint8Array, rinfo: object) => void): Socket;
+declare const _default: {
+    Socket: {
+        new (): Socket;
+        prototype: any;
+    };
+    createSocket: typeof createSocket;
+};
+export default _default;

package/dist/polyfills/diagnostics_channel.d.ts

@@ -0,0 +1,27 @@
+export interface DiagChannel {
+    name: string;
+    readonly hasSubscribers: boolean;
+    subscribe(handler: (message: unknown, name: string) => void): void;
+    unsubscribe(handler: (message: unknown, name: string) => void): boolean;
+    publish(message: unknown): void;
+}
+export declare const DiagChannel: {
+    new (name: string): DiagChannel;
+    prototype: any;
+};
+export declare function channel(name: string): DiagChannel;
+export declare function hasSubscribers(name: string): boolean;
+export declare function subscribe(name: string, handler: (message: unknown, name: string) => void): void;
+export declare function unsubscribe(name: string, handler: (message: unknown, name: string) => void): boolean;
+export { DiagChannel as Channel };
+declare const _default: {
+    channel: typeof channel;
+    hasSubscribers: typeof hasSubscribers;
+    subscribe: typeof subscribe;
+    unsubscribe: typeof unsubscribe;
+    Channel: {
+        new (name: string): DiagChannel;
+        prototype: any;
+    };
+};
+export default _default;

package/dist/polyfills/dns.d.ts

@@ -0,0 +1,76 @@
+type SingleResult = (err: Error | null, addr?: string, fam?: number) => void;
+type MultiResult = (err: Error | null, entries?: Array<{
+    address: string;
+    family: number;
+}>) => void;
+export declare function lookup(host: string, cb: SingleResult): void;
+export declare function lookup(host: string, opts: {
+    family?: number;
+    all?: true;
+}, cb: MultiResult): void;
+export declare function lookup(host: string, opts: {
+    family?: number;
+    all?: boolean;
+}, cb: SingleResult | MultiResult): void;
+export declare function resolve(_host: string, cb: (err: Error | null, addrs?: string[]) => void): void;
+export declare function resolve4(host: string, cb: (err: Error | null, addrs?: string[]) => void): void;
+export declare function resolve6(_host: string, cb: (err: Error | null, addrs?: string[]) => void): void;
+export declare function reverse(_ip: string, cb: (err: Error | null, names?: string[]) => void): void;
+export declare function setServers(_list: string[]): void;
+export declare function getServers(): string[];
+export declare function setDefaultResultOrder(_order: string): void;
+export declare function getDefaultResultOrder(): string;
+export declare const promises: {
+    lookup(host: string, opts?: {
+        family?: number;
+        all?: boolean;
+    }): Promise<{
+        address: string;
+        family: number;
+    } | Array<{
+        address: string;
+        family: number;
+    }>>;
+    resolve(host: string): Promise<string[]>;
+    resolve4(host: string): Promise<string[]>;
+    resolve6(_host: string): Promise<string[]>;
+    reverse(_ip: string): Promise<string[]>;
+    setServers(_s: string[]): void;
+    getServers(): string[];
+};
+export declare const ADDRCONFIG = 0;
+export declare const V4MAPPED = 0;
+export declare const ALL = 0;
+declare const _default: {
+    lookup: typeof lookup;
+    resolve: typeof resolve;
+    resolve4: typeof resolve4;
+    resolve6: typeof resolve6;
+    reverse: typeof reverse;
+    setServers: typeof setServers;
+    getServers: typeof getServers;
+    setDefaultResultOrder: typeof setDefaultResultOrder;
+    getDefaultResultOrder: typeof getDefaultResultOrder;
+    promises: {
+        lookup(host: string, opts?: {
+            family?: number;
+            all?: boolean;
+        }): Promise<{
+            address: string;
+            family: number;
+        } | Array<{
+            address: string;
+            family: number;
+        }>>;
+        resolve(host: string): Promise<string[]>;
+        resolve4(host: string): Promise<string[]>;
+        resolve6(_host: string): Promise<string[]>;
+        reverse(_ip: string): Promise<string[]>;
+        setServers(_s: string[]): void;
+        getServers(): string[];
+    };
+    ADDRCONFIG: number;
+    V4MAPPED: number;
+    ALL: number;
+};
+export default _default;

package/dist/polyfills/domain.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from "./events";
+export interface Domain extends EventEmitter {
+    members: unknown[];
+    add(emitter: EventEmitter): void;
+    remove(emitter: EventEmitter): void;
+    bind<F extends (...args: unknown[]) => unknown>(fn: F): F;
+    intercept<F extends (...args: unknown[]) => unknown>(fn: F): F;
+    run<T>(fn: () => T): T;
+    dispose(): void;
+    enter(): void;
+    exit(): void;
+}
+export declare const Domain: {
+    new (): Domain;
+    prototype: any;
+};
+export declare function create(): Domain;
+export declare let active: Domain | null;
+declare const _default: {
+    Domain: {
+        new (): Domain;
+        prototype: any;
+    };
+    create: typeof create;
+    active: null;
+};
+export default _default;

package/dist/polyfills/esbuild.d.ts

@@ -0,0 +1,106 @@
+import type { MemoryVolume } from "../memory-volume";
+export interface TransformConfig {
+    loader?: "js" | "jsx" | "ts" | "tsx" | "json" | "css";
+    format?: "iife" | "cjs" | "esm";
+    target?: string | string[];
+    minify?: boolean;
+    sourcemap?: boolean | "inline" | "external";
+    jsx?: "transform" | "preserve";
+    jsxFactory?: string;
+    jsxFragment?: string;
+}
+export interface TransformOutput {
+    code: string;
+    map: string;
+    warnings: unknown[];
+}
+export interface BundleConfig {
+    entryPoints?: string[];
+    stdin?: {
+        contents: string;
+        resolveDir?: string;
+        loader?: "js" | "jsx" | "ts" | "tsx" | "json" | "css";
+    };
+    bundle?: boolean;
+    outdir?: string;
+    outfile?: string;
+    format?: "iife" | "cjs" | "esm";
+    platform?: "browser" | "node" | "neutral";
+    target?: string | string[];
+    minify?: boolean;
+    sourcemap?: boolean | "inline" | "external";
+    external?: string[];
+    write?: boolean;
+    plugins?: unknown[];
+    absWorkingDir?: string;
+    conditions?: string[];
+    mainFields?: string[];
+}
+export interface BundleOutput {
+    errors: unknown[];
+    warnings: unknown[];
+    outputFiles?: Array<{
+        path: string;
+        contents: Uint8Array;
+        text: string;
+    }>;
+    metafile?: {
+        inputs?: Record<string, unknown>;
+        outputs?: Record<string, unknown>;
+    };
+}
+export declare function setVolume(vol: MemoryVolume): void;
+export declare function setWasmUrl(url: string): void;
+export declare function initialize(opts?: {
+    wasmURL?: string;
+}): Promise<void>;
+export declare function transform(source: string, cfg?: TransformConfig): Promise<TransformOutput>;
+export declare function build(cfg: BundleConfig): Promise<BundleOutput>;
+export declare function formatMessages(messages: unknown[], opts?: {
+    kind?: "error" | "warning";
+    color?: boolean;
+}): Promise<string[]>;
+export declare const version = "0.21.5";
+export declare function context(cfg: BundleConfig): Promise<{
+    rebuild: () => Promise<BundleOutput>;
+    watch: (opts?: unknown) => Promise<void>;
+    serve: (opts?: unknown) => Promise<{
+        host: string;
+        port: number;
+    }>;
+    cancel: () => Promise<void>;
+    dispose: () => Promise<void>;
+}>;
+export declare function stop(): void;
+export declare function analyzeMetafile(metafile: string | {
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+}, _opts?: {
+    verbose?: boolean;
+    color?: boolean;
+}): Promise<string>;
+export declare function analyzeMetafileSync(metafile: string | {
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+}, _opts?: {
+    verbose?: boolean;
+    color?: boolean;
+}): string;
+export declare function transformSync(source: string, cfg?: TransformConfig): TransformOutput;
+export declare function buildSync(cfg: BundleConfig): BundleOutput;
+declare const _default: {
+    initialize: typeof initialize;
+    transform: typeof transform;
+    transformSync: typeof transformSync;
+    build: typeof build;
+    buildSync: typeof buildSync;
+    context: typeof context;
+    stop: typeof stop;
+    formatMessages: typeof formatMessages;
+    analyzeMetafile: typeof analyzeMetafile;
+    analyzeMetafileSync: typeof analyzeMetafileSync;
+    version: string;
+    setVolume: typeof setVolume;
+    setWasmUrl: typeof setWasmUrl;
+};
+export default _default;