recker 1.0.26 → 1.0.27

package/dist/browser/cache.js

@@ -0,0 +1,199 @@
+export class IndexedDBStorage {
+    dbName;
+    storeName;
+    defaultTTL;
+    maxEntries;
+    db = null;
+    initPromise = null;
+    constructor(options = {}) {
+        this.dbName = options.dbName ?? 'recker-cache';
+        this.storeName = options.storeName ?? 'responses';
+        this.defaultTTL = options.defaultTTL ?? 5 * 60 * 1000;
+        this.maxEntries = options.maxEntries ?? 1000;
+    }
+    async init() {
+        if (this.db)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.dbName, 1);
+            request.onerror = () => {
+                reject(new Error(`Failed to open IndexedDB: ${request.error?.message}`));
+            };
+            request.onsuccess = () => {
+                this.db = request.result;
+                resolve();
+            };
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains(this.storeName)) {
+                    const store = db.createObjectStore(this.storeName, { keyPath: 'key' });
+                    store.createIndex('expiresAt', 'expiresAt', { unique: false });
+                }
+            };
+        });
+        return this.initPromise;
+    }
+    async get(key) {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.get(key);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                const entry = request.result;
+                if (!entry) {
+                    resolve(null);
+                    return;
+                }
+                if (entry.expiresAt && entry.expiresAt < Date.now()) {
+                    this.delete(key).catch(() => { });
+                    resolve(null);
+                    return;
+                }
+                resolve(entry);
+            };
+        });
+    }
+    async set(key, value, ttl, metadata) {
+        await this.init();
+        const entry = {
+            key,
+            value,
+            createdAt: Date.now(),
+            expiresAt: ttl !== undefined ? Date.now() + ttl : undefined,
+            etag: metadata?.etag,
+            lastModified: metadata?.lastModified,
+        };
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.put(entry);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve();
+            transaction.oncomplete = () => {
+                this.enforceMaxEntries().catch(() => { });
+            };
+        });
+    }
+    async delete(key) {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.delete(key);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(true);
+        });
+    }
+    async has(key) {
+        const entry = await this.get(key);
+        return entry !== null;
+    }
+    async clear() {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.clear();
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve();
+        });
+    }
+    async keys() {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.getAllKeys();
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+    async size() {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.count();
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+    async cleanup() {
+        await this.init();
+        const now = Date.now();
+        let removed = 0;
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const index = store.index('expiresAt');
+            const range = IDBKeyRange.upperBound(now);
+            const request = index.openCursor(range);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = (event) => {
+                const cursor = event.target.result;
+                if (cursor) {
+                    cursor.delete();
+                    removed++;
+                    cursor.continue();
+                }
+            };
+            transaction.oncomplete = () => resolve(removed);
+        });
+    }
+    async enforceMaxEntries() {
+        const currentSize = await this.size();
+        if (currentSize <= this.maxEntries)
+            return;
+        const toRemove = currentSize - this.maxEntries;
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const index = store.index('expiresAt');
+            let removed = 0;
+            const request = index.openCursor();
+            request.onerror = () => reject(request.error);
+            request.onsuccess = (event) => {
+                const cursor = event.target.result;
+                if (cursor && removed < toRemove) {
+                    cursor.delete();
+                    removed++;
+                    cursor.continue();
+                }
+            };
+            transaction.oncomplete = () => resolve();
+        });
+    }
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+            this.initPromise = null;
+        }
+    }
+    async destroy() {
+        this.close();
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.deleteDatabase(this.dbName);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve();
+        });
+    }
+}
+export function isIndexedDBAvailable() {
+    try {
+        return typeof indexedDB !== 'undefined' && indexedDB !== null;
+    }
+    catch {
+        return false;
+    }
+}
+export function getBrowserCacheStorage(options) {
+    if (isIndexedDBAvailable()) {
+        return new IndexedDBStorage(options);
+    }
+    return null;
+}

package/dist/browser/constants/http-status.d.ts

