@serveryyswys/node.operit 0.0.0-stage → 0.1.2

package/dist/string_decoder.d.ts

@@ -0,0 +1,15 @@
+export declare class StringDecoder {
+    static StringDecoder: typeof StringDecoder;
+    readonly encoding: string;
+    private pending;
+    constructor(encoding?: string);
+    get lastNeed(): number;
+    get lastTotal(): number;
+    get lastChar(): Uint8Array;
+    write(buffer: Uint8Array): string;
+    end(buffer?: Uint8Array): string;
+    private combine;
+    private writeUtf8;
+    private writeUtf16;
+    private writeBase64;
+}

package/dist/string_decoder.js

@@ -0,0 +1,237 @@
+'use strict';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringDecoder = void 0;
+/**
+ * Node string_decoder 模块的移植。
+ *
+ * 三种编码的缓冲语义（照 Node 实测行为）：
+ *   utf8     末尾不完整的字符缓起来；end() 只吐**一个** U+FFFD，不按字节数吐
+ *   utf16le  末尾悬空的单字节缓起来；end() 直接丢弃（不吐替换字符）
+ *   base64   缓冲的是**输入字节**：每 3 字节输出 4 个 base64 字符，end() 用带 padding 的形式收尾
+ *   hex/ascii/latin1  无缓冲
+ */
+const bytesCodec = __importStar(require("./lib/bytes"));
+function normalizeEncoding(encoding) {
+    const value = typeof encoding === 'string' ? encoding.toLowerCase() : 'utf8';
+    if (value === 'utf-8') {
+        return 'utf8';
+    }
+    if (value === 'binary') {
+        return 'latin1';
+    }
+    if (value === 'ucs2' || value === 'ucs-2' || value === 'utf-16le') {
+        return 'utf16le';
+    }
+    if (value === 'utf8' || value === 'utf16le' || value === 'latin1' || value === 'ascii' || value === 'base64' || value === 'hex') {
+        return value;
+    }
+    throw new TypeError('Unknown encoding: ' + String(encoding));
+}
+/** UTF-8 序列首字节应有的总长度；非法首字节按 1 处理（交给解码器吐替换字符）。 */
+function utf8SequenceLength(byte) {
+    if (byte < 0x80) {
+        return 1;
+    }
+    if (byte >= 0xc2 && byte <= 0xdf) {
+        return 2;
+    }
+    if (byte >= 0xe0 && byte <= 0xef) {
+        return 3;
+    }
+    if (byte >= 0xf0 && byte <= 0xf4) {
+        return 4;
+    }
+    return 1;
+}
+/** 返回 bytes 中最长的、以完整字符结尾的前缀长度。 */
+function completePrefixLength(bytes) {
+    let index = bytes.length;
+    let lookback = 0;
+    while (index > 0 && lookback < 4) {
+        index -= 1;
+        lookback += 1;
+        const byte = bytes[index];
+        if (byte < 0x80) {
+            return bytes.length;
+        }
+        if (byte >= 0xc0) {
+            return index + utf8SequenceLength(byte) > bytes.length ? index : bytes.length;
+        }
+    }
+    return bytes.length;
+}
+class StringDecoder {
+    constructor(encoding) {
+        this.encoding = normalizeEncoding(encoding);
+        this.pending = new Uint8Array(0);
+    }
+    get lastNeed() {
+        if (this.pending.length === 0) {
+            return 0;
+        }
+        if (this.encoding === 'utf8') {
+            return utf8SequenceLength(this.pending[0]) - this.pending.length;
+        }
+        if (this.encoding === 'utf16le') {
+            return 1;
+        }
+        if (this.encoding === 'base64') {
+            return 3 - this.pending.length;
+        }
+        return 0;
+    }
+    get lastTotal() {
+        if (this.pending.length === 0) {
+            return 0;
+        }
+        if (this.encoding === 'utf8') {
+            return utf8SequenceLength(this.pending[0]);
+        }
+        if (this.encoding === 'utf16le') {
+            return 2;
+        }
+        if (this.encoding === 'base64') {
+            return 3;
+        }
+        return 0;
+    }
+    get lastChar() {
+        return this.pending;
+    }
+    write(buffer) {
+        if (!(buffer instanceof Uint8Array)) {
+            throw new TypeError('The "buf" argument must be an instance of Buffer or Uint8Array.');
+        }
+        if (this.encoding === 'utf8') {
+            return this.writeUtf8(buffer);
+        }
+        if (this.encoding === 'utf16le') {
+            return this.writeUtf16(buffer);
+        }
+        if (this.encoding === 'base64') {
+            return this.writeBase64(buffer);
+        }
+        if (this.encoding === 'hex') {
+            return hexOf(buffer);
+        }
+        if (this.encoding === 'ascii') {
+            return asciiOf(buffer);
+        }
+        return bytesCodec.bytesToLatin1(buffer);
+    }
+    end(buffer) {
+        let text = '';
+        if (buffer !== undefined && buffer.length > 0) {
+            text = this.write(buffer);
+        }
+        if (this.pending.length === 0) {
+            return text;
+        }
+        const pending = this.pending;
+        this.pending = new Uint8Array(0);
+        if (this.encoding === 'utf8') {
+            return text + '�';
+        }
+        if (this.encoding === 'base64') {
+            return text + bytesCodec.encodeBase64(pending);
+        }
+        // utf16le 的悬空半字符与 hex/ascii/latin1 一样没有残留，直接结束
+        return text;
+    }
+    combine(buffer) {
+        if (this.pending.length === 0) {
+            return buffer;
+        }
+        const merged = new Uint8Array(this.pending.length + buffer.length);
+        merged.set(this.pending);
+        merged.set(buffer, this.pending.length);
+        this.pending = new Uint8Array(0);
+        return merged;
+    }
+    writeUtf8(buffer) {
+        const merged = this.combine(buffer);
+        const complete = completePrefixLength(merged);
+        if (complete < merged.length) {
+            const rest = merged.subarray(complete);
+            this.pending = new Uint8Array(rest.length);
+            this.pending.set(rest);
+        }
+        return bytesCodec.utf8Decode(merged.subarray(0, complete));
+    }
+    writeUtf16(buffer) {
+        const merged = this.combine(buffer);
+        let usable = merged.length;
+        if (usable % 2 === 1) {
+            usable -= 1;
+            this.pending = new Uint8Array([merged[merged.length - 1]]);
+        }
+        return decodeUtf16Pairs(merged.subarray(0, usable));
+    }
+    writeBase64(buffer) {
+        const merged = this.combine(buffer);
+        const usable = merged.length - (merged.length % 3);
+        if (usable < merged.length) {
+            const rest = merged.subarray(usable);
+            this.pending = new Uint8Array(rest.length);
+            this.pending.set(rest);
+        }
+        return bytesCodec.encodeBase64(merged.subarray(0, usable));
+    }
+}
+exports.StringDecoder = StringDecoder;
+StringDecoder.StringDecoder = StringDecoder;
+function hexOf(buffer) {
+    const digits = '0123456789abcdef';
+    let out = '';
+    for (let i = 0; i < buffer.length; i += 1) {
+        out += digits.charAt(buffer[i] >> 4) + digits.charAt(buffer[i] & 15);
+    }
+    return out;
+}
+function decodeUtf16Pairs(buffer) {
+    let out = '';
+    for (let i = 0; i + 1 < buffer.length; i += 2) {
+        out += String.fromCharCode(buffer[i] | (buffer[i + 1] << 8));
+    }
+    return out;
+}
+function asciiOf(buffer) {
+    let out = '';
+    for (let i = 0; i < buffer.length; i += 1) {
+        out += String.fromCharCode(buffer[i] & 0x7f);
+    }
+    return out;
+}

