@bendyline/squisq-formats 2.4.6 → 2.5.1

package/NOTICE.md

@@ -10,7 +10,7 @@ Third-party components remain under their respective license terms.
 | ---------------- | ------- | ----------------------- | ---------------------------------- |
 | @pdf-lib/fontkit | 1.1.1   | MIT                     | https://github.com/Hopding/fontkit |
 | @pdf-lib/upng    | 1.0.1   | MIT                     | https://github.com/Hopding/upng    |
-| @xmldom/xmldom   | 0.9.11  | MIT                     | https://github.com/xmldom/xmldom   |
+| @xmldom/xmldom   | 0.9.12  | MIT                     | https://github.com/xmldom/xmldom   |
 | jszip            | 3.10.1  | MIT OR GPL-3.0-or-later | https://github.com/Stuk/jszip      |
 | pdf-lib          | 1.17.1  | MIT                     | https://pdf-lib.js.org             |
 | pdfjs-dist       | 4.10.38 | Apache-2.0              | https://mozilla.github.io/pdf.js   |

package/dist/{chunk-KN62QJYK.js → chunk-2LT3JL7U.js}

@@ -1,6 +1,6 @@
 import {
   extractPlainText
-} from "./chunk-6X5XN3CZ.js";
+} from "./chunk-AVOZAKGP.js";
 import {
   escapeXml
 } from "./chunk-JU2RHXUB.js";
@@ -13,6 +13,10 @@ import {
   extractFilename,
   inferMimeType
 } from "./chunk-6RQOV3B3.js";
+import {
+  FootnoteIndex,
+  footnoteIds
+} from "./chunk-BXWNU4T5.js";
 
 // src/epub/export.ts
 import JSZip from "jszip";
