@volter/tabnode 0.2.14-volter.88

package/dist/node-lib/binding/stream_wrap.d.ts

@@ -0,0 +1,191 @@
+import { type OwnedHandle } from './handles';
+/** The four slots libuv's `StreamBase` reports a read or a write through. */
+export declare const kReadBytesOrError = 0;
+export declare const kArrayBufferOffset = 1;
+export declare const kBytesWritten = 2;
+export declare const kLastWriteWasAsync = 3;
+export declare const streamBaseState: Int32Array<ArrayBuffer>;
+/** Node's `WriteWrap`: the request `writeGeneric` fills and hands to a write. */
+export declare class WriteWrap {
+    handle: LibuvStreamWrap | null;
+    oncomplete: ((status: number) => void) | null;
+    async: boolean;
+    bytes: number;
+    buffer: unknown;
+    callback: unknown;
+    error: unknown;
+    _chunks: unknown;
+}
+/** Node's `ShutdownWrap`: the request a `_final` hands to `shutdown`. */
+export declare class ShutdownWrap {
+    handle: LibuvStreamWrap | null;
+    oncomplete: ((status: number) => void) | null;
+    callback: (() => void) | null;
+}
+/**
+ * The bytes one direction of a pairing is carrying, oldest first, and the
+ * handle a write of them carried. A descriptor crosses an IPC channel beside
+ * the bytes of the message it belongs to and is read out of the receiver just
+ * before those bytes reach it, which is the order `setupChannel` in Node's
+ * `internal/child_process.js` reads them in.
+ */
+interface Inbound {
+    bytes: Uint8Array;
+    handle?: unknown;
+}
+/**
+ * The base every `TCP` and `Pipe` extends, as `LibuvStreamWrap` is the base of
+ * libuv's `uv_stream_t` wrappers.
+ *
+ * A pairing is two of these with `peer` pointing at each other. A write copies
+ * its bytes and hands them to the peer on a microtask, because libuv never
+ * delivers a read inside the write that caused it; the peer delivers them to
+ * `onread` while it is reading and holds them while it is not, which is what
+ * `readStart` and `readStop` mean.
+ */
+export declare class LibuvStreamWrap implements OwnedHandle {
+    /** Set by `net.js` to `onStreamRead`; the only way bytes reach a stream. */
+    onread: ((arrayBuffer: ArrayBuffer | null) => unknown) | null;
+    /** `net.js` owns this flag; `readStart`/`readStop` follow it. */
+    reading: boolean;
+    bytesRead: number;
+    bytesWritten: number;
+    /** Nothing is ever queued: a write is taken whole by the peer. */
+    writeQueueSize: number;
+    /** The engine has no descriptors for a paired handle, as libuv reports -1 for one it has no fd for. */
+    fd: number;
+    /** The other end of the pairing, once there is one. */
+    peer: LibuvStreamWrap | null;
+    /** True once `close()` has been called; a closed handle carries nothing. */
+    closed: boolean;
+    /**
+     * The handle the read now being delivered carried, which `setupChannel`
+     * takes off the channel at the top of its `onread`. libuv keeps the same
+     * thing in a pipe's pending-handle queue.
+     */
+    pendingHandle: unknown;
+    protected inbound: Inbound[];
+    protected inboundEof: boolean;
+    protected inboundError: number | null;
+    protected eofDelivered: boolean;
+    protected userBuffer: Uint8Array | null;
+    protected readonly asyncId: number;
+    constructor();
+    getAsyncId(): number;
+    ref(): void;
+    unref(): void;
+    hasRef(): boolean;
+    readStart(): number;
+    readStop(): number;
+    /** Node's `onread` option: reads land in the program's own buffer. */
+    useUserBuffer(buffer: Uint8Array): void;
+    /**
+     * libuv's `uv_shutdown`: this end says it will write no more, and the peer
+     * reads EOF. The request completes on its own turn, as libuv's does.
+     */
+    shutdown(req: ShutdownWrap): number;
+    writeBuffer(req: WriteWrap, buffer: Uint8Array): number;
+    writev(req: WriteWrap, chunks: unknown[], allBuffers: boolean): number;
+    writeUtf8String(req: WriteWrap, text: string, handle?: unknown): number;
+    writeAsciiString(req: WriteWrap, text: string): number;
+    writeLatin1String(req: WriteWrap, text: string): number;
+    writeUcs2String(req: WriteWrap, text: string): number;
+    /**
+     * libuv's `uv_close`. The peer reads EOF, as it does when the other end of a
+     * socket goes; the callback runs on its own turn, because `net.js` emits
+     * `close` from it and Node emits that after the turn that destroyed.
+     */
+    close(callback?: () => void): void;
+    /** What a `TCP` or a `Pipe` gives up beyond the stream: a port, a path. */
+    protected onCloseHandle(): void;
+    /**
+     * libuv's `dup()`: a second handle on the same connection.
+     *
+     * A descriptor sent over IPC arrives in the receiver as a NEW descriptor
+     * referring to the same socket, which is what `SCM_RIGHTS` gives it, and
+     * Node's own `child_process.js` counts on exactly that: on the receiver's
+     * `NODE_HANDLE_ACK` the sender CLOSES the handle it sent. With one handle
+     * for both, that close ended the connection the child had just been given
+     * and its first write was `EBADF`.
+     *
+     * The duplicate takes over this end of the pairing and this end is left
+     * peerless, so closing it announces nothing -- the sender has already given
+     * the socket up (`handleConversion`'s `send` sets `socket._handle = null`
+     * and silences its reads before the write).
+     */
+    duplicate(): LibuvStreamWrap;
+    /** Two handles become each other's peer; what one writes the other reads. */
+    static pair(a: LibuvStreamWrap, b: LibuvStreamWrap): void;
+    /**
+     * Take over another handle's end of a pairing, with everything that arrived
+     * on it while nobody was holding it. This is what opening a descriptor is
+     * here: a forked child's channel is opened by the child after its parent has
+     * already written to it -- `fork(…)` and `send(…)` are one synchronous turn
+     * in every program that does it -- and the bytes waiting at that descriptor
+     * are the child's. A pairing whose bytes stayed behind left the child
+     * waiting for a message its parent had already sent.
+     */
+    takeOverFrom(other: LibuvStreamWrap): void;
+    /**
+     * A write: the bytes are copied (the caller may reuse its buffer) and put in
+     * the peer's queue at once, where anything the writer does afterwards lands
+     * behind them. Delivery is still the peer's own turn, because libuv never
+     * delivers a read inside the write that caused it. It completes
+     * synchronously — `kBytesWritten` set, `kLastWriteWasAsync` 0 — because the
+     * engine's writes are taken whole and there is no queue for a `drain` to
+     * empty.
+     *
+     * Handing the bytes over on a microtask instead put them BEHIND an end
+     * announced from the same turn: `stdin.write('hello'); stdin.end()` is one
+     * synchronous block in every program that does it, the peer read EOF first
+     * and the bytes were dropped after it, and `spawn('cat')` fed that way
+     * produced nothing.
+     */
+    protected dispatchWrite(req: WriteWrap, buffer: Uint8Array, handle?: unknown): number;
+    /**
+     * The peer will write no more; this end reads EOF once it has read the rest.
+     * Announced on a microtask of its own, so it lands behind the writes that
+     * were handed over before it: `stdin.write('hello'); stdin.end()` is one
+     * turn in every program, and an EOF announced from inside `end` reached the
+     * reader first and the bytes never reached it at all.
+     */
+    protected sendEof(): void;
+    /**
+     * libuv's close-with-reset: the peer's next read is `ECONNRESET`, not EOF,
+     * which is how `socket.resetAndDestroy()` differs from `socket.destroy()`.
+     */
+    protected sendReset(): void;
+    /** An error arriving on the read side, delivered as libuv delivers one. */
+    receiveError(code: number): void;
+    /** Bytes arriving from the peer, and the handle their write carried. */
+    receive(bytes: Uint8Array, handle?: unknown): void;
+    /** The peer is done writing. */
+    receiveEof(): void;
+    /**
+     * What arrived is recorded the moment it arrives and delivered on a turn of
+     * its own, once, however many arrivals that turn holds. This is the order
+     * libuv's loop reads in: everything a writer did in one turn is read in the
+     * order it did it, and never from inside the call that did it.
+     */
+    private flushScheduled;
+    protected scheduleFlush(): void;
+    /**
+     * Hand what has arrived to `onStreamRead`, in libuv's shape: the byte count
+     * in `streamBaseState[kReadBytesOrError]`, the offset beside it, the
+     * `ArrayBuffer` as the argument. A reader that pushes back calls `readStop`
+     * from inside `onread`, so the loop re-reads `reading` every time.
+     */
+    protected flushInbound(): void;
+}
+declare const _default: {
+    LibuvStreamWrap: typeof LibuvStreamWrap;
+    WriteWrap: typeof WriteWrap;
+    ShutdownWrap: typeof ShutdownWrap;
+    streamBaseState: Int32Array<ArrayBuffer>;
+    kReadBytesOrError: number;
+    kArrayBufferOffset: number;
+    kBytesWritten: number;
+    kLastWriteWasAsync: number;
+};
+export default _default;
+//# sourceMappingURL=stream_wrap.d.ts.map

