fractalpop 0.1.0

package/dist/lang/sql.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);
+    config.caseInsensitive = true;
+    if (spec.comments) Object.assign(config, commentRules(spec.comments));
+    return config;
+}
+
+const config = keywordLang({
+    keywords: [
+        "add",
+        "all",
+        "alter",
+        "and",
+        "as",
+        "asc",
+        "between",
+        "by",
+        "case",
+        "check",
+        "column",
+        "constraint",
+        "create",
+        "cross",
+        "database",
+        "default",
+        "delete",
+        "desc",
+        "distinct",
+        "drop",
+        "else",
+        "end",
+        "exists",
+        "foreign",
+        "from",
+        "full",
+        "group",
+        "having",
+        "in",
+        "index",
+        "inner",
+        "insert",
+        "into",
+        "is",
+        "join",
+        "key",
+        "left",
+        "like",
+        "limit",
+        "not",
+        "null",
+        "offset",
+        "on",
+        "or",
+        "order",
+        "outer",
+        "primary",
+        "references",
+        "right",
+        "select",
+        "set",
+        "table",
+        "then",
+        "union",
+        "unique",
+        "update",
+        "values",
+        "view",
+        "when",
+        "where",
+        "with"
+    ],
+    typeKeywords: [
+        "bigint",
+        "binary",
+        "bit",
+        "blob",
+        "boolean",
+        "char",
+        "date",
+        "datetime",
+        "decimal",
+        "double",
+        "float",
+        "int",
+        "integer",
+        "interval",
+        "json",
+        "numeric",
+        "real",
+        "smallint",
+        "text",
+        "time",
+        "timestamp",
+        "uuid",
+        "varchar"
+    ],
+    comments: {
+        "line": [
+            "--"
+        ],
+        "block": true
+    }});
+
+export { config };

package/dist/lang/svelte.d.ts

@@ -0,0 +1,15 @@
+import { ParseOptions } from '../core.js';
+
+/** A lexer emits these: `[numericType, value]`. */
+type Token = [number, string];
+
+/** Svelte composite lexer. A `.svelte` file mixes three languages:
+ *   <script [lang=ts]> … </script>   → the JS/TS runtime
+ *   markup with {expr} / {#if} / {@render} blocks → Svelte markup (expressions delegated to JS)
+ *   <style [lang=sass|scss]> … </style> → the css / scss / sass tokenizer
+ * The region splitter tokenizes each part and concatenates the streams in source order. */
+
+declare const tokenize: (code: string) => Token[];
+declare const config: ParseOptions;
+
+export { config, tokenize };

package/dist/lang/swift.d.ts

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

package/dist/lang/swift.js

