@volter/tabnode 0.2.14-volter.88

package/src/node-lib/binding/tty_wrap.ts

@@ -0,0 +1,56 @@
+/**
+ * `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';
+import { guessHandleTypeOfFd } from './fds';
+
+/** libuv's `uv_tty_t`, over the same stream the rest of the binding is. */
+export 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) {
+    super();
+    this.fdNumber = fd;
+    this.fd = fd;
+    if (ctx && typeof ctx === 'object' && !isTTY(fd)) {
+      ctx.code = 'ENOTTY';
+    }
+  }
+
+  /** A terminal the engine does not own has one size and no mode to set. */
+  getWindowSize(out: number[]): number {
+    out[0] = 80;
+    out[1] = 24;
+    return 0;
+  }
+
+  setRawMode(_raw: number): number {
+    return 0;
+  }
+}
+
+/** libuv's `uv_guess_handle(fd) === UV_TTY`, as the running program sees it. */
+export function isTTY(fd: number): boolean {
+  if (fd !== 0 && fd !== 1 && fd !== 2) return guessHandleTypeOfFd(fd) === 'TTY';
+  const realm = (globalThis as unknown as {
+    process?: { stdin?: { isTTY?: boolean }; stdout?: { isTTY?: boolean }; stderr?: { isTTY?: boolean } };
+  }).process;
+  const stream = fd === 0 ? realm?.stdin : fd === 1 ? realm?.stdout : realm?.stderr;
+  return stream?.isTTY === true;
+}
+
+export default { TTY, isTTY };

package/src/node-lib/binding/util.ts