package/dist/node-lib/binding/stream_wrap.d.ts.map

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

package/dist/node-lib/binding/stubs.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The two bindings `internal/child_process.js` names only to ask an
+ * `instanceof` of.
+ *
+ * `udp_wrap`'s `UDP` tells a datagram handle from a stream one when a handle
+ * is sent over IPC, and `http_parser`'s `HTTPParser` tells a parser handle
+ * from a socket when one is released. The engine has no datagram handle and
+ * parses HTTP in JavaScript, so nothing is ever an instance of either; the
+ * classes exist so the question can be asked, and answered no.
+ */
+/** libuv's `uv_udp_t`, which this engine never makes one of. */
+export declare class UDP {
+}
+/** The HTTP parser handle a C++ Node keeps on a socket; this one has none. */
+export declare class HTTPParser {
+}
+export declare const udpWrapBinding: {
+    UDP: typeof UDP;
+};
+export declare const httpParserBinding: {
+    HTTPParser: typeof HTTPParser;
+};
+//# sourceMappingURL=stubs.d.ts.map

package/dist/node-lib/binding/stubs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stubs.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/stubs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,gEAAgE;AAChE,qBAAa,GAAG;CAAG;AAEnB,8EAA8E;AAC9E,qBAAa,UAAU;CAAG;AAE1B,eAAO,MAAM,cAAc;;CAAU,CAAC;AACtC,eAAO,MAAM,iBAAiB;;CAAiB,CAAC"}

