fractalpop 0.1.0

package/dist/lang/go.d.ts

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

package/dist/lang/go.js

@@ -0,0 +1,91 @@
+/** 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: [
+        "break",
+        "case",
+        "chan",
+        "const",
+        "continue",
+        "default",
+        "defer",
+        "else",
+        "fallthrough",
+        "for",
+        "func",
+        "go",
+        "goto",
+        "if",
+        "import",
+        "interface",
+        "map",
+        "package",
+        "range",
+        "return",
+        "select",
+        "struct",
+        "switch",
+        "type",
+        "var"
+    ],
+    typeKeywords: [
+        "bool",
+        "byte",
+        "complex64",
+        "complex128",
+        "error",
+        "float32",
+        "float64",
+        "int",
+        "int8",
+        "int16",
+        "int32",
+        "int64",
+        "rune",
+        "string",
+        "uint",
+        "uint8",
+        "uint16",
+        "uint32",
+        "uint64",
+        "uintptr"
+    ],
+    comments: {
+        "line": [
+            "//"
+        ],
+        "block": true
+    }
+});
+
+export { config };

package/dist/lang/graphql.d.ts

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

package/dist/lang/graphql.js

@@ -0,0 +1,66 @@
+/** 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: [
+        "directive",
+        "enum",
+        "extend",
+        "fragment",
+        "implements",
+        "input",
+        "interface",
+        "mutation",
+        "on",
+        "query",
+        "repeatable",
+        "scalar",
+        "schema",
+        "subscription",
+        "type",
+        "union"
+    ],
+    typeKeywords: [
+        "Boolean",
+        "Float",
+        "ID",
+        "Int",
+        "String"
+    ],
+    comments: {
+        "line": [
+            "#"
+        ]
+    }
+});
+
+export { config };

package/dist/lang/hcl.d.ts

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

package/dist/lang/hcl.js

@@ -0,0 +1,51 @@
+/** 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: [
+        "false",
+        "for",
+        "if",
+        "in",
+        "null",
+        "true"
+    ],
+    comments: {
+        "line": [
+            "//",
+            "#"
+        ],
+        "block": true
+    }
+});
+
+export { config };

package/dist/lang/html.d.ts

@@ -0,0 +1,12 @@
+import { ParseOptions } from '../core.js';
+
+/** A lexer emits these: `[numericType, value]`. */
+type Token = [number, string];
+
+/** HTML / XML / markup tokenizer. Also the basis for Svelte markup regions.
+ * Emits tags (class), attribute names (property), values (string), and text. */
+
+declare const tokenize: (code: string) => Token[];
+declare const config: ParseOptions;
+
+export { config, tokenize };

package/dist/lang/html.js

