@serveryyswys/node.operit 0.0.0-stage → 0.1.2

package/dist/lib/punycode.js

@@ -0,0 +1,179 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = encode;
+exports.decode = decode;
+exports.toASCII = toASCII;
+exports.toUnicode = toUnicode;
+/**
+ * RFC 3492（Punycode）编解码。
+ *
+ * url.parse 会把非 ASCII 主机名转成 xn-- 形式（Node 用 domainToASCII），
+ * 所以这里是 url 模块的前置件。
+ *
+ * 范围说明：只做 punycode 本体，不做 UTS-46 / IDNA2008 的那套映射
+ * （大小写折叠、NFKC 归一化、禁用字符检查）。对常见域名足够；
+ * `faß.de` 这类需要 UTS-46 特殊处理的域名结果可能与 Node 不同，见 BUILTINS.json。
+ */
+const BASE = 36;
+const TMIN = 1;
+const TMAX = 26;
+const SKEW = 38;
+const DAMP = 700;
+const INITIAL_BIAS = 72;
+const INITIAL_N = 128;
+function adapt(delta, numPoints, firstTime) {
+    let value = firstTime ? Math.floor(delta / DAMP) : delta >> 1;
+    value += Math.floor(value / numPoints);
+    let k = 0;
+    while (value > ((BASE - TMIN) * TMAX) >> 1) {
+        value = Math.floor(value / (BASE - TMIN));
+        k += BASE;
+    }
+    return k + Math.floor(((BASE - TMIN + 1) * value) / (value + SKEW));
+}
+function encodeDigit(value) {
+    // 0-25 -> a-z, 26-35 -> 0-9
+    return value < 26 ? String.fromCharCode(97 + value) : String.fromCharCode(22 + value);
+}
+function decodeDigit(code) {
+    if (code >= 48 && code <= 57) {
+        return code - 22;
+    }
+    if (code >= 65 && code <= 90) {
+        return code - 65;
+    }
+    if (code >= 97 && code <= 122) {
+        return code - 97;
+    }
+    return BASE;
+}
+/** 把一段 Unicode 字符串编成 punycode（不含 xn-- 前缀）。 */
+function encode(input) {
+    const codePoints = [];
+    for (const character of input) {
+        codePoints.push(character.codePointAt(0));
+    }
+    const output = [];
+    let n = INITIAL_N;
+    let delta = 0;
+    let bias = INITIAL_BIAS;
+    for (let i = 0; i < codePoints.length; i += 1) {
+        if (codePoints[i] < 0x80) {
+            output.push(String.fromCharCode(codePoints[i]));
+        }
+    }
+    const basicLength = output.length;
+    let handled = basicLength;
+    if (basicLength > 0) {
+        output.push('-');
+    }
+    while (handled < codePoints.length) {
+        let next = Number.MAX_SAFE_INTEGER;
+        for (let i = 0; i < codePoints.length; i += 1) {
+            if (codePoints[i] >= n && codePoints[i] < next) {
+                next = codePoints[i];
+            }
+        }
+        delta += (next - n) * (handled + 1);
+        n = next;
+        for (let i = 0; i < codePoints.length; i += 1) {
+            if (codePoints[i] < n) {
+                delta += 1;
+            }
+            if (codePoints[i] === n) {
+                let q = delta;
+                for (let k = BASE;; k += BASE) {
+                    const threshold = k <= bias ? TMIN : (k >= bias + TMAX ? TMAX : k - bias);
+                    if (q < threshold) {
+                        break;
+                    }
+                    output.push(encodeDigit(threshold + ((q - threshold) % (BASE - threshold))));
+                    q = Math.floor((q - threshold) / (BASE - threshold));
+                }
+                output.push(encodeDigit(q));
+                bias = adapt(delta, handled + 1, handled === basicLength);
+                delta = 0;
+                handled += 1;
+            }
+        }
+        delta += 1;
+        n += 1;
+    }
+    return output.join('');
+}
+/** 把 punycode（不含 xn-- 前缀）解回 Unicode 字符串。非法输入抛错。 */
+function decode(input) {
+    const output = [];
+    let n = INITIAL_N;
+    let index = 0;
+    let bias = INITIAL_BIAS;
+    let basic = input.lastIndexOf('-');
+    if (basic < 0) {
+        basic = 0;
+    }
+    for (let i = 0; i < basic; i += 1) {
+        if (input.charCodeAt(i) >= 0x80) {
+            throw new Error('Invalid input: non-basic code point in the basic segment');
+        }
+        output.push(input.charCodeAt(i));
+    }
+    let cursor = basic > 0 ? basic + 1 : 0;
+    while (cursor < input.length) {
+        const oldIndex = index;
+        let weight = 1;
+        for (let k = BASE;; k += BASE) {
+            if (cursor >= input.length) {
+                throw new Error('Invalid input: truncated punycode');
+            }
+            const digit = decodeDigit(input.charCodeAt(cursor));
+            cursor += 1;
+            if (digit >= BASE) {
+                throw new Error('Invalid input: bad digit');
+            }
+            index += digit * weight;
+            const threshold = k <= bias ? TMIN : (k >= bias + TMAX ? TMAX : k - bias);
+            if (digit < threshold) {
+                break;
+            }
+            weight *= BASE - threshold;
+        }
+        const length = output.length + 1;
+        bias = adapt(index - oldIndex, length, oldIndex === 0);
+        n += Math.floor(index / length);
+        index %= length;
+        output.splice(index, 0, n);
+        index += 1;
+    }
+    let out = '';
+    for (let i = 0; i < output.length; i += 1) {
+        out += String.fromCodePoint(output[i]);
+    }
+    return out;
+}
+/** 域名 -> ASCII（xn--）。纯 ASCII 输入原样返回（已小写化由调用方负责）。 */
+function toASCII(domain) {
+    return domain.split('.').map(function (label) {
+        let ascii = true;
+        for (let i = 0; i < label.length; i += 1) {
+            if (label.charCodeAt(i) >= 0x80) {
+                ascii = false;
+                break;
+            }
+        }
+        return ascii ? label : 'xn--' + encode(label.toLowerCase());
+    }).join('.');
+}
+/** 域名 -> Unicode。xn-- 标签解回 Unicode，其余原样。 */
+function toUnicode(domain) {
+    return domain.split('.').map(function (label) {
+        if (label.length > 4 && label.slice(0, 4).toLowerCase() === 'xn--') {
+            try {
+                return decode(label.slice(4));
+            }
+            catch (failure) {
+                return label;
+            }
+        }
+        return label;
+    }).join('.');
+}

