fractalpop 0.1.0

package/dist/lang/ruby.js

@@ -0,0 +1,84 @@
+/** 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: [
+        "BEGIN",
+        "END",
+        "__ENCODING__",
+        "__FILE__",
+        "__LINE__",
+        "alias",
+        "and",
+        "begin",
+        "break",
+        "case",
+        "class",
+        "def",
+        "defined",
+        "do",
+        "else",
+        "elsif",
+        "end",
+        "ensure",
+        "false",
+        "for",
+        "if",
+        "in",
+        "module",
+        "next",
+        "nil",
+        "not",
+        "or",
+        "redo",
+        "rescue",
+        "retry",
+        "return",
+        "self",
+        "super",
+        "then",
+        "true",
+        "undef",
+        "unless",
+        "until",
+        "when",
+        "while",
+        "yield"
+    ],
+    comments: {
+        "line": [
+            "#"
+        ]
+    }
+});
+
+export { config };

package/dist/lang/rust.d.ts

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

package/dist/lang/rust.js

@@ -0,0 +1,95 @@
+/** 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",
+        "const",
+        "continue",
+        "crate",
+        "else",
+        "enum",
+        "extern",
+        "false",
+        "fn",
+        "for",
+        "if",
+        "impl",
+        "in",
+        "let",
+        "loop",
+        "match",
+        "mod",
+        "move",
+        "mut",
+        "pub",
+        "ref",
+        "return",
+        "self",
+        "Self",
+        "static",
+        "struct",
+        "super",
+        "trait",
+        "true",
+        "type",
+        "unsafe",
+        "use",
+        "where",
+        "while",
+        "async",
+        "await",
+        "dyn",
+        "abstract",
+        "become",
+        "box",
+        "do",
+        "final",
+        "macro",
+        "override",
+        "priv",
+        "typeof",
+        "unsized",
+        "virtual",
+        "yield",
+        "try"
+    ],
+    comments: {
+        "line": [
+            "//"
+        ],
+        "block": true
+    }
+});
+
+export { config };

package/dist/lang/sass.d.ts

@@ -0,0 +1,15 @@
+import { ParseOptions } from '../core.js';
+
+/** A lexer emits these: `[numericType, value]`. */
+type Token = [number, string];
+
+/** Indented pure Sass (.sass) — no braces, no semicolons; structure is indentation.
+ * A line-oriented tokenizer classifies each line from its indent + leading token,
+ * then lexes the content. The property/selector colon ambiguity is resolved by
+ * looking ahead at the next line's indent (a selector has deeper-indented children;
+ * a bare declaration does not). See SPEC §6. */
+
+declare const tokenize: (code: string) => Token[];
+declare const config: ParseOptions;
+
+export { config, tokenize };

package/dist/lang/sass.js

