@volter/tabnode 0.2.14-volter.88

package/dist/node-lib/buffer-module.d.ts

@@ -0,0 +1,51 @@
+/** Node's `Buffer`, as the engine's own parts use it. */
+export interface BufferConstructor {
+    new (size: number): NodeBuffer;
+    from(value: unknown, encodingOrOffset?: unknown, length?: number): NodeBuffer;
+    alloc(size: number, fill?: unknown, encoding?: string): NodeBuffer;
+    allocUnsafe(size: number): NodeBuffer;
+    allocUnsafeSlow(size: number): NodeBuffer;
+    concat(list: readonly Uint8Array[], totalLength?: number): NodeBuffer;
+    isBuffer(value: unknown): boolean;
+    isEncoding(encoding: string): boolean;
+    byteLength(value: unknown, encoding?: string): number;
+    compare(a: Uint8Array, b: Uint8Array): number;
+    poolSize: number;
+    prototype: NodeBuffer;
+}
+/** The whole of Node's `buffer` module object. */
+export interface BufferModule {
+    Buffer: BufferConstructor;
+    SlowBuffer: (size: number) => Uint8Array;
+    kMaxLength: number;
+    kStringMaxLength: number;
+    INSPECT_MAX_BYTES: number;
+    constants: {
+        MAX_LENGTH: number;
+        MAX_STRING_LENGTH: number;
+    };
+    atob(input: string): string;
+    btoa(input: string): string;
+    isUtf8(value: Uint8Array): boolean;
+    isAscii(value: Uint8Array): boolean;
+    transcode?: (source: Uint8Array, from: string, to: string) => Uint8Array;
+    Blob: unknown;
+    File: unknown;
+    resolveObjectURL: unknown;
+}
+/** Node's own `buffer.js`, built by the loader on the first property read. */
+export declare const bufferModule: BufferModule;
+/**
+ * Node's `Buffer`, which is the one every part of the engine uses. The type
+ * is `Uint8Array` with Node's own methods on it: TypeScript's `Buffer` comes
+ * from `@types/node` and describes the host's, not this one.
+ */
+/**
+ * The type of one of these buffers. At runtime it is Node's own `Buffer`, so
+ * the type is the one `@types/node` describes: every part of the engine was
+ * written against that name and means this object by it.
+ */
+export type NodeBuffer = Buffer;
+export declare const Buffer: BufferConstructor;
+export default bufferModule;
+//# sourceMappingURL=buffer-module.d.ts.map

package/dist/node-lib/buffer-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-module.d.ts","sourceRoot":"","sources":["../../src/node-lib/buffer-module.ts"],"names":[],"mappings":"AAkBA,yDAAyD;AACzD,MAAM,WAAW,iBAAiB;IAChC,KAAK,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IAC/B,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,gBAAgB,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAC9E,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IACnE,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IACtC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IAC1C,MAAM,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IACtE,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IAClC,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACtC,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACtD,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,UAAU,CAAC;CACvB;AAED,kDAAkD;AAClD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,CAAC;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7D,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC;IACnC,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC;IACpC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,UAAU,CAAC;IACzE,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,8EAA8E;AAC9E,eAAO,MAAM,YAAY,cAAqC,CAAC;AAE/D;;;;GAIG;AACH;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAEhC,eAAO,MAAM,MAAM,mBAAoD,CAAC;AAExE,eAAe,YAAY,CAAC"}

package/dist/node-lib/child-process-module.d.ts

@@ -0,0 +1,26 @@
+/** Node's `child_process` module object, as a program receives it. */
+export interface ChildProcessModule {
+    ChildProcess: new () => unknown;
+    spawn: (...args: unknown[]) => unknown;
+    spawnSync: (...args: unknown[]) => unknown;
+    exec: (...args: unknown[]) => unknown;
+    execSync: (...args: unknown[]) => unknown;
+    execFile: (...args: unknown[]) => unknown;
+    execFileSync: (...args: unknown[]) => unknown;
+    fork: (...args: unknown[]) => unknown;
+    _forkChild: (fd: number, serializationMode: string) => void;
+}
+/** The loaded module: Node's own `child_process.js`, evaluated once. */
+export declare const childProcessModule: ChildProcessModule;
+/**
+ * `setupChannel` from Node's `internal/child_process.js`: what wires one end
+ * of an IPC channel onto a process object. The parent's end is wired by
+ * `ChildProcess.prototype.spawn`; the child's is wired by the engine's `node`
+ * command, which is this engine's `lib/internal/process/pre_execution.js`.
+ */
+export interface ChannelControl {
+    refCounted(): void;
+    unrefCounted(): void;
+}
+export declare function setupChannel(target: unknown, channel: unknown, serializationMode: string): ChannelControl;
+//# sourceMappingURL=child-process-module.d.ts.map