@@ -0,0 +1,274 @@
+/**
+ * `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';
+import { nodeLibInternalRequire } from '../load';
+
+/** Node's `propertyFilter` and promise-state constants, by their own values. */
+const constants = {
+  ALL_PROPERTIES: 0,
+  ONLY_WRITABLE: 1,
+  ONLY_ENUMERABLE: 2,
+  ONLY_CONFIGURABLE: 4,
+  SKIP_STRINGS: 8,
+  SKIP_SYMBOLS: 16,
+  kPending: 0,
+  kFulfilled: 1,
+  kRejected: 2,
+};
+
+/** Whether a key is an array index, which `getOwnNonIndexProperties` leaves out. */
+function isIndexKey(key: string): boolean {
+  const number = Number(key);
+  return Number.isInteger(number) && number >= 0 && String(number) === key;
+}
+
+export const utilBinding = {
+  privateSymbols: {
+    arrow_message_private_symbol: Symbol('arrow_message_private_symbol'),
+    decorated_private_symbol: Symbol('decorated_private_symbol'),
+    untransferable_object_private_symbol: Symbol('untransferable_object_private_symbol'),
+    host_defined_option_symbol: Symbol('host_defined_option_symbol'),
+    transfer_mode_private_symbol: Symbol('transfer_mode_private_symbol'),
+  },
+  constants,
+
+  /** Node warns differently for a deprecation raised inside a dependency; nothing here is. */
+  isInsideNodeModules: (): boolean => false,
+
+  /**
+   * 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 = 0): Array<string | symbol> => {
+    const keys: Array<string | symbol> = [];
+    if ((filter & constants.SKIP_STRINGS) === 0) {
+      for (const key of Object.getOwnPropertyNames(target)) {
+        if (isIndexKey(key)) continue;
+        if ((filter & constants.ONLY_ENUMERABLE) !== 0) {
+          const own = Object.getOwnPropertyDescriptor(target, key);
+          if (!own?.enumerable) continue;
+        }
+        keys.push(key);
+      }
+    }
+    if ((filter & constants.SKIP_SYMBOLS) === 0) {
+      for (const key of Object.getOwnPropertySymbols(target)) {
+        if ((filter & constants.ONLY_ENUMERABLE) !== 0) {
+          const own = Object.getOwnPropertyDescriptor(target, key);
+          if (!own?.enumerable) continue;
+        }
+        keys.push(key);
+      }
+    }
+    return keys;
+  },
+
+  /** The promise loss named at the top of this file. */
+  getPromiseDetails: (): [number] => [constants.kPending],
+
+  /** The proxy loss named at the top of this file. */
+  getProxyDetails: (): undefined => void 0,
+
+  /**
+   * 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] => {
+    if (value instanceof Map) {
+      const entries: unknown[] = [];
+      for (const [key, item] of value) { entries.push(key, item); }
+      return [entries, true];
+    }
+    if (value instanceof Set) return [[...value], false];
+    if (isIterator) return [[], false];
+    return [[], false];
+  },
+
+  /**
+   * 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 => {
+    let current: object | null = value;
+    while (current !== null) {
+      const own = Object.getOwnPropertyDescriptor(current, 'constructor');
+      const constructor = own?.value as { name?: string } | undefined;
+      if (typeof constructor === 'function' && constructor.name) return constructor.name;
+      current = Object.getPrototypeOf(current) as object | null;
+    }
+    return '';
+  },
+
+  /** A pointer's value, printed for an external. A tab has no externals. */
+  getExternalValue: (): bigint => BigInt(0),
+
+  /** What kind of thing a descriptor is, out of the engine's own table. */
+  guessHandleType: 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 = true): void => {
+    for (const key of keys) {
+      let built: unknown;
+      let ready = false;
+      Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        get() {
+          if (!ready) { ready = true; built = (nodeLibInternalRequire(id) as Record<string, unknown>)[key]; }
+          return built;
+        },
+        set: writable ? (value: unknown) => { built = value; ready = true; } : void 0,
+      });
+    }
+  },
+
+  /**
+   * 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 = 10): Array<Record<string, unknown>> => {
+    const original = Error.prepareStackTrace;
+    const limit = Error.stackTraceLimit;
+    try {
+      Error.stackTraceLimit = Math.max(frameCount + 2, 10);
+      Error.prepareStackTrace = (_error, sites: unknown[]) => sites.map((raw) => {
+        const site = raw as {
+          getFunctionName?: () => string | null; getFileName?: () => string | null;
+          getLineNumber?: () => number | null; getColumnNumber?: () => number | null;
+          getScriptNameOrSourceURL?: () => string | null;
+        };
+        return {
+          functionName: site.getFunctionName?.() ?? '',
+          scriptName: site.getFileName?.() ?? site.getScriptNameOrSourceURL?.() ?? '',
+          scriptId: '0',
+          lineNumber: site.getLineNumber?.() ?? 0,
+          column: site.getColumnNumber?.() ?? 0,
+          columnNumber: site.getColumnNumber?.() ?? 0,
+        };
+      });
+      const holder: { stack?: unknown } = {};
+      Error.captureStackTrace(holder, utilBinding.getCallSites);
+      const sites = holder.stack as Array<Record<string, unknown>> | undefined;
+      if (!Array.isArray(sites)) return [];
+      // A frame inside a builtin is not the caller's business: Node drops the
+      // `node:util` frame its own `getCallSites` stands in, and so does this.
+      return sites.filter((site) => !String(site.scriptName ?? '').startsWith('node:')).slice(0, frameCount);
+    } finally {
+      Error.prepareStackTrace = original;
+      Error.stackTraceLimit = limit;
+    }
+  },
+
+  /**
+   * 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> => {
+    const parsed: Record<string, string> = {};
+    const text = String(content);
+    let at = 0;
+    while (at < text.length) {
+      // A line's key, up to its `=`; anything with no `=` is not a setting.
+      let lineEnd = text.indexOf('\n', at);
+      if (lineEnd === -1) lineEnd = text.length;
+      let line = text.slice(at, lineEnd);
+      const hash = line.indexOf('#');
+      const keyEnd = line.indexOf('=');
+      if (keyEnd === -1 || (hash !== -1 && hash < keyEnd)) { at = lineEnd + 1; continue; }
+      let key = line.slice(0, keyEnd).trim();
+      if (key.startsWith('export ')) key = key.slice(7).trim();
+      if (key === '') { at = lineEnd + 1; continue; }
+
+      const rest = text.slice(at + keyEnd + 1);
+      const first = rest[rest.search(/\S|$/u)];
+      if (first === '"' || first === "'" || first === '`') {
+        // A quoted value ends at its own closing quote, wherever that is.
+        const open = at + keyEnd + 1 + rest.indexOf(first);
+        const close = text.indexOf(first, open + 1);
+        if (close !== -1) {
+          const value = text.slice(open + 1, close);
+          parsed[key] = first === '"' ? value.replace(/\\n/gu, '\n').replace(/\\r/gu, '\r') : value;
+          const after = text.indexOf('\n', close);
+          at = after === -1 ? text.length : after + 1;
+          continue;
+        }
+      }
+      // An unquoted value runs to the end of its line, minus any comment.
+      line = text.slice(at + keyEnd + 1, lineEnd);
+      const comment = line.indexOf('#');
+      parsed[key] = (comment === -1 ? line : line.slice(0, comment)).trim();
+      at = lineEnd + 1;
+    }
+    return parsed;
+  },
+
+  /**
+   * 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 => {
+    const until = Date.now() + milliseconds;
+    while (Date.now() < until) { /* the caller asked to block */ }
+  },
+};
+
+export default utilBinding;