package/dist/node-lib/binding/tcp_wrap.d.ts

@@ -0,0 +1,98 @@
+/**
+ * `internalBinding('tcp_wrap')`: the engine's loopback, in libuv's shape.
+ *
+ * One engine is one host. A `bind` reserves a port, a `listen` starts
+ * answering on it, and a `connect` to a loopback address on a port something
+ * is listening on pairs two handles whose writes are each other's reads —
+ * which is what the engine has always done for a `net` connect, moved here so
+ * that Node's own `net.js` runs on it. A connect to anything that is not this
+ * host is `ECONNREFUSED`, because there is nothing else to reach: a page's
+ * request to the outside goes through `fetch`, not through a socket.
+ *
+ * A wildcard bind holds the port for both families, as a dual-stack `::` bind
+ * does on Linux, so `connect('127.0.0.1')` reaches a server that bound `::`.
+ */
+import { LibuvStreamWrap } from './stream_wrap';
+/** libuv's `uv_tcp_t` flavours, and the two flags `getFlags` builds. */
+export declare const constants: {
+    SOCKET: number;
+    SERVER: number;
+    UV_TCP_IPV6ONLY: number;
+    UV_TCP_REUSEPORT: number;
+};
+/** What `getsockname`/`getpeername` fill in. */
+export interface SockName {
+    address: string;
+    family: string;
+    port: number;
+}
+/** Node's `TCPConnectWrap`: the request a connect fills and is answered through. */
+export declare class TCPConnectWrap {
+    oncomplete: ((status: number, handle: unknown, req: unknown, readable: boolean, writable: boolean) => void) | null;
+    address: string;
+    port: number;
+    localAddress: string | undefined;
+    localPort: number | undefined;
+    addressType: number | undefined;
+}
+/**
+ * What the page bridge is told when a guest starts or stops listening. The
+ * bridge used to learn this from the engine's own `http.Server`; `http` is
+ * Node's own file now and knows nothing of a page, so the news comes from
+ * where a port is actually taken.
+ */
+type ListenWatcher = (port: number, address: string) => void;
+export declare function setPortWatchers(onListen: ListenWatcher | null, onClose: ((port: number) => void) | null): void;
+/** The listening handle a connect to this port reaches, if any. */
+export declare function listenerOnPort(port: number): TCP | undefined;
+export declare class TCP extends LibuvStreamWrap {
+    /** `constants.SOCKET` or `constants.SERVER`. */
+    readonly type: number;
+    listening: boolean;
+    /** Set by `net.js` on a server handle; how an accepted pairing is announced. */
+    onconnection: ((status: number, clientHandle: TCP) => void) | null;
+    private local;
+    private remote;
+    private ephemeral;
+    constructor(type?: number);
+    bind(address: string, port: number, _flags?: number): number;
+    bind6(address: string, port: number, _flags?: number): number;
+    private bindTo;
+    listen(_backlog: number): number;
+    connect(req: TCPConnectWrap, address: string, port: number): number;
+    connect6(req: TCPConnectWrap, address: string, port: number): number;
+    private connectTo;
+    /**
+     * Name both ends of a pairing the engine made without a connect. The page
+     * bridge's end of an upgraded connection is one: there was no `connect`, and
+     * the socket an `upgrade` listener is handed still has to answer
+     * `remoteAddress` and `localPort` as a connection's socket does.
+     */
+    adoptNames(local: SockName, remote: SockName): void;
+    /** libuv's `dup()`: the same connection, under both its names. */
+    duplicate(): TCP;
+    getsockname(out: Partial<SockName>): number;
+    getpeername(out: Partial<SockName>): number;
+    /** Nothing is buffered between two handles in one realm, so there is nothing to delay. */
+    setNoDelay(_enable: boolean): number;
+    /** There is no idle connection to probe: a pairing is alive while both ends are. */
+    setKeepAlive(_enable: boolean, _delay: number): number;
+    setSimultaneousAccepts(_enable: boolean): number;
+    /** An engine handle carries no descriptor a program can hand it. */
+    open(_fd: number): number;
+    /** libuv's `uv_tcp_close_reset`: the peer reads ECONNRESET rather than EOF. */
+    reset(callback?: () => void): number;
+    protected onCloseHandle(): void;
+}
+declare const _default: {
+    TCP: typeof TCP;
+    TCPConnectWrap: typeof TCPConnectWrap;
+    constants: {
+        SOCKET: number;
+        SERVER: number;
+        UV_TCP_IPV6ONLY: number;
+        UV_TCP_REUSEPORT: number;
+    };
+};
+export default _default;
+//# sourceMappingURL=tcp_wrap.d.ts.map