package/dist/node-lib/child-process-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-process-module.d.ts","sourceRoot":"","sources":["../../src/node-lib/child-process-module.ts"],"names":[],"mappings":"AAyBA,sEAAsE;AACtE,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,UAAU,OAAO,CAAC;IAChC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IACvC,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IAC3C,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IACtC,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IAC1C,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IAC1C,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IAC9C,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IACtC,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7D;AAED,wEAAwE;AACxE,eAAO,MAAM,kBAAkB,EAA8C,kBAAkB,CAAC;AAEhG;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,UAAU,IAAI,IAAI,CAAC;IACnB,YAAY,IAAI,IAAI,CAAC;CACtB;AAID,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,GAAG,cAAc,CAGzG"}

package/dist/node-lib/events-module.d.ts

@@ -0,0 +1,58 @@
+/** A listener, as the engine's own shims type one. */
+export type EventListener = (...args: any[]) => void;
+/** Node's `EventEmitter`, as every part of the engine reads one. */
+export interface EventEmitter {
+    addListener(event: string | symbol, listener: EventListener): this;
+    on(event: string | symbol, listener: EventListener): this;
+    once(event: string | symbol, listener: EventListener): this;
+    removeListener(event: string | symbol, listener: EventListener): this;
+    off(event: string | symbol, listener: EventListener): this;
+    removeAllListeners(event?: string | symbol): this;
+    setMaxListeners(n: number): this;
+    getMaxListeners(): number;
+    listeners(event: string | symbol): Array<EventListener>;
+    rawListeners(event: string | symbol): Array<EventListener>;
+    emit(event: string | symbol, ...args: unknown[]): boolean;
+    listenerCount(event: string | symbol, listener?: EventListener): number;
+    prependListener(event: string | symbol, listener: EventListener): this;
+    prependOnceListener(event: string | symbol, listener: EventListener): this;
+    eventNames(): Array<string | symbol>;
+}
+/** The whole of Node's `events` module object. */
+export interface EventsModule {
+    EventEmitter: new (options?: {
+        captureRejections?: boolean;
+    }) => EventEmitter;
+    EventEmitterAsyncResource: unknown;
+    once(emitter: unknown, name: string | symbol, options?: unknown): Promise<unknown[]>;
+    on(emitter: unknown, name: string | symbol, options?: unknown): AsyncIterableIterator<unknown[]>;
+    getEventListeners(emitter: unknown, name: string | symbol): Array<EventListener>;
+    getMaxListeners(emitter: unknown): number;
+    setMaxListeners(n?: number, ...emitters: unknown[]): void;
+    addAbortListener(signal: AbortSignal, listener: EventListener): Disposable;
+    listenerCount(emitter: unknown, type: string | symbol): number;
+    init: unknown;
+    captureRejectionSymbol: symbol;
+    errorMonitor: symbol;
+    usingDomains: boolean;
+    defaultMaxListeners: number;
+}
+/**
+ * The class itself, named before the loader can build it: the engine's own
+ * files construct and subclass it, and `./lazy.ts` says why a name here
+ * stands for the thing rather than being it.
+ */
+export declare const EventEmitter: new (options?: {
+    captureRejections?: boolean;
+}) => EventEmitter;
+/**
+ * The module, which in Node IS the class: `events.js` ends with
+ * `module.exports = EventEmitter` and hangs `once`, `on`, `getEventListeners`
+ * and the rest off it, so `require("events") === require("events")
+ * .EventEmitter` and `new (require("events"))()` is an emitter. One object
+ * here too, for the same reason -- a guest that constructs the module got
+ * "not a constructor" when this was a separate object standing beside it.
+ */
+export declare const eventsModule: EventsModule;
+export default eventsModule;
+//# sourceMappingURL=events-module.d.ts.map

package/dist/node-lib/events-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-module.d.ts","sourceRoot":"","sources":["../../src/node-lib/events-module.ts"],"names":[],"mappings":"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"}

package/dist/node-lib/fs-module.d.ts

@@ -0,0 +1,5 @@
+export declare const fsModule: Record<string, unknown>;
+export declare const fsPromisesModule: Record<string, unknown>;
+export declare function fsModuleFor(process: object): unknown;
+export default fsModule;
+//# sourceMappingURL=fs-module.d.ts.map