package/dist/lib/stream-types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * stream 的公开类型。
+ *
+ * 独立成文件的原因与 path-types / zlib-types 相同：stream.ts 用 `export =` 导出模块本体，
+ * 无法再导出类型，而 index.ts 聚合时要求这些名字是"可命名"的。
+ */
+/** 只有可写侧被用到的结构类型：pipe 的终点不需要是完整的 Writable。 */
+export interface WritableLike {
+    write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+    end(chunk?: unknown, encoding?: unknown, callback?: unknown): void;
+    on(event: string, listener: (...args: unknown[]) => void): unknown;
+    once(event: string, listener: (...args: unknown[]) => void): unknown;
+    removeListener(event: string, listener: (...args: unknown[]) => void): unknown;
+    emit(event: string, ...args: unknown[]): boolean;
+    readonly writable?: boolean;
+}
+export interface StreamOptions {
+    highWaterMark?: number;
+    objectMode?: boolean;
+    encoding?: string;
+    read?: (this: unknown, size: number) => void;
+    write?: (chunk: unknown, encoding: string, callback: (error?: Error | null) => void) => void;
+    transform?: (chunk: unknown, encoding: string, callback: (error?: Error | null, data?: unknown) => void) => void;
+    flush?: (callback: (error?: Error | null) => void) => void;
+    final?: (callback: (error?: Error | null) => void) => void;
+    destroy?: (error: Error | null, callback: (error?: Error | null) => void) => void;
+    writableObjectMode?: boolean;
+    readableObjectMode?: boolean;
+}