package/dist/node-lib/binding/tcp_wrap.d.ts.map

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

package/dist/node-lib/binding/tty_wrap.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `internalBinding('tty_wrap')`: the engine's standard streams, where a host
+ * reports one of them as a terminal.
+ *
+ * `internal/child_process.js` reads two things from it: whether a descriptor
+ * is a terminal, which decides whether an `inherit` entry is a TTY, and the
+ * `TTY` class, which `getHandleWrapType` asks an `instanceof` of. The engine
+ * writes to a page or to a host's pipe, so a descriptor is a terminal only
+ * when the running program's own `process.stdout.isTTY` says so -- which is
+ * what a held run gets, and what a program reads to decide on colour.
+ */
+import { LibuvStreamWrap } from './stream_wrap';
+/** libuv's `uv_tty_t`, over the same stream the rest of the binding is. */
+export declare class TTY extends LibuvStreamWrap {
+    readonly fdNumber: number;
+    /**
+     * Node's `new TTY(fd, ctx)` writes an errno onto `ctx` when the fd is not
+     * a terminal, so `tty.WriteStream` refuses to wrap a pipe. A run's stdout
+     * that was not given a TTY is a pipe: `isTTY` is false and `hasColors`
+     * answers false, and `util.inspect` does not colorize a number on it.
+     */
+    constructor(fd: number, ctx?: {
+        code?: string;
+    } | boolean);
+    /** A terminal the engine does not own has one size and no mode to set. */
+    getWindowSize(out: number[]): number;
+    setRawMode(_raw: number): number;
+}
+/** libuv's `uv_guess_handle(fd) === UV_TTY`, as the running program sees it. */
+export declare function isTTY(fd: number): boolean;
+declare const _default: {
+    TTY: typeof TTY;
+    isTTY: typeof isTTY;
+};
+export default _default;
+//# sourceMappingURL=tty_wrap.d.ts.map

