nuvox 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -21,18 +21,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   DEFAULT_COLOR_PRESETS: () => DEFAULT_PRESETS,
+  LANGUAGE_LABELS: () => LANGUAGE_LABELS,
   REQUIRED_TOKEN_PATHS: () => REQUIRED_TOKEN_PATHS,
   TOKEN_CATEGORIES: () => TOKEN_CATEGORIES,
   amber: () => amber,
   brutalism: () => brutalism,
   copper: () => copper,
+  createHistory: () => createHistory,
   cyberpunk: () => cyberpunk,
   dark: () => dark,
   darkGlass: () => darkGlass,
   defineTheme: () => defineTheme,
   emerald: () => emerald,
+  execRichTextCommand: () => execRichTextCommand,
   findMissingTokenPaths: () => findMissingTokenPaths,
   getAccent: () => getAccent,
+  getActiveCommands: () => getActiveCommands,
   getNextSortDirection: () => getNextSortDirection,
   getSelectAllState: () => getSelectAllState,
   getTheme: () => getTheme,
@@ -47,11 +51,16 @@ __export(src_exports, {
   material: () => material,
   minimalism: () => minimalism,
   neobrutalism: () => neobrutalism,
+  nuvoxHighlight: () => nuvoxHighlight,
+  pushHistory: () => pushHistory,
+  redoHistory: () => redoHistory,
   registerAccent: () => registerAccent,
   registerTheme: () => registerTheme,
   rose: () => rose,
+  sanitizeHtml: () => sanitizeHtml,
   skeuomorphism: () => skeuomorphism,
   teal: () => teal,
+  undoHistory: () => undoHistory,
   violet: () => violet
 });
 module.exports = __toCommonJS(src_exports);
@@ -890,21 +899,727 @@ function getSelectAllState(totalCount, selectedCount) {
   if (selectedCount >= totalCount) return "all";
   return "some";
 }
