@run0/jiki 0.1.0

package/dist/polyfills/http.d.ts

@@ -0,0 +1,147 @@
+import { EventEmitter } from "./events";
+import { Readable, Writable, BufferImpl } from "./stream";
+type ServerListenCallback = (port: number, server: Server) => void;
+type ServerCloseCallback = (port: number) => void;
+export declare function setServerListenCallback(cb: ServerListenCallback): void;
+export declare function setServerCloseCallback(cb: ServerCloseCallback): void;
+export declare function getServer(_port: number): Server | undefined;
+export declare const METHODS: string[];
+export declare const STATUS_CODES: Record<number, string>;
+export declare class IncomingMessage extends Readable {
+    method: string;
+    url: string;
+    headers: Record<string, string | string[] | undefined>;
+    httpVersion: string;
+    statusCode?: number;
+    statusMessage?: string;
+    socket: {
+        remoteAddress: string;
+        remotePort: number;
+        destroy(): void;
+    };
+    complete: boolean;
+    aborted: boolean;
+    connection: {
+        remoteAddress: string;
+    };
+    rawHeaders: string[];
+    trailers: Record<string, string>;
+    rawTrailers: string[];
+    constructor(opts?: {
+        method?: string;
+        url?: string;
+        headers?: Record<string, string>;
+    });
+    setTimeout(_ms: number, _cb?: () => void): this;
+}
+export declare class ServerResponse extends Writable {
+    statusCode: number;
+    statusMessage: string;
+    headersSent: boolean;
+    finished: boolean;
+    private _headers;
+    private _body;
+    setHeader(name: string, value: string | string[]): this;
+    getHeader(name: string): string | string[] | undefined;
+    removeHeader(name: string): void;
+    getHeaders(): Record<string, string | string[]>;
+    hasHeader(name: string): boolean;
+    writeHead(statusCode: number, statusMessage?: string | Record<string, string | string[]>, headers?: Record<string, string | string[]>): this;
+    _write(chunk: unknown, _encoding: string, callback: () => void): void;
+    end(chunkOrCb?: unknown, encodingOrCb?: string | (() => void), cb?: () => void): this;
+    getBody(): Uint8Array;
+    getBodyString(): string;
+    addTrailers(headers: Record<string, string>): void;
+    flushHeaders(): void;
+    cork(): void;
+    uncork(): void;
+}
+type RequestHandler = (req: IncomingMessage, res: ServerResponse) => void;
+export declare class Server extends EventEmitter {
+    private handler;
+    private _port;
+    listening: boolean;
+    keepAliveTimeout: number;
+    headersTimeout: number;
+    requestTimeout: number;
+    timeout: number;
+    constructor(handler?: RequestHandler);
+    setTimeout(ms?: number, _cb?: () => void): this;
+    listen(portOrOpts?: number | Record<string, unknown>, hostOrCb?: string | (() => void), cb?: () => void): this;
+    close(cb?: () => void): this;
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    } | null;
+    handleRequest(methodOrReq: string | IncomingMessage, urlOrRes?: string | ServerResponse, headers?: Record<string, string>, body?: BufferImpl | string): Promise<{
+        statusCode: number;
+        statusMessage: string;
+        headers: Record<string, string>;
+        body: BufferImpl;
+    }>;
+}
+export declare function createServer(handler?: RequestHandler): Server;
+export declare class ClientRequest extends Writable {
+    method: string;
+    path: string;
+    private _headers;
+    private _body;
+    private _url;
+    constructor(options: string | {
+        hostname?: string;
+        host?: string;
+        port?: number;
+        path?: string;
+        method?: string;
+        headers?: Record<string, string>;
+        protocol?: string;
+    });
+    aborted: boolean;
+    setHeader(name: string, value: string): void;
+    getHeader(name: string): string | undefined;
+    removeHeader(name: string): void;
+    abort(): void;
+    setTimeout(_ms: number, _cb?: () => void): this;
+    destroy(error?: Error): this;
+    _write(chunk: unknown, _encoding: string, callback: () => void): void;
+    end(chunkOrCb?: unknown, encodingOrCb?: string | (() => void), cb?: () => void): this;
+}
+export declare function request(options: unknown, cb?: (res: IncomingMessage) => void): ClientRequest;
+export declare function get(options: unknown, cb?: (res: IncomingMessage) => void): ClientRequest;
+export declare const Agent: {
+    new (_opts?: unknown): {};
+};
+export declare const globalAgent: {};
+declare const _default: {
+    METHODS: string[];
+    STATUS_CODES: Record<number, string>;
+    IncomingMessage: typeof IncomingMessage;
+    ServerResponse: typeof ServerResponse;
+    Server: typeof Server;
+    ClientRequest: typeof ClientRequest;
+    createServer: typeof createServer;
+    request: typeof request;
+    get: typeof get;
+    Agent: {
+        new (_opts?: unknown): {};
+    };
+    globalAgent: {};
+    setServerListenCallback: typeof setServerListenCallback;
+    setServerCloseCallback: typeof setServerCloseCallback;
+    getServer: typeof getServer;
+};
+export default _default;
+export declare const httpsModule: {
+    createServer: typeof createServer;
+    request: typeof request;
+    get: typeof get;
+    Server: typeof Server;
+    Agent: {
+        new (_opts?: unknown): {};
+    };
+    globalAgent: {};
+    IncomingMessage: typeof IncomingMessage;
+    ServerResponse: typeof ServerResponse;
+    ClientRequest: typeof ClientRequest;
+};