package/dist/node-lib/binding/tty_wrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tty_wrap.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/tty_wrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAGhD,2EAA2E;AAC3E,qBAAa,GAAI,SAAQ,eAAe;IACtC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B;;;;;OAKG;gBACS,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO;IASzD,0EAA0E;IAC1E,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM;IAMpC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAGjC;AAED,gFAAgF;AAChF,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAOzC;;;;;AAED,wBAA8B"}

package/dist/node-lib/binding/util.d.ts

@@ -0,0 +1,126 @@
+/**
+ * `internalBinding('util')`: what V8 tells Node about a value.
+ *
+ * `internal/util/inspect.js` is the reason this file is the size it is.
+ * Printing a value the way Node prints it means asking V8 questions
+ * JavaScript cannot ask itself, and each one is answered here out of the
+ * realm's own built-ins -- an object's non-index properties, the name of the
+ * constructor that made it, the entries inside a `Map` or a `Set`.
+ *
+ * THE TWO NAMED LOSSES, and why they are losses rather than gaps to close:
+ *
+ * `getProxyDetails` asks V8 for a `Proxy`'s target and handler. A proxy is
+ * invisible to the code it wraps -- that is the whole of what a proxy is --
+ * and no JavaScript can see through one. This answers undefined, which is
+ * `not a proxy`, so `inspect` prints the value the proxy stands for. That is
+ * also what Node prints without `--show-proxy`, so the loss shows only under
+ * `showProxy: true`.
+ *
+ * `defineLazyProperties` is how `util.js` exposes `parseArgs`, `TextDecoder`,
+ * `MIMEType` and the rest: each is a getter that requires its own file on the
+ * first read. It must reach the loader's require, not the realm's -- there is
+ * no `require` on a realm -- or every one of those names reads undefined.
+ *
+ * `getConstructorName` asks V8 which constructor made a value, which V8 knows
+ * from the object's own shape even after its prototype has been severed.
+ * This walks the prototype chain for an own `constructor`, which is the only
+ * record JavaScript keeps -- so an object whose prototype was set to null
+ * prints as `[Object: null prototype]` where Node prints `[Foo: null
+ * prototype]`. Everything with a prototype still names its constructor.
+ *
+ * `getPromiseDetails` asks V8 for a promise's state and its value without
+ * awaiting it. A promise's state cannot be read synchronously from
+ * JavaScript; `then` is the only door and it is asynchronous by definition.
+ * This answers `[kPending]`, so `inspect` prints `Promise { <pending> }` for
+ * every promise, settled or not. A program that needs to know awaits it.
+ */
+import { guessHandleTypeOfFd } from './fds';
+export declare const utilBinding: {
+    privateSymbols: {
+        arrow_message_private_symbol: symbol;
+        decorated_private_symbol: symbol;
+        untransferable_object_private_symbol: symbol;
+        host_defined_option_symbol: symbol;
+        transfer_mode_private_symbol: symbol;
+    };
+    constants: {
+        ALL_PROPERTIES: number;
+        ONLY_WRITABLE: number;
+        ONLY_ENUMERABLE: number;
+        ONLY_CONFIGURABLE: number;
+        SKIP_STRINGS: number;
+        SKIP_SYMBOLS: number;
+        kPending: number;
+        kFulfilled: number;
+        kRejected: number;
+    };
+    /** Node warns differently for a deprecation raised inside a dependency; nothing here is. */
+    isInsideNodeModules: () => boolean;
+    /**
+     * An object's own properties that are not array indices, filtered the way
+     * V8's `GetOwnNonIndexProperties` filters: `ONLY_ENUMERABLE` keeps the
+     * enumerable ones, `SKIP_SYMBOLS` and `SKIP_STRINGS` drop a kind outright.
+     * `inspect` asks for this to list an array's non-index keys and a typed
+     * array's own properties without walking its elements.
+     */
+    getOwnNonIndexProperties: (target: object, filter?: number) => Array<string | symbol>;
+    /** The promise loss named at the top of this file. */
+    getPromiseDetails: () => [number];
+    /** The proxy loss named at the top of this file. */
+    getProxyDetails: () => undefined;
+    /**
+     * The entries inside a `Map` or a `Set`, which `inspect` prints. V8 reads
+     * them out of the object's own storage; this reads them the way any program
+     * does, which answers for a real map or set. An ITERATOR over one keeps its
+     * position in V8's own state and cannot be previewed without consuming it,
+     * so an iterator previews as empty rather than being spent -- a printed
+     * value is not worth destroying the thing printed.
+     */
+    previewEntries: (value: unknown, isIterator?: boolean) => [unknown[], boolean];
+    /**
+     * The name of the constructor that made a value, as V8 reports it: the
+     * first prototype in the chain with an own `constructor` whose name is not
+     * empty. `inspect` prints it before an object's braces.
+     */
+    getConstructorName: (value: object) => string;
+    /** A pointer's value, printed for an external. A tab has no externals. */
+    getExternalValue: () => bigint;
+    /** What kind of thing a descriptor is, out of the engine's own table. */
+    guessHandleType: typeof guessHandleTypeOfFd;
+    /**
+     * Node's `defineLazyProperties`: each key becomes a getter that requires
+     * the module the first time it is read, so a builtin that exposes another
+     * builtin's class does not load it to say so.
+     */
+    defineLazyProperties: (target: object, id: string, keys: string[], writable?: boolean) => void;
+    /**
+     * The stack, as `util.getCallSites()` reports it: one entry per frame with
+     * the function's name, the script it is in, and where in that script. V8's
+     * own structured-stack door is what Node reads too -- `Error
+     * .prepareStackTrace` handed an array of call sites -- so this asks the
+     * realm the same question and shapes the answer the same way. The harness
+     * of Node's own tests calls it on every `mustNotCall`, which is why a
+     * missing one showed up as thirty test files at once.
+     */
+    getCallSites: (frameCount?: number) => Array<Record<string, unknown>>;
+    /**
+     * A `.env` file's contents as an object, which `util.parseEnv` returns and
+     * which `--env-file` loads a process's environment from. Node parses it in
+     * C++; the rules are the ones its own fixture states, and they are the
+     * whole of the format: a `KEY=VALUE` per line, `export ` allowed in front
+     * of the key and dropped, a `#` starting a comment outside quotes wherever
+     * it stands -- `a#b` is `a`, no space needed -- and a
+     * value that may be wrapped in single quotes, double quotes or backticks --
+     * a quoted value keeps its spaces and may run over several lines, and only
+     * a double-quoted one expands `\n` and `\r`.
+     */
+    parseEnv: (content: string) => Record<string, string>;
+    /**
+     * A blocking sleep. A tab has one thread and nothing else can run while
+     * this spins, which is exactly what a blocking sleep is; only a program
+     * that asked for one gets it.
+     */
+    sleep: (milliseconds: number) => void;
+};
+export default utilBinding;
+//# sourceMappingURL=util.d.ts.map

