@j0hanz/fetch-url-mcp 1.1.1 → 1.1.3

package/dist/AGENTS.md

@@ -34,7 +34,7 @@
 - `tests/` — Unit/integration tests (46+ test files) using Node.js built-in test runner
 - `scripts/` — Build & test orchestration (`tasks.mjs`)
 - `assets/` — Server icon (`logo.svg`)
-- `.github/workflows/` — CI/CD (`release.yml`: lint → type-check → test → build → publish to npm, MCP Registry, Docker)
+- `.github/workflows/` — CI/CD (`release.yml`: lint → type-check → type-check:tests → test → build → publish to npm, MCP Registry, Docker)
 
 > Ignore: `dist/`, `node_modules/`, `coverage/`, `.cache/`, `.tsbuildinfo`
 
@@ -49,6 +49,7 @@ All commands verified from `.github/workflows/release.yml` (CI) and `package.jso
 - **Start:** `npm run start` → `node dist/index.js` (see `package.json`)
 - **Build:** `npm run build` → `node scripts/tasks.mjs build` — cleans `dist/`, compiles TS, validates `instructions.md`, copies assets, sets executable bit (see `scripts/tasks.mjs`, `package.json`)
 - **Type-check:** `npm run type-check` → `tsc -p tsconfig.json --noEmit` (see `scripts/tasks.mjs`, `.github/workflows/release.yml`)
+- **Type-check (tests):** `npm run type-check:tests` → build output + `tsc -p tsconfig.tests.json --noEmit` (see `scripts/tasks.mjs`, `.github/workflows/release.yml`)
 - **Lint:** `npm run lint` → `eslint .` (see `package.json`, `.github/workflows/release.yml`)
 - **Lint (fix):** `npm run lint:fix` → `eslint . --fix` (see `package.json`)
 - **Format:** `npm run format` → `prettier --write .` (see `package.json`)
@@ -135,7 +136,7 @@ All commands verified from `.github/workflows/release.yml` (CI) and `package.jso
   - Config values temporarily overridden per test with `try/finally` cleanup (observed in `tests/fetch-url-tool.test.ts`)
   - Worker pool shutdown in `after()` hooks for clean teardown (observed in `tests/fetch-url-tool.test.ts`)
   - No external services (DB/containers) required for tests
-- **CI validation order:** `lint` → `type-check` → `test` → `build` (see `.github/workflows/release.yml`)
+- **CI validation order:** `lint` → `type-check` → `type-check:tests` → `test` → `build` (see `.github/workflows/release.yml`)
 
 ## 7) Common Pitfalls (Verified Only)
 

package/dist/cache.js

