md2gost 1.3.0

package/dist/index.mjs

@@ -0,0 +1,2130 @@
+// src/index.ts
+import path4 from "path";
+import { fileURLToPath } from "url";
+
+// src/main.ts
+import path3 from "path";
+
+// src/doc.ts
+var Doc = class {
+  nodes = [];
+  rainbow = false;
+  numberingLazy = false;
+  numberingSections = false;
+  numberingAutoprefix = true;
+  backtickMono = "italic";
+  title;
+  author;
+  etime;
+  ctime;
+  mtime;
+  hyphenation = false;
+  headings = {
+    h1: { size: 14, spacing: { before: 18, after: 4 }, indent_full: false, uppercase: false },
+    h3: { size: 14, spacing: { before: 8, after: 4 }, indent_full: false, uppercase: false },
+    h2: { size: 14, spacing: { before: 8, after: 4 }, indent_full: false, uppercase: false },
+    h4: { size: 14, spacing: { before: 8, after: 4 }, indent_full: false, uppercase: false },
+    h5: { size: 14, spacing: { before: 8, after: 4 }, indent_full: false, uppercase: false },
+    h6: { size: 14, spacing: { before: 8, after: 4 }, indent_full: false, uppercase: false }
+  };
+  text = {
+    size: 14,
+    line_spacing: 1.5,
+    indent: 1.25,
+    spacing: { after: 8 }
+  };
+  table = {
+    title: {
+      style: "normal",
+      size: void 0
+    },
+    heading: {
+      style: "normal",
+      align: "center"
+    },
+    spacing: { before: void 0, after: void 0 },
+    text: {
+      size: 12,
+      line_spacing: 1.25
+    }
+  };
+  code = {
+    title: {
+      style: "normal",
+      size: void 0
+    },
+    spacing: { before: void 0, after: void 0 },
+    highlight: false,
+    text: { size: 12 }
+  };
+  list = {
+    ordered: { style: "bracket" },
+    unordered: { style: "dash" },
+    autopunctuation: true
+  };
+  img = {
+    spacing: { before: void 0, after: void 0 },
+    text: { size: void 0 }
+  };
+  appendText(text) {
+    this.nodes.push({ type: "text", text });
+  }
+  appendTitle(text, level) {
+    this.nodes.push({ type: "title", text, level });
+  }
+  appendNode(node) {
+    this.nodes.push(node);
+  }
+};
+function tableRow(...items) {
+  return items.map((v) => ({ type: "text", text: v }));
+}
+
+// src/parser.ts
+import fs2 from "fs/promises";
+
+// src/utils.ts
+import fs from "fs/promises";
+function choice(...options) {
+  return options[randomInt(options.length)];
+}
+function randomInt(maxmin, max, rnd = Math.random) {
+  if (max != void 0)
+    return Math.floor(rnd() * (maxmin - max)) + max;
+  return Math.floor(rnd() * maxmin);
+}
+function trimEnd(str, ...chs) {
+  if (!chs || chs.length == 0) return str.trimEnd();
+  let trimmed = false;
+  do {
+    trimmed = false;
+    for (const ch of chs)
+      while (str.endsWith(ch)) {
+        str = str.slice(0, -ch.length);
+        trimmed = true;
+      }
+  } while (trimmed);
+  return str;
+}
+function trimStart(str, ...chs) {
+  if (!chs || chs.length == 0) return str.trimStart();
+  let trimmed = false;
+  do {
+    trimmed = false;
+    for (const ch of chs)
+      while (str.startsWith(ch)) {
+        str = str.slice(ch.length);
+        trimmed = true;
+      }
+  } while (trimmed);
+  return str;
+}
+function toCapitalCase(str) {
+  return str.slice(0, 1).toUpperCase() + str.slice(1);
+}
+async function checkIfFileIsBlocked(path5) {
+  let file;
+  try {
+    file = await fs.open(path5, "r+");
+    return false;
+  } catch (err) {
+    if (!err) return false;
+    if (err.code === "EBUSY" || err.code === "EACCES" || err.code === "EPERM") return true;
+    if (err.code === "ENOENT") return false;
+    throw err;
+  } finally {
+    if (file) await file.close();
+  }
+}
+function hslToHex(h, s, l) {
+  l /= 100;
+  const a = s * Math.min(l, 1 - l) / 100;
+  const f = (n) => {
+    const k = (n + h / 30) % 12;
+    const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+    return Math.round(255 * color).toString(16).padStart(2, "0");
+  };
+  return `${f(0)}${f(8)}${f(4)}`;
+}
+function repeat(n, v) {
+  if (v === void 0) v = (i) => i;
+  return new Array(n).fill(null).map((_, i) => v instanceof Function ? v(i) : v);
+}
+
+// src/parser.ts
+import path from "path";
+async function parseMD(file, logwarn = console.warn) {
+  const lines = (await fs2.readFile(file, { encoding: "utf8" })).split("\n");
+  const doc = new Doc();
+  try {
+    doc.title = toCapitalCase(trimEnd(path.parse(file).name, ".g"));
+    const stats = await fs2.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 P = ordered ? "1)" : "*";
+    function skipEmptyLines() {
+      let emptyFound = false;
+      for (let i = lineI; i < lines.length; i++) {
+        let ln = parseLine(lines[i]);
+        if (ln.prefix == "	") ln = parseLine(ln.text);
+        if (ln.prefix == "" && ln.text == "") {
+          emptyFound = true;
+          continue;
+        }
+        if (ln.prefix == "" && !emptyFound) {
+          lineI = i;
+          return false;
+        }
+        if (ln.prefix == "*" || ln.prefix == "1)") {
+          lineI = i;
+          return false;
+        }
+        return true;
+      }
+      return true;
+    }
+    while (lineI < lines.length) {
+      if (skipEmptyLines()) break;
+      let ln = parseLine(lines[lineI]);
+      const last = node.items.at(-1);
+      if (ln.level == level) {
+        if (ln.prefix == "	") ln = parseLine(ln.text);
+        if (ln.prefix == "" && last?.type == "listItem")
+          last.text += "\n" + ln.text;
+        else if (ln.prefix == P)
+          node.items.push({ type: "listItem", text: ln.text });
+        else break;
+      } else if (ln.level > level) {
+        if (ln.level == level + 1) ln = parseLine(ln.text);
+        if ((ln.prefix == "" || ln.prefix == "	") && last?.type == "listItem")
+          last.text += "\n" + ln.text;
+        else if (ln.prefix == "*" || ln.prefix == "1)") {
+          lineI++;
+          node.items.push(parseList(ln.text, ln.parts, ln.prefix == "1)", level + 1));
+          continue;
+        } else break;
+      } else break;
+      lineI++;
+    }
+    return node;
+  }
+  function parseImg(parts) {
+    const text = parts[0].replaceAll("\\n", "\n").trim() || void 0;
+    const size = parts[2];
+    let width = null;
+    let height = null;
+    if (size) {
+      const s = size.split("x");
+      const w = parseInt(s[0] || "");
+      const h = parseInt(s[1] || "");
+      if (isFinite(w)) width = w;
+      if (isFinite(h)) height = h;
+    }
+    const src = trimEnd(trimStart(parts[1], "<"), ">");
+    return { type: "image", text, src, width, height };
+  }
+  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 = "";
+    while (lineI < lines.length) {
+      let ln = lines[lineI++];
+      if (ln.startsWith("```")) break;
+      text += "\n" + ln;
+    }
+    node.code = text.trim();
+    return node;
+  }
+  function parseSection(text) {
+    const match = /from\s+(\d+)/.exec(text);
+    const num = match ? parseInt(match[1] || "") : NaN;
+    return { type: "sectionBreak", pageStart: isFinite(num) ? num : null };
+  }
+  class RuleError extends Error {
+  }
+  ;
+  function apllyRule(text) {
+    text = text.trim().replaceAll(/\s+/g, " ");
+    const textl = text.toLowerCase();
+    const rules = {
+      "highlight code": (v) => doc.code.highlight = true,
+      // deprecated
+      "rainbow": (v) => doc.rainbow = true,
+      "title": (v) => doc.title = v,
+      "author": (v) => doc.author = v,
+      "etime": (v) => doc.etime = tryParseInt(v),
+      "ctime": (v) => doc.ctime = tryParseDate(v),
+      "mtime": (v) => doc.mtime = tryParseDate(v),
+      "numbering lazy": (v) => {
+        choices(v, "", "on", "off");
+        doc.numberingLazy = !v || v == "on";
+      },
+      "numbering sections": (v) => {
+        choices(v, "", "on", "off");
+        doc.numberingSections = !v || v == "on";
+      },
+      "numbering autoprefix": (v) => {
+        choices(v, "", "on", "off");
+        doc.numberingAutoprefix = v == "on";
+      },
+      "backtick_mono": (v) => doc.backtickMono = choices(v, "italic", "off", "on", "outline"),
+      "hyphenation": (v) => doc.hyphenation = true,
+      "table title style": (v) => doc.table.title.style = choices(v, "normal", "bold", "italic"),
+      "table title size": (v) => doc.table.title.size = tryParseInt(v),
+      "table spacing before": (v) => doc.table.spacing.before = tryParseInt(v),
+      "table spacing after": (v) => doc.table.spacing.after = tryParseInt(v),
+      "table heading style": (v) => doc.table.heading.style = choices(v, "normal", "bold", "italic"),
+      "table heading align": (v) => doc.table.heading.align = choices(v, "left", "center", "right"),
+      "table text size": (v) => doc.table.text.size = tryParseInt(v),
+      "table text line_spacing": (v) => doc.table.text.line_spacing = tryParseFloat(v),
+      "code title style": (v) => doc.code.title.style = choices(v, "normal", "bold", "italic"),
+      "code title size": (v) => doc.code.title.size = tryParseInt(v),
+      "code spacing before": (v) => doc.code.spacing.before = tryParseInt(v),
+      "code spacing after": (v) => doc.code.spacing.after = tryParseInt(v),
+      "code highlight": (v) => {
+        choices(v, "", "on", "off");
+        doc.code.highlight = !v || v == "on";
+      },
+      "code text size": (v) => doc.code.text.size = tryParseInt(v),
+      "list ordered style": (v) => doc.list.ordered.style = choices(v, "bracket", "dot", "keep"),
+      "list unordered style": (v) => doc.list.unordered.style = choices(v, "dash", "bullet", "keep"),
+      "list autopunctuation": (v) => {
+        choices(v, "", "on", "off");
+        doc.list.autopunctuation = v == "on";
+      },
+      "headings alt_style_1": (v) => {
+        for (let i = 1; i <= 6; i++) {
+          doc.headings[`h${i}`].indent_full = true;
+          doc.headings[`h${i}`].spacing.after = 10;
+          doc.headings[`h${i}`].spacing.before = 15;
+        }
+        doc.headings.h1.size = 18;
+        doc.headings.h1.uppercase = true;
+        doc.headings.h1.spacing.before = 0;
+        doc.headings.h2.size = 16;
+      },
+      "text size": (v) => doc.text.size = tryParseInt(v),
+      "text line_spacing": (v) => doc.text.line_spacing = tryParseFloat(v),
+      "text indent": (v) => doc.text.indent = tryParseFloat(v),
+      "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)
+    };
+    const reRules = [
+      {
+        re: /^(headings (h[1-6])(\+?) (size|spacing (before|after)|uppercase|indent))(.*)/,
+        n: (m) => ({ rule: m[1], value: (m.at(-1) || "").trim() }),
+        f(m) {
+          const level = parseInt(m[2][1]);
+          const plus = m[3] == "+";
+          const property = m[4];
+          const value = (m.at(-1) || "").trim();
+          for (let i = level; i <= (plus ? 6 : level); i++) {
+            const h = doc.headings[`h${i}`];
+            if (property == "size") h.size = tryParseInt(value);
+            else if (property == "spacing before") h.spacing.before = tryParseInt(value);
+            else if (property == "spacing after") h.spacing.after = tryParseInt(value);
+            else if (property == "uppercase") {
+              choices(value, "", "on", "off");
+              h.uppercase = !value || value == "on";
+            } else if (property == "indent") h.indent_full = choices(value, "first_line", "left") == "left";
+          }
+        }
+      }
+    ];
+    const rulePrefix = Object.keys(rules).find(
+      (prefix) => textl.startsWith(prefix) && !textl.slice(prefix.length)[0]?.trim()
+    );
+    const reRule = rulePrefix ? void 0 : reRules.map(({ re, f, n }) => ({ f, n, m: re.exec(textl) })).find(({ m }) => !!m);
+    let applyRule = rulePrefix ? () => rules[rulePrefix](text.slice(rulePrefix.length).trim()) : reRule ? () => reRule.f(reRule.m) : void 0;
+    if (applyRule) {
+      try {
+        applyRule();
+      } catch (e) {
+        let rule = rulePrefix;
+        let value = rulePrefix && text.slice(rulePrefix.length);
+        if (reRule) {
+          const n = reRule.n(reRule.m);
+          rule = n.rule;
+          value = n.value;
+        }
+        if (e instanceof RuleError) logwarn(`Rule "${rule}" wrong value: "${value}". ${e.message}`);
+        else throw e;
+      }
+    } else {
+      logwarn(`Wrong rule: "${text}"`);
+    }
+    function tryParseInt(v) {
+      const num = parseInt(v);
+      if (!isFinite(num)) throw new RuleError("Only integers are allowed");
+      return num;
+    }
+    function tryParseFloat(v) {
+      const num = parseFloat(v);
+      if (!isFinite(num)) throw new RuleError("Only integers and floats are allowed");
+      return num;
+    }
+    function tryParseDate(v) {
+      const date = new Date(v);
+      if (!isFinite(date.valueOf())) throw new RuleError("Only ISO 8601 date is allowed");
+      return date;
+    }
+    function choices(v, ...vars) {
+      if (vars.includes(v)) return v;
+      throw new RuleError("Allowed: " + vars.join(", "));
+    }
+  }
+  function skipComment() {
+    while (lineI - 1 < lines.length && !lines[lineI - 1].includes("-->"))
+      lineI++;
+  }
+  let lineI = 0;
+  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");
+    }
+  }
+  doc.nodes = doc.nodes.filter((n) => n.type != "text" || n.text != "");
+  findDocs(doc.nodes, logwarn);
+  findTables(doc.nodes);
+  findPageBreaks(doc.nodes);
+  return doc;
+}
+function parseLine(line) {
+  let level = 0;
+  while (line.startsWith("    ") || line.startsWith("	")) {
+    if (line.startsWith("    ")) line = line = line.slice(4);
+    else if (line.startsWith("	")) line = line.slice(1);
+    level++;
+  }
+  if (level > 0) return { prefix: "	", text: line.trim(), level, parts: [] };
+  if (/^\s*---+\s*$/.test(line)) return { prefix: "---", text: "", level, parts: [] };
+  const splited = line.trim().split(/\s/);
+  let prefix = splited[0].toLowerCase();
+  let text = splited.slice(1).join(" ");
+  let parts = [];
+  if (prefix.startsWith("!")) {
+    const m_img = /!\[(.*)\]\((.*)\)({(.*)})?/.exec(line);
+    if (m_img) return {
+      prefix: "Img",
+      text: line.trim(),
+      level,
+      parts: [m_img[1], m_img[2], m_img[4]]
+    };
+  }
+  if (prefix == "-" || prefix == "*") {
+    parts = ["", prefix];
+    prefix = "*";
+  }
+  if (prefix.endsWith(".") || prefix.endsWith(")")) {
+    const index = parseInt(prefix.slice(0, -1));
+    if (isFinite(index)) {
+      parts = [`${index}`, prefix.at(-1) || ")"];
+      prefix = "1)";
+    }
+  }
+  if (prefix.startsWith("```")) return { prefix: "Code", text: line.trim().slice(3), level, parts };
+  if (prefix.startsWith("<!--")) return { prefix: "Comment", text: line.trim().slice("<!--".length).trim(), level, parts };
+  if (["#", "##", "###", "####", "#####", "######", "*", "1)", "!!section", "!!rule"].includes(prefix))
+    return { prefix, text, level: 0, parts };
+  return { prefix: "", text: line.trim(), level, parts };
+}
+function findDocs(nodes, logwarn = console.warn) {
+  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"));
+    if (!m_doc) continue;
+    let dict = {};
+    try {
+      dict = JSON.parse(`{${m_doc[2]}}`);
+    } catch (x) {
+      logwarn(`Cant parse doc dict: {${m_doc[2].replaceAll("\n", " ")}}`);
+    }
+    nodes.splice(i, 1, {
+      type: "externalDoc",
+      path: trimEnd(trimStart(m_doc[1], "<", '"'), ">", '"'),
+      dict: stringifyDict(dict)
+    });
+  }
+}
+function stringifyDict(dict) {
+  const r = {};
+  for (const key in dict) {
+    let v = dict[key];
+    if (typeof v == "string" || typeof v == "boolean" || typeof v == "number") {
+      r[key] = `${v}`;
+      continue;
+    }
+    if (!v) continue;
+    if (v instanceof Array) {
+      const d2 = {};
+      v.forEach((v2, i) => d2[`${i}`] = v2);
+      v = d2;
+    }
+    const d = stringifyDict(v);
+    for (const k in d)
+      r[key + "." + k] = d[k];
+  }
+  return r;
+}
+function findTables(nodes) {
+  const re_sep = /^(\s*:?-+:?\s*(?<!\\)\|)+\s*:?-+:?\s*$/;
+  const re_sep_oneCol = /^\|\s*:?-+:?\s*\|$/;
+  const trim = (line) => {
+    line = line.trim();
+    if (line.at(0) == "|") line = line.slice(1);
+    if (line.at(-1) == "|") line = line.slice(0, -1);
+    return line.trim();
+  };
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.type != "text") continue;
+    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 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)];
+    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));
+    }
+    const table = { type: "table", align, rows };
+    nodes.splice(i, 1, table);
+    const prev = nodes[i - 1];
+    if (offset > 0) {
+      table.title = lines[0];
+    } else if (prev?.type == "text") {
+      nodes.splice(i - 1, 1);
+      table.title = prev.text;
+      i--;
+    }
+  }
+}
+function findPageBreaks(nodes) {
+  const re_sep = /^\s*---+\s*$/;
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.type != "text") continue;
+    if (!node.text.includes("---")) 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 });
+      }
+    }
+    nodes.splice(i, 1, ...newNodes);
+    i += newNodes.length - 1;
+  }
+}
+function runifyDoc(doc) {
+  function runifyNode(node) {
+    if ("text" in node && node.text)
+      node.text = runifyText(node.text, doc.rainbow);
+    if ("title" in node && node.title)
+      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);
+  }
+  doc.nodes.forEach(runifyNode);
+  return doc;
+}
+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}\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] };
+  }).map((rune) => rune.text.split("\n").map((p, i) => ({
+    text: p.replaceAll(/\s+/g, " ").replaceAll("&nbsp;", "\xA0").replaceAll("&Tab;", "	"),
+    linebreak: i > 0,
+    link: rune.link
+  }))).flat().map((rune) => rune.text.split("***").map((p, i, arr) => ({
+    text: p,
+    linebreak: i == 0 && rune.linebreak,
+    link: rune.link,
+    bold: i % 2 == 1 && i != arr.length - 1,
+    italic: i % 2 == 1 && i != arr.length - 1
+  }))).flat().map((rune) => rune.text.split("**").map((p, i, arr) => ({
+    text: p,
+    linebreak: i == 0 && rune.linebreak,
+    link: rune.link,
+    bold: i % 2 == 1 && i != arr.length - 1 || rune.bold,
+    italic: rune.italic
+  }))).flat().map((rune) => rune.text.split("*").map((p, i, arr) => ({
+    text: p,
+    linebreak: i == 0 && rune.linebreak,
+    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) => {
+    const m = /\[(!?([a-zA-Zа-яА-ЯёЁ_\d]+|#)(\s*[-\+]\s*\d+)?)\]/.exec(p);
+    const v = m && m[1];
+    const isVal = v?.at(0) == "!";
+    return {
+      ...rune,
+      text: v ? isVal ? v.slice(1) : v : p,
+      type: v ? isVal ? "val" : "ref" : rune.type,
+      linebreak: i == 0 && rune.linebreak
+    };
+  })).flat().map((rune) => ({
+    ...rune,
+    ...!rune.type || rune.type == "text" ? {
+      text: rune.text.replaceAll("&Star;", "*").replaceAll("&#x200B;", "")
+    } : {}
+  })).map((rune) => !rainbow || rune.type && rune.type != "text" ? [rune] : rune.text.split("").map((p, i) => ({
+    ...rune,
+    text: p,
+    linebreak: i == 0 && rune.linebreak,
+    color: hslToHex(rainbowI++ % 360, 100, 50)
+  }))).flat();
+}
+function replaceAmpCodes(text) {
+  const codes = {
+    "&#124;": "|",
+    "&shy;": "\xAD",
+    "&laquo;": "\xAB",
+    "&raquo;": "\xBB",
+    "&lsaquo;": "\u2039",
+    "&rsaquo;": "\u203A",
+    "&alpha;": "\u03B1",
+    "&beta;": "\u03B2",
+    "&gamma;": "\u03B3",
+    "&delta;": "\u03B4",
+    "&epsilon;": "\u03B5",
+    "&zeta;": "\u03B6",
+    "&eta;": "\u03B7",
+    "&theta;": "\u03B8",
+    "&iota;": "\u03B9",
+    "&kappa;": "\u03BA",
+    "&lambda;": "\u03BB",
+    "&mu;": "\u03BC",
+    "&nu;": "\u03BD",
+    "&xi;": "\u03BE",
+    "&omicron;": "\u03BF",
+    "&pi;": "\u03C0",
+    "&rho;": "\u03C1",
+    "&sigma;": "\u03C3",
+    "&tau;": "\u03C4",
+    "&upsilon;": "\u03C5",
+    "&phi;": "\u03C6",
+    "&chi;": "\u03C7",
+    "&psi;": "\u03C8",
+    "&omega;": "\u03C9",
+    "&Delta;": "\u0394",
+    "&Sigma;": "\u03A3",
+    "&Omega;": "\u03A9",
+    "&infin;": "\u221E",
+    "&sum;": "\u2211",
+    "&prod;": "\u220F",
+    "&radic;": "\u221A",
+    "&int;": "\u222B",
+    "&part;": "\u2202",
+    "&asymp;": "\u2248",
+    "&ne;": "\u2260",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&le;": "\u2264",
+    "&ge;": "\u2265",
+    "&plusmn;": "\xB1",
+    "&times;": "\xD7",
+    "&divide;": "\xF7",
+    "&copy;": "\xA9",
+    "&reg;": "\xAE",
+    "&trade;": "\u2122",
+    "&sect;": "\xA7",
+    "&para;": "\xB6",
+    "&hellip;": "\u2026",
+    "&bull;": "\u2022",
+    "&middot;": "\xB7",
+    "&deg;": "\xB0",
+    "&euro;": "\u20AC",
+    "&pound;": "\xA3",
+    "&yen;": "\xA5",
+    "&cent;": "\xA2",
+    "&curren;": "\xA4",
+    "&fnof;": "\u0192",
+    "&permil;": "\u2030"
+  };
+  for (const code in codes) {
+    if (!Object.hasOwn(codes, code)) continue;
+    const char = codes[code];
+    text = text.replaceAll(code, char);
+  }
+  return text;
+}
+
+// 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 } from "docx";
+import { imageSize } from "image-size";
+import path2 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";
+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) {
+  const getPath = (fname) => {
+    if (process.platform == "win32" && fname[0] == "/") fname = "." + fname;
+    return path2.isAbsolute(fname) ? fname : path2.join(workdir, fname);
+  };
+  const sections = [];
+  const numbering = [];
+  const docSections = (function splitSections() {
+    const sections2 = [{ pageStart: 1, nodes: [] }];
+    for (let j = 0; j < doc.nodes.length; j++) {
+      const node = doc.nodes[j];
+      if (node.type == "sectionBreak")
+        sections2.push({ pageStart: node.pageStart, nodes: [] });
+      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) {
+      switch (node.type) {
+        case "text":
+          return new Paragraph({
+            children: renderText(node.text),
+            indent: node.noIndent ? { firstLine: 0 } : {},
+            ...node.center ? { alignment: "center", indent: { firstLine: 0 } } : {},
+            spacing: {
+              ...node.noMargin ? { after: 0 } : {},
+              ...prevChild instanceof Table ? { before: (doc.table.spacing.after ?? doc.text.spacing.after) * 20 } : {}
+            }
+          });
+        case "title":
+          if (node.level < 0 || node.level > 6) throw new Error("Wrong heading level");
+          const level = node.level == 0 ? 1 : node.level;
+          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),
+            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) } } : {},
+            spacing: {
+              before: styles.spacing.before * 20,
+              after: styles.spacing.after * 20
+            }
+          });
+        case "pageBreak":
+          if (!(prevChild instanceof Paragraph))
+            return new Paragraph({ children: [new PageBreak()] });
+          prevChild.addChildElement(new PageBreak());
+          return [];
+        case "list":
+          let renderList2 = function(node2, level2 = 0) {
+            let mark = node2.mark;
+            if (node2.ordered) mark = doc.list.ordered.style == "keep" ? mark : doc.list.ordered.style == "dot" ? "." : ")";
+            else mark = doc.list.unordered.style == "keep" ? mark : doc.list.unordered.style == "bullet" ? "*" : "-";
+            addListItemLevel(list.levels, level2, node2.startIndex, node2.items.length, !!node2.ordered, !!node2.alternativeStyle, mark);
+            for (const item of node2.items) {
+              if (item.type == "list") renderList2({ ...item, alternativeStyle: !!node2.alternativeStyle }, level2 + 1);
+              else {
+                items.push(new Paragraph({
+                  children: renderText(item.text),
+                  style: STYLE_list,
+                  numbering: { reference: id, level: level2 },
+                  spacing: {
+                    ...addMargin ? { before: (doc.table.spacing.after ?? doc.text.spacing.after) * 20 } : {}
+                  }
+                }));
+                addMargin = false;
+              }
+            }
+          };
+          var renderList = renderList2;
+          if (node.items.length == 0) return [];
+          const id = `l${numbering.length + 1}`;
+          const list = {
+            reference: id,
+            levels: []
+          };
+          numbering.push(list);
+          const items = [];
+          let addMargin = prevChild instanceof Table;
+          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);
+          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),
+                style: STYLE_table_title,
+                ...prevChild instanceof Table ? { spacing: { before: spacingInner * 20 } } : doc.table.spacing.before ? { spacing: { before: doc.table.spacing.before * 20 } } : {}
+              })
+            ] : prevChild instanceof Table ? [
+              new Paragraph({ spacing: { line: 20, before: spacingInner * 20, after: 0 } })
+            ] : doc.table.spacing.before ? [
+              new Paragraph({ spacing: { line: 20, before: doc.table.spacing.before * 20, after: 0 } })
+            ] : [],
+            new Table({
+              // width: { type: "pct", size: 100 },
+              width: { type: "dxa", size: 9572 },
+              rows: node.rows.map((row, rowI) => new TableRow({
+                tableHeader: 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",
+                      indent: { firstLine: 0 },
+                      spacing: { after: 0, line: 240 * doc.table.text.line_spacing }
+                    })
+                  ]
+                }))
+              }))
+            })
+          ];
+        case "tableOfContents":
+          return [
+            new TableOfContents("\u041E\u0433\u043B\u0430\u0432\u043B\u0435\u043D\u0438\u0435", {
+              hyperlink: true,
+              headingStyleRange: "1-3"
+            }),
+            new Paragraph({ children: [new PageBreak()] })
+          ];
+        case "image":
+          const type = node.src.split(".").at(-1) || "";
+          if (!["jpg", "png", "gif", "bmp", "svg"].includes(type))
+            throw new Error(`Unsupported image format: "${type}", file: ${node.src}`);
+          const img_path = getPath(node.src);
+          if (!fs3.existsSync(img_path))
+            throw new Error(`File not exist: ${node.src}`);
+          const data = fs3.readFileSync(img_path);
+          const dimensions = imageSize(data);
+          const [MaxW, MaxH] = [600, 800];
+          let [width, height] = [dimensions.width, dimensions.height];
+          if (node.width && node.height) [width, height] = [node.width, node.height];
+          if (node.width) [width, height] = [node.width, height / width * node.width];
+          if (node.height) [width, height] = [width / height * node.height, node.height];
+          if (height > MaxH) [width, height] = [width / height * MaxH, MaxH];
+          if (width > MaxW) [width, height] = [MaxW, height / width * MaxW];
+          return [
+            new Paragraph({
+              alignment: "center",
+              indent: { firstLine: 0 },
+              spacing: {
+                line: 240,
+                ...!node.text && doc.img.spacing.after !== void 0 ? { after: doc.img.spacing.after * 20 } : {},
+                ...doc.img.spacing.before !== void 0 ? { before: doc.img.spacing.before * 20 } : {}
+              },
+              keepNext: !!node.text,
+              children: [
+                new ImageRun({
+                  type,
+                  data,
+                  transformation: { width, height },
+                  ...type == "svg" ? { fallback: { data: "", type: "png" } } : {}
+                })
+              ]
+            }),
+            ...node.text ? [
+              new Paragraph({
+                children: renderText(node.text, doc.img.text.size),
+                alignment: "center",
+                indent: { firstLine: 0 },
+                spacing: {
+                  line: 240,
+                  ...doc.img.spacing.after !== void 0 ? { after: doc.img.spacing.after * 20 } : {}
+                }
+              })
+            ] : []
+          ];
+        case "code":
+          const code = doc.code.highlight && renderCodeHighlighting(node.code, node.lang);
+          return [
+            ...node.title ? [
+              new Paragraph({
+                children: renderText(node.title, doc.code.title.size),
+                style: STYLE_code_title
+              })
+            ] : prevNode?.type == "code" ? [
+              new Paragraph({ spacing: { line: 20 } })
+            ] : [],
+            ...code ? code : node.code.split("\n").map((p, i) => new Paragraph({
+              children: [new TextRun(p)],
+              style: STYLE_code,
+              ...i == 0 && !node.title && doc.code.spacing.before && prevNode?.type != "code" ? { spacing: { before: doc.code.spacing.before * 20 } } : {}
+            }))
+          ];
+        case "externalDoc":
+          const doc_path = getPath(node.path);
+          if (!fs3.existsSync(doc_path))
+            throw new Error(`File not exist: ${node.path}`);
+          const ext = path2.extname(doc_path);
+          if (ext != ".docx" && ext != ".pdf")
+            throw new Error(`File not .docx or .pdf: ${node.path}`);
+          return new Paragraph({
+            text: `!!(${doc_path})${JSON.stringify(node.dict)}`,
+            indent: { firstLine: 0 },
+            alignment: "left"
+          });
+        case "sectionBreak":
+          return [];
+        default:
+          node;
+          throw new Error("switch default");
+      }
+    }, renderNodeL2 = function(node, prevChild, prevNode) {
+      const r = renderNode2(node, prevChild, prevNode);
+      if (r instanceof Array) return r;
+      return [r];
+    };
+    var renderNode = renderNode2, renderNodeL = renderNodeL2;
+    const children = [];
+    sections.push({
+      children,
+      properties: {
+        page: {
+          pageNumbers: !section.pageStart ? {} : {
+            start: section.pageStart
+          },
+          margin: {
+            top: convertMillimetersToTwip(20),
+            left: convertMillimetersToTwip(30),
+            right: convertMillimetersToTwip(15),
+            bottom: convertMillimetersToTwip(20)
+          }
+        }
+      },
+      footers: {
+        default: new Footer({
+          children: [
+            new Paragraph({
+              alignment: AlignmentType.CENTER,
+              children: [new TextRun({
+                children: section.pageStart ? [PageNumber.CURRENT] : []
+              })],
+              indent: { firstLine: 0 },
+              spacing: { line: 240 }
+            })
+          ]
+        })
+      }
+    });
+    for (let i = 0; i < section.nodes.length; i++)
+      children.push(...renderNodeL2(section.nodes[i], children.at(-1), section.nodes[i - 1]));
+  }
+  const docx = new Document({
+    sections,
+    externalStyles: genXml_style(assets, doc),
+    // features: { updateFields: true },
+    numbering: { config: numbering },
+    ...doc.rainbow ? { background: { color: "#000000" } } : {},
+    ...doc.hyphenation ? {
+      hyphenation: {
+        autoHyphenation: true,
+        consecutiveHyphenLimit: 2,
+        doNotHyphenateCaps: true,
+        hyphenationZone: 360
+      }
+    } : {}
+    // title: doc.title,
+    // creator: doc.author,
+    // lastModifiedBy: doc.author,
+  });
+  const buffer = await Packer.toBuffer(docx, void 0, [
+    { path: "docProps/app.xml", data: genXml_app({ totalTime: doc.etime }) },
+    {
+      path: "docProps/core.xml",
+      data: genXml_core({
+        title: doc.title,
+        creator: doc.author,
+        createdAt: doc.ctime,
+        modifiedAt: doc.mtime
+      })
+    }
+  ]);
+  fs3.writeFileSync(fout, buffer);
+  function renderText(text, size) {
+    function renderRune(rune, link = false) {
+      if (rune.anchor) return new Bookmark({
+        id: rune.anchor,
+        children: [renderRune({ ...rune, anchor: void 0 })]
+      });
+      if (rune.link) {
+        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 });
+      }
+      let children = null;
+      if (rune.type == "val" && rune.text == "pages") {
+        rune.type = "text";
+        children = [PageNumber.TOTAL_PAGES];
+      }
+      return new TextRun({
+        ...children ? { children } : { text: rune.text },
+        language: { value: rune.lang == "en" ? "en-US" : "ru-RU" },
+        ...rune.linebreak ? { break: 1 } : {},
+        ...rune.bold ? { bold: true } : {},
+        ...rune.italic ? { italics: true } : {},
+        ...link ? { color: "0563c1", underline: { type: "single" } } : {},
+        ...rune.color ? { color: rune.color } : {},
+        ...size && size > 0 ? { size: size * 2 } : {},
+        ...rune.type && rune.type != "text" ? { highlight: "black", color: "ffffff" } : {},
+        ...rune.mono ? doc.backtickMono == "outline" ? { font: "consolas", size: (doc.text.size - 1) * 2, border: { style: "single", space: 2 } } : doc.backtickMono == "on" ? { font: "consolas", size: (doc.text.size - 1) * 2 } : doc.backtickMono == "italic" ? { italics: true } : {} : {}
+      });
+    }
+    if (typeof text == "string") text = [{ text }];
+    if (text.at(-1)?.text == "" && text.at(-1)?.linebreak) text = text.slice(0, -1);
+    text = splitRunesByLang(text);
+    return text.map((r) => renderRune(r));
+    function splitRunesByLang(runes) {
+      const result = [];
+      for (let r = 0; r < runes.length; r++) {
+        const rune = runes[r];
+        const text2 = rune.text;
+        if (!text2 || text2.length === 0) {
+          result.push(rune);
+          continue;
+        }
+        let bufferStart = 0;
+        let lastType = 0;
+        let segmentType = 0;
+        for (let i = 0; i < text2.length; i++) {
+          const code = text2.charCodeAt(i);
+          let type = 0;
+          if (code >= 65 && code <= 90 || code >= 97 && code <= 122)
+            type = 1;
+          else if (code >= 1024 && code <= 1279)
+            type = 2;
+          if (segmentType === 0 && type !== 0) segmentType = type;
+          if (i > bufferStart && type !== 0 && lastType !== 0 && type !== lastType) {
+            result.push(copyRune(rune, text2.slice(bufferStart, i), segmentType, bufferStart == 0));
+            bufferStart = i;
+            segmentType = type;
+          }
+          if (type !== 0) lastType = type;
+        }
+        if (bufferStart === 0)
+          result.push(copyRune(rune, text2, segmentType || lastType, true));
+        else
+          result.push(copyRune(rune, text2.slice(bufferStart), segmentType, false));
+      }
+      return result;
+      function copyRune(src, text2, type, first) {
+        return {
+          ...src,
+          text: text2,
+          anchor: first ? src.anchor : void 0,
+          linebreak: src.linebreak && first,
+          lang: type == 1 ? "en" : type == 2 ? "ru" : void 0
+        };
+      }
+    }
+  }
+}
+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);
+  let indent = level;
+  const format = ordered ? LevelFormat.DECIMAL : LevelFormat.BULLET;
+  for (let i = 1; i < levels.length + 1; i++) {
+    const prevprevformat = levels[i - 2]?.format;
+    const prevformat = levels[i - 1]?.format;
+    const curformat = i < levels.length ? levels[i]?.format : format;
+    if (prevprevformat != curformat && prevformat != curformat) indent--;
+  }
+  const longList = startIndex + itemCount > 10;
+  const left = alternativeStyle ? 0 : longList ? 20.5 : 17.5;
+  const hanging = longList && !alternativeStyle ? convertMillimetersToTwip(8) : null;
+  const text = ordered ? alternativeStyle ? `%${level + 1}.` : mark == "." ? `%${level + 1}.` : `%${level + 1})` : (
+    // mark == "*" ? "\u2022" : "\u2012";
+    mark == "*" ? "\xB7" : "\u2012"
+  );
+  levels.push({
+    level,
+    format,
+    start: startIndex,
+    text,
+    style: {
+      ...text == "\xB7" ? {
+        run: {
+          font: { name: "Symbol" }
+        }
+      } : {},
+      paragraph: {
+        indent: {
+          left: convertMillimetersToTwip(left + 5 * indent),
+          ...alternativeStyle ? { firstLine: convertMillimetersToTwip(12.5) } : {},
+          ...hanging ? { hanging } : {}
+        }
+      }
+    }
+  });
+}
+function renderCodeHighlighting(code, lang) {
+  const grammar = Prism.languages[lang.trim().toLowerCase()];
+  if (!grammar) return null;
+  const themeColors = {
+    // shared
+    "plain": "000000",
+    "comment": "008000",
+    "punctuation": "000000",
+    "operator": "000000",
+    // keywords & control flow
+    "keyword": "0000ff",
+    "boolean": "0000ff",
+    "builtin": "0000ff",
+    "important": "0000ff",
+    // literals
+    "string": lang === "css" ? "0451a5" : lang === "json" ? "a31515" : "a31515",
+    "number": "098658",
+    "constant": "0000ff",
+    "symbol": "0000ff",
+    "char": "a31515",
+    // identifiers
+    "class-name": lang === "js" || lang === "ts" ? "267f99" : "0451a5",
+    "function": "0451a5",
+    "variable": "000000",
+    "namespace": "000000",
+    "property": lang === "css" ? "e50000" : "0451a5",
+    // markup / HTML / XML
+    "tag": lang === "html" || lang === "xml" ? "800000" : "0000ff",
+    "selector": "800000",
+    "attr-name": "e50000",
+    "attr-value": "a31515",
+    "entity": "800000",
+    "doctype": "808080",
+    "cdata": "808080",
+    "prolog": "808080",
+    // CSS specific
+    "atrule": "0000ff",
+    "url": "0451a5",
+    // regex
+    "regex": "811f3f"
+  };
+  const tokens = Prism.tokenize(code, grammar);
+  return tokensToParagraphs(tokens);
+  function tokensToParagraphs(tokens2) {
+    const paragraphs = [];
+    let currentRuns = [];
+    function addText(text, type) {
+      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"
+          })
+        );
+        if (index < lines.length - 1) {
+          paragraphs.push(new Paragraph({ children: currentRuns, style: STYLE_code }));
+          currentRuns = [];
+        }
+      });
+    }
+    function process2(token, parentType = "plain") {
+      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);
+    }
+    tokens2.forEach((t) => process2(t));
+    if (currentRuns.length > 0) {
+      paragraphs.push(new Paragraph({ children: currentRuns, style: STYLE_code }));
+    }
+    return paragraphs;
+  }
+}
+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">
+<TotalTime>${totalTime || randomInt(30, 120)}</TotalTime>
+</Properties>
+	`;
+}
+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>
+<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(path2.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)}"/>`);
+    xml2 = replaceTag(xml2, `<w:sz w:val="${doc.text.size * 2}"/>`);
+    return xml2;
+  });
+  xml = editStyle(`<w:style w:type="paragraph" w:customStyle="1" w:styleId="ListingCaption">`, (xml2) => {
+    if (doc.code.spacing.before !== void 0)
+      xml2 = replaceTag(xml2, `<w:spacing w:after="0" w:line="240" w:lineRule="auto" w:before="${doc.code.spacing.before * 20}"/>`);
+    if (doc.code.title.style != "normal")
+      xml2 = addrPrStyle(xml2, doc.code.title.style == "bold" ? "<w:b/>" : "<w:i/>");
+    return xml2;
+  });
+  xml = editStyle(`<w:style w:type="paragraph" w:customStyle="1" w:styleId="ListingCode">`, (xml2) => {
+    xml2 = replaceTag(xml2, `<w:sz w:val="${doc.code.text.size * 2}"/>`);
+    if (doc.code.spacing.after !== void 0)
+      xml2 = replaceTag(xml2, `<w:spacing w:line="240" w:lineRule="auto" w:after="${doc.code.spacing.after * 20}"/>`);
+    return xml2;
+  });
+  xml = editStyle(`<w:style w:type="paragraph" w:customStyle="1" w:styleId="TableCaption">`, (xml2) => {
+    if (doc.table.title.style != "normal")
+      xml2 = addrPrStyle(xml2, doc.table.title.style == "bold" ? "<w:b/>" : "<w:i/>");
+    return xml2;
+  });
+  return xml;
+  function replaceTag(xml2, tag) {
+    const tagName = /<([^\s]+)\b/.exec(tag)?.[1];
+    if (!tagName) throw err();
+    const regex = new RegExp(`(<${tagName}\\b[^>]*/>)`, "s");
+    return xml2.replace(regex, tag);
+  }
+  function editStyle(tag, f) {
+    const startI = xml.indexOf(tag);
+    if (startI < 0) throw err();
+    let endI = xml.indexOf(`</w:style>`, startI);
+    if (endI < 0) throw err();
+    endI += `</w:style>`.length;
+    return xml.slice(0, startI) + f(xml.slice(startI, endI)) + xml.slice(endI);
+  }
+  function insertAfter(xml2, search, value) {
+    const sI = xml2.indexOf(search);
+    if (sI < 0) return { ok: false, xml: xml2 };
+    const i = sI + search.length;
+    return { ok: true, xml: xml2.slice(0, i) + value + xml2.slice(i) };
+  }
+  function insertBefore(xml2, search, value) {
+    const i = xml2.indexOf(search);
+    if (i < 0) return { ok: false, xml: xml2 };
+    return { ok: true, xml: xml2.slice(0, i) + value + xml2.slice(i) };
+  }
+  function addrPrStyle(xml2, value) {
+    let r = insertAfter(xml2, "<w:rPr>", value);
+    if (r.ok) return r.xml;
+    r = insertBefore(xml2, "</w:style>", `<w:rPr>${value}</w:rPr>`);
+    if (r.ok) return r.xml;
+    throw err();
+  }
+  function err() {
+    return new Error(`styles.xml is corrupted (broken extension version - upgrade or downgrade)`);
+  }
+}
+
+// src/enricher.ts
+function enrichDoc(doc, logwarn = console.warn) {
+  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" });
+      i++;
+    } else if (node.type == "title" && node.text.toUpperCase() == "\u0420\u0415\u0424\u0415\u0420\u0410\u0422") {
+      node.level = 0;
+      node.text = node.text.toUpperCase();
+      const nextNode = doc.nodes[i + 1];
+      if (nextNode?.type == "text") {
+        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." });
+      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") {
+      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") {
+      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 list = doc.nodes[i + 1];
+      if (list?.type != "list") {
+        warn();
+        continue;
+      }
+      const rows = [tableRow("\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();
+          continue;
+        }
+        const i2 = item.text.indexOf(":");
+        if (i2 < 0) {
+          warn();
+          continue;
+        }
+        rows.push(tableRow(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") {
+      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 list = doc.nodes[i + 1];
+      if (list?.type != "list") {
+        warn();
+        continue;
+      }
+      const items = [];
+      for (const item of list.items) {
+        if (item.type != "listItem") {
+          warn();
+          continue;
+        }
+        items.push({ type: "text", text: trimEnd(item.text, "."), noIndent: true, noMargin: true });
+      }
+      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 + 2, 0, ...items);
+    } else if (node.type == "title" && 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" });
+          break;
+        }
+      }
+    } else if (node.type == "title" && 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" });
+      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") {
+      node.center = true;
+      node.text = node.text.toUpperCase();
+      doc.nodes.splice(i++, 0, { type: "pageBreak" });
+      const nextNode = doc.nodes[i + 1];
+      if (nextNode?.type == "list") {
+        nextNode.alternativeStyle = true;
+        i++;
+        continue;
+      }
+      const list = {
+        type: "list",
+        mark: ".",
+        startIndex: 1,
+        alternativeStyle: true,
+        ordered: true,
+        items: []
+      };
+      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]+\])/);
+        for (const item of items)
+          list.items.push({ type: "listItem", text: item });
+        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") {
+      node.level = 0;
+      node.center = true;
+      node.text = node.text.toUpperCase();
+      doc.nodes.splice(i++, 0, { type: "pageBreak" });
+      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("]", "].") });
+          j++;
+          node2.level = 1;
+          const splitI = node2.text.indexOf("]");
+          doc.nodes.splice(j++, 0, { type: "pageBreak" });
+          if (splitI >= 0) {
+            doc.nodes.splice(j++ + 1, 0, { type: "text", text: node2.text.slice(splitI + 1), center: true });
+            node2.text = "\u041F\u0420\u0418\u041B\u041E\u0416\u0415\u041D\u0418\u0415 " + node2.text.slice(0, splitI + 1);
+            node2.center = true;
+          }
+        }
+      }
+    } else if (node.type == "list") {
+      let enrichList2 = function(list, isLastItem, isSubList = false) {
+        const isLongList = 3 < Math.max(...list.items.filter((v) => v.type == "listItem").map((v) => v.text.split(/\s+/).length));
+        const hasSublist = list.items.some((v) => v.type == "list");
+        const ending = isLongList || hasSublist || isSubList ? ";" : ",";
+        for (let i2 = 0; i2 < list.items.length; i2++) {
+          const item = list.items[i2];
+          const itemNext = list.items[i2 + 1];
+          const isLast = i2 == list.items.length - 1;
+          if (item.type == "list") enrichList2(item, isLast, true);
+          else {
+            const end = itemNext?.type == "list" ? ":" : isLastItem && isLast ? "." : ending;
+            item.text = trimEnd(item.text, ".", ",", ";", ":", "!") + end;
+          }
+        }
+      };
+      var enrichList = enrichList2;
+      if (doc.list.autopunctuation) enrichList2(node, true);
+    } else if (node.type == "image") {
+      if (node.text)
+        node.text = trimEnd(node.text, ".", ",", ";", ":", "!");
+    } else if (node.type == "table") {
+      if (node.title)
+        node.title = trimEnd(node.title, ".", ",", ";", ":", "!");
+    } else if (node.type == "code") {
+      if (node.title)
+        node.title = trimEnd(node.title, ".", ",", ";", ":", "!");
+    } 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" });
+      }
+      const prevNode = doc.nodes[i - 1];
+      if (prevNode && prevNode?.type != "externalDoc" && prevNode?.type != "pageBreak" && prevNode?.type != "sectionBreak") {
+        doc.nodes.splice(i, 0, { type: "pageBreak" });
+        i++;
+      }
+    }
+  }
+}
+
+// src/main.ts
+import { spawn } from "child_process";
+import fs4 from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { PDFDocument } from "pdf-lib";
+
+// src/alchemist.ts
+var APPENDIX_NAME = "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0418\u041A\u041B\u041C\u041D\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0428\u0429\u042D\u042E\u042F";
+function alchemist(doc, logwarn = console.warn) {
+  const counter = {
+    codesAll: 0,
+    imgsAll: 0,
+    tablesAll: 0,
+    codes: 0,
+    imgs: 0,
+    tables: 0,
+    titles: { l1: 0, l2: 0, l3: 0, l4: 0, l5: 0 }
+  };
+  const named = {};
+  const vals = {};
+  let lastRefI = 0;
+  let prevNum = -1;
+  let prevPrefix = "";
+  let nextNum = -1;
+  let nextPrefix = "";
+  let prefix = "";
+  let synopsis = null;
+  let appendix = false;
+  if (doc.numberingLazy) addLazyNumbering(doc);
+  doc.nodes.forEach((node, i) => {
+    if (nextNum < 0) {
+      let l1 = counter.titles.l1;
+      let codes = counter.codes;
+      let imgs = counter.imgs;
+      let tables = counter.tables;
+      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 == "title" && n.level == 1 && doc.numberingSections) {
+          const num = getTitleNum(n);
+          if (num) l1 = num;
+          else l1++;
+          codes = 0;
+          imgs = 0;
+          tables = 0;
+        }
+      }
+      nextPrefix = l1 > 0 && doc.numberingSections ? `${l1}.` : "";
+    }
+    if (node.tags && node.type == "text" && node.tags.includes("synopsis"))
+      synopsis = node;
+    if (node.type == "title") {
+      for (let i2 = 1; i2 <= 5; i2++) {
+        if (i2 == node.level) counter.titles[`l${i2}`]++;
+        if (i2 > node.level) counter.titles[`l${i2}`] = 0;
+      }
+      if (node.level == 0 && node.text.map((r) => r.text).join("").trim().toUpperCase() == "\u041F\u0420\u0418\u041B\u041E\u0416\u0415\u041D\u0418\u042F") {
+        appendix = true;
+        counter.titles.l1 = 0;
+      }
+      if (node.level == 1) {
+        const num = getTitleNum(node);
+        if (num) counter.titles.l1 = num;
+        if (doc.numberingSections || appendix) {
+          counter.codes = 0;
+          counter.imgs = 0;
+          counter.tables = 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") {
+        counter.codes++;
+        counter.codesAll++;
+      }
+      if (node.type == "image") {
+        counter.imgs++;
+        counter.imgsAll++;
+      }
+      if (node.type == "table" && !node.tags?.includes("definitions_table")) {
+        counter.tables++;
+        counter.tablesAll++;
+      }
+      prevNum = nextNum;
+      prevPrefix = prefix;
+      nextNum = -1;
+    }
+  });
+  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["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 (synopsis) {
+    synopsis.text = [
+      "\u041E\u0442\u0447\u0435\u0442 ",
+      "pages",
+      " \u0441.",
+      counter.imgsAll > 0 && `, ${counter.imgsAll} \u0440\u0438\u0441.`,
+      counter.tablesAll > 0 && `, ${counter.tablesAll} \u0442\u0430\u0431\u043B.`,
+      counter.codesAll > 0 && `, ${counter.codesAll} \u043B\u0438\u0441\u0442.`,
+      sourcesCount > 0 && `, ${sourcesCount} \u0438\u0441\u0442\u043E\u0447\u043D.`,
+      appendix && counter.titles.l1 > 0 && `, ${counter.titles.l1} \u043F\u0440\u0438\u043B.`
+    ].filter((v) => !!v).map((text, i) => ({ text, type: i == 1 ? "val" : "text" }));
+  }
+  function getTitleNum(node) {
+    if (node.text.some((r) => r.type == "ref")) return null;
+    const text = node.text[0]?.text;
+    if (!text) return null;
+    const m = /^\s*(\d+)/.exec(text);
+    const num = parseInt(m?.[1] || "");
+    if (!isFinite(num)) return null;
+    return num;
+  }
+  function materializeNode(node) {
+    if ("text" in node && node.text)
+      materializeRunes(node.text, node);
+    if ("title" in node && node.title)
+      materializeRunes(node.title, node);
+    if (node.type == "list") materializeList(node);
+    if (node.type == "table") materializeTable(node);
+  }
+  function materializeList(node) {
+    node.items.forEach((item) => {
+      if (item.type == "list") materializeList(item);
+      else materializeRunes(item.text, node);
+    });
+  }
+  function materializeTable(node) {
+    node.rows.forEach((row) => row.forEach((item) => {
+      materializeNode(item);
+    }));
+  }
+  function materializeRunes(runes, node) {
+    runes.forEach((rune, i) => {
+      if (rune.type == "val") {
+        if (!(rune.text in vals)) vals[rune.text] = [];
+        vals[rune.text].push((n) => {
+          rune.type = "text";
+          rune.text = `${n}`;
+        });
+        return;
+      }
+      if (rune.type != "ref") return;
+      const type = node.type;
+      const m = /^(.*?)([-\+]\d+)?$/.exec(rune.text.replaceAll(/\s+/g, ""));
+      const tag = m?.[1] || "";
+      const math = m?.[2] || "";
+      const mathSubstarct = math.at(0) == "-";
+      const v = named[tag];
+      const applyMath = (n) => {
+        if (!math) return n;
+        const v2 = parseInt(math.slice(1));
+        if (mathSubstarct) return n - v2;
+        return n + v2;
+      };
+      if (type == "title") {
+        const num = counter.titles[`l${node.level}`];
+        if (appendix) {
+          const char = APPENDIX_NAME[counter.titles.l1 - 1];
+          if (v instanceof Array) v.forEach((fn) => fn.f(-1, char));
+          named[tag] = { n: -1, prefix: char };
+          rune.type = "text";
+          rune.text = char;
+          return;
+        }
+        const prefix2 = node.level <= 1 ? "" : repeat(node.level - 1, (i2) => counter.titles[`l${i2 + 1}`]).join(".") + ".";
+        if (v instanceof Array) v.forEach((fn) => fn.f(num, prefix2));
+        named[tag] = { n: num, prefix: prefix2 };
+        rune.type = "text";
+        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" } : (() => {
+          throw new Error("switch default");
+        })();
+        num++;
+        if (doc.numberingAutoprefix) {
+          const prevRune = runes[i - 1];
+          if (prevRune && prevRune.text.trim().toLowerCase() == text.toLowerCase())
+            prevRune.text = "";
+          const nextRune = runes[i + 1];
+          if (nextRune) {
+            nextRune.text = nextRune.text.trimStart();
+            if (nextRune.text[0] == "-") nextRune.text = nextRune.text.slice(1);
+            if (nextRune.text[0] == "\u2013") nextRune.text = nextRune.text.slice(1);
+            nextRune.text = nextRune.text.trimStart();
+            nextRune.text = toCapitalCase(nextRune.text);
+          }
+          text = `${text} ${prefix}${num} \u2013 `;
+        } 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`);
+        named[tag] = { n: num, prefix };
+        rune.type = "text";
+        rune.text = text;
+        return;
+      }
+      if (tag == "#") {
+        if (nextNum < 0) return;
+        rune.type = "text";
+        if (mathSubstarct)
+          rune.text = `${prevPrefix}${applyMath(prevNum + 1)}`;
+        else
+          rune.text = `${nextPrefix}${applyMath(nextNum)}`;
+        return;
+      }
+      if (!v || v instanceof Array) {
+        const f = (n, prefix2) => {
+          rune.type = "text";
+          rune.text = n < 0 ? prefix2 : `${prefix2}${applyMath(n)}`;
+        };
+        if (v) v.push({ f, i: lastRefI++ });
+        else named[tag] = [{ f, i: lastRefI++ }];
+      } else {
+        rune.type = "text";
+        rune.text = `${v.prefix}${applyMath(v.n)}`;
+      }
+    });
+  }
+  function crystallizeSources() {
+    const sourcesList = doc.nodes.find((node) => node.type == "list" && node.alternativeStyle);
+    if (!sourcesList || sourcesList.type != "list") return 0;
+    const items = sourcesList.items.filter((v) => v.type == "listItem").map((v) => v.text).map((item, i) => {
+      const refI = item[0]?.text ? 0 : 1;
+      const ref = item[refI];
+      if (ref?.type != "ref") {
+        return { text: item, ref: "", i: 99999 + i };
+      }
+      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 };
+      }
+      const firstOccurrenceI = Math.min(...refs.map((v) => v.i));
+      return { text: item.slice(refI + 1), ref: ref.text, i: firstOccurrenceI };
+    });
+    items.sort((a, b) => a.i - b.i);
+    const hasIdAny = items.some((it) => !!it.ref);
+    sourcesList.items = items.map((item, i) => {
+      const key = hasIdAny ? item.ref : i + 1;
+      const refs = named[key];
+      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}`);
+        refs.forEach((r) => hasIdAny ? r.f(i + 1, "") : r.f(-1, `[${i + 1}]`));
+      }
+      return { type: "listItem", text: item.text };
+    });
+    return sourcesList.items.length;
+  }
+}
+function addLazyNumbering(doc) {
+  doc.nodes.forEach((node) => {
+    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;
+    runes.splice(0, 0, { text: "#", type: "ref" });
+  });
+}
+
+// src/main.ts
+import PizZip from "pizzip";
+var DISABLE_MACRO = false;
+async function render({
+  progress = (increment, message) => {
+  },
+  assets,
+  file,
+  output,
+  renderPDF = false,
+  removeIntermediateDocx = false,
+  disableMacros = false,
+  logwarn = console.warn,
+  logPS = (msg) => console.log(`PS: ${msg}`),
+  logPSError = (msg) => console.error(`PS: ${msg}`)
+}) {
+  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...");
+  const fin = path3.resolve(file);
+  const doc = await parseMD(fin, logwarn);
+  progress(10, "\u041A\u043E\u043B\u0434\u0443\u0435\u043C \u043D\u0430\u0434 \u0441\u0438\u043D\u0442\u0430\u043A\u0441\u0438\u0441\u043E\u043C...");
+  enrichDoc(doc, logwarn);
+  const runicDoc = runifyDoc(doc);
+  alchemist(runicDoc, logwarn);
+  const pout = output && path3.parse(path3.resolve(output));
+  if (pout) await fs4.mkdir(pout.dir, { recursive: true });
+  const p = path3.parse(fin);
+  const fdir = p.dir;
+  const fname = trimEnd(p.name, ".g");
+  const ftmp = path3.join(fdir, fname + ".tmp.docx");
+  const fout = pout ? path3.join(pout.dir, pout.name + ".docx") : path3.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))
+    throw new Error(`\u0417\u0430\u043A\u0440\u043E\u0439\u0442\u0435 docx \u0444\u0430\u0439\u043B. Output file is busy or locked: ${fout}`);
+  progress(10, phrase_renderDocx());
+  await serializeDocx(runicDoc, ftmp, fdir, assets);
+  let willRunMacros = !disableMacros && (renderPDF || hasReasonForRunningMacros(runicDoc));
+  let limitedRender = false;
+  if (process.platform != "win32" && willRunMacros) {
+    limitedRender = true;
+    willRunMacros = false;
+  }
+  if (willRunMacros) {
+    progress(20, phrase_runMacros());
+    const tmpfolder = path3.join(pout ? pout.dir : fdir, ".md2gost_out");
+    await fs4.rm(tmpfolder, { recursive: true, force: true });
+    try {
+      const ok = await runDocxMacro(progress, logPS, logPSError, assets, fdir, ftmp, fout, renderPDF);
+      if (!ok) {
+        await fs4.rename(ftmp, fout);
+        return { fout, err: "inPS" };
+      }
+    } catch (x) {
+      await fs4.rename(ftmp, fout);
+      return { fout, err: "noPS", errS: x };
+    }
+    await fs4.unlink(ftmp);
+    const errorTxt = path3.join(tmpfolder, "error.txt");
+    if (existsSync2(errorTxt)) {
+      const err = await fs4.readFile(errorTxt);
+      await fs4.rm(tmpfolder, { recursive: true, force: true });
+      return { fout, err: "vba", errS: `${err}` };
+    }
+    await updateMetadata(fout, doc);
+    if (renderPDF) {
+      progress(10, phrase_combine());
+      if (!existsSync2(tmpfolder))
+        return { fout, err: "pdf" };
+      try {
+        const files = (await fs4.readdir(tmpfolder)).sort().map((f) => path3.join(tmpfolder, f));
+        const pdf = pout ? path3.join(pout.dir, pout.base) : path3.join(fdir, fname + ".pdf");
+        await mergePDFs(files, pdf, doc);
+        await fs4.rm(tmpfolder, { recursive: true, force: true });
+        if (removeIntermediateDocx && existsSync2(fout)) await fs4.unlink(fout);
+        return { fout: pdf };
+      } catch (err) {
+        return { fout, err: "pdf", errS: err };
+      }
+    }
+  } else {
+    await fs4.rename(ftmp, fout);
+  }
+  return { fout, err: limitedRender ? "noWin" : void 0 };
+}
+function hasReasonForRunningMacros(doc) {
+  if (DISABLE_MACRO) return false;
+  return doc.nodes.some((n) => n.type == "code" || n.type == "table");
+}
+function runDocxMacro(progress, log, logError, assets, cwd, fin, fout, renderPDF) {
+  const script = path3.join(assets, "run.ps1");
+  const templateMacro = path3.join(assets, "template.dotm");
+  return new Promise((res, rej) => {
+    const child = spawn("powershell", [
+      "-NoProfile",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      script,
+      "-InputDoc",
+      fin,
+      "-OutputDoc",
+      fout,
+      "-MacroTemplate",
+      templateMacro,
+      ...renderPDF ? ["-RenderPDF"] : []
+    ], { cwd });
+    child.stdout.on("data", (data) => {
+      data = `${data}`;
+      const m = /\[\*(\d)\]/.exec(data);
+      if (m) progress(12, {
+        // "1": "Fixing breaks (listings)",
+        "1": render_fixingBreaks(),
+        // "2": "Fixing breaks (tables)",
+        "2": render_fixingBreaks(),
+        // "3": "Rendering to PDF",
+        "3": render_renderPDF()
+      }[m[1]] || "Make some work");
+      log(data);
+    });
+    let ok = true;
+    child.stderr.on("data", (data) => {
+      ok = false;
+      logError(`${data}`);
+    });
+    child.on("close", () => res(ok));
+    child.on("error", rej);
+  });
+}
+async function mergePDFs(files, fout, doc) {
+  const mergedPdf = await PDFDocument.create();
+  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) {
+    const bytes = await fs4.readFile(file);
+    const pdf = await PDFDocument.load(bytes);
+    const pages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+    pages.forEach((page) => mergedPdf.addPage(page));
+  }
+  const pdfBytes = await mergedPdf.save();
+  await fs4.writeFile(fout, pdfBytes);
+}
+async function updateMetadata(docfile, doc) {
+  const content = await fs4.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}`
+    );
+  }
+  let coreXml = zip.file("docProps/core.xml").asText();
+  coreXml = replaceTag(coreXml, "dc:title", doc.title || "Document");
+  if (doc.ctime) coreXml = replaceTag(coreXml, "dcterms:created", doc.ctime.toISOString());
+  if (doc.mtime) coreXml = replaceTag(coreXml, "dcterms:modified", doc.mtime.toISOString());
+  coreXml = replaceTag(coreXml, "dc:creator", doc.author || "Student");
+  coreXml = replaceTag(coreXml, "cp:lastModifiedBy", doc.author || "Student");
+  zip.file("docProps/core.xml", coreXml);
+  let appXml = zip.file("docProps/app.xml").asText();
+  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) {
+    return unsafe.replaceAll(/[<>&"']/g, (ch) => {
+      switch (ch) {
+        case "<":
+          return "&lt;";
+        case ">":
+          return "&gt;";
+        case "&":
+          return "&amp;";
+        case '"':
+          return "&quot;";
+        case "'":
+          return "&apos;";
+        default:
+          return ch;
+      }
+    });
+  }
+}
+var phrase_renderDocx = () => choice(
+  "\u041C\u0430\u0442\u0435\u0440\u0438\u0430\u043B\u0438\u0437\u0443\u0435\u043C \u0431\u0443\u043C\u0430\u0436\u043D\u044B\u0439 \u0430\u0440\u0442\u0435\u0444\u0430\u043A\u0442...",
+  "\u041A\u0443\u0435\u043C DOCX \u0432 \u0442\u0435\u043A\u0441\u0442\u043E\u0432\u043E\u0439 \u043A\u0443\u0437\u043D\u0438\u0446\u0435...",
+  "\u041F\u043B\u0435\u0442\u0435\u043C \u043F\u043E\u043B\u043E\u0442\u043D\u043E \u0434\u043E\u043A\u0443\u043C\u0435\u043D\u0442\u0430...",
+  "\u0422\u0440\u0430\u043D\u0441\u043C\u0443\u0442\u0438\u0440\u0443\u0435\u043C \u043F\u0440\u043E\u0441\u0442\u044B\u0435 \u0441\u0438\u043C\u0432\u043E\u043B\u044B \u0432 \u0432\u0435\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u0435\u043D\u043D\u044B\u0435 \u0441\u0442\u0440\u0430\u043D\u0438\u0446\u044B...",
+  "\u0412\u044B\u043A\u043E\u0432\u044B\u0432\u0430\u0435\u043C \u0441\u0442\u0440\u0430\u043D\u0438\u0446\u044B \u0438\u0437 \u0440\u0443\u0434\u044B \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432...",
+  "\u041E\u0442\u043B\u0438\u0432\u0430\u0435\u043C \u0444\u043E\u0440\u043C\u0443 \u0431\u0443\u0434\u0443\u0449\u0438\u0445 \u0441\u0442\u0440\u0430\u043D\u0438\u0446...",
+  "\u0417\u0430\u043A\u043B\u0430\u0434\u044B\u0432\u0430\u0435\u043C \u0444\u0443\u043D\u0434\u0430\u043C\u0435\u043D\u0442 \u0432\u0435\u043B\u0438\u043A\u043E\u0433\u043E \u0442\u0440\u0430\u043A\u0442\u0430\u0442\u0430...",
+  "\u041F\u0435\u0440\u0435\u043F\u043B\u0430\u0432\u043B\u044F\u0435\u043C \u043C\u044B\u0441\u043B\u0438 \u0432 \u0441\u0442\u0440\u043E\u0439\u043D\u044B\u0435 \u0430\u0431\u0437\u0430\u0446\u044B...",
+  "\u0421\u043B\u0430\u0433\u0430\u0435\u043C \u0441\u0442\u0440\u0430\u043D\u0438\u0446\u044B \u0432 \u0433\u0430\u0440\u043C\u043E\u043D\u0438\u044E \u0441\u0442\u0440\u0443\u043A\u0442\u0443\u0440\u044B..."
+);
+var phrase_runMacros = () => choice(
+  "\u041F\u0440\u043E\u0431\u0443\u0436\u0434\u0430\u0435\u043C \u0434\u0440\u0435\u0432\u043D\u0438\u0445 \u0434\u0443\u0445\u043E\u0432 VBA...",
+  "\u041F\u0440\u0438\u0437\u044B\u0432\u0430\u0435\u043C \u0434\u0443\u0445 \u0412\u043E\u0440\u0434\u0430 \u0438\u0437 \u0431\u0435\u0437\u0434\u043D\u044B \u043E\u0444\u0438\u0441\u043D\u043E\u0433\u043E \u043F\u0430\u043A\u0435\u0442\u0430...",
+  "\u0412\u0434\u044B\u0445\u0430\u0435\u043C \u043C\u0430\u043D\u0443 \u0432 \u0441\u043F\u044F\u0449\u0438\u0435 \u0440\u0443\u043D\u044B \u0430\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0437\u0430\u0446\u0438\u0438...",
+  "\u041E\u0442\u043F\u0438\u0440\u0430\u0435\u043C \u0442\u0430\u0439\u043D\u044B\u0435 \u0444\u0443\u043D\u043A\u0446\u0438\u0438 \u043E\u0444\u0438\u0441\u043D\u043E\u0439 \u043C\u0430\u0433\u0438\u0438..."
+);
+var render_fixingBreaks = () => choice(
+  '\u041F\u043E\u0434\u043A\u043B\u0435\u0438\u0432\u0430\u0435\u043C "\u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0435\u043D\u0438\u0435 \u043B\u0438\u0441\u0442\u0438\u043D\u0433\u0430" \u043D\u0430 \u0440\u0430\u0437\u043E\u0440\u0432\u0430\u043D\u043D\u044B\u0435 \u0441\u0442\u0440\u0430\u043D\u0438\u0446\u044B...',
+  '\u041F\u043E\u0434\u043A\u043B\u0435\u0438\u0432\u0430\u0435\u043C "\u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0435\u043D\u0438\u0435 \u0442\u0430\u0431\u043B\u0438\u0446\u044B" \u043D\u0430 \u0440\u0430\u0437\u043E\u0440\u0432\u0430\u043D\u043D\u044B\u0435 \u0441\u0442\u0440\u0430\u043D\u0438\u0446\u044B...',
+  "\u0423\u043A\u0440\u0435\u043F\u043B\u044F\u0435\u043C \u0441\u0442\u0435\u043D\u044B \u0441\u0435\u043A\u0446\u0438\u0439 \u0441\u0432\u044F\u0437\u0443\u044E\u0449\u0438\u043C\u0438 \u0441\u043B\u043E\u0432\u0430\u043C\u0438...",
+  "\u041D\u0430\u043D\u043E\u0441\u0438\u043C \u0440\u0443\u043D\u044B \u043F\u0440\u0435\u0435\u043C\u0441\u0442\u0432\u0435\u043D\u043D\u043E\u0441\u0442\u0438 \u043D\u0430 \u0440\u0430\u0437\u0440\u044B\u0432\u044B \u0441\u0442\u0440\u0430\u043D\u0438\u0446...",
+  "\u0427\u0438\u043D\u0438\u043C \u0431\u0430\u0433 \u0440\u0430\u0437\u0440\u044B\u0432\u0430 \u043F\u043E\u0432\u0435\u0441\u0442\u0432\u043E\u0432\u0430\u043D\u0438\u044F...",
+  "\u0421\u043E\u0435\u0434\u0438\u043D\u044F\u0435\u043C \u043E\u0441\u043A\u043E\u043B\u043A\u0438 \u043B\u0438\u0441\u0442\u0438\u043D\u0433\u0430 \u0432 \u0435\u0434\u0438\u043D\u043E\u0435 \u043F\u043E\u043B\u043E\u0442\u043D\u043E...",
+  "\u041D\u0430\u043A\u043B\u0430\u0434\u044B\u0432\u0430\u0435\u043C \u0447\u0430\u0440\u044B \u043D\u0435\u043F\u0440\u0435\u0440\u044B\u0432\u043D\u043E\u0441\u0442\u0438 \u043D\u0430 \u0442\u0435\u043A\u0441\u0442..."
+);
+var render_renderPDF = () => choice(
+  "\u0421\u043E\u0431\u0438\u0440\u0430\u0435\u043C \u0434\u043E\u043A\u0443\u043C\u0435\u043D\u0442\u044B \u0438 \u043F\u0440\u0435\u0432\u0440\u0430\u0449\u0430\u0435\u043C \u0438\u0445 \u0432 PDF-\u0441\u0432\u0438\u0442\u043A\u0438...",
+  "\u041E\u0431\u0440\u0430\u0449\u0430\u0435\u043C \u0436\u0438\u0432\u043E\u0435 \u0441\u043B\u043E\u0432\u043E \u0432 \u043D\u0435\u0437\u044B\u0431\u043B\u0435\u043C\u044B\u0439 \u043A\u0430\u043C\u0435\u043D\u044C PDF...",
+  "\u041D\u0430\u0432\u0435\u043A\u0438 \u0437\u0430\u043F\u0435\u0447\u0430\u0442\u043B\u0435\u0432\u0430\u0435\u043C \u0441\u0432\u0438\u0442\u043A\u0438 \u0432 \u043A\u0440\u0438\u0441\u0442\u0430\u043B\u043B\u0430\u0445 \u043F\u0430\u043C\u044F\u0442\u0438...",
+  "\u0417\u0430\u043F\u0435\u0447\u0430\u0442\u044B\u0432\u0430\u0435\u043C \u0442\u0435\u043A\u0441\u0442 \u0432 \u044F\u043D\u0442\u0430\u0440\u0435 \u0444\u043E\u0440\u043C\u0430\u0442\u0430 PDF..."
+);
+var phrase_combine = () => choice(
+  "\u0421\u043A\u043B\u0435\u0438\u0432\u0430\u0435\u043C \u0432\u0441\u0451 \u0441\u0438\u043D\u0435\u0439 \u0438\u0437\u043E\u043B\u0435\u043D\u0442\u043E\u0439...",
+  "\u0421\u043A\u0440\u0435\u043F\u043B\u044F\u0435\u043C \u043F\u0435\u0447\u0430\u0442\u044F\u043C\u0438 \u0441\u0443\u0434\u044C\u0431\u044B \u043F\u043E\u0441\u043B\u0435\u0434\u043D\u044E\u044E \u0441\u0442\u0440\u0430\u043D\u0438\u0446\u0443...",
+  "\u0421\u043F\u043B\u0430\u0432\u043B\u044F\u0435\u043C \u0444\u0438\u043D\u0430\u043B\u044C\u043D\u044B\u0439 \u0430\u0440\u0442\u0435\u0444\u0430\u043A\u0442 \u0438\u0437 \u043C\u043D\u043E\u0436\u0435\u0441\u0442\u0432\u0430 \u043E\u0441\u043A\u043E\u043B\u043A\u043E\u0432..."
+);
+
+// src/index.ts
+import assert from "assert";
+async function renderMarkdown(config) {
+  assert(config && typeof config == "object", "Config object is required");
+  assert(typeof config.input == "string", "Input file path must be a string.");
+  assert(typeof config.output == "string" || typeof config.output == "undefined", "Output path must be a string or undefined.");
+  assert(config.format == "docx" || config.format == "pdf" || typeof config.format == "undefined", "Format must be either 'docx' or 'pdf', or undefined.");
+  assert(typeof config.keepIntermediateDocx == "boolean" || typeof config.keepIntermediateDocx == "undefined", "keepIntermediateDocx must be a boolean or undefined.");
+  assert(typeof config.disableMacros == "boolean" || typeof config.disableMacros == "undefined", "disableMacros must be a boolean or undefined.");
+  assert(typeof config.progress == "function" || typeof config.progress == "undefined", "Progress callback must be a function or undefined.");
+  {
+    const extraProps = getExtraProperties(
+      config,
+      ["input", "output", "format", "keepIntermediateDocx", "disableMacros", "progress"]
+    );
+    assert(extraProps.length == 0, `Found unknown properties in config: ${extraProps.join(", ")}`);
+  }
+  const renderPDF = config.format === "pdf" || !config.format && !!config.output?.endsWith(".pdf");
+  const removeIntermediateDocx = !config.keepIntermediateDocx;
+  const disableMacros = !!config.disableMacros;
+  const warnings = [];
+  const logPS = [];
+  let totalPercent = 0;
+  const handleProgress = config.progress ? (increment, message) => {
+    totalPercent = Math.min(totalPercent + increment, 99);
+    config.progress(totalPercent, message);
+  } : void 0;
+  try {
+    let throwMDE2 = function(code, msg) {
+      throw new MDRenderError(code, msg, fout, warnings, logPS, errS ? { cause: errS } : void 0);
+    };
+    var throwMDE = throwMDE2;
+    const { fout, err, errS } = await render({
+      progress: handleProgress,
+      assets: getAssetsDir(),
+      file: config.input,
+      output: config.output,
+      renderPDF,
+      removeIntermediateDocx,
+      disableMacros,
+      logwarn: (msg) => warnings.push(msg),
+      logPS: (msg) => logPS.push(msg),
+      logPSError: (msg) => logPS.push(msg)
+    });
+    config.progress?.(100, "Done!");
+    ;
+    if (err == "noPS") throwMDE2("noPS", `Failed to initialize PowerShell. Ensure PowerShell is installed and explicitly added to your system's PATH environment variable.`);
+    if (err == "inPS") throwMDE2("inPS", `An unexpected error occurred executing commands inside PowerShell. Verify that Microsoft Word is properly installed and licensed.`);
+    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.`);
+    let intermediateDocxPath;
+    if (renderPDF) {
+      const pin = path4.parse(path4.resolve(config.input));
+      const fname = pin.name.endsWith(".g") ? pin.name.slice(0, -2) : pin.name;
+      const pout = config.output ? path4.parse(path4.resolve(config.output)) : void 0;
+      intermediateDocxPath = pout ? path4.join(pout.dir, pout.name + ".docx") : path4.join(pin.dir, fname + ".docx");
+    }
+    return {
+      filePath: fout,
+      ...intermediateDocxPath && { intermediateDocxPath },
+      warnings
+    };
+  } catch (x) {
+    if (x instanceof MDRenderError) throw x;
+    const message = x instanceof Error ? x.message : String(x);
+    throw new MDRenderError("unknown", `An unhandled internal error occurred during rendering: ${message}`, null, warnings, logPS, { cause: x });
+  }
+}
+var MDRenderError = class _MDRenderError extends Error {
+  /**
+   * File path of the partially rendered `.docx` file, if available when the error occurred.
+   */
+  renderedFile;
+  /**
+   * Code indicating the underlying cause of the failure:
+   * - `unknown`: An unhandled or unexpected internal runtime error.
+   * - `noPS`: PowerShell could not be started or found in the system PATH.
+   * - `inPS`: A failure occurred inside PowerShell; MS Word may be missing or corrupt.
+   * - `vba`: An error occurred during the execution of internal Word VBA macros.
+   * - `pdf`: A failure occurred specifically during the PDF export phase.
+   * - `noWin`: The operation requires Windows capabilities that are unavailable on the host OS.
+   */
+  code;
+  /**
+   * Non-fatal warnings captured during the process *before* the fatal error was thrown.
+   */
+  warnings;
+  /**
+   * Standard output and error streams aggregated from the underlying PowerShell shell session.
+   */
+  powershellLog;
+  /**
+   * @param code - Machine-readable error code.
+   * @param message - Human-readable error details.
+   * @param renderedFile - Path to a partial output file, if any.
+   * @param warnings - List of non-fatal warnings gathered prior to the exception.
+   * @param powershellLog - List of shell execution strings collected during execution.
+   * @param options - Standard native error options (e.g., to preserve the error `cause`).
+   */
+  constructor(code, message, renderedFile, warnings = [], powershellLog, options) {
+    super(message, options);
+    this.name = "MDRenderError";
+    this.code = code;
+    this.renderedFile = renderedFile;
+    this.warnings = warnings;
+    this.powershellLog = powershellLog;
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(this, _MDRenderError);
+  }
+};
+function getAssetsDir() {
+  if (typeof __dirname !== "undefined")
+    return path4.resolve(__dirname, "../assets");
+  const metaUrl = new Function("return import.meta.url")();
+  return path4.resolve(path4.dirname(fileURLToPath(metaUrl)), "../assets");
+}
+function getExtraProperties(configObj, allowedConfigKeys) {
+  return Object.keys(configObj).filter(
+    (key) => !allowedConfigKeys.includes(key)
+  );
+}
+export {
+  MDRenderError,
+  renderMarkdown as default
+};
+//# sourceMappingURL=index.mjs.map