package/dist/polyfills/module.d.ts

@@ -0,0 +1,29 @@
+export declare const builtinModules: string[];
+export declare function isBuiltin(moduleName: string): boolean;
+export declare function initModule(requireFactory: (dir: string) => (id: string) => unknown): void;
+export declare function createRequire(filename: string): (id: string) => unknown;
+export declare class Module {
+    id: string;
+    filename: string;
+    exports: unknown;
+    loaded: boolean;
+    children: Module[];
+    paths: string[];
+    parent: Module | null;
+    constructor(id?: string);
+    static _resolveFilename(request: string, _parent?: unknown): string;
+    static _cache: Record<string, Module>;
+    static _extensions: Record<string, unknown>;
+    static builtinModules: string[];
+    static isBuiltin: typeof isBuiltin;
+    static createRequire: typeof createRequire;
+    static wrap(code: string): string;
+    static Module: typeof Module;
+}
+declare const _default: {
+    Module: typeof Module;
+    builtinModules: string[];
+    isBuiltin: typeof isBuiltin;
+    createRequire: typeof createRequire;
+};
+export default _default;

package/dist/polyfills/net.d.ts

@@ -0,0 +1,53 @@
+import { Duplex } from "./stream";
+import { EventEmitter } from "./events";
+export declare class Socket extends Duplex {
+    remoteAddress: string;
+    remotePort: number;
+    localAddress: string;
+    localPort: number;
+    connecting: boolean;
+    destroyed: boolean;
+    timeout: number;
+    allowHalfOpen: boolean;
+    connect(...args: unknown[]): this;
+    destroy(error?: Error): this;
+    setTimeout(timeout: number, cb?: () => void): this;
+    setNoDelay(): this;
+    setKeepAlive(): this;
+    ref(): this;
+    unref(): this;
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    };
+}
+export declare class Server extends EventEmitter {
+    listening: boolean;
+    listen(port?: number, hostOrCb?: string | (() => void), cb?: () => void): this;
+    close(cb?: () => void): this;
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    } | null;
+    ref(): this;
+    unref(): this;
+}
+export declare function createServer(_options?: unknown, _connectionListener?: unknown): Server;
+export declare function createConnection(_options: unknown, cb?: () => void): Socket;
+export declare function connect(_options: unknown, cb?: () => void): Socket;
+export declare function isIP(input: string): number;
+export declare function isIPv4(input: string): boolean;
+export declare function isIPv6(input: string): boolean;
+declare const _default: {
+    Socket: typeof Socket;
+    Server: typeof Server;
+    createServer: typeof createServer;
+    createConnection: typeof createConnection;
+    connect: typeof connect;
+    isIP: typeof isIP;
+    isIPv4: typeof isIPv4;
+    isIPv6: typeof isIPv6;
+};
+export default _default;

package/dist/polyfills/os.d.ts

