@scriptc/compiler 0.4.5 → 0.4.6

package/ambient/node-fallback/os.d.ts

@@ -0,0 +1,288 @@
+/* node:os — the slice a CLI needs: platform() (same implementation as
+ * process.platform), homedir(), tmpdir() (Node's env cascade), EOL
+ * (always "\n" — POSIX pinned, like path.sep), and networkInterfaces()
+ * (getifaddrs(3); the interface shapes mirror @types/node's exactly so
+ * both type worlds map to the same IR structure). */
+declare module "os" {
+  export function platform(): string;
+  export function homedir(): string;
+  export function tmpdir(): string;
+  /* uname(2)'s release field — Node's own implementation. */
+  export function release(): string;
+  /* uname(2)'s sysname field ("Darwin", "Linux") — Node's os.type(). */
+  export function type(): string;
+  /* Total system memory in bytes (sysctl hw.memsize / sysconf). */
+  export function totalmem(): number;
+  export function availableParallelism(): number;
+  /* The passwd-entry snapshot (uv_os_get_passwd): shell is `string |
+   * null` to match @types/node (POSIX always answers the string arm);
+   * homedir is pw_dir — NOT os.homedir()'s $HOME-first cascade. The type
+   * is interned explicitly in type-mapper.ts (the AddressInfo pattern — this
+   * concrete form and @types/node's UserInfo<string> both), and the call
+   * assembles field-by-field in lowerOsUserInfoCall. */
+  export interface UserInfo {
+    username: string;
+    uid: number;
+    gid: number;
+    shell: string | null;
+    homedir: string;
+  }
+  export function userInfo(): UserInfo;
+  /* The TARGET platform's line terminator (a compile-time constant:
+   * "\r\n" under a win32 triple, "\n" everywhere else). */
+  export const EOL: "\r\n" | "\n";
+  export interface NetworkInterfaceBase {
+    address: string;
+    netmask: string;
+    mac: string;
+    internal: boolean;
+    cidr: string | null;
+    scopeid?: number;
+  }
+  export interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
+    family: "IPv4";
+  }
+  export interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
+    family: "IPv6";
+    scopeid: number;
+  }
+  export type NetworkInterfaceInfo = NetworkInterfaceInfoIPv4 | NetworkInterfaceInfoIPv6;
+  export function networkInterfaces(): { [name: string]: NetworkInterfaceInfo[] | undefined };
+  /* Host facts, libuv's answers: model/speed/times per logical CPU, the
+   * host name, the 1/5/15-minute load averages, uptime in seconds, free
+   * memory in bytes, process.arch, uname's machine and version fields,
+   * the byte order, and a process's scheduling priority (an omitted pid
+   * is the current process). Shapes mirror @types/node's. */
+  export interface CpuInfo {
+    model: string;
+    speed: number;
+    times: {
+      user: number;
+      nice: number;
+      sys: number;
+      idle: number;
+      irq: number;
+    };
+  }
+  export function cpus(): CpuInfo[];
+  export function hostname(): string;
+  export function loadavg(): number[];
+  export function uptime(): number;
+  export function freemem(): number;
+  export function arch(): string;
+  export function machine(): string;
+  export function version(): string;
+  export function endianness(): "BE" | "LE";
+  export function getPriority(pid?: number): number;
+  export function setPriority(priority: number): void;
+  export function setPriority(pid: number, priority: number): void;
+  /* The TARGET platform's null device ("\\\\.\\nul" under a win32 triple). */
+  export const devNull: string;
+  /* The platform's constants: null-prototype objects with read-only
+   * members, `signals` frozen (Node's internalBinding('constants').os). */
+  export type SignalConstants = {
+    [
+      key in
+        | "SIGABRT"
+        | "SIGALRM"
+        | "SIGBUS"
+        | "SIGCHLD"
+        | "SIGCONT"
+        | "SIGFPE"
+        | "SIGHUP"
+        | "SIGILL"
+        | "SIGINT"
+        | "SIGIO"
+        | "SIGIOT"
+        | "SIGKILL"
+        | "SIGPIPE"
+        | "SIGPOLL"
+        | "SIGPROF"
+        | "SIGPWR"
+        | "SIGQUIT"
+        | "SIGSEGV"
+        | "SIGSTKFLT"
+        | "SIGSTOP"
+        | "SIGSYS"
+        | "SIGTERM"
+        | "SIGTRAP"
+        | "SIGTSTP"
+        | "SIGTTIN"
+        | "SIGTTOU"
+        | "SIGUNUSED"
+        | "SIGURG"
+        | "SIGUSR1"
+        | "SIGUSR2"
+        | "SIGVTALRM"
+        | "SIGWINCH"
+        | "SIGXCPU"
+        | "SIGXFSZ"
+        | "SIGBREAK"
+        | "SIGLOST"
+        | "SIGINFO"
+    ]: number;
+  };
+  export namespace constants {
+    const UV_UDP_REUSEADDR: number;
+    namespace signals {}
+    const signals: SignalConstants;
+    namespace errno {
+      const E2BIG: number;
+      const EACCES: number;
+      const EADDRINUSE: number;
+      const EADDRNOTAVAIL: number;
+      const EAFNOSUPPORT: number;
+      const EAGAIN: number;
+      const EALREADY: number;
+      const EBADF: number;
+      const EBADMSG: number;
+      const EBUSY: number;
+      const ECANCELED: number;
+      const ECHILD: number;
+      const ECONNABORTED: number;
+      const ECONNREFUSED: number;
+      const ECONNRESET: number;
+      const EDEADLK: number;
+      const EDESTADDRREQ: number;
+      const EDOM: number;
+      const EDQUOT: number;
+      const EEXIST: number;
+      const EFAULT: number;
+      const EFBIG: number;
+      const EHOSTUNREACH: number;
+      const EIDRM: number;
+      const EILSEQ: number;
+      const EINPROGRESS: number;
+      const EINTR: number;
+      const EINVAL: number;
+      const EIO: number;
+      const EISCONN: number;
+      const EISDIR: number;
+      const ELOOP: number;
+      const EMFILE: number;
+      const EMLINK: number;
+      const EMSGSIZE: number;
+      const EMULTIHOP: number;
+      const ENAMETOOLONG: number;
+      const ENETDOWN: number;
+      const ENETRESET: number;
+      const ENETUNREACH: number;
+      const ENFILE: number;
+      const ENOBUFS: number;
+      const ENODATA: number;
+      const ENODEV: number;
+      const ENOENT: number;
+      const ENOEXEC: number;
+      const ENOLCK: number;
+      const ENOLINK: number;
+      const ENOMEM: number;
+      const ENOMSG: number;
+      const ENOPROTOOPT: number;
+      const ENOSPC: number;
+      const ENOSR: number;
+      const ENOSTR: number;
+      const ENOSYS: number;
+      const ENOTCONN: number;
+      const ENOTDIR: number;
+      const ENOTEMPTY: number;
+      const ENOTSOCK: number;
+      const ENOTSUP: number;
+      const ENOTTY: number;
+      const ENXIO: number;
+      const EOPNOTSUPP: number;
+      const EOVERFLOW: number;
+      const EPERM: number;
+      const EPIPE: number;
+      const EPROTO: number;
+      const EPROTONOSUPPORT: number;
+      const EPROTOTYPE: number;
+      const ERANGE: number;
+      const EROFS: number;
+      const ESPIPE: number;
+      const ESRCH: number;
+      const ESTALE: number;
+      const ETIME: number;
+      const ETIMEDOUT: number;
+      const ETXTBSY: number;
+      const EWOULDBLOCK: number;
+      const EXDEV: number;
+      const WSAEINTR: number;
+      const WSAEBADF: number;
+      const WSAEACCES: number;
+      const WSAEFAULT: number;
+      const WSAEINVAL: number;
+      const WSAEMFILE: number;
+      const WSAEWOULDBLOCK: number;
+      const WSAEINPROGRESS: number;
+      const WSAEALREADY: number;
+      const WSAENOTSOCK: number;
+      const WSAEDESTADDRREQ: number;
+      const WSAEMSGSIZE: number;
+      const WSAEPROTOTYPE: number;
+      const WSAENOPROTOOPT: number;
+      const WSAEPROTONOSUPPORT: number;
+      const WSAESOCKTNOSUPPORT: number;
+      const WSAEOPNOTSUPP: number;
+      const WSAEPFNOSUPPORT: number;
+      const WSAEAFNOSUPPORT: number;
+      const WSAEADDRINUSE: number;
+      const WSAEADDRNOTAVAIL: number;
+      const WSAENETDOWN: number;
+      const WSAENETUNREACH: number;
+      const WSAENETRESET: number;
+      const WSAECONNABORTED: number;
+      const WSAECONNRESET: number;
+      const WSAENOBUFS: number;
+      const WSAEISCONN: number;
+      const WSAENOTCONN: number;
+      const WSAESHUTDOWN: number;
+      const WSAETOOMANYREFS: number;
+      const WSAETIMEDOUT: number;
+      const WSAECONNREFUSED: number;
+      const WSAELOOP: number;
+      const WSAENAMETOOLONG: number;
+      const WSAEHOSTDOWN: number;
+      const WSAEHOSTUNREACH: number;
+      const WSAENOTEMPTY: number;
+      const WSAEPROCLIM: number;
+      const WSAEUSERS: number;
+      const WSAEDQUOT: number;
+      const WSAESTALE: number;
+      const WSAEREMOTE: number;
+      const WSASYSNOTREADY: number;
+      const WSAVERNOTSUPPORTED: number;
+      const WSANOTINITIALISED: number;
+      const WSAEDISCON: number;
+      const WSAENOMORE: number;
+      const WSAECANCELLED: number;
+      const WSAEINVALIDPROCTABLE: number;
+      const WSAEINVALIDPROVIDER: number;
+      const WSAEPROVIDERFAILEDINIT: number;
+      const WSASYSCALLFAILURE: number;
+      const WSASERVICE_NOT_FOUND: number;
+      const WSATYPE_NOT_FOUND: number;
+      const WSA_E_NO_MORE: number;
+      const WSA_E_CANCELLED: number;
+      const WSAEREFUSED: number;
+    }
+    namespace dlopen {
+      const RTLD_LAZY: number;
+      const RTLD_NOW: number;
+      const RTLD_GLOBAL: number;
+      const RTLD_LOCAL: number;
+      const RTLD_DEEPBIND: number;
+    }
+    namespace priority {
+      const PRIORITY_LOW: number;
+      const PRIORITY_BELOW_NORMAL: number;
+      const PRIORITY_NORMAL: number;
+      const PRIORITY_ABOVE_NORMAL: number;
+      const PRIORITY_HIGH: number;
+      const PRIORITY_HIGHEST: number;
+    }
+  }
+}
+
+declare module "node:os" {
+  export * from "os";
+}

