@regmisatyam/retex 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3444 @@
+'use strict';
+
+// src/types/source.ts
+function pos(offset, line, column) {
+  return { offset, line, column };
+}
+function range(start, end) {
+  return { start, end };
+}
+function mergeRanges(a, b) {
+  return {
+    start: a.start.offset <= b.start.offset ? a.start : b.start,
+    end: a.end.offset >= b.end.offset ? a.end : b.end
+  };
+}
+function rangeContains(r, offset) {
+  return offset >= r.start.offset && offset <= r.end.offset;
+}
+
+// src/types/tokens.ts
+var TokenType = /* @__PURE__ */ ((TokenType2) => {
+  TokenType2["Command"] = "Command";
+  TokenType2["LBrace"] = "LBrace";
+  TokenType2["RBrace"] = "RBrace";
+  TokenType2["LBracket"] = "LBracket";
+  TokenType2["RBracket"] = "RBracket";
+  TokenType2["Text"] = "Text";
+  TokenType2["Whitespace"] = "Whitespace";
+  TokenType2["ParBreak"] = "ParBreak";
+  TokenType2["LineBreak"] = "LineBreak";
+  TokenType2["Comment"] = "Comment";
+  TokenType2["EOF"] = "EOF";
+  return TokenType2;
+})(TokenType || {});
+var SPECIAL_CHARS = /* @__PURE__ */ new Set(["\\", "{", "}", "[", "]"]);
+
+// src/types/ast.ts
+function isParent(node) {
+  return Array.isArray(node.children);
+}
+function isNode(node, type) {
+  return node.type === type;
+}
+
+// src/types/diagnostics.ts
+var DiagnosticSeverity = /* @__PURE__ */ ((DiagnosticSeverity2) => {
+  DiagnosticSeverity2["Error"] = "error";
+  DiagnosticSeverity2["Warning"] = "warning";
+  DiagnosticSeverity2["Info"] = "info";
+  DiagnosticSeverity2["Hint"] = "hint";
+  return DiagnosticSeverity2;
+})(DiagnosticSeverity || {});
+var DiagnosticCode = /* @__PURE__ */ ((DiagnosticCode2) => {
+  DiagnosticCode2["UnexpectedToken"] = "RTX1001";
+  DiagnosticCode2["UnterminatedGroup"] = "RTX1002";
+  DiagnosticCode2["UnterminatedArgument"] = "RTX1003";
+  DiagnosticCode2["UnexpectedEOF"] = "RTX1004";
+  DiagnosticCode2["MismatchedBrace"] = "RTX1005";
+  DiagnosticCode2["UnknownCommand"] = "RTX2001";
+  DiagnosticCode2["UnknownEnvironment"] = "RTX2002";
+  DiagnosticCode2["MissingRequiredArgument"] = "RTX2003";
+  DiagnosticCode2["TooManyArguments"] = "RTX2004";
+  DiagnosticCode2["MissingEnvironmentEnd"] = "RTX2005";
+  DiagnosticCode2["MismatchedEnvironment"] = "RTX2006";
+  DiagnosticCode2["InvalidColor"] = "RTX3001";
+  DiagnosticCode2["InvalidUrl"] = "RTX3002";
+  DiagnosticCode2["InvalidDimension"] = "RTX3003";
+  DiagnosticCode2["MissingRequiredField"] = "RTX3004";
+  DiagnosticCode2["UnknownField"] = "RTX3005";
+  DiagnosticCode2["EmptyArgument"] = "RTX3006";
+  DiagnosticCode2["CommandOutsideContext"] = "RTX4001";
+  DiagnosticCode2["UnknownIcon"] = "RTX4002";
+  DiagnosticCode2["UnknownThemeColor"] = "RTX4003";
+  DiagnosticCode2["UnsafeUrlBlocked"] = "RTX5001";
+  return DiagnosticCode2;
+})(DiagnosticCode || {});
+
+// src/tokenizer/tokenizer.ts
+var isLetter = (c) => c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+var isInlineSpace = (c) => c === " " || c === "	" || c === "\r";
+var Tokenizer = class _Tokenizer {
+  constructor(source) {
+    this.offset = 0;
+    this.line = 1;
+    this.column = 1;
+    this.tokens = [];
+    this.diagnostics = [];
+    this.src = source.replace(/\r\n?/g, "\n");
+  }
+  static tokenize(source) {
+    return new _Tokenizer(source).run();
+  }
+  run() {
+    while (!this.atEnd()) {
+      this.scanToken();
+    }
+    this.push("EOF" /* EOF */, "", this.position());
+    return { tokens: this.tokens, diagnostics: this.diagnostics };
+  }
+  /* --------------------------- scanners --------------------------- */
+  scanToken() {
+    const start = this.position();
+    const c = this.peek();
+    switch (c) {
+      case "\\":
+        this.scanBackslash(start);
+        return;
+      case "{":
+        this.read();
+        this.push("LBrace" /* LBrace */, "{", start);
+        return;
+      case "}":
+        this.read();
+        this.push("RBrace" /* RBrace */, "}", start);
+        return;
+      case "[":
+        this.read();
+        this.push("LBracket" /* LBracket */, "[", start);
+        return;
+      case "]":
+        this.read();
+        this.push("RBracket" /* RBracket */, "]", start);
+        return;
+      case "%":
+        if (this.peek(1) === "%") {
+          this.scanComment(start);
+          return;
+        }
+        this.scanText(start);
+        return;
+      default:
+        if (isInlineSpace(c) || c === "\n") {
+          this.scanWhitespace(start);
+          return;
+        }
+        this.scanText(start);
+    }
+  }
+  scanBackslash(start) {
+    this.read();
+    const next = this.peek();
+    if (next === "\\") {
+      this.read();
+      this.push("LineBreak" /* LineBreak */, "\\\\", start);
+      return;
+    }
+    if (isLetter(next)) {
+      let name = "";
+      while (isLetter(this.peek())) name += this.read();
+      if (this.peek() === "*") name += this.read();
+      this.push("Command" /* Command */, name, start);
+      return;
+    }
+    if (next !== "" && next !== "\n") {
+      const ch = this.read();
+      this.push("Text" /* Text */, ch, start);
+      return;
+    }
+    this.push("Text" /* Text */, "\\", start);
+  }
+  scanComment(start) {
+    let value = "";
+    while (!this.atEnd() && this.peek() !== "\n") value += this.read();
+    this.push("Comment" /* Comment */, value, start);
+  }
+  scanWhitespace(start) {
+    let value = "";
+    let newlines = 0;
+    while (!this.atEnd()) {
+      const c = this.peek();
+      if (c === "\n") {
+        newlines++;
+        value += this.read();
+      } else if (isInlineSpace(c)) {
+        value += this.read();
+      } else {
+        break;
+      }
+    }
+    this.push(newlines >= 2 ? "ParBreak" /* ParBreak */ : "Whitespace" /* Whitespace */, value, start);
+  }
+  scanText(start) {
+    let value = "";
+    while (!this.atEnd()) {
+      const c = this.peek();
+      if (c === "\\" || c === "{" || c === "}" || c === "[" || c === "]" || c === "\n" || isInlineSpace(c)) {
+        break;
+      }
+      if (c === "%" && this.peek(1) === "%") break;
+      value += this.read();
+    }
+    if (value === "") value = this.read();
+    this.push("Text" /* Text */, value, start);
+  }
+  /* --------------------------- cursor ----------------------------- */
+  atEnd() {
+    return this.offset >= this.src.length;
+  }
+  peek(k = 0) {
+    return this.src[this.offset + k] ?? "";
+  }
+  read() {
+    const c = this.src[this.offset] ?? "";
+    this.offset++;
+    if (c === "\n") {
+      this.line++;
+      this.column = 1;
+    } else {
+      this.column++;
+    }
+    return c;
+  }
+  position() {
+    return { offset: this.offset, line: this.line, column: this.column };
+  }
+  push(type, value, start) {
+    this.tokens.push({ type, value, range: { start, end: this.position() } });
+  }
+};
+function tokenize(source) {
+  return Tokenizer.tokenize(source);
+}
+
+// src/parser/registry.ts
+var CommandRegistry = class _CommandRegistry {
+  constructor() {
+    this.commands = /* @__PURE__ */ new Map();
+    this.environments = /* @__PURE__ */ new Map();
+  }
+  registerCommand(def) {
+    this.commands.set(def.name, def);
+    return this;
+  }
+  registerEnvironment(def) {
+    this.environments.set(def.name, def);
+    return this;
+  }
+  getCommand(name) {
+    return this.commands.get(name);
+  }
+  getEnvironment(name) {
+    return this.environments.get(name);
+  }
+  hasCommand(name) {
+    return this.commands.has(name);
+  }
+  hasEnvironment(name) {
+    return this.environments.has(name);
+  }
+  commandNames() {
+    return [...this.commands.keys()];
+  }
+  environmentNames() {
+    return [...this.environments.keys()];
+  }
+  allCommands() {
+    return [...this.commands.values()];
+  }
+  allEnvironments() {
+    return [...this.environments.values()];
+  }
+  /** Shallow-clone the registry (definitions are shared, maps are copied). */
+  clone() {
+    const next = new _CommandRegistry();
+    next.commands = new Map(this.commands);
+    next.environments = new Map(this.environments);
+    return next;
+  }
+};
+
+// src/parser/args.ts
+function splitTopLevel(raw, sep = ",") {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (let i = 0; i < raw.length; i++) {
+    const c = raw[i];
+    if (c === "{" || c === "[") depth++;
+    else if (c === "}" || c === "]") depth = Math.max(0, depth - 1);
+    if (c === sep && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += c;
+    }
+  }
+  parts.push(current);
+  return parts;
+}
+function parseListArg(raw) {
+  return splitTopLevel(raw).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function parseKeyValArg(raw) {
+  const segments = splitTopLevel(raw);
+  const merged = [];
+  for (const seg of segments) {
+    if (!seg.includes("=") && merged.length > 0) {
+      merged[merged.length - 1] += "," + seg;
+    } else {
+      merged.push(seg);
+    }
+  }
+  const fields = {};
+  for (const seg of merged) {
+    const trimmed = seg.trim();
+    if (trimmed === "") continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) {
+      fields[trimmed] = "";
+      continue;
+    }
+    const key = trimmed.slice(0, eq).trim();
+    const value = trimmed.slice(eq + 1).trim();
+    if (key) fields[key] = value;
+  }
+  return fields;
+}
+
+// src/security/sanitize.ts
+function escapeHtml(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeAttribute(input) {
+  return escapeHtml(input);
+}
+var SAFE_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "mailto:", "tel:", "ftp:", "sms:"]);
+var SCHEME_RE = /^([a-z][a-z0-9+.-]*):/i;
+var CONTROL_CHARS_RE = /[\x00-\x1f\x7f]/g;
+function sanitizeUrl(input) {
+  const raw = String(input ?? "").trim();
+  const cleaned = raw.replace(CONTROL_CHARS_RE, "");
+  const match = SCHEME_RE.exec(cleaned);
+  if (!match) {
+    return { safe: cleaned, blocked: false };
+  }
+  const scheme = match[1].toLowerCase() + ":";
+  if (SAFE_PROTOCOLS.has(scheme)) {
+    return { safe: cleaned, blocked: false, scheme };
+  }
+  return { safe: "#", blocked: true, scheme };
+}
+function isSafeColor(value) {
+  const v = value.trim();
+  if (/^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(v)) return true;
+  if (/^(rgb|rgba|hsl|hsla)\(\s*[0-9.,%\s/]+\)$/i.test(v)) return true;
+  return CSS_NAMED_COLORS.has(v.toLowerCase());
+}
+function isSafeDimension(value) {
+  return /^-?\d*\.?\d+(px|pt|em|rem|ex|ch|vw|vh|vmin|vmax|cm|mm|in|pc|%|fr)?$/.test(
+    value.trim()
+  );
+}
+function sanitizeStyleValue(value) {
+  const v = value.trim();
+  if (/[<>;{}]/.test(v) || /expression|url\s*\(|javascript:/i.test(v)) {
+    return void 0;
+  }
+  return v;
+}
+var CSS_NAMED_COLORS = /* @__PURE__ */ new Set([
+  "black",
+  "silver",
+  "gray",
+  "grey",
+  "white",
+  "maroon",
+  "red",
+  "purple",
+  "fuchsia",
+  "green",
+  "lime",
+  "olive",
+  "yellow",
+  "navy",
+  "blue",
+  "teal",
+  "aqua",
+  "cyan",
+  "magenta",
+  "orange",
+  "pink",
+  "brown",
+  "gold",
+  "indigo",
+  "violet",
+  "tan",
+  "beige",
+  "ivory",
+  "coral",
+  "salmon",
+  "khaki",
+  "crimson",
+  "turquoise",
+  "lavender",
+  "plum",
+  "orchid",
+  "slateblue",
+  "slategray",
+  "steelblue",
+  "skyblue",
+  "royalblue",
+  "midnightblue",
+  "darkblue",
+  "darkgreen",
+  "darkred",
+  "darkgray",
+  "darkgrey",
+  "lightgray",
+  "lightgrey",
+  "lightblue",
+  "transparent",
+  "currentcolor",
+  "inherit"
+]);
+
+// src/icons/icons.ts
+var ICONS = {
+  github: {
+    body: '<path d="M12 1.5A10.5 10.5 0 0 0 8.7 22c.5.1.7-.2.7-.5v-2c-2.9.6-3.5-1.3-3.5-1.3-.5-1.2-1.2-1.5-1.2-1.5-.9-.6.1-.6.1-.6 1 .1 1.6 1 1.6 1 .9 1.6 2.4 1.1 3 .9.1-.7.4-1.1.7-1.4-2.3-.3-4.8-1.2-4.8-5.2 0-1.2.4-2.1 1-2.9-.1-.3-.5-1.3.1-2.7 0 0 .9-.3 2.8 1.1a9.6 9.6 0 0 1 5 0c1.9-1.4 2.8-1.1 2.8-1.1.6 1.4.2 2.4.1 2.7.7.8 1 1.7 1 2.9 0 4-2.5 4.9-4.8 5.2.4.3.7 1 .7 2v3c0 .3.2.6.7.5A10.5 10.5 0 0 0 12 1.5Z"/>'
+  },
+  linkedin: {
+    body: '<path d="M20.5 2h-17A1.5 1.5 0 0 0 2 3.5v17A1.5 1.5 0 0 0 3.5 22h17a1.5 1.5 0 0 0 1.5-1.5v-17A1.5 1.5 0 0 0 20.5 2ZM8 19H5v-9h3v9ZM6.5 8.7A1.7 1.7 0 1 1 6.5 5.3a1.7 1.7 0 0 1 0 3.4ZM19 19h-3v-4.7c0-1.1 0-2.6-1.6-2.6s-1.8 1.2-1.8 2.5V19h-3v-9h2.9v1.2h.04a3.2 3.2 0 0 1 2.9-1.6c3.1 0 3.7 2 3.7 4.7V19Z"/>'
+  },
+  email: {
+    body: '<path d="M3 5h18a1 1 0 0 1 1 1v12a1 1 0 0 1-1 1H3a1 1 0 0 1-1-1V6a1 1 0 0 1 1-1Zm.4 2 8.6 6 8.6-6H3.4ZM20 8.2l-7.4 5.2a1 1 0 0 1-1.2 0L4 8.2V17h16V8.2Z"/>',
+    aliases: ["mail", "envelope"]
+  },
+  phone: {
+    body: '<path d="M6.6 10.8a15.5 15.5 0 0 0 6.6 6.6l2.2-2.2a1 1 0 0 1 1-.25 11.4 11.4 0 0 0 3.6.58 1 1 0 0 1 1 1V20a1 1 0 0 1-1 1A17 17 0 0 1 3 4a1 1 0 0 1 1-1h3.5a1 1 0 0 1 1 1 11.4 11.4 0 0 0 .57 3.6 1 1 0 0 1-.25 1l-2.2 2.2Z"/>',
+    aliases: ["tel", "telephone"]
+  },
+  location: {
+    body: '<path d="M12 2a7 7 0 0 0-7 7c0 5 7 13 7 13s7-8 7-13a7 7 0 0 0-7-7Zm0 9.5A2.5 2.5 0 1 1 12 6.5a2.5 2.5 0 0 1 0 5Z"/>',
+    aliases: ["map", "pin", "marker", "geo"]
+  },
+  website: {
+    body: '<path d="M12 2a10 10 0 1 0 0 20 10 10 0 0 0 0-20Zm6.9 6h-2.9a15.7 15.7 0 0 0-1.3-3.4A8 8 0 0 1 18.9 8ZM12 4c.8 1.1 1.5 2.5 1.9 4h-3.8c.4-1.5 1.1-2.9 1.9-4ZM4.3 14a8 8 0 0 1 0-4h3.3a17.6 17.6 0 0 0 0 4H4.3Zm.8 2h2.9a15.7 15.7 0 0 0 1.3 3.4A8 8 0 0 1 5.1 16Zm2.9-8H5.1a8 8 0 0 1 4.2-3.4A15.7 15.7 0 0 0 8 8Zm4 12c-.8-1.1-1.5-2.5-1.9-4h3.8c-.4 1.5-1.1 2.9-1.9 4Zm2.3-6h-4.6a15.3 15.3 0 0 1 0-4h4.6a15.3 15.3 0 0 1 0 4Zm.4 5.4a15.7 15.7 0 0 0 1.3-3.4h2.9a8 8 0 0 1-4.2 3.4ZM16.4 14a17.6 17.6 0 0 0 0-4h3.3a8 8 0 0 1 0 4h-3.3Z"/>',
+    aliases: ["globe", "web", "link", "url"]
+  },
+  twitter: {
+    body: '<path d="M22 5.9c-.7.3-1.5.6-2.3.7a4 4 0 0 0 1.8-2.2c-.8.5-1.7.8-2.6 1a4 4 0 0 0-6.8 3.6A11.3 11.3 0 0 1 3.9 4.8a4 4 0 0 0 1.2 5.3c-.6 0-1.2-.2-1.8-.5a4 4 0 0 0 3.2 3.9c-.6.1-1.2.2-1.8.1a4 4 0 0 0 3.7 2.8A8 8 0 0 1 2 18.1 11.3 11.3 0 0 0 8.1 20c7.4 0 11.5-6.2 11.5-11.5v-.5c.8-.6 1.5-1.3 2-2.1Z"/>',
+    aliases: ["x"]
+  },
+  gitlab: {
+    body: '<path d="m21.9 13.1-1.1-3.4-2.2-6.8a.6.6 0 0 0-1.1 0l-2.2 6.8H8.7L6.5 2.9a.6.6 0 0 0-1.1 0L3.2 9.7l-1.1 3.4a1.2 1.2 0 0 0 .4 1.3l9.5 6.9 9.5-6.9a1.2 1.2 0 0 0 .4-1.3Z"/>'
+  },
+  stackoverflow: {
+    body: '<path d="M17 21v-6h2v8H4v-8h2v6h11ZM7 17h9v-2H7v2Zm.3-4.2 8.8 1.8.4-2-8.8-1.8-.4 2Zm1.2-4.4 8.1 3.8.8-1.8-8.1-3.8-.8 1.8Zm2.5-4 6.9 5.7 1.3-1.5-6.9-5.7-1.3 1.5ZM15.6 1l-1.6 1.2 5.3 7.2 1.6-1.2L15.6 1Z"/>',
+    aliases: ["stack-overflow", "so"]
+  },
+  scholar: {
+    body: '<path d="M12 2 1 9l11 7 9-5.7V17h2V9L12 2ZM5 14.2V18c0 1.7 3.1 3 7 3s7-1.3 7-3v-3.8l-7 4.4-7-4.4Z"/>',
+    aliases: ["google-scholar", "academic"]
+  },
+  orcid: {
+    body: '<path d="M12 2a10 10 0 1 0 0 20 10 10 0 0 0 0-20ZM8.5 7.6a1.1 1.1 0 1 1 0 2.2 1.1 1.1 0 0 1 0-2.2ZM9.5 17h-2v-6.2h2V17Zm2-6.2h3.3c2.2 0 3.6 1.5 3.6 3.1 0 1.8-1.4 3.1-3.6 3.1H11.5v-6.2Zm2 1.7v2.8h1.1c1.2 0 1.8-.6 1.8-1.4s-.6-1.4-1.8-1.4h-1.1Z"/>'
+  },
+  calendar: {
+    body: '<path d="M7 2v2H5a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2h-2V2h-2v2H9V2H7ZM5 9h14v10H5V9Z"/>',
+    aliases: ["date"]
+  },
+  briefcase: {
+    body: '<path d="M9 3a2 2 0 0 0-2 2v1H4a2 2 0 0 0-2 2v11a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-3V5a2 2 0 0 0-2-2H9Zm0 3V5h6v1H9Z"/>',
+    aliases: ["work", "job"]
+  }
+};
+var ALIASES = {};
+for (const [name, def] of Object.entries(ICONS)) {
+  for (const alias of def.aliases ?? []) ALIASES[alias] = name;
+}
+function resolveIconName(name) {
+  const key = name.trim().toLowerCase();
+  if (ICONS[key]) return key;
+  if (ALIASES[key]) return ALIASES[key];
+  return void 0;
+}
+function hasIcon(name) {
+  return resolveIconName(name) !== void 0;
+}
+function getIcon(name) {
+  const key = resolveIconName(name);
+  return key ? ICONS[key] : void 0;
+}
+function registerIcon(name, def) {
+  const key = name.trim().toLowerCase();
+  ICONS[key] = def;
+  for (const alias of def.aliases ?? []) ALIASES[alias] = key;
+}
+function iconNames() {
+  return Object.keys(ICONS);
+}
+function iconToSvg(name, opts = {}) {
+  const def = getIcon(name);
+  if (!def) return null;
+  const size = opts.size ?? "1em";
+  const dim = typeof size === "number" ? `${size}` : size;
+  const cls = opts.className ? ` class="${opts.className}"` : "";
+  const fillOrStroke = def.stroked ? 'fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"' : 'fill="currentColor"';
+  return `<svg${cls} width="${dim}" height="${dim}" viewBox="0 0 24 24" ${fillOrStroke} role="img" aria-hidden="true" focusable="false">${def.body}</svg>`;
+}
+
+// src/parser/builtins.ts
+var mark = (name, type, summary) => ({
+  name,
+  category: "inline",
+  args: [{ kind: "content", name: "content" }],
+  summary,
+  example: `\\${name}{...}`,
+  build: ({ args }) => ({ type, children: args[0]?.children ?? [] })
+});
+var scaleSwitch = (name, scale) => ({
+  name,
+  category: "switch",
+  scoped: true,
+  summary: `Set the font size to "${name}" for the rest of the group.`,
+  example: `{\\${name} ...}`,
+  build: ({ scope }) => ({ type: "fontscale", scale, children: scope })
+});
+var TYPOGRAPHY = [
+  mark("textbf", "bold", "Bold text."),
+  mark("textit", "italic", "Italic text."),
+  mark("emph", "italic", "Emphasized (italic) text."),
+  mark("underline", "underline", "Underlined text."),
+  mark("sout", "strike", "Struck-through text."),
+  {
+    name: "textcolor",
+    category: "inline",
+    args: [
+      { kind: "string", name: "color", format: "color" },
+      { kind: "content", name: "content" }
+    ],
+    summary: "Color text with a hex/named color.",
+    example: "\\textcolor{#2563eb}{OpenAI}",
+    build: ({ args, utils, report }) => {
+      const color = utils.textOf(args[0]).trim();
+      if (color && !isSafeColor(color)) {
+        report({
+          severity: "warning" /* Warning */,
+          code: "RTX3001" /* InvalidColor */,
+          message: `"${color}" is not a recognized color; it will be ignored.`,
+          range: args[0]?.range ?? ZERO_RANGE
+        });
+      }
+      return {
+        type: "color",
+        color: isSafeColor(color) ? color : "",
+        children: args[1]?.children ?? []
+      };
+    }
+  },
+  {
+    name: "fontsize",
+    category: "inline",
+    args: [
+      { kind: "string", name: "size", format: "dimension" },
+      { kind: "content", name: "content" }
+    ],
+    summary: "Set an explicit font size for the wrapped content.",
+    example: "\\fontsize{14pt}{Custom Size}",
+    build: ({ args, utils, report }) => {
+      const size = utils.textOf(args[0]).trim();
+      if (size && !isSafeDimension(size)) {
+        report({
+          severity: "warning" /* Warning */,
+          code: "RTX3003" /* InvalidDimension */,
+          message: `"${size}" is not a valid dimension.`,
+          range: args[0]?.range ?? ZERO_RANGE
+        });
+      }
+      return {
+        type: "fontsize",
+        size: isSafeDimension(size) ? size : "1em",
+        children: args[1]?.children ?? []
+      };
+    }
+  },
+  {
+    name: "fontfamily",
+    category: "inline",
+    args: [
+      { kind: "string", name: "family" },
+      { kind: "content", name: "content" }
+    ],
+    summary: "Set the font family for the wrapped content.",
+    example: "\\fontfamily{Georgia}{Serif text}",
+    build: ({ args, utils }) => ({
+      type: "fontfamily",
+      family: utils.textOf(args[0]).trim() || "inherit",
+      children: args[1]?.children ?? []
+    })
+  },
+  {
+    name: "themecolor",
+    category: "inline",
+    args: [
+      { kind: "string", name: "token" },
+      { kind: "content", name: "content" }
+    ],
+    summary: "Color text using a token from the active theme.",
+    example: "\\themecolor{primary}{Highlighted}",
+    build: ({ args, utils }) => ({
+      type: "themecolor",
+      token: utils.textOf(args[0]).trim() || "primary",
+      children: args[1]?.children ?? []
+    })
+  },
+  scaleSwitch("small", "small"),
+  scaleSwitch("large", "large"),
+  scaleSwitch("Large", "Large"),
+  scaleSwitch("Huge", "Huge"),
+  {
+    name: "normalsize",
+    category: "switch",
+    scoped: true,
+    summary: "Reset the font size to the document base size.",
+    build: ({ scope }) => ({ type: "fontscale", scale: "normal", children: scope })
+  },
+  {
+    name: "bfseries",
+    category: "switch",
+    scoped: true,
+    summary: "Switch to bold for the rest of the group.",
+    build: ({ scope }) => ({ type: "bold", children: scope })
+  },
+  {
+    name: "itshape",
+    category: "switch",
+    scoped: true,
+    summary: "Switch to italic for the rest of the group.",
+    build: ({ scope }) => ({ type: "italic", children: scope })
+  },
+  {
+    name: "ttfamily",
+    category: "switch",
+    scoped: true,
+    summary: "Switch to a monospace font for the rest of the group.",
+    build: ({ scope }) => ({
+      type: "fontfamily",
+      family: "monospace",
+      children: scope
+    })
+  }
+];
+var LINKS = [
+  {
+    name: "href",
+    category: "inline",
+    args: [
+      { kind: "string", name: "url", format: "url" },
+      { kind: "content", name: "label" }
+    ],
+    summary: "A hyperlink with custom label text.",
+    example: "\\href{https://github.com/you}{GitHub}",
+    build: ({ args, utils }) => {
+      const raw = utils.textOf(args[0]).trim();
+      return {
+        type: "link",
+        href: utils.safeUrl(raw),
+        rawHref: raw,
+        children: args[1]?.children ?? []
+      };
+    }
+  },
+  {
+    name: "url",
+    category: "inline",
+    args: [{ kind: "string", name: "url", format: "url" }],
+    summary: "A hyperlink that displays its own URL.",
+    example: "\\url{https://linkedin.com/in/you}",
+    build: ({ args, utils }) => {
+      const raw = utils.textOf(args[0]).trim();
+      return { type: "url", href: utils.safeUrl(raw), rawHref: raw };
+    }
+  }
+];
+var SECTIONS = [
+  {
+    name: "section",
+    category: "block",
+    args: [{ kind: "string", name: "title" }],
+    summary: "A top-level resume section.",
+    example: "\\section{Experience}",
+    build: ({ args, utils }) => ({
+      type: "section",
+      title: utils.textOf(args[0]).trim(),
+      level: 1
+    })
+  },
+  {
+    name: "subsection",
+    category: "block",
+    args: [{ kind: "string", name: "title" }],
+    summary: "A second-level section heading.",
+    example: "\\subsection{Open Source}",
+    build: ({ args, utils }) => ({
+      type: "section",
+      title: utils.textOf(args[0]).trim(),
+      level: 2
+    })
+  }
+];
+var CONTACT_FIELDS = [
+  { cmd: "name", field: "name", summary: "Your full name (document header)." },
+  { cmd: "title", field: "title", summary: "Professional headline / role." },
+  { cmd: "email", field: "email", summary: "Contact email (rendered as a mailto link)." },
+  { cmd: "phone", field: "phone", summary: "Contact phone number." },
+  { cmd: "location", field: "location", summary: "City / location." },
+  { cmd: "website", field: "website", summary: "Personal website (rendered as a link)." }
+];
+var CONTACT = CONTACT_FIELDS.map(({ cmd, field, summary }) => ({
+  name: cmd,
+  category: "meta",
+  args: [{ kind: "string", name: cmd }],
+  summary,
+  example: `\\${cmd}{...}`,
+  build: ({ args, utils }) => ({ type: "contact", field, value: utils.textOf(args[0]).trim() })
+}));
+var zero = { offset: 0, line: 1, column: 1 };
+var ZERO_RANGE = { start: zero, end: zero };
+var requireFields = (report, fields, required, range2) => {
+  for (const key of required) {
+    if (!fields[key]) {
+      report({
+        severity: "warning" /* Warning */,
+        code: "RTX3004" /* MissingRequiredField */,
+        message: `Missing recommended field "${key}".`,
+        range: range2
+      });
+    }
+  }
+};
+var ENTRIES = [
+  {
+    name: "job",
+    category: "block",
+    args: [
+      { kind: "keyval", name: "fields" },
+      { kind: "content", name: "body", optional: true }
+    ],
+    summary: "A work-experience entry.",
+    example: "\\job{title=Senior Engineer, company=OpenAI, start=2023, end=Present}{Built AI systems}",
+    build: ({ args, report }) => {
+      const fields = parseKeyValArg(args[0]?.raw ?? "");
+      const r = args[0]?.range ?? ZERO_RANGE;
+      requireFields(report, fields, ["title", "company"], r);
+      return { type: "job", fields, children: args[1]?.children ?? [] };
+    }
+  },
+  {
+    name: "education",
+    category: "block",
+    args: [
+      { kind: "keyval", name: "fields" },
+      { kind: "content", name: "body", optional: true }
+    ],
+    summary: "An education entry.",
+    example: "\\education{school=MIT, degree=BS Computer Science, start=2018, end=2022}",
+    build: ({ args, report }) => {
+      const fields = parseKeyValArg(args[0]?.raw ?? "");
+      const r = args[0]?.range ?? ZERO_RANGE;
+      requireFields(report, fields, ["school", "degree"], r);
+      return { type: "education", fields, children: args[1]?.children ?? [] };
+    }
+  },
+  {
+    name: "project",
+    category: "block",
+    args: [
+      { kind: "keyval", name: "fields" },
+      { kind: "content", name: "body", optional: true }
+    ],
+    summary: "A project entry.",
+    example: "\\project{name=ReTeX, url=https://github.com/you/retex}{A resume engine}",
+    build: ({ args, report }) => {
+      const fields = parseKeyValArg(args[0]?.raw ?? "");
+      const r = args[0]?.range ?? ZERO_RANGE;
+      requireFields(report, fields, ["name"], r);
+      return { type: "project", fields, children: args[1]?.children ?? [] };
+    }
+  },
+  {
+    name: "skills",
+    category: "block",
+    args: [{ kind: "list", name: "skills" }],
+    summary: "A comma-separated list of skills.",
+    example: "\\skills{JavaScript, TypeScript, React, Node.js, AWS}",
+    build: ({ args }) => ({ type: "skills", items: parseListArg(args[0]?.raw ?? "") })
+  }
+];
+var ICONS2 = [
+  {
+    name: "icon",
+    category: "inline",
+    args: [{ kind: "string", name: "name" }],
+    summary: "Inline SVG icon (github, linkedin, email, phone, \u2026).",
+    example: "\\icon{github}",
+    build: ({ args, utils, report }) => {
+      const name = utils.textOf(args[0]).trim().toLowerCase();
+      if (name && !hasIcon(name)) {
+        report({
+          severity: "info" /* Info */,
+          code: "RTX4002" /* UnknownIcon */,
+          message: `Unknown icon "${name}".`,
+          range: args[0]?.range ?? ZERO_RANGE
+        });
+      }
+      return { type: "icon", name };
+    }
+  }
+];
+var PRIMITIVES = [
+  {
+    name: "newline",
+    category: "inline",
+    summary: "An explicit line break.",
+    build: () => ({ type: "linebreak" })
+  },
+  {
+    name: "linebreak",
+    category: "inline",
+    summary: "An explicit line break.",
+    build: () => ({ type: "linebreak" })
+  },
+  {
+    name: "hrule",
+    category: "block",
+    summary: "A horizontal rule / divider.",
+    build: () => ({ type: "rule" })
+  },
+  {
+    name: "divider",
+    category: "block",
+    summary: "A horizontal rule / divider.",
+    build: () => ({ type: "rule" })
+  },
+  {
+    name: "vspace",
+    category: "block",
+    args: [{ kind: "string", name: "size", format: "dimension" }],
+    summary: "Vertical space.",
+    example: "\\vspace{1em}",
+    build: ({ args, utils }) => ({
+      type: "space",
+      axis: "vertical",
+      size: utils.textOf(args[0]).trim() || "1em"
+    })
+  },
+  {
+    name: "hspace",
+    category: "inline",
+    args: [{ kind: "string", name: "size", format: "dimension" }],
+    summary: "Horizontal space.",
+    example: "\\hspace{1em}",
+    build: ({ args, utils }) => ({
+      type: "space",
+      axis: "horizontal",
+      size: utils.textOf(args[0]).trim() || "1em"
+    })
+  },
+  // `\item` and `\column` are consumed by their environments; they are
+  // registered so they are recognized (and so the validator can flag misuse
+  // outside the right environment) but have no standalone builder.
+  {
+    name: "item",
+    category: "block",
+    summary: "A list item (inside itemize/enumerate).",
+    example: "\\item Built distributed systems"
+  },
+  {
+    name: "column",
+    category: "block",
+    args: [{ kind: "string", name: "width", format: "dimension" }],
+    summary: "A column (inside the columns environment).",
+    example: "\\column{40%}"
+  }
+];
+var ENVIRONMENTS = [
+  {
+    name: "itemize",
+    itemCommand: "item",
+    allowedChildren: ["item"],
+    summary: "A bulleted list.",
+    example: "\\begin{itemize}\n  \\item ...\n\\end{itemize}",
+    build: ({ entries }) => ({
+      type: "list",
+      kind: "itemize",
+      items: (entries ?? []).map(
+        (e) => ({ type: "item", children: e.content })
+      )
+    })
+  },
+  {
+    name: "enumerate",
+    itemCommand: "item",
+    allowedChildren: ["item"],
+    summary: "A numbered list.",
+    example: "\\begin{enumerate}\n  \\item ...\n\\end{enumerate}",
+    build: ({ entries }) => ({
+      type: "list",
+      kind: "enumerate",
+      items: (entries ?? []).map(
+        (e) => ({ type: "item", children: e.content })
+      )
+    })
+  },
+  {
+    name: "columns",
+    itemCommand: "column",
+    allowedChildren: ["column"],
+    summary: "A multi-column layout.",
+    example: "\\begin{columns}\n  \\column{40%} Left\n  \\column{60%} Right\n\\end{columns}",
+    build: ({ entries, utils }) => ({
+      type: "columns",
+      columns: (entries ?? []).map((e) => {
+        const width = utils.textOf(e.marker.args[0]).trim() || "auto";
+        return { type: "column", width, children: e.content };
+      })
+    })
+  },
+  {
+    name: "center",
+    summary: "Center-align the contained block content.",
+    example: "\\begin{center} ... \\end{center}",
+    build: ({ body }) => ({
+      type: "command",
+      name: "center",
+      args: [{ kind: "required", children: body }]
+    })
+  }
+];
+function createDefaultRegistry() {
+  const registry = new CommandRegistry();
+  for (const def of [
+    ...TYPOGRAPHY,
+    ...LINKS,
+    ...SECTIONS,
+    ...CONTACT,
+    ...ENTRIES,
+    ...ICONS2,
+    ...PRIMITIVES
+  ]) {
+    registry.registerCommand(def);
+  }
+  for (const env of ENVIRONMENTS) registry.registerEnvironment(env);
+  return registry;
+}
+
+// src/ast/walk.ts
+function childrenOf(node) {
+  if (node.type === "list") return node.items;
+  if (node.type === "columns") return node.columns;
+  if (isParent(node)) return node.children;
+  return [];
+}
+function walk(root, opts) {
+  const visit = (node, parent) => {
+    const descend = opts.enter ? opts.enter(node, parent) : void 0;
+    if (descend !== false) {
+      for (const child of childrenOf(node)) visit(child, node);
+    }
+    opts.exit?.(node, parent);
+  };
+  visit(root, null);
+}
+function collect(root, pred) {
+  const out = [];
+  walk(root, {
+    enter(n) {
+      if (pred(n)) out.push(n);
+    }
+  });
+  return out;
+}
+function nodePathAt(root, offset) {
+  const path = [];
+  const visit = (node) => {
+    const r = node.range;
+    if (r && (offset < r.start.offset || offset > r.end.offset)) return false;
+    path.push(node);
+    for (const child of childrenOf(node)) {
+      if (visit(child)) break;
+    }
+    return true;
+  };
+  visit(root);
+  return path;
+}
+
+// src/ast/text.ts
+function flattenText(input) {
+  const nodes = Array.isArray(input) ? input : [input];
+  let out = "";
+  for (const node of nodes) {
+    switch (node.type) {
+      case "text":
+        out += node.value;
+        break;
+      case "linebreak":
+        out += " ";
+        break;
+      case "parbreak":
+        out += "\n\n";
+        break;
+      case "url":
+        out += node.href;
+        break;
+      case "icon":
+        out += "";
+        break;
+      default:
+        out += flattenText(childrenOf(node));
+    }
+  }
+  return out;
+}
+function normalizeWhitespace(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+
+// src/parser/suggest.ts
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}
+function closestMatch(name, candidates) {
+  let best;
+  let bestDist = Infinity;
+  const threshold = Math.max(2, Math.floor(name.length / 3) + 1);
+  for (const c of candidates) {
+    const d = levenshtein(name.toLowerCase(), c.toLowerCase());
+    if (d < bestDist) {
+      bestDist = d;
+      best = c;
+    }
+  }
+  return best !== void 0 && bestDist <= threshold ? best : void 0;
+}
+
+// src/parser/parser.ts
+var ZERO = { offset: 0, line: 1, column: 1 };
+var ZERO_RANGE2 = { start: ZERO, end: ZERO };
+var Parser = class _Parser {
+  constructor(tokens, options = {}) {
+    this.diagnostics = [];
+    this.pos = 0;
+    this.depth = 0;
+    this.reportedMaxDepth = false;
+    /** Range of the command currently being built, for builder diagnostics. */
+    this.currentRange = ZERO_RANGE2;
+    this.tokens = tokens;
+    this.registry = options.registry ?? createDefaultRegistry();
+    this.maxDepth = options.maxDepth ?? 300;
+    this.utils = {
+      textOf: (arg) => {
+        if (!arg) return "";
+        if (arg.raw !== void 0) return arg.raw;
+        return flattenText(arg.children);
+      },
+      safeUrl: (url) => {
+        const res = sanitizeUrl(url);
+        if (res.blocked) {
+          this.report({
+            severity: "warning" /* Warning */,
+            code: "RTX5001" /* UnsafeUrlBlocked */,
+            message: `Blocked unsafe URL with "${res.scheme ?? "unknown"}" scheme.`,
+            range: this.currentRange
+          });
+        }
+        return res.safe;
+      }
+    };
+  }
+  static parse(tokens, options) {
+    return new _Parser(tokens, options).parse();
+  }
+  parse() {
+    const start = this.peek().range.start;
+    const children = this.parseContent(() => this.at("EOF" /* EOF */));
+    const ast = {
+      type: "document",
+      children,
+      range: { start, end: this.previousEnd() }
+    };
+    return { ast, diagnostics: this.diagnostics };
+  }
+  /* --------------------------- content loop --------------------------- */
+  parseContent(stop) {
+    if (++this.depth > this.maxDepth) {
+      this.depth--;
+      return this.skipFlat(stop);
+    }
+    try {
+      return this.parseContentInner(stop);
+    } finally {
+      this.depth--;
+    }
+  }
+  parseContentInner(stop) {
+    const nodes = [];
+    while (!this.at("EOF" /* EOF */) && !stop()) {
+      const tok = this.peek();
+      if (tok.type === "Command" /* Command */) {
+        const def = this.registry.getCommand(tok.value);
+        if (def?.scoped) {
+          const built = this.parseScopedSwitch(def, stop);
+          if (Array.isArray(built)) nodes.push(...built);
+          else nodes.push(built);
+          break;
+        }
+      }
+      const node = this.parseNode();
+      if (Array.isArray(node)) nodes.push(...node);
+      else if (node) nodes.push(node);
+    }
+    return nodes;
+  }
+  parseNode() {
+    const tok = this.peek();
+    switch (tok.type) {
+      case "Command" /* Command */:
+        return this.parseCommandApplication();
+      case "LBrace" /* LBrace */:
+        return this.parseGroup();
+      case "RBrace" /* RBrace */:
+        this.advance();
+        this.report({
+          severity: "warning" /* Warning */,
+          code: "RTX1005" /* MismatchedBrace */,
+          message: "Unexpected '}' with no matching '{'.",
+          range: tok.range
+        });
+        return null;
+      case "Text" /* Text */:
+        this.advance();
+        return { type: "text", value: tok.value, range: tok.range };
+      case "Whitespace" /* Whitespace */:
+        this.advance();
+        return { type: "text", value: " ", range: tok.range };
+      case "ParBreak" /* ParBreak */:
+        this.advance();
+        return { type: "parbreak", range: tok.range };
+      case "LineBreak" /* LineBreak */:
+        this.advance();
+        return { type: "linebreak", range: tok.range };
+      case "LBracket" /* LBracket */:
+        this.advance();
+        return { type: "text", value: "[", range: tok.range };
+      case "RBracket" /* RBracket */:
+        this.advance();
+        return { type: "text", value: "]", range: tok.range };
+      case "Comment" /* Comment */:
+      default:
+        this.advance();
+        return null;
+    }
+  }
+  parseGroup() {
+    const open = this.advance();
+    const children = this.parseContent(() => this.at("RBrace" /* RBrace */));
+    const end = this.consumeClose(
+      "RBrace" /* RBrace */,
+      open,
+      "RTX1002" /* UnterminatedGroup */
+    );
+    return { type: "group", children, range: { start: open.range.start, end } };
+  }
+  /* --------------------------- commands ------------------------------- */
+  parseScopedSwitch(def, stop) {
+    const start = this.advance();
+    const args = this.parseArgs(def.args ?? []);
+    const scope = this.parseContent(stop);
+    return this.buildCommand(def, args, scope, start);
+  }
+  parseCommandApplication() {
+    const start = this.advance();
+    const name = start.value;
+    if (name === "begin") return this.parseEnvironment(start);
+    if (name === "end") {
+      this.skipInlineTrivia();
+      const got = this.tryReadGroupRaw();
+      this.report({
+        severity: "error" /* Error */,
+        code: "RTX2006" /* MismatchedEnvironment */,
+        message: got ? `\\end{${got}} has no matching \\begin{${got}}.` : "\\end has no matching \\begin.",
+        range: { start: start.range.start, end: this.previousEnd() }
+      });
+      return null;
+    }
+    const def = this.registry.getCommand(name);
+    if (!def) {
+      const args2 = this.parseGreedyArgs();
+      const range2 = { start: start.range.start, end: this.previousEnd() };
+      const suggestion = closestMatch(name, this.registry.commandNames());
+      this.report({
+        severity: "warning" /* Warning */,
+        code: "RTX2001" /* UnknownCommand */,
+        message: suggestion ? `Unknown command "\\${name}". Did you mean "\\${suggestion}"?` : `Unknown command "\\${name}".`,
+        range: range2,
+        ...suggestion ? {
+          fixes: [
+            {
+              title: `Replace with \\${suggestion}`,
+              replacement: `\\${suggestion}`,
+              range: start.range
+            }
+          ]
+        } : {}
+      });
+      return { type: "command", name, args: args2, range: range2 };
+    }
+    const args = this.parseArgs(def.args ?? []);
+    return this.buildCommand(def, args, [], start);
+  }
+  buildCommand(def, args, scope, start) {
+    const range2 = { start: start.range.start, end: this.previousEnd() };
+    this.currentRange = range2;
+    const built = def.build ? def.build({
+      name: def.name,
+      args,
+      scope,
+      report: (d) => this.report(d),
+      utils: this.utils
+    }) : null;
+    if (built == null) {
+      return { type: "command", name: def.name, args, range: range2 };
+    }
+    if (Array.isArray(built)) {
+      for (const n of built) if (!n.range) n.range = range2;
+      return built;
+    }
+    if (!built.range) built.range = range2;
+    return built;
+  }
+  /* --------------------------- arguments ------------------------------ */
+  parseArgs(specs) {
+    const args = [];
+    for (const spec of specs) {
+      const arg = this.parseArg(spec);
+      if (arg) {
+        args.push(arg);
+      } else if (!spec.optional) {
+        this.report({
+          severity: "error" /* Error */,
+          code: "RTX2003" /* MissingRequiredArgument */,
+          message: `Missing required argument${spec.name ? ` "${spec.name}"` : ""}.`,
+          range: { start: this.previousEnd(), end: this.previousEnd() }
+        });
+        args.push({ kind: "required", children: [], raw: "", range: ZERO_RANGE2 });
+      }
+    }
+    return args;
+  }
+  parseArg(spec) {
+    this.skipInlineTrivia();
+    const bracket = spec.delimiter === "bracket";
+    const open = bracket ? "LBracket" /* LBracket */ : "LBrace" /* LBrace */;
+    const close = bracket ? "RBracket" /* RBracket */ : "RBrace" /* RBrace */;
+    if (!this.at(open)) return null;
+    const openTok = this.advance();
+    const kind = spec.optional ? "optional" : "required";
+    if (spec.kind === "content") {
+      const children = this.parseContent(() => this.at(close));
+      const end2 = this.consumeClose(close, openTok, "RTX1003" /* UnterminatedArgument */);
+      return { kind, children, range: { start: openTok.range.start, end: end2 } };
+    }
+    const raw = this.readRawUntil(close);
+    const end = this.consumeClose(close, openTok, "RTX1003" /* UnterminatedArgument */);
+    return { kind, children: [], raw, range: { start: openTok.range.start, end } };
+  }
+  parseGreedyArgs() {
+    const args = [];
+    for (; ; ) {
+      this.skipInlineTrivia();
+      if (!this.at("LBrace" /* LBrace */)) break;
+      const openTok = this.advance();
+      const children = this.parseContent(() => this.at("RBrace" /* RBrace */));
+      const end = this.consumeClose(
+        "RBrace" /* RBrace */,
+        openTok,
+        "RTX1003" /* UnterminatedArgument */
+      );
+      args.push({
+        kind: "required",
+        children,
+        range: { start: openTok.range.start, end }
+      });
+    }
+    return args;
+  }
+  /** Concatenate the raw source of tokens until the matching close at depth 0. */
+  readRawUntil(close) {
+    let raw = "";
+    let depth = 0;
+    while (!this.at("EOF" /* EOF */)) {
+      const t = this.peek();
+      if (depth === 0 && t.type === close) break;
+      if (t.type === "LBrace" /* LBrace */ || t.type === "LBracket" /* LBracket */) {
+        depth++;
+      } else if (t.type === "RBrace" /* RBrace */ || t.type === "RBracket" /* RBracket */) {
+        if (depth === 0) break;
+        depth--;
+      }
+      raw += t.type === "Command" /* Command */ ? `\\${t.value}` : t.value;
+      this.advance();
+    }
+    return raw;
+  }
+  /* -------------------------- environments ---------------------------- */
+  parseEnvironment(beginTok) {
+    const name = this.readGroupName();
+    const options = [];
+    let opt;
+    while (opt = this.parseArg({ kind: "string", optional: true, delimiter: "bracket" })) {
+      options.push(opt);
+    }
+    const def = this.registry.getEnvironment(name);
+    if (!def) {
+      const body2 = this.parseEnvBody(name);
+      const range3 = { start: beginTok.range.start, end: this.previousEnd() };
+      const suggestion = closestMatch(name, this.registry.environmentNames());
+      this.report({
+        severity: "warning" /* Warning */,
+        code: "RTX2002" /* UnknownEnvironment */,
+        message: suggestion ? `Unknown environment "${name}". Did you mean "${suggestion}"?` : `Unknown environment "${name}".`,
+        range: range3
+      });
+      return { type: "group", children: body2, range: range3 };
+    }
+    let body;
+    let entries;
+    if (def.itemCommand) {
+      entries = this.parseEnvEntries(name, def.itemCommand);
+      body = entries.flatMap((e) => e.content);
+    } else {
+      body = this.parseEnvBody(name);
+    }
+    const range2 = { start: beginTok.range.start, end: this.previousEnd() };
+    this.currentRange = range2;
+    const node = def.build ? def.build({
+      name,
+      body,
+      entries,
+      options,
+      report: (d) => this.report(d),
+      utils: this.utils
+    }) : null;
+    if (node == null) {
+      return { type: "group", children: body, range: range2 };
+    }
+    if (Array.isArray(node)) {
+      for (const n of node) if (!n.range) n.range = range2;
+      return node;
+    }
+    if (!node.range) node.range = range2;
+    return node;
+  }
+  parseEnvBody(name) {
+    const body = this.parseContent(() => this.atCommand("end"));
+    this.consumeEnd(name);
+    return body;
+  }
+  parseEnvEntries(name, itemCommand) {
+    const entries = [];
+    const stop = () => this.atCommand(itemCommand) || this.atCommand("end");
+    this.skipTrivia();
+    if (!stop() && !this.at("EOF" /* EOF */)) {
+      const stray = this.parseContent(stop);
+      if (stray.some((n) => n.type !== "text" || n.value.trim() !== "")) {
+        this.report({
+          severity: "warning" /* Warning */,
+          code: "RTX4001" /* CommandOutsideContext */,
+          message: `Content before the first \\${itemCommand} in "${name}" was ignored.`,
+          range: stray[0]?.range ?? this.currentRange
+        });
+      }
+    }
+    while (this.atCommand(itemCommand)) {
+      const markerTok = this.advance();
+      const def = this.registry.getCommand(itemCommand);
+      const margs = this.parseArgs(def?.args ?? []);
+      const marker = {
+        type: "command",
+        name: itemCommand,
+        args: margs,
+        range: { start: markerTok.range.start, end: this.previousEnd() }
+      };
+      const content = this.parseContent(stop);
+      entries.push({ marker, content });
+    }
+    this.consumeEnd(name);
+    return entries;
+  }
+  consumeEnd(name) {
+    if (!this.atCommand("end")) {
+      this.report({
+        severity: "error" /* Error */,
+        code: "RTX2005" /* MissingEnvironmentEnd */,
+        message: `Missing \\end{${name}}.`,
+        range: { start: this.previousEnd(), end: this.previousEnd() }
+      });
+      return;
+    }
+    const endTok = this.advance();
+    const got = this.readGroupName();
+    if (got !== name) {
+      this.report({
+        severity: "error" /* Error */,
+        code: "RTX2006" /* MismatchedEnvironment */,
+        message: `Expected \\end{${name}} but found \\end{${got}}.`,
+        range: { start: endTok.range.start, end: this.previousEnd() }
+      });
+    }
+  }
+  /** Read a `{name}` group's raw contents, reporting if it is missing. */
+  readGroupName() {
+    this.skipInlineTrivia();
+    if (!this.at("LBrace" /* LBrace */)) {
+      this.report({
+        severity: "error" /* Error */,
+        code: "RTX2003" /* MissingRequiredArgument */,
+        message: "Expected '{name}'.",
+        range: { start: this.previousEnd(), end: this.previousEnd() }
+      });
+      return "";
+    }
+    const open = this.advance();
+    const raw = this.readRawUntil("RBrace" /* RBrace */);
+    this.consumeClose("RBrace" /* RBrace */, open, "RTX1003" /* UnterminatedArgument */);
+    return raw.trim();
+  }
+  /** Like {@link readGroupName} but returns "" silently when absent. */
+  tryReadGroupRaw() {
+    this.skipInlineTrivia();
+    if (!this.at("LBrace" /* LBrace */)) return "";
+    const open = this.advance();
+    const raw = this.readRawUntil("RBrace" /* RBrace */);
+    this.consumeClose("RBrace" /* RBrace */, open, "RTX1003" /* UnterminatedArgument */);
+    return raw.trim();
+  }
+  /**
+   * Recursion-limit fallback: consume the current scope's tokens flatly
+   * (tracking nested braces) without descending, so adversarial deep nesting
+   * cannot overflow the stack. Emits one diagnostic per parse.
+   */
+  skipFlat(stop) {
+    if (!this.reportedMaxDepth) {
+      this.reportedMaxDepth = true;
+      this.report({
+        severity: "warning" /* Warning */,
+        code: "RTX1001" /* UnexpectedToken */,
+        message: `Maximum nesting depth (${this.maxDepth}) exceeded; deeply nested content was skipped.`,
+        range: this.peek().range
+      });
+    }
+    let bdepth = 0;
+    while (!this.at("EOF" /* EOF */)) {
+      if (bdepth === 0 && stop()) break;
+      const t = this.peek();
+      if (t.type === "LBrace" /* LBrace */ || t.type === "LBracket" /* LBracket */) bdepth++;
+      else if (t.type === "RBrace" /* RBrace */ || t.type === "RBracket" /* RBracket */) {
+        if (bdepth === 0) break;
+        bdepth--;
+      }
+      this.advance();
+    }
+    return [];
+  }
+  /* ----------------------------- cursor ------------------------------- */
+  consumeClose(close, open, code) {
+    if (this.at(close)) {
+      const end = this.peek().range.end;
+      this.advance();
+      return end;
+    }
+    this.report({
+      severity: "error" /* Error */,
+      code,
+      message: `Unterminated "${open.value}" \u2014 expected a matching close.`,
+      range: open.range
+    });
+    return this.previousEnd();
+  }
+  at(type) {
+    return this.peek().type === type;
+  }
+  atCommand(name) {
+    const t = this.peek();
+    return t.type === "Command" /* Command */ && t.value === name;
+  }
+  skipInlineTrivia() {
+    while (this.at("Whitespace" /* Whitespace */) || this.at("Comment" /* Comment */)) {
+      this.advance();
+    }
+  }
+  skipTrivia() {
+    while (this.at("Whitespace" /* Whitespace */) || this.at("Comment" /* Comment */) || this.at("ParBreak" /* ParBreak */)) {
+      this.advance();
+    }
+  }
+  peek(k = 0) {
+    return this.tokens[this.pos + k] ?? this.tokens[this.tokens.length - 1];
+  }
+  advance() {
+    const t = this.peek();
+    if (this.pos < this.tokens.length - 1) this.pos++;
+    return t;
+  }
+  previousEnd() {
+    return this.tokens[this.pos - 1]?.range.end ?? this.peek().range.start;
+  }
+  report(d) {
+    this.diagnostics.push({ ...d, source: "parser" });
+  }
+};
+function parse(tokens, options) {
+  return Parser.parse(tokens, options);
+}
+
+// src/validator/validator.ts
+var ZERO_RANGE3 = {
+  start: { offset: 0, line: 1, column: 1 },
+  end: { offset: 0, line: 1, column: 1 }
+};
+function validate(ast, options = {}) {
+  const diagnostics = [];
+  const report = (d) => {
+    diagnostics.push({ ...d, source: "validator" });
+  };
+  walk(ast, {
+    enter(node) {
+      switch (node.type) {
+        case "command":
+          checkStrayCommand(node, report);
+          break;
+        case "section":
+          if (node.title.trim() === "") {
+            report({
+              severity: "warning" /* Warning */,
+              code: "RTX3006" /* EmptyArgument */,
+              message: "Section heading is empty.",
+              range: node.range ?? ZERO_RANGE3
+            });
+          }
+          break;
+        case "contact":
+          if (node.value.trim() === "") {
+            report({
+              severity: "warning" /* Warning */,
+              code: "RTX3006" /* EmptyArgument */,
+              message: `\\${node.field} is empty.`,
+              range: node.range ?? ZERO_RANGE3
+            });
+          }
+          break;
+        case "themecolor":
+          if (options.theme && !(node.token in options.theme.colors)) {
+            report({
+              severity: "warning" /* Warning */,
+              code: "RTX4003" /* UnknownThemeColor */,
+              message: `Theme color "${node.token}" is not defined in theme "${options.theme.name}".`,
+              range: node.range ?? ZERO_RANGE3
+            });
+          }
+          break;
+        case "skills":
+          if (node.items.length === 0) {
+            report({
+              severity: "info" /* Info */,
+              code: "RTX3006" /* EmptyArgument */,
+              message: "\\skills has no entries.",
+              range: node.range ?? ZERO_RANGE3
+            });
+          }
+          break;
+      }
+    }
+  });
+  return diagnostics;
+}
+function checkStrayCommand(node, report) {
+  if (node.name === "item") {
+    report({
+      severity: "error" /* Error */,
+      code: "RTX4001" /* CommandOutsideContext */,
+      message: "\\item must appear inside an itemize or enumerate environment.",
+      range: node.range ?? ZERO_RANGE3
+    });
+  } else if (node.name === "column") {
+    report({
+      severity: "error" /* Error */,
+      code: "RTX4001" /* CommandOutsideContext */,
+      message: "\\column must appear inside a columns environment.",
+      range: node.range ?? ZERO_RANGE3
+    });
+  }
+}
+
+// src/theme/default.ts
+var defaultTheme = {
+  name: "default",
+  colors: {
+    primary: "#2563eb",
+    secondary: "#64748b",
+    text: "#1e293b",
+    muted: "#64748b",
+    background: "#ffffff",
+    border: "#e2e8f0",
+    accent: "#2563eb",
+    success: "#16a34a"
+  },
+  fonts: {
+    heading: '"Inter", "Helvetica Neue", Helvetica, Arial, sans-serif',
+    body: '"Inter", "Helvetica Neue", Helvetica, Arial, sans-serif',
+    mono: '"JetBrains Mono", "SF Mono", "Fira Code", Consolas, monospace'
+  },
+  fontSizes: {
+    base: "10.5pt",
+    small: "9pt",
+    large: "12pt",
+    Large: "15pt",
+    Huge: "22pt",
+    name: "26pt",
+    section: "13pt"
+  },
+  spacing: {
+    unit: "4px",
+    section: "1.1rem",
+    item: "0.28rem",
+    page: "0.55in"
+  },
+  page: {
+    size: "Letter",
+    margin: "0.55in",
+    maxWidth: "8.5in"
+  },
+  sectionStyle: "rule"
+};
+
+// src/theme/themes.ts
+function resolveTheme(partial, base = defaultTheme) {
+  if (!partial) return base;
+  return {
+    name: partial.name ?? base.name,
+    colors: { ...base.colors, ...partial.colors },
+    fonts: { ...base.fonts, ...partial.fonts },
+    fontSizes: { ...base.fontSizes, ...partial.fontSizes },
+    spacing: { ...base.spacing, ...partial.spacing },
+    page: { ...base.page, ...partial.page },
+    sectionStyle: partial.sectionStyle ?? base.sectionStyle
+  };
+}
+var modernTheme = resolveTheme({
+  name: "modern",
+  colors: { primary: "#7c3aed", accent: "#7c3aed", text: "#111827" },
+  sectionStyle: "underline"
+});
+var classicTheme = resolveTheme({
+  name: "classic",
+  colors: { primary: "#111827", secondary: "#4b5563", accent: "#111827" },
+  fonts: {
+    heading: 'Georgia, "Times New Roman", serif',
+    body: 'Georgia, "Times New Roman", serif',
+    mono: 'Consolas, "Courier New", monospace'
+  },
+  sectionStyle: "rule"
+});
+var compactTheme = resolveTheme({
+  name: "compact",
+  fontSizes: {
+    base: "9.5pt",
+    small: "8pt",
+    large: "11pt",
+    Large: "13pt",
+    Huge: "18pt",
+    name: "20pt",
+    section: "11pt"
+  },
+  spacing: { unit: "3px", section: "0.7rem", item: "0.18rem", page: "0.4in" },
+  sectionStyle: "bar"
+});
+var themes = {
+  default: defaultTheme,
+  modern: modernTheme,
+  classic: classicTheme,
+  compact: compactTheme
+};
+function getTheme(name) {
+  return themes[name] ?? defaultTheme;
+}
+
+// src/renderers/css.ts
+var tokenSafe = (s) => s.replace(/[^a-zA-Z0-9_-]/g, "");
+function themeToCss(theme, prefix = "retex") {
+  const p = prefix;
+  const colorVars = Object.entries(theme.colors).map(([k, v]) => `    --${p}-color-${tokenSafe(k)}: ${v};`).join("\n");
+  return `.${p}-resume {
+${colorVars}
+    --${p}-primary: ${theme.colors.primary};
+    --${p}-text: ${theme.colors.text};
+    --${p}-muted: ${theme.colors.muted};
+    --${p}-border: ${theme.colors.border};
+    --${p}-bg: ${theme.colors.background};
+    --${p}-font-heading: ${theme.fonts.heading};
+    --${p}-font-body: ${theme.fonts.body};
+    --${p}-font-mono: ${theme.fonts.mono};
+    --${p}-fs-base: ${theme.fontSizes.base};
+    --${p}-fs-small: ${theme.fontSizes.small};
+    --${p}-fs-large: ${theme.fontSizes.large};
+    --${p}-fs-Large: ${theme.fontSizes.Large};
+    --${p}-fs-Huge: ${theme.fontSizes.Huge};
+    --${p}-fs-name: ${theme.fontSizes.name};
+    --${p}-fs-section: ${theme.fontSizes.section};
+    --${p}-sp-section: ${theme.spacing.section};
+    --${p}-sp-item: ${theme.spacing.item};
+
+    box-sizing: border-box;
+    max-width: ${theme.page.maxWidth};
+    margin: 0 auto;
+    padding: ${theme.spacing.page};
+    background: var(--${p}-bg);
+    color: var(--${p}-text);
+    font-family: var(--${p}-font-body);
+    font-size: var(--${p}-fs-base);
+    line-height: 1.45;
+}
+.${p}-resume *, .${p}-resume *::before, .${p}-resume *::after { box-sizing: border-box; }
+
+.${p}-header { margin-bottom: var(--${p}-sp-section); }
+.${p}-name {
+    font-family: var(--${p}-font-heading);
+    font-size: var(--${p}-fs-name);
+    font-weight: 700;
+    margin: 0 0 0.1em;
+    color: var(--${p}-text);
+    letter-spacing: -0.01em;
+}
+.${p}-title {
+    font-size: var(--${p}-fs-large);
+    color: var(--${p}-primary);
+    margin: 0 0 0.45em;
+    font-weight: 500;
+}
+.${p}-contact {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.35rem 1rem;
+    font-size: var(--${p}-fs-small);
+    color: var(--${p}-muted);
+}
+.${p}-contact-item {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.3em;
+    color: inherit;
+    text-decoration: none;
+}
+.${p}-contact-item svg { opacity: 0.8; }
+
+.${p}-section { margin-bottom: var(--${p}-sp-section); break-inside: avoid; }
+.${p}-section-title {
+    font-family: var(--${p}-font-heading);
+    font-size: var(--${p}-fs-section);
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    color: var(--${p}-primary);
+    margin: 0 0 0.5em;
+}
+.${p}-section--rule .${p}-section-title { border-bottom: 2px solid var(--${p}-border); padding-bottom: 0.2em; }
+.${p}-section--underline .${p}-section-title { text-decoration: underline; text-underline-offset: 3px; }
+.${p}-section--bar .${p}-section-title {
+    border-left: 3px solid var(--${p}-primary);
+    padding-left: 0.5em;
+    border-bottom: none;
+}
+.${p}-subsection-title {
+    font-family: var(--${p}-font-heading);
+    font-size: var(--${p}-fs-large);
+    font-weight: 600;
+    margin: 0.6em 0 0.3em;
+}
+
+.${p}-entry { margin-bottom: 0.6rem; break-inside: avoid; }
+.${p}-entry-row {
+    display: flex;
+    justify-content: space-between;
+    align-items: baseline;
+    gap: 1rem;
+}
+.${p}-entry-title { font-weight: 700; }
+.${p}-entry-subtitle { color: var(--${p}-primary); font-weight: 500; }
+.${p}-entry-dates, .${p}-entry-location {
+    color: var(--${p}-muted);
+    font-size: var(--${p}-fs-small);
+    white-space: nowrap;
+}
+.${p}-entry-body { margin-top: 0.15rem; }
+.${p}-entry-body p { margin: 0.2em 0; }
+
+.${p}-list { margin: 0.2rem 0 0.2rem 1.1rem; padding: 0; }
+.${p}-list li { margin-bottom: var(--${p}-sp-item); padding-left: 0.15rem; }
+
+.${p}-columns { display: flex; gap: 1.5rem; align-items: flex-start; }
+.${p}-column { min-width: 0; }
+
+.${p}-skills { display: flex; flex-wrap: wrap; gap: 0.4rem; list-style: none; margin: 0.2rem 0; padding: 0; }
+.${p}-skill {
+    background: color-mix(in srgb, var(--${p}-primary) 12%, transparent);
+    color: var(--${p}-primary);
+    border-radius: 4px;
+    padding: 0.12rem 0.5rem;
+    font-size: var(--${p}-fs-small);
+    font-weight: 500;
+    white-space: nowrap;
+}
+
+.${p}-link { color: var(--${p}-primary); text-decoration: none; }
+.${p}-link:hover { text-decoration: underline; }
+.${p}-icon { display: inline-flex; vertical-align: -0.125em; }
+.${p}-rule { border: none; border-top: 1px solid var(--${p}-border); margin: 0.6rem 0; }
+.${p}-center { text-align: center; }
+.${p}-scale-small { font-size: var(--${p}-fs-small); }
+.${p}-scale-large { font-size: var(--${p}-fs-large); }
+.${p}-scale-Large { font-size: var(--${p}-fs-Large); }
+.${p}-scale-Huge { font-size: var(--${p}-fs-Huge); }
+p.${p}-para { margin: 0 0 0.45em; }
+p.${p}-para:last-child { margin-bottom: 0; }
+
+@media print {
+    .${p}-resume { max-width: none; margin: 0; padding: 0; }
+    .${p}-section, .${p}-entry { break-inside: avoid; }
+    a { color: inherit; }
+}`;
+}
+
+// src/renderers/context.ts
+var BLOCK_TYPES = /* @__PURE__ */ new Set([
+  "section",
+  "job",
+  "education",
+  "project",
+  "skills",
+  "list",
+  "columns",
+  "rule"
+]);
+function isBlockNode(node) {
+  if (BLOCK_TYPES.has(node.type)) return true;
+  if (node.type === "space") return node.axis === "vertical";
+  if (node.type === "command" && node.name === "center") return true;
+  return false;
+}
+
+// src/renderers/structure.ts
+function toRegions(children) {
+  const regions = [{ nodes: [] }];
+  for (const node of children) {
+    if (node.type === "section" && node.level === 1) {
+      regions.push({ section: node, nodes: [] });
+    } else {
+      regions[regions.length - 1].nodes.push(node);
+    }
+  }
+  return regions;
+}
+var CONTACTISH = /* @__PURE__ */ new Set(["contact", "icon", "link", "url"]);
+function splitPreamble(nodes) {
+  const name = nodes.find(
+    (n) => n.type === "contact" && n.field === "name"
+  );
+  const title = nodes.find(
+    (n) => n.type === "contact" && n.field === "title"
+  );
+  const contacts = nodes.filter(
+    (n) => CONTACTISH.has(n.type) && n !== name && n !== title
+  );
+  const other = nodes.filter(
+    (n) => !CONTACTISH.has(n.type) && n.type !== "parbreak" && !(n.type === "text" && n.value.trim() === "")
+  );
+  return { name, title, contacts, other };
+}
+function entryParts(fields, kind) {
+  let title;
+  let subtitle;
+  if (kind === "education") {
+    title = fields.school ?? fields.degree ?? "";
+    subtitle = fields.school ? fields.degree ?? "" : "";
+  } else if (kind === "project") {
+    title = fields.name ?? fields.title ?? "";
+    subtitle = fields.organization ?? fields.tech ?? "";
+  } else {
+    title = fields.title ?? fields.role ?? fields.name ?? "";
+    subtitle = fields.company ?? fields.organization ?? "";
+  }
+  return {
+    title,
+    subtitle,
+    dates: dateRange(fields.start, fields.end, fields.date),
+    location: fields.location ?? "",
+    url: fields.url ?? fields.link ?? ""
+  };
+}
+function dateRange(start, end, date) {
+  if (date) return date;
+  if (start && end) return `${start} \u2013 ${end}`;
+  return start ?? end ?? "";
+}
+
+// src/renderers/html.ts
+var tokenSafe2 = (s) => s.replace(/[^a-zA-Z0-9_-]/g, "");
+var HtmlRenderer = class {
+  constructor(options = {}) {
+    this.theme = options.theme ?? resolveTheme();
+    this.prefix = options.classPrefix ?? "retex";
+    this.overrides = options.overrides ?? /* @__PURE__ */ new Map();
+    this.useHeader = options.header ?? true;
+    this.ctx = {
+      theme: this.theme,
+      classPrefix: this.prefix,
+      overrides: this.overrides,
+      renderNodes: (nodes) => this.renderFlow(nodes),
+      cls: (name) => this.cls(name)
+    };
+  }
+  /** Render the resume body as an HTML fragment (no `<html>`/`<style>`). */
+  render(ast) {
+    const regions = toRegions(ast.children);
+    const parts = [];
+    const preamble = regions[0]?.section ? void 0 : regions.shift();
+    if (preamble) parts.push(this.renderPreamble(preamble.nodes));
+    for (const region of regions) {
+      if (region.section) parts.push(this.renderSection(region.section, region.nodes));
+      else parts.push(this.renderFlow(region.nodes));
+    }
+    return `<div class="${this.cls("resume")}">
+${parts.filter(Boolean).join("\n")}
+</div>`;
+  }
+  /** Render a complete, standalone HTML document including the stylesheet. */
+  renderDocument(ast, title = "Resume") {
+    return [
+      "<!DOCTYPE html>",
+      '<html lang="en">',
+      "<head>",
+      '<meta charset="utf-8">',
+      '<meta name="viewport" content="width=device-width, initial-scale=1">',
+      `<title>${escapeHtml(title)}</title>`,
+      `<style>
+${this.styles()}
+</style>`,
+      "</head>",
+      "<body>",
+      this.render(ast),
+      "</body>",
+      "</html>"
+    ].join("\n");
+  }
+  /** The stylesheet for the active theme (without `<style>` tags). */
+  styles() {
+    return themeToCss(this.theme, this.prefix);
+  }
+  /* --------------------------- structuring ---------------------------- */
+  renderSection(section, body) {
+    const styleMod = ` ${this.cls("section")}--${this.theme.sectionStyle}`;
+    return `<section class="${this.cls("section")}${styleMod}"><h2 class="${this.cls("section-title")}">${escapeHtml(section.title)}</h2><div class="${this.cls("section-body")}">${this.renderFlow(body)}</div></section>`;
+  }
+  renderPreamble(nodes) {
+    if (!this.useHeader) return this.renderFlow(nodes);
+    const { name, title, contacts, other } = splitPreamble(nodes);
+    const hasHeader = name || title || contacts.length > 0;
+    let html = "";
+    if (hasHeader) {
+      html += `<header class="${this.cls("header")}">`;
+      if (name) html += `<h1 class="${this.cls("name")}">${escapeHtml(name.value)}</h1>`;
+      if (title) html += `<p class="${this.cls("title")}">${escapeHtml(title.value)}</p>`;
+      if (contacts.length > 0) {
+        html += `<div class="${this.cls("contact")}">${contacts.map((c) => this.renderContactItem(c)).join("")}</div>`;
+      }
+      html += `</header>`;
+    }
+    if (other.length > 0) html += this.renderFlow(other);
+    return html;
+  }
+  renderContactItem(node) {
+    const item = this.cls("contact-item");
+    if (node.type === "contact") {
+      switch (node.field) {
+        case "email":
+          return this.contactLink(`mailto:${node.value}`, "email", node.value, item);
+        case "phone":
+          return this.contactLink(
+            `tel:${node.value.replace(/[^\d+]/g, "")}`,
+            "phone",
+            node.value,
+            item
+          );
+        case "website":
+          return this.contactLink(node.value, "website", node.value, item);
+        case "location":
+          return `<span class="${item}">${this.icon("location")}${escapeHtml(node.value)}</span>`;
+        default:
+          return `<span class="${item}">${escapeHtml(node.value)}</span>`;
+      }
+    }
+    if (node.type === "icon")
+      return `<span class="${item}">${this.renderNode(node)}</span>`;
+    if (node.type === "link" || node.type === "url") {
+      return `<span class="${item}">${this.renderNode(node)}</span>`;
+    }
+    return this.renderNode(node);
+  }
+  contactLink(url, icon, label, cls) {
+    const { safe } = sanitizeUrl(url);
+    return `<a class="${cls}" href="${escapeAttribute(safe)}">${this.icon(icon)}${escapeHtml(label)}</a>`;
+  }
+  /* ----------------------------- flow / inline ------------------------ */
+  /** Block-aware rendering: groups inline runs into `<p>`, renders blocks as-is. */
+  renderFlow(nodes) {
+    const out = [];
+    let inline = [];
+    const flush = () => {
+      const html = this.renderInline(inline).trim();
+      if (html) out.push(`<p class="${this.cls("para")}">${html}</p>`);
+      inline = [];
+    };
+    for (const node of nodes) {
+      if (node.type === "parbreak") {
+        flush();
+      } else if (isBlockNode(node)) {
+        flush();
+        out.push(this.renderNode(node));
+      } else {
+        inline.push(node);
+      }
+    }
+    flush();
+    return out.join("\n");
+  }
+  renderInline(nodes) {
+    return nodes.map((n) => this.renderNode(n)).join("");
+  }
+  /* ------------------------------ per node ---------------------------- */
+  renderNode(node) {
+    const override = this.overrides.get(node.type) ?? (node.type === "command" ? this.overrides.get(`command:${node.name}`) : void 0);
+    if (override) return override(node, this.ctx, (ns) => this.renderFlow(ns));
+    switch (node.type) {
+      case "text":
+        return escapeHtml(node.value);
+      case "parbreak":
+        return "";
+      case "linebreak":
+        return "<br>";
+      case "rule":
+        return `<hr class="${this.cls("rule")}">`;
+      case "space":
+        return node.axis === "vertical" ? `<div style="height:${this.dim(node.size)}"></div>` : `<span style="display:inline-block;width:${this.dim(node.size)}"></span>`;
+      case "group":
+        return this.renderInline(node.children);
+      case "bold":
+        return `<strong>${this.renderInline(node.children)}</strong>`;
+      case "italic":
+        return `<em>${this.renderInline(node.children)}</em>`;
+      case "underline":
+        return `<u>${this.renderInline(node.children)}</u>`;
+      case "strike":
+        return `<s>${this.renderInline(node.children)}</s>`;
+      case "color": {
+        const inner = this.renderInline(node.children);
+        if (!node.color || !isSafeColor(node.color)) return inner;
+        return `<span style="color:${node.color}">${inner}</span>`;
+      }
+      case "themecolor": {
+        const inner = this.renderInline(node.children);
+        const tok = tokenSafe2(node.token);
+        return `<span style="color:var(--${this.prefix}-color-${tok}, currentColor)">${inner}</span>`;
+      }
+      case "fontsize": {
+        const inner = this.renderInline(node.children);
+        if (!isSafeDimension(node.size)) return inner;
+        return `<span style="font-size:${node.size}">${inner}</span>`;
+      }
+      case "fontfamily": {
+        const inner = this.renderInline(node.children);
+        const family = node.family === "monospace" ? `var(--${this.prefix}-font-mono)` : sanitizeStyleValue(node.family);
+        if (!family) return inner;
+        return `<span style="font-family:${family}">${inner}</span>`;
+      }
+      case "fontscale": {
+        const inner = this.renderInline(node.children);
+        if (node.scale === "normal") return `<span>${inner}</span>`;
+        return `<span class="${this.cls(`scale-${node.scale}`)}">${inner}</span>`;
+      }
+      case "link":
+        return this.renderLink(node.href, this.renderInline(node.children));
+      case "url":
+        return this.renderLink(node.href, escapeHtml(node.rawHref));
+      case "icon":
+        return this.icon(node.name);
+      case "section":
+        return `<h${node.level + 1} class="${this.cls("subsection-title")}">${escapeHtml(node.title)}</h${node.level + 1}>`;
+      case "list":
+        return this.renderList(node);
+      case "columns":
+        return this.renderColumns(node);
+      case "skills":
+        return this.renderSkills(node.items);
+      case "job":
+        return this.renderEntry(node.fields, node.children, "job");
+      case "education":
+        return this.renderEntry(node.fields, node.children, "education");
+      case "project":
+        return this.renderEntry(node.fields, node.children, "project");
+      case "contact":
+        return this.renderContactItem(node);
+      case "command":
+        return this.renderCommand(node);
+      case "error":
+        return "";
+      default:
+        return "";
+    }
+  }
+  renderLink(href, label) {
+    const { safe } = sanitizeUrl(href);
+    const external = /^https?:/i.test(safe);
+    const rel = external ? ' target="_blank" rel="noopener noreferrer"' : "";
+    return `<a class="${this.cls("link")}" href="${escapeAttribute(safe)}"${rel}>${label}</a>`;
+  }
+  renderList(node) {
+    const tag = node.kind === "enumerate" ? "ol" : "ul";
+    const items = node.items.map((item) => `<li>${this.renderInline(item.children).trim()}</li>`).join("");
+    return `<${tag} class="${this.cls("list")}">${items}</${tag}>`;
+  }
+  renderColumns(node) {
+    const cols = node.columns.map((col) => {
+      const basis = isSafeDimension(col.width) ? col.width : "auto";
+      const flex = basis === "auto" ? "flex:1 1 0" : `flex:0 0 ${basis}`;
+      return `<div class="${this.cls("column")}" style="${flex}">${this.renderFlow(col.children)}</div>`;
+    }).join("");
+    return `<div class="${this.cls("columns")}">${cols}</div>`;
+  }
+  renderSkills(items) {
+    const lis = items.map((s) => `<li class="${this.cls("skill")}">${escapeHtml(s)}</li>`).join("");
+    return `<ul class="${this.cls("skills")}">${lis}</ul>`;
+  }
+  renderEntry(fields, body, kind) {
+    const { title, subtitle, dates, location, url } = entryParts(fields, kind);
+    const titleHtml = url ? this.renderLink(sanitizeUrl(url).safe, escapeHtml(title)) : escapeHtml(title);
+    let html = `<div class="${this.cls("entry")} ${this.cls(kind)}">`;
+    html += `<div class="${this.cls("entry-row")}">`;
+    html += `<span class="${this.cls("entry-title")}">${titleHtml}</span>`;
+    if (dates)
+      html += `<span class="${this.cls("entry-dates")}">${escapeHtml(dates)}</span>`;
+    html += `</div>`;
+    if (subtitle || location) {
+      html += `<div class="${this.cls("entry-row")}">`;
+      html += `<span class="${this.cls("entry-subtitle")}">${escapeHtml(subtitle)}</span>`;
+      if (location)
+        html += `<span class="${this.cls("entry-location")}">${escapeHtml(location)}</span>`;
+      html += `</div>`;
+    }
+    if (body.length > 0) {
+      html += `<div class="${this.cls("entry-body")}">${this.renderFlow(body)}</div>`;
+    }
+    html += `</div>`;
+    return html;
+  }
+  renderCommand(node) {
+    if (node.name === "center") {
+      const inner2 = node.args.flatMap((a) => a.children);
+      return `<div class="${this.cls("center")}">${this.renderFlow(inner2)}</div>`;
+    }
+    const inner = node.args.flatMap((a) => a.children);
+    return inner.length > 0 ? this.renderInline(inner) : "";
+  }
+  /* ------------------------------ helpers ----------------------------- */
+  icon(name) {
+    const svg = iconToSvg(name, { className: this.cls("icon") });
+    if (svg) return svg;
+    return `<span class="${this.cls("icon")}" title="${escapeAttribute(name)}"></span>`;
+  }
+  dim(value) {
+    return isSafeDimension(value) ? value : "0";
+  }
+  cls(name) {
+    return `${this.prefix}-${name}`;
+  }
+};
+function renderHtml(ast, options) {
+  return new HtmlRenderer(options).render(ast);
+}
+function renderHtmlDocument(ast, options) {
+  return new HtmlRenderer(options).renderDocument(ast, options?.title);
+}
+
+// src/renderers/json.ts
+function toJsonTree(ast, opts = {}) {
+  const strip = opts.stripMeta ?? false;
+  const clone = (value) => {
+    if (Array.isArray(value)) return value.map(clone);
+    if (value && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        if (strip && (k === "range" || k === "hash")) continue;
+        out[k] = clone(v);
+      }
+      return out;
+    }
+    return value;
+  };
+  return clone(ast);
+}
+function renderJson(ast, opts = {}) {
+  return JSON.stringify(toJsonTree(ast, opts), null, opts.indent ?? 2);
+}
+
+// src/renderers/pdf.ts
+function pageCss(theme) {
+  return `@page { size: ${theme.page.size}; margin: ${theme.page.margin}; }
+html, body { margin: 0; padding: 0; background: #fff; }
+@media screen { body { background: #f1f5f9; padding: 24px; } .retex-resume { box-shadow: 0 1px 8px rgba(0,0,0,.12); } }`;
+}
+function renderPrintHtml(ast, options = {}) {
+  const theme = options.theme ?? resolveTheme();
+  const renderer = new HtmlRenderer({ ...options, theme });
+  const body = renderer.render(ast);
+  const title = options.title ?? "Resume";
+  return [
+    "<!DOCTYPE html>",
+    '<html lang="en">',
+    "<head>",
+    '<meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1">',
+    `<title>${title.replace(/[<>&]/g, "")}</title>`,
+    `<style>
+${renderer.styles()}
+${pageCss(theme)}
+</style>`,
+    "</head>",
+    "<body>",
+    body,
+    "</body>",
+    "</html>"
+  ].join("\n");
+}
+async function renderPdf(ast, options = {}) {
+  const html = renderPrintHtml(ast, options);
+  const theme = options.theme ?? resolveTheme();
+  const launch = options.launch ?? await defaultLauncher();
+  const browser = await launch();
+  try {
+    const page = await browser.newPage();
+    await page.setContent(html, { waitUntil: "networkidle0" });
+    return await page.pdf({
+      printBackground: options.printBackground ?? true,
+      preferCSSPageSize: true,
+      format: theme.page.size,
+      margin: {
+        top: theme.page.margin,
+        bottom: theme.page.margin,
+        left: theme.page.margin,
+        right: theme.page.margin
+      }
+    });
+  } finally {
+    await browser.close();
+  }
+}
+async function defaultLauncher() {
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      'puppeteer'
+    );
+    return () => mod.launch({ headless: true });
+  } catch {
+    throw new Error(
+      "PDF export requires a headless browser. Either install `puppeteer` (`npm i -D puppeteer`) or pass `options.launch` with your own Playwright/Chromium launcher. Alternatively, use `renderPrintHtml()` and print to PDF in the browser via `window.print()`."
+    );
+  }
+}
+
+// src/renderers/react.ts
+var tokenSafe3 = (s) => s.replace(/[^a-zA-Z0-9_-]/g, "");
+var ReactRenderer = class {
+  constructor(options) {
+    this.key = 0;
+    if (typeof options.createElement !== "function") {
+      throw new TypeError(
+        "ReactRenderer requires a `createElement` factory (e.g. React.createElement)."
+      );
+    }
+    this.theme = options.theme ?? resolveTheme();
+    this.prefix = options.classPrefix ?? "retex";
+    this.h = options.createElement;
+    this.Fragment = options.Fragment ?? "div";
+    this.overrides = options.overrides ?? /* @__PURE__ */ new Map();
+    this.useHeader = options.header ?? true;
+  }
+  /** The stylesheet for the active theme. Render it in a `<style>` yourself. */
+  styles() {
+    return themeToCss(this.theme, this.prefix);
+  }
+  /** Render the document AST to a React element. */
+  render(ast) {
+    const regions = toRegions(ast.children);
+    const parts = [];
+    const preamble = regions[0]?.section ? void 0 : regions.shift();
+    if (preamble) parts.push(...this.renderPreamble(preamble.nodes));
+    for (const region of regions) {
+      if (region.section) parts.push(this.renderSection(region.section, region.nodes));
+      else parts.push(...this.renderFlow(region.nodes));
+    }
+    return this.el("div", { className: this.cls("resume") }, parts);
+  }
+  ctx() {
+    return {
+      theme: this.theme,
+      classPrefix: this.prefix,
+      h: this.h,
+      Fragment: this.Fragment,
+      overrides: this.overrides,
+      renderNodes: (nodes) => this.renderFlow(nodes),
+      cls: (name) => this.cls(name)
+    };
+  }
+  /* --------------------------- structuring ---------------------------- */
+  renderSection(section, body) {
+    return this.el(
+      "section",
+      {
+        className: `${this.cls("section")} ${this.cls("section")}--${this.theme.sectionStyle}`
+      },
+      [
+        this.el("h2", { className: this.cls("section-title") }, [section.title]),
+        this.el("div", { className: this.cls("section-body") }, this.renderFlow(body))
+      ]
+    );
+  }
+  renderPreamble(nodes) {
+    if (!this.useHeader) return this.renderFlow(nodes);
+    const { name, title, contacts, other } = splitPreamble(nodes);
+    const out = [];
+    if (name || title || contacts.length > 0) {
+      const head = [];
+      if (name) head.push(this.el("h1", { className: this.cls("name") }, [name.value]));
+      if (title) head.push(this.el("p", { className: this.cls("title") }, [title.value]));
+      if (contacts.length > 0) {
+        head.push(
+          this.el(
+            "div",
+            { className: this.cls("contact") },
+            contacts.map((c) => this.renderNode(c))
+          )
+        );
+      }
+      out.push(this.el("header", { className: this.cls("header") }, head));
+    }
+    if (other.length > 0) out.push(...this.renderFlow(other));
+    return out;
+  }
+  /* ----------------------------- flow / inline ------------------------ */
+  renderFlow(nodes) {
+    const out = [];
+    let inline = [];
+    const flush = () => {
+      if (inline.length === 0) return;
+      const meaningful = inline.some((n) => n.type !== "text" || n.value.trim() !== "");
+      if (meaningful) {
+        out.push(
+          this.el("p", { className: this.cls("para") }, this.renderInline(inline))
+        );
+      }
+      inline = [];
+    };
+    for (const node of nodes) {
+      if (node.type === "parbreak") flush();
+      else if (isBlockNode(node)) {
+        flush();
+        out.push(this.renderNode(node));
+      } else inline.push(node);
+    }
+    flush();
+    return out;
+  }
+  renderInline(nodes) {
+    return nodes.map((n) => this.renderNode(n));
+  }
+  /* ------------------------------ per node ---------------------------- */
+  renderNode(node) {
+    const override = this.overrides.get(node.type) ?? (node.type === "command" ? this.overrides.get(`command:${node.name}`) : void 0);
+    if (override) return override(node, this.ctx(), (ns) => this.renderFlow(ns));
+    switch (node.type) {
+      case "text":
+        return node.value;
+      case "parbreak":
+        return null;
+      case "linebreak":
+        return this.el("br", null, []);
+      case "rule":
+        return this.el("hr", { className: this.cls("rule") }, []);
+      case "space":
+        return node.axis === "vertical" ? this.el("div", { style: { height: this.dim(node.size) } }, []) : this.el(
+          "span",
+          { style: { display: "inline-block", width: this.dim(node.size) } },
+          []
+        );
+      case "group":
+        return this.frag(this.renderInline(node.children));
+      case "bold":
+        return this.el("strong", null, this.renderInline(node.children));
+      case "italic":
+        return this.el("em", null, this.renderInline(node.children));
+      case "underline":
+        return this.el("u", null, this.renderInline(node.children));
+      case "strike":
+        return this.el("s", null, this.renderInline(node.children));
+      case "color": {
+        const inner = this.renderInline(node.children);
+        if (!node.color || !isSafeColor(node.color)) return this.frag(inner);
+        return this.el("span", { style: { color: node.color } }, inner);
+      }
+      case "themecolor":
+        return this.el(
+          "span",
+          {
+            style: {
+              color: `var(--${this.prefix}-color-${tokenSafe3(node.token)}, currentColor)`
+            }
+          },
+          this.renderInline(node.children)
+        );
+      case "fontsize": {
+        const inner = this.renderInline(node.children);
+        if (!isSafeDimension(node.size)) return this.frag(inner);
+        return this.el("span", { style: { fontSize: node.size } }, inner);
+      }
+      case "fontfamily": {
+        const inner = this.renderInline(node.children);
+        const family = node.family === "monospace" ? `var(--${this.prefix}-font-mono)` : sanitizeStyleValue(node.family);
+        if (!family) return this.frag(inner);
+        return this.el("span", { style: { fontFamily: family } }, inner);
+      }
+      case "fontscale":
+        return node.scale === "normal" ? this.frag(this.renderInline(node.children)) : this.el(
+          "span",
+          { className: this.cls(`scale-${node.scale}`) },
+          this.renderInline(node.children)
+        );
+      case "link":
+        return this.renderLink(node.href, this.renderInline(node.children));
+      case "url":
+        return this.renderLink(node.href, [node.rawHref]);
+      case "icon":
+        return this.renderIcon(node.name);
+      case "section":
+        return this.el(
+          `h${node.level + 1}`,
+          { className: this.cls("subsection-title") },
+          [node.title]
+        );
+      case "list":
+        return this.renderList(node);
+      case "columns":
+        return this.renderColumns(node);
+      case "skills":
+        return this.el(
+          "ul",
+          { className: this.cls("skills") },
+          node.items.map((s) => this.el("li", { className: this.cls("skill") }, [s]))
+        );
+      case "job":
+        return this.renderEntry(node, "job");
+      case "education":
+        return this.renderEntry(node, "education");
+      case "project":
+        return this.renderEntry(node, "project");
+      case "contact":
+        return this.renderContact(node);
+      case "command":
+        return this.renderCommand(node);
+      default:
+        return null;
+    }
+  }
+  renderContact(node) {
+    const item = this.cls("contact-item");
+    switch (node.field) {
+      case "email":
+        return this.contactLink(`mailto:${node.value}`, "email", node.value, item);
+      case "phone":
+        return this.contactLink(
+          `tel:${node.value.replace(/[^\d+]/g, "")}`,
+          "phone",
+          node.value,
+          item
+        );
+      case "website":
+        return this.contactLink(node.value, "website", node.value, item);
+      case "location":
+        return this.el("span", { className: item }, [
+          this.renderIcon("location"),
+          node.value
+        ]);
+      default:
+        return this.el("span", { className: item }, [node.value]);
+    }
+  }
+  contactLink(url, icon, label, cls) {
+    const { safe } = sanitizeUrl(url);
+    return this.el("a", { className: cls, href: safe }, [this.renderIcon(icon), label]);
+  }
+  renderLink(href, label) {
+    const { safe } = sanitizeUrl(href);
+    const external = /^https?:/i.test(safe);
+    const props = { className: this.cls("link"), href: safe };
+    if (external) {
+      props.target = "_blank";
+      props.rel = "noopener noreferrer";
+    }
+    return this.el("a", props, label);
+  }
+  renderList(node) {
+    const tag = node.kind === "enumerate" ? "ol" : "ul";
+    return this.el(
+      tag,
+      { className: this.cls("list") },
+      node.items.map((item) => this.el("li", null, this.renderInline(item.children)))
+    );
+  }
+  renderColumns(node) {
+    return this.el(
+      "div",
+      { className: this.cls("columns") },
+      node.columns.map((col) => {
+        const basis = isSafeDimension(col.width) ? col.width : "auto";
+        const style = basis === "auto" ? { flex: "1 1 0" } : { flex: `0 0 ${basis}` };
+        return this.el(
+          "div",
+          { className: this.cls("column"), style },
+          this.renderFlow(col.children)
+        );
+      })
+    );
+  }
+  renderEntry(node, kind) {
+    const { title, subtitle, dates, location, url } = entryParts(node.fields, kind);
+    const rows = [];
+    const titleEl = url ? this.renderLink(sanitizeUrl(url).safe, [title]) : title;
+    rows.push(
+      this.el("div", { className: this.cls("entry-row") }, [
+        this.el("span", { className: this.cls("entry-title") }, [titleEl]),
+        dates ? this.el("span", { className: this.cls("entry-dates") }, [dates]) : null
+      ])
+    );
+    if (subtitle || location) {
+      rows.push(
+        this.el("div", { className: this.cls("entry-row") }, [
+          this.el("span", { className: this.cls("entry-subtitle") }, [subtitle]),
+          location ? this.el("span", { className: this.cls("entry-location") }, [location]) : null
+        ])
+      );
+    }
+    if (node.children.length > 0) {
+      rows.push(
+        this.el(
+          "div",
+          { className: this.cls("entry-body") },
+          this.renderFlow(node.children)
+        )
+      );
+    }
+    return this.el("div", { className: `${this.cls("entry")} ${this.cls(kind)}` }, rows);
+  }
+  renderCommand(node) {
+    const inner = node.args.flatMap((a) => a.children);
+    if (node.name === "center") {
+      return this.el("div", { className: this.cls("center") }, this.renderFlow(inner));
+    }
+    return this.frag(this.renderInline(inner));
+  }
+  renderIcon(name) {
+    const svg = iconToSvg(name);
+    if (!svg) return this.el("span", { className: this.cls("icon"), title: name }, []);
+    return this.el(
+      "span",
+      {
+        className: this.cls("icon"),
+        dangerouslySetInnerHTML: { __html: svg }
+      },
+      []
+    );
+  }
+  /* ------------------------------ helpers ----------------------------- */
+  el(type, props, children) {
+    const filtered = children.filter((c) => c !== null && c !== void 0 && c !== "");
+    const finalProps = { ...props ?? {}, key: this.key++ };
+    return this.h(type, finalProps, ...filtered);
+  }
+  frag(children) {
+    return this.el(this.Fragment, null, children);
+  }
+  dim(value) {
+    return isSafeDimension(value) ? value : "0";
+  }
+  cls(name) {
+    return `${this.prefix}-${name}`;
+  }
+};
+function renderReact(ast, options) {
+  return new ReactRenderer(options).render(ast);
+}
+
+// src/engine.ts
+var isTheme = (t) => !!t && "colors" in t && "fonts" in t && "fontSizes" in t && "page" in t;
+var ReTeXEngine = class {
+  constructor(options = {}) {
+    this.htmlOverrides = /* @__PURE__ */ new Map();
+    this.reactOverrides = /* @__PURE__ */ new Map();
+    this.cache = /* @__PURE__ */ new Map();
+    this.generation = 0;
+    this.registry = createDefaultRegistry();
+    this.theme = isTheme(options.theme) ? options.theme : resolveTheme(options.theme);
+    this.prefix = options.classPrefix ?? "retex";
+    this.cacheSize = options.cacheSize ?? 64;
+    for (const plugin of options.plugins ?? []) this.use(plugin);
+  }
+  /* ----------------------------- plugins ------------------------------ */
+  use(plugin) {
+    for (const cmd of plugin.commands ?? []) this.registerCommand(cmd);
+    for (const env of plugin.environments ?? []) this.registerEnvironment(env);
+    for (const [name, def] of Object.entries(plugin.icons ?? {})) {
+      this.registerIcon(name, def);
+    }
+    for (const [key, fn] of Object.entries(plugin.htmlRenderers ?? {})) {
+      this.registerHtmlRenderer(key, fn);
+    }
+    for (const [key, fn] of Object.entries(plugin.reactRenderers ?? {})) {
+      this.registerReactRenderer(key, fn);
+    }
+    if (plugin.theme) this.setTheme(plugin.theme);
+    plugin.setup?.(this);
+    this.invalidate();
+    return this;
+  }
+  registerCommand(def) {
+    const { render, ...spec } = def;
+    this.registry.registerCommand(spec);
+    if (render?.html) this.htmlOverrides.set(`command:${def.name}`, render.html);
+    if (render?.react) this.reactOverrides.set(`command:${def.name}`, render.react);
+    this.invalidate();
+    return this;
+  }
+  registerEnvironment(def) {
+    this.registry.registerEnvironment(def);
+    this.invalidate();
+    return this;
+  }
+  registerHtmlRenderer(key, fn) {
+    this.htmlOverrides.set(key, fn);
+    return this;
+  }
+  registerReactRenderer(key, fn) {
+    this.reactOverrides.set(key, fn);
+    return this;
+  }
+  registerIcon(name, def) {
+    registerIcon(name, def);
+    return this;
+  }
+  /* ----------------------------- theming ------------------------------ */
+  setTheme(theme) {
+    this.theme = isTheme(theme) ? theme : resolveTheme(theme, this.theme);
+    this.invalidate();
+    return this;
+  }
+  getTheme() {
+    return this.theme;
+  }
+  getRegistry() {
+    return this.registry;
+  }
+  /* --------------------------- compilation ---------------------------- */
+  tokenize(source) {
+    return tokenize(source);
+  }
+  /** Tokenize, parse, and (by default) validate a source string. Cached. */
+  compile(source, options = {}) {
+    const runValidate = options.validate ?? true;
+    const key = `${this.generation}:${runValidate ? "v" : "p"}:${source}`;
+    const cached = this.cache.get(key);
+    if (cached) return cached;
+    const { tokens, diagnostics: lexDiags } = tokenize(source);
+    const { ast, diagnostics: parseDiags } = new Parser(tokens, {
+      registry: this.registry
+    }).parse();
+    const diagnostics = [...lexDiags, ...parseDiags];
+    if (runValidate) diagnostics.push(...validate(ast, { theme: this.theme }));
+    const result = { source, tokens, ast, diagnostics };
+    this.remember(key, result);
+    return result;
+  }
+  parse(source) {
+    return this.compile(source, { validate: false }).ast;
+  }
+  validate(input) {
+    if (typeof input === "string") return this.compile(input).diagnostics;
+    return validate(input, { theme: this.theme });
+  }
+  /* ----------------------------- renderers ---------------------------- */
+  toHtml(input, options = {}) {
+    return this.htmlRenderer(options).render(this.astOf(input));
+  }
+  toHtmlDocument(input, options = {}) {
+    return this.htmlRenderer(options).renderDocument(this.astOf(input), options.title);
+  }
+  toReact(input, options) {
+    return new ReactRenderer({
+      ...options,
+      theme: this.theme,
+      classPrefix: this.prefix,
+      overrides: this.reactOverrides
+    }).render(this.astOf(input));
+  }
+  toJson(input, options) {
+    return renderJson(this.astOf(input), options);
+  }
+  toPrintHtml(input, options = {}) {
+    return renderPrintHtml(this.astOf(input), this.printOptions(options));
+  }
+  toPdf(input, options = {}) {
+    return renderPdf(this.astOf(input), this.printOptions(options));
+  }
+  /** The CSS stylesheet for the active theme. */
+  styles() {
+    return this.htmlRenderer().styles();
+  }
+  /* ------------------------------ internals --------------------------- */
+  astOf(input) {
+    return typeof input === "string" ? this.compile(input, { validate: false }).ast : input;
+  }
+  htmlRenderer(options = {}) {
+    return new HtmlRenderer({
+      theme: this.theme,
+      classPrefix: this.prefix,
+      overrides: this.htmlOverrides,
+      ...options
+    });
+  }
+  printOptions(options) {
+    return {
+      theme: this.theme,
+      classPrefix: this.prefix,
+      overrides: this.htmlOverrides,
+      ...options
+    };
+  }
+  invalidate() {
+    this.generation++;
+    this.cache.clear();
+  }
+  remember(key, result) {
+    if (this.cache.size >= this.cacheSize) {
+      const oldest = this.cache.keys().next().value;
+      if (oldest !== void 0) this.cache.delete(oldest);
+    }
+    this.cache.set(key, result);
+  }
+};
+function createEngine(options) {
+  return new ReTeXEngine(options);
+}
+
+// src/plugin/examples.ts
+var badgePlugin = {
+  name: "badge",
+  commands: [
+    {
+      name: "badge",
+      category: "inline",
+      args: [{ kind: "content", name: "label" }],
+      summary: "A small inline badge / pill.",
+      example: "\\badge{New}",
+      render: {
+        html: (node, ctx, renderChildren) => {
+          const n = node;
+          const inner = renderChildren(n.args[0]?.children ?? []);
+          return `<span class="${ctx.cls("badge")}" style="display:inline-block;padding:0.05em 0.45em;border-radius:999px;font-size:0.8em;background:var(--${ctx.classPrefix}-primary);color:#fff;vertical-align:middle">${inner}</span>`;
+        },
+        react: (node, ctx, renderChildren) => {
+          const n = node;
+          return ctx.h(
+            "span",
+            {
+              className: ctx.cls("badge"),
+              style: {
+                display: "inline-block",
+                padding: "0.05em 0.45em",
+                borderRadius: "999px",
+                fontSize: "0.8em",
+                background: `var(--${ctx.classPrefix}-primary)`,
+                color: "#fff",
+                verticalAlign: "middle"
+              }
+            },
+            ...renderChildren(n.args[0]?.children ?? [])
+          );
+        }
+      }
+    }
+  ]
+};
+var ratingPlugin = {
+  name: "rating",
+  commands: [
+    {
+      name: "rating",
+      category: "inline",
+      args: [{ kind: "string", name: "score" }],
+      summary: "A 0\u20135 proficiency rating rendered as dots.",
+      example: "\\rating{4}",
+      render: {
+        html: (node, ctx) => {
+          const n = node;
+          const score = clamp(parseFloat(n.args[0]?.raw ?? "0"));
+          let dots = "";
+          for (let i = 1; i <= 5; i++) {
+            dots += `<span style="color:${i <= score ? `var(--${ctx.classPrefix}-primary)` : `var(--${ctx.classPrefix}-border)`}">\u25CF</span>`;
+          }
+          return `<span class="${ctx.cls("rating")}" aria-label="${score} out of 5">${dots}</span>`;
+        }
+      }
+    }
+  ]
+};
+function clamp(n) {
+  if (Number.isNaN(n)) return 0;
+  return Math.max(0, Math.min(5, Math.round(n)));
+}
+
+// src/editor/printer.ts
+function escapeText(value) {
+  return value.replace(/([{}\\])/g, "\\$1");
+}
+function fieldsToString(fields) {
+  return Object.entries(fields).map(([k, v]) => v === "" ? k : `${k}=${v}`).join(", ");
+}
+function printDocument(ast) {
+  return printBlocks(ast.children).trimEnd() + "\n";
+}
+function printBlocks(nodes) {
+  const out = [];
+  let inline = [];
+  const flush = () => {
+    const s = printInline(inline).trim();
+    if (s) out.push(s);
+    inline = [];
+  };
+  for (const node of nodes) {
+    if (node.type === "parbreak") {
+      flush();
+    } else if (isBlockNode(node) || node.type === "section" || node.type === "list" || node.type === "columns") {
+      flush();
+      out.push(printBlock(node));
+    } else {
+      inline.push(node);
+    }
+  }
+  flush();
+  return out.join("\n\n");
+}
+function printBlock(node, indent = "") {
+  switch (node.type) {
+    case "section":
+      return `${indent}\\${node.level === 2 ? "subsection" : "section"}{${node.title}}`;
+    case "list": {
+      const env = node.kind;
+      const items = node.items.map((it) => `${indent}  \\item ${printInline(it.children).trim()}`).join("\n");
+      return `${indent}\\begin{${env}}
+${items}
+${indent}\\end{${env}}`;
+    }
+    case "columns": {
+      const cols = node.columns.map(
+        (c) => `${indent}  \\column{${c.width}}
+${indentLines(printBlocks(c.children), indent + "  ")}`
+      ).join("\n");
+      return `${indent}\\begin{columns}
+${cols}
+${indent}\\end{columns}`;
+    }
+    case "job":
+    case "education":
+    case "project": {
+      const head = `${indent}\\${node.type}{${fieldsToString(node.fields)}}`;
+      if (node.children.length === 0) return head;
+      return `${head}{${printInline(node.children).trim()}}`;
+    }
+    case "skills":
+      return `${indent}\\skills{${node.items.join(", ")}}`;
+    case "rule":
+      return `${indent}\\hrule`;
+    case "space":
+      return `${indent}\\${node.axis === "vertical" ? "vspace" : "hspace"}{${node.size}}`;
+    case "command":
+      if (node.name === "center") {
+        const inner = node.args.flatMap((a) => a.children);
+        return `${indent}\\begin{center}
+${indentLines(printBlocks(inner), indent + "  ")}
+${indent}\\end{center}`;
+      }
+      return indent + printInline([node]);
+    default:
+      return indent + printInline([node]);
+  }
+}
+function printInline(nodes) {
+  return nodes.map(printNode).join("");
+}
+function printNode(node) {
+  switch (node.type) {
+    case "text":
+      return escapeText(node.value);
+    case "parbreak":
+      return "\n\n";
+    case "linebreak":
+      return "\\\\";
+    case "group":
+      return `{${printInline(node.children)}}`;
+    case "bold":
+      return `\\textbf{${printInline(node.children)}}`;
+    case "italic":
+      return `\\textit{${printInline(node.children)}}`;
+    case "underline":
+      return `\\underline{${printInline(node.children)}}`;
+    case "strike":
+      return `\\sout{${printInline(node.children)}}`;
+    case "color":
+      return `\\textcolor{${node.color}}{${printInline(node.children)}}`;
+    case "themecolor":
+      return `\\themecolor{${node.token}}{${printInline(node.children)}}`;
+    case "fontsize":
+      return `\\fontsize{${node.size}}{${printInline(node.children)}}`;
+    case "fontfamily":
+      return `\\fontfamily{${node.family}}{${printInline(node.children)}}`;
+    case "fontscale":
+      return `{\\${node.scale === "normal" ? "normalsize" : node.scale} ${printInline(node.children)}}`;
+    case "link":
+      return `\\href{${node.rawHref}}{${printInline(node.children)}}`;
+    case "url":
+      return `\\url{${node.rawHref}}`;
+    case "icon":
+      return `\\icon{${node.name}}`;
+    case "contact":
+      return `\\${node.field}{${node.value}}`;
+    case "space":
+      return `\\${node.axis === "vertical" ? "vspace" : "hspace"}{${node.size}}`;
+    case "command": {
+      const args = node.args.map((a) => a.raw !== void 0 ? `{${a.raw}}` : `{${printInline(a.children)}}`).join("");
+      return `\\${node.name}${args}`;
+    }
+    // Block nodes appearing in inline context fall back to block printing.
+    default:
+      return printBlock(node);
+  }
+}
+function indentLines(text, indent) {
+  return text.split("\n").map((line) => line ? indent + line : line).join("\n");
+}
+
+// src/editor/editor.ts
+var EditorService = class {
+  constructor(options = {}) {
+    this.registry = options.registry ?? createDefaultRegistry();
+    this.theme = options.theme;
+  }
+  /* ----------------------------- diagnostics -------------------------- */
+  getDiagnostics(source) {
+    const { tokens, diagnostics: lex } = tokenize(source);
+    const { ast, diagnostics: parse2 } = new Parser(tokens, {
+      registry: this.registry
+    }).parse();
+    return [...lex, ...parse2, ...validate(ast, this.theme ? { theme: this.theme } : {})];
+  }
+  /* ------------------------------ inspect ----------------------------- */
+  /** Parse and return the AST for inspection / debugging. */
+  inspect(source) {
+    const { tokens } = tokenize(source);
+    return new Parser(tokens, { registry: this.registry }).parse().ast;
+  }
+  /* ------------------------------ format ------------------------------ */
+  format(source) {
+    return printDocument(this.inspect(source));
+  }
+  /* --------------------------- completion ----------------------------- */
+  getCompletions(source, offset) {
+    const before = source.slice(0, offset);
+    const envMatch = /\\(begin|end)\{([a-zA-Z*]*)$/.exec(before);
+    if (envMatch) {
+      const prefix = envMatch[2];
+      const start = offset - prefix.length;
+      return this.registry.allEnvironments().filter((e) => e.name.startsWith(prefix)).map((e) => this.environmentCompletion(e, this.rangeAt(source, start, offset)));
+    }
+    const fieldKeys = this.fieldContext(before);
+    if (fieldKeys) {
+      return fieldKeys.map((key) => ({
+        label: key,
+        kind: "field",
+        detail: "entry field",
+        insertText: `${key}=`
+      }));
+    }
+    const cmdMatch = /\\([a-zA-Z*]*)$/.exec(before);
+    if (cmdMatch) {
+      const prefix = cmdMatch[1];
+      const start = offset - prefix.length - 1;
+      return this.registry.allCommands().filter((c) => c.name.startsWith(prefix)).sort((a, b) => a.name.localeCompare(b.name)).map((c) => this.commandCompletion(c, this.rangeAt(source, start, offset)));
+    }
+    return [];
+  }
+  commandCompletion(def, range2) {
+    const args = def.args ?? [];
+    const snippetArgs = args.map(
+      (a, i) => a.optional ? `[\${${i + 1}:${a.name ?? "opt"}}]` : `{\${${i + 1}:${a.name ?? "arg"}}}`
+    ).join("");
+    const plainArgs = args.map((a) => a.optional ? "[]" : "{}").join("");
+    return {
+      label: `\\${def.name}`,
+      kind: "command",
+      detail: def.summary,
+      documentation: this.commandDoc(def),
+      insertText: `${def.name}${plainArgs}`,
+      snippet: `${def.name}${snippetArgs}`,
+      range: range2
+    };
+  }
+  environmentCompletion(def, range2) {
+    return {
+      label: def.name,
+      kind: "environment",
+      detail: def.summary,
+      documentation: def.documentation ?? def.example,
+      insertText: `${def.name}}`,
+      snippet: `${def.name}}
+	$0
+\\end{${def.name}}`,
+      range: range2
+    };
+  }
+  /** Suggest field keys when the cursor is inside a `\job/\education/\project{…}`. */
+  fieldContext(before) {
+    const m = /\\(job|education|project)\{([^{}]*)$/.exec(before);
+    if (!m) return null;
+    switch (m[1]) {
+      case "job":
+        return ["title", "company", "location", "start", "end", "url"];
+      case "education":
+        return ["school", "degree", "location", "start", "end", "gpa"];
+      case "project":
+        return ["name", "url", "start", "end", "tech"];
+      default:
+        return null;
+    }
+  }
+  /* ------------------------------ hover ------------------------------- */
+  getHover(source, offset) {
+    const { tokens } = tokenize(source);
+    const idx = tokens.findIndex(
+      (t) => t.type === "Command" /* Command */ && offset >= t.range.start.offset && offset <= t.range.end.offset
+    );
+    if (idx === -1) return null;
+    const token = tokens[idx];
+    if (token.value === "begin" || token.value === "end") {
+      const name = this.readNameAfter(tokens, idx);
+      const env = name ? this.registry.getEnvironment(name) : void 0;
+      if (env) {
+        return {
+          contents: this.environmentDoc(env),
+          range: token.range
+        };
+      }
+      return null;
+    }
+    const def = this.registry.getCommand(token.value);
+    if (!def) {
+      return {
+        contents: `Unknown command \`\\${token.value}\``,
+        range: token.range
+      };
+    }
+    return { contents: this.commandDoc(def), range: token.range };
+  }
+  commandDoc(def) {
+    const sig = `\\${def.name}` + (def.args ?? []).map((a) => a.optional ? `[${a.name ?? "opt"}]` : `{${a.name ?? "arg"}}`).join("");
+    const lines = [`\`\`\`tex
+${sig}
+\`\`\``];
+    if (def.summary) lines.push(def.summary);
+    if (def.documentation) lines.push(def.documentation);
+    if (def.example) lines.push(`**Example:**
+\`\`\`tex
+${def.example}
+\`\`\``);
+    return lines.join("\n\n");
+  }
+  environmentDoc(def) {
+    const lines = [`\`\`\`tex
+\\begin{${def.name}} \u2026 \\end{${def.name}}
+\`\`\``];
+    if (def.summary) lines.push(def.summary);
+    if (def.example) lines.push(`**Example:**
+\`\`\`tex
+${def.example}
+\`\`\``);
+    return lines.join("\n\n");
+  }
+  /* ------------------------ semantic highlighting --------------------- */
+  getSemanticTokens(source) {
+    const { tokens } = tokenize(source);
+    const out = [];
+    for (let i = 0; i < tokens.length; i++) {
+      const t = tokens[i];
+      switch (t.type) {
+        case "Command" /* Command */: {
+          if (t.value === "begin" || t.value === "end") {
+            out.push({ range: t.range, type: "environment", modifiers: [] });
+            break;
+          }
+          const def = this.registry.getCommand(t.value);
+          out.push({
+            range: t.range,
+            type: def ? "command" : "command-unknown",
+            modifiers: def?.category ? [def.category] : []
+          });
+          break;
+        }
+        case "LBrace" /* LBrace */:
+        case "RBrace" /* RBrace */:
+          out.push({ range: t.range, type: "brace", modifiers: [] });
+          break;
+        case "LBracket" /* LBracket */:
+        case "RBracket" /* RBracket */:
+          out.push({ range: t.range, type: "bracket", modifiers: [] });
+          break;
+        case "Comment" /* Comment */:
+          out.push({ range: t.range, type: "comment", modifiers: [] });
+          break;
+        case "LineBreak" /* LineBreak */:
+          out.push({ range: t.range, type: "linebreak", modifiers: [] });
+          break;
+        case "Text" /* Text */:
+          out.push({ range: t.range, type: "text", modifiers: [] });
+          break;
+      }
+    }
+    return out;
+  }
+  /* ------------------------------ helpers ----------------------------- */
+  readNameAfter(tokens, idx) {
+    let j = idx + 1;
+    while (tokens[j] && tokens[j].type === "Whitespace" /* Whitespace */) j++;
+    if (!tokens[j] || tokens[j].type !== "LBrace" /* LBrace */) return void 0;
+    j++;
+    let name = "";
+    while (tokens[j] && tokens[j].type !== "RBrace" /* RBrace */) {
+      name += tokens[j].value;
+      j++;
+    }
+    return name.trim();
+  }
+  rangeAt(source, start, end) {
+    return {
+      start: this.positionAt(source, start),
+      end: this.positionAt(source, end)
+    };
+  }
+  positionAt(source, offset) {
+    let line = 1;
+    let column = 1;
+    for (let i = 0; i < offset && i < source.length; i++) {
+      if (source[i] === "\n") {
+        line++;
+        column = 1;
+      } else {
+        column++;
+      }
+    }
+    return { offset, line, column };
+  }
+};
+
+// src/incremental/incremental.ts
+var isLetter2 = (c) => c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+var IncrementalCompiler = class {
+  constructor(options = {}) {
+    /** Position-independent parse cache, keyed by exact block text. */
+    this.parseCache = /* @__PURE__ */ new Map();
+    /** Position-resolved cache, keyed by `offset:line:text` (already shifted). */
+    this.positioned = /* @__PURE__ */ new Map();
+    this.hits = 0;
+    this.misses = 0;
+    this.registry = options.registry ?? createDefaultRegistry();
+  }
+  /** Clear all caches (e.g. after registering new commands). */
+  reset() {
+    this.parseCache.clear();
+    this.positioned.clear();
+  }
+  compile(source) {
+    this.hits = 0;
+    this.misses = 0;
+    const segments = splitBalancedSegments(source);
+    const children = [];
+    const diagnostics = [];
+    let first = true;
+    const nextPositioned = /* @__PURE__ */ new Map();
+    for (const seg of segments) {
+      const text = source.slice(seg.start, seg.end);
+      if (text.trim() === "") continue;
+      const posKey = `${seg.start}:${seg.startLine}:${text}`;
+      let resolved = this.positioned.get(posKey);
+      if (resolved) {
+        this.hits++;
+      } else {
+        let parsed = this.parseCache.get(text);
+        if (parsed) {
+          this.hits++;
+        } else {
+          this.misses++;
+          const { tokens } = tokenize(text);
+          const { ast: ast2, diagnostics: d } = new Parser(tokens, {
+            registry: this.registry
+          }).parse();
+          parsed = { children: ast2.children, diagnostics: d };
+          this.parseCache.set(text, parsed);
+        }
+        const dOffset = seg.start;
+        const dLine = seg.startLine - 1;
+        resolved = {
+          children: parsed.children.map((n) => shiftClone(n, dOffset, dLine)),
+          diagnostics: parsed.diagnostics.map((d) => shiftClone(d, dOffset, dLine))
+        };
+      }
+      nextPositioned.set(posKey, resolved);
+      if (!first) children.push({ type: "parbreak" });
+      first = false;
+      for (const node of resolved.children) children.push(node);
+      for (const diag of resolved.diagnostics) diagnostics.push(diag);
+    }
+    this.positioned = nextPositioned;
+    const ast = {
+      type: "document",
+      children,
+      range: { start: { offset: 0, line: 1, column: 1 }, end: endPosition(source) }
+    };
+    return {
+      ast,
+      diagnostics,
+      stats: {
+        segments: segments.length,
+        cacheHits: this.hits,
+        cacheMisses: this.misses
+      }
+    };
+  }
+};
+function splitBalancedSegments(source) {
+  const raw = [];
+  const re = /\n([ \t]*\n)+/g;
+  let last = 0;
+  let m;
+  while (m = re.exec(source)) {
+    raw.push({ start: last, end: m.index });
+    last = m.index + m[0].length;
+  }
+  raw.push({ start: last, end: source.length });
+  const segments = [];
+  let buffer = null;
+  for (const part of raw) {
+    if (buffer === null) buffer = { start: part.start, end: part.end };
+    else buffer.end = part.end;
+    if (isBalanced(source.slice(buffer.start, buffer.end))) {
+      segments.push({ ...buffer, startLine: lineAt(source, buffer.start) });
+      buffer = null;
+    }
+  }
+  if (buffer !== null) {
+    segments.push({ ...buffer, startLine: lineAt(source, buffer.start) });
+  }
+  return segments;
+}
+function isBalanced(text) {
+  let depth = 0;
+  let env = 0;
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === "\\") {
+      i++;
+      if (isLetter2(text[i] ?? "")) {
+        let name = "";
+        while (isLetter2(text[i] ?? "")) name += text[i++];
+        if (name === "begin") env++;
+        else if (name === "end") env--;
+      } else {
+        i++;
+      }
+      continue;
+    }
+    if (c === "{" || c === "[") depth++;
+    else if (c === "}" || c === "]") depth--;
+    i++;
+  }
+  return depth === 0 && env === 0;
+}
+function shiftClone(value, dOffset, dLine) {
+  if (Array.isArray(value)) {
+    return value.map((v) => shiftClone(v, dOffset, dLine));
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    if ("offset" in obj && "line" in obj && "column" in obj) {
+      return {
+        offset: obj.offset + dOffset,
+        line: obj.line + dLine,
+        column: obj.column
+      };
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) out[k] = shiftClone(v, dOffset, dLine);
+    return out;
+  }
+  return value;
+}
+function lineAt(source, offset) {
+  let line = 1;
+  for (let i = 0; i < offset && i < source.length; i++) {
+    if (source[i] === "\n") line++;
+  }
+  return line;
+}
+function endPosition(source) {
+  let line = 1;
+  let column = 1;
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] === "\n") {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return { offset: source.length, line, column };
+}
+
+exports.BLOCK_TYPES = BLOCK_TYPES;
+exports.CommandRegistry = CommandRegistry;
+exports.DiagnosticCode = DiagnosticCode;
+exports.DiagnosticSeverity = DiagnosticSeverity;
+exports.EditorService = EditorService;
+exports.HtmlRenderer = HtmlRenderer;
+exports.IncrementalCompiler = IncrementalCompiler;
+exports.Parser = Parser;
+exports.ReTeXEngine = ReTeXEngine;
+exports.ReactRenderer = ReactRenderer;
+exports.SPECIAL_CHARS = SPECIAL_CHARS;
+exports.TokenType = TokenType;
+exports.Tokenizer = Tokenizer;
+exports.badgePlugin = badgePlugin;
+exports.childrenOf = childrenOf;
+exports.classicTheme = classicTheme;
+exports.closestMatch = closestMatch;
+exports.collect = collect;
+exports.compactTheme = compactTheme;
+exports.createDefaultRegistry = createDefaultRegistry;
+exports.createEngine = createEngine;
+exports.dateRange = dateRange;
+exports.defaultTheme = defaultTheme;
+exports.entryParts = entryParts;
+exports.escapeAttribute = escapeAttribute;
+exports.escapeHtml = escapeHtml;
+exports.flattenText = flattenText;
+exports.getIcon = getIcon;
+exports.getTheme = getTheme;
+exports.hasIcon = hasIcon;
+exports.iconNames = iconNames;
+exports.iconToSvg = iconToSvg;
+exports.isBalanced = isBalanced;
+exports.isBlockNode = isBlockNode;
+exports.isNode = isNode;
+exports.isParent = isParent;
+exports.isSafeColor = isSafeColor;
+exports.isSafeDimension = isSafeDimension;
+exports.levenshtein = levenshtein;
+exports.mergeRanges = mergeRanges;
+exports.modernTheme = modernTheme;
+exports.nodePathAt = nodePathAt;
+exports.normalizeWhitespace = normalizeWhitespace;
+exports.pageCss = pageCss;
+exports.parse = parse;
+exports.parseKeyValArg = parseKeyValArg;
+exports.parseListArg = parseListArg;
+exports.pos = pos;
+exports.printDocument = printDocument;
+exports.range = range;
+exports.rangeContains = rangeContains;
+exports.ratingPlugin = ratingPlugin;
+exports.registerIcon = registerIcon;
+exports.renderHtml = renderHtml;
+exports.renderHtmlDocument = renderHtmlDocument;
+exports.renderJson = renderJson;
+exports.renderPdf = renderPdf;
+exports.renderPrintHtml = renderPrintHtml;
+exports.renderReact = renderReact;
+exports.resolveIconName = resolveIconName;
+exports.resolveTheme = resolveTheme;
+exports.sanitizeStyleValue = sanitizeStyleValue;
+exports.sanitizeUrl = sanitizeUrl;
+exports.splitBalancedSegments = splitBalancedSegments;
+exports.splitPreamble = splitPreamble;
+exports.splitTopLevel = splitTopLevel;
+exports.themeToCss = themeToCss;
+exports.themes = themes;
+exports.toJsonTree = toJsonTree;
+exports.toRegions = toRegions;
+exports.tokenize = tokenize;
+exports.validate = validate;
+exports.walk = walk;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map