@@ -0,0 +1,201 @@
+import { tokenize as tokenize$1 } from '../core.js';
+import { onLiteral } from './css.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_KEYWORD = 1;
+const T_CLASS = 3;
+const T_PROPERTY = 4;
+const T_ENTITY = 5;
+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 isNameType = (type)=>type === T_IDENTIFIER || type === T_CLASS || type === T_PROPERTY;
+function applySassSymbols(tokens) {
+    for(let i = 0; i < tokens.length; i++){
+        const token = tokens[i];
+        const [type, value] = token;
+        // $variable — the plain lexer already keeps `$name` as one word token.
+        if (isNameType(type) && value[0] === '$') {
+            token[0] = T_PROPERTY;
+            continue;
+        }
+        if (type === T_SIGN) {
+            const next = tokens[i + 1];
+            // @at-rule: merge '@' + word → keyword (@mixin, @include, @if, @use, …).
+            if (value === '@' && next && isNameType(next[0])) {
+                tokens.splice(i, 2, [
+                    T_KEYWORD,
+                    '@' + next[1]
+                ]);
+                continue;
+            }
+            // %placeholder selector: merge '%' + word → class.
+            if (value === '%' && next && isNameType(next[0])) {
+                tokens.splice(i, 2, [
+                    T_CLASS,
+                    '%' + next[1]
+                ]);
+                continue;
+            }
+            // !flag: merge '!' + word → keyword (!default, !global, !important, !optional).
+            if (value === '!' && next && isNameType(next[0])) {
+                tokens.splice(i, 2, [
+                    T_KEYWORD,
+                    '!' + next[1]
+                ]);
+                continue;
+            }
+        }
+        // function / mixin call: a name directly before '(' → entity.
+        if (isNameType(type) && value[0] !== '$') {
+            const next = tokens[i + 1];
+            if (next && next[0] === T_SIGN && next[1] === '(') token[0] = T_ENTITY;
+        }
+    }
+}
+
+const onCommentStart = (curr, next)=>curr === '/' && next === '*' ? 2 : curr === '/' && next === '/' ? 1 : 0;
+const onCommentEnd = (prev, curr)=>curr === '\n' ? 1 : prev === '*' && curr === '/' ? 2 : 0;
+/** Lex a run of inline Sass content (a value or a selector) and color its symbols. */ function lexInline(text) {
+    const tokens = tokenize$1(text, {
+        onCommentStart,
+        onCommentEnd,
+        onLiteral
+    });
+    applySassSymbols(tokens);
+    return tokens;
+}
+/** In a selector line, promote `.name` / `#name` to class coloring. */ function retagSelector(tokens) {
+    for(let i = 0; i < tokens.length; i++){
+        const [type, value] = tokens[i];
+        if (type === T_SIGN && (value === '.' || value === '#')) {
+            const next = tokens[i + 1];
+            if (next && next[0] !== T_SPACE && next[0] !== T_BREAK) next[0] = T_CLASS;
+        }
+    }
+}
+const leadingWhitespace = (line)=>line.match(/^[ \t]*/)?.[0] ?? '';
+const tokenize = (code)=>{
+    const out = [];
+    const lines = code.split('\n');
+    // Indent length of each non-blank line (-1 for blank), for child lookahead.
+    const indents = lines.map((line)=>line.trim() === '' ? -1 : leadingWhitespace(line).length);
+    const hasChildren = (index)=>{
+        const own = indents[index];
+        for(let j = index + 1; j < lines.length; j++){
+            const next = indents[j];
+            if (next === -1) continue;
+            return next > own;
+        }
+        return false;
+    };
+    let inBlockComment = false;
+    for(let l = 0; l < lines.length; l++){
+        const line = lines[l];
+        const indent = leadingWhitespace(line);
+        const content = line.slice(indent.length);
+        if (indent) out.push([
+            T_SPACE,
+            indent
+        ]);
+        if (inBlockComment) {
+            out.push([
+                T_COMMENT,
+                content
+            ]);
+            if (content.includes('*/')) inBlockComment = false;
+        } else if (content === '') ; else if (content.startsWith('//')) {
+            out.push([
+                T_COMMENT,
+                content
+            ]);
+        } else if (content.startsWith('/*')) {
+            out.push([
+                T_COMMENT,
+                content
+            ]);
+            if (!content.includes('*/')) inBlockComment = true;
+        } else if (content[0] === '@') {
+            // at-rule / control directive — symbols handled by applySassSymbols.
+            out.push(...lexInline(content));
+        } else if (content[0] === '=' || content[0] === '+') {
+            // indented-syntax mixin define (=name) / include (+name).
+            out.push([
+                T_SIGN,
+                content[0]
+            ]);
+            const rest = content.slice(1);
+            const nameMatch = rest.match(/^[\w-]+/)?.[0];
+            if (nameMatch) {
+                out.push([
+                    T_ENTITY,
+                    nameMatch
+                ]);
+                out.push(...lexInline(rest.slice(nameMatch.length)));
+            } else {
+                out.push(...lexInline(rest));
+            }
+        } else {
+            const decl = content.match(/^(\$?[\w-]+)\s*:(.*)$/);
+            const isPseudoSelector = decl ? hasChildren(l) && /^\S/.test(decl[2]) : false;
+            if (decl && !isPseudoSelector) {
+                // declaration: `prop: value` or `$var: value`
+                const [, prop, rest] = decl;
+                out.push([
+                    T_PROPERTY,
+                    prop
+                ]);
+                const colonAt = content.indexOf(':', prop.length);
+                out.push([
+                    T_SIGN,
+                    ':'
+                ]);
+                out.push(...lexInline(content.slice(colonAt + 1)));
+            } else {
+                // selector line
+                const tokens = lexInline(content);
+                retagSelector(tokens);
+                out.push(...tokens);
+            }
+        }
+        if (l < lines.length - 1) out.push([
+            T_BREAK,
+            '\n'
+        ]);
+    }
+    return out;
+};
+const config = {
+    tokenize
+};
+
+export { config, tokenize };

