fractalpop 0.1.0

package/dist/lang/c.js

@@ -0,0 +1,90 @@
+/** Reusable comment-scanner bases shared by keyword-based language presets. */ /** Build onCommentStart/onCommentEnd for a mix of line + block comment styles.
+ * Line comments open as type 1 and close at `\n`; block comments open as type 2
+ * and close at the terminator — so a single onCommentEnd serves both. */ function commentRules(style) {
+    const line = style.line ?? [];
+    const hasSlash = line.includes('//');
+    const hasHash = line.includes('#');
+    const hasDash = line.includes('--');
+    const block = style.block ?? false;
+    return {
+        onCommentStart (curr, next) {
+            if (block && curr === '/' && next === '*') return 2;
+            if (hasSlash && curr === '/' && next === '/') return 1;
+            if (hasHash && curr === '#') return 1;
+            if (hasDash && curr === '-' && next === '-') return 1;
+            return 0;
+        },
+        onCommentEnd (prev, curr) {
+            if (curr === '\n') return 1;
+            if (block && prev === '*' && curr === '/') return 2;
+            return 0;
+        }
+    };
+}
+/** Assemble a keyword-based language config over the shared general lexer. */ function keywordLang(spec) {
+    const config = {};
+    if (spec.keywords) config.keywords = new Set(spec.keywords);
+    if (spec.typeKeywords) config.typeKeywords = new Set(spec.typeKeywords);
+    if (spec.caseInsensitive) config.caseInsensitive = true;
+    if (spec.comments) Object.assign(config, commentRules(spec.comments));
+    return config;
+}
+
+const config = keywordLang({
+    keywords: [
+        "auto",
+        "break",
+        "case",
+        "const",
+        "continue",
+        "default",
+        "do",
+        "else",
+        "enum",
+        "extern",
+        "for",
+        "goto",
+        "if",
+        "inline",
+        "register",
+        "restrict",
+        "return",
+        "sizeof",
+        "static",
+        "struct",
+        "switch",
+        "typedef",
+        "union",
+        "volatile",
+        "while",
+        "_Alignas",
+        "_Alignof",
+        "_Atomic",
+        "_Generic",
+        "_Noreturn",
+        "_Static_assert",
+        "_Thread_local"
+    ],
+    typeKeywords: [
+        "void",
+        "char",
+        "short",
+        "int",
+        "long",
+        "float",
+        "double",
+        "signed",
+        "unsigned",
+        "_Bool",
+        "_Complex",
+        "_Imaginary"
+    ],
+    comments: {
+        "line": [
+            "//"
+        ],
+        "block": true
+    }
+});
+
+export { config };

package/dist/lang/cpp.d.ts

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

package/dist/lang/cpp.js

