@vanduo-oss/vd3-cbun 1.3.2 → 1.4.0

package/dist/code-editor/index.cjs

@@ -25,6 +25,7 @@ __export(index_exports, {
   VdCodeEditor: () => VdCodeEditor2,
   VdCodeEditorCore: () => VdCodeEditor,
   highlight: () => highlight,
+  renderTokensToHtml: () => renderTokensToHtml,
   tokenize: () => tokenize
 });
 module.exports = __toCommonJS(index_exports);
@@ -33,6 +34,26 @@ module.exports = __toCommonJS(index_exports);
 var import_vue = require("vue");
 
 // 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;
@@ -45,26 +66,12 @@ function scan(source, rules) {
     plainStart = -1;
   };
   while (i < n) {
-    let matched = false;
-    for (let r = 0; r < rules.length; r++) {
-      const rule = rules[r];
-      rule.re.lastIndex = i;
-      const m = rule.re.exec(source);
-      if (m && m[0].length > 0) {
-        flushPlain(i);
-        const value = m[0];
-        if (rule.expand) {
-          const sub = rule.expand(value);
-          for (let k = 0; k < sub.length; k++) tokens.push(sub[k]);
-        } else {
-          tokens.push({ type: rule.type, value });
-        }
-        i += value.length;
-        matched = true;
-        break;
-      }
-    }
-    if (!matched) {
+    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++;
     }
@@ -196,14 +203,194 @@ var BUILTINS = [
   "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) {
-  return [
+  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 },
-    { type: "string", re: /`(?:[^`\\]|\\.)*`?/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
@@ -214,9 +401,15 @@ function makeRules(keywords) {
     { 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);
@@ -227,8 +420,304 @@ 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) {
+function expandTag(value, vue) {
   const out = [];
   const open = /^<\/?/.exec(value)[0];
   out.push({ type: "punctuation", value: open });
@@ -239,55 +728,186 @@ function expandTag(value) {
     rest = rest.slice(name[0].length);
   }
   if (rest) {
-    const inner = scan(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;
 }
-var RULES = [
-  { type: "comment", re: /<!--[\s\S]*?-->/y },
-  { type: "meta", re: /<!\[CDATA\[[\s\S]*?\]\]>/y },
-  { type: "meta", re: /<!DOCTYPE[^>]*>/iy },
-  {
-    expand: expandTag,
-    re: /<\/?[a-zA-Z][\w:-]*(?:\s+[^\s/>"'=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+))?)*\s*\/?>/y
-  },
-  { expand: expandTag, re: /<\/?[a-zA-Z][\w:-]*/y },
-  { type: "meta", re: /&[a-zA-Z][a-zA-Z0-9]*;|&#\d+;|&#x[0-9a-fA-F]+;/y }
-];
+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 scan(source, RULES);
+  return tokenizeMarkup(source, { vue: false });
 }
-
-// src/code-editor/tokenizer/css.js
-var RULES2 = [
-  { 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: /[-a-zA-Z]+(?=\s*:)/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, RULES2);
+function tokenizeVue(source) {
+  return tokenizeMarkup(source, { vue: true });
 }
 
 // src/code-editor/tokenizer/json.js
-var RULES3 = [
+var RULES2 = [
   { type: "property", re: /"(?:[^"\\]|\\.)*"(?=\s*:)/y },
   { type: "string", re: /"(?:[^"\\]|\\.)*"?/y },
   { type: "number", re: /-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/y },
@@ -296,11 +916,11 @@ var RULES3 = [
   { type: "punctuation", re: /[{}[\]:,]/y }
 ];
 function tokenizeJson(source) {
-  return scan(source, RULES3);
+  return scan(source, RULES2);
 }
 
 // src/code-editor/tokenizer/markdown.js
-var RULES4 = [
+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 },
@@ -311,7 +931,7 @@ var RULES4 = [
   { type: "meta", re: /\*[^*\n]+?\*|_[^_\n]+?_/y }
 ];
 function tokenizeMarkdown(source) {
-  return scan(source, RULES4);
+  return scan(source, RULES3);
 }
 
 // src/code-editor/tokenizer/shell.js
@@ -393,7 +1013,7 @@ var BUILTINS2 = [
   "tar",
   "ssh"
 ];
-var RULES5 = [
+var RULES4 = [
   { type: "comment", re: /#[^\n]*/y },
   { type: "string", re: /"(?:[^"\\]|\\.)*"?/y },
   { type: "string", re: /'[^']*'?/y },
@@ -406,7 +1026,7 @@ var RULES5 = [
   { type: "punctuation", re: /[(){}[\]]/y }
 ];
 function tokenizeShell(source) {
-  return scan(source, RULES5);
+  return scan(source, RULES4);
 }
 
 // src/code-editor/tokenizer/python.js
@@ -489,7 +1109,7 @@ var BUILTINS3 = [
   "AttributeError",
   "RuntimeError"
 ];
-var RULES6 = [
+var RULES5 = [
   { type: "comment", re: /#[^\n]*/y },
   {
     type: "string",
@@ -512,7 +1132,7 @@ var RULES6 = [
   { type: "plain", re: /\w+|\s+/y }
 ];
 function tokenizePython(source) {
-  return scan(source, RULES6);
+  return scan(source, RULES5);
 }
 
 // src/code-editor/tokenizer/index.js
@@ -520,6 +1140,7 @@ var TOKENIZERS = {
   javascript: tokenizeJavaScript,
   typescript: tokenizeTypeScript,
   html: tokenizeHtml,
+  vue: tokenizeVue,
   css: tokenizeCss,
   json: tokenizeJson,
   markdown: tokenizeMarkdown,
@@ -531,6 +1152,7 @@ var LANGUAGES = Object.freeze([
   "javascript",
   "typescript",
   "html",
+  "vue",
   "css",
   "json",
   "markdown",
@@ -546,7 +1168,6 @@ var ALIASES = Object.freeze({
   tsx: "typescript",
   htm: "html",
   xml: "html",
-  vue: "html",
   svg: "html",
   sh: "shell",
   bash: "shell",
@@ -600,9 +1221,12 @@ function renderTokensToHtml(tokens) {
   }
   return html;
 }
-function highlight(source, language) {
+function highlight(source, language, options) {
   const html = renderTokensToHtml(tokenize(source, language));
-  return source.endsWith("\n") || source === "" ? html + "\n" : html;
+  if (options && options.trailingNewline && (source.endsWith("\n") || source === "")) {
+    return html + "\n";
+  }
+  return html;
 }
 function renderTokensToDom(tokens, doc) {
   const frag = doc.createDocumentFragment();
@@ -756,7 +1380,7 @@ function handleBackspacePair(value, start, end) {
 }
 
 // src/code-editor/core.js
-var VD_CODE_EDITOR_VERSION = "1.0.1";
+var VD_CODE_EDITOR_VERSION = "1.1.0";
 var DEFAULTS = {
   value: "",
   language: "plaintext",