package/dist/node-lib/fs-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-module.d.ts","sourceRoot":"","sources":["../../src/node-lib/fs-module.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,QAAQ,yBAA4C,CAAC;AAClE,eAAO,MAAM,gBAAgB,yBAA8D,CAAC;AAS5F,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAYpD;AAED,eAAe,QAAQ,CAAC"}

package/dist/node-lib/http-bridge.d.ts

@@ -0,0 +1,43 @@
+import type { Socket } from './net-module';
+/** What a page request answers with, the shape the bridge has always answered. */
+export interface ResponseData {
+    statusCode: number;
+    /** Absent where the server sent none, as Node's `res.statusMessage` may be. */
+    statusMessage?: string;
+    /** A header's value is a string, or the strings of a header sent more than once, as Node's `res.getHeaders()` answers. */
+    headers: Record<string, string | string[]>;
+    /** Bytes, as a host's own server answers them; Node's Buffer is a Uint8Array. Absent where there is no body. */
+    body?: Uint8Array;
+}
+/** Whether any guest is listening on this port right now. */
+export declare function __listening(port: number): boolean;
+/**
+ * A request to a guest's server, answered whole. The connection is this
+ * engine's own loopback: the guest's server accepts it, and nothing leaves
+ * the tab.
+ */
+export declare function __requestOverLoopback(port: number, method: string, url: string, headers: Record<string, string>, body?: Buffer): Promise<ResponseData>;
+/**
+ * The same request, answered as it arrives: the head first, then each chunk
+ * the server writes, then the end. This is what the service worker streams
+ * to the page.
+ */
+export declare function __streamOverLoopback(port: number, method: string, url: string, headers: Record<string, string>, body: Buffer | undefined, onStart: (statusCode: number, statusMessage: string, headers: Record<string, string>) => void, onChunk: (chunk: Uint8Array) => void, onEnd: () => void): Promise<void>;
+/** What an upgrade answered with: the 101 and the socket the page now owns. */
+export interface UpgradeResult {
+    statusCode: number;
+    /** Absent where the server sent none, as Node's `res.statusMessage` may be. */
+    statusMessage?: string;
+    headers: Record<string, string>;
+    socket: Socket | null;
+}
+/**
+ * An `Upgrade` request through the same door. On a 101 the connection stops
+ * being HTTP and becomes the two ends of a socket: the guest's server holds
+ * one -- its `upgrade` listener was handed it by Node's own `http` -- and the
+ * page holds this one, which is exactly what the real `ws` needs on both
+ * sides. The bytes llhttp had already read past the head are pushed back
+ * onto this end, because they are the first frame.
+ */
+export declare function __upgradeOverLoopback(port: number, method: string, url: string, headers: Record<string, string>): Promise<UpgradeResult>;
+//# sourceMappingURL=http-bridge.d.ts.map

package/dist/node-lib/http-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-bridge.d.ts","sourceRoot":"","sources":["../../src/node-lib/http-bridge.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAK3C,kFAAkF;AAClF,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,+EAA+E;IAC/E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,0HAA0H;IAC1H,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAC3C,gHAAgH;IAChH,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED,6DAA6D;AAC7D,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AA8GD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,GACxF,OAAO,CAAC,YAAY,CAAC,CAmCvB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,EACpG,OAAO,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,EAC7F,OAAO,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,EACpC,KAAK,EAAE,MAAM,IAAI,GAChB,OAAO,CAAC,IAAI,CAAC,CAgCf;AAED,+EAA+E;AAC/E,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,+EAA+E;IAC/E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACzE,OAAO,CAAC,aAAa,CAAC,CA2CxB"}

package/dist/node-lib/http-module.d.ts

