@j0hanz/superfetch 1.2.5 → 2.0.1

package/dist/utils/code-language-helpers.d.ts

@@ -0,0 +1,5 @@
+export declare function containsJsxTag(code: string): boolean;
+export declare function containsWord(source: string, word: string): boolean;
+export declare function splitLines(content: string): string[];
+export declare function extractLanguageFromClassName(className: string): string | undefined;
+export declare function resolveLanguageFromDataAttribute(dataLang: string): string | undefined;

package/dist/utils/code-language-helpers.js

@@ -0,0 +1,62 @@
+export function containsJsxTag(code) {
+    for (let index = 0; index < code.length - 1; index += 1) {
+        if (code[index] !== '<')
+            continue;
+        const next = code[index + 1];
+        if (!next)
+            continue;
+        if (next >= 'A' && next <= 'Z')
+            return true;
+    }
+    return false;
+}
+export function containsWord(source, word) {
+    let startIndex = source.indexOf(word);
+    while (startIndex !== -1) {
+        const before = startIndex === 0 ? '' : source[startIndex - 1];
+        const afterIndex = startIndex + word.length;
+        const after = afterIndex >= source.length ? '' : source[afterIndex];
+        if (!isWordChar(before) && !isWordChar(after))
+            return true;
+        startIndex = source.indexOf(word, startIndex + word.length);
+    }
+    return false;
+}
+export function splitLines(content) {
+    return content.split('\n');
+}
+export function extractLanguageFromClassName(className) {
+    const tokens = className.match(/\S+/g);
+    if (!tokens)
+        return undefined;
+    for (const token of tokens) {
+        const lower = token.toLowerCase();
+        if (lower.startsWith('language-'))
+            return token.slice('language-'.length);
+        if (lower.startsWith('lang-'))
+            return token.slice('lang-'.length);
+        if (lower.startsWith('highlight-')) {
+            return token.slice('highlight-'.length);
+        }
+    }
+    return undefined;
+}
+export function resolveLanguageFromDataAttribute(dataLang) {
+    const trimmed = dataLang.trim();
+    if (!trimmed)
+        return undefined;
+    for (const char of trimmed) {
+        if (!isWordChar(char))
+            return undefined;
+    }
+    return trimmed;
+}
+function isWordChar(char) {
+    if (!char)
+        return false;
+    const code = char.charCodeAt(0);
+    return ((code >= 48 && code <= 57) ||
+        (code >= 65 && code <= 90) ||
+        (code >= 97 && code <= 122) ||
+        char === '_');
+}

package/dist/utils/code-language-parsing.d.ts

@@ -0,0 +1,5 @@
+export declare function containsJsxTag(code: string): boolean;
+export declare function containsWord(source: string, word: string): boolean;
+export declare function splitLines(content: string): string[];
+export declare function extractLanguageFromClassName(className: string): string | undefined;
+export declare function resolveLanguageFromDataAttribute(dataLang: string): string | undefined;

package/dist/utils/code-language-parsing.js

@@ -0,0 +1,62 @@
+export function containsJsxTag(code) {
+    for (let index = 0; index < code.length - 1; index += 1) {
+        if (code[index] !== '<')
+            continue;
+        const next = code[index + 1];
+        if (!next)
+            continue;
+        if (next >= 'A' && next <= 'Z')
+            return true;
+    }
+    return false;
+}
+export function containsWord(source, word) {
+    let startIndex = source.indexOf(word);
+    while (startIndex !== -1) {
+        const before = startIndex === 0 ? '' : source[startIndex - 1];
+        const afterIndex = startIndex + word.length;
+        const after = afterIndex >= source.length ? '' : source[afterIndex];
+        if (!isWordChar(before) && !isWordChar(after))
+            return true;
+        startIndex = source.indexOf(word, startIndex + word.length);
+    }
+    return false;
+}
+export function splitLines(content) {
+    return content.split('\n');
+}
+export function extractLanguageFromClassName(className) {
+    const tokens = className.match(/\S+/g);
+    if (!tokens)
+        return undefined;
+    for (const token of tokens) {
+        const lower = token.toLowerCase();
+        if (lower.startsWith('language-'))
+            return token.slice('language-'.length);
+        if (lower.startsWith('lang-'))
+            return token.slice('lang-'.length);
+        if (lower.startsWith('highlight-')) {
+            return token.slice('highlight-'.length);
+        }
+    }
+    return undefined;
+}
+export function resolveLanguageFromDataAttribute(dataLang) {
+    const trimmed = dataLang.trim();
+    if (!trimmed)
+        return undefined;
+    for (const char of trimmed) {
+        if (!isWordChar(char))
+            return undefined;
+    }
+    return trimmed;
+}
+function isWordChar(char) {
+    if (!char)
+        return false;
+    const code = char.charCodeAt(0);
+    return ((code >= 48 && code <= 57) ||
+        (code >= 65 && code <= 90) ||
+        (code >= 97 && code <= 122) ||
+        char === '_');
+}