@@ -0,0 +1,168 @@
+/**
+ * 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_STRING = 2;
+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 isSpace = (c)=>c === ' ' || c === '\t' || c === '\r';
+const isNameChar = (c)=>/[A-Za-z0-9_:.\-]/.test(c);
+/** Push text, splitting out newlines (break) and horizontal whitespace (space). */ function pushText(tokens, type, text) {
+    if (!text) return;
+    let buf = '';
+    const flush = ()=>{
+        if (buf) {
+            tokens.push([
+                type,
+                buf
+            ]);
+            buf = '';
+        }
+    };
+    for (const ch of text){
+        if (ch === '\n') {
+            flush();
+            tokens.push([
+                T_BREAK,
+                '\n'
+            ]);
+        } else {
+            buf += ch;
+        }
+    }
+    flush();
+}
+const tokenize = (code)=>{
+    const tokens = [];
+    let i = 0;
+    const n = code.length;
+    while(i < n){
+        const curr = code[i];
+        // Comment <!-- ... -->
+        if (code.startsWith('<!--', i)) {
+            const end = code.indexOf('-->', i + 4);
+            const stop = end === -1 ? n : end + 3;
+            pushText(tokens, T_COMMENT, code.slice(i, stop));
+            i = stop;
+            continue;
+        }
+        // Tag start
+        if (curr === '<') {
+            tokens.push([
+                T_SIGN,
+                '<'
+            ]);
+            i++;
+            if (code[i] === '/') {
+                tokens.push([
+                    T_SIGN,
+                    '/'
+                ]);
+                i++;
+            }
+            // tag name
+            const nameStart = i;
+            while(i < n && isNameChar(code[i]))i++;
+            if (i > nameStart) tokens.push([
+                T_CLASS,
+                code.slice(nameStart, i)
+            ]);
+            // attributes until > or />
+            while(i < n && code[i] !== '>'){
+                const c = code[i];
+                if (c === '\n') {
+                    tokens.push([
+                        T_BREAK,
+                        '\n'
+                    ]);
+                    i++;
+                } else if (isSpace(c)) {
+                    const s = i++;
+                    while(i < n && isSpace(code[i]))i++;
+                    tokens.push([
+                        T_SPACE,
+                        code.slice(s, i)
+                    ]);
+                } else if (c === '/') {
+                    tokens.push([
+                        T_SIGN,
+                        '/'
+                    ]);
+                    i++;
+                } else if (c === '=') {
+                    tokens.push([
+                        T_SIGN,
+                        '='
+                    ]);
+                    i++;
+                } else if (c === '"' || c === "'") {
+                    const q = c;
+                    const s = i++;
+                    while(i < n && code[i] !== q)i++;
+                    if (i < n) i++;
+                    pushText(tokens, T_STRING, code.slice(s, i));
+                } else if (isNameChar(c)) {
+                    const s = i++;
+                    while(i < n && isNameChar(code[i]))i++;
+                    tokens.push([
+                        T_PROPERTY,
+                        code.slice(s, i)
+                    ]);
+                } else {
+                    tokens.push([
+                        T_SIGN,
+                        c
+                    ]);
+                    i++;
+                }
+            }
+            if (code[i] === '>') {
+                tokens.push([
+                    T_SIGN,
+                    '>'
+                ]);
+                i++;
+            }
+            continue;
+        }
+        // Text run until next tag
+        const start = i;
+        while(i < n && code[i] !== '<')i++;
+        pushText(tokens, T_IDENTIFIER, code.slice(start, i));
+    }
+    return tokens;
+};
+const config = {
+    tokenize
+};
+
+export { config, tokenize };

package/dist/lang/java.d.ts

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

package/dist/lang/java.js

@@ -0,0 +1,96 @@
+/** 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",
+        "assert",
+        "break",
+        "case",
+        "catch",
+        "class",
+        "const",
+        "continue",
+        "default",
+        "do",
+        "else",
+        "enum",
+        "extends",
+        "final",
+        "finally",
+        "for",
+        "goto",
+        "if",
+        "implements",
+        "import",
+        "instanceof",
+        "interface",
+        "native",
+        "new",
+        "package",
+        "private",
+        "protected",
+        "public",
+        "return",
+        "static",
+        "strictfp",
+        "super",
+        "switch",
+        "synchronized",
+        "this",
+        "throw",
+        "throws",
+        "transient",
+        "try",
+        "volatile",
+        "while"
+    ],
+    typeKeywords: [
+        "boolean",
+        "byte",
+        "char",
+        "double",
+        "float",
+        "int",
+        "long",
+        "short",
+        "void"
+    ],
+    comments: {
+        "line": [
+            "//"
+        ],
+        "block": true
+    }
+});
+
+export { config };

package/dist/lang/javascript.d.ts

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

package/dist/lang/json.d.ts

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

package/dist/lang/json.js

@@ -0,0 +1,47 @@
+/** 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: [
+        "true",
+        "false",
+        "null"
+    ],
+    comments: {
+        "line": [
+            "//"
+        ],
+        "block": true
+    }
+});
+
+export { config };

package/dist/lang/kotlin.d.ts

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