@@ -0,0 +1,35 @@
+/** The whole of Node's `http` module object, as the engine's parts read it. */
+export interface HttpModule {
+    Agent: new (options?: unknown) => unknown;
+    ClientRequest: new (...args: unknown[]) => unknown;
+    IncomingMessage: new (socket?: unknown) => unknown;
+    OutgoingMessage: new () => unknown;
+    Server: new (options?: unknown, listener?: unknown) => unknown;
+    ServerResponse: new (request: unknown) => unknown;
+    createServer(options?: unknown, listener?: unknown): unknown;
+    request(...args: unknown[]): unknown;
+    get(...args: unknown[]): unknown;
+    globalAgent: unknown;
+    METHODS: string[];
+    STATUS_CODES: Record<number, string>;
+    maxHeaderSize: number;
+    setMaxIdleHTTPParsers(max: number): void;
+    validateHeaderName(name: string, label?: string): void;
+    validateHeaderValue(name: string, value: unknown): void;
+}
+export declare const httpModule: HttpModule;
+export declare const httpsModule: HttpModule;
+/**
+ * The five `_http_*` modules, which Node lets a program require by name --
+ * they are legacy public names, not internals, and a program that subclasses
+ * `_http_outgoing`'s `OutgoingMessage` or reads `_http_server`'s `STATUS_CODES`
+ * reaches them that way.
+ */
+export declare const httpCommonModule: Record<string, unknown>;
+export declare const httpIncomingModule: Record<string, unknown>;
+export declare const httpOutgoingModule: Record<string, unknown>;
+export declare const httpServerModule: Record<string, unknown>;
+export declare const httpClientModule: Record<string, unknown>;
+export declare const httpAgentModule: Record<string, unknown>;
+export default httpModule;
+//# sourceMappingURL=http-module.d.ts.map

package/dist/node-lib/http-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-module.d.ts","sourceRoot":"","sources":["../../src/node-lib/http-module.ts"],"names":[],"mappings":"AAgBA,+EAA+E;AAC/E,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,KAAK,OAAO,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;IAC1C,aAAa,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IACnD,eAAe,EAAE,KAAK,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;IACnD,eAAe,EAAE,UAAU,OAAO,CAAC;IACnC,MAAM,EAAE,KAAK,OAAO,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;IAC/D,cAAc,EAAE,KAAK,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC;IAClD,YAAY,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IAC7D,OAAO,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;IACrC,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;IACjC,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvD,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CACzD;AAED,eAAO,MAAM,UAAU,YAAiC,CAAC;AACzD,eAAO,MAAM,WAAW,YAAkC,CAAC;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,yBAAsD,CAAC;AACpF,eAAO,MAAM,kBAAkB,yBAAwD,CAAC;AACxF,eAAO,MAAM,kBAAkB,yBAAwD,CAAC;AACxF,eAAO,MAAM,gBAAgB,yBAAsD,CAAC;AACpF,eAAO,MAAM,gBAAgB,yBAAsD,CAAC;AACpF,eAAO,MAAM,eAAe,yBAAqD,CAAC;AAElF,eAAe,UAAU,CAAC"}

package/dist/node-lib/internals/addresses.d.ts

@@ -0,0 +1,40 @@
+export declare class SocketAddress {
+    constructor(options?: {
+        address?: string;
+        port?: number;
+        family?: string;
+        flowlabel?: number;
+    });
+    get address(): string;
+    get port(): number;
+    get family(): string;
+    get flowlabel(): number;
+    toJSON(): {
+        address: string;
+        port: number;
+        family: string;
+        flowlabel: number;
+    };
+    static isSocketAddress(value: unknown): value is SocketAddress;
+    /** Node's `SocketAddress.parse('host:port')`; null for anything it cannot read. */
+    static parse(input: string): SocketAddress | undefined;
+}
+export declare class BlockList {
+    private entries;
+    private static familyOf;
+    private static addressOf;
+    addAddress(address: string | SocketAddress, family?: string): void;
+    addRange(start: string | SocketAddress, end: string | SocketAddress, family?: string): void;
+    addSubnet(network: string | SocketAddress, prefix: number, family?: string): void;
+    check(address: string | SocketAddress, family?: string): boolean;
+    get rules(): string[];
+    static isBlockList(value: unknown): value is BlockList;
+}
+export declare const internalSocketAddress: {
+    SocketAddress: typeof SocketAddress;
+    kSocketAddressHandle: symbol;
+};
+export declare const internalBlockList: {
+    BlockList: typeof BlockList;
+};
+//# sourceMappingURL=addresses.d.ts.map

package/dist/node-lib/internals/addresses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.d.ts","sourceRoot":"","sources":["../../../src/node-lib/internals/addresses.ts"],"names":[],"mappings":"AAiCA,qBAAa,aAAa;gBACZ,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAO;IAmBlG,IAAI,OAAO,IAAI,MAAM,CAAkE;IACvF,IAAI,IAAI,IAAI,MAAM,CAA+D;IACjF,IAAI,MAAM,IAAI,MAAM,CAAiE;IACrF,IAAI,SAAS,IAAI,MAAM,CAAoE;IAE3F,MAAM,IAAI;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAI9E,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa;IAI9D,mFAAmF;IACnF,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;CAUvD;AAOD,qBAAa,SAAS;IACpB,OAAO,CAAC,OAAO,CAAc;IAE7B,OAAO,CAAC,MAAM,CAAC,QAAQ;IAQvB,OAAO,CAAC,MAAM,CAAC,SAAS;IASxB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAMlE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAY3F,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAWjF,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO;IAehE,IAAI,KAAK,IAAI,MAAM,EAAE,CAEpB;IAED,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS;CAGvD;AAED,eAAO,MAAM,qBAAqB;;;CAA0E,CAAC;AAC7G,eAAO,MAAM,iBAAiB;;CAAgB,CAAC"}

