@vanduo-oss/vd3-cbun 1.0.0 → 1.2.0

package/dist/code-editor/index.js

@@ -0,0 +1,1328 @@
+// src/code-editor/vue.js
+import { defineComponent, h, ref, onMounted, onBeforeUnmount, watch } from "vue";
+
+// src/code-editor/tokenizer/scanner.js
+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) {
+    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) {
+      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"
+];
+function makeRules(keywords) {
+  return [
+    { type: "comment", re: /\/\/[^\n]*/y },
+    { type: "comment", re: /\/\*[\s\S]*?\*\//y },
+    { type: "string", re: /"(?:[^"\\\n]|\\.)*"?/y },
+    { type: "string", re: /'(?:[^'\\\n]|\\.)*'?/y },
+    { type: "string", 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: "operator", re: /\.{3}|=>|[+\-*/%=<>!&|^~?]+/y },
+    { type: "punctuation", re: /[{}()[\];,.:]/y }
+  ];
+}
+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/html.js
+function expandTag(value) {
+  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 inner = scan(rest, [
+      { type: "string", re: /"[^"]*"?|'[^']*'?/y },
+      { type: "operator", re: /=/y },
+      { type: "punctuation", re: /\/?>/y },
+      { type: "attribute", re: /[a-zA-Z_:@][\w:.-]*/y }
+    ]);
+    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 tokenizeHtml(source) {
+  return scan(source, RULES);
+}
+
+// src/code-editor/tokenizer/css.js
+var RULES2 = [
+  { type: "comment", re: /\/\*[\s\S]*?\*\//y },
+  { 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);
+}
+
+// src/code-editor/tokenizer/json.js
+var RULES3 = [
+  { 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, RULES3);
+}
+
+// src/code-editor/tokenizer/markdown.js
+var RULES4 = [
+  { 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, RULES4);
+}
+
+// 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 RULES5 = [
+  { 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, RULES5);
+}
+
+// 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 RULES6 = [
+  { 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, RULES6);
+}
+
+// src/code-editor/tokenizer/index.js
+var TOKENIZERS = {
+  javascript: tokenizeJavaScript,
+  typescript: tokenizeTypeScript,
+  html: tokenizeHtml,
+  css: tokenizeCss,
+  json: tokenizeJson,
+  markdown: tokenizeMarkdown,
+  shell: tokenizeShell,
+  python: tokenizePython
+};
+var LANGUAGES = Object.freeze([
+  "plaintext",
+  "javascript",
+  "typescript",
+  "html",
+  "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",
+  vue: "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) {
+  const html = renderTokensToHtml(tokenize(source, language));
+  return source.endsWith("\n") || source === "" ? html + "\n" : 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;
+}
+
+// src/code-editor/constants.js
+var DEFAULT_TAB_SIZE = 2;
+var MAX_HIGHLIGHT_LENGTH = 1e5;
+var AUTO_CLOSE_PAIRS = Object.freeze({
+  "(": ")",
+  "[": "]",
+  "{": "}",
+  '"': '"',
+  "'": "'",
+  "`": "`"
+});
+var OPENERS = Object.freeze(Object.keys(AUTO_CLOSE_PAIRS));
+var CLOSERS = Object.freeze([")", "]", "}", '"', "'", "`"]);
+function closerFor(ch) {
+  return AUTO_CLOSE_PAIRS[ch];
+}
+function isMatchingPair(open, close) {
+  return AUTO_CLOSE_PAIRS[open] === close;
+}
+
+// src/code-editor/editing.js
+var CLOSER_SET = new Set(CLOSERS);
+var WORD = /[\w$]/;
+function indentOnEnter(value, start, end, unit) {
+  const lineStart = value.lastIndexOf("\n", start - 1) + 1;
+  const leading = /^[ \t]*/.exec(value.slice(lineStart, start))[0];
+  const prev = value[start - 1];
+  const next = value[end];
+  const opens = prev === "{" || prev === "[" || prev === "(";
+  if (opens && isMatchingPair(prev, next)) {
+    const inner = leading + unit;
+    const text2 = "\n" + inner + "\n" + leading;
+    const caret2 = start + 1 + inner.length;
+    return { from: start, to: end, text: text2, selectionStart: caret2, selectionEnd: caret2 };
+  }
+  const indent = opens ? leading + unit : leading;
+  const text = "\n" + indent;
+  const caret = start + text.length;
+  return { from: start, to: end, text, selectionStart: caret, selectionEnd: caret };
+}
+function handleTab(value, start, end, unit) {
+  if (start !== end && value.slice(start, end).indexOf("\n") !== -1) {
+    const from = value.lastIndexOf("\n", start - 1) + 1;
+    const block = value.slice(from, end);
+    const indented = block.replace(/^/gm, unit);
+    const added = indented.length - block.length;
+    return {
+      from,
+      to: end,
+      text: indented,
+      selectionStart: start + unit.length,
+      selectionEnd: end + added
+    };
+  }
+  return {
+    from: start,
+    to: end,
+    text: unit,
+    selectionStart: start + unit.length,
+    selectionEnd: start + unit.length
+  };
+}
+function handleShiftTab(value, start, end, unit) {
+  const from = value.lastIndexOf("\n", start - 1) + 1;
+  const size = unit.length || 1;
+  const lines = value.slice(from, end).split("\n");
+  let firstRemoved = 0;
+  let totalRemoved = 0;
+  const dedented = lines.map((line, idx) => {
+    let remove = 0;
+    while (remove < size && line[remove] === " ") remove++;
+    if (remove === 0 && line[0] === "	") remove = 1;
+    if (idx === 0) firstRemoved = remove;
+    totalRemoved += remove;
+    return line.slice(remove);
+  }).join("\n");
+  return {
+    from,
+    to: end,
+    text: dedented,
+    selectionStart: Math.max(from, start - firstRemoved),
+    selectionEnd: Math.max(from, end - totalRemoved)
+  };
+}
+function autoClosePair(char, value, start, end) {
+  const closer = closerFor(char);
+  if (!closer) return null;
+  if (start !== end) {
+    return {
+      from: start,
+      to: end,
+      text: char + value.slice(start, end) + closer,
+      selectionStart: start + 1,
+      selectionEnd: end + 1
+    };
+  }
+  const nextChar = value[start];
+  if (char === closer) {
+    if (nextChar && WORD.test(nextChar)) return null;
+    const prevChar = value[start - 1];
+    if (prevChar && WORD.test(prevChar)) return null;
+  } else if (nextChar && WORD.test(nextChar)) {
+    return null;
+  }
+  return {
+    from: start,
+    to: end,
+    text: char + closer,
+    selectionStart: start + 1,
+    selectionEnd: start + 1
+  };
+}
+function skipOverCloser(char, value, start, end) {
+  if (start !== end || !CLOSER_SET.has(char)) return null;
+  if (value[start] === char) {
+    return { caretOnly: true, selectionStart: start + 1, selectionEnd: start + 1 };
+  }
+  return null;
+}
+function handleBackspacePair(value, start, end) {
+  if (start !== end || start === 0) return null;
+  const prev = value[start - 1];
+  const next = value[start];
+  if (AUTO_CLOSE_PAIRS[prev] && AUTO_CLOSE_PAIRS[prev] === next) {
+    return {
+      from: start - 1,
+      to: start + 1,
+      text: "",
+      selectionStart: start - 1,
+      selectionEnd: start - 1
+    };
+  }
+  return null;
+}
+
+// src/code-editor/core.js
+var VD_CODE_EDITOR_VERSION = "1.0.0";
+var DEFAULTS = {
+  value: "",
+  language: "plaintext",
+  readOnly: false,
+  lineNumbers: true,
+  tabSize: DEFAULT_TAB_SIZE,
+  placeholder: "",
+  maxLength: void 0,
+  wrap: false,
+  autoClose: true,
+  highlightActiveLine: true,
+  maxHighlightLength: MAX_HIGHLIGHT_LENGTH,
+  spellcheck: false,
+  ariaLabel: "Code editor",
+  copy: true
+};
+var RAF = typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : (cb) => setTimeout(cb, 16);
+var CAF = typeof window !== "undefined" && window.cancelAnimationFrame ? window.cancelAnimationFrame.bind(window) : clearTimeout;
+function resolveElement(element) {
+  if (!element) return null;
+  if (typeof element === "string") {
+    return typeof document !== "undefined" ? document.querySelector(element) : null;
+  }
+  return element;
+}
+function countNewlines(str, end) {
+  let n = 0;
+  const limit = end == null ? str.length : end;
+  for (let i = 0; i < limit; i++) {
+    if (str.charCodeAt(i) === 10) n++;
+  }
+  return n;
+}
+var VdCodeEditor = class {
+  constructor(options = {}) {
+    this._opts = Object.assign({}, DEFAULTS, options);
+    this._listeners = /* @__PURE__ */ Object.create(null);
+    this._domListeners = [];
+    this._raf = 0;
+    this._ro = null;
+    this._copyTimer = 0;
+    this._destroyed = false;
+    this._lineHeight = 21;
+    this._paddingTop = 0;
+    this._gutterCount = -1;
+    this._lastValue = this._opts.value == null ? "" : String(this._opts.value);
+    this.element = resolveElement(options.element);
+    if (this.element) this._mount();
+  }
+  // ── mounting ──────────────────────────────────────────────────────────────
+  _mount() {
+    const el = this.element;
+    const doc = el.ownerDocument;
+    const opts = this._opts;
+    const showGutter = opts.lineNumbers && !opts.wrap;
+    const showActiveLine = opts.highlightActiveLine && !opts.wrap;
+    el.classList.add("vd-code-editor");
+    el.classList.toggle("is-wrap", !!opts.wrap);
+    el.classList.toggle("is-readonly", !!opts.readOnly);
+    el.classList.toggle("has-gutter", showGutter);
+    el.style.setProperty("--vd-code-editor-tab-size", String(opts.tabSize));
+    if (showActiveLine) {
+      this._activeLine = doc.createElement("div");
+      this._activeLine.className = "vd-code-editor-active-line";
+      this._activeLine.setAttribute("aria-hidden", "true");
+      el.appendChild(this._activeLine);
+    }
+    this._pre = doc.createElement("pre");
+    this._pre.className = "vd-code-editor-highlight";
+    this._pre.setAttribute("aria-hidden", "true");
+    this._code = doc.createElement("code");
+    this._code.className = "vd-code-editor-code";
+    this._pre.appendChild(this._code);
+    el.appendChild(this._pre);
+    if (showGutter) {
+      this._gutter = doc.createElement("div");
+      this._gutter.className = "vd-code-editor-gutter";
+      this._gutter.setAttribute("aria-hidden", "true");
+      this._gutterLines = doc.createElement("div");
+      this._gutterLines.className = "vd-code-editor-gutter-lines";
+      this._gutter.appendChild(this._gutterLines);
+      el.appendChild(this._gutter);
+    }
+    const ta = doc.createElement("textarea");
+    ta.className = "vd-code-editor-input";
+    ta.value = this._lastValue;
+    ta.spellcheck = !!opts.spellcheck;
+    ta.wrap = opts.wrap ? "soft" : "off";
+    ta.setAttribute("autocomplete", "off");
+    ta.setAttribute("autocapitalize", "off");
+    ta.setAttribute("autocorrect", "off");
+    ta.setAttribute("aria-label", opts.ariaLabel || "Code editor");
+    ta.setAttribute("aria-multiline", "true");
+    if (opts.readOnly) ta.readOnly = true;
+    if (opts.placeholder) ta.placeholder = opts.placeholder;
+    if (opts.maxLength != null) ta.maxLength = opts.maxLength;
+    ta.style.tabSize = String(opts.tabSize);
+    this._pre.style.tabSize = String(opts.tabSize);
+    this._textarea = ta;
+    el.appendChild(ta);
+    if (opts.copy && typeof navigator !== "undefined" && navigator.clipboard) {
+      const btn = doc.createElement("button");
+      btn.type = "button";
+      btn.className = "vd-code-editor-copy";
+      btn.setAttribute("aria-label", "Copy code");
+      btn.textContent = "Copy";
+      this._copyBtn = btn;
+      el.appendChild(btn);
+    }
+    this._attach();
+    this._measure();
+    this._repaint();
+    this._syncScroll();
+  }
+  _attach() {
+    const ta = this._textarea;
+    this._listen(ta, "input", () => this._handleInput());
+    this._listen(ta, "scroll", () => this._syncScroll());
+    this._listen(ta, "keydown", (e) => this._handleKeydown(e));
+    this._listen(ta, "focus", (e) => this._handleFocus(e));
+    this._listen(ta, "blur", (e) => this._handleBlur(e));
+    this._listen(ta, "click", () => this._updateActiveLine());
+    this._listen(ta, "keyup", () => this._updateActiveLine());
+    this._listen(ta, "select", () => this._updateActiveLine());
+    if (this._copyBtn) this._listen(this._copyBtn, "click", () => this._handleCopy());
+    if (typeof ResizeObserver === "function") {
+      this._ro = new ResizeObserver(() => {
+        this._measure();
+        this._syncScroll();
+      });
+      this._ro.observe(this.element);
+    }
+    const fonts = this.element.ownerDocument.fonts;
+    if (fonts && fonts.ready && typeof fonts.ready.then === "function") {
+      fonts.ready.then(() => {
+        if (this._destroyed) return;
+        this._measure();
+        this._syncScroll();
+      });
+    }
+  }
+  _listen(target, type, handler) {
+    target.addEventListener(type, handler);
+    this._domListeners.push([target, type, handler]);
+  }
+  // ── rendering ─────────────────────────────────────────────────────────────
+  _measure() {
+    if (typeof getComputedStyle !== "function") return;
+    const cs = getComputedStyle(this._textarea);
+    const lh = parseFloat(cs.lineHeight);
+    if (Number.isFinite(lh) && lh > 0) this._lineHeight = lh;
+    const pt = parseFloat(cs.paddingTop);
+    this._paddingTop = Number.isFinite(pt) ? pt : 0;
+  }
+  _scheduleRepaint() {
+    if (this._raf || this._destroyed) return;
+    this._raf = RAF(() => {
+      this._raf = 0;
+      if (!this._destroyed) this._repaint();
+    });
+  }
+  _repaint() {
+    const value = this._textarea.value;
+    const doc = this.element.ownerDocument;
+    const trailing = value.endsWith("\n") || value === "";
+    if (value.length > this._opts.maxHighlightLength) {
+      this._code.classList.add("is-plain");
+      this._code.replaceChildren(doc.createTextNode(trailing ? value + "\n" : value));
+    } else {
+      this._code.classList.remove("is-plain");
+      const frag = renderTokensToDom(tokenize(value, this._opts.language), doc);
+      if (trailing) frag.appendChild(doc.createTextNode("\n"));
+      this._code.replaceChildren(frag);
+    }
+    this._updateGutter(value);
+  }
+  _updateGutter(value) {
+    if (!this._gutterLines) return;
+    const lines = countNewlines(value) + 1;
+    if (lines === this._gutterCount) return;
+    this._gutterCount = lines;
+    this.element.style.setProperty(
+      "--vd-code-editor-gutter-digits",
+      String(Math.max(2, String(lines).length))
+    );
+    let text = "1";
+    for (let i = 2; i <= lines; i++) text += "\n" + i;
+    this._gutterLines.textContent = text;
+  }
+  _syncScroll() {
+    const ta = this._textarea;
+    if (!ta) return;
+    const st = ta.scrollTop;
+    if (this._pre) {
+      this._pre.scrollTop = st;
+      this._pre.scrollLeft = ta.scrollLeft;
+    }
+    if (this._gutterLines) {
+      this._gutterLines.style.transform = "translateY(" + -st + "px)";
+    }
+    this._updateActiveLine();
+  }
+  _updateActiveLine() {
+    if (!this._activeLine) return;
+    const ta = this._textarea;
+    const line = countNewlines(ta.value, ta.selectionStart || 0);
+    const top = this._paddingTop + line * this._lineHeight - ta.scrollTop;
+    this._activeLine.style.height = this._lineHeight + "px";
+    this._activeLine.style.transform = "translateY(" + top + "px)";
+  }
+  // ── input + keymap ────────────────────────────────────────────────────────
+  _handleInput() {
+    this._scheduleRepaint();
+    this._syncScroll();
+    this._emitChangeIfChanged();
+  }
+  _emitChangeIfChanged() {
+    const v = this._textarea.value;
+    if (v === this._lastValue) return;
+    this._lastValue = v;
+    this._emit("change", { value: v });
+  }
+  _handleFocus(e) {
+    this.element.classList.add("is-focused");
+    this._emit("focus", e);
+  }
+  _handleBlur(e) {
+    this.element.classList.remove("is-focused");
+    this._emit("blur", e);
+  }
+  _handleKeydown(e) {
+    if (this._opts.readOnly || e.isComposing) return;
+    if (e.ctrlKey || e.metaKey || e.altKey) return;
+    const ta = this._textarea;
+    const value = ta.value;
+    const s = ta.selectionStart;
+    const en = ta.selectionEnd;
+    const unit = " ".repeat(this._opts.tabSize);
+    if (e.key === "Enter") {
+      e.preventDefault();
+      this._applyEdit(indentOnEnter(value, s, en, unit));
+      return;
+    }
+    if (e.key === "Tab") {
+      e.preventDefault();
+      this._applyEdit(
+        e.shiftKey ? handleShiftTab(value, s, en, unit) : handleTab(value, s, en, unit)
+      );
+      return;
+    }
+    if (e.key === "Backspace") {
+      const edit = handleBackspacePair(value, s, en);
+      if (edit) {
+        e.preventDefault();
+        this._applyEdit(edit);
+      }
+      return;
+    }
+    if (e.key.length === 1 && this._opts.autoClose) {
+      const skip = skipOverCloser(e.key, value, s, en);
+      if (skip) {
+        e.preventDefault();
+        ta.setSelectionRange(skip.selectionStart, skip.selectionEnd);
+        this._updateActiveLine();
+        return;
+      }
+      const auto = autoClosePair(e.key, value, s, en);
+      if (auto) {
+        e.preventDefault();
+        this._applyEdit(auto);
+      }
+    }
+  }
+  // Apply an edit, preferring execCommand so the native undo stack is preserved;
+  // fall back to setRangeText, then to a direct value splice (jsdom/old engines).
+  _applyEdit(edit) {
+    const ta = this._textarea;
+    ta.setSelectionRange(edit.from, edit.to);
+    let nativeInput = false;
+    if (this._tryExecInsert(edit.text)) {
+      nativeInput = true;
+    } else if (typeof ta.setRangeText === "function") {
+      ta.setRangeText(edit.text, edit.from, edit.to, "end");
+    } else {
+      ta.value = ta.value.slice(0, edit.from) + edit.text + ta.value.slice(edit.to);
+    }
+    if (edit.selectionStart != null) {
+      const end = edit.selectionEnd == null ? edit.selectionStart : edit.selectionEnd;
+      ta.setSelectionRange(edit.selectionStart, end);
+    }
+    if (nativeInput) {
+      this._updateActiveLine();
+    } else {
+      this._handleInput();
+    }
+  }
+  _tryExecInsert(text) {
+    try {
+      return typeof document !== "undefined" && typeof document.execCommand === "function" && document.execCommand("insertText", false, text);
+    } catch {
+      return false;
+    }
+  }
+  _handleCopy() {
+    if (this._destroyed || typeof navigator === "undefined" || !navigator.clipboard) return;
+    navigator.clipboard.writeText(this._textarea.value).then(
+      () => this._flashCopied(),
+      () => {
+      }
+    );
+  }
+  _flashCopied() {
+    if (!this._copyBtn) return;
+    this._copyBtn.classList.add("is-copied");
+    this._copyBtn.textContent = "Copied";
+    if (this._copyTimer) clearTimeout(this._copyTimer);
+    this._copyTimer = setTimeout(() => {
+      this._copyTimer = 0;
+      if (this._destroyed || !this._copyBtn) return;
+      this._copyBtn.classList.remove("is-copied");
+      this._copyBtn.textContent = "Copy";
+    }, 1200);
+  }
+  // ── public API ────────────────────────────────────────────────────────────
+  getValue() {
+    return this._textarea ? this._textarea.value : this._lastValue;
+  }
+  setValue(next, options) {
+    const silent = !!(options && options.silent);
+    const v = next == null ? "" : String(next);
+    if (!this._textarea) {
+      this._lastValue = v;
+      return this;
+    }
+    if (v === this._textarea.value) return this;
+    this._textarea.value = v;
+    if (silent) this._lastValue = v;
+    this._repaint();
+    this._syncScroll();
+    if (!silent) this._emitChangeIfChanged();
+    return this;
+  }
+  getSelection() {
+    const ta = this._textarea;
+    if (!ta) return { start: 0, end: 0, text: "" };
+    return {
+      start: ta.selectionStart,
+      end: ta.selectionEnd,
+      text: ta.value.slice(ta.selectionStart, ta.selectionEnd)
+    };
+  }
+  setSelection(start, end) {
+    if (!this._textarea) return this;
+    const e = end == null ? start : end;
+    this._textarea.setSelectionRange(start, e);
+    this._updateActiveLine();
+    return this;
+  }
+  insertText(text) {
+    if (!this._textarea) return this;
+    const ta = this._textarea;
+    const str = String(text);
+    this._applyEdit({
+      from: ta.selectionStart,
+      to: ta.selectionEnd,
+      text: str,
+      selectionStart: ta.selectionStart + str.length
+    });
+    return this;
+  }
+  setLanguage(language) {
+    this._opts.language = language || "plaintext";
+    if (this._textarea) this._repaint();
+    return this;
+  }
+  setReadOnly(readOnly) {
+    this._opts.readOnly = !!readOnly;
+    if (this._textarea) this._textarea.readOnly = !!readOnly;
+    if (this.element) this.element.classList.toggle("is-readonly", !!readOnly);
+    return this;
+  }
+  setTabSize(tabSize) {
+    const n = Number(tabSize) || DEFAULT_TAB_SIZE;
+    this._opts.tabSize = n;
+    if (this._textarea) this._textarea.style.tabSize = String(n);
+    if (this._pre) this._pre.style.tabSize = String(n);
+    if (this.element) this.element.style.setProperty("--vd-code-editor-tab-size", String(n));
+    return this;
+  }
+  setPlaceholder(text) {
+    this._opts.placeholder = text || "";
+    if (this._textarea) this._textarea.placeholder = text || "";
+    return this;
+  }
+  setAutoClose(autoClose) {
+    this._opts.autoClose = !!autoClose;
+    return this;
+  }
+  focus() {
+    if (this._textarea) this._textarea.focus();
+    return this;
+  }
+  blur() {
+    if (this._textarea) this._textarea.blur();
+    return this;
+  }
+  on(name, handler) {
+    if (!this._listeners[name]) this._listeners[name] = [];
+    this._listeners[name].push(handler);
+    return this;
+  }
+  off(name, handler) {
+    const list = this._listeners[name];
+    if (!list) return this;
+    const i = list.indexOf(handler);
+    if (i !== -1) list.splice(i, 1);
+    return this;
+  }
+  _emit(name, payload) {
+    const list = this._listeners[name];
+    if (!list) return;
+    for (let i = 0; i < list.length; i++) list[i](payload);
+  }
+  destroy() {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    if (this._raf) CAF(this._raf);
+    if (this._copyTimer) clearTimeout(this._copyTimer);
+    if (this._ro) {
+      this._ro.disconnect();
+      this._ro = null;
+    }
+    for (let i = 0; i < this._domListeners.length; i++) {
+      const [target, type, handler] = this._domListeners[i];
+      target.removeEventListener(type, handler);
+    }
+    this._domListeners = [];
+    if (this.element) {
+      const nodes = [this._activeLine, this._pre, this._gutter, this._textarea, this._copyBtn];
+      for (let i = 0; i < nodes.length; i++) {
+        const n = nodes[i];
+        if (n && n.parentNode === this.element) this.element.removeChild(n);
+      }
+      this.element.classList.remove(
+        "vd-code-editor",
+        "is-wrap",
+        "is-readonly",
+        "has-gutter",
+        "is-focused"
+      );
+    }
+    this._listeners = /* @__PURE__ */ Object.create(null);
+    this._textarea = null;
+    this._pre = null;
+    this._code = null;
+    this._gutter = null;
+    this._gutterLines = null;
+    this._activeLine = null;
+    this._copyBtn = null;
+  }
+};
+
+// src/code-editor/vue.js
+var VdCodeEditor2 = defineComponent({
+  name: "VdCodeEditor",
+  props: {
+    /** Editor contents (v-model). */
+    modelValue: { type: String, default: "" },
+    /** Syntax language id or alias (e.g. `js`, `python`, `plaintext`). */
+    language: { type: String, default: "plaintext" },
+    /** Render as a non-editable viewer (copy still works). */
+    readOnly: { type: Boolean, default: false },
+    /** Show the line-number gutter (ignored in wrap mode). */
+    lineNumbers: { type: Boolean, default: true },
+    /** Indent width, in spaces. */
+    tabSize: { type: Number, default: 2 },
+    /** Empty-state placeholder text. */
+    placeholder: { type: String, default: "" },
+    /** Native `maxlength` cap on the content. */
+    maxLength: { type: Number, default: void 0 },
+    /** Soft-wrap long lines (disables the gutter + active-line). */
+    wrap: { type: Boolean, default: false },
+    /** Auto-close brackets/quotes and step over closers. */
+    autoClose: { type: Boolean, default: true },
+    /** Highlight the caret's line (ignored in wrap mode). */
+    highlightActiveLine: { type: Boolean, default: true },
+    /** Skip highlighting above this many characters (perf guard). */
+    maxHighlightLength: { type: Number, default: 1e5 },
+    /** Native spellcheck on the textarea. */
+    spellcheck: { type: Boolean, default: false },
+    /** Show the copy-to-clipboard button (when the clipboard API exists). */
+    copy: { type: Boolean, default: true },
+    /** Accessible label for the textarea. */
+    ariaLabel: { type: String, default: "Code editor" }
+  },
+  emits: ["update:modelValue", "change", "focus", "blur", "ready"],
+  setup(props, { emit, expose }) {
+    const el = ref(null);
+    let instance = null;
+    const create = () => {
+      instance = new VdCodeEditor({
+        element: el.value,
+        value: props.modelValue,
+        language: props.language,
+        readOnly: props.readOnly,
+        lineNumbers: props.lineNumbers,
+        tabSize: props.tabSize,
+        placeholder: props.placeholder,
+        maxLength: props.maxLength,
+        wrap: props.wrap,
+        autoClose: props.autoClose,
+        highlightActiveLine: props.highlightActiveLine,
+        maxHighlightLength: props.maxHighlightLength,
+        spellcheck: props.spellcheck,
+        copy: props.copy,
+        ariaLabel: props.ariaLabel
+      });
+      instance.on("change", (payload) => {
+        emit("update:modelValue", payload.value);
+        emit("change", payload.value);
+      });
+      instance.on("focus", (e) => emit("focus", e));
+      instance.on("blur", (e) => emit("blur", e));
+      emit("ready", instance);
+    };
+    const teardown = () => {
+      if (instance) {
+        instance.destroy();
+        instance = null;
+      }
+    };
+    onMounted(() => {
+      if (typeof window === "undefined" || !el.value) return;
+      create();
+    });
+    watch(
+      () => props.modelValue,
+      (next) => {
+        if (instance && next !== instance.getValue()) instance.setValue(next, { silent: true });
+      }
+    );
+    watch(
+      () => props.language,
+      (v) => instance && instance.setLanguage(v)
+    );
+    watch(
+      () => props.readOnly,
+      (v) => instance && instance.setReadOnly(v)
+    );
+    watch(
+      () => props.tabSize,
+      (v) => instance && instance.setTabSize(v)
+    );
+    watch(
+      () => props.placeholder,
+      (v) => instance && instance.setPlaceholder(v)
+    );
+    watch(
+      () => props.autoClose,
+      (v) => instance && instance.setAutoClose(v)
+    );
+    watch(
+      () => [
+        props.lineNumbers,
+        props.wrap,
+        props.highlightActiveLine,
+        props.spellcheck,
+        props.maxLength,
+        props.maxHighlightLength,
+        props.copy,
+        props.ariaLabel
+      ],
+      () => {
+        if (!instance) return;
+        teardown();
+        create();
+      }
+    );
+    onBeforeUnmount(teardown);
+    expose({
+      getInstance: () => instance,
+      focus: () => instance && instance.focus(),
+      blur: () => instance && instance.blur(),
+      getValue: () => instance ? instance.getValue() : props.modelValue,
+      setValue: (value) => instance && instance.setValue(value),
+      getSelection: () => instance ? instance.getSelection() : { start: 0, end: 0, text: "" },
+      setSelection: (start, end) => instance && instance.setSelection(start, end),
+      insertText: (text) => instance && instance.insertText(text),
+      getContainer: () => el.value
+    });
+    return () => h("div", { ref: el, class: "vd-code-editor" });
+  }
+});
+export {
+  LANGUAGES,
+  VD_CODE_EDITOR_VERSION,
+  VdCodeEditor2 as VdCodeEditor,
+  VdCodeEditor as VdCodeEditorCore,
+  highlight,
+  tokenize
+};
+//# sourceMappingURL=index.js.map