package/dist/timers/promises.d.ts

@@ -0,0 +1,19 @@
+/**
+ * timers/promises 子路径入口。
+ *
+ * 与 Node 的差异（都写进了 BUILTINS.json）：
+ *   - setInterval 用「每次 await 一个 setTimeout」实现，而不是原生 interval，
+ *     所以延迟会随迭代次数累积漂移；好处是取消语义直白、与 Node 的可迭代行为一致。
+ *   - signal 只按结构检查（aborted / addEventListener），因为没有 AbortController。
+ */
+import type { TimerOptions } from '../lib/timers-types';
+declare const api: {
+    setTimeout: (delayMs?: number, value?: unknown, options?: TimerOptions) => Promise<unknown>;
+    setImmediate: (value?: unknown, options?: TimerOptions) => Promise<unknown>;
+    setInterval: (delayMs: number, value?: unknown, options?: TimerOptions) => AsyncGenerator<unknown>;
+    scheduler: {
+        wait: (delayMs?: number, options?: TimerOptions) => Promise<void>;
+        yield: () => Promise<void>;
+    };
+};
+export = api;

package/dist/timers/promises.js

@@ -0,0 +1,74 @@
+'use strict';
+function abortFailure() {
+    const error = new Error('The operation was aborted');
+    error.name = 'AbortError';
+    error.code = 'ABORT_ERR';
+    return error;
+}
+function alreadyAborted(signal) {
+    return signal !== undefined && signal.aborted === true;
+}
+/** 到点后用 value 决议；signal 中止则用 AbortError 拒绝。 */
+function waitFor(delayMs, value, options) {
+    return new Promise(function (resolve, reject) {
+        const signal = options === undefined ? undefined : options.signal;
+        if (alreadyAborted(signal)) {
+            reject(abortFailure());
+            return;
+        }
+        let settled = false;
+        const handle = setTimeout(function () {
+            settled = true;
+            detach();
+            resolve(value);
+        }, delayMs);
+        const onAbort = function () {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            detach();
+            clearTimeout(handle);
+            reject(abortFailure());
+        };
+        function detach() {
+            if (signal !== undefined && typeof signal.removeEventListener === 'function') {
+                signal.removeEventListener('abort', onAbort);
+            }
+        }
+        if (signal !== undefined && typeof signal.addEventListener === 'function') {
+            signal.addEventListener('abort', onAbort);
+        }
+    });
+}
+async function* interval(delayMs, value, options) {
+    for (;;) {
+        await waitFor(delayMs, undefined, options);
+        yield value;
+    }
+}
+const scheduler = {
+    wait: function (delayMs, options) {
+        return waitFor(delayMs === undefined ? 1 : delayMs, undefined, options);
+    },
+    yield: function () {
+        return new Promise(function (resolve) {
+            queueMicrotask(function () {
+                resolve();
+            });
+        });
+    }
+};
+const api = {
+    setTimeout: function (delayMs, value, options) {
+        return waitFor(delayMs === undefined ? 1 : delayMs, value, options);
+    },
+    setImmediate: function (value, options) {
+        return waitFor(0, value, options);
+    },
+    setInterval: function (delayMs, value, options) {
+        return interval(delayMs, value, options);
+    },
+    scheduler: scheduler
+};
+module.exports = api;

