md2gost 1.5.1 → 1.6.0

package/dist/index.mjs

@@ -1,13 +1,18 @@
+import { fileURLToPath as __md2gostFileURLToPath } from "node:url";
+import { dirname as __md2gostPathDirname } from "node:path";
+const __MD2GOST_DIRNAME__ = __md2gostPathDirname(__md2gostFileURLToPath(import.meta.url));
+
 // src/index.ts
-import path5 from "path";
-import { fileURLToPath } from "url";
+import path6 from "path";
 
 // src/main.ts
-import path4 from "path";
+import path5 from "path";
 
 // src/doc.ts
 var Doc = class {
   nodes = [];
+  header = { type: "none" };
+  footer = { type: "auto" };
   rainbow = false;
   numberingLazy = false;
   numberingSections = false;
@@ -67,36 +72,66 @@ var Doc = class {
     spacing: { before: void 0, after: void 0 },
     text: { size: void 0 }
   };
-  appendText(text) {
-    this.nodes.push({ type: "text", text });
+  formula = {
+    spacing: { before: 8, after: 8 }
+  };
+  admonition = {
+    note: { title: "**\u041F\u0440\u0438\u043C\u0435\u0447\u0430\u043D\u0438\u0435**", indent: 1.25, spacing: { before: 8, after: 8 }, padding: { top: 6, right: 10, bottom: 6, left: 10 }, background: "f5f5f5", color: "666666", bar_width: 2.25, icon: true, icon_size: 16, title_color: true },
+    info: { title: "**\u041F\u0440\u0438\u043C\u0435\u0447\u0430\u043D\u0438\u0435**", indent: 1.25, spacing: { before: 8, after: 8 }, padding: { top: 6, right: 10, bottom: 6, left: 10 }, background: "f0f7ff", color: "1976d2", bar_width: 2.25, icon: true, icon_size: 16, title_color: true },
+    tip: { title: "**\u0420\u0435\u043A\u043E\u043C\u0435\u043D\u0434\u0430\u0446\u0438\u044F**", indent: 1.25, spacing: { before: 8, after: 8 }, padding: { top: 6, right: 10, bottom: 6, left: 10 }, background: "f2f8f2", color: "2e7d32", bar_width: 2.25, icon: true, icon_size: 16, title_color: true },
+    warning: { title: "**\u0412\u043D\u0438\u043C\u0430\u043D\u0438\u0435**", indent: 1.25, spacing: { before: 8, after: 8 }, padding: { top: 6, right: 10, bottom: 6, left: 10 }, background: "fff7ea", color: "b26a00", bar_width: 2.25, icon: true, icon_size: 16, title_color: true },
+    danger: { title: "**\u041A\u0440\u0438\u0442\u0438\u0447\u0435\u0441\u043A\u0438 \u0432\u0430\u0436\u043D\u043E**", indent: 1.25, spacing: { before: 8, after: 8 }, padding: { top: 6, right: 10, bottom: 6, left: 10 }, background: "fff0f0", color: "d32f2f", bar_width: 2.25, icon: true, icon_size: 16, title_color: true }
+  };
+  appendText(text, sourceLine) {
+    this.nodes.push({ type: "text", text, sourceLine });
   }
-  appendTitle(text, level) {
-    this.nodes.push({ type: "title", text, level });
+  appendTitle(text, level, sourceLine) {
+    this.nodes.push({ type: "title", text, level, sourceLine });
   }
   appendNode(node) {
     this.nodes.push(node);
   }
+  lineSkips = [];
+  addLineSkip(line, delta) {
+    this.lineSkips.push({ ln: line, d: delta });
+  }
+  mapSourceLine(line) {
+    for (const { ln, d } of this.lineSkips)
+      if (ln <= line) line -= d;
+    return line;
+  }
 };
-function tableRow(...items) {
-  return items.map((v) => ({ type: "text", text: v }));
+function tableRow(sourceLine, ...items) {
+  return items.map((v) => ({ type: "text", text: v, sourceLine }));
 }
 
 // src/parser.ts
-import fs2 from "fs/promises";
+import fs3 from "fs/promises";
 
 // src/utils.ts
 import fs from "fs/promises";
 import fss from "fs";
 import * as path from "node:path";
-function choice(...options) {
-  return options[randomInt(options.length)];
+
+// src/errors.ts
+var UserInputError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+
+// src/utils.ts
+function choice(first, ...options) {
+  const all = [first, ...options];
+  return all[randomInt(all.length)];
 }
 function randomInt(maxmin, max, rnd = Math.random) {
   if (max != void 0)
-    return Math.floor(rnd() * (maxmin - max)) + max;
+    return Math.floor(rnd() * (max - maxmin)) + maxmin;
   return Math.floor(rnd() * maxmin);
 }
 function trimEnd(str, ...chs) {
+  chs = chs.filter((ch) => ch.length > 0);
   if (!chs || chs.length == 0) return str.trimEnd();
   let trimmed = false;
   do {
@@ -110,6 +145,7 @@ function trimEnd(str, ...chs) {
   return str;
 }
 function trimStart(str, ...chs) {
+  chs = chs.filter((ch) => ch.length > 0);
   if (!chs || chs.length == 0) return str.trimStart();
   let trimmed = false;
   do {
@@ -125,10 +161,10 @@ function trimStart(str, ...chs) {
 function toCapitalCase(str) {
   return str.slice(0, 1).toUpperCase() + str.slice(1);
 }
-async function checkIfFileIsBlocked(path6) {
+async function checkIfFileIsBlocked(path7) {
   let file;
   try {
-    file = await fs.open(path6, "r+");
+    file = await fs.open(path7, "r+");
     return false;
   } catch (err) {
     if (!err) return false;
@@ -181,22 +217,791 @@ function realpathAllowMissing(inputPath) {
 function isMissingPathError(err) {
   return err instanceof Error && "code" in err && (err.code === "ENOENT" || err.code === "ENOTDIR");
 }
+function getSafePathResolver(workdir, checkFilesIsInsidePath) {
+  const allowedRealPath = checkFilesIsInsidePath === false ? false : realpathAllowMissing(checkFilesIsInsidePath === "" ? workdir : checkFilesIsInsidePath);
+  const resolvePath = (fname, origin) => {
+    if (process.platform != "win32") fname = fname.replaceAll("\\", "/");
+    if (process.platform == "win32" && fname.startsWith("/")) fname = "." + fname;
+    const targetPath = path.isAbsolute(fname) ? path.resolve(fname) : path.resolve(origin || workdir, fname);
+    if (allowedRealPath !== false) {
+      const targetRealPath = realpathAllowMissing(targetPath);
+      const relative2 = path.relative(allowedRealPath, targetRealPath);
+      const isOutside = relative2 === ".." || relative2.startsWith(`..${path.sep}`) || path.isAbsolute(relative2);
+      if (isOutside) throw new UserInputError(`Access denied: "${fname}" resolves outside the working directory.`);
+    }
+    return targetPath;
+  };
+  const getRelative = (fname) => {
+    const targetPath = resolvePath(fname);
+    if (allowedRealPath !== false)
+      return path.relative(allowedRealPath, targetPath);
+    return path.relative(workdir, targetPath);
+  };
+  return { resolvePath, getRelative };
+}
+function isLocalFilePath(link) {
+  const value = link.trim();
+  if (value.startsWith("//")) return false;
+  if (path.win32.isAbsolute(value)) return true;
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value)) return false;
+  if (value.startsWith("#")) return false;
+  return true;
+}
+function deepOverwrite(target, source) {
+  const result = Object.assign(/* @__PURE__ */ Object.create(null), target);
+  for (const [key, sourceValue] of Object.entries(source)) {
+    if (key === "__proto__" || key === "prototype" || key === "constructor")
+      continue;
+    const targetValue = Object.hasOwn(result, key) ? result[key] : void 0;
+    result[key] = isJSONDict(targetValue) && isJSONDict(sourceValue) ? deepOverwrite(targetValue, sourceValue) : sourceValue;
+  }
+  return result;
+  function isJSONDict(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+  }
+}
 
 // src/parser.ts
+import path3 from "path";
+
+// src/preprocessor.ts
+import fs2 from "fs/promises";
 import path2 from "path";
-async function parseMD(file, logwarn = console.warn) {
-  const lines = (await fs2.readFile(file, { encoding: "utf8" })).split("\n");
+async function preprocess(file, variables, checkFilesIsInsidePath, options, signal, logwarn = console.warn) {
+  const rootFile = path2.resolve(file);
+  const { resolvePath, getRelative } = getSafePathResolver(path2.dirname(rootFile), checkFilesIsInsidePath);
+  const ctx = {
+    options,
+    workdir: path2.dirname(rootFile),
+    includes: 0,
+    iterations: 0,
+    inputLength: 0,
+    generatedLength: 0,
+    signal: signal || void 0,
+    logwarn,
+    countAsOutput(v) {
+      ctx.generatedLength += v.length;
+      if (options.maxGeneratedLength !== void 0 && ctx.generatedLength > options.maxGeneratedLength)
+        throw new UserInputError(`Maximum output length exceeded (${options.maxGeneratedLength})`);
+      return v;
+    }
+  };
+  const rootNode = { type: "include", path: rootFile, dict: {}, trimEnd: false, trimStart: false };
+  return processInclude(rootNode, variables, resolvePath, getRelative, [], ctx);
+}
+async function processInclude(node, variables, resolvePath, getRelative, stack, ctx) {
+  ctx.signal?.throwIfAborted();
+  const fpath = resolvePath(node.path);
+  const relativePath = getRelative(fpath);
+  const dir = path2.dirname(fpath);
+  if (ctx.options.maxIncludeDepth !== void 0 && stack.length > ctx.options.maxIncludeDepth)
+    throw new UserInputError(`Maximum include depth exceeded while including "${relativePath}":
+${stack.join(" -> ")}`);
+  if (stack.length > 0) {
+    ctx.includes++;
+    const maxIncludes = ctx.options.maxIncludes === void 0 ? 1e3 : ctx.options.maxIncludes;
+    if (ctx.includes > maxIncludes)
+      throw new UserInputError(`Maximum include count exceeded (${maxIncludes})`);
+  }
+  let rawContent;
+  try {
+    if (ctx.options.maxFileLength !== void 0) {
+      const size = (await fs2.stat(fpath)).size;
+      if (size > ctx.options.maxFileLength * 3)
+        throw new UserInputError(`File is too large (${size} > ${ctx.options.maxFileLength * 3}) "${relativePath}"`);
+    }
+    rawContent = await fs2.readFile(fpath, { encoding: "utf8", signal: ctx.signal });
+    if (ctx.options.maxFileLength !== void 0 && rawContent.length > ctx.options.maxFileLength)
+      throw new UserInputError(`File is too large (${rawContent.length} > ${ctx.options.maxFileLength}) "${relativePath}"`);
+    ctx.inputLength += rawContent.length;
+    if (ctx.options.maxTotalInputLength !== void 0 && ctx.inputLength > ctx.options.maxTotalInputLength)
+      throw new UserInputError(`Maximum total input length exceeded (${ctx.inputLength} > ${ctx.options.maxTotalInputLength})`);
+  } catch (err) {
+    ctx.signal?.throwIfAborted();
+    if (err instanceof UserInputError) throw err;
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new UserInputError(`Failed to read included file "${relativePath}": ${reason}`);
+  }
+  let content = rawContent;
+  if (variables) {
+    variables = deepOverwrite(variables, node.dict);
+    const nodes = parseFExpr(rawContent);
+    nodes.forEach((n) => n.type == "expr" && (n.source.fname = relativePath));
+    content = processExpressions(nodes, variables || {}, ctx);
+  } else {
+    variables = {};
+    ctx.countAsOutput(content);
+  }
+  content = await fixLinks(content, fixLink);
+  if (!ctx.options.allowIncludes) return content;
+  const includes = await parseIncludes(content, ctx.logwarn);
+  let result = "";
+  for (const node2 of includes) {
+    if (node2.type == "text") result += node2.value;
+    else {
+      let r = await processInclude(node2, variables, resolvePath, getRelative, [...stack, relativePath], ctx);
+      if (node2.trimStart) r = r.trimStart();
+      if (node2.trimEnd) r = r.trimEnd();
+      result += r;
+    }
+  }
+  if (node.sourceLineCount) {
+    const delta = result.split("\n").length - node.sourceLineCount + 1;
+    result += "\n\uE100" + delta + "\uE101";
+  }
+  return result;
+  function fixLink(oldpath) {
+    oldpath = oldpath.trim();
+    oldpath = trimEnd(trimStart(oldpath, "<", '"'), ">", '"');
+    const newpath = !isLocalFilePath(oldpath) ? oldpath : path2.relative(ctx.workdir, resolvePath(oldpath, dir)).split(path2.sep).join("/");
+    if (newpath.includes(" ")) return `<${newpath}>`;
+    return newpath;
+  }
+}
+function parseFExpr(content) {
+  const nodes = [];
+  let textStart = 0;
+  let ln = 1;
+  function countLines(start, end) {
+    for (let i = start; i < end; i++)
+      if (content[i] == "\n") ln++;
+  }
+  function pushText(start, end) {
+    if (start >= end) return;
+    const value = content.slice(start, end);
+    const prev = nodes.at(-1);
+    countLines(start, end);
+    if (prev?.type == "text")
+      prev.value += value;
+    else
+      nodes.push({ type: "text", value });
+  }
+  function isEscaped(i) {
+    let slashes = 0;
+    for (i--; i >= 0 && content[i] == "\\"; i--)
+      slashes++;
+    return slashes % 2 != 0;
+  }
+  for (let i = 0; i < content.length; i++) {
+    if (content.startsWith("<!--", i)) {
+      const end2 = content.indexOf("-->", i + 4);
+      if (end2 < 0) break;
+      i = end2 + 2;
+      continue;
+    }
+    if (!content.startsWith("{{", i))
+      continue;
+    if (isEscaped(i)) {
+      pushText(textStart, i - 1);
+      pushText(i, i + 2);
+      textStart = i + 2;
+      i++;
+      continue;
+    }
+    const trimLeft = content[i + 2] == "-" && !/\d/.test(content[i + 3] || "");
+    const valueStart = i + 2 + (trimLeft ? 1 : 0);
+    let end = -1;
+    let inString = false;
+    let escaped = false;
+    for (let j = valueStart; j < content.length - 1; j++) {
+      const ch = content[j];
+      if (inString) {
+        if (escaped) escaped = false;
+        else if (ch === "\\") escaped = true;
+        else if (ch === '"') inString = false;
+        continue;
+      }
+      if (ch == '"') {
+        inString = true;
+        continue;
+      }
+      if (ch === "}" && content[j + 1] === "}") {
+        end = j;
+        break;
+      }
+    }
+    if (end < 0) continue;
+    const trimRight = end > valueStart && content[end - 1] == "-";
+    const valueEnd = trimRight ? end - 1 : end;
+    const hasQuotes = i > 0 && content[i - 1] == '"' && !isEscaped(i - 1) && content[end + 2] === '"';
+    let textEnd = hasQuotes ? i - 1 : i;
+    const untrimmedTextEnd = textEnd;
+    if (trimLeft)
+      while (textEnd > textStart && /\s/.test(content[textEnd - 1])) textEnd--;
+    pushText(textStart, textEnd);
+    countLines(textEnd, untrimmedTextEnd);
+    const lineStart = content.lastIndexOf("\n", i + 2);
+    const source = { ln, col: lineStart < 0 ? i + 1 : i - lineStart };
+    nodes.push({ type: "expr", value: content.slice(valueStart, valueEnd), hasQuotes, trimLeft, trimRight, source });
+    let next = hasQuotes ? end + 3 : end + 2;
+    if (trimRight) {
+      const untrimmedNext = next;
+      while (next < content.length && /\s/.test(content[next])) next++;
+      countLines(untrimmedNext, next);
+    }
+    textStart = next;
+    i = next - 1;
+  }
+  pushText(textStart, content.length);
+  return nodes;
+}
+function getByPath(value, path7) {
+  for (const key of path7) {
+    if (value === null || value === void 0)
+      return value;
+    const obj = Object(value);
+    if (!Object.hasOwn(obj, key))
+      return void 0;
+    value = obj[key];
+  }
+  return value;
+}
+function processExpressions(nodes, variables, ctx) {
+  const expr = parseExp(nodes, ctx);
+  const tree = buildExpTree(expr, ctx);
+  const res = execExpTree(tree, variables, ctx);
+  return res.join("");
+}
+function parseExp(nodes, ctx) {
+  const reVar = String.raw`[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*|\.\d+|\[\d+\])*`;
+  const reIdent = String.raw`[A-Za-z_$][A-Za-z0-9_$]*`;
+  const reStr = String.raw`"(?:\\.|[^"\\])*"`;
+  const reNum = String.raw`-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?`;
+  const reVal = String.raw`(?:${reStr}|${reNum}|true|false|null)`;
+  const reOCompare = String.raw`(?:==|!=|<|<=|>|>=|\bin\b)`;
+  const reOMath = String.raw`(?:\+|-|/|//|%|\*|\*\*)`;
+  const reOLogical = String.raw`(?:and|or|&&|\|\||\?\?)`;
+  const re_var = new RegExp(String.raw`^\s*((?:${reVar})|${reVal})\s*(?:(${reOMath}|${reOLogical})\s*((?:${reVar})|${reVal}))?\s*$`);
+  const re_val = new RegExp(String.raw`^${reVal}$`);
+  const re_str = new RegExp(String.raw`^\s*(${reStr})\s*$`);
+  const re_else = /^:else\s*$/;
+  const re_for = new RegExp(String.raw`^#for\s+(${reIdent})(?:\s*,\s*(${reIdent}))?\s+in\s+(${reVar}|${reNum}|${reStr})\s*$`);
+  const re_forEnd = /^\/for\s*$/;
+  const re_if = new RegExp(String.raw`^#if\s+((?:${reVar})|${reVal})\s*(?:(${reOCompare}|${reOLogical})\s*((?:${reVar})|${reVal}))?\s*$`);
+  const re_ifEnd = /^\/if\s*$/;
+  const re_path = /[A-Za-z_$][A-Za-z0-9_$]*|\d+/g;
+  return nodes.map((node) => {
+    ctx.signal?.throwIfAborted();
+    if (node.type == "text") return { type: "text", value: node.value };
+    const enode = node;
+    const source = node.source;
+    const expression = `{{${node.trimLeft ? "-" : ""}${node.value}${node.trimRight ? "-" : ""}}}`;
+    const rawValue = node.hasQuotes ? `"${expression}"` : expression;
+    function retWarn(msg) {
+      ctx.logwarn(msg + pos(enode));
+      return { type: "text", value: rawValue };
+    }
+    const mvar = re_var.exec(node.value);
+    if (mvar) {
+      const left = parseOperand(mvar[1]);
+      if (!left) return retWarn("Unsupported expression: " + rawValue);
+      const operator = mvar[2];
+      if (!operator) return { type: "var", left, source, hasQuotes: node.hasQuotes };
+      const right = parseOperand(mvar[3]);
+      if (!right) return retWarn("Unsupported expression: " + rawValue);
+      return { type: "var", left, operator, right, source, hasQuotes: node.hasQuotes };
+    }
+    const mstr = re_str.exec(node.value);
+    if (mstr) {
+      const str = safeParse(node.value);
+      if (str === void 0) return retWarn("Cant parse string: " + node.value);
+      return { type: "text", value: node.hasQuotes ? JSON.stringify(str) : `${str}` };
+    }
+    const mfor = re_for.exec(node.value);
+    if (mfor) {
+      if (!ctx.options.allowLoops) return retWarn("Loop expressions are not allowed");
+      const varValue = mfor[1];
+      const varKey = mfor[2];
+      const array = parseOperand(mfor[3]);
+      if (!array) return retWarn("Unsupported expression: " + rawValue);
+      return { type: "for", varValue, varKey, array, source };
+    }
+    const mif = re_if.exec(node.value);
+    if (mif) {
+      const left = parseOperand(mif[1]);
+      if (!left) return retWarn("Unsupported expression: " + rawValue);
+      const operator = mif[2];
+      if (!operator) return { type: "if", left, source };
+      const right = parseOperand(mif[3]);
+      if (!right) return retWarn("Unsupported expression: " + rawValue);
+      return { type: "if", left, operator, right, source };
+    }
+    if (re_else.exec(node.value)) return { type: "else", source };
+    if (re_ifEnd.exec(node.value)) return { type: "ifEnd", source };
+    if (re_forEnd.exec(node.value)) {
+      if (!ctx.options.allowLoops) return retWarn("Loop expressions are not allowed");
+      return { type: "forEnd", source };
+    }
+    return retWarn("Unsupported expression: " + rawValue);
+  });
+  function pos(node) {
+    return ` [Ln ${node.source.ln}, Col ${node.source.col}] (${node.source.fname})`;
+  }
+  function safeParse(value) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return void 0;
+    }
+  }
+  function parsePath(value) {
+    const parts = value?.match(re_path);
+    if (!parts?.length) return void 0;
+    return parts.map((part) => /^\d+$/.test(part) ? Number(part) : part);
+  }
+  function parseOperand(value) {
+    if (!value) return void 0;
+    if (re_val.test(value)) {
+      const val = safeParse(value);
+      if (val === void 0) return null;
+      return { t: "val", val };
+    }
+    const path7 = parsePath(value);
+    if (!path7) return null;
+    return { t: "var", path: path7 };
+  }
+}
+function buildExpTree(nodes, ctx, depth = 0, source) {
+  ctx.signal?.throwIfAborted();
+  if (ctx.options.maxDepth !== void 0 && depth >= ctx.options.maxDepth) {
+    ctx.logwarn(`Maximum expression nesting depth exceeded (${ctx.options.maxDepth})${source ? pos({ source }) : ""}`);
+    return nodes.map((n) => {
+      if (n.type == "text" || n.type == "var") return n;
+      if (n.type == "else" || n.type == "forEnd" || n.type == "ifEnd") {
+        const str = n.type == "else" ? "{{:else}}" : n.type == "ifEnd" ? "{{/if}}" : "{{/for}}";
+        return { type: "text", value: str };
+      }
+      if (n.type == "for") {
+        const second = n.varKey ? `, ${n.varKey}` : "";
+        return { type: "text", value: `{{#for ${n.varValue}${second} in ${strOperand(n.array)}}}` };
+      }
+      if (n.type == "if") {
+        const right = n.right ? ` ${n.operator} ${strOperand(n.right)}` : "";
+        return { type: "text", value: `{{#if ${strOperand(n.left)}${right}}}` };
+      }
+      n;
+      return { type: "text", value: "" };
+    });
+  }
+  const tree = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.type == "text" || node.type == "var") {
+      tree.push(node);
+    }
+    if (node.type == "else" || node.type == "forEnd" || node.type == "ifEnd") {
+      const str = node.type == "else" ? "{{:else}}" : node.type == "ifEnd" ? "{{/if}}" : "{{/for}}";
+      ctx.logwarn(`Unexpected expression (${str})` + pos(node));
+      tree.push({ type: "text", value: str });
+    }
+    if (node.type == "for" || node.type == "if") {
+      const r = parseBlockWithElse(i);
+      if (!r) {
+        if (node.type == "for") {
+          const second = node.varKey ? `, ${node.varKey}` : "";
+          tree.push({ type: "text", value: `{{#for ${node.varValue}${second} in ${strOperand(node.array)}}}` });
+        } else if (node.type == "if") {
+          const right = node.right ? ` ${node.operator} ${strOperand(node.right)}` : "";
+          tree.push({ type: "text", value: `{{#if ${strOperand(node.left)}${right}}}` });
+        }
+      } else {
+        const { body, bodyElse, endI } = r;
+        i = endI;
+        tree.push({ ...node, body, bodyElse });
+      }
+    }
+  }
+  return tree;
+  function pos(node) {
+    return ` [Ln ${node.source.ln}, Col ${node.source.col}] (${node.source.fname})`;
+  }
+  function strOperand(v) {
+    return v.t == "val" ? JSON.stringify(v.val) : v.path.join(".");
+  }
+  function findBlockEnd(startI, type, skipElse) {
+    const stack = [];
+    for (let i = startI; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.type == "if") stack.push("if");
+      else if (node.type == "for") stack.push("for");
+      else if (node.type == "forEnd" && stack.at(-1) == "for") stack.pop();
+      else if (node.type == "ifEnd" && stack.at(-1) == "if") stack.pop();
+      else if (stack.length == 0) {
+        if (node.type == "else" && !skipElse) return i;
+        if (node.type == "forEnd" && type == "for") return i;
+        if (node.type == "ifEnd" && type == "if") return i;
+      }
+    }
+    return -1;
+  }
+  function parseBlockWithElse(startI) {
+    const node = nodes[startI];
+    if (node.type != "for" && node.type != "if") return null;
+    const n = node;
+    const type = n.type;
+    const unclosed = (m) => ctx.logwarn(`Unclosed ${type} ${m}` + pos(n));
+    const bodyEnd = findBlockEnd(startI + 1, type, false);
+    if (bodyEnd < 0) {
+      unclosed("body");
+      return null;
+    }
+    const bodyNodes = nodes.slice(startI + 1, bodyEnd);
+    const body = buildExpTree(bodyNodes, ctx, depth + 1, n.source);
+    let endI = bodyEnd;
+    let bodyElse;
+    if (nodes[bodyEnd].type == "else") {
+      const bodyElseEnd = findBlockEnd(bodyEnd + 1, type, true);
+      if (bodyElseEnd < 0) {
+        unclosed("else block");
+        return null;
+      }
+      const bodyElseNodes = nodes.slice(bodyEnd + 1, bodyElseEnd);
+      bodyElse = buildExpTree(bodyElseNodes, ctx, depth + 1, n.source);
+      endI = bodyElseEnd;
+    }
+    return { body, bodyElse, endI };
+  }
+}
+function execExpTree(tree, variables, ctx) {
+  return tree.flatMap((node) => {
+    ctx.signal?.throwIfAborted();
+    if (node.type == "text") return ctx.countAsOutput(node.value);
+    if (node.type == "var") {
+      const n = node;
+      const value = execOperator(node.left, node.operator, node.right);
+      const rawValue = () => {
+        const right = n.right ? ` ${n.operator} ${strOperand(n.right)}` : "";
+        const value2 = `{{${strOperand(n.left)}${right}}}`;
+        return n.hasQuotes ? `"${value2}"` : value2;
+      };
+      if (value === void 0) ctx.logwarn("Undefined variable: " + rawValue() + pos(node));
+      const result = value === void 0 ? rawValue() : typeof value == "object" || node.hasQuotes ? JSON.stringify(value) : `${value}`;
+      return ctx.countAsOutput(result);
+    }
+    if (node.type == "if") {
+      const res = execOperator(node.left, node.operator, node.right);
+      const result = res && typeof res == "object" ? (Array.isArray(res) ? res : Object.keys(res)).length > 0 : !!res;
+      if (result) return execExpTree(node.body, variables, ctx);
+      if (node.bodyElse) return execExpTree(node.bodyElse, variables, ctx);
+      return "";
+    }
+    if (node.type == "for") {
+      if (!ctx.options.allowLoops) throw new UserInputError("Loop expressions are not allowed");
+      const arr = node.array.t == "val" ? node.array.val : getByPath(variables, node.array.path);
+      if (!arr || typeof arr == "object" && (Array.isArray(arr) ? arr : Object.keys(arr)).length == 0) {
+        if (node.bodyElse) return execExpTree(node.bodyElse, variables, ctx);
+        return "";
+      }
+      const values = (() => {
+        const n = node;
+        function checkLoopIterations(count, final = true) {
+          const max = ctx.options.maxLoopIterations === void 0 ? 1e3 : ctx.options.maxLoopIterations;
+          if (count > max)
+            throw new UserInputError(`Maximum loop iterations exceeded (${final ? count + " " : ""}> ${max})` + pos(n));
+          if (ctx.options.maxTotalIterations !== void 0 && ctx.iterations + count > ctx.options.maxTotalIterations)
+            throw new UserInputError(`Maximum total loop iterations exceeded (${ctx.options.maxTotalIterations})`);
+        }
+        if (typeof arr == "number" && Number.isInteger(arr)) {
+          if (arr < 0) {
+            ctx.logwarn(`For loop source is a negative integer (${arr})` + pos(node));
+            return [];
+          }
+          checkLoopIterations(arr);
+          return Array.from({ length: arr }, (_, i) => ({ k: i, v: i + 1 }));
+        }
+        if (typeof arr == "object") {
+          if (Array.isArray(arr)) {
+            checkLoopIterations(arr.length);
+            return arr.map((v, i) => ({ k: i, v }));
+          }
+          const keys = Object.keys(arr);
+          checkLoopIterations(keys.length);
+          return keys.map((k) => ({ k, v: arr[k] }));
+        }
+        if (typeof arr == "string") {
+          const values2 = [];
+          for (const v of arr) {
+            values2.push({ k: values2.length, v });
+            checkLoopIterations(values2.length, false);
+          }
+          return values2;
+        }
+      })();
+      if (!values) {
+        ctx.logwarn(`For loop source is not object, string or integer (${arr})` + pos(node));
+        return "";
+      }
+      return values.flatMap(({ k, v }) => {
+        ctx.signal?.throwIfAborted();
+        ctx.iterations++;
+        if (ctx.options.maxTotalIterations !== void 0 && ctx.iterations > ctx.options.maxTotalIterations)
+          throw new UserInputError(`Maximum total loop iterations exceeded (${ctx.options.maxTotalIterations})`);
+        const locals = Object.assign(/* @__PURE__ */ Object.create(null), variables);
+        locals[node.varValue] = v;
+        if (node.varKey) locals[node.varKey] = k;
+        return execExpTree(node.body, locals, ctx);
+      });
+    }
+    node;
+    return "";
+  });
+  function pos(node) {
+    return ` [Ln ${node.source.ln}, Col ${node.source.col}] (${node.source.fname})`;
+  }
+  function strOperand(v) {
+    return v.t == "val" ? JSON.stringify(v.val) : v.path.join(".");
+  }
+  function isEqual(obj1, obj2) {
+    if (obj1 === obj2) return true;
+    if (obj1 == null || obj2 == null || typeof obj1 !== "object" || typeof obj2 !== "object")
+      return obj1 == obj2;
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) return false;
+    for (const key of keys1)
+      if (!Object.hasOwn(obj2, key) || !isEqual(obj1[key], obj2[key]))
+        return false;
+    return true;
+  }
+  function execOperator(left, operator, right) {
+    const leftV = left.t == "val" ? left.val : getByPath(variables, left.path);
+    if (!operator || !right) return leftV;
+    const rightV = right.t == "val" ? right.val : getByPath(variables, right.path);
+    if (operator == "==") return isEqual(leftV, rightV);
+    if (operator == "!=") return !isEqual(leftV, rightV);
+    if (operator == "<=") return leftV < rightV || isEqual(leftV, rightV);
+    if (operator == ">=") return leftV > rightV || isEqual(leftV, rightV);
+    if (operator == "<") return leftV < rightV;
+    if (operator == ">") return leftV > rightV;
+    if (operator == "in") return !!rightV && typeof rightV == "object" && (Array.isArray(rightV) ? rightV : Object.keys(rightV)).some((v) => isEqual(v, leftV));
+    if (operator == "and" || operator == "&&") return leftV && rightV;
+    if (operator == "or" || operator == "||") return leftV || rightV;
+    if (operator == "??") return leftV ?? rightV;
+    if (operator == "+") return leftV + rightV;
+    if (operator == "-") return leftV - rightV;
+    if (operator == "*") return leftV * rightV;
+    if (operator == "**") return Math.pow(leftV, rightV);
+    if (operator == "/") return rightV == 0 ? 0 : leftV / rightV;
+    if (operator == "//") return Math.floor(rightV == 0 ? 0 : leftV / rightV);
+    if (operator == "%") return rightV == 0 ? 0 : leftV % rightV;
+    operator;
+    return false;
+  }
+}
+function parseIncludePath(value) {
+  value = value.trim();
+  const trimLeft = value.startsWith("-");
+  if (trimLeft) value = value.slice(1).trimStart();
+  const trimLeftInner = value.startsWith("-");
+  if (trimLeftInner) value = value.slice(1).trimStart();
+  const trimRight = value.endsWith("-");
+  if (trimRight) value = value.slice(0, -1).trimEnd();
+  const trimRightInner = value.endsWith("-");
+  if (trimRightInner) value = value.slice(0, -1).trimEnd();
+  const path7 = trimEnd(trimStart(value, "<", '"'), ">", '"');
+  return { path: path7, trimLeft, trimLeftInner, trimRight, trimRightInner };
+}
+function findClosingBrace(content, start) {
+  let depth = 0;
+  let inString = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let i = start; i < content.length; i++) {
+    const ch = content[i];
+    if (lineComment) {
+      if (ch == "\n") lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (ch == "*" && content[i + 1] == "/") {
+        blockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      if (ch == "\\") i++;
+      else if (ch == '"') inString = false;
+      continue;
+    }
+    if (ch == '"') {
+      inString = true;
+      continue;
+    }
+    if (ch == "/" && content[i + 1] == "/") {
+      lineComment = true;
+      i++;
+      continue;
+    }
+    if (ch == "/" && content[i + 1] == "*") {
+      blockComment = true;
+      i++;
+      continue;
+    }
+    if (ch == "{") depth++;
+    else if (ch == "}" && --depth == 0) return i;
+  }
+  return -1;
+}
+async function parseIncludes(content, logwarn) {
+  const { default: JSONC } = await import("jsonc-simple-parser");
+  const re_doc = /^!!\(([^{}]*)\)\s*{(.*)}$/s;
+  const re_codeFence = /^( {0,3})(`{3,})([^`]*)$/;
+  const nodes = [];
+  let textStart = 0;
+  function pushText(start, end) {
+    if (start >= end) return;
+    const value = content.slice(start, end);
+    const prev = nodes.at(-1);
+    if (prev?.type === "text")
+      prev.value += value;
+    else
+      nodes.push({ type: "text", value });
+  }
+  let codeFence = 0;
+  for (let i = 0; i < content.length; i++) {
+    if (i != 0 && content[i - 1] != "\n") continue;
+    const lineEnd = content.indexOf("\n", i);
+    const line = content.slice(i, lineEnd < 0 ? content.length : lineEnd).replace(/\r$/, "");
+    const m_fence = re_codeFence.exec(line);
+    if (m_fence) {
+      const ticks = m_fence[2].length;
+      const suffix = m_fence[3];
+      if (codeFence == 0) {
+        codeFence = ticks;
+        continue;
+      }
+      if (ticks >= codeFence && suffix.trim() == "") {
+        codeFence = 0;
+        continue;
+      }
+    }
+    if (codeFence != 0) continue;
+    if (content.slice(i, i + 2) !== "!!") continue;
+    const m_start = /^!!\([^{}]*\)\s*{/.exec(content.slice(i));
+    if (!m_start) continue;
+    const end = findClosingBrace(content, i + m_start[0].length - 1);
+    if (end < 0) continue;
+    const block = content.slice(i, end + 1);
+    const m_doc = re_doc.exec(block);
+    if (!m_doc) continue;
+    const { path: path7, trimLeft, trimLeftInner, trimRight, trimRightInner } = parseIncludePath(m_doc[1]);
+    if (!path7.toLowerCase().endsWith(".md")) continue;
+    let dict = {};
+    try {
+      dict = JSONC.parse(`{${m_doc[2]}}`);
+    } catch {
+      logwarn(`Can't parse include dict: {${m_doc[2].replaceAll("\n", " ")}}`);
+      continue;
+    }
+    let textEnd = i;
+    if (trimLeft)
+      while (textEnd > textStart && /\s/.test(content[textEnd - 1])) textEnd--;
+    pushText(textStart, textEnd);
+    nodes.push({ type: "include", path: path7, dict, sourceLineCount: block.split("\n").length, trimStart: trimLeftInner, trimEnd: trimRightInner });
+    let next = end + 1;
+    if (trimRight)
+      while (next < content.length && /\s/.test(content[next])) next++;
+    textStart = next;
+    i = next - 1;
+  }
+  pushText(textStart, content.length);
+  return nodes;
+}
+async function fixLinks(content, fixLink) {
+  const { default: JSONC } = await import("jsonc-simple-parser");
+  const re_codeFence = /^( {0,3})(`{3,})([^`]*)$/;
+  let result = "";
+  let textStart = 0;
+  function append(start, end) {
+    if (start >= end) return;
+    result += content.slice(start, end);
+  }
+  let codeFence = 0;
+  for (let i = 0; i < content.length; i++) {
+    if (i != 0 && content[i - 1] != "\n") continue;
+    const lineEnd = content.indexOf("\n", i);
+    const lineTextEnd = lineEnd < 0 ? content.length : lineEnd - (content[lineEnd - 1] == "\r" ? 1 : 0);
+    const line = content.slice(i, lineTextEnd);
+    const m_fence = re_codeFence.exec(line);
+    if (m_fence) {
+      const ticks = m_fence[2].length;
+      const suffix = m_fence[3];
+      if (codeFence == 0) {
+        codeFence = ticks;
+        continue;
+      }
+      if (ticks >= codeFence && suffix.trim() == "") {
+        codeFence = 0;
+        continue;
+      }
+    }
+    if (codeFence != 0) continue;
+    if (content.at(i) != "!") continue;
+    const m_img = /^!\[(.*)\]\((.*)\)({(.*)})?$/.exec(line);
+    if (m_img) {
+      append(textStart, i);
+      result += `![${m_img[1]}](${fixLink(m_img[2])})${m_img[3] || ""}`;
+      textStart = lineTextEnd;
+      i = lineEnd < 0 ? content.length : lineEnd;
+      continue;
+    }
+    const m_start = /^!!\([^{}]*\)\s*{/.exec(content.slice(i));
+    if (!m_start) continue;
+    const end = findClosingBrace(content, i + m_start[0].length - 1);
+    if (end < 0) continue;
+    const block = content.slice(i, end + 1);
+    const m_doc = /^!!\(([^{}]*)\)(\s*{(.*)})$/s.exec(block);
+    if (!m_doc) continue;
+    try {
+      JSONC.parse(m_doc[2].trim());
+    } catch {
+      continue;
+    }
+    const { path: path7, trimLeft, trimLeftInner, trimRight, trimRightInner } = parseIncludePath(m_doc[1]);
+    let fixedPath = fixLink(path7);
+    if (fixedPath.startsWith("-") || fixedPath.endsWith("-"))
+      fixedPath = `"${fixedPath}"`;
+    append(textStart, i);
+    result += `!!(${trimLeft ? "-" : ""}${trimLeftInner ? "-" : ""}${fixedPath}${trimRightInner ? "-" : ""}${trimRight ? "-" : ""})${m_doc[2]}`;
+    textStart = end + 1;
+    i = end;
+  }
+  append(textStart, content.length);
+  return result;
+}
+
+// src/parser.ts
+async function parseMD(file, variables, templateOptions = {}, checkFilesIsInsidePath = false, signal, logwarn = console.warn) {
+  signal?.throwIfAborted();
+  const preprocessed = await preprocess(file, variables, checkFilesIsInsidePath, templateOptions, signal, logwarn);
+  signal?.throwIfAborted();
+  const lines = preprocessed.split("\n");
   const doc = new Doc();
+  const warnAt = (line, message) => logwarn(`Line ${doc.mapSourceLine(line)}: ${message}`);
+  (function processLineSkips() {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.at(0) != "\uE100") continue;
+      const m = /\uE100(-?\d+)\uE101/.exec(line);
+      if (!m) {
+        lines[i] = line.replaceAll("\uE100", "").replaceAll("\uE101", "");
+        continue;
+      }
+      lines[i] = line.slice(m?.[0].length);
+      doc.addLineSkip(i + 1, parseInt(m[1]));
+    }
+  })();
   try {
-    doc.title = toCapitalCase(trimEnd(path2.parse(file).name, ".g"));
-    const stats = await fs2.stat(file);
+    doc.title = toCapitalCase(trimEnd(path3.parse(file).name, ".g"));
+    const stats = await fs3.stat(file);
     doc.ctime = stats.birthtime;
   } catch {
   }
   function parseList(text, parts, ordered, level = 0) {
     const startIndex = isFinite(parseInt(parts[0])) ? parseInt(parts[0]) : 1;
     const mark = ordered ? parts[1] == "." ? "." : ")" : parts[1] == "*" ? "*" : "-";
-    const node = { type: "list", ordered, mark, startIndex, items: [{ type: "listItem", text }] };
+    const node = { type: "list", ordered, mark, startIndex, sourceLine: lineI, items: [{ type: "listItem", text, sourceLine: lineI }] };
     const P = ordered ? "1)" : "*";
     function skipEmptyLines() {
       let emptyFound = false;
@@ -228,7 +1033,7 @@ async function parseMD(file, logwarn = console.warn) {
         if (ln.prefix == "" && last?.type == "listItem")
           last.text += "\n" + ln.text;
         else if (ln.prefix == P)
-          node.items.push({ type: "listItem", text: ln.text });
+          node.items.push({ type: "listItem", text: ln.text, sourceLine: lineI + 1 });
         else break;
       } else if (ln.level > level) {
         if (ln.level == level + 1) ln = parseLine(ln.text);
@@ -257,19 +1062,19 @@ async function parseMD(file, logwarn = console.warn) {
       if (isFinite(h)) height = h;
     }
     const src = trimEnd(trimStart(parts[1], "<"), ">");
-    return { type: "image", text, src, width, height };
+    return { type: "image", text, src, width, height, sourceLine: lineI };
   }
   function parseCode(text) {
     const header = text.split(" ");
     const title = header.slice(1).join(" ").trim() || void 0;
-    const node = { type: "code", lang: header[0], title, code: "" };
-    text = "";
+    const node = { type: "code", lang: header[0], title, code: "", sourceLine: lineI };
+    const code = [];
     while (lineI < lines.length) {
       const ln = lines[lineI++];
       if (ln.startsWith("```")) break;
-      text += "\n" + ln;
+      code.push(ln);
     }
-    node.code = text.trim();
+    node.code = code.join("\n");
     return node;
   }
   function parseSection(text) {
@@ -282,9 +1087,78 @@ async function parseMD(file, logwarn = console.warn) {
     return {
       type: "sectionBreak",
       pageStart: unpaged ? -1 : isFinite(num) ? num : null,
-      orientation: portrait ? "portrait" : landscape ? "landscape" : null
+      orientation: portrait ? "portrait" : landscape ? "landscape" : null,
+      sourceLine: lineI
     };
   }
+  function parseHeaderFooter(kind, options) {
+    const value = options.trim().toLowerCase();
+    if (value == "none" || kind == "footer" && value == "auto") {
+      setHeaderFooter(kind, { type: value });
+      return;
+    }
+    const align = value == "" ? "left" : /^align=(left|center|right)$/.exec(value)?.[1];
+    if (!align) {
+      warnAt(lineI, `Wrong ${kind} options: "${options}". Expected align=left, align=center, align=right${kind == "footer" ? ", none, or auto" : ", or none"}.`);
+      return;
+    }
+    const end = `!!end${kind}`;
+    const content = [];
+    const initialLineI = lineI;
+    let closed = false;
+    while (lineI < lines.length) {
+      const line = lines[lineI++];
+      if (line.trim().toLowerCase() == end) {
+        closed = true;
+        break;
+      }
+      content.push(line);
+    }
+    if (!closed) {
+      lineI = initialLineI;
+      warnAt(initialLineI, `${kind} block is not closed`);
+      return;
+    }
+    const nodes = [{ type: "text", text: content.join("\n").trim(), sourceLine: initialLineI + 1 }];
+    findTables(nodes, false);
+    const supported = nodes.filter((node) => node.type == "text" || node.type == "table");
+    if (supported.length != 1 || supported[0]?.type == "text" && !supported[0].text) {
+      warnAt(initialLineI, `${kind} must contain text or one table`);
+      return;
+    }
+    setHeaderFooter(kind, { type: "content", align, nodes: supported });
+    function setHeaderFooter(kind2, value2) {
+      let section;
+      for (let i = doc.nodes.length - 1; i >= 0; i--) {
+        if (doc.nodes[i]?.type == "sectionBreak") {
+          section = doc.nodes[i];
+          break;
+        }
+      }
+      if (section?.type == "sectionBreak") section[kind2] = value2;
+      else doc[kind2] = value2;
+    }
+  }
+  function parseAdmonition(parts) {
+    const marker = parts[0];
+    const type = parts[1];
+    const title = parts[2];
+    const attributes = parts[3];
+    const content = [];
+    const close = new RegExp(`^${marker}\\s*$`);
+    const initialLineI = lineI;
+    let closed = false;
+    while (lineI < lines.length) {
+      const line = lines[lineI++];
+      if (close.test(line)) {
+        closed = true;
+        break;
+      }
+      content.push(line);
+    }
+    if (!closed) warnAt(initialLineI, `Admonition "${type}" is not closed`);
+    return { type: "admonition", admonitionType: type, title, text: content.filter((t) => !!t.trim()).join("\n").trim(), attributes, sourceLine: initialLineI };
+  }
   class RuleError extends Error {
   }
   ;
@@ -354,9 +1228,43 @@ async function parseMD(file, logwarn = console.warn) {
       "text spacing after": (v) => doc.text.spacing.after = tryParseInt(v),
       "img text size": (v) => doc.img.text.size = tryParseInt(v),
       "img spacing before": (v) => doc.img.spacing.before = tryParseInt(v),
-      "img spacing after": (v) => doc.img.spacing.after = tryParseInt(v)
+      "img spacing after": (v) => doc.img.spacing.after = tryParseInt(v),
+      "formula spacing before": (v) => doc.formula.spacing.before = tryParseInt(v),
+      "formula spacing after": (v) => doc.formula.spacing.after = tryParseInt(v)
     };
     const reRules = [
+      {
+        re: /^(admonition (all|note|info|tip|warning|danger) (spacing (before|after)|padding|indent|background|color|bar_width|icon size|icon|title_color|title))(.*)/,
+        n: (m) => ({ rule: m[1], value: (m.at(-1) || "").trim() }),
+        f(m) {
+          const type = m[2];
+          const property = m[3];
+          const value = (m.at(-1) || "").trim();
+          const valueKeepCase = text.slice(m[1].length).trim();
+          const types = type == "all" ? ["note", "info", "tip", "warning", "danger"] : [type];
+          for (const type2 of types) {
+            const style = doc.admonition[type2];
+            if (property == "spacing before") style.spacing.before = tryParseInt(value);
+            else if (property == "spacing after") style.spacing.after = tryParseInt(value);
+            else if (property == "indent") style.indent = tryParseFloat(value);
+            else if (property == "padding") {
+              const padding = value.split(" ").map(tryParseInt);
+              if (padding.length != 2) throw new RuleError("Two values are required: horizontal vertical");
+              style.padding = { top: padding[1], right: padding[0], bottom: padding[1], left: padding[0] };
+            } else if (property == "background") style.background = tryParseColor(value);
+            else if (property == "color") style.color = tryParseColor(value);
+            else if (property == "bar_width") style.bar_width = tryParseFloat(value);
+            else if (property == "icon size") style.icon_size = tryParseInt(value);
+            else if (property == "icon") {
+              choices(value, "on", "off");
+              style.icon = value == "on";
+            } else if (property == "title_color") {
+              choices(value, "on", "off");
+              style.title_color = value == "on";
+            } else if (property == "title") style.title = valueKeepCase;
+          }
+        }
+      },
       {
         re: /^(headings (h[1-6])(\+?) (size|spacing (before|after)|uppercase|indent))(.*)/,
         n: (m) => ({ rule: m[1], value: (m.at(-1) || "").trim() }),
@@ -394,11 +1302,11 @@ async function parseMD(file, logwarn = console.warn) {
           rule = n.rule;
           value = n.value;
         }
-        if (e instanceof RuleError) logwarn(`Rule "${rule}" wrong value: "${value}". ${e.message}`);
+        if (e instanceof RuleError) warnAt(lineI, `Rule "${rule}" wrong value: "${value}". ${e.message}`);
         else throw e;
       }
     } else {
-      logwarn(`Wrong rule: "${text}"`);
+      warnAt(lineI, `Wrong rule: "${text}"`);
     }
     function tryParseInt(v) {
       const num = parseInt(v);
@@ -415,6 +1323,11 @@ async function parseMD(file, logwarn = console.warn) {
       if (!isFinite(date.valueOf())) throw new RuleError("Only ISO 8601 date is allowed");
       return date;
     }
+    function tryParseColor(v) {
+      const color = /^#?([\da-f]{6})$/i.exec(v)?.[1];
+      if (!color) throw new RuleError("Only #RRGGBB colors are allowed");
+      return color;
+    }
     function choices(v, ...vars) {
       if (vars.includes(v)) return v;
       throw new RuleError("Allowed: " + vars.join(", "));
@@ -428,66 +1341,85 @@ async function parseMD(file, logwarn = console.warn) {
   while (lineI < lines.length) {
     const line = lines[lineI++];
     const { prefix, text, parts } = parseLine(line);
-    switch (prefix) {
-      case "#":
-        doc.appendTitle(text, 1);
-        break;
-      case "##":
-        doc.appendTitle(text, 2);
-        break;
-      case "###":
-        doc.appendTitle(text, 3);
-        break;
-      case "####":
-        doc.appendTitle(text, 4);
-        break;
-      case "#####":
-        doc.appendTitle(text, 5);
-        break;
-      case "######":
-        doc.appendTitle(text, 6);
-        break;
-      case "*":
-        doc.appendNode(parseList(text, parts, false));
-        break;
-      case "1)":
-        doc.appendNode(parseList(text, parts, true));
-        break;
-      case "Img":
-        doc.appendNode(parseImg(parts));
-        break;
-      case "Code":
-        doc.appendNode(parseCode(text));
-        break;
-      case "Comment":
-        skipComment();
-        break;
-      case "!!section":
-        doc.appendNode(parseSection(text));
-        break;
-      case "!!rule":
-        apllyRule(text);
-        break;
-      case "---":
-        doc.appendNode({ type: "pageBreak" });
-        break;
-      case "":
-      case "	":
-        const last = doc.nodes.at(-1);
-        if (line.trim() != "" && last?.type == "text") {
-          if (last.text != "") last.text += "\n";
-          last.text += line.trim();
-        } else doc.appendText(line.trim());
-        break;
-      default:
-        prefix;
-        throw new Error("switch default");
+    try {
+      switch (prefix) {
+        case "#":
+          doc.appendTitle(text, 1, lineI);
+          break;
+        case "##":
+          doc.appendTitle(text, 2, lineI);
+          break;
+        case "###":
+          doc.appendTitle(text, 3, lineI);
+          break;
+        case "####":
+          doc.appendTitle(text, 4, lineI);
+          break;
+        case "#####":
+          doc.appendTitle(text, 5, lineI);
+          break;
+        case "######":
+          doc.appendTitle(text, 6, lineI);
+          break;
+        case "*":
+          doc.appendNode(parseList(text, parts, false));
+          break;
+        case "1)":
+          doc.appendNode(parseList(text, parts, true));
+          break;
+        case "Img":
+          doc.appendNode(parseImg(parts));
+          break;
+        case "Code":
+          doc.appendNode(parseCode(text));
+          break;
+        case "Admonition":
+          doc.appendNode(parseAdmonition(parts));
+          break;
+        case "Comment":
+          skipComment();
+          break;
+        case "!!section":
+          doc.appendNode(parseSection(text));
+          break;
+        case "!!header":
+          parseHeaderFooter("header", text);
+          break;
+        case "!!footer":
+          parseHeaderFooter("footer", text);
+          break;
+        case "!!rule":
+          apllyRule(text);
+          break;
+        case "---":
+          doc.appendNode({ type: "pageBreak", sourceLine: lineI });
+          break;
+        case "":
+        case "	":
+          const last = doc.nodes.at(-1);
+          if (line.trim() != "" && last?.type == "text") {
+            if (last.text == "") last.sourceLine = lineI;
+            else last.text += "\n";
+            last.text += line.trim();
+          } else doc.appendText(line.trim(), lineI);
+          break;
+        default:
+          prefix;
+          throw new Error("switch default");
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Line ${lineI}: ${message}`, { cause: error });
     }
   }
+  doc.nodes.forEach((node) => {
+    if (node.type == "admonition" && node.title == "\n")
+      node.title = doc.admonition[node.admonitionType].title;
+  });
   doc.nodes = doc.nodes.filter((n) => n.type != "text" || n.text != "");
-  findDocs(doc.nodes, logwarn);
+  await findDocs(doc.nodes, warnAt);
+  findMath(doc.nodes, warnAt);
   findTables(doc.nodes);
-  findPageBreaks(doc.nodes);
   return doc;
 }
 function parseLine(line) {
@@ -504,7 +1436,7 @@ function parseLine(line) {
   const text = splited.slice(1).join(" ");
   let parts = [];
   if (prefix.startsWith("!")) {
-    const m_img = /!\[(.*)\]\((.*)\)({(.*)})?/.exec(line);
+    const m_img = /^!\[(.*)\]\((.*)\)({(.*)})?/.exec(line);
     if (m_img) return {
       prefix: "Img",
       text: line.trim(),
@@ -524,29 +1456,37 @@ function parseLine(line) {
     }
   }
   if (prefix.startsWith("```")) return { prefix: "Code", text: line.trim().slice(3), level, parts };
+  const m_admonition = /^(:{3,})(note|info|tip|warning|danger)(?:\[([^\]]*)\])?(?:\{([^}]*)\})?\s*$/i.exec(line.trim());
+  if (m_admonition) return {
+    prefix: "Admonition",
+    text: "",
+    level,
+    parts: [m_admonition[1], m_admonition[2].toLowerCase(), m_admonition[3] ?? "\n", m_admonition[4] || ""]
+  };
   if (prefix.startsWith("<!--")) return { prefix: "Comment", text: line.trim().slice("<!--".length).trim(), level, parts };
-  if (["#", "##", "###", "####", "#####", "######", "*", "1)", "!!section", "!!rule"].includes(prefix))
+  if (["#", "##", "###", "####", "#####", "######", "*", "1)", "!!section", "!!header", "!!footer", "!!rule"].includes(prefix))
     return { prefix, text, level: 0, parts };
   return { prefix: "", text: line.trim(), level, parts };
 }
-function findDocs(nodes, logwarn = console.warn) {
+async function findDocs(nodes, warnAt) {
+  const { default: JSONC } = await import("jsonc-simple-parser");
   const re_doc = /^!!\(([^{}]*)\)\s*{(.*)}$/s;
-  const re_remTrailingComma = /,(\s*[}\]])/g;
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
     if (node.type != "text") continue;
-    const m_doc = re_doc.exec(node.text.trimEnd().replaceAll(re_remTrailingComma, "$1"));
+    const m_doc = re_doc.exec(node.text.trimEnd());
     if (!m_doc) continue;
     let dict = {};
     try {
-      dict = JSON.parse(`{${m_doc[2]}}`);
+      dict = JSONC.parse(`{${m_doc[2]}}`);
     } catch {
-      logwarn(`Cant parse doc dict: {${m_doc[2].replaceAll("\n", " ")}}`);
+      warnAt(node.sourceLine ?? -1, `Cant parse doc dict: {${m_doc[2].replaceAll("\n", " ")}}`);
     }
     nodes.splice(i, 1, {
       type: "externalDoc",
       path: trimEnd(trimStart(m_doc[1], "<", '"'), ">", '"'),
-      dict: stringifyDict(dict)
+      dict: stringifyDict(dict),
+      sourceLine: node.sourceLine
     });
   }
 }
@@ -570,7 +1510,7 @@ function stringifyDict(dict) {
   }
   return r;
 }
-function findTables(nodes) {
+function findTables(nodes, hasHeader = true) {
   const re_sep = /^(\s*:?-+:?\s*(?<!\\)\|)+\s*:?-+:?\s*$/;
   const re_sep_oneCol = /^\|\s*:?-+:?\s*\|$/;
   const trim = (line) => {
@@ -585,19 +1525,20 @@ function findTables(nodes) {
     const lines = node.text.split("\n");
     const offset = lines[0].includes("|") ? 0 : 1;
     if (lines.length < 2 + offset) continue;
-    const sep = trim(lines[1 + offset]);
-    if (!re_sep.test(sep) && !re_sep_oneCol.test(lines[1 + offset])) continue;
-    const cols = sep.split("|");
+    const sep2 = trim(lines[1 + offset]);
+    if (!re_sep.test(sep2) && !re_sep_oneCol.test(lines[1 + offset])) continue;
+    const cols = sep2.split("|");
     const header = trim(lines[offset]).split(/(?<!\\)\|/).map((v) => v.trim());
     if (header.length != cols.length) continue;
     const align = cols.map((v) => v.trim()).map((v) => v.startsWith(":") && v.endsWith(":") ? "c" : v.endsWith(":") ? "r" : "l");
-    const rows = [tableRow(...header)];
+    let sourceLine = node.sourceLine + offset;
+    const rows = [tableRow(sourceLine++, ...header)];
     for (const line of lines.slice(2 + offset)) {
       const row = trim(line).split(/(?<!\\)\|/).map((v) => v.trim());
       while (row.length < cols.length) row.push("");
-      rows.push(tableRow(...row));
+      rows.push(tableRow(++sourceLine, ...row));
     }
-    const table = { type: "table", align, rows };
+    const table = { type: "table", align, rows, sourceLine: node.sourceLine, ...hasHeader ? {} : { header: false } };
     nodes.splice(i, 1, table);
     const prev = nodes[i - 1];
     if (offset > 0) {
@@ -609,43 +1550,133 @@ function findTables(nodes) {
     }
   }
 }
-function findPageBreaks(nodes) {
-  const re_sep = /^\s*---+\s*$/;
+function findMath(nodes, warnAt) {
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
-    if (node.type != "text") continue;
-    if (!node.text.includes("---")) continue;
+    if (node?.type != "text") continue;
     const lines = node.text.split("\n");
-    const newNodes = [];
-    for (const line of lines) {
-      if (re_sep.test(line)) newNodes.push({ type: "pageBreak" });
-      else {
-        const last = newNodes.at(-1);
-        if (last?.type == "text") last.text += "\n" + line;
-        else newNodes.push({ type: "text", text: line, noIndent: node.noIndent, noMargin: node.noMargin });
+    const replacement = [];
+    let text = [];
+    let textStart = 0;
+    const flush = () => {
+      if (text.length)
+        replacement.push({ type: "text", text: text.join("\n"), sourceLine: (node.sourceLine ?? 0) + textStart });
+      text = [];
+    };
+    for (let line = 0; line < lines.length; line++) {
+      if (lines[line]?.trim() != "$$") {
+        if (!text.length) textStart = line;
+        text.push(lines[line]);
+        continue;
       }
+      const start = line;
+      let end = line + 1;
+      while (end < lines.length && lines[end]?.trim() != "$$") end++;
+      if (end >= lines.length) {
+        warnAt((node.sourceLine ?? 0) + start, "Formula is not closed");
+        if (!text.length) textStart = line;
+        text.push(lines[line]);
+        continue;
+      }
+      let id;
+      let manualNumber;
+      const idMatch = /^\s*(\[[a-zA-Zа-яА-ЯёЁ_\d#]+\])\s*$/.exec(text.at(-1) || "");
+      const numberMatch = /^\s*(\(.*\))\s*$/.exec(text.at(-1) || "");
+      if (idMatch) {
+        id = `(${idMatch[1]})`;
+        text.pop();
+      } else if (numberMatch) {
+        manualNumber = numberMatch[1];
+        text.pop();
+      }
+      flush();
+      replacement.push({
+        type: "math",
+        latex: lines.slice(start + 1, end).join("\n").trim(),
+        title: id ?? manualNumber,
+        sourceLine: (node.sourceLine ?? 0) + start
+      });
+      line = end;
+      textStart = end + 1;
+    }
+    flush();
+    if (replacement.some((n) => n.type == "math")) {
+      nodes.splice(i, 1, ...replacement);
+      i += replacement.length - 1;
     }
-    nodes.splice(i, 1, ...newNodes);
-    i += newNodes.length - 1;
   }
 }
 function runifyDoc(doc) {
   function runifyNode(node) {
-    if ("text" in node && node.text)
+    if ("text" in node && node.text !== void 0)
       node.text = runifyText(node.text, doc.rainbow);
-    if ("title" in node && node.title)
+    if ("title" in node && node.title !== void 0)
       node.title = runifyText(node.title, doc.rainbow);
     if (node.type == "table")
       node.rows.forEach((row) => row.forEach(runifyNode));
     if (node.type == "list")
       node.items.forEach(runifyNode);
+    if (node.type == "sectionBreak") {
+      runifyHeaderFooter(node.header);
+      runifyHeaderFooter(node.footer);
+    }
   }
   doc.nodes.forEach(runifyNode);
+  runifyHeaderFooter(doc.header);
+  runifyHeaderFooter(doc.footer);
   return doc;
+  function runifyHeaderFooter(value) {
+    if (value?.type != "content") return;
+    value.nodes.forEach(runifyNode);
+  }
 }
 var rainbowI = 0;
 function runifyText(text, rainbow = false) {
-  return replaceAmpCodes(text).replaceAll("\n", "&Tab;\n").replaceAll(/\s*<br>\s*/g, "\n").replaceAll("\u2014", "-").replaceAll(" - ", " \u2013 ").replaceAll(/(?<=[\p{L}\p{N}])-(?=[\p{L}\p{N}])/gu, "\u2011").replaceAll(/(^|[^\p{L}\d_])"([\p{L}\d_])/gu, "$1\xAB$2").replaceAll(/([\p{L}\d_])"([^\p{L}\d_]|$)/gu, "$1\xBB$2").replaceAll(/(^|\s)(\*+)($|\s)/g, (sub) => sub.replaceAll("*", "&Star;")).split(/(\[[^\]]*\]\([^)]*\))/g).map((p) => {
+  const formulas = [];
+  const codeSpans = [];
+  function findClosingBackticks(from, count) {
+    for (let i = from; i < text.length; ) {
+      const start = text.indexOf("`", i);
+      if (start < 0) return -1;
+      let end = start + 1;
+      while (text[end] == "`") end++;
+      if (end - start == count) return start;
+      i = end;
+    }
+    return -1;
+  }
+  ;
+  let preprocessedText = "";
+  for (let i = 0; i < text.length; ) {
+    if (text[i] == "`") {
+      let delimiterEnd = i + 1;
+      while (text[delimiterEnd] == "`") delimiterEnd++;
+      const delimiterLength = delimiterEnd - i;
+      const end = findClosingBackticks(delimiterEnd, delimiterLength);
+      if (end >= 0) {
+        codeSpans.push(text.slice(delimiterEnd, end));
+        preprocessedText += `\uE002${codeSpans.length - 1}\uE003`;
+        i = end + delimiterLength;
+        continue;
+      }
+      preprocessedText += text.slice(i, delimiterEnd);
+      i = delimiterEnd;
+      continue;
+    }
+    if (text[i] == "$" && text[i - 1] != "\\" && text[i + 1] != "$") {
+      let end = i + 1;
+      while (end < text.length && text[end] != "\n" && (text[end] != "$" || text[end - 1] == "\\")) end++;
+      if (end < text.length && text[end] == "$") {
+        formulas.push(text.slice(i + 1, end));
+        preprocessedText += `\uE000${formulas.length - 1}\uE001`;
+        i = end + 1;
+        continue;
+      }
+    }
+    preprocessedText += text[i++];
+  }
+  text = preprocessedText.replaceAll("\\$", "$");
+  return replaceAmpCodes(text).replaceAll("\n", "&Tab;\n").replaceAll(/\s*<br>\s*/g, "\n").replaceAll("\u2014", "-").replaceAll(" - ", " \u2013 ").replaceAll(/(^|[^\p{L}\d_])"([\p{L}\d_])/gu, "$1\xAB$2").replaceAll(/([\p{L}\d_])"([^\p{L}\d_]|$)/gu, "$1\xBB$2").replaceAll(/(^|\s)(\*+)($|\s)/g, (sub) => sub.replaceAll("*", "&Star;")).split(/(\[[^\]]*\]\([^)]*\))/g).map((p) => {
     const m = /\[([^\]]*)\]\(([^)]*)\)/.exec(p);
     if (!m) return { text: p };
     return { text: m[1], link: m[2] };
@@ -671,17 +1702,23 @@ function runifyText(text, rainbow = false) {
     link: rune.link,
     bold: rune.bold,
     italic: i % 2 == 1 && i != arr.length - 1 || rune.italic
-  }))).flat().map((rune) => rune.text.split("```").map((p, i, arr) => ({
-    ...rune,
-    text: p,
-    linebreak: i == 0 && rune.linebreak,
-    mono: i % 2 == 1 && i != arr.length - 1
-  }))).flat().map((rune) => rune.mono ? rune : rune.text.split("`").map((p, i, arr) => ({
-    ...rune,
-    text: p,
-    linebreak: i == 0 && rune.linebreak,
-    mono: i % 2 == 1 && i != arr.length - 1
-  }))).flat().map((rune) => rune.link ? [rune] : rune.text.split(/(\[!?[a-zA-Zа-яА-ЯёЁ_\d#]+\s*[+-]?\s*\d*\])/g).map((p, i) => {
+  }))).flat().map((rune) => rune.text.split(/(\uE002\d+\uE003)/).map((p, i) => {
+    const m = /^\uE002(\d+)\uE003$/.exec(p);
+    return {
+      ...rune,
+      text: m ? codeSpans[parseInt(m[1])] : p,
+      mono: m ? true : rune.mono,
+      linebreak: i == 0 && rune.linebreak
+    };
+  })).flat().map((rune) => rune.mono ? [rune] : rune.text.split(/(\uE000\d+\uE001)/).map((p, i) => {
+    const m = /^\uE000(\d+)\uE001$/.exec(p);
+    return {
+      ...rune,
+      text: m ? formulas[parseInt(m[1])] : p,
+      type: m ? "math" : rune.type,
+      linebreak: i == 0 && rune.linebreak
+    };
+  })).flat().map((rune) => rune.link || rune.mono ? [rune] : rune.text.split(/(\[!?[a-zA-Zа-яА-ЯёЁ_\d#]+\s*[+-]?\s*\d*\])/g).map((p, i) => {
     const m = /\[(!?([a-zA-Zа-яА-ЯёЁ_\d]+|#)(\s*[-+]\s*\d+)?)\]/.exec(p);
     const v = m && m[1];
     const isVal = v?.at(0) == "!";
@@ -691,12 +1728,14 @@ function runifyText(text, rainbow = false) {
       type: v ? isVal ? "val" : "ref" : rune.type,
       linebreak: i == 0 && rune.linebreak
     };
-  })).flat().map((rune) => ({
+  })).flat().map((rune, i, arr) => ({
     ...rune,
     ...!rune.type || rune.type == "text" ? {
-      text: rune.text.replaceAll("&Star;", "*").replaceAll("&#x200B;", "")
+      text: formatTypography(
+        arr[i + 1]?.type == "ref" || arr[i + 1]?.type == "val" ? rune.text.replace(/[ \t]+$/, NBSP) : rune.text
+      ).replaceAll("&Star;", "*").replaceAll("&#x200B;", "")
     } : {}
-  })).map((rune) => !rainbow || rune.type && rune.type != "text" ? [rune] : rune.text.split("").map((p, i) => ({
+  })).map((rune) => !rainbow || rune.mono || rune.type && rune.type != "text" ? [rune] : rune.text.split("").map((p, i) => ({
     ...rune,
     text: p,
     linebreak: i == 0 && rune.linebreak,
@@ -706,6 +1745,7 @@ function runifyText(text, rainbow = false) {
 function replaceAmpCodes(text) {
   const codes = {
     "&#124;": "|",
+    "&amp;": "&",
     "&shy;": "\xAD",
     "&laquo;": "\xAB",
     "&raquo;": "\xBB",
@@ -777,90 +1817,616 @@ function replaceAmpCodes(text) {
   }
   return text;
 }
+var NBSP = "\xA0";
+var NON_BREAKING_HYPHEN = "\u2011";
+var shortWords = ["\u0430", "\u0432", "\u0432\u043E", "\u0438", "\u043A", "\u043A\u043E", "\u043E", "\u043E\u0431", "\u043E\u0442", "\u0441", "\u0441\u043E", "\u0443", "\u0431\u0435\u0437", "\u0434\u043E", "\u0437\u0430", "\u0438\u0437", "\u043D\u0430", "\u043D\u0435", "\u043F\u043E", "\u043F\u043E\u0434", "\u043F\u0440\u0438", "\u043F\u0440\u043E", "\u0434\u043B\u044F"];
+var referenceTerms = [
+  "\u0440\u0438\u0441\u0443\u043D\u043E\u043A",
+  "\u0440\u0438\u0441\u0443\u043D\u043A\u0430",
+  "\u0440\u0438\u0441\u0443\u043D\u043A\u0435",
+  "\u0440\u0438\u0441\u0443\u043D\u043A\u0443",
+  "\u0440\u0438\u0441\u0443\u043D\u043A\u043E\u043C",
+  "\u0440\u0438\u0441\u0443\u043D\u043A\u0438",
+  "\u0440\u0438\u0441\u0443\u043D\u043A\u043E\u0432",
+  "\u0440\u0438\u0441\u0443\u043D\u043A\u0430\u0445",
+  "\u0442\u0430\u0431\u043B\u0438\u0446\u0430",
+  "\u0442\u0430\u0431\u043B\u0438\u0446\u044B",
+  "\u0442\u0430\u0431\u043B\u0438\u0446\u0435",
+  "\u0442\u0430\u0431\u043B\u0438\u0446\u0443",
+  "\u0442\u0430\u0431\u043B\u0438\u0446\u0435\u0439",
+  "\u0442\u0430\u0431\u043B\u0438\u0446",
+  "\u0442\u0430\u0431\u043B\u0438\u0446\u0430\u0445",
+  "\u043B\u0438\u0441\u0442\u0438\u043D\u0433",
+  "\u043B\u0438\u0441\u0442\u0438\u043D\u0433\u0430",
+  "\u043B\u0438\u0441\u0442\u0438\u043D\u0433\u0435",
+  "\u043B\u0438\u0441\u0442\u0438\u043D\u0433\u0443",
+  "\u043B\u0438\u0441\u0442\u0438\u043D\u0433\u043E\u043C",
+  "\u043B\u0438\u0441\u0442\u0438\u043D\u0433\u0438",
+  "\u043B\u0438\u0441\u0442\u0438\u043D\u0433\u043E\u0432",
+  "\u043B\u0438\u0441\u0442\u0438\u043D\u0433\u0430\u0445",
+  "\u0444\u043E\u0440\u043C\u0443\u043B\u0430",
+  "\u0444\u043E\u0440\u043C\u0443\u043B\u044B",
+  "\u0444\u043E\u0440\u043C\u0443\u043B\u0435",
+  "\u0444\u043E\u0440\u043C\u0443\u043B\u0443",
+  "\u0444\u043E\u0440\u043C\u0443\u043B\u043E\u0439",
+  "\u0444\u043E\u0440\u043C\u0443\u043B",
+  "\u0444\u043E\u0440\u043C\u0443\u043B\u0430\u0445",
+  "\u0443\u0440\u0430\u0432\u043D\u0435\u043D\u0438\u0435",
+  "\u0443\u0440\u0430\u0432\u043D\u0435\u043D\u0438\u044F",
+  "\u0443\u0440\u0430\u0432\u043D\u0435\u043D\u0438\u0438",
+  "\u0443\u0440\u0430\u0432\u043D\u0435\u043D\u0438\u044E",
+  "\u0443\u0440\u0430\u0432\u043D\u0435\u043D\u0438\u0435\u043C",
+  "\u0443\u0440\u0430\u0432\u043D\u0435\u043D\u0438\u0439",
+  "\u0443\u0440\u0430\u0432\u043D\u0435\u043D\u0438\u044F\u0445",
+  "\u0440\u0430\u0437\u0434\u0435\u043B",
+  "\u0440\u0430\u0437\u0434\u0435\u043B\u0430",
+  "\u0440\u0430\u0437\u0434\u0435\u043B\u0435",
+  "\u0440\u0430\u0437\u0434\u0435\u043B\u0443",
+  "\u0440\u0430\u0437\u0434\u0435\u043B\u043E\u043C",
+  "\u0440\u0430\u0437\u0434\u0435\u043B\u044B",
+  "\u0440\u0430\u0437\u0434\u0435\u043B\u043E\u0432",
+  "\u0440\u0430\u0437\u0434\u0435\u043B\u0430\u0445",
+  "\u0433\u043B\u0430\u0432\u0430",
+  "\u0433\u043B\u0430\u0432\u044B",
+  "\u0433\u043B\u0430\u0432\u0435",
+  "\u0433\u043B\u0430\u0432\u0443",
+  "\u0433\u043B\u0430\u0432\u043E\u0439",
+  "\u0433\u043B\u0430\u0432",
+  "\u0433\u043B\u0430\u0432\u0430\u0445",
+  "\u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u0435",
+  "\u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F",
+  "\u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u0438",
+  "\u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044E",
+  "\u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u0435\u043C",
+  "\u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u0439",
+  "\u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F\u0445",
+  "\u043F\u0440\u0438\u043C\u0435\u0440",
+  "\u043F\u0440\u0438\u043C\u0435\u0440\u0430",
+  "\u043F\u0440\u0438\u043C\u0435\u0440\u0435",
+  "\u043F\u0440\u0438\u043C\u0435\u0440\u0443",
+  "\u043F\u0440\u0438\u043C\u0435\u0440\u043E\u043C",
+  "\u043F\u0440\u0438\u043C\u0435\u0440\u044B",
+  "\u043F\u0440\u0438\u043C\u0435\u0440\u043E\u0432",
+  "\u043F\u0440\u0438\u043C\u0435\u0440\u0430\u0445",
+  "\u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C",
+  "\u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C\u0430",
+  "\u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C\u0435",
+  "\u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C\u0443",
+  "\u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C\u043E\u043C",
+  "\u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C\u044B",
+  "\u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C\u043E\u0432",
+  "\u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C\u0430\u0445",
+  "\u0441\u0445\u0435\u043C\u0430",
+  "\u0441\u0445\u0435\u043C\u044B",
+  "\u0441\u0445\u0435\u043C\u0435",
+  "\u0441\u0445\u0435\u043C\u0443",
+  "\u0441\u0445\u0435\u043C\u043E\u0439",
+  "\u0441\u0445\u0435\u043C",
+  "\u0441\u0445\u0435\u043C\u0430\u0445"
+];
+var referenceAbbreviations = ["\u0440\u0438\u0441", "\u0442\u0430\u0431\u043B", "\u043B\u0438\u0441\u0442", "\u0444\u043E\u0440\u043C", "\u0443\u0440", "\u0440\u0430\u0437\u0434", "\u0433\u043B", "\u043F\u0440\u0438\u043B"];
+var units = ["%", "\xB0C", "\xB0F", "\u043C\u043C", "\u0441\u043C", "\u0434\u043C", "\u043A\u043C", "\u043C\u043A\u043C", "\u043D\u043C", "\u043C", "\u043C\u0433", "\u043A\u0433", "\u0433", "\u043C\u043B", "\u043B", "\u043C\u0441", "\u043C\u043A\u0441", "\u043D\u0441", "\u0441", "\u043C\u0438\u043D", "\u0447", "\u0413\u0446", "\u043A\u0413\u0446", "\u041C\u0413\u0446", "\u0413\u0413\u0446", "\u0412\u0442", "\u043A\u0412\u0442", "\u041C\u0412\u0442", "\u0412", "\u043A\u0412", "\u0410", "\u043C\u0410", "\u041E\u043C", "\u043A\u041E\u043C", "\u041C\u041E\u043C", "\u0411", "\u041A\u0411", "\u041C\u0411", "\u0413\u0411", "\u0422\u0411", "\u0431\u0438\u0442", "\u041A\u0431\u0438\u0442", "\u041C\u0431\u0438\u0442", "\u0413\u0431\u0438\u0442", "\u0431\u0438\u0442/\u0441", "\u041A\u0431\u0438\u0442/\u0441", "\u041C\u0431\u0438\u0442/\u0441", "\u0413\u0431\u0438\u0442/\u0441"];
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function createAlternation(values) {
+  return [...values].sort((a, b) => b.length - a.length).map(escapeRegExp).join("|");
+}
+var shortWordsPattern = createAlternation(shortWords);
+var referenceTermsPattern = createAlternation(referenceTerms);
+var referenceAbbreviationsPattern = createAlternation(referenceAbbreviations);
+var unitsPattern = createAlternation(units);
+var referenceIdentifierPattern = String.raw`(?:\(\s*\d+(?:\.\d+)*\s*\)|\d+(?:\.\d+)*|[А-ЯЁA-Z](?:[^\p{L}]|$))`;
+function formatTypography(text) {
+  return text.replace(
+    new RegExp(`(^|[^\\p{L}\\p{N}_])(${shortWordsPattern})[ \\t]+(?=\\S)`, "giu"),
+    (_, prefix, word) => `${prefix}${word}${NBSP}`
+  ).replace(
+    new RegExp(`(^|[^\\p{L}\\p{N}_])(${referenceTermsPattern})[ \\t]+(?=${referenceIdentifierPattern})`, "giu"),
+    (_, prefix, term) => `${prefix}${term}${NBSP}`
+  ).replace(
+    new RegExp(`(^|[^\\p{L}\\p{N}_])(${referenceAbbreviationsPattern})\\.[ \\t]+(?=${referenceIdentifierPattern})`, "giu"),
+    (_, prefix, abbreviation) => `${prefix}${abbreviation}.${NBSP}`
+  ).replace(/\b(п|пп|ч|ст|с|стр|абз)\.[ \t]+(?=\d)/giu, `$1.${NBSP}`).replace(/№[ \t]+(?=\d)/gu, `\u2116${NBSP}`).replace(/(§§?)[ \t]+(?=\d)/gu, `$1${NBSP}`).replace(/\b(ГОСТ)[ \t]+(?=Р(?:[ \t]+\d)|\d)/giu, `$1${NBSP}`).replace(
+    /\b(ГОСТ\u00A0Р|ГОСТ Р)[ \t]+(?=\d)/giu,
+    (_, standard) => `${standard.replace(" ", NBSP)}${NBSP}`
+  ).replace(/\b(ISO|IEC|IEEE|RFC|DIN|EN)[ \t]+(?=\d)/g, `$1${NBSP}`).replace(/\b(г|ул|пр|просп|пер|бул|наб|пл|д|корп|стр|кв)\.[ \t]+(?=\S)/giu, `$1.${NBSP}`).replace(/(\d{4})[ \t]+(?=гг?\.)/gu, `$1${NBSP}`).replace(/([А-ЯЁA-Z])\.[ \t]+([А-ЯЁA-Z])\.[ \t]+(?=[А-ЯЁA-Z][\p{L}-]+)/gu, `$1.${NBSP}$2.${NBSP}`).replace(/([А-ЯЁA-Z])\.[ \t]+(?=[А-ЯЁA-Z][\p{L}-]+)/gu, `$1.${NBSP}`).replace(new RegExp(`(\\d)[ \\t]+(?=(?:${unitsPattern})(?=$|[^\\p{L}]))`, "giu"), `$1${NBSP}`).replaceAll(/(?<=[\p{L}\p{N}])-(?=[\p{L}\p{N}])/gu, NON_BREAKING_HYPHEN);
+}
 
 // src/serializer.ts
-import * as fs3 from "fs";
-import { AlignmentType, Document, Footer, convertMillimetersToTwip, Packer, PageBreak, PageNumber, Paragraph, TableOfContents, TextRun, LevelFormat, Table, TableRow, TableCell, ImageRun, ExternalHyperlink, InternalHyperlink, Bookmark, XmlComponent, LineRuleType, PageOrientation } from "docx";
+import * as fs4 from "fs";
+import { AlignmentType, BorderStyle, Document, Footer, Header, convertMillimetersToTwip, Packer, PageBreak, PageNumber, Paragraph, TableOfContents, TextRun, LevelFormat, Table, TableRow, TableCell, ImageRun, ExternalHyperlink, InternalHyperlink, Bookmark, XmlComponent as XmlComponent2, LineRuleType, PageOrientation, VerticalAlignTable } from "docx";
 import { imageSize } from "image-size";
-import path3 from "path";
-import Prism from "prismjs";
-import "prismjs/components/prism-clike";
-import "prismjs/components/prism-markup";
-import "prismjs/components/prism-css";
-import "prismjs/components/prism-javascript";
-import "prismjs/components/prism-typescript";
-import "prismjs/components/prism-jsx";
-import "prismjs/components/prism-tsx";
-import "prismjs/components/prism-json";
-import "prismjs/components/prism-bash";
-import "prismjs/components/prism-powershell";
-import "prismjs/components/prism-python";
-import "prismjs/components/prism-java";
-import "prismjs/components/prism-c";
-import "prismjs/components/prism-cpp";
-import "prismjs/components/prism-csharp";
-import "prismjs/components/prism-go";
-import "prismjs/components/prism-rust";
-import "prismjs/components/prism-php";
-import "prismjs/components/prism-ruby";
-import "prismjs/components/prism-swift";
-import "prismjs/components/prism-kotlin";
-import "prismjs/components/prism-sql";
-import "prismjs/components/prism-yaml";
-import "prismjs/components/prism-markdown";
-import "prismjs/components/prism-docker";
-import "prismjs/components/prism-nginx";
+import path4 from "path";
 
-// src/errors.ts
-var UserInputError = class extends Error {
-  constructor(message) {
-    super(message);
+// src/math.ts
+import { XmlComponent } from "docx";
+var Omml = class extends XmlComponent {
+  constructor(tag, children = [], attributes = {}) {
+    super(tag);
+    if (Object.keys(attributes).length) this.root.push({ _attr: attributes });
+    this.root.push(...children);
+  }
+};
+var symbols = {
+  alpha: "\u03B1",
+  beta: "\u03B2",
+  gamma: "\u03B3",
+  delta: "\u03B4",
+  epsilon: "\u03B5",
+  varepsilon: "\u03B5",
+  zeta: "\u03B6",
+  eta: "\u03B7",
+  theta: "\u03B8",
+  vartheta: "\u03D1",
+  iota: "\u03B9",
+  kappa: "\u03BA",
+  lambda: "\u03BB",
+  mu: "\u03BC",
+  nu: "\u03BD",
+  xi: "\u03BE",
+  pi: "\u03C0",
+  rho: "\u03C1",
+  sigma: "\u03C3",
+  tau: "\u03C4",
+  upsilon: "\u03C5",
+  phi: "\u03C6",
+  varphi: "\u03D5",
+  chi: "\u03C7",
+  psi: "\u03C8",
+  omega: "\u03C9",
+  Gamma: "\u0393",
+  Delta: "\u0394",
+  Theta: "\u0398",
+  Lambda: "\u039B",
+  Xi: "\u039E",
+  Pi: "\u03A0",
+  Sigma: "\u03A3",
+  Upsilon: "\u03A5",
+  Phi: "\u03A6",
+  Psi: "\u03A8",
+  Omega: "\u03A9",
+  cdot: "\xB7",
+  times: "\xD7",
+  div: "\xF7",
+  pm: "\xB1",
+  mp: "\u2213",
+  ast: "\u2217",
+  star: "\u22C6",
+  circ: "\u2218",
+  bullet: "\u2219",
+  oplus: "\u2295",
+  ominus: "\u2296",
+  otimes: "\u2297",
+  oslash: "\u2298",
+  odot: "\u2299",
+  setminus: "\u2216",
+  wedge: "\u2227",
+  vee: "\u2228",
+  le: "\u2264",
+  leq: "\u2264",
+  ge: "\u2265",
+  geq: "\u2265",
+  neq: "\u2260",
+  ne: "\u2260",
+  approx: "\u2248",
+  equiv: "\u2261",
+  sim: "\u223C",
+  simeq: "\u2243",
+  cong: "\u2245",
+  propto: "\u221D",
+  ll: "\u226A",
+  gg: "\u226B",
+  infty: "\u221E",
+  partial: "\u2202",
+  nabla: "\u2207",
+  in: "\u2208",
+  notin: "\u2209",
+  ni: "\u220B",
+  subset: "\u2282",
+  subseteq: "\u2286",
+  superset: "\u2283",
+  supseteq: "\u2287",
+  emptyset: "\u2205",
+  varnothing: "\u2205",
+  cup: "\u222A",
+  cap: "\u2229",
+  perp: "\u22A5",
+  parallel: "\u2225",
+  mid: "\u2223",
+  angle: "\u2220",
+  therefore: "\u2234",
+  because: "\u2235",
+  to: "\u2192",
+  rightarrow: "\u2192",
+  leftarrow: "\u2190",
+  leftrightarrow: "\u2194",
+  mapsto: "\u21A6",
+  Rightarrow: "\u21D2",
+  Leftarrow: "\u21D0",
+  Leftrightarrow: "\u21D4",
+  uparrow: "\u2191",
+  downarrow: "\u2193",
+  updownarrow: "\u2195",
+  forall: "\u2200",
+  exists: "\u2203",
+  neg: "\xAC",
+  land: "\u2227",
+  lor: "\u2228",
+  degree: "\xB0",
+  ell: "\u2113",
+  prime: "\u2032",
+  hbar: "\u210F",
+  aleph: "\u2135",
+  Re: "\u211C",
+  Im: "\u2111",
+  ldots: "\u2026",
+  dots: "\u2026",
+  cdots: "\u22EF",
+  vdots: "\u22EE",
+  ddots: "\u22F1"
+};
+var operators = { sin: "sin", cos: "cos", tan: "tan", cot: "cot", sec: "sec", csc: "csc", log: "log", ln: "ln", exp: "exp", max: "max", min: "min", gcd: "gcd", det: "det" };
+function run(text, style) {
+  const value = style == "plain" ? "p" : style == "bold" ? "b" : style == "italic" ? "i" : void 0;
+  return new Omml("m:r", [
+    ...style == "double-struck" || style == "script" ? [new Omml("m:rPr", [new Omml("m:scr", [], { "m:val": style }), new Omml("m:sty", [], { "m:val": "p" })])] : [],
+    ...value ? [new Omml("m:rPr", [new Omml("m:sty", [], { "m:val": value })])] : [],
+    new Omml("m:t", [text], { "xml:space": "preserve" })
+  ]);
+}
+function arg(children) {
+  return new Omml("m:e", children);
+}
+function delimiter(children, begin, end) {
+  return new Omml("m:d", [
+    new Omml("m:dPr", [new Omml("m:begChr", [], { "m:val": begin }), new Omml("m:endChr", [], { "m:val": end })]),
+    arg(children)
+  ]);
+}
+function latexToOmml(latex, para = false) {
+  const parser = new LatexParser(latex);
+  const body = parser.sequence();
+  if (!parser.done()) throw new Error(`unexpected "${parser.peek()}"`);
+  const math = new Omml("m:oMath", body);
+  return para ? new Omml("m:oMathPara", [math]) : math;
+}
+var LatexParser = class {
+  constructor(source) {
+    this.source = source;
+  }
+  source;
+  i = 0;
+  done() {
+    return this.i >= this.source.length;
+  }
+  peek() {
+    return this.source[this.i] || "";
+  }
+  take() {
+    return this.source[this.i++] || "";
+  }
+  skipWhitespace() {
+    while (/\s/.test(this.peek())) this.take();
+  }
+  command(name) {
+    return this.source.slice(this.i).startsWith(`\\${name}`) && !/[A-Za-z]/.test(this.source[this.i + name.length + 1] || "");
+  }
+  sequence(stop, style, preserveWhitespace = false, boundary) {
+    const result = [];
+    while (!this.done() && this.peek() != stop && !boundary?.()) {
+      if (/\s/.test(this.peek())) {
+        this.take();
+        if (preserveWhitespace) result.push(run(" ", style));
+        continue;
+      }
+      if (this.command("displaystyle") || this.command("textstyle")) {
+        this.take();
+        while (/[A-Za-z]/.test(this.peek())) this.take();
+        continue;
+      }
+      if (this.source.startsWith("\\!", this.i)) {
+        this.i += 2;
+        continue;
+      }
+      result.push(this.decoratedAtom(style, preserveWhitespace));
+    }
+    if (stop) {
+      if (this.take() != stop) throw new Error(`missing "${stop}"`);
+    }
+    return result;
+  }
+  decoratedAtom(style, preserveWhitespace = false) {
+    let value = this.atom(style, preserveWhitespace);
+    let sub;
+    let sup;
+    while (true) {
+      const beforeSpace = this.i;
+      this.skipWhitespace();
+      if (this.peek() != "_" && this.peek() != "^") {
+        this.i = beforeSpace;
+        break;
+      }
+      const marker = this.take();
+      const script = this.groupOrAtom(style);
+      if (marker == "_" ? sub : sup) throw new Error("duplicate script");
+      if (marker == "_") sub = script;
+      else sup = script;
+    }
+    if (sub && sup) value = new Omml("m:sSubSup", [new Omml("m:e", [value]), new Omml("m:sub", sub), new Omml("m:sup", sup)]);
+    else if (sub) value = new Omml("m:sSub", [new Omml("m:e", [value]), new Omml("m:sub", sub)]);
+    else if (sup) value = new Omml("m:sSup", [new Omml("m:e", [value]), new Omml("m:sup", sup)]);
+    return value;
+  }
+  groupOrAtom(style, preserveWhitespace = false) {
+    this.skipWhitespace();
+    if (this.done() || ["}", "_", "^", "&"].includes(this.peek())) throw new Error("argument expected");
+    if (this.peek() == "{") {
+      this.take();
+      return this.sequence("}", style, preserveWhitespace);
+    }
+    return [this.atom(style)];
+  }
+  atom(style, preserveWhitespace = false) {
+    const ch = this.take();
+    if (!ch || ["}", "_", "^", "&"].includes(ch)) throw new Error(`unexpected "${ch}"`);
+    if (ch == "{") return new Omml("m:box", [arg(this.sequence("}", style, preserveWhitespace))]);
+    if (ch != "\\") return run(ch, style);
+    let name = "";
+    while (/[A-Za-z]/.test(this.peek())) name += this.take();
+    if (!name) {
+      const escaped = this.take();
+      if (!escaped) throw new Error("command expected");
+      const spaces = { ",": "\u2009", ";": "\u2004", ":": "\u2005", " ": " " };
+      if (spaces[escaped]) return run(spaces[escaped], style);
+      if (escaped == "!") return run("", style);
+      return run(escaped, style);
+    }
+    this.skipWhitespace();
+    if (name == "frac" || name == "dfrac" || name == "tfrac") return new Omml("m:f", [new Omml("m:num", this.groupOrAtom(style)), new Omml("m:den", this.groupOrAtom(style))]);
+    if (name == "sqrt") {
+      let degree;
+      if (this.peek() == "[") {
+        this.take();
+        degree = this.sequence("]", style);
+      }
+      return new Omml("m:rad", [new Omml("m:radPr", degree ? [] : [new Omml("m:degHide", [], { "m:val": "1" })]), new Omml("m:deg", degree || []), arg(this.groupOrAtom(style))]);
+    }
+    if (name == "text") return new Omml("m:box", [arg(this.groupOrAtom("plain", true))]);
+    if (name == "mathrm" || name == "operatorname") return new Omml("m:box", [arg(this.groupOrAtom("plain"))]);
+    if (name == "mathbf") return new Omml("m:box", [arg(this.groupOrAtom("bold"))]);
+    if (name == "mathit") return new Omml("m:box", [arg(this.groupOrAtom("italic"))]);
+    if (["mathbb", "mathcal"].includes(name)) return new Omml("m:box", [arg(this.groupOrAtom(name == "mathbb" ? "double-struck" : "script"))]);
+    if (["hat", "widehat", "vec"].includes(name)) {
+      const chr = name == "vec" ? "\u20D7" : "\u0302";
+      return new Omml("m:acc", [new Omml("m:accPr", [new Omml("m:chr", [], { "m:val": chr })]), arg(this.groupOrAtom(style))]);
+    }
+    if (["overline", "bar", "underline"].includes(name)) {
+      const pos = name == "underline" ? "bot" : "top";
+      return new Omml("m:bar", [new Omml("m:barPr", [new Omml("m:pos", [], { "m:val": pos })]), arg(this.groupOrAtom(style))]);
+    }
+    if (name == "binom" || name == "dbinom") return delimiter([new Omml("m:f", [new Omml("m:fPr", [new Omml("m:type", [], { "m:val": "noBar" })]), new Omml("m:num", this.groupOrAtom(style)), new Omml("m:den", this.groupOrAtom(style))])], "(", ")");
+    if (name == "lim") {
+      let below = true;
+      if (this.command("limits") || this.command("nolimits")) {
+        below = this.command("limits");
+        this.i += below ? 7 : 9;
+        this.skipWhitespace();
+      }
+      let sub = [];
+      if (this.peek() == "_") {
+        this.take();
+        sub = this.groupOrAtom(style);
+      }
+      if (!sub.length) return run("lim", "plain");
+      return new Omml(below ? "m:limLow" : "m:sSub", [arg([run("lim", "plain")]), new Omml(below ? "m:lim" : "m:sub", sub)]);
+    }
+    if (["sum", "prod", "int", "iint", "iiint"].includes(name)) {
+      const chr = name == "sum" ? "\u2211" : name == "prod" ? "\u220F" : name == "iint" ? "\u222C" : name == "iiint" ? "\u222D" : "\u222B";
+      let sub = [], sup = [];
+      let limitLocation;
+      while (true) {
+        this.skipWhitespace();
+        if (this.command("limits") || this.command("nolimits")) {
+          const limits = this.command("limits");
+          this.i += limits ? 7 : 9;
+          limitLocation = limits ? "undOvr" : "subSup";
+          continue;
+        }
+        if (this.peek() != "_" && this.peek() != "^") break;
+        const marker = this.take();
+        const script = this.groupOrAtom(style);
+        if (marker == "_" ? sub.length : sup.length) throw new Error("duplicate script");
+        if (marker == "_") sub = script;
+        else sup = script;
+        this.skipWhitespace();
+      }
+      while (/\s/.test(this.peek())) this.take();
+      const operand = this.done() || ["}", "]", ")", "&", "=", "<", ">"].includes(this.peek()) || this.command("right") || this.command("end") || this.source.startsWith("\\\\", this.i) ? [] : [this.decoratedAtom(style)];
+      return new Omml("m:nary", [new Omml("m:naryPr", [
+        new Omml("m:chr", [], { "m:val": chr }),
+        ...limitLocation ? [new Omml("m:limLoc", [], { "m:val": limitLocation })] : [],
+        new Omml("m:subHide", [], { "m:val": sub.length ? "0" : "1" }),
+        new Omml("m:supHide", [], { "m:val": sup.length ? "0" : "1" })
+      ]), new Omml("m:sub", sub), new Omml("m:sup", sup), arg(operand)]);
+    }
+    if (name == "left") {
+      const begin = this.readDelimiter();
+      const body = this.sequence(void 0, style, false, () => this.command("right"));
+      if (!this.command("right")) throw new Error("missing \\right");
+      this.i += 6;
+      return delimiter(body, begin, this.readDelimiter());
+    }
+    if (name == "begin") return this.matrix(style);
+    if (symbols[name]) return run(symbols[name], style);
+    if (operators[name]) return run(operators[name], "plain");
+    if (["quad", "qquad"].includes(name)) return run(name == "quad" ? "\u2003" : "\u2003\u2003", style);
+    throw new Error(`unsupported command \\${name}`);
+  }
+  readDelimiter() {
+    this.skipWhitespace();
+    const ch = this.take();
+    if (ch == ".") return "";
+    if (ch && "()[]|{}".includes(ch)) return ch;
+    if (ch == "\\") {
+      let name = "";
+      while (/[A-Za-z]/.test(this.peek())) name += this.take();
+      if (!name) name = this.take();
+      const delimiters = { "{": "{", "}": "}", "|": "\u2016", lbrace: "{", rbrace: "}", langle: "\u27E8", rangle: "\u27E9", lvert: "|", rvert: "|", vert: "|", lVert: "\u2016", rVert: "\u2016", Vert: "\u2016" };
+      if (delimiters[name]) return delimiters[name];
+    }
+    throw new Error("delimiter expected");
+  }
+  matrix(style) {
+    if (this.peek() != "{") throw new Error("environment name expected");
+    this.take();
+    let env = "";
+    while (!this.done() && this.peek() != "}") env += this.take();
+    this.take();
+    if (!["matrix", "pmatrix", "bmatrix", "cases"].includes(env)) throw new Error(`unsupported environment ${env}`);
+    const rows = [];
+    let cells = [];
+    while (true) {
+      this.skipWhitespace();
+      if (this.done()) throw new Error(`environment ${env} is not closed`);
+      if (this.command("end")) {
+        this.i += 4;
+        this.skipWhitespace();
+        const closing = `{${env}}`;
+        if (!this.source.startsWith(closing, this.i)) throw new Error(`mismatched environment ${env}`);
+        this.i += closing.length;
+        if (cells.length) rows.push(new Omml("m:mr", cells));
+        break;
+      }
+      cells.push(arg(this.sequence(void 0, style, false, () => this.peek() == "&" || this.source.startsWith("\\\\", this.i) || this.command("end"))));
+      if (this.peek() == "&") {
+        this.take();
+        continue;
+      }
+      if (this.source.startsWith("\\\\", this.i)) {
+        this.i += 2;
+        rows.push(new Omml("m:mr", cells));
+        cells = [];
+      }
+    }
+    const matrix = new Omml("m:m", rows);
+    if (env == "pmatrix") return delimiter([matrix], "(", ")");
+    if (env == "bmatrix") return delimiter([matrix], "[", "]");
+    if (env == "cases") return delimiter([matrix], "{", "");
+    return matrix;
   }
 };
 
 // src/serializer.ts
+import Prism from "prismjs";
+import "prismjs/components/prism-clike.js";
+import "prismjs/components/prism-markup.js";
+import "prismjs/components/prism-css.js";
+import "prismjs/components/prism-javascript.js";
+import "prismjs/components/prism-typescript.js";
+import "prismjs/components/prism-jsx.js";
+import "prismjs/components/prism-tsx.js";
+import "prismjs/components/prism-json.js";
+import "prismjs/components/prism-bash.js";
+import "prismjs/components/prism-powershell.js";
+import "prismjs/components/prism-python.js";
+import "prismjs/components/prism-java.js";
+import "prismjs/components/prism-c.js";
+import "prismjs/components/prism-cpp.js";
+import "prismjs/components/prism-csharp.js";
+import "prismjs/components/prism-go.js";
+import "prismjs/components/prism-rust.js";
+import "prismjs/components/prism-php.js";
+import "prismjs/components/prism-ruby.js";
+import "prismjs/components/prism-swift.js";
+import "prismjs/components/prism-kotlin.js";
+import "prismjs/components/prism-sql.js";
+import "prismjs/components/prism-yaml.js";
+import "prismjs/components/prism-markdown.js";
+import "prismjs/components/prism-docker.js";
+import "prismjs/components/prism-nginx.js";
 var STYLE_list = "afc";
 var STYLE_table_title = "TableCaption";
 var STYLE_code_title = "ListingCaption";
 var STYLE_code = "ListingCode";
-async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath) {
-  const allowedRealPath = checkFilesIsInsidePath === false ? false : realpathAllowMissing(checkFilesIsInsidePath === "" ? workdir : checkFilesIsInsidePath);
-  const getPath = (fname) => {
-    if (process.platform != "win32") fname = fname.replaceAll("\\", "/");
-    if (process.platform == "win32" && fname.startsWith("/")) fname = "." + fname;
-    const targetPath = path3.isAbsolute(fname) ? path3.resolve(fname) : path3.resolve(workdir, fname);
-    if (allowedRealPath !== false) {
-      const targetRealPath = realpathAllowMissing(targetPath);
-      const relative = path3.relative(allowedRealPath, targetRealPath);
-      const isOutside = relative === ".." || relative.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative);
-      if (isOutside) throw new UserInputError(`Access denied: "${fname}" resolves outside the working directory.`);
-    }
-    return targetPath;
-  };
+async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath, logwarn = console.warn) {
+  const { resolvePath: getPath } = getSafePathResolver(workdir, checkFilesIsInsidePath);
   const sections = [];
   const numbering = [];
   const docSections = (function splitSections() {
-    const sections2 = [{ displayPageNum: true, orientation: "portrait", pageStart: 1, nodes: [] }];
+    let header = doc.header;
+    let footer = doc.footer;
+    const sections2 = [{ displayPageNum: true, orientation: "portrait", pageStart: 1, header, footer, nodes: [] }];
     for (let j = 0; j < doc.nodes.length; j++) {
       const node = doc.nodes[j];
-      if (node.type == "sectionBreak")
+      if (node.type == "sectionBreak") {
+        header = node.header ?? header;
+        footer = node.footer ?? footer;
         sections2.push({
-          displayPageNum: node.pageStart == null ? sections2.at(-1)?.displayPageNum || true : node.pageStart >= 0,
+          displayPageNum: node.pageStart == null ? sections2.at(-1)?.displayPageNum ?? true : node.pageStart >= 0,
           orientation: node.orientation || sections2.at(-1)?.orientation || "portrait",
           pageStart: node.pageStart,
+          header,
+          footer,
           nodes: []
         });
-      else
+      } else
         sections2.at(-1)?.nodes.push(node);
     }
     return sections2.filter((s) => s.nodes.length > 0);
   })();
   for (const section of docSections) {
-    let renderNode2 = function(node, prevChild, prevNode) {
+    let renderHeaderFooter2 = function(value, isFooter) {
+      if (value.type == "none") return void 0;
+      if (value.type == "auto") {
+        if (!isFooter) return void 0;
+        return new Footer({
+          children: [new Paragraph({
+            alignment: AlignmentType.CENTER,
+            children: [new TextRun({ children: section.displayPageNum ? [PageNumber.CURRENT] : [] })],
+            indent: { firstLine: 0 },
+            spacing: { after: 0, line: 240 }
+          })]
+        });
+      }
+      const contentValue = value;
+      const content = contentValue.nodes.flatMap((node) => {
+        if (node.type == "text") return [new Paragraph({
+          children: renderText(node.text, node.sourceLine),
+          alignment: contentValue.align,
+          indent: { firstLine: 0 },
+          spacing: isFooter ? { after: 0, line: 240 } : { line: 240 }
+        })];
+        return [renderHeaderFooterTable2(node)];
+      });
+      return isFooter ? new Footer({ children: content }) : new Header({ children: content });
+    }, renderHeaderFooterTable2 = function(node) {
+      return new Table({
+        width: { type: "dxa", size: convertMillimetersToTwip(section.orientation == "landscape" ? 255.8 : 168.8) },
+        borders: {
+          top: { style: BorderStyle.SINGLE, size: 4, color: "808080" },
+          bottom: { style: BorderStyle.SINGLE, size: 4, color: "808080" },
+          left: { style: BorderStyle.SINGLE, size: 4, color: "808080" },
+          right: { style: BorderStyle.SINGLE, size: 4, color: "808080" },
+          insideHorizontal: { style: BorderStyle.SINGLE, size: 4, color: "808080" },
+          insideVertical: { style: BorderStyle.SINGLE, size: 4, color: "808080" }
+        },
+        rows: node.rows.map((row) => new TableRow({
+          children: row.map((cell, colI) => new TableCell({
+            children: cell.type == "text" ? [new Paragraph({
+              children: renderText(cell.text, node.sourceLine),
+              alignment: node.align[colI] == "c" ? "center" : node.align[colI] == "r" ? "right" : "left",
+              indent: { firstLine: 0 },
+              spacing: { after: 0, line: 240 * 1.25 }
+            })] : []
+          }))
+        }))
+      });
+    }, renderNode2 = function(node, prevChild, prevNode) {
       switch (node.type) {
         case "text":
           return new Paragraph({
-            children: renderText(node.text),
+            children: renderText(node.text, node.sourceLine),
             indent: node.noIndent ? { firstLine: 0 } : {},
             ...node.center ? { alignment: "center", indent: { firstLine: 0 } } : {},
             spacing: {
@@ -874,7 +2440,7 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
           const styles = doc.headings[`h${level}`];
           if (styles.uppercase) node.text.forEach((r) => r.text = r.text.toUpperCase());
           return new Paragraph({
-            children: renderText(node.text, styles.size),
+            children: renderText(node.text, node.sourceLine, styles.size),
             style: `${node.level}`,
             ...node.center ? { alignment: "center", indent: { firstLine: 0 } } : {},
             ...!node.center && node.level != 0 && styles.indent_full ? { indent: { firstLine: 0, left: convertMillimetersToTwip(12.5) } } : {},
@@ -898,7 +2464,7 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
               if (item.type == "list") renderList2({ ...item, alternativeStyle: !!node2.alternativeStyle }, level2 + 1);
               else {
                 items.push(new Paragraph({
-                  children: renderText(item.text),
+                  children: renderText(item.text, item.sourceLine ?? node2.sourceLine),
                   style: STYLE_list,
                   numbering: { reference: id, level: level2 },
                   spacing: {
@@ -922,13 +2488,13 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
           renderList2(node);
           return items;
         case "table":
-          if (node.rows[0] && doc.table.heading.style == "italic") node.rows[0].forEach((n) => n.type == "text" ? n.text.forEach((r) => r.italic = true) : 0);
-          if (node.rows[0] && doc.table.heading.style == "bold") node.rows[0].forEach((n) => n.type == "text" ? n.text.forEach((r) => r.bold = true) : 0);
+          if (node.header !== false && node.rows[0] && doc.table.heading.style == "italic") node.rows[0].forEach((n) => n.type == "text" ? n.text.forEach((r) => r.italic = true) : 0);
+          if (node.header !== false && node.rows[0] && doc.table.heading.style == "bold") node.rows[0].forEach((n) => n.type == "text" ? n.text.forEach((r) => r.bold = true) : 0);
           const spacingInner = Math.max(doc.table.spacing.after ?? doc.text.spacing.after, doc.table.spacing.before ?? 0);
           return [
             ...node.title ? [
               new Paragraph({
-                children: renderText(node.title, doc.table.title.size),
+                children: renderText(node.title, node.sourceLine, doc.table.title.size),
                 style: STYLE_table_title,
                 ...prevChild instanceof Table ? { spacing: { before: spacingInner * 20 } } : doc.table.spacing.before ? { spacing: { before: doc.table.spacing.before * 20 } } : {}
               })
@@ -944,13 +2510,13 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
                 size: convertMillimetersToTwip(section.orientation === "landscape" ? 255.8 : 168.8)
               },
               rows: node.rows.map((row, rowI) => new TableRow({
-                tableHeader: rowI == 0,
+                tableHeader: node.header !== false && rowI == 0,
                 cantSplit: true,
                 children: row.map((item, colI) => new TableCell({
                   children: item.type != "text" ? renderNodeL2(item) : [
                     new Paragraph({
-                      children: renderText(item.text, node.normalFontSize ? void 0 : doc.table.text.size),
-                      alignment: rowI == 0 ? doc.table.heading.align : node.align[colI] == "c" ? "center" : node.align[colI] == "r" ? "right" : "left",
+                      children: renderText(item.text, node.sourceLine, node.normalFontSize ? void 0 : doc.table.text.size),
+                      alignment: node.header !== false && rowI == 0 ? doc.table.heading.align : node.align[colI] == "c" ? "center" : node.align[colI] == "r" ? "right" : "left",
                       indent: { firstLine: 0 },
                       spacing: { after: 0, line: 240 * doc.table.text.line_spacing }
                     })
@@ -968,13 +2534,13 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
             new Paragraph({ children: [new PageBreak()] })
           ];
         case "image":
-          const type = node.src.split(".").at(-1) || "";
+          const type = (node.src.split(".").at(-1) || "").toLowerCase();
           if (!["jpg", "png", "gif", "bmp", "svg"].includes(type))
             throw new UserInputError(`Unsupported image format: "${type}", file: ${node.src}`);
           const img_path = getPath(node.src);
-          if (!fs3.existsSync(img_path))
+          if (!fs4.existsSync(img_path))
             throw new UserInputError(`File not exist: ${node.src}`);
-          const data = fs3.readFileSync(img_path);
+          const data = fs4.readFileSync(img_path);
           const dimensions = imageSize(data);
           const [MaxW, MaxH] = section.orientation == "landscape" ? [950, 600] : [600, 900];
           let [width, height] = [dimensions.width, dimensions.height];
@@ -1006,7 +2572,7 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
             }),
             ...node.text ? [
               new Paragraph({
-                children: renderText(node.text, doc.img.text.size),
+                children: renderText(node.text, node.sourceLine, doc.img.text.size),
                 alignment: "center",
                 indent: { firstLine: 0 },
                 spacing: {
@@ -1021,7 +2587,7 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
           return [
             ...node.title ? [
               new Paragraph({
-                children: renderText(node.title, doc.code.title.size),
+                children: renderText(node.title, node.sourceLine, doc.code.title.size),
                 style: STYLE_code_title
               })
             ] : prevNode?.type == "code" ? [
@@ -1033,11 +2599,44 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
               ...i == 0 && !node.title && doc.code.spacing.before && prevNode?.type != "code" ? { spacing: { before: doc.code.spacing.before * 20 } } : {}
             }))
           ];
+        case "math":
+          const formulaWidth = convertMillimetersToTwip(section.orientation == "landscape" ? 255.8 : 168.8);
+          const number = node.title?.map((rune) => rune.text).join("") || "";
+          const sideWidth = Math.max(
+            convertMillimetersToTwip(5),
+            Math.ceil(estimateNumberWidthPt(number, doc.text.size) * 20 + convertMillimetersToTwip(3))
+          );
+          return [
+            ...prevNode?.type != "math" ? [
+              new Paragraph({ indent: { firstLine: 0 }, spacing: { line: 20, after: doc.formula.spacing.before * 20 } })
+            ] : [],
+            new Table({
+              width: { type: "dxa", size: formulaWidth },
+              borders: { top: { style: BorderStyle.NONE }, bottom: { style: BorderStyle.NONE }, left: { style: BorderStyle.NONE }, right: { style: BorderStyle.NONE }, insideHorizontal: { style: BorderStyle.NONE }, insideVertical: { style: BorderStyle.NONE } },
+              rows: [new TableRow({
+                children: [
+                  new TableCell({ width: { type: "dxa", size: sideWidth }, children: [new Paragraph({ indent: { firstLine: 0 }, spacing: { after: 0 } })] }),
+                  new TableCell({
+                    children: [
+                      new Paragraph({ alignment: AlignmentType.CENTER, indent: { firstLine: 0 }, spacing: { after: 0 }, children: [renderMath(node.latex, true, node.sourceLine)] })
+                    ]
+                  }),
+                  new TableCell({ width: { type: "dxa", size: sideWidth }, children: [new Paragraph({
+                    indent: { firstLine: 0 },
+                    spacing: { line: 240, after: 0 },
+                    alignment: AlignmentType.RIGHT,
+                    children: renderText(node.title || [], node.sourceLine)
+                  })], verticalAlign: VerticalAlignTable.CENTER })
+                ]
+              })]
+            }),
+            new Paragraph({ indent: { firstLine: 0 }, spacing: { line: 20, after: doc.formula.spacing.after * 20 } })
+          ];
         case "externalDoc":
           const doc_path = getPath(node.path);
-          if (!fs3.existsSync(doc_path))
+          if (!fs4.existsSync(doc_path))
             throw new UserInputError(`File not exist: ${node.path}`);
-          const ext = path3.extname(doc_path);
+          const ext = path4.extname(doc_path);
           if (ext != ".docx" && ext != ".pdf")
             throw new UserInputError(`File not .docx or .pdf: ${node.path}`);
           return new Paragraph({
@@ -1045,6 +2644,39 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
             indent: { firstLine: 0 },
             alignment: "left"
           });
+        case "admonition":
+          const style = `xAdmonition${node.admonitionType == "note" ? "" : node.admonitionType}`;
+          const admonition = doc.admonition[node.admonitionType];
+          const color = "#" + admonition.color;
+          const icon = admonition.icon ? [new ImageRun({
+            type: "svg",
+            data: Buffer.from(admonitionIcons[node.admonitionType](admonition.title_color ? color : "#000000")),
+            transformation: { width: admonition.icon_size, height: admonition.icon_size },
+            fallback: {
+              data: Buffer.from((admonition.title_color ? admonitionIconsFallback : admonitionIconsFallbackBlack)[node.admonitionType], "base64"),
+              type: "png"
+            }
+          }), new TextRun(" ")] : [];
+          const prevIsSameType = prevNode?.type == "admonition" && prevNode.admonitionType == node.admonitionType;
+          const showTitle = node.title.map((r) => r.text).join("") != "";
+          return [
+            ...prevIsSameType ? [
+              new Paragraph({ spacing: { line: 20, before: 0, after: 0 } })
+            ] : [],
+            ...showTitle ? [
+              new Paragraph({
+                style,
+                children: [...icon, ...renderText(admonition.title_color ? node.title.map((r) => ({ ...r, color })) : node.title, node.sourceLine)],
+                keepNext: true,
+                ...prevIsSameType ? { spacing: { before: 0 } } : {}
+              })
+            ] : [],
+            new Paragraph({
+              style,
+              children: renderText(node.text, node.sourceLine),
+              ...prevIsSameType && !showTitle ? { spacing: { before: 0 } } : {}
+            })
+          ];
         case "sectionBreak":
           return [];
         default:
@@ -1052,12 +2684,20 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
           throw new Error("switch default");
       }
     }, renderNodeL2 = function(node, prevChild, prevNode) {
-      const r = renderNode2(node, prevChild, prevNode);
-      if (r instanceof Array) return r;
-      return [r];
+      try {
+        const r = renderNode2(node, prevChild, prevNode);
+        if (r instanceof Array) return r;
+        return [r];
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/^Line -?\d+:/.test(message)) throw error;
+        throw new Error(`${node.sourceLine ? `Line ${node.sourceLine}: ` : ""}${message}`, { cause: error });
+      }
     };
-    var renderNode = renderNode2, renderNodeL = renderNodeL2;
+    var renderHeaderFooter = renderHeaderFooter2, renderHeaderFooterTable = renderHeaderFooterTable2, renderNode = renderNode2, renderNodeL = renderNodeL2;
     const children = [];
+    const header = renderHeaderFooter2(section.header, false);
+    const footer = renderHeaderFooter2(section.footer, true);
     sections.push({
       children,
       properties: {
@@ -1085,20 +2725,8 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
           }
         }
       },
-      footers: {
-        default: new Footer({
-          children: [
-            new Paragraph({
-              alignment: AlignmentType.CENTER,
-              children: [new TextRun({
-                children: section.displayPageNum ? [PageNumber.CURRENT] : []
-              })],
-              indent: { firstLine: 0 },
-              spacing: { line: 240 }
-            })
-          ]
-        })
-      }
+      ...header ? { headers: { default: header } } : {},
+      ...footer ? { footers: { default: footer } } : {}
     });
     for (let i = 0; i < section.nodes.length; i++)
       children.push(...renderNodeL2(section.nodes[i], children.at(-1), section.nodes[i - 1]));
@@ -1133,8 +2761,8 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
       })
     }
   ]);
-  fs3.writeFileSync(fout, buffer);
-  function renderText(text, size) {
+  fs4.writeFileSync(fout, buffer);
+  function renderText(text, sourceLine, size) {
     function renderRune(rune, link = false) {
       if (rune.anchor) return new Bookmark({
         id: rune.anchor,
@@ -1144,8 +2772,12 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
         const children2 = [renderRune({ ...rune, link: void 0 }, true)];
         return rune.link.startsWith("#") ? new InternalHyperlink({ children: children2, anchor: rune.link.slice(1) }) : new ExternalHyperlink({ children: children2, link: rune.link });
       }
+      if (rune.type == "math") return renderMath(rune.text, false, sourceLine);
       let children = null;
-      if (rune.type == "val" && rune.text == "pages") {
+      if (rune.type == "val" && rune.text == "page") {
+        rune.type = "text";
+        children = [PageNumber.CURRENT];
+      } else if (rune.type == "val" && rune.text == "pages") {
         rune.type = "text";
         children = doc.totalPagesOffset == 0 ? [PageNumber.TOTAL_PAGES] : [
           // Complex Formula Field: { = { NUMPAGES } + 1 }
@@ -1229,7 +2861,36 @@ async function serializeDocx(doc, fout, workdir, assets, checkFilesIsInsidePath)
       }
     }
   }
+  function renderMath(latex, para, sourceLine) {
+    try {
+      return latexToOmml(latex, para);
+    } catch (error) {
+      logwarn(`${sourceLine ? `Line ${doc.mapSourceLine(sourceLine + 1)}: ` : ""}Formula was not converted: ${error instanceof Error ? error.message : String(error)}`);
+      return new TextRun(latex);
+    }
+  }
 }
+var admonitionIcons = {
+  note: (c) => `<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><style>.a{fill:${c}}</style><path class="a" d="m13 12q0-0.4-0.3-0.7-0.3-0.3-0.7-0.3-0.4 0-0.7 0.3-0.3 0.3-0.3 0.7v4q0 0.4 0.3 0.7 0.3 0.3 0.7 0.3 0.4 0 0.7-0.3 0.3-0.3 0.3-0.7zm-1-2.5c0.3 0 0.6-0.1 0.9-0.4 0.2-0.2 0.3-0.5 0.3-0.8q0-0.6-0.3-0.9c-0.3-0.3-0.6-0.4-0.9-0.4-0.3 0-0.6 0.1-0.9 0.4q-0.3 0.3-0.3 0.9c0 0.3 0.1 0.6 0.3 0.8 0.3 0.3 0.6 0.4 0.9 0.4z"/><path fill-rule="evenodd" class="a" d="m22 12c0 5.5-4.5 10-10 10-5.5 0-10-4.5-10-10 0-5.5 4.5-10 10-10 5.5 0 10 4.5 10 10zm-15.7 5.7c1.5 1.5 3.6 2.3 5.7 2.3 2.1 0 4.2-0.8 5.7-2.3 1.5-1.5 2.3-3.6 2.3-5.7 0-2.1-0.8-4.2-2.3-5.7-1.5-1.5-3.6-2.3-5.7-2.3-2.1 0-4.2 0.8-5.7 2.3-1.5 1.5-2.3 3.6-2.3 5.7 0 2.1 0.8 4.2 2.3 5.7z"/></svg>`,
+  info: (c) => `<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><style>.a{fill:${c}}</style><path class="a" d="m13 12q0-0.4-0.3-0.7-0.3-0.3-0.7-0.3-0.4 0-0.7 0.3-0.3 0.3-0.3 0.7v4q0 0.4 0.3 0.7 0.3 0.3 0.7 0.3 0.4 0 0.7-0.3 0.3-0.3 0.3-0.7zm-1-2.5c0.3 0 0.6-0.1 0.9-0.4 0.2-0.2 0.3-0.5 0.3-0.8q0-0.6-0.3-0.9c-0.3-0.3-0.6-0.4-0.9-0.4-0.3 0-0.6 0.1-0.9 0.4-0.2 0.2-0.3 0.5-0.3 0.9 0 0.3 0.1 0.6 0.3 0.8 0.3 0.3 0.6 0.4 0.9 0.4z"/><path fill-rule="evenodd" class="a" d="m22 12c0 5.5-4.5 10-10 10-5.5 0-10-4.5-10-10 0-5.5 4.5-10 10-10 5.5 0 10 4.5 10 10zm-15.7 5.7c1.5 1.5 3.6 2.3 5.7 2.3 2.1 0 4.2-0.8 5.7-2.3 1.5-1.5 2.3-3.6 2.3-5.7 0-2.1-0.8-4.2-2.3-5.7-1.5-1.5-3.6-2.3-5.7-2.3-2.1 0-4.2 0.8-5.7 2.3-1.5 1.5-2.3 3.6-2.3 5.7 0 2.1 0.8 4.2 2.3 5.7z"/></svg>`,
+  tip: (c) => `<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><style>.a{fill:${c}}</style><path class="a" d="m8.1 20c0.2 0.9 0.7 1.6 1.5 2.2 0.7 0.5 1.5 0.8 2.4 0.8 0.9 0 1.7-0.3 2.4-0.8 0.8-0.6 1.3-1.3 1.5-2.2q0.2 0 0.4-0.1 0.1-0.1 0.3-0.2 0.1-0.1 0.2-0.3 0.1-0.2 0.1-0.4v-2.5q0.8-0.6 1.5-1.3 0.7-0.8 1.1-1.7 0.5-0.9 0.8-1.9 0.2-1 0.2-2.1c0-4.7-3.8-8.5-8.5-8.5-4.7 0-8.5 3.8-8.5 8.5q0 1.1 0.2 2.1 0.3 1 0.8 1.9 0.4 0.9 1.1 1.7 0.7 0.7 1.5 1.3v2.5q0 0.2 0.1 0.4 0.1 0.2 0.2 0.3 0.2 0.1 0.3 0.2 0.2 0.1 0.4 0.1zm6.8-3v1h-5.8v-1zm-1.1 3q-0.3 0.5-0.7 0.7-0.5 0.3-1 0.3-0.6 0-1-0.3-0.5-0.2-0.8-0.7zm-1.7-17c3.6 0 6.5 2.9 6.5 6.5q0 0.8-0.2 1.6-0.2 0.8-0.6 1.5-0.4 0.8-0.9 1.4-0.5 0.6-1.2 1h-7.2q-0.6-0.4-1.2-1-0.5-0.6-0.9-1.4-0.4-0.7-0.6-1.5-0.2-0.8-0.2-1.6c0-3.6 2.9-6.5 6.5-6.5z"/></svg>`,
+  warning: (c) => `<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><style>.a{fill:${c}}</style><path class="a" d="m9.4 4.3c1.2-1.9 4-1.9 5.2 0l7.4 12.1c1.2 2-0.2 4.6-2.6 4.6h-14.8c-2.4 0-3.8-2.6-2.6-4.6zm3.4 1.1c-0.4-0.7-1.3-0.7-1.7 0l-7.4 12.1c-0.4 0.7 0.1 1.6 0.8 1.6h14.9c0.8 0 1.3-0.9 0.9-1.6zm-0.9 3.7c0.6 0 1 0.5 1 1v3c0 0.6-0.4 1-1 1-0.6 0-1-0.4-1-1v-3c0-0.5 0.4-1 1-1zm-1.1 7.5c0-0.6 0.5-1.1 1.1-1.1 0.6 0 1.2 0.5 1.2 1.1 0 0.7-0.6 1.2-1.2 1.2-0.6 0-1.1-0.5-1.1-1.2z"/></svg>`,
+  danger: (c) => `<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><style>.a{fill:${c}}.b{fill:none;stroke:${c};stroke-linecap:round;stroke-linejoin:round;stroke-width:2}</style><path class="a" d="m12 14.5c-0.3 0-0.6 0.1-0.9 0.4-0.2 0.2-0.3 0.5-0.3 0.8q0 0.6 0.3 0.9c0.3 0.3 0.6 0.4 0.9 0.4 0.3 0 0.6-0.1 0.9-0.4q0.3-0.3 0.3-0.9c0-0.3-0.1-0.6-0.3-0.8-0.3-0.3-0.6-0.4-0.9-0.4z"/><path fill-rule="evenodd" class="b" d="m12 8v4"/><path class="b" d="m15.3 2q0.2 0 0.4 0 0.2 0.1 0.4 0.2 0.2 0 0.3 0.1 0.2 0.1 0.3 0.3l4.7 4.7q0.2 0.1 0.3 0.3 0.1 0.1 0.1 0.3 0.1 0.2 0.2 0.4 0 0.2 0 0.4v6.6q0 0.2 0 0.4-0.1 0.2-0.2 0.4 0 0.2-0.1 0.3-0.1 0.2-0.3 0.3l-4.7 4.7q-0.1 0.2-0.3 0.3-0.1 0.1-0.3 0.1-0.2 0.1-0.4 0.2-0.2 0-0.4 0h-6.6q-0.2 0-0.4 0-0.2-0.1-0.4-0.2-0.2 0-0.3-0.1-0.2-0.1-0.3-0.3l-4.7-4.7q-0.2-0.1-0.3-0.3-0.1-0.1-0.1-0.3-0.1-0.2-0.2-0.4 0-0.2 0-0.4v-6.6q0-0.2 0-0.4 0.1-0.2 0.2-0.4 0-0.2 0.1-0.3 0.1-0.2 0.3-0.3l4.7-4.7q0.1-0.2 0.3-0.3 0.1-0.1 0.3-0.1 0.2-0.1 0.4-0.2 0.2 0 0.4 0z"/></svg>`
+};
+var admonitionIconsFallback = {
+  note: `iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAilBMVEUAAABmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmbNZZ8EAAAALnRSTlMA//BXB/7YePSoRaAMKt3USM91y08CZiK8tUzjLxM82zjGblsPPSRhBkJzadIoQt+BPAAAAMBJREFUeJydUVcOwjAUi9Mm3YsOoLRlb7j/9RDJK22EEAL/OLKd5A3G/oVtBbnLs8CyTd2PQYj9se4IzKuubffVDMIZ6eBpfy44Xk4q3GhIRa6gVLiApThJ1M9bSF2BhUTxAZg+uZQ6yDxc9dVupfkCT7HUwQENpGIOauqWad6BkxFqAaBqyJCITKOhpzxsTGNCn/fl9ka5pHJtapDla0XHvkFWC343RnL+NkQ99vrEmF2YY/+8KLXajLv522p/wANc8QfHdtgFgwAAAABJRU5ErkJggg==`,
+  info: `iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAilBMVEUAAAAZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtIZdtL9UeA9AAAALnRSTlMA//BXB/7YePSoRaAMKt3USM91y08CZiK8tUzjLxM82zjGblsPPSRhBkJzadIoQt+BPAAAAMBJREFUeJydUVcOwjAUi9Mm3YsOoLRlb7j/9RDJK22EEAL/OLKd5A3G/oVtBbnLs8CyTd2PQYj9se4IzKuubffVDMIZ6eBpfy44Xk4q3GhIRa6gVLiApThJ1M9bSF2BhUTxAZg+uZQ6yDxc9dVupfkCT7HUwQENpGIOauqWad6BkxFqAaBqyJCITKOhpzxsTGNCn/fl9ka5pHJtapDla0XHvkFWC343RnL+NkQ99vrEmF2YY/+8KLXajLv522p/wANc8QfHdtgFgwAAAABJRU5ErkJggg==`,
+  tip: `iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAllBMVEUAAAAufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTIufTLBWjFSAAAAMnRSTlMA//AF9MXq5ssCgtub1XmmJgghfRkRC+exGm0tRBX+i2c1Tt8pMHC0RwxdtsOoo64eS7UJBqAAAADPSURBVHichVLZEoIwENtU7luUUwUB79v//zkHpKWiM+Ypk+x2szsl+ofAUhlTrWAkR7cCHQonlvWwASvrR7Sc6XBXgx67sOc9vcCYCGMmdKKjijXnE4Z6aF+g4fQJ3ZQGGtj2bIernKTESYxwZCOHJzpS2bCQ9+wANiQkUrHkqbQhIVEFTUTxoEWcm4YYQTS1YWQ99eFK71bK+4QtFL5Fh1A4SijrRAm6a2XQP3VKeMfYOHPjY9cWKfarqYP7WKcFa+vZ5sugja8l/vgv/MALHToJTMdMgakAAAAASUVORK5CYII=`,
+  warning: `iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAllBMVEUAAACyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagCyagD2Sl3HAAAAMnRSTlMA/w3r5vwbWbsElS1drcsiElT5ArX2wo045GaR779hCUx02KB7BdPiPyiCaxZSMsa5W/G4KzAAAADCSURBVHictZDJEoJADES7GZBFdlABFdz39f9/zmIoCge9WeaS5HVNkmngD6F5pKd9EeYkaX3yJ+NDRJofgwQ3gEO9P2zKlQ1oOicqHxrM6hzROCrCnWvYuQekHL/zkrMQA+rAYES346FggUbAkqLb79BHK9g7Tlt+ozEEUIlH3WVk3QFIfPXG5j2AgvtKFudr81edpcwzLiQIGG9lETX73da55NQeOpeWmUx79tiWFC6i9luNPJSzx7GKYyvom/9TvACzaQfmlOkXxAAAAABJRU5ErkJggg==`,
+  danger: `iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAdVBMVEUAAADTLy+/ICDSLi7SLi7GHBzPKSnSLy/SLi7MGhrTLy/TLy/SLy/RLi7SLy/SLi7TLi7KLCzRLi7SLi7KKyvTLi7TLy/EJyfTLi6/KyvTLy/TLy/SLi7TLy/MKSnMKyvTLy/SLy/TLi7OJyfSLi7TLy/TLy/z9/9QAAAAJ3RSTlMA/wi9wgklCyEK7L/UFuXA4B0c6Rj+Vg2zDMXc2LkZHre0lhqmySRpaHOvAAAAtElEQVR4nKVRRxLDIBBbGdx77yX1/0/M2EBMHE8u0QWtBCwriH6juECiKXQ9DJQOBOGuzz1YK2jLMNyU7kRghioMhmQW1Mo1ncjgiKyVTB5iTSdyObz1BdeSu0LxfbHaXXknIqCWWwFJ6o29yyPDH4Yvm38ZO/BpVNXBkOM9AUcwczNGyAHtcbEF4WiIKPUQm8dI0vMQ8y3Ek9hlK6I0wSJvMxn6bD8+DedfS5Q9lN5p+0/xArzsBn7bxA9sAAAAAElFTkSuQmCC`
+};
+var admonitionIconsFallbackBlack = {
+  note: `iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAilBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAggvAAAALnRSTlMA//AHeFjY9N2gDCpEqM3TSToi47XVR9D9Zky8L3RWPRNPxm4CUFsPJGFpKAbKjdKbTAAAAMRJREFUeJydUdkSgjAM7BbKfYjKKQp4n///e860AdpxfNC8bGY3bZINY/+GJfzE5aUvLJOPPFB4kc7bwLru+r6rN4Ct83wx5ic+K0XlhnNV6FZUFaywk5insvMZjppAIJd4BZYycSAkxrirp1mmcIuYClThFC0ciRy0VJoovICTECgCoGlIcBCaQktfxTiYwthcIDWEo0fjWrQge+0l3MYFWQP+0C3BZLBu4qCZqGxvnoxZg2k7Y8WXQ8nTltxNPk77Q7wBVQsHvaZMK8YAAAAASUVORK5CYII=`,
+  info: `iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAilBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAggvAAAALnRSTlMA//AHeFjY9N2gDCpEqM3TSToi47XVR9D9Zky8L3RWPRNPxm4CUFsPJGFpKAbKjdKbTAAAAMRJREFUeJydUdkSgjAM7BbKfYjKKQp4n///e860AdpxfNC8bGY3bZINY/+GJfzE5aUvLJOPPFB4kc7bwLru+r6rN4Ct83wx5ic+K0XlhnNV6FZUFaywk5insvMZjppAIJd4BZYycSAkxrirp1mmcIuYClThFC0ciRy0VJoovICTECgCoGlIcBCaQktfxTiYwthcIDWEo0fjWrQge+0l3MYFWQP+0C3BZLBu4qCZqGxvnoxZg2k7Y8WXQ8nTltxNPk77Q7wBVQsHvaZMK8YAAAAASUVORK5CYII=`,
+  tip: `iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAh1BMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD3YishAAAALXRSTlMA/+gFxBrmCvAH9EXbmyd9sC+kedXxTckiEW3ryx8VZ4s1gt8rqHC1XQyDshgZvchdAAAAyUlEQVR4nIWS5w7CMAyEfR20dO/SSSdlvf/zIaokDQWJ+3XyZ8dDIfonb9BMUxu8XbiIwOQacrwZkXZZU9j+AUm7xY0EzpNZDbkqgA9H5/6W48y9aiLbyieM3GY4yA1rhMxdMMugw1W0cGVQIhYVgQzuKJmzYW4TEmmw+VTVNiFRD0WkxVAKAXLRgujooGYbHmck0ru9xW8IWHyLVSdBrJMcJ1KwvqV/HmEFTHuwcPDYAQqwtIb7eYNVYfrOT6cvQF5UKdH+L/zQCzA0CJnLbfrbAAAAAElFTkSuQmCC`,
+  warning: `iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAllBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6C80qAAAAMnRSTlMA/w3mA/xUu1kb610AyyKtEi35lbXvwvZhv2aPCTnYixagayh7TDKSBeLTdII/xrk2W23LF/kAAADFSURBVHictZDJcsIwEET7WbINosDGLGELS8Kanf//OUpyucAmN4q+jOZ1aUZq6QmKMsiif4wpQHrPzxTfCbTuBjm20gDTHDZnaaXIMK/zfsyrrwnxe834YSNrMmnI+JZPGOVqY6T2C50rzx0zlYY+cdf9A7qqDPvBoeJ74r6khfv13R/4zqvL6nZheV/SjNMiHN6S8q+GSagjdgH0KI7hkJT7O1Vy9qt66DRE1mLYiMemwVg7n3ddJg+zx0UdF2mvGf5DugCExweZt6hkrgAAAABJRU5ErkJggg==`,
+  danger: `iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAYFBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6T+iNAAAAIHRSTlMA/wi9Cr8lwgwY7Bwhw7cW29Tl4OkdVh6z/bmWpsXXyQwvE4cAAACqSURBVHicpVFHEsIwEJPiFKeRXgjt/79ksNfEBA8XdNJKnpFXC/xGvlKw5r7edE4nu2bXl5ZKW6oV29LpVU8VuSFSHBZL09HTgahmn5rcgomnA3HG4vWDC7PYKkkizu18BUBKLkgh2rD3eGT8w0gk/MvYwU9jng+GrJeSlSxvjM0tqLeTJXHGFcAUqmQKlziaEgO1SxQwDTyJE/mHAvJ7+LRA+XB67b0P4gn4WAUqr4Oj0wAAAABJRU5ErkJggg==`
+};
 function addListItemLevel(levels, level, startIndex, itemCount, ordered, alternativeStyle, mark) {
   if (levels.find((v) => v.level == level)) return;
   levels.sort((a, b) => a.level - b.level);
@@ -1268,7 +2929,7 @@ function addListItemLevel(levels, level, startIndex, itemCount, ordered, alterna
     }
   });
 }
-var RawXml = class extends XmlComponent {
+var RawXml = class extends XmlComponent2 {
   constructor(tag, attributes = {}, text = null) {
     super(tag);
     if (Object.keys(attributes).length > 0)
@@ -1278,60 +2939,158 @@ var RawXml = class extends XmlComponent {
   }
 };
 function renderCodeHighlighting(code, lang) {
-  const grammar = Prism.languages[lang.trim().toLowerCase()];
+  const language = lang.trim().toLowerCase();
+  const grammar = Prism.languages[language];
   if (!grammar) return null;
   const themeColors = {
     // shared
     "plain": "000000",
     "comment": "008000",
+    "hashbang": "008000",
+    "shebang": "008000",
     "punctuation": "000000",
     "operator": "000000",
+    "script": "000000",
+    "script-punctuation": "000000",
+    "expression": "000000",
+    "interpolation": "000000",
     // keywords & control flow
     "keyword": "0000ff",
+    "control-flow": "af00db",
     "boolean": "0000ff",
-    "builtin": "0000ff",
+    "null": "0000ff",
+    "builtin": "267f99",
     "important": "0000ff",
+    // "instruction": "0000ff",
+    // "directive": "0000ff",
+    "directive-hash": "0000ff",
+    "macro": "0000ff",
+    "macro-name": "0000ff",
+    "rule": "0000ff",
     // literals
-    "string": lang === "css" ? "0451a5" : lang === "json" ? "a31515" : "a31515",
-    "number": "098658",
-    "constant": "0000ff",
-    "symbol": "0000ff",
+    "string": "a31515",
+    "template-string": "a31515",
+    "template-punctuation": "a31515",
+    "string-literal": "a31515",
     "char": "a31515",
+    "number": "098658",
+    "datetime": "098658",
+    "constant": "0070c1",
+    "symbol": "0070c1",
+    "scalar": "0000ff",
+    "conversion-option": "0000ff",
     // identifiers
-    "class-name": lang === "js" || lang === "ts" ? "267f99" : "0451a5",
-    "function": "0451a5",
-    "variable": "000000",
-    "namespace": "000000",
-    "property": lang === "css" ? "e50000" : "0451a5",
+    "class-name": "267f99",
+    "class-name-definition": "267f99",
+    "type-definition": "267f99",
+    "return-type": "267f99",
+    "attribute": "267f99",
+    "attribute-class-name": "267f99",
+    "annotation": "267f99",
+    "decorator": "267f99",
+    "namespace": "267f99",
+    "double-colon": "267f99",
+    "function": "795e26",
+    "function-definition": "795e26",
+    "method-definition": "795e26",
+    "variable": "001080",
+    "parameter": "001080",
+    "environment": "001080",
+    "assign-left": "001080",
+    "property": language === "css" ? "e50000" : language === "json" ? "0451a5" : "001080",
+    "key": "0451a5",
+    "package": "000000",
+    "lifetime-annotation": "0000ff",
     // markup / HTML / XML
-    "tag": lang === "html" || lang === "xml" ? "800000" : "0000ff",
+    "tag": "800000",
     "selector": "800000",
     "attr-name": "e50000",
-    "attr-value": "a31515",
+    "attr-value": "0000ff",
     "entity": "800000",
     "doctype": "808080",
+    "doctype-tag": "808080",
+    "name": "808080",
     "cdata": "808080",
     "prolog": "808080",
+    "delimiter": language === "php" ? "800000" : "a31515",
     // CSS specific
     "atrule": "0000ff",
     "url": "0451a5",
     // regex
-    "regex": "811f3f"
+    "regex": "811f3f",
+    "regex-delimiter": "811f3f",
+    "regex-source": "811f3f",
+    "regex-flags": "0000ff",
+    "interpolation-punctuation": "0000ff",
+    // Markdown
+    "title": "800000",
+    "blockquote": "0451a5",
+    "list": "0451a5",
+    "bold": "000080",
+    "italic": "800080",
+    "code": "800000",
+    "code-snippet": "800000",
+    "code-block": "800000",
+    "code-language": "0000ff",
+    "inserted": "098658",
+    "deleted": "a31515",
+    "strike": "000000",
+    "hr": "800000"
   };
+  const controlFlowKeywords = /* @__PURE__ */ new Set([
+    "if",
+    "else",
+    "elif",
+    "elseif",
+    "unless",
+    "then",
+    "switch",
+    "case",
+    "default",
+    "when",
+    "match",
+    "for",
+    "foreach",
+    "while",
+    "do",
+    "until",
+    "loop",
+    "break",
+    "continue",
+    "return",
+    "goto",
+    "throw",
+    "throws",
+    "try",
+    "catch",
+    "except",
+    "finally",
+    "rescue",
+    "ensure",
+    "await",
+    "yield",
+    "new",
+    "delete",
+    "in",
+    "of",
+    "instanceof"
+  ]);
   const tokens = Prism.tokenize(code, grammar);
   return tokensToParagraphs(tokens);
   function tokensToParagraphs(tokens2) {
     const paragraphs = [];
     let currentRuns = [];
-    function addText(text, type) {
+    const plainStyle = { color: themeColors.plain, bold: false, italics: false, strike: false };
+    function addText(text, style) {
       const lines = text.split("\n");
       lines.forEach((line, index) => {
         currentRuns.push(
           new TextRun({
             text: line,
-            color: themeColors[type] || themeColors["plain"],
-            bold: type === "bold",
-            italics: type === "italic"
+            color: style.color,
+            bold: style.bold,
+            italics: style.italics,
+            strike: style.strike
           })
         );
         if (index < lines.length - 1) {
@@ -1340,15 +3099,28 @@ function renderCodeHighlighting(code, lang) {
         }
       });
     }
-    function process2(token, parentType = "plain") {
+    function process2(token, parentStyle = plainStyle) {
       if (typeof token === "string")
-        addText(token, parentType);
-      else if (Array.isArray(token.content))
-        token.content.forEach((t) => process2(t, token.type));
-      else if (typeof token.content === "string")
-        addText(token.content, token.type);
-      else
-        process2(token.content, token.type);
+        addText(token, parentStyle);
+      else {
+        const aliases = typeof token.alias == "string" ? [token.alias] : token.alias || [];
+        const types = [token.type, ...aliases];
+        const colorType = types.find((type) => themeColors[type]);
+        const isControlFlow = token.type == "keyword" && typeof token.content == "string" && controlFlowKeywords.has(token.content);
+        const inheritPunctuation = token.type == "punctuation" && parentStyle.color != themeColors.plain;
+        const style = {
+          color: isControlFlow ? themeColors["control-flow"] : inheritPunctuation ? parentStyle.color : colorType ? themeColors[colorType] : parentStyle.color,
+          bold: parentStyle.bold || types.includes("bold") || types.includes("important") || types.includes("title"),
+          italics: parentStyle.italics || types.includes("italic"),
+          strike: parentStyle.strike || types.includes("strike")
+        };
+        if (Array.isArray(token.content))
+          token.content.forEach((t) => process2(t, style));
+        else if (typeof token.content === "string")
+          addText(token.content, style);
+        else
+          process2(token.content, style);
+      }
     }
     tokens2.forEach((t) => process2(t));
     if (currentRuns.length > 0) {
@@ -1357,6 +3129,37 @@ function renderCodeHighlighting(code, lang) {
     return paragraphs;
   }
 }
+function estimateNumberWidthPt(text, fontSizePt) {
+  const charWidths = {
+    ".": 0.25,
+    ",": 0.25,
+    "-": 0.333,
+    "(": 0.333,
+    ")": 0.333,
+    " ": 0.25,
+    "a": 0.444,
+    "b": 0.5,
+    "c": 0.444,
+    "d": 0.5,
+    "e": 0.444,
+    "A": 0.722,
+    "B": 0.667,
+    "C": 0.667,
+    "D": 0.722,
+    "E": 0.611,
+    "\u0430": 0.5,
+    "\u0431": 0.5,
+    "\u0432": 0.5,
+    "\u0433": 0.5,
+    "\u0434": 0.5,
+    "\u0410": 0.722,
+    "\u0411": 0.667,
+    "\u0412": 0.667,
+    "\u0413": 0.611,
+    "\u0414": 0.722
+  };
+  return [...text].reduce((width, char) => width + (charWidths[char] ?? 0.5) * fontSizePt, 0);
+}
 function genXml_app({ totalTime }) {
   return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes">
@@ -1364,20 +3167,29 @@ function genXml_app({ totalTime }) {
 </Properties>
 	`;
 }
+function escapeXml(value) {
+  return value.replaceAll(/[<>&"']/g, (ch) => ({
+    "<": "&lt;",
+    ">": "&gt;",
+    "&": "&amp;",
+    '"': "&quot;",
+    "'": "&apos;"
+  })[ch]);
+}
 function genXml_core({ title, creator, createdAt, modifiedAt }) {
   if (!createdAt) createdAt = /* @__PURE__ */ new Date();
   if (!modifiedAt) modifiedAt = /* @__PURE__ */ new Date();
   return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:dcmitype="http://purl.org/dc/dcmitype/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-<dc:title>${title || "Document"}</dc:title>
-<dc:creator>${creator || "Student"}</dc:creator>
-<cp:lastModifiedBy>${creator || "Student"}</cp:lastModifiedBy>
+<dc:title>${escapeXml(title || "Document")}</dc:title>
+<dc:creator>${escapeXml(creator || "Student")}</dc:creator>
+<cp:lastModifiedBy>${escapeXml(creator || "Student")}</cp:lastModifiedBy>
 <dcterms:created xsi:type="dcterms:W3CDTF">${createdAt.toISOString()}</dcterms:created>
 <dcterms:modified xsi:type="dcterms:W3CDTF">${modifiedAt.toISOString()}</dcterms:modified>
 </cp:coreProperties>`;
 }
 function genXml_style(assets, doc) {
-  let xml = fs3.readFileSync(path3.join(assets, "styles.xml"), { encoding: "utf8" });
+  let xml = fs4.readFileSync(path4.join(assets, "styles.xml"), { encoding: "utf8" });
   xml = editStyle(`<w:style w:type="paragraph" w:default="1" w:styleId="a2">`, (xml2) => {
     xml2 = replaceTag(xml2, `<w:spacing w:line="${doc.text.line_spacing * 240}" w:lineRule="auto" w:after="${doc.text.spacing.after * 20}"/>`);
     xml2 = replaceTag(xml2, `<w:ind w:firstLine="${convertMillimetersToTwip(doc.text.indent * 10)}"/>`);
@@ -1402,7 +3214,33 @@ function genXml_style(assets, doc) {
       xml2 = addrPrStyle(xml2, doc.table.title.style == "bold" ? "<w:b/>" : "<w:i/>");
     return xml2;
   });
+  const admonitionTypes = ["note", "info", "tip", "warning", "danger"];
+  for (const type of admonitionTypes) {
+    const suffix = type == "note" ? "" : type;
+    const styleId = `xAdmonition${suffix}`;
+    const styleTag = `<w:style w:type="paragraph" w:customStyle="1" w:styleId="${styleId}">`;
+    const style = doc.admonition[type];
+    xml = editStyle(styleTag, (xml2) => {
+      xml2 = replaceTagOrInsertAfter(xml2, "<w:pPr>", `<w:spacing w:before="${style.spacing.before * 20}" w:after="${style.spacing.after * 20}"/>`);
+      xml2 = replaceTagOrInsertAfter(xml2, "<w:pPr>", `<w:ind w:left="${convertMillimetersToTwip(style.indent * 10)}" w:firstLine="0"/>`);
+      xml2 = replaceBorder(xml2, "top", style.padding.top, "FFFFFF", 2);
+      xml2 = replaceBorder(xml2, "right", style.padding.right, "FFFFFF", 2);
+      xml2 = replaceBorder(xml2, "bottom", style.padding.bottom, "FFFFFF", 2);
+      xml2 = replaceBorder(xml2, "left", style.padding.left, style.color, Math.max(1, Math.round(style.bar_width * 8)));
+      xml2 = replaceTagOrInsertAfter(xml2, "<w:pPr>", `<w:shd w:val="clear" w:color="auto" w:fill="${style.background}"/>`);
+      return xml2;
+    });
+  }
   return xml;
+  function replaceBorder(xml2, side, space, color, size) {
+    return replaceTagOrInsertAfter(xml2, "<w:pBdr>", `<w:${side} w:val="single" w:sz="${size}" w:space="${space}" w:color="${color}"/>`);
+  }
+  function replaceTagOrInsertAfter(xml2, insertAfter2, tag) {
+    const tagName = /<([^\s>]+)/.exec(tag)?.[1];
+    if (!tagName) throw err();
+    const regex = new RegExp(`<${tagName}\\b[^>]*/>`);
+    return regex.test(xml2) ? xml2.replace(regex, tag) : xml2.replace(insertAfter2, `${insertAfter2}${tag}`);
+  }
   function replaceTag(xml2, tag) {
     const tagName = /<([^\s]+)\b/.exec(tag)?.[1];
     if (!tagName) throw err();
@@ -1442,13 +3280,14 @@ function genXml_style(assets, doc) {
 
 // src/enricher.ts
 function enrichDoc(doc, logwarn = console.warn) {
+  const warnAt = (line, message) => logwarn(`Line ${doc.mapSourceLine(line)}: ${message}`);
   for (let i = 0; i < doc.nodes.length; i++) {
     const node = doc.nodes[i];
-    if (node.type == "title" && node.text.toUpperCase().startsWith("\u0422\u0418\u0422\u0423\u041B\u042C\u041D\u0418\u041A")) {
-      doc.nodes.splice(i, 1, { type: "text", text: node.text.toUpperCase() });
-      doc.nodes.splice(i + 1, 0, { type: "pageBreak" });
+    if (node.type == "title" && node.level == 1 && node.text.toUpperCase().startsWith("\u0422\u0418\u0422\u0423\u041B\u042C\u041D\u0418\u041A")) {
+      doc.nodes.splice(i, 1, { type: "text", text: node.text.toUpperCase(), sourceLine: node.sourceLine });
+      doc.nodes.splice(i + 1, 0, { type: "pageBreak", sourceLine: node.sourceLine });
       i++;
-    } else if (node.type == "title" && node.text.toUpperCase() == "\u0420\u0415\u0424\u0415\u0420\u0410\u0422") {
+    } else if (node.type == "title" && node.level == 1 && node.text.toUpperCase() == "\u0420\u0415\u0424\u0415\u0420\u0410\u0422") {
       node.level = 0;
       node.text = node.text.toUpperCase();
       const nextNode = doc.nodes[i + 1];
@@ -1456,81 +3295,83 @@ function enrichDoc(doc, logwarn = console.warn) {
         nextNode.noIndent = true;
         nextNode.text = trimEnd(nextNode.text, ".").toUpperCase();
       }
-      doc.nodes.splice(i + 1, 0, { type: "text", tags: ["synopsis"], text: "\u041E\u0442\u0447\u0435\u0442 [!pages] \u0441., [!imgs] \u0440\u0438\u0441., [!tables] \u0442\u0430\u0431\u043B., [!codes] \u043B\u0438\u0441\u0442., [!sources] \u0438\u0441\u0442\u043E\u0447\u043D." });
+      doc.nodes.splice(i + 1, 0, { type: "text", tags: ["synopsis"], text: "\u041E\u0442\u0447\u0435\u0442 [!pages] \u0441., [!imgs] \u0440\u0438\u0441., [!tables] \u0442\u0430\u0431\u043B., [!codes] \u043B\u0438\u0441\u0442., [!sources] \u0438\u0441\u0442\u043E\u0447\u043D.", sourceLine: node.sourceLine });
       while (i + 1 < doc.nodes.length && doc.nodes[i + 1]?.type != "title") i++;
-      doc.nodes.splice(i + 1, 0, { type: "pageBreak" });
-    } else if (node.type == "title" && node.text.toUpperCase() == "\u041E\u0413\u041B\u0410\u0412\u041B\u0415\u041D\u0418\u0415") {
+      doc.nodes.splice(i + 1, 0, { type: "pageBreak", sourceLine: node.sourceLine });
+    } else if (node.type == "title" && node.level == 1 && node.text.toUpperCase() == "\u041E\u0413\u041B\u0410\u0412\u041B\u0415\u041D\u0418\u0415") {
       node.level = 0;
       node.text = node.text.toUpperCase();
-      doc.nodes.splice(i + 1, 0, { type: "tableOfContents" });
-    } else if (node.type == "title" && node.text.toUpperCase() == "\u0422\u0415\u0420\u041C\u0418\u041D\u042B \u0418 \u041E\u041F\u0420\u0415\u0414\u0415\u041B\u0415\u041D\u0418\u042F") {
+      doc.nodes.splice(i + 1, 0, { type: "tableOfContents", sourceLine: node.sourceLine });
+    } else if (node.type == "title" && node.level == 1 && node.text.toUpperCase() == "\u0422\u0415\u0420\u041C\u0418\u041D\u042B \u0418 \u041E\u041F\u0420\u0415\u0414\u0415\u041B\u0415\u041D\u0418\u042F") {
       node.center = true;
       node.text = node.text.toUpperCase();
-      const warn = () => logwarn("Wrong format of \u0422\u0415\u0420\u041C\u0418\u041D\u042B \u0418 \u041E\u041F\u0420\u0415\u0414\u0415\u041B\u0415\u041D\u0418\u042F");
+      const warn = (ln) => warnAt(ln, "Wrong format of \u0422\u0415\u0420\u041C\u0418\u041D\u042B \u0418 \u041E\u041F\u0420\u0415\u0414\u0415\u041B\u0415\u041D\u0418\u042F");
       const list = doc.nodes[i + 1];
       if (list?.type != "list") {
-        warn();
+        warn(node.sourceLine);
         continue;
       }
-      const rows = [tableRow("\u0422\u0435\u0440\u043C\u0438\u043D", "\u041E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D\u0438\u0435")];
+      const rows = [tableRow(list.sourceLine, "\u0422\u0435\u0440\u043C\u0438\u043D", "\u041E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D\u0438\u0435")];
       const align = ["l", "l"];
       for (const item of list.items) {
         if (item.type != "listItem") {
-          warn();
+          warn(item.sourceLine);
           continue;
         }
         const i2 = item.text.indexOf(":");
         if (i2 < 0) {
-          warn();
+          warn(item.sourceLine);
           continue;
         }
-        rows.push(tableRow(item.text.slice(0, i2).trim(), item.text.slice(i2 + 1).trim()));
+        rows.push(tableRow(item.sourceLine, item.text.slice(0, i2).trim(), item.text.slice(i2 + 1).trim()));
       }
-      doc.nodes.splice(i + 1, 1, { type: "text", text: "\u0412 \u043D\u0430\u0441\u0442\u043E\u044F\u0449\u0435\u043C \u043E\u0442\u0447\u0435\u0442\u0435 \u043F\u0440\u0438\u043C\u0435\u043D\u044F\u044E\u0442\u0441\u044F \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0435 \u0442\u0435\u0440\u043C\u0438\u043D\u044B \u0441 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044E\u0449\u0438\u043C\u0438 \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D\u0438\u044F\u043C\u0438." });
-      doc.nodes.splice(i + 2, 0, { type: "table", align, rows, normalFontSize: true, tags: ["definitions_table"] });
-      doc.nodes.splice(i + 3, 0, { type: "pageBreak" });
-    } else if (node.type == "title" && node.text.toUpperCase() == "\u041F\u0415\u0420\u0415\u0427\u0415\u041D\u042C \u0421\u041E\u041A\u0420\u0410\u0429\u0415\u041D\u0418\u0419 \u0418 \u041E\u0411\u041E\u0417\u041D\u0410\u0427\u0415\u041D\u0418\u0419") {
+      doc.nodes.splice(i + 1, 1, { type: "text", text: "\u0412 \u043D\u0430\u0441\u0442\u043E\u044F\u0449\u0435\u043C \u043E\u0442\u0447\u0435\u0442\u0435 \u043F\u0440\u0438\u043C\u0435\u043D\u044F\u044E\u0442\u0441\u044F \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0435 \u0442\u0435\u0440\u043C\u0438\u043D\u044B \u0441 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044E\u0449\u0438\u043C\u0438 \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D\u0438\u044F\u043C\u0438.", sourceLine: node.sourceLine });
+      doc.nodes.splice(i + 2, 0, { type: "table", align, rows, normalFontSize: true, tags: ["definitions_table"], sourceLine: node.sourceLine });
+      doc.nodes.splice(i + 3, 0, { type: "pageBreak", sourceLine: node.sourceLine });
+    } else if (node.type == "title" && node.level == 1 && node.text.toUpperCase() == "\u041F\u0415\u0420\u0415\u0427\u0415\u041D\u042C \u0421\u041E\u041A\u0420\u0410\u0429\u0415\u041D\u0418\u0419 \u0418 \u041E\u0411\u041E\u0417\u041D\u0410\u0427\u0415\u041D\u0418\u0419") {
       node.center = true;
       node.text = node.text.toUpperCase();
-      const warn = () => logwarn("Wrong format of \u041F\u0415\u0420\u0415\u0427\u0415\u041D\u042C \u0421\u041E\u041A\u0420\u0410\u0429\u0415\u041D\u0418\u0419 \u0418 \u041E\u0411\u041E\u0417\u041D\u0410\u0427\u0415\u041D\u0418\u0419");
+      const warn = (ln) => warnAt(ln, "Wrong format of \u041F\u0415\u0420\u0415\u0427\u0415\u041D\u042C \u0421\u041E\u041A\u0420\u0410\u0429\u0415\u041D\u0418\u0419 \u0418 \u041E\u0411\u041E\u0417\u041D\u0410\u0427\u0415\u041D\u0418\u0419");
       const list = doc.nodes[i + 1];
       if (list?.type != "list") {
-        warn();
+        warn(node.sourceLine);
         continue;
       }
       const items = [];
       for (const item of list.items) {
         if (item.type != "listItem") {
-          warn();
+          warn(item.sourceLine);
           continue;
         }
-        items.push({ type: "text", text: trimEnd(item.text, "."), noIndent: true, noMargin: true });
+        items.push({ type: "text", text: trimEnd(item.text, "."), noIndent: true, noMargin: true, sourceLine: item.sourceLine });
       }
-      doc.nodes.splice(i + 1, 1, { type: "text", text: "\u0412 \u043D\u0430\u0441\u0442\u043E\u044F\u0449\u0435\u043C \u043E\u0442\u0447\u0435\u0442\u0435 \u043F\u0440\u0438\u043C\u0435\u043D\u044F\u044E\u0442 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0435 \u0441\u043E\u043A\u0440\u0430\u0449\u0435\u043D\u0438\u044F \u0438 \u043E\u0431\u043E\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u044F." });
-      doc.nodes.splice(i + 2, 0, { type: "pageBreak" });
+      doc.nodes.splice(i + 1, 1, { type: "text", text: "\u0412 \u043D\u0430\u0441\u0442\u043E\u044F\u0449\u0435\u043C \u043E\u0442\u0447\u0435\u0442\u0435 \u043F\u0440\u0438\u043C\u0435\u043D\u044F\u044E\u0442 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0435 \u0441\u043E\u043A\u0440\u0430\u0449\u0435\u043D\u0438\u044F \u0438 \u043E\u0431\u043E\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u044F.", sourceLine: node.sourceLine });
+      doc.nodes.splice(i + 2, 0, { type: "pageBreak", sourceLine: node.sourceLine });
       doc.nodes.splice(i + 2, 0, ...items);
-    } else if (node.type == "title" && node.text.toUpperCase() == "\u0412\u0412\u0415\u0414\u0415\u041D\u0418\u0415") {
+    } else if (node.type == "title" && node.level == 1 && node.text.toUpperCase() == "\u0412\u0412\u0415\u0414\u0415\u041D\u0418\u0415") {
       node.center = true;
       node.text = node.text.toUpperCase();
       for (let j = i + 1; j < doc.nodes.length; j++) {
         const node2 = doc.nodes[j];
         if (node2?.type == "title") {
-          doc.nodes.splice(j, 0, { type: "pageBreak" });
+          doc.nodes.splice(j, 0, { type: "pageBreak", sourceLine: -1 });
           break;
         }
       }
-    } else if (node.type == "title" && node.text.toUpperCase() == "\u0417\u0410\u041A\u041B\u042E\u0427\u0415\u041D\u0418\u0415") {
+    } else if (node.type == "title" && node.level == 1 && node.text.toUpperCase() == "\u0417\u0410\u041A\u041B\u042E\u0427\u0415\u041D\u0418\u0415") {
       node.center = true;
       node.text = node.text.toUpperCase();
-      doc.nodes.splice(i, 0, { type: "pageBreak" });
+      doc.nodes.splice(i, 0, { type: "pageBreak", sourceLine: node.sourceLine });
       i++;
-    } else if (node.type == "title" && node.text.toUpperCase() == "\u0421\u041F\u0418\u0421\u041E\u041A \u0418\u0421\u041F\u041E\u041B\u042C\u0417\u041E\u0412\u0410\u041D\u041D\u042B\u0425 \u0418\u0421\u0422\u041E\u0427\u041D\u0418\u041A\u041E\u0412") {
+    } else if (node.type == "title" && node.level == 1 && node.text.toUpperCase() == "\u0421\u041F\u0418\u0421\u041E\u041A \u0418\u0421\u041F\u041E\u041B\u042C\u0417\u041E\u0412\u0410\u041D\u041D\u042B\u0425 \u0418\u0421\u0422\u041E\u0427\u041D\u0418\u041A\u041E\u0412") {
       node.center = true;
       node.text = node.text.toUpperCase();
-      doc.nodes.splice(i++, 0, { type: "pageBreak" });
+      doc.nodes.splice(i++, 0, { type: "pageBreak", sourceLine: node.sourceLine });
       const nextNode = doc.nodes[i + 1];
       if (nextNode?.type == "list") {
         nextNode.alternativeStyle = true;
+        nextNode.tags = nextNode.tags || [];
+        nextNode.tags.push("sources");
         i++;
         continue;
       }
@@ -1539,35 +3380,38 @@ function enrichDoc(doc, logwarn = console.warn) {
         mark: ".",
         startIndex: 1,
         alternativeStyle: true,
+        tags: ["sources"],
         ordered: true,
-        items: []
+        items: [],
+        sourceLine: node.sourceLine + 1
       };
       const startI = i + 1;
       while (true) {
         const textNode = doc.nodes[i + 1];
         if (textNode?.type != "text") break;
         const items = textNode.text.split(/\n\s*(?=\[[a-zA-Zа-яА-ЯёЁ_\d]+\])/);
+        let sourceLine = textNode.sourceLine;
         for (const item of items)
-          list.items.push({ type: "listItem", text: item });
+          list.items.push({ type: "listItem", text: item, sourceLine: sourceLine++ });
         i++;
       }
       if (list.items.length > 0)
         doc.nodes.splice(startI, i - startI + 1, list);
-    } else if (node.type == "title" && node.text.toUpperCase() == "\u041F\u0420\u0418\u041B\u041E\u0416\u0415\u041D\u0418\u042F") {
+    } else if (node.type == "title" && node.level == 1 && node.text.toUpperCase() == "\u041F\u0420\u0418\u041B\u041E\u0416\u0415\u041D\u0418\u042F") {
       node.level = 0;
       node.center = true;
       node.text = node.text.toUpperCase();
-      doc.nodes.splice(i++, 0, { type: "pageBreak" });
+      doc.nodes.splice(i++, 0, { type: "pageBreak", sourceLine: node.sourceLine });
       for (let j = i + 1; j < doc.nodes.length; j++) {
         const node2 = doc.nodes[j];
         if (node2.type == "title") {
-          doc.nodes.splice(i++ + 1, 0, { type: "text", text: "\u041F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u0435 " + node2.text.replace("]", "].") });
+          doc.nodes.splice(i++ + 1, 0, { type: "text", text: "\u041F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u0435 " + node2.text.replace("]", "]."), sourceLine: node2.sourceLine });
           j++;
           node2.level = 1;
           const splitI = node2.text.indexOf("]");
-          doc.nodes.splice(j++, 0, { type: "pageBreak" });
+          doc.nodes.splice(j++, 0, { type: "pageBreak", sourceLine: node2.sourceLine });
           if (splitI >= 0) {
-            doc.nodes.splice(j++ + 1, 0, { type: "text", text: node2.text.slice(splitI + 1), center: true });
+            doc.nodes.splice(j++ + 1, 0, { type: "text", text: node2.text.slice(splitI + 1), center: true, sourceLine: node2.sourceLine });
             node2.text = "\u041F\u0420\u0418\u041B\u041E\u0416\u0415\u041D\u0418\u0415 " + node2.text.slice(0, splitI + 1);
             node2.center = true;
           }
@@ -1603,11 +3447,11 @@ function enrichDoc(doc, logwarn = console.warn) {
     } else if (node.type == "externalDoc") {
       const nextNode = doc.nodes[i + 1];
       if (nextNode && nextNode?.type != "externalDoc" && nextNode?.type != "pageBreak" && nextNode?.type != "sectionBreak") {
-        doc.nodes.splice(i + 1, 0, { type: "pageBreak" });
+        doc.nodes.splice(i + 1, 0, { type: "pageBreak", sourceLine: node.sourceLine });
       }
       const prevNode = doc.nodes[i - 1];
       if (prevNode && prevNode?.type != "externalDoc" && prevNode?.type != "pageBreak" && prevNode?.type != "sectionBreak") {
-        doc.nodes.splice(i, 0, { type: "pageBreak" });
+        doc.nodes.splice(i, 0, { type: "pageBreak", sourceLine: node.sourceLine });
         i++;
       }
     }
@@ -1616,7 +3460,7 @@ function enrichDoc(doc, logwarn = console.warn) {
 
 // src/main.ts
 import { exec, spawn } from "child_process";
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { PDFDocument } from "pdf-lib";
 
@@ -1627,12 +3471,15 @@ function alchemist(doc, logwarn = console.warn) {
     codesAll: 0,
     imgsAll: 0,
     tablesAll: 0,
+    formulasAll: 0,
     codes: 0,
     imgs: 0,
     tables: 0,
+    formulas: 0,
     titles: { l1: 0, l2: 0, l3: 0, l4: 0, l5: 0 }
   };
   const named = {};
+  const warnAt = (line, message) => logwarn(`${line ? `Line ${doc.mapSourceLine(line)}: ` : ""}${message}`);
   const vals = {};
   let lastRefI = 0;
   let prevNum = -1;
@@ -1649,11 +3496,13 @@ function alchemist(doc, logwarn = console.warn) {
       let codes = counter.codes;
       let imgs = counter.imgs;
       let tables = counter.tables;
+      let formulas = counter.formulas;
       for (let j = i; j < doc.nodes.length && nextNum < 0; j++) {
         const n = doc.nodes[j];
         if (n.type == "code") nextNum = codes + 1;
         if (n.type == "image") nextNum = imgs + 1;
         if (n.type == "table") nextNum = tables + 1;
+        if (n.type == "math") nextNum = formulas + 1;
         if (n.type == "title" && n.level == 1 && doc.numberingSections) {
           const num = getTitleNum(n);
           if (num) l1 = num;
@@ -1661,6 +3510,7 @@ function alchemist(doc, logwarn = console.warn) {
           codes = 0;
           imgs = 0;
           tables = 0;
+          formulas = 0;
         }
       }
       nextPrefix = l1 > 0 && doc.numberingSections ? `${l1}.` : "";
@@ -1683,13 +3533,14 @@ function alchemist(doc, logwarn = console.warn) {
           counter.codes = 0;
           counter.imgs = 0;
           counter.tables = 0;
+          counter.formulas = 0;
         }
         prefix = doc.numberingSections ? `${counter.titles.l1}.` : "";
         if (appendix) prefix = APPENDIX_NAME[counter.titles.l1 - 1] + ".";
       }
     }
     materializeNode(node);
-    if (node.type == "code" || node.type == "image" || node.type == "table") {
+    if (node.type == "code" || node.type == "image" || node.type == "table" || node.type == "math") {
       if (node.type == "code") {
         counter.codes++;
         counter.codesAll++;
@@ -1702,18 +3553,27 @@ function alchemist(doc, logwarn = console.warn) {
         counter.tables++;
         counter.tablesAll++;
       }
+      if (node.type == "math") {
+        counter.formulas++;
+        counter.formulasAll++;
+      }
       prevNum = nextNum;
       prevPrefix = prefix;
       nextNum = -1;
     }
   });
+  for (const value of [doc.header, doc.footer, ...doc.nodes.filter((node) => node.type == "sectionBreak").flatMap((node) => [node.header, node.footer])]) {
+    if (value?.type != "content") continue;
+    value.nodes.forEach(materializeNode);
+  }
   const sourcesCount = crystallizeSources();
-  vals["codes"]?.forEach((f) => f(counter.codes));
-  vals["imgs"]?.forEach((f) => f(counter.imgs));
-  vals["tables"]?.forEach((f) => f(counter.tables));
+  vals["codes"]?.forEach((f) => f(counter.codesAll));
+  vals["imgs"]?.forEach((f) => f(counter.imgsAll));
+  vals["tables"]?.forEach((f) => f(counter.tablesAll));
+  vals["formulas"]?.forEach((f) => f(counter.formulasAll));
   vals["sources"]?.forEach((f) => f(sourcesCount));
   Object.entries(named).forEach(([k, v]) => {
-    if (v instanceof Array) logwarn(`\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u0430\u044F \u0441\u0441\u044B\u043B\u043A\u0430 [${k}]`);
+    if (v instanceof Array) v.forEach((ref) => warnAt(ref.sourceLine, `\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u0430\u044F \u0441\u0441\u044B\u043B\u043A\u0430 [${k}]`));
   });
   if (synopsis) {
     synopsis.text = [
@@ -1747,7 +3607,7 @@ function alchemist(doc, logwarn = console.warn) {
   function materializeList(node) {
     node.items.forEach((item) => {
       if (item.type == "list") materializeList(item);
-      else materializeRunes(item.text, node);
+      else materializeRunes(item.text, { ...node, sourceLine: item.sourceLine ?? node.sourceLine });
     });
   }
   function materializeTable(node) {
@@ -1795,8 +3655,9 @@ function alchemist(doc, logwarn = console.warn) {
         rune.text = repeat(node.level, (i2) => counter.titles[`l${i2 + 1}`]).join(".");
         return;
       }
-      if (type == "code" || type == "image" || type == "table") {
-        let { num, text } = type == "code" ? { num: counter.codes, text: "\u041B\u0438\u0441\u0442\u0438\u043D\u0433" } : type == "image" ? { num: counter.imgs, text: "\u0420\u0438\u0441\u0443\u043D\u043E\u043A" } : type == "table" ? { num: counter.tables, text: "\u0422\u0430\u0431\u043B\u0438\u0446\u0430" } : (() => {
+      if (type == "code" || type == "image" || type == "table" || type == "math") {
+        let { num, text } = type == "code" ? { num: counter.codes, text: "\u041B\u0438\u0441\u0442\u0438\u043D\u0433" } : type == "image" ? { num: counter.imgs, text: "\u0420\u0438\u0441\u0443\u043D\u043E\u043A" } : type == "table" ? { num: counter.tables, text: "\u0422\u0430\u0431\u043B\u0438\u0446\u0430" } : type == "math" ? { num: counter.formulas, text: "" } : (() => {
+          type;
           throw new Error("switch default");
         })();
         num++;
@@ -1813,9 +3674,10 @@ function alchemist(doc, logwarn = console.warn) {
             nextRune.text = toCapitalCase(nextRune.text);
           }
           text = `${text} ${prefix}${num} \u2013 `;
+          if (type == "math") text = `${prefix}${num}`;
         } else text = `${prefix}${num}`;
         if (v instanceof Array) v.forEach((fn) => fn.f(num, prefix));
-        else if (v && tag != "#") logwarn(`id [${tag}] ${type == "code" ? "\u043B\u0438\u0441\u0442\u0438\u043D\u0433\u0430" : type == "image" ? "\u0440\u0438\u0441\u0443\u043D\u043A\u0430" : type == "table" ? "\u0442\u0430\u0431\u043B\u0438\u0446\u044B" : ""} \u0443\u0436\u0435 \u0437\u0430\u043D\u044F\u0442\u043E \u0447\u0435\u043C-\u0442\u043E \u0434\u0440\u0443\u0433\u0438\u043C`);
+        else if (v && tag != "#") warnAt(node.sourceLine, `id [${tag}] ${type == "code" ? "\u043B\u0438\u0441\u0442\u0438\u043D\u0433\u0430" : type == "image" ? "\u0440\u0438\u0441\u0443\u043D\u043A\u0430" : type == "table" ? "\u0442\u0430\u0431\u043B\u0438\u0446\u044B" : type == "math" ? "\u0444\u043E\u0440\u043C\u0443\u043B\u044B" : ""} \u0443\u0436\u0435 \u0437\u0430\u043D\u044F\u0442\u043E \u0447\u0435\u043C-\u0442\u043E \u0434\u0440\u0443\u0433\u0438\u043C`);
         named[tag] = { n: num, prefix };
         rune.type = "text";
         rune.text = text;
@@ -1835,8 +3697,8 @@ function alchemist(doc, logwarn = console.warn) {
           rune.type = "text";
           rune.text = n < 0 ? prefix2 : `${prefix2}${applyMath(n)}`;
         };
-        if (v) v.push({ f, i: lastRefI++ });
-        else named[tag] = [{ f, i: lastRefI++ }];
+        if (v) v.push({ f, i: lastRefI++, sourceLine: node.sourceLine });
+        else named[tag] = [{ f, i: lastRefI++, sourceLine: node.sourceLine }];
       } else {
         rune.type = "text";
         rune.text = `${v.prefix}${applyMath(v.n)}`;
@@ -1844,21 +3706,22 @@ function alchemist(doc, logwarn = console.warn) {
     });
   }
   function crystallizeSources() {
-    const sourcesList = doc.nodes.find((node) => node.type == "list" && node.alternativeStyle);
+    const sourcesList = doc.nodes.find((node) => node.type == "list" && node.tags?.includes("sources"));
     if (!sourcesList || sourcesList.type != "list") return 0;
-    const items = sourcesList.items.filter((v) => v.type == "listItem").map((v) => v.text).map((item, i) => {
+    const items = sourcesList.items.filter((v) => v.type == "listItem").map((v, i) => {
+      const item = v.text;
       const refI = item[0]?.text ? 0 : 1;
       const ref = item[refI];
       if (ref?.type != "ref") {
-        return { text: item, ref: "", i: 99999 + i };
+        return { text: item, ref: "", i: 99999 + i, srcI: v.sourceLine };
       }
       const refs = named[ref.text];
       if (refs && !(refs instanceof Array)) {
-        logwarn(`id [${ref.text}] \u0438\u0441\u0442\u043E\u0447\u043D\u0438\u043A\u0430 \u0443\u0436\u0435 \u0437\u0430\u043D\u044F\u0442\u043E \u0447\u0435\u043C-\u0442\u043E \u0434\u0440\u0443\u0433\u0438\u043C`);
-        return { text: item.slice(refI + 1), ref: "", i: 99999 + i };
+        warnAt(sourcesList.sourceLine, `id [${ref.text}] \u0438\u0441\u0442\u043E\u0447\u043D\u0438\u043A\u0430 \u0443\u0436\u0435 \u0437\u0430\u043D\u044F\u0442\u043E \u0447\u0435\u043C-\u0442\u043E \u0434\u0440\u0443\u0433\u0438\u043C`);
+        return { text: item.slice(refI + 1), ref: "", i: 99999 + i, srcI: v.sourceLine };
       }
-      const firstOccurrenceI = Math.min(...refs.map((v) => v.i));
-      return { text: item.slice(refI + 1), ref: ref.text, i: firstOccurrenceI };
+      const firstOccurrenceI = Math.min(...refs.map((v2) => v2.i));
+      return { text: item.slice(refI + 1), ref: ref.text, i: firstOccurrenceI, srcI: v.sourceLine };
     });
     items.sort((a, b) => a.i - b.i);
     const hasIdAny = items.some((it) => !!it.ref);
@@ -1868,16 +3731,17 @@ function alchemist(doc, logwarn = console.warn) {
       named[key] = { prefix: "", n: i + 1 };
       if (refs instanceof Array) {
         if (hasIdAny && refs.length <= 1)
-          logwarn(`\u0412 \u0442\u0435\u043A\u0441\u0442\u0435 \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u044E\u0442 \u0441\u0441\u044B\u043B\u043A\u0438 \u043D\u0430 \u0438\u0441\u0442\u043E\u0447\u043D\u0438\u043A: ${item.ref}`);
+          warnAt(item.srcI, `\u0412 \u0442\u0435\u043A\u0441\u0442\u0435 \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u044E\u0442 \u0441\u0441\u044B\u043B\u043A\u0438 \u043D\u0430 \u0438\u0441\u0442\u043E\u0447\u043D\u0438\u043A: ${item.ref}`);
         refs.forEach((r) => hasIdAny ? r.f(i + 1, "") : r.f(-1, `[${i + 1}]`));
       }
-      return { type: "listItem", text: item.text };
+      return { type: "listItem", text: item.text, sourceLine: item.srcI };
     });
     return sourcesList.items.length;
   }
 }
 function addLazyNumbering(doc) {
   doc.nodes.forEach((node) => {
+    if (node.type == "math" && !node.title) node.title = [{ text: "(", type: "text" }, { text: "#", type: "ref" }, { text: ")", type: "text" }];
     const runes = node.type == "code" || node.type == "table" ? node.title : node.type == "image" ? node.text : null;
     if (!runes) return;
     if (runes.find((rune) => rune.type == "ref")) return;
@@ -1899,6 +3763,8 @@ async function render({
   disableMacros = false,
   useLibreOffice = false,
   checkFilesIsInsidePath = "",
+  templateOptions = { allowIncludes: true, allowLoops: true },
+  variables,
   logwarn = console.warn,
   loginfo = console.info,
   logPS = (msg) => console.log(`PS: ${msg}`),
@@ -1906,23 +3772,23 @@ async function render({
   signal = null
 }) {
   signal?.throwIfAborted();
-  const fin = path4.resolve(file);
+  const fin = path5.resolve(file);
   progress(10, "\u041F\u044B\u0442\u0430\u0435\u043C\u0441\u044F \u043F\u043E\u043D\u044F\u0442\u044C, \u0447\u0442\u043E \u0432\u044B \u0442\u0443\u0442 \u043D\u0430\u043F\u0438\u0441\u0430\u043B\u0438...");
   loginfo(`[!1] Parsing file ${fin}`);
-  const doc = await parseMD(fin, logwarn);
+  const doc = await parseMD(fin, variables, templateOptions, checkFilesIsInsidePath, signal, logwarn);
   signal?.throwIfAborted();
   progress(10, "\u041A\u043E\u043B\u0434\u0443\u0435\u043C \u043D\u0430\u0434 \u0441\u0438\u043D\u0442\u0430\u043A\u0441\u0438\u0441\u043E\u043C...");
   loginfo("[!2] Processing document");
   enrichDoc(doc, logwarn);
   const runicDoc = runifyDoc(doc);
   alchemist(runicDoc, logwarn);
-  const pout = output && path4.parse(path4.resolve(output));
-  if (pout) await fs4.mkdir(pout.dir, { recursive: true });
-  const p = path4.parse(fin);
+  const pout = output && path5.parse(path5.resolve(output));
+  if (pout) await fs5.mkdir(pout.dir, { recursive: true });
+  const p = path5.parse(fin);
   const fdir = p.dir;
   const fname = trimEnd(p.name, ".g");
-  const ftmp = path4.join(fdir, fname + ".tmp.docx");
-  const fout = pout ? path4.join(pout.dir, pout.name + ".docx") : path4.join(fdir, fname + ".docx");
+  const ftmp = path5.join(fdir, fname + ".tmp.docx");
+  const fout = pout ? path5.join(pout.dir, pout.name + ".docx") : path5.join(fdir, fname + ".docx");
   if (await checkIfFileIsBlocked(ftmp))
     throw new Error(`\u0417\u0430\u043A\u0440\u043E\u0439\u0442\u0435 docx \u0444\u0430\u0439\u043B. Output file is busy or locked: ${ftmp}`);
   if (await checkIfFileIsBlocked(fout))
@@ -1930,7 +3796,7 @@ async function render({
   signal?.throwIfAborted();
   progress(10, phrase_renderDocx());
   loginfo("[!3] Serializing to docx");
-  await serializeDocx(runicDoc, ftmp, fdir, assets, checkFilesIsInsidePath);
+  await serializeDocx(runicDoc, ftmp, fdir, assets, checkFilesIsInsidePath, logwarn);
   let willRunMacros = !disableMacros && (renderPDF || hasReasonForRunningMacros(runicDoc));
   let limitedRender = false;
   if (process.platform != "win32" && willRunMacros && !useLibreOffice) {
@@ -1941,31 +3807,31 @@ async function render({
     signal?.throwIfAborted();
     progress(20, phrase_runMacros());
     loginfo("[!4] Starting macros");
-    const tmpfolder = path4.join(pout ? pout.dir : fdir, ".md2gost_out");
-    await fs4.rm(tmpfolder, { recursive: true, force: true });
+    const tmpfolder = path5.join(pout ? pout.dir : fdir, ".md2gost_out");
+    await fs5.rm(tmpfolder, { recursive: true, force: true });
     try {
       const macroRunner = useLibreOffice ? runUnoScript : runDocxMacro;
       const ok = await macroRunner(progress, logPS, logPSError, assets, fdir, ftmp, fout, renderPDF, signal);
       if (!ok) {
-        await fs4.rename(ftmp, fout);
+        await fs5.rename(ftmp, fout);
         return { fout, err: "inPS" };
       }
     } catch (x) {
       if (signal?.aborted) {
-        await fs4.unlink(ftmp).catch(() => {
+        await fs5.unlink(ftmp).catch(() => {
         });
         throw x;
       }
-      await fs4.rename(ftmp, fout);
+      await fs5.rename(ftmp, fout);
       return { fout, err: "noPS", errS: x };
     }
     if (existsSync2(ftmp))
-      await fs4.unlink(ftmp);
+      await fs5.unlink(ftmp);
     signal?.throwIfAborted();
-    const errorTxt = path4.join(tmpfolder, "error.txt");
+    const errorTxt = path5.join(tmpfolder, "error.txt");
     if (existsSync2(errorTxt)) {
-      const err = await fs4.readFile(errorTxt);
-      await fs4.rm(tmpfolder, { recursive: true, force: true });
+      const err = await fs5.readFile(errorTxt);
+      await fs5.rm(tmpfolder, { recursive: true, force: true });
       return { fout, err: "vba", errS: `${err}` };
     }
     loginfo("[!5] Updating metadata");
@@ -1977,11 +3843,11 @@ async function render({
       if (!existsSync2(tmpfolder))
         return { fout, err: "pdf" };
       try {
-        const files = (await fs4.readdir(tmpfolder)).sort().map((f) => path4.join(tmpfolder, f));
-        const pdf = pout ? path4.join(pout.dir, pout.base) : path4.join(fdir, fname + ".pdf");
+        const files = (await fs5.readdir(tmpfolder)).sort().map((f) => path5.join(tmpfolder, f));
+        const pdf = pout ? path5.join(pout.dir, pout.name + ".pdf") : path5.join(fdir, fname + ".pdf");
         await mergePDFs(files, pdf, doc, signal || void 0);
-        await fs4.rm(tmpfolder, { recursive: true, force: true });
-        if (removeIntermediateDocx && existsSync2(fout)) await fs4.unlink(fout);
+        await fs5.rm(tmpfolder, { recursive: true, force: true });
+        if (removeIntermediateDocx && existsSync2(fout)) await fs5.unlink(fout);
         return { fout: pdf };
       } catch (err) {
         if (signal?.aborted) throw err;
@@ -1989,7 +3855,7 @@ async function render({
       }
     }
   } else {
-    await fs4.rename(ftmp, fout);
+    await fs5.rename(ftmp, fout);
   }
   loginfo(`[!7] Rendered to ${fout}`);
   return { fout, err: limitedRender ? "noWin" : void 0 };
@@ -2023,8 +3889,8 @@ function killProcessTree(child, wordPid) {
   }
 }
 function runDocxMacro(progress, log, logError, assets, cwd, fin, fout, renderPDF, signal) {
-  const script = path4.join(assets, "run.ps1");
-  const templateMacro = path4.join(assets, "template.dotm");
+  const script = path5.join(assets, "run.ps1");
+  const templateMacro = path5.join(assets, "template.dotm");
   return new Promise((res, rej) => {
     if (signal?.aborted)
       return rej(signal.reason ?? new Error("Aborted before execution started"));
@@ -2100,7 +3966,7 @@ function getPythonExecutable() {
   return process.env.UNO_PYTHON_PATH || "python3";
 }
 function runUnoScript(progress, log, logError, assets, cwd, fin, fout, renderPDF, signal) {
-  const script = process.env.MACRO_ENGINE_PATH || path4.join(assets, "macro_engine.py");
+  const script = process.env.MACRO_ENGINE_PATH || path5.join(assets, "macro_engine.py");
   const pythonExec = getPythonExecutable();
   return new Promise((res, rej) => {
     if (signal?.aborted) {
@@ -2164,31 +4030,61 @@ function runUnoScript(progress, log, logError, assets, cwd, fin, fout, renderPDF
   });
 }
 async function mergePDFs(files, fout, doc, signal) {
-  const mergedPdf = await PDFDocument.create();
+  const pdfFiles = files.filter((file) => file.toLowerCase().endsWith(".pdf"));
+  let mainPdfIndex = -1;
+  for (let i = 0; i < pdfFiles.length; i++) {
+    if (pdfFiles[i].toLowerCase().endsWith("-main.pdf"))
+      mainPdfIndex = i;
+  }
+  let mergedPdf;
+  if (mainPdfIndex >= 0) {
+    const bytes = await fs5.readFile(pdfFiles[mainPdfIndex], { signal });
+    mergedPdf = await PDFDocument.load(bytes);
+    signal?.throwIfAborted();
+    let insertionIndex = 0;
+    for (const file of pdfFiles.slice(0, mainPdfIndex)) {
+      const sourceBytes = await fs5.readFile(file, { signal });
+      const pdf = await PDFDocument.load(sourceBytes);
+      signal?.throwIfAborted();
+      const pages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+      for (const page of pages)
+        mergedPdf.insertPage(insertionIndex++, page);
+      signal?.throwIfAborted();
+    }
+    for (const file of pdfFiles.slice(mainPdfIndex + 1)) {
+      const sourceBytes = await fs5.readFile(file, { signal });
+      const pdf = await PDFDocument.load(sourceBytes);
+      signal?.throwIfAborted();
+      const pages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+      pages.forEach((page) => mergedPdf.addPage(page));
+      signal?.throwIfAborted();
+    }
+  } else {
+    mergedPdf = await PDFDocument.create();
+    for (const file of pdfFiles) {
+      const bytes = await fs5.readFile(file, { signal });
+      const pdf = await PDFDocument.load(bytes);
+      signal?.throwIfAborted();
+      const pages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+      pages.forEach((page) => mergedPdf.addPage(page));
+      signal?.throwIfAborted();
+    }
+  }
   if (doc?.title) mergedPdf.setTitle(doc.title, { showInWindowTitleBar: true });
   if (doc?.author) mergedPdf.setAuthor(doc.author);
   if (doc?.ctime) mergedPdf.setCreationDate(doc.ctime);
   if (doc?.mtime) mergedPdf.setModificationDate(doc.mtime);
-  for (const file of files) {
-    if (!file.endsWith(".pdf")) continue;
-    const bytes = await fs4.readFile(file, { signal });
-    const pdf = await PDFDocument.load(bytes);
-    signal?.throwIfAborted();
-    const pages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
-    pages.forEach((page) => mergedPdf.addPage(page));
-    signal?.throwIfAborted();
-  }
   const pdfBytes = await mergedPdf.save();
-  await fs4.writeFile(fout, pdfBytes, { signal });
+  await fs5.writeFile(fout, pdfBytes, { signal });
 }
 async function updateMetadata(docfile, doc) {
-  const content = await fs4.readFile(docfile);
+  const content = await fs5.readFile(docfile);
   const zip = new PizZip(content);
   function replaceTag(xml, tag, value) {
     const regex = new RegExp(`(<${tag}\\b[^>]*>)(.*?)(</${tag}>)`, "gs");
     return xml.replace(
       regex,
-      (m, otag, old, ctag) => `${otag}${escapeXml(value)}${ctag}`
+      (m, otag, old, ctag) => `${otag}${escapeXml2(value)}${ctag}`
     );
   }
   let coreXml = zip.file("docProps/core.xml").asText();
@@ -2202,8 +4098,8 @@ async function updateMetadata(docfile, doc) {
   appXml = replaceTag(appXml, "TotalTime", `${doc.etime || randomInt(30, 120)}`);
   zip.file("docProps/app.xml", appXml);
   const buffer = zip.generate({ type: "nodebuffer" });
-  await fs4.writeFile(docfile, buffer);
-  function escapeXml(unsafe) {
+  await fs5.writeFile(docfile, buffer);
+  function escapeXml2(unsafe) {
     return unsafe.replaceAll(/[<>&"']/g, (ch) => {
       switch (ch) {
         case "<":
@@ -2274,11 +4170,26 @@ async function renderMarkdown(config) {
   assert(typeof config.useLibreOffice == "boolean" || typeof config.useLibreOffice == "undefined", "useLibreOffice must be a boolean or undefined.");
   assert(typeof config.checkFilesIsInsidePath == "string" || config.checkFilesIsInsidePath === false || typeof config.checkFilesIsInsidePath == "undefined", "checkFilesIsInsidePath must be a string, false or undefined.");
   assert(typeof config.progress == "function" || typeof config.progress == "undefined", "Progress callback must be a function or undefined.");
+  assert(typeof config.variables == "object" && config.variables !== null && !Array.isArray(config.variables) || typeof config.variables == "undefined", "variables must be an object or undefined.");
+  assert(typeof config.templateOptions == "object" && config.templateOptions !== null && !Array.isArray(config.templateOptions) || typeof config.templateOptions == "undefined", "templateOptions must be an object or undefined.");
+  if (config.templateOptions) {
+    const options = config.templateOptions;
+    const booleanProps = ["allowLoops", "allowIncludes"];
+    const limitProps = ["maxLoopIterations", "maxTotalIterations", "maxDepth", "maxIncludeDepth", "maxIncludes", "maxFileLength", "maxTotalInputLength", "maxGeneratedLength"];
+    const extraProps = getExtraProperties(options, [...booleanProps, ...limitProps]);
+    assert(extraProps.length == 0, `Found unknown properties in config.templateOptions: ${extraProps.join(", ")}`);
+    booleanProps.forEach(
+      (p) => assert(options[p] === void 0 || typeof options[p] == "boolean", `config.templateOptions.${p} must be a boolean or undefined.`)
+    );
+    limitProps.forEach(
+      (p) => assert(options[p] === void 0 || Number.isSafeInteger(options[p]) && options[p] >= 0, `config.templateOptions.${p} must be a non-negative safe integer or undefined.`)
+    );
+  }
   assert(config.abortSignal instanceof AbortSignal || typeof config.abortSignal == "undefined", "abortSignal must be an AbortSignal or undefined.");
   {
     const extraProps = getExtraProperties(
       config,
-      ["input", "output", "format", "keepIntermediateDocx", "disableMacros", "useLibreOffice", "progress", "logger", "abortSignal", "checkFilesIsInsidePath"]
+      ["input", "output", "format", "keepIntermediateDocx", "disableMacros", "useLibreOffice", "progress", "logger", "abortSignal", "checkFilesIsInsidePath", "variables", "templateOptions"]
     );
     assert(extraProps.length == 0, `Found unknown properties in config: ${extraProps.join(", ")}`);
   }
@@ -2292,20 +4203,25 @@ async function renderMarkdown(config) {
       (p) => assert(typeof logger[p] == "function", `config.logger.${p} must be a function.`)
     );
   }
-  const renderPDF = config.format === "pdf" || !config.format && !!config.output?.endsWith(".pdf");
+  const outputExtension = config.output && path6.extname(config.output).toLowerCase();
+  const renderPDF = config.format === "pdf" || !config.format && outputExtension === ".pdf";
   const removeIntermediateDocx = !config.keepIntermediateDocx;
   const disableMacros = !!config.disableMacros;
   const useLibreOffice = !!config.useLibreOffice;
   const checkFilesIsInsidePath = config.checkFilesIsInsidePath === void 0 ? "" : config.checkFilesIsInsidePath;
   assert(!(disableMacros && renderPDF), "Macros must be enabled to render PDF output.");
-  const pin = path5.parse(path5.resolve(config.input));
+  if (outputExtension && outputExtension !== ".docx" && outputExtension !== ".pdf")
+    throw new TypeError("Output file extension must be either '.docx' or '.pdf'.");
+  if (outputExtension && outputExtension !== (renderPDF ? ".pdf" : ".docx"))
+    throw new TypeError(`Output file extension must match the selected '${renderPDF ? "pdf" : "docx"}' format.`);
+  const pin = path6.parse(path6.resolve(config.input));
   const fname = pin.name.endsWith(".g") ? pin.name.slice(0, -2) : pin.name;
   let resolvedOutput = config.output;
   if (resolvedOutput) {
-    const isDir = resolvedOutput.endsWith("/") || resolvedOutput.endsWith("\\") || !path5.extname(resolvedOutput);
+    const isDir = resolvedOutput.endsWith("/") || resolvedOutput.endsWith("\\") || !path6.extname(resolvedOutput);
     if (isDir) {
       const ext = renderPDF ? ".pdf" : ".docx";
-      resolvedOutput = path5.join(resolvedOutput, fname + ext);
+      resolvedOutput = path6.join(resolvedOutput, fname + ext);
     }
   }
   const warnings = [];
@@ -2330,6 +4246,8 @@ async function renderMarkdown(config) {
       disableMacros,
       useLibreOffice,
       checkFilesIsInsidePath,
+      variables: config.variables,
+      templateOptions: config.templateOptions,
       loginfo: logger?.info,
       logwarn: (msg) => {
         logger?.warn(msg);
@@ -2345,7 +4263,6 @@ async function renderMarkdown(config) {
       },
       signal: config.abortSignal
     });
-    config.progress?.(100, "Done!");
     if (useLibreOffice) {
       if (err == "noPS") throwMDE2("noPS", `Failed to run the LibreOffice binary (soffice). Ensure LibreOffice is installed and added to your system's PATH environment variable.`);
       if (err == "inPS") throwMDE2("inPS", `An unexpected error occurred executing the LibreOffice conversion command. Verify that LibreOffice is properly installed, up to date, and has permission to access the target files.`);
@@ -2356,10 +4273,11 @@ async function renderMarkdown(config) {
     if (err == "vba") throwMDE2("vba", `Microsoft Word VBA Macro execution failed: ${errS}`);
     if (err == "pdf") throwMDE2("pdf", `Failed to export document to PDF.`);
     if (err == "noWin") throwMDE2("noWin", `Platform restriction: Extended formatting macros and PDF rendering are only supported natively on Windows systems.`);
+    config.progress?.(100, "Done!");
     let intermediateDocxPath;
     if (renderPDF && !removeIntermediateDocx) {
-      const pout = resolvedOutput ? path5.parse(path5.resolve(resolvedOutput)) : void 0;
-      intermediateDocxPath = pout ? path5.join(pout.dir, pout.name + ".docx") : path5.join(pin.dir, fname + ".docx");
+      const pout = resolvedOutput ? path6.parse(path6.resolve(resolvedOutput)) : void 0;
+      intermediateDocxPath = pout ? path6.join(pout.dir, pout.name + ".docx") : path6.join(pin.dir, fname + ".docx");
     }
     return {
       filePath: fout,
@@ -2417,10 +4335,7 @@ var MDRenderError = class _MDRenderError extends Error {
   }
 };
 function getAssetsDir() {
-  if (typeof __dirname !== "undefined")
-    return path5.resolve(__dirname, "../assets");
-  const metaUrl = new Function("return import.meta.url")();
-  return path5.resolve(path5.dirname(fileURLToPath(metaUrl)), "../assets");
+  return path6.resolve(__MD2GOST_DIRNAME__, "../assets");
 }
 function getExtraProperties(configObj, allowedConfigKeys) {
   return Object.keys(configObj).filter(
@@ -2429,6 +4344,7 @@ function getExtraProperties(configObj, allowedConfigKeys) {
 }
 export {
   MDRenderError,
+  UserInputError,
   renderMarkdown as default
 };
 //# sourceMappingURL=index.mjs.map