@scelar/nodepod 1.0.1 → 1.0.3

package/dist/polyfills/fs.d.ts

@@ -0,0 +1,274 @@
+import type { MemoryVolume, FileStat, FileWatchHandle, WatchCallback, WatchEventKind } from "../memory-volume";
+export type { FileStat, FileWatchHandle, WatchCallback, WatchEventKind };
+export type PathArg = string | URL;
+export interface Dirent {
+    name: string;
+    parentPath: string;
+    path: string;
+    _dir: boolean;
+    _file: boolean;
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+    isSymbolicLink(): boolean;
+}
+interface DirentConstructor {
+    new (entryName: string, isDir: boolean, isFile: boolean, parentPath?: string): Dirent;
+    (this: any, entryName: string, isDir: boolean, isFile: boolean, parentPath?: string): void;
+    prototype: any;
+}
+export declare const Dirent: DirentConstructor;
+export interface Dir {
+    readonly path: string;
+    _entries: Dirent[];
+    _pos: number;
+    _closed: boolean;
+    readSync(): Dirent | null;
+    read(): Promise<Dirent | null>;
+    read(cb: (err: Error | null, dirent: Dirent | null) => void): void;
+    closeSync(): void;
+    close(): Promise<void>;
+    close(cb: (err: Error | null) => void): void;
+    [Symbol.asyncIterator](): AsyncIterableIterator<Dirent>;
+}
+interface DirConstructor {
+    new (dirPath: string, entries: Dirent[]): Dir;
+    (this: any, dirPath: string, entries: Dirent[]): void;
+    prototype: any;
+}
+export declare const Dir: DirConstructor;
+export declare class StatFs {
+    type: number;
+    bsize: number;
+    blocks: number;
+    bfree: number;
+    bavail: number;
+    files: number;
+    ffree: number;
+    constructor();
+}
+export declare class StatWatcher {
+    private _listeners;
+    private _interval;
+    start(_filename: string, _persistent?: boolean, _interval?: number): void;
+    stop(): void;
+    ref(): this;
+    unref(): this;
+    on(event: string, listener: (...args: unknown[]) => void): this;
+    once(event: string, listener: (...args: unknown[]) => void): this;
+    removeListener(event: string, listener: (...args: unknown[]) => void): this;
+    off(event: string, listener: (...args: unknown[]) => void): this;
+    addListener(event: string, listener: (...args: unknown[]) => void): this;
+    removeAllListeners(event?: string): this;
+    emit(event: string, ...args: unknown[]): boolean;
+    private _emit;
+}
+interface FsConstantsShape {
+    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;
+    O_DSYNC: number;
+    O_NONBLOCK: number;
+    O_NOCTTY: number;
+    S_IFMT: number;
+    S_IFREG: number;
+    S_IFDIR: number;
+    S_IFLNK: number;
+    S_IFCHR: number;
+    S_IFBLK: number;
+    S_IFIFO: number;
+    S_IFSOCK: number;
+    S_IRWXU: number;
+    S_IRUSR: number;
+    S_IWUSR: number;
+    S_IXUSR: number;
+    S_IRWXG: number;
+    S_IRGRP: number;
+    S_IWGRP: number;
+    S_IXGRP: number;
+    S_IRWXO: number;
+    S_IROTH: number;
+    S_IWOTH: number;
+    S_IXOTH: number;
+    COPYFILE_EXCL: number;
+    COPYFILE_FICLONE: number;
+    COPYFILE_FICLONE_FORCE: number;
+    UV_FS_SYMLINK_DIR: number;
+    UV_FS_SYMLINK_JUNCTION: number;
+}
+interface FsPromisesShape {
+    readFile(target: PathArg): Promise<Buffer>;
+    readFile(target: PathArg, enc: "utf8" | "utf-8"): Promise<string>;
+    readFile(target: PathArg, opts: {
+        encoding: "utf8" | "utf-8";
+    }): Promise<string>;
+    writeFile(target: PathArg, data: string | Uint8Array): Promise<void>;
+    appendFile(target: PathArg, data: string | Uint8Array): Promise<void>;
+    stat(target: PathArg): Promise<FileStat>;
+    lstat(target: PathArg): Promise<FileStat>;
+    readdir(target: PathArg): Promise<string[]>;
+    mkdir(target: PathArg, opts?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    unlink(target: PathArg): Promise<void>;
+    rmdir(target: PathArg): Promise<void>;
+    rm(target: PathArg, opts?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    rename(src: PathArg, dest: PathArg): Promise<void>;
+    access(target: PathArg, mode?: number): Promise<void>;
+    realpath(target: PathArg): Promise<string>;
+    copyFile(src: PathArg, dest: PathArg): Promise<void>;
+    symlink(target: PathArg, path: PathArg, type?: string): Promise<void>;
+    readlink(target: PathArg): Promise<string>;
+    link(existingPath: PathArg, newPath: PathArg): Promise<void>;
+    chmod(target: PathArg, mode: number): Promise<void>;
+    chown(target: PathArg, uid: number, gid: number): Promise<void>;
+    lchown(target: PathArg, uid: number, gid: number): Promise<void>;
+    truncate(target: PathArg, len?: number): Promise<void>;
+    utimes(target: PathArg, atime: unknown, mtime: unknown): Promise<void>;
+    lutimes(target: PathArg, atime: unknown, mtime: unknown): Promise<void>;
+    glob(pattern: string | string[], opts?: {
+        cwd?: string;
+        exclude?: string[] | ((p: string) => boolean);
+    }): AsyncIterable<string>;
+}
+export interface FsBridge {
+    readFileSync(target: PathArg): Buffer;
+    readFileSync(target: PathArg, enc: "utf8" | "utf-8"): string;
+    readFileSync(target: PathArg, opts: {
+        encoding: "utf8" | "utf-8";
+    }): string;
+    readFileSync(target: PathArg, opts: {
+        encoding?: null;
+    }): Buffer;
+    writeFileSync(target: PathArg, data: string | Uint8Array): void;
+    appendFileSync(target: PathArg, data: string | Uint8Array): void;
+    existsSync(target: PathArg): boolean;
+    mkdirSync(target: PathArg, opts?: {
+        recursive?: boolean;
+    }): void;
+    readdirSync(target: PathArg): string[];
+    readdirSync(target: PathArg, opts: {
+        withFileTypes: true;
+    }): Dirent[];
+    readdirSync(target: PathArg, opts?: {
+        withFileTypes?: boolean;
+        encoding?: string;
+    } | string): string[] | Dirent[];
+    statSync(target: PathArg): FileStat;
+    lstatSync(target: PathArg): FileStat;
+    fstatSync(fd: number): FileStat;
+    unlinkSync(target: PathArg): void;
+    rmdirSync(target: PathArg): void;
+    renameSync(src: PathArg, dest: PathArg): void;
+    realpathSync: ((target: PathArg) => string) & {
+        native: (target: PathArg) => string;
+    };
+    accessSync(target: PathArg, mode?: number): void;
+    copyFileSync(src: PathArg, dest: PathArg): void;
+    symlinkSync(target: PathArg, path: PathArg, type?: string): void;
+    readlinkSync(target: PathArg): string;
+    linkSync(existingPath: PathArg, newPath: PathArg): void;
+    chmodSync(target: PathArg, mode: number): void;
+    chownSync(target: PathArg, uid: number, gid: number): void;
+    truncateSync(target: PathArg, len?: number): void;
+    openSync(target: string, flags: string | number, mode?: number): number;
+    closeSync(fd: number): void;
+    readSync(fd: number, buf: Buffer | Uint8Array, off: number, len: number, pos: number | null): number;
+    writeSync(fd: number, buf: Buffer | Uint8Array | string, off?: number, len?: number, pos?: number | null): number;
+    ftruncateSync(fd: number, len?: number): void;
+    fsyncSync(fd: number): void;
+    fdatasyncSync(fd: number): void;
+    mkdtempSync(prefix: string): string;
+    rmSync(target: string, opts?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): void;
+    opendirSync(target: unknown): Dir;
+    watch(filename: string, opts?: {
+        persistent?: boolean;
+        recursive?: boolean;
+    }, listener?: WatchCallback): FileWatchHandle;
+    watch(filename: string, listener?: WatchCallback): FileWatchHandle;
+    readFile(target: string, cb: (err: Error | null, data?: Uint8Array) => void): void;
+    readFile(target: string, opts: {
+        encoding: string;
+    }, cb: (err: Error | null, data?: string) => void): void;
+    writeFile(target: string, data: string | Uint8Array, cb: (err: Error | null) => void): void;
+    appendFile(target: string, data: string | Uint8Array, cb: (err: Error | null) => void): void;
+    stat(target: string, cb: (err: Error | null, stats?: FileStat) => void): void;
+    lstat(target: string, cb: (err: Error | null, stats?: FileStat) => void): void;
+    readdir(target: string, cb: (err: Error | null, entries?: string[]) => void): void;
+    mkdir(target: string, opts: {
+        recursive?: boolean;
+    }, cb: (err: Error | null) => void): void;
+    unlink(target: string, cb: (err: Error | null) => void): void;
+    rmdir(target: string, cb: (err: Error | null) => void): void;
+    rename(oldPath: string, newPath: string, cb: (err: Error | null) => void): void;
+    realpath(target: string, cb: (err: Error | null, resolved?: string) => void): void;
+    access(target: string, cb: (err: Error | null) => void): void;
+    access(target: string, mode: number, cb: (err: Error | null) => void): void;
+    symlink(target: string, path: string, cb: (err: Error | null) => void): void;
+    symlink(target: string, path: string, type: string, cb: (err: Error | null) => void): void;
+    readlink(target: string, cb: (err: Error | null, linkTarget?: string) => void): void;
+    link(existingPath: string, newPath: string, cb: (err: Error | null) => void): void;
+    chmod(target: string, mode: number, cb: (err: Error | null) => void): void;
+    chown(target: string, uid: number, gid: number, cb: (err: Error | null) => void): void;
+    createReadStream(target: string, opts?: {
+        encoding?: string;
+        start?: number;
+        end?: number;
+    }): import("./stream").Readable;
+    createWriteStream(target: string, opts?: {
+        encoding?: string;
+        flags?: string;
+    }): import("./stream").Writable;
+    cpSync(src: unknown, dest: unknown, opts?: {
+        recursive?: boolean;
+        force?: boolean;
+        errorOnExist?: boolean;
+    }): void;
+    cp(src: unknown, dest: unknown, optsOrCb?: unknown, cb?: (err: Error | null) => void): void;
+    readvSync(fd: number, buffers: ArrayBufferView[], pos?: number | null): number;
+    readv(fd: number, buffers: ArrayBufferView[], posOrCb?: unknown, cb?: unknown): void;
+    globSync(pattern: string | string[], opts?: {
+        cwd?: string;
+        exclude?: string[] | ((p: string) => boolean);
+    }): string[];
+    glob(pattern: string | string[], optsOrCb?: unknown, cb?: unknown): void;
+    statfsSync(target: unknown, opts?: unknown): StatFs;
+    statfs(target: unknown, optsOrCb?: unknown, cb?: unknown): void;
+    openAsBlob(target: unknown, opts?: {
+        type?: string;
+    }): Promise<Blob>;
+    exists(target: unknown, cb: (exists: boolean) => void): void;
+    lchmodSync(target: unknown, mode: number): void;
+    lchmod(target: unknown, mode: number, cb: (err: Error | null) => void): void;
+    fdatasync(fd: number, cb: (err: Error | null) => void): void;
+    fsync(fd: number, cb: (err: Error | null) => void): void;
+    ftruncate(fd: number, lenOrCb?: unknown, cb?: unknown): void;
+    truncate(target: unknown, lenOrCb?: unknown, cb?: unknown): void;
+    mkdtemp(prefix: string, optsOrCb?: unknown, cb?: unknown): void;
+    StatFs: typeof StatFs;
+    StatWatcher: typeof StatWatcher;
+    promises: FsPromisesShape;
+    constants: FsConstantsShape;
+}
+export declare function buildFileSystemBridge(volume: MemoryVolume, getCwd?: () => string): FsBridge;
+export default buildFileSystemBridge;

package/dist/polyfills/fsevents.d.ts

@@ -0,0 +1,62 @@
+export declare const constants: {
+    kFSEventStreamEventFlagNone: number;
+    kFSEventStreamEventFlagMustScanSubDirs: number;
+    kFSEventStreamEventFlagUserDropped: number;
+    kFSEventStreamEventFlagKernelDropped: number;
+    kFSEventStreamEventFlagEventIdsWrapped: number;
+    kFSEventStreamEventFlagHistoryDone: number;
+    kFSEventStreamEventFlagRootChanged: number;
+    kFSEventStreamEventFlagMount: number;
+    kFSEventStreamEventFlagUnmount: number;
+    kFSEventStreamEventFlagItemCreated: number;
+    kFSEventStreamEventFlagItemRemoved: number;
+    kFSEventStreamEventFlagItemInodeMetaMod: number;
+    kFSEventStreamEventFlagItemRenamed: number;
+    kFSEventStreamEventFlagItemModified: number;
+    kFSEventStreamEventFlagItemFinderInfoMod: number;
+    kFSEventStreamEventFlagItemChangeOwner: number;
+    kFSEventStreamEventFlagItemXattrMod: number;
+    kFSEventStreamEventFlagItemIsFile: number;
+    kFSEventStreamEventFlagItemIsDir: number;
+    kFSEventStreamEventFlagItemIsSymlink: number;
+};
+export declare function watch(_path: string, _handler: (filePath: string, flags: number, id: number) => void): () => Promise<void>;
+export declare function getInfo(filePath: string, flags: number): {
+    event: string;
+    path: string;
+    type: string;
+    changes: {
+        inode: boolean;
+        finder: boolean;
+        access: boolean;
+        xattrs: boolean;
+    };
+    flags: number;
+};
+declare const _default: {
+    watch: typeof watch;
+    getInfo: typeof getInfo;
+    constants: {
+        kFSEventStreamEventFlagNone: number;
+        kFSEventStreamEventFlagMustScanSubDirs: number;
+        kFSEventStreamEventFlagUserDropped: number;
+        kFSEventStreamEventFlagKernelDropped: number;
+        kFSEventStreamEventFlagEventIdsWrapped: number;
+        kFSEventStreamEventFlagHistoryDone: number;
+        kFSEventStreamEventFlagRootChanged: number;
+        kFSEventStreamEventFlagMount: number;
+        kFSEventStreamEventFlagUnmount: number;
+        kFSEventStreamEventFlagItemCreated: number;
+        kFSEventStreamEventFlagItemRemoved: number;
+        kFSEventStreamEventFlagItemInodeMetaMod: number;
+        kFSEventStreamEventFlagItemRenamed: number;
+        kFSEventStreamEventFlagItemModified: number;
+        kFSEventStreamEventFlagItemFinderInfoMod: number;
+        kFSEventStreamEventFlagItemChangeOwner: number;
+        kFSEventStreamEventFlagItemXattrMod: number;
+        kFSEventStreamEventFlagItemIsFile: number;
+        kFSEventStreamEventFlagItemIsDir: number;
+        kFSEventStreamEventFlagItemIsSymlink: number;
+    };
+};
+export default _default;

package/dist/polyfills/http.d.ts

@@ -0,0 +1,215 @@
+import { EventEmitter } from "./events";
+import { Readable, Writable } from "./stream";
+import { TcpSocket, type NetAddress } from "./net";
+export type HttpHandler = (incoming: IncomingMessage, outgoing: ServerResponse) => void | Promise<void>;
+export interface ConnectionOptions {
+    method?: string;
+    path?: string;
+    headers?: Record<string, string | string[]>;
+    hostname?: string;
+    host?: string;
+    port?: number;
+}
+export interface CompletedResponse {
+    statusCode: number;
+    statusMessage: string;
+    headers: Record<string, string>;
+    body: Buffer;
+}
+export interface IncomingMessage extends Readable {
+    httpVersion: string;
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    complete: boolean;
+    headers: Record<string, string | string[] | undefined>;
+    rawHeaders: string[];
+    trailers: Record<string, string | undefined>;
+    rawTrailers: string[];
+    method?: string;
+    url?: string;
+    statusCode?: number;
+    statusMessage?: string;
+    aborted: boolean;
+    socket: TcpSocket;
+    connection: TcpSocket;
+    setTimeout(ms: number, handler?: () => void): this;
+    destroy(err?: Error): this;
+    _injectBody(raw: Buffer | string | null): void;
+}
+export interface IncomingMessageConstructor {
+    new (sock?: TcpSocket): IncomingMessage;
+    (this: any, sock?: TcpSocket): void;
+    prototype: any;
+    build(verb: string, target: string, hdrs: Record<string, string>, payload?: Buffer | string): IncomingMessage;
+}
+export declare const IncomingMessage: IncomingMessageConstructor;
+export interface ServerResponse extends Writable {
+    statusCode: number;
+    statusMessage: string;
+    headersSent: boolean;
+    finished: boolean;
+    sendDate: boolean;
+    socket: TcpSocket | null;
+    req: IncomingMessage;
+    connection: TcpSocket | null;
+    _onComplete(fn: (r: CompletedResponse) => void): void;
+    assignSocket(socket: TcpSocket): void;
+    detachSocket(socket: TcpSocket): void;
+    setHeader(key: string, val: string | string[] | number): this;
+    getHeader(key: string): string | string[] | undefined;
+    getHeaders(): Record<string, string | string[]>;
+    getHeaderNames(): string[];
+    hasHeader(key: string): boolean;
+    appendHeader(key: string, val: string | string[]): this;
+    removeHeader(key: string): void;
+    flushHeaders(): void;
+    writeContinue(): void;
+    writeProcessing(): void;
+    writeEarlyHints(hints: Record<string, string | string[]>, cb?: () => void): void;
+    writeHead(code: number, msgOrHdrs?: any, extraHdrs?: any): this;
+    write(data: any, encOrCb?: any, cb?: any): boolean;
+    end(dataOrCb?: any, encOrCb?: any, cb?: any): this;
+    send(payload: string | Buffer | object): this;
+    setTimeout(ms: number, handler?: () => void): this;
+    json(obj: unknown): this;
+    status(c: number): this;
+    redirect(target: string | number, loc?: string): void;
+    addTrailers(headers: Record<string, string>): void;
+    _collectedBody(): Buffer;
+    _collectedBodyText(): string;
+}
+export interface ServerResponseConstructor {
+    new (incoming: IncomingMessage): ServerResponse;
+    (this: any, incoming: IncomingMessage): void;
+    prototype: any;
+}
+export declare const ServerResponse: ServerResponseConstructor;
+export interface Server extends EventEmitter {
+    listening: boolean;
+    maxHeadersCount: number | null;
+    timeout: number;
+    keepAliveTimeout: number;
+    headersTimeout: number;
+    requestTimeout: number;
+    maxRequestsPerSocket: number | null;
+    listen(portOrOpts?: any, hostOrCb?: any, cb?: any): this;
+    close(cb?: (err?: Error) => void): this;
+    address(): NetAddress | null;
+    setTimeout(ms?: number, handler?: () => void): this;
+    ref(): this;
+    unref(): this;
+    closeAllConnections(): void;
+    closeIdleConnections(): void;
+    dispatchUpgrade(target: string, hdrs: Record<string, string>): {
+        req: IncomingMessage;
+        socket: TcpSocket;
+    };
+    dispatchRequest(verb: string, target: string, hdrs: Record<string, string>, payload?: Buffer | string): Promise<CompletedResponse>;
+}
+export interface ServerConstructor {
+    new (optsOrHandler?: Record<string, unknown> | HttpHandler, handler?: HttpHandler): Server;
+    (this: any, optsOrHandler?: Record<string, unknown> | HttpHandler, handler?: HttpHandler): void;
+    prototype: any;
+}
+export declare const Server: ServerConstructor;
+export declare function createServer(optsOrHandler?: Record<string, unknown> | HttpHandler, handler?: HttpHandler): Server;
+export declare const STATUS_CODES: Record<number, string>;
+export declare const METHODS: string[];
+export interface ClientRequest extends Writable {
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    finished: boolean;
+    aborted: boolean;
+    reusedSocket: boolean;
+    maxHeadersCount: number | null;
+    readonly socket: TcpSocket;
+    readonly connection: TcpSocket;
+    setHeader(k: string, v: string): void;
+    getHeader(k: string): string | undefined;
+    removeHeader(k: string): void;
+    write(chunk: any, encOrCb?: any, cb?: any): boolean;
+    end(dataOrCb?: any, encOrCb?: any, cb?: any): this;
+    abort(): void;
+    setTimeout(ms: number, handler?: () => void): this;
+    flushHeaders(): void;
+    setNoDelay(noDelay?: boolean): void;
+    setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
+}
+export interface ClientRequestConstructor {
+    new (opts: ConnectionOptions, proto?: "http" | "https"): ClientRequest;
+    (this: any, opts: ConnectionOptions, proto?: "http" | "https"): void;
+    prototype: any;
+}
+export declare const ClientRequest: ClientRequestConstructor;
+export declare function request(first: string | URL | ConnectionOptions, second?: ConnectionOptions | ((r: IncomingMessage) => void), third?: (r: IncomingMessage) => void): ClientRequest;
+export declare function get(first: string | URL | ConnectionOptions, second?: ConnectionOptions | ((r: IncomingMessage) => void), third?: (r: IncomingMessage) => void): ClientRequest;
+export declare function _buildClientRequest(first: string | URL | ConnectionOptions, second: ConnectionOptions | ((r: IncomingMessage) => void) | undefined, third: ((r: IncomingMessage) => void) | undefined, proto: "http" | "https"): ClientRequest;
+export type RegistryHook = (port: number, srv: Server) => void;
+export declare function getServer(port: number): Server | undefined;
+export declare function getAllServers(): Map<number, Server>;
+export declare function closeAllServers(): void;
+export declare function closeServersByPid(pid: number): void;
+export declare function getServerOwner(port: number): number | undefined;
+export declare function setServerListenCallback(fn: RegistryHook | null): void;
+export declare function setServerCloseCallback(fn: ((port: number) => void) | null): void;
+export interface AgentConfig {
+    keepAlive?: boolean;
+    keepAliveMsecs?: number;
+    maxSockets?: number;
+    maxTotalSockets?: number;
+    maxFreeSockets?: number;
+    scheduling?: "fifo" | "lifo";
+    timeout?: number;
+}
+export interface Agent extends EventEmitter {
+    maxSockets: number;
+    maxFreeSockets: number;
+    maxTotalSockets: number;
+    sockets: Record<string, TcpSocket[]>;
+    freeSockets: Record<string, TcpSocket[]>;
+    requests: Record<string, IncomingMessage[]>;
+    options: AgentConfig;
+    createConnection(cfg: Record<string, unknown>, done?: (err: Error | null, sock: TcpSocket) => void): TcpSocket;
+    getName(o: {
+        host?: string;
+        port?: number;
+        localAddress?: string;
+    }): string;
+    addRequest(r: ClientRequest, o: Record<string, unknown>): void;
+    destroy(): void;
+}
+export interface AgentConstructor {
+    new (cfg?: AgentConfig): Agent;
+    (this: any, cfg?: AgentConfig): void;
+    prototype: any;
+}
+export declare const Agent: AgentConstructor;
+export declare const globalAgent: Agent;
+export declare function decodeFrame(raw: Uint8Array): {
+    op: number;
+    data: Uint8Array;
+    consumed: number;
+} | null;
+export declare function encodeFrame(op: number, payload: Uint8Array, masked: boolean): Uint8Array;
+declare const _default: {
+    Server: ServerConstructor;
+    IncomingMessage: IncomingMessageConstructor;
+    ServerResponse: ServerResponseConstructor;
+    ClientRequest: ClientRequestConstructor;
+    createServer: typeof createServer;
+    request: typeof request;
+    get: typeof get;
+    STATUS_CODES: Record<number, string>;
+    METHODS: string[];
+    getServer: typeof getServer;
+    getAllServers: typeof getAllServers;
+    setServerListenCallback: typeof setServerListenCallback;
+    setServerCloseCallback: typeof setServerCloseCallback;
+    _buildClientRequest: typeof _buildClientRequest;
+    Agent: AgentConstructor;
+    globalAgent: Agent;
+    decodeFrame: typeof decodeFrame;
+    encodeFrame: typeof encodeFrame;
+};
+export default _default;

package/dist/polyfills/http2.d.ts

@@ -0,0 +1,119 @@
+import { EventEmitter } from "./events";
+export interface Http2Session extends EventEmitter {
+    close(done?: () => void): void;
+    destroy(_err?: Error, _code?: number): void;
+    readonly destroyed: boolean;
+    readonly encrypted: boolean;
+    readonly closed: boolean;
+    ping(_cb: (err: Error | null, dur: number, buf: Uint8Array) => void): boolean;
+    ref(): void;
+    unref(): void;
+    setTimeout(_ms: number, _cb?: () => void): void;
+}
+export declare const Http2Session: {
+    new (): Http2Session;
+    prototype: any;
+};
+export interface ClientHttp2Session extends Http2Session {
+}
+export declare const ClientHttp2Session: {
+    new (): ClientHttp2Session;
+    prototype: any;
+};
+export interface ServerHttp2Session extends Http2Session {
+}
+export declare const ServerHttp2Session: {
+    new (): ServerHttp2Session;
+    prototype: any;
+};
+export interface Http2Stream extends EventEmitter {
+    close(_code?: number, _cb?: () => void): void;
+    readonly id: number;
+    readonly pending: boolean;
+    readonly destroyed: boolean;
+    readonly closed: boolean;
+    priority(_opts: unknown): void;
+    setTimeout(_ms: number, _cb?: () => void): void;
+    end(_data?: unknown, _enc?: string, _cb?: () => void): void;
+}
+export declare const Http2Stream: {
+    new (): Http2Stream;
+    prototype: any;
+};
+export interface Http2ServerRequest extends EventEmitter {
+}
+export declare const Http2ServerRequest: {
+    new (): Http2ServerRequest;
+    prototype: any;
+};
+export interface Http2ServerResponse extends EventEmitter {
+    writeHead(_code: number, _hdrs?: object): this;
+    end(_data?: unknown): void;
+}
+export declare const Http2ServerResponse: {
+    new (): Http2ServerResponse;
+    prototype: any;
+};
+export declare function createServer(_opts?: unknown, _handler?: unknown): EventEmitter;
+export declare function createSecureServer(_opts?: unknown, _handler?: unknown): EventEmitter;
+export declare function connect(_authority: string, _opts?: unknown, _cb?: () => void): ClientHttp2Session;
+export declare const constants: {
+    NGHTTP2_SESSION_SERVER: number;
+    NGHTTP2_SESSION_CLIENT: number;
+    HTTP2_HEADER_STATUS: string;
+    HTTP2_HEADER_METHOD: string;
+    HTTP2_HEADER_AUTHORITY: string;
+    HTTP2_HEADER_SCHEME: string;
+    HTTP2_HEADER_PATH: string;
+    HTTP_STATUS_OK: number;
+    HTTP_STATUS_NOT_FOUND: number;
+};
+export declare function getDefaultSettings(): object;
+export declare function getPackedSettings(_settings?: object): Uint8Array;
+export declare function getUnpackedSettings(_buf: Uint8Array): object;
+export declare const sensitiveHeaders: unique symbol;
+declare const _default: {
+    Http2Session: {
+        new (): Http2Session;
+        prototype: any;
+    };
+    ClientHttp2Session: {
+        new (): ClientHttp2Session;
+        prototype: any;
+    };
+    ServerHttp2Session: {
+        new (): ServerHttp2Session;
+        prototype: any;
+    };
+    Http2Stream: {
+        new (): Http2Stream;
+        prototype: any;
+    };
+    Http2ServerRequest: {
+        new (): Http2ServerRequest;
+        prototype: any;
+    };
+    Http2ServerResponse: {
+        new (): Http2ServerResponse;
+        prototype: any;
+    };
+    createServer: typeof createServer;
+    createSecureServer: typeof createSecureServer;
+    connect: typeof connect;
+    constants: {
+        NGHTTP2_SESSION_SERVER: number;
+        NGHTTP2_SESSION_CLIENT: number;
+        HTTP2_HEADER_STATUS: string;
+        HTTP2_HEADER_METHOD: string;
+        HTTP2_HEADER_AUTHORITY: string;
+        HTTP2_HEADER_SCHEME: string;
+        HTTP2_HEADER_PATH: string;
+        HTTP_STATUS_OK: number;
+        HTTP_STATUS_NOT_FOUND: number;
+    };
+    getDefaultSettings: typeof getDefaultSettings;
+    getPackedSettings: typeof getPackedSettings;
+    getUnpackedSettings: typeof getUnpackedSettings;
+    sensitiveHeaders: symbol;
+};
+export default _default;

package/dist/polyfills/https.d.ts

@@ -0,0 +1,24 @@
+import { Server, IncomingMessage, ServerResponse, ClientRequest, createServer, STATUS_CODES, METHODS, getServer, getAllServers, setServerListenCallback, setServerCloseCallback, Agent, globalAgent } from './http';
+import type { ConnectionOptions, AgentConfig } from './http';
+export { Server, IncomingMessage, ServerResponse, ClientRequest, createServer, STATUS_CODES, METHODS, getServer, getAllServers, setServerListenCallback, setServerCloseCallback, Agent, globalAgent, };
+export type { ConnectionOptions, AgentConfig };
+export declare function request(target: string | URL | ConnectionOptions, optsOrCb?: ConnectionOptions | ((res: IncomingMessage) => void), cb?: (res: IncomingMessage) => void): ClientRequest;
+export declare function get(target: string | URL | ConnectionOptions, optsOrCb?: ConnectionOptions | ((res: IncomingMessage) => void), cb?: (res: IncomingMessage) => void): ClientRequest;
+declare const _default: {
+    Server: import("./http").ServerConstructor;
+    IncomingMessage: import("./http").IncomingMessageConstructor;
+    ServerResponse: import("./http").ServerResponseConstructor;
+    ClientRequest: import("./http").ClientRequestConstructor;
+    createServer: typeof createServer;
+    request: typeof request;
+    get: typeof get;
+    STATUS_CODES: Record<number, string>;
+    METHODS: string[];
+    getServer: typeof getServer;
+    getAllServers: typeof getAllServers;
+    setServerListenCallback: typeof setServerListenCallback;
+    setServerCloseCallback: typeof setServerCloseCallback;
+    Agent: import("./http").AgentConstructor;
+    globalAgent: Agent;
+};
+export default _default;