@@ -0,0 +1,73 @@
+export declare const HttpStatus: {
+    readonly CONTINUE: 100;
+    readonly SWITCHING_PROTOCOLS: 101;
+    readonly PROCESSING: 102;
+    readonly EARLY_HINTS: 103;
+    readonly OK: 200;
+    readonly CREATED: 201;
+    readonly ACCEPTED: 202;
+    readonly NON_AUTHORITATIVE_INFORMATION: 203;
+    readonly NO_CONTENT: 204;
+    readonly RESET_CONTENT: 205;
+    readonly PARTIAL_CONTENT: 206;
+    readonly MULTI_STATUS: 207;
+    readonly ALREADY_REPORTED: 208;
+    readonly IM_USED: 226;
+    readonly MULTIPLE_CHOICES: 300;
+    readonly MOVED_PERMANENTLY: 301;
+    readonly FOUND: 302;
+    readonly SEE_OTHER: 303;
+    readonly NOT_MODIFIED: 304;
+    readonly USE_PROXY: 305;
+    readonly TEMPORARY_REDIRECT: 307;
+    readonly PERMANENT_REDIRECT: 308;
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly PAYMENT_REQUIRED: 402;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly METHOD_NOT_ALLOWED: 405;
+    readonly NOT_ACCEPTABLE: 406;
+    readonly PROXY_AUTHENTICATION_REQUIRED: 407;
+    readonly REQUEST_TIMEOUT: 408;
+    readonly CONFLICT: 409;
+    readonly GONE: 410;
+    readonly LENGTH_REQUIRED: 411;
+    readonly PRECONDITION_FAILED: 412;
+    readonly PAYLOAD_TOO_LARGE: 413;
+    readonly URI_TOO_LONG: 414;
+    readonly UNSUPPORTED_MEDIA_TYPE: 415;
+    readonly RANGE_NOT_SATISFIABLE: 416;
+    readonly EXPECTATION_FAILED: 417;
+    readonly IM_A_TEAPOT: 418;
+    readonly MISDIRECTED_REQUEST: 421;
+    readonly UNPROCESSABLE_ENTITY: 422;
+    readonly LOCKED: 423;
+    readonly FAILED_DEPENDENCY: 424;
+    readonly TOO_EARLY: 425;
+    readonly UPGRADE_REQUIRED: 426;
+    readonly PRECONDITION_REQUIRED: 428;
+    readonly TOO_MANY_REQUESTS: 429;
+    readonly REQUEST_HEADER_FIELDS_TOO_LARGE: 431;
+    readonly UNAVAILABLE_FOR_LEGAL_REASONS: 451;
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly NOT_IMPLEMENTED: 501;
+    readonly BAD_GATEWAY: 502;
+    readonly SERVICE_UNAVAILABLE: 503;
+    readonly GATEWAY_TIMEOUT: 504;
+    readonly HTTP_VERSION_NOT_SUPPORTED: 505;
+    readonly VARIANT_ALSO_NEGOTIATES: 506;
+    readonly INSUFFICIENT_STORAGE: 507;
+    readonly LOOP_DETECTED: 508;
+    readonly NOT_EXTENDED: 510;
+    readonly NETWORK_AUTHENTICATION_REQUIRED: 511;
+};
+export type HttpStatusCode = (typeof HttpStatus)[keyof typeof HttpStatus];
+export declare const HttpStatusText: Record<HttpStatusCode, string>;
+export declare function isSuccess(status: number): boolean;
+export declare function isRedirect(status: number): boolean;
+export declare function isClientError(status: number): boolean;
+export declare function isServerError(status: number): boolean;
+export declare function isError(status: number): boolean;
+export declare function isRetryable(status: number): boolean;
+export declare function getStatusText(status: number): string;

package/dist/browser/constants/http-status.js

