@50arms/ui 0.0.0-stage → 35.2.0

package/dist/lib/syntax/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/lib/syntax/index.ts"],"sourcesContent":["/* ============================================================================\n   SYNTAX — one tokenizer, many languages, nesting as a first-class mechanism.\n\n   THE WHOLE DESIGN RESTS ON ONE INVARIANT: a language produces a flat list of\n   offsets into the source, never a string of markup. That is what makes the\n   editor possible (the highlight layer is character-identical to the textarea\n   under it) and what makes nesting possible (an inner language's tokens splice\n   into the outer stream). See `types.ts` for the argument in full.\n\n   Public surface:\n     tokenize(source, language)  ->  Token[]\n     listLanguages()             ->  every registered name\n     resolveLanguage(alias)      ->  canonical name, or null\n\n   ---------------------------------------------------------------------------\n   WHY SEEDING IS LAZY AND NOT A TOP-LEVEL LOOP.\n\n   This file used to register the built-in grammars with a bare top-level\n   statement:\n\n       for (const grammar of LANGUAGES) registerGrammar(grammar);\n\n   It works in dev and in every test, and it is DELETED FROM EVERY BUILD.\n   `package.json` declares `sideEffects: [\"*.css\"]`, which tells the bundler\n   that every JS module in this package is side-effect-free — so Rollup keeps\n   the module (its `tokenize` export is used) and drops the top-level statements\n   that contribute to no used export. The loop is exactly that.\n\n   The symptom is silence. `tokenize` still returns a complete, gap-free token\n   list covering the whole source — every token typed `text`, because no grammar\n   is registered — so the coverage invariant holds, nothing throws, and code\n   renders as plain unstyled text. Measured on the published build:\n   `listLanguages()` returned `[]` and a TypeScript sample produced one token\n   type. It shipped that way in `dist/` AND in the demo build; only the dev\n   server, which does not tree-shake, looked correct.\n\n   THIS IS CAV-11'S CLASS, NOT ITS INSTANCE. That one was a bare\n   `import \"./x\"` for its side effect, and the fix — import a VALUE — is\n   already followed here: `LANGUAGES` is a real import. It does not help,\n   because the deletion is of the CALL, not of the import.\n\n   So seeding is reachable from the used exports instead: no bundler can drop a\n   call that the function a consumer invokes makes on its own path. The `seeded`\n   flag makes it once-only, and the cost after the first call is one boolean\n   test.\n   ========================================================================= */\n\nimport { LANGUAGES } from \"./languages\";\nimport {\n  getGrammar as getGrammarRaw,\n  listLanguages as listLanguagesRaw,\n  registerGrammar as registerGrammarRaw,\n  resolveLanguage as resolveLanguageRaw,\n} from \"./registry\";\nimport { tokenize as tokenizeRaw } from \"./tokenize\";\nimport type { Grammar, Token } from \"./types\";\n\nlet seeded = false;\n\n/** Register the built-in grammars, once. Called by every entry point below. */\nfunction ensureSeeded(): void {\n  if (seeded) return;\n  seeded = true;\n  for (const grammar of LANGUAGES) registerGrammarRaw(grammar);\n}\n\nexport function tokenize(source: string, language: string | null | undefined): Token[] {\n  ensureSeeded();\n  return tokenizeRaw(source, language);\n}\n\nexport function listLanguages(): string[] {\n  ensureSeeded();\n  return listLanguagesRaw();\n}\n\nexport function resolveLanguage(alias: string | null | undefined): string | null {\n  ensureSeeded();\n  return resolveLanguageRaw(alias);\n}\n\nexport function getGrammar(name: string | null | undefined): Grammar | undefined {\n  ensureSeeded();\n  return getGrammarRaw(name);\n}\n\n/**\n * Register a custom grammar.\n *\n * Seeds first, so a consumer registering `json` deliberately overrides the\n * built-in rather than being silently overwritten by it on the next call that\n * happens to seed.\n */\nexport function registerGrammar(grammar: Grammar): void {\n  ensureSeeded();\n  registerGrammarRaw(grammar);\n}\n\nexport { checkCoverage } from \"./tokenize\";\nexport { defineGrammar } from \"./registry\";\nexport type { Token, TokenType, Grammar, Rule, TokenizeContext } from \"./types\";\n"],"names":["seeded","ensureSeeded","grammar","LANGUAGES","registerGrammarRaw","tokenize","source","language","tokenizeRaw","listLanguages","listLanguagesRaw","resolveLanguage","alias","resolveLanguageRaw","registerGrammar"],"mappings":";;;;;AAyDA,IAAIA,IAAS;AAGb,SAASC,IAAqB;AAC5B,MAAI,CAAAD,GACJ;AAAA,IAAAA,IAAS;AACT,eAAWE,KAAWC,EAAWC,CAAAA,EAAmBF,CAAO;AAAA;AAC7D;AAEO,SAASG,EAASC,GAAgBC,GAA8C;AACrF,SAAAN,EAAA,GACOO,EAAYF,GAAQC,CAAQ;AACrC;AAEO,SAASE,IAA0B;AACxC,SAAAR,EAAA,GACOS,EAAA;AACT;AAEO,SAASC,EAAgBC,GAAiD;AAC/E,SAAAX,EAAA,GACOY,EAAmBD,CAAK;AACjC;AAcO,SAASE,EAAgBZ,GAAwB;AACtD,EAAAD,EAAA,GACAG,EAAmBF,CAAO;AAC5B;"}

package/dist/lib/syntax/languages/bash.js

