recker 1.0.2-0

package/dist/utils/header-parser.js

@@ -0,0 +1,457 @@
+export function parseCacheInfo(headers) {
+    const info = { hit: false };
+    const cfCacheStatus = headers.get('cf-cache-status');
+    if (cfCacheStatus) {
+        info.provider = 'cloudflare';
+        info.status = cfCacheStatus.toUpperCase();
+        info.hit = cfCacheStatus.toUpperCase() === 'HIT';
+    }
+    const xCache = headers.get('x-cache');
+    if (xCache) {
+        const upper = xCache.toUpperCase();
+        info.hit = upper.includes('HIT');
+        if (upper.includes('FASTLY'))
+            info.provider = 'fastly';
+        else if (upper.includes('VARNISH'))
+            info.provider = 'varnish';
+        if (upper.includes('HIT'))
+            info.status = 'HIT';
+        else if (upper.includes('MISS'))
+            info.status = 'MISS';
+        else if (upper.includes('EXPIRED'))
+            info.status = 'EXPIRED';
+        else if (upper.includes('STALE'))
+            info.status = 'STALE';
+    }
+    const akamaiCache = headers.get('x-akamai-cache-status');
+    if (akamaiCache) {
+        info.provider = 'akamai';
+        info.hit = akamaiCache.toUpperCase().includes('HIT');
+    }
+    const cloudFrontCache = headers.get('x-cache');
+    const cloudFrontId = headers.get('x-amz-cf-id');
+    if (cloudFrontId) {
+        info.provider = 'cloudfront';
+    }
+    const cacheControl = headers.get('cache-control');
+    if (cacheControl) {
+        const maxAgeMatch = cacheControl.match(/max-age=(\d+)/);
+        if (maxAgeMatch) {
+            info.maxAge = parseInt(maxAgeMatch[1], 10);
+        }
+    }
+    const age = headers.get('age');
+    if (age) {
+        info.age = parseInt(age, 10);
+    }
+    return info;
+}
+const PLATFORM_DETECTORS = [
+    {
+        name: 'cloudflare',
+        category: 'cdn',
+        headers: ['cf-ray', 'cf-cache-status'],
+        detect: (headers) => headers.get('cf-ray') !== null,
+        extract: (headers) => {
+            const ray = headers.get('cf-ray');
+            const metadata = {};
+            if (ray) {
+                metadata.ray = ray;
+                const parts = ray.split('-');
+                if (parts.length > 1) {
+                    return { region: parts[1], metadata };
+                }
+            }
+            return { metadata };
+        }
+    },
+    {
+        name: 'fastly',
+        category: 'cdn',
+        headers: ['fastly-debug-digest', 'x-served-by'],
+        detect: (headers) => {
+            const servedBy = headers.get('x-served-by');
+            return servedBy?.includes('cache-') || headers.get('fastly-debug-digest') !== null;
+        },
+        extract: (headers) => ({
+            server: headers.get('x-served-by') || undefined,
+            metadata: {
+                digest: headers.get('fastly-debug-digest')
+            }
+        })
+    },
+    {
+        name: 'akamai',
+        category: 'cdn',
+        headers: ['x-akamai-request-id', 'x-akamai-cache-status'],
+        detect: (headers) => headers.get('x-akamai-request-id') !== null,
+        extract: (headers) => ({
+            metadata: {
+                requestId: headers.get('x-akamai-request-id'),
+                cacheId: headers.get('x-akamai-cache-status')
+            }
+        })
+    },
+    {
+        name: 'aws-cloudfront',
+        category: 'cloud',
+        headers: ['x-amz-cf-id', 'x-amz-cf-pop'],
+        detect: (headers) => headers.get('x-amz-cf-id') !== null,
+        extract: (headers) => ({
+            region: headers.get('x-amz-cf-pop') || undefined,
+            metadata: {
+                requestId: headers.get('x-amz-cf-id'),
+                pop: headers.get('x-amz-cf-pop')
+            }
+        })
+    },
+    {
+        name: 'gcp',
+        category: 'cloud',
+        headers: ['x-cloud-trace-context', 'x-goog-request-id'],
+        detect: (headers) => headers.get('x-cloud-trace-context') !== null || headers.get('x-goog-request-id') !== null,
+        extract: (headers) => {
+            const trace = headers.get('x-cloud-trace-context');
+            return {
+                metadata: {
+                    traceId: trace ? trace.split('/')[0] : undefined,
+                    requestId: headers.get('x-goog-request-id')
+                }
+            };
+        }
+    },
+    {
+        name: 'azure',
+        category: 'cloud',
+        headers: ['x-ms-request-id', 'x-azure-ref'],
+        detect: (headers) => headers.get('x-ms-request-id') !== null,
+        extract: (headers) => ({
+            metadata: {
+                requestId: headers.get('x-ms-request-id'),
+                ref: headers.get('x-azure-ref')
+            }
+        })
+    },
+    {
+        name: 'oracle-cloud',
+        category: 'cloud',
+        headers: ['x-oracle-dms-rid', 'x-oracle-dms-ecid'],
+        detect: (headers) => headers.get('x-oracle-dms-rid') !== null,
+        extract: (headers) => ({
+            metadata: {
+                requestId: headers.get('x-oracle-dms-rid'),
+                ecid: headers.get('x-oracle-dms-ecid')
+            }
+        })
+    },
+    {
+        name: 'alibaba-cloud',
+        category: 'cloud',
+        headers: ['ali-swift-global-savetime', 'eagleeye-traceid'],
+        detect: (headers) => headers.get('eagleeye-traceid') !== null,
+        extract: (headers) => ({
+            metadata: {
+                traceId: headers.get('eagleeye-traceid')
+            }
+        })
+    },
+    {
+        name: 'vercel',
+        category: 'hosting',
+        headers: ['x-vercel-id', 'x-vercel-cache'],
+        detect: (headers) => headers.get('x-vercel-id') !== null,
+        extract: (headers) => ({
+            metadata: {
+                requestId: headers.get('x-vercel-id'),
+                cache: headers.get('x-vercel-cache')
+            }
+        })
+    },
+    {
+        name: 'netlify',
+        category: 'hosting',
+        headers: ['x-nf-request-id', 'x-nf-trace-id'],
+        detect: (headers) => headers.get('x-nf-request-id') !== null,
+        extract: (headers) => ({
+            metadata: {
+                requestId: headers.get('x-nf-request-id'),
+                traceId: headers.get('x-nf-trace-id')
+            }
+        })
+    },
+    {
+        name: 'render',
+        category: 'hosting',
+        headers: ['x-render-origin-server'],
+        detect: (headers) => headers.get('x-render-origin-server') !== null,
+        extract: (headers) => ({
+            metadata: {
+                origin: headers.get('x-render-origin-server')
+            }
+        })
+    }
+];
+export function parsePlatformInfo(headers) {
+    const info = {
+        metadata: {}
+    };
+    for (const detector of PLATFORM_DETECTORS) {
+        if (detector.detect(headers)) {
+            info.provider = detector.name;
+            info.category = detector.category;
+            const extracted = detector.extract(headers);
+            if (extracted.region)
+                info.region = extracted.region;
+            if (extracted.server)
+                info.server = extracted.server;
+            if (extracted.metadata) {
+                Object.assign(info.metadata, extracted.metadata);
+            }
+            break;
+        }
+    }
+    if (!info.provider) {
+        const server = headers.get('server');
+        if (server) {
+            info.server = server;
+            const serverLower = server.toLowerCase();
+            if (serverLower.includes('cloudflare')) {
+                info.provider = 'cloudflare';
+                info.category = 'cdn';
+            }
+            else if (serverLower.includes('cloudfront')) {
+                info.provider = 'aws-cloudfront';
+                info.category = 'cloud';
+            }
+            else if (serverLower.includes('fastly')) {
+                info.provider = 'fastly';
+                info.category = 'cdn';
+            }
+            else if (serverLower.includes('akamai')) {
+                info.provider = 'akamai';
+                info.category = 'cdn';
+            }
+            else if (serverLower.includes('nginx')) {
+                info.provider = 'nginx';
+                info.category = 'server';
+            }
+            else if (serverLower.includes('apache')) {
+                info.provider = 'apache';
+                info.category = 'server';
+            }
+            else if (serverLower.includes('varnish')) {
+                info.provider = 'varnish';
+                info.category = 'proxy';
+            }
+            else {
+                info.provider = 'unknown';
+                info.category = 'unknown';
+            }
+        }
+    }
+    if (!info.provider) {
+        const via = headers.get('via');
+        if (via) {
+            const viaLower = via.toLowerCase();
+            if (viaLower.includes('cloudflare')) {
+                info.provider = 'cloudflare';
+                info.category = 'cdn';
+            }
+            else if (viaLower.includes('akamai')) {
+                info.provider = 'akamai';
+                info.category = 'cdn';
+            }
+            else if (viaLower.includes('varnish')) {
+                info.provider = 'varnish';
+                info.category = 'proxy';
+            }
+            else if (viaLower.includes('squid')) {
+                info.provider = 'squid';
+                info.category = 'proxy';
+            }
+        }
+    }
+    if (Object.keys(info.metadata || {}).length === 0) {
+        delete info.metadata;
+    }
+    return info;
+}
+export function parseRateLimitInfo(headers, status) {
+    const info = { limited: status === 429 };
+    const limit = headers.get('x-ratelimit-limit') || headers.get('ratelimit-limit');
+    const remaining = headers.get('x-ratelimit-remaining') || headers.get('ratelimit-remaining');
+    const reset = headers.get('x-ratelimit-reset') || headers.get('ratelimit-reset');
+    if (limit)
+        info.limit = parseInt(limit, 10);
+    if (remaining)
+        info.remaining = parseInt(remaining, 10);
+    if (reset) {
+        const resetValue = parseInt(reset, 10);
+        if (resetValue > 1000000000) {
+            info.reset = new Date(resetValue * 1000);
+        }
+        else {
+            info.reset = new Date(Date.now() + resetValue * 1000);
+        }
+    }
+    const retryAfter = headers.get('retry-after');
+    if (retryAfter) {
+        const seconds = parseInt(retryAfter, 10);
+        if (!isNaN(seconds)) {
+            info.retryAfter = seconds;
+        }
+        else {
+            const retryDate = new Date(retryAfter);
+            if (!isNaN(retryDate.getTime())) {
+                info.retryAfter = Math.ceil((retryDate.getTime() - Date.now()) / 1000);
+            }
+        }
+    }
+    const policy = headers.get('ratelimit-policy');
+    if (policy) {
+        info.policy = policy;
+    }
+    if (info.remaining !== undefined && info.remaining === 0) {
+        info.limited = true;
+    }
+    return info;
+}
+export function parseCompressionInfo(headers) {
+    const info = {};
+    const encoding = headers.get('content-encoding');
+    if (encoding) {
+        info.encoding = encoding.toLowerCase();
+    }
+    const xOriginalSize = headers.get('x-original-size') || headers.get('x-uncompressed-size');
+    if (xOriginalSize) {
+        info.originalSize = parseInt(xOriginalSize, 10);
+    }
+    const contentLength = headers.get('content-length');
+    if (contentLength) {
+        info.compressedSize = parseInt(contentLength, 10);
+    }
+    if (info.originalSize && info.compressedSize) {
+        info.ratio = info.originalSize / info.compressedSize;
+    }
+    return info;
+}
+export function parseCSPInfo(headers) {
+    const info = {
+        directives: {},
+        reportOnly: false
+    };
+    let cspHeader = headers.get('content-security-policy');
+    if (!cspHeader) {
+        cspHeader = headers.get('content-security-policy-report-only');
+        if (cspHeader) {
+            info.reportOnly = true;
+        }
+    }
+    if (cspHeader) {
+        info.policy = cspHeader;
+        const directives = cspHeader.split(';').map(d => d.trim()).filter(Boolean);
+        for (const directive of directives) {
+            const [name, ...values] = directive.split(/\s+/);
+            if (name) {
+                info.directives[name] = values;
+            }
+        }
+    }
+    return info;
+}
+export function parseContentType(headers) {
+    const info = {};
+    const contentType = headers.get('content-type');
+    if (!contentType)
+        return info;
+    const parts = contentType.split(';').map(p => p.trim());
+    if (parts[0]) {
+        info.mediaType = parts[0];
+        const [type, subtype] = parts[0].split('/');
+        if (type)
+            info.type = type;
+        if (subtype)
+            info.subtype = subtype;
+    }
+    for (let i = 1; i < parts.length; i++) {
+        const param = parts[i];
+        const [key, value] = param.split('=').map(s => s.trim());
+        if (key === 'charset' && value) {
+            info.charset = value.replace(/['"]/g, '');
+        }
+        else if (key === 'boundary' && value) {
+            info.boundary = value.replace(/['"]/g, '');
+        }
+    }
+    return info;
+}
+export function parseAcceptInfo(headers) {
+    const info = {
+        types: [],
+        encodings: [],
+        languages: []
+    };
+    const accept = headers.get('accept');
+    if (accept) {
+        const types = accept.split(',').map(t => t.trim());
+        for (const typeStr of types) {
+            const [mediaType, ...params] = typeStr.split(';').map(s => s.trim());
+            let q = 1.0;
+            for (const param of params) {
+                if (param.startsWith('q=')) {
+                    q = parseFloat(param.substring(2)) || 1.0;
+                }
+            }
+            const [type, subtype] = mediaType.split('/');
+            info.types.push({
+                mediaType,
+                q,
+                type: type || undefined,
+                subtype: subtype || undefined
+            });
+        }
+        info.types.sort((a, b) => b.q - a.q);
+    }
+    const acceptEncoding = headers.get('accept-encoding');
+    if (acceptEncoding) {
+        const encodings = acceptEncoding.split(',').map(e => e.trim());
+        for (const encodingStr of encodings) {
+            const [encoding, ...params] = encodingStr.split(';').map(s => s.trim());
+            let q = 1.0;
+            for (const param of params) {
+                if (param.startsWith('q=')) {
+                    q = parseFloat(param.substring(2)) || 1.0;
+                }
+            }
+            info.encodings.push({ encoding, q });
+        }
+        info.encodings.sort((a, b) => b.q - a.q);
+    }
+    const acceptLanguage = headers.get('accept-language');
+    if (acceptLanguage) {
+        const languages = acceptLanguage.split(',').map(l => l.trim());
+        for (const languageStr of languages) {
+            const [language, ...params] = languageStr.split(';').map(s => s.trim());
+            let q = 1.0;
+            for (const param of params) {
+                if (param.startsWith('q=')) {
+                    q = parseFloat(param.substring(2)) || 1.0;
+                }
+            }
+            info.languages.push({ language, q });
+        }
+        info.languages.sort((a, b) => b.q - a.q);
+    }
+    return info;
+}
+export function parseHeaders(headers, status) {
+    return {
+        cache: parseCacheInfo(headers),
+        platform: parsePlatformInfo(headers),
+        rateLimit: parseRateLimitInfo(headers, status),
+        compression: parseCompressionInfo(headers),
+        csp: parseCSPInfo(headers),
+        contentType: parseContentType(headers),
+        accept: parseAcceptInfo(headers)
+    };
+}

package/dist/utils/html-cleaner.d.ts

@@ -0,0 +1,2 @@
+export declare function cleanHtml(html: string): string;
+//# sourceMappingURL=html-cleaner.d.ts.map

package/dist/utils/html-cleaner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-cleaner.d.ts","sourceRoot":"","sources":["../../src/utils/html-cleaner.ts"],"names":[],"mappings":"AAIA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAmC9C"}

package/dist/utils/html-cleaner.js

@@ -0,0 +1,21 @@
+export function cleanHtml(html) {
+    if (!html)
+        return '';
+    let text = html;
+    text = text.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, '');
+    text = text.replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, '');
+    text = text.replace(/<!--[\s\S]*?-->/g, '');
+    text = text.replace(/<\/(div|p|h[1-6]|li|ul|ol|tr|table|section|article|main|header|footer|nav)>/gi, '\n');
+    text = text.replace(/<(br|hr)\s*\/?>/gi, '\n');
+    text = text.replace(/<[^>]+>/g, ' ');
+    text = text
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'");
+    text = text.replace(/[ \t]+/g, ' ');
+    text = text.replace(/\n\s*\n\s*\n+/g, '\n\n');
+    return text.trim();
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,33 @@
+import { ReckerRequest, ReckerResponse, Timings } from '../types/index.js';
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
+export interface LoggerOptions {
+    level?: LogLevel;
+    prefix?: string;
+    timestamp?: boolean;
+    colors?: boolean;
+}
+export declare class Logger {
+    private level;
+    private prefix;
+    private useTimestamp;
+    private useColors;
+    constructor(options?: LoggerOptions);
+    private detectLogLevel;
+    private supportsColors;
+    private colorize;
+    private formatTimestamp;
+    private shouldLog;
+    private log;
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    logRequest(req: ReckerRequest): void;
+    logResponse(req: ReckerRequest, res: ReckerResponse, startTime: number): void;
+    logTimings(timings: Timings): void;
+    logError(req: ReckerRequest, error: Error): void;
+    private formatBytes;
+}
+export declare function getLogger(): Logger;
+export declare function setLogger(logger: Logger): void;
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE3E,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAEpE,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AA2BD,qBAAa,MAAM;IACjB,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,YAAY,CAAU;IAC9B,OAAO,CAAC,SAAS,CAAU;gBAEf,OAAO,GAAE,aAAkB;IAOvC,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,GAAG;IAQX,KAAK,CAAC,OAAO,EAAE,MAAM;IAIrB,IAAI,CAAC,OAAO,EAAE,MAAM;IAIpB,IAAI,CAAC,OAAO,EAAE,MAAM;IAIpB,KAAK,CAAC,OAAO,EAAE,MAAM;IAOrB,UAAU,CAAC,GAAG,EAAE,aAAa;IAmB7B,WAAW,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM;IA4BtE,UAAU,CAAC,OAAO,EAAE,OAAO;IAoB3B,QAAQ,CAAC,GAAG,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK;IAoBzC,OAAO,CAAC,WAAW;CAOpB;AAKD,wBAAgB,SAAS,IAAI,MAAM,CAKlC;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,QAEvC"}

package/dist/utils/logger.js

@@ -0,0 +1,160 @@
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+};
+const levels = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    none: 999,
+};
+export class Logger {
+    level;
+    prefix;
+    useTimestamp;
+    useColors;
+    constructor(options = {}) {
+        this.level = options.level || this.detectLogLevel();
+        this.prefix = options.prefix || 'recker';
+        this.useTimestamp = options.timestamp !== false;
+        this.useColors = options.colors !== false && this.supportsColors();
+    }
+    detectLogLevel() {
+        const env = process.env.DEBUG || '';
+        if (env === '*' || env.includes('recker') || env.includes('*')) {
+            return 'debug';
+        }
+        return 'none';
+    }
+    supportsColors() {
+        return (process.stdout.isTTY &&
+            !process.env.NO_COLOR &&
+            process.env.TERM !== 'dumb');
+    }
+    colorize(text, color) {
+        if (!this.useColors)
+            return text;
+        return `${colors[color]}${text}${colors.reset}`;
+    }
+    formatTimestamp() {
+        if (!this.useTimestamp)
+            return '';
+        const now = new Date();
+        const time = now.toTimeString().split(' ')[0];
+        return this.colorize(`[${time}]`, 'gray') + ' ';
+    }
+    shouldLog(level) {
+        return levels[level] >= levels[this.level];
+    }
+    log(level, message) {
+        if (!this.shouldLog(level))
+            return;
+        const timestamp = this.formatTimestamp();
+        const prefix = this.colorize(`[${this.prefix}]`, 'cyan');
+        console.log(`${timestamp}${prefix} ${message}`);
+    }
+    debug(message) {
+        this.log('debug', message);
+    }
+    info(message) {
+        this.log('info', message);
+    }
+    warn(message) {
+        this.log('warn', this.colorize(message, 'yellow'));
+    }
+    error(message) {
+        this.log('error', this.colorize(message, 'red'));
+    }
+    logRequest(req) {
+        if (!this.shouldLog('debug'))
+            return;
+        const method = this.colorize(req.method, 'blue');
+        const url = this.colorize(req.url, 'bright');
+        this.debug(`${this.colorize('→', 'green')} ${method} ${url}`);
+        if (req.headers && Array.from(req.headers.keys()).length > 0) {
+            const headerStr = Array.from(req.headers.entries())
+                .map(([k, v]) => `  ${this.colorize(k, 'gray')}: ${v}`)
+                .join('\n');
+            console.log(headerStr);
+        }
+    }
+    logResponse(req, res, startTime) {
+        if (!this.shouldLog('debug'))
+            return;
+        const duration = Date.now() - startTime;
+        const statusColor = res.ok ? 'green' : 'red';
+        const status = this.colorize(String(res.status), statusColor);
+        const method = this.colorize(req.method, 'gray');
+        this.debug(`${this.colorize('←', 'green')} ${status} ${method} ${req.url} ${this.colorize(`(${duration}ms)`, 'gray')}`);
+        if (res.timings) {
+            this.logTimings(res.timings);
+        }
+        const contentLength = res.headers.get('content-length');
+        if (contentLength) {
+            const size = this.formatBytes(parseInt(contentLength, 10));
+            console.log(`  ${this.colorize('Size:', 'gray')} ${size}`);
+        }
+    }
+    logTimings(timings) {
+        if (!this.shouldLog('debug'))
+            return;
+        const parts = [];
+        if (timings.dns)
+            parts.push(`DNS: ${timings.dns.toFixed(0)}ms`);
+        if (timings.tcp)
+            parts.push(`TCP: ${timings.tcp.toFixed(0)}ms`);
+        if (timings.tls)
+            parts.push(`TLS: ${timings.tls.toFixed(0)}ms`);
+        if (timings.firstByte)
+            parts.push(`TTFB: ${timings.firstByte.toFixed(0)}ms`);
+        if (timings.total)
+            parts.push(`Total: ${timings.total.toFixed(0)}ms`);
+        if (parts.length > 0) {
+            const timelinesStr = parts.join(', ');
+            console.log(`  ${this.colorize('├─', 'gray')} ${timelinesStr}`);
+        }
+    }
+    logError(req, error) {
+        if (!this.shouldLog('error'))
+            return;
+        const method = this.colorize(req.method, 'gray');
+        this.error(`${this.colorize('✖', 'red')} ${method} ${req.url}`);
+        console.log(`  ${this.colorize('Error:', 'red')} ${error.message}`);
+        if (error.stack && this.shouldLog('debug')) {
+            const stack = error.stack
+                .split('\n')
+                .slice(1, 4)
+                .map((line) => `  ${this.colorize('│', 'gray')} ${line.trim()}`)
+                .join('\n');
+            console.log(stack);
+        }
+    }
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+    }
+}
+let globalLogger = null;
+export function getLogger() {
+    if (!globalLogger) {
+        globalLogger = new Logger();
+    }
+    return globalLogger;
+}
+export function setLogger(logger) {
+    globalLogger = logger;
+}

package/dist/utils/progress.d.ts

@@ -0,0 +1,4 @@
+import { ProgressEvent, ProgressCallback } from '../types/index.js';
+export declare function createProgressStream(stream: ReadableStream<Uint8Array>, onProgress: ProgressCallback, total?: number): ReadableStream<Uint8Array>;
+export declare function calculateProgress(loaded: number, total?: number): ProgressEvent;
+//# sourceMappingURL=progress.d.ts.map

package/dist/utils/progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../src/utils/progress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAKpE,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,EAClC,UAAU,EAAE,gBAAgB,EAC5B,KAAK,CAAC,EAAE,MAAM,GACb,cAAc,CAAC,UAAU,CAAC,CA6C5B;AAKD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,aAAa,CAW/E"}