@@ -0,0 +1,138 @@
+/** Reusable comment-scanner bases shared by keyword-based language presets. */ /** Build onCommentStart/onCommentEnd for a mix of line + block comment styles.
+ * Line comments open as type 1 and close at `\n`; block comments open as type 2
+ * and close at the terminator — so a single onCommentEnd serves both. */ function commentRules(style) {
+    const line = style.line ?? [];
+    const hasSlash = line.includes('//');
+    const hasHash = line.includes('#');
+    const hasDash = line.includes('--');
+    const block = style.block ?? false;
+    return {
+        onCommentStart (curr, next) {
+            if (block && curr === '/' && next === '*') return 2;
+            if (hasSlash && curr === '/' && next === '/') return 1;
+            if (hasHash && curr === '#') return 1;
+            if (hasDash && curr === '-' && next === '-') return 1;
+            return 0;
+        },
+        onCommentEnd (prev, curr) {
+            if (curr === '\n') return 1;
+            if (block && prev === '*' && curr === '/') return 2;
+            return 0;
+        }
+    };
+}
+/** Assemble a keyword-based language config over the shared general lexer. */ function keywordLang(spec) {
+    const config = {};
+    if (spec.keywords) config.keywords = new Set(spec.keywords);
+    if (spec.typeKeywords) config.typeKeywords = new Set(spec.typeKeywords);
+    if (spec.caseInsensitive) config.caseInsensitive = true;
+    if (spec.comments) Object.assign(config, commentRules(spec.comments));
+    return config;
+}
+
+const config = keywordLang({
+    keywords: [
+        "alignas",
+        "alignof",
+        "and",
+        "and_eq",
+        "asm",
+        "auto",
+        "bitand",
+        "bitor",
+        "break",
+        "case",
+        "catch",
+        "class",
+        "compl",
+        "concept",
+        "const",
+        "consteval",
+        "constexpr",
+        "constinit",
+        "const_cast",
+        "continue",
+        "co_await",
+        "co_return",
+        "co_yield",
+        "decltype",
+        "default",
+        "delete",
+        "do",
+        "dynamic_cast",
+        "else",
+        "enum",
+        "explicit",
+        "export",
+        "extern",
+        "false",
+        "for",
+        "friend",
+        "goto",
+        "if",
+        "inline",
+        "mutable",
+        "namespace",
+        "new",
+        "noexcept",
+        "not",
+        "not_eq",
+        "nullptr",
+        "operator",
+        "or",
+        "or_eq",
+        "private",
+        "protected",
+        "public",
+        "register",
+        "reinterpret_cast",
+        "requires",
+        "return",
+        "sizeof",
+        "static",
+        "static_assert",
+        "static_cast",
+        "struct",
+        "switch",
+        "template",
+        "this",
+        "thread_local",
+        "throw",
+        "true",
+        "try",
+        "typedef",
+        "typeid",
+        "typename",
+        "union",
+        "using",
+        "virtual",
+        "volatile",
+        "while",
+        "xor",
+        "xor_eq"
+    ],
+    typeKeywords: [
+        "bool",
+        "char",
+        "char8_t",
+        "char16_t",
+        "char32_t",
+        "double",
+        "float",
+        "int",
+        "long",
+        "short",
+        "signed",
+        "unsigned",
+        "void",
+        "wchar_t"
+    ],
+    comments: {
+        "line": [
+            "//"
+        ],
+        "block": true
+    }
+});
+
+export { config };

package/dist/lang/csharp.d.ts

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

package/dist/lang/csharp.js

@@ -0,0 +1,148 @@
+/** Reusable comment-scanner bases shared by keyword-based language presets. */ /** Build onCommentStart/onCommentEnd for a mix of line + block comment styles.
+ * Line comments open as type 1 and close at `\n`; block comments open as type 2
+ * and close at the terminator — so a single onCommentEnd serves both. */ function commentRules(style) {
+    const line = style.line ?? [];
+    const hasSlash = line.includes('//');
+    const hasHash = line.includes('#');
+    const hasDash = line.includes('--');
+    const block = style.block ?? false;
+    return {
+        onCommentStart (curr, next) {
+            if (block && curr === '/' && next === '*') return 2;
+            if (hasSlash && curr === '/' && next === '/') return 1;
+            if (hasHash && curr === '#') return 1;
+            if (hasDash && curr === '-' && next === '-') return 1;
+            return 0;
+        },
+        onCommentEnd (prev, curr) {
+            if (curr === '\n') return 1;
+            if (block && prev === '*' && curr === '/') return 2;
+            return 0;
+        }
+    };
+}
+/** Assemble a keyword-based language config over the shared general lexer. */ function keywordLang(spec) {
+    const config = {};
+    if (spec.keywords) config.keywords = new Set(spec.keywords);
+    if (spec.typeKeywords) config.typeKeywords = new Set(spec.typeKeywords);
+    if (spec.caseInsensitive) config.caseInsensitive = true;
+    if (spec.comments) Object.assign(config, commentRules(spec.comments));
+    return config;
+}
+
+const config = keywordLang({
+    keywords: [
+        "abstract",
+        "as",
+        "async",
+        "await",
+        "base",
+        "break",
+        "case",
+        "catch",
+        "checked",
+        "class",
+        "const",
+        "continue",
+        "default",
+        "delegate",
+        "do",
+        "else",
+        "enum",
+        "event",
+        "explicit",
+        "extern",
+        "false",
+        "finally",
+        "fixed",
+        "for",
+        "foreach",
+        "from",
+        "get",
+        "global",
+        "goto",
+        "if",
+        "implicit",
+        "in",
+        "init",
+        "interface",
+        "internal",
+        "into",
+        "is",
+        "join",
+        "let",
+        "lock",
+        "namespace",
+        "new",
+        "null",
+        "on",
+        "operator",
+        "orderby",
+        "out",
+        "override",
+        "params",
+        "partial",
+        "private",
+        "protected",
+        "public",
+        "readonly",
+        "record",
+        "ref",
+        "remove",
+        "required",
+        "return",
+        "sealed",
+        "select",
+        "set",
+        "sizeof",
+        "stackalloc",
+        "static",
+        "struct",
+        "switch",
+        "this",
+        "throw",
+        "true",
+        "try",
+        "typeof",
+        "unchecked",
+        "unsafe",
+        "using",
+        "value",
+        "virtual",
+        "volatile",
+        "when",
+        "where",
+        "while",
+        "with",
+        "yield"
+    ],
+    typeKeywords: [
+        "bool",
+        "byte",
+        "char",
+        "decimal",
+        "double",
+        "dynamic",
+        "float",
+        "int",
+        "long",
+        "nint",
+        "nuint",
+        "object",
+        "sbyte",
+        "short",
+        "string",
+        "uint",
+        "ulong",
+        "ushort",
+        "void"
+    ],
+    comments: {
+        "line": [
+            "//"
+        ],
+        "block": true
+    }
+});
+
+export { config };