package/ambient/node-fallback/path-posix.d.ts

@@ -0,0 +1,22 @@
+/// <reference path="./path.d.ts" />
+
+declare module "path/posix" {
+  export function join(...paths: string[]): string;
+  export function resolve(...paths: string[]): string;
+  export function normalize(path: string): string;
+  export function dirname(path: string): string;
+  export function basename(path: string, suffix?: string): string;
+  export function extname(path: string): string;
+  export function isAbsolute(path: string): boolean;
+  export function relative(from: string, to: string): string;
+  export function toNamespacedPath(path: string): string;
+  export function matchesGlob(path: string, pattern: string): boolean;
+  export function parse(path: string): import("path").ParsedPath;
+  export function format(pathObject: import("path").FormatInputPathObject): string;
+  export const sep: "/";
+  export const delimiter: ":";
+}
+
+declare module "node:path/posix" {
+  export * from "path/posix";
+}

package/ambient/node-fallback/path-win32.d.ts

@@ -0,0 +1,22 @@
+/// <reference path="./path.d.ts" />
+
+declare module "path/win32" {
+  export function join(...paths: string[]): string;
+  export function resolve(...paths: string[]): string;
+  export function normalize(path: string): string;
+  export function dirname(path: string): string;
+  export function basename(path: string, suffix?: string): string;
+  export function extname(path: string): string;
+  export function isAbsolute(path: string): boolean;
+  export function relative(from: string, to: string): string;
+  export function toNamespacedPath(path: string): string;
+  export function matchesGlob(path: string, pattern: string): boolean;
+  export function parse(path: string): import("path").ParsedPath;
+  export function format(pathObject: import("path").FormatInputPathObject): string;
+  export const sep: "\\";
+  export const delimiter: ";";
+}
+
+declare module "node:path/win32" {
+  export * from "path/win32";
+}

