quickwin 2026.5.2-3.145209

package/lib/polyfill.js

@@ -0,0 +1,500 @@
+import * as os from 'os';
+// 1. window — triggers Emscripten browser path
+if (typeof globalThis.window === 'undefined')
+    globalThis.window = globalThis;
+// 2. TextDecoder polyfill
+if (typeof globalThis.TextDecoder === 'undefined') {
+    globalThis.TextDecoder = class TextDecoder {
+        encoding = 'utf-8';
+        decode(buffer) {
+            if (!buffer)
+                return '';
+            const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+            let out = '';
+            for (let i = 0; i < bytes.length;) {
+                const b = bytes[i++];
+                if (b < 0x80) {
+                    out += String.fromCharCode(b);
+                    continue;
+                }
+                let c;
+                if (b < 0xE0) {
+                    c = b & 0x1F;
+                    c = (c << 6) | (bytes[i++] & 0x3F);
+                }
+                else if (b < 0xF0) {
+                    c = b & 0x0F;
+                    c = (c << 6) | (bytes[i++] & 0x3F);
+                    c = (c << 6) | (bytes[i++] & 0x3F);
+                }
+                else {
+                    c = b & 0x07;
+                    c = (c << 6) | (bytes[i++] & 0x3F);
+                    c = (c << 6) | (bytes[i++] & 0x3F);
+                    c = (c << 6) | (bytes[i++] & 0x3F);
+                }
+                if (c <= 0xFFFF)
+                    out += String.fromCharCode(c);
+                else {
+                    c -= 0x10000;
+                    out += String.fromCharCode(0xD800 | (c >> 10), 0xDC00 | (c & 0x3FF));
+                }
+            }
+            return out;
+        }
+    };
+}
+// 3. setTimeout polyfill — bridge to os.setTimeout
+if (typeof globalThis.setTimeout === 'undefined') {
+    globalThis.setTimeout = (fn, ms, ...args) => {
+        return os.setTimeout(() => fn(...args), ms);
+    };
+}
+// 4. TextEncoder polyfill
+if (typeof globalThis.TextEncoder === 'undefined') {
+    globalThis.TextEncoder = class TextEncoder {
+        encoding = 'utf-8';
+        encode(input) {
+            if (!input)
+                return new Uint8Array(0);
+            const bytes = [];
+            for (let i = 0; i < input.length; i++) {
+                let c = input.charCodeAt(i);
+                if (c < 0x80) {
+                    bytes.push(c);
+                }
+                else if (c < 0x800) {
+                    bytes.push(0xC0 | (c >> 6), 0x80 | (c & 0x3F));
+                }
+                else if (c < 0xD800 || c >= 0xE000) {
+                    bytes.push(0xE0 | (c >> 12), 0x80 | ((c >> 6) & 0x3F), 0x80 | (c & 0x3F));
+                }
+                else {
+                    i++;
+                    const c2 = input.charCodeAt(i);
+                    c = 0x10000 + ((c & 0x3FF) << 10) | (c2 & 0x3FF);
+                    bytes.push(0xF0 | (c >> 18), 0x80 | ((c >> 12) & 0x3F), 0x80 | ((c >> 6) & 0x3F), 0x80 | (c & 0x3F));
+                }
+            }
+            return new Uint8Array(bytes);
+        }
+    };
+}
+// 5. console.error polyfill — QuickJS only has console.log
+if (typeof console.error === 'undefined') {
+    console.error = (...args) => { console.log(...args); };
+}
+// ── SHA-1 ──
+function sha1Bytes(bytes) {
+    const len = bytes.length;
+    const ml = len * 8;
+    bytes.push(0x80);
+    while (bytes.length % 64 !== 56) {
+        bytes.push(0);
+    }
+    bytes.push(0);
+    bytes.push(0);
+    bytes.push(0);
+    bytes.push(0);
+    bytes.push((ml >>> 24) & 0xFF);
+    bytes.push((ml >>> 16) & 0xFF);
+    bytes.push((ml >>> 8) & 0xFF);
+    bytes.push(ml & 0xFF);
+    let h0 = 0x67452301, h1 = 0xEFCDAB89;
+    let h2 = 0x98BADCFE, h3 = 0x10325476, h4 = 0xC3D2E1F0;
+    const rotl = (x, n) => ((x << n) | (x >>> (32 - n))) >>> 0;
+    for (let i = 0; i < bytes.length; i += 64) {
+        const w = [];
+        for (let t = 0; t < 16; t++) {
+            w[t] = (bytes[i + 4 * t] << 24) | (bytes[i + 4 * t + 1] << 16) |
+                (bytes[i + 4 * t + 2] << 8) | bytes[i + 4 * t + 3];
+        }
+        for (let t = 16; t < 80; t++) {
+            w[t] = rotl(w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16], 1);
+        }
+        let a = h0, b = h1, c = h2, d = h3, e = h4;
+        for (let t = 0; t < 80; t++) {
+            let f, k;
+            if (t < 20) {
+                f = (b & c) | (~b & d);
+                k = 0x5A827999;
+            }
+            else if (t < 40) {
+                f = b ^ c ^ d;
+                k = 0x6ED9EBA1;
+            }
+            else if (t < 60) {
+                f = (b & c) | (b & d) | (c & d);
+                k = 0x8F1BBCDC;
+            }
+            else {
+                f = b ^ c ^ d;
+                k = 0xCA62C1D6;
+            }
+            const temp = (rotl(a, 5) + f + e + k + w[t]) >>> 0;
+            e = d;
+            d = c;
+            c = rotl(b, 30);
+            b = a;
+            a = temp;
+        }
+        h0 = (h0 + a) >>> 0;
+        h1 = (h1 + b) >>> 0;
+        h2 = (h2 + c) >>> 0;
+        h3 = (h3 + d) >>> 0;
+        h4 = (h4 + e) >>> 0;
+    }
+    const result = new Uint8Array(20);
+    const w32 = (off, v) => {
+        result[off] = (v >>> 24) & 0xFF;
+        result[off + 1] = (v >>> 16) & 0xFF;
+        result[off + 2] = (v >>> 8) & 0xFF;
+        result[off + 3] = v & 0xFF;
+    };
+    w32(0, h0);
+    w32(4, h1);
+    w32(8, h2);
+    w32(12, h3);
+    w32(16, h4);
+    return result;
+}
+// ── Base64 ──
+const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+function b64Encode(data) {
+    let r = '';
+    for (let i = 0; i < data.length; i += 3) {
+        const b0 = data[i], b1 = i + 1 < data.length ? data[i + 1] : 0, b2 = i + 2 < data.length ? data[i + 2] : 0;
+        r += B64[b0 >> 2] + B64[((b0 & 3) << 4) | (b1 >> 4)];
+        r += i + 1 < data.length ? B64[((b1 & 15) << 2) | (b2 >> 6)] : '=';
+        r += i + 2 < data.length ? B64[b2 & 63] : '=';
+    }
+    return r;
+}
+function b64Decode(str) {
+    str = str.replace(/[^A-Za-z0-9+/=]/g, '');
+    const bytes = [];
+    for (let i = 0; i < str.length; i += 4) {
+        const c0 = B64.indexOf(str[i]), c1 = B64.indexOf(str[i + 1]);
+        const c2 = B64.indexOf(str[i + 2]), c3 = B64.indexOf(str[i + 3]);
+        bytes.push((c0 << 2) | (c1 >> 4));
+        if (c2 >= 0)
+            bytes.push(((c1 & 15) << 4) | (c2 >> 2));
+        if (c3 >= 0)
+            bytes.push(((c2 & 3) << 6) | c3);
+    }
+    return new Uint8Array(bytes);
+}
+// ── btoa / atob ──
+if (typeof globalThis.btoa === 'undefined') {
+    globalThis.btoa = (data) => {
+        const bytes = new Uint8Array(data.length);
+        for (let i = 0; i < data.length; i++)
+            bytes[i] = data.charCodeAt(i) & 0xFF;
+        return b64Encode(bytes);
+    };
+}
+if (typeof globalThis.atob === 'undefined') {
+    globalThis.atob = (data) => {
+        const bytes = b64Decode(data);
+        let r = '';
+        for (let i = 0; i < bytes.length; i++)
+            r += String.fromCharCode(bytes[i]);
+        return r;
+    };
+}
+function _encode(s) { return encodeURIComponent(s); }
+function _decode(s) {
+    try {
+        return decodeURIComponent(s.replace(/\+/g, ' '));
+    }
+    catch {
+        return s;
+    }
+}
+function _normalizePath(path) {
+    if (!path)
+        return '/';
+    const parts = path.split('/');
+    const out = [];
+    let hasRoot = path[0] === '/';
+    if (hasRoot)
+        out.push('');
+    for (const p of parts) {
+        if (p === '' || p === '.')
+            continue;
+        if (p === '..') {
+            const last = out[out.length - 1];
+            if (last !== undefined && last !== '')
+                out.pop();
+        }
+        else {
+            out.push(p);
+        }
+    }
+    if (path.endsWith('/') && out[out.length - 1] !== '')
+        out.push('');
+    const result = out.join('/');
+    if (hasRoot && !result.startsWith('/'))
+        return '/' + result;
+    return result || '/';
+}
+function _parseURL(url) {
+    const r = { scheme: '', user: '', pass: '', host: '', port: '', path: '/', query: '', fragment: '' };
+    const fi = url.indexOf('#');
+    if (fi >= 0) {
+        r.fragment = url.slice(fi + 1);
+        url = url.slice(0, fi);
+    }
+    const qi = url.indexOf('?');
+    if (qi >= 0) {
+        r.query = url.slice(qi + 1);
+        url = url.slice(0, qi);
+    }
+    const sm = url.match(/^([a-zA-Z][a-zA-Z0-9+\-.]*):(.*)$/);
+    if (sm) {
+        r.scheme = sm[1].toLowerCase();
+        url = sm[2];
+    }
+    if (url.startsWith('//')) {
+        url = url.slice(2);
+        const si = url.indexOf('/');
+        let auth;
+        if (si < 0) {
+            auth = url;
+            url = '';
+        }
+        else {
+            auth = url.slice(0, si);
+            url = url.slice(si);
+        }
+        const ai = auth.lastIndexOf('@');
+        if (ai >= 0) {
+            const ui = auth.slice(0, ai);
+            auth = auth.slice(ai + 1);
+            const ci = ui.indexOf(':');
+            if (ci >= 0) {
+                r.user = _decode(ui.slice(0, ci));
+                r.pass = _decode(ui.slice(ci + 1));
+            }
+            else
+                r.user = _decode(ui);
+        }
+        if (auth.startsWith('[')) {
+            const cb = auth.indexOf(']');
+            r.host = auth.slice(1, cb).toLowerCase();
+            const pp = auth.slice(cb + 1);
+            if (pp.startsWith(':'))
+                r.port = pp.slice(1);
+        }
+        else {
+            const ci = auth.lastIndexOf(':');
+            if (ci >= 0 && ci === auth.lastIndexOf(':')) {
+                r.host = auth.slice(0, ci).toLowerCase();
+                r.port = auth.slice(ci + 1);
+            }
+            else
+                r.host = auth.toLowerCase();
+        }
+    }
+    r.path = url;
+    if (r.host && !r.path.startsWith('/'))
+        r.path = '/' + r.path;
+    return r;
+}
+class URLSearchParamsImpl {
+    _list = [];
+    constructor(init) {
+        if (typeof init === 'string') {
+            const s = init.startsWith('?') ? init.slice(1) : init;
+            if (!s)
+                return;
+            for (const p of s.split('&')) {
+                const eq = p.indexOf('=');
+                if (eq < 0) {
+                    this._list.push([_decode(p), '']);
+                    continue;
+                }
+                this._list.push([_decode(p.slice(0, eq)), _decode(p.slice(eq + 1))]);
+            }
+        }
+        else if (init) {
+            if (Array.isArray(init))
+                for (const [k, v] of init)
+                    this._list.push([String(k), String(v)]);
+            else
+                for (const k of Object.keys(init))
+                    this._list.push([k, String(init[k])]);
+        }
+    }
+    append(key, value) { this._list.push([key, value]); }
+    delete(key) { this._list = this._list.filter(([k]) => k !== key); }
+    get(key) { for (const [k, v] of this._list)
+        if (k === key)
+            return v; return null; }
+    getAll(key) { return this._list.filter(([k]) => k === key).map(([, v]) => v); }
+    has(key) { return this._list.some(([k]) => k === key); }
+    set(key, value) {
+        let f = false;
+        for (let i = 0; i < this._list.length; i++) {
+            if (this._list[i][0] === key) {
+                if (!f) {
+                    this._list[i][1] = value;
+                    f = true;
+                }
+                else {
+                    this._list.splice(i, 1);
+                    i--;
+                }
+            }
+        }
+        if (!f)
+            this._list.push([key, value]);
+    }
+    sort() { this._list.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0); }
+    forEach(fn) { for (const [k, v] of this._list)
+        fn(v, k); }
+    *keys() { for (const [k] of this._list)
+        yield k; }
+    *values() { for (const [, v] of this._list)
+        yield v; }
+    *entries() { for (const item of this._list)
+        yield [item[0], item[1]]; }
+    *[Symbol.iterator]() { for (const item of this._list)
+        yield item; }
+    toString() { return this._list.map(([k, v]) => _encode(k) + '=' + _encode(v)).join('&'); }
+    get size() { return this._list.length; }
+}
+if (typeof globalThis.URLSearchParams === 'undefined') {
+    globalThis.URLSearchParams = URLSearchParamsImpl;
+}
+class URLImpl {
+    _scheme = '';
+    _username = '';
+    _password = '';
+    _hostname = '';
+    _port = '';
+    _pathname = '/';
+    _query = '';
+    _fragment = '';
+    _searchParams = new URLSearchParamsImpl();
+    constructor(url, base) {
+        let p = _parseURL(url);
+        if (p.scheme) {
+            this._apply(p);
+            return;
+        }
+        if (base === undefined)
+            throw new TypeError('Invalid URL');
+        const b = new URLImpl(base);
+        if (p.host) {
+            p.scheme = b._scheme;
+            this._apply(p);
+            return;
+        }
+        if (!p.path && !p.query) {
+            this._apply({
+                scheme: b._scheme, user: b._username, pass: b._password,
+                host: b._hostname, port: b._port,
+                path: b._pathname, query: b._query, fragment: p.fragment || ''
+            });
+            return;
+        }
+        p.scheme = b._scheme;
+        if (!p.user)
+            p.user = b._username;
+        if (!p.pass)
+            p.pass = b._password;
+        if (!p.host)
+            p.host = b._hostname;
+        if (!p.port)
+            p.port = b._port;
+        if (!p.fragment)
+            p.fragment = '';
+        if (p.path && !p.path.startsWith('/')) {
+            const bd = b._pathname.substring(0, b._pathname.lastIndexOf('/') + 1);
+            p.path = _normalizePath(bd + p.path);
+        }
+        else if (!p.path) {
+            p.path = b._pathname;
+            if (!p.query)
+                p.query = b._query;
+        }
+        this._apply(p);
+    }
+    _apply(p) {
+        this._scheme = p.scheme;
+        this._username = p.user;
+        this._password = p.pass;
+        this._hostname = p.host;
+        this._port = p.port;
+        this._pathname = _normalizePath(p.path || '/');
+        this._query = p.query;
+        this._fragment = p.fragment;
+        this._searchParams = new URLSearchParamsImpl(this._query);
+    }
+    get href() { return this.toString(); }
+    get protocol() { return this._scheme + ':'; }
+    get hostname() { return this._hostname; }
+    get port() { return this._port; }
+    get pathname() { return this._pathname; }
+    get search() { return this._query ? '?' + this._query : ''; }
+    get hash() { return this._fragment ? '#' + this._fragment : ''; }
+    get host() {
+        const h = this._hostname;
+        const ipv6 = h.includes(':');
+        return (ipv6 ? '[' + h + ']' : h) + (this._port ? ':' + this._port : '');
+    }
+    get origin() {
+        const h = this._hostname;
+        const ipv6 = h.includes(':');
+        return this._scheme + '://' + (ipv6 ? '[' + h + ']' : h) + (this._port ? ':' + this._port : '');
+    }
+    get username() { return this._username; }
+    get password() { return this._password; }
+    get searchParams() { return this._searchParams; }
+    toString() {
+        let s = this._scheme + ':';
+        const special = ['http', 'https', 'ws', 'wss', 'ftp', 'file'];
+        if (this._hostname || (special.includes(this._scheme) && this._pathname.startsWith('/'))) {
+            s += '//';
+            if (this._username) {
+                s += _encode(this._username);
+                if (this._password)
+                    s += ':' + _encode(this._password);
+                s += '@';
+            }
+            s += this._hostname;
+            if (this._port)
+                s += ':' + this._port;
+        }
+        s += this._pathname;
+        if (this._query)
+            s += '?' + this._query;
+        if (this._fragment)
+            s += '#' + this._fragment;
+        return s;
+    }
+    toJSON() { return this.toString(); }
+}
+if (typeof globalThis.URL === 'undefined') {
+    globalThis.URL = URLImpl;
+}
+if (typeof globalThis.crypto === 'undefined') {
+    globalThis.crypto = {
+        getRandomValues: (array) => {
+            const view = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+            for (let i = 0; i < view.length; i++)
+                view[i] = (Math.random() * 256) | 0;
+            return array;
+        },
+        subtle: {
+            digest: (algorithm, data) => {
+                if (algorithm.toUpperCase() !== 'SHA-1')
+                    return Promise.reject(new Error('Digest: ' + algorithm + ' not supported'));
+                const bytes = data instanceof Uint8Array ? Array.from(data) : Array.from(new Uint8Array(data));
+                const hash = sha1Bytes(bytes);
+                return Promise.resolve(hash.buffer);
+            }
+        }
+    };
+}