fractalpop 0.1.0

package/dist/full.js

@@ -0,0 +1,356 @@
+import { registerLanguages } from './index.js';
+export * from './index.js';
+import { config as config$1 } from './lang/typescript.js';
+import { config } from './lang/plaintext.js';
+import { config as config$v } from './lang/javascript.js';
+import { config as config$u } from './lang/css.js';
+import { config as config$t } from './lang/scss.js';
+import { config as config$s } from './lang/sass.js';
+import { config as config$r } from './lang/html.js';
+import { config as config$q } from './lang/svelte.js';
+import { config as config$p } from './lang/markdown.js';
+import { config as config$o } from './lang/diff.js';
+import { config as config$n } from './lang/c.js';
+import { config as config$m } from './lang/cpp.js';
+import { config as config$l } from './lang/csharp.js';
+import { config as config$k } from './lang/dockerfile.js';
+import { config as config$j } from './lang/go.js';
+import { config as config$i } from './lang/graphql.js';
+import { config as config$h } from './lang/hcl.js';
+import { config as config$g } from './lang/java.js';
+import { config as config$f } from './lang/json.js';
+import { config as config$e } from './lang/kotlin.js';
+import { config as config$d } from './lang/lua.js';
+import { config as config$c } from './lang/php.js';
+import { config as config$b } from './lang/powershell.js';
+import { config as config$a } from './lang/python.js';
+import { config as config$9 } from './lang/ruby.js';
+import { config as config$8 } from './lang/rust.js';
+import { config as config$7 } from './lang/shell.js';
+import { config as config$6 } from './lang/sql.js';
+import { config as config$5 } from './lang/swift.js';
+import { config as config$4 } from './lang/toml.js';
+import { config as config$3 } from './lang/yaml.js';
+import { config as config$2 } from './lang/zig.js';
+
+/** 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 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);
+            }
+        }
+    }
+}
+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
+});
+
+const configs = {
+    typescript: config$1,
+    javascript: config$v,
+    css: config$u,
+    scss: config$t,
+    sass: config$s,
+    html: config$r,
+    svelte: config$q,
+    markdown: config$p,
+    diff: config$o,
+    plaintext: config,
+    c: config$n,
+    cpp: config$m,
+    csharp: config$l,
+    dockerfile: config$k,
+    go: config$j,
+    graphql: config$i,
+    hcl: config$h,
+    java: config$g,
+    json: config$f,
+    kotlin: config$e,
+    lua: config$d,
+    php: config$c,
+    powershell: config$b,
+    python: config$a,
+    ruby: config$9,
+    rust: config$8,
+    shell: config$7,
+    sql: config$6,
+    swift: config$5,
+    toml: config$4,
+    yaml: config$3,
+    zig: config$2
+};
+
+const languages = allLanguages.map((language)=>{
+    const config = configs[language.id];
+    if (!config) {
+        throw new Error(`Missing parse config for language "${language.id}"`);
+    }
+    return {
+        language,
+        config
+    };
+});
+
+registerLanguages(languages);

package/dist/gpu.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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;
+}
+interface ParsedLine {
+    index: number;
+    value: string;
+    tokens: ParsedToken[];
+    annotations: string[];
+}
+interface ParsedCode {
+    value: string;
+    lines: ParsedLine[];
+}
+/** 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;
+}
+
+/** Parse `code` through the GPU lexer and assemble it into a `ParsedCode` shape. */
+declare function parse(code: string): Promise<ParsedCode>;
+/** Highlight `code` using the GPU lexer, returning an HTML string. */
+declare function highlight(code: string, options?: DisplayOptions): Promise<string>;
+
+export { highlight, parse };
+export type { DisplayOptions, ParsedCode };

package/dist/gpu.js

@@ -0,0 +1,215 @@
+import { parse as parse$1 } from 'gpu-lexer';
+
+/**
+ * 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'
+];
+// Numeric indices, used everywhere in the hot path.
+const T_IDENTIFIER = 0;
+const T_KEYWORD = 1;
+const T_STRING = 2;
+const T_CLASS = 3;
+const T_ENTITY = 5;
+const T_SIGN = 7;
+const T_COMMENT = 8;
+const T_BREAK = 9;
+({
+    TokenMap: new Map(TokenTypes.map((type, index)=>[
+            type,
+            index
+        ]))
+});
+/** Split a flat token stream into lines, handling embedded newlines. */ function assemble(value, tokens) {
+    const lines = [];
+    let lineIndex = 0;
+    const lineTokens = [];
+    let lastWasBreak = false;
+    function flushLine(tokens) {
+        lines.push({
+            index: lineIndex++,
+            value: tokens.map(([, tokenValue])=>tokenValue).join(''),
+            tokens: tokens.map(([type, tokenValue])=>({
+                    type: TokenTypes[type],
+                    value: tokenValue
+                })),
+            annotations: []
+        });
+    }
+    for(let index = 0; index < tokens.length; index++){
+        const token = tokens[index];
+        const [type, tokenValue] = token;
+        if (type !== T_BREAK) {
+            if (tokenValue.includes('\n')) {
+                const values = tokenValue.split('\n');
+                for(let part = 0; part < values.length; part++){
+                    lineTokens.push([
+                        type,
+                        values[part]
+                    ]);
+                    if (part < values.length - 1) {
+                        flushLine(lineTokens);
+                        lineTokens.length = 0;
+                    }
+                }
+            } else {
+                lineTokens.push(token);
+            }
+            lastWasBreak = false;
+        } else {
+            if (lastWasBreak) {
+                flushLine([]);
+            } else {
+                flushLine(lineTokens);
+                lineTokens.length = 0;
+            }
+            if (index === tokens.length - 1) flushLine([]);
+            lastWasBreak = true;
+        }
+    }
+    if (lineTokens.length) flushLine(lineTokens);
+    return {
+        value,
+        lines
+    };
+}
+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}` : ''}`;
+}
+
+const labelToType = {
+    plain: T_IDENTIFIER,
+    comment: T_COMMENT,
+    string: T_STRING,
+    number: T_CLASS,
+    keyword: T_KEYWORD,
+    type: T_CLASS,
+    function: T_ENTITY,
+    constant: T_CLASS,
+    operator: T_SIGN
+};
+function appendPlain(tokens, value) {
+    tokens.push([
+        T_IDENTIFIER,
+        value
+    ]);
+}
+/** Parse `code` through the GPU lexer and assemble it into a `ParsedCode` shape. */ async function parse(code) {
+    if (code.length === 0) {
+        return {
+            value: '',
+            lines: []
+        };
+    }
+    const spans = await parse$1(code);
+    const tokens = [];
+    let position = 0;
+    for (const span of spans){
+        if (span.start > position) {
+            appendPlain(tokens, code.slice(position, span.start));
+        }
+        const type = labelToType[span.type] ?? T_IDENTIFIER;
+        tokens.push([
+            type,
+            code.slice(span.start, span.end)
+        ]);
+        position = span.end;
+    }
+    if (position < code.length) {
+        appendPlain(tokens, code.slice(position));
+    }
+    return assemble(code, tokens);
+}
+/** Highlight `code` using the GPU lexer, returning an HTML string. */ async function highlight(code, options) {
+    const parsed = await parse(code);
+    return render(parsed, options);
+}
+
+export { highlight, parse };