package/dist/lang/css.d.ts

@@ -0,0 +1,21 @@
+import { ParseOptions } from '../core.js';
+
+/** A lexer emits these: `[numericType, value]`. */
+type Token = [number, string];
+
+/** CSS preset. Runs the plain lexer, then post-processes to mark declarations
+ * (property before a `:` inside a block) and rejoin `--dashed-names`. */
+
+declare const keywords: Set<string>;
+declare const onCommentStart: (curr: string, next: string) => number;
+declare const onCommentEnd: (prev: string, curr: string) => number;
+declare const onLiteral: (curr: string, index: number, code: string) => number;
+/** Rejoin CSS dashed identifiers split by the shared punctuation lexer. */
+declare const mergeDashedNames: (tokens: Token[]) => void;
+/** Mark `property:` declarations inside brace blocks. Shared with SCSS. */
+declare const cssDeclarationPass: (tokens: Token[]) => void;
+/** Add CSS declaration context after the shared plain lexer runs. */
+declare const tokenize: (code: string, options?: ParseOptions) => Token[];
+declare const config: ParseOptions;
+
+export { config, cssDeclarationPass, keywords, mergeDashedNames, onCommentEnd, onCommentStart, onLiteral, tokenize };

package/dist/lang/css.js

@@ -0,0 +1,164 @@
+import { tokenize as tokenize$1 } from '../core.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'
+];
+// Numeric indices, used everywhere in the hot path.
+const T_IDENTIFIER = 0;
+const T_CLASS = 3;
+const T_PROPERTY = 4;
+const T_SIGN = 7;
+const T_COMMENT = 8;
+const T_BREAK = 9;
+const T_SPACE = 10;
+({
+    TokenMap: new Map(TokenTypes.map((type, index)=>[
+            type,
+            index
+        ]))
+});
+
+const keywords = new Set([
+    '@media',
+    '@import',
+    '@keyframes',
+    '@font-face',
+    '@supports',
+    '@page',
+    '@counter-style',
+    '@font-feature-values',
+    '@viewport',
+    '@document',
+    '@namespace',
+    '@charset',
+    '@layer',
+    '@container'
+]);
+const onCommentStart = (curr, next)=>curr + next === '/*' ? 1 : 0;
+const onCommentEnd = (prev, curr)=>prev + curr === '*/' ? 1 : 0;
+const onLiteral = (curr, index, code)=>{
+    if (curr !== '#') return 0;
+    return code.slice(index).match(/^#(?:[\da-f]{8}|[\da-f]{6}|[\da-f]{4}|[\da-f]{3})(?![\w-])/i)?.[0].length || 0;
+};
+const isIgnored = (type)=>type === T_SPACE || type === T_BREAK || type === T_COMMENT;
+const isPropertyPart = ([type, value])=>type === T_IDENTIFIER || type === T_CLASS || type === T_SIGN && value === '-';
+const isNamePart = ([type])=>type === T_IDENTIFIER || type === T_CLASS || type === T_PROPERTY;
+const isNameStart = (token)=>isNamePart(token) && !/^\d/.test(token[1]);
+const isHyphen = ([type, value])=>type === T_SIGN && value === '-';
+/** Rejoin CSS dashed identifiers split by the shared punctuation lexer. */ const mergeDashedNames = (tokens)=>{
+    for(let index = 0; index < tokens.length; index++){
+        let firstWord = index;
+        let end = index;
+        if (isHyphen(tokens[end])) {
+            while(tokens[end] && isHyphen(tokens[end]))end++;
+            if (!tokens[end] || !isNameStart(tokens[end])) continue;
+            firstWord = end++;
+        } else if (isNameStart(tokens[end])) {
+            end++;
+        } else {
+            continue;
+        }
+        let dashed = firstWord > index;
+        while(tokens[end] && isHyphen(tokens[end])){
+            const hyphenStart = end;
+            while(tokens[end] && isHyphen(tokens[end]))end++;
+            if (!tokens[end] || !isNamePart(tokens[end])) {
+                end = hyphenStart;
+                break;
+            }
+            dashed = true;
+            end++;
+        }
+        if (!dashed) continue;
+        const name = tokens.slice(index, end).map(([, value])=>value).join('');
+        tokens.splice(index, end - index, [
+            tokens[firstWord][0],
+            name
+        ]);
+    }
+};
+/** True when a colon opens a nested block (selector) rather than a declaration. */ const opensBlock = (tokens, start)=>{
+    let parentheses = 0;
+    let brackets = 0;
+    for(let index = start; index < tokens.length; index++){
+        const [type, value] = tokens[index];
+        if (type !== T_SIGN) continue;
+        if (value === '(') parentheses++;
+        else if (value === ')') parentheses--;
+        else if (value === '[') brackets++;
+        else if (value === ']') brackets--;
+        else if (!parentheses && !brackets && value === '{') return true;
+        else if (!parentheses && !brackets && (value === ';' || value === '}')) return false;
+    }
+    return false;
+};
+/** Mark `property:` declarations inside brace blocks. Shared with SCSS. */ const cssDeclarationPass = (tokens)=>{
+    let blockDepth = 0;
+    let declarationStart = false;
+    for(let index = 0; index < tokens.length; index++){
+        const [type, value] = tokens[index];
+        if (type === T_SIGN && value === '{') {
+            blockDepth++;
+            declarationStart = true;
+            continue;
+        }
+        if (type === T_SIGN && value === '}') {
+            blockDepth--;
+            declarationStart = false;
+            continue;
+        }
+        if (type === T_SIGN && value === ';') {
+            declarationStart = blockDepth > 0;
+            continue;
+        }
+        if (!declarationStart || isIgnored(type)) continue;
+        const propertyStart = index;
+        let propertyEnd = index;
+        while(propertyEnd < tokens.length && isPropertyPart(tokens[propertyEnd]))propertyEnd++;
+        let colon = propertyEnd;
+        while(colon < tokens.length && isIgnored(tokens[colon][0]))colon++;
+        if (propertyEnd > propertyStart && tokens[colon]?.[0] === T_SIGN && tokens[colon][1] === ':' && !opensBlock(tokens, colon + 1)) {
+            const property = tokens.slice(propertyStart, propertyEnd).map(([, part])=>part).join('');
+            tokens.splice(propertyStart, propertyEnd - propertyStart, [
+                T_PROPERTY,
+                property
+            ]);
+        }
+        declarationStart = false;
+    }
+};
+/** Add CSS declaration context after the shared plain lexer runs. */ const tokenize = (code, options)=>{
+    const tokens = tokenize$1(code, {
+        ...options,
+        tokenize: undefined
+    });
+    mergeDashedNames(tokens);
+    cssDeclarationPass(tokens);
+    return tokens;
+};
+const config = {
+    keywords,
+    onCommentStart,
+    onCommentEnd,
+    onLiteral,
+    tokenize
+};
+
+export { config, cssDeclarationPass, keywords, mergeDashedNames, onCommentEnd, onCommentStart, onLiteral, tokenize };

package/dist/lang/diff.d.ts

@@ -0,0 +1,30 @@
+import { ParseOptions } from '../core.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>`. */
+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[];
+}
+
+/** diff / patch — line-annotation preset. Colors added/removed/hunk/meta lines. */
+
+declare const annotateLine: (line: ParsedLine) => void;
+declare const config: ParseOptions;
+
+export { annotateLine, config };