@@ -0,0 +1,156 @@
+export const HttpStatus = {
+    CONTINUE: 100,
+    SWITCHING_PROTOCOLS: 101,
+    PROCESSING: 102,
+    EARLY_HINTS: 103,
+    OK: 200,
+    CREATED: 201,
+    ACCEPTED: 202,
+    NON_AUTHORITATIVE_INFORMATION: 203,
+    NO_CONTENT: 204,
+    RESET_CONTENT: 205,
+    PARTIAL_CONTENT: 206,
+    MULTI_STATUS: 207,
+    ALREADY_REPORTED: 208,
+    IM_USED: 226,
+    MULTIPLE_CHOICES: 300,
+    MOVED_PERMANENTLY: 301,
+    FOUND: 302,
+    SEE_OTHER: 303,
+    NOT_MODIFIED: 304,
+    USE_PROXY: 305,
+    TEMPORARY_REDIRECT: 307,
+    PERMANENT_REDIRECT: 308,
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    PAYMENT_REQUIRED: 402,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    METHOD_NOT_ALLOWED: 405,
+    NOT_ACCEPTABLE: 406,
+    PROXY_AUTHENTICATION_REQUIRED: 407,
+    REQUEST_TIMEOUT: 408,
+    CONFLICT: 409,
+    GONE: 410,
+    LENGTH_REQUIRED: 411,
+    PRECONDITION_FAILED: 412,
+    PAYLOAD_TOO_LARGE: 413,
+    URI_TOO_LONG: 414,
+    UNSUPPORTED_MEDIA_TYPE: 415,
+    RANGE_NOT_SATISFIABLE: 416,
+    EXPECTATION_FAILED: 417,
+    IM_A_TEAPOT: 418,
+    MISDIRECTED_REQUEST: 421,
+    UNPROCESSABLE_ENTITY: 422,
+    LOCKED: 423,
+    FAILED_DEPENDENCY: 424,
+    TOO_EARLY: 425,
+    UPGRADE_REQUIRED: 426,
+    PRECONDITION_REQUIRED: 428,
+    TOO_MANY_REQUESTS: 429,
+    REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+    UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+    INTERNAL_SERVER_ERROR: 500,
+    NOT_IMPLEMENTED: 501,
+    BAD_GATEWAY: 502,
+    SERVICE_UNAVAILABLE: 503,
+    GATEWAY_TIMEOUT: 504,
+    HTTP_VERSION_NOT_SUPPORTED: 505,
+    VARIANT_ALSO_NEGOTIATES: 506,
+    INSUFFICIENT_STORAGE: 507,
+    LOOP_DETECTED: 508,
+    NOT_EXTENDED: 510,
+    NETWORK_AUTHENTICATION_REQUIRED: 511,
+};
+export const HttpStatusText = {
+    100: 'Continue',
+    101: 'Switching Protocols',
+    102: 'Processing',
+    103: 'Early Hints',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    203: 'Non-Authoritative Information',
+    204: 'No Content',
+    205: 'Reset Content',
+    206: 'Partial Content',
+    207: 'Multi-Status',
+    208: 'Already Reported',
+    226: 'IM Used',
+    300: 'Multiple Choices',
+    301: 'Moved Permanently',
+    302: 'Found',
+    303: 'See Other',
+    304: 'Not Modified',
+    305: 'Use Proxy',
+    307: 'Temporary Redirect',
+    308: 'Permanent Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Timeout',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Payload Too Large',
+    414: 'URI Too Long',
+    415: 'Unsupported Media Type',
+    416: 'Range Not Satisfiable',
+    417: 'Expectation Failed',
+    418: "I'm a Teapot",
+    421: 'Misdirected Request',
+    422: 'Unprocessable Entity',
+    423: 'Locked',
+    424: 'Failed Dependency',
+    425: 'Too Early',
+    426: 'Upgrade Required',
+    428: 'Precondition Required',
+    429: 'Too Many Requests',
+    431: 'Request Header Fields Too Large',
+    451: 'Unavailable For Legal Reasons',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+    505: 'HTTP Version Not Supported',
+    506: 'Variant Also Negotiates',
+    507: 'Insufficient Storage',
+    508: 'Loop Detected',
+    510: 'Not Extended',
+    511: 'Network Authentication Required',
+};
+export function isSuccess(status) {
+    return status >= 200 && status < 300;
+}
+export function isRedirect(status) {
+    return status >= 300 && status < 400;
+}
+export function isClientError(status) {
+    return status >= 400 && status < 500;
+}
+export function isServerError(status) {
+    return status >= 500 && status < 600;
+}
+export function isError(status) {
+    return status >= 400;
+}
+export function isRetryable(status) {
+    const retryableCodes = [
+        HttpStatus.TOO_MANY_REQUESTS,
+        HttpStatus.INTERNAL_SERVER_ERROR,
+        HttpStatus.BAD_GATEWAY,
+        HttpStatus.SERVICE_UNAVAILABLE,
+        HttpStatus.GATEWAY_TIMEOUT,
+    ];
+    return retryableCodes.includes(status);
+}
+export function getStatusText(status) {
+    return HttpStatusText[status] || 'Unknown Status';
+}