@@ -0,0 +1,125 @@
+/** 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",
+        "associatedtype",
+        "break",
+        "case",
+        "catch",
+        "class",
+        "continue",
+        "convenience",
+        "default",
+        "defer",
+        "deinit",
+        "didSet",
+        "do",
+        "dynamic",
+        "else",
+        "enum",
+        "extension",
+        "fallthrough",
+        "false",
+        "fileprivate",
+        "final",
+        "for",
+        "func",
+        "get",
+        "guard",
+        "if",
+        "import",
+        "in",
+        "indirect",
+        "infix",
+        "init",
+        "inout",
+        "internal",
+        "is",
+        "lazy",
+        "let",
+        "mutating",
+        "nil",
+        "nonmutating",
+        "open",
+        "operator",
+        "override",
+        "precedencegroup",
+        "private",
+        "protocol",
+        "public",
+        "repeat",
+        "required",
+        "rethrows",
+        "return",
+        "self",
+        "set",
+        "some",
+        "static",
+        "struct",
+        "subscript",
+        "super",
+        "switch",
+        "throw",
+        "throws",
+        "true",
+        "try",
+        "typealias",
+        "unowned",
+        "var",
+        "weak",
+        "where",
+        "while",
+        "willSet"
+    ],
+    typeKeywords: [
+        "Any",
+        "Bool",
+        "Character",
+        "Double",
+        "Float",
+        "Int",
+        "Never",
+        "String",
+        "UInt",
+        "Void"
+    ],
+    comments: {
+        "line": [
+            "//"
+        ],
+        "block": true
+    }
+});
+
+export { config };

package/dist/lang/toml.d.ts

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

package/dist/lang/toml.js

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

package/dist/lang/typescript.d.ts

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

package/dist/lang/yaml.d.ts

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

package/dist/lang/yaml.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: [
+        "false",
+        "False",
+        "FALSE",
+        "no",
+        "No",
+        "NO",
+        "null",
+        "Null",
+        "NULL",
+        "off",
+        "Off",
+        "OFF",
+        "on",
+        "On",
+        "ON",
+        "true",
+        "True",
+        "TRUE",
+        "yes",
+        "Yes",
+        "YES"
+    ],
+    comments: {
+        "line": [
+            "#"
+        ]
+    }
+});
+
+export { config };

package/dist/lang/zig.d.ts

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

package/dist/lang/zig.js

@@ -0,0 +1,133 @@
+/** 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: [
+        "addrspace",
+        "align",
+        "allowzero",
+        "and",
+        "anyframe",
+        "anytype",
+        "asm",
+        "async",
+        "await",
+        "break",
+        "callconv",
+        "catch",
+        "comptime",
+        "const",
+        "continue",
+        "defer",
+        "else",
+        "enum",
+        "errdefer",
+        "error",
+        "export",
+        "extern",
+        "false",
+        "fn",
+        "for",
+        "if",
+        "inline",
+        "linksection",
+        "noalias",
+        "noinline",
+        "nosuspend",
+        "null",
+        "opaque",
+        "or",
+        "orelse",
+        "packed",
+        "pub",
+        "resume",
+        "return",
+        "struct",
+        "suspend",
+        "switch",
+        "test",
+        "threadlocal",
+        "true",
+        "try",
+        "undefined",
+        "union",
+        "unreachable",
+        "usingnamespace",
+        "var",
+        "volatile",
+        "while"
+    ],
+    typeKeywords: [
+        "anyerror",
+        "anyopaque",
+        "bool",
+        "c_char",
+        "c_int",
+        "c_long",
+        "c_longdouble",
+        "c_longlong",
+        "c_short",
+        "c_uint",
+        "c_ulong",
+        "c_ulonglong",
+        "c_ushort",
+        "comptime_float",
+        "comptime_int",
+        "f16",
+        "f32",
+        "f64",
+        "f80",
+        "f128",
+        "i8",
+        "i16",
+        "i32",
+        "i64",
+        "i128",
+        "isize",
+        "noreturn",
+        "type",
+        "u8",
+        "u16",
+        "u32",
+        "u64",
+        "u128",
+        "usize",
+        "void"
+    ],
+    comments: {
+        "line": [
+            "//"
+        ]
+    }
+});
+
+export { config };

package/dist/lang.d.ts

@@ -0,0 +1,30 @@
+import { ParseOptions } from './core.js';
+
+/** Mutable registry that maps a canonical language id to its parse config. */
+
+declare function getLanguageConfig(id: string): ParseOptions | undefined;
+
+/** Mutable language metadata registry with alias/extension normalization. */
+
+interface Language {
+    id: string;
+    extension: string;
+    aliases: readonly string[];
+}
+declare function registerLanguage(language: Language, config?: ParseOptions): void;
+declare function setDefaults(languages: readonly Language[]): void;
+declare function setDefaults(configs: Record<string, ParseOptions>): void;
+declare function importDefaults(ids: string[]): Promise<void>;
+/** Find canonical language metadata by name, alias, or extension. */
+declare function findLanguage(name: string): Language | undefined;
+/** Resolve a name/alias/extension to its canonical language id. */
+declare function lang(name: string): string | undefined;
+/** Alias for {@link lang}. */
+declare const canonicalizeLang: typeof lang;
+declare function getRegisteredLanguages(): readonly Language[];
+declare function resetLanguageRegistry(): void;
+
+declare const allLanguages: readonly Language[];
+
+export { allLanguages, canonicalizeLang, findLanguage, getLanguageConfig, getRegisteredLanguages, importDefaults, lang, registerLanguage, resetLanguageRegistry, setDefaults };
+export type { Language };