fractalpop 0.1.0

package/dist/lang/kotlin.js

@@ -0,0 +1,113 @@
+/** 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: [
+        "as",
+        "break",
+        "by",
+        "catch",
+        "class",
+        "companion",
+        "const",
+        "constructor",
+        "continue",
+        "data",
+        "do",
+        "else",
+        "enum",
+        "false",
+        "finally",
+        "for",
+        "fun",
+        "get",
+        "if",
+        "import",
+        "in",
+        "infix",
+        "init",
+        "interface",
+        "internal",
+        "is",
+        "lateinit",
+        "noinline",
+        "null",
+        "object",
+        "open",
+        "operator",
+        "out",
+        "override",
+        "package",
+        "private",
+        "protected",
+        "public",
+        "reified",
+        "return",
+        "sealed",
+        "set",
+        "suspend",
+        "tailrec",
+        "this",
+        "throw",
+        "true",
+        "try",
+        "typealias",
+        "val",
+        "var",
+        "vararg",
+        "when",
+        "where",
+        "while"
+    ],
+    typeKeywords: [
+        "Any",
+        "Boolean",
+        "Byte",
+        "Char",
+        "Double",
+        "Float",
+        "Int",
+        "Long",
+        "Nothing",
+        "Short",
+        "String",
+        "Unit"
+    ],
+    comments: {
+        "line": [
+            "//"
+        ],
+        "block": true
+    }
+});
+
+export { config };

package/dist/lang/lua.d.ts

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

package/dist/lang/lua.js

@@ -0,0 +1,65 @@
+/** 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: [
+        "and",
+        "break",
+        "do",
+        "else",
+        "elseif",
+        "end",
+        "false",
+        "for",
+        "function",
+        "goto",
+        "if",
+        "in",
+        "local",
+        "nil",
+        "not",
+        "or",
+        "repeat",
+        "return",
+        "then",
+        "true",
+        "until",
+        "while"
+    ],
+    comments: {
+        "line": [
+            "--"
+        ]
+    }
+});
+
+export { config };

package/dist/lang/markdown.d.ts

@@ -0,0 +1,12 @@
+import { ParseOptions } from '../core.js';
+
+/** A lexer emits these: `[numericType, value]`. */
+type Token = [number, string];
+
+/** Markdown / MDX tokenizer — headings, fences, inline code, emphasis, links, lists.
+ * Line-oriented; a fenced ``` block colors its body as string until it closes. */
+
+declare const tokenize: (code: string) => Token[];
+declare const config: ParseOptions;
+
+export { config, tokenize };

package/dist/lang/markdown.js