package/src/node-lib/binding/uv.ts

@@ -0,0 +1,102 @@
+/**
+ * `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.
+ */
+
+/** The codes Node's `net`, `child_process` and their internals name. */
+const codes: Record<string, [number, string]> = {
+  UV_E2BIG: [-7, 'argument list too long'],
+  UV_EACCES: [-13, 'permission denied'],
+  UV_EADDRINUSE: [-98, 'address already in use'],
+  UV_EADDRNOTAVAIL: [-99, 'address not available'],
+  UV_EAFNOSUPPORT: [-97, 'address family not supported'],
+  UV_EAGAIN: [-11, 'resource temporarily unavailable'],
+  UV_EALREADY: [-114, 'connection already in progress'],
+  UV_EBADF: [-9, 'bad file descriptor'],
+  UV_EBUSY: [-16, 'resource busy or locked'],
+  UV_ECANCELED: [-125, 'operation canceled'],
+  UV_ECONNABORTED: [-103, 'software caused connection abort'],
+  UV_ECONNREFUSED: [-111, 'connection refused'],
+  UV_ECONNRESET: [-104, 'connection reset by peer'],
+  UV_EEXIST: [-17, 'file already exists'],
+  UV_EFAULT: [-14, 'bad address in system call argument'],
+  UV_EHOSTUNREACH: [-113, 'host is unreachable'],
+  UV_EINTR: [-4, 'interrupted system call'],
+  UV_EINVAL: [-22, 'invalid argument'],
+  UV_EIO: [-5, 'i/o error'],
+  UV_EISCONN: [-106, 'socket is already connected'],
+  UV_EISDIR: [-21, 'illegal operation on a directory'],
+  UV_EMFILE: [-24, 'too many open files'],
+  UV_ENAMETOOLONG: [-36, 'name too long'],
+  UV_ENETDOWN: [-100, 'network is down'],
+  UV_ENETUNREACH: [-101, 'network is unreachable'],
+  UV_ENFILE: [-23, 'file table overflow'],
+  UV_ENOBUFS: [-105, 'no buffer space available'],
+  UV_ENOENT: [-2, 'no such file or directory'],
+  UV_ENOMEM: [-12, 'not enough memory'],
+  UV_ENOSYS: [-38, 'function not implemented'],
+  UV_ENOTCONN: [-107, 'socket is not connected'],
+  UV_ENOTDIR: [-20, 'not a directory'],
+  UV_ENOTEMPTY: [-39, 'directory not empty'],
+  UV_ENOTSOCK: [-88, 'socket operation on non-socket'],
+  UV_ENOTSUP: [-95, 'operation not supported on socket'],
+  UV_EOF: [-4095, 'end of file'],
+  UV_EPERM: [-1, 'operation not permitted'],
+  UV_EPIPE: [-32, 'broken pipe'],
+  UV_EPROTO: [-71, 'protocol error'],
+  UV_ESHUTDOWN: [-108, 'cannot send after transport endpoint shutdown'],
+  UV_ESRCH: [-3, 'no such process'],
+  UV_ETIMEDOUT: [-110, 'connection timed out'],
+  UV_UNKNOWN: [-4094, 'unknown error'],
+};
+
+const names = new Map<number, string>();
+for (const [name, [value]] of Object.entries(codes)) if (!names.has(value)) names.set(value, name.slice(3));
+// The constants table (and a Darwin host's `require('constants')`) names
+// EADDRNOTAVAIL 49 and EAGAIN 35; `util.getSystemErrorName` reads this map,
+// so those numbers must name the same errors Linux's -99 and -11 do.
+if (!names.has(-49)) names.set(-49, 'EADDRNOTAVAIL');
+if (!names.has(-35)) names.set(-35, 'EAGAIN');
+
+/** libuv's `uv_err_name`: the code a number stands for, `UNKNOWN` for a number none does. */
+export function errname(code: number): string {
+  return names.get(code) ?? `Unknown system error ${code}`;
+}
+
+/** Node's `getErrorMap()`: every number to its `[name, message]` pair. */
+export function getErrorMap(): Map<number, [string, string]> {
+  const map = new Map<number, [string, string]>();
+  for (const [name, [value, message]] of Object.entries(codes)) {
+    if (!map.has(value)) map.set(value, [name.slice(3), message]);
+  }
+  if (!map.has(-49)) map.set(-49, ['EADDRNOTAVAIL', 'address not available']);
+  if (!map.has(-35)) map.set(-35, ['EAGAIN', 'resource temporarily unavailable']);
+  return map;
+}
+
+const uvBinding: Record<string, unknown> = { errname, getErrorMap };
+for (const [name, [value]] of Object.entries(codes)) uvBinding[name] = value;
+
+export const UV_EOF = codes.UV_EOF[0];
+export const UV_ECONNREFUSED = codes.UV_ECONNREFUSED[0];
+export const UV_ECONNRESET = codes.UV_ECONNRESET[0];
+export const UV_EADDRINUSE = codes.UV_EADDRINUSE[0];
+export const UV_ENOENT = codes.UV_ENOENT[0];
+export const UV_ENOTSOCK = codes.UV_ENOTSOCK[0];
+export const UV_EPIPE = codes.UV_EPIPE[0];
+export const UV_EINVAL = codes.UV_EINVAL[0];
+export const UV_ENOTCONN = codes.UV_ENOTCONN[0];
+export const UV_ECANCELED = codes.UV_ECANCELED[0];
+export const UV_ENOTSUP = codes.UV_ENOTSUP[0];
+export const UV_EBADF = codes.UV_EBADF[0];
+export const UV_ENOSYS = codes.UV_ENOSYS[0];
+export const UV_EADDRNOTAVAIL = codes.UV_EADDRNOTAVAIL[0];
+export const UV_EACCES = codes.UV_EACCES[0];
+export const UV_ENOBUFS = codes.UV_ENOBUFS[0];
+export const UV_ESRCH = codes.UV_ESRCH[0];
+
+export default uvBinding;