@@ -0,0 +1,91 @@
+export declare function hostname(): string;
+export declare function type(): string;
+export declare function platform(): string;
+export declare function arch(): string;
+export declare function release(): string;
+export declare function tmpdir(): string;
+export declare function homedir(): string;
+export declare function userInfo(): {
+    username: string;
+    uid: number;
+    gid: number;
+    shell: string;
+    homedir: string;
+};
+export declare function cpus(): {
+    model: string;
+    speed: number;
+    times: {
+        user: number;
+        nice: number;
+        sys: number;
+        idle: number;
+        irq: number;
+    };
+}[];
+export declare function totalmem(): number;
+export declare function freemem(): number;
+export declare function uptime(): number;
+export declare function loadavg(): [number, number, number];
+export declare function networkInterfaces(): Record<string, unknown[]>;
+export declare function endianness(): "BE" | "LE";
+export declare const EOL = "\n";
+export declare const constants: {
+    signals: {
+        SIGHUP: number;
+        SIGINT: number;
+        SIGQUIT: number;
+        SIGTERM: number;
+        SIGKILL: number;
+    };
+    errno: {};
+    priority: {
+        PRIORITY_LOW: number;
+        PRIORITY_BELOW_NORMAL: number;
+        PRIORITY_NORMAL: number;
+        PRIORITY_ABOVE_NORMAL: number;
+        PRIORITY_HIGH: number;
+        PRIORITY_HIGHEST: number;
+    };
+};
+export declare function version(): string;
+export declare function machine(): string;
+declare const _default: {
+    hostname: typeof hostname;
+    type: typeof type;
+    platform: typeof platform;
+    arch: typeof arch;
+    release: typeof release;
+    tmpdir: typeof tmpdir;
+    homedir: typeof homedir;
+    userInfo: typeof userInfo;
+    cpus: typeof cpus;
+    totalmem: typeof totalmem;
+    freemem: typeof freemem;
+    uptime: typeof uptime;
+    loadavg: typeof loadavg;
+    networkInterfaces: typeof networkInterfaces;
+    endianness: typeof endianness;
+    EOL: string;
+    constants: {
+        signals: {
+            SIGHUP: number;
+            SIGINT: number;
+            SIGQUIT: number;
+            SIGTERM: number;
+            SIGKILL: number;
+        };
+        errno: {};
+        priority: {
+            PRIORITY_LOW: number;
+            PRIORITY_BELOW_NORMAL: number;
+            PRIORITY_NORMAL: number;
+            PRIORITY_ABOVE_NORMAL: number;
+            PRIORITY_HIGH: number;
+            PRIORITY_HIGHEST: number;
+        };
+    };
+    version: typeof version;
+    machine: typeof machine;
+};
+export default _default;

package/dist/polyfills/path.d.ts

@@ -0,0 +1,96 @@
+export declare const sep = "/";
+export declare const delimiter = ":";
+export declare function normalize(path: string): string;
+export declare function join(...paths: string[]): string;
+export declare function resolve(...paths: string[]): string;
+export declare function isAbsolute(path: string): boolean;
+export declare function dirname(path: string): string;
+export declare function basename(path: string, ext?: string): string;
+export declare function extname(path: string): string;
+export declare function relative(from: string, to: string): string;
+export declare function parse(path: string): {
+    root: string;
+    dir: string;
+    base: string;
+    ext: string;
+    name: string;
+};
+export declare function format(obj: {
+    root?: string;
+    dir?: string;
+    base?: string;
+    ext?: string;
+    name?: string;
+}): string;
+export declare const posix: {
+    sep: string;
+    delimiter: string;
+    normalize: typeof normalize;
+    join: typeof join;
+    resolve: typeof resolve;
+    isAbsolute: typeof isAbsolute;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    relative: typeof relative;
+    parse: typeof parse;
+    format: typeof format;
+};
+/** @note win32 uses posix implementation — Windows paths not supported in browser */
+export declare const win32: {
+    sep: string;
+    delimiter: string;
+    normalize: typeof normalize;
+    join: typeof join;
+    resolve: typeof resolve;
+    isAbsolute: typeof isAbsolute;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    relative: typeof relative;
+    parse: typeof parse;
+    format: typeof format;
+};
+declare const _default: {
+    sep: string;
+    delimiter: string;
+    normalize: typeof normalize;
+    join: typeof join;
+    resolve: typeof resolve;
+    isAbsolute: typeof isAbsolute;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    relative: typeof relative;
+    parse: typeof parse;
+    format: typeof format;
+    posix: {
+        sep: string;
+        delimiter: string;
+        normalize: typeof normalize;
+        join: typeof join;
+        resolve: typeof resolve;
+        isAbsolute: typeof isAbsolute;
+        dirname: typeof dirname;
+        basename: typeof basename;
+        extname: typeof extname;
+        relative: typeof relative;
+        parse: typeof parse;
+        format: typeof format;
+    };
+    win32: {
+        sep: string;
+        delimiter: string;
+        normalize: typeof normalize;
+        join: typeof join;
+        resolve: typeof resolve;
+        isAbsolute: typeof isAbsolute;
+        dirname: typeof dirname;
+        basename: typeof basename;
+        extname: typeof extname;
+        relative: typeof relative;
+        parse: typeof parse;
+        format: typeof format;
+    };
+};
+export default _default;