@@ -0,0 +1,77 @@
+import { defineGrammar as c } from "../registry.js";
+function n(e) {
+  return e.trim().split(/\s+/).sort((a, o) => o.length - a.length).join("|");
+}
+const s = n(`
+  alias break case continue declare do done elif else esac eval exec exit export
+  fi for function if in local readonly return select set shift source then time
+  trap typeset unset until while
+`), r = n(`
+  awk basename cat cd chmod chown cp curl cut date dirname docker echo env find
+  git grep head jq kill ln ls make mkdir mv npm printf ps pwd read rm rmdir sed
+  seq sleep sort ssh sudo tail tar tee test touch tr uname uniq wc wget which
+  xargs yarn
+`);
+function t() {
+  return [
+    { match: new RegExp("(?<![^\\s])#[^\\n]*"), token: "comment" },
+    /* Heredoc: terminated form first, then the half-typed one. Group 3 is the
+       delimiter and group 6 closes on it; group 2 is the optional quote and is
+       matched again by `\2` so `<<'EOF'` cannot be closed by `<<EOF`. */
+    {
+      match: /(<<-?)[ \t]*(['"]?)(\w+)\2([^\n]*\n)((?:[^\n]*\n)*?)([ \t]*\3(?![\w]))/,
+      groups: ["operator", null, "constant", null, "string", "constant"]
+    },
+    {
+      match: /(<<-?)[ \t]*(['"]?)(\w+)\2([^\n]*\n)((?:[^\n]+\n?|\n)*)/,
+      groups: ["operator", null, "constant", null, "string"]
+    },
+    { match: /\$'(?:[^'\\]|\\[^])*'?/, token: "string" },
+    { match: /\$\{[^}\n]*\}/, token: "variable" },
+    { match: /\$\(\(|\$\(/, token: "punctuation", push: "subshell" },
+    { match: /\$[A-Za-z_]\w*|\$[0-9@*#?$!_-]/, token: "variable" },
+    { match: /"/, token: "string", push: "dqString" },
+    { match: /'/, token: "string", push: "sqString" },
+    { match: /`/, token: "punctuation", push: "backtick" },
+    { match: new RegExp(`\\b(?:${s})\\b`), token: "keyword" },
+    { match: new RegExp(`(?<![\\w./-])(?:${r})(?![\\w./-])`), token: "function" },
+    /* Flags are named switches on a command — the same role an attribute plays
+       on a tag, which is the closest honest category in the closed set. */
+    { match: new RegExp("(?<=\\s)--?[A-Za-z][\\w-]*"), token: "attribute" },
+    { match: new RegExp("(?<=(?:^|[;|&`(])[ \\t]*)[A-Za-z_][\\w./-]*", "m"), token: "function" },
+    { match: new RegExp("(?<![\\w$./-])\\d+(?:\\.\\d+)?(?![\\w./-])"), token: "number" },
+    { match: /\[\[|\]\]|[[\]]/, token: "punctuation" },
+    { match: /&&|\|\||>>|<<|>&|<&|=~|==|!=|[|&;<>=!]/, token: "operator" },
+    { match: /[(){}]/, token: "punctuation" }
+  ];
+}
+const h = c({
+  name: "bash",
+  aliases: ["sh", "shell", "zsh", "ksh", "shellscript"],
+  states: {
+    root: t(),
+    /* `$((…))` pushes once; its second `)` is left to the outer punctuation
+       rule. The stack guard in the scanner refuses to pop past root, so the
+       asymmetry cannot corrupt anything downstream. */
+    subshell: [{ match: /\)/, token: "punctuation", pop: !0 }, ...t()],
+    backtick: [{ match: /`/, token: "punctuation", pop: !0 }, ...t()],
+    dqString: [
+      { match: /\\[^]/, token: "escape" },
+      { match: /\$\{[^}\n]*\}|\$[A-Za-z_]\w*|\$[0-9@*#?$!]/, token: "variable" },
+      { match: /\$\(/, token: "punctuation", push: "subshell" },
+      { match: /"/, token: "string", pop: !0 },
+      { match: /[^"\\$]+/, token: "string" },
+      { match: /\$/, token: "string" }
+    ],
+    /* No escape rule and no variable rule, on purpose: inside single quotes a
+       backslash is a backslash and `$HOME` is four literal characters. */
+    sqString: [
+      { match: /'/, token: "string", pop: !0 },
+      { match: /[^']+/, token: "string" }
+    ]
+  }
+});
+export {
+  h as bash
+};
+//# sourceMappingURL=bash.js.map

package/dist/lib/syntax/languages/bash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash.js","sources":["../../../../src/lib/syntax/languages/bash.ts"],"sourcesContent":["import { defineGrammar } from \"../registry\";\nimport type { Rule } from \"../types\";\n\n/* ============================================================================\n   BASH / SH / ZSH.\n\n   QUOTING IS THE LANGUAGE. `\"$HOME\"` expands and `'$HOME'` does not, and that\n   single character is the difference between a working script and one that\n   deletes the wrong directory. So the two quote styles are two STATES with\n   different rule sets, not one string rule with a flag: inside double quotes\n   `$VAR`, `${…}` and `$(…)` are live and highlighted as such; inside single\n   quotes literally nothing is, because literally nothing is.\n\n   `#` IS ONLY A COMMENT AFTER WHITESPACE, for the same reason as in YAML —\n   `curl http://x#frag` and `${x#prefix}` both contain one that is not.\n\n   A HEREDOC IS MATCHED WITH A BACKREFERENCE TO ITS OWN DELIMITER, because that\n   is the only thing that ends it. The cost is visible and deliberate: the rest\n   of the header LINE (`cat <<EOF > out.txt`) rides inside the same match as\n   plain text, since `embed`/`until` cannot start a region part-way through a\n   rule's own match. Losing colour on one redirect is a fair price for the body\n   of every heredoc in the file being a string instead of misparsed commands.\n\n   COMMAND POSITION IS INFERRED FROM THE LINE, NOT FROM A PARSE. A word is a\n   command when it opens a line or follows `;`, `|`, `&` or `(` — which is a\n   lookbehind, not knowledge. `then echo hi` on one line leaves `echo` unstyled\n   by that rule (the builtin list catches it) and a `\\`-continued argument at\n   the start of its line is styled as a command. Both are colouring misses in\n   the token stream, never coverage breaks.\n\n   SHELL STRINGS MAY SPAN LINES, unlike every other language here: multi-line\n   quoted arguments are idiomatic (`git commit -m \"…\"`), so popping at `\\n`\n   would be wrong far more often than it would be protective.\n   ========================================================================= */\n\nfunction words(list: string): string {\n  return list\n    .trim()\n    .split(/\\s+/)\n    .sort((a, b) => b.length - a.length)\n    .join(\"|\");\n}\n\nconst KEYWORDS = words(`\n  alias break case continue declare do done elif else esac eval exec exit export\n  fi for function if in local readonly return select set shift source then time\n  trap typeset unset until while\n`);\n\nconst BUILTINS = words(`\n  awk basename cat cd chmod chown cp curl cut date dirname docker echo env find\n  git grep head jq kill ln ls make mkdir mv npm printf ps pwd read rm rmdir sed\n  seq sleep sort ssh sudo tail tar tee test touch tr uname uniq wc wget which\n  xargs yarn\n`);\n\n/** Everything valid inside a command context — reused by `$(…)` and backticks. */\nfunction commandRules(): Rule[] {\n  return [\n    { match: /(?<![^\\s])#[^\\n]*/, token: \"comment\" },\n\n    /* Heredoc: terminated form first, then the half-typed one. Group 3 is the\n       delimiter and group 6 closes on it; group 2 is the optional quote and is\n       matched again by `\\2` so `<<'EOF'` cannot be closed by `<<EOF`. */\n    {\n      match: /(<<-?)[ \\t]*(['\"]?)(\\w+)\\2([^\\n]*\\n)((?:[^\\n]*\\n)*?)([ \\t]*\\3(?![\\w]))/,\n      groups: [\"operator\", null, \"constant\", null, \"string\", \"constant\"],\n    },\n    {\n      match: /(<<-?)[ \\t]*(['\"]?)(\\w+)\\2([^\\n]*\\n)((?:[^\\n]+\\n?|\\n)*)/,\n      groups: [\"operator\", null, \"constant\", null, \"string\"],\n    },\n\n    { match: /\\$'(?:[^'\\\\]|\\\\[^])*'?/, token: \"string\" },\n    { match: /\\$\\{[^}\\n]*\\}/, token: \"variable\" },\n    { match: /\\$\\(\\(|\\$\\(/, token: \"punctuation\", push: \"subshell\" },\n    { match: /\\$[A-Za-z_]\\w*|\\$[0-9@*#?$!_-]/, token: \"variable\" },\n\n    { match: /\"/, token: \"string\", push: \"dqString\" },\n    { match: /'/, token: \"string\", push: \"sqString\" },\n    { match: /`/, token: \"punctuation\", push: \"backtick\" },\n\n    { match: new RegExp(`\\\\b(?:${KEYWORDS})\\\\b`), token: \"keyword\" },\n    { match: new RegExp(`(?<![\\\\w./-])(?:${BUILTINS})(?![\\\\w./-])`), token: \"function\" },\n\n    /* Flags are named switches on a command — the same role an attribute plays\n       on a tag, which is the closest honest category in the closed set. */\n    { match: /(?<=\\s)--?[A-Za-z][\\w-]*/, token: \"attribute\" },\n\n    { match: /(?<=(?:^|[;|&`(])[ \\t]*)[A-Za-z_][\\w./-]*/m, token: \"function\" },\n\n    { match: /(?<![\\w$./-])\\d+(?:\\.\\d+)?(?![\\w./-])/, token: \"number\" },\n\n    { match: /\\[\\[|\\]\\]|[[\\]]/, token: \"punctuation\" },\n    { match: /&&|\\|\\||>>|<<|>&|<&|=~|==|!=|[|&;<>=!]/, token: \"operator\" },\n    { match: /[(){}]/, token: \"punctuation\" },\n  ];\n}\n\nexport const bash = defineGrammar({\n  name: \"bash\",\n  aliases: [\"sh\", \"shell\", \"zsh\", \"ksh\", \"shellscript\"],\n  states: {\n    root: commandRules(),\n\n    /* `$((…))` pushes once; its second `)` is left to the outer punctuation\n       rule. The stack guard in the scanner refuses to pop past root, so the\n       asymmetry cannot corrupt anything downstream. */\n    subshell: [{ match: /\\)/, token: \"punctuation\", pop: true }, ...commandRules()],\n    backtick: [{ match: /`/, token: \"punctuation\", pop: true }, ...commandRules()],\n\n    dqString: [\n      { match: /\\\\[^]/, token: \"escape\" },\n      { match: /\\$\\{[^}\\n]*\\}|\\$[A-Za-z_]\\w*|\\$[0-9@*#?$!]/, token: \"variable\" },\n      { match: /\\$\\(/, token: \"punctuation\", push: \"subshell\" },\n      { match: /\"/, token: \"string\", pop: true },\n      { match: /[^\"\\\\$]+/, token: \"string\" },\n      { match: /\\$/, token: \"string\" },\n    ],\n\n    /* No escape rule and no variable rule, on purpose: inside single quotes a\n       backslash is a backslash and `$HOME` is four literal characters. */\n    sqString: [\n      { match: /'/, token: \"string\", pop: true },\n      { match: /[^']+/, token: \"string\" },\n    ],\n  },\n});\n"],"names":["words","list","b","KEYWORDS","BUILTINS","commandRules","bash","defineGrammar"],"mappings":";AAmCA,SAASA,EAAMC,GAAsB;AACnC,SAAOA,EACJ,KAAA,EACA,MAAM,KAAK,EACX,KAAK,CAAC,GAAGC,MAAMA,EAAE,SAAS,EAAE,MAAM,EAClC,KAAK,GAAG;AACb;AAEA,MAAMC,IAAWH,EAAM;AAAA;AAAA;AAAA;AAAA,CAItB,GAEKI,IAAWJ,EAAM;AAAA;AAAA;AAAA;AAAA;AAAA,CAKtB;AAGD,SAASK,IAAuB;AAC9B,SAAO;AAAA,IACL,EAAE,OAAO,WAAA,qBAAA,GAAqB,OAAO,UAAA;AAAA;AAAA;AAAA;AAAA,IAKrC;AAAA,MACE,OAAO;AAAA,MACP,QAAQ,CAAC,YAAY,MAAM,YAAY,MAAM,UAAU,UAAU;AAAA,IAAA;AAAA,IAEnE;AAAA,MACE,OAAO;AAAA,MACP,QAAQ,CAAC,YAAY,MAAM,YAAY,MAAM,QAAQ;AAAA,IAAA;AAAA,IAGvD,EAAE,OAAO,0BAA0B,OAAO,SAAA;AAAA,IAC1C,EAAE,OAAO,iBAAiB,OAAO,WAAA;AAAA,IACjC,EAAE,OAAO,eAAe,OAAO,eAAe,MAAM,WAAA;AAAA,IACpD,EAAE,OAAO,kCAAkC,OAAO,WAAA;AAAA,IAElD,EAAE,OAAO,KAAK,OAAO,UAAU,MAAM,WAAA;AAAA,IACrC,EAAE,OAAO,KAAK,OAAO,UAAU,MAAM,WAAA;AAAA,IACrC,EAAE,OAAO,KAAK,OAAO,eAAe,MAAM,WAAA;AAAA,IAE1C,EAAE,OAAO,IAAI,OAAO,SAASF,CAAQ,MAAM,GAAG,OAAO,UAAA;AAAA,IACrD,EAAE,OAAO,IAAI,OAAO,mBAAmBC,CAAQ,eAAe,GAAG,OAAO,WAAA;AAAA;AAAA;AAAA,IAIxE,EAAE,OAAO,WAAA,4BAAA,GAA4B,OAAO,YAAA;AAAA,IAE5C,EAAE,OAAO,WAAA,+CAAA,GAAA,GAA8C,OAAO,WAAA;AAAA,IAE9D,EAAE,OAAO,WAAA,4CAAA,GAAyC,OAAO,SAAA;AAAA,IAEzD,EAAE,OAAO,mBAAmB,OAAO,cAAA;AAAA,IACnC,EAAE,OAAO,0CAA0C,OAAO,WAAA;AAAA,IAC1D,EAAE,OAAO,UAAU,OAAO,cAAA;AAAA,EAAc;AAE5C;AAEO,MAAME,IAAOC,EAAc;AAAA,EAChC,MAAM;AAAA,EACN,SAAS,CAAC,MAAM,SAAS,OAAO,OAAO,aAAa;AAAA,EACpD,QAAQ;AAAA,IACN,MAAMF,EAAA;AAAA;AAAA;AAAA;AAAA,IAKN,UAAU,CAAC,EAAE,OAAO,MAAM,OAAO,eAAe,KAAK,GAAA,GAAQ,GAAGA,GAAc;AAAA,IAC9E,UAAU,CAAC,EAAE,OAAO,KAAK,OAAO,eAAe,KAAK,GAAA,GAAQ,GAAGA,GAAc;AAAA,IAE7E,UAAU;AAAA,MACR,EAAE,OAAO,SAAS,OAAO,SAAA;AAAA,MACzB,EAAE,OAAO,8CAA8C,OAAO,WAAA;AAAA,MAC9D,EAAE,OAAO,QAAQ,OAAO,eAAe,MAAM,WAAA;AAAA,MAC7C,EAAE,OAAO,KAAK,OAAO,UAAU,KAAK,GAAA;AAAA,MACpC,EAAE,OAAO,YAAY,OAAO,SAAA;AAAA,MAC5B,EAAE,OAAO,MAAM,OAAO,SAAA;AAAA,IAAS;AAAA;AAAA;AAAA,IAKjC,UAAU;AAAA,MACR,EAAE,OAAO,KAAK,OAAO,UAAU,KAAK,GAAA;AAAA,MACpC,EAAE,OAAO,SAAS,OAAO,SAAA;AAAA,IAAS;AAAA,EACpC;AAEJ,CAAC;"}

package/dist/lib/syntax/languages/css.js

@@ -0,0 +1,81 @@
+import { defineGrammar as n } from "../registry.js";
+function e() {
+  return [
+    { match: /--[\w-]+/, token: "variable" },
+    { match: /[$@][\w-]+/, token: "variable" },
+    { match: /-?[A-Za-z_][\w-]*(?=\()/, token: "function" },
+    { match: /#[0-9a-fA-F]{3,8}(?![\w-])/, token: "constant" },
+    { match: /"/, token: "string", push: "dqString" },
+    { match: /'/, token: "string", push: "sqString" },
+    /* Identifiers before numbers so `a1` stays one token; numbers before
+       punctuation so `.5em` is not read as a class selector. */
+    { match: /-?[A-Za-z_][\w-]*/, token: "constant" },
+    { match: /([+-]?(?:\d*\.\d+|\d+))(%|[A-Za-z]+)?/, groups: ["number", "type"] },
+    { match: /[()[\]:;,]/, token: "punctuation" },
+    { match: /[*/+\->~^$|=]/, token: "operator" }
+  ];
+}
+function t() {
+  return [
+    { match: /\/\*[^]*?\*\//, token: "comment" },
+    /* Unterminated: to EOF. A `/*` someone is halfway through typing must not
+       leave the remainder of the file coloured as live declarations. */
+    { match: /\/\*[^]*/, token: "comment" },
+    { match: /\/\/[^\n]*/, token: "comment" }
+  ];
+}
+const a = n({
+  name: "css",
+  aliases: ["scss", "sass", "less", "postcss", "pcss"],
+  states: {
+    /* Selector context. */
+    root: [
+      { match: /url\([^)"'\n]*\)/i, token: "url" },
+      ...t(),
+      { match: /@[\w-]+/, token: "atrule" },
+      { match: /\{/, token: "punctuation", push: "block" },
+      { match: /\}/, token: "punctuation" },
+      { match: /"/, token: "string", push: "dqString" },
+      { match: /'/, token: "string", push: "sqString" },
+      { match: /\[[^\]\n]*\]/, token: "selector" },
+      { match: /::?[A-Za-z][\w-]*(?:\([^)\n]*\))?/, token: "selector" },
+      { match: /[.#][\w-]+/, token: "selector" },
+      { match: /[&*]/, token: "selector" },
+      { match: /-?[A-Za-z_][\w-]*/, token: "selector" },
+      { match: /([+-]?(?:\d*\.\d+|\d+))(%|[A-Za-z]+)?/, groups: ["number", "type"] },
+      { match: /[()[\],;:]/, token: "punctuation" },
+      { match: /[>+~]/, token: "operator" }
+    ],
+    /* Declaration context. */
+    block: [
+      { match: /url\([^)"'\n]*\)/i, token: "url" },
+      ...t(),
+      { match: /\}/, token: "punctuation", pop: !0 },
+      /* Nesting: a preprocessor block inside a block. The inner selector is
+         read with declaration rules, which is imperfect and still far better
+         than dropping out of block context and mis-reading the closing brace. */
+      { match: /\{/, token: "punctuation", push: "block" },
+      { match: /!\s*[\w-]+/, token: "keyword" },
+      { match: /@[\w-]+(?=[\s({;])/, token: "atrule" },
+      { match: /--[\w-]+(?=\s*:)/, token: "property" },
+      { match: /-?[A-Za-z_][\w-]*(?=\s*:)/, token: "property" },
+      ...e()
+    ],
+    dqString: [
+      { match: /\\[^]/, token: "escape" },
+      { match: /"/, token: "string", pop: !0 },
+      { match: /[^"\\\n]+/, token: "string" },
+      { match: /\n/, token: "text", pop: !0 }
+    ],
+    sqString: [
+      { match: /\\[^]/, token: "escape" },
+      { match: /'/, token: "string", pop: !0 },
+      { match: /[^'\\\n]+/, token: "string" },
+      { match: /\n/, token: "text", pop: !0 }
+    ]
+  }
+});
+export {
+  a as css
+};
+//# sourceMappingURL=css.js.map

package/dist/lib/syntax/languages/css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.js","sources":["../../../../src/lib/syntax/languages/css.ts"],"sourcesContent":["import { defineGrammar } from \"../registry\";\nimport type { Rule } from \"../types\";\n\n/* ============================================================================\n   CSS, and the preprocessors that are CSS plus punctuation.\n\n   TWO CONTEXTS, NOT ONE. Outside a block, a name is a SELECTOR; inside one, the\n   name before a colon is a PROPERTY and everything after it is a VALUE. They\n   are the same characters and they mean different things, so the grammar has\n   two states and `{` / `}` move between them. A single-state CSS grammar has to\n   guess, and it guesses wrong on every nested rule.\n\n   THE CLOSED TOKEN SET HAS NO `unit`, SO A UNIT IS TYPED AS `type`. `10px` and\n   `10%` differ only in their suffix and that suffix is the DIMENSION of the\n   number — type information about the value. Colouring it apart from the digits\n   is what makes a stylesheet scannable; folding it into `number` loses the one\n   distinction anyone actually looks for. Inventing a category was the other\n   option and it is the wrong one: the set is closed so a language cannot mint\n   its own colour (see `types.ts`).\n\n   `url(…)` IS MATCHED BEFORE COMMENTS, and that ordering is load-bearing. SCSS\n   and LESS both use `//` line comments, so `url(http://x/y)` would otherwise\n   grey out from the `//` to the end of the line and take the closing paren with\n   it. The bug looks like \"the rest of my file lost its colours\".\n\n   ONE GRAMMAR FOR CSS / SCSS / LESS / POSTCSS. `$var`, `@var`, `&`, `//` and\n   nesting are all accepted here. A highlighter is not a validator, and four\n   near-identical forks would mean fixing `url()` four times.\n   ========================================================================= */\n\n/** Value-position rules, identical inside a block and inside `@media (…)`. */\nfunction valueRules(): Rule[] {\n  return [\n    { match: /--[\\w-]+/, token: \"variable\" },\n    { match: /[$@][\\w-]+/, token: \"variable\" },\n    { match: /-?[A-Za-z_][\\w-]*(?=\\()/, token: \"function\" },\n    { match: /#[0-9a-fA-F]{3,8}(?![\\w-])/, token: \"constant\" },\n    { match: /\"/, token: \"string\", push: \"dqString\" },\n    { match: /'/, token: \"string\", push: \"sqString\" },\n    /* Identifiers before numbers so `a1` stays one token; numbers before\n       punctuation so `.5em` is not read as a class selector. */\n    { match: /-?[A-Za-z_][\\w-]*/, token: \"constant\" },\n    { match: /([+-]?(?:\\d*\\.\\d+|\\d+))(%|[A-Za-z]+)?/, groups: [\"number\", \"type\"] },\n    { match: /[()[\\]:;,]/, token: \"punctuation\" },\n    { match: /[*/+\\->~^$|=]/, token: \"operator\" },\n  ];\n}\n\nfunction comments(): Rule[] {\n  return [\n    { match: /\\/\\*[^]*?\\*\\//, token: \"comment\" },\n    /* Unterminated: to EOF. A `/*` someone is halfway through typing must not\n       leave the remainder of the file coloured as live declarations. */\n    { match: /\\/\\*[^]*/, token: \"comment\" },\n    { match: /\\/\\/[^\\n]*/, token: \"comment\" },\n  ];\n}\n\nexport const css = defineGrammar({\n  name: \"css\",\n  aliases: [\"scss\", \"sass\", \"less\", \"postcss\", \"pcss\"],\n  states: {\n    /* Selector context. */\n    root: [\n      { match: /url\\([^)\"'\\n]*\\)/i, token: \"url\" },\n      ...comments(),\n\n      { match: /@[\\w-]+/, token: \"atrule\" },\n      { match: /\\{/, token: \"punctuation\", push: \"block\" },\n      { match: /\\}/, token: \"punctuation\" },\n\n      { match: /\"/, token: \"string\", push: \"dqString\" },\n      { match: /'/, token: \"string\", push: \"sqString\" },\n\n      { match: /\\[[^\\]\\n]*\\]/, token: \"selector\" },\n      { match: /::?[A-Za-z][\\w-]*(?:\\([^)\\n]*\\))?/, token: \"selector\" },\n      { match: /[.#][\\w-]+/, token: \"selector\" },\n      { match: /[&*]/, token: \"selector\" },\n      { match: /-?[A-Za-z_][\\w-]*/, token: \"selector\" },\n\n      { match: /([+-]?(?:\\d*\\.\\d+|\\d+))(%|[A-Za-z]+)?/, groups: [\"number\", \"type\"] },\n      { match: /[()[\\],;:]/, token: \"punctuation\" },\n      { match: /[>+~]/, token: \"operator\" },\n    ],\n\n    /* Declaration context. */\n    block: [\n      { match: /url\\([^)\"'\\n]*\\)/i, token: \"url\" },\n      ...comments(),\n\n      { match: /\\}/, token: \"punctuation\", pop: true },\n      /* Nesting: a preprocessor block inside a block. The inner selector is\n         read with declaration rules, which is imperfect and still far better\n         than dropping out of block context and mis-reading the closing brace. */\n      { match: /\\{/, token: \"punctuation\", push: \"block\" },\n\n      { match: /!\\s*[\\w-]+/, token: \"keyword\" },\n      { match: /@[\\w-]+(?=[\\s({;])/, token: \"atrule\" },\n      { match: /--[\\w-]+(?=\\s*:)/, token: \"property\" },\n      { match: /-?[A-Za-z_][\\w-]*(?=\\s*:)/, token: \"property\" },\n\n      ...valueRules(),\n    ],\n\n    dqString: [\n      { match: /\\\\[^]/, token: \"escape\" },\n      { match: /\"/, token: \"string\", pop: true },\n      { match: /[^\"\\\\\\n]+/, token: \"string\" },\n      { match: /\\n/, token: \"text\", pop: true },\n    ],\n    sqString: [\n      { match: /\\\\[^]/, token: \"escape\" },\n      { match: /'/, token: \"string\", pop: true },\n      { match: /[^'\\\\\\n]+/, token: \"string\" },\n      { match: /\\n/, token: \"text\", pop: true },\n    ],\n  },\n});\n"],"names":["valueRules","comments","css","defineGrammar"],"mappings":"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"}

package/dist/lib/syntax/languages/html.js

@@ -0,0 +1,91 @@
+import { defineGrammar as a } from "../registry.js";
+function s(n, t) {
+  const e = new RegExp(`\\b${t}\\s*=\\s*("[^"]*"|'[^']*'|[^\\s>]+)`, "i").exec(n);
+  return e ? e[1].replace(/^["']|["']$/g, "").trim() : null;
+}
+function r(n) {
+  const t = s(n, "lang")?.toLowerCase();
+  if (t)
+    return t === "ts" || t === "typescript" ? "typescript" : t === "tsx" ? "tsx" : t === "jsx" ? "jsx" : "javascript";
+  const e = s(n, "type")?.toLowerCase() ?? "";
+  return e.includes("typescript") ? "typescript" : e.includes("json") || e === "importmap" || e === "speculationrules" ? "json" : "javascript";
+}
+function o(n) {
+  const t = s(n, "lang")?.toLowerCase();
+  return t === "scss" || t === "sass" ? "scss" : t === "less" ? "less" : "css";
+}
+function c() {
+  return {
+    tag: [
+      { match: /\/?>/, token: "tag", pop: !0 },
+      { match: /=/, token: "operator" },
+      { match: /"/, token: "string", push: "dqAttr" },
+      { match: /'/, token: "string", push: "sqAttr" },
+      /* An unquoted value, recognised by what precedes it rather than by its
+         own shape — otherwise `width=100` colours `100` as another attribute. */
+      { match: new RegExp("(?<==\\s*)[^\\s=<>\"'`]+"), token: "string" },
+      /* Permissive on purpose: `@click`, `:prop`, `v-bind:x`, `#slot`, `data-*`
+         and `xlink:href` are all attribute names in something this parses. */
+      { match: /[^\s=<>"'`/]+/, token: "attribute" }
+    ],
+    /* Attribute values may legally span lines (long class lists do it), so
+       unlike a code string these do not pop at `\n`. */
+    dqAttr: [
+      { match: /"/, token: "string", pop: !0 },
+      { match: /&(?:#\d+|#[xX][0-9a-fA-F]+|[A-Za-z][A-Za-z0-9]*);/, token: "escape" },
+      { match: /[^"&]+|&/, token: "string" }
+    ],
+    sqAttr: [
+      { match: /'/, token: "string", pop: !0 },
+      { match: /&(?:#\d+|#[xX][0-9a-fA-F]+|[A-Za-z][A-Za-z0-9]*);/, token: "escape" },
+      { match: /[^'&]+|&/, token: "string" }
+    ]
+  };
+}
+function i(n, t) {
+  return [
+    {
+      match: /(<script)(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>"'])*)(>)/i,
+      groups: ["tag", "attribute", "tag"],
+      embed: (e) => r(e[2]),
+      until: n,
+      untilToken: "tag"
+    },
+    {
+      match: /(<style)(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>"'])*)(>)/i,
+      groups: ["tag", "attribute", "tag"],
+      embed: (e) => o(e[2]),
+      until: t,
+      untilToken: "tag"
+    }
+  ];
+}
+const m = a({
+  name: "html",
+  aliases: ["htm", "xml", "svg"],
+  states: {
+    root: [
+      { match: /<!--[^]*?-->/, token: "comment" },
+      /* Unterminated comment swallows the rest, which is exactly what a browser
+         does — the alternative is colouring dead markup as live. */
+      { match: /<!--[^]*/, token: "comment" },
+      { match: /<!\[CDATA\[[^]*?\]\]>/, token: "string" },
+      { match: /<!doctype\b[^>]*>/i, token: "keyword" },
+      { match: /<\?[^]*?\?>/, token: "keyword" },
+      ...i(/<\/script\s*>/i, /<\/style\s*>/i),
+      { match: /<\/?[A-Za-z][\w:.-]*/, token: "tag", push: "tag" },
+      { match: /\{\{/, token: "punctuation", embed: "javascript", until: /\}\}/, untilToken: "punctuation" },
+      { match: /&(?:#\d+|#[xX][0-9a-fA-F]+|[A-Za-z][A-Za-z0-9]*);/, token: "escape" }
+    ],
+    ...c()
+  }
+});
+export {
+  s as attrValue,
+  i as embedRules,
+  m as html,
+  c as markupStates,
+  r as scriptLang,
+  o as styleLang
+};
+//# sourceMappingURL=html.js.map

package/dist/lib/syntax/languages/html.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.js","sources":["../../../../src/lib/syntax/languages/html.ts"],"sourcesContent":["import { defineGrammar } from \"../registry\";\nimport type { Rule } from \"../types\";\n\n/* ============================================================================\n   HTML, XML, SVG — and the two languages that live inside them.\n\n   `<style>` AND `<script>` ARE EMBEDS, NOT DECORATION. A page's CSS and its\n   JavaScript are the parts a reader actually reads; leaving them as undifferen-\n   tiated markup text is the difference between a highlighter and a colouriser.\n   The scanner locates `</script>` BEFORE the inner grammar runs, so a `</script>`\n   sitting inside a JavaScript string cannot end the block early — that is the\n   host's decision to make and only the host can make it correctly.\n\n   THE OPENING TAG OF AN EMBED IS ONE RULE, SO ITS ATTRIBUTES ARE ONE TOKEN.\n   `embed` is a property of the rule that OPENS the region, and its callback\n   only ever sees that rule's own match — which means the match has to include\n   the attributes, or `lang=\"ts\"` is invisible at the moment the language is\n   chosen. Splitting attributes into names and values would take a state, and a\n   state cannot carry a decision back to the rule that opened it. The trade is\n   deliberate: `setup lang=\"ts\"` reads as one attribute run, and in exchange the\n   block inside it is genuinely TypeScript.\n\n   `type=\"module\"` IS STILL JAVASCRIPT. It is a loading mode, not a language, so\n   it stays `javascript`; `lang=\"ts\"` and a `type` naming typescript are the only\n   things that switch. Being consistent here matters more than being clever —\n   a reader must be able to predict which colours a `<script>` will get.\n\n   `{{ … }}` IS TREATED AS AN EXPRESSION. Nothing in plain HTML produces double\n   braces in text; in practice they are always a template interpolation (Vue,\n   Angular, Handlebars), and reading them as JavaScript is right far more often\n   than it is wrong. An unknown embed is still safe — it degrades to plain text\n   and still terminates.\n   ========================================================================= */\n\n/** Reads one attribute out of the raw attribute run of an opening tag. */\nexport function attrValue(attrs: string, name: string): string | null {\n  const m = new RegExp(`\\\\b${name}\\\\s*=\\\\s*(\"[^\"]*\"|'[^']*'|[^\\\\s>]+)`, \"i\").exec(attrs);\n  if (!m) return null;\n  return m[1].replace(/^[\"']|[\"']$/g, \"\").trim();\n}\n\n/** The language a `<script>` block's attributes ask for. */\nexport function scriptLang(attrs: string): string {\n  const lang = attrValue(attrs, \"lang\")?.toLowerCase();\n  if (lang) {\n    if (lang === \"ts\" || lang === \"typescript\") return \"typescript\";\n    if (lang === \"tsx\") return \"tsx\";\n    if (lang === \"jsx\") return \"jsx\";\n    return \"javascript\";\n  }\n\n  const type = attrValue(attrs, \"type\")?.toLowerCase() ?? \"\";\n  if (type.includes(\"typescript\")) return \"typescript\";\n  if (type.includes(\"json\") || type === \"importmap\" || type === \"speculationrules\") return \"json\";\n  return \"javascript\";\n}\n\n/** The language a `<style>` block's attributes ask for. */\nexport function styleLang(attrs: string): string {\n  const lang = attrValue(attrs, \"lang\")?.toLowerCase();\n  if (lang === \"scss\" || lang === \"sass\") return \"scss\";\n  if (lang === \"less\") return \"less\";\n  return \"css\";\n}\n\n/**\n * The tag-interior states, shared with the Vue grammar so a directive like\n * `@click` or `:prop` is understood identically in both. Returned fresh per\n * grammar — `defineGrammar` rewrites every pattern, so sharing rule OBJECTS\n * between two grammars would work only by luck.\n */\nexport function markupStates(): Record<string, Rule[]> {\n  return {\n    tag: [\n      { match: /\\/?>/, token: \"tag\", pop: true },\n      { match: /=/, token: \"operator\" },\n      { match: /\"/, token: \"string\", push: \"dqAttr\" },\n      { match: /'/, token: \"string\", push: \"sqAttr\" },\n      /* An unquoted value, recognised by what precedes it rather than by its\n         own shape — otherwise `width=100` colours `100` as another attribute. */\n      { match: /(?<==\\s*)[^\\s=<>\"'`]+/, token: \"string\" },\n      /* Permissive on purpose: `@click`, `:prop`, `v-bind:x`, `#slot`, `data-*`\n         and `xlink:href` are all attribute names in something this parses. */\n      { match: /[^\\s=<>\"'`/]+/, token: \"attribute\" },\n    ],\n\n    /* Attribute values may legally span lines (long class lists do it), so\n       unlike a code string these do not pop at `\\n`. */\n    dqAttr: [\n      { match: /\"/, token: \"string\", pop: true },\n      { match: /&(?:#\\d+|#[xX][0-9a-fA-F]+|[A-Za-z][A-Za-z0-9]*);/, token: \"escape\" },\n      { match: /[^\"&]+|&/, token: \"string\" },\n    ],\n    sqAttr: [\n      { match: /'/, token: \"string\", pop: true },\n      { match: /&(?:#\\d+|#[xX][0-9a-fA-F]+|[A-Za-z][A-Za-z0-9]*);/, token: \"escape\" },\n      { match: /[^'&]+|&/, token: \"string\" },\n    ],\n  };\n}\n\n/** The `<script>` / `<style>` embed rules, shared with Vue's own root. */\nexport function embedRules(scriptUntil: RegExp, styleUntil: RegExp): Rule[] {\n  return [\n    {\n      match: /(<script)(?=[\\s/>])((?:\"[^\"]*\"|'[^']*'|[^>\"'])*)(>)/i,\n      groups: [\"tag\", \"attribute\", \"tag\"],\n      embed: (m) => scriptLang(m[2]),\n      until: scriptUntil,\n      untilToken: \"tag\",\n    },\n    {\n      match: /(<style)(?=[\\s/>])((?:\"[^\"]*\"|'[^']*'|[^>\"'])*)(>)/i,\n      groups: [\"tag\", \"attribute\", \"tag\"],\n      embed: (m) => styleLang(m[2]),\n      until: styleUntil,\n      untilToken: \"tag\",\n    },\n  ];\n}\n\nexport const html = defineGrammar({\n  name: \"html\",\n  aliases: [\"htm\", \"xml\", \"svg\"],\n  states: {\n    root: [\n      { match: /<!--[^]*?-->/, token: \"comment\" },\n      /* Unterminated comment swallows the rest, which is exactly what a browser\n         does — the alternative is colouring dead markup as live. */\n      { match: /<!--[^]*/, token: \"comment\" },\n\n      { match: /<!\\[CDATA\\[[^]*?\\]\\]>/, token: \"string\" },\n      { match: /<!doctype\\b[^>]*>/i, token: \"keyword\" },\n      { match: /<\\?[^]*?\\?>/, token: \"keyword\" },\n\n      ...embedRules(/<\\/script\\s*>/i, /<\\/style\\s*>/i),\n\n      { match: /<\\/?[A-Za-z][\\w:.-]*/, token: \"tag\", push: \"tag\" },\n\n      { match: /\\{\\{/, token: \"punctuation\", embed: \"javascript\", until: /\\}\\}/, untilToken: \"punctuation\" },\n\n      { match: /&(?:#\\d+|#[xX][0-9a-fA-F]+|[A-Za-z][A-Za-z0-9]*);/, token: \"escape\" },\n    ],\n\n    ...markupStates(),\n  },\n});\n"],"names":["attrValue","attrs","name","m","scriptLang","lang","type","styleLang","markupStates","embedRules","scriptUntil","styleUntil","html","defineGrammar"],"mappings":"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"}

package/dist/lib/syntax/languages/index.js

@@ -0,0 +1,49 @@
+import { bash as o } from "./bash.js";
+import { css as m } from "./css.js";
+import { html as r } from "./html.js";
+import { javascript as t, typescript as p, jsx as i, tsx as s } from "./javascript.js";
+import { markdown as f } from "../markdown/grammar.js";
+import { json as a } from "./json.js";
+import { mongodb as l } from "./mongodb.js";
+import { plain as n } from "./plain.js";
+import { sql as c, mysql as e, postgresql as j } from "./sql.js";
+import { vue as q } from "./vue.js";
+import { yaml as x } from "./yaml.js";
+const E = [
+  n,
+  a,
+  x,
+  f,
+  t,
+  p,
+  i,
+  s,
+  r,
+  m,
+  c,
+  e,
+  j,
+  l,
+  o,
+  q
+];
+export {
+  E as LANGUAGES,
+  o as bash,
+  m as css,
+  r as html,
+  t as javascript,
+  a as json,
+  i as jsx,
+  f as markdown,
+  l as mongodb,
+  e as mysql,
+  n as plain,
+  j as postgresql,
+  c as sql,
+  s as tsx,
+  p as typescript,
+  q as vue,
+  x as yaml
+};
+//# sourceMappingURL=index.js.map

package/dist/lib/syntax/languages/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/lib/syntax/languages/index.ts"],"sourcesContent":["import type { Grammar } from \"../types\";\nimport { bash } from \"./bash\";\nimport { css } from \"./css\";\nimport { html } from \"./html\";\nimport { javascript, jsx, tsx, typescript } from \"./javascript\";\nimport { markdown } from \"../markdown/grammar\";\nimport { json } from \"./json\";\nimport { mongodb } from \"./mongodb\";\nimport { plain } from \"./plain\";\nimport { mysql, postgresql, sql } from \"./sql\";\nimport { vue } from \"./vue\";\nimport { yaml } from \"./yaml\";\n\n/**\n * Every grammar, as a VALUE. `src/lib/syntax/index.ts` iterates this list to\n * seed the registry at module load.\n *\n * It is a list rather than each module registering itself on import, because\n * `package.json` declares `sideEffects: [\"*.css\"]` — which tells every bundler\n * that a bare `import \"./javascript\"` is safe to delete, and esbuild does. That\n * is exactly how this project once shipped an empty icon registry (CAV-11).\n *\n * Order is not significant: an embedded language is resolved through\n * `getGrammar` when the region is scanned, not when the grammar is defined, so\n * `vue` may reference `css` regardless of which was registered first.\n *\n * Markdown is imported from its own module rather than its barrel: the barrel\n * also exports the React renderer, and the tokenizer must stay usable without\n * React in the graph.\n *\n * Adding a language: write the grammar, add it here. Nothing else.\n */\nexport const LANGUAGES: Grammar[] = [\n  plain,\n  json,\n  yaml,\n  markdown,\n  javascript,\n  typescript,\n  jsx,\n  tsx,\n  html,\n  css,\n  sql,\n  mysql,\n  postgresql,\n  mongodb,\n  bash,\n  vue,\n];\n\nexport { plain, json, yaml, markdown, javascript, typescript, jsx, tsx, html, css, sql, mysql, postgresql, mongodb, bash, vue };\n"],"names":["LANGUAGES","plain","json","yaml","markdown","javascript","typescript","jsx","tsx","html","css","sql","mysql","postgresql","mongodb","bash","vue"],"mappings":";;;;;;;;;;;AAgCO,MAAMA,IAAuB;AAAA,EAClCC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AACF;"}

package/dist/lib/syntax/languages/javascript.js

@@ -0,0 +1,133 @@
+import { defineGrammar as n } from "../registry.js";
+function o(t) {
+  return t.trim().split(/\s+/).sort((s, e) => e.length - s.length).join("|");
+}
+const i = o(`
+  as async await break case catch class const continue debugger default delete
+  do else export extends finally for from function get if import in instanceof
+  let new of return set static super switch this throw try typeof var void
+  while with yield
+`), p = o(`
+  abstract accessor asserts declare enum global implements infer interface is
+  keyof module namespace out override private protected public readonly require
+  satisfies type unique
+`), h = o("any bigint boolean never number object string symbol unknown");
+function a(t, s = []) {
+  const e = [
+    ...s,
+    /* Comments first, or `//` reads as an empty regex literal and `/*` as a
+       division followed by a multiplication. */
+    { match: /\/\/[^\n]*/, token: "comment" },
+    { match: /\/\*[^]*?\*\//, token: "comment" },
+    /* Unterminated block comment: everything to EOF is comment. Without this
+       the `/` falls through to the operator rule and the rest of the file is
+       highlighted as code that the compiler will never see. */
+    { match: /\/\*[^]*/, token: "comment" },
+    { match: /`/, token: "string", push: "template" },
+    { match: /"/, token: "string", push: "dqString" },
+    { match: /'/, token: "string", push: "sqString" },
+    /* The regex heuristic. Two lookbehinds: the first admits the keywords that
+       are followed by a value, the second rejects anything that could END a
+       value. Neither consumes, so the token is exactly the literal. */
+    {
+      match: new RegExp("(?:(?<=\\b(?:return|typeof|instanceof|case|delete|void|yield|await|in|of|do|else)\\s*)|(?<![\\w$)\\]]\\s*))\\/(?![*/])(?:\\[(?:\\\\.|[^\\]\\\\\\n])*\\]|\\\\.|[^/\\\\\\n[])+\\/[dgimsuvy]*"),
+      token: "regex"
+    },
+    {
+      match: /0[bB][01](?:_?[01])*n?|0[oO][0-7](?:_?[0-7])*n?|0[xX][0-9a-fA-F](?:_?[0-9a-fA-F])*n?|(?:\d(?:_?\d)*)?\.\d(?:_?\d)*(?:[eE][+-]?\d(?:_?\d)*)?|\d(?:_?\d)*(?:\.(?:\d(?:_?\d)*)?)?(?:[eE][+-]?\d(?:_?\d)*)?n?/,
+      token: "number"
+    },
+    /* `(?![\w$])` rather than `\b`: `$` is not a word character, so `\b` would
+       happily end a keyword at `for$` and colour half an identifier. */
+    { match: /\b(?:true|false)(?![\w$])/, token: "boolean" },
+    { match: /\b(?:null|undefined)(?![\w$])/, token: "null" },
+    ...t.ts ? [{ match: new RegExp(`\\b(?:${h})(?![\\w$])`), token: "type" }] : [],
+    {
+      match: new RegExp(`\\b(?:${t.ts ? `${i}|${p}` : i})(?![\\w$])`),
+      token: "keyword"
+    },
+    /* Decorators read as annotations, which is what `attribute` is for — the
+       same role an attribute plays on a tag. */
+    { match: /@[A-Za-z_$][\w$]*/, token: "attribute" },
+    { match: /#[A-Za-z_$][\w$]*/, token: "property" },
+    /* Callee before member, member before key, key before plain identifier.
+       Reordering these silently degrades: `obj.map(` would stop being a call. */
+    { match: /[A-Za-z_$][\w$]*(?=\s*\()/, token: "function" },
+    { match: new RegExp("(?<=\\.)[A-Za-z_$][\\w$]*"), token: "property" },
+    { match: /[A-Za-z_$][\w$]*(?=\s*:)/, token: "property" },
+    { match: new RegExp("(?<![\\w$])[A-Z][A-Z0-9_]*[A-Z0-9](?![\\w$])"), token: "constant" },
+    { match: new RegExp("(?<![\\w$])[A-Z][A-Za-z0-9_$]*(?![\\w$])"), token: "type" },
+    { match: /[A-Za-z_$][\w$]*/, token: "variable" },
+    {
+      match: /\.\.\.|=>|\?\?=|\?\?|\?\.|\*\*=|\*\*|\+\+|--|<<=|>>>=|>>=|>>>|<<|>>|===|!==|==|!=|<=|>=|&&=|\|\|=|&&|\|\||[+\-*/%&|^]=|=|[+\-*/%&|^~!<>]|\?/,
+      token: "operator"
+    },
+    { match: /[()[\];,.:]/, token: "punctuation" }
+  ], m = [
+    { match: /<>|<\/>/, token: "tag" },
+    /* `(?=[\s/>])` is what keeps `x <a` from becoming a tag: a real element is
+       always followed by whitespace, `/` or `>`. */
+    { match: /<\/?[A-Za-z][\w.:-]*(?=[\s/>])/, token: "tag", push: "jsxTag" }
+  ], c = t.jsx ? [...m, ...e] : e, r = {
+    root: [...c, { match: /[{}]/, token: "punctuation" }],
+    /* One state serves both `${…}` and any nested object literal inside it, so
+       `${ {a: 1} }` closes the right brace. A second state would be identical. */
+    interp: [
+      { match: /\}/, token: "punctuation", pop: !0 },
+      { match: /\{/, token: "punctuation", push: "interp" },
+      ...c
+    ],
+    template: [
+      { match: /\\[^]/, token: "escape" },
+      { match: /\$\{/, token: "punctuation", push: "interp" },
+      { match: /`/, token: "string", pop: !0 },
+      { match: /[^`\\$]+/, token: "string" },
+      /* A `$` that is not opening an interpolation is ordinary content. */
+      { match: /\$/, token: "string" }
+    ],
+    dqString: [
+      { match: /\\(?:u\{[0-9a-fA-F]+\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|[^])/, token: "escape" },
+      { match: /"/, token: "string", pop: !0 },
+      { match: /[^"\\\n]+/, token: "string" },
+      { match: /\n/, token: "text", pop: !0 }
+    ],
+    sqString: [
+      { match: /\\(?:u\{[0-9a-fA-F]+\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|[^])/, token: "escape" },
+      { match: /'/, token: "string", pop: !0 },
+      { match: /[^'\\\n]+/, token: "string" },
+      { match: /\n/, token: "text", pop: !0 }
+    ]
+  };
+  return t.jsx && (r.jsxTag = [
+    { match: /\/?>/, token: "tag", pop: !0 },
+    { match: /\{/, token: "punctuation", push: "interp" },
+    { match: /"/, token: "string", push: "dqString" },
+    { match: /'/, token: "string", push: "sqString" },
+    { match: /=/, token: "operator" },
+    { match: /[@:]?[A-Za-z_$][\w$.:-]*/, token: "attribute" },
+    { match: /\s+/, token: "text" }
+  ]), r;
+}
+const k = n({
+  name: "javascript",
+  aliases: ["js", "mjs", "cjs", "node"],
+  states: a({ ts: !1, jsx: !1 })
+}), d = n({
+  name: "typescript",
+  aliases: ["ts", "mts", "cts"],
+  states: a({ ts: !0, jsx: !1 })
+}), l = n({
+  name: "jsx",
+  states: a({ ts: !1, jsx: !0 })
+}), g = n({
+  name: "tsx",
+  states: a({ ts: !0, jsx: !0 })
+});
+export {
+  k as javascript,
+  a as jsStates,
+  l as jsx,
+  g as tsx,
+  d as typescript
+};
+//# sourceMappingURL=javascript.js.map

package/dist/lib/syntax/languages/javascript.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript.js","sources":["../../../../src/lib/syntax/languages/javascript.ts"],"sourcesContent":["import { defineGrammar } from \"../registry\";\nimport type { Rule } from \"../types\";\n\n/* ============================================================================\n   JAVASCRIPT, TYPESCRIPT, JSX, TSX — one rule set, four registrations.\n\n   THEY ARE ONE LANGUAGE, AND FORKING THEM WOULD MEAN FIXING EVERY BUG FOUR\n   TIMES. `jsStates()` builds the whole state machine from two booleans, so a\n   correction to template literals or to the regex heuristic lands in all four\n   at once. The differences are genuinely that small: TypeScript adds keywords\n   and primitive type names, JSX adds element rules.\n\n   JSX IS OPT-IN, AND THAT IS THE POINT. `a < b` and `<Foo>` are the same two\n   characters. A grammar that guesses gets one of them wrong in every file, so\n   `javascript` and `typescript` never treat `<` as a tag and `jsx`/`tsx` always\n   consider it. Picking the right fence label is the author's decision, and it\n   is the only decision that can actually be correct.\n\n   REGEX-VS-DIVISION IS A HEURISTIC AND IS LABELLED AS ONE. Telling `/` apart\n   needs to know whether the previous token ended a VALUE (division) or ended an\n   OPERATOR (regex literal), which is parser knowledge this scanner does not\n   have. The rule below approximates it with a lookbehind: a `/` is a regex\n   unless the nearest preceding non-space character could end a value\n   (identifier char, `)`, `]`), with an explicit exception for the keywords that\n   can precede a value (`return /x/`). The known wrong answers are `if (x) /re/`\n   and `)` closing a control head — both read as division. That is a colouring\n   mistake in an uncommon line, not a coverage break: the token stream still\n   reproduces the source exactly, which is the invariant that actually matters.\n\n   EVERY QUOTED STRING ENDS AT A NEWLINE. Multi-line strings are legal in almost\n   none of these languages, and an editor is full of half-typed lines. A string\n   state that ran past `\\n` would repaint the entire rest of the file the moment\n   someone typed one quote.\n   ========================================================================= */\n\n/** Longest-first so `in` cannot shadow `instanceof` under a backtracking engine. */\nfunction words(list: string): string {\n  return list\n    .trim()\n    .split(/\\s+/)\n    .sort((a, b) => b.length - a.length)\n    .join(\"|\");\n}\n\nconst JS_KEYWORDS = words(`\n  as async await break case catch class const continue debugger default delete\n  do else export extends finally for from function get if import in instanceof\n  let new of return set static super switch this throw try typeof var void\n  while with yield\n`);\n\nconst TS_KEYWORDS = words(`\n  abstract accessor asserts declare enum global implements infer interface is\n  keyof module namespace out override private protected public readonly require\n  satisfies type unique\n`);\n\nconst TS_PRIMITIVES = words(`any bigint boolean never number object string symbol unknown`);\n\nexport interface JsFlavour {\n  /** TypeScript keywords and primitive type names. */\n  ts: boolean;\n  /** JSX element rules. See the JSX-IS-OPT-IN note above. */\n  jsx: boolean;\n}\n\n/**\n * The complete state machine, rebuilt per grammar.\n *\n * A FUNCTION, NOT A SHARED CONSTANT: `defineGrammar` rewrites every pattern\n * (sticky + hasIndices), and two grammars handing it the same rule objects\n * would work only by accident. Fresh objects make that impossible to get wrong.\n *\n * `prefix` rules are spliced in ahead of everything else in the shared rule\n * body, which is how MongoDB adds `$gte` without re-deriving JavaScript.\n */\nexport function jsStates(flavour: JsFlavour, prefix: Rule[] = []): Record<string, Rule[]> {\n  const base: Rule[] = [\n    ...prefix,\n\n    /* Comments first, or `//` reads as an empty regex literal and `/*` as a\n       division followed by a multiplication. */\n    { match: /\\/\\/[^\\n]*/, token: \"comment\" },\n    { match: /\\/\\*[^]*?\\*\\//, token: \"comment\" },\n    /* Unterminated block comment: everything to EOF is comment. Without this\n       the `/` falls through to the operator rule and the rest of the file is\n       highlighted as code that the compiler will never see. */\n    { match: /\\/\\*[^]*/, token: \"comment\" },\n\n    { match: /`/, token: \"string\", push: \"template\" },\n    { match: /\"/, token: \"string\", push: \"dqString\" },\n    { match: /'/, token: \"string\", push: \"sqString\" },\n\n    /* The regex heuristic. Two lookbehinds: the first admits the keywords that\n       are followed by a value, the second rejects anything that could END a\n       value. Neither consumes, so the token is exactly the literal. */\n    {\n      match:\n        /(?:(?<=\\b(?:return|typeof|instanceof|case|delete|void|yield|await|in|of|do|else)\\s*)|(?<![\\w$)\\]]\\s*))\\/(?![*/])(?:\\[(?:\\\\.|[^\\]\\\\\\n])*\\]|\\\\.|[^/\\\\\\n[])+\\/[dgimsuvy]*/,\n      token: \"regex\",\n    },\n\n    {\n      match:\n        /0[bB][01](?:_?[01])*n?|0[oO][0-7](?:_?[0-7])*n?|0[xX][0-9a-fA-F](?:_?[0-9a-fA-F])*n?|(?:\\d(?:_?\\d)*)?\\.\\d(?:_?\\d)*(?:[eE][+-]?\\d(?:_?\\d)*)?|\\d(?:_?\\d)*(?:\\.(?:\\d(?:_?\\d)*)?)?(?:[eE][+-]?\\d(?:_?\\d)*)?n?/,\n      token: \"number\",\n    },\n\n    /* `(?![\\w$])` rather than `\\b`: `$` is not a word character, so `\\b` would\n       happily end a keyword at `for$` and colour half an identifier. */\n    { match: /\\b(?:true|false)(?![\\w$])/, token: \"boolean\" },\n    { match: /\\b(?:null|undefined)(?![\\w$])/, token: \"null\" },\n    ...(flavour.ts ? [{ match: new RegExp(`\\\\b(?:${TS_PRIMITIVES})(?![\\\\w$])`), token: \"type\" } as Rule] : []),\n    {\n      match: new RegExp(`\\\\b(?:${flavour.ts ? `${JS_KEYWORDS}|${TS_KEYWORDS}` : JS_KEYWORDS})(?![\\\\w$])`),\n      token: \"keyword\",\n    },\n\n    /* Decorators read as annotations, which is what `attribute` is for — the\n       same role an attribute plays on a tag. */\n    { match: /@[A-Za-z_$][\\w$]*/, token: \"attribute\" },\n    { match: /#[A-Za-z_$][\\w$]*/, token: \"property\" },\n\n    /* Callee before member, member before key, key before plain identifier.\n       Reordering these silently degrades: `obj.map(` would stop being a call. */\n    { match: /[A-Za-z_$][\\w$]*(?=\\s*\\()/, token: \"function\" },\n    { match: /(?<=\\.)[A-Za-z_$][\\w$]*/, token: \"property\" },\n    { match: /[A-Za-z_$][\\w$]*(?=\\s*:)/, token: \"property\" },\n    { match: /(?<![\\w$])[A-Z][A-Z0-9_]*[A-Z0-9](?![\\w$])/, token: \"constant\" },\n    { match: /(?<![\\w$])[A-Z][A-Za-z0-9_$]*(?![\\w$])/, token: \"type\" },\n    { match: /[A-Za-z_$][\\w$]*/, token: \"variable\" },\n\n    {\n      match:\n        /\\.\\.\\.|=>|\\?\\?=|\\?\\?|\\?\\.|\\*\\*=|\\*\\*|\\+\\+|--|<<=|>>>=|>>=|>>>|<<|>>|===|!==|==|!=|<=|>=|&&=|\\|\\|=|&&|\\|\\||[+\\-*/%&|^]=|=|[+\\-*/%&|^~!<>]|\\?/,\n      token: \"operator\",\n    },\n    { match: /[()[\\];,.:]/, token: \"punctuation\" },\n  ];\n\n  const jsxRules: Rule[] = [\n    { match: /<>|<\\/>/, token: \"tag\" },\n    /* `(?=[\\s/>])` is what keeps `x <a` from becoming a tag: a real element is\n       always followed by whitespace, `/` or `>`. */\n    { match: /<\\/?[A-Za-z][\\w.:-]*(?=[\\s/>])/, token: \"tag\", push: \"jsxTag\" },\n  ];\n\n  const braceless = flavour.jsx ? [...jsxRules, ...base] : base;\n\n  const states: Record<string, Rule[]> = {\n    root: [...braceless, { match: /[{}]/, token: \"punctuation\" }],\n\n    /* One state serves both `${…}` and any nested object literal inside it, so\n       `${ {a: 1} }` closes the right brace. A second state would be identical. */\n    interp: [\n      { match: /\\}/, token: \"punctuation\", pop: true },\n      { match: /\\{/, token: \"punctuation\", push: \"interp\" },\n      ...braceless,\n    ],\n\n    template: [\n      { match: /\\\\[^]/, token: \"escape\" },\n      { match: /\\$\\{/, token: \"punctuation\", push: \"interp\" },\n      { match: /`/, token: \"string\", pop: true },\n      { match: /[^`\\\\$]+/, token: \"string\" },\n      /* A `$` that is not opening an interpolation is ordinary content. */\n      { match: /\\$/, token: \"string\" },\n    ],\n\n    dqString: [\n      { match: /\\\\(?:u\\{[0-9a-fA-F]+\\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|[^])/, token: \"escape\" },\n      { match: /\"/, token: \"string\", pop: true },\n      { match: /[^\"\\\\\\n]+/, token: \"string\" },\n      { match: /\\n/, token: \"text\", pop: true },\n    ],\n\n    sqString: [\n      { match: /\\\\(?:u\\{[0-9a-fA-F]+\\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|[^])/, token: \"escape\" },\n      { match: /'/, token: \"string\", pop: true },\n      { match: /[^'\\\\\\n]+/, token: \"string\" },\n      { match: /\\n/, token: \"text\", pop: true },\n    ],\n  };\n\n  if (flavour.jsx) {\n    states.jsxTag = [\n      { match: /\\/?>/, token: \"tag\", pop: true },\n      { match: /\\{/, token: \"punctuation\", push: \"interp\" },\n      { match: /\"/, token: \"string\", push: \"dqString\" },\n      { match: /'/, token: \"string\", push: \"sqString\" },\n      { match: /=/, token: \"operator\" },\n      { match: /[@:]?[A-Za-z_$][\\w$.:-]*/, token: \"attribute\" },\n      { match: /\\s+/, token: \"text\" },\n    ];\n  }\n\n  return states;\n}\n\nexport const javascript = defineGrammar({\n  name: \"javascript\",\n  aliases: [\"js\", \"mjs\", \"cjs\", \"node\"],\n  states: jsStates({ ts: false, jsx: false }),\n});\n\nexport const typescript = defineGrammar({\n  name: \"typescript\",\n  aliases: [\"ts\", \"mts\", \"cts\"],\n  states: jsStates({ ts: true, jsx: false }),\n});\n\nexport const jsx = defineGrammar({\n  name: \"jsx\",\n  states: jsStates({ ts: false, jsx: true }),\n});\n\nexport const tsx = defineGrammar({\n  name: \"tsx\",\n  states: jsStates({ ts: true, jsx: true }),\n});\n"],"names":["words","list","a","b","JS_KEYWORDS","TS_KEYWORDS","TS_PRIMITIVES","jsStates","flavour","prefix","base","jsxRules","braceless","states","javascript","defineGrammar","typescript","jsx","tsx"],"mappings":"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"}

package/dist/lib/syntax/languages/json.js

@@ -0,0 +1,45 @@
+import { defineGrammar as t } from "../registry.js";
+const e = t({
+  name: "json",
+  aliases: ["jsonc", "json5"],
+  states: {
+    root: [
+      { match: /\/\/[^\n]*/, token: "comment" },
+      { match: /\/\*[^]*?\*\//, token: "comment" },
+      /* Unterminated block comment runs to EOF. The alternative is the `/`
+         falling through as plain text and the rest of the file being coloured
+         as live config while the parser sees none of it. */
+      { match: /\/\*[^]*/, token: "comment" },
+      { match: /"(?:[^"\\\n]|\\.)*"(?=\s*:)/, token: "property" },
+      { match: /'(?:[^'\\\n]|\\.)*'(?=\s*:)/, token: "property" },
+      { match: /[A-Za-z_$][\w$]*(?=\s*:)/, token: "property" },
+      { match: /"/, token: "string", push: "dqString" },
+      { match: /'/, token: "string", push: "sqString" },
+      { match: /\btrue\b|\bfalse\b/, token: "boolean" },
+      { match: /\bnull\b/, token: "null" },
+      {
+        match: /[+-]?(?:0[xX][0-9a-fA-F]+|Infinity|NaN|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?|\.\d+(?:[eE][+-]?\d+)?)/,
+        token: "number"
+      },
+      { match: /[{}[\],:]/, token: "punctuation" }
+    ],
+    /* `\n` pops. An editor sees a lone `"` constantly — half a typed line — and
+       a string state that outlived the line would repaint the whole document. */
+    dqString: [
+      { match: /\\(?:u[0-9a-fA-F]{4}|["\\/bfnrt]|[^])/, token: "escape" },
+      { match: /"/, token: "string", pop: !0 },
+      { match: /[^"\\\n]+/, token: "string" },
+      { match: /\n/, token: "text", pop: !0 }
+    ],
+    sqString: [
+      { match: /\\(?:u[0-9a-fA-F]{4}|['\\/bfnrt]|[^])/, token: "escape" },
+      { match: /'/, token: "string", pop: !0 },
+      { match: /[^'\\\n]+/, token: "string" },
+      { match: /\n/, token: "text", pop: !0 }
+    ]
+  }
+});
+export {
+  e as json
+};
+//# sourceMappingURL=json.js.map

package/dist/lib/syntax/languages/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sources":["../../../../src/lib/syntax/languages/json.ts"],"sourcesContent":["import { defineGrammar } from \"../registry\";\n\n/* ============================================================================\n   JSON — and, deliberately, its two dialects.\n\n   THE KEY IS NOT A STRING. `\"name\": \"value\"` has two quoted runs and they mean\n   completely different things: one is a NAME and one is a VALUE. Colouring them\n   identically is what makes a large config file unreadable, and separating them\n   is most of what JSON highlighting is for. The rule below decides with a\n   lookahead for the colon — the only information that tells them apart, and it\n   is available at exactly the moment the scanner needs it.\n\n   A KEY IS ONE TOKEN, escapes included. Splitting `é` out of a key would\n   mean pushing a state, and a state cannot see the colon that is still four\n   characters ahead. Values keep their escape highlighting; keys trade it for\n   being correctly identified, which is the trade that matters.\n\n   ONE GRAMMAR COVERS JSON, JSONC AND JSON5. Comments, single quotes, unquoted\n   keys and hex numbers are accepted here even though strict JSON forbids them.\n   A highlighter is not a validator: refusing to colour a `//` in a tsconfig\n   helps nobody, and a strict-mode fork would double every future fix for a\n   payoff that only ever appears as a MISSING colour. The aliases are claimed so\n   a `jsonc` fence resolves rather than falling back to plain text.\n   ========================================================================= */\n\nexport const json = defineGrammar({\n  name: \"json\",\n  aliases: [\"jsonc\", \"json5\"],\n  states: {\n    root: [\n      { match: /\\/\\/[^\\n]*/, token: \"comment\" },\n      { match: /\\/\\*[^]*?\\*\\//, token: \"comment\" },\n      /* Unterminated block comment runs to EOF. The alternative is the `/`\n         falling through as plain text and the rest of the file being coloured\n         as live config while the parser sees none of it. */\n      { match: /\\/\\*[^]*/, token: \"comment\" },\n\n      { match: /\"(?:[^\"\\\\\\n]|\\\\.)*\"(?=\\s*:)/, token: \"property\" },\n      { match: /'(?:[^'\\\\\\n]|\\\\.)*'(?=\\s*:)/, token: \"property\" },\n      { match: /[A-Za-z_$][\\w$]*(?=\\s*:)/, token: \"property\" },\n\n      { match: /\"/, token: \"string\", push: \"dqString\" },\n      { match: /'/, token: \"string\", push: \"sqString\" },\n\n      { match: /\\btrue\\b|\\bfalse\\b/, token: \"boolean\" },\n      { match: /\\bnull\\b/, token: \"null\" },\n      {\n        match:\n          /[+-]?(?:0[xX][0-9a-fA-F]+|Infinity|NaN|\\d+(?:\\.\\d*)?(?:[eE][+-]?\\d+)?|\\.\\d+(?:[eE][+-]?\\d+)?)/,\n        token: \"number\",\n      },\n\n      { match: /[{}[\\],:]/, token: \"punctuation\" },\n    ],\n\n    /* `\\n` pops. An editor sees a lone `\"` constantly — half a typed line — and\n       a string state that outlived the line would repaint the whole document. */\n    dqString: [\n      { match: /\\\\(?:u[0-9a-fA-F]{4}|[\"\\\\/bfnrt]|[^])/, token: \"escape\" },\n      { match: /\"/, token: \"string\", pop: true },\n      { match: /[^\"\\\\\\n]+/, token: \"string\" },\n      { match: /\\n/, token: \"text\", pop: true },\n    ],\n\n    sqString: [\n      { match: /\\\\(?:u[0-9a-fA-F]{4}|['\\\\/bfnrt]|[^])/, token: \"escape\" },\n      { match: /'/, token: \"string\", pop: true },\n      { match: /[^'\\\\\\n]+/, token: \"string\" },\n      { match: /\\n/, token: \"text\", pop: true },\n    ],\n  },\n});\n"],"names":["json","defineGrammar"],"mappings":";AAyBO,MAAMA,IAAOC,EAAc;AAAA,EAChC,MAAM;AAAA,EACN,SAAS,CAAC,SAAS,OAAO;AAAA,EAC1B,QAAQ;AAAA,IACN,MAAM;AAAA,MACJ,EAAE,OAAO,cAAc,OAAO,UAAA;AAAA,MAC9B,EAAE,OAAO,iBAAiB,OAAO,UAAA;AAAA;AAAA;AAAA;AAAA,MAIjC,EAAE,OAAO,YAAY,OAAO,UAAA;AAAA,MAE5B,EAAE,OAAO,+BAA+B,OAAO,WAAA;AAAA,MAC/C,EAAE,OAAO,+BAA+B,OAAO,WAAA;AAAA,MAC/C,EAAE,OAAO,4BAA4B,OAAO,WAAA;AAAA,MAE5C,EAAE,OAAO,KAAK,OAAO,UAAU,MAAM,WAAA;AAAA,MACrC,EAAE,OAAO,KAAK,OAAO,UAAU,MAAM,WAAA;AAAA,MAErC,EAAE,OAAO,sBAAsB,OAAO,UAAA;AAAA,MACtC,EAAE,OAAO,YAAY,OAAO,OAAA;AAAA,MAC5B;AAAA,QACE,OACE;AAAA,QACF,OAAO;AAAA,MAAA;AAAA,MAGT,EAAE,OAAO,aAAa,OAAO,cAAA;AAAA,IAAc;AAAA;AAAA;AAAA,IAK7C,UAAU;AAAA,MACR,EAAE,OAAO,yCAAyC,OAAO,SAAA;AAAA,MACzD,EAAE,OAAO,KAAK,OAAO,UAAU,KAAK,GAAA;AAAA,MACpC,EAAE,OAAO,aAAa,OAAO,SAAA;AAAA,MAC7B,EAAE,OAAO,MAAM,OAAO,QAAQ,KAAK,GAAA;AAAA,IAAK;AAAA,IAG1C,UAAU;AAAA,MACR,EAAE,OAAO,yCAAyC,OAAO,SAAA;AAAA,MACzD,EAAE,OAAO,KAAK,OAAO,UAAU,KAAK,GAAA;AAAA,MACpC,EAAE,OAAO,aAAa,OAAO,SAAA;AAAA,MAC7B,EAAE,OAAO,MAAM,OAAO,QAAQ,KAAK,GAAA;AAAA,IAAK;AAAA,EAC1C;AAEJ,CAAC;"}