package/ambient/node-fallback/path.d.ts

@@ -0,0 +1,55 @@
+/// <reference path="./path-posix.d.ts" />
+/// <reference path="./path-win32.d.ts" />
+
+/* node:path — the TARGET platform's implementation (Node's rule): posix
+ * on posix triples, path.win32 under a win32 triple, with the posix and
+ * win32 namespaces answering their own platform anywhere. Every function
+ * is a pure string algorithm matching Node's implementations
+ * exactly; join/resolve are variadic like Node's. */
+declare module "path" {
+  export function join(...paths: string[]): string;
+  export function resolve(...paths: string[]): string;
+  export function normalize(path: string): string;
+  export function dirname(path: string): string;
+  export function basename(path: string, suffix?: string): string;
+  export function extname(path: string): string;
+  export function isAbsolute(path: string): boolean;
+  export function relative(from: string, to: string): string;
+  export function toNamespacedPath(path: string): string;
+  /* matchesGlob() is Node's glob matcher: brace expansion, extglobs, POSIX
+   * classes and the ** and dot rules. */
+  export function matchesGlob(path: string, pattern: string): boolean;
+  /* parse() splits a path into its root, directory, base, extension and
+   * name; format() joins those fields back (Node's `||` defaults). */
+  export interface ParsedPath {
+    root: string;
+    dir: string;
+    base: string;
+    ext: string;
+    name: string;
+  }
+  export interface FormatInputPathObject {
+    root?: string | undefined;
+    dir?: string | undefined;
+    base?: string | undefined;
+    ext?: string | undefined;
+    name?: string | undefined;
+  }
+  export function parse(path: string): ParsedPath;
+  export function format(pathObject: FormatInputPathObject): string;
+  /* The union @types/node declares: the bare module answers the TARGET
+   * platform's value (a compile-time constant — "\\"/";" under a win32
+   * triple, "/"/":" everywhere else). */
+  export const sep: "\\" | "/";
+  export const delimiter: ";" | ":";
+  /* The platform-specific namespaces (real Node submodules too —
+   * "node:path/posix" resolves). Each carries the FULL surface and
+   * answers ITS platform's rules on any target, Node's own contract;
+   * the bare module IS the target platform's implementation. */
+  export const posix: typeof import("path/posix");
+  export const win32: typeof import("path/win32");
+}
+
+declare module "node:path" {
+  export * from "path";
+}

