quickwin 2026.5.2-3.145209

package/lib/fetch.js

@@ -0,0 +1,746 @@
+import '../lib/polyfill.js';
+import * as sock from 'sock';
+import * as wolfssl from 'wolfssl';
+import * as os from 'os';
+import * as brotli from 'brotli';
+const setTimeout = os.setTimeout;
+const clearTimeout = os.clearTimeout;
+function str2ab(str) {
+    const buf = new ArrayBuffer(str.length);
+    const view = new Uint8Array(buf);
+    for (let i = 0; i < str.length; i++)
+        view[i] = str.charCodeAt(i);
+    return buf;
+}
+function ab2str(buf) {
+    const view = new Uint8Array(buf);
+    let str = '';
+    for (let i = 0; i < view.length; i++)
+        str += String.fromCharCode(view[i]);
+    return str;
+}
+function getArrayBuffer(view) {
+    if (view.buffer instanceof ArrayBuffer)
+        return view.buffer;
+    const copy = new ArrayBuffer(view.byteLength);
+    new Uint8Array(copy).set(view);
+    return copy;
+}
+class _QuickReadableStream {
+    _chunks = [];
+    _state = 'readable';
+    _pendingRead = null;
+    _locked = false;
+    _sock;
+    _ssl;
+    _isHTTPS;
+    _cleanup;
+    _contentLength;
+    _receivedBytes = 0;
+    constructor(sock, ssl, isHTTPS, cleanup, contentLength = 0) {
+        this._sock = sock;
+        this._ssl = ssl;
+        this._isHTTPS = isHTTPS;
+        this._cleanup = cleanup;
+        this._contentLength = contentLength;
+    }
+    get locked() { return this._locked; }
+    getReader() {
+        if (this._locked)
+            throw new TypeError('ReadableStream is locked');
+        this._locked = true;
+        return new _QuickReader(this);
+    }
+    cancel(reason) {
+        if (this._state !== 'readable')
+            return;
+        this._state = 'closed';
+        this._locked = false;
+        if (this._cleanup) {
+            this._cleanup();
+            this._cleanup = null;
+        }
+        if (this._pendingRead) {
+            const pr = this._pendingRead;
+            this._pendingRead = null;
+            pr.resolve({ done: true });
+        }
+    }
+    // ── Internal methods called by socket handler ──
+    _pushChunk(buf) {
+        if (this._state !== 'readable')
+            return;
+        const chunk = new Uint8Array(buf);
+        this._receivedBytes += chunk.length;
+        if (this._pendingRead) {
+            const pr = this._pendingRead;
+            this._pendingRead = null;
+            pr.resolve({ done: false, value: chunk });
+        }
+        else {
+            this._chunks.push(chunk);
+        }
+        // Auto-close if Content-Length is satisfied
+        if (this._contentLength > 0 && this._receivedBytes >= this._contentLength) {
+            this._close();
+        }
+    }
+    _close() {
+        if (this._state !== 'readable')
+            return;
+        this._state = 'closed';
+        if (this._cleanup) {
+            this._cleanup();
+            this._cleanup = null;
+        }
+        if (this._pendingRead) {
+            const pr = this._pendingRead;
+            this._pendingRead = null;
+            pr.resolve({ done: true });
+        }
+    }
+    _error(err) {
+        if (this._state !== 'readable')
+            return;
+        this._state = 'errored';
+        if (this._pendingRead) {
+            const pr = this._pendingRead;
+            this._pendingRead = null;
+            pr.reject(err);
+        }
+    }
+    _tryRead() {
+        if (this._chunks.length > 0) {
+            const chunk = this._chunks.shift();
+            return Promise.resolve({ done: false, value: chunk });
+        }
+        if (this._state === 'closed')
+            return Promise.resolve({ done: true });
+        if (this._state === 'errored')
+            return Promise.reject(new Error('Stream errored'));
+        return null;
+    }
+}
+class _PreloadedStream {
+    _buffer;
+    _offset = 0;
+    _state = 'readable';
+    _pendingRead = null;
+    _locked = false;
+    constructor(buffer) {
+        this._buffer = new Uint8Array(buffer);
+    }
+    get locked() { return this._locked; }
+    getReader() {
+        if (this._locked)
+            throw new TypeError('ReadableStream is locked');
+        this._locked = true;
+        const stream = this;
+        return {
+            read() {
+                if (stream._offset < stream._buffer.length) {
+                    const chunk = stream._buffer.slice(stream._offset, stream._offset + 8192);
+                    stream._offset += chunk.length;
+                    return Promise.resolve({ done: false, value: chunk });
+                }
+                return Promise.resolve({ done: true });
+            },
+            cancel(reason) {
+                stream._state = 'closed';
+                stream._locked = false;
+            },
+            releaseLock() {
+                // no-op
+            }
+        };
+    }
+    cancel(reason) {
+        this._state = 'closed';
+        this._locked = false;
+    }
+    _tryRead() {
+        if (this._offset < this._buffer.length) {
+            const chunk = this._buffer.slice(this._offset, this._offset + 8192);
+            this._offset += chunk.length;
+            return Promise.resolve({ done: false, value: chunk });
+        }
+        if (this._state === 'closed')
+            return Promise.resolve({ done: true });
+        return null;
+    }
+}
+class _QuickReader {
+    _stream;
+    constructor(stream) {
+        this._stream = stream;
+    }
+    read() {
+        if (!this._stream)
+            throw new TypeError('Reader released');
+        const result = this._stream._tryRead();
+        if (result)
+            return result;
+        return new Promise((resolve, reject) => {
+            if (!this._stream) {
+                reject(new TypeError('Reader released'));
+                return;
+            }
+            this._stream._pendingRead = { resolve, reject };
+        });
+    }
+    cancel(reason) {
+        if (this._stream) {
+            this._stream.cancel(reason);
+            this._stream = null;
+        }
+    }
+    releaseLock() {
+        this._stream = null;
+    }
+}
+// ── Headers ──
+class FetchHeaders {
+    _headers = {};
+    constructor(init) {
+        if (init) {
+            if (init instanceof FetchHeaders) {
+                this._headers = { ...init._headers };
+            }
+            else if (typeof init === 'object') {
+                for (const key in init) {
+                    this._headers[key.toLowerCase()] = init[key];
+                }
+            }
+        }
+    }
+    append(name, value) {
+        const key = name.toLowerCase();
+        if (this._headers[key]) {
+            this._headers[key] += ', ' + value;
+        }
+        else {
+            this._headers[key] = value;
+        }
+    }
+    delete(name) {
+        delete this._headers[name.toLowerCase()];
+    }
+    get(name) {
+        return this._headers[name.toLowerCase()] || null;
+    }
+    has(name) {
+        return name.toLowerCase() in this._headers;
+    }
+    set(name, value) {
+        this._headers[name.toLowerCase()] = value;
+    }
+    forEach(callback) {
+        for (const key in this._headers) {
+            callback(this._headers[key], key, this);
+        }
+    }
+    entries() {
+        const entries = [];
+        for (const key in this._headers) {
+            entries.push([key, this._headers[key]]);
+        }
+        return entries[Symbol.iterator]();
+    }
+    keys() {
+        return Object.keys(this._headers)[Symbol.iterator]();
+    }
+    values() {
+        const values = [];
+        for (const key in this._headers) {
+            values.push(this._headers[key]);
+        }
+        return values[Symbol.iterator]();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}
+// ── Response ──
+class FetchResponse {
+    status;
+    statusText;
+    headers;
+    ok;
+    redirected;
+    type;
+    url;
+    body;
+    _bodyConsumed = false;
+    _preloadedBody = null;
+    get bodyUsed() {
+        return this._bodyConsumed || this.body.locked;
+    }
+    constructor(status, statusText, headers, bodyStream) {
+        this.status = status;
+        this.statusText = statusText;
+        this.headers = headers;
+        this.ok = status >= 200 && status < 300;
+        this.redirected = false;
+        this.type = 'basic';
+        this.url = '';
+        this.body = bodyStream;
+    }
+    async text() {
+        if (this._preloadedBody) {
+            if (this._bodyConsumed)
+                throw new TypeError('Body already used');
+            this._bodyConsumed = true;
+            return ab2str(this._preloadedBody);
+        }
+        if (this.bodyUsed)
+            throw new TypeError('Body already used');
+        this._bodyConsumed = true;
+        const reader = this.body.getReader();
+        let result = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            for (let i = 0; i < value.length; i++)
+                result += String.fromCharCode(value[i]);
+        }
+        return result;
+    }
+    async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+    }
+    async arrayBuffer() {
+        if (this._preloadedBody) {
+            if (this._bodyConsumed)
+                throw new TypeError('Body already used');
+            this._bodyConsumed = true;
+            return this._preloadedBody;
+        }
+        if (this.bodyUsed)
+            throw new TypeError('Body already used');
+        this._bodyConsumed = true;
+        const reader = this.body.getReader();
+        const chunks = [];
+        let totalLength = 0;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            chunks.push(value);
+            totalLength += value.length;
+        }
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return getArrayBuffer(result);
+    }
+}
+function parseHeaders(data) {
+    const headerEnd = data.indexOf('\r\n\r\n');
+    if (headerEnd < 0)
+        return null;
+    const headerPart = data.slice(0, headerEnd);
+    const lines = headerPart.split('\r\n');
+    const statusLine = lines[0];
+    const match = statusLine.match(/^HTTP\/\d\.\d\s+(\d+)\s+(.*)$/);
+    if (!match)
+        throw new Error('Invalid HTTP response: ' + statusLine);
+    const status = parseInt(match[1], 10);
+    const statusText = match[2];
+    const headers = new FetchHeaders();
+    for (let i = 1; i < lines.length; i++) {
+        const colonIndex = lines[i].indexOf(':');
+        if (colonIndex > 0) {
+            const name = lines[i].slice(0, colonIndex).trim();
+            const value = lines[i].slice(colonIndex + 1).trim();
+            headers.append(name, value);
+        }
+    }
+    return { status, statusText, headers };
+}
+// ── State machine constants ──
+const ST_CONNECTING = 0;
+const ST_HANDSHAKE = 1;
+const ST_SEND = 2;
+const ST_RECV_HEADERS = 3;
+const ST_RECV_BODY = 4;
+const ST_DONE = 5;
+// ── Main fetch request ──
+function fetchRequest(parsedUrl, options) {
+    return new Promise((resolve, reject) => {
+        const method = options.method || 'GET';
+        const headers = new FetchHeaders(options.headers);
+        const body = options.body || null;
+        const timeout = options.timeout || 30000;
+        const isHTTPS = parsedUrl.protocol === 'https:';
+        if (!headers.has('host'))
+            headers.set('Host', parsedUrl.hostname);
+        if (!headers.has('user-agent'))
+            headers.set('User-Agent', 'QuickJS/1.0');
+        if (!headers.has('connection'))
+            headers.set('Connection', 'close');
+        if (!headers.has('accept-encoding'))
+            headers.set('Accept-Encoding', 'br');
+        if (body && !headers.has('content-length'))
+            headers.set('Content-Length', String(body.length));
+        let request = method + ' ' + parsedUrl.pathname + ' HTTP/1.1\r\n';
+        headers.forEach((value, name) => {
+            request += name + ': ' + value + '\r\n';
+        });
+        request += '\r\n';
+        if (body)
+            request += body;
+        let s = null;
+        let ssl = null;
+        let ctx = null;
+        let state = ST_CONNECTING;
+        let resolved = false;
+        let timerId;
+        let stream = null;
+        let headerBuffer = '';
+        const cleanupSocket = () => {
+            state = ST_DONE;
+            if (ssl) {
+                wolfssl.wolfSSL_free(ssl);
+                ssl = null;
+            }
+            if (ctx) {
+                wolfssl.wolfSSL_CTX_free(ctx);
+                ctx = null;
+            }
+            if (s) {
+                sock.closesocket(s);
+                s = null;
+            }
+        };
+        const cleanup = () => {
+            if (timerId) {
+                clearTimeout(timerId);
+                timerId = undefined;
+            }
+        };
+        const doResolve = (response) => {
+            if (!resolved) {
+                resolved = true;
+                cleanup();
+                resolve(response);
+            }
+        };
+        const doReject = (error) => {
+            if (!resolved) {
+                resolved = true;
+                cleanup();
+                cleanupSocket();
+                reject(error);
+            }
+        };
+        const streamCleanup = () => {
+            cleanup();
+            cleanupSocket();
+        };
+        timerId = setTimeout(() => {
+            doReject(new Error('Request timeout'));
+        }, timeout);
+        s = sock.socket();
+        if (!s || s === 0) {
+            doReject(new Error('Failed to create socket'));
+            return;
+        }
+        const fd = s;
+        sock.set_on_event(fd, (event) => {
+            if (state === ST_DONE)
+                return;
+            if (event.lNetworkEvents & sock.FD_CONNECT) {
+                const err = event.iErrorCode[0];
+                if (err !== 0) {
+                    doReject(new Error('Connection failed: ' + err));
+                    return;
+                }
+                if (isHTTPS) {
+                    const method = wolfssl.wolfTLSv1_2_client_method();
+                    ctx = wolfssl.wolfSSL_CTX_new(method);
+                    wolfssl.wolfSSL_CTX_set_verify(ctx, wolfssl.SSL_VERIFY_NONE);
+                    ssl = wolfssl.wolfSSL_new(ctx);
+                    if (!ssl) {
+                        doReject(new Error('SSL_new failed'));
+                        return;
+                    }
+                    wolfssl.wolfSSL_set_fd(ssl, sock.get_fd(fd));
+                    const sniHost = headers.get('host') || parsedUrl.hostname;
+                    if (sniHost)
+                        wolfssl.wolfSSL_UseSNI(ssl, wolfssl.WOLFSSL_SNI_HOST_NAME, sniHost);
+                    state = ST_HANDSHAKE;
+                }
+                else {
+                    sock.send(fd, str2ab(request));
+                    state = ST_RECV_HEADERS;
+                }
+            }
+            if ((event.lNetworkEvents & sock.FD_READ) || (event.lNetworkEvents & sock.FD_WRITE)) {
+                if (state === ST_HANDSHAKE) {
+                    if (!ssl) {
+                        doReject(new Error('TLS not initialized'));
+                        return;
+                    }
+                    const ret = wolfssl.wolfSSL_connect(ssl);
+                    if (ret === wolfssl.SSL_SUCCESS) {
+                        wolfssl.wolfSSL_write(ssl, str2ab(request));
+                        state = ST_RECV_HEADERS;
+                    }
+                    else {
+                        const err = wolfssl.wolfSSL_get_error(ssl, ret);
+                        if (err !== wolfssl.WOLFSSL_ERROR_WANT_READ &&
+                            err !== wolfssl.WOLFSSL_ERROR_WANT_WRITE) {
+                            doReject(new Error('TLS handshake failed: ' + err));
+                        }
+                    }
+                }
+                else if (state === ST_RECV_HEADERS) {
+                    while (true) {
+                        if (!s && !ssl)
+                            break;
+                        let data;
+                        if (isHTTPS && ssl) {
+                            data = wolfssl.wolfSSL_read(ssl, 8192);
+                        }
+                        else if (s) {
+                            data = sock.recv(s, 8192);
+                        }
+                        else {
+                            break;
+                        }
+                        if (!data || data.byteLength === 0)
+                            break;
+                        headerBuffer += ab2str(data);
+                        const headerEnd = headerBuffer.indexOf('\r\n\r\n');
+                        if (headerEnd >= 0) {
+                            const parsed = parseHeaders(headerBuffer);
+                            if (!parsed) {
+                                doReject(new Error('Failed to parse HTTP headers'));
+                                return;
+                            }
+                            const trailingBody = headerBuffer.slice(headerEnd + 4);
+                            const contentLength = parseInt(parsed.headers.get('content-length') || '0', 10);
+                            stream = new _QuickReadableStream(fd, ssl, isHTTPS, streamCleanup, contentLength);
+                            if (trailingBody.length > 0) {
+                                stream._pushChunk(str2ab(trailingBody));
+                            }
+                            const response = new FetchResponse(parsed.status, parsed.statusText, parsed.headers, stream);
+                            state = ST_RECV_BODY;
+                            doResolve(response);
+                            // Break out of header recv loop — any remaining data
+                            // in the socket will be handled by the ST_RECV_BODY path below
+                            break;
+                        }
+                    }
+                }
+                else if (state === ST_RECV_BODY && stream) {
+                    while (true) {
+                        if (!s && !ssl)
+                            break;
+                        let data;
+                        if (isHTTPS && ssl) {
+                            data = wolfssl.wolfSSL_read(ssl, 8192);
+                        }
+                        else if (s) {
+                            data = sock.recv(s, 8192);
+                        }
+                        else {
+                            break;
+                        }
+                        if (!data || data.byteLength === 0)
+                            break;
+                        stream._pushChunk(data);
+                    }
+                }
+            }
+            if (event.lNetworkEvents & sock.FD_CLOSE) {
+                if (state === ST_DONE)
+                    return;
+                if (state === ST_RECV_HEADERS) {
+                    doReject(new Error('Connection closed before response'));
+                }
+                else if (state === ST_RECV_BODY && stream) {
+                    while (true) {
+                        if (!s && !ssl)
+                            break;
+                        let data;
+                        if (isHTTPS && ssl) {
+                            data = wolfssl.wolfSSL_read(ssl, 8192);
+                        }
+                        else if (s) {
+                            data = sock.recv(s, 8192);
+                        }
+                        else {
+                            break;
+                        }
+                        if (!data || data.byteLength === 0)
+                            break;
+                        stream._pushChunk(data);
+                    }
+                    stream._close();
+                    stream = null;
+                    state = ST_DONE;
+                }
+            }
+        });
+        const ip = sock.resolve(parsedUrl.hostname);
+        if (!ip) {
+            doReject(new Error('DNS resolution failed for: ' + parsedUrl.hostname));
+            return;
+        }
+        sock.connect(s, ip, parseInt(parsedUrl.port, 10) || (isHTTPS ? 443 : 80));
+    });
+}
+// ── Public fetch (with redirect handling and caching) ──
+function headersToObj(headers) {
+    const obj = {};
+    headers.forEach((value, name) => { obj[name] = value; });
+    return obj;
+}
+function parseMaxAge(cc) {
+    const m = cc.match(/max-age=(\d+)/);
+    return m ? parseInt(m[1], 10) : 0;
+}
+async function fetch(url, options = {}) {
+    const redirectMode = options.redirect || 'follow';
+    const maxRedirects = redirectMode === 'follow' ? (options.maxRedirects || 5) : 0;
+    let currentUrl = url;
+    let redirectCount = 0;
+    const method = options.method || 'GET';
+    const cache = typeof __httpCache__ !== 'undefined' ? __httpCache__ : null;
+    // ── Cache lookup (GET only) ──
+    let cachedMeta = null;
+    let conditionalHeaders = {};
+    if (cache && method === 'GET') {
+        const metaStr = cache.readMeta(currentUrl);
+        if (metaStr) {
+            cachedMeta = JSON.parse(metaStr);
+            const age = Math.floor(Date.now() / 1000) - cachedMeta.storedAt;
+            if (cachedMeta.maxAge > 0 && age < cachedMeta.maxAge) {
+                const body = cache.readBody(currentUrl);
+                if (body) {
+                    const resp = new FetchResponse(cachedMeta.status, cachedMeta.statusText, new FetchHeaders(cachedMeta.headers || {}), new _PreloadedStream(body));
+                    resp.url = currentUrl;
+                    resp._preloadedBody = body;
+                    return resp;
+                }
+            }
+            if (cachedMeta.etag)
+                conditionalHeaders['If-None-Match'] = cachedMeta.etag;
+            if (cachedMeta.lastModified)
+                conditionalHeaders['If-Modified-Since'] = cachedMeta.lastModified;
+        }
+    }
+    while (true) {
+        const mergedOptions = { ...options };
+        const mergedHeaders = { ...(options.headers || {}) };
+        for (const key in conditionalHeaders) {
+            mergedHeaders[key] = conditionalHeaders[key];
+        }
+        if (Object.keys(mergedHeaders).length > 0)
+            mergedOptions.headers = mergedHeaders;
+        const parsedUrl = new URL(currentUrl);
+        const response = await fetchRequest(parsedUrl, mergedOptions);
+        response.url = currentUrl;
+        // ── Handle brotli Content-Encoding ──
+        const contentEncoding = response.headers.get('content-encoding') || '';
+        if (contentEncoding.includes('br')) {
+            const compressedBody = await response.arrayBuffer();
+            const decompressedBody = brotli.decompress(compressedBody);
+            const newHeaders = new FetchHeaders();
+            response.headers.forEach((v, k) => {
+                if (k !== 'content-encoding')
+                    newHeaders.set(k, v);
+            });
+            newHeaders.set('content-length', String(decompressedBody.byteLength));
+            const stream = new _PreloadedStream(decompressedBody);
+            response._preloadedBody = decompressedBody;
+            response._bodyConsumed = false;
+            response.body = stream;
+            response.headers = newHeaders;
+        }
+        // ── Handle 304 Not Modified ──
+        if (response.status === 304 && cachedMeta && cache) {
+            const body = cache.readBody(currentUrl);
+            if (body) {
+                cachedMeta.storedAt = Math.floor(Date.now() / 1000);
+                response.headers.forEach((value, name) => {
+                    cachedMeta.headers[name] = value;
+                });
+                cache.writeMeta(currentUrl, JSON.stringify(cachedMeta));
+                const resp = new FetchResponse(cachedMeta.status, cachedMeta.statusText, new FetchHeaders(cachedMeta.headers), new _PreloadedStream(body));
+                resp.url = currentUrl;
+                resp._preloadedBody = body;
+                return resp;
+            }
+        }
+        // ── Cache 200 GET responses ──
+        if (cache && method === 'GET' && response.status === 200 && !cachedMeta) {
+            const body = await response.arrayBuffer();
+            const cc = response.headers.get('cache-control') || '';
+            const maxAge = parseMaxAge(cc);
+            if (maxAge > 0) {
+                cache.writeCache(currentUrl, maxAge, body);
+                const meta = JSON.stringify({
+                    storedAt: Math.floor(Date.now() / 1000),
+                    maxAge,
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: headersToObj(response.headers),
+                    etag: response.headers.get('etag') || undefined,
+                    lastModified: response.headers.get('last-modified') || undefined,
+                });
+                cache.writeMeta(currentUrl, meta);
+            }
+            const resp = new FetchResponse(response.status, response.statusText, response.headers, new _PreloadedStream(body));
+            resp.url = currentUrl;
+            resp._preloadedBody = body;
+            return resp;
+        }
+        // ── Redirect handling ──
+        const isRedirect = response.status === 301 || response.status === 302 ||
+            response.status === 303 || response.status === 307 || response.status === 308;
+        if (isRedirect) {
+            if (redirectMode === 'error') {
+                response.body.cancel('redirect');
+                throw new Error('Redirect not allowed for: ' + currentUrl);
+            }
+            if (redirectMode === 'manual') {
+                response.redirected = true;
+                return response;
+            }
+            if (maxRedirects > 0 && redirectCount < maxRedirects) {
+                const location = response.headers.get('location');
+                if (!location)
+                    throw new Error('Redirect response missing Location header');
+                response.body.cancel('redirect');
+                currentUrl = new URL(location, currentUrl).href;
+                redirectCount++;
+                response.redirected = true;
+                if (response.status === 303) {
+                    options.method = 'GET';
+                    delete options.body;
+                }
+            }
+            else {
+                if (redirectCount > 0)
+                    response.redirected = true;
+                return response;
+            }
+        }
+        else {
+            if (redirectCount > 0)
+                response.redirected = true;
+            return response;
+        }
+    }
+}
+// ── Register globals ──
+globalThis.fetch = fetch;
+globalThis.Response = FetchResponse;
+globalThis.Headers = FetchHeaders;