@zuilib/text-editor 0.7.2 → 0.8.0

package/dist/index.js

@@ -14,11 +14,11 @@ import { LinkPlugin } from "@lexical/react/LexicalLinkPlugin";
 import { MarkdownShortcutPlugin } from "@lexical/react/LexicalMarkdownShortcutPlugin";
 import { AutoFocusPlugin } from "@lexical/react/LexicalAutoFocusPlugin";
 import { TablePlugin } from "@lexical/react/LexicalTablePlugin";
-import { CHECK_LIST, CODE, TRANSFORMERS as TRANSFORMERS2 } from "@lexical/markdown";
+import { CHECK_LIST, CODE as CODE2, TRANSFORMERS as TRANSFORMERS2 } from "@lexical/markdown";
 import { useLexicalComposerContext as useLexicalComposerContext6 } from "@lexical/react/LexicalComposerContext";
 import { HeadingNode, QuoteNode } from "@lexical/rich-text";
 import { ListItemNode, ListNode as ListNode2 } from "@lexical/list";
-import { CodeHighlightNode, CodeNode } from "@lexical/code";
+import { CodeHighlightNode, CodeNode as CodeNode2 } from "@lexical/code";
 import { AutoLinkNode, LinkNode } from "@lexical/link";
 import { TableCellNode as TableCellNode2, TableNode as TableNode2, TableRowNode as TableRowNode2 } from "@lexical/table";
 