package/dist/polyfills/perf_hooks.d.ts

@@ -0,0 +1,21 @@
+export declare const performance: Performance;
+export declare class PerformanceObserver {
+    private callback;
+    constructor(callback: (list: unknown) => void);
+    observe(_options?: unknown): void;
+    disconnect(): void;
+}
+export declare function monitorEventLoopDelay(_options?: unknown): {
+    enable(): void;
+    disable(): void;
+    min: number;
+    max: number;
+    mean: number;
+    percentile(p: number): number;
+};
+declare const _default: {
+    performance: Performance;
+    PerformanceObserver: typeof PerformanceObserver;
+    monitorEventLoopDelay: typeof monitorEventLoopDelay;
+};
+export default _default;

package/dist/polyfills/process.d.ts

@@ -0,0 +1,99 @@
+import { EventListener } from "./events";
+export interface ProcessEnv {
+    [key: string]: string | undefined;
+}
+interface ProcessStream {
+    isTTY: boolean;
+    on: (event: string, listener: EventListener) => ProcessStream;
+    once: (event: string, listener: EventListener) => ProcessStream;
+    off: (event: string, listener: EventListener) => ProcessStream;
+    emit: (event: string, ...args: unknown[]) => boolean;
+    addListener: (event: string, listener: EventListener) => ProcessStream;
+    removeListener: (event: string, listener: EventListener) => ProcessStream;
+    removeAllListeners: (event?: string) => ProcessStream;
+    setMaxListeners: (n: number) => ProcessStream;
+    getMaxListeners: () => number;
+    listenerCount: (event: string) => number;
+    listeners: (event: string) => EventListener[];
+    rawListeners: (event: string) => EventListener[];
+    prependListener: (event: string, listener: EventListener) => ProcessStream;
+    prependOnceListener: (event: string, listener: EventListener) => ProcessStream;
+    eventNames: () => string[];
+    pause?: () => ProcessStream;
+    resume?: () => ProcessStream;
+    setEncoding?: (encoding: string) => ProcessStream;
+}
+interface ProcessWritableStream extends ProcessStream {
+    write: (data: string | Buffer, encoding?: string, callback?: () => void) => boolean;
+    end?: (data?: string, callback?: () => void) => void;
+}
+interface ProcessReadableStream extends ProcessStream {
+    read?: (size?: number) => string | Buffer | null;
+    setRawMode?: (mode: boolean) => ProcessReadableStream;
+}
+export interface Process {
+    env: ProcessEnv;
+    cwd: () => string;
+    chdir: (directory: string) => void;
+    platform: string;
+    arch: string;
+    version: string;
+    versions: {
+        node: string;
+        v8: string;
+        uv: string;
+    };
+    argv: string[];
+    argv0: string;
+    execPath: string;
+    execArgv: string[];
+    pid: number;
+    ppid: number;
+    exit: (code?: number) => never;
+    nextTick: (callback: (...args: unknown[]) => void, ...args: unknown[]) => void;
+    stdout: ProcessWritableStream;
+    stderr: ProcessWritableStream;
+    stdin: ProcessReadableStream;
+    hrtime: {
+        (time?: [number, number]): [number, number];
+        bigint: () => bigint;
+    };
+    memoryUsage: () => {
+        rss: number;
+        heapTotal: number;
+        heapUsed: number;
+        external: number;
+        arrayBuffers: number;
+    };
+    uptime: () => number;
+    cpuUsage: () => {
+        user: number;
+        system: number;
+    };
+    on: (event: string, listener: EventListener) => Process;
+    once: (event: string, listener: EventListener) => Process;
+    off: (event: string, listener: EventListener) => Process;
+    emit: (event: string, ...args: unknown[]) => boolean;
+    addListener: (event: string, listener: EventListener) => Process;
+    removeListener: (event: string, listener: EventListener) => Process;
+    removeAllListeners: (event?: string) => Process;
+    listeners: (event: string) => EventListener[];
+    listenerCount: (event: string) => number;
+    prependListener: (event: string, listener: EventListener) => Process;
+    prependOnceListener: (event: string, listener: EventListener) => Process;
+    eventNames: () => string[];
+    setMaxListeners: (n: number) => Process;
+    getMaxListeners: () => number;
+    send?: (message: unknown, callback?: (error: Error | null) => void) => boolean;
+    connected?: boolean;
+    _cwdCallCount?: number;
+}
+export declare function createProcess(options?: {
+    cwd?: string;
+    env?: ProcessEnv;
+    onExit?: (code: number) => void;
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+}): Process;
+export declare const process: Process;
+export default process;

