@50arms/ui 0.0.0-stage → 35.1.0

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

@@ -0,0 +1,24 @@
+import { defineGrammar as e } from "../registry.js";
+import { jsStates as a } from "./javascript.js";
+const m = e({
+  name: "mongodb",
+  aliases: ["mongo", "nosql"],
+  states: a({ ts: !1, jsx: !1 }, [
+    /* Quoted first — the string rules would otherwise swallow `"$match"` whole,
+       and the bare rule below would never see it. */
+    { match: /"\$[A-Za-z][\w.]*"|'\$[A-Za-z][\w.]*'/, token: "keyword" },
+    { match: /\$\$?[A-Za-z][\w.]*/, token: "keyword" },
+    /* BSON constructors are types, not calls: `ObjectId("…")` names a VALUE
+       KIND. The base grammar's callee rule would otherwise type them `function`
+       and they would read like user-defined helpers. */
+    {
+      match: /\b(?:ObjectId|ISODate|NumberLong|NumberInt|NumberDecimal|BinData|UUID|Timestamp|MinKey|MaxKey|DBRef|Code|Decimal128|Long)(?![\w$])/,
+      token: "type"
+    },
+    { match: /\b(?:db|rs|sh|use)(?![\w$])/, token: "keyword" }
+  ])
+});
+export {
+  m as mongodb
+};
+//# sourceMappingURL=mongodb.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mongodb.js","sources":["../../../../src/lib/syntax/languages/mongodb.ts"],"sourcesContent":["import { defineGrammar } from \"../registry\";\nimport { jsStates } from \"./javascript\";\n\n/* ============================================================================\n   MONGODB — the shell dialect, which is JavaScript with an operator vocabulary.\n\n   THERE IS NO \"NOSQL\" LANGUAGE TO WRITE A GRAMMAR FOR, so `nosql` is claimed as\n   an alias of this: the concrete thing anyone labelling a block that way is\n   actually pasting is a Mongo query or an aggregation pipeline.\n\n   IT REUSES `jsStates` RATHER THAN RE-DERIVING JAVASCRIPT. A Mongo query IS\n   JavaScript — template literals, regex literals, comments and all — and a\n   second copy would mean fixing the regex-vs-division heuristic twice and\n   getting it wrong once. Only three rules are added, spliced in AHEAD of the\n   base set so they win where they overlap.\n\n   `$gte` IS A KEYWORD, NOT AN IDENTIFIER, and that is the whole reason this is\n   a separate registration. In plain JavaScript `$gte` is a perfectly ordinary\n   variable name and `\"$match\"` is a perfectly ordinary string; in a pipeline\n   they are the operators that carry all the meaning. Reading a stage document\n   with every `$` operator coloured as string is the failure this fixes.\n   ========================================================================= */\n\nexport const mongodb = defineGrammar({\n  name: \"mongodb\",\n  aliases: [\"mongo\", \"nosql\"],\n  states: jsStates({ ts: false, jsx: false }, [\n    /* Quoted first — the string rules would otherwise swallow `\"$match\"` whole,\n       and the bare rule below would never see it. */\n    { match: /\"\\$[A-Za-z][\\w.]*\"|'\\$[A-Za-z][\\w.]*'/, token: \"keyword\" },\n    { match: /\\$\\$?[A-Za-z][\\w.]*/, token: \"keyword\" },\n    /* BSON constructors are types, not calls: `ObjectId(\"…\")` names a VALUE\n       KIND. The base grammar's callee rule would otherwise type them `function`\n       and they would read like user-defined helpers. */\n    {\n      match:\n        /\\b(?:ObjectId|ISODate|NumberLong|NumberInt|NumberDecimal|BinData|UUID|Timestamp|MinKey|MaxKey|DBRef|Code|Decimal128|Long)(?![\\w$])/,\n      token: \"type\",\n    },\n    { match: /\\b(?:db|rs|sh|use)(?![\\w$])/, token: \"keyword\" },\n  ]),\n});\n"],"names":["mongodb","defineGrammar","jsStates"],"mappings":";;AAuBO,MAAMA,IAAUC,EAAc;AAAA,EACnC,MAAM;AAAA,EACN,SAAS,CAAC,SAAS,OAAO;AAAA,EAC1B,QAAQC,EAAS,EAAE,IAAI,IAAO,KAAK,MAAS;AAAA;AAAA;AAAA,IAG1C,EAAE,OAAO,yCAAyC,OAAO,UAAA;AAAA,IACzD,EAAE,OAAO,uBAAuB,OAAO,UAAA;AAAA;AAAA;AAAA;AAAA,IAIvC;AAAA,MACE,OACE;AAAA,MACF,OAAO;AAAA,IAAA;AAAA,IAET,EAAE,OAAO,+BAA+B,OAAO,UAAA;AAAA,EAAU,CAC1D;AACH,CAAC;"}

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

@@ -0,0 +1,10 @@
+import { defineGrammar as t } from "../registry.js";
+const a = t({
+  name: "plain",
+  aliases: ["text", "txt", "plaintext", "none"],
+  states: { root: [{ match: /[^]+/, token: "text" }] }
+});
+export {
+  a as plain
+};
+//# sourceMappingURL=plain.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plain.js","sources":["../../../../src/lib/syntax/languages/plain.ts"],"sourcesContent":["import { defineGrammar } from \"../registry\";\n\n/**\n * The identity grammar: everything is text.\n *\n * It exists so \"no highlighting\" is a REGISTERED language rather than a missing\n * one. A picker can offer it, a fence can name it, and the editor behaves\n * identically — only the colours are absent. Without it, \"plain\" and \"the\n * language you asked for does not exist\" would be indistinguishable states.\n */\nexport const plain = defineGrammar({\n  name: \"plain\",\n  aliases: [\"text\", \"txt\", \"plaintext\", \"none\"],\n  states: { root: [{ match: /[^]+/, token: \"text\" }] },\n});\n"],"names":["plain","defineGrammar"],"mappings":";AAUO,MAAMA,IAAQC,EAAc;AAAA,EACjC,MAAM;AAAA,EACN,SAAS,CAAC,QAAQ,OAAO,aAAa,MAAM;AAAA,EAC5C,QAAQ,EAAE,MAAM,CAAC,EAAE,OAAO,QAAQ,OAAO,QAAQ,EAAA;AACnD,CAAC;"}

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