package/dist/lang/diff.js

@@ -0,0 +1,18 @@
+/** diff / patch — line-annotation preset. Colors added/removed/hunk/meta lines. */ const annotateLine = (line)=>{
+    let annotation = '';
+    if (line.value.startsWith('+') && !line.value.startsWith('+++')) annotation = 'diff-add';
+    else if (line.value.startsWith('-') && !line.value.startsWith('---')) annotation = 'diff-remove';
+    else if (line.value.startsWith('@@')) annotation = 'diff-hunk';
+    else if (/^(diff --git|index |--- |\+\+\+ )/.test(line.value)) {
+        annotation = 'diff-meta';
+        for (const token of line.tokens){
+            if (token.type === 'property') token.type = 'identifier';
+        }
+    }
+    if (annotation) line.annotations.push(annotation);
+};
+const config = {
+    annotateLine
+};
+
+export { annotateLine, config };

package/dist/lang/dockerfile.d.ts

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

package/dist/lang/dockerfile.js

@@ -0,0 +1,60 @@
+/** Reusable comment-scanner bases shared by keyword-based language presets. */ /** Build onCommentStart/onCommentEnd for a mix of line + block comment styles.
+ * Line comments open as type 1 and close at `\n`; block comments open as type 2
+ * and close at the terminator — so a single onCommentEnd serves both. */ function commentRules(style) {
+    const line = style.line ?? [];
+    const hasSlash = line.includes('//');
+    const hasHash = line.includes('#');
+    const hasDash = line.includes('--');
+    const block = style.block ?? false;
+    return {
+        onCommentStart (curr, next) {
+            if (block && curr === '/' && next === '*') return 2;
+            if (hasSlash && curr === '/' && next === '/') return 1;
+            if (hasHash && curr === '#') return 1;
+            if (hasDash && curr === '-' && next === '-') return 1;
+            return 0;
+        },
+        onCommentEnd (prev, curr) {
+            if (curr === '\n') return 1;
+            if (block && prev === '*' && curr === '/') return 2;
+            return 0;
+        }
+    };
+}
+/** Assemble a keyword-based language config over the shared general lexer. */ function keywordLang(spec) {
+    const config = {};
+    if (spec.keywords) config.keywords = new Set(spec.keywords);
+    if (spec.typeKeywords) config.typeKeywords = new Set(spec.typeKeywords);
+    config.caseInsensitive = true;
+    if (spec.comments) Object.assign(config, commentRules(spec.comments));
+    return config;
+}
+
+const config = keywordLang({
+    keywords: [
+        "add",
+        "arg",
+        "cmd",
+        "copy",
+        "entrypoint",
+        "env",
+        "expose",
+        "from",
+        "healthcheck",
+        "label",
+        "maintainer",
+        "onbuild",
+        "run",
+        "shell",
+        "stopsignal",
+        "user",
+        "volume",
+        "workdir"
+    ],
+    comments: {
+        "line": [
+            "#"
+        ]
+    }});
+
+export { config };