@j0hanz/superfetch 1.2.5 → 2.0.1

package/dist/transformers/markdown/noise-rule.js

@@ -0,0 +1,80 @@
+import { isRecord } from '../../utils/guards.js';
+const STRUCTURAL_TAGS = new Set([
+    'script',
+    'style',
+    'noscript',
+    'iframe',
+    'nav',
+    'footer',
+    'aside',
+    'header',
+    'form',
+    'button',
+    'input',
+    'select',
+    'textarea',
+]);
+const NAVIGATION_ROLES = new Set([
+    'navigation',
+    'banner',
+    'complementary',
+    'contentinfo',
+    'tree',
+    'menubar',
+    'menu',
+]);
+const PROMO_PATTERN = /banner|promo|announcement|cta|callout|advert|newsletter|subscribe|cookie|consent|popup|modal|overlay|toast/;
+const FIXED_PATTERN = /\b(fixed|sticky)\b/;
+const HIGH_Z_PATTERN = /\bz-(?:4\d|50)\b/;
+const ISOLATE_PATTERN = /\bisolate\b/;
+function isElement(node) {
+    return (isRecord(node) &&
+        'getAttribute' in node &&
+        typeof node.getAttribute === 'function');
+}
+function isStructuralNoiseTag(tagName) {
+    return (STRUCTURAL_TAGS.has(tagName) || tagName === 'svg' || tagName === 'canvas');
+}
+function isElementHidden(element) {
+    return (element.getAttribute('hidden') !== null ||
+        element.getAttribute('aria-hidden') === 'true');
+}
+function hasNoiseRole(role) {
+    return role !== null && NAVIGATION_ROLES.has(role);
+}
+function matchesPromoIdOrClass(className, id) {
+    const combined = `${className} ${id}`.toLowerCase();
+    return PROMO_PATTERN.test(combined);
+}
+function matchesHighZIsolate(className) {
+    return HIGH_Z_PATTERN.test(className) && ISOLATE_PATTERN.test(className);
+}
+function matchesFixedOrHighZIsolate(className) {
+    return FIXED_PATTERN.test(className) || matchesHighZIsolate(className);
+}
+function readElementMetadata(element) {
+    return {
+        tagName: element.tagName.toLowerCase(),
+        className: element.getAttribute('class') ?? '',
+        id: element.getAttribute('id') ?? '',
+        role: element.getAttribute('role'),
+        isHidden: isElementHidden(element),
+    };
+}
+function isNoiseElement(node) {
+    const metadata = readElementMetadata(node);
+    return (isStructuralNoiseTag(metadata.tagName) ||
+        metadata.isHidden ||
+        hasNoiseRole(metadata.role) ||
+        matchesFixedOrHighZIsolate(metadata.className) ||
+        matchesPromoIdOrClass(metadata.className, metadata.id));
+}
+function isNoiseNode(node) {
+    return isElement(node) && isNoiseElement(node);
+}
+export function addNoiseRule(instance) {
+    instance.addRule('removeNoise', {
+        filter: (node) => isNoiseNode(node),
+        replacement: () => '',
+    });
+}

package/dist/transformers/markdown/turndown-instance.d.ts

@@ -0,0 +1,2 @@
+import TurndownService from 'turndown';
+export declare function getTurndown(): TurndownService;

package/dist/transformers/markdown/turndown-instance.js

@@ -0,0 +1,19 @@
+import TurndownService from 'turndown';
+import { addFencedCodeRule } from './fenced-code-rule.js';
+import { addNoiseRule } from './noise-rule.js';
+let turndownInstance = null;
+function createTurndownInstance() {
+    const instance = new TurndownService({
+        headingStyle: 'atx',
+        codeBlockStyle: 'fenced',
+        emDelimiter: '_',
+        bulletListMarker: '-',
+    });
+    addNoiseRule(instance);
+    addFencedCodeRule(instance);
+    return instance;
+}
+export function getTurndown() {
+    turndownInstance ??= createTurndownInstance();
+    return turndownInstance;
+}