package/dist/timers.d.ts

@@ -0,0 +1,21 @@
+import type { TimerOptions } from './lib/timers-types';
+declare function setImmediate(handler: (...args: unknown[]) => void, ...args: unknown[]): unknown;
+declare function clearImmediate(handle: unknown): void;
+declare const api: {
+    setTimeout: typeof setTimeout;
+    clearTimeout: typeof clearTimeout;
+    setInterval: typeof setInterval;
+    clearInterval: typeof clearInterval;
+    setImmediate: typeof setImmediate;
+    clearImmediate: typeof clearImmediate;
+    promises: {
+        setTimeout: (delayMs?: number, value?: unknown, options?: TimerOptions) => Promise<unknown>;
+        setImmediate: (value?: unknown, options?: TimerOptions) => Promise<unknown>;
+        setInterval: (delayMs: number, value?: unknown, options?: TimerOptions) => AsyncGenerator<unknown>;
+        scheduler: {
+            wait: (delayMs?: number, options?: TimerOptions) => Promise<void>;
+            yield: () => Promise<void>;
+        };
+    };
+};
+export = api;

package/dist/timers.js

@@ -0,0 +1,41 @@
+'use strict';
+/**
+ * timers 模块。
+ *
+ * 宿主（Operit）提供 setTimeout / clearTimeout / setInterval / clearInterval 全局，
+ * 所以这几个直接就是全局函数本身（Node 的 timers.setTimeout === 全局 setTimeout 也是这样）。
+ *
+ * setImmediate / clearImmediate 宿主没有，这里落在 setTimeout(…, 0) 上。
+ * 与 Node 的差别：Node 的 setImmediate 在 check 阶段、先于定时器；这里两者同一个队列，
+ * 因此 setImmediate(fn) 与 setTimeout(fn, 0) 是同一件事。已在 BUILTINS.json 写明。
+ */
+const timersPromises = require("./timers/promises");
+const promisifyCustom = Symbol.for('nodejs.util.promisify.custom');
+function setImmediate(handler, ...args) {
+    return setTimeout(handler, 0, ...args);
+}
+function clearImmediate(handle) {
+    clearTimeout(handle);
+}
+// promisify(setTimeout) 是很常见的写法，靠的就是 setTimeout 上的这个符号。
+// 宿主已经有就不动它（Node 上它是只读 getter，赋值会直接抛），没有才补上。
+if (Object.getOwnPropertyDescriptor(setTimeout, promisifyCustom) === undefined) {
+    Object.defineProperty(setTimeout, promisifyCustom, {
+        value: function (delayMs, value, options) {
+            return timersPromises.setTimeout(delayMs, value, options);
+        },
+        writable: true,
+        enumerable: false,
+        configurable: true
+    });
+}
+const api = {
+    setTimeout: setTimeout,
+    clearTimeout: clearTimeout,
+    setInterval: setInterval,
+    clearInterval: clearInterval,
+    setImmediate: setImmediate,
+    clearImmediate: clearImmediate,
+    promises: timersPromises
+};
+module.exports = api;

package/dist/tty.d.ts