@@ -160,12 +160,1411 @@ function CodeBlockShortcutPlugin() {
 // src/plugins/CodeHighlightPlugin.tsx
 import { useEffect as useEffect3 } from "react";
 import { useLexicalComposerContext as useLexicalComposerContext3 } from "@lexical/react/LexicalComposerContext";
-import { registerCodeHighlighting } from "@lexical/code";
+
+// src/code/registry.ts
+var PLAIN_LANGUAGE = "plain";
+var PLAIN = {
+  name: PLAIN_LANGUAGE,
+  aliases: ["plaintext", "text", "txt"],
+  rules: []
+};
+var grammars = /* @__PURE__ */ new Map();
+function normalize(name) {
+  return name.trim().toLowerCase();
+}
+function registerCodeLanguage(grammar) {
+  for (const name of [grammar.name, ...grammar.aliases ?? []]) {
+    grammars.set(normalize(name), grammar);
+  }
+}
+function hasCodeLanguage(name) {
+  return grammars.has(normalize(name));
+}
+function resolveCodeLanguage(name) {
+  if (!name) return PLAIN;
+  const key = normalize(name);
+  return grammars.get(key) ?? (key.startsWith("diff-") ? grammars.get("diff") : void 0) ?? PLAIN;
+}
+function getCodeLanguages() {
+  return [...new Set([...grammars.values()].map((g) => g.name))].sort();
+}
+registerCodeLanguage(PLAIN);
+
+// src/code/languages/common.ts
+var LINE_COMMENT = String.raw`//[^\n]*`;
+var BLOCK_COMMENT = String.raw`/\*[^]*?(?:\*/|$)`;
+var HASH_COMMENT = String.raw`#[^\n]*`;
+var DOUBLE_QUOTED = String.raw`"(?:[^"\\\n]|\\[^])*"?`;
+var SINGLE_QUOTED = String.raw`'(?:[^'\\\n]|\\[^])*'?`;
+var TRIPLE_DOUBLE_QUOTED = String.raw`"""[^]*?(?:"""|$)`;
+var TRIPLE_SINGLE_QUOTED = String.raw`'''[^]*?(?:'''|$)`;
+var BACKTICK_QUOTED = String.raw`\`(?:[^\`\\]|\\[^])*\`?`;
+var C_NUMBER = String.raw`\b(?:0[xX][\da-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?)[a-zA-Z]*\b`;
+var ANNOTATION = String.raw`@[\w.]+`;
+var MEMBER = String.raw`(?<=\.\s*)[A-Za-z_$][\w$]*\b(?!\s*\()`;
+var C_OPERATOR = String.raw`[-+*/%=!<>&|^~?:]+`;
+var PUNCTUATION = String.raw`[{}()\[\];,.]`;
+
+// src/code/languages/c.ts
+var PREPROCESSOR = String.raw`(?<=^|\n)[ \t]*#[ \t]*\w+[^\n]*`;
+var c = {
+  name: "c",
+  aliases: ["h", "cpp", "c++", "cc", "cxx", "hpp", "hh"],
+  rules: [
+    { type: "comment", match: LINE_COMMENT },
+    { type: "comment", match: BLOCK_COMMENT },
+    { type: "meta", match: PREPROCESSOR },
+    { type: "string", match: DOUBLE_QUOTED },
+    { type: "string", match: SINGLE_QUOTED },
+    { type: "number", match: C_NUMBER },
+    { type: "property", match: MEMBER },
+    { type: "operator", match: String.raw`->|::|` + C_OPERATOR },
+    { type: "punctuation", match: PUNCTUATION }
+  ],
+  keywords: [
+    "auto",
+    "break",
+    "case",
+    "const",
+    "continue",
+    "default",
+    "do",
+    "else",
+    "enum",
+    "extern",
+    "for",
+    "goto",
+    "if",
+    "inline",
+    "register",
+    "restrict",
+    "return",
+    "sizeof",
+    "static",
+    "struct",
+    "switch",
+    "typedef",
+    "union",
+    "volatile",
+    "while",
+    // C++
+    "catch",
+    "class",
+    "const_cast",
+    "constexpr",
+    "consteval",
+    "delete",
+    "dynamic_cast",
+    "explicit",
+    "export",
+    "final",
+    "friend",
+    "mutable",
+    "namespace",
+    "new",
+    "noexcept",
+    "operator",
+    "override",
+    "private",
+    "protected",
+    "public",
+    "reinterpret_cast",
+    "static_cast",
+    "template",
+    "this",
+    "throw",
+    "try",
+    "typename",
+    "using",
+    "virtual"
+  ],
+  types: [
+    "bool",
+    "char",
+    "double",
+    "float",
+    "int",
+    "long",
+    "short",
+    "signed",
+    "unsigned",
+    "void",
+    "wchar_t",
+    "size_t",
+    "ssize_t",
+    "int8_t",
+    "int16_t",
+    "int32_t",
+    "int64_t",
+    "uint8_t",
+    "uint16_t",
+    "uint32_t",
+    "uint64_t"
+  ],
+  constants: ["true", "false", "NULL", "nullptr"],
+  callIsFunction: true,
+  capitalizedIsType: true
+};
+
+// src/code/languages/css.ts
+var css = {
+  name: "css",
+  aliases: ["scss", "less", "postcss"],
+  rules: [
+    { type: "comment", match: BLOCK_COMMENT },
+    { type: "comment", match: LINE_COMMENT },
+    { type: "keyword", match: String.raw`@[\w-]+|!\s*important\b` },
+    { type: "variable", match: String.raw`--[\w-]+|\$[\w-]+` },
+    { type: "string", match: DOUBLE_QUOTED },
+    { type: "string", match: SINGLE_QUOTED },
+    { type: "tag", match: String.raw`(?<=(?:^|[{};]|\*/)\s*)[^{};@\s][^{};]*?(?=\s*\{)` },
+    { type: "property", match: String.raw`(?<=[{;(]\s*)[-\w]+(?=\s*:)` },
+    { type: "constant", match: String.raw`#[\da-fA-F]{3,8}\b` },
+    { type: "function", match: String.raw`[-\w]+(?=\()` },
+    { type: "number", match: String.raw`(?<![\w-])[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?(?:%|[a-zA-Z]+)?` },
+    { type: "punctuation", match: String.raw`[{}()\[\];:,]` },
+    { type: "operator", match: String.raw`[>+~*/=]` }
+  ]
+};
+
+// src/code/languages/diff.ts
+var LINE = String.raw`[^\n]*`;
+var AT = String.raw`(?<=^|\n)`;
+var diff = {
+  name: "diff",
+  aliases: ["patch"],
+  rules: [
+    { type: "comment", match: AT + String.raw`(?:diff |index |--- |\+\+\+ |Index: |={3,}|\*{3} )` + LINE },
+    { type: "meta", match: AT + String.raw`@@` + LINE },
+    { type: "inserted", match: AT + String.raw`\+` + LINE },
+    { type: "deleted", match: AT + "-" + LINE }
+  ]
+};
+
+// src/code/languages/go.ts
+var go = {
+  name: "go",
+  aliases: ["golang"],
+  rules: [
+    { type: "comment", match: LINE_COMMENT },
+    { type: "comment", match: BLOCK_COMMENT },
+    { type: "string", match: String.raw`\`[^\`]*\`?` },
+    { type: "string", match: DOUBLE_QUOTED },
+    { type: "string", match: SINGLE_QUOTED },
+    { type: "number", match: C_NUMBER },
+    { type: "property", match: MEMBER },
+    { type: "operator", match: String.raw`:=|<-|\.\.\.|` + C_OPERATOR },
+    { type: "punctuation", match: PUNCTUATION }
+  ],
+  keywords: [
+    "break",
+    "case",
+    "chan",
+    "const",
+    "continue",
+    "default",
+    "defer",
+    "else",
+    "fallthrough",
+    "for",
+    "func",
+    "go",
+    "goto",
+    "if",
+    "import",
+    "interface",
+    "map",
+    "package",
+    "range",
+    "return",
+    "select",
+    "struct",
+    "switch",
+    "type",
+    "var"
+  ],
+  types: [
+    "any",
+    "bool",
+    "byte",
+    "comparable",
+    "complex64",
+    "complex128",
+    "error",
+    "float32",
+    "float64",
+    "int",
+    "int8",
+    "int16",
+    "int32",
+    "int64",
+    "rune",
+    "string",
+    "uint",
+    "uint8",
+    "uint16",
+    "uint32",
+    "uint64",
+    "uintptr"
+  ],
+  builtins: [
+    "append",
+    "cap",
+    "clear",
+    "close",
+    "complex",
+    "copy",
+    "delete",
+    "imag",
+    "len",
+    "make",
+    "max",
+    "min",
+    "new",
+    "panic",
+    "print",
+    "println",
+    "real",
+    "recover"
+  ],
+  constants: ["true", "false", "nil", "iota"],
+  callIsFunction: true,
+  // Exported names are Capitalized in Go; coloring them all as types is noise
+  capitalizedIsType: false
+};
+
+// src/code/languages/java.ts
+var java = {
+  name: "java",
+  rules: [
+    { type: "comment", match: LINE_COMMENT },
+    { type: "comment", match: BLOCK_COMMENT },
+    { type: "string", match: TRIPLE_DOUBLE_QUOTED },
+    { type: "string", match: DOUBLE_QUOTED },
+    { type: "string", match: SINGLE_QUOTED },
+    { type: "meta", match: ANNOTATION },
+    { type: "number", match: C_NUMBER },
+    { type: "property", match: MEMBER },
+    { type: "operator", match: String.raw`->|::|` + C_OPERATOR },
+    { type: "punctuation", match: PUNCTUATION }
+  ],
+  keywords: [
+    "abstract",
+    "assert",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "default",
+    "do",
+    "else",
+    "enum",
+    "extends",
+    "final",
+    "finally",
+    "for",
+    "goto",
+    "if",
+    "implements",
+    "import",
+    "instanceof",
+    "interface",
+    "native",
+    "new",
+    "package",
+    "permits",
+    "private",
+    "protected",
+    "public",
+    "record",
+    "return",
+    "sealed",
+    "static",
+    "strictfp",
+    "super",
+    "switch",
+    "synchronized",
+    "this",
+    "throw",
+    "throws",
+    "transient",
+    "try",
+    "var",
+    "volatile",
+    "while",
+    "yield"
+  ],
+  types: ["boolean", "byte", "char", "double", "float", "int", "long", "short", "void"],
+  constants: ["true", "false", "null"],
+  callIsFunction: true,
+  capitalizedIsType: true
+};
+
+// src/code/languages/javascript.ts
+var REGEX = String.raw`(?<=(?:^|[=(,:;!&|?{}\[+\-*%<>~^]|\breturn|\btypeof|\bcase|\bof|\bin)\s*)/(?![/*])(?:[^/\\\n\[]|\\[^]|\[(?:[^\]\\\n]|\\[^])*\])+/[dgimsuyv]*`;
+var JSX_TAG = String.raw`(?<=<\/?)[A-Za-z][\w.:-]*`;
+var javascript = {
+  name: "javascript",
+  aliases: ["js", "jsx", "mjs", "cjs", "typescript", "ts", "tsx", "mts", "cts"],
+  rules: [
+    { type: "comment", match: LINE_COMMENT },
+    { type: "comment", match: BLOCK_COMMENT },
+    { type: "string", match: BACKTICK_QUOTED },
+    { type: "string", match: DOUBLE_QUOTED },
+    { type: "string", match: SINGLE_QUOTED },
+    { type: "regex", match: REGEX },
+    { type: "meta", match: ANNOTATION },
+    { type: "number", match: C_NUMBER },
+    { type: "property", match: MEMBER },
+    { type: "tag", match: JSX_TAG },
+    { type: "operator", match: String.raw`=>|\.\.\.|` + C_OPERATOR },
+    { type: "punctuation", match: PUNCTUATION }
+  ],
+  keywords: [
+    "as",
+    "async",
+    "await",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "finally",
+    "for",
+    "from",
+    "function",
+    "get",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "instanceof",
+    "interface",
+    "let",
+    "new",
+    "of",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "set",
+    "static",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+    // TypeScript
+    "abstract",
+    "asserts",
+    "declare",
+    "infer",
+    "is",
+    "keyof",
+    "module",
+    "namespace",
+    "override",
+    "readonly",
+    "satisfies",
+    "type",
+    "unique"
+  ],
+  types: [
+    "any",
+    "bigint",
+    "boolean",
+    "never",
+    "null",
+    "number",
+    "object",
+    "string",
+    "symbol",
+    "undefined",
+    "unknown",
+    "void"
+  ],
+  builtins: [
+    "Array",
+    "BigInt",
+    "Boolean",
+    "Date",
+    "Error",
+    "JSON",
+    "Map",
+    "Math",
+    "Number",
+    "Object",
+    "Promise",
+    "Proxy",
+    "Reflect",
+    "RegExp",
+    "Set",
+    "String",
+    "Symbol",
+    "WeakMap",
+    "WeakSet",
+    "console",
+    "document",
+    "globalThis",
+    "window",
+    "parseFloat",
+    "parseInt",
+    "setTimeout",
+    "setInterval",
+    "clearTimeout",
+    "clearInterval",
+    "fetch",
+    "require",
+    "process"
+  ],
+  constants: ["true", "false", "null", "undefined", "NaN", "Infinity"],
+  callIsFunction: true,
+  capitalizedIsType: true
+};
+
+// src/code/languages/json.ts
+var json = {
+  name: "json",
+  aliases: ["jsonc", "json5"],
+  rules: [
+    { type: "comment", match: String.raw`//[^\n]*|/\*[^]*?(?:\*/|$)` },
+    { type: "property", match: String.raw`"(?:[^"\\\n]|\\[^])*"(?=\s*:)` },
+    { type: "string", match: String.raw`"(?:[^"\\\n]|\\[^])*"?` },
+    { type: "number", match: String.raw`-?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b` },
+    { type: "punctuation", match: String.raw`[{}\[\]:,]` }
+  ],
+  constants: ["true", "false", "null"]
+};
+
+// src/code/languages/kotlin.ts
+var kotlin = {
+  name: "kotlin",
+  aliases: ["kt", "kts"],
+  rules: [
+    { type: "comment", match: LINE_COMMENT },
+    { type: "comment", match: BLOCK_COMMENT },
+    { type: "string", match: TRIPLE_DOUBLE_QUOTED },
+    { type: "string", match: DOUBLE_QUOTED },
+    { type: "string", match: SINGLE_QUOTED },
+    { type: "meta", match: ANNOTATION },
+    { type: "number", match: C_NUMBER },
+    { type: "property", match: MEMBER },
+    { type: "operator", match: String.raw`->|\.\.|\?:|!!|` + C_OPERATOR },
+    { type: "punctuation", match: PUNCTUATION }
+  ],
+  keywords: [
+    "abstract",
+    "actual",
+    "annotation",
+    "as",
+    "break",
+    "by",
+    "catch",
+    "class",
+    "companion",
+    "const",
+    "constructor",
+    "continue",
+    "crossinline",
+    "data",
+    "do",
+    "else",
+    "enum",
+    "expect",
+    "external",
+    "final",
+    "finally",
+    "for",
+    "fun",
+    "get",
+    "if",
+    "import",
+    "in",
+    "infix",
+    "init",
+    "inline",
+    "inner",
+    "interface",
+    "internal",
+    "is",
+    "lateinit",
+    "noinline",
+    "object",
+    "open",
+    "operator",
+    "out",
+    "override",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "reified",
+    "return",
+    "sealed",
+    "set",
+    "super",
+    "suspend",
+    "tailrec",
+    "this",
+    "throw",
+    "try",
+    "typealias",
+    "val",
+    "value",
+    "var",
+    "vararg",
+    "when",
+    "where",
+    "while"
+  ],
+  builtins: [
+    "it",
+    "println",
+    "print",
+    "listOf",
+    "mutableListOf",
+    "mapOf",
+    "mutableMapOf",
+    "setOf",
+    "mutableSetOf",
+    "arrayOf",
+    "emptyList",
+    "emptyMap",
+    "lazy",
+    "require",
+    "check",
+    "error",
+    "TODO",
+    "apply",
+    "also",
+    "let",
+    "run",
+    "with",
+    "takeIf",
+    "takeUnless",
+    "repeat"
+  ],
+  constants: ["true", "false", "null"],
+  callIsFunction: true,
+  capitalizedIsType: true
+};
+
+// src/code/languages/markdown.ts
+var AT2 = String.raw`(?<=^|\n)`;
+var markdown = {
+  name: "markdown",
+  aliases: ["md", "mdx"],
+  rules: [
+    { type: "comment", match: String.raw`<!--[^]*?(?:-->|$)` },
+    { type: "string", match: String.raw`\`\`\`[^]*?(?:\`\`\`|$)|\`[^\`\n]*\`` },
+    { type: "keyword", match: AT2 + String.raw`#{1,6}[ \t][^\n]*` },
+    { type: "meta", match: AT2 + String.raw`(?:>|[-*+]|\d+\.)(?=\s)` },
+    { type: "tag", match: String.raw`\*\*[^*\n]+\*\*|__[^_\n]+__` },
+    { type: "variable", match: String.raw`(?<![*\w])\*[^*\n]+\*(?!\w)|(?<![_\w])_[^_\n]+_(?!\w)` },
+    { type: "function", match: String.raw`!?\[[^\]\n]*\](?=\()` },
+    { type: "string", match: String.raw`(?<=\]\()[^)\n]*(?=\))` },
+    { type: "punctuation", match: AT2 + String.raw`(?:---+|\*\*\*+|___+)(?=\n|$)` }
+  ]
+};
+
+// src/code/languages/markup.ts
+var markup = {
+  name: "html",
+  aliases: ["xml", "svg", "xhtml", "vue", "markup", "rss", "atom"],
+  rules: [
+    { type: "comment", match: String.raw`<!--[^]*?(?:-->|$)` },
+    { type: "string", match: String.raw`<!\[CDATA\[[^]*?(?:\]\]>|$)` },
+    { type: "meta", match: String.raw`<![\w]+[^>]*>?|<\?[^]*?(?:\?>|$)` },
+    { type: "tag", match: String.raw`(?<=<\/?)[A-Za-z][\w:.-]*` },
+    { type: "string", match: String.raw`(?<=<[^>]*=\s*)(?:"[^"]*"|'[^']*')` },
+    { type: "attr", match: String.raw`(?<=<[^>]*\s)[^\s"'<>/=]+` },
+    { type: "punctuation", match: String.raw`<\/?|\/?>|(?<=<[^>]*)=` },
+    { type: "constant", match: String.raw`&#?\w+;` }
+  ]
+};
+
+// src/code/languages/python.ts
+var PREFIX = String.raw`(?:\b[rRbBuUfF]{1,2})?`;
+var NUMBER = String.raw`\b(?:0[xX][\da-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?[jJ]?)\b`;
+var python = {
+  name: "python",
+  aliases: ["py", "py3"],
+  rules: [
+    { type: "comment", match: HASH_COMMENT },
+    { type: "string", match: PREFIX + String.raw`"""[^]*?(?:"""|$)` },
+    { type: "string", match: PREFIX + String.raw`'''[^]*?(?:'''|$)` },
+    { type: "string", match: PREFIX + String.raw`"(?:[^"\\\n]|\\[^])*"?` },
+    { type: "string", match: PREFIX + String.raw`'(?:[^'\\\n]|\\[^])*'?` },
+    { type: "meta", match: String.raw`@[\w.]+` },
+    { type: "number", match: NUMBER },
+    { type: "property", match: MEMBER },
+    { type: "operator", match: String.raw`->|:=|\*\*|//|[-+*/%=!<>&|^~@]+` },
+    { type: "punctuation", match: PUNCTUATION + "|:" }
+  ],
+  keywords: [
+    "and",
+    "as",
+    "assert",
+    "async",
+    "await",
+    "break",
+    "case",
+    "class",
+    "continue",
+    "def",
+    "del",
+    "elif",
+    "else",
+    "except",
+    "finally",
+    "for",
+    "from",
+    "global",
+    "if",
+    "import",
+    "in",
+    "is",
+    "lambda",
+    "match",
+    "nonlocal",
+    "not",
+    "or",
+    "pass",
+    "raise",
+    "return",
+    "try",
+    "while",
+    "with",
+    "yield"
+  ],
+  builtins: [
+    "self",
+    "cls",
+    "print",
+    "len",
+    "range",
+    "enumerate",
+    "zip",
+    "map",
+    "filter",
+    "sorted",
+    "reversed",
+    "open",
+    "input",
+    "abs",
+    "min",
+    "max",
+    "sum",
+    "any",
+    "all",
+    "iter",
+    "next",
+    "isinstance",
+    "issubclass",
+    "getattr",
+    "setattr",
+    "hasattr",
+    "super",
+    "type",
+    "id",
+    "hash",
+    "repr",
+    "format",
+    "vars",
+    "dir"
+  ],
+  types: ["int", "float", "str", "bytes", "bool", "list", "dict", "set", "tuple", "object", "complex", "frozenset"],
+  constants: ["True", "False", "None", "Ellipsis", "NotImplemented"],
+  callIsFunction: true,
+  capitalizedIsType: true
+};
+
+// src/code/languages/rust.ts
+var NUMBER2 = String.raw`\b(?:0[xX][\da-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?)(?:[iuf](?:8|16|32|64|128|size))?\b`;
+var rust = {
+  name: "rust",
+  aliases: ["rs"],
+  rules: [
+    { type: "comment", match: LINE_COMMENT },
+    { type: "comment", match: BLOCK_COMMENT },
+    { type: "meta", match: String.raw`#!?\[[^\]\n]*\]` },
+    { type: "string", match: String.raw`b?r#*"[^]*?(?:"#*|$)` },
+    { type: "string", match: String.raw`b?"(?:[^"\\]|\\[^])*"?` },
+    { type: "string", match: String.raw`b?'(?:[^'\\\n]|\\[^])'` },
+    { type: "variable", match: String.raw`'[a-z_]\w*\b(?!')` },
+    { type: "function", match: String.raw`\b[a-z_]\w*!(?=[\s(\[{])` },
+    { type: "number", match: NUMBER2 },
+    { type: "property", match: MEMBER },
+    { type: "operator", match: String.raw`->|=>|::|\.\.=?|` + C_OPERATOR },
+    { type: "punctuation", match: PUNCTUATION + "|#" }
+  ],
+  keywords: [
+    "as",
+    "async",
+    "await",
+    "break",
+    "const",
+    "continue",
+    "crate",
+    "dyn",
+    "else",
+    "enum",
+    "extern",
+    "fn",
+    "for",
+    "if",
+    "impl",
+    "in",
+    "let",
+    "loop",
+    "match",
+    "mod",
+    "move",
+    "mut",
+    "pub",
+    "ref",
+    "return",
+    "self",
+    "Self",
+    "static",
+    "struct",
+    "super",
+    "trait",
+    "type",
+    "union",
+    "unsafe",
+    "use",
+    "where",
+    "while"
+  ],
+  types: [
+    "bool",
+    "char",
+    "f32",
+    "f64",
+    "i8",
+    "i16",
+    "i32",
+    "i64",
+    "i128",
+    "isize",
+    "str",
+    "u8",
+    "u16",
+    "u32",
+    "u64",
+    "u128",
+    "usize",
+    "String",
+    "Vec",
+    "Option",
+    "Result",
+    "Box",
+    "Rc",
+    "Arc",
+    "HashMap",
+    "HashSet"
+  ],
+  constants: ["true", "false", "None", "Some", "Ok", "Err"],
+  callIsFunction: true,
+  capitalizedIsType: true
+};
+
+// src/code/languages/shell.ts
+var shell = {
+  name: "shell",
+  aliases: ["sh", "bash", "zsh", "console", "shellsession"],
+  rules: [
+    { type: "variable", match: String.raw`\$\{[^}\n]*\}|\$\w+|\$[@#?*!$-]` },
+    { type: "comment", match: String.raw`(?<=^|\s)#[^\n]*` },
+    { type: "string", match: String.raw`"(?:[^"\\\n]|\\[^])*"?` },
+    { type: "string", match: String.raw`'[^'\n]*'?` },
+    { type: "punctuation", match: String.raw`(?<=^|\n)[$#](?=\s)` },
+    { type: "attr", match: String.raw`(?<=\s)--?[A-Za-z][\w-]*` },
+    { type: "operator", match: String.raw`\|\|?|&&?|;;?|[<>]+|=` },
+    { type: "punctuation", match: String.raw`[(){}\[\]]` }
+  ],
+  identifier: String.raw`[A-Za-z_][\w.-]*`,
+  keywords: [
+    "if",
+    "then",
+    "else",
+    "elif",
+    "fi",
+    "for",
+    "while",
+    "until",
+    "do",
+    "done",
+    "case",
+    "esac",
+    "in",
+    "function",
+    "select",
+    "time",
+    "return",
+    "exit",
+    "local",
+    "export",
+    "readonly",
+    "declare",
+    "set",
+    "unset",
+    "shift",
+    "source",
+    "alias",
+    "break",
+    "continue"
+  ],
+  builtins: [
+    "echo",
+    "cd",
+    "ls",
+    "pwd",
+    "cat",
+    "grep",
+    "sed",
+    "awk",
+    "mkdir",
+    "rm",
+    "cp",
+    "mv",
+    "chmod",
+    "chown",
+    "curl",
+    "wget",
+    "git",
+    "npm",
+    "pnpm",
+    "yarn",
+    "npx",
+    "node",
+    "python",
+    "python3",
+    "pip",
+    "docker",
+    "kubectl",
+    "sudo",
+    "test",
+    "printf",
+    "read",
+    "eval",
+    "exec",
+    "trap",
+    "wait",
+    "kill",
+    "ps",
+    "tar",
+    "zip",
+    "unzip",
+    "touch",
+    "find",
+    "xargs",
+    "sort",
+    "uniq",
+    "head",
+    "tail",
+    "wc",
+    "tee",
+    "which",
+    "env",
+    "ssh",
+    "scp",
+    "make",
+    "cargo",
+    "go",
+    "brew",
+    "apt",
+    "apt-get",
+    "gradle",
+    "mvn",
+    "java",
+    "jq",
+    "true",
+    "false"
+  ]
+};
+
+// src/code/languages/sql.ts
+var sql = {
+  name: "sql",
+  aliases: ["mysql", "postgres", "postgresql", "pgsql", "plsql", "sqlite", "soql"],
+  caseInsensitive: true,
+  rules: [
+    { type: "comment", match: String.raw`--[^\n]*` },
+    { type: "comment", match: BLOCK_COMMENT },
+    { type: "string", match: String.raw`'(?:[^'\n]|'')*'?` },
+    { type: "variable", match: String.raw`[@:]\w+|\$\d+` },
+    { type: "number", match: String.raw`\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b` },
+    { type: "operator", match: String.raw`\|\||::|[-+*/%=<>!]+` },
+    { type: "punctuation", match: String.raw`[(),;.]` }
+  ],
+  keywords: [
+    "add",
+    "all",
+    "alter",
+    "and",
+    "as",
+    "asc",
+    "begin",
+    "between",
+    "by",
+    "cascade",
+    "case",
+    "check",
+    "column",
+    "commit",
+    "constraint",
+    "create",
+    "cross",
+    "default",
+    "delete",
+    "desc",
+    "distinct",
+    "drop",
+    "else",
+    "end",
+    "except",
+    "exists",
+    "foreign",
+    "from",
+    "full",
+    "group",
+    "having",
+    "if",
+    "in",
+    "index",
+    "inner",
+    "insert",
+    "intersect",
+    "into",
+    "is",
+    "join",
+    "key",
+    "left",
+    "like",
+    "limit",
+    "not",
+    "null",
+    "offset",
+    "on",
+    "or",
+    "order",
+    "outer",
+    "primary",
+    "references",
+    "returning",
+    "right",
+    "rollback",
+    "select",
+    "set",
+    "table",
+    "then",
+    "top",
+    "transaction",
+    "truncate",
+    "union",
+    "unique",
+    "update",
+    "using",
+    "values",
+    "view",
+    "when",
+    "where",
+    "with",
+    "recursive",
+    "ilike",
+    "over",
+    "partition",
+    "window",
+    "rows",
+    "range",
+    "fetch",
+    "first",
+    "next",
+    "only",
+    "nulls",
+    "last",
+    "explain",
+    "analyze",
+    "grant",
+    "revoke",
+    "schema",
+    "database",
+    "trigger",
+    "procedure",
+    "function",
+    "returns",
+    "declare",
+    "cursor",
+    "loop",
+    "while",
+    "for",
+    "exec",
+    "execute",
+    "merge",
+    "matched",
+    "replace",
+    "ignore",
+    "conflict",
+    "do",
+    "nothing",
+    "nowait",
+    "lock",
+    "share",
+    "lateral",
+    "natural",
+    "any",
+    "some",
+    "escape"
+  ],
+  types: [
+    "int",
+    "integer",
+    "bigint",
+    "smallint",
+    "tinyint",
+    "varchar",
+    "char",
+    "text",
+    "boolean",
+    "bool",
+    "date",
+    "timestamp",
+    "timestamptz",
+    "time",
+    "interval",
+    "decimal",
+    "numeric",
+    "float",
+    "real",
+    "double",
+    "serial",
+    "bigserial",
+    "uuid",
+    "json",
+    "jsonb",
+    "bytea",
+    "blob",
+    "array",
+    "money",
+    "precision",
+    "varying"
+  ],
+  builtins: [
+    "count",
+    "sum",
+    "avg",
+    "min",
+    "max",
+    "coalesce",
+    "now",
+    "cast",
+    "concat",
+    "lower",
+    "upper",
+    "length",
+    "substring",
+    "round",
+    "trim",
+    "nullif",
+    "greatest",
+    "least",
+    "array_agg",
+    "string_agg",
+    "json_agg",
+    "row_number",
+    "rank",
+    "dense_rank",
+    "date_trunc",
+    "extract",
+    "current_date",
+    "current_timestamp",
+    "current_user",
+    "exists",
+    "abs",
+    "ceil",
+    "floor",
+    "random",
+    "generate_series"
+  ],
+  constants: ["true", "false", "null", "unknown"],
+  callIsFunction: true
+};
+
+// src/code/languages/yaml.ts
+var LINE_START = String.raw`(?<=^|\n)`;
+var KEY = String.raw`(?<=^|\n|\s|-\s)(?:"(?:[^"\\\n]|\\[^])*"|'(?:[^'\n]|'')*'|[^\s"'#\-\[\]{},:!&*?|>][^:#\n]*?)(?=:(?:\s|$))`;
+var yaml = {
+  name: "yaml",
+  aliases: ["yml"],
+  rules: [
+    { type: "comment", match: String.raw`(?<=^|\s)#[^\n]*` },
+    { type: "meta", match: LINE_START + String.raw`(?:---|\.\.\.)(?=\s|$)` },
+    { type: "property", match: KEY },
+    { type: "variable", match: String.raw`[&*][\w-]+` },
+    { type: "meta", match: String.raw`![\w!/:-]*` },
+    { type: "string", match: String.raw`"(?:[^"\\\n]|\\[^])*"?` },
+    { type: "string", match: String.raw`'(?:[^'\n]|'')*'?` },
+    { type: "punctuation", match: String.raw`(?<=:\s*)[|>][-+]?\d*(?=[ \t]*(?:\n|$|#))` },
+    { type: "punctuation", match: String.raw`(?<=^|\n|\s)-(?=\s)|[\[\]{},:]` },
+    { type: "constant", match: String.raw`(?<=:\s)~(?=\s|$)` },
+    {
+      type: "number",
+      match: String.raw`(?<![\w.-])[-+]?(?:0x[\da-fA-F]+|\d[\d_]*(?:\.\d*)?(?:[eE][+-]?\d+)?|\.inf|\.nan)(?![\w.-])`
+    }
+  ],
+  constants: [
+    "true",
+    "false",
+    "null",
+    "yes",
+    "no",
+    "on",
+    "off",
+    "True",
+    "False",
+    "Null",
+    "Yes",
+    "No",
+    "On",
+    "Off",
+    "TRUE",
+    "FALSE",
+    "NULL",
+    "YES",
+    "NO",
+    "ON",
+    "OFF"
+  ]
+};
+
+// src/code/languages/index.ts
+var BUILTIN_CODE_LANGUAGES = [
+  javascript,
+  kotlin,
+  java,
+  c,
+  python,
+  go,
+  rust,
+  json,
+  yaml,
+  shell,
+  sql,
+  css,
+  markup,
+  diff,
+  markdown
+];
+for (const grammar of BUILTIN_CODE_LANGUAGES) registerCodeLanguage(grammar);
+
+// src/code/lexer.ts
+var DEFAULT_IDENTIFIER = String.raw`[A-Za-z_$][\w$]*`;
+var WHITESPACE = String.raw`\s+`;
+var SCREAMING_CASE = /^[A-Z][A-Z\d_]+$/;
+var CAPITALIZED = /^[A-Z]/;
+var compiled = /* @__PURE__ */ new WeakMap();
+function countGroups(source) {
+  return new RegExp(`${source}|`).exec("").length - 1;
+}
+function compile(grammar) {
+  const cached = compiled.get(grammar);
+  if (cached) return cached;
+  const rules = [...grammar.rules, "whitespace", "identifier"];
+  const sources = rules.map((rule) => {
+    if (rule === "whitespace") return WHITESPACE;
+    if (rule === "identifier") return grammar.identifier ?? DEFAULT_IDENTIFIER;
+    return rule.match;
+  });
+  const groupStarts = [];
+  let group = 1;
+  for (const source of sources) {
+    groupStarts.push(group);
+    group += 1 + countGroups(source);
+  }
+  const regex = new RegExp(
+    sources.map((source) => `(${source})`).join("|"),
+    grammar.caseInsensitive ? "yi" : "y"
+  );
+  const words = /* @__PURE__ */ new Map();
+  const addWords = (list, type) => {
+    for (const word of list ?? []) {
+      words.set(grammar.caseInsensitive ? word.toLowerCase() : word, type);
+    }
+  };
+  addWords(grammar.builtins, "builtin");
+  addWords(grammar.types, "type");
+  addWords(grammar.constants, "constant");
+  addWords(grammar.keywords, "keyword");
+  const result = { regex, groupStarts, rules, words };
+  compiled.set(grammar, result);
+  return result;
+}
+function isCallee(code, end) {
+  let i = end;
+  while (code[i] === " " || code[i] === "	") i++;
+  return code[i] === "(";
+}
+function classifyIdentifier(word, grammar, words, code, end) {
+  const known = words.get(grammar.caseInsensitive ? word.toLowerCase() : word);
+  if (known) return known;
+  if (grammar.capitalizedIsType) {
+    if (SCREAMING_CASE.test(word)) return "constant";
+    if (CAPITALIZED.test(word)) return "type";
+  }
+  if (grammar.callIsFunction && isCallee(code, end)) return "function";
+  return "text";
+}
+function matchedRule(match, compiled2) {
+  const { groupStarts, rules } = compiled2;
+  for (let i = 0; i < groupStarts.length; i++) {
+    if (match[groupStarts[i]] !== void 0) return rules[i];
+  }
+  throw new Error("zui code lexer: no alternative matched");
+}
+function tokenizeCode(code, grammar) {
+  const c2 = compile(grammar);
+  const tokens = [];
+  const push = (type, text) => {
+    const last = tokens[tokens.length - 1];
+    if (last && last.type === type) {
+      tokens[tokens.length - 1] = { type, text: last.text + text };
+    } else {
+      tokens.push({ type, text });
+    }
+  };
+  let pos = 0;
+  let textStart = 0;
+  const flushText = (end) => {
+    if (end > textStart) push("text", code.slice(textStart, end));
+  };
+  while (pos < code.length) {
+    c2.regex.lastIndex = pos;
+    const match = c2.regex.exec(code);
+    if (match === null || match[0].length === 0) {
+      pos += 1;
+      continue;
+    }
+    const text = match[0];
+    const end = pos + text.length;
+    const rule = matchedRule(match, c2);
+    let type;
+    if (rule === "whitespace") type = "text";
+    else if (rule === "identifier") type = classifyIdentifier(text, grammar, c2.words, code, end);
+    else type = rule.type;
+    if (type !== "text") {
+      flushText(pos);
+      push(type, text);
+      textStart = end;
+    }
+    pos = end;
+  }
+  flushText(code.length);
+  return tokens;
+}
+
+// src/code/lexicalTokenizer.ts
+import {
+  $createLineBreakNode,
+  $createTabNode,
+  $nodesOfType
+} from "lexical";
+import { $createCodeHighlightNode, CodeNode, registerCodeHighlighting } from "@lexical/code";
+import { mergeRegister } from "@lexical/utils";
+var MAX_HIGHLIGHT_LENGTH = 2e5;
+function grammarFor(code, language) {
+  return code.length > MAX_HIGHLIGHT_LENGTH ? PLAIN : resolveCodeLanguage(language);
+}
+var codeTokenizer = {
+  defaultLanguage: PLAIN_LANGUAGE,
+  tokenize(code, language) {
+    return tokenizeCode(code, grammarFor(code, language)).map(
+      (token) => token.type === "text" ? token.text : { type: token.type, alias: "", content: token.text }
+    );
+  },
+  $tokenize(codeNode, language) {
+    const code = codeNode.getTextContent();
+    const nodes = [];
+    for (const { type, text } of tokenizeCode(code, grammarFor(code, language))) {
+      const highlightType = type === "text" ? void 0 : type;
+      for (const part of text.split(/(\n|\t)/)) {
+        if (part === "\n") nodes.push($createLineBreakNode());
+        else if (part === "	") nodes.push($createTabNode());
+        else if (part.length > 0) nodes.push($createCodeHighlightNode(part, highlightType));
+      }
+    }
+    return nodes;
+  }
+};
+function openLanguageGate(language) {
+  const prism = globalThis.Prism;
+  const table = prism?.languages;
+  if (!table || Object.prototype.hasOwnProperty.call(table, language)) return false;
+  table[language] = {};
+  return true;
+}
+function registerCodeBlockHighlighting(editor) {
+  const unregister = mergeRegister(
+    editor.registerNodeTransform(CodeNode, (node) => {
+      const language = node.getLanguage();
+      if (language && openLanguageGate(language)) node.markDirty();
+    }),
+    registerCodeHighlighting(editor, codeTokenizer)
+  );
+  editor.update(
+    () => {
+      for (const node of $nodesOfType(CodeNode)) node.markDirty();
+    },
+    { tag: "history-merge" }
+  );
+  return unregister;
+}
+
+// src/code/types.ts
+var CODE_TOKEN_TYPES = [
+  "comment",
+  "string",
+  "number",
+  "keyword",
+  "builtin",
+  "type",
+  "function",
+  "property",
+  "variable",
+  "constant",
+  "operator",
+  "punctuation",
+  "tag",
+  "attr",
+  "regex",
+  "meta",
+  "inserted",
+  "deleted"
+];
+
+// src/plugins/CodeHighlightPlugin.tsx
 function CodeHighlightPlugin() {
   const [editor] = useLexicalComposerContext3();
-  useEffect3(() => {
-    return registerCodeHighlighting(editor);
-  }, [editor]);
+  useEffect3(() => registerCodeBlockHighlighting(editor), [editor]);
   return null;
 }
 
@@ -199,8 +1598,8 @@ function MarkdownSyncPlugin({
         if (dirtyElements.size === 0 && dirtyLeaves.size === 0) return;
         if (tags.has("initial-load")) return;
         editorState.read(() => {
-          const markdown = $convertToMarkdownString(transformers);
-          onChangeRef.current?.(markdown);
+          const markdown2 = $convertToMarkdownString(transformers);
+          onChangeRef.current?.(markdown2);
         });
       }
     );
@@ -211,7 +1610,7 @@ function MarkdownSyncPlugin({
 // src/nodes/FrontmatterNode.ts
 import {
   $applyNodeReplacement,
-  $createLineBreakNode,
+  $createLineBreakNode as $createLineBreakNode2,
   $createTextNode,
   ElementNode
 } from "lexical";
@@ -280,7 +1679,7 @@ ${body}
     while (lines.length > 0 && lines[lines.length - 1].length === 0) lines.pop();
     const node = $createFrontmatterNode();
     lines.forEach((line, index) => {
-      if (index > 0) node.append($createLineBreakNode());
+      if (index > 0) node.append($createLineBreakNode2());
       node.append($createTextNode(line));
     });
     rootNode.append(node);
@@ -381,9 +1780,9 @@ var SIDE_FIXED_POINTS = {
 function serializeDrawingData(data) {
   return JSON.stringify(data);
 }
-function parseDrawingData(json) {
+function parseDrawingData(json2) {
   try {
-    return normalizeDrawingData(JSON.parse(json));
+    return normalizeDrawingData(JSON.parse(json2));
   } catch {
     return EMPTY_DRAWING;
   }
@@ -531,7 +1930,7 @@ function bbox(shape) {
     h: Math.abs(shape.h)
   };
 }
-function normalize(shape) {
+function normalize2(shape) {
   if (isConnectorType(shape.type)) return shape;
   if (shape.w >= 0 && shape.h >= 0) return shape;
   const b = bbox(shape);
@@ -573,10 +1972,10 @@ function manhattan(a, b) {
   return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
 }
 function ellipsePolygon(r, segments = 40) {
-  const c = rectCenter(r);
+  const c2 = rectCenter(r);
   return Array.from({ length: segments }, (_, i) => {
     const a = i * 2 * Math.PI / segments;
-    return { x: c.x + r.w / 2 * Math.cos(a), y: c.y + r.h / 2 * Math.sin(a) };
+    return { x: c2.x + r.w / 2 * Math.cos(a), y: c2.y + r.h / 2 * Math.sin(a) };
   });
 }
 function rectPolygon(r) {
@@ -898,7 +2297,7 @@ function fixedPointFor(box, point) {
     [fy * b.h, "fy", 0],
     [(1 - fy) * b.h, "fy", 1]
   ];
-  edges.sort((a, c) => a[0] - c[0]);
+  edges.sort((a, c2) => a[0] - c2[0]);
   const [, axis, value] = edges[0];
   const snapped = axis === "fx" ? [value, fy] : [fx, value];
   return [round3(snapped[0]), round3(snapped[1])];
@@ -920,9 +2319,9 @@ function bindingHeading(box, binding, toward) {
   const fixed = edgeHeading(binding);
   if (fixed) return fixed;
   const b = bbox(box);
-  const c = center(box);
-  const dx = (toward.x - c.x) / Math.max(b.w, 1);
-  const dy = (toward.y - c.y) / Math.max(b.h, 1);
+  const c2 = center(box);
+  const dx = (toward.x - c2.x) / Math.max(b.w, 1);
+  const dy = (toward.y - c2.y) / Math.max(b.h, 1);
   if (Math.abs(dx) >= Math.abs(dy)) return dx >= 0 ? "right" : "left";
   return dy >= 0 ? "down" : "up";
 }
@@ -1192,17 +2591,17 @@ function simplify(points) {
   return out;
 }
 function applyElbowOverride(points, t, obstacles) {
-  const [a, b, c, d] = points;
-  const horizontalMiddle = Math.abs(b.y - c.y) < 0.01 && Math.abs(b.x - c.x) > 0.01;
-  const verticalMiddle = Math.abs(b.x - c.x) < 0.01 && Math.abs(b.y - c.y) > 0.01;
+  const [a, b, c2, d] = points;
+  const horizontalMiddle = Math.abs(b.y - c2.y) < 0.01 && Math.abs(b.x - c2.x) > 0.01;
+  const verticalMiddle = Math.abs(b.x - c2.x) < 0.01 && Math.abs(b.y - c2.y) > 0.01;
   const clamped = Math.min(0.95, Math.max(0.05, t));
   let next;
   if (verticalMiddle) {
     const x = a.x + (d.x - a.x) * clamped;
-    next = [a, { x, y: b.y }, { x, y: c.y }, d];
+    next = [a, { x, y: b.y }, { x, y: c2.y }, d];
   } else if (horizontalMiddle) {
     const y = a.y + (d.y - a.y) * clamped;
-    next = [a, { x: b.x, y }, { x: c.x, y }, d];
+    next = [a, { x: b.x, y }, { x: c2.x, y }, d];
   } else {
     return points;
   }
@@ -1569,9 +2968,9 @@ var STROKE_WIDTH = 2;
 function isDrawingSkeleton(value) {
   return isRecord2(value) && Array.isArray(value.boxes);
 }
-function parseDrawingSkeleton(json) {
+function parseDrawingSkeleton(json2) {
   try {
-    const parsed = JSON.parse(json);
+    const parsed = JSON.parse(json2);
     if (!isDrawingSkeleton(parsed)) return EMPTY_DRAWING;
     return expandSkeleton(normalizeSkeleton(parsed));
   } catch {
@@ -1584,7 +2983,7 @@ function expandSkeleton(skeleton) {
   const sizes = new Map(boxes.map((box) => [box.id, measureBox(box, boxTypes.get(box.id))]));
   const boxIds = new Set(boxTypes.keys());
   const connectors = (skeleton.connectors ?? []).filter(
-    (c) => boxIds.has(endId(c.from)) && boxIds.has(endId(c.to)) && endId(c.from) !== endId(c.to)
+    (c2) => boxIds.has(endId(c2.from)) && boxIds.has(endId(c2.to)) && endId(c2.from) !== endId(c2.to)
   );
   const positions = layoutBoxes(boxes, sizes, connectors, skeleton.direction ?? "right");
   const boxShapes = boxes.map(
@@ -1599,7 +2998,7 @@ function expandSkeleton(skeleton) {
     used.add(id);
     return id;
   };
-  const connectorShapes = connectors.map((c) => expandConnector(c, centers, nextId("c")));
+  const connectorShapes = connectors.map((c2) => expandConnector(c2, centers, nextId("c")));
   const textShapes = (skeleton.texts ?? []).map((t) => expandText(t, nextId("t")));
   const shapes = resolveBindings([...boxShapes, ...connectorShapes, ...textShapes]);
   const bottom = shapes.reduce((max, shape) => {
@@ -1652,7 +3051,7 @@ function layoutBoxes(boxes, sizes, connectors, direction) {
   const positions = /* @__PURE__ */ new Map();
   const auto = boxes.filter((box) => box.x === void 0 || box.y === void 0);
   const autoIds = new Set(auto.map((box) => box.id));
-  const edges = connectors.map((c) => ({ from: endId(c.from), to: endId(c.to) })).filter((e) => e.from !== e.to && autoIds.has(e.from) && autoIds.has(e.to));
+  const edges = connectors.map((c2) => ({ from: endId(c2.from), to: endId(c2.to) })).filter((e) => e.from !== e.to && autoIds.has(e.from) && autoIds.has(e.to));
   const ranks = rankNodes(
     auto.map((box) => box.id),
     acyclicEdges(
@@ -1671,7 +3070,7 @@ function layoutBoxes(boxes, sizes, connectors, direction) {
   const rowCross = rows.map(
     (row) => row.reduce((sum, id) => sum + sizes.get(id)[cross], 0) + Math.max(0, row.length - 1) * STACK_GAP
   );
-  const maxCross = rowCross.reduce((max, c) => Math.max(max, c), 0);
+  const maxCross = rowCross.reduce((max, c2) => Math.max(max, c2), 0);
   let mainOffset = LAYOUT_ORIGIN;
   rows.forEach((row, rank) => {
     let crossOffset = LAYOUT_ORIGIN + (maxCross - rowCross[rank]) / 2;
@@ -1800,8 +3199,8 @@ function normalizeSkeleton(raw) {
     const box = normalizeBox(b);
     return box ? [box] : [];
   });
-  const connectors = Array.isArray(value.connectors) ? value.connectors.flatMap((c) => {
-    const connector = normalizeConnector(c);
+  const connectors = Array.isArray(value.connectors) ? value.connectors.flatMap((c2) => {
+    const connector = normalizeConnector(c2);
     return connector ? [connector] : [];
   }) : [];
   const texts = Array.isArray(value.texts) ? value.texts.flatMap((t) => {
@@ -2497,7 +3896,7 @@ var textStyle = { userSelect: "none" };
 function luminance(color) {
   const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(color);
   if (!m) return 1;
-  const hex = m[1].length === 3 ? m[1].replace(/./g, (c) => c + c) : m[1];
+  const hex = m[1].length === 3 ? m[1].replace(/./g, (c2) => c2 + c2) : m[1];
   const [r, g, b] = [0, 2, 4].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255);
   return 0.2126 * r + 0.7152 * g + 0.0722 * b;
 }
@@ -3103,9 +4502,9 @@ function DrawingCanvas({ nodeKey, data }) {
         ...nextWidth !== "full" || explicitFull ? { width: nextWidth } : {},
         shapes: nextShapes
       };
-      const json = serializeDrawingData(payload);
-      if (json === lastCommittedRef.current) return;
-      lastCommittedRef.current = json;
+      const json2 = serializeDrawingData(payload);
+      if (json2 === lastCommittedRef.current) return;
+      lastCommittedRef.current = json2;
       editor.update(() => {
         const node = $getNodeByKey2(nodeKey);
         if ($isDrawingNode(node)) node.setData(payload);
@@ -3349,7 +4748,7 @@ function DrawingCanvas({ nodeKey, data }) {
           })
         );
       }
-      updateShapes((prev) => prev.map(normalize), { commit: true });
+      updateShapes((prev) => prev.map(normalize2), { commit: true });
     },
     [getPoint, paths, updateShapes, startTextEditing]
   );
@@ -4076,6 +5475,19 @@ var TABLE = {
   type: "element"
 };
 
+// src/transformers/codeTransformer.ts
+import { CODE } from "@lexical/markdown";
+import { $isCodeNode as $isCodeNode2 } from "@lexical/code";
+var CODE_BLOCK = {
+  ...CODE,
+  export: (node, exportChildren) => {
+    if (!$isCodeNode2(node)) return null;
+    if (node.getLanguage() !== PLAIN_LANGUAGE) return CODE.export?.(node, exportChildren) ?? null;
+    const text = node.getTextContent();
+    return "```" + (text ? "\n" + text : "") + "\n```";
+  }
+};
+
 // src/theme.ts
 var editorTheme = {
   ltr: "text-left",
@@ -4113,38 +5525,9 @@ var editorTheme = {
     underlineStrikethrough: "underline line-through"
   },
   code: "zui-code bg-muted rounded-md p-4 font-mono text-sm block my-2 overflow-x-auto",
-  codeHighlight: {
-    atrule: "text-blue-500",
-    attr: "text-yellow-500",
-    boolean: "text-purple-500",
-    builtin: "text-cyan-500",
-    cdata: "text-gray-500",
-    char: "text-green-500",
-    class: "text-yellow-500",
-    "class-name": "text-yellow-500",
-    comment: "text-gray-500",
-    constant: "text-purple-500",
-    deleted: "text-red-500",
-    doctype: "text-gray-500",
-    entity: "text-red-500",
-    function: "text-blue-500",
-    important: "text-red-500",
-    inserted: "text-green-500",
-    keyword: "text-purple-500",
-    namespace: "text-purple-500",
-    number: "text-green-500",
-    operator: "text-gray-500",
-    prolog: "text-gray-500",
-    property: "text-blue-500",
-    punctuation: "text-gray-500",
-    regex: "text-red-500",
-    selector: "text-blue-500",
-    string: "text-green-500",
-    symbol: "text-green-500",
-    tag: "text-red-500",
-    url: "text-blue-500",
-    variable: "text-blue-500"
-  },
+  codeHighlight: Object.fromEntries(
+    CODE_TOKEN_TYPES.map((type) => [type, `zui-token zui-token-${type}`])
+  ),
   quote: "zui-quote border-l-4 border-border pl-4 italic",
   frontmatter: "zui-frontmatter",
   table: "zui-table",
@@ -4170,8 +5553,16 @@ function useEditorContext() {
 
 // src/EditorRoot.tsx
 import { Fragment as Fragment3, jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
-var SYNC_TRANSFORMERS = [FRONTMATTER, DRAWING, DIAGRAM, CHECK_LIST, TABLE, ...TRANSFORMERS2];
-var SHORTCUT_TRANSFORMERS = [TABLE, ...TRANSFORMERS2.filter((t) => t !== CODE)];
+var SYNC_TRANSFORMERS = [
+  FRONTMATTER,
+  DRAWING,
+  DIAGRAM,
+  CHECK_LIST,
+  TABLE,
+  CODE_BLOCK,
+  ...TRANSFORMERS2.filter((t) => t !== CODE2)
+];
+var SHORTCUT_TRANSFORMERS = [TABLE, ...TRANSFORMERS2.filter((t) => t !== CODE2)];
 var NO_DEFAULT_BLOCK_WIDTH = {};
 function onError(error) {
   console.error(error);
@@ -4181,7 +5572,7 @@ var editorNodes = [
   ListNode2,
   ListItemNode,
   QuoteNode,
-  CodeNode,
+  CodeNode2,
   CodeHighlightNode,
   AutoLinkNode,
   LinkNode,
@@ -4445,7 +5836,7 @@ import {
 } from "lexical";
 import { useLexicalComposerContext as useLexicalComposerContext8 } from "@lexical/react/LexicalComposerContext";
 import { INSERT_TABLE_COMMAND } from "@lexical/table";
-import { $insertNodeToNearestRoot, mergeRegister } from "@lexical/utils";
+import { $insertNodeToNearestRoot, mergeRegister as mergeRegister2 } from "@lexical/utils";
 var TRACKED_FORMATS = [
   "bold",
   "italic",
@@ -4470,7 +5861,7 @@ function useMarkdownEditor() {
   const activeDrawingRef = useRef7(null);
   const [drawingWidth, setDrawingWidth] = useState6(null);
   useEffect10(
-    () => mergeRegister(
+    () => mergeRegister2(
       editor.registerUpdateListener(({ editorState }) => {
         editorState.read(() => {
           const table = $getSelectedTable();
@@ -4937,7 +6328,7 @@ function OutlinePlugin() {
               title: collapsed ? "Show outline" : "Hide outline",
               "aria-label": collapsed ? "Show outline" : "Hide outline",
               "aria-expanded": !collapsed,
-              onClick: () => setCollapsed((c) => !c),
+              onClick: () => setCollapsed((c2) => !c2),
               children: /* @__PURE__ */ jsx16(
                 "svg",
                 {
@@ -5187,6 +6578,9 @@ export {
   BLOCK_WIDTHS,
   BOX_DEFINITIONS,
   BOX_TYPES,
+  BUILTIN_CODE_LANGUAGES,
+  CODE_BLOCK,
+  CODE_TOKEN_TYPES,
   COLOR_PRESETS,
   CONNECTOR_TYPES,
   DEFAULT_TABLE_SETTINGS,
@@ -5203,6 +6597,7 @@ export {
   HistoryButtons,
   InsertButtons,
   MarkdownEditor_default as MarkdownEditor,
+  PLAIN_LANGUAGE,
   SHAPE_TYPES,
   SIDE_FIXED_POINTS,
   STROKE_COLORS,
@@ -5214,12 +6609,15 @@ export {
   anchorPoint,
   bindEndpoints,
   boxOutline,
+  codeTokenizer,
   connectorPoints,
   drawingToMermaid,
   expandSkeleton,
   findBoxAt,
   fixedPointFor,
   formatTableSettingsMarker,
+  getCodeLanguages,
+  hasCodeLanguage,
   isBlockWidth,
   isDrawingSkeleton,
   makeBinding,
@@ -5227,8 +6625,12 @@ export {
   parseDrawingData,
   parseDrawingSkeleton,
   parseTableSettingsMarker,
+  registerCodeBlockHighlighting,
+  registerCodeLanguage,
   resolveBindings,
+  resolveCodeLanguage,
   routeElbow,
   serializeDrawingData,
+  tokenizeCode,
   useMarkdownEditor
 };