yaxa-svelte 2.0.4 → 2.2.0

package/dist/components/elements/CodeBlock.svelte

@@ -46,10 +46,15 @@
 		const isSvelte = ['svelte', 'svelte5', 'sv'].includes(lang);
 		const isHtml = ['html', 'xml', 'svg'].includes(lang);
 		const isPython = ['python', 'py'].includes(lang);
-		const isSql = lang === 'sql';
+		const isRust = ['rust', 'rs'].includes(lang);
+		const isGo = ['go', 'golang'].includes(lang);
+		const isSql = ['sql', 'pgsql', 'postgres', 'postgresql', 'mysql', 'sqlite'].includes(lang);
+		const isGraphQL = ['graphql', 'gql'].includes(lang);
 		const isBash = ['bash', 'sh', 'zsh', 'shell'].includes(lang);
 		const isJson = ['json', 'jsonc', 'json5'].includes(lang);
 		const isCss = ['css', 'scss', 'postcss', 'tailwind', 'tailwindcss'].includes(lang);
+		const isYaml = ['yaml', 'yml'].includes(lang);
+		const isToml = ['toml', 'cargo'].includes(lang);
 
 		let multilineState:
 			| null
@@ -179,7 +184,7 @@
 
 				if (
 					(!isLatex && remaining.startsWith('//')) ||
-					((isPython || isBash || lang === 'env' || lang === 'yaml' || lang === 'yml') &&
+					((isPython || isBash || lang === 'env' || isYaml || isToml || isGraphQL) &&
 						remaining.startsWith('#')) ||
 					(isLatex && remaining.startsWith('%')) ||
 					(isSql && remaining.startsWith('--'))
@@ -188,8 +193,8 @@
 					break;
 				}
 
-				// 2. Python Triple-Quoted Strings (Docstrings)
-				if (isPython && (remaining.startsWith('"""') || remaining.startsWith("'''"))) {
+				// 2. Python & TOML Triple-Quoted Strings (Docstrings / Multiline)
+				if ((isPython || isToml) && (remaining.startsWith('"""') || remaining.startsWith("'''"))) {
 					const delim = remaining.startsWith('"""') ? '"""' : "'''";
 					const closeIdx = remaining.indexOf(delim, 3);
 					if (closeIdx !== -1) {
@@ -228,6 +233,110 @@
 					}
 				}
 
+				// 4b. YAML Key-Value Pairs, Anchors, Aliases & Directives
+				if (isYaml) {
+					// Anchors & Aliases (&anchor, *alias)
+					const anchorMatch = remaining.match(/^([&*][\w.-]+)/);
+					if (anchorMatch) {
+						tokens.push({ text: anchorMatch[0], type: 'macro' });
+						remaining = remaining.slice(anchorMatch[0].length);
+						continue;
+					}
+
+					// Tags (!!str, !!int, !!map, !custom)
+					const yamlTagMatch = remaining.match(/^(!{1,2}[\w.-]+)/);
+					if (yamlTagMatch) {
+						tokens.push({ text: yamlTagMatch[0], type: 'directive' });
+						remaining = remaining.slice(yamlTagMatch[0].length);
+						continue;
+					}
+
+					// Document start/end markers (--- or ...)
+					if (remaining === line) {
+						const docMarkerMatch = remaining.match(/^(\s*(?:---|(?:\.\.\.))\s*)$/);
+						if (docMarkerMatch) {
+							tokens.push({ text: docMarkerMatch[1], type: 'punctuation' });
+							remaining = remaining.slice(docMarkerMatch[1].length);
+							continue;
+						}
+					}
+
+					// Quoted keys before ':'
+					const yamlQuotedKeyMatch = remaining.match(
+						/^("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')(?=\s*:(?:\s|$))/
+					);
+					if (yamlQuotedKeyMatch) {
+						tokens.push({ text: yamlQuotedKeyMatch[1], type: 'attr' });
+						remaining = remaining.slice(yamlQuotedKeyMatch[1].length);
+						continue;
+					}
+
+					// Bare keys before ':'
+					const yamlKeyMatch = remaining.match(/^([\w.-]+)(?=\s*:(?:\s|$))/);
+					if (yamlKeyMatch) {
+						tokens.push({ text: yamlKeyMatch[0], type: 'attr' });
+						remaining = remaining.slice(yamlKeyMatch[0].length);
+						continue;
+					}
+
+					// YAML booleans, nulls & block scalar indicators
+					const yamlKwMatch = remaining.match(/^(true|false|yes|no|on|off|null|~|[|>][+-]?)\b/i);
+					if (yamlKwMatch) {
+						tokens.push({ text: yamlKwMatch[0], type: 'keyword' });
+						remaining = remaining.slice(yamlKwMatch[0].length);
+						continue;
+					}
+				}
+
+				// 4c. TOML Table Headers & Key-Value Pairs
+				if (isToml) {
+					// Table headers ([table] or [[array_of_tables]])
+					const tomlTableMatch = remaining.match(/^(\[\[?[\w.:"-]+\]\]?)/);
+					if (tomlTableMatch) {
+						tokens.push({ text: tomlTableMatch[0], type: 'directive' });
+						remaining = remaining.slice(tomlTableMatch[0].length);
+						continue;
+					}
+
+					// Quoted keys before '='
+					const tomlQuotedKeyMatch = remaining.match(
+						/^("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')(?=\s*=)/
+					);
+					if (tomlQuotedKeyMatch) {
+						tokens.push({ text: tomlQuotedKeyMatch[1], type: 'attr' });
+						remaining = remaining.slice(tomlQuotedKeyMatch[1].length);
+						continue;
+					}
+
+					// Bare or dotted keys before '='
+					const tomlKeyMatch = remaining.match(/^([\w.-]+)(?=\s*=)/);
+					if (tomlKeyMatch) {
+						tokens.push({ text: tomlKeyMatch[0], type: 'attr' });
+						remaining = remaining.slice(tomlKeyMatch[0].length);
+						continue;
+					}
+
+					// Special TOML float constants (+inf, -inf, nan)
+					const tomlFloatMatch = remaining.match(/^([+-]?(?:inf|nan))\b/i);
+					if (tomlFloatMatch) {
+						tokens.push({ text: tomlFloatMatch[0], type: 'number' });
+						remaining = remaining.slice(tomlFloatMatch[0].length);
+						continue;
+					}
+				}
+
+				// 4d. ISO Dates / Timestamps for YAML & TOML
+				if (isYaml || isToml) {
+					const dateMatch = remaining.match(
+						/^(\d{4}-\d{2}-\d{2}(?:[Tt\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[Zz]|[+-]\d{2}:\d{2})?)?|\d{2}:\d{2}:\d{2}(?:\.\d+)?)\b/
+					);
+					if (dateMatch) {
+						tokens.push({ text: dateMatch[0], type: 'number' });
+						remaining = remaining.slice(dateMatch[0].length);
+						continue;
+					}
+				}
+
 				// 5. CSS & Tailwind CSS v4 At-Rules, Variables & Colors
 				if (isCss) {
 					// Tailwind v4 & CSS At-rules (@theme, @utility, @source, @plugin, @import, @custom-variant, etc.)
@@ -316,10 +425,10 @@
 					}
 				}
 
-				// 9. Python Built-in Types (int, str, dict, list, bool, etc.)
+				// 9. Python Built-in Types & Modern Typing Constructs (Python 3.0 to 3.13+)
 				if (isPython) {
 					const pyTypeMatch = remaining.match(
-						/^(str|int|float|bool|dict|list|tuple|set|bytes|Any|Optional|Union|Callable|Literal)\b/
+						/^(str|int|float|bool|dict|list|tuple|set|bytes|Any|Optional|Union|Callable|Literal|TypeIs|TypeGuard|Self)\b/
 					);
 					if (pyTypeMatch) {
 						tokens.push({ text: pyTypeMatch[0], type: 'macro' });
@@ -340,6 +449,126 @@
 					}
 				}
 
+				// 10b. Rust Attributes, Macro Invocations, Lifetimes & Standard Types
+				if (isRust) {
+					// Rust Attributes (#[derive(Debug, Clone)], #![no_std])
+					const rustAttrMatch = remaining.match(/^#(!?\[[\w:,()=\s"-]+\])/);
+					if (rustAttrMatch) {
+						tokens.push({ text: rustAttrMatch[0], type: 'decorator' });
+						remaining = remaining.slice(rustAttrMatch[0].length);
+						continue;
+					}
+
+					// Rust Macro Invocations (println!, vec!, format!, panic!, etc.)
+					const rustMacroMatch = remaining.match(
+						/^(println|eprintln|print|eprint|format|vec|panic|assert|assert_eq|assert_ne|todo|unimplemented|unreachable|write|writeln|cfg|include|env|concat)!/
+					);
+					if (rustMacroMatch) {
+						tokens.push({ text: rustMacroMatch[0], type: 'macro' });
+						remaining = remaining.slice(rustMacroMatch[0].length);
+						continue;
+					}
+
+					// Rust Lifetimes ('a, 'static)
+					const lifetimeMatch = remaining.match(/^'(?:static|[a-z_]\w*)(?!')\b/);
+					if (lifetimeMatch) {
+						tokens.push({ text: lifetimeMatch[0], type: 'macro' });
+						remaining = remaining.slice(lifetimeMatch[0].length);
+						continue;
+					}
+
+					// Rust Primitive & Standard Types
+					const rustTypeMatch = remaining.match(
+						/^(i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize|f32|f64|bool|char|str|String|Option|Result|Vec|Box|Rc|Arc|Cell|RefCell|Mutex|RwLock|HashMap|HashSet|BTreeMap|BTreeSet|Self|None|Some|Ok|Err)\b/
+					);
+					if (rustTypeMatch) {
+						tokens.push({ text: rustTypeMatch[0], type: 'macro' });
+						remaining = remaining.slice(rustTypeMatch[0].length);
+						continue;
+					}
+				}
+
+				// 10c. Go Primitive Types & Built-ins
+				if (isGo) {
+					const goTypeMatch = remaining.match(
+						/^(string|int|int8|int16|int32|int64|uint|uint8|uint16|uint32|uint64|uintptr|byte|rune|float32|float64|complex64|complex128|error|any|bool)\b/
+					);
+					if (goTypeMatch) {
+						tokens.push({ text: goTypeMatch[0], type: 'macro' });
+						remaining = remaining.slice(goTypeMatch[0].length);
+						continue;
+					}
+
+					const goBuiltinMatch = remaining.match(
+						/^(make|len|cap|new|append|copy|close|delete|panic|recover|print|println|complex|real|imag)\b(?=\s*\()/
+					);
+					if (goBuiltinMatch) {
+						tokens.push({ text: goBuiltinMatch[0], type: 'function' });
+						remaining = remaining.slice(goBuiltinMatch[0].length);
+						continue;
+					}
+				}
+
+				// 10d. SQL Data Types & Clauses
+				if (isSql) {
+					// SQL Standard Data Types
+					const sqlTypeMatch = remaining.match(
+						/^(INTEGER|INT|BIGINT|SMALLINT|TINYINT|SERIAL|BIGSERIAL|VARCHAR|TEXT|CHAR|CHARACTER|BOOLEAN|BOOL|DATE|TIME|TIMESTAMP|TIMESTAMPTZ|NUMERIC|DECIMAL|FLOAT|REAL|DOUBLE\s+PRECISION|DOUBLE|JSON|JSONB|UUID|BLOB|BYTEA|ARRAY|INTERVAL)\b/i
+					);
+					if (sqlTypeMatch) {
+						tokens.push({ text: sqlTypeMatch[0], type: 'macro' });
+						remaining = remaining.slice(sqlTypeMatch[0].length);
+						continue;
+					}
+
+					// Comprehensive SQL Clauses & Keywords
+					const sqlKwMatch = remaining.match(
+						/^(CREATE|ALTER|DROP|TRUNCATE|TABLE|DATABASE|SCHEMA|VIEW|INDEX|TRIGGER|FUNCTION|PROCEDURE|PRIMARY|FOREIGN|KEY|REFERENCES|CONSTRAINT|CHECK|DEFAULT|UNIQUE|NOT|NULL|CASCADE|RESTRICT|SELECT|DISTINCT|FROM|WHERE|AND|OR|IN|BETWEEN|LIKE|ILIKE|IS|EXISTS|HAVING|GROUP|ORDER|BY|ASC|DESC|LIMIT|OFFSET|FETCH|FIRST|NEXT|ROWS|ONLY|JOIN|INNER|LEFT|RIGHT|FULL|OUTER|CROSS|ON|USING|INSERT|INTO|VALUES|UPDATE|SET|DELETE|RETURNING|UNION|INTERSECT|EXCEPT|ALL|CASE|WHEN|THEN|ELSE|END|AS|BEGIN|COMMIT|ROLLBACK|TRANSACTION|SAVEPOINT|GRANT|REVOKE|WITH|RECURSIVE|OVER|PARTITION)\b/i
+					);
+					if (sqlKwMatch) {
+						tokens.push({ text: sqlKwMatch[0], type: 'keyword' });
+						remaining = remaining.slice(sqlKwMatch[0].length);
+						continue;
+					}
+				}
+
+				// 10e. GraphQL Variables, Directives & Scalars
+				if (isGraphQL) {
+					// GraphQL Variables ($id, $input)
+					const gqlVarMatch = remaining.match(/^(\$[\w]+)\b/);
+					if (gqlVarMatch) {
+						tokens.push({ text: gqlVarMatch[0], type: 'macro' });
+						remaining = remaining.slice(gqlVarMatch[0].length);
+						continue;
+					}
+
+					// Directives (@include, @skip, @deprecated, @specifiedBy)
+					const gqlDirMatch = remaining.match(/^(@(?:include|skip|deprecated|specifiedBy))\b/);
+					if (gqlDirMatch) {
+						tokens.push({ text: gqlDirMatch[0], type: 'decorator' });
+						remaining = remaining.slice(gqlDirMatch[0].length);
+						continue;
+					}
+
+					// Core Scalars
+					const gqlScalarMatch = remaining.match(/^(String|Int|Float|Boolean|ID)\b/);
+					if (gqlScalarMatch) {
+						tokens.push({ text: gqlScalarMatch[0], type: 'macro' });
+						remaining = remaining.slice(gqlScalarMatch[0].length);
+						continue;
+					}
+
+					// GraphQL Keywords
+					const gqlKwMatch = remaining.match(
+						/^(query|mutation|subscription|fragment|on|type|input|interface|union|enum|scalar|schema|directive|extend)\b/
+					);
+					if (gqlKwMatch) {
+						tokens.push({ text: gqlKwMatch[0], type: 'keyword' });
+						remaining = remaining.slice(gqlKwMatch[0].length);
+						continue;
+					}
+				}
+
 				// 11. Bash / Shell Variables & CLI Flags
 				if (isBash) {
 					const bashVarMatch = remaining.match(/^(\$\{?[\w#?@*!$-]+\}?)/);
@@ -591,7 +820,7 @@
 			? 'text-neutral-800 dark:text-neutral-200'
 			: 'text-neutral-200'} {wrap ? 'whitespace-pre-wrap' : 'whitespace-pre'}"><code
 			class="language-{language}"
-			>{#each tokenizedLines as lineTokens, lineIdx}{@const lineNum =
+			>{#each tokenizedLines as lineTokens, lineIdx (lineIdx)}{@const lineNum =
 					lineIdx + 1}{@const isHighlighted = highlightLines.includes(lineNum)}<div
 					class="table-row {isHighlighted
 						? '-mx-4 block border-l-2 border-primary-500 bg-primary-500/10 px-4'
@@ -600,7 +829,7 @@
 								? 'text-neutral-400 dark:text-neutral-600'
 								: 'text-neutral-600 dark:text-neutral-500'}">{lineNum}</span
 						>{/if}<span class="table-cell"
-						>{#each lineTokens as token}{#if token.type === 'rune'}<span
+						>{#each lineTokens as token, tokenIdx (tokenIdx)}{#if token.type === 'rune'}<span
 									class="font-bold text-amber-500 dark:text-amber-400">{token.text}</span
 								>{:else if token.type === 'keyword'}<span class="font-semibold text-primary-500"
 									>{token.text}</span

package/dist/components/elements/CodeBlock.test.js

@@ -48,6 +48,36 @@ describe('tokenizeCode', () => {
         const line4 = tokens[4].map((t) => ({ text: t.text, type: t.type }));
         expect(line4).toContainEqual({ text: 'assert', type: 'keyword' });
     });
+    it('tokenizes Python 3.13+ syntax: type parameters, TypeIs narrowing, match/case and decorators', () => {
+        const pyCode = `type Point[T = int] = tuple[T, T]
+@deprecated
+def is_str(val: object) -> TypeIs[str]:
+    match val:
+        case str():
+            return True
+        case _:
+            return False`;
+        const tokens = tokenizeCode(pyCode, 'python');
+        expect(tokens).toHaveLength(8);
+        // Line 0: type Point[T = int] = tuple[T, T]
+        const line0 = tokens[0].map((t) => ({ text: t.text, type: t.type }));
+        expect(line0).toContainEqual({ text: 'type', type: 'keyword' });
+        expect(line0).toContainEqual({ text: 'int', type: 'macro' });
+        expect(line0).toContainEqual({ text: 'tuple', type: 'macro' });
+        // Line 1: @deprecated
+        const line1 = tokens[1].map((t) => ({ text: t.text, type: t.type }));
+        expect(line1).toContainEqual({ text: '@deprecated', type: 'decorator' });
+        // Line 2: def is_str(val: object) -> TypeIs[str]:
+        const line2 = tokens[2].map((t) => ({ text: t.text, type: t.type }));
+        expect(line2).toContainEqual({ text: 'def', type: 'keyword' });
+        expect(line2).toContainEqual({ text: 'TypeIs', type: 'macro' });
+        expect(line2).toContainEqual({ text: 'str', type: 'macro' });
+        // Line 3 & 4: match / case
+        const line3 = tokens[3].map((t) => ({ text: t.text, type: t.type }));
+        expect(line3).toContainEqual({ text: 'match', type: 'keyword' });
+        const line4 = tokens[4].map((t) => ({ text: t.text, type: t.type }));
+        expect(line4).toContainEqual({ text: 'case', type: 'keyword' });
+    });
     it('tokenizes tailwind css v4 at-rules, variables and hex colors', () => {
         const cssCode = `@theme {
   --color-primary-500: #ff3e00;
@@ -150,4 +180,201 @@ type TaskResult = Awaited<Promise<Record<string, unknown>>>;`;
         const line11 = tokens[11].map((t) => ({ text: t.text, type: t.type }));
         expect(line11).toContainEqual({ text: 'Awaited', type: 'macro' });
     });
+    it('tokenizes YAML keys, anchors, aliases, tags, booleans and document markers', () => {
+        const yamlCode = `---
+# App configuration
+name: "yaxa-app"
+version: 2.1
+enabled: true
+maintenance: off
+defaults: &base_config
+  timeout: 30
+production: *base_config
+tag_demo: !custom_tag
+created_at: 2026-10-27`;
+        const tokens = tokenizeCode(yamlCode, 'yaml');
+        expect(tokens).toHaveLength(11);
+        // Line 0: ---
+        expect(tokens[0][0]).toEqual({ text: '---', type: 'punctuation' });
+        // Line 1: # App configuration
+        expect(tokens[1][0]).toEqual({ text: '# App configuration', type: 'comment' });
+        // Line 2: name: "yaxa-app"
+        const line2 = tokens[2].map((t) => ({ text: t.text, type: t.type }));
+        expect(line2).toContainEqual({ text: 'name', type: 'attr' });
+        expect(line2).toContainEqual({ text: '"yaxa-app"', type: 'string' });
+        // Line 4: enabled: true
+        const line4 = tokens[4].map((t) => ({ text: t.text, type: t.type }));
+        expect(line4).toContainEqual({ text: 'enabled', type: 'attr' });
+        expect(line4).toContainEqual({ text: 'true', type: 'keyword' });
+        // Line 5: maintenance: off
+        const line5 = tokens[5].map((t) => ({ text: t.text, type: t.type }));
+        expect(line5).toContainEqual({ text: 'maintenance', type: 'attr' });
+        expect(line5).toContainEqual({ text: 'off', type: 'keyword' });
+        // Line 6: defaults: &base_config
+        const line6 = tokens[6].map((t) => ({ text: t.text, type: t.type }));
+        expect(line6).toContainEqual({ text: 'defaults', type: 'attr' });
+        expect(line6).toContainEqual({ text: '&base_config', type: 'macro' });
+        // Line 8: production: *base_config
+        const line8 = tokens[8].map((t) => ({ text: t.text, type: t.type }));
+        expect(line8).toContainEqual({ text: 'production', type: 'attr' });
+        expect(line8).toContainEqual({ text: '*base_config', type: 'macro' });
+        // Line 9: tag_demo: !custom_tag
+        const line9 = tokens[9].map((t) => ({ text: t.text, type: t.type }));
+        expect(line9).toContainEqual({ text: 'tag_demo', type: 'attr' });
+        expect(line9).toContainEqual({ text: '!custom_tag', type: 'directive' });
+        // Line 10: created_at: 2026-10-27
+        const line10 = tokens[10].map((t) => ({ text: t.text, type: t.type }));
+        expect(line10).toContainEqual({ text: 'created_at', type: 'attr' });
+        expect(line10).toContainEqual({ text: '2026-10-27', type: 'number' });
+    });
+    it('tokenizes TOML table headers, keys, dates, and multiline strings', () => {
+        const tomlCode = `[server]
+port = 8080
+enabled = true
+started = 1979-05-27T07:32:00Z
+bio = """
+Hello World
+Multilined
+"""`;
+        const tokens = tokenizeCode(tomlCode, 'toml');
+        expect(tokens).toHaveLength(8);
+        // Line 0: [server]
+        expect(tokens[0][0]).toEqual({ text: '[server]', type: 'directive' });
+        // Line 1: port = 8080
+        const line1 = tokens[1].map((t) => ({ text: t.text, type: t.type }));
+        expect(line1).toContainEqual({ text: 'port', type: 'attr' });
+        expect(line1).toContainEqual({ text: '8080', type: 'number' });
+        // Line 2: enabled = true
+        const line2 = tokens[2].map((t) => ({ text: t.text, type: t.type }));
+        expect(line2).toContainEqual({ text: 'enabled', type: 'attr' });
+        expect(line2).toContainEqual({ text: 'true', type: 'keyword' });
+        // Line 3: started = 1979-05-27T07:32:00Z
+        const line3 = tokens[3].map((t) => ({ text: t.text, type: t.type }));
+        expect(line3).toContainEqual({ text: 'started', type: 'attr' });
+        expect(line3).toContainEqual({ text: '1979-05-27T07:32:00Z', type: 'number' });
+        // Multiline string across lines 4, 5, 6, 7
+        expect(tokens[4].some((t) => t.type === 'string')).toBe(true);
+        expect(tokens[5][0].type).toBe('string');
+        expect(tokens[6][0].type).toBe('string');
+        expect(tokens[7].some((t) => t.type === 'string')).toBe(true);
+    });
+    it('tokenizes Rust attributes, macros, lifetimes, and standard types to Tier 1 standard', () => {
+        const rustCode = `#[derive(Debug, Clone)]
+pub fn process<'a>(name: &'a str) -> Option<String> {
+    let items: Vec<i32> = vec![1, 2, 3];
+    println!("Processed: {}", name);
+    Some(name.to_string())
+}`;
+        const tokens = tokenizeCode(rustCode, 'rust');
+        expect(tokens).toHaveLength(6);
+        // Line 0: #[derive(Debug, Clone)]
+        expect(tokens[0][0].type).toBe('decorator');
+        // Line 1: pub fn process<'a>(name: &'a str) -> Option<String>
+        const line1 = tokens[1].map((t) => ({ text: t.text, type: t.type }));
+        expect(line1).toContainEqual({ text: 'pub', type: 'keyword' });
+        expect(line1).toContainEqual({ text: 'fn', type: 'keyword' });
+        expect(line1).toContainEqual({ text: "'a", type: 'macro' });
+        expect(line1).toContainEqual({ text: 'str', type: 'macro' });
+        expect(line1).toContainEqual({ text: 'Option', type: 'macro' });
+        expect(line1).toContainEqual({ text: 'String', type: 'macro' });
+        // Line 2: let items: Vec<i32> = vec![1, 2, 3];
+        const line2 = tokens[2].map((t) => ({ text: t.text, type: t.type }));
+        expect(line2).toContainEqual({ text: 'Vec', type: 'macro' });
+        expect(line2).toContainEqual({ text: 'i32', type: 'macro' });
+        expect(line2).toContainEqual({ text: 'vec!', type: 'macro' });
+        // Line 3: println!("...")
+        const line3 = tokens[3].map((t) => ({ text: t.text, type: t.type }));
+        expect(line3).toContainEqual({ text: 'println!', type: 'macro' });
+        // Line 4: Some(...)
+        const line4 = tokens[4].map((t) => ({ text: t.text, type: t.type }));
+        expect(line4).toContainEqual({ text: 'Some', type: 'macro' });
+    });
+    it('tokenizes Go built-in functions and primitive types to Tier 1 standard', () => {
+        const goCode = `package main
+func NewBuffer(size int) (error, any) {
+    buf := make([]byte, size)
+    println(len(buf))
+    return nil, buf
+}`;
+        const tokens = tokenizeCode(goCode, 'go');
+        expect(tokens).toHaveLength(6);
+        // Line 0: package main
+        expect(tokens[0].some((t) => t.text === 'package' && t.type === 'keyword')).toBe(true);
+        // Line 1: func NewBuffer(size int) (error, any)
+        const line1 = tokens[1].map((t) => ({ text: t.text, type: t.type }));
+        expect(line1).toContainEqual({ text: 'func', type: 'keyword' });
+        expect(line1).toContainEqual({ text: 'int', type: 'macro' });
+        expect(line1).toContainEqual({ text: 'error', type: 'macro' });
+        expect(line1).toContainEqual({ text: 'any', type: 'macro' });
+        // Line 2: make([]byte)
+        const line2 = tokens[2].map((t) => ({ text: t.text, type: t.type }));
+        expect(line2).toContainEqual({ text: 'make', type: 'function' });
+        expect(line2).toContainEqual({ text: 'byte', type: 'macro' });
+        // Line 3: len(buf)
+        const line3 = tokens[3].map((t) => ({ text: t.text, type: t.type }));
+        expect(line3).toContainEqual({ text: 'len', type: 'function' });
+    });
+    it('tokenizes SQL DDL, constraints, clauses, and data types to Tier 1 standard', () => {
+        const sqlCode = `CREATE TABLE users (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    email VARCHAR(255) NOT NULL UNIQUE,
+    metadata JSONB,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);
+SELECT id, email FROM users WHERE id IS NOT NULL ORDER BY created_at DESC LIMIT 10;`;
+        const tokens = tokenizeCode(sqlCode, 'sql');
+        expect(tokens).toHaveLength(7);
+        // Line 0: CREATE TABLE users (
+        const line0 = tokens[0].map((t) => ({ text: t.text.toUpperCase(), type: t.type }));
+        expect(line0).toContainEqual({ text: 'CREATE', type: 'keyword' });
+        expect(line0).toContainEqual({ text: 'TABLE', type: 'keyword' });
+        // Line 1: id UUID PRIMARY KEY DEFAULT ...
+        const line1 = tokens[1].map((t) => ({ text: t.text.toUpperCase(), type: t.type }));
+        expect(line1).toContainEqual({ text: 'UUID', type: 'macro' });
+        expect(line1).toContainEqual({ text: 'PRIMARY', type: 'keyword' });
+        expect(line1).toContainEqual({ text: 'KEY', type: 'keyword' });
+        expect(line1).toContainEqual({ text: 'DEFAULT', type: 'keyword' });
+        // Line 2: VARCHAR
+        const line2 = tokens[2].map((t) => ({ text: t.text.toUpperCase(), type: t.type }));
+        expect(line2).toContainEqual({ text: 'VARCHAR', type: 'macro' });
+        expect(line2).toContainEqual({ text: 'NOT', type: 'keyword' });
+        expect(line2).toContainEqual({ text: 'NULL', type: 'keyword' });
+        expect(line2).toContainEqual({ text: 'UNIQUE', type: 'keyword' });
+        // Line 3: JSONB
+        const line3 = tokens[3].map((t) => ({ text: t.text.toUpperCase(), type: t.type }));
+        expect(line3).toContainEqual({ text: 'JSONB', type: 'macro' });
+        // Line 4: TIMESTAMPTZ
+        const line4 = tokens[4].map((t) => ({ text: t.text.toUpperCase(), type: t.type }));
+        expect(line4).toContainEqual({ text: 'TIMESTAMPTZ', type: 'macro' });
+        // Line 6: SELECT query
+        const line6 = tokens[6].map((t) => ({ text: t.text.toUpperCase(), type: t.type }));
+        expect(line6).toContainEqual({ text: 'SELECT', type: 'keyword' });
+        expect(line6).toContainEqual({ text: 'FROM', type: 'keyword' });
+        expect(line6).toContainEqual({ text: 'WHERE', type: 'keyword' });
+        expect(line6).toContainEqual({ text: 'ORDER', type: 'keyword' });
+        expect(line6).toContainEqual({ text: 'BY', type: 'keyword' });
+        expect(line6).toContainEqual({ text: 'DESC', type: 'keyword' });
+        expect(line6).toContainEqual({ text: 'LIMIT', type: 'keyword' });
+    });
+    it('tokenizes GraphQL queries, variables, directives, and scalar types to Tier 1 standard', () => {
+        const gqlCode = `query GetUser($userId: ID!, $withDetails: Boolean = true) {
+  user(id: $userId) {
+    id
+    name
+    email @include(if: $withDetails)
+  }
+}`;
+        const tokens = tokenizeCode(gqlCode, 'graphql');
+        expect(tokens).toHaveLength(7);
+        // Line 0: query GetUser($userId: ID!, $withDetails: Boolean = true)
+        const line0 = tokens[0].map((t) => ({ text: t.text, type: t.type }));
+        expect(line0).toContainEqual({ text: 'query', type: 'keyword' });
+        expect(line0).toContainEqual({ text: '$userId', type: 'macro' });
+        expect(line0).toContainEqual({ text: 'ID', type: 'macro' });
+        expect(line0).toContainEqual({ text: '$withDetails', type: 'macro' });
+        expect(line0).toContainEqual({ text: 'Boolean', type: 'macro' });
+        // Line 4: email @include(if: $withDetails)
+        const line4 = tokens[4].map((t) => ({ text: t.text, type: t.type }));
+        expect(line4).toContainEqual({ text: '@include', type: 'decorator' });
+    });
 });

package/dist/components/elements/CodeDiff.svelte

@@ -318,6 +318,8 @@
 										>{token.text}</span
 									>{:else if token.type === 'macro'}<span
 										class="font-semibold text-indigo-600 dark:text-indigo-400">{token.text}</span
+									>{:else if token.type === 'decorator'}<span
+										class="text-purple-600 dark:text-purple-400">{token.text}</span
 									>{:else if token.type === 'number'}<span
 										class="text-purple-600 dark:text-purple-400">{token.text}</span
 									>{:else if token.type === 'punctuation'}<span
@@ -378,6 +380,12 @@
 									<span class="text-amber-600 dark:text-amber-300">{token.text}</span>
 								{:else if token.type === 'function'}
 									<span class="text-sky-600 dark:text-sky-400">{token.text}</span>
+								{:else if token.type === 'macro'}
+									<span class="font-semibold text-indigo-600 dark:text-indigo-400"
+										>{token.text}</span
+									>
+								{:else if token.type === 'decorator'}
+									<span class="text-purple-600 dark:text-purple-400">{token.text}</span>
 								{:else if token.type === 'number'}
 									<span class="text-purple-600 dark:text-purple-400">{token.text}</span>
 								{:else if token.type === 'punctuation'}
@@ -437,6 +445,12 @@
 									<span class="text-amber-600 dark:text-amber-300">{token.text}</span>
 								{:else if token.type === 'function'}
 									<span class="text-sky-600 dark:text-sky-400">{token.text}</span>
+								{:else if token.type === 'macro'}
+									<span class="font-semibold text-indigo-600 dark:text-indigo-400"
+										>{token.text}</span
+									>
+								{:else if token.type === 'decorator'}
+									<span class="text-purple-600 dark:text-purple-400">{token.text}</span>
 								{:else if token.type === 'number'}
 									<span class="text-purple-600 dark:text-purple-400">{token.text}</span>
 								{:else if token.type === 'punctuation'}

package/dist/components/elements/CodeDiff.test.js

@@ -49,4 +49,20 @@ describe('CodeDiff Component & Diff Algorithm', () => {
         expect(target.textContent).toContain('Greeting.svelte');
         cleanup();
     });
+    it('should highlight modern Python 3.13 and macro tokens in diff view', () => {
+        const original = `def check(val: object):\n  return False`;
+        const modified = `@deprecated\ndef check(val: object) -> TypeIs[str]:\n  return True`;
+        const { target, cleanup } = renderComponent(CodeDiff, {
+            original,
+            modified,
+            filename: 'validator.py',
+            language: 'python',
+            viewMode: 'unified'
+        });
+        expect(target.textContent).toContain('@deprecated');
+        expect(target.textContent).toContain('TypeIs');
+        expect(target.textContent).toContain('+3');
+        expect(target.textContent).toContain('-2');
+        cleanup();
+    });
 });

package/dist/components/elements/EmptyState.svelte.d.ts

@@ -3,35 +3,15 @@ import type { Snippet } from 'svelte';
 import type { IconSource } from './Icon.svelte';
 export declare const emptyStateVariants: import("tailwind-variants").TVReturnType<{
     size: {
-        sm: "py-6 px-4 gap-2";
-        md: "py-10 px-6 gap-3";
-        lg: "py-16 px-8 gap-4";
+        sm: string;
+        md: string;
+        lg: string;
     };
     bordered: {
-        true: "border border-dashed border-neutral-300 dark:border-neutral-800";
-        false: "border-0";
+        true: string;
+        false: string;
     };
-}, undefined, "flex flex-col items-center justify-center text-center p-8 rounded-2xl bg-white dark:bg-neutral-900/50", {
-    size: {
-        sm: "py-6 px-4 gap-2";
-        md: "py-10 px-6 gap-3";
-        lg: "py-16 px-8 gap-4";
-    };
-    bordered: {
-        true: "border border-dashed border-neutral-300 dark:border-neutral-800";
-        false: "border-0";
-    };
-}, undefined, import("tailwind-variants").TVReturnTypeLike<{
-    size: {
-        sm: "py-6 px-4 gap-2";
-        md: "py-10 px-6 gap-3";
-        lg: "py-16 px-8 gap-4";
-    };
-    bordered: {
-        true: "border border-dashed border-neutral-300 dark:border-neutral-800";
-        false: "border-0";
-    };
-}, undefined>>;
+}, undefined, "flex flex-col items-center justify-center text-center p-8 rounded-2xl bg-white dark:bg-neutral-900/50", undefined, undefined, undefined>;
 export type EmptyStateProps = VariantProps<typeof emptyStateVariants> & {
     title?: string;
     description?: string;