package/dist/node-lib/internals/buffer-and-streams.d.ts

@@ -0,0 +1,96 @@
+import { createBlobFromFilePath } from '../binding/blob';
+/** Node's `once(fn)`: the same function, run at most once. */
+export declare function once<F extends (...args: never[]) => unknown>(callback: F, options?: {
+    preserveReturnValue?: boolean;
+}): F;
+/**
+ * Node's `defineLazyProperties`: each key becomes a getter that loads the
+ * named module on first read. `buffer.js` hangs `Blob`, `File` and
+ * `resolveObjectURL` off its exports this way, so a program that never asks
+ * for a Blob never loads one.
+ */
+export declare function defineLazyProperties(target: object, id: string, keys: string[], enumerable?: boolean): void;
+/** Node's `lazyDOMException`: the realm's own, which every realm here has. */
+export declare function lazyDOMException(message: string, name: string): Error;
+/**
+ * Node's `encodingsMap`: the number each encoding is to the buffer binding,
+ * from `enum encoding` in `node_buffer.h`. Only `buffer.js` and the binding
+ * exchange them.
+ */
+export declare const encodingsMap: Record<string, number>;
+/** Node's `customInspectSymbol` and the symbol `Buffer.isEncoding` is marked with. */
+export declare const customInspectSymbol: unique symbol;
+export declare const kIsEncodingSymbol: unique symbol;
+/** `internal/abort_controller`: the realm's own, which is the web's. */
+export declare const internalAbortController: {
+    AbortController: {
+        new (): AbortController;
+        prototype: AbortController;
+    };
+    AbortSignal: {
+        new (): AbortSignal;
+        prototype: AbortSignal;
+        abort(reason?: any): AbortSignal;
+        any(signals: AbortSignal[]): AbortSignal;
+        timeout(milliseconds: number): AbortSignal;
+    };
+    aborted: (signal: AbortSignal) => boolean;
+};
+/**
+ * `internal/blob` and `internal/file`: the realm's own `Blob` and `File`,
+ * which every realm the engine runs in has. `resolveObjectURL` answers
+ * nothing, because the engine registers no blob URLs of its own.
+ * `createBlobFromFilePath` is the blob binding's, which `fs.openAsBlob` is.
+ */
+export declare const internalBlob: {
+    Blob: {
+        new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+        prototype: Blob;
+    };
+    isBlob: (value: unknown) => boolean;
+    resolveObjectURL: () => undefined;
+    createBlobFromFilePath: typeof createBlobFromFilePath;
+};
+export declare const internalFile: {
+    File: unknown;
+};
+/**
+ * `internal/webstreams/adapters`: what `Readable.toWeb`, `Readable.fromWeb`,
+ * `Writable.toWeb`, `Writable.fromWeb` and the `Duplex` pair reach for.
+ *
+ * Node's own is pure JavaScript over Node's own `ReadableStream` and
+ * `WritableStream`, which are themselves a port of the web's. A tab HAS the
+ * web's, so this is the one place where the platform is the implementation
+ * rather than a thing to port: each adapter is written against the realm's
+ * `ReadableStream`/`WritableStream`, which is what a server bundle turning a
+ * `node:http` request into a `Request` gets. The engine carried these same
+ * six bodies as patches over its hand-written streams; they move here,
+ * unchanged in behaviour, now that the streams above them are Node's.
+ *
+ * What is not here is what Node's adapters add on top: a byte-mode
+ * `ReadableStream` with BYOB readers, and the `AbortSignal` options. Named,
+ * not guessed at.
+ */
+type AnyStream = Record<string, (...args: never[]) => unknown> & Record<string, unknown>;
+declare function newReadableStreamFromStreamReadable(readable: AnyStream): ReadableStream;
+declare function newStreamReadableFromReadableStream(web: ReadableStream): AnyStream;
+declare function newWritableStreamFromStreamWritable(writable: AnyStream): WritableStream;
+declare function newStreamWritableFromWritableStream(web: WritableStream): AnyStream;
+declare function newReadableWritablePairFromDuplex(duplex: AnyStream): {
+    readable: ReadableStream;
+    writable: WritableStream;
+};
+declare function newStreamDuplexFromReadableWritablePair(pair: {
+    readable: ReadableStream;
+    writable: WritableStream;
+}): AnyStream;
+export declare const internalWebStreamsAdapters: {
+    newReadableStreamFromStreamReadable: typeof newReadableStreamFromStreamReadable;
+    newStreamReadableFromReadableStream: typeof newStreamReadableFromReadableStream;
+    newWritableStreamFromStreamWritable: typeof newWritableStreamFromStreamWritable;
+    newStreamWritableFromWritableStream: typeof newStreamWritableFromWritableStream;
+    newReadableWritablePairFromDuplex: typeof newReadableWritablePairFromDuplex;
+    newStreamDuplexFromReadableWritablePair: typeof newStreamDuplexFromReadableWritablePair;
+};
+export {};
+//# sourceMappingURL=buffer-and-streams.d.ts.map