package/dist/node-lib/binding/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/util.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAC;AAsB5C,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;IAUtB,4FAA4F;+BACnE,OAAO;IAEhC;;;;;;OAMG;uCACgC,MAAM,sBAAe,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;IAwB9E,sDAAsD;6BAC/B,CAAC,MAAM,CAAC;IAE/B,oDAAoD;2BAC/B,SAAS;IAE9B;;;;;;;OAOG;4BACqB,OAAO,eAAe,OAAO,KAAG,CAAC,OAAO,EAAE,EAAE,OAAO,CAAC;IAW5E;;;;OAIG;gCACyB,MAAM,KAAG,MAAM;IAW3C,0EAA0E;4BACpD,MAAM;IAE5B,yEAAyE;;IAGzE;;;;OAIG;mCAC4B,MAAM,MAAM,MAAM,QAAQ,MAAM,EAAE,yBAAoB,IAAI;IAgBzF;;;;;;;;OAQG;2CAC8B,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAiC/D;;;;;;;;;;OAUG;wBACiB,MAAM,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAuCnD;;;;OAIG;0BACmB,MAAM,KAAG,IAAI;CAIpC,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/node-lib/binding/uv.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `internalBinding('uv')`: libuv's error numbers and names.
+ *
+ * The engine has no libuv, and the numbers are still libuv's, because Node's
+ * own files compare against them and a program reads `err.errno` and
+ * `err.code` and expects the pair a Linux Node reports. The engine's platform
+ * is `linux`, so these are Linux's.
+ */
+/** libuv's `uv_err_name`: the code a number stands for, `UNKNOWN` for a number none does. */
+export declare function errname(code: number): string;
+/** Node's `getErrorMap()`: every number to its `[name, message]` pair. */
+export declare function getErrorMap(): Map<number, [string, string]>;
+declare const uvBinding: Record<string, unknown>;
+export declare const UV_EOF: number;
+export declare const UV_ECONNREFUSED: number;
+export declare const UV_ECONNRESET: number;
+export declare const UV_EADDRINUSE: number;
+export declare const UV_ENOENT: number;
+export declare const UV_ENOTSOCK: number;
+export declare const UV_EPIPE: number;
+export declare const UV_EINVAL: number;
+export declare const UV_ENOTCONN: number;
+export declare const UV_ECANCELED: number;
+export declare const UV_ENOTSUP: number;
+export declare const UV_EBADF: number;
+export declare const UV_ENOSYS: number;
+export declare const UV_EADDRNOTAVAIL: number;
+export declare const UV_EACCES: number;
+export declare const UV_ENOBUFS: number;
+export declare const UV_ESRCH: number;
+export default uvBinding;
+//# sourceMappingURL=uv.d.ts.map