package/ambient/node-fallback/process.d.ts

@@ -0,0 +1,11 @@
+/* Node's process module default export is the global process object. These
+ * declaration aliases let the ESM spelling typecheck against the same
+ * deliberately narrow fallback surface when @types/node is absent. */
+declare module "process" {
+  export = process;
+}
+
+declare module "node:process" {
+  import process = require("process");
+  export = process;
+}

package/ambient/node-fallback/punycode.d.ts

@@ -0,0 +1,18 @@
+/* node:punycode (deprecated, DEP0040) — punycode.js 2.1.0: decode and
+ * toUnicode throw its RangeErrors on malformed input; ucs2 converts
+ * between strings and UTF-16 code point arrays. */
+declare module "punycode" {
+  export function decode(string: string): string;
+  export function encode(string: string): string;
+  export function toUnicode(domain: string): string;
+  export function toASCII(domain: string): string;
+  export namespace ucs2 {
+    function decode(string: string): number[];
+    function encode(codePoints: readonly number[]): string;
+  }
+  export const version: string;
+}
+
+declare module "node:punycode" {
+  export * from "punycode";
+}

package/ambient/node-fallback/querystring.d.ts

@@ -0,0 +1,55 @@
+/* node:querystring — Node's legacy query-string codec (NOT
+ * URLSearchParams: '+' means space on the parse side and escape encodes
+ * spaces as %20). parse answers the null-prototype dictionary as a pure
+ * index-signature record (repeated keys become string[] buckets;
+ * @types/node's Dict adds an undefined arm the lowering tolerates);
+ * stringify serializes string/number/boolean values and arrays of those
+ * (Node's rules: arrays expand to repeated keys, null/undefined and
+ * anything else serialize as the empty value). The maxKeys option lowers
+ * (0 removes the cap, Node's rule); the custom encoder/decoder options
+ * typecheck under the options-record stance and fence by name at the
+ * call. decode/encode are Node's own aliases of parse/stringify. */
+declare module "querystring" {
+  export interface ParseOptions {
+    maxKeys?: number;
+    decodeURIComponent?: (str: string) => string;
+    [option: string]: unknown;
+  }
+  export interface StringifyOptions {
+    encodeURIComponent?: (str: string) => string;
+    [option: string]: unknown;
+  }
+  export interface ParsedUrlQuery {
+    [key: string]: string | string[] | undefined;
+  }
+  export interface ParsedUrlQueryInput {
+    [key: string]:
+      | string
+      | number
+      | boolean
+      | bigint
+      | ReadonlyArray<string | number | boolean | bigint>
+      | null
+      | undefined;
+  }
+  export function parse(
+    str: string,
+    sep?: string | null,
+    eq?: string | null,
+    options?: ParseOptions,
+  ): ParsedUrlQuery;
+  export function stringify(
+    obj?: ParsedUrlQueryInput,
+    sep?: string | null,
+    eq?: string | null,
+    options?: StringifyOptions,
+  ): string;
+  export const decode: typeof parse;
+  export const encode: typeof stringify;
+  export function escape(str: string): string;
+  export function unescape(str: string): string;
+}
+
+declare module "node:querystring" {
+  export * from "querystring";
+}