package/dist/node-lib/internals/buffer-and-streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-and-streams.d.ts","sourceRoot":"","sources":["../../../src/node-lib/internals/buffer-and-streams.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,8DAA8D;AAC9D,wBAAgB,IAAI,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EAC1D,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE;IAAE,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAE,GACvD,CAAC,CAWH;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,UAAU,UAAO,GAAG,IAAI,CAqBxG;AAED,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,KAAK,CAIrE;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAG/C,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,mBAAmB,eAA2C,CAAC;AAC5E,eAAO,MAAM,iBAAiB,eAA8B,CAAC;AAE7D,wEAAwE;AACxE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;sBAGhB,WAAW,KAAG,OAAO;CACxC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY;;;;;oBAEP,OAAO,KAAG,OAAO;4BACX,SAAS;;CAEhC,CAAC;AACF,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAMzF,iBAAS,mCAAmC,CAAC,QAAQ,EAAE,SAAS,GAAG,cAAc,CAWhF;AAQD,iBAAS,mCAAmC,CAAC,GAAG,EAAE,cAAc,GAAG,SAAS,CAe3E;AAED,iBAAS,mCAAmC,CAAC,QAAQ,EAAE,SAAS,GAAG,cAAc,CAUhF;AAED,iBAAS,mCAAmC,CAAC,GAAG,EAAE,cAAc,GAAG,SAAS,CAc3E;AAED,iBAAS,iCAAiC,CAAC,MAAM,EAAE,SAAS,GAAG;IAAE,QAAQ,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,cAAc,CAAA;CAAE,CAKpH;AAED,iBAAS,uCAAuC,CAAC,IAAI,EAAE;IAAE,QAAQ,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,cAAc,CAAA;CAAE,GAAG,SAAS,CAmBxH;AAED,eAAO,MAAM,0BAA0B;;;;;;;CAOtC,CAAC"}

package/dist/node-lib/internals/child-process.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Node's `validatePath`: a path is a string or a `Uint8Array`, and it carries
+ * no NUL. `fork('a\u0000b')` is a program's own bug and Node says so rather
+ * than opening a file whose name stops at the NUL.
+ */
+declare function validatePath(path: unknown, propName?: string): void;
+/**
+ * Node's `getValidatedPath`: a `file:` URL is the path it names, and anything
+ * else is validated as it stands. `fork(new URL('file:///app/child.js'))` is
+ * an ordinary call and `test-child-process-fork-url.mjs` makes it.
+ */
+declare function getValidatedPath(fileURLOrPath: unknown, propName?: string): string | Uint8Array;
+export declare const internalFsUtils: {
+    getValidatedPath: typeof getValidatedPath;
+    validatePath: typeof validatePath;
+};
+/**
+ * `internal/dgram`: the one name `internal/child_process.js` reads from it,
+ * the symbol a `dgram.Socket` keeps its handle under. The engine's `dgram` is
+ * a stub with no handle, so nothing is ever sent this way; the symbol exists
+ * because the conversion table names it while it is built.
+ */
+export declare const internalDgram: {
+    kStateSymbol: symbol;
+};
+export {};
+//# sourceMappingURL=child-process.d.ts.map

package/dist/node-lib/internals/child-process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-process.d.ts","sourceRoot":"","sources":["../../../src/node-lib/internals/child-process.ts"],"names":[],"mappings":"AAwBA;;;;GAIG;AACH,iBAAS,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,SAAS,GAAG,IAAI,CAW5D;AAED;;;;GAIG;AACH,iBAAS,gBAAgB,CAAC,aAAa,EAAE,OAAO,EAAE,QAAQ,SAAS,GAAG,MAAM,GAAG,UAAU,CAMxF;AAED,eAAO,MAAM,eAAe;;;CAAqC,CAAC;AAElE;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;CAA2C,CAAC"}

