fractalpop 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,108 @@
+import * as __core_js from './core.js';
+import { ParseOptions } from './core.js';
+
+/** Mutable registry that maps a canonical language id to its parse config. */
+
+declare function getLanguageConfig(id: string): ParseOptions | undefined;
+declare function resetLanguageConfigRegistry(): void;
+
+/** Mutable language metadata registry with alias/extension normalization. */
+
+interface Language {
+    id: string;
+    extension: string;
+    aliases: readonly string[];
+}
+declare function registerLanguage(language: Language, config?: ParseOptions): void;
+declare function setDefaults(languages: readonly Language[]): void;
+declare function setDefaults(configs: Record<string, ParseOptions>): void;
+declare function importDefaults(ids: string[]): Promise<void>;
+/** Find canonical language metadata by name, alias, or extension. */
+declare function findLanguage(name: string): Language | undefined;
+/** Resolve a name/alias/extension to its canonical language id. */
+declare function lang(name: string): string | undefined;
+/** Alias for {@link lang}. */
+declare const canonicalizeLang: typeof lang;
+declare function getRegisteredLanguages(): readonly Language[];
+declare function resetLanguageRegistry(): void;
+
+declare const allLanguages: readonly Language[];
+
+/**
+ * fractalpop core — token model, line assembly, and rendering.
+ *
+ * Design: tokens are numeric `[type, value]` pairs during lexing (fast Set/array
+ * work); the string type names are resolved only at render. Output is an HTML
+ * string with no DOM required — so SSR and client produce identical markup.
+ */
+/** The stable, ordered token-type list. This list is the theming contract:
+ * each type maps to one CSS variable `--fp-<type>` and one class `fp__token--<type>`. */
+declare const TokenTypes: readonly ["identifier", "keyword", "string", "class", "property", "entity", "jsxliterals", "sign", "comment", "break", "space"];
+type TokenType = (typeof TokenTypes)[number];
+interface ParsedToken {
+    type: TokenType;
+    value: string;
+}
+/** Mutable token handed to `mark`. Hooks may change className/style/properties. */
+interface MarkToken {
+    type: TokenType;
+    value: string;
+    className: string;
+    style: Record<string, string | number>;
+    properties: Record<string, string | number | boolean>;
+}
+/** Mutable line handed to `markLine`. Hooks may change className/style/properties. */
+interface MarkLine {
+    index: number;
+    value: string;
+    tokens: ParsedToken[];
+    annotations: string[];
+    className: string;
+    style: Record<string, string | number>;
+    properties: Record<string, string | number | boolean>;
+}
+interface DisplayOptions {
+    /** Extra class name appended per token type, e.g. `{ keyword: 'font-bold' }`. */
+    cx?: Partial<Record<TokenType, string>>;
+    /** Mutate a single token before it renders. */
+    mark?: (token: MarkToken) => void;
+    /** Mutate a whole line before it renders (used for line highlighting). */
+    markLine?: (line: MarkLine) => void;
+}
+
+/** Highlight range: either a single 1-based line or an inclusive [start, end] pair. */
+type HighlightRange = number | [number, number];
+/**
+ * Parse `{1,3-5,7}` fence metadata into a Set of 1-based line numbers.
+ *
+ * Tolerates whitespace (`{ 1 , 3 - 5 }`) and silently ignores invalid or
+ * negative numbers.
+ */
+declare function parseHighlightMeta(meta?: string | null): Set<number>;
+/**
+ * Convert `{1,3-5,7}` fence metadata into remark-compatible highlight ranges.
+ *
+ * Returns single numbers for individual lines and `[start, end]` tuples for
+ * explicit ranges. Invalid/negative numbers are ignored.
+ */
+declare function toHighlightRanges(meta?: string | null): HighlightRange[];
+/** Escape characters Svelte's compiler would otherwise interpret in markup. */
+declare function escapeSvelte(html: string): string;
+
+interface HighlightOptions extends DisplayOptions {
+    /** Language id, extension, or alias. Defaults to 'typescript'. */
+    lang?: string;
+    /** Explicit parse config that overrides the registry. */
+    config?: __core_js.ParseOptions;
+}
+interface LanguagePair {
+    language: Language;
+    config: __core_js.ParseOptions;
+}
+/** Register multiple languages with their parse configs. */
+declare function registerLanguages(languages: readonly LanguagePair[]): void;
+/** Highlight `code` to an HTML string. No DOM required. */
+declare function highlight(code: string, options?: HighlightOptions): string;
+
+export { allLanguages, canonicalizeLang, escapeSvelte, findLanguage, getLanguageConfig, getRegisteredLanguages, highlight, importDefaults, lang, parseHighlightMeta, registerLanguage, registerLanguages, resetLanguageConfigRegistry, resetLanguageRegistry, setDefaults, toHighlightRanges };
+export type { DisplayOptions, HighlightOptions, HighlightRange, LanguagePair, MarkLine, MarkToken, HighlightOptions as Options, TokenType };