@@ -0,0 +1,113 @@
+import { defineGrammar as s } from "../registry.js";
+function t(e) {
+  return e.trim().split(/\s+/).sort((n, a) => a.length - n.length).join("|");
+}
+const o = t(`
+  add all alter analyze and any as asc authorization before begin between by
+  cascade case cast check collate column commit constraint create cross current
+  cursor database declare default delete desc distinct do drop each else end
+  escape except exec execute exists explain fetch filter first for foreign from
+  full function grant group having if ignore in index inner insert intersect
+  into is join key last lateral left like limit lock loop merge natural next no
+  not nulls of offset on only open or order out outer over partition primary
+  procedure range recursive references rename replace restrict return returning
+  revoke right rollback row rows savepoint schema select set show some table
+  temporary then to transaction trigger truncate union unique unlock update
+  usage use using vacuum values view when where while window with within
+`), i = t(`
+  array bigint binary bit blob bool boolean bytea char character clob date
+  datetime decimal double float inet int int2 int4 int8 integer interval json
+  jsonb longtext mediumint money numeric real serial smallint text time
+  timestamp timestamptz tinyint uuid varbinary varchar xml year
+`), l = t(`
+  auto_increment binlog change charset collation columns databases delayed
+  describe engine fields fulltext high_priority keys kill low_priority modify
+  optimize privileges processlist repair spatial straight_join tables unsigned
+  variables warnings zerofill
+`), c = t(`
+  analyse concurrently conflict deferrable ilike immediate initially isnull
+  materialized notnull nowait owned reindex reset returns similar tablespace
+  unlogged variadic verbose
+`);
+function r(e) {
+  const n = e.extra ? `${o}|${e.extra}` : o, a = [
+    { match: /--[^\n]*/, token: "comment" },
+    ...e.mysql ? [{ match: /#[^\n]*/, token: "comment" }] : [],
+    { match: /\/\*[^]*?\*\//, token: "comment" },
+    { match: /\/\*[^]*/, token: "comment" },
+    /* Dollar quoting: the optional tag is captured so `\1` closes with the tag
+       it opened with. With no tag the backreference matches empty and the
+       pattern degenerates to `$$…$$`, which is exactly the other legal form. */
+    ...e.postgres ? [
+      { match: /\$([A-Za-z_]\w*)?\$[^]*?\$\1\$/, token: "string" },
+      { match: /\$([A-Za-z_]\w*)?\$[^]*/, token: "string" }
+    ] : [],
+    { match: /[eEnN]?'/, token: "string", push: "sqString" },
+    ...e.postgres ? [{ match: /"/, token: "property", push: "quotedName" }] : [{ match: /"/, token: "string", push: "dqString" }],
+    ...e.mysql ? [{ match: /`[^`\n]*`?/, token: "property" }] : [],
+    /* Bind parameters, in every shape the three dialects and their drivers use. */
+    { match: /\$\d+|[@:][A-Za-z_]\w*|\?/, token: "variable" },
+    { match: /\b\d+(?:\.\d*)?(?:[eE][+-]?\d+)?\b|\B\.\d+\b/, token: "number" },
+    { match: /\bnull\b/i, token: "null" },
+    { match: /\b(?:true|false)\b/i, token: "boolean" },
+    { match: new RegExp(`\\b(?:${i})\\b`, "i"), token: "type" },
+    { match: new RegExp(`\\b(?:${n})\\b`, "i"), token: "keyword" },
+    { match: /[A-Za-z_][\w$]*(?=\s*\()/, token: "function" },
+    { match: new RegExp("(?<=\\.)[A-Za-z_][\\w$]*"), token: "property" },
+    { match: /[A-Za-z_][\w$]*/, token: "variable" },
+    { match: /\|\||::|<<|>>|<=|>=|<>|!=|->>|->|[-+*/%=<>^~!@#&|]/, token: "operator" },
+    { match: /[(),;.[\]]/, token: "punctuation" }
+  ];
+  return s({
+    name: e.name,
+    aliases: e.aliases,
+    states: {
+      root: a,
+      /* `''` is SQL's own escape; the backslash form is a MySQL extension and
+         costs nothing to accept in the others. */
+      sqString: [
+        { match: /''|\\[^]/, token: "escape" },
+        { match: /'/, token: "string", pop: !0 },
+        { match: /[^'\\\n]+/, token: "string" },
+        { match: /\n/, token: "text", pop: !0 }
+      ],
+      dqString: [
+        { match: /""|\\[^]/, token: "escape" },
+        { match: /"/, token: "string", pop: !0 },
+        { match: /[^"\\\n]+/, token: "string" },
+        { match: /\n/, token: "text", pop: !0 }
+      ],
+      quotedName: [
+        { match: /""/, token: "escape" },
+        { match: /"/, token: "property", pop: !0 },
+        { match: /[^"\n]+/, token: "property" },
+        { match: /\n/, token: "text", pop: !0 }
+      ]
+    }
+  });
+}
+const p = r({
+  name: "sql",
+  aliases: ["sqlite"],
+  mysql: !1,
+  postgres: !1,
+  extra: ""
+}), u = r({
+  name: "mysql",
+  aliases: ["mariadb"],
+  mysql: !0,
+  postgres: !1,
+  extra: l
+}), h = r({
+  name: "postgresql",
+  aliases: ["postgres", "pgsql"],
+  mysql: !1,
+  postgres: !0,
+  extra: c
+});
+export {
+  u as mysql,
+  h as postgresql,
+  p as sql
+};
+//# sourceMappingURL=sql.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sql.js","sources":["../../../../src/lib/syntax/languages/sql.ts"],"sourcesContent":["import { defineGrammar } from \"../registry\";\nimport type { Grammar, Rule } from \"../types\";\n\n/* ============================================================================\n   SQL — one grammar, three dialects.\n\n   THE DIALECTS DIFFER IN FOUR PLACES AND NOWHERE ELSE, so they are four\n   booleans and a keyword string rather than three files. What actually varies:\n   what quotes an IDENTIFIER (MySQL backticks, Postgres double quotes), whether\n   `#` starts a comment (MySQL only), whether `$tag$…$tag$` is a string\n   (Postgres only), and the reserved-word list.\n\n   `\"users\"` MEANS OPPOSITE THINGS IN THE TWO DIALECTS and that is not a detail.\n   In Postgres it is a column name; in MySQL, by default, it is a string\n   literal. Colouring both as strings — which is what a single \"SQL\" grammar has\n   to do — tells a Postgres reader their identifiers are data. The dialect flag\n   is the only way to be right, which is why `postgresql` and `mysql` are\n   registered names rather than aliases of one another.\n\n   KEYWORDS ARE CASE-INSENSITIVE because SQL is, and half the world writes\n   `select` while the other half writes `SELECT`. A case-sensitive keyword list\n   silently highlights only one house style.\n\n   STRINGS END AT A NEWLINE. SQL permits them to continue, but an unclosed quote\n   in an editor would otherwise repaint every query below it; a lone quote must\n   stay a local mistake.\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  add all alter analyze and any as asc authorization before begin between by\n  cascade case cast check collate column commit constraint create cross current\n  cursor database declare default delete desc distinct do drop each else end\n  escape except exec execute exists explain fetch filter first for foreign from\n  full function grant group having if ignore in index inner insert intersect\n  into is join key last lateral left like limit lock loop merge natural next no\n  not nulls of offset on only open or order out outer over partition primary\n  procedure range recursive references rename replace restrict return returning\n  revoke right rollback row rows savepoint schema select set show some table\n  temporary then to transaction trigger truncate union unique unlock update\n  usage use using vacuum values view when where while window with within\n`);\n\nconst TYPES = words(`\n  array bigint binary bit blob bool boolean bytea char character clob date\n  datetime decimal double float inet int int2 int4 int8 integer interval json\n  jsonb longtext mediumint money numeric real serial smallint text time\n  timestamp timestamptz tinyint uuid varbinary varchar xml year\n`);\n\nconst MYSQL_EXTRA = words(`\n  auto_increment binlog change charset collation columns databases delayed\n  describe engine fields fulltext high_priority keys kill low_priority modify\n  optimize privileges processlist repair spatial straight_join tables unsigned\n  variables warnings zerofill\n`);\n\nconst POSTGRES_EXTRA = words(`\n  analyse concurrently conflict deferrable ilike immediate initially isnull\n  materialized notnull nowait owned reindex reset returns similar tablespace\n  unlogged variadic verbose\n`);\n\ninterface Dialect {\n  name: string;\n  aliases?: readonly string[];\n  /** MySQL: `` `col` `` is an identifier and `#` starts a comment. */\n  mysql: boolean;\n  /** Postgres: `\"col\"` is an identifier and `$tag$…$tag$` is a string. */\n  postgres: boolean;\n  extra: string;\n}\n\nfunction sqlGrammar(dialect: Dialect): Grammar {\n  const keywords = dialect.extra ? `${KEYWORDS}|${dialect.extra}` : KEYWORDS;\n\n  const rules: Rule[] = [\n    { match: /--[^\\n]*/, token: \"comment\" },\n    ...(dialect.mysql ? [{ match: /#[^\\n]*/, token: \"comment\" } as Rule] : []),\n    { match: /\\/\\*[^]*?\\*\\//, token: \"comment\" },\n    { match: /\\/\\*[^]*/, token: \"comment\" },\n\n    /* Dollar quoting: the optional tag is captured so `\\1` closes with the tag\n       it opened with. With no tag the backreference matches empty and the\n       pattern degenerates to `$$…$$`, which is exactly the other legal form. */\n    ...(dialect.postgres\n      ? ([\n          { match: /\\$([A-Za-z_]\\w*)?\\$[^]*?\\$\\1\\$/, token: \"string\" },\n          { match: /\\$([A-Za-z_]\\w*)?\\$[^]*/, token: \"string\" },\n        ] as Rule[])\n      : []),\n\n    { match: /[eEnN]?'/, token: \"string\", push: \"sqString\" },\n    ...(dialect.postgres\n      ? [{ match: /\"/, token: \"property\", push: \"quotedName\" } as Rule]\n      : [{ match: /\"/, token: \"string\", push: \"dqString\" } as Rule]),\n    ...(dialect.mysql ? [{ match: /`[^`\\n]*`?/, token: \"property\" } as Rule] : []),\n\n    /* Bind parameters, in every shape the three dialects and their drivers use. */\n    { match: /\\$\\d+|[@:][A-Za-z_]\\w*|\\?/, token: \"variable\" },\n\n    { match: /\\b\\d+(?:\\.\\d*)?(?:[eE][+-]?\\d+)?\\b|\\B\\.\\d+\\b/, token: \"number\" },\n    { match: /\\bnull\\b/i, token: \"null\" },\n    { match: /\\b(?:true|false)\\b/i, token: \"boolean\" },\n    { match: new RegExp(`\\\\b(?:${TYPES})\\\\b`, \"i\"), token: \"type\" },\n    { match: new RegExp(`\\\\b(?:${keywords})\\\\b`, \"i\"), token: \"keyword\" },\n\n    { match: /[A-Za-z_][\\w$]*(?=\\s*\\()/, token: \"function\" },\n    { match: /(?<=\\.)[A-Za-z_][\\w$]*/, token: \"property\" },\n    { match: /[A-Za-z_][\\w$]*/, token: \"variable\" },\n\n    { match: /\\|\\||::|<<|>>|<=|>=|<>|!=|->>|->|[-+*/%=<>^~!@#&|]/, token: \"operator\" },\n    { match: /[(),;.[\\]]/, token: \"punctuation\" },\n  ];\n\n  return defineGrammar({\n    name: dialect.name,\n    aliases: dialect.aliases,\n    states: {\n      root: rules,\n      /* `''` is SQL's own escape; the backslash form is a MySQL extension and\n         costs nothing to accept in the others. */\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      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      quotedName: [\n        { match: /\"\"/, token: \"escape\" },\n        { match: /\"/, token: \"property\", pop: true },\n        { match: /[^\"\\n]+/, token: \"property\" },\n        { match: /\\n/, token: \"text\", pop: true },\n      ],\n    },\n  });\n}\n\nexport const sql = sqlGrammar({\n  name: \"sql\",\n  aliases: [\"sqlite\"],\n  mysql: false,\n  postgres: false,\n  extra: \"\",\n});\n\nexport const mysql = sqlGrammar({\n  name: \"mysql\",\n  aliases: [\"mariadb\"],\n  mysql: true,\n  postgres: false,\n  extra: MYSQL_EXTRA,\n});\n\nexport const postgresql = sqlGrammar({\n  name: \"postgresql\",\n  aliases: [\"postgres\", \"pgsql\"],\n  mysql: false,\n  postgres: true,\n  extra: POSTGRES_EXTRA,\n});\n"],"names":["words","list","a","b","KEYWORDS","TYPES","MYSQL_EXTRA","POSTGRES_EXTRA","sqlGrammar","dialect","keywords","rules","defineGrammar","sql","mysql","postgresql"],"mappings":"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"}

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

@@ -0,0 +1,31 @@
+import { defineGrammar as a } from "../registry.js";
+import { markupStates as m, embedRules as n, attrValue as o } from "./html.js";
+function r(t) {
+  const e = o(t, "lang")?.toLowerCase();
+  return e && e !== "html" ? e : "html";
+}
+const l = a({
+  name: "vue",
+  states: {
+    root: [
+      { match: /<!--[^]*?-->/, token: "comment" },
+      { match: /<!--[^]*/, token: "comment" },
+      {
+        match: /(<template)(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>"'])*)(>)/i,
+        groups: ["tag", "attribute", "tag"],
+        embed: (t) => r(t[2]),
+        until: /^<\/template\s*>/m,
+        untilToken: "tag"
+      },
+      ...n(/^<\/script\s*>/m, /^<\/style\s*>/m),
+      /* Anything else at the top level of an SFC — a custom block, or markup
+         someone left outside the three known ones — still reads as markup. */
+      { match: /<\/?[A-Za-z][\w:.-]*/, token: "tag", push: "tag" }
+    ],
+    ...m()
+  }
+});
+export {
+  l as vue
+};
+//# sourceMappingURL=vue.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vue.js","sources":["../../../../src/lib/syntax/languages/vue.ts"],"sourcesContent":["import { defineGrammar } from \"../registry\";\nimport { attrValue, embedRules, markupStates } from \"./html\";\n\n/* ============================================================================\n   VUE SINGLE FILE COMPONENT — three languages in one file, and the reason the\n   `embed` callback takes the MATCH rather than a fixed name.\n\n   `<script lang=\"ts\">` MUST BECOME TYPESCRIPT, NOT JAVASCRIPT. This is the case\n   the whole dynamic-embed mechanism exists for: the language of the block is\n   written IN the block's own opening tag, so it can only be decided at the\n   moment that tag matches. A grammar that hard-codes `embed: \"javascript\"`\n   gets every typed SFC wrong — `interface`, `satisfies` and type annotations\n   all read as ordinary identifiers, which is precisely the failure the old\n   danx-ui had (it aliased `vue` to `html` and lost script and style entirely).\n\n   THE BLOCK TERMINATORS ARE ANCHORED TO COLUMN ZERO, and that is a deliberate\n   trade with a known cost. `until` locates the closing tag BEFORE the inner\n   grammar runs — which is what stops a `</script>` inside a JS string from\n   ending the block early — but a Vue template legitimately CONTAINS\n   `</template>`, because `<template #footer>` is a slot. An unanchored search\n   would stop at the first nested one and hand the rest of the file to the wrong\n   grammar. `^<\\/template>` only matches the top-level closer, since SFC blocks\n   are written flush left and their contents are indented. The cost: an SFC\n   whose whole `<template>` block is itself indented is not recognised. That is\n   a formatting style essentially nobody uses; a nested slot is in every second\n   component.\n\n   `lang=\"pug\"` RESOLVES TO NOTHING, AND THAT IS FINE. An unregistered embed is\n   scanned as plain text and still terminates correctly at `until` — an\n   unimplemented preprocessor must never break the file containing it.\n   ========================================================================= */\n\n/** The language a `<template>` block's attributes ask for. */\nfunction templateLang(attrs: string): string {\n  const lang = attrValue(attrs, \"lang\")?.toLowerCase();\n  /* Returned even though nothing implements it: `getGrammar` yields undefined,\n     the region degrades to plain text, and the closing tag is still found. */\n  if (lang && lang !== \"html\") return lang;\n  return \"html\";\n}\n\nexport const vue = defineGrammar({\n  name: \"vue\",\n  states: {\n    root: [\n      { match: /<!--[^]*?-->/, token: \"comment\" },\n      { match: /<!--[^]*/, token: \"comment\" },\n\n      {\n        match: /(<template)(?=[\\s/>])((?:\"[^\"]*\"|'[^']*'|[^>\"'])*)(>)/i,\n        groups: [\"tag\", \"attribute\", \"tag\"],\n        embed: (m) => templateLang(m[2]),\n        until: /^<\\/template\\s*>/m,\n        untilToken: \"tag\",\n      },\n\n      ...embedRules(/^<\\/script\\s*>/m, /^<\\/style\\s*>/m),\n\n      /* Anything else at the top level of an SFC — a custom block, or markup\n         someone left outside the three known ones — still reads as markup. */\n      { match: /<\\/?[A-Za-z][\\w:.-]*/, token: \"tag\", push: \"tag\" },\n    ],\n\n    ...markupStates(),\n  },\n});\n"],"names":["templateLang","attrs","lang","attrValue","vue","defineGrammar","m","embedRules","markupStates"],"mappings":";;AAiCA,SAASA,EAAaC,GAAuB;AAC3C,QAAMC,IAAOC,EAAUF,GAAO,MAAM,GAAG,YAAA;AAGvC,SAAIC,KAAQA,MAAS,SAAeA,IAC7B;AACT;AAEO,MAAME,IAAMC,EAAc;AAAA,EAC/B,MAAM;AAAA,EACN,QAAQ;AAAA,IACN,MAAM;AAAA,MACJ,EAAE,OAAO,gBAAgB,OAAO,UAAA;AAAA,MAChC,EAAE,OAAO,YAAY,OAAO,UAAA;AAAA,MAE5B;AAAA,QACE,OAAO;AAAA,QACP,QAAQ,CAAC,OAAO,aAAa,KAAK;AAAA,QAClC,OAAO,CAACC,MAAMN,EAAaM,EAAE,CAAC,CAAC;AAAA,QAC/B,OAAO;AAAA,QACP,YAAY;AAAA,MAAA;AAAA,MAGd,GAAGC,EAAW,mBAAmB,gBAAgB;AAAA;AAAA;AAAA,MAIjD,EAAE,OAAO,wBAAwB,OAAO,OAAO,MAAM,MAAA;AAAA,IAAM;AAAA,IAG7D,GAAGC,EAAA;AAAA,EAAa;AAEpB,CAAC;"}

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

@@ -0,0 +1,55 @@
+import { defineGrammar as t } from "../registry.js";
+const e = t({
+  name: "yaml",
+  aliases: ["yml"],
+  states: {
+    root: [
+      { match: new RegExp("(?<![^\\s])#[^\\n]*"), token: "comment" },
+      /* `---` and `...` only at column zero — inside a value they are content. */
+      { match: /^(?:---|\.\.\.)(?=[ \t]|$)/m, token: "punctuation" },
+      { match: new RegExp("(?<![^\\s])[&*][\\w.-]+"), token: "variable" },
+      { match: new RegExp("(?<![^\\s])!!?[\\w!./-]*"), token: "type" },
+      { match: new RegExp("(?<![^\\s])<<"), token: "operator" },
+      /* Header, then body. Group 3 is the body's indent and is consumed only by
+         the backreference inside its own optional group — see the header note. */
+      {
+        match: /([|>][+-]?\d*)(?=[ \t]*(?:#[^\n]*)?(?:\n|$))([^\n]*(?:\n[ \t]*(?=\n|$))*(?:\n([ \t]+)[^\n]*(?:\n(?:[ \t]*(?=\n|$)|\3[^\n]*))*)?)/,
+        groups: ["operator", "string"]
+      },
+      { match: new RegExp("(?<![^\\s])-(?=[ \\t]|$)"), token: "punctuation" },
+      /* The key. Everything up to a colon that is followed by space or line end
+         — `url: http://x` has a colon that fails that lookahead, which is what
+         stops the scheme from being read as a second key. */
+      {
+        match: new RegExp(`(?<![^\\s{,[])("(?:[^"\\\\\\n]|\\\\.)*"|'(?:[^'\\n]|'')*'|[^\\s#&*!|>%@\`"'[\\]{},][^:\\n]*?)(:)(?=[ \\t]|$)`, "m"),
+        groups: ["property", "punctuation"]
+      },
+      { match: /"/, token: "string", push: "dqString" },
+      { match: /'/, token: "string", push: "sqString" },
+      { match: new RegExp("(?<![^\\s[{,])(?:true|false|yes|no|on|off)(?![\\w-])", "i"), token: "boolean" },
+      { match: new RegExp("(?<![^\\s[{,])(?:null|~)(?![\\w-])", "i"), token: "null" },
+      {
+        match: new RegExp("(?<![^\\s[{,])[-+]?(?:0x[0-9a-f]+|0o[0-7]+|\\d[\\d_]*(?:\\.\\d*)?(?:e[+-]?\\d+)?|\\.\\d+(?:e[+-]?\\d+)?|\\.inf|\\.nan)(?![\\w-])", "i"),
+        token: "number"
+      },
+      { match: /[[\]{},]/, token: "punctuation" }
+    ],
+    dqString: [
+      { match: /\\(?: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 }
+    ],
+    /* YAML's single-quoted escape is a doubled quote, not a backslash. */
+    sqString: [
+      { match: /''/, token: "escape" },
+      { match: /'/, token: "string", pop: !0 },
+      { match: /[^'\n]+/, token: "string" },
+      { match: /\n/, token: "text", pop: !0 }
+    ]
+  }
+});
+export {
+  e as yaml
+};
+//# sourceMappingURL=yaml.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"yaml.js","sources":["../../../../src/lib/syntax/languages/yaml.ts"],"sourcesContent":["import { defineGrammar } from \"../registry\";\n\n/* ============================================================================\n   YAML — the language whose highlighting is load-bearing, because its meaning\n   is invisible. A misplaced space changes the document and nothing on screen\n   says so. Getting the KEY / VALUE split right is the whole job.\n\n   `#` IS ONLY A COMMENT AFTER WHITESPACE. `url: http://x#y` has no comment in\n   it, and neither does `pass: hunter2#1`. The rule uses a negative lookbehind\n   for a non-space character rather than matching `#` outright — the naive\n   version greys out the tail of every URL in the file, which looks like the\n   value is optional and is the single most common YAML-highlighting bug.\n\n   BLOCK SCALARS ARE MATCHED BY THEIR OWN INDENT, VIA A BACKREFERENCE. The body\n   of `|` or `>` runs until a line dedents past the body's first line, and no\n   positional rule can be told what that indent is — so the pattern CAPTURES the\n   first content line's indent and requires every following line to carry it.\n   The backreference stays inside the group that defines it, because a\n   backreference to a group that never participated matches the EMPTY STRING in\n   JavaScript, and an empty `\\3` would swallow the next sibling key.\n\n   QUOTED SCALARS END AT A NEWLINE even though YAML permits them to continue.\n   Half-typed lines are constant in an editor, and a string state that outlived\n   its line would repaint the rest of the document on one keystroke. The cost is\n   a rare multi-line flow scalar; the benefit is that a stray quote is local.\n   ========================================================================= */\n\nexport const yaml = defineGrammar({\n  name: \"yaml\",\n  aliases: [\"yml\"],\n  states: {\n    root: [\n      { match: /(?<![^\\s])#[^\\n]*/, token: \"comment\" },\n\n      /* `---` and `...` only at column zero — inside a value they are content. */\n      { match: /^(?:---|\\.\\.\\.)(?=[ \\t]|$)/m, token: \"punctuation\" },\n\n      { match: /(?<![^\\s])[&*][\\w.-]+/, token: \"variable\" },\n      { match: /(?<![^\\s])!!?[\\w!./-]*/, token: \"type\" },\n      { match: /(?<![^\\s])<</, token: \"operator\" },\n\n      /* Header, then body. Group 3 is the body's indent and is consumed only by\n         the backreference inside its own optional group — see the header note. */\n      {\n        match:\n          /([|>][+-]?\\d*)(?=[ \\t]*(?:#[^\\n]*)?(?:\\n|$))([^\\n]*(?:\\n[ \\t]*(?=\\n|$))*(?:\\n([ \\t]+)[^\\n]*(?:\\n(?:[ \\t]*(?=\\n|$)|\\3[^\\n]*))*)?)/,\n        groups: [\"operator\", \"string\"],\n      },\n\n      { match: /(?<![^\\s])-(?=[ \\t]|$)/, token: \"punctuation\" },\n\n      /* The key. Everything up to a colon that is followed by space or line end\n         — `url: http://x` has a colon that fails that lookahead, which is what\n         stops the scheme from being read as a second key. */\n      {\n        match:\n          /(?<![^\\s{,[])(\"(?:[^\"\\\\\\n]|\\\\.)*\"|'(?:[^'\\n]|'')*'|[^\\s#&*!|>%@`\"'[\\]{},][^:\\n]*?)(:)(?=[ \\t]|$)/m,\n        groups: [\"property\", \"punctuation\"],\n      },\n\n      { match: /\"/, token: \"string\", push: \"dqString\" },\n      { match: /'/, token: \"string\", push: \"sqString\" },\n\n      { match: /(?<![^\\s[{,])(?:true|false|yes|no|on|off)(?![\\w-])/i, token: \"boolean\" },\n      { match: /(?<![^\\s[{,])(?:null|~)(?![\\w-])/i, token: \"null\" },\n      {\n        match:\n          /(?<![^\\s[{,])[-+]?(?:0x[0-9a-f]+|0o[0-7]+|\\d[\\d_]*(?:\\.\\d*)?(?:e[+-]?\\d+)?|\\.\\d+(?:e[+-]?\\d+)?|\\.inf|\\.nan)(?![\\w-])/i,\n        token: \"number\",\n      },\n\n      { match: /[[\\]{},]/, token: \"punctuation\" },\n    ],\n\n    dqString: [\n      { match: /\\\\(?: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    /* YAML's single-quoted escape is a doubled quote, not a backslash. */\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":["yaml","defineGrammar"],"mappings":";AA2BO,MAAMA,IAAOC,EAAc;AAAA,EAChC,MAAM;AAAA,EACN,SAAS,CAAC,KAAK;AAAA,EACf,QAAQ;AAAA,IACN,MAAM;AAAA,MACJ,EAAE,OAAO,WAAA,qBAAA,GAAqB,OAAO,UAAA;AAAA;AAAA,MAGrC,EAAE,OAAO,+BAA+B,OAAO,cAAA;AAAA,MAE/C,EAAE,OAAO,WAAA,yBAAA,GAAyB,OAAO,WAAA;AAAA,MACzC,EAAE,OAAO,WAAA,0BAAA,GAA0B,OAAO,OAAA;AAAA,MAC1C,EAAE,OAAO,WAAA,eAAA,GAAgB,OAAO,WAAA;AAAA;AAAA;AAAA,MAIhC;AAAA,QACE,OACE;AAAA,QACF,QAAQ,CAAC,YAAY,QAAQ;AAAA,MAAA;AAAA,MAG/B,EAAE,OAAO,WAAA,0BAAA,GAA0B,OAAO,cAAA;AAAA;AAAA;AAAA;AAAA,MAK1C;AAAA,QACE,OACE,WAAA,gHAAA,GAAA;AAAA,QACF,QAAQ,CAAC,YAAY,aAAa;AAAA,MAAA;AAAA,MAGpC,EAAE,OAAO,KAAK,OAAO,UAAU,MAAM,WAAA;AAAA,MACrC,EAAE,OAAO,KAAK,OAAO,UAAU,MAAM,WAAA;AAAA,MAErC,EAAE,OAAO,WAAA,wDAAA,GAAA,GAAuD,OAAO,UAAA;AAAA,MACvE,EAAE,OAAO,WAAA,sCAAA,GAAA,GAAqC,OAAO,OAAA;AAAA,MACrD;AAAA,QACE,OACE,WAAA,oIAAA,GAAA;AAAA,QACF,OAAO;AAAA,MAAA;AAAA,MAGT,EAAE,OAAO,YAAY,OAAO,cAAA;AAAA,IAAc;AAAA,IAG5C,UAAU;AAAA,MACR,EAAE,OAAO,6CAA6C,OAAO,SAAA;AAAA,MAC7D,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;AAAA,IAI1C,UAAU;AAAA,MACR,EAAE,OAAO,MAAM,OAAO,SAAA;AAAA,MACtB,EAAE,OAAO,KAAK,OAAO,UAAU,KAAK,GAAA;AAAA,MACpC,EAAE,OAAO,WAAW,OAAO,SAAA;AAAA,MAC3B,EAAE,OAAO,MAAM,OAAO,QAAQ,KAAK,GAAA;AAAA,IAAK;AAAA,EAC1C;AAEJ,CAAC;"}

package/dist/lib/syntax/markdown/grammar.js

@@ -0,0 +1,52 @@
+import { defineGrammar as c } from "../registry.js";
+import { parseDocument as d } from "./parse.js";
+const k = c({
+  name: "markdown",
+  aliases: ["md", "mdown", "gfm"],
+  states: {},
+  tokenize(s, m) {
+    const o = [];
+    return d(s, {
+      span(r, n, t) {
+        n > r && o.push({ start: r, end: n, type: t, lang: "markdown" });
+      },
+      embed(r, n, t) {
+        for (const i of m.sub(r, n, t)) o.push(i);
+      },
+      /* Structure is not the highlighter's business: a token list is flat, and
+         a caret in a textarea needs a colour per character, not a tree. The
+         editor's projector is the consumer that wants these — see ./frames.ts.
+         Spelled out as no-ops rather than left off the interface, so adding a
+         frame somewhere in the parser cannot silently skip a consumer that
+         needed it. */
+      open() {
+      },
+      close() {
+      }
+    }), l(s, o);
+  }
+});
+function l(s, m) {
+  m.sort((n, t) => n.start - t.start || n.end - t.end);
+  const o = [];
+  let e = 0;
+  const r = (n, t, i, f) => {
+    if (t <= n) return;
+    const a = o[o.length - 1];
+    if (a && a.end === n && a.type === i && a.lang === f) {
+      a.end = t;
+      return;
+    }
+    o.push({ start: n, end: t, type: i, lang: f });
+  };
+  for (const n of m) {
+    if (n.end <= e) continue;
+    const t = Math.max(n.start, e);
+    t > e && r(e, t, "text", "markdown"), r(t, n.end, n.type, n.lang), e = n.end;
+  }
+  return e < s.length && r(e, s.length, "text", "markdown"), o;
+}
+export {
+  k as markdown
+};
+//# sourceMappingURL=grammar.js.map

package/dist/lib/syntax/markdown/grammar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.js","sources":["../../../../src/lib/syntax/markdown/grammar.ts"],"sourcesContent":["/* ============================================================================\n   MARKDOWN GRAMMAR — the editor's view of the same parse.\n\n   THE ONE THING THIS FILE IS FOR. `ctx.sub(code, language, offset)` on every\n   fenced block and every front-matter body. That single call is the entire\n   nesting feature for markdown: a ```json fence is tokenized by the JSON\n   grammar, at absolute offsets, and the tokens splice into the markdown stream\n   carrying `lang: \"json\"`. Nothing here knows what JSON is, and nothing in the\n   JSON grammar knows it is inside a document.\n\n   IT DOES NOT PARSE ANYTHING ITSELF. The parser reports every span it consumes\n   through a `Sink` (see ./spans.ts) while it still knows the absolute offset;\n   this file collects those reports and normalises them. A second, independent\n   scan would be a second set of rules to keep in agreement with the first, and\n   the disagreement would show up as a caret that drifts away from its glyph.\n   ========================================================================= */\n\nimport { defineGrammar } from \"../registry\";\nimport type { Token, TokenizeContext, TokenType } from \"../types\";\nimport { parseDocument } from \"./parse\";\nimport type { Sink } from \"./spans\";\n\nexport const markdown = defineGrammar({\n  name: \"markdown\",\n  aliases: [\"md\", \"mdown\", \"gfm\"],\n  states: {},\n\n  tokenize(source: string, ctx: TokenizeContext): Token[] {\n    const collected: Token[] = [];\n\n    const sink: Sink = {\n      span(start, end, type) {\n        if (end > start) collected.push({ start, end, type, lang: \"markdown\" });\n      },\n      embed(code, language, at) {\n        for (const token of ctx.sub(code, language, at)) collected.push(token);\n      },\n      /* Structure is not the highlighter's business: a token list is flat, and\n         a caret in a textarea needs a colour per character, not a tree. The\n         editor's projector is the consumer that wants these — see ./frames.ts.\n         Spelled out as no-ops rather than left off the interface, so adding a\n         frame somewhere in the parser cannot silently skip a consumer that\n         needed it. */\n      open() {},\n      close() {},\n    };\n\n    parseDocument(source, sink);\n    return normalize(source, collected);\n  },\n});\n\n/**\n * Turns the parser's reports into a list `checkCoverage` accepts: ascending,\n * non-overlapping, gap-free, and merged where adjacent tokens share a type.\n *\n * The clamp is a last line of defence, not a licence. A span that starts behind\n * the cursor is a parser bug, and the tests assert the raw emission is already\n * sound on a large document — but the editor overlay must stay aligned with the\n * textarea under it even on the day a bug ships, because a thrown exception\n * there blanks the whole editor and a clipped token merely mis-colours a word.\n */\nfunction normalize(source: string, tokens: Token[]): Token[] {\n  tokens.sort((a, b) => a.start - b.start || a.end - b.end);\n\n  const out: Token[] = [];\n  let cursor = 0;\n\n  const push = (start: number, end: number, type: TokenType, lang: string) => {\n    if (end <= start) return;\n    const last = out[out.length - 1];\n    if (last && last.end === start && last.type === type && last.lang === lang) {\n      last.end = end;\n      return;\n    }\n    out.push({ start, end, type, lang });\n  };\n\n  for (const token of tokens) {\n    if (token.end <= cursor) continue;\n    const start = Math.max(token.start, cursor);\n    /* Whitespace, list indentation, the `\\r` of a CRLF file: everything the\n       parser did not claim is still source and still has to be covered. */\n    if (start > cursor) push(cursor, start, \"text\", \"markdown\");\n    push(start, token.end, token.type, token.lang);\n    cursor = token.end;\n  }\n\n  if (cursor < source.length) push(cursor, source.length, \"text\", \"markdown\");\n  return out;\n}\n"],"names":["markdown","defineGrammar","source","ctx","collected","parseDocument","start","end","type","code","language","at","token","normalize","tokens","a","b","out","cursor","push","lang","last"],"mappings":";;AAsBO,MAAMA,IAAWC,EAAc;AAAA,EACpC,MAAM;AAAA,EACN,SAAS,CAAC,MAAM,SAAS,KAAK;AAAA,EAC9B,QAAQ,CAAA;AAAA,EAER,SAASC,GAAgBC,GAA+B;AACtD,UAAMC,IAAqB,CAAA;AAmB3B,WAAAC,EAAcH,GAjBK;AAAA,MACjB,KAAKI,GAAOC,GAAKC,GAAM;AACrB,QAAID,IAAMD,KAAOF,EAAU,KAAK,EAAE,OAAAE,GAAO,KAAAC,GAAK,MAAAC,GAAM,MAAM,YAAY;AAAA,MACxE;AAAA,MACA,MAAMC,GAAMC,GAAUC,GAAI;AACxB,mBAAWC,KAAST,EAAI,IAAIM,GAAMC,GAAUC,CAAE,EAAG,CAAAP,EAAU,KAAKQ,CAAK;AAAA,MACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAOA,OAAO;AAAA,MAAC;AAAA,MACR,QAAQ;AAAA,MAAC;AAAA,IAAA,CAGe,GACnBC,EAAUX,GAAQE,CAAS;AAAA,EACpC;AACF,CAAC;AAYD,SAASS,EAAUX,GAAgBY,GAA0B;AAC3D,EAAAA,EAAO,KAAK,CAACC,GAAGC,MAAMD,EAAE,QAAQC,EAAE,SAASD,EAAE,MAAMC,EAAE,GAAG;AAExD,QAAMC,IAAe,CAAA;AACrB,MAAIC,IAAS;AAEb,QAAMC,IAAO,CAACb,GAAeC,GAAaC,GAAiBY,MAAiB;AAC1E,QAAIb,KAAOD,EAAO;AAClB,UAAMe,IAAOJ,EAAIA,EAAI,SAAS,CAAC;AAC/B,QAAII,KAAQA,EAAK,QAAQf,KAASe,EAAK,SAASb,KAAQa,EAAK,SAASD,GAAM;AAC1E,MAAAC,EAAK,MAAMd;AACX;AAAA,IACF;AACA,IAAAU,EAAI,KAAK,EAAE,OAAAX,GAAO,KAAAC,GAAK,MAAAC,GAAM,MAAAY,GAAM;AAAA,EACrC;AAEA,aAAWR,KAASE,GAAQ;AAC1B,QAAIF,EAAM,OAAOM,EAAQ;AACzB,UAAMZ,IAAQ,KAAK,IAAIM,EAAM,OAAOM,CAAM;AAG1C,IAAIZ,IAAQY,KAAQC,EAAKD,GAAQZ,GAAO,QAAQ,UAAU,GAC1Da,EAAKb,GAAOM,EAAM,KAAKA,EAAM,MAAMA,EAAM,IAAI,GAC7CM,IAASN,EAAM;AAAA,EACjB;AAEA,SAAIM,IAAShB,EAAO,UAAQiB,EAAKD,GAAQhB,EAAO,QAAQ,QAAQ,UAAU,GACnEe;AACT;"}