@@ -0,0 +1,9 @@
+declare function isatty(): boolean;
+declare function ReadStream(): never;
+declare function WriteStream(): never;
+declare const api: {
+    isatty: typeof isatty;
+    ReadStream: typeof ReadStream;
+    WriteStream: typeof WriteStream;
+};
+export = api;

package/dist/tty.js

@@ -0,0 +1,25 @@
+'use strict';
+/**
+ * tty 模块。
+ *
+ * Operit 沙箱里没有终端，所以：
+ *   - isatty() 一律 false（这正是 supports-color / debug 这类包需要知道的答案）；
+ *   - ReadStream / WriteStream 需要真实终端，构造时显式抛 ONJ_UNSUPPORTED，
+ *     不放一个"能 new 但不能用"的空壳。
+ */
+const errors_1 = require("./lib/errors");
+function isatty() {
+    return false;
+}
+function ReadStream() {
+    throw (0, errors_1.onjError)('ONJ_UNSUPPORTED', 'tty.ReadStream 需要真实终端，Operit 沙箱里没有终端。');
+}
+function WriteStream() {
+    throw (0, errors_1.onjError)('ONJ_UNSUPPORTED', 'tty.WriteStream 需要真实终端，Operit 沙箱里没有终端。');
+}
+const api = {
+    isatty: isatty,
+    ReadStream: ReadStream,
+    WriteStream: WriteStream
+};
+module.exports = api;

package/dist/unsupported.d.ts

@@ -0,0 +1,12 @@
+/**
+ * node.operit 对"在 Operit 运行时不成立的 Node 内置模块"的统一表达。
+ *
+ * 首选策略是构建期拒绝：OperitPackageManager 读到 BUILTINS.json 中 status 为 unsupported 的条目时，
+ * 应当直接报构建错误，不要把问题带到运行时。
+ *
+ * 若选择在运行时表达，重写器应产出调用形式：
+ *     require('<rel>/node_modules/@serveryyswys/node.operit/unsupported.js')('vm')
+ * 这样错误信息里能带上原始模块名。直接 require 本模块只会得到下面的通用错误。
+ */
+declare function unsupportedNodeBuiltin(name?: string): never;
+export = unsupportedNodeBuiltin;

package/dist/unsupported.js

@@ -0,0 +1,17 @@
+'use strict';
+/**
+ * node.operit 对"在 Operit 运行时不成立的 Node 内置模块"的统一表达。
+ *
+ * 首选策略是构建期拒绝：OperitPackageManager 读到 BUILTINS.json 中 status 为 unsupported 的条目时，
+ * 应当直接报构建错误，不要把问题带到运行时。
+ *
+ * 若选择在运行时表达，重写器应产出调用形式：
+ *     require('<rel>/node_modules/@serveryyswys/node.operit/unsupported.js')('vm')
+ * 这样错误信息里能带上原始模块名。直接 require 本模块只会得到下面的通用错误。
+ */
+function unsupportedNodeBuiltin(name) {
+    const target = typeof name === 'string' && name.length > 0 ? name : '<未知模块>';
+    throw new Error('node.operit 不提供 Node 内置模块 "' + target + '"：它在 Operit 的 QuickJS 运行时不成立。' +
+        '请查阅 node.operit/BUILTINS.json 的 builtins 条目。');
+}
+module.exports = unsupportedNodeBuiltin;

package/dist/url.d.ts

@@ -0,0 +1,28 @@
+import { URLSearchParams as SearchParams } from './lib/url-search-params';
+import { URL as WhatwgUrl } from './lib/url-whatwg';
+import type { ParsedUrl } from './lib/url-types';
+declare function parseUrl(input: string, parseQueryString?: boolean, slashesDenoteHost?: boolean): ParsedUrl;
+declare function formatUrl(source?: unknown): string;
+declare function resolveUrl(from: unknown, to: unknown): string;
+declare function pathToFileURL(filepath: unknown): WhatwgUrl;
+/**
+ * 把 URL 实例转成 http.request 的选项对象。
+ * 语义照 Node：IPv6 主机去掉方括号、path 是 pathname + search、auth 从 username/password 还原。
+ */
+declare function urlToHttpOptions(url: unknown): Record<string, unknown>;
+declare function fileURLToPath(path: unknown): string;
+declare function domainToASCII(domain: unknown): string;
+declare function domainToUnicode(domain: unknown): string;
+declare const urlModule: {
+    URLSearchParams: typeof SearchParams;
+    parse: typeof parseUrl;
+    format: typeof formatUrl;
+    resolve: typeof resolveUrl;
+    pathToFileURL: typeof pathToFileURL;
+    fileURLToPath: typeof fileURLToPath;
+    domainToASCII: typeof domainToASCII;
+    domainToUnicode: typeof domainToUnicode;
+    URL: typeof WhatwgUrl;
+    urlToHttpOptions: typeof urlToHttpOptions;
+};
+export = urlModule;