package/dist/node-lib/internals/events-util.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The internals Node's `events`, `util` and `internal/util/inspect` name that
+ * are not vendored.
+ *
+ * Each is the whole of what those files take from it. Every one of them is
+ * required lazily, inside the function that needs it -- Node wrote them that
+ * way to break its own cycles -- so nothing here is built unless a program
+ * walks the path that asks.
+ */
+/** `internal/console/global`: the realm's console, which `util.debuglog` logs through. */
+export declare const internalConsoleGlobal: Record<string, unknown>;
+/**
+ * `internal/process/execution`: the one call `internal/util.js` makes into
+ * it, reading the working directory where a failure to read it is not an
+ * error but an empty answer.
+ */
+export declare const internalProcessExecution: {
+    tryGetCwd: () => string;
+};
+/**
+ * `internal/process/warning`: Node emits a warning on the next tick through
+ * `process.emitWarning`, and synchronously through this one where the tick
+ * would come too late -- a deprecation raised while the process is exiting.
+ */
+export declare const internalProcessWarning: {
+    emitWarningSync: (warning: unknown, type?: string, code?: string) => void;
+};
+/**
+ * `internal/source_map/source_map_cache`: a tab compiles no source maps into
+ * the engine's own error stacks. Each name answers the way Node's does with
+ * source maps switched off.
+ */
+export declare const internalSourceMapCache: {
+    findSourceMap: () => undefined;
+    maybeCacheSourceMap: () => void;
+    sourceMapCacheToObject: () => undefined;
+    getSourceMapsSupport: () => {
+        enabled: boolean;
+        nodeModules: boolean;
+        generatedCode: boolean;
+    };
+    setSourceMapsSupport: () => void;
+    rekeySourceMap: () => void;
+};
+/**
+ * `internal/deps/undici/undici`: what `http.js` reaches for when a program
+ * touches `http.WebSocket`, `http.CloseEvent` or `http.MessageEvent`.
+ *
+ * Node bundles undici to have those classes at all. A tab already has them --
+ * they are the platform's, and they are what `new WebSocket(url)` means
+ * everywhere else on the page -- so the realm's own are what the engine
+ * answers with, rather than a second implementation of the same three names.
+ */
+export declare const internalUndici: {
+    readonly WebSocket: unknown;
+    readonly CloseEvent: unknown;
+    readonly MessageEvent: unknown;
+};
+/**
+ * `internal/readline/interface`: the one name `internal/fs/promises.js`
+ * takes from it, at its top, so every use of `fs/promises` needs it.
+ * `filehandle.readLines()` builds one of these over the file's own stream;
+ * the engine's `readline` already has that class, over the same streams.
+ */
+export declare const internalReadlineInterface: {
+    readonly Interface: unknown;
+};
+/**
+ * `internal/worker/js_transferable`: the marks Node puts on an object that
+ * can cross a `postMessage`. `internal/fs/promises.js` marks its `FileHandle`
+ * so one can be sent to a worker. Nothing crosses a thread boundary here --
+ * a handle is a number in this engine's own table -- so the marks are the
+ * symbols and a no-op, which is what an unmarked object gets anyway.
+ */
+export declare const internalJsTransferable: {
+    markTransferMode: () => void;
+    kDeserialize: symbol;
+    kTransfer: symbol;
+    kTransferList: symbol;
+    kClone: symbol;
+    setDeserializerCreateObjectFunction: () => void;
+};
+//# sourceMappingURL=events-util.d.ts.map

package/dist/node-lib/internals/events-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-util.d.ts","sourceRoot":"","sources":["../../../src/node-lib/internals/events-util.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH,0FAA0F;AAC1F,eAAO,MAAM,qBAAqB,yBAEhC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;qBACpB,MAAM;CAItB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;+BACN,OAAO,SAAS,MAAM,SAAS,MAAM,KAAG,IAAI;CAKxE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;yBACd,SAAS;+BACH,IAAI;kCACD,SAAS;gCACX;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,WAAW,EAAE,OAAO,CAAC;QAAC,aAAa,EAAE,OAAO,CAAA;KAAE;gCAElE,IAAI;0BACV,IAAI;CACzB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;;;;CAI1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;;CAErC,CAAC;AAUF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;4BACX,IAAI;;;;;+CAKe,IAAI;CAC9C,CAAC"}

package/dist/node-lib/internals/index.d.ts