package/dist/lib/stream-types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/timers-types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * timers 的公开类型。
+ *
+ * 独立成文件的原因与其他 types 文件相同：timers.ts / timers/promises.ts 用 `export =`
+ * 导出模块本体，无法再导出类型，而 index.ts 聚合时要求这些名字是"可命名"的。
+ *
+ * signal 用的是结构类型而不是 AbortSignal：QuickJS 不保证提供 AbortController，
+ * 而打包后的代码可能传入 Node/浏览器那边的实现，只要形状对就行。
+ */
+export interface AbortSignalLike {
+    aborted?: boolean;
+    addEventListener?: (type: string, listener: () => void) => void;
+    removeEventListener?: (type: string, listener: () => void) => void;
+}
+export interface TimerOptions {
+    signal?: AbortSignalLike;
+    ref?: boolean;
+}

package/dist/lib/timers-types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/url-search-params.d.ts

@@ -0,0 +1,26 @@
+import type { IteratorLike } from './url-types';
+export declare function hexByte(value: number): string;
+/** application/x-www-form-urlencoded 序列化：空格变 +，其余按 UTF-8 百分号编码。 */
+export declare function formSerialize(value: string): string;
+/** 表单反序列化：+ 变空格，再按 UTF-8 百分号解码。 */
+export declare function formParse(value: string): string;
+type PairList = Array<[string, string]>;
+export declare class URLSearchParams {
+    list: PairList;
+    constructor(init?: unknown);
+    get size(): number;
+    append(name: unknown, value: unknown): void;
+    delete(name: unknown, value?: unknown): void;
+    get(name: unknown, value?: unknown): string | null;
+    getAll(name: unknown): string[];
+    has(name: unknown, value?: unknown): boolean;
+    set(name: unknown, value: unknown): void;
+    sort(): void;
+    forEach(callback: (value: string, name: string, params: URLSearchParams) => void, thisArg?: unknown): void;
+    entries(): IteratorLike<[string, string]>;
+    keys(): IteratorLike<string>;
+    values(): IteratorLike<string>;
+    [Symbol.iterator](): IteratorLike<[string, string]>;
+    toString(): string;
+}
+export {};

package/dist/lib/url-search-params.js