@@ -93,13 +93,16 @@ class InMemoryCacheStore {
     isEnabled() {
         return config.cache.enabled;
     }
+    isExpired(entry, now = Date.now()) {
+        return entry.expiresAtMs <= now;
+    }
     keys() {
         if (!this.isEnabled())
             return [];
         const now = Date.now();
         const result = [];
         for (const [key, entry] of this.entries) {
-            if (entry.expiresAtMs > now)
+            if (!this.isExpired(entry, now))
                 result.push(key);
         }
         return result;
@@ -130,7 +133,7 @@ class InMemoryCacheStore {
         if (!entry)
             return undefined;
         const now = Date.now();
-        if (entry.expiresAtMs <= now) {
+        if (this.isExpired(entry, now)) {
             this.delete(cacheKey);
             this.notify(cacheKey, true);
             return undefined;

package/dist/cli.js

@@ -19,6 +19,17 @@ const optionSchema = {
 function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function toBoolean(value) {
+    return value === true;
+}
+function buildCliValues(values) {
+    const { stdio, help, version } = values;
+    return {
+        stdio: toBoolean(stdio),
+        help: toBoolean(help),
+        version: toBoolean(version),
+    };
+}
 export function renderCliUsage() {
     return `${usageLines.join('\n')}\n`;
 }
@@ -32,11 +43,7 @@ export function parseCliArgs(args) {
         });
         return {
             ok: true,
-            values: {
-                stdio: values.stdio,
-                help: values.help,
-                version: values.version,
-            },
+            values: buildCliValues(values),
         };
     }
     catch (error) {

package/dist/config.js

@@ -233,24 +233,25 @@ const RESOLVED_TASKS_MAX_PER_OWNER = Math.min(DEFAULT_TASKS_MAX_PER_OWNER, DEFAU
 function resolveWorkerResourceLimits() {
     const limits = {};
     let hasAny = false;
-    const maxOldGenerationSizeMb = parseOptionalInteger(env['TRANSFORM_WORKER_MAX_OLD_GENERATION_MB'], 1);
-    const maxYoungGenerationSizeMb = parseOptionalInteger(env['TRANSFORM_WORKER_MAX_YOUNG_GENERATION_MB'], 1);
-    const codeRangeSizeMb = parseOptionalInteger(env['TRANSFORM_WORKER_CODE_RANGE_MB'], 1);
-    const stackSizeMb = parseOptionalInteger(env['TRANSFORM_WORKER_STACK_MB'], 1);
-    if (maxOldGenerationSizeMb !== undefined) {
-        limits.maxOldGenerationSizeMb = maxOldGenerationSizeMb;
-        hasAny = true;
-    }
-    if (maxYoungGenerationSizeMb !== undefined) {
-        limits.maxYoungGenerationSizeMb = maxYoungGenerationSizeMb;
-        hasAny = true;
-    }
-    if (codeRangeSizeMb !== undefined) {
-        limits.codeRangeSizeMb = codeRangeSizeMb;
-        hasAny = true;
-    }
-    if (stackSizeMb !== undefined) {
-        limits.stackSizeMb = stackSizeMb;
+    const entries = [
+        [
+            'maxOldGenerationSizeMb',
+            parseOptionalInteger(env['TRANSFORM_WORKER_MAX_OLD_GENERATION_MB'], 1),
+        ],
+        [
+            'maxYoungGenerationSizeMb',
+            parseOptionalInteger(env['TRANSFORM_WORKER_MAX_YOUNG_GENERATION_MB'], 1),
+        ],
+        [
+            'codeRangeSizeMb',
+            parseOptionalInteger(env['TRANSFORM_WORKER_CODE_RANGE_MB'], 1),
+        ],
+        ['stackSizeMb', parseOptionalInteger(env['TRANSFORM_WORKER_STACK_MB'], 1)],
+    ];
+    for (const [key, value] of entries) {
+        if (value === undefined)
+            continue;
+        limits[key] = value;
         hasAny = true;
     }
     return hasAny ? limits : undefined;

package/dist/crypto.js

@@ -18,6 +18,11 @@ function assertAllowedAlgorithm(algorithm) {
         throw new Error(`Hash algorithm not allowed: ${algorithm}`);
     }
 }
+function padBuffer(buffer, length) {
+    const padded = Buffer.alloc(length);
+    buffer.copy(padded);
+    return padded;
+}
 export function timingSafeEqualUtf8(a, b) {
     const aBuffer = Buffer.from(a, 'utf8');
     const bBuffer = Buffer.from(b, 'utf8');
@@ -26,10 +31,8 @@ export function timingSafeEqualUtf8(a, b) {
     }
     // Avoid early return timing differences on length mismatch.
     const maxLength = Math.max(aBuffer.length, bBuffer.length);
-    const paddedA = Buffer.alloc(maxLength);
-    const paddedB = Buffer.alloc(maxLength);
-    aBuffer.copy(paddedA);
-    bBuffer.copy(paddedB);
+    const paddedA = padBuffer(aBuffer, maxLength);
+    const paddedB = padBuffer(bBuffer, maxLength);
     return timingSafeEqual(paddedA, paddedB) && aBuffer.length === bBuffer.length;
 }
 function hashHex(algorithm, input) {

package/dist/dom-noise-removal.js

@@ -103,22 +103,25 @@ function buildTokenRegex(tokens) {
         return NO_MATCH_REGEX;
     return new RegExp(`(?:^|[^a-z0-9])(?:${[...tokens].map(escapeRegexLiteral).join('|')})(?:$|[^a-z0-9])`, 'i');
 }
+function addTokens(target, tokens) {
+    for (const token of tokens)
+        target.add(token);
+}
 function getPromoMatchers(currentConfig, flags) {
     const baseTokens = new Set(PROMO_TOKENS_ALWAYS);
     const aggressiveTokens = new Set();
     if (currentConfig.aggressiveMode) {
-        for (const t of PROMO_TOKENS_AGGRESSIVE)
-            aggressiveTokens.add(t);
+        addTokens(aggressiveTokens, PROMO_TOKENS_AGGRESSIVE);
+    }
+    if (flags.cookieBanners) {
+        addTokens(baseTokens, PROMO_TOKENS_BY_CATEGORY['cookie-banners']);
+    }
+    if (flags.newsletters) {
+        addTokens(baseTokens, PROMO_TOKENS_BY_CATEGORY['newsletters']);
+    }
+    if (flags.socialShare) {
+        addTokens(baseTokens, PROMO_TOKENS_BY_CATEGORY['social-share']);
     }
-    if (flags.cookieBanners)
-        for (const t of PROMO_TOKENS_BY_CATEGORY['cookie-banners'])
-            baseTokens.add(t);
-    if (flags.newsletters)
-        for (const t of PROMO_TOKENS_BY_CATEGORY['newsletters'])
-            baseTokens.add(t);
-    if (flags.socialShare)
-        for (const t of PROMO_TOKENS_BY_CATEGORY['social-share'])
-            baseTokens.add(t);
     for (const t of currentConfig.extraTokens) {
         const n = t.toLowerCase().trim();
         if (n)

package/dist/errors.js

@@ -19,17 +19,20 @@ export class FetchError extends Error {
 export function getErrorMessage(error) {
     if (isError(error))
         return error.message;
-    if (typeof error === 'string' && error.length > 0)
+    if (isNonEmptyString(error))
         return error;
     if (isErrorWithMessage(error))
         return error.message;
     return formatUnknownError(error);
 }
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
 function isErrorWithMessage(error) {
     if (!isObject(error))
         return false;
     const { message } = error;
-    return typeof message === 'string' && message.length > 0;
+    return isNonEmptyString(message);
 }
 function formatUnknownError(error) {
     if (error === null || error === undefined)

package/dist/fetch-content.d.ts

@@ -0,0 +1,4 @@
+export declare function getCharsetFromContentType(contentType: string | null): string | undefined;
+export declare function decodeBuffer(buffer: Uint8Array, encoding: string): string;
+export declare function resolveEncoding(declaredEncoding: string | undefined, sample: Uint8Array): string | undefined;
+export declare function isBinaryContent(buffer: Uint8Array, encoding?: string): boolean;

package/dist/fetch-content.js

@@ -0,0 +1,163 @@
+import { Buffer } from 'node:buffer';
+export function getCharsetFromContentType(contentType) {
+    if (!contentType)
+        return undefined;
+    const match = /charset=([^;]+)/i.exec(contentType);
+    const charsetGroup = match?.[1];
+    if (!charsetGroup)
+        return undefined;
+    let charset = charsetGroup.trim();
+    if (charset.startsWith('"') && charset.endsWith('"')) {
+        charset = charset.slice(1, -1);
+    }
+    return charset.trim();
+}
+function createDecoder(encoding) {
+    if (!encoding)
+        return new TextDecoder('utf-8');
+    try {
+        return new TextDecoder(encoding);
+    }
+    catch {
+        return new TextDecoder('utf-8');
+    }
+}
+export function decodeBuffer(buffer, encoding) {
+    return createDecoder(encoding).decode(buffer);
+}
+function normalizeEncodingLabel(encoding) {
+    return encoding?.trim().toLowerCase() ?? '';
+}
+function isUnicodeWideEncoding(encoding) {
+    const normalized = normalizeEncodingLabel(encoding);
+    return (normalized.startsWith('utf-16') ||
+        normalized.startsWith('utf-32') ||
+        normalized === 'ucs-2' ||
+        normalized === 'unicodefffe' ||
+        normalized === 'unicodefeff');
+}
+const BOM_SIGNATURES = [
+    // 4-byte BOMs must come first to avoid false matches with 2-byte prefixes
+    { bytes: [0xff, 0xfe, 0x00, 0x00], encoding: 'utf-32le' },
+    { bytes: [0x00, 0x00, 0xfe, 0xff], encoding: 'utf-32be' },
+    { bytes: [0xef, 0xbb, 0xbf], encoding: 'utf-8' },
+    { bytes: [0xff, 0xfe], encoding: 'utf-16le' },
+    { bytes: [0xfe, 0xff], encoding: 'utf-16be' },
+];
+function startsWithBytes(buffer, signature) {
+    const sigLen = signature.length;
+    if (buffer.length < sigLen)
+        return false;
+    for (let i = 0; i < sigLen; i += 1) {
+        if (buffer[i] !== signature[i])
+            return false;
+    }
+    return true;
+}
+function detectBomEncoding(buffer) {
+    for (const { bytes, encoding } of BOM_SIGNATURES) {
+        if (startsWithBytes(buffer, bytes))
+            return encoding;
+    }
+    return undefined;
+}
+function readQuotedValue(input, startIndex) {
+    const first = input[startIndex];
+    if (!first)
+        return '';
+    const quoted = first === '"' || first === "'";
+    if (quoted) {
+        const end = input.indexOf(first, startIndex + 1);
+        return end === -1 ? '' : input.slice(startIndex + 1, end).trim();
+    }
+    const tail = input.slice(startIndex);
+    const stop = tail.search(/[\s/>]/);
+    return (stop === -1 ? tail : tail.slice(0, stop)).trim();
+}
+function extractHtmlCharset(headSnippet) {
+    const lower = headSnippet.toLowerCase();
+    const charsetToken = 'charset=';
+    const charsetIdx = lower.indexOf(charsetToken);
+    if (charsetIdx === -1)
+        return undefined;
+    const valueStart = charsetIdx + charsetToken.length;
+    const charset = readQuotedValue(headSnippet, valueStart);
+    return charset ? charset.toLowerCase() : undefined;
+}
+function extractXmlEncoding(headSnippet) {
+    const lower = headSnippet.toLowerCase();
+    const xmlStart = lower.indexOf('<?xml');
+    if (xmlStart === -1)
+        return undefined;
+    const xmlEnd = lower.indexOf('?>', xmlStart);
+    const declaration = xmlEnd === -1
+        ? headSnippet.slice(xmlStart)
+        : headSnippet.slice(xmlStart, xmlEnd + 2);
+    const declarationLower = declaration.toLowerCase();
+    const encodingToken = 'encoding=';
+    const encodingIdx = declarationLower.indexOf(encodingToken);
+    if (encodingIdx === -1)
+        return undefined;
+    const valueStart = encodingIdx + encodingToken.length;
+    const encoding = readQuotedValue(declaration, valueStart);
+    return encoding ? encoding.toLowerCase() : undefined;
+}
+function detectHtmlDeclaredEncoding(buffer) {
+    const scanSize = Math.min(buffer.length, 8_192);
+    if (scanSize === 0)
+        return undefined;
+    const headSnippet = Buffer.from(buffer.buffer, buffer.byteOffset, scanSize).toString('latin1');
+    return extractHtmlCharset(headSnippet) ?? extractXmlEncoding(headSnippet);
+}
+export function resolveEncoding(declaredEncoding, sample) {
+    const bomEncoding = detectBomEncoding(sample);
+    if (bomEncoding)
+        return bomEncoding;
+    if (declaredEncoding)
+        return declaredEncoding;
+    return detectHtmlDeclaredEncoding(sample);
+}
+const BINARY_SIGNATURES = [
+    [0x25, 0x50, 0x44, 0x46],
+    [0x89, 0x50, 0x4e, 0x47],
+    [0x47, 0x49, 0x46, 0x38],
+    [0xff, 0xd8, 0xff],
+    [0x52, 0x49, 0x46, 0x46],
+    [0x42, 0x4d],
+    [0x49, 0x49, 0x2a, 0x00],
+    [0x4d, 0x4d, 0x00, 0x2a],
+    [0x00, 0x00, 0x01, 0x00],
+    [0x50, 0x4b, 0x03, 0x04],
+    [0x1f, 0x8b],
+    [0x42, 0x5a, 0x68],
+    [0x52, 0x61, 0x72, 0x21],
+    [0x37, 0x7a, 0xbc, 0xaf],
+    [0x7f, 0x45, 0x4c, 0x46],
+    [0x4d, 0x5a],
+    [0xcf, 0xfa, 0xed, 0xfe],
+    [0x00, 0x61, 0x73, 0x6d],
+    [0x1a, 0x45, 0xdf, 0xa3],
+    [0x66, 0x74, 0x79, 0x70],
+    [0x46, 0x4c, 0x56],
+    [0x49, 0x44, 0x33],
+    [0xff, 0xfb],
+    [0xff, 0xfa],
+    [0x4f, 0x67, 0x67, 0x53],
+    [0x66, 0x4c, 0x61, 0x43],
+    [0x4d, 0x54, 0x68, 0x64],
+    [0x77, 0x4f, 0x46, 0x46],
+    [0x00, 0x01, 0x00, 0x00],
+    [0x4f, 0x54, 0x54, 0x4f],
+    [0x53, 0x51, 0x4c, 0x69],
+];
+function hasNullByte(buffer, limit) {
+    const checkLen = Math.min(buffer.length, limit);
+    return buffer.subarray(0, checkLen).includes(0x00);
+}
+export function isBinaryContent(buffer, encoding) {
+    for (const signature of BINARY_SIGNATURES) {
+        if (startsWithBytes(buffer, signature))
+            return true;
+    }
+    return !isUnicodeWideEncoding(encoding) && hasNullByte(buffer, 1000);
+}

package/dist/fetch-stream.d.ts

@@ -0,0 +1,4 @@
+import { Readable } from 'node:stream';
+import type { ReadableStream as NodeReadableStream } from 'node:stream/web';
+export declare function toNodeReadableStream(stream: ReadableStream<Uint8Array>, url: string, stage: string): NodeReadableStream<Uint8Array>;
+export declare function toWebReadableStream(stream: Readable, url: string, stage: string): ReadableStream<Uint8Array>;

package/dist/fetch-stream.js

@@ -0,0 +1,28 @@
+import { Readable } from 'node:stream';
+import { FetchError } from './errors.js';
+import { isObject } from './type-guards.js';
+function isReadableStreamLike(value) {
+    if (!isObject(value))
+        return false;
+    return (typeof value['getReader'] === 'function' &&
+        typeof value['cancel'] === 'function' &&
+        typeof value['tee'] === 'function' &&
+        typeof value['locked'] === 'boolean');
+}
+function assertReadableStreamLike(stream, url, stage) {
+    if (isReadableStreamLike(stream))
+        return;
+    throw new FetchError('Invalid response stream', url, 500, {
+        reason: 'invalid_stream',
+        stage,
+    });
+}
+export function toNodeReadableStream(stream, url, stage) {
+    assertReadableStreamLike(stream, url, stage);
+    return stream;
+}
+export function toWebReadableStream(stream, url, stage) {
+    const converted = Readable.toWeb(stream);
+    assertReadableStreamLike(converted, url, stage);
+    return converted;
+}

package/dist/fetch.js

@@ -10,6 +10,8 @@ import { finished, pipeline } from 'node:stream/promises';
 import { createBrotliDecompress, createGunzip, createInflate } from 'node:zlib';
 import { config } from './config.js';
 import { createErrorWithCode, FetchError, isSystemError } from './errors.js';
+import { decodeBuffer, getCharsetFromContentType, isBinaryContent, resolveEncoding, } from './fetch-content.js';
+import { toNodeReadableStream, toWebReadableStream } from './fetch-stream.js';
 import { createDefaultBlockList, normalizeIpForBlockList, } from './ip-blocklist.js';
 import { getOperationId, getRequestId, logDebug, logError, logWarn, redactUrl, } from './observability.js';
 import { isError, isObject } from './type-guards.js';
@@ -26,23 +28,6 @@ const defaultRedactor = {
     redact: redactUrl,
 };
 const defaultFetch = (input, init) => globalThis.fetch(input, init);
-function assertReadableStreamLike(stream, url, stage) {
-    if (isObject(stream) && typeof stream['getReader'] === 'function')
-        return;
-    throw new FetchError('Invalid response stream', url, 500, {
-        reason: 'invalid_stream',
-        stage,
-    });
-}
-function toNodeReadableStream(stream, url, stage) {
-    assertReadableStreamLike(stream, url, stage);
-    return stream;
-}
-function toWebReadableStream(stream, url, stage) {
-    const converted = Readable.toWeb(stream);
-    assertReadableStreamLike(converted, url, stage);
-    return converted;
-}
 class IpBlocker {
     security;
     blockList = createDefaultBlockList();
@@ -569,8 +554,11 @@ function createTooManyRedirectsFetchError(url) {
 function createMissingRedirectLocationFetchError(url) {
     return new FetchError('Redirect response missing Location header', url);
 }
+function buildNetworkErrorMessage(url) {
+    return `Network error: Could not reach ${url}`;
+}
 function createNetworkFetchError(url, message) {
-    return new FetchError(`Network error: Could not reach ${url}`, url, undefined, message ? { message } : {});
+    return new FetchError(buildNetworkErrorMessage(url), url, undefined, message ? { message } : {});
 }
 function createUnknownFetchError(url, message) {
     return new FetchError(message, url);
@@ -619,7 +607,7 @@ function mapFetchError(error, fallbackUrl, timeoutMs) {
         code === 'EINVAL') {
         return new FetchError(error.message, url, 400, { code });
     }
-    return new FetchError(`Network error: Could not reach ${url}`, url, undefined, {
+    return new FetchError(buildNetworkErrorMessage(url), url, undefined, {
         code,
         message: error.message,
     });
@@ -868,168 +856,6 @@ class RedirectFollower {
         }
     }
 }
-function getCharsetFromContentType(contentType) {
-    if (!contentType)
-        return undefined;
-    const match = /charset=([^;]+)/i.exec(contentType);
-    const charsetGroup = match?.[1];
-    if (!charsetGroup)
-        return undefined;
-    let charset = charsetGroup.trim();
-    if (charset.startsWith('"') && charset.endsWith('"')) {
-        charset = charset.slice(1, -1);
-    }
-    return charset.trim();
-}
-function createDecoder(encoding) {
-    if (!encoding)
-        return new TextDecoder('utf-8');
-    try {
-        return new TextDecoder(encoding);
-    }
-    catch {
-        return new TextDecoder('utf-8');
-    }
-}
-function decodeBuffer(buffer, encoding) {
-    return createDecoder(encoding).decode(buffer);
-}
-function normalizeEncodingLabel(encoding) {
-    return encoding?.trim().toLowerCase() ?? '';
-}
-function isUnicodeWideEncoding(encoding) {
-    const normalized = normalizeEncodingLabel(encoding);
-    return (normalized.startsWith('utf-16') ||
-        normalized.startsWith('utf-32') ||
-        normalized === 'ucs-2' ||
-        normalized === 'unicodefffe' ||
-        normalized === 'unicodefeff');
-}
-const BOM_SIGNATURES = [
-    // 4-byte BOMs must come first to avoid false matches with 2-byte prefixes
-    { bytes: [0xff, 0xfe, 0x00, 0x00], encoding: 'utf-32le' },
-    { bytes: [0x00, 0x00, 0xfe, 0xff], encoding: 'utf-32be' },
-    { bytes: [0xef, 0xbb, 0xbf], encoding: 'utf-8' },
-    { bytes: [0xff, 0xfe], encoding: 'utf-16le' },
-    { bytes: [0xfe, 0xff], encoding: 'utf-16be' },
-];
-function detectBomEncoding(buffer) {
-    for (const { bytes, encoding } of BOM_SIGNATURES) {
-        if (startsWithBytes(buffer, bytes))
-            return encoding;
-    }
-    return undefined;
-}
-function readQuotedValue(input, startIndex) {
-    const first = input[startIndex];
-    if (!first)
-        return '';
-    const quoted = first === '"' || first === "'";
-    if (quoted) {
-        const end = input.indexOf(first, startIndex + 1);
-        return end === -1 ? '' : input.slice(startIndex + 1, end).trim();
-    }
-    const tail = input.slice(startIndex);
-    const stop = tail.search(/[\s/>]/);
-    return (stop === -1 ? tail : tail.slice(0, stop)).trim();
-}
-function extractHtmlCharset(headSnippet) {
-    const lower = headSnippet.toLowerCase();
-    const charsetToken = 'charset=';
-    const charsetIdx = lower.indexOf(charsetToken);
-    if (charsetIdx === -1)
-        return undefined;
-    const valueStart = charsetIdx + charsetToken.length;
-    const charset = readQuotedValue(headSnippet, valueStart);
-    return charset ? charset.toLowerCase() : undefined;
-}
-function extractXmlEncoding(headSnippet) {
-    const lower = headSnippet.toLowerCase();
-    const xmlStart = lower.indexOf('<?xml');
-    if (xmlStart === -1)
-        return undefined;
-    const xmlEnd = lower.indexOf('?>', xmlStart);
-    const declaration = xmlEnd === -1
-        ? headSnippet.slice(xmlStart)
-        : headSnippet.slice(xmlStart, xmlEnd + 2);
-    const declarationLower = declaration.toLowerCase();
-    const encodingToken = 'encoding=';
-    const encodingIdx = declarationLower.indexOf(encodingToken);
-    if (encodingIdx === -1)
-        return undefined;
-    const valueStart = encodingIdx + encodingToken.length;
-    const encoding = readQuotedValue(declaration, valueStart);
-    return encoding ? encoding.toLowerCase() : undefined;
-}
-function detectHtmlDeclaredEncoding(buffer) {
-    const scanSize = Math.min(buffer.length, 8_192);
-    if (scanSize === 0)
-        return undefined;
-    const headSnippet = Buffer.from(buffer.buffer, buffer.byteOffset, scanSize).toString('latin1');
-    return extractHtmlCharset(headSnippet) ?? extractXmlEncoding(headSnippet);
-}
-function resolveEncoding(declaredEncoding, sample) {
-    const bomEncoding = detectBomEncoding(sample);
-    if (bomEncoding)
-        return bomEncoding;
-    if (declaredEncoding)
-        return declaredEncoding;
-    return detectHtmlDeclaredEncoding(sample);
-}
-const BINARY_SIGNATURES = [
-    [0x25, 0x50, 0x44, 0x46],
-    [0x89, 0x50, 0x4e, 0x47],
-    [0x47, 0x49, 0x46, 0x38],
-    [0xff, 0xd8, 0xff],
-    [0x52, 0x49, 0x46, 0x46],
-    [0x42, 0x4d],
-    [0x49, 0x49, 0x2a, 0x00],
-    [0x4d, 0x4d, 0x00, 0x2a],
-    [0x00, 0x00, 0x01, 0x00],
-    [0x50, 0x4b, 0x03, 0x04],
-    [0x1f, 0x8b],
-    [0x42, 0x5a, 0x68],
-    [0x52, 0x61, 0x72, 0x21],
-    [0x37, 0x7a, 0xbc, 0xaf],
-    [0x7f, 0x45, 0x4c, 0x46],
-    [0x4d, 0x5a],
-    [0xcf, 0xfa, 0xed, 0xfe],
-    [0x00, 0x61, 0x73, 0x6d],
-    [0x1a, 0x45, 0xdf, 0xa3],
-    [0x66, 0x74, 0x79, 0x70],
-    [0x46, 0x4c, 0x56],
-    [0x49, 0x44, 0x33],
-    [0xff, 0xfb],
-    [0xff, 0xfa],
-    [0x4f, 0x67, 0x67, 0x53],
-    [0x66, 0x4c, 0x61, 0x43],
-    [0x4d, 0x54, 0x68, 0x64],
-    [0x77, 0x4f, 0x46, 0x46],
-    [0x00, 0x01, 0x00, 0x00],
-    [0x4f, 0x54, 0x54, 0x4f],
-    [0x53, 0x51, 0x4c, 0x69],
-];
-function startsWithBytes(buffer, signature) {
-    const sigLen = signature.length;
-    if (buffer.length < sigLen)
-        return false;
-    for (let i = 0; i < sigLen; i += 1) {
-        if (buffer[i] !== signature[i])
-            return false;
-    }
-    return true;
-}
-function hasNullByte(buffer, limit) {
-    const checkLen = Math.min(buffer.length, limit);
-    return buffer.subarray(0, checkLen).includes(0x00);
-}
-function isBinaryContent(buffer, encoding) {
-    for (const signature of BINARY_SIGNATURES) {
-        if (startsWithBytes(buffer, signature))
-            return true;
-    }
-    return !isUnicodeWideEncoding(encoding) && hasNullByte(buffer, 1000);
-}
 class ResponseTextReader {
     async read(response, url, maxBytes, signal, encoding) {
         const { buffer, encoding: effectiveEncoding, truncated, } = await this.readBuffer(response, url, maxBytes, signal, encoding);