package/ambient/node-fallback/stream-consumers.d.ts

@@ -0,0 +1,21 @@
+declare module "stream/consumers" {
+  /* The promise consumers over a readable: accumulate every chunk and
+   * settle — text (the utf8 decode), json (the text through JSON.parse:
+   * `unknown`, validated with a checked cast; malformed input rejects
+   * with the parse's SyntaxError), buffer (the concatenated bytes;
+   * string chunks contribute their utf8 bytes, Node's Blob rule).
+   * Stream errors reject; an early close rejects with
+   * ERR_STREAM_PREMATURE_CLOSE. arrayBuffer answers an ArrayBuffer over
+   * the bytes; blob fences per site. */
+  function text(stream: unknown): Promise<string>;
+  function json(stream: unknown): Promise<unknown>;
+  function buffer(stream: unknown): Promise<Buffer>;
+  function arrayBuffer(stream: unknown): Promise<ArrayBuffer>;
+  function blob(stream: unknown): Promise<unknown>;
+  export { arrayBuffer, blob, buffer, json, text };
+}
+
+declare module "node:stream/consumers" {
+  import streamConsumers = require("stream/consumers");
+  export = streamConsumers;
+}

package/ambient/node-fallback/stream-promises.d.ts

@@ -0,0 +1,28 @@
+/// <reference path="./stream.d.ts" />
+
+declare module "stream/promises" {
+  /* The promise forms of finished/pipeline: a void promise the stream's
+   * terminal point settles (rejected with the error, or
+   * ERR_STREAM_PREMATURE_CLOSE on an early close). Stream arguments are
+   * the lowered surface — iterables/generators/functions fence per site.
+   * pipeline's trailing { signal, end } object and finished's options
+   * (readable, writable, error, cleanup, signal) are supported. A last
+   * stage that is an async function resolves the promise with its value. */
+  function pipeline<T extends unknown[]>(...streams: T): import("stream").PipelinePromise<T>;
+  function finished(
+    stream: unknown,
+    options?: {
+      readable?: boolean;
+      writable?: boolean;
+      error?: boolean;
+      cleanup?: boolean;
+      signal?: AbortSignal;
+    } | null,
+  ): Promise<void>;
+  export { pipeline, finished };
+}
+
+declare module "node:stream/promises" {
+  import streamPromises = require("stream/promises");
+  export = streamPromises;
+}