@@ -31,6 +35,10 @@ async function markdownDocToEpub(doc, options = {}) {
   const uuid = createEpubUuid();
   const embeddedIconFonts = fontAwesomeFaces(collectInlineIconFamilies(doc));
   const chapters = splitIntoChapters(doc.children);
+  const footnoteIndex = new FootnoteIndex(doc);
+  const citedAnywhere = /* @__PURE__ */ new Set();
+  collectCitedIdentifiers(doc.children, citedAnywhere);
+  const uncitedFootnotes = footnoteIndex.ordered().filter((fn) => fn.definition && !citedAnywhere.has(fn.identifier)).map((fn) => fn.identifier);
   const imageEntries = collectDocImages(doc.children);
   const resolvedImages = /* @__PURE__ */ new Map();
   const usedImageNames = /* @__PURE__ */ new Set();
@@ -148,11 +156,14 @@ async function markdownDocToEpub(doc, options = {}) {
     const id = `chapter-${num}`;
     const filename = `${id}.xhtml`;
     const audioInfo = chapterAudio[i] ?? null;
+    const isLastChapter = i === chapters.length - 1;
     const { xhtml, ids } = renderChapterXhtml(
       chap.nodes,
       title,
       resolvedImages,
-      audioInfo !== null
+      audioInfo !== null,
+      footnoteIndex,
+      isLastChapter ? uncitedFootnotes : []
     );
     zip.file(`OEBPS/chapters/${filename}`, xhtml);
     let smilFilename;
@@ -267,14 +278,43 @@ function collectDocImages(nodes) {
   nodes.forEach(walkBlock);
   return images;
 }
-function renderChapterXhtml(nodes, bookTitle, images, addIds = false) {
+function collectCitedIdentifiers(nodes, into) {
+  for (const raw of nodes) {
+    const node = raw;
+    if (node?.type === "footnoteReference" && node.identifier) into.add(node.identifier);
+    if (Array.isArray(node?.children)) collectCitedIdentifiers(node.children, into);
+  }
+}
+function renderFootnotesXhtml(identifiers, ctx) {
+  const index = ctx.footnotes;
+  if (!index || identifiers.length === 0) return "";
+  const seen = /* @__PURE__ */ new Set();
+  const notes = index.ordered().filter(
+    (fn) => identifiers.includes(fn.identifier) && !seen.has(fn.identifier) && seen.add(fn.identifier)
+  );
+  if (notes.length === 0) return "";
+  const items = notes.map((fn) => {
+    const { def } = footnoteIds(fn.identifier);
+    const body = fn.definition ? fn.definition.children.map((c) => blockToXhtml(c, ctx)).join("") : "";
+    return `<li id="${escapeXml(def)}" epub:type="footnote"><span class="squisq-footnote-num">${fn.number}.</span> ${body}</li>`;
+  });
+  return `
+<aside class="squisq-footnotes" epub:type="footnotes"><hr/>
+<ol>
+` + items.join("\n") + `
+</ol>
+</aside>`;
+}
+function renderChapterXhtml(nodes, bookTitle, images, addIds = false, footnotes, trailingFootnotes = []) {
   const ids = [];
   const nextId = () => {
     const id = `p${ids.length + 1}`;
     ids.push(id);
     return id;
   };
-  const body = nodes.map((n) => blockToXhtml(n, images, addIds ? nextId : void 0)).join("\n");
+  const ctx = { images, footnotes, cited: /* @__PURE__ */ new Set() };
+  const rendered = nodes.map((n) => blockToXhtml(n, ctx, addIds ? nextId : void 0)).join("\n");
+  const body = rendered + renderFootnotesXhtml([...ctx.cited ?? [], ...trailingFootnotes], ctx);
   const xhtml = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE html>
 <html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops">
@@ -289,7 +329,7 @@ ${body}
 </html>`;
   return { xhtml, ids };
 }
-function blockToXhtml(node, images, nextId) {
+function blockToXhtml(node, ctx, nextId) {
   let cached;
   const idAttr = () => {
     if (!nextId) return "";
@@ -299,18 +339,18 @@ function blockToXhtml(node, images, nextId) {
   switch (node.type) {
     case "heading": {
       const tag = `h${node.depth}`;
-      return `<${tag}${idAttr()}>${inlinesToXhtml(node.children, images)}</${tag}>`;
+      return `<${tag}${idAttr()}>${inlinesToXhtml(node.children, ctx)}</${tag}>`;
     }
     case "paragraph":
-      return `<p${idAttr()}>${inlinesToXhtml(node.children, images)}</p>`;
+      return `<p${idAttr()}>${inlinesToXhtml(node.children, ctx)}</p>`;
     case "blockquote":
       return `<blockquote${idAttr()}>
-${node.children.map((c) => blockToXhtml(c, images, nextId)).join("\n")}
+${node.children.map((c) => blockToXhtml(c, ctx, nextId)).join("\n")}
 </blockquote>`;
     case "list": {
       const tag = node.ordered ? "ol" : "ul";
       const startAttr = node.ordered && node.start && node.start !== 1 ? ` start="${node.start}"` : "";
-      const items = node.children.map((item) => listItemToXhtml(item, images)).join("\n");
+      const items = node.children.map((item) => listItemToXhtml(item, ctx)).join("\n");
       return `<${tag}${idAttr()}${startAttr}>
 ${items}
 </${tag}>`;
@@ -322,7 +362,7 @@ ${items}
     case "thematicBreak":
       return `<hr${idAttr()}/>`;
     case "table":
-      return tableToXhtml(node, images, idAttr());
+      return tableToXhtml(node, ctx, idAttr());
     case "htmlBlock":
       return `<p${idAttr()}>${escapeXml(node.rawHtml.replace(/<[^>]+>/g, ""))}</p>`;
     case "math":
@@ -331,12 +371,12 @@ ${items}
       return "";
   }
 }
-function listItemToXhtml(item, images) {
-  const content = item.children.map((c) => blockToXhtml(c, images)).join("\n");
-  const unwrapped = item.children.length === 1 && item.children[0].type === "paragraph" ? inlinesToXhtml(item.children[0].children, images) : content;
+function listItemToXhtml(item, ctx) {
+  const content = item.children.map((c) => blockToXhtml(c, ctx)).join("\n");
+  const unwrapped = item.children.length === 1 && item.children[0].type === "paragraph" ? inlinesToXhtml(item.children[0].children, ctx) : content;
   return `<li>${unwrapped}</li>`;
 }
-function tableToXhtml(table, images, idAttr = "") {
+function tableToXhtml(table, ctx, idAttr = "") {
   const rows = table.children;
   if (rows.length === 0) return `<table${idAttr}></table>`;
   const headerRow = rows[0];
@@ -345,36 +385,47 @@ function tableToXhtml(table, images, idAttr = "") {
   function cellToXhtml(cell, tag, colIndex) {
     const a = align[colIndex];
     const style = a ? ` style="text-align: ${a}"` : "";
-    return `<${tag}${style}>${inlinesToXhtml(cell.children, images)}</${tag}>`;
+    return `<${tag}${style}>${inlinesToXhtml(cell.children, ctx)}</${tag}>`;
   }
   const thead = `<thead><tr>${headerRow.children.map((c, i) => cellToXhtml(c, "th", i)).join("")}</tr></thead>`;
   const tbody = bodyRows.length > 0 ? `<tbody>${bodyRows.map((row) => `<tr>${row.children.map((c, i) => cellToXhtml(c, "td", i)).join("")}</tr>`).join("")}</tbody>` : "";
   return `<table${idAttr}>${thead}${tbody}</table>`;
 }
-function inlinesToXhtml(nodes, images) {
-  return nodes.map((n) => inlineToXhtml(n, images)).join("");
+function inlinesToXhtml(nodes, ctx) {
+  return nodes.map((n) => inlineToXhtml(n, ctx)).join("");
 }
-function inlineToXhtml(node, images) {
+function inlineToXhtml(node, ctx) {
   switch (node.type) {
     case "text":
       return escapeXml(node.value);
     case "strong":
-      return `<strong>${inlinesToXhtml(node.children, images)}</strong>`;
+      return `<strong>${inlinesToXhtml(node.children, ctx)}</strong>`;
     case "emphasis":
-      return `<em>${inlinesToXhtml(node.children, images)}</em>`;
+      return `<em>${inlinesToXhtml(node.children, ctx)}</em>`;
     case "delete":
-      return `<del>${inlinesToXhtml(node.children, images)}</del>`;
+      return `<del>${inlinesToXhtml(node.children, ctx)}</del>`;
+    case "superscript":
+      return `<sup>${inlinesToXhtml(node.children, ctx)}</sup>`;
+    case "footnoteReference": {
+      if (!ctx.footnotes) return "";
+      const { number, occurrence } = ctx.footnotes.cite(node.identifier);
+      const { ref, def } = footnoteIds(node.identifier, occurrence);
+      ctx.cited?.add(node.identifier);
+      return `<sup class="squisq-footnote-ref" epub:type="noteref"><a href="#${escapeXml(def)}" id="${escapeXml(ref)}">${number}</a></sup>`;
+    }
+    case "subscript":
+      return `<sub>${inlinesToXhtml(node.children, ctx)}</sub>`;
     case "inlineCode":
       return `<code>${escapeXml(node.value)}</code>`;
     case "link": {
       const href = sanitizeUrl(node.url, "link");
-      if (!href) return inlinesToXhtml(node.children, images);
+      if (!href) return inlinesToXhtml(node.children, ctx);
       const titleAttr = node.title ? ` title="${escapeXml(node.title)}"` : "";
-      return `<a href="${escapeXml(href)}"${titleAttr}>${inlinesToXhtml(node.children, images)}</a>`;
+      return `<a href="${escapeXml(href)}"${titleAttr}>${inlinesToXhtml(node.children, ctx)}</a>`;
     }
     case "image": {
       const alt = escapeXml(node.alt ?? "");
-      const resolved = images.get(node.url);
+      const resolved = ctx.images.get(node.url);
       const safeSrc = resolved ? `../images/${resolved.filename}` : sanitizeUrl(node.url, "media");
       if (!safeSrc) return alt;
       const src = escapeXml(safeSrc);

package/dist/{chunk-DNGNODJP.js → chunk-5JQ5NDRC.js}

@@ -105,6 +105,8 @@ var CONTENT_NODE_TYPES = {
   emphasis: true,
   strong: true,
   delete: true,
+  superscript: true,
+  subscript: true,
   inlineCode: true,
   link: true,
   image: true,
@@ -132,6 +134,8 @@ var COMMON_SUPPORTED = [
   "emphasis",
   "strong",
   "delete",
+  "superscript",
+  "subscript",
   "inlineCode",
   "link",
   "image",
@@ -407,7 +411,10 @@ function defaultFormats() {
   };
   const xlsx = {
     id: "xlsx",
-    templateAnnotationHandling: "ignored",
+    // Not 'ignored': a `{[dataTable sheet=… anchor=…]}` annotation decides which
+    // worksheet a table lands on and at which cell, so annotations demonstrably
+    // affect the exported result.
+    templateAnnotationHandling: "preserved",
     label: "Excel (XLSX)",
     mimeType: MIME.xlsx,
     extensions: [".xlsx"],
@@ -424,7 +431,10 @@ function defaultFormats() {
       const warnings = omitted > 0 ? [`XLSX export is tables-only; ${omitted} non-table block(s) were omitted.`] : [];
       const blob = await markdownDocToXlsx(markdownDoc, {
         ...optionsFor(options, "xlsx"),
-        ...options.title !== void 0 ? { title: options.title } : {}
+        ...options.title !== void 0 ? { title: options.title } : {},
+        // Placement problems (a bad anchor, overlapping regions) degrade rather
+        // than throw, so they have to reach the caller as conversion warnings.
+        onWarning: (message) => warnings.push(message)
       });
       return ok(await toBytes(blob), MIME.xlsx, warnings);
     }

package/dist/{chunk-DWNNYO5H.js → chunk-A6N6IN3I.js}

@@ -1,6 +1,6 @@
 import {
   stripHtmlTags
-} from "./chunk-6X5XN3CZ.js";
+} from "./chunk-AVOZAKGP.js";
 
 // src/ooxml/relIds.ts
 var RelIdAllocator = class {
@@ -92,6 +92,10 @@ function inlineNodeToRuns(node, handlers, format) {
       return inlineNodesToRuns(node.children, handlers, { ...format, italic: true });
     case "delete":
       return inlineNodesToRuns(node.children, handlers, { ...format, strike: true });
+    case "superscript":
+      return inlineNodesToRuns(node.children, handlers, { ...format, vertAlign: "superscript" });
+    case "subscript":
+      return inlineNodesToRuns(node.children, handlers, { ...format, vertAlign: "subscript" });
     case "inlineCode":
       return handlers.run(node.value, { ...format, code: true });
     case "inlineMath":

package/dist/{chunk-6X5XN3CZ.js → chunk-AVOZAKGP.js}

@@ -11,6 +11,8 @@ function inlineToPlainText(node) {
     case "emphasis":
     case "strong":
     case "delete":
+    case "superscript":
+    case "subscript":
     case "link":
       return extractPlainText(node.children);
     case "image":
@@ -29,5 +31,6 @@ function extractPlainText(nodes) {
 
 export {
   stripHtmlTags,
+  inlineToPlainText,
   extractPlainText
 };

package/dist/chunk-BXWNU4T5.js

@@ -0,0 +1,108 @@
+// src/shared/footnotes.ts
+var FootnoteIndex = class {
+  constructor(doc) {
+    this.numbers = /* @__PURE__ */ new Map();
+    this.definitions = /* @__PURE__ */ new Map();
+    /** Citations rendered so far, per identifier — see {@link cite}. */
+    this.citations = /* @__PURE__ */ new Map();
+    collectReferences(doc.children, (id) => {
+      if (!this.numbers.has(id)) this.numbers.set(id, this.numbers.size + 1);
+    });
+    collectDefinitions(doc.children, (def) => {
+      this.definitions.set(def.identifier, def);
+      if (!this.numbers.has(def.identifier))
+        this.numbers.set(def.identifier, this.numbers.size + 1);
+    });
+  }
+  /** Whether the document has any footnotes at all. */
+  get isEmpty() {
+    return this.numbers.size === 0;
+  }
+  /** The reader-facing number for an identifier (assigning one if unseen). */
+  numberFor(identifier) {
+    const existing = this.numbers.get(identifier);
+    if (existing !== void 0) return existing;
+    const next = this.numbers.size + 1;
+    this.numbers.set(identifier, next);
+    return next;
+  }
+  /**
+   * Record one citation and return how to anchor it.
+   *
+   * Prose may cite the same footnote repeatedly. Every citation needs its own
+   * element id — reusing one id would emit duplicate ids, which is invalid HTML
+   * and leaves the backlink pointing at whichever copy the browser found first.
+   * Call this exactly once per rendered reference, in document order.
+   */
+  cite(identifier) {
+    const number = this.numberFor(identifier);
+    const occurrence = (this.citations.get(identifier) ?? 0) + 1;
+    this.citations.set(identifier, occurrence);
+    return { number, occurrence };
+  }
+  /** Every footnote in reading order. */
+  ordered() {
+    return [...this.numbers.entries()].map(([identifier, number]) => ({
+      identifier,
+      number,
+      definition: this.definitions.get(identifier),
+      citations: this.citations.get(identifier) ?? 0
+    })).sort((a, b) => a.number - b.number);
+  }
+};
+function isFootnoteDefinition(node) {
+  return node.type === "footnoteDefinition";
+}
+function childrenOf(node) {
+  return "children" in node && Array.isArray(node.children) ? node.children : [];
+}
+function collectReferences(nodes, visit) {
+  for (const node of nodes) {
+    if (node.type === "footnoteDefinition") continue;
+    if (node.type === "footnoteReference") {
+      visit(node.identifier);
+      continue;
+    }
+    collectReferences(childrenOf(node), visit);
+  }
+}
+function collectDefinitions(nodes, visit) {
+  for (const node of nodes) {
+    if (isFootnoteDefinition(node)) {
+      visit(node);
+      continue;
+    }
+    collectDefinitions(childrenOf(node), visit);
+  }
+}
+function footnoteIds(identifier, occurrence = 1) {
+  const safe = identifier.replace(/[^A-Za-z0-9_-]/g, "-");
+  const suffix = occurrence > 1 ? `-${occurrence}` : "";
+  return { ref: `fnref-${safe}${suffix}`, def: `fn-${safe}` };
+}
+function renumberFootnotes(doc) {
+  const index = new FootnoteIndex(doc);
+  if (index.isEmpty) return;
+  const renamed = /* @__PURE__ */ new Map();
+  for (const fn of index.ordered()) renamed.set(fn.identifier, String(fn.number));
+  if ([...renamed].every(([from, to]) => from === to)) return;
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.type === "footnoteReference" || node.type === "footnoteDefinition") {
+        const next = renamed.get(node.identifier);
+        if (next !== void 0) {
+          node.identifier = next;
+          if ("label" in node && node.label !== void 0) node.label = next;
+        }
+      }
+      if ("children" in node && Array.isArray(node.children)) walk(node.children);
+    }
+  };
+  walk(doc.children);
+}
+
+export {
+  FootnoteIndex,
+  footnoteIds,
+  renumberFootnotes
+};

package/dist/{chunk-BGDN7BXK.js → chunk-FIOSE4BO.js}

@@ -4,10 +4,10 @@ import {
   inlineNodesToRuns,
   normalizeOoxmlHex,
   sanitizeOfficeHyperlink
-} from "./chunk-DWNNYO5H.js";
+} from "./chunk-A6N6IN3I.js";
 import {
   stripHtmlTags
-} from "./chunk-6X5XN3CZ.js";
+} from "./chunk-AVOZAKGP.js";
 import {
   createPackage
 } from "./chunk-ILCJ3WFD.js";
@@ -59,6 +59,9 @@ import {
 import {
   extToMime
 } from "./chunk-AONELFLA.js";
+import {
+  renumberFootnotes
+} from "./chunk-BXWNU4T5.js";
 
 // src/docx/export.ts
 import { resolveFontFamily } from "@bendyline/squisq/schemas";
@@ -471,6 +474,7 @@ function makeRun(text, format) {
   if (format.strike) rPrParts.push("<w:strike/>");
   if (format.color) rPrParts.push(`<w:color w:val="${format.color}"/>`);
   if (format.code) rPrParts.push(`<w:sz w:val="${DEFAULT_CODE_FONT_SIZE}"/>`);
+  if (format.vertAlign) rPrParts.push(`<w:vertAlign w:val="${format.vertAlign}"/>`);
   const rPr = rPrParts.length > 0 ? `<w:rPr>${rPrParts.join("")}</w:rPr>` : "";
   return `<w:r>${rPr}<w:t xml:space="preserve">${escapeXml(text)}</w:t></w:r>`;
 }
@@ -797,7 +801,9 @@ async function docxToMarkdownDoc(data, options = {}) {
     return { type: "document", children: [] };
   }
   const blocks = await convertDocumentStories(body, ctx);
-  return { type: "document", children: blocks };
+  const doc = { type: "document", children: blocks };
+  renumberFootnotes(doc);
+  return doc;
 }
 async function docxToDoc(data, options = {}) {
   const markdownDoc = await docxToMarkdownDoc(data, options);
@@ -1062,7 +1068,9 @@ async function convertParagraph2(el, ctx) {
   return { type: "paragraph", children: inlines };
 }
 async function convertRuns(paragraphEl, ctx) {
-  return mergeAdjacentText(await convertInlineElements(Array.from(paragraphEl.children), ctx));
+  return normalizeParagraphWhitespace(
+    await convertInlineElements(Array.from(paragraphEl.children), ctx)
+  );
 }
 async function convertInlineElements(children, ctx) {
   const result = [];
@@ -1105,6 +1113,9 @@ async function convertRun(runEl, ctx) {
         result.push({ type: "inlineCode", value: text });
       } else {
         let node = { type: "text", value: text };
+        if (format.vertAlign) {
+          node = format.vertAlign === "superscript" ? { type: "superscript", children: [node] } : { type: "subscript", children: [node] };
+        }
         if (format.strike) {
           node = { type: "delete", children: [node] };
         }
@@ -1202,7 +1213,7 @@ function appendInlineGroup(target, group) {
   target.push(...group);
 }
 function parseRunFormat(rPr, ctx) {
-  if (!rPr) return { bold: false, italic: false, strike: false, code: false };
+  if (!rPr) return { bold: false, italic: false, strike: false, code: false, vertAlign: null };
   const bold = hasChildElement(rPr, "b") && !isFalseToggle(getFirstChildElement(rPr, "b"));
   const italic = hasChildElement(rPr, "i") && !isFalseToggle(getFirstChildElement(rPr, "i"));
   const strike = hasChildElement(rPr, "strike") && !isFalseToggle(getFirstChildElement(rPr, "strike"));
@@ -1212,7 +1223,10 @@ function parseRunFormat(rPr, ctx) {
   const rFonts = getFirstChildElement(rPr, "rFonts");
   const fontName = rFonts ? getAttr(rFonts, "ascii") ?? getAttr(rFonts, "hAnsi") ?? "" : "";
   const isMonospace = /consolas|courier|mono/i.test(fontName);
-  return { bold, italic, strike, code: isCodeStyle || isMonospace };
+  const vertAlignEl = getFirstChildElement(rPr, "vertAlign");
+  const vertAlignVal = vertAlignEl ? getAttr(vertAlignEl, "val") : null;
+  const vertAlign = vertAlignVal === "superscript" || vertAlignVal === "subscript" ? vertAlignVal : null;
+  return { bold, italic, strike, code: isCodeStyle || isMonospace, vertAlign };
 }
 function isFalseToggle(el) {
   const val = getAttr(el, "val");
@@ -1486,6 +1500,64 @@ function mergeAdjacentText(nodes) {
   }
   return result;
 }
+function isImportedInlineContainer(node) {
+  return node.type === "emphasis" || node.type === "strong" || node.type === "delete" || node.type === "superscript" || node.type === "subscript" || node.type === "link";
+}
+function normalizeParagraphWhitespace(nodes) {
+  const result = [];
+  let line = [];
+  const flushLine = () => {
+    const normalized = liftFormattedBoundaryWhitespace(line);
+    takeLeadingHorizontalWhitespace(normalized);
+    takeTrailingHorizontalWhitespace(normalized);
+    result.push(...mergeAdjacentText(normalized));
+    line = [];
+  };
+  for (const node of nodes) {
+    if (node.type === "break") {
+      flushLine();
+      result.push(node);
+    } else {
+      line.push(node);
+    }
+  }
+  flushLine();
+  return result;
+}
+function liftFormattedBoundaryWhitespace(nodes) {
+  const result = [];
+  for (const node of nodes) {
+    if (!isImportedInlineContainer(node)) {
+      result.push(node);
+      continue;
+    }
+    const children = liftFormattedBoundaryWhitespace(node.children);
+    const leading = takeLeadingHorizontalWhitespace(children);
+    const trailing = takeTrailingHorizontalWhitespace(children);
+    if (leading) result.push({ type: "text", value: leading });
+    if (children.length > 0) result.push({ ...node, children });
+    if (trailing) result.push({ type: "text", value: trailing });
+  }
+  return mergeAdjacentText(result);
+}
+function takeLeadingHorizontalWhitespace(nodes) {
+  const first = nodes[0];
+  if (first?.type !== "text") return "";
+  const match = /^[\t ]+/.exec(first.value);
+  if (!match) return "";
+  first.value = first.value.slice(match[0].length);
+  if (!first.value) nodes.shift();
+  return match[0];
+}
+function takeTrailingHorizontalWhitespace(nodes) {
+  const last = nodes[nodes.length - 1];
+  if (last?.type !== "text") return "";
+  const match = /[\t ]+$/.exec(last.value);
+  if (!match) return "";
+  last.value = last.value.slice(0, -match[0].length);
+  if (!last.value) nodes.pop();
+  return match[0];
+}
 
 export {
   markdownDocToDocx,

package/dist/{chunk-XCV242AO.js → chunk-FMQWNPCV.js}

@@ -4,11 +4,11 @@ import {
   inlineNodesToRuns,
   sanitizeOfficeHyperlink,
   toOoxmlHex
-} from "./chunk-DWNNYO5H.js";
+} from "./chunk-A6N6IN3I.js";
 import {
   extractPlainText,
   stripHtmlTags
-} from "./chunk-6X5XN3CZ.js";
+} from "./chunk-AVOZAKGP.js";
 import {
   createPackage
 } from "./chunk-ILCJ3WFD.js";
@@ -1232,6 +1232,9 @@ function makeRun(text, format, style) {
   if (format.bold) rPrParts.push(`b="1"`);
   if (format.italic) rPrParts.push(`i="1"`);
   if (format.strike) rPrParts.push(`strike="sngStrike"`);
+  if (format.vertAlign) {
+    rPrParts.push(`baseline="${format.vertAlign === "superscript" ? 3e4 : -25e3}"`);
+  }
   let innerParts = "";
   if (format.code) {
     innerParts += `<a:solidFill><a:srgbClr val="${style.codeColor}"/></a:solidFill>`;