@vanduo-oss/vd3-cbun 1.3.2 → 1.4.0

package/dist/code-editor/highlight.cjs

@@ -0,0 +1,1242 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/code-editor/highlight.js
+var highlight_exports = {};
+__export(highlight_exports, {
+  LANGUAGES: () => LANGUAGES,
+  escapeHtml: () => escapeHtml,
+  highlight: () => highlight,
+  renderTokensToDom: () => renderTokensToDom,
+  renderTokensToHtml: () => renderTokensToHtml,
+  tokenize: () => tokenize
+});
+module.exports = __toCommonJS(highlight_exports);
+
+// src/code-editor/tokenizer/scanner.js
+function matchRule(source, i, rules) {
+  for (let r = 0; r < rules.length; r++) {
+    const rule = rules[r];
+    if (rule.when && !rule.when(source, i)) continue;
+    let value;
+    if (rule.consume) {
+      const got = rule.consume(source, i);
+      if (!got || !got.value || got.value.length === 0) continue;
+      value = got.value;
+    } else {
+      rule.re.lastIndex = i;
+      const m = rule.re.exec(source);
+      if (!m || m[0].length === 0) continue;
+      value = m[0];
+    }
+    const tokens = rule.expand ? rule.expand(value) : [{ type: rule.type, value }];
+    return { tokens, length: value.length, value };
+  }
+  return null;
+}
+function scan(source, rules) {
+  const tokens = [];
+  const n = source.length;
+  let i = 0;
+  let plainStart = -1;
+  const flushPlain = (end) => {
+    if (plainStart !== -1 && end > plainStart) {
+      tokens.push({ type: "plain", value: source.slice(plainStart, end) });
+    }
+    plainStart = -1;
+  };
+  while (i < n) {
+    const hit = matchRule(source, i, rules);
+    if (hit) {
+      flushPlain(i);
+      for (let k = 0; k < hit.tokens.length; k++) tokens.push(hit.tokens[k]);
+      i += hit.length;
+    } else {
+      if (plainStart === -1) plainStart = i;
+      i++;
+    }
+  }
+  flushPlain(n);
+  return coalesce(tokens);
+}
+function coalesce(tokens) {
+  if (tokens.length < 2) return tokens;
+  const out = [{ type: tokens[0].type, value: tokens[0].value }];
+  for (let i = 1; i < tokens.length; i++) {
+    const cur = tokens[i];
+    const prev = out[out.length - 1];
+    if (cur.type === prev.type) prev.value += cur.value;
+    else out.push({ type: cur.type, value: cur.value });
+  }
+  return out;
+}
+function wordRegex(words, flags) {
+  const sorted = [...words].sort((a, b) => b.length - a.length);
+  return new RegExp("(?:" + sorted.join("|") + ")\\b", (flags || "") + "y");
+}
+
+// src/code-editor/tokenizer/javascript.js
+var JS_KEYWORDS = [
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "export",
+  "extends",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  "async",
+  "await",
+  "let",
+  "static",
+  "get",
+  "set",
+  "of",
+  "as",
+  "from"
+];
+var TS_KEYWORDS = [
+  ...JS_KEYWORDS,
+  "interface",
+  "type",
+  "enum",
+  "implements",
+  "declare",
+  "namespace",
+  "readonly",
+  "satisfies",
+  "abstract",
+  "public",
+  "private",
+  "protected",
+  "keyof",
+  "infer",
+  "is",
+  "asserts",
+  "override",
+  "module",
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "symbol",
+  "bigint",
+  "any",
+  "unknown",
+  "never"
+];
+var BUILTINS = [
+  "console",
+  "window",
+  "document",
+  "globalThis",
+  "Math",
+  "JSON",
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "Promise",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Date",
+  "RegExp",
+  "Error",
+  "Function",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "require",
+  "module",
+  "exports",
+  "process",
+  "NaN",
+  "Infinity"
+];
+var REGEX_AFTER_KEYWORD = /* @__PURE__ */ new Set([
+  "return",
+  "throw",
+  "case",
+  "in",
+  "of",
+  "typeof",
+  "void",
+  "delete",
+  "new",
+  "else",
+  "do",
+  "yield",
+  "await",
+  "extends"
+]);
+function isWs(c) {
+  return c === 32 || c === 9 || c === 10 || c === 13;
+}
+function isWord(c) {
+  return c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 36 || c === 95;
+}
+function canStartRegex(source, i) {
+  let j = i - 1;
+  while (j >= 0 && isWs(source.charCodeAt(j))) j--;
+  if (j < 0) return true;
+  const c = source.charCodeAt(j);
+  if (c === 41 || c === 93) return false;
+  if ((c === 43 || c === 45) && j > 0 && source.charCodeAt(j - 1) === c) return false;
+  if (isWord(c)) {
+    let start = j;
+    while (start > 0 && isWord(source.charCodeAt(start - 1))) start--;
+    return REGEX_AFTER_KEYWORD.has(source.slice(start, j + 1));
+  }
+  return true;
+}
+function isRegexFlag(c) {
+  return c === 100 || c === 103 || c === 105 || c === 109 || c === 115 || c === 117 || c === 118 || c === 121;
+}
+function consumeRegex(source, i) {
+  const n = source.length;
+  let j = i + 1;
+  let inClass = false;
+  while (j < n) {
+    const c = source.charCodeAt(j);
+    if (c === 10) return null;
+    if (c === 92) {
+      j += 2;
+      continue;
+    }
+    if (inClass) {
+      if (c === 93) inClass = false;
+      j++;
+      continue;
+    }
+    if (c === 91) {
+      inClass = true;
+      j++;
+      continue;
+    }
+    if (c === 47) {
+      j++;
+      while (j < n && isRegexFlag(source.charCodeAt(j))) j++;
+      return { value: source.slice(i, j) };
+    }
+    j++;
+  }
+  return null;
+}
+function skipQuoted(s, i) {
+  const q = s.charCodeAt(i);
+  let j = i + 1;
+  const n = s.length;
+  while (j < n) {
+    const c = s.charCodeAt(j);
+    if (c === 92) {
+      j += 2;
+      continue;
+    }
+    if (c === q) return j + 1;
+    if (c === 10) return j;
+    j++;
+  }
+  return n;
+}
+function findTemplateInterpEnd(s, start) {
+  let depth = 1;
+  let i = start;
+  const n = s.length;
+  while (i < n && depth > 0) {
+    const c = s.charCodeAt(i);
+    if (c === 47 && s.charCodeAt(i + 1) === 47) {
+      const nl = s.indexOf("\n", i + 2);
+      if (nl < 0) return n;
+      i = nl;
+      continue;
+    }
+    if (c === 47 && s.charCodeAt(i + 1) === 42) {
+      const end = s.indexOf("*/", i + 2);
+      i = end < 0 ? n : end + 2;
+      continue;
+    }
+    if (c === 34 || c === 39) {
+      i = skipQuoted(s, i);
+      continue;
+    }
+    if (c === 96) {
+      i = skipTemplate(s, i);
+      continue;
+    }
+    if (c === 123) depth++;
+    else if (c === 125) {
+      depth--;
+      if (depth === 0) return i;
+    }
+    i++;
+  }
+  return n;
+}
+function skipTemplate(s, i) {
+  let j = i + 1;
+  const n = s.length;
+  while (j < n) {
+    const c = s.charCodeAt(j);
+    if (c === 92) {
+      j += 2;
+      continue;
+    }
+    if (c === 96) return j + 1;
+    if (c === 36 && s.charCodeAt(j + 1) === 123) {
+      const end = findTemplateInterpEnd(s, j + 2);
+      j = end < n && s.charCodeAt(end) === 125 ? end + 1 : end;
+      continue;
+    }
+    j++;
+  }
+  return n;
+}
+function expandTemplateLiteral(value, rules) {
+  const out = [];
+  const n = value.length;
+  let i = 1;
+  let strStart = 0;
+  const flushString = (end) => {
+    if (end > strStart) out.push({ type: "string", value: value.slice(strStart, end) });
+  };
+  while (i < n) {
+    const c = value.charCodeAt(i);
+    if (c === 92) {
+      i += i + 1 < n ? 2 : 1;
+      continue;
+    }
+    if (c === 96) {
+      flushString(i + 1);
+      return out;
+    }
+    if (c === 36 && i + 1 < n && value.charCodeAt(i + 1) === 123) {
+      flushString(i);
+      out.push({ type: "operator", value: "${" });
+      const innerStart = i + 2;
+      const innerEnd = findTemplateInterpEnd(value, innerStart);
+      const inner = value.slice(innerStart, innerEnd);
+      if (inner) {
+        const parts = scan(inner, rules);
+        for (let k = 0; k < parts.length; k++) out.push(parts[k]);
+      }
+      if (innerEnd < n && value.charCodeAt(innerEnd) === 125) {
+        out.push({ type: "punctuation", value: "}" });
+        i = innerEnd + 1;
+      } else {
+        i = innerEnd;
+      }
+      strStart = i;
+      continue;
+    }
+    i++;
+  }
+  flushString(n);
+  return out;
+}
+function makeRules(keywords) {
+  const rules = [
+    { type: "comment", re: /\/\/[^\n]*/y },
+    { type: "comment", re: /\/\*[\s\S]*?(?:\*\/|$)/y },
+    // unterminated -> comment to EOF
+    { type: "string", re: /"(?:[^"\\\n]|\\.)*"?/y },
+    { type: "string", re: /'(?:[^'\\\n]|\\.)*'?/y },
+    { expand: (value) => expandTemplateLiteral(value, rules), re: /`(?:[^`\\]|\\.)*`?/y },
+    {
+      type: "number",
+      re: /0[xX][\da-fA-F_]+n?|0[bB][01_]+n?|0[oO][0-7_]+n?|(?:\d[\d_]*\.?[\d_]*|\.\d[\d_]*)(?:[eE][+-]?\d+)?n?/y
+    },
+    { type: "keyword", re: wordRegex(keywords) },
+    { type: "boolean", re: /(?:true|false)\b/y },
+    { type: "null", re: /(?:null|undefined)\b/y },
+    { type: "builtin", re: wordRegex(BUILTINS) },
+    { type: "function", re: /[A-Za-z_$][\w$]*(?=\s*\()/y },
+    { type: "plain", re: /[A-Za-z_$][\w$]*/y },
+    {
+      type: "regex",
+      when: (source, i) => source.charCodeAt(i) === 47 && canStartRegex(source, i),
+      consume: consumeRegex
+    },
+    { type: "operator", re: /\.{3}|=>|[+\-*/%=<>!&|^~?]+/y },
+    { type: "punctuation", re: /[{}()[\];,.:]/y }
+  ];
+  return rules;
+}
+var JS_RULES = makeRules(JS_KEYWORDS);
+var TS_RULES = makeRules(TS_KEYWORDS);
+function tokenizeJavaScript(source) {
+  return scan(source, JS_RULES);
+}
+function tokenizeTypeScript(source) {
+  return scan(source, TS_RULES);
+}
+
+// src/code-editor/tokenizer/css.js
+var PROPERTIES = [
+  "align-content",
+  "align-items",
+  "align-self",
+  "all",
+  "animation",
+  "animation-delay",
+  "animation-direction",
+  "animation-duration",
+  "animation-fill-mode",
+  "animation-iteration-count",
+  "animation-name",
+  "animation-play-state",
+  "animation-timing-function",
+  "appearance",
+  "aspect-ratio",
+  "backdrop-filter",
+  "backface-visibility",
+  "background",
+  "background-attachment",
+  "background-blend-mode",
+  "background-clip",
+  "background-color",
+  "background-image",
+  "background-origin",
+  "background-position",
+  "background-repeat",
+  "background-size",
+  "block-size",
+  "border",
+  "border-block",
+  "border-block-end",
+  "border-block-start",
+  "border-bottom",
+  "border-bottom-color",
+  "border-bottom-left-radius",
+  "border-bottom-right-radius",
+  "border-bottom-style",
+  "border-bottom-width",
+  "border-collapse",
+  "border-color",
+  "border-end-end-radius",
+  "border-end-start-radius",
+  "border-image",
+  "border-inline",
+  "border-inline-end",
+  "border-inline-start",
+  "border-left",
+  "border-left-color",
+  "border-left-style",
+  "border-left-width",
+  "border-radius",
+  "border-right",
+  "border-right-color",
+  "border-right-style",
+  "border-right-width",
+  "border-spacing",
+  "border-start-end-radius",
+  "border-start-start-radius",
+  "border-style",
+  "border-top",
+  "border-top-color",
+  "border-top-left-radius",
+  "border-top-right-radius",
+  "border-top-style",
+  "border-top-width",
+  "border-width",
+  "bottom",
+  "box-decoration-break",
+  "box-shadow",
+  "box-sizing",
+  "break-after",
+  "break-before",
+  "break-inside",
+  "caption-side",
+  "caret-color",
+  "clear",
+  "clip",
+  "clip-path",
+  "color",
+  "color-scheme",
+  "column-count",
+  "column-fill",
+  "column-gap",
+  "column-rule",
+  "column-span",
+  "column-width",
+  "columns",
+  "contain",
+  "container",
+  "content",
+  "counter-increment",
+  "counter-reset",
+  "cursor",
+  "direction",
+  "display",
+  "empty-cells",
+  "filter",
+  "flex",
+  "flex-basis",
+  "flex-direction",
+  "flex-flow",
+  "flex-grow",
+  "flex-shrink",
+  "flex-wrap",
+  "float",
+  "font",
+  "font-family",
+  "font-feature-settings",
+  "font-kerning",
+  "font-size",
+  "font-size-adjust",
+  "font-stretch",
+  "font-style",
+  "font-synthesis",
+  "font-variant",
+  "font-variation-settings",
+  "font-weight",
+  "gap",
+  "grid",
+  "grid-area",
+  "grid-auto-columns",
+  "grid-auto-flow",
+  "grid-auto-rows",
+  "grid-column",
+  "grid-column-end",
+  "grid-column-start",
+  "grid-row",
+  "grid-row-end",
+  "grid-row-start",
+  "grid-template",
+  "grid-template-areas",
+  "grid-template-columns",
+  "grid-template-rows",
+  "hanging-punctuation",
+  "height",
+  "hyphens",
+  "image-rendering",
+  "inline-size",
+  "inset",
+  "inset-block",
+  "inset-inline",
+  "isolation",
+  "justify-content",
+  "justify-items",
+  "justify-self",
+  "left",
+  "letter-spacing",
+  "line-break",
+  "line-clamp",
+  "line-height",
+  "list-style",
+  "list-style-image",
+  "list-style-position",
+  "list-style-type",
+  "margin",
+  "margin-block",
+  "margin-block-end",
+  "margin-block-start",
+  "margin-bottom",
+  "margin-inline",
+  "margin-inline-end",
+  "margin-inline-start",
+  "margin-left",
+  "margin-right",
+  "margin-top",
+  "mask",
+  "mask-image",
+  "max-block-size",
+  "max-height",
+  "max-inline-size",
+  "max-width",
+  "min-block-size",
+  "min-height",
+  "min-inline-size",
+  "min-width",
+  "mix-blend-mode",
+  "object-fit",
+  "object-position",
+  "offset",
+  "opacity",
+  "order",
+  "orphans",
+  "outline",
+  "outline-color",
+  "outline-offset",
+  "outline-style",
+  "outline-width",
+  "overflow",
+  "overflow-anchor",
+  "overflow-wrap",
+  "overflow-x",
+  "overflow-y",
+  "overscroll-behavior",
+  "padding",
+  "padding-block",
+  "padding-block-end",
+  "padding-block-start",
+  "padding-bottom",
+  "padding-inline",
+  "padding-inline-end",
+  "padding-inline-start",
+  "padding-left",
+  "padding-right",
+  "padding-top",
+  "page-break-after",
+  "page-break-before",
+  "page-break-inside",
+  "perspective",
+  "place-content",
+  "place-items",
+  "place-self",
+  "pointer-events",
+  "position",
+  "quotes",
+  "resize",
+  "right",
+  "rotate",
+  "row-gap",
+  "scale",
+  "scroll-behavior",
+  "scroll-margin",
+  "scroll-padding",
+  "scroll-snap-align",
+  "scroll-snap-type",
+  "shape-outside",
+  "tab-size",
+  "table-layout",
+  "text-align",
+  "text-align-last",
+  "text-decoration",
+  "text-decoration-color",
+  "text-decoration-line",
+  "text-decoration-style",
+  "text-decoration-thickness",
+  "text-emphasis",
+  "text-indent",
+  "text-overflow",
+  "text-rendering",
+  "text-shadow",
+  "text-transform",
+  "text-underline-offset",
+  "text-wrap",
+  "top",
+  "touch-action",
+  "transform",
+  "transform-origin",
+  "transition",
+  "transition-delay",
+  "transition-duration",
+  "transition-property",
+  "transition-timing-function",
+  "translate",
+  "unicode-bidi",
+  "user-select",
+  "vertical-align",
+  "visibility",
+  "white-space",
+  "widows",
+  "width",
+  "will-change",
+  "word-break",
+  "word-spacing",
+  "word-wrap",
+  "writing-mode",
+  "z-index"
+];
+function cssPropRegex(names) {
+  const sorted = [...names].sort((a, b) => b.length - a.length);
+  return new RegExp("(?:" + sorted.join("|") + ")(?=\\s*:)", "y");
+}
+var RULES = [
+  { type: "comment", re: /\/\*[\s\S]*?(?:\*\/|$)/y },
+  // unterminated -> comment to EOF
+  { type: "string", re: /"(?:[^"\\\n]|\\.)*"?|'(?:[^'\\\n]|\\.)*'?/y },
+  { type: "meta", re: /@[a-zA-Z-]+/y },
+  { type: "keyword", re: /!important\b/y },
+  { type: "number", re: /#[0-9a-fA-F]{3,8}\b/y },
+  { type: "number", re: /-?(?:\d*\.\d+|\d+)(?:%|[a-zA-Z]{1,4})?/y },
+  { type: "property", re: /--[\w-]+/y },
+  { type: "property", re: cssPropRegex(PROPERTIES) },
+  { type: "attribute", re: /[.#][a-zA-Z_-][\w-]*/y },
+  { type: "meta", re: /::?[a-zA-Z_-][\w-]*/y },
+  { type: "function", re: /[-a-zA-Z][\w-]*(?=\()/y },
+  { type: "punctuation", re: /[{}()[\];:,]/y },
+  { type: "operator", re: /[>+~*]/y },
+  // Catch-all: consume an identifier/dash run (or whitespace) in one match so
+  // the greedy property/function look-ahead rules run once per run, not once
+  // per character (keeps scanning linear).
+  { type: "plain", re: /[-\w$]+|\s+/y }
+];
+function tokenizeCss(source) {
+  return scan(source, RULES);
+}
+
+// src/code-editor/tokenizer/html.js
+function expandTag(value, vue) {
+  const out = [];
+  const open = /^<\/?/.exec(value)[0];
+  out.push({ type: "punctuation", value: open });
+  let rest = value.slice(open.length);
+  const name = /^[a-zA-Z][\w:-]*/.exec(rest);
+  if (name) {
+    out.push({ type: "tag", value: name[0] });
+    rest = rest.slice(name[0].length);
+  }
+  if (rest) {
+    const attrRules = vue ? [
+      { type: "string", re: /"[^"]*"?|'[^']*'?/y },
+      { type: "operator", re: /=/y },
+      { type: "punctuation", re: /\/?>/y },
+      { type: "meta", re: /(?:v-[\w:.@-]+|[@:][\w:.@-]*)/y },
+      { type: "attribute", re: /[a-zA-Z_][\w:.-]*/y }
+    ] : [
+      { type: "string", re: /"[^"]*"?|'[^']*'?/y },
+      { type: "operator", re: /=/y },
+      { type: "punctuation", re: /\/?>/y },
+      { type: "attribute", re: /[a-zA-Z_:@][\w:.-]*/y }
+    ];
+    const inner = scanSlice(rest, attrRules);
+    for (let i = 0; i < inner.length; i++) out.push(inner[i]);
+  }
+  return out;
+}
+function scanSlice(source, rules) {
+  const tokens = [];
+  const n = source.length;
+  let i = 0;
+  let plainStart = -1;
+  const flushPlain = (end) => {
+    if (plainStart !== -1 && end > plainStart) {
+      tokens.push({ type: "plain", value: source.slice(plainStart, end) });
+    }
+    plainStart = -1;
+  };
+  while (i < n) {
+    const hit = matchRule(source, i, rules);
+    if (hit) {
+      flushPlain(i);
+      for (let k = 0; k < hit.tokens.length; k++) tokens.push(hit.tokens[k]);
+      i += hit.length;
+    } else {
+      if (plainStart === -1) plainStart = i;
+      i++;
+    }
+  }
+  flushPlain(n);
+  return tokens;
+}
+function ieqChar(a, b) {
+  if (a === b) return true;
+  if (a >= 65 && a <= 90) return a + 32 === b;
+  if (b >= 65 && b <= 90) return b + 32 === a;
+  return false;
+}
+function findCloseTag(source, start, tagName) {
+  const n = source.length;
+  const tlen = tagName.length;
+  for (let i = start; i < n; i++) {
+    if (source.charCodeAt(i) !== 60) continue;
+    if (source.charCodeAt(i + 1) !== 47) continue;
+    let ok = true;
+    for (let k = 0; k < tlen; k++) {
+      if (!ieqChar(source.charCodeAt(i + 2 + k), tagName.charCodeAt(k))) {
+        ok = false;
+        break;
+      }
+    }
+    if (!ok) continue;
+    let j = i + 2 + tlen;
+    while (j < n) {
+      const c = source.charCodeAt(j);
+      if (c === 32 || c === 9 || c === 10 || c === 13) j++;
+      else break;
+    }
+    if (j < n && source.charCodeAt(j) === 62) return { start: i, end: j + 1 };
+  }
+  return null;
+}
+function embedInfo(tagValue) {
+  const open = /^<(script|style)\b/i.exec(tagValue);
+  if (!open) return null;
+  if (!tagValue.endsWith(">") || tagValue.endsWith("/>")) return null;
+  const tag = open[1].toLowerCase();
+  if (tag === "style") return { tag: "style", lang: "css" };
+  const lang = /\blang\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i.exec(tagValue);
+  const id = (lang && (lang[1] || lang[2] || lang[3]) || "").toLowerCase();
+  if (id === "ts" || id === "tsx" || id === "typescript")
+    return { tag: "script", lang: "typescript" };
+  return { tag: "script", lang: "javascript" };
+}
+function tokenizeEmbed(source, lang) {
+  if (lang === "typescript") return tokenizeTypeScript(source);
+  if (lang === "css") return tokenizeCss(source);
+  return tokenizeJavaScript(source);
+}
+function expandMustache(value) {
+  const out = [{ type: "meta", value: "{{" }];
+  let inner = value.slice(2);
+  let close = "";
+  if (value.length >= 4 && inner.endsWith("}}")) {
+    close = "}}";
+    inner = inner.slice(0, -2);
+  }
+  if (inner) {
+    const parts = tokenizeJavaScript(inner);
+    for (let i = 0; i < parts.length; i++) out.push(parts[i]);
+  }
+  if (close) out.push({ type: "meta", value: close });
+  return out;
+}
+function makeMarkupRules(vue) {
+  const expand = (value) => expandTag(value, vue);
+  const rules = [
+    { type: "comment", re: /<!--[\s\S]*?-->/y },
+    { type: "meta", re: /<!\[CDATA\[[\s\S]*?\]\]>/y },
+    { type: "meta", re: /<!DOCTYPE[^>]*>/iy },
+    {
+      expand,
+      re: /<\/?[a-zA-Z][\w:-]*(?:\s+[^\s/>"'=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+))?)*\s*\/?>/y
+    },
+    { expand, re: /<\/?[a-zA-Z][\w:-]*/y },
+    { type: "meta", re: /&[a-zA-Z][a-zA-Z0-9]*;|&#\d+;|&#x[0-9a-fA-F]+;/y }
+  ];
+  if (vue) {
+    rules.splice(1, 0, { expand: expandMustache, re: /\{\{[\s\S]*?(?:\}\}|$)/y });
+  }
+  return rules;
+}
+var HTML_RULES = makeMarkupRules(false);
+var VUE_RULES = makeMarkupRules(true);
+function tokenizeMarkup(source, options) {
+  const vue = !!(options && options.vue);
+  const rules = vue ? VUE_RULES : HTML_RULES;
+  const tokens = [];
+  const n = source.length;
+  let i = 0;
+  let plainStart = -1;
+  const flushPlain = (end) => {
+    if (plainStart !== -1 && end > plainStart) {
+      tokens.push({ type: "plain", value: source.slice(plainStart, end) });
+    }
+    plainStart = -1;
+  };
+  while (i < n) {
+    const hit = matchRule(source, i, rules);
+    if (hit) {
+      flushPlain(i);
+      const embed = embedInfo(hit.value);
+      if (embed) {
+        for (let k = 0; k < hit.tokens.length; k++) tokens.push(hit.tokens[k]);
+        i += hit.length;
+        const close = findCloseTag(source, i, embed.tag);
+        const bodyEnd = close ? close.start : n;
+        const body = source.slice(i, bodyEnd);
+        if (body) {
+          const inner = tokenizeEmbed(body, embed.lang);
+          for (let k = 0; k < inner.length; k++) tokens.push(inner[k]);
+        }
+        if (close) {
+          const closeTokens = expandTag(source.slice(close.start, close.end), vue);
+          for (let k = 0; k < closeTokens.length; k++) tokens.push(closeTokens[k]);
+          i = close.end;
+        } else {
+          i = n;
+        }
+        continue;
+      }
+      for (let k = 0; k < hit.tokens.length; k++) tokens.push(hit.tokens[k]);
+      i += hit.length;
+    } else {
+      if (plainStart === -1) plainStart = i;
+      i++;
+    }
+  }
+  flushPlain(n);
+  return coalesce(tokens);
+}
+function tokenizeHtml(source) {
+  return tokenizeMarkup(source, { vue: false });
+}
+function tokenizeVue(source) {
+  return tokenizeMarkup(source, { vue: true });
+}
+
+// src/code-editor/tokenizer/json.js
+var RULES2 = [
+  { type: "property", re: /"(?:[^"\\]|\\.)*"(?=\s*:)/y },
+  { type: "string", re: /"(?:[^"\\]|\\.)*"?/y },
+  { type: "number", re: /-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/y },
+  { type: "boolean", re: /\b(?:true|false)\b/y },
+  { type: "null", re: /\bnull\b/y },
+  { type: "punctuation", re: /[{}[\]:,]/y }
+];
+function tokenizeJson(source) {
+  return scan(source, RULES2);
+}
+
+// src/code-editor/tokenizer/markdown.js
+var RULES3 = [
+  { type: "string", re: /```[\s\S]*?```|~~~[\s\S]*?~~~|`[^`\n]*`/y },
+  { type: "keyword", re: /^ {0,3}#{1,6} [^\n]*/my },
+  { type: "comment", re: /^ {0,3}>[^\n]*/my },
+  { type: "punctuation", re: /^ {0,3}(?:[-*+]|\d+\.)\s/my },
+  { type: "meta", re: /^ {0,3}(?:-{3,}|\*{3,}|_{3,})\s*$/my },
+  { type: "function", re: /!?\[[^\][\n]*\]\([^()\n]*\)/y },
+  { type: "operator", re: /\*\*[^\n]*?\*\*|__[^\n]*?__/y },
+  { type: "meta", re: /\*[^*\n]+?\*|_[^_\n]+?_/y }
+];
+function tokenizeMarkdown(source) {
+  return scan(source, RULES3);
+}
+
+// src/code-editor/tokenizer/shell.js
+var KEYWORDS = [
+  "if",
+  "then",
+  "elif",
+  "else",
+  "fi",
+  "for",
+  "while",
+  "until",
+  "do",
+  "done",
+  "case",
+  "esac",
+  "function",
+  "in",
+  "select",
+  "return",
+  "break",
+  "continue",
+  "local",
+  "export",
+  "readonly",
+  "declare",
+  "typeset",
+  "set",
+  "unset",
+  "shift",
+  "exit",
+  "source",
+  "alias"
+];
+var BUILTINS2 = [
+  "echo",
+  "printf",
+  "read",
+  "cd",
+  "pwd",
+  "ls",
+  "cat",
+  "grep",
+  "sed",
+  "awk",
+  "cut",
+  "sort",
+  "uniq",
+  "head",
+  "tail",
+  "find",
+  "xargs",
+  "curl",
+  "wget",
+  "git",
+  "npm",
+  "pnpm",
+  "yarn",
+  "node",
+  "python",
+  "pip",
+  "docker",
+  "kubectl",
+  "make",
+  "chmod",
+  "chown",
+  "mkdir",
+  "rmdir",
+  "rm",
+  "cp",
+  "mv",
+  "touch",
+  "test",
+  "sudo",
+  "env",
+  "which",
+  "kill",
+  "ps",
+  "tar",
+  "ssh"
+];
+var RULES4 = [
+  { type: "comment", re: /#[^\n]*/y },
+  { type: "string", re: /"(?:[^"\\]|\\.)*"?/y },
+  { type: "string", re: /'[^']*'?/y },
+  { type: "variable", re: /\$\{[^}\n]*\}?|\$[A-Za-z_]\w*|\$[@*#?$!0-9-]/y },
+  { type: "keyword", re: wordRegex(KEYWORDS) },
+  { type: "builtin", re: wordRegex(BUILTINS2) },
+  { type: "attribute", re: /(?:^|\s)-{1,2}[A-Za-z][\w-]*/y },
+  { type: "number", re: /\b\d+\b/y },
+  { type: "operator", re: /\|\||&&|[|&;<>]+/y },
+  { type: "punctuation", re: /[(){}[\]]/y }
+];
+function tokenizeShell(source) {
+  return scan(source, RULES4);
+}
+
+// src/code-editor/tokenizer/python.js
+var KEYWORDS2 = [
+  "def",
+  "class",
+  "return",
+  "if",
+  "elif",
+  "else",
+  "for",
+  "while",
+  "break",
+  "continue",
+  "pass",
+  "import",
+  "from",
+  "as",
+  "with",
+  "try",
+  "except",
+  "finally",
+  "raise",
+  "yield",
+  "lambda",
+  "global",
+  "nonlocal",
+  "del",
+  "assert",
+  "async",
+  "await",
+  "in",
+  "is",
+  "not",
+  "and",
+  "or",
+  "match",
+  "case"
+];
+var BUILTINS3 = [
+  "print",
+  "len",
+  "range",
+  "int",
+  "float",
+  "str",
+  "list",
+  "dict",
+  "set",
+  "tuple",
+  "bool",
+  "bytes",
+  "type",
+  "isinstance",
+  "issubclass",
+  "super",
+  "open",
+  "enumerate",
+  "zip",
+  "map",
+  "filter",
+  "sorted",
+  "reversed",
+  "sum",
+  "min",
+  "max",
+  "abs",
+  "round",
+  "input",
+  "repr",
+  "format",
+  "object",
+  "self",
+  "cls",
+  "Exception",
+  "ValueError",
+  "TypeError",
+  "KeyError",
+  "IndexError",
+  "AttributeError",
+  "RuntimeError"
+];
+var RULES5 = [
+  { type: "comment", re: /#[^\n]*/y },
+  {
+    type: "string",
+    re: /[rRbBfFuU]{0,2}(?:"""[\s\S]*?"""|'''[\s\S]*?'''|"(?:[^"\\\n]|\\.)*"?|'(?:[^'\\\n]|\\.)*'?)/y
+  },
+  { type: "meta", re: /@[A-Za-z_]\w*/y },
+  { type: "keyword", re: wordRegex(KEYWORDS2) },
+  { type: "boolean", re: /\b(?:True|False)\b/y },
+  { type: "null", re: /\bNone\b/y },
+  { type: "builtin", re: wordRegex(BUILTINS3) },
+  { type: "function", re: /[A-Za-z_]\w*(?=\s*\()/y },
+  {
+    type: "number",
+    re: /\b0[xXoObB][0-9a-fA-F_]+\b|\b\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?[jJ]?\b/y
+  },
+  { type: "operator", re: /:=|[+\-*/%=<>!&|^~@]+/y },
+  { type: "punctuation", re: /[()[\]{}:;,.]/y },
+  // Catch-all: consume an identifier run (or whitespace) in one match so the
+  // greedy function look-ahead rule runs once per run, not once per character.
+  { type: "plain", re: /\w+|\s+/y }
+];
+function tokenizePython(source) {
+  return scan(source, RULES5);
+}
+
+// src/code-editor/tokenizer/index.js
+var TOKENIZERS = {
+  javascript: tokenizeJavaScript,
+  typescript: tokenizeTypeScript,
+  html: tokenizeHtml,
+  vue: tokenizeVue,
+  css: tokenizeCss,
+  json: tokenizeJson,
+  markdown: tokenizeMarkdown,
+  shell: tokenizeShell,
+  python: tokenizePython
+};
+var LANGUAGES = Object.freeze([
+  "plaintext",
+  "javascript",
+  "typescript",
+  "html",
+  "vue",
+  "css",
+  "json",
+  "markdown",
+  "shell",
+  "python"
+]);
+var ALIASES = Object.freeze({
+  js: "javascript",
+  jsx: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  ts: "typescript",
+  tsx: "typescript",
+  htm: "html",
+  xml: "html",
+  svg: "html",
+  sh: "shell",
+  bash: "shell",
+  zsh: "shell",
+  shellscript: "shell",
+  py: "python",
+  python3: "python",
+  md: "markdown",
+  mkd: "markdown",
+  json5: "json",
+  jsonc: "json",
+  text: "plaintext",
+  txt: "plaintext",
+  plain: "plaintext"
+});
+function resolveLanguage(language) {
+  const id = String(language || "plaintext").toLowerCase();
+  return ALIASES[id] || id;
+}
+function getTokenizer(language) {
+  return TOKENIZERS[resolveLanguage(language)] || null;
+}
+function tokenize(source, language) {
+  if (!source) return [];
+  const tokenizer = getTokenizer(language);
+  if (!tokenizer) return [{ type: "plain", value: source }];
+  return tokenizer(source);
+}
+
+// src/code-editor/highlight.js
+var ESCAPE_RE = /[&<>"']/g;
+var ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHtml(str) {
+  return String(str).replace(ESCAPE_RE, (ch) => ESCAPE_MAP[ch]);
+}
+function renderTokensToHtml(tokens) {
+  let html = "";
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.type === "plain") {
+      html += escapeHtml(t.value);
+    } else {
+      html += '<span class="vd-tk-' + t.type + '">' + escapeHtml(t.value) + "</span>";
+    }
+  }
+  return html;
+}
+function highlight(source, language, options) {
+  const html = renderTokensToHtml(tokenize(source, language));
+  if (options && options.trailingNewline && (source.endsWith("\n") || source === "")) {
+    return html + "\n";
+  }
+  return html;
+}
+function renderTokensToDom(tokens, doc) {
+  const frag = doc.createDocumentFragment();
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.type === "plain") {
+      frag.appendChild(doc.createTextNode(t.value));
+    } else {
+      const span = doc.createElement("span");
+      span.className = "vd-tk-" + t.type;
+      span.textContent = t.value;
+      frag.appendChild(span);
+    }
+  }
+  return frag;
+}
+//# sourceMappingURL=highlight.cjs.map