@bendyline/squisq-formats 2.4.5 → 2.5.0

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>`;

package/dist/{chunk-DNGNODJP.js → chunk-JTGWQK5V.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-KT5DX2QP.js → chunk-M7XPXGXW.js}

@@ -6,6 +6,9 @@ import {
   fontAwesomeFaces,
   fontAwesomeGlyph
 } from "./chunk-USU6HTKB.js";
+import {
+  FootnoteIndex
+} from "./chunk-BXWNU4T5.js";
 
 // src/pdf/export.ts
 import { PDFDocument, StandardFonts, rgb, PDFString } from "pdf-lib";
@@ -450,6 +453,7 @@ async function createExportContext(pdfDoc, options, doc) {
     contentWidth: pageWidth - 2 * margin,
     bottomY: margin,
     colors: { text: colorText, heading: colorHeading, link: colorLink },
+    footnotes: new FootnoteIndex(doc),
     text: new WinAnsiTracker(),
     signal: options.signal
   };
@@ -464,19 +468,25 @@ function newPage(ctx) {
   ctx.page = page;
   ctx.y = ctx.pageHeight - ctx.margin;
 }
+var VERT_ALIGN_SCALE = 0.72;
+function vertAlignShift(kind, baseSize) {
+  return kind === "superscript" ? baseSize * 0.33 : baseSize * -0.14;
+}
 function flattenInlines(nodes, ctx, state) {
   const spans = [];
   for (const node of nodes) {
     switch (node.type) {
       case "text": {
         const font = state.code ? state.bold ? ctx.fonts.monoBold : ctx.fonts.mono : pickFont(ctx, state.bold, state.italic);
+        const baseSize = state.code ? CODE_FONT_SIZE : ctx.fontSize;
         spans.push({
           text: ctx.text.clean(node.value),
           font,
-          fontSize: state.code ? CODE_FONT_SIZE : ctx.fontSize,
+          fontSize: state.vertAlign ? baseSize * VERT_ALIGN_SCALE : baseSize,
           color: state.code ? COLOR_CODE_TEXT : state.color ?? ctx.colors.text,
           link: state.link,
-          strikethrough: state.strikethrough
+          strikethrough: state.strikethrough,
+          ...state.vertAlign ? { baselineShift: vertAlignShift(state.vertAlign, baseSize) } : {}
         });
         break;
       }
@@ -498,6 +508,15 @@ function flattenInlines(nodes, ctx, state) {
           })
         );
         break;
+      case "superscript":
+      case "subscript":
+        spans.push(
+          ...flattenInlines(node.children, ctx, {
+            ...state,
+            vertAlign: node.type === "superscript" ? "superscript" : "subscript"
+          })
+        );
+        break;
       case "inlineCode": {
         spans.push({
           text: ctx.text.clean(node.value),
@@ -585,11 +604,13 @@ function flattenInlines(nodes, ctx, state) {
         break;
       case "footnoteReference": {
         const ref = node;
+        const marker = ctx.footnotes ? String(ctx.footnotes.cite(ref.identifier).number) : ref.label ?? ref.identifier;
         spans.push({
-          text: ctx.text.clean(`[${ref.identifier}]`),
+          text: ctx.text.clean(marker),
           font: ctx.fonts.regular,
-          fontSize: ctx.fontSize * 0.75,
-          color: ctx.colors.link
+          fontSize: ctx.fontSize * VERT_ALIGN_SCALE,
+          color: ctx.colors.link,
+          baselineShift: vertAlignShift("superscript", ctx.fontSize)
         });
         break;
       }
@@ -626,9 +647,10 @@ function drawSpans(spans, ctx, availableWidth, x0) {
     ensureSpace(ctx, lineHeight);
     let x = x0;
     for (const span of line) {
+      const spanBaseline = ctx.y - span.fontSize + (span.baselineShift ?? 0);
       ctx.page.drawText(span.text, {
         x,
-        y: ctx.y - span.fontSize,
+        y: spanBaseline,
         // pdf-lib y is baseline
         size: span.fontSize,
         font: span.font,
@@ -636,7 +658,7 @@ function drawSpans(spans, ctx, availableWidth, x0) {
       });
       const textWidth = span.font.widthOfTextAtSize(span.text, span.fontSize);
       if (span.link) {
-        const baseline = ctx.y - span.fontSize;
+        const baseline = spanBaseline;
         ctx.page.drawLine({
           start: { x, y: baseline - 1 },
           end: { x: x + textWidth, y: baseline - 1 },
@@ -659,7 +681,7 @@ function drawSpans(spans, ctx, availableWidth, x0) {
         ctx.page.node.addAnnot(annotation);
       }
       if (span.strikethrough) {
-        const midY = ctx.y - span.fontSize * 0.6;
+        const midY = spanBaseline + span.fontSize * 0.4;
         ctx.page.drawLine({
           start: { x, y: midY },
           end: { x: x + textWidth, y: midY },
@@ -1022,7 +1044,8 @@ function renderMathBlock(node, ctx, extraIndent) {
   ctx.y -= PARAGRAPH_SPACING;
 }
 function renderFootnoteDefinition(node, ctx, extraIndent) {
-  const label = ctx.text.clean(`[${node.identifier}]`);
+  const number = ctx.footnotes?.numberFor(node.identifier);
+  const label = ctx.text.clean(number !== void 0 ? `${number}.` : `[${node.identifier}]`);
   const lineH = ctx.fontSize * LINE_HEIGHT_FACTOR;
   ensureSpace(ctx, lineH);
   ctx.page.drawText(label, {