package/dist/transformers/markdown.d.ts

@@ -0,0 +1,2 @@
+import type { MetadataBlock } from '../config/types/content.js';
+export declare function htmlToMarkdown(html: string, metadata?: MetadataBlock): string;

package/dist/transformers/markdown.js

@@ -0,0 +1,185 @@
+import TurndownService from 'turndown';
+import { CODE_BLOCK, FRONTMATTER_DELIMITER, joinLines, } from '../config/formatting.js';
+import { detectLanguageFromCode, resolveLanguageFromAttributes, } from '../utils/code-language.js';
+import { isRecord } from '../utils/guards.js';
+const YAML_SPECIAL_CHARS = /[:[\]{}"\r\t'|>&*!?,#]|\n/;
+const YAML_NUMERIC = /^[\d.]+$/;
+const YAML_RESERVED_WORDS = /^(true|false|null|yes|no|on|off)$/i;
+const ESCAPE_PATTERNS = {
+    backslash: /\\/g,
+    quote: /"/g,
+    newline: /\n/g,
+    tab: /\t/g,
+};
+const YAML_QUOTE_CHECKS = [
+    (input) => YAML_SPECIAL_CHARS.test(input),
+    (input) => input.startsWith(' ') || input.endsWith(' '),
+    (input) => input === '',
+    (input) => YAML_NUMERIC.test(input),
+    (input) => YAML_RESERVED_WORDS.test(input),
+];
+function needsYamlQuotes(value) {
+    return YAML_QUOTE_CHECKS.some((check) => check(value));
+}
+function escapeYamlValue(value) {
+    if (!needsYamlQuotes(value)) {
+        return value;
+    }
+    const escaped = value
+        .replace(ESCAPE_PATTERNS.backslash, '\\\\')
+        .replace(ESCAPE_PATTERNS.quote, '\\"')
+        .replace(ESCAPE_PATTERNS.newline, '\\n')
+        .replace(ESCAPE_PATTERNS.tab, '\\t');
+    return `"${escaped}"`;
+}
+function appendFrontmatterField(lines, key, value) {
+    if (!value)
+        return;
+    lines.push(`${key}: ${escapeYamlValue(value)}`);
+}
+function buildFrontmatter(metadata) {
+    if (!metadata)
+        return '';
+    const lines = [FRONTMATTER_DELIMITER];
+    appendFrontmatterField(lines, 'title', metadata.title);
+    appendFrontmatterField(lines, 'source', metadata.url);
+    lines.push(FRONTMATTER_DELIMITER);
+    return joinLines(lines);
+}
+function isElement(node) {
+    return (isRecord(node) &&
+        'getAttribute' in node &&
+        typeof node.getAttribute === 'function');
+}
+function isFencedCodeBlock(node, options) {
+    return (options.codeBlockStyle === 'fenced' &&
+        node.nodeName === 'PRE' &&
+        node.firstChild?.nodeName === 'CODE');
+}
+function formatFencedCodeBlock(node) {
+    const codeNode = node.firstChild;
+    if (!isElement(codeNode))
+        return '';
+    const code = codeNode.textContent || '';
+    const language = resolveCodeLanguage(codeNode, code);
+    return CODE_BLOCK.format(code, language);
+}
+function resolveCodeLanguage(codeNode, code) {
+    const { className, dataLanguage } = readCodeAttributes(codeNode);
+    const attributeLanguage = resolveLanguageFromAttributes(className, dataLanguage);
+    return attributeLanguage ?? detectLanguageFromCode(code) ?? '';
+}
+function readCodeAttributes(codeNode) {
+    return {
+        className: codeNode.getAttribute('class') ?? '',
+        dataLanguage: codeNode.getAttribute('data-language') ?? '',
+    };
+}
+function addFencedCodeRule(instance) {
+    instance.addRule('fencedCodeBlockWithLanguage', {
+        filter: (node, options) => isFencedCodeBlock(node, options),
+        replacement: (_content, node) => formatFencedCodeBlock(node),
+    });
+}
+const STRUCTURAL_TAGS = new Set([
+    'script',
+    'style',
+    'noscript',
+    'iframe',
+    'nav',
+    'footer',
+    'aside',
+    'header',
+    'form',
+    'button',
+    'input',
+    'select',
+    'textarea',
+]);
+const NAVIGATION_ROLES = new Set([
+    'navigation',
+    'banner',
+    'complementary',
+    'contentinfo',
+    'tree',
+    'menubar',
+    'menu',
+]);
+const PROMO_PATTERN = /banner|promo|announcement|cta|callout|advert|newsletter|subscribe|cookie|consent|popup|modal|overlay|toast/;
+const FIXED_PATTERN = /\b(fixed|sticky)\b/;
+const HIGH_Z_PATTERN = /\bz-(?:4\d|50)\b/;
+const ISOLATE_PATTERN = /\bisolate\b/;
+function isStructuralNoiseTag(tagName) {
+    return (STRUCTURAL_TAGS.has(tagName) || tagName === 'svg' || tagName === 'canvas');
+}
+function isElementHidden(element) {
+    return (element.getAttribute('hidden') !== null ||
+        element.getAttribute('aria-hidden') === 'true');
+}
+function hasNoiseRole(role) {
+    return role !== null && NAVIGATION_ROLES.has(role);
+}
+function matchesPromoIdOrClass(className, id) {
+    const combined = `${className} ${id}`.toLowerCase();
+    return PROMO_PATTERN.test(combined);
+}
+function matchesHighZIsolate(className) {
+    return HIGH_Z_PATTERN.test(className) && ISOLATE_PATTERN.test(className);
+}
+function matchesFixedOrHighZIsolate(className) {
+    return FIXED_PATTERN.test(className) || matchesHighZIsolate(className);
+}
+function readElementMetadata(element) {
+    return {
+        tagName: element.tagName.toLowerCase(),
+        className: element.getAttribute('class') ?? '',
+        id: element.getAttribute('id') ?? '',
+        role: element.getAttribute('role'),
+        isHidden: isElementHidden(element),
+    };
+}
+function isNoiseElement(node) {
+    const metadata = readElementMetadata(node);
+    return (isStructuralNoiseTag(metadata.tagName) ||
+        metadata.isHidden ||
+        hasNoiseRole(metadata.role) ||
+        matchesFixedOrHighZIsolate(metadata.className) ||
+        matchesPromoIdOrClass(metadata.className, metadata.id));
+}
+function isNoiseNode(node) {
+    return isElement(node) && isNoiseElement(node);
+}
+function addNoiseRule(instance) {
+    instance.addRule('removeNoise', {
+        filter: (node) => isNoiseNode(node),
+        replacement: () => '',
+    });
+}
+let turndownInstance = null;
+function createTurndownInstance() {
+    const instance = new TurndownService({
+        headingStyle: 'atx',
+        codeBlockStyle: 'fenced',
+        emDelimiter: '_',
+        bulletListMarker: '-',
+    });
+    addNoiseRule(instance);
+    addFencedCodeRule(instance);
+    return instance;
+}
+function getTurndown() {
+    turndownInstance ??= createTurndownInstance();
+    return turndownInstance;
+}
+export function htmlToMarkdown(html, metadata) {
+    const frontmatter = buildFrontmatter(metadata);
+    if (!html)
+        return frontmatter;
+    try {
+        const content = getTurndown().turndown(html).trim();
+        return frontmatter ? `${frontmatter}\n${content}` : content;
+    }
+    catch {
+        return frontmatter;
+    }
+}

package/dist/transformers/markdown.transformer.js

@@ -1,126 +1,14 @@
-import TurndownService from 'turndown';
-import { CODE_BLOCK, FRONTMATTER_DELIMITER, joinLines, } from '../config/formatting.js';
-import { detectLanguageFromCode, resolveLanguageFromAttributes, } from '../utils/code-language.js';
-let turndownInstance = null;
-function getTurndown() {
-    if (turndownInstance)
-        return turndownInstance;
-    turndownInstance = createTurndownInstance();
-    return turndownInstance;
-}
-function createTurndownInstance() {
-    const instance = new TurndownService({
-        headingStyle: 'atx',
-        codeBlockStyle: 'fenced',
-        emDelimiter: '_',
-        bulletListMarker: '-',
-    });
-    addNoiseRule(instance);
-    addFencedCodeRule(instance);
-    return instance;
-}
-function addNoiseRule(instance) {
-    instance.addRule('removeNoise', {
-        filter: ['script', 'style', 'noscript', 'nav', 'footer', 'aside', 'iframe'],
-        replacement: () => '',
-    });
-}
-function addFencedCodeRule(instance) {
-    instance.addRule('fencedCodeBlockWithLanguage', {
-        filter: (node, options) => isFencedCodeBlock(node, options),
-        replacement: (_content, node) => formatFencedCodeBlock(node),
-    });
-}
-function isFencedCodeBlock(node, options) {
-    if (options.codeBlockStyle !== 'fenced')
-        return false;
-    if (node.nodeName !== 'PRE')
-        return false;
-    const { firstChild } = node;
-    if (!firstChild)
-        return false;
-    return firstChild.nodeName === 'CODE';
-}
-function isElement(node) {
-    return (node !== null &&
-        typeof node === 'object' &&
-        'getAttribute' in node &&
-        typeof node.getAttribute === 'function');
-}
-function formatFencedCodeBlock(node) {
-    const codeNode = node.firstChild;
-    if (!isElement(codeNode))
-        return '';
-    const code = codeNode.textContent || '';
-    const language = resolveCodeLanguage(codeNode, code);
-    return CODE_BLOCK.format(code, language);
-}
-function resolveCodeLanguage(codeNode, code) {
-    const className = codeNode.getAttribute('class') ?? '';
-    const dataLang = codeNode.getAttribute('data-language') ?? '';
-    const attributeLanguage = resolveLanguageFromAttributes(className, dataLang);
-    return attributeLanguage ?? detectLanguageFromCode(code) ?? '';
-}
-const YAML_SPECIAL_CHARS = /[:[\]{}"\r\t'|>&*!?,#]|\n/;
-const YAML_NUMERIC = /^[\d.]+$/;
-const YAML_RESERVED_WORDS = /^(true|false|null|yes|no|on|off)$/i;
-const ESCAPE_PATTERNS = {
-    backslash: /\\/g,
-    quote: /"/g,
-    newline: /\n/g,
-    tab: /\t/g,
-};
-function needsYamlQuotes(value) {
-    const checks = [
-        (input) => YAML_SPECIAL_CHARS.test(input),
-        (input) => input.startsWith(' ') || input.endsWith(' '),
-        (input) => input === '',
-        (input) => YAML_NUMERIC.test(input),
-        (input) => YAML_RESERVED_WORDS.test(input),
-    ];
-    return checks.some((check) => check(value));
-}
-function escapeYamlValue(value) {
-    if (!needsYamlQuotes(value)) {
-        return value;
-    }
-    const escaped = value
-        .replace(ESCAPE_PATTERNS.backslash, '\\\\')
-        .replace(ESCAPE_PATTERNS.quote, '\\"')
-        .replace(ESCAPE_PATTERNS.newline, '\\n')
-        .replace(ESCAPE_PATTERNS.tab, '\\t');
-    return `"${escaped}"`;
-}
-function createFrontmatter(metadata) {
-    const lines = [FRONTMATTER_DELIMITER];
-    if (metadata.title) {
-        lines.push(`title: ${escapeYamlValue(metadata.title)}`);
-    }
-    if (metadata.url) {
-        lines.push(`source: ${escapeYamlValue(metadata.url)}`);
-    }
-    lines.push(FRONTMATTER_DELIMITER);
-    return joinLines(lines);
-}
-function convertHtmlToMarkdown(html) {
-    return getTurndown().turndown(html).trim();
-}
-function buildFrontmatterBlock(metadata) {
-    return metadata ? createFrontmatter(metadata) : '';
-}
+import { buildFrontmatter } from './markdown/frontmatter.js';
+import { getTurndown } from './markdown/turndown-instance.js';
 export function htmlToMarkdown(html, metadata) {
-    const frontmatter = buildFrontmatterBlock(metadata);
-    if (!isValidHtmlInput(html)) {
+    const frontmatter = buildFrontmatter(metadata);
+    if (!html)
         return frontmatter;
-    }
     try {
-        const content = convertHtmlToMarkdown(html);
+        const content = getTurndown().turndown(html).trim();
         return frontmatter ? `${frontmatter}\n${content}` : content;
     }
     catch {
         return frontmatter;
     }
 }
-function isValidHtmlInput(html) {
-    return Boolean(html && typeof html === 'string');
-}

package/dist/utils/cached-payload.d.ts

@@ -0,0 +1,7 @@
+export interface CachedPayload {
+    content?: string;
+    markdown?: string;
+    title?: string;
+}
+export declare function parseCachedPayload(raw: string): CachedPayload | null;
+export declare function resolveCachedPayloadContent(payload: CachedPayload): string | null;

package/dist/utils/cached-payload.js

@@ -0,0 +1,36 @@
+import { isRecord } from './guards.js';
+export function parseCachedPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return isCachedPayload(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveCachedPayloadContent(payload) {
+    if (typeof payload.markdown === 'string') {
+        return payload.markdown;
+    }
+    if (typeof payload.content === 'string') {
+        return payload.content;
+    }
+    return null;
+}
+function hasOptionalStringProperty(value, key) {
+    const prop = value[key];
+    if (prop === undefined)
+        return true;
+    return typeof prop === 'string';
+}
+function isCachedPayload(value) {
+    if (!isRecord(value))
+        return false;
+    if (!hasOptionalStringProperty(value, 'content'))
+        return false;
+    if (!hasOptionalStringProperty(value, 'markdown'))
+        return false;
+    if (!hasOptionalStringProperty(value, 'title'))
+        return false;
+    return true;
+}

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

@@ -0,0 +1 @@
+export declare function detectBash(code: string): boolean;

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

@@ -0,0 +1,48 @@
+import { splitLines } from './code-language-parsing.js';
+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'];
+export 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} `));
+    });
+}

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

@@ -0,0 +1,2 @@
+export declare function detectLanguageFromCode(code: string): string | undefined;
+export declare function resolveLanguageFromAttributes(className: string, dataLang: string): string | undefined;

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

@@ -0,0 +1,13 @@
+import { CODE_DETECTORS } from './code-language-detectors.js';
+import { extractLanguageFromClassName, resolveLanguageFromDataAttribute, } from './code-language-parsing.js';
+export function detectLanguageFromCode(code) {
+    for (const { language, detect } of CODE_DETECTORS) {
+        if (detect(code))
+            return language;
+    }
+    return undefined;
+}
+export function resolveLanguageFromAttributes(className, dataLang) {
+    const classMatch = extractLanguageFromClassName(className);
+    return classMatch ?? resolveLanguageFromDataAttribute(dataLang);
+}

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

@@ -0,0 +1,5 @@
+export interface CodeDetector {
+    language: string;
+    detect: (code: string) => boolean;
+}
+export declare const CODE_DETECTORS: readonly CodeDetector[];

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

@@ -0,0 +1,142 @@
+import { detectBash } from './code-language-bash.js';
+import { containsJsxTag, containsWord, splitLines, } from './code-language-parsing.js';
+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 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/;
+export 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(';');
+}