package/dist/browser/cookies/memory-cookie-jar.d.ts

@@ -0,0 +1,30 @@
+import type { CookieJar } from '../types/index.js';
+interface ParsedCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    expires?: Date;
+    maxAge?: number;
+    secure: boolean;
+    httpOnly: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    partitioned?: boolean;
+    priority?: 'Low' | 'Medium' | 'High';
+    createdAt: number;
+}
+export declare class MemoryCookieJar implements CookieJar {
+    private cookies;
+    getCookieString(url: string): string;
+    setCookie(rawCookie: string, url: string): void;
+    clear(): void;
+    clearDomain(domain: string): void;
+    getAllCookies(): ParsedCookie[];
+    private parseCookie;
+    private decode;
+    private domainMatches;
+    private pathMatches;
+    private defaultPath;
+    private isExpired;
+}
+export {};

package/dist/browser/cookies/memory-cookie-jar.js

@@ -0,0 +1,210 @@
+const cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
+const cookieValueRegExp = /^[\u0021-\u003A\u003C-\u007E]*$/;
+const domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+const pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
+export class MemoryCookieJar {
+    cookies = new Map();
+    getCookieString(url) {
+        const parsedUrl = new URL(url);
+        const hostname = parsedUrl.hostname;
+        const pathname = parsedUrl.pathname || '/';
+        const isSecure = parsedUrl.protocol === 'https:';
+        const now = Date.now();
+        const matchingCookies = [];
+        for (const [domain, pathMap] of this.cookies.entries()) {
+            if (!this.domainMatches(hostname, domain))
+                continue;
+            for (const [path, nameMap] of pathMap.entries()) {
+                if (!this.pathMatches(pathname, path))
+                    continue;
+                for (const cookie of nameMap.values()) {
+                    if (this.isExpired(cookie, now)) {
+                        nameMap.delete(cookie.name);
+                        continue;
+                    }
+                    if (cookie.secure && !isSecure)
+                        continue;
+                    matchingCookies.push(cookie);
+                }
+            }
+        }
+        matchingCookies.sort((a, b) => {
+            const pathDiff = b.path.length - a.path.length;
+            if (pathDiff !== 0)
+                return pathDiff;
+            return a.createdAt - b.createdAt;
+        });
+        return matchingCookies.map(c => `${c.name}=${c.value}`).join('; ');
+    }
+    setCookie(rawCookie, url) {
+        const parsedUrl = new URL(url);
+        const hostname = parsedUrl.hostname;
+        const pathname = parsedUrl.pathname || '/';
+        const cookie = this.parseCookie(rawCookie, hostname, pathname);
+        if (!cookie)
+            return;
+        if (!this.domainMatches(hostname, cookie.domain)) {
+            return;
+        }
+        if (!this.cookies.has(cookie.domain)) {
+            this.cookies.set(cookie.domain, new Map());
+        }
+        const domainMap = this.cookies.get(cookie.domain);
+        if (!domainMap.has(cookie.path)) {
+            domainMap.set(cookie.path, new Map());
+        }
+        const pathMap = domainMap.get(cookie.path);
+        pathMap.set(cookie.name, cookie);
+    }
+    clear() {
+        this.cookies.clear();
+    }
+    clearDomain(domain) {
+        this.cookies.delete(domain);
+    }
+    getAllCookies() {
+        const all = [];
+        for (const domainMap of this.cookies.values()) {
+            for (const pathMap of domainMap.values()) {
+                for (const cookie of pathMap.values()) {
+                    all.push(cookie);
+                }
+            }
+        }
+        return all;
+    }
+    parseCookie(setCookieStr, requestDomain, requestPath) {
+        const parts = setCookieStr.split(';').map(p => p.trim());
+        if (parts.length === 0 || !parts[0])
+            return null;
+        const [nameValue, ...attributes] = parts;
+        const eqIndex = nameValue.indexOf('=');
+        if (eqIndex === -1)
+            return null;
+        const name = nameValue.substring(0, eqIndex).trim();
+        const rawValue = nameValue.substring(eqIndex + 1).trim();
+        if (!name)
+            return null;
+        const value = this.decode(rawValue);
+        const cookie = {
+            name,
+            value,
+            domain: requestDomain,
+            path: this.defaultPath(requestPath),
+            secure: false,
+            httpOnly: false,
+            createdAt: Date.now()
+        };
+        for (const attr of attributes) {
+            const lowerAttr = attr.toLowerCase();
+            if (lowerAttr === 'secure') {
+                cookie.secure = true;
+            }
+            else if (lowerAttr === 'httponly') {
+                cookie.httpOnly = true;
+            }
+            else if (lowerAttr === 'partitioned') {
+                cookie.partitioned = true;
+            }
+            else if (lowerAttr.startsWith('domain=')) {
+                let domain = attr.substring(7).trim();
+                if (domain.startsWith('.')) {
+                    domain = domain.substring(1);
+                }
+                if (domainValueRegExp.test(domain)) {
+                    cookie.domain = domain.toLowerCase();
+                }
+            }
+            else if (lowerAttr.startsWith('path=')) {
+                const path = attr.substring(5).trim();
+                if (!path || pathValueRegExp.test(path)) {
+                    cookie.path = path || '/';
+                }
+            }
+            else if (lowerAttr.startsWith('expires=')) {
+                const expiresStr = attr.substring(8).trim();
+                const expires = new Date(expiresStr);
+                if (Number.isFinite(expires.valueOf())) {
+                    cookie.expires = expires;
+                }
+            }
+            else if (lowerAttr.startsWith('max-age=')) {
+                const maxAgeStr = attr.substring(8).trim();
+                if (/^-?\d+$/.test(maxAgeStr)) {
+                    cookie.maxAge = parseInt(maxAgeStr, 10);
+                }
+            }
+            else if (lowerAttr.startsWith('samesite=')) {
+                const samesite = attr.substring(9).trim().toLowerCase();
+                if (samesite === 'strict')
+                    cookie.sameSite = 'Strict';
+                else if (samesite === 'lax')
+                    cookie.sameSite = 'Lax';
+                else if (samesite === 'none')
+                    cookie.sameSite = 'None';
+            }
+            else if (lowerAttr.startsWith('priority=')) {
+                const priority = attr.substring(9).trim().toLowerCase();
+                if (priority === 'low')
+                    cookie.priority = 'Low';
+                else if (priority === 'medium')
+                    cookie.priority = 'Medium';
+                else if (priority === 'high')
+                    cookie.priority = 'High';
+            }
+        }
+        return cookie;
+    }
+    decode(str) {
+        if (str.indexOf('%') === -1)
+            return str;
+        try {
+            return decodeURIComponent(str);
+        }
+        catch {
+            return str;
+        }
+    }
+    domainMatches(requestDomain, cookieDomain) {
+        const reqLower = requestDomain.toLowerCase();
+        const cookieLower = cookieDomain.toLowerCase();
+        if (reqLower === cookieLower)
+            return true;
+        if (reqLower.endsWith('.' + cookieLower))
+            return true;
+        return false;
+    }
+    pathMatches(requestPath, cookiePath) {
+        if (requestPath === cookiePath)
+            return true;
+        if (requestPath.startsWith(cookiePath)) {
+            if (cookiePath.endsWith('/'))
+                return true;
+            if (requestPath[cookiePath.length] === '/')
+                return true;
+        }
+        return false;
+    }
+    defaultPath(requestPath) {
+        if (!requestPath || !requestPath.startsWith('/')) {
+            return '/';
+        }
+        const lastSlash = requestPath.lastIndexOf('/');
+        if (lastSlash === 0) {
+            return '/';
+        }
+        return requestPath.substring(0, lastSlash);
+    }
+    isExpired(cookie, now) {
+        if (cookie.maxAge !== undefined) {
+            if (cookie.maxAge <= 0)
+                return true;
+            const expiresAt = cookie.createdAt + (cookie.maxAge * 1000);
+            return now >= expiresAt;
+        }
+        if (cookie.expires) {
+            return now >= cookie.expires.getTime();
+        }
+        return false;
+    }
+}