@@ -0,0 +1,2 @@
+export declare function nodeLibInternal(name: string): (() => unknown) | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/node-lib/internals/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/node-lib/internals/index.ts"],"names":[],"mappings":"AAgCA,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS,CAiCzE"}

package/dist/node-lib/internals/modules.d.ts

@@ -0,0 +1,67 @@
+import { fileURLToPath, pathToFileURL } from '../../shims/url';
+/**
+ * `internal/bootstrap/realm`'s `BuiltinModule`, the two class methods the
+ * hooks file calls to turn a CommonJS filename into a URL and back.
+ */
+export declare const internalBootstrapRealm: {
+    BuiltinModule: {
+        /**
+         * Whether a normalized id (no `node:`) is a builtin a program may require.
+         * Node asks this of a filename to decide whether it is `node:<id>` rather
+         * than a path; a name the engine does not answer is a path or nothing.
+         */
+        canBeRequiredByUsers(id: string): boolean;
+        /**
+         * The canonical id of a requirable builtin, `node:` prefix or not, and
+         * undefined for anything else -- a `file:` URL, a path, a bare package
+         * name. Node returns undefined rather than throwing, and the hooks file
+         * tests the result rather than catching.
+         */
+        normalizeRequirableId(id: string): string | undefined;
+        /**
+         * Whether `id` is a compiled builtin, which `internal/util/inspect`
+         * asks of every `node:` stack frame when it colorizes an Error. Node's
+         * class answers from the realm's module map; the engine answers from
+         * the same list `canBeRequiredByUsers` reads, plus `internal/` files
+         * inspect also greys. The method was missing, so a pipe child that
+         * still had FORCE_COLOR threw `exists is not a function` while printing
+         * an assertion and the test exited 1.
+         */
+        exists(id: string): boolean;
+    };
+};
+/**
+ * `internal/url`: the conversions between a path and a URL that the hooks
+ * file makes, and the three names `_http_client.js` and `https.js` take to
+ * turn a URL into the options a request is made from.
+ */
+export declare const internalUrl: {
+    fileURLToPath: typeof fileURLToPath;
+    pathToFileURL: typeof pathToFileURL;
+    /**
+     * Node's `toPathIfFileURL`: `fs` takes a path or a `file:` URL for every
+     * one of its calls, and this is the one line that turns the second into
+     * the first. Anything else is handed on untouched, for `fs` to validate.
+     */
+    toPathIfFileURL: (value: unknown) => unknown;
+    readonly URL: unknown;
+    /** Node's `isURL`: a `URL` of this realm, or one shaped like it. */
+    isURL: (value: unknown) => boolean;
+    /**
+     * Node's `urlToHttpOptions`: the request options a `URL` stands for. The
+     * rules are Node's own -- an IPv6 host loses its brackets, the path is the
+     * pathname and the search together, and a password without a user is still
+     * an auth pair.
+     */
+    urlToHttpOptions: (url: URL) => Record<string, unknown>;
+};
+/**
+ * `internal/encoding`: the realm's own `TextDecoder`. The hooks file decodes
+ * an `ArrayBuffer` or a typed array a load hook returned into the source
+ * string the loader compiles.
+ */
+export declare const internalEncoding: {
+    readonly TextDecoder: unknown;
+    readonly TextEncoder: unknown;
+};
+//# sourceMappingURL=modules.d.ts.map

package/dist/node-lib/internals/modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.d.ts","sourceRoot":"","sources":["../../../src/node-lib/internals/modules.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;QAE/B;;;;WAIG;iCACsB,MAAM,GAAG,OAAO;QAGzC;;;;;WAKG;kCACuB,MAAM,GAAG,MAAM,GAAG,SAAS;QAKrD;;;;;;;;WAQG;mBACQ,MAAM,GAAG,OAAO;;CAM9B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;IAGtB;;;;OAIG;6BACsB,OAAO,KAAG,OAAO;;IAM1C,oEAAoE;mBACrD,OAAO,KAAG,OAAO;IAMhC;;;;;OAKG;4BACqB,GAAG,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAkBtD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;CAG5B,CAAC"}

package/dist/node-lib/internals/readline-access.d.ts

@@ -0,0 +1,2 @@
+export declare function readlineModule(): Record<string, unknown>;
+//# sourceMappingURL=readline-access.d.ts.map

package/dist/node-lib/internals/readline-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readline-access.d.ts","sourceRoot":"","sources":["../../../src/node-lib/internals/readline-access.ts"],"names":[],"mappings":"AAWA,wBAAgB,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIxD"}