@aithe/aithe-ui 26.2.2 → 26.3.1

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

@@ -0,0 +1,27 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(#.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /('''[\s\S]*?'''|"""[\s\S]*?""")/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(False|None|True|and|as|assert|async|await|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|import|in|is|lambda|nonlocal|not|or|pass|raise|return|try|while|with|yield)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(True|False|None)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(print|len|range|type|int|str|float|list|dict|set|tuple|bool|super|self|cls|open|input|isinstance|enumerate|zip|map|filter|sorted|reversed|abs|min|max|sum|any|all|hasattr|getattr|setattr|delattr|__init__|__str__|__repr__|__call__)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*[jJlL]?)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|f"(?:[^"\\]|\\.)*"|f'(?:[^'\\]|\\.)*')/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: /([{}[\](),:])/g, className: 'hl-punctuation', order: 9 },
+];
+const definition = { langId: 'python', name: 'Python', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-r.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lang-r.d.ts.map

package/dist/core/highlight/lang-r.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-r.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/lang-r.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,21 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(#.*$)/gm, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(if|else|in|case|stop|ifelse|elseif|for|while|repeat|switch|function|return|next|break|TRUE|FALSE|NULL|Inf|NaN|NA|NA_integer_|NA_real_|NA_complex_|NA_character_)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(TRUE|FALSE|NULL|NA|NaN|Inf)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(print|cat|sprintf|paste|paste0|format|sink|readline|readLines|writeLines|scan|read.csv|read.table|write.csv|write.table|save|load|library|require|install.packages|source|setwd|getwd|list.files|dir|file.exists|file.create|file.remove|file.rename|file.copy|file.append|file.info|file.path|dir.create|unlink|system|options|getOption|set.seed|sample|seq|rep|length|nrow|ncol|dim|names|rownames|colnames|class|typeof|mode|str|summary|head|tail|unique|duplicated|table|aggregate|apply|lapply|sapply|vapply|tapply|mapply|by|merge|cbind|rbind|split|subset|order|sort|rank|scale|center|scale|log|exp|sqrt|abs|round|ceiling|floor|trunc|signif|sin|cos|tan|asin|acos|atan|atan2|min|max|which|which.min|which.max|mean|median|sd|var|cor|cov|quantile|IQR|fivenum|range|diff|sum|prod|cumsum|cumprod|cummin|cummax|pmax|pmin|colSums|rowSums|colMeans|rowMeans|is.na|is.null|is.nan|is.finite|is.infinite|is.array|is.character|is.complex|is.double|is.element|is.environment|is.factor|is.function|is.integer|is.language|is.list|is.logical|is.matrix|is.na|is.name|is.nan|is.null|is.numeric|is.object|is.ordered|is.package_version|is.pairlist|is.primitive|is.qr|is.R|is.raw|is.recursive|is.single|is.symbol|is.table|is.unsorted|is.vector|as.array|as.character|as.complex|as.double|as.expression|as.factor|as.integer|as.list|as.logical|as.matrix|as.name|as.null|as.numeric|as.ordered|as.raw|as.table)\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: /([{}[\](),;])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'r', name: 'R', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-ruby.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lang-ruby.d.ts.map

package/dist/core/highlight/lang-ruby.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-ruby.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/lang-ruby.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,29 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(#.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(=begin[\s\S]*?=end)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(BEGIN|END|alias|and|begin|break|case|class|def|defined|do|else|elsif|end|ensure|for|if|in|module|next|nil|not|or|redo|rescue|retry|return|self|super|then|undef|unless|until|when|while|yield)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|nil)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(puts|print|p|require|include|extend|attr_accessor|attr_reader|attr_writer|raise|throw|catch|fail|lambda|proc|new|send|respond_to|method_missing|block_given|each|map|select|reject|reduce|inject)\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-builtin', order: 9 },
+    { pattern: /(:\w+)/g, className: 'hl-key', order: 10 },
+    { pattern: /([{}[\](),;])/g, className: 'hl-punctuation', order: 11 },
+];
+const definition = { langId: 'ruby', name: 'Ruby', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-rust.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lang-rust.d.ts.map

package/dist/core/highlight/lang-rust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-rust.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/lang-rust.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lang-scala.d.ts.map

package/dist/core/highlight/lang-scala.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-scala.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/lang-scala.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lang-sql.d.ts.map

package/dist/core/highlight/lang-sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-sql.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/lang-sql.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lang-svelte.d.ts.map

package/dist/core/highlight/lang-svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-svelte.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/lang-svelte.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lang-swift.d.ts.map

package/dist/core/highlight/lang-swift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-swift.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/lang-swift.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lang-tsx.d.ts.map

package/dist/core/highlight/lang-tsx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-tsx.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/lang-tsx.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lang-typescript.d.ts.map

package/dist/core/highlight/lang-typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-typescript.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/lang-typescript.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lang-vue.d.ts.map

package/dist/core/highlight/lang-vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-vue.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/lang-vue.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lang-wasm.d.ts.map

package/dist/core/highlight/lang-wasm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-wasm.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/lang-wasm.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lang-xml.d.ts.map

package/dist/core/highlight/lang-xml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-xml.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/lang-xml.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lang-yaml.d.ts.map

package/dist/core/highlight/lang-yaml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-yaml.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/lang-yaml.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,22 @@
+export interface SyntaxRule {
+    pattern: RegExp;
+    className: string;
+    order: number;
+}
+export interface LanguageDefinition {
+    langId: string;
+    name?: string;
+    rules: SyntaxRule[];
+}
+export declare class SyntaxRegistry {
+    static register(def: LanguageDefinition): void;
+    static get(langId: string): LanguageDefinition | undefined;
+    static getAll(): Map<string, LanguageDefinition>;
+    static has(langId: string): boolean;
+    static unregister(langId: string): boolean;
+    static clear(): void;
+    static escapeHtml(str: string): string;
+    static highlightCode(code: string, rules: SyntaxRule[]): string;
+    static highlightByLanguage(code: string, langId: string): string;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/core/highlight/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/core/highlight/registry.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,EAAE,CAAC;CACrB;AAoED,qBAAa,cAAc;IACzB,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,kBAAkB,GAAG,IAAI;IAQ9C,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAI1D,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC;IAIhD,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAInC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAI1C,MAAM,CAAC,KAAK,IAAI,IAAI;IAIpB,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAItC,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,MAAM;IAQ/D,MAAM,CAAC,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;CAQjE"}

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);
+    }
+}