package/dist/utils/code-language.d.ts

@@ -1,2 +1,11 @@
+export declare function containsJsxTag(code: string): boolean;
+export declare function containsWord(source: string, word: string): boolean;
+export declare function splitLines(content: string): string[];
+export declare function extractLanguageFromClassName(className: string): string | undefined;
+export declare function resolveLanguageFromDataAttribute(dataLang: string): string | undefined;
+export interface CodeDetector {
+    language: string;
+    detect: (code: string) => boolean;
+}
 export declare function detectLanguageFromCode(code: string): string | undefined;
 export declare function resolveLanguageFromAttributes(className: string, dataLang: string): string | undefined;

package/dist/utils/code-language.js

@@ -1,56 +1,260 @@
-const CODE_PATTERNS = [
-    [
-        /^\s*import\s+.*\s+from\s+['"]react['"]|<[A-Z][a-zA-Z]*[\s/>]|jsx\s*:|className=/m,
-        'jsx',
-    ],
-    [
-        /:\s*(string|number|boolean|void|any|unknown|never)\b|interface\s+\w+|type\s+\w+\s*=/m,
-        'typescript',
-    ],
-    [/^\s*(fn|let\s+mut|impl|struct|enum|use\s+\w+::)/m, 'rust'],
-    [
-        /^\s*(export|const|let|var|function|class|async|await)\b|^\s*import\s+.*['"]]/m,
-        'javascript',
-    ],
-    [/^\s*(def|class|import|from|if __name__|print\()/m, 'python'],
-    [
-        /^\s*(npm|yarn|pnpm|npx|brew|apt|pip|cargo|go )\s+(install|add|run|build|start)/m,
-        'bash',
-    ],
-    [/^\s*[$#]\s+\w+|^\s*#!|^\s*(sudo|chmod|mkdir|cd|ls|cat|echo)\s+/m, 'bash'],
-    [/^\s*[.#@]?[\w-]+\s*\{[^}]*\}|@media|@import|@keyframes/m, 'css'],
-    [/^\s*<(!DOCTYPE|html|head|body|div|span|p|a|script|style)\b/im, 'html'],
-    [/^\s*\{\s*"|^\s*\[\s*("|\d|true|false|null)/m, 'json'],
-    [/^\s*[\w-]+:\s*.+$/m, 'yaml'],
-    [/^\s*(SELECT|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP)\s+/im, 'sql'],
-    [/^\s*(func|package|import\s+")/m, 'go'],
+export function containsJsxTag(code) {
+    for (let index = 0; index < code.length - 1; index += 1) {
+        if (code[index] !== '<')
+            continue;
+        const next = code[index + 1];
+        if (!next)
+            continue;
+        if (next >= 'A' && next <= 'Z')
+            return true;
+    }
+    return false;
+}
+export function containsWord(source, word) {
+    let startIndex = source.indexOf(word);
+    while (startIndex !== -1) {
+        const before = startIndex === 0 ? '' : source[startIndex - 1];
+        const afterIndex = startIndex + word.length;
+        const after = afterIndex >= source.length ? '' : source[afterIndex];
+        if (!isWordChar(before) && !isWordChar(after))
+            return true;
+        startIndex = source.indexOf(word, startIndex + word.length);
+    }
+    return false;
+}
+export function splitLines(content) {
+    return content.split('\n');
+}
+export function extractLanguageFromClassName(className) {
+    const tokens = className.match(/\S+/g);
+    if (!tokens)
+        return undefined;
+    for (const token of tokens) {
+        const lower = token.toLowerCase();
+        if (lower.startsWith('language-'))
+            return token.slice('language-'.length);
+        if (lower.startsWith('lang-'))
+            return token.slice('lang-'.length);
+        if (lower.startsWith('highlight-')) {
+            return token.slice('highlight-'.length);
+        }
+    }
+    return undefined;
+}
+export function resolveLanguageFromDataAttribute(dataLang) {
+    const trimmed = dataLang.trim();
+    if (!trimmed)
+        return undefined;
+    for (const char of trimmed) {
+        if (!isWordChar(char))
+            return undefined;
+    }
+    return trimmed;
+}
+function isWordChar(char) {
+    if (!char)
+        return false;
+    const code = char.charCodeAt(0);
+    return ((code >= 48 && code <= 57) ||
+        (code >= 65 && code <= 90) ||
+        (code >= 97 && code <= 122) ||
+        char === '_');
+}
+const BASH_PACKAGE_MANAGERS = [
+    'npm',
+    'yarn',
+    'pnpm',
+    'npx',
+    'brew',
+    'apt',
+    'pip',
+    'cargo',
+    'go',
+];
+const BASH_VERBS = ['install', 'add', 'run', 'build', 'start'];
+const BASH_COMMANDS = ['sudo', 'chmod', 'mkdir', 'cd', 'ls', 'cat', 'echo'];
+function detectBash(code) {
+    const lines = splitLines(code);
+    for (const line of lines) {
+        const trimmed = line.trimStart();
+        if (!trimmed)
+            continue;
+        if (isBashIndicator(trimmed))
+            return true;
+    }
+    return false;
+}
+function startsWithCommand(line, commands) {
+    return commands.some((command) => line === command || line.startsWith(`${command} `));
+}
+function isBashIndicator(line) {
+    return (isShebang(line) ||
+        isPromptLine(line) ||
+        startsWithCommand(line, BASH_COMMANDS) ||
+        startsWithPackageManagerCommand(line));
+}
+function isShebang(line) {
+    return line.startsWith('#!');
+}
+function isPromptLine(line) {
+    return line.startsWith('$ ') || line.startsWith('# ');
+}
+function startsWithPackageManagerCommand(line) {
+    return BASH_PACKAGE_MANAGERS.some((manager) => {
+        if (!line.startsWith(`${manager} `))
+            return false;
+        const rest = line.slice(manager.length + 1);
+        return BASH_VERBS.some((verb) => rest === verb || rest.startsWith(`${verb} `));
+    });
+}
+const TYPE_HINTS = [
+    'string',
+    'number',
+    'boolean',
+    'void',
+    'any',
+    'unknown',
+    'never',
+];
+const HTML_TAGS = [
+    '<!doctype',
+    '<html',
+    '<head',
+    '<body',
+    '<div',
+    '<span',
+    '<p',
+    '<a',
+    '<script',
+    '<style',
+];
+const SQL_KEYWORDS = [
+    'select',
+    'insert',
+    'update',
+    'delete',
+    'create',
+    'alter',
+    'drop',
 ];
-const CLASS_PATTERNS = [
-    /language-(\w+)/,
-    /lang-(\w+)/,
-    /highlight-(\w+)/,
+const JS_WORD_REGEX = /\b(?:const|let|var|function|class|async|await|export|import)\b/;
+const PYTHON_WORD_REGEX = /\b(?:def|class|import|from)\b/;
+const RUST_WORD_REGEX = /\b(?:fn|impl|struct|enum)\b/;
+const CSS_DIRECTIVE_REGEX = /@media|@import|@keyframes/;
+const CODE_DETECTORS = [
+    { language: 'jsx', detect: detectJsx },
+    { language: 'typescript', detect: detectTypescript },
+    { language: 'rust', detect: detectRust },
+    { language: 'javascript', detect: detectJavascript },
+    { language: 'python', detect: detectPython },
+    { language: 'bash', detect: detectBash },
+    { language: 'css', detect: detectCss },
+    { language: 'html', detect: detectHtml },
+    { language: 'json', detect: detectJson },
+    { language: 'yaml', detect: detectYaml },
+    { language: 'sql', detect: detectSql },
+    { language: 'go', detect: detectGo },
 ];
+function detectJsx(code) {
+    const lower = code.toLowerCase();
+    if (lower.includes('classname='))
+        return true;
+    if (lower.includes('jsx:'))
+        return true;
+    if (lower.includes("from 'react'") || lower.includes('from "react"')) {
+        return true;
+    }
+    return containsJsxTag(code);
+}
+function detectTypescript(code) {
+    const lower = code.toLowerCase();
+    if (containsWord(lower, 'interface'))
+        return true;
+    if (containsWord(lower, 'type'))
+        return true;
+    return TYPE_HINTS.some((hint) => lower.includes(`: ${hint}`) || lower.includes(`:${hint}`));
+}
+function detectRust(code) {
+    const lower = code.toLowerCase();
+    return (RUST_WORD_REGEX.test(lower) ||
+        lower.includes('let mut') ||
+        (lower.includes('use ') && lower.includes('::')));
+}
+function detectJavascript(code) {
+    const lower = code.toLowerCase();
+    return JS_WORD_REGEX.test(lower);
+}
+function detectPython(code) {
+    const lower = code.toLowerCase();
+    return (PYTHON_WORD_REGEX.test(lower) ||
+        lower.includes('print(') ||
+        lower.includes('__name__'));
+}
+function detectCss(code) {
+    const lower = code.toLowerCase();
+    if (CSS_DIRECTIVE_REGEX.test(lower))
+        return true;
+    const lines = splitLines(code);
+    for (const line of lines) {
+        const trimmed = line.trimStart();
+        if (!trimmed)
+            continue;
+        if (isCssSelectorLine(trimmed) || isCssPropertyLine(trimmed))
+            return true;
+    }
+    return false;
+}
+function detectHtml(code) {
+    const lower = code.toLowerCase();
+    return HTML_TAGS.some((tag) => lower.includes(tag));
+}
+function detectJson(code) {
+    const trimmed = code.trimStart();
+    if (!trimmed)
+        return false;
+    return trimmed.startsWith('{') || trimmed.startsWith('[');
+}
+function detectYaml(code) {
+    const lines = splitLines(code);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const colonIndex = trimmed.indexOf(':');
+        if (colonIndex <= 0)
+            continue;
+        const after = trimmed[colonIndex + 1];
+        if (after === ' ' || after === '\t')
+            return true;
+    }
+    return false;
+}
+function detectSql(code) {
+    const lower = code.toLowerCase();
+    return SQL_KEYWORDS.some((keyword) => containsWord(lower, keyword));
+}
+function detectGo(code) {
+    const lower = code.toLowerCase();
+    return (containsWord(lower, 'package') ||
+        containsWord(lower, 'func') ||
+        lower.includes('import "'));
+}
+function isCssSelectorLine(line) {
+    if (!line.startsWith('.') && !line.startsWith('#'))
+        return false;
+    return line.includes('{');
+}
+function isCssPropertyLine(line) {
+    return line.includes(':') && line.includes(';');
+}
 export function detectLanguageFromCode(code) {
-    for (const [pattern, language] of CODE_PATTERNS) {
-        if (pattern.test(code)) {
+    for (const { language, detect } of CODE_DETECTORS) {
+        if (detect(code))
             return language;
-        }
     }
     return undefined;
 }
 export function resolveLanguageFromAttributes(className, dataLang) {
-    const classMatch = matchFirstCapture(className, CLASS_PATTERNS);
+    const classMatch = extractLanguageFromClassName(className);
     return classMatch ?? resolveLanguageFromDataAttribute(dataLang);
 }
-function matchFirstCapture(value, patterns) {
-    for (const pattern of patterns) {
-        const match = pattern.exec(value);
-        if (match?.[1])
-            return match[1];
-    }
-    return undefined;
-}
-function resolveLanguageFromDataAttribute(dataLang) {
-    const match = /^(\w+)$/.exec(dataLang);
-    return match?.[1];
-}

package/dist/utils/error-details.d.ts

@@ -0,0 +1,3 @@
+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;

package/dist/utils/error-details.js

@@ -0,0 +1,12 @@
+export function getErrorMessage(error) {
+    return error instanceof Error ? error.message : 'Unknown error';
+}
+export function createErrorWithCode(message, code) {
+    const error = new Error(message);
+    return Object.assign(error, { code });
+}
+export function isSystemError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        typeof Reflect.get(error, 'code') === 'string');
+}

package/dist/utils/error-utils.js

@@ -8,5 +8,5 @@ export function createErrorWithCode(message, code) {
 export function isSystemError(error) {
     return (error instanceof Error &&
         'code' in error &&
-        typeof error.code === 'string');
+        typeof Reflect.get(error, 'code') === 'string');
 }

package/dist/utils/filename-generator.js

@@ -2,6 +2,17 @@ const MAX_FILENAME_LENGTH = 200;
 const UNSAFE_CHARS_REGEX = /[<>:"/\\|?*]|\p{C}/gu;
 const WHITESPACE_REGEX = /\s+/g;
 const DEFAULT_EXTENSION = '.md';
+function trimHyphens(value) {
+    let start = 0;
+    let end = value.length;
+    while (start < end && value[start] === '-') {
+        start += 1;
+    }
+    while (end > start && value[end - 1] === '-') {
+        end -= 1;
+    }
+    return value.slice(start, end);
+}
 export function generateSafeFilename(url, title, hashFallback, extension = DEFAULT_EXTENSION) {
     const fromUrl = extractFilenameFromUrl(url);
     if (fromUrl)
@@ -16,20 +27,31 @@ export function generateSafeFilename(url, title, hashFallback, extension = DEFAU
     }
     return `download-${Date.now()}${extension}`;
 }
+function getLastPathSegment(url) {
+    const segments = url.pathname.split('/').filter(Boolean);
+    if (segments.length === 0)
+        return null;
+    const lastSegment = segments[segments.length - 1];
+    return lastSegment ?? null;
+}
+function stripCommonPageExtension(segment) {
+    return segment.replace(/\.(html?|php|aspx?|jsp)$/i, '');
+}
+function normalizeUrlFilenameSegment(segment) {
+    const cleaned = stripCommonPageExtension(segment);
+    if (!cleaned)
+        return null;
+    if (cleaned === 'index')
+        return null;
+    return cleaned;
+}
 function extractFilenameFromUrl(url) {
     try {
         const urlObj = new URL(url);
-        const { pathname } = urlObj;
-        const segments = pathname.split('/').filter(Boolean);
-        if (segments.length === 0)
-            return null;
-        const lastSegment = segments[segments.length - 1];
+        const lastSegment = getLastPathSegment(urlObj);
         if (!lastSegment)
             return null;
-        const cleaned = lastSegment.replace(/\.(html?|php|aspx?|jsp)$/i, '');
-        if (!cleaned || cleaned === 'index')
-            return null;
-        return cleaned;
+        return normalizeUrlFilenameSegment(lastSegment);
     }
     catch {
         return null;
@@ -41,9 +63,9 @@ function slugifyTitle(title) {
         .trim()
         .replace(UNSAFE_CHARS_REGEX, '')
         .replace(WHITESPACE_REGEX, '-')
-        .replace(/-+/g, '-')
-        .replace(/^-|-$/g, '');
-    return slug.length > 0 ? slug : null;
+        .replace(/-+/g, '-');
+    const trimmed = trimHyphens(slug);
+    return trimmed || null;
 }
 function sanitizeFilename(name, extension) {
     let sanitized = name

package/dist/utils/guards.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/utils/guards.js

@@ -0,0 +1,3 @@
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/utils/header-normalizer.d.ts

@@ -2,7 +2,4 @@ interface NormalizeOptions {
     readonly trimValues?: boolean;
 }
 export declare function normalizeHeaderRecord(headers: Record<string, string> | undefined, blockedHeaders: Set<string>, options?: NormalizeOptions): Record<string, string> | undefined;
-export declare function normalizeHeaderEntries(headers: Record<string, string>, blockedHeaders: Set<string>, options?: NormalizeOptions): Headers;
-export declare function hasHeaderEntries(headers: Headers): boolean;
-export declare function headersToRecord(headers: Headers): Record<string, string>;
 export {};

package/dist/utils/header-normalizer.js

@@ -6,7 +6,7 @@ export function normalizeHeaderRecord(headers, blockedHeaders, options = {}) {
         return undefined;
     return headersToRecord(normalized);
 }
-export function normalizeHeaderEntries(headers, blockedHeaders, options = {}) {
+function normalizeHeaderEntries(headers, blockedHeaders, options = {}) {
     const normalized = new Headers();
     for (const [key, value] of Object.entries(headers)) {
         if (blockedHeaders.has(key.toLowerCase()))
@@ -15,10 +15,10 @@ export function normalizeHeaderEntries(headers, blockedHeaders, options = {}) {
     }
     return normalized;
 }
-export function hasHeaderEntries(headers) {
+function hasHeaderEntries(headers) {
     return !headers.keys().next().done;
 }
-export function headersToRecord(headers) {
+function headersToRecord(headers) {
     return Object.fromEntries(headers.entries());
 }
 function setHeaderValue(headers, key, value, trimValue) {

package/dist/utils/ip-address.d.ts

@@ -0,0 +1,4 @@
+type IpSegment = number | string;
+export declare function buildIpv4(parts: readonly [number, number, number, number]): string;
+export declare function buildIpv6(parts: readonly IpSegment[]): string;
+export {};

package/dist/utils/ip-address.js

@@ -0,0 +1,6 @@
+export function buildIpv4(parts) {
+    return parts.join('.');
+}
+export function buildIpv6(parts) {
+    return parts.map(String).join(':');
+}

package/dist/utils/tool-error-handler.d.ts

@@ -1,3 +1,3 @@
 import type { ToolErrorResponse } from '../config/types/tools.js';
-export declare function createToolErrorResponse(message: string, url: string, code: string, details?: Record<string, unknown>): ToolErrorResponse;
-export declare function handleToolError(error: unknown, url: string, fallbackMessage?: string, details?: Record<string, unknown>): ToolErrorResponse;
+export declare function createToolErrorResponse(message: string, url: string): ToolErrorResponse;
+export declare function handleToolError(error: unknown, url: string, fallbackMessage?: string): ToolErrorResponse;