package/dist/node-lib/binding/uv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uv.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/uv.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAyDH,6FAA6F;AAC7F,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,0EAA0E;AAC1E,wBAAgB,WAAW,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAQ3D;AAED,QAAA,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAA4B,CAAC;AAGpE,eAAO,MAAM,MAAM,QAAkB,CAAC;AACtC,eAAO,MAAM,eAAe,QAA2B,CAAC;AACxD,eAAO,MAAM,aAAa,QAAyB,CAAC;AACpD,eAAO,MAAM,aAAa,QAAyB,CAAC;AACpD,eAAO,MAAM,SAAS,QAAqB,CAAC;AAC5C,eAAO,MAAM,WAAW,QAAuB,CAAC;AAChD,eAAO,MAAM,QAAQ,QAAoB,CAAC;AAC1C,eAAO,MAAM,SAAS,QAAqB,CAAC;AAC5C,eAAO,MAAM,WAAW,QAAuB,CAAC;AAChD,eAAO,MAAM,YAAY,QAAwB,CAAC;AAClD,eAAO,MAAM,UAAU,QAAsB,CAAC;AAC9C,eAAO,MAAM,QAAQ,QAAoB,CAAC;AAC1C,eAAO,MAAM,SAAS,QAAqB,CAAC;AAC5C,eAAO,MAAM,gBAAgB,QAA4B,CAAC;AAC1D,eAAO,MAAM,SAAS,QAAqB,CAAC;AAC5C,eAAO,MAAM,UAAU,QAAsB,CAAC;AAC9C,eAAO,MAAM,QAAQ,QAAoB,CAAC;AAE1C,eAAe,SAAS,CAAC"}

package/dist/node-lib/binding/zlib-pako.d.ts

@@ -0,0 +1,22 @@
+/** A fresh `z_stream`, the object every call below reads and writes. */
+export declare function zstream(): Record<string, unknown>;
+export declare const inflateModule: {
+    inflateInit2(strm: unknown, windowBits: number): number;
+    inflate(strm: unknown, flush: number): number;
+    inflateEnd(strm: unknown): number;
+    inflateReset(strm: unknown): number;
+    inflateSetDictionary(strm: unknown, dictionary: Uint8Array): number;
+};
+export declare const deflateModule: {
+    deflateInit2(strm: unknown, level: number, method: number, windowBits: number, memLevel: number, strategy: number): number;
+    deflate(strm: unknown, flush: number): number;
+    deflateEnd(strm: unknown): number;
+    deflateReset(strm: unknown): number;
+    deflateSetDictionary(strm: unknown, dictionary: Uint8Array): number;
+};
+/** zlib's constants and its own error text, beside the checksum it defines. */
+export declare const zlibConstants: Record<string, number> & {
+    messages: Record<number, string>;
+    crc32: (crc: number, buffer: Uint8Array, length: number, position: number) => number;
+};
+//# sourceMappingURL=zlib-pako.d.ts.map