package/src/node-lib/binding/zlib-pako.ts

@@ -0,0 +1,50 @@
+/**
+ * zlib's own inflate and deflate, as pako ports them.
+ *
+ * pako is already the engine's dependency, and `pako/lib/zlib/*` is not
+ * pako's convenience API -- it is zlib's `inflate.c` and `deflate.c` ported
+ * line for line, taking a `z_stream` and honouring `next_in`, `avail_in`,
+ * `next_out` and `avail_out` exactly as the C does. `./zlib.ts` says why the
+ * binding sits at this layer and not on pako's `Inflate`/`Deflate`, which
+ * cannot answer Node's contract.
+ */
+import ZStream from 'pako/lib/zlib/zstream.js';
+import * as pakoInflate from 'pako/lib/zlib/inflate.js';
+import * as pakoDeflate from 'pako/lib/zlib/deflate.js';
+import pakoConstants from 'pako/lib/zlib/constants.js';
+import pakoCrc32 from 'pako/lib/zlib/crc32.js';
+import pakoMessages from 'pako/lib/zlib/messages.js';
+
+/** A fresh `z_stream`, the object every call below reads and writes. */
+export function zstream(): Record<string, unknown> {
+  return new (ZStream as unknown as new () => Record<string, unknown>)();
+}
+
+export const inflateModule = pakoInflate as unknown as {
+  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 const deflateModule = pakoDeflate as unknown as {
+  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 const zlibConstants: Record<string, number> & {
+  messages: Record<number, string>;
+  crc32: (crc: number, buffer: Uint8Array, length: number, position: number) => number;
+} = {
+  ...(pakoConstants as unknown as Record<string, number>),
+  messages: pakoMessages as unknown as Record<number, string>,
+  crc32: pakoCrc32 as unknown as (crc: number, buffer: Uint8Array, length: number, position: number) => number,
+} as Record<string, number> & {
+  messages: Record<number, string>;
+  crc32: (crc: number, buffer: Uint8Array, length: number, position: number) => number;
+};