@aithe/aithe-ui 26.2.3 → 26.3.2

package/dist/core/highlight/lang-rust.js

@@ -0,0 +1,24 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(as|async|await|break|const|continue|crate|dyn|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|union|unsafe|use|where|while|yield|abstract|become|box|do|final|macro|override|priv|try|typeof|unsized|virtual)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(Option|Result|Some|None|Ok|Err|String|Vec|HashMap|HashSet|Box|Rc|Arc|Cell|RefCell|Mutex|RwLock|Path|PathBuf|OsString|Duration|Iterator|Clone|Copy|Debug|Display|Eq|PartialEq|Ord|PartialOrd|Hash|Default|From|Into|TryFrom|TryInto|ToString|AsRef|AsMut|Deref|Drop|Send|Sync|Sized)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*[fiu]?(?:8|16|32|64|128|size)?)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*")/g, className: 'hl-string', order: 6 },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /(#!\[.*?])/g, className: 'hl-keyword', order: 8 },
+    { pattern: /('(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 9 },
+    { pattern: /([{}[\](),;:<>])/g, className: 'hl-punctuation', order: 10 },
+];
+const definition = { langId: 'rust', name: 'Rust', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-scala.js

@@ -0,0 +1,26 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(abstract|case|catch|class|def|do|else|enum|extends|false|final|finally|for|forSome|given|if|implicit|import|lazy|macro|match|new|null|object|override|package|private|protected|public|return|sealed|super|this|throw|trait|true|try|type|val|var|while|with|yield)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|null)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(Array|Boolean|Byte|Char|Double|Float|Int|Long|Short|String|Unit|Any|AnyRef|AnyVal|Nothing|Option|Some|None|Either|Left|Right|Try|Success|Failure|Future|Promise|List|Set|Map|Vector|Seq|Stream|Iterator|Iterable|Traversable|PartialFunction|Function|Tuple|Product|Serializable|Ordered|Ordering|Numeric|Integral|Fractional|Floating|StringBuilder|BigInt|BigDecimal|Console|Predef|print|println|printf|readLine|assert|require|ensuring|implicitly)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*[fFLl]?)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|"""[\s\S]*?""")/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /([{}[\](),;:.=>@])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'scala', name: 'Scala', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-sql.js