package/dist/node-lib/binding/zlib-pako.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zlib-pako.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/zlib-pako.ts"],"names":[],"mappings":"AAiBA,wEAAwE;AACxE,wBAAgB,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEjD;AAED,eAAO,MAAM,aAAa,EAA6B;IACrD,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;IACxD,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9C,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;IAClC,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;IACpC,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CAAC;CACrE,CAAC;AAEF,eAAO,MAAM,aAAa,EAA6B;IACrD,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3H,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9C,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;IAClC,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;IACpC,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CAAC;CACrE,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;IACnD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;CAQtF,CAAC"}

package/dist/node-lib/binding/zlib.d.ts

@@ -0,0 +1,38 @@
+type ProcessCallback = () => void;
+/**
+ * One compression or decompression stream. Node makes one per `Gzip`,
+ * `Inflate` and the rest, initializes it once, and then drives it a buffer at
+ * a time until its input is gone.
+ */
+export declare class Zlib {
+    #private;
+    readonly mode: number;
+    /** `zlib.js` hangs its own error reporter here. */
+    onerror: ((message: string, errno: number, code?: string) => void) | null;
+    constructor(mode: number);
+    init(windowBits: number, level: number, memLevel: number, strategy: number, writeState: Uint32Array, processCallback: ProcessCallback, dictionary?: Uint8Array): void;
+    write(flush: number, inBuf: Uint8Array | null, inOff: number, inLen: number, outBuf: Uint8Array, outOff: number, outLen: number): this;
+    writeSync(flush: number, inBuf: Uint8Array | null, inOff: number, inLen: number, outBuf: Uint8Array, outOff: number, outLen: number): this;
+    /**
+     * `deflateParams` mid-stream. pako's deflate does not carry it, so the
+     * level and strategy are taken by starting the stream again -- which is
+     * what zlib does when the two cannot be changed in place, and is only
+     * reachable before any output has been produced.
+     */
+    params(level: number, strategy: number): void;
+    reset(): void;
+    close(): void;
+    /** Node asks a handle for these two after a `Z_STREAM_END`. */
+    get ended(): boolean;
+}
+export declare const zlibBinding: {
+    Zlib: typeof Zlib;
+    BrotliEncoder: new (...args: unknown[]) => never;
+    BrotliDecoder: new (...args: unknown[]) => never;
+    ZstdCompress: new (...args: unknown[]) => never;
+    ZstdDecompress: new (...args: unknown[]) => never;
+    /** `zlib.crc32`, which is zlib's own table-driven one. */
+    crc32: (data: Uint8Array | string, value?: number) => number;
+};
+export default zlibBinding;
+//# sourceMappingURL=zlib.d.ts.map

package/dist/node-lib/binding/zlib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zlib.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/zlib.ts"],"names":[],"mappings":"AAwCA,KAAK,eAAe,GAAG,MAAM,IAAI,CAAC;AAElC;;;;GAIG;AACH,qBAAa,IAAI;;aAaa,IAAI,EAAE,MAAM;IAHxC,mDAAmD;IACnD,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,IAAI,CAAQ;gBAErD,IAAI,EAAE,MAAM;IAkBxC,IAAI,CACF,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EACrE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,eAAe,EAAE,UAAU,CAAC,EAAE,UAAU,GACjF,IAAI;IA8EP,KAAK,CACH,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EACrE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GACjD,IAAI;IAaP,SAAS,CACP,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EACrE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GACjD,IAAI;IAKP;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAM7C,KAAK,IAAI,IAAI;IAgBb,KAAK,IAAI,IAAI;IAEb,+DAA+D;IAC/D,IAAI,KAAK,IAAI,OAAO,CAAwB;CAC7C;AA8BD,eAAO,MAAM,WAAW;;iCAlB0C,OAAO,EAAE,KAAK,KAAK;iCAAnB,OAAO,EAAE,KAAK,KAAK;gCAAnB,OAAO,EAAE,KAAK,KAAK;kCAAnB,OAAO,EAAE,KAAK,KAAK;IAwBnF,0DAA0D;kBAC5C,UAAU,GAAG,MAAM,qBAAc,MAAM;CAItD,CAAC;AAEF,eAAe,WAAW,CAAC"}