package/dist/lang/scss.d.ts

@@ -0,0 +1,14 @@
+import { ParseOptions } from '../core.js';
+
+/** A lexer emits these: `[numericType, value]`. */
+type Token = [number, string];
+
+/** SCSS — CSS brace/semicolon structure plus Sass features ($vars, @rules, %placeholder,
+ * #{} interpolation, // line comments, math, !flags). Structure is CSS's; symbols are Sass's. */
+
+declare const onCommentStart: (curr: string, next: string) => number;
+declare const onCommentEnd: (prev: string, curr: string) => number;
+declare const tokenize: (code: string, options?: ParseOptions) => Token[];
+declare const config: ParseOptions;
+
+export { config, onCommentEnd, onCommentStart, tokenize };

package/dist/lang/scss.js

@@ -0,0 +1,105 @@
+import { tokenize as tokenize$1 } from '../core.js';
+import { onLiteral, mergeDashedNames, cssDeclarationPass } from './css.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_KEYWORD = 1;
+const T_CLASS = 3;
+const T_PROPERTY = 4;
+const T_ENTITY = 5;
+const T_SIGN = 7;
+({
+    TokenMap: new Map(TokenTypes.map((type, index)=>[
+            type,
+            index
+        ]))
+});
+
+const isNameType = (type)=>type === T_IDENTIFIER || type === T_CLASS || type === T_PROPERTY;
+function applySassSymbols(tokens) {
+    for(let i = 0; i < tokens.length; i++){
+        const token = tokens[i];
+        const [type, value] = token;
+        // $variable — the plain lexer already keeps `$name` as one word token.
+        if (isNameType(type) && value[0] === '$') {
+            token[0] = T_PROPERTY;
+            continue;
+        }
+        if (type === T_SIGN) {
+            const next = tokens[i + 1];
+            // @at-rule: merge '@' + word → keyword (@mixin, @include, @if, @use, …).
+            if (value === '@' && next && isNameType(next[0])) {
+                tokens.splice(i, 2, [
+                    T_KEYWORD,
+                    '@' + next[1]
+                ]);
+                continue;
+            }
+            // %placeholder selector: merge '%' + word → class.
+            if (value === '%' && next && isNameType(next[0])) {
+                tokens.splice(i, 2, [
+                    T_CLASS,
+                    '%' + next[1]
+                ]);
+                continue;
+            }
+            // !flag: merge '!' + word → keyword (!default, !global, !important, !optional).
+            if (value === '!' && next && isNameType(next[0])) {
+                tokens.splice(i, 2, [
+                    T_KEYWORD,
+                    '!' + next[1]
+                ]);
+                continue;
+            }
+        }
+        // function / mixin call: a name directly before '(' → entity.
+        if (isNameType(type) && value[0] !== '$') {
+            const next = tokens[i + 1];
+            if (next && next[0] === T_SIGN && next[1] === '(') token[0] = T_ENTITY;
+        }
+    }
+}
+
+const onCommentStart = (curr, next)=>curr === '/' && next === '*' ? 2 : curr === '/' && next === '/' ? 1 : 0;
+const onCommentEnd = (prev, curr)=>curr === '\n' ? 1 : prev === '*' && curr === '/' ? 2 : 0;
+const tokenize = (code, options)=>{
+    const tokens = tokenize$1(code, {
+        ...options,
+        tokenize: undefined,
+        onCommentStart,
+        onCommentEnd,
+        onLiteral
+    });
+    mergeDashedNames(tokens);
+    cssDeclarationPass(tokens);
+    applySassSymbols(tokens);
+    return tokens;
+};
+const config = {
+    onCommentStart,
+    onCommentEnd,
+    onLiteral,
+    tokenize
+};
+
+export { config, onCommentEnd, onCommentStart, tokenize };

package/dist/lang/shell.d.ts

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

package/dist/lang/shell.js

@@ -0,0 +1,64 @@
+/** 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: [
+        "case",
+        "coproc",
+        "do",
+        "done",
+        "elif",
+        "else",
+        "esac",
+        "export",
+        "fi",
+        "for",
+        "function",
+        "if",
+        "in",
+        "local",
+        "readonly",
+        "return",
+        "select",
+        "then",
+        "time",
+        "until",
+        "while"
+    ],
+    comments: {
+        "line": [
+            "#"
+        ]
+    }
+});
+
+export { config };

package/dist/lang/sql.d.ts

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