package/ambient/node-fallback/stream-web.d.ts

@@ -0,0 +1,36 @@
+/* node:stream/web — the module exports the web stream globals themselves
+ * (require("stream/web").ReadableStream === globalThis.ReadableStream). */
+declare module "stream/web" {
+  export const ReadableStream: typeof globalThis.ReadableStream;
+  export type ReadableStream<T = unknown> = globalThis.ReadableStream<T>;
+  export const ReadableStreamDefaultReader: typeof globalThis.ReadableStreamDefaultReader;
+  export type ReadableStreamDefaultReader<T = unknown> = globalThis.ReadableStreamDefaultReader<T>;
+  export const ReadableStreamDefaultController: typeof globalThis.ReadableStreamDefaultController;
+  export type ReadableStreamDefaultController<T = unknown> =
+    globalThis.ReadableStreamDefaultController<T>;
+  export const WritableStream: typeof globalThis.WritableStream;
+  export type WritableStream<W = unknown> = globalThis.WritableStream<W>;
+  export const WritableStreamDefaultWriter: typeof globalThis.WritableStreamDefaultWriter;
+  export type WritableStreamDefaultWriter<W = unknown> = globalThis.WritableStreamDefaultWriter<W>;
+  export const WritableStreamDefaultController: typeof globalThis.WritableStreamDefaultController;
+  export type WritableStreamDefaultController = globalThis.WritableStreamDefaultController;
+  export const TransformStream: typeof globalThis.TransformStream;
+  export type TransformStream<I = unknown, O = unknown> = globalThis.TransformStream<I, O>;
+  export const TransformStreamDefaultController: typeof globalThis.TransformStreamDefaultController;
+  export type TransformStreamDefaultController<O = unknown> =
+    globalThis.TransformStreamDefaultController<O>;
+  export const CountQueuingStrategy: typeof globalThis.CountQueuingStrategy;
+  export type CountQueuingStrategy = globalThis.CountQueuingStrategy;
+  export const ByteLengthQueuingStrategy: typeof globalThis.ByteLengthQueuingStrategy;
+  export type ByteLengthQueuingStrategy = globalThis.ByteLengthQueuingStrategy;
+  export const TextEncoderStream: typeof globalThis.TextEncoderStream;
+  export type TextEncoderStream = globalThis.TextEncoderStream;
+  export const TextDecoderStream: typeof globalThis.TextDecoderStream;
+  export type TextDecoderStream = globalThis.TextDecoderStream;
+  export type UnderlyingSource<T = unknown> = globalThis.UnderlyingSource<T>;
+  export type QueuingStrategy<T = unknown> = globalThis.QueuingStrategy<T>;
+}
+
+declare module "node:stream/web" {
+  export * from "stream/web";
+}