@@ -0,0 +1,281 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URLSearchParams = void 0;
+exports.hexByte = hexByte;
+exports.formSerialize = formSerialize;
+exports.formParse = formParse;
+/**
+ * URLSearchParams（application/x-www-form-urlencoded 的 WHATWG 实现）。
+ *
+ * 从 url.ts 抽出来单独成文件，是为了让 lib/url-whatwg.ts 也能用它而不产生循环依赖：
+ *   url.ts          -> lib/url-search-params.ts, lib/url-whatwg.ts
+ *   lib/url-whatwg.ts -> lib/url-search-params.ts
+ *
+ * 额外提供一个内部钩子：URL 的 searchParams 是"活视图"，
+ * 参数一变 href / search 就得跟着变，所以这里允许注册一个变更回调。
+ * 这个回调不是标准 API，只是本库内部用。
+ */
+const bytes_1 = require("./bytes");
+const FORM_SAFE = new Set();
+(function initFormSafe() {
+    for (let code = 0x41; code <= 0x5a; code += 1) {
+        FORM_SAFE.add(code);
+    }
+    for (let code = 0x61; code <= 0x7a; code += 1) {
+        FORM_SAFE.add(code);
+    }
+    for (let code = 0x30; code <= 0x39; code += 1) {
+        FORM_SAFE.add(code);
+    }
+    FORM_SAFE.add(0x2a); // *
+    FORM_SAFE.add(0x2d); // -
+    FORM_SAFE.add(0x2e); // .
+    FORM_SAFE.add(0x5f); // _
+})();
+function hexByte(value) {
+    return '%' + (value < 16 ? '0' : '') + value.toString(16).toUpperCase();
+}
+/** application/x-www-form-urlencoded 序列化：空格变 +，其余按 UTF-8 百分号编码。 */
+function formSerialize(value) {
+    const bytes = (0, bytes_1.utf8Encode)(value);
+    let out = '';
+    for (let i = 0; i < bytes.length; i += 1) {
+        const byte = bytes[i];
+        if (FORM_SAFE.has(byte)) {
+            out += String.fromCharCode(byte);
+        }
+        else if (byte === 0x20) {
+            out += '+';
+        }
+        else {
+            out += hexByte(byte);
+        }
+    }
+    return out;
+}
+/** 表单反序列化：+ 变空格，再按 UTF-8 百分号解码。 */
+function formParse(value) {
+    const bytes = [];
+    for (let i = 0; i < value.length; i += 1) {
+        const character = value.charAt(i);
+        if (character === '+') {
+            bytes.push(0x20);
+            continue;
+        }
+        if (character === '%' && i + 2 < value.length) {
+            const hex = value.slice(i + 1, i + 3);
+            if (/^[0-9A-Fa-f]{2}$/.test(hex)) {
+                bytes.push(parseInt(hex, 16));
+                i += 2;
+                continue;
+            }
+        }
+        const encoded = (0, bytes_1.utf8Encode)(character);
+        for (let j = 0; j < encoded.length; j += 1) {
+            bytes.push(encoded[j]);
+        }
+    }
+    return (0, bytes_1.utf8Decode)(Uint8Array.from(bytes));
+}
+/** 参数一变就通知持有者（URL 的 searchParams 是活视图，靠这个同步）。 */
+function fireChange(params) {
+    const hook = params.__onjOnChange;
+    if (typeof hook === 'function') {
+        hook();
+    }
+}
+class URLSearchParams {
+    constructor(init) {
+        // 公开而非 private：`export =` 的模块里，导出类带 private 成员会触发 TS4094
+        this.list = [];
+        if (init === undefined || init === null) {
+            return;
+        }
+        if (typeof init === 'string') {
+            this.list = parseFormPairs(init);
+            return;
+        }
+        const iterable = init;
+        if (typeof iterable[Symbol.iterator] === 'function') {
+            for (const entry of init) {
+                const pair = entry;
+                if (pair === null || typeof pair !== 'object' || pair.length !== 2) {
+                    throw new TypeError('Each query pair must be an iterable [name, value] tuple');
+                }
+                this.list.push([String(pair[0]), String(pair[1])]);
+            }
+            return;
+        }
+        const record = init;
+        const keys = Object.keys(record);
+        for (let i = 0; i < keys.length; i += 1) {
+            this.list.push([keys[i], String(record[keys[i]])]);
+        }
+    }
+    get size() {
+        return this.list.length;
+    }
+    append(name, value) {
+        this.list.push([String(name), String(value)]);
+        fireChange(this);
+    }
+    delete(name, value) {
+        const target = String(name);
+        const hasValue = value !== undefined;
+        const wanted = hasValue ? String(value) : '';
+        this.list = this.list.filter(function (pair) {
+            if (pair[0] !== target) {
+                return true;
+            }
+            return hasValue && pair[1] !== wanted;
+        });
+        fireChange(this);
+    }
+    get(name, value) {
+        const target = String(name);
+        const hasValue = value !== undefined;
+        const wanted = hasValue ? String(value) : '';
+        for (let i = 0; i < this.list.length; i += 1) {
+            if (this.list[i][0] === target && (!hasValue || this.list[i][1] === wanted)) {
+                return this.list[i][1];
+            }
+        }
+        return null;
+    }
+    getAll(name) {
+        const target = String(name);
+        const out = [];
+        for (let i = 0; i < this.list.length; i += 1) {
+            if (this.list[i][0] === target) {
+                out.push(this.list[i][1]);
+            }
+        }
+        return out;
+    }
+    has(name, value) {
+        return this.get(name, value) !== null;
+    }
+    set(name, value) {
+        const target = String(name);
+        const next = String(value);
+        let replaced = false;
+        const out = [];
+        for (let i = 0; i < this.list.length; i += 1) {
+            if (this.list[i][0] !== target) {
+                out.push(this.list[i]);
+                continue;
+            }
+            if (!replaced) {
+                out.push([target, next]);
+                replaced = true;
+            }
+        }
+        if (!replaced) {
+            out.push([target, next]);
+        }
+        this.list = out;
+        fireChange(this);
+    }
+    sort() {
+        // 按解码后的名字做稳定排序（比较 UTF-16 码元）
+        const indexed = this.list.map(function (pair, index) {
+            return { pair: pair, index: index };
+        });
+        indexed.sort(function (left, right) {
+            if (left.pair[0] < right.pair[0]) {
+                return -1;
+            }
+            if (left.pair[0] > right.pair[0]) {
+                return 1;
+            }
+            return left.index - right.index;
+        });
+        this.list = indexed.map(function (entry) { return entry.pair; });
+        fireChange(this);
+    }
+    forEach(callback, thisArg) {
+        const snapshot = this.list.slice();
+        for (let i = 0; i < snapshot.length; i += 1) {
+            callback.call(thisArg, snapshot[i][1], snapshot[i][0], this);
+        }
+    }
+    entries() {
+        let index = 0;
+        const list = this.list;
+        return asIterable({
+            next: function () {
+                if (index >= list.length) {
+                    return { value: [undefined, undefined], done: true };
+                }
+                const value = list[index];
+                index += 1;
+                return { value: [value[0], value[1]], done: false };
+            }
+        });
+    }
+    keys() {
+        let index = 0;
+        const list = this.list;
+        return asIterable({
+            next: function () {
+                if (index >= list.length) {
+                    return { value: undefined, done: true };
+                }
+                return { value: list[index++][0], done: false };
+            }
+        });
+    }
+    values() {
+        let index = 0;
+        const list = this.list;
+        return asIterable({
+            next: function () {
+                if (index >= list.length) {
+                    return { value: undefined, done: true };
+                }
+                return { value: list[index++][1], done: false };
+            }
+        });
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    toString() {
+        const parts = [];
+        for (let i = 0; i < this.list.length; i += 1) {
+            parts.push(formSerialize(this.list[i][0]) + '=' + formSerialize(this.list[i][1]));
+        }
+        return parts.join('&');
+    }
+}
+exports.URLSearchParams = URLSearchParams;
+/** 把裸迭代器补成可迭代对象 —— Node 的 entries/keys/values 都是可迭代的。 */
+function asIterable(iterator) {
+    const wrapper = iterator;
+    wrapper[Symbol.iterator] = function () {
+        return wrapper;
+    };
+    return wrapper;
+}
+function parseFormPairs(input) {
+    const out = [];
+    const source = input.charAt(0) === '?' ? input.slice(1) : input;
+    if (source === '') {
+        return out;
+    }
+    const segments = source.split('&');
+    for (let i = 0; i < segments.length; i += 1) {
+        const segment = segments[i];
+        if (segment === '') {
+            continue;
+        }
+        const equals = segment.indexOf('=');
+        if (equals < 0) {
+            out.push([formParse(segment), '']);
+        }
+        else {
+            out.push([formParse(segment.slice(0, equals)), formParse(segment.slice(equals + 1))]);
+        }
+    }
+    return out;
+}

package/dist/lib/url-types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * url 的公开类型。
+ *
+ * 独立成文件的原因与 path-types / zlib-types / stream-types / fs-types /
+ * child-process-types 相同：url.ts 用 `export =` 导出模块本体，无法再导出类型，
+ * 而 index.ts 聚合时要求这些名字是"可命名"的。
+ */
+/** 可迭代的迭代器（Node 的 entries/keys/values 都是可迭代的）。 */
+export interface IteratorLike<T> {
+    next(): {
+        value: T;
+        done: boolean;
+    };
+    [Symbol.iterator](): IteratorLike<T>;
+}
+export interface ParsedUrl {
+    protocol: string | null;
+    slashes: boolean | null;
+    auth: string | null;
+    host: string | null;
+    port: string | null;
+    hostname: string | null;
+    hash: string | null;
+    search: string | null;
+    query: unknown;
+    pathname: string | null;
+    path: string | null;
+    href: string;
+}
+export interface URLObjectLike {
+    href: string;
+    origin: string;
+    protocol: string;
+    username: string;
+    password: string;
+    host: string;
+    hostname: string;
+    port: string;
+    pathname: string;
+    search: string;
+    hash: string;
+    toString(): string;
+    toJSON(): string;
+}

package/dist/lib/url-types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/url-whatwg.d.ts

@@ -0,0 +1,78 @@
+/**
+ * WHATWG URL（RFC 3986 + URL 标准的解析与序列化）。
+ *
+ * 覆盖：特殊协议（http/https/ws/wss/ftp/file）与自定义协议、authority（userinfo / host / port）、
+ * IPv4 / IPv6 / 域名的 punycode、按组件的百分号编码、点段规范化、相对引用解析、
+ * 全部 getter 与 setter、url.searchParams 的活视图、URL.canParse / URL.parse。
+ *
+ * 与 Node 的已知差异见 BUILTINS.json 的 url 条目：IPv4 的十六进制/八进制写法、
+ * 非 ASCII 域名的 UTS-46 映射（只做 punycode，不做映射与归一化）、blob: 的 origin。
+ */
+import { URLSearchParams } from './url-search-params';
+/** fragment 组：C0 组 + 空格 " < > ` */
+export declare function fragmentEncodeSet(code: number): boolean;
+/** query 组：C0 组 + 空格 " # < > */
+export declare function queryEncodeSet(code: number): boolean;
+/** special-query 组：query 组 + ' */
+export declare function specialQueryEncodeSet(code: number): boolean;
+/** path 组：query 组 + ? ` { } */
+export declare function pathEncodeSet(code: number): boolean;
+/** userinfo 组：path 组 + / : ; = @ [ \ ] ^ | */
+export declare function userinfoEncodeSet(code: number): boolean;
+interface UrlRecord {
+    scheme: string;
+    username: string;
+    password: string;
+    /** null 表示没有 authority（不透明路径） */
+    host: string | null;
+    port: number | null;
+    /** 有 authority 时是段数组；没有时是不透明路径字符串 */
+    path: string[] | string;
+    query: string | null;
+    fragment: string | null;
+}
+export declare function parseUrlRecord(input: string, base?: UrlRecord | null): UrlRecord | null;
+export declare class URL {
+    private record;
+    searchParams: URLSearchParams;
+    constructor(input: unknown, base?: unknown);
+    private buildSearchParams;
+    /**
+     * 把 searchParams 写回 query。只在参数**真的被改动**时调用。
+     *
+     * 两处不能想当然：
+     *   - 不能用 URLSearchParams.toString()：那是表单序列化（空格 -> +），
+     *     而 URL 的 query 用 URL 的 query 编码集（空格 -> %20）；
+     *   - 没被改动过时必须保持 query 原样，否则 new URL('http://x/?b').search
+     *     会从 '?b' 变成 '?b='。
+     */
+    private applyParams;
+    /** 不透明路径（没有 authority）时用字符串路径。 */
+    private isOpaque;
+    get href(): string;
+    set href(value: unknown);
+    get origin(): string;
+    get protocol(): string;
+    set protocol(value: unknown);
+    get username(): string;
+    set username(value: unknown);
+    get password(): string;
+    set password(value: unknown);
+    get host(): string;
+    set host(value: unknown);
+    get hostname(): string;
+    set hostname(value: unknown);
+    get port(): string;
+    set port(value: unknown);
+    get pathname(): string;
+    set pathname(value: unknown);
+    get search(): string;
+    set search(value: unknown);
+    get hash(): string;
+    set hash(value: unknown);
+    toString(): string;
+    toJSON(): string;
+    static canParse(input: unknown, base?: unknown): boolean;
+    static parse(input: unknown, base?: unknown): URL | null;
+}
+export {};