@@ -0,0 +1,172 @@
+/**
+ * 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_PROPERTY = 4;
+const T_SIGN = 7;
+const T_COMMENT = 8;
+const T_BREAK = 9;
+({
+    TokenMap: new Map(TokenTypes.map((type, index)=>[
+            type,
+            index
+        ]))
+});
+
+/** Tokenize the inline content of a normal text line. */ function inline(tokens, text) {
+    let i = 0;
+    const n = text.length;
+    let buf = '';
+    const flush = ()=>{
+        if (buf) {
+            tokens.push([
+                T_IDENTIFIER,
+                buf
+            ]);
+            buf = '';
+        }
+    };
+    while(i < n){
+        const c = text[i];
+        // inline code
+        if (c === '`') {
+            flush();
+            const end = text.indexOf('`', i + 1);
+            const stop = end === -1 ? n : end + 1;
+            tokens.push([
+                T_STRING,
+                text.slice(i, stop)
+            ]);
+            i = stop;
+            continue;
+        }
+        // emphasis markers
+        if (c === '*' || c === '_') {
+            flush();
+            const s = i;
+            while(i < n && (text[i] === '*' || text[i] === '_'))i++;
+            tokens.push([
+                T_SIGN,
+                text.slice(s, i)
+            ]);
+            continue;
+        }
+        // link / image [text](url)
+        if (c === '[') {
+            const close = text.indexOf(']', i);
+            if (close !== -1 && text[close + 1] === '(') {
+                const paren = text.indexOf(')', close);
+                if (paren !== -1) {
+                    flush();
+                    tokens.push([
+                        T_SIGN,
+                        '['
+                    ]);
+                    tokens.push([
+                        T_PROPERTY,
+                        text.slice(i + 1, close)
+                    ]);
+                    tokens.push([
+                        T_SIGN,
+                        ']('
+                    ]);
+                    tokens.push([
+                        T_STRING,
+                        text.slice(close + 2, paren)
+                    ]);
+                    tokens.push([
+                        T_SIGN,
+                        ')'
+                    ]);
+                    i = paren + 1;
+                    continue;
+                }
+            }
+        }
+        buf += c;
+        i++;
+    }
+    flush();
+}
+const tokenize = (code)=>{
+    const tokens = [];
+    const lines = code.split('\n');
+    let fence = '';
+    for(let l = 0; l < lines.length; l++){
+        const line = lines[l];
+        const trimmed = line.trimStart();
+        const fenceMarker = trimmed.match(/^(`{3,}|~{3,})/)?.[1];
+        if (fence) {
+            if (fenceMarker && fenceMarker[0] === fence[0] && fenceMarker.length >= fence.length) {
+                fence = '';
+            }
+            tokens.push([
+                T_STRING,
+                line
+            ]);
+        } else if (fenceMarker) {
+            fence = fenceMarker;
+            tokens.push([
+                T_COMMENT,
+                line
+            ]); // fence line (with optional lang label)
+        } else if (/^#{1,6}\s/.test(trimmed)) {
+            tokens.push([
+                T_CLASS,
+                line
+            ]); // heading
+        } else if (/^>/.test(trimmed)) {
+            tokens.push([
+                T_COMMENT,
+                line
+            ]); // blockquote
+        } else {
+            const indent = line.slice(0, line.length - trimmed.length);
+            if (indent) tokens.push([
+                T_IDENTIFIER,
+                indent
+            ]);
+            const listMarker = trimmed.match(/^([-*+]|\d+\.)\s/)?.[1];
+            if (listMarker) {
+                tokens.push([
+                    T_KEYWORD,
+                    listMarker
+                ]);
+                inline(tokens, trimmed.slice(listMarker.length));
+            } else {
+                inline(tokens, trimmed);
+            }
+        }
+        if (l < lines.length - 1) tokens.push([
+            T_BREAK,
+            '\n'
+        ]);
+    }
+    return tokens;
+};
+const config = {
+    tokenize
+};
+
+export { config, tokenize };

package/dist/lang/php.d.ts

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

package/dist/lang/php.js

@@ -0,0 +1,129 @@
+/** 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",
+        "and",
+        "array",
+        "as",
+        "break",
+        "callable",
+        "case",
+        "catch",
+        "class",
+        "clone",
+        "const",
+        "continue",
+        "declare",
+        "default",
+        "do",
+        "echo",
+        "else",
+        "elseif",
+        "empty",
+        "enddeclare",
+        "endfor",
+        "endforeach",
+        "endif",
+        "endswitch",
+        "endwhile",
+        "enum",
+        "eval",
+        "exit",
+        "extends",
+        "false",
+        "final",
+        "finally",
+        "fn",
+        "for",
+        "foreach",
+        "from",
+        "function",
+        "global",
+        "goto",
+        "if",
+        "implements",
+        "include",
+        "include_once",
+        "instanceof",
+        "insteadof",
+        "interface",
+        "isset",
+        "list",
+        "match",
+        "namespace",
+        "new",
+        "null",
+        "or",
+        "print",
+        "private",
+        "protected",
+        "public",
+        "readonly",
+        "require",
+        "require_once",
+        "return",
+        "static",
+        "switch",
+        "throw",
+        "trait",
+        "true",
+        "try",
+        "unset",
+        "use",
+        "var",
+        "while",
+        "xor",
+        "yield"
+    ],
+    typeKeywords: [
+        "bool",
+        "float",
+        "int",
+        "iterable",
+        "mixed",
+        "never",
+        "object",
+        "string",
+        "void"
+    ],
+    comments: {
+        "line": [
+            "//",
+            "#"
+        ],
+        "block": true
+    }
+});
+
+export { config };

package/dist/lang/plaintext.d.ts

@@ -0,0 +1,7 @@
+import { ParseOptions } from '../core.js';
+
+/** Plain text — no keywords, no comments. Everything is an identifier/space/break. */
+
+declare const config: ParseOptions;
+
+export { config };

package/dist/lang/plaintext.js

@@ -0,0 +1,3 @@
+/** Plain text — no keywords, no comments. Everything is an identifier/space/break. */ const config = {};
+
+export { config };

package/dist/lang/powershell.d.ts

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

package/dist/lang/powershell.js

@@ -0,0 +1,74 @@
+/** 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: [
+        "begin",
+        "break",
+        "catch",
+        "class",
+        "continue",
+        "data",
+        "define",
+        "do",
+        "dynamicparam",
+        "else",
+        "elseif",
+        "end",
+        "enum",
+        "exit",
+        "filter",
+        "finally",
+        "for",
+        "foreach",
+        "from",
+        "function",
+        "if",
+        "in",
+        "param",
+        "process",
+        "return",
+        "switch",
+        "throw",
+        "trap",
+        "try",
+        "until",
+        "using",
+        "while"
+    ],
+    comments: {
+        "line": [
+            "#"
+        ]
+    }});
+
+export { config };

package/dist/lang/python.d.ts

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

package/dist/lang/python.js

@@ -0,0 +1,75 @@
+/** 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: [
+        "and",
+        "as",
+        "assert",
+        "async",
+        "await",
+        "break",
+        "class",
+        "continue",
+        "def",
+        "del",
+        "elif",
+        "else",
+        "except",
+        "finally",
+        "for",
+        "from",
+        "global",
+        "if",
+        "import",
+        "in",
+        "is",
+        "lambda",
+        "nonlocal",
+        "not",
+        "or",
+        "pass",
+        "raise",
+        "return",
+        "try",
+        "while",
+        "with",
+        "yield"
+    ],
+    comments: {
+        "line": [
+            "#"
+        ]
+    }
+});
+
+export { config };

package/dist/lang/ruby.d.ts

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