@j0hanz/superfetch 2.0.0 → 2.0.1

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,187 +1,5 @@
-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';
-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;
-}
-function isElement(node) {
-    if (!isRecord(node))
-        return false;
-    return 'getAttribute' in node && typeof node.getAttribute === 'function';
-}
-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[0-9]|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 ? NAVIGATION_ROLES.has(role) : false;
-}
-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) {
-    if (FIXED_PATTERN.test(className))
-        return true;
-    return matchesHighZIsolate(className);
-}
-function addNoiseRule(instance) {
-    instance.addRule('removeNoise', {
-        filter: (node) => isNoiseNode(node),
-        replacement: () => '',
-    });
-}
-function isNoiseNode(node) {
-    if (!isElement(node))
-        return false;
-    return isNoiseElement(node);
-}
-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);
-    if (isStructuralNoiseTag(metadata.tagName))
-        return true;
-    if (metadata.isHidden)
-        return true;
-    if (hasNoiseRole(metadata.role))
-        return true;
-    if (matchesFixedOrHighZIsolate(metadata.className))
-        return true;
-    return matchesPromoIdOrClass(metadata.className, metadata.id);
-}
-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 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') ?? '',
-    };
-}
-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 appendFrontmatterField(lines, key, value) {
-    if (!value)
-        return;
-    lines.push(`${key}: ${escapeYamlValue(value)}`);
-}
-function createFrontmatter(metadata) {
-    const lines = [FRONTMATTER_DELIMITER];
-    appendFrontmatterField(lines, 'title', metadata.title);
-    appendFrontmatterField(lines, 'source', metadata.url);
-    lines.push(FRONTMATTER_DELIMITER);
-    return joinLines(lines);
-}
+import { buildFrontmatter } from './markdown/frontmatter.js';
+import { getTurndown } from './markdown/turndown-instance.js';
 export function htmlToMarkdown(html, metadata) {
     const frontmatter = buildFrontmatter(metadata);
     if (!html)
@@ -194,8 +12,3 @@ export function htmlToMarkdown(html, metadata) {
         return frontmatter;
     }
 }
-function buildFrontmatter(metadata) {
-    if (!metadata)
-        return '';
-    return createFrontmatter(metadata);
-}

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(';');
+}

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;