@@ -0,0 +1,21 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(ADD|ALL|ALTER|AND|ANY|AS|ASC|BETWEEN|BY|CASCADE|CASE|CHECK|COLUMN|CONSTRAINT|CREATE|CROSS|CUBE|CURRENT_DATE|CURRENT_TIME|CURRENT_TIMESTAMP|DATABASE|DEFAULT|DELETE|DESC|DISTINCT|DROP|ELSE|END|ESCAPE|EXCEPT|EXISTS|FOREIGN|FROM|FULL|GROUP|HAVING|IN|INDEX|INNER|INSERT|INTERSECT|INTO|IS|JOIN|KEY|LEFT|LIKE|LIMIT|MATERIALIZED|NATURAL|NOT|NULL|OFFSET|ON|OR|ORDER|OUTER|OVER|PARTITION|PRIMARY|REFERENCES|RIGHT|ROLLUP|ROW|ROWS|SCHEMA|SELECT|SET|SOME|TABLE|THEN|TO|TRIGGER|TRUNCATE|UNION|UNIQUE|UPDATE|USING|VALUES|VIEW|WHEN|WHERE|WITH|WITHOUT)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|null)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(COUNT|SUM|AVG|MIN|MAX|COALESCE|NULLIF|CAST|CONVERT|SUBSTRING|TRIM|UPPER|LOWER|LENGTH|REPLACE|CONCAT|NOW|CURDATE|CURTIME|DATE_ADD|DATE_SUB|DATEDIFF|EXTRACT|YEAR|MONTH|DAY|HOUR|MINUTE|SECOND|ROW_NUMBER|RANK|DENSE_RANK|LEAD|LAG|FIRST_VALUE|LAST_VALUE)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 6 },
+    { pattern: /([{}[\](),;.])/g, className: 'hl-punctuation', order: 7 },
+];
+const definition = { langId: 'sql', name: 'SQL', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-svelte.js

@@ -0,0 +1,27 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(<!--[\s\S]*?-->)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(each|if|else if|else|await|then|catch|bind|class|style|animate|on|use|as|transition|in|let|of|this)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|null|undefined)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(each|if|else if|else|await|then|catch|bind|class|style|animate|on|use|as|transition|in|let|of|this)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /(<\/?)([\w:-]+)/g, className: 'hl-tag', order: 8 },
+    { pattern: /({[\s\S]*?})/g, className: 'hl-keyword', order: 9 },
+    { pattern: /([{}[\](),;])/g, className: 'hl-punctuation', order: 10 },
+];
+const definition = { langId: 'svelte', name: 'Svelte', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-swift.js

@@ -0,0 +1,28 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(actor|associatedtype|async|await|break|case|catch|class|continue|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|optional|override|postfix|precedence|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|self|Self|set|some|static|struct|subscript|super|switch|throw|throws|true|try|typealias|unowned|var|weak|where|while|willSet)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|nil)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(Array|Bool|Character|Date|Dictionary|Double|Float|Int|Int8|Int16|Int32|Int64|String|UInt|UInt8|UInt16|UInt32|UInt64|Set|Optional|Error|Result|Any|AnyObject|Never|Void|CGFloat|CGPoint|CGSize|CGRect|NSObject|NSArray|NSDictionary|NSString|NSData|NSDate|URL|UUID|IndexPath|Notification|Bundle|UserDefaults|Calendar|Locale|TimeZone|Data|JSONDecoder|JSONEncoder|Codable|Encodable|Decodable|Hashable|Equatable|Comparable|Identifiable|CaseIterable|CustomStringConvertible)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|"""(?:[^"\\]|\\.)*""")/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /(#[\\w]+)/g, className: 'hl-keyword', order: 8 },
+    { pattern: /(\$\$?[\w.]+)/g, className: 'hl-keyword', order: 9 },
+    { pattern: /([{}[\](),;:.?])/g, className: 'hl-punctuation', order: 10 },
+];
+const definition = { langId: 'swift', name: 'Swift', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-tsx.js

@@ -0,0 +1,35 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(const|let|var|function|return|if|else|for|while|do|switch|case|break|continue|new|typeof|instanceof|in|of|class|extends|import|export|from|default|as|async|await|try|catch|finally|throw|void|yield|static|get|set|public|private|protected|readonly|abstract|enum|implements|interface|package|super|this|type|namespace|declare|keyof|infer|never|unknown|any|satisfies)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|null|undefined|NaN|Infinity)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(React|Component|useState|useEffect|useContext|useReducer|useCallback|useMemo|useRef|useImperativeHandle|useLayoutEffect|useDebugValue|Fragment|createElement|cloneElement|createRef|forwardRef|memo|lazy|Suspense|StrictMode|createContext|useTransition|useDeferredValue|useId|useSyncExternalStore|useInsertionEffect|FC|ReactNode|ReactElement|JSX|PropsWithChildren|Dispatch|SetStateAction)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /(<\/?)([\w:-]+)/g, className: 'hl-tag', order: 8 },
+    { pattern: /([\w:-]+)(=)/g, className: 'hl-attr', order: 9 },
+    { pattern: /(<\w+)/g, className: 'hl-tag', order: 10 },
+    { pattern: /(\/>|<\/\w+>)/g, className: 'hl-tag', order: 11 },
+    {
+        pattern: /:\s*(string|number|boolean|any|void|never|unknown|object|undefined|null|symbol|bigint)\b/g,
+        className: 'hl-type',
+        order: 12,
+    },
+    { pattern: /([{}[\](),;<>])/g, className: 'hl-punctuation', order: 13 },
+];
+const definition = { langId: 'tsx', name: 'TSX', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-typescript.js

@@ -0,0 +1,31 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(const|let|var|function|return|if|else|for|while|do|switch|case|break|continue|new|typeof|instanceof|in|of|class|extends|import|export|from|default|as|async|await|try|catch|finally|throw|void|yield|static|get|set|public|private|protected|readonly|abstract|enum|implements|interface|package|super|this|type|namespace|declare|readonly|keyof|infer|never|unknown|any)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|null|undefined|NaN|Infinity)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(document|window|console|Array|Object|String|Number|Boolean|Function|Symbol|Map|Set|WeakMap|WeakSet|Promise|Date|JSON|Math|RegExp|Error|TypeError|SyntaxError|Partial|Required|Readonly|Pick|Omit|Record|Exclude|Extract|NonNullable|ReturnType|Parameters)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    {
+        pattern: /:\s*(string|number|boolean|any|void|never|unknown|object|undefined|null|symbol|bigint|interface|type|enum)\b/g,
+        className: 'hl-type',
+        order: 8,
+    },
+    { pattern: /([{}[\](),;<>])/g, className: 'hl-punctuation', order: 9 },
+];
+const definition = { langId: 'typescript', name: 'TypeScript', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-vue.js

@@ -0,0 +1,29 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(<!--[\s\S]*?-->)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(v-if|v-else-if|v-else|v-for|v-show|v-model|v-bind|v-on|v-slot|v-text|v-html|v-once|v-pre|v-cloak|v-memo|ref|key|is|slot|slot-scope|scope)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|null|undefined)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(computed|watch|watchEffect|ref|reactive|toRefs|toRef|shallowRef|shallowReactive|triggerRef|customRef|markRaw|readonly|shallowReadonly|isRef|isReactive|isReadonly|isProxy|unref|nextTick|defineComponent|defineAsyncComponent|defineEmits|defineProps|defineExpose|withDefaults|h|mergeProps|provide|inject|onMounted|onBeforeMount|onUnmounted|onBeforeUnmount|onUpdated|onBeforeUpdate|onActivated|onDeactivated|onErrorCaptured|onRenderTracked|onRenderTriggered)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /(<\/?)([\w:-]+)/g, className: 'hl-tag', order: 8 },
+    { pattern: /(@[\w.-]+)/g, className: 'hl-keyword', order: 9 },
+    { pattern: /(:[\w.-]+)/g, className: 'hl-attr', order: 10 },
+    { pattern: /(#[^{][\w-]*)/g, className: 'hl-keyword', order: 11 },
+    { pattern: /([{}[\](),;])/g, className: 'hl-punctuation', order: 12 },
+];
+const definition = { langId: 'vue', name: 'Vue', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-wasm.js

@@ -0,0 +1,22 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(;;.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\(;[\s\S]*?;\))/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(module|func|param|result|local|global|memory|table|elem|data|type|start|import|export|mut|ref|funcref|externref|i32|i64|f32|f64|v128|block|loop|if|then|else|end|br|br_if|br_table|return|call|call_indirect|drop|select|local.get|local.set|local.tee|global.get|global.set|memory.size|memory.grow|memory.init|memory.copy|memory.fill|table.get|table.set|table.size|table.grow|table.init|table.copy|table.fill|table.get|elem.drop|data.drop)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(i32\.|i64\.|f32\.|f64\.|v128\.)\w+/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*")/g, className: 'hl-string', order: 6 },
+    { pattern: /(\$[\\w]+)/g, className: 'hl-function', order: 7 },
+    { pattern: /([{}[\](),;])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'wasm', name: 'WebAssembly', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-xml.js

@@ -0,0 +1,12 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(<\/?)([\w:-]+)/g, className: 'hl-tag', order: 1 },
+    { pattern: /([\w:-]+)(=)/g, className: 'hl-attr', order: 2 },
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 3 },
+    { pattern: /(<!--[\s\S]*?-->)/g, className: 'hl-comment', order: 4 },
+    { pattern: /(<!DOCTYPE[\s\S]*?>)/gi, className: 'hl-doctype', order: 5 },
+    { pattern: /(&\w+;)/g, className: 'hl-entity', order: 6 },
+    { pattern: /(<|\/?>)/g, className: 'hl-tag', order: 7 },
+];
+const definition = { langId: 'xml', name: 'XML', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-yaml.js

@@ -0,0 +1,14 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /^(\s*)[-*:]\s+/gm, className: 'hl-keyword', order: 1 },
+    { pattern: /^(\s*)([a-zA-Z_][a-zA-Z0-9_-]*)(?=:)/gm, className: 'hl-key', order: 2 },
+    { pattern: /:\s*("[^"]*"|'[^']*')/g, className: 'hl-string', order: 3 },
+    { pattern: /:\s*(\d+\.?\d*)/g, className: 'hl-number', order: 4 },
+    { pattern: /:\s*(true|false|yes|no|null|~)/gi, className: 'hl-boolean', order: 5 },
+    { pattern: /("[^"]*"|'[^']*')/g, className: 'hl-string', order: 6 },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 7 },
+    { pattern: /\b(true|false|yes|no|null|~)\b/gi, className: 'hl-boolean', order: 8 },
+    { pattern: /(#[^\n]*)$/gm, className: 'hl-comment', order: 9 },
+];
+const definition = { langId: 'yaml', name: 'YAML', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/registry.js

@@ -0,0 +1,99 @@
+const registry = new Map();
+function escapeHtml(str) {
+    const htmlEscapes = {
+        '&': '&',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&#39;',
+    };
+    return str.replace(/[&<>"']/g, (char) => htmlEscapes[char] ?? char);
+}
+function collectRanges(code, rules) {
+    const ranges = [];
+    for (const rule of rules) {
+        const regex = new RegExp(rule.pattern.source, rule.pattern.flags);
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+            ranges.push({
+                start: match.index,
+                end: match.index + match[0].length,
+                className: rule.className,
+                order: rule.order,
+            });
+            if (!rule.pattern.global)
+                break;
+        }
+    }
+    return ranges;
+}
+function mergeRanges(ranges) {
+    const sorted = [...ranges].sort((a, b) => a.start - b.start || a.order - b.order);
+    const merged = [];
+    for (const range of sorted) {
+        const last = merged.at(-1);
+        if (!last || range.start >= last.end) {
+            merged.push(range);
+        }
+    }
+    return merged;
+}
+function buildOutput(code, ranges) {
+    let result = '';
+    let lastEnd = 0;
+    for (const range of ranges) {
+        if (range.start > lastEnd) {
+            result += escapeHtml(code.slice(lastEnd, range.start));
+        }
+        result += `<span class="${range.className}">${escapeHtml(code.slice(range.start, range.end))}</span>`;
+        lastEnd = range.end;
+    }
+    if (lastEnd < code.length) {
+        result += escapeHtml(code.slice(lastEnd));
+    }
+    return result;
+}
+export class SyntaxRegistry {
+    static register(def) {
+        if (registry.has(def.langId)) {
+            console.warn(`[SyntaxRegistry] Language "${def.langId}" already registered, overwriting.`);
+        }
+        const sortedRules = [...def.rules].sort((a, b) => a.order - b.order);
+        registry.set(def.langId, { ...def, rules: sortedRules });
+    }
+    static get(langId) {
+        return registry.get(langId);
+    }
+    static getAll() {
+        return new Map(registry);
+    }
+    static has(langId) {
+        return registry.has(langId);
+    }
+    static unregister(langId) {
+        return registry.delete(langId);
+    }
+    static clear() {
+        registry.clear();
+    }
+    static escapeHtml(str) {
+        return escapeHtml(str);
+    }
+    static highlightCode(code, rules) {
+        if (!code)
+            return '';
+        if (!rules || rules.length === 0)
+            return escapeHtml(code);
+        const ranges = collectRanges(code, rules);
+        const merged = mergeRanges(ranges);
+        return buildOutput(code, merged);
+    }
+    static highlightByLanguage(code, langId) {
+        const langDef = SyntaxRegistry.get(langId);
+        if (!langDef) {
+            console.warn(`[SyntaxRegistry] Language "${langId}" not found, returning plain text.`);
+            return escapeHtml(code);
+        }
+        return SyntaxRegistry.highlightCode(code, langDef.rules);
+    }
+}