package/dist/index.js

@@ -0,0 +1,523 @@
+import { parse } from './core.js';
+import { config as config$1 } from './lang/typescript.js';
+import { config } from './lang/plaintext.js';
+
+/**
+ * fractalpop core — token model, line assembly, and rendering.
+ *
+ * Design: tokens are numeric `[type, value]` pairs during lexing (fast Set/array
+ * work); the string type names are resolved only at render. Output is an HTML
+ * string with no DOM required — so SSR and client produce identical markup.
+ */ /** The stable, ordered token-type list. This list is the theming contract:
+ * each type maps to one CSS variable `--fp-<type>` and one class `fp__token--<type>`. */ const TokenTypes = [
+    'identifier',
+    'keyword',
+    'string',
+    'class',
+    'property',
+    'entity',
+    'jsxliterals',
+    'sign',
+    'comment',
+    'break',
+    'space'
+];
+({
+    TokenMap: new Map(TokenTypes.map((type, index)=>[
+            type,
+            index
+        ]))
+});
+function lineClassName(annotations) {
+    return `fp__line${annotations.map((annotation)=>` fp__line--${annotation}`).join('')}`;
+}
+function createLine(parsedLine, markLine) {
+    const line = {
+        index: parsedLine.index,
+        value: parsedLine.value,
+        tokens: parsedLine.tokens,
+        annotations: parsedLine.annotations,
+        className: lineClassName(parsedLine.annotations),
+        style: {},
+        properties: {}
+    };
+    markLine?.(line);
+    return line;
+}
+function createToken({ type, value }, cx, mark) {
+    const extraClassName = cx?.[type];
+    const token = {
+        type,
+        value,
+        className: `fp__token--${type}${extraClassName ? ` ${extraClassName}` : ''}`,
+        style: {
+            color: `var(--fp-${type})`
+        },
+        properties: {}
+    };
+    mark?.(token);
+    return token;
+}
+/** Render parsed lines to an HTML string. Fast path when no display hooks are set. */ function render(parsed, options) {
+    const cx = options?.cx;
+    const mark = options?.mark;
+    const markLine = options?.markLine;
+    // Fast path: no per-token object allocation, straight string concat.
+    if (!cx && !mark && !markLine) {
+        return parsed.lines.map((line)=>{
+            const className = lineClassName(line.annotations);
+            const children = line.tokens.map(({ type, value })=>`<span class="fp__token--${type}" style="color:var(--fp-${type})">${encode(value)}</span>`).join('');
+            return `<span class="${encode(className)}">${children}</span>`;
+        }).join('\n');
+    }
+    // Hook path: build mutable objects and run cx/mark/markLine.
+    return parsed.lines.map((parsedLine)=>{
+        const line = createLine(parsedLine, markLine);
+        const children = parsedLine.tokens.map((parsedToken)=>{
+            const token = createToken(parsedToken, cx, mark);
+            return `<span ${attributes({
+                ...token.properties,
+                className: token.className,
+                style: token.style
+            })}>${encode(token.value)}</span>`;
+        }).join('');
+        return `<span ${attributes({
+            ...line.properties,
+            className: line.className,
+            style: line.style
+        })}>${children}</span>`;
+    }).join('\n');
+}
+const entities = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#039;'
+};
+const encode = (value)=>value.replace(/[&<>"']/g, (character)=>entities[character]);
+function attributes(values) {
+    const styleValue = values.style ?? {};
+    const style = Object.entries(styleValue).map(([key, value])=>`${key.replace(/[A-Z]/g, (match)=>`-${match.toLowerCase()}`)}:${value}`).join(';');
+    const properties = Object.entries(values).filter(([key, value])=>/^[\w:-]+$/.test(key) && key !== 'className' && key !== 'style' && value !== false && value != null).map(([key, value])=>value === true ? key : `${key}="${encode(String(value))}"`).join(' ');
+    const className = values.className || '';
+    return `class="${encode(className)}"${style ? ` style="${encode(style)}"` : ''}${properties ? ` ${properties}` : ''}`;
+}
+
+/** Mutable registry that maps a canonical language id to its parse config. */ const configRegistry = new Map();
+function registerLanguageConfig(id, config) {
+    configRegistry.set(id, config);
+}
+function getLanguageConfig(id) {
+    return configRegistry.get(id);
+}
+function resetLanguageConfigRegistry() {
+    configRegistry.clear();
+}
+
+const languageRegistry = new Map();
+function normalizeLanguageName(value) {
+    return value.trim().toLowerCase().replace(/^\./, '');
+}
+function registerName(name, language) {
+    const normalized = normalizeLanguageName(name);
+    if (!normalized) return;
+    const existing = languageRegistry.get(normalized);
+    if (existing && existing.id !== language.id) {
+        throw new Error(`Language name "${normalized}" is shared by "${existing.id}" and "${language.id}"`);
+    }
+    languageRegistry.set(normalized, language);
+}
+function registerLanguage(language, config) {
+    const names = new Set([
+        language.id,
+        language.extension,
+        ...language.aliases
+    ]);
+    for (const name of names){
+        registerName(name, language);
+    }
+    if (config) {
+        registerLanguageConfig(language.id, config);
+    }
+}
+function setDefaults(input) {
+    resetLanguageRegistry();
+    resetLanguageConfigRegistry();
+    if (Array.isArray(input)) {
+        for (const language of input){
+            registerLanguage(language);
+        }
+    } else {
+        for (const [id, config] of Object.entries(input)){
+            const language = allLanguages.find((l)=>l.id === id);
+            if (language) {
+                registerLanguage(language, config);
+            } else {
+                registerLanguage({
+                    id,
+                    extension: id,
+                    aliases: []
+                }, config);
+            }
+        }
+    }
+}
+const configImporters = {
+    javascript: ()=>import('./lang/javascript.js'),
+    typescript: ()=>import('./lang/typescript.js'),
+    css: ()=>import('./lang/css.js'),
+    scss: ()=>import('./lang/scss.js'),
+    sass: ()=>import('./lang/sass.js'),
+    html: ()=>import('./lang/html.js'),
+    svelte: ()=>import('./lang/svelte.js'),
+    markdown: ()=>import('./lang/markdown.js'),
+    diff: ()=>import('./lang/diff.js'),
+    plaintext: ()=>import('./lang/plaintext.js'),
+    c: ()=>import('./lang/c.js'),
+    cpp: ()=>import('./lang/cpp.js'),
+    csharp: ()=>import('./lang/csharp.js'),
+    dockerfile: ()=>import('./lang/dockerfile.js'),
+    go: ()=>import('./lang/go.js'),
+    graphql: ()=>import('./lang/graphql.js'),
+    hcl: ()=>import('./lang/hcl.js'),
+    java: ()=>import('./lang/java.js'),
+    json: ()=>import('./lang/json.js'),
+    kotlin: ()=>import('./lang/kotlin.js'),
+    lua: ()=>import('./lang/lua.js'),
+    php: ()=>import('./lang/php.js'),
+    powershell: ()=>import('./lang/powershell.js'),
+    python: ()=>import('./lang/python.js'),
+    ruby: ()=>import('./lang/ruby.js'),
+    rust: ()=>import('./lang/rust.js'),
+    shell: ()=>import('./lang/shell.js'),
+    sql: ()=>import('./lang/sql.js'),
+    swift: ()=>import('./lang/swift.js'),
+    toml: ()=>import('./lang/toml.js'),
+    yaml: ()=>import('./lang/yaml.js'),
+    zig: ()=>import('./lang/zig.js')
+};
+async function importDefaults(ids) {
+    await Promise.all(ids.map(async (id)=>{
+        const importer = configImporters[id];
+        if (!importer) return;
+        const { config } = await importer();
+        const language = allLanguages.find((l)=>l.id === id);
+        if (language) {
+            registerLanguage(language, config);
+        } else {
+            registerLanguage({
+                id,
+                extension: id,
+                aliases: []
+            }, config);
+        }
+    }));
+}
+/** Find canonical language metadata by name, alias, or extension. */ function findLanguage(name) {
+    if (typeof name !== 'string') return undefined;
+    return languageRegistry.get(normalizeLanguageName(name));
+}
+/** Resolve a name/alias/extension to its canonical language id. */ function lang(name) {
+    return findLanguage(name)?.id;
+}
+/** Alias for {@link lang}. */ const canonicalizeLang = lang;
+function getRegisteredLanguages() {
+    return [
+        ...new Set(languageRegistry.values())
+    ];
+}
+function resetLanguageRegistry() {
+    languageRegistry.clear();
+}
+const allLanguages = [
+    {
+        id: 'javascript',
+        extension: 'js',
+        aliases: [
+            'jsx',
+            'node'
+        ]
+    },
+    {
+        id: 'typescript',
+        extension: 'ts',
+        aliases: [
+            'tsx'
+        ]
+    },
+    {
+        id: 'css',
+        extension: 'css',
+        aliases: []
+    },
+    {
+        id: 'scss',
+        extension: 'scss',
+        aliases: []
+    },
+    {
+        id: 'sass',
+        extension: 'sass',
+        aliases: [
+            'indented-sass'
+        ]
+    },
+    {
+        id: 'html',
+        extension: 'html',
+        aliases: [
+            'htm',
+            'xml'
+        ]
+    },
+    {
+        id: 'svelte',
+        extension: 'svelte',
+        aliases: []
+    },
+    {
+        id: 'markdown',
+        extension: 'md',
+        aliases: [
+            'md',
+            'mdx',
+            'svx'
+        ]
+    },
+    {
+        id: 'diff',
+        extension: 'diff',
+        aliases: [
+            'patch'
+        ]
+    },
+    {
+        id: 'plaintext',
+        extension: 'txt',
+        aliases: [
+            'text',
+            'plain'
+        ]
+    },
+    {
+        id: 'c',
+        extension: 'c',
+        aliases: []
+    },
+    {
+        id: 'cpp',
+        extension: 'cpp',
+        aliases: [
+            'c++',
+            'cc',
+            'cxx'
+        ]
+    },
+    {
+        id: 'csharp',
+        extension: 'cs',
+        aliases: [
+            'c#',
+            'dotnet'
+        ]
+    },
+    {
+        id: 'dockerfile',
+        extension: 'dockerfile',
+        aliases: [
+            'docker'
+        ]
+    },
+    {
+        id: 'go',
+        extension: 'go',
+        aliases: [
+            'golang'
+        ]
+    },
+    {
+        id: 'graphql',
+        extension: 'graphql',
+        aliases: [
+            'gql'
+        ]
+    },
+    {
+        id: 'hcl',
+        extension: 'hcl',
+        aliases: [
+            'terraform',
+            'tf'
+        ]
+    },
+    {
+        id: 'java',
+        extension: 'java',
+        aliases: []
+    },
+    {
+        id: 'json',
+        extension: 'json',
+        aliases: [
+            'jsonc'
+        ]
+    },
+    {
+        id: 'kotlin',
+        extension: 'kt',
+        aliases: [
+            'kts'
+        ]
+    },
+    {
+        id: 'lua',
+        extension: 'lua',
+        aliases: []
+    },
+    {
+        id: 'php',
+        extension: 'php',
+        aliases: []
+    },
+    {
+        id: 'powershell',
+        extension: 'ps1',
+        aliases: [
+            'pwsh'
+        ]
+    },
+    {
+        id: 'python',
+        extension: 'py',
+        aliases: [
+            'python3'
+        ]
+    },
+    {
+        id: 'ruby',
+        extension: 'rb',
+        aliases: []
+    },
+    {
+        id: 'rust',
+        extension: 'rs',
+        aliases: []
+    },
+    {
+        id: 'shell',
+        extension: 'sh',
+        aliases: [
+            'bash',
+            'zsh'
+        ]
+    },
+    {
+        id: 'sql',
+        extension: 'sql',
+        aliases: []
+    },
+    {
+        id: 'swift',
+        extension: 'swift',
+        aliases: []
+    },
+    {
+        id: 'toml',
+        extension: 'toml',
+        aliases: []
+    },
+    {
+        id: 'yaml',
+        extension: 'yaml',
+        aliases: [
+            'yml'
+        ]
+    },
+    {
+        id: 'zig',
+        extension: 'zig',
+        aliases: []
+    }
+];
+setDefaults({
+    typescript: config$1,
+    plaintext: config
+});
+
+/** Highlight range: either a single 1-based line or an inclusive [start, end] pair. */ function parseMetaParts(meta) {
+    const match = meta?.match(/\{([^}]*)\}/);
+    return match ? match[1].split(',') : undefined;
+}
+/**
+ * Parse `{1,3-5,7}` fence metadata into a Set of 1-based line numbers.
+ *
+ * Tolerates whitespace (`{ 1 , 3 - 5 }`) and silently ignores invalid or
+ * negative numbers.
+ */ function parseHighlightMeta(meta) {
+    const lines = new Set();
+    const parts = parseMetaParts(meta);
+    if (!parts) return lines;
+    for (const part of parts){
+        const range = part.trim();
+        if (!range) continue;
+        if (range.includes('-')) {
+            const [start, end] = range.split('-').map((n)=>Number(n.trim()));
+            if (Number.isFinite(start) && Number.isFinite(end) && start > 0 && end >= start) {
+                for(let i = start; i <= end; i++)lines.add(i);
+            }
+        } else {
+            const n = Number(range);
+            if (Number.isFinite(n) && n > 0) lines.add(n);
+        }
+    }
+    return lines;
+}
+/**
+ * Convert `{1,3-5,7}` fence metadata into remark-compatible highlight ranges.
+ *
+ * Returns single numbers for individual lines and `[start, end]` tuples for
+ * explicit ranges. Invalid/negative numbers are ignored.
+ */ function toHighlightRanges(meta) {
+    const out = [];
+    const parts = parseMetaParts(meta);
+    if (!parts) return out;
+    for (const part of parts){
+        const range = part.trim();
+        if (!range) continue;
+        if (range.includes('-')) {
+            const [start, end] = range.split('-').map((n)=>Number(n.trim()));
+            if (Number.isFinite(start) && Number.isFinite(end) && start > 0 && end >= start) {
+                out.push([
+                    start,
+                    end
+                ]);
+            }
+        } else {
+            const n = Number(range);
+            if (Number.isFinite(n) && n > 0) out.push(n);
+        }
+    }
+    return out;
+}
+/** Escape characters Svelte's compiler would otherwise interpret in markup. */ function escapeSvelte(html) {
+    return html.replace(/\{/g, '&#123;').replace(/\}/g, '&#125;').replace(/`/g, '&#96;');
+}
+
+/** Register multiple languages with their parse configs. */ function registerLanguages(languages) {
+    for (const { language, config } of languages){
+        registerLanguage(language, config);
+    }
+}
+/** Highlight `code` to an HTML string. No DOM required. */ function highlight(code, options) {
+    const { lang, config, cx, mark, markLine } = options || {};
+    const resolvedConfig = config ?? (lang ? getLanguageConfig(canonicalizeLang(lang) ?? lang) : undefined) ?? getLanguageConfig('typescript') ?? {};
+    const parsed = parse(code, resolvedConfig);
+    return render(parsed, {
+        cx,
+        mark,
+        markLine
+    });
+}
+
+export { allLanguages, canonicalizeLang, escapeSvelte, findLanguage, getLanguageConfig, getRegisteredLanguages, highlight, importDefaults, lang, parseHighlightMeta, registerLanguage, registerLanguages, resetLanguageConfigRegistry, resetLanguageRegistry, setDefaults, toHighlightRanges };

package/dist/lang/c.d.ts

@@ -0,0 +1,5 @@
+import { ParseOptions } from '../core.js';
+
+declare const config: ParseOptions;
+
+export { config };