+
+// src/core/code-highlight.ts
+function tokenizeFlat(source, grammar) {
+  const tokens = [];
+  const n = source.length;
+  let i = 0;
+  outer: while (i < n) {
+    for (const rule of grammar.rules) {
+      if (rule.pattern) {
+        rule.pattern.lastIndex = i;
+        const m = rule.pattern.exec(source);
+        if (m && m.index === i && m[0].length > 0) {
+          tokens.push({ type: rule.type, content: m[0] });
+          i += m[0].length;
+          continue outer;
+        }
+      } else if (rule.match) {
+        const result = rule.match(source, i, tokens);
+        if (result && result.length > 0) {
+          tokens.push(...result.tokens);
+          i += result.length;
+          continue outer;
+        }
+      }
+    }
+    const ch = source[i];
+    const last = tokens[tokens.length - 1];
+    if (last && last.type === "plain") last.content += ch;
+    else tokens.push({ type: "plain", content: ch });
+    i++;
+  }
+  return tokens;
+}
+function splitIntoLines(tokens) {
+  const lines = [[]];
+  for (const tok of tokens) {
+    const parts = tok.content.split("\n");
+    parts.forEach((part, idx) => {
+      if (part.length > 0) lines[lines.length - 1].push({ type: tok.type, content: part });
+      if (idx < parts.length - 1) lines.push([]);
+    });
+  }
+  return lines;
+}
+var KEYWORD = (words) => new RegExp(`\\b(?:${words})\\b`, "y");
+function matchTemplateLiteral(source, start, jsGrammar2) {
+  if (source[start] !== "`") return null;
+  const tokens = [{ type: "string", content: "`" }];
+  let i = start + 1;
+  let buf = "";
+  const flush = () => {
+    if (buf) {
+      tokens.push({ type: "string", content: buf });
+      buf = "";
+    }
+  };
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === "\\" && i + 1 < source.length) {
+      buf += ch + source[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch === "`") {
+      flush();
+      tokens.push({ type: "string", content: "`" });
+      i++;
+      return { length: i - start, tokens };
+    }
+    if (ch === "$" && source[i + 1] === "{") {
+      flush();
+      tokens.push({ type: "punctuation", content: "${" });
+      i += 2;
+      const exprStart = i;
+      let depth = 1;
+      while (i < source.length && depth > 0) {
+        if (source[i] === "{") depth++;
+        else if (source[i] === "}") depth--;
+        if (depth > 0) i++;
+      }
+      const exprSource = source.slice(exprStart, i);
+      tokens.push(...tokenizeFlat(exprSource, jsGrammar2));
+      if (i < source.length) {
+        tokens.push({ type: "punctuation", content: "}" });
+        i++;
+      }
+      continue;
+    }
+    buf += ch;
+    i++;
+  }
+  flush();
+  return { length: i - start, tokens };
+}
+var REGEX_EXPRESSION_KEYWORDS = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "case",
+  "do",
+  "else",
+  "yield",
+  "await"
+]);
+function matchRegexLiteral(source, start) {
+  if (source[start] !== "/" || source[start + 1] === "/" || source[start + 1] === "*") return null;
+  let j = start - 1;
+  while (j >= 0 && /\s/.test(source[j])) j--;
+  if (j >= 0) {
+    const prevChar = source[j];
+    const looksLikeValueEnd = /[)\]}\w$]/.test(prevChar) || prevChar === '"' || prevChar === "'" || prevChar === "`";
+    if (looksLikeValueEnd) {
+      const wordBefore = source.slice(0, j + 1).match(/([A-Za-z_$][\w$]*)$/)?.[1];
+      if (!(wordBefore && REGEX_EXPRESSION_KEYWORDS.has(wordBefore))) return null;
+    }
+  }
+  let i = start + 1;
+  let inClass = false;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "\n") return null;
+    if (ch === "[") inClass = true;
+    else if (ch === "]") inClass = false;
+    else if (ch === "/" && !inClass) {
+      i++;
+      break;
+    }
+    i++;
+  }
+  if (source[i - 1] !== "/") return null;
+  while (i < source.length && /[a-z]/i.test(source[i])) i++;
+  return { length: i - start, tokens: [{ type: "regex", content: source.slice(start, i) }] };
+}
+function buildJsGrammar(withTags) {
+  const grammar = { rules: [] };
+  const rules = grammar.rules;
+  if (withTags) {
+    rules.push({ type: "tag", pattern: /<\/?[A-Za-z][\w.-]*/y });
+  }
+  rules.push(
+    { type: "comment", pattern: /\/\/[^\n]*|\/\*[\s\S]*?\*\//y },
+    { type: "string", pattern: /"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'/y },
+    { type: "custom-template", match: (src, idx) => matchTemplateLiteral(src, idx, grammar) },
+    { type: "custom-regex", match: (src, idx) => matchRegexLiteral(src, idx) },
+    { type: "decorator", pattern: /@[A-Za-z_$][\w$]*/y },
+    { type: "boolean", pattern: KEYWORD("true|false|null|undefined") },
+    {
+      type: "keyword",
+      pattern: KEYWORD(
+        "const|let|var|function|return|if|else|for|while|do|switch|case|default|break|continue|class|extends|super|new|this|typeof|instanceof|in|of|try|catch|finally|throw|async|await|yield|import|export|from|as|void|delete|static|get|set|interface|type|enum|implements|public|private|protected|readonly|namespace|declare|abstract|is|keyof|infer|satisfies"
+      )
+    },
+    {
+      type: "builtin",
+      pattern: KEYWORD(
+        "console|Math|JSON|Promise|Array|Object|Map|Set|WeakMap|WeakSet|String|Number|Boolean|Symbol|Error|Date|RegExp|Reflect|Proxy|globalThis|Infinity|NaN|BigInt|fetch|localStorage|sessionStorage"
+      )
+    },
+    { type: "number", pattern: /\b0[xX][0-9a-fA-F]+\b|\b\d+\.?\d*(?:[eE][+-]?\d+)?n?\b/y },
+    { type: "function", pattern: /[A-Za-z_$][\w$]*(?=\s*\()/y },
+    { type: "punctuation", pattern: /[{}()[\];,.:?]/y }
+  );
+  return grammar;
+}
+var jsGrammar = buildJsGrammar(false);
+var jsxGrammar = buildJsGrammar(true);
+var jsonGrammar = {
+  rules: [
+    { type: "string", pattern: /"(?:[^"\\\n]|\\.)*"/y },
+    { type: "boolean", pattern: KEYWORD("true|false|null") },
+    { type: "number", pattern: /-?\b\d+\.?\d*(?:[eE][+-]?\d+)?\b/y },
+    { type: "punctuation", pattern: /[{}[\]:,]/y }
+  ]
+};
+var cssGrammar = {
+  rules: [
+    { type: "comment", pattern: /\/\*[\s\S]*?\*\//y },
+    { type: "string", pattern: /"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'/y },
+    { type: "keyword", pattern: /!important\b/y },
+    { type: "atrule", pattern: /@[a-zA-Z-]+/y },
+    // Custom-property declarations/usage (--brand-color, var(--x)) —
+    // checked before the generic hex-color/selector rules below.
+    { type: "variable", pattern: /--[a-zA-Z_][\w-]*/y },
+    { type: "function", pattern: /\b(?:var|calc|rgba?|hsla?|clamp|minmax|repeat|url|translate[XYZ]?|rotate[XYZ]?|scale[XYZ]?|linear-gradient|radial-gradient)(?=\()/y },
+    // Pseudo-classes/elements (:hover, ::before) before the plain ":" punctuation.
+    { type: "pseudo", pattern: /::?[a-zA-Z-]+/y },
+    // Hex colors before the generic "#name" id-selector pattern below.
+    { type: "builtin", pattern: /#[0-9a-fA-F]{3,8}\b/y },
+    { type: "selector", pattern: /[.#][a-zA-Z_-][\w-]*/y },
+    { type: "property", pattern: /[a-zA-Z-]+(?=\s*:)/y },
+    { type: "number", pattern: /-?\d+\.?\d*(?:px|em|rem|%|vh|vw|s|ms|deg|fr)?\b/y },
+    { type: "punctuation", pattern: /[{}:;,()]/y }
+  ]
+};
+var htmlGrammar = {
+  rules: [
+    { type: "comment", pattern: /<!--[\s\S]*?-->/y },
+    { type: "keyword", pattern: /<!DOCTYPE[^>]*>/iy },
+    { type: "tag", pattern: /<\/?[a-zA-Z][\w:-]*/y },
+    { type: "attrName", pattern: /[a-zA-Z-]+(?=\s*=)/y },
+    { type: "string", pattern: /"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'/y },
+    { type: "builtin", pattern: /&[a-zA-Z#0-9]+;/y },
+    { type: "punctuation", pattern: /[<>=/]/y }
+  ]
+};
+var bashGrammar = {
+  rules: [
+    { type: "comment", pattern: /#[^\n]*/y },
+    { type: "string", pattern: /"(?:[^"\\\n]|\\.)*"|'[^'\n]*'/y },
+    { type: "variable", pattern: /\$\{?\w+\}?/y },
+    {
+      type: "keyword",
+      pattern: KEYWORD(
+        "if|then|else|elif|fi|for|do|done|while|case|esac|function|return|exit|export|local|echo|cd|sudo|npm|yarn|pnpm|git|mkdir|rm|cp|mv|cat|grep|sed|awk"
+      )
+    },
+    { type: "number", pattern: /\b\d+\b/y },
+    { type: "function", pattern: /(?<=^|\s)--?[a-zA-Z][\w-]*/y },
+    { type: "punctuation", pattern: /[|&;()]/y }
+  ]
+};
+var pythonGrammar = {
+  rules: [
+    { type: "comment", pattern: /#[^\n]*/y },
+    { type: "decorator", pattern: /@[A-Za-z_][\w.]*/y },
+    {
+      // f/r/b/u string prefixes (f"...", rb'...', etc.) before plain strings.
+      type: "string",
+      pattern: /[rRbBfFuU]{0,2}(?:"""[\s\S]*?"""|'''[\s\S]*?'''|"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*')/y
+    },
+    { type: "boolean", pattern: KEYWORD("True|False|None") },
+    {
+      type: "keyword",
+      pattern: KEYWORD(
+        "def|return|if|elif|else|for|while|in|not|and|or|is|import|from|as|class|try|except|finally|raise|with|lambda|yield|pass|break|continue|global|nonlocal|assert|del|async|await|self"
+      )
+    },
+    { type: "builtin", pattern: KEYWORD("print|len|range|str|int|float|list|dict|set|tuple|type|isinstance|super|open|input|enumerate|zip|map|filter|sorted|sum|min|max|any|all") },
+    { type: "number", pattern: /\b\d+\.?\d*\b/y },
+    { type: "function", pattern: /[A-Za-z_]\w*(?=\s*\()/y },
+    { type: "punctuation", pattern: /[:,.()[\]{}]/y }
+  ]
+};
+var markdownGrammar = {
+  rules: [
+    { type: "comment", pattern: /```[\s\S]*?```/y },
+    { type: "keyword", pattern: /^#{1,6}[^\n]*/my },
+    { type: "punctuation", pattern: /^(?:-{3,}|\*{3,}|_{3,})$/my },
+    { type: "function", pattern: /`[^`\n]+`/y },
+    { type: "builtin", pattern: /\*\*[^*\n]+\*\*/y },
+    { type: "variable", pattern: /~~[^~\n]+~~/y },
+    { type: "string", pattern: /\*[^*\n]+\*/y },
+    { type: "tag", pattern: /!?\[[^\]\n]*\]\([^)\n]*\)/y },
+    { type: "punctuation", pattern: /^[-*+]\s|^\d+\.\s/my }
+  ]
+};
+var yamlGrammar = {
+  rules: [
+    { type: "comment", pattern: /#[^\n]*/y },
+    { type: "property", pattern: /^[ \t]*[\w.-]+(?=\s*:)/my },
+    { type: "string", pattern: /"(?:[^"\\\n]|\\.)*"|'[^'\n]*'/y },
+    { type: "boolean", pattern: KEYWORD("true|false|null|yes|no|on|off|True|False|Null") },
+    { type: "number", pattern: /-?\b\d+\.?\d*\b/y },
+    { type: "variable", pattern: /[&*][\w-]+/y },
+    { type: "punctuation", pattern: /[:\-[\]{},]/y }
+  ]
+};
+var sqlGrammar = {
+  rules: [
+    { type: "comment", pattern: /--[^\n]*|\/\*[\s\S]*?\*\//y },
+    { type: "string", pattern: /'(?:[^'\\\n]|\\.)*'/y },
+    {
+      type: "keyword",
+      pattern: new RegExp(
+        "\\b(?:SELECT|FROM|WHERE|INSERT|INTO|VALUES|UPDATE|SET|DELETE|CREATE|TABLE|ALTER|DROP|JOIN|INNER|LEFT|RIGHT|OUTER|ON|GROUP|BY|ORDER|HAVING|LIMIT|OFFSET|AS|AND|OR|NOT|NULL|IS|IN|LIKE|BETWEEN|DISTINCT|UNION|ALL|EXISTS|CASE|WHEN|THEN|ELSE|END|PRIMARY|KEY|FOREIGN|REFERENCES|DEFAULT|CONSTRAINT|INDEX|VIEW|WITH)\\b",
+        "iy"
+      )
+    },
+    { type: "number", pattern: /\b\d+\.?\d*\b/y },
+    { type: "function", pattern: /\b[A-Za-z_]\w*(?=\s*\()/y },
+    { type: "punctuation", pattern: /[(),;.*=<>!]/y }
+  ]
+};
+var GRAMMARS = {
+  javascript: jsGrammar,
+  typescript: jsGrammar,
+  jsx: jsxGrammar,
+  tsx: jsxGrammar,
+  json: jsonGrammar,
+  css: cssGrammar,
+  html: htmlGrammar,
+  bash: bashGrammar,
+  python: pythonGrammar,
+  markdown: markdownGrammar,
+  yaml: yamlGrammar,
+  sql: sqlGrammar
+};
+var ALIASES = {
+  js: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  ts: "typescript",
+  sh: "bash",
+  shell: "bash",
+  zsh: "bash",
+  py: "python",
+  md: "markdown",
+  htm: "html",
+  yml: "yaml"
+};
+var LANGUAGE_LABELS = {
+  javascript: "JavaScript",
+  typescript: "TypeScript",
+  jsx: "JSX",
+  tsx: "TSX",
+  json: "JSON",
+  css: "CSS",
+  html: "HTML",
+  bash: "Shell",
+  python: "Python",
+  markdown: "Markdown",
+  yaml: "YAML",
+  sql: "SQL",
+  plaintext: "Plain text"
+};
+function normalizeLanguage(language) {
+  const lower = language.trim().toLowerCase();
+  return ALIASES[lower] ?? lower;
+}
+var nuvoxHighlight = (code, language) => {
+  const key = normalizeLanguage(language ?? "plaintext");
+  const grammar = GRAMMARS[key];
+  if (!grammar) return splitIntoLines([{ type: "plain", content: code }]);
+  try {
+    return splitIntoLines(tokenizeFlat(code, grammar));
+  } catch {
+    return splitIntoLines([{ type: "plain", content: code }]);
+  }
+};
+
+// src/core/rich-text.ts
+var MARK_TAGS = {
+  bold: "STRONG",
+  italic: "EM",
+  underline: "U",
+  strike: "S",
+  code: "CODE"
+};
+var BLOCK_TAGS = {
+  paragraph: "P",
+  h1: "H1",
+  h2: "H2",
+  h3: "H3",
+  blockquote: "BLOCKQUOTE",
+  bulletList: "UL",
+  orderedList: "OL"
+};
+var BLOCK_TAG_NAMES = /* @__PURE__ */ new Set(["P", "H1", "H2", "H3", "BLOCKQUOTE", "DIV"]);
+function isMark(command) {
+  return command in MARK_TAGS;
+}
+function isBlock(command) {
+  return command in BLOCK_TAGS;
+}
+function isCommandActive(ancestorTags, command) {
+  if (command === "link") return ancestorTags.includes("A");
+  if (command === "unlink") return false;
+  if (isMark(command)) return ancestorTags.includes(MARK_TAGS[command]);
+  if (isBlock(command)) return ancestorTags.includes(BLOCK_TAGS[command]);
+  return false;
+}
+function closestWithinRoot(node, tag, root) {
+  let n = node;
+  while (n && n !== root) {
+    if (n.nodeType === Node.ELEMENT_NODE && n.tagName === tag) return n;
+    n = n.parentNode;
+  }
+  return null;
+}
+function closestBlock(node, root) {
+  let n = node && node.nodeType === Node.ELEMENT_NODE ? node : node?.parentNode ?? null;
+  while (n && n !== root) {
+    if (n.nodeType === Node.ELEMENT_NODE && BLOCK_TAG_NAMES.has(n.tagName)) return n;
+    n = n.parentNode;
+  }
+  return null;
+}
+function unwrapElement(el) {
+  const parent = el.parentNode;
+  if (!parent) return;
+  while (el.firstChild) parent.insertBefore(el.firstChild, el);
+  parent.removeChild(el);
+}
+function replaceTag(el, tag) {
+  const next = document.createElement(tag);
+  while (el.firstChild) next.appendChild(el.firstChild);
+  el.parentNode?.replaceChild(next, el);
+  return next;
+}
+function selectNodeContents(node, collapseToEnd = false) {
+  const sel = window.getSelection();
+  if (!sel) return;
+  const range = document.createRange();
+  range.selectNodeContents(node);
+  if (collapseToEnd) range.collapse(false);
+  sel.removeAllRanges();
+  sel.addRange(range);
+}
+var ZERO_WIDTH_SPACE = "\u200B";
+function selectAtMarker(sel, marker, offset) {
+  const range = document.createRange();
+  range.setStart(marker, offset);
+  range.collapse(true);
+  sel.removeAllRanges();
+  sel.addRange(range);
+}
+function togglePendingMark(root, tag) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  const range = sel.getRangeAt(0);
+  const existing = closestWithinRoot(range.startContainer, tag, root);
+  if (existing) {
+    const marker2 = document.createTextNode(ZERO_WIDTH_SPACE);
+    existing.parentNode?.insertBefore(marker2, existing.nextSibling);
+    selectAtMarker(sel, marker2, 1);
+    return;
+  }
+  const wrapper = document.createElement(tag);
+  const marker = document.createTextNode(ZERO_WIDTH_SPACE);
+  wrapper.appendChild(marker);
+  range.insertNode(wrapper);
+  selectAtMarker(sel, marker, 1);
+}
+function toggleMark(root, tag) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  if (sel.isCollapsed) {
+    togglePendingMark(root, tag);
+    return;
+  }
+  const range = sel.getRangeAt(0);
+  const existing = closestWithinRoot(range.commonAncestorContainer, tag, root);
+  if (existing) {
+    unwrapElement(existing);
+    return;
+  }
+  const wrapper = document.createElement(tag);
+  wrapper.appendChild(range.extractContents());
+  range.insertNode(wrapper);
+  selectNodeContents(wrapper);
+}
+function setBlockTag(root, targetTag) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  const block = closestBlock(sel.getRangeAt(0).startContainer, root);
+  if (!block) return;
+  const next = replaceTag(block, block.tagName === targetTag ? "P" : targetTag);
+  selectNodeContents(next, true);
+}
+function toggleList(root, listTag) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  const range = sel.getRangeAt(0);
+  const li = closestWithinRoot(range.startContainer, "LI", root);
+  if (li && li.parentElement?.tagName === listTag) {
+    const list2 = li.parentElement;
+    const p = document.createElement("P");
+    while (li.firstChild) p.appendChild(li.firstChild);
+    list2.parentNode?.replaceChild(p, list2);
+    selectNodeContents(p, true);
+    return;
+  }
+  const block = closestBlock(range.startContainer, root);
+  if (!block) return;
+  const list = document.createElement(listTag);
+  const item = document.createElement("LI");
+  while (block.firstChild) item.appendChild(block.firstChild);
+  list.appendChild(item);
+  block.parentNode?.replaceChild(list, block);
+  selectNodeContents(item, true);
+}
+function setLink(root, url) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0 || sel.isCollapsed) return;
+  const range = sel.getRangeAt(0);
+  const existing = closestWithinRoot(range.commonAncestorContainer, "A", root);
+  if (existing) {
+    existing.setAttribute("href", url);
+    return;
+  }
+  const a = document.createElement("A");
+  a.setAttribute("href", url);
+  a.setAttribute("rel", "noopener noreferrer");
+  a.appendChild(range.extractContents());
+  range.insertNode(a);
+  selectNodeContents(a);
+}
+function unlink(root) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  const a = closestWithinRoot(sel.getRangeAt(0).commonAncestorContainer, "A", root);
+  if (a) unwrapElement(a);
+}
+function findStyledSpanWithinRoot(node, property, root) {
+  let n = node;
+  while (n && n !== root) {
+    if (n.nodeType === Node.ELEMENT_NODE) {
+      const el = n;
+      if (el.tagName === "SPAN" && el.style.getPropertyValue(property)) return el;
+    }
+    n = n.parentNode;
+  }
+  return null;
+}
+function setInlineStyle(root, property, value) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  const range = sel.getRangeAt(0);
+  if (sel.isCollapsed) {
+    const existing2 = findStyledSpanWithinRoot(range.startContainer, property, root);
+    if (existing2) {
+      existing2.style.setProperty(property, value);
+      return;
+    }
+    const wrapper2 = document.createElement("span");
+    wrapper2.style.setProperty(property, value);
+    const marker = document.createTextNode(ZERO_WIDTH_SPACE);
+    wrapper2.appendChild(marker);
+    range.insertNode(wrapper2);
+    selectAtMarker(sel, marker, 1);
+    return;
+  }
+  const existing = findStyledSpanWithinRoot(range.commonAncestorContainer, property, root);
+  if (existing) {
+    existing.style.setProperty(property, value);
+    return;
+  }
+  const wrapper = document.createElement("span");
+  wrapper.style.setProperty(property, value);
+  wrapper.appendChild(range.extractContents());
+  range.insertNode(wrapper);
+  selectNodeContents(wrapper);
+}
+function clearInlineStyle(root, property) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  const el = findStyledSpanWithinRoot(sel.getRangeAt(0).commonAncestorContainer, property, root);
+  if (!el) return;
+  el.style.removeProperty(property);
+  if (!el.getAttribute("style")) unwrapElement(el);
+}
+function execRichTextCommand(root, command, value) {
+  if (isMark(command)) toggleMark(root, MARK_TAGS[command]);
+  else if (command === "bulletList") toggleList(root, "UL");
+  else if (command === "orderedList") toggleList(root, "OL");
+  else if (isBlock(command)) setBlockTag(root, BLOCK_TAGS[command]);
+  else if (command === "link" && value) setLink(root, value);
+  else if (command === "unlink") unlink(root);
+  else if (command === "textColor" && value) setInlineStyle(root, "color", value);
+  else if (command === "clearTextColor") clearInlineStyle(root, "color");
+  else if (command === "highlight" && value) setInlineStyle(root, "background-color", value);
+  else if (command === "clearHighlight") clearInlineStyle(root, "background-color");
+}
+function getActiveCommands(root) {
+  const result = /* @__PURE__ */ new Set();
+  if (typeof window === "undefined") return result;
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return result;
+  const tags = [];
+  let node = sel.anchorNode;
+  while (node && node !== root) {
+    if (node.nodeType === Node.ELEMENT_NODE) tags.push(node.tagName);
+    node = node.parentNode;
+  }
+  const commands = [...Object.keys(MARK_TAGS), ...Object.keys(BLOCK_TAGS), "link"];
+  for (const command of commands) {
+    if (isCommandActive(tags, command)) result.add(command);
+  }
+  return result;
+}
+var ALLOWED_TAGS = /* @__PURE__ */ new Set([
+  "P",
+  "BR",
+  "STRONG",
+  "B",
+  "EM",
+  "I",
+  "U",
+  "S",
+  "STRIKE",
+  "CODE",
+  "A",
+  "H1",
+  "H2",
+  "H3",
+  "BLOCKQUOTE",
+  "UL",
+  "OL",
+  "LI",
+  "SPAN"
+]);
+var ALLOWED_ATTRS = {
+  A: ["href"],
+  SPAN: ["style"]
+};
+var ALLOWED_STYLE_PROPS = /* @__PURE__ */ new Set(["color", "background-color"]);
+var SAFE_COLOR_VALUE = /^(#[0-9a-fA-F]{3,8}|rgb\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*\)|rgba\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*,\s*[\d.]+\s*\)|hsl\([^();]*\)|hsla\([^();]*\)|[a-zA-Z]+)$/;
+function sanitizeStyleAttr(value) {
+  const out = [];
+  for (const decl of value.split(";")) {
+    const colon = decl.indexOf(":");
+    if (colon === -1) continue;
+    const prop = decl.slice(0, colon).trim().toLowerCase();
+    const val = decl.slice(colon + 1).trim();
+    if (ALLOWED_STYLE_PROPS.has(prop) && SAFE_COLOR_VALUE.test(val)) {
+      out.push(`${prop}: ${val}`);
+    }
+  }
+  return out.join("; ");
+}
+var STRIP_ENTIRELY = /* @__PURE__ */ new Set(["SCRIPT", "STYLE", "IFRAME", "OBJECT", "EMBED"]);
+function sanitizeElement(el) {
+  for (const child of Array.from(el.childNodes)) {
+    if (child.nodeType === Node.TEXT_NODE) continue;
+    if (child.nodeType !== Node.ELEMENT_NODE) {
+      child.parentNode?.removeChild(child);
+      continue;
+    }
+    const childEl = child;
+    if (STRIP_ENTIRELY.has(childEl.tagName)) {
+      childEl.parentNode?.removeChild(childEl);
+      continue;
+    }
+    if (!ALLOWED_TAGS.has(childEl.tagName)) {
+      sanitizeElement(childEl);
+      const parent = childEl.parentNode;
+      while (childEl.firstChild) parent?.insertBefore(childEl.firstChild, childEl);
+      parent?.removeChild(childEl);
+      continue;
+    }
+    const allowedAttrs = ALLOWED_ATTRS[childEl.tagName] ?? [];
+    for (const attr of Array.from(childEl.attributes)) {
+      const name = attr.name.toLowerCase();
+      if (!allowedAttrs.includes(name)) {
+        childEl.removeAttribute(attr.name);
+        continue;
+      }
+      if (name === "style") {
+        const cleaned = sanitizeStyleAttr(attr.value);
+        if (cleaned) childEl.setAttribute("style", cleaned);
+        else childEl.removeAttribute("style");
+      }
+    }
+    if (childEl.tagName === "A") {
+      const href = childEl.getAttribute("href") ?? "";
+      const safe = /^https?:\/\//i.test(href) || href.startsWith("/") || href.startsWith("#") || href.startsWith("mailto:");
+      if (!safe) childEl.removeAttribute("href");
+      childEl.setAttribute("rel", "noopener noreferrer");
+      childEl.setAttribute("target", "_blank");
+    }
+    sanitizeElement(childEl);
+  }
+}
+function sanitizeHtml(html) {
+  if (typeof DOMParser === "undefined") return "";
+  const doc = new DOMParser().parseFromString(html, "text/html");
+  sanitizeElement(doc.body);
+  return doc.body.innerHTML;
+}
+var HISTORY_LIMIT = 100;
+function createHistory() {
+  return { past: [], future: [] };
+}
+function pushHistory(history, previousValue) {
+  return { past: [...history.past, previousValue].slice(-HISTORY_LIMIT), future: [] };
+}
+function undoHistory(history, currentValue) {
+  if (history.past.length === 0) return null;
+  const value = history.past[history.past.length - 1];
+  return {
+    history: { past: history.past.slice(0, -1), future: [currentValue, ...history.future] },
+    value
+  };
+}
+function redoHistory(history, currentValue) {
+  if (history.future.length === 0) return null;
+  const value = history.future[0];
+  return {
+    history: { past: [...history.past, currentValue], future: history.future.slice(1) },
+    value
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_COLOR_PRESETS,
+  LANGUAGE_LABELS,
   REQUIRED_TOKEN_PATHS,
   TOKEN_CATEGORIES,
   amber,
   brutalism,
   copper,
+  createHistory,
   cyberpunk,
   dark,
   darkGlass,
   defineTheme,
   emerald,
+  execRichTextCommand,
   findMissingTokenPaths,
   getAccent,
+  getActiveCommands,
   getNextSortDirection,
   getSelectAllState,
   getTheme,
@@ -919,11 +1634,16 @@ function getSelectAllState(totalCount, selectedCount) {
   material,
   minimalism,
   neobrutalism,
+  nuvoxHighlight,
+  pushHistory,
+  redoHistory,
   registerAccent,
   registerTheme,
   rose,
+  sanitizeHtml,
   skeuomorphism,
   teal,
+  undoHistory,
   violet
 });
 //# sourceMappingURL=index.cjs.map