package/dist/polyfills/querystring.d.ts

@@ -0,0 +1,15 @@
+export declare function stringify(obj: Record<string, unknown>, sep?: string, eq?: string): string;
+export declare function parse(str: string, sep?: string, eq?: string): Record<string, string | string[]>;
+export declare function escape(str: string): string;
+export declare function unescape(str: string): string;
+export declare function encode(obj: Record<string, unknown>, sep?: string, eq?: string): string;
+export declare function decode(str: string, sep?: string, eq?: string): Record<string, string | string[]>;
+declare const _default: {
+    stringify: typeof stringify;
+    parse: typeof parse;
+    escape: typeof escape;
+    unescape: typeof unescape;
+    encode: typeof encode;
+    decode: typeof decode;
+};
+export default _default;

package/dist/polyfills/readdirp.d.ts

@@ -0,0 +1,18 @@
+import type { MemFS } from "../memfs";
+export declare function initReaddirp(vfs: MemFS): void;
+export interface ReaddirpEntry {
+    path: string;
+    fullPath: string;
+    basename: string;
+    dirent: {
+        isFile(): boolean;
+        isDirectory(): boolean;
+    };
+}
+export default function readdirp(root: string, options?: {
+    fileFilter?: string | string[];
+    directoryFilter?: string | string[];
+    depth?: number;
+}): AsyncIterable<ReaddirpEntry> & {
+    [Symbol.asyncIterator](): AsyncIterableIterator<ReaddirpEntry>;
+};

package/dist/polyfills/readline.d.ts

@@ -0,0 +1,32 @@
+import { EventEmitter } from "./events";
+export declare class Interface extends EventEmitter {
+    private _input;
+    private _output;
+    terminal: boolean;
+    constructor(options?: {
+        input?: unknown;
+        output?: unknown;
+        terminal?: boolean;
+    });
+    question(query: string, cb: (answer: string) => void): void;
+    close(): void;
+    pause(): this;
+    resume(): this;
+    prompt(_preserveCursor?: boolean): void;
+    setPrompt(_prompt: string): void;
+    write(_data: string): void;
+}
+export declare function createInterface(options?: unknown): Interface;
+export declare function clearLine(_stream: unknown, _dir: number, _cb?: () => void): boolean;
+export declare function clearScreenDown(_stream: unknown, _cb?: () => void): boolean;
+export declare function cursorTo(_stream: unknown, _x: number, _y?: number, _cb?: () => void): boolean;
+export declare function moveCursor(_stream: unknown, _dx: number, _dy: number, _cb?: () => void): boolean;
+declare const _default: {
+    Interface: typeof Interface;
+    createInterface: typeof createInterface;
+    clearLine: typeof clearLine;
+    clearScreenDown: typeof clearScreenDown;
+    cursorTo: typeof cursorTo;
+    moveCursor: typeof moveCursor;
+};
+export default _default;