@j0hanz/superfetch 2.2.2 → 2.4.0

package/dist/cache.d.ts

@@ -40,4 +40,3 @@ export declare function registerCachedContentResource(server: McpServer): void;
 export declare function generateSafeFilename(url: string, title?: string, hashFallback?: string, extension?: string): string;
 export declare function handleDownload(res: ServerResponse, namespace: string, hash: string): void;
 export {};
-//# sourceMappingURL=cache.d.ts.map

package/dist/cache.js

@@ -1,4 +1,3 @@
-import { LRUCache } from 'lru-cache';
 import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { ErrorCode, McpError, SubscribeRequestSchema, UnsubscribeRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { config } from './config.js';
@@ -105,10 +104,65 @@ export function toResourceUri(cacheKey) {
         return null;
     return buildCacheResourceUri(parts.namespace, parts.urlHash);
 }
-const contentCache = new LRUCache({
+// Cache behavior contract (native implementation):
+// - Max entries: config.cache.maxKeys
+// - TTL in ms: config.cache.ttl * 1000
+// - Access does NOT extend TTL
+class NativeLruCache {
+    max;
+    ttlMs;
+    entries = new Map();
+    constructor({ max, ttlMs }) {
+        this.max = max;
+        this.ttlMs = ttlMs;
+    }
+    get(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return undefined;
+        if (this.isExpired(entry, Date.now())) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        // Refresh LRU order without extending TTL.
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        return entry.value;
+    }
+    set(key, value) {
+        if (this.max <= 0 || this.ttlMs <= 0)
+            return;
+        this.entries.delete(key);
+        this.entries.set(key, {
+            value,
+            expiresAtMs: Date.now() + this.ttlMs,
+        });
+        this.purgeExpired(Date.now());
+        while (this.entries.size > this.max) {
+            const oldestKey = this.entries.keys().next().value;
+            if (oldestKey === undefined)
+                break;
+            this.entries.delete(oldestKey);
+        }
+    }
+    keys() {
+        this.purgeExpired(Date.now());
+        return [...this.entries.keys()];
+    }
+    purgeExpired(now) {
+        for (const [key, entry] of this.entries) {
+            if (this.isExpired(entry, now)) {
+                this.entries.delete(key);
+            }
+        }
+    }
+    isExpired(entry, now) {
+        return entry.expiresAtMs <= now;
+    }
+}
+const contentCache = new NativeLruCache({
     max: config.cache.maxKeys,
-    ttl: config.cache.ttl * 1000,
-    updateAgeOnGet: false,
+    ttlMs: config.cache.ttl * 1000,
 });
 const updateListeners = new Set();
 export function onCacheUpdate(listener) {
@@ -396,43 +450,32 @@ function buildMarkdownContentResponse(uri, content) {
         ],
     };
 }
-function isSingleParam(value) {
-    return typeof value === 'string';
-}
 function parseDownloadParams(namespace, hash) {
-    if (!isSingleParam(namespace) || !isSingleParam(hash))
+    const resolvedNamespace = resolveStringParam(namespace);
+    const resolvedHash = resolveStringParam(hash);
+    if (!resolvedNamespace || !resolvedHash)
         return null;
-    if (!namespace || !hash)
+    if (!isValidNamespace(resolvedNamespace))
         return null;
-    if (!isValidNamespace(namespace))
+    if (!isValidHash(resolvedHash))
         return null;
-    if (!isValidHash(hash))
-        return null;
-    return { namespace, hash };
+    return { namespace: resolvedNamespace, hash: resolvedHash };
 }
 function buildCacheKeyFromParams(params) {
     return `${params.namespace}:${params.hash}`;
 }
+function sendJsonError(res, status, error, code) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error, code }));
+}
 function respondBadRequest(res, message) {
-    res.writeHead(400, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({
-        error: message,
-        code: 'BAD_REQUEST',
-    }));
+    sendJsonError(res, 400, message, 'BAD_REQUEST');
 }
 function respondNotFound(res) {
-    res.writeHead(404, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({
-        error: 'Content not found or expired',
-        code: 'NOT_FOUND',
-    }));
+    sendJsonError(res, 404, 'Content not found or expired', 'NOT_FOUND');
 }
 function respondServiceUnavailable(res) {
-    res.writeHead(503, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({
-        error: 'Download service is disabled',
-        code: 'SERVICE_UNAVAILABLE',
-    }));
+    sendJsonError(res, 503, 'Download service is disabled', 'SERVICE_UNAVAILABLE');
 }
 export function generateSafeFilename(url, title, hashFallback, extension = '.md') {
     const fromUrl = extractFilenameFromUrl(url);
@@ -567,4 +610,3 @@ export function handleDownload(res, namespace, hash) {
     logDebug('Serving download', { cacheKey, fileName: payload.fileName });
     sendDownloadPayload(res, payload);
 }
-//# sourceMappingURL=cache.js.map

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+export declare const serverVersion: string;
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 export type TransformMetadataFormat = 'markdown' | 'frontmatter';
 interface AuthConfig {
@@ -43,6 +44,7 @@ export declare const config: {
     };
     transform: {
         timeoutMs: number;
+        stageWarnRatio: number;
         metadataFormat: TransformMetadataFormat;
     };
     tools: {
@@ -89,4 +91,3 @@ export declare const config: {
 };
 export declare function enableHttpMode(): void;
 export {};
-//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -1,4 +1,5 @@
 import packageJson from '../package.json' with { type: 'json' };
+export const serverVersion = packageJson.version;
 function buildIpv4(parts) {
     return parts.join('.');
 }
@@ -73,6 +74,9 @@ function parseUrlEnv(value, name) {
     }
     return new URL(value);
 }
+function readUrlEnv(name) {
+    return parseUrlEnv(process.env[name], name);
+}
 function parseAllowedHosts(envValue) {
     const hosts = new Set();
     for (const entry of parseList(envValue)) {
@@ -108,16 +112,16 @@ const DEFAULT_TOOL_TIMEOUT_MS = TIMEOUT.DEFAULT_FETCH_TIMEOUT_MS +
     5000;
 function readCoreOAuthUrls() {
     return {
-        issuerUrl: parseUrlEnv(process.env.OAUTH_ISSUER_URL, 'OAUTH_ISSUER_URL'),
-        authorizationUrl: parseUrlEnv(process.env.OAUTH_AUTHORIZATION_URL, 'OAUTH_AUTHORIZATION_URL'),
-        tokenUrl: parseUrlEnv(process.env.OAUTH_TOKEN_URL, 'OAUTH_TOKEN_URL'),
+        issuerUrl: readUrlEnv('OAUTH_ISSUER_URL'),
+        authorizationUrl: readUrlEnv('OAUTH_AUTHORIZATION_URL'),
+        tokenUrl: readUrlEnv('OAUTH_TOKEN_URL'),
     };
 }
 function readOptionalOAuthUrls(baseUrl) {
     return {
-        revocationUrl: parseUrlEnv(process.env.OAUTH_REVOCATION_URL, 'OAUTH_REVOCATION_URL'),
-        registrationUrl: parseUrlEnv(process.env.OAUTH_REGISTRATION_URL, 'OAUTH_REGISTRATION_URL'),
-        introspectionUrl: parseUrlEnv(process.env.OAUTH_INTROSPECTION_URL, 'OAUTH_INTROSPECTION_URL'),
+        revocationUrl: readUrlEnv('OAUTH_REVOCATION_URL'),
+        registrationUrl: readUrlEnv('OAUTH_REGISTRATION_URL'),
+        introspectionUrl: readUrlEnv('OAUTH_INTROSPECTION_URL'),
         resourceUrl: parseUrlEnv(process.env.OAUTH_RESOURCE_URL, 'OAUTH_RESOURCE_URL') ??
             new URL('/mcp', baseUrl),
     };
@@ -196,6 +200,7 @@ export const config = {
     },
     transform: {
         timeoutMs: TIMEOUT.DEFAULT_TRANSFORM_TIMEOUT_MS,
+        stageWarnRatio: parseFloat(process.env.TRANSFORM_STAGE_WARN_RATIO ?? '0.5'),
         metadataFormat: parseTransformMetadataFormat(process.env.TRANSFORM_METADATA_FORMAT),
     },
     tools: {
@@ -271,4 +276,3 @@ export const config = {
 export function enableHttpMode() {
     runtimeState.httpMode = true;
 }
-//# sourceMappingURL=config.js.map

package/dist/crypto.d.ts

@@ -1,3 +1,2 @@
 export declare function timingSafeEqualUtf8(a: string, b: string): boolean;
 export declare function sha256Hex(input: string | Uint8Array): string;
-//# sourceMappingURL=crypto.d.ts.map

package/dist/crypto.js

@@ -30,4 +30,3 @@ function hashHex(algorithm, input) {
 export function sha256Hex(input) {
     return hashHex('sha256', input);
 }
-//# sourceMappingURL=crypto.js.map

package/dist/dom-noise-removal.d.ts

@@ -3,4 +3,3 @@
  * Used as a preprocessing step before markdown conversion.
  */
 export declare function removeNoiseFromHtml(html: string, document?: Document, baseUrl?: string): string;
-//# sourceMappingURL=dom-noise-removal.d.ts.map

package/dist/dom-noise-removal.js

@@ -56,6 +56,37 @@ const STRUCTURAL_TAGS = new Set([
     'canvas',
 ]);
 const ALWAYS_NOISE_TAGS = new Set(['nav', 'footer']);
+const BASE_NOISE_SELECTORS = [
+    'nav',
+    'footer',
+    'header[class*="site"]',
+    'header[class*="nav"]',
+    'header[class*="menu"]',
+    '[role="banner"]',
+    '[role="navigation"]',
+    '[role="dialog"]',
+    '[style*="display: none"]',
+    '[style*="display:none"]',
+    '[hidden]',
+    '[aria-hidden="true"]',
+];
+const BASE_NOISE_SELECTOR = BASE_NOISE_SELECTORS.join(',');
+const CANDIDATE_NOISE_SELECTOR = [
+    ...STRUCTURAL_TAGS,
+    ...ALWAYS_NOISE_TAGS,
+    'aside',
+    'header',
+    '[class]',
+    '[id]',
+    '[role]',
+    '[style]',
+].join(',');
+function buildNoiseSelector(extraSelectors) {
+    const extra = extraSelectors.filter((selector) => selector.trim().length > 0);
+    if (extra.length === 0)
+        return BASE_NOISE_SELECTOR;
+    return `${BASE_NOISE_SELECTOR},${extra.join(',')}`;
+}
 const NAVIGATION_ROLES = new Set([
     'navigation',
     'banner',
@@ -126,6 +157,16 @@ function getPromoTokens() {
     promoTokensCache = tokens;
     return tokens;
 }
+let promoRegexCache = null;
+function getPromoRegex() {
+    if (promoRegexCache)
+        return promoRegexCache;
+    const tokens = Array.from(getPromoTokens());
+    const escaped = tokens.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    const pattern = `(?:^|[^a-z0-9])(?:${escaped.join('|')})(?:$|[^a-z0-9])`;
+    promoRegexCache = new RegExp(pattern, 'i');
+    return promoRegexCache;
+}
 const HEADER_NOISE_PATTERN = /\b(site-header|masthead|topbar|navbar|nav(?:bar)?|menu|header-nav)\b/i;
 const FIXED_PATTERN = /\b(fixed|sticky)\b/;
 const HIGH_Z_PATTERN = /\bz-(?:4\d|50)\b/;
@@ -230,18 +271,9 @@ function isElementHidden(element) {
 function hasNoiseRole(role) {
     return role !== null && NAVIGATION_ROLES.has(role);
 }
-function tokenizeIdentifierLikeText(value) {
-    return value
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, ' ')
-        .trim()
-        .split(' ')
-        .filter(Boolean);
-}
 function matchesPromoIdOrClass(className, id) {
-    const tokens = tokenizeIdentifierLikeText(`${className} ${id}`);
-    const promoTokens = getPromoTokens();
-    return tokens.some((token) => promoTokens.has(token));
+    const regex = getPromoRegex();
+    return regex.test(className) || regex.test(id);
 }
 function matchesFixedOrHighZIsolate(className) {
     return (FIXED_PATTERN.test(className) ||
@@ -279,9 +311,10 @@ function isNodeListLike(value) {
     return isObject(value) && typeof value.length === 'number';
 }
 function tryGetNodeListItem(nodes, index) {
-    if (typeof nodes.item === 'function')
+    if ('item' in nodes && typeof nodes.item === 'function') {
         return nodes.item(index);
-    return (nodes[index] ?? null);
+    }
+    return nodes[index] ?? null;
 }
 function removeNoiseFromNodeListLike(nodes, shouldCheckNoise) {
     for (let index = nodes.length - 1; index >= 0; index -= 1) {
@@ -309,39 +342,12 @@ function removeNoiseNodes(nodes, shouldCheckNoise = true) {
 function stripNoiseNodes(document) {
     // Pass 1: Trusted selectors (Common noise)
     // We trust these selectors match actual noise, so we skip the expensive isNoiseElement check
-    const baseSelectors = [
-        'nav',
-        'footer',
-        'header[class*="site"]',
-        'header[class*="nav"]',
-        'header[class*="menu"]',
-        '[role="banner"]',
-        '[role="navigation"]',
-        '[role="dialog"]',
-        '[style*="display: none"]',
-        '[style*="display:none"]',
-        '[hidden]',
-        '[aria-hidden="true"]',
-    ];
     // Add user-configured extra selectors
-    const extraSelectors = config.noiseRemoval.extraSelectors.filter((s) => s.trim().length > 0);
-    const targetSelectors = [...baseSelectors, ...extraSelectors].join(',');
-    if (targetSelectors) {
-        const potentialNoiseNodes = document.querySelectorAll(targetSelectors);
-        removeNoiseNodes(potentialNoiseNodes, false);
-    }
+    const targetSelectors = buildNoiseSelector(config.noiseRemoval.extraSelectors);
+    const potentialNoiseNodes = document.querySelectorAll(targetSelectors);
+    removeNoiseNodes(potentialNoiseNodes, false);
     // Second pass: check remaining elements for noise patterns (promo, fixed positioning, etc.)
-    const candidateSelectors = [
-        ...STRUCTURAL_TAGS,
-        ...ALWAYS_NOISE_TAGS,
-        'aside',
-        'header',
-        '[class]',
-        '[id]',
-        '[role]',
-        '[style]',
-    ].join(',');
-    const allElements = document.querySelectorAll(candidateSelectors);
+    const allElements = document.querySelectorAll(CANDIDATE_NOISE_SELECTOR);
     removeNoiseNodes(allElements, true);
 }
 // ─────────────────────────────────────────────────────────────────────────────
@@ -479,4 +485,3 @@ export function removeNoiseFromHtml(html, document, baseUrl) {
         return html;
     }
 }
-//# sourceMappingURL=dom-noise-removal.js.map

package/dist/errors.d.ts

@@ -8,4 +8,3 @@ export declare class FetchError extends Error {
 export declare function getErrorMessage(error: unknown): string;
 export declare function createErrorWithCode(message: string, code: string): NodeJS.ErrnoException;
 export declare function isSystemError(error: unknown): error is NodeJS.ErrnoException;
-//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -42,4 +42,3 @@ export function isSystemError(error) {
     const { code } = error;
     return typeof code === 'string';
 }
-//# sourceMappingURL=errors.js.map

package/dist/fetch.d.ts

@@ -38,4 +38,3 @@ export declare function readResponseText(response: Response, url: string, maxByt
 }>;
 export declare function fetchNormalizedUrl(normalizedUrl: string, options?: FetchOptions): Promise<string>;
 export {};
-//# sourceMappingURL=fetch.d.ts.map

package/dist/fetch.js

@@ -300,11 +300,11 @@ export function isRawTextContentUrl(url) {
     return hasKnownRawTextExtension(lowerBase);
 }
 function hasKnownRawTextExtension(urlBaseLower) {
-    for (const ext of RAW_TEXT_EXTENSIONS) {
-        if (urlBaseLower.endsWith(ext))
-            return true;
-    }
-    return false;
+    const lastDot = urlBaseLower.lastIndexOf('.');
+    if (lastDot === -1)
+        return false;
+    const ext = urlBaseLower.slice(lastDot);
+    return RAW_TEXT_EXTENSIONS.has(ext);
 }
 const DNS_LOOKUP_TIMEOUT_MS = 5000;
 const SLOW_REQUEST_THRESHOLD_MS = 5000;
@@ -314,25 +314,6 @@ function normalizeLookupResults(addresses, family) {
     }
     return [{ address: addresses, family: family ?? 4 }];
 }
-function findBlockedIpError(list, hostname) {
-    for (const addr of list) {
-        const ip = typeof addr === 'string' ? addr : addr.address;
-        if (!isBlockedIp(ip)) {
-            continue;
-        }
-        return createErrorWithCode(`Blocked IP detected for ${hostname}`, 'EBLOCKED');
-    }
-    return null;
-}
-function findInvalidFamilyError(list, hostname) {
-    for (const addr of list) {
-        const family = typeof addr === 'string' ? 0 : addr.family;
-        if (family === 4 || family === 6)
-            continue;
-        return createErrorWithCode(`Invalid address family returned for ${hostname}`, 'EINVAL');
-    }
-    return null;
-}
 function createNoDnsResultsError(hostname) {
     return createErrorWithCode(`No DNS results returned for ${hostname}`, 'ENODATA');
 }
@@ -358,7 +339,17 @@ function selectLookupResult(list, useAll, hostname) {
     };
 }
 function findLookupError(list, hostname) {
-    return (findInvalidFamilyError(list, hostname) ?? findBlockedIpError(list, hostname));
+    for (const addr of list) {
+        const family = typeof addr === 'string' ? 0 : addr.family;
+        if (family !== 4 && family !== 6) {
+            return createErrorWithCode(`Invalid address family returned for ${hostname}`, 'EINVAL');
+        }
+        const ip = typeof addr === 'string' ? addr : addr.address;
+        if (isBlockedIp(ip)) {
+            return createErrorWithCode(`Blocked IP detected for ${hostname}`, 'EBLOCKED');
+        }
+    }
+    return null;
 }
 function normalizeAndValidateLookupResults(addresses, resolvedFamily, hostname) {
     const list = normalizeLookupResults(addresses, resolvedFamily);
@@ -503,6 +494,12 @@ function createRateLimitError(url, headerValue) {
 function createHttpError(url, status, statusText) {
     return new FetchError(`HTTP ${status}: ${statusText}`, url, status);
 }
+function createTooManyRedirectsError(url) {
+    return new FetchError('Too many redirects', url);
+}
+function createMissingRedirectLocationError(url) {
+    return new FetchError('Redirect response missing Location header', url);
+}
 function createSizeLimitError(url, maxBytes) {
     return new FetchError(`Response exceeds maximum size of ${maxBytes} bytes`, url);
 }
@@ -534,21 +531,29 @@ function resolveErrorUrl(error, fallback) {
         return requestUrl;
     return fallback;
 }
-function mapFetchError(error, fallbackUrl, timeoutMs) {
-    if (error instanceof FetchError)
-        return error;
-    const url = resolveErrorUrl(error, fallbackUrl);
-    if (isAbortError(error)) {
-        if (isTimeoutError(error)) {
-            return createTimeoutError(url, timeoutMs);
-        }
-        return createCanceledError(url);
+function resolveAbortFetchError(error, url, timeoutMs) {
+    if (!isAbortError(error))
+        return null;
+    if (isTimeoutError(error)) {
+        return createTimeoutError(url, timeoutMs);
     }
+    return createCanceledError(url);
+}
+function resolveUnexpectedFetchError(error, url) {
     if (error instanceof Error) {
         return createNetworkError(url, error.message);
     }
     return createUnknownError(url, 'Unexpected error');
 }
+function mapFetchError(error, fallbackUrl, timeoutMs) {
+    if (error instanceof FetchError)
+        return error;
+    const url = resolveErrorUrl(error, fallbackUrl);
+    const abortError = resolveAbortFetchError(error, url, timeoutMs);
+    if (abortError)
+        return abortError;
+    return resolveUnexpectedFetchError(error, url);
+}
 const fetchChannel = diagnosticsChannel.channel('superfetch.fetch');
 function publishFetchEvent(event) {
     if (!fetchChannel.hasSubscribers)
@@ -713,14 +718,14 @@ function assertRedirectWithinLimit(response, currentUrl, redirectLimit, redirect
     if (redirectCount < redirectLimit)
         return;
     cancelResponseBody(response);
-    throw new FetchError('Too many redirects', currentUrl);
+    throw createTooManyRedirectsError(currentUrl);
 }
 function getRedirectLocation(response, currentUrl) {
     const location = response.headers.get('location');
     if (location)
         return location;
     cancelResponseBody(response);
-    throw new FetchError('Redirect response missing Location header', currentUrl);
+    throw createMissingRedirectLocationError(currentUrl);
 }
 function annotateRedirectError(error, url) {
     if (!isObject(error))
@@ -737,26 +742,26 @@ function resolveRedirectTarget(baseUrl, location) {
     }
     return validateAndNormalizeUrl(resolved.href);
 }
+async function withRedirectErrorContext(url, fn) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        annotateRedirectError(error, url);
+        throw error;
+    }
+}
 export async function fetchWithRedirects(url, init, maxRedirects) {
     let currentUrl = url;
     const redirectLimit = Math.max(0, maxRedirects);
     for (let redirectCount = 0; redirectCount <= redirectLimit; redirectCount += 1) {
-        const { response, nextUrl } = await performFetchCycleSafely(currentUrl, init, redirectLimit, redirectCount);
+        const { response, nextUrl } = await withRedirectErrorContext(currentUrl, () => performFetchCycle(currentUrl, init, redirectLimit, redirectCount));
         if (!nextUrl) {
             return { response, url: currentUrl };
         }
         currentUrl = nextUrl;
     }
-    throw new FetchError('Too many redirects', currentUrl);
-}
-async function performFetchCycleSafely(currentUrl, init, redirectLimit, redirectCount) {
-    try {
-        return await performFetchCycle(currentUrl, init, redirectLimit, redirectCount);
-    }
-    catch (error) {
-        annotateRedirectError(error, currentUrl);
-        throw error;
-    }
+    throw createTooManyRedirectsError(currentUrl);
 }
 function assertContentLengthWithinLimit(response, url, maxBytes) {
     const contentLengthHeader = response.headers.get('content-length');
@@ -841,15 +846,18 @@ async function readStreamWithLimit(stream, url, maxBytes, signal) {
     finalizeRead(state);
     return { text: state.parts.join(''), size: state.total };
 }
+async function readResponseTextFallback(response, url, maxBytes) {
+    const text = await response.text();
+    const size = Buffer.byteLength(text);
+    if (size > maxBytes) {
+        throw createSizeLimitError(url, maxBytes);
+    }
+    return { text, size };
+}
 export async function readResponseText(response, url, maxBytes, signal) {
     assertContentLengthWithinLimit(response, url, maxBytes);
     if (!response.body) {
-        const text = await response.text();
-        const size = Buffer.byteLength(text);
-        if (size > maxBytes) {
-            throw createSizeLimitError(url, maxBytes);
-        }
-        return { text, size };
+        return readResponseTextFallback(response, url, maxBytes);
     }
     return readStreamWithLimit(response.body, url, maxBytes, signal);
 }
@@ -925,4 +933,3 @@ export async function fetchNormalizedUrl(normalizedUrl, options) {
     const requestInit = buildRequestInit(headers, signal);
     return fetchWithTelemetry(normalizedUrl, requestInit, timeoutMs);
 }
-//# sourceMappingURL=fetch.js.map

package/dist/host-normalization.d.ts

@@ -0,0 +1 @@
+export declare function normalizeHost(value: string): string | null;

package/dist/host-normalization.js

@@ -0,0 +1,47 @@
+import { isIP } from 'node:net';
+export function normalizeHost(value) {
+    const trimmed = value.trim().toLowerCase();
+    if (!trimmed)
+        return null;
+    const first = takeFirstHostValue(trimmed);
+    if (!first)
+        return null;
+    const ipv6 = stripIpv6Brackets(first);
+    if (ipv6)
+        return stripTrailingDots(ipv6);
+    if (isIpV6Literal(first)) {
+        return stripTrailingDots(first);
+    }
+    return stripTrailingDots(stripPortIfPresent(first));
+}
+function takeFirstHostValue(value) {
+    const first = value.split(',')[0];
+    if (!first)
+        return null;
+    const trimmed = first.trim();
+    return trimmed ? trimmed : null;
+}
+function stripIpv6Brackets(value) {
+    if (!value.startsWith('['))
+        return null;
+    const end = value.indexOf(']');
+    if (end === -1)
+        return null;
+    return value.slice(1, end);
+}
+function stripPortIfPresent(value) {
+    const colonIndex = value.indexOf(':');
+    if (colonIndex === -1)
+        return value;
+    return value.slice(0, colonIndex);
+}
+function isIpV6Literal(value) {
+    return isIP(value) === 6;
+}
+function stripTrailingDots(value) {
+    let result = value;
+    while (result.endsWith('.')) {
+        result = result.slice(0, -1);
+    }
+    return result;
+}

package/dist/http-native.d.ts

@@ -3,4 +3,3 @@ export declare function startHttpServer(): Promise<{
     port: number;
     host: string;
 }>;
-//# sourceMappingURL=http-native.d.ts.map