ooxml-core 0.2.0

package/dist/docx/layout/index.cjs

@@ -0,0 +1,2537 @@
+'use strict';
+
+// src/units/units.ts
+function integer(unit, value, allowNegative = true) {
+  if (!Number.isSafeInteger(value)) throw new RangeError(`${unit} must be a safe integer`);
+  if (!allowNegative && value < 0) throw new RangeError(`${unit} must not be negative`);
+  return value;
+}
+function finite(unit, value) {
+  if (!Number.isFinite(value)) throw new RangeError(`${unit} must be finite`);
+  return value;
+}
+var roundAway = (unit, value) => Math.sign(finite(unit, value)) * Math.round(Math.abs(value)) || 0;
+var twips = (value) => integer("twips", value, false);
+var roundSignedTwips = (value) => integer("twips", roundAway("twips", value));
+var twipsToPixels = (value) => value / 15;
+
+// src/docx/paragraph-alignment.ts
+function alignFromJustification(jc, rtl) {
+  switch (jc) {
+    case "left":
+    case "center":
+    case "right":
+      return jc;
+    case "start":
+      return rtl ? "right" : "left";
+    case "end":
+      return rtl ? "left" : "right";
+    case "both":
+    case "distribute":
+    case "thaiDistribute":
+    case "mediumKashida":
+    case "highKashida":
+    case "lowKashida":
+      return "justify";
+    default:
+      return void 0;
+  }
+}
+
+// src/docx/paragraph-styles.ts
+var PAGINATION_KEYS = [
+  "keepNext",
+  "keepLines",
+  "widowControl",
+  "contextualSpacing",
+  "suppressLineNumbers"
+];
+function applyStyle(styleId, catalog, out) {
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = styleId;
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const style = catalog.styles[current];
+    if (!style) break;
+    chain.push(style);
+    current = style.basedOn;
+  }
+  for (const style of chain.reverse()) Object.assign(out, style.formatting);
+}
+function resolveParagraphFormatting(paragraph, catalog) {
+  const result = { ...catalog.docDefaults };
+  const explicitStyle = paragraph.style;
+  const defaultStyle = Object.values(catalog.styles).find((style) => style.isDefault)?.id;
+  applyStyle(explicitStyle || defaultStyle, catalog, result);
+  const direct = {};
+  const keys = [
+    "align",
+    "justification",
+    "direction",
+    "spacingBeforeTwips",
+    "spacingAfterTwips",
+    "lineSpacingTwips",
+    "lineSpacingRule",
+    "indentLeftTwips",
+    "indentRightTwips",
+    "indentStartTwips",
+    "indentEndTwips",
+    "firstLineTwips",
+    "hangingTwips",
+    ...PAGINATION_KEYS,
+    "borders",
+    "shadingFill"
+  ];
+  for (const key of keys) {
+    const value = paragraph[key];
+    if (value !== void 0) Object.assign(direct, { [key]: value });
+  }
+  Object.assign(result, direct);
+  if (paragraph.align !== void 0 && paragraph.justification === void 0)
+    delete result.justification;
+  if ((result.justification === "start" || result.justification === "end") && result.direction === "rtl" && (paragraph.align === void 0 || paragraph.justification !== void 0) && result.align === alignFromJustification(result.justification, false)) {
+    const align = alignFromJustification(result.justification, true);
+    if (align === void 0) delete result.align;
+    else result.align = align;
+  }
+  return result;
+}
+function resolveStyleNumbering(styleId, catalog) {
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = styleId;
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const style = catalog.styles[current];
+    if (!style) break;
+    chain.push(style);
+    current = style.basedOn;
+  }
+  return chain.find((style) => style.numbering)?.numbering;
+}
+
+// src/docx/resolve-table.ts
+function styleChain(styleId, catalog) {
+  if (!styleId || !catalog) return [];
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = styleId;
+  while (current && !visited.has(current)) {
+    const style = catalog.styles[current];
+    if (!style) break;
+    visited.add(current);
+    chain.push(style);
+    current = style.basedOn;
+  }
+  return chain.reverse();
+}
+function applicableRegions(look, rowIndex, rowCount, colIndex, colCount) {
+  const regions = ["wholeTable"];
+  if (!look?.noVBand) regions.push(colIndex % 2 === 0 ? "band1Vert" : "band2Vert");
+  if (!look?.noHBand) regions.push(rowIndex % 2 === 0 ? "band1Horz" : "band2Horz");
+  if (look?.lastColumn && colIndex === colCount - 1) regions.push("lastCol");
+  if (look?.firstColumn && colIndex === 0) regions.push("firstCol");
+  if (look?.lastRow && rowIndex === rowCount - 1) regions.push("lastRow");
+  if (look?.firstRow && rowIndex === 0) regions.push("firstRow");
+  return regions;
+}
+function resolveTableStyleFormatting(tableStyleId, catalog, look, rowIndex, rowCount, colIndex, colCount) {
+  const chain = styleChain(tableStyleId, catalog);
+  const regions = applicableRegions(look, rowIndex, rowCount, colIndex, colCount);
+  const result = {};
+  for (const style of chain) {
+    if (style.borders) result.borders = { ...result.borders, ...style.borders };
+    if (style.shadingFill) result.shadingFill = style.shadingFill;
+    for (const region of regions) {
+      const formatting = style.conditional[region];
+      if (!formatting) continue;
+      if (formatting.borders) result.borders = { ...result.borders, ...formatting.borders };
+      if (formatting.shadingFill) result.shadingFill = formatting.shadingFill;
+      if (formatting.shadingThemeFill) result.shadingThemeFill = formatting.shadingThemeFill;
+      if (formatting.run) result.run = { ...result.run, ...formatting.run };
+    }
+  }
+  return result;
+}
+
+// src/docx/run-formatting.ts
+var TOGGLE_KEYS = [
+  "bold",
+  "italic",
+  "caps",
+  "smallCaps",
+  "strike",
+  "doubleStrike",
+  "vanish"
+];
+var OVERRIDE_KEYS = [
+  "underline",
+  "underlineStyle",
+  "underlineColor",
+  "highlight",
+  "verticalAlign",
+  "fontSize",
+  "fontFamily",
+  "fontTheme",
+  "color",
+  "colorTheme",
+  "characterSpacingTwips",
+  "textScalePercent",
+  "ligatures",
+  "kerningHalfPoints",
+  "positionHalfPoints",
+  "shadingFill",
+  "shadingThemeFill"
+];
+function paragraphStyleRunChain(styleId, paragraphCatalog, runCatalog) {
+  if (!paragraphCatalog) return [];
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = styleId || Object.values(paragraphCatalog.styles).find((style) => style.isDefault)?.id;
+  while (current && !visited.has(current)) {
+    const style = paragraphCatalog.styles[current];
+    if (!style) break;
+    visited.add(current);
+    const runDefinition = runCatalog?.styles[current];
+    if (runDefinition) chain.push(runDefinition.formatting);
+    current = style.basedOn;
+  }
+  return chain.reverse();
+}
+function characterStyleChain(styleId, runCatalog) {
+  if (!styleId || !runCatalog) return [];
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = styleId;
+  while (current && !visited.has(current)) {
+    const style = runCatalog.styles[current];
+    if (!style) break;
+    visited.add(current);
+    chain.push(style.formatting);
+    current = style.basedOn;
+  }
+  return chain.reverse();
+}
+function resolveRunFormatting(run, context = {}) {
+  const docDefaults = context.runCatalog?.docDefaults ?? {};
+  const paragraphChain = paragraphStyleRunChain(
+    context.paragraphStyleId,
+    context.paragraphCatalog,
+    context.runCatalog
+  );
+  const characterChain = characterStyleChain(run.style, context.runCatalog);
+  const tableLevels = context.tableStyleRun ? [context.tableStyleRun] : [];
+  const levels = [
+    docDefaults,
+    ...paragraphChain,
+    ...tableLevels,
+    ...characterChain,
+    run
+  ];
+  const result = {};
+  const chainValue = (chain, key) => {
+    for (let index = chain.length - 1; index >= 0; index--)
+      if (chain[index]?.[key] !== void 0) return Boolean(chain[index]?.[key]);
+    return false;
+  };
+  for (const key of TOGGLE_KEYS) {
+    const direct = run[key];
+    const state = direct !== void 0 ? Boolean(direct) : Boolean(docDefaults[key]) !== (chainValue(paragraphChain, key) !== (chainValue(tableLevels, key) !== chainValue(characterChain, key)));
+    if (state) result[key] = true;
+  }
+  for (const key of OVERRIDE_KEYS) {
+    for (const level of levels) {
+      const value = level[key];
+      if (value !== void 0) result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/docx/theme-color.ts
+var TOKEN_TO_SLOT = {
+  dark1: "dk1",
+  light1: "lt1",
+  dark2: "dk2",
+  light2: "lt2",
+  accent1: "accent1",
+  accent2: "accent2",
+  accent3: "accent3",
+  accent4: "accent4",
+  accent5: "accent5",
+  accent6: "accent6",
+  hyperlink: "hlink",
+  followedHyperlink: "folHlink"
+};
+var DEFAULT_MAPPING = {
+  bg1: "lt1",
+  tx1: "dk1",
+  bg2: "lt2",
+  tx2: "dk2"
+};
+function resolveThemeColorToken(token, theme) {
+  const logical = {
+    background1: "bg1",
+    text1: "tx1",
+    background2: "bg2",
+    text2: "tx2"
+  };
+  const logicalKey = logical[token];
+  if (logicalKey) {
+    const slot2 = theme.colorMapping[logicalKey] ?? DEFAULT_MAPPING[logicalKey];
+    return theme.colors[slot2];
+  }
+  const slot = TOKEN_TO_SLOT[token];
+  return slot ? theme.colors[slot] : void 0;
+}
+function hexToRgb(hex) {
+  const normalized = hex.replace(/^#/, "");
+  if (!/^[0-9a-fA-F]{6}$/.test(normalized)) return null;
+  return {
+    r: Number.parseInt(normalized.slice(0, 2), 16),
+    g: Number.parseInt(normalized.slice(2, 4), 16),
+    b: Number.parseInt(normalized.slice(4, 6), 16)
+  };
+}
+function toHex(value) {
+  return Math.min(255, Math.max(0, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
+}
+function srgbToLinear(channel) {
+  const c = Math.min(1, Math.max(0, channel / 255));
+  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function linearToSrgb(linear) {
+  const c = Math.min(1, Math.max(0, linear));
+  return 255 * (c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055);
+}
+function applyThemeShade(hex, fraction) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return hex;
+  const mix = (channel) => linearToSrgb(srgbToLinear(channel) * fraction);
+  return `#${toHex(mix(rgb.r))}${toHex(mix(rgb.g))}${toHex(mix(rgb.b))}`;
+}
+function applyThemeTint(hex, fraction) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return hex;
+  const mix = (channel) => linearToSrgb(1 - (1 - srgbToLinear(channel)) * fraction);
+  return `#${toHex(mix(rgb.r))}${toHex(mix(rgb.g))}${toHex(mix(rgb.b))}`;
+}
+function resolveThemeColorReference(ref, theme) {
+  const base = resolveThemeColorToken(ref.token, theme);
+  if (!base) return void 0;
+  let hex = `#${base.replace(/^#/, "")}`;
+  if (ref.shade !== void 0) hex = applyThemeShade(hex, ref.shade);
+  if (ref.tint !== void 0) hex = applyThemeTint(hex, ref.tint);
+  return hex;
+}
+
+// src/docx/expect-defined.ts
+function expectDefined(value, context) {
+  if (value === void 0 || value === null) {
+    throw new Error(`Internal invariant violated: ${context} is missing.`);
+  }
+  return value;
+}
+
+// src/docx/defined-props.ts
+function definedProps(source) {
+  return Object.fromEntries(Object.entries(source).filter(([, value]) => value !== void 0));
+}
+
+// src/docx/field-runs.ts
+function fieldName(instr) {
+  return instr.trim().split(/\s+/)[0]?.toUpperCase() ?? "";
+}
+
+// src/docx/notes.ts
+var romanNumerals = [
+  [1e3, "M"],
+  [900, "CM"],
+  [500, "D"],
+  [400, "CD"],
+  [100, "C"],
+  [90, "XC"],
+  [50, "L"],
+  [40, "XL"],
+  [10, "X"],
+  [9, "IX"],
+  [5, "V"],
+  [4, "IV"],
+  [1, "I"]
+];
+function toRoman(value) {
+  let remaining = Math.max(1, Math.round(value));
+  let result = "";
+  for (const [amount, numeral] of romanNumerals) {
+    while (remaining >= amount) {
+      result += numeral;
+      remaining -= amount;
+    }
+  }
+  return result || "I";
+}
+function toLetters(value) {
+  let remaining = Math.max(1, Math.round(value));
+  let result = "";
+  while (remaining > 0) {
+    remaining--;
+    result = String.fromCharCode(97 + remaining % 26) + result;
+    remaining = Math.floor(remaining / 26);
+  }
+  return result || "a";
+}
+function formatNoteNumber(value, format) {
+  switch (format) {
+    case "upperRoman":
+      return toRoman(value);
+    case "lowerRoman":
+      return toRoman(value).toLowerCase();
+    case "upperLetter":
+      return toLetters(value).toUpperCase();
+    case "lowerLetter":
+      return toLetters(value);
+    case "decimalZero":
+      return value < 10 ? `0${value}` : String(value);
+    default:
+      return String(value);
+  }
+}
+function walkParagraph(paragraph, kind, order) {
+  for (const run of paragraph.runs) {
+    if (run.noteReference?.kind === kind && !order.has(run.noteReference.id))
+      order.set(run.noteReference.id, order.size + 1);
+  }
+}
+function walkBlocks(blocks, kind, order) {
+  for (const block of blocks) {
+    if (block.type === "paragraph") walkParagraph(block, kind, order);
+    else
+      for (const row of block.rows)
+        for (const cell of row) walkBlocks(cell.paragraphs, kind, order);
+  }
+}
+function numberNotesInOrder(blocks, kind) {
+  const order = /* @__PURE__ */ new Map();
+  walkBlocks(blocks, kind, order);
+  return order;
+}
+
+// src/docx/numbering-parse.ts
+function resolveNumberingLevel(catalog, numId, level) {
+  const num = catalog.nums[numId];
+  if (!num) return void 0;
+  const override = num.levelOverrides?.[level];
+  const base = override?.lvl ?? catalog.abstractNums[num.abstractNumId]?.levels[level];
+  if (!base) return void 0;
+  return override?.startOverride !== void 0 ? { ...base, start: override.startOverride } : base;
+}
+
+// src/docx/numbering-text.ts
+function romanNumeral(n) {
+  const values = [1e3, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
+  const numerals = [
+    "M",
+    "CM",
+    "D",
+    "CD",
+    "C",
+    "XC",
+    "L",
+    "XL",
+    "X",
+    "IX",
+    "V",
+    "IV",
+    "I"
+  ];
+  let remaining = Math.max(1, Math.min(Math.trunc(n), 3999));
+  let result = "";
+  for (const [i, value] of values.entries()) {
+    while (remaining >= value) {
+      result += numerals[i] ?? "";
+      remaining -= value;
+    }
+  }
+  return result;
+}
+var LATIN_LOWER = Array.from("abcdefghijklmnopqrstuvwxyz");
+function letterLabel(n) {
+  const index = Math.max(0, Math.trunc(n) - 1);
+  const letter = LATIN_LOWER[index % LATIN_LOWER.length] ?? "a";
+  return letter.repeat(Math.floor(index / LATIN_LOWER.length) + 1);
+}
+var ORDINAL_SUFFIX = (n) => {
+  const abs = Math.abs(Math.trunc(n));
+  if (abs % 100 >= 11 && abs % 100 <= 13) return "th";
+  switch (abs % 10) {
+    case 1:
+      return "st";
+    case 2:
+      return "nd";
+    case 3:
+      return "rd";
+    default:
+      return "th";
+  }
+};
+function ordinalNumeral(n) {
+  return `${Math.trunc(n)}${ORDINAL_SUFFIX(n)}`;
+}
+var ONES = [
+  "",
+  "one",
+  "two",
+  "three",
+  "four",
+  "five",
+  "six",
+  "seven",
+  "eight",
+  "nine",
+  "ten",
+  "eleven",
+  "twelve",
+  "thirteen",
+  "fourteen",
+  "fifteen",
+  "sixteen",
+  "seventeen",
+  "eighteen",
+  "nineteen"
+];
+var TENS = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"];
+function cardinalWords(n) {
+  const value = Math.trunc(n);
+  if (value < 0 || value > 999999) return String(value);
+  if (value === 0) return "zero";
+  const chunk = (v) => {
+    const parts = [];
+    if (v >= 100) {
+      parts.push(ONES[Math.floor(v / 100)] ?? "", "hundred");
+      v %= 100;
+    }
+    if (v >= 20) {
+      parts.push((TENS[Math.floor(v / 10)] ?? "") + (v % 10 ? `-${ONES[v % 10] ?? ""}` : ""));
+    } else if (v > 0) {
+      parts.push(ONES[v] ?? "");
+    }
+    return parts.join(" ");
+  };
+  const thousands = Math.floor(value / 1e3);
+  const rest = value % 1e3;
+  const words = [];
+  if (thousands) words.push(chunk(thousands), "thousand");
+  if (rest || !thousands) words.push(chunk(rest));
+  return words.filter(Boolean).join(" ");
+}
+var ORDINAL_WORDS = {
+  one: "first",
+  two: "second",
+  three: "third",
+  five: "fifth",
+  eight: "eighth",
+  nine: "ninth",
+  twelve: "twelfth"
+};
+function ordinalWords(n) {
+  const value = Math.trunc(n);
+  if (value < 0 || value > 999999) return ordinalNumeral(value);
+  const words = cardinalWords(value);
+  const splitAt = Math.max(words.lastIndexOf(" "), words.lastIndexOf("-"));
+  const head = splitAt >= 0 ? words.slice(0, splitAt + 1) : "";
+  const lastWord = splitAt >= 0 ? words.slice(splitAt + 1) : words;
+  if (ORDINAL_WORDS[lastWord]) return head + ORDINAL_WORDS[lastWord];
+  if (lastWord.endsWith("y")) return `${head}${lastWord.slice(0, -1)}ieth`;
+  return `${head}${lastWord}th`;
+}
+
+// src/docx/numbering-format.ts
+function formatListNumber(numFmt, value) {
+  switch (numFmt) {
+    case "decimal":
+      return String(value);
+    case "decimalZero":
+      return value < 10 && value >= 0 ? `0${value}` : String(value);
+    case "upperRoman":
+      return romanNumeral(value);
+    case "lowerRoman":
+      return romanNumeral(value).toLowerCase();
+    case "upperLetter":
+      return letterLabel(value).toUpperCase();
+    case "lowerLetter":
+      return letterLabel(value);
+    case "ordinal":
+      return ordinalNumeral(value);
+    case "ordinalText":
+      return ordinalWords(value);
+    case "cardinalText":
+      return cardinalWords(value);
+    case "none":
+      return "";
+    case "bullet":
+      return "";
+    default:
+      return String(value);
+  }
+}
+function resolveParagraphNumbering(paragraph, styleCatalog, numberingCatalog) {
+  if (paragraph.numbering)
+    return paragraph.numbering.numId > 0 ? paragraph.numbering : void 0;
+  if (!styleCatalog) return void 0;
+  const inherited = resolveStyleNumbering(paragraph.style, styleCatalog);
+  if (!inherited || inherited.numId <= 0) return void 0;
+  if (numberingCatalog && paragraph.style && styleCatalog.styles[paragraph.style]) {
+    for (let level = 0; level < 9; level++) {
+      const definition = resolveNumberingLevel(numberingCatalog, String(inherited.numId), level);
+      if (definition?.paragraphStyleId === paragraph.style)
+        return { numId: inherited.numId, level };
+    }
+  }
+  return inherited;
+}
+function flattenParagraphs(blocks) {
+  const result = [];
+  for (const block of blocks) {
+    if (block.type === "paragraph") result.push(block);
+    else for (const row of block.rows) for (const cell of row) result.push(...cell.paragraphs);
+  }
+  return result;
+}
+var NumberingCounters = class {
+  counts = /* @__PURE__ */ new Map();
+  started = /* @__PURE__ */ new Map();
+  forNum(numId) {
+    let counts = this.counts.get(numId);
+    if (!counts) {
+      counts = /* @__PURE__ */ new Map();
+      this.counts.set(numId, counts);
+    }
+    return counts;
+  }
+  startedLevels(numId) {
+    let started = this.started.get(numId);
+    if (!started) {
+      started = /* @__PURE__ */ new Set();
+      this.started.set(numId, started);
+    }
+    return started;
+  }
+  /** Advances one level and resets deeper counters according to their resolved restart rules. */
+  advance(numId, level, def, catalog) {
+    const counts = this.forNum(numId);
+    const started = this.startedLevels(numId);
+    const next = started.has(level) ? (counts.get(level) ?? def.start) + 1 : def.start;
+    counts.set(level, next);
+    started.add(level);
+    for (const deeper of [...started]) {
+      if (deeper <= level) continue;
+      const deeperDef = resolveNumberingLevel(catalog, numId, deeper);
+      const restart = deeperDef?.lvlRestart;
+      if (restart === 0) continue;
+      const trigger = restart !== void 0 && restart > 0 && restart <= deeper ? restart - 1 : deeper - 1;
+      if (level > trigger) continue;
+      counts.delete(deeper);
+      started.delete(deeper);
+    }
+    for (let ancestor = 0; ancestor < level; ancestor++) {
+      if (started.has(ancestor)) continue;
+      const ancestorDef = resolveNumberingLevel(catalog, numId, ancestor);
+      if (!ancestorDef) continue;
+      counts.set(ancestor, ancestorDef.start);
+      started.add(ancestor);
+    }
+    return next;
+  }
+  /** Current value for an ancestor placeholder, defaulting to its own start when never instantiated. */
+  current(numId, level, start) {
+    return this.forNum(numId).get(level) ?? start;
+  }
+};
+function substituteLvlText(lvlText, numId, level, catalog, counters, forceDecimal) {
+  return lvlText.replace(/%([1-9])/g, (match, digit) => {
+    const ancestorLevel = Number(digit) - 1;
+    if (ancestorLevel > level) return match;
+    const ancestorDef = resolveNumberingLevel(catalog, numId, ancestorLevel);
+    const start = ancestorDef?.start ?? 1;
+    const value = counters.current(numId, ancestorLevel, start);
+    const fmt = forceDecimal ? "decimal" : ancestorDef?.numFmt ?? "decimal";
+    return formatListNumber(fmt, value);
+  });
+}
+function computeListLabels(model) {
+  const catalog = model.numberingCatalog;
+  const labels = /* @__PURE__ */ new Map();
+  if (!catalog) return labels;
+  const counters = new NumberingCounters();
+  for (const paragraph of flattenParagraphs(model.blocks)) {
+    const numbering = resolveParagraphNumbering(paragraph, model.paragraphStyles, catalog);
+    if (!numbering) continue;
+    const numId = String(numbering.numId);
+    const level = Math.min(8, Math.max(0, numbering.level));
+    const def = resolveNumberingLevel(catalog, numId, level);
+    if (!def) continue;
+    if (def.numFmt === "none") continue;
+    counters.advance(numId, level, def, catalog);
+    const text = def.numFmt === "bullet" ? def.lvlText : substituteLvlText(def.lvlText, numId, level, catalog, counters, Boolean(def.isLgl));
+    labels.set(paragraph.id, {
+      numId,
+      level,
+      text,
+      suffix: def.suffix ?? "tab",
+      ...definedProps({
+        alignment: def.lvlJc,
+        indentLeftTwips: def.indentLeftTwips,
+        hangingTwips: def.hangingTwips,
+        firstLineTwips: def.firstLineTwips,
+        markerFormat: def.markerFormat,
+        tabStopTwips: def.tabStopTwips
+      })
+    });
+  }
+  return labels;
+}
+var SYMBOL_BULLETS = {
+  "\uF0B7": "\u2022",
+  "\uF0A7": "\u25AA",
+  "\uF0D8": "\u27A2",
+  "\uF076": "\u2756",
+  "\uF0FC": "\u2713",
+  "\uF06E": "\u25A0",
+  "\uF071": "\u2751",
+  "\uF0E0": "\u27A9",
+  "\uF0B2": "\u25CB"
+};
+function displayListLabel(text) {
+  return text.replace(/[-]/g, (char) => SYMBOL_BULLETS[char] ?? "\u2022");
+}
+
+// src/docx/field-date.ts
+function datePicture(instr) {
+  const match = /\\@\s*(?:"([^"]*)"|(\S+))/.exec(instr);
+  return match ? match[1] ?? match[2] : void 0;
+}
+var TOKENS = /yyyy|yy|MMMM|MMM|MM|M|dddd|ddd|dd|d|HH|H|hh|h|mm|ss|am\/pm|AM\/PM|'[^']*'/g;
+function formatWordDate(date, picture, locale = "en-US") {
+  const name = (options) => new Intl.DateTimeFormat(locale, options).format(date);
+  const pad = (value) => String(value).padStart(2, "0");
+  const hours12 = date.getHours() % 12 || 12;
+  return picture.replace(TOKENS, (token) => {
+    switch (token) {
+      case "yyyy":
+        return String(date.getFullYear());
+      case "yy":
+        return pad(date.getFullYear() % 100);
+      case "MMMM":
+        return name({ month: "long" });
+      case "MMM":
+        return name({ month: "short" });
+      case "MM":
+        return pad(date.getMonth() + 1);
+      case "M":
+        return String(date.getMonth() + 1);
+      case "dddd":
+        return name({ weekday: "long" });
+      case "ddd":
+        return name({ weekday: "short" });
+      case "dd":
+        return pad(date.getDate());
+      case "d":
+        return String(date.getDate());
+      case "HH":
+        return pad(date.getHours());
+      case "H":
+        return String(date.getHours());
+      case "hh":
+        return pad(hours12);
+      case "h":
+        return String(hours12);
+      case "mm":
+        return pad(date.getMinutes());
+      case "ss":
+        return pad(date.getSeconds());
+      case "am/pm":
+        return date.getHours() < 12 ? "am" : "pm";
+      case "AM/PM":
+        return date.getHours() < 12 ? "AM" : "PM";
+      default:
+        return token.slice(1, -1);
+    }
+  });
+}
+function dateFieldResult(name, instr, now, locale) {
+  const picture = datePicture(instr) ?? (name === "DATE" ? "M/d/yyyy" : "h:mm am/pm");
+  return formatWordDate(now, picture, locale);
+}
+
+// src/docx/table-visuals.ts
+var NONE = { style: "none" };
+function edgeFrom(borders, side, onBoundary) {
+  if (!borders) return void 0;
+  if (onBoundary) return borders[side];
+  return side === "top" || side === "bottom" ? borders.insideH : borders.insideV;
+}
+function resolveCellVisuals(table, cell, placement, styles) {
+  const styled = table.style ? resolveTableStyleFormatting(
+    table.style,
+    styles,
+    table.look,
+    placement.row,
+    placement.rowCount,
+    placement.column,
+    placement.columnCount
+  ) : {};
+  const hasBorderInfo = Boolean(styled.borders || table.borders || cell.borders);
+  const shadingFill = cell.shadingFill ?? styled.shadingFill;
+  if (!hasBorderInfo) return shadingFill ? { shadingFill } : {};
+  const boundary = {
+    top: placement.row === 0,
+    bottom: placement.lastRow === placement.rowCount - 1,
+    left: placement.column === 0,
+    right: placement.lastColumn === placement.columnCount - 1
+  };
+  const borders = {};
+  for (const side of ["top", "bottom", "left", "right"])
+    borders[side] = cell.borders?.[side] ?? edgeFrom(table.borders, side, boundary[side]) ?? edgeFrom(styled.borders, side, boundary[side]) ?? NONE;
+  return { borders, ...shadingFill ? { shadingFill } : {} };
+}
+
+// src/docx/layout/units.ts
+function twipsToPx(value) {
+  return value * 96 / 1440;
+}
+var NO_TWIPS = twips(0);
+function pxToTwips(px) {
+  return roundSignedTwips(px * 1440 / 96);
+}
+function ptToPx(pt) {
+  return pt * 96 / 72;
+}
+var DEFAULT_TAB_STOP_PX = twipsToPx(twips(720));
+var DEFAULT_FONT_FAMILY = "Calibri";
+var DEFAULT_FONT_SIZE_PT = 11;
+var SINGLE_LINE_SPACING_UNITS = 240;
+
+// src/docx/layout/measure.ts
+function fontMetrics(measurer, font) {
+  const height = measurer.lineHeightOf(font);
+  const ascent = Math.min(height, measurer.ascentOf?.(font) ?? height * 0.8);
+  return { ascent, descent: height - ascent };
+}
+function createFakeMeasurer(options = {}) {
+  const charWidthFactor = options.charWidthFactor ?? 0.6;
+  const lineHeightFactor = options.lineHeightFactor ?? 1.15;
+  return {
+    widthOf(text, font) {
+      let width = 0;
+      for (const ch of text) {
+        if (ch === "	" || ch === "\n") continue;
+        width += font.sizePx * charWidthFactor * (font.bold ? 1.08 : 1) * (ch === " " ? 0.6 : 1);
+      }
+      return width;
+    },
+    lineHeightOf(font) {
+      return font.sizePx * lineHeightFactor;
+    }
+  };
+}
+
+// src/docx/layout/ligatures.ts
+function ligatureCss(value) {
+  const enabled = (token) => value === "all" || value.toLowerCase().includes(token);
+  return `${enabled("standard") ? "common-ligatures" : "no-common-ligatures"} ${enabled("contextual") ? "contextual" : "no-contextual"} ${enabled("historical") ? "historical-ligatures" : "no-historical-ligatures"} ${enabled("discretional") ? "discretionary-ligatures" : "no-discretionary-ligatures"}`;
+}
+
+// src/docx/layout/text-breaks.ts
+function isEastAsianChar(ch) {
+  const cp = ch.codePointAt(0) ?? 0;
+  return cp >= 4352 && cp <= 4607 || cp >= 11904 && cp <= 40959 || cp >= 43360 && cp <= 43391 || cp >= 44032 && cp <= 55295 || cp >= 63744 && cp <= 64255 || cp >= 65072 && cp <= 65103 || cp >= 65280 && cp <= 65519 || cp >= 131072 && cp <= 262143;
+}
+function tokenizeRun(text, runIndex) {
+  const tokens = [];
+  let word = "";
+  let wordStart = 0;
+  const flushWord = () => {
+    if (word) tokens.push({ kind: "word", text: word, runIndex, sourceStart: wordStart });
+    word = "";
+  };
+  const chars = [...new Intl.Segmenter(void 0, { granularity: "grapheme" }).segment(text)].map(
+    (part) => part.segment
+  );
+  let offset = 0;
+  for (const ch of chars) {
+    if (ch === "\n") {
+      flushWord();
+      tokens.push({ kind: "lineBreak", runIndex, sourceStart: offset });
+    } else if (ch === "	") {
+      flushWord();
+      tokens.push({ kind: "tab", runIndex, sourceStart: offset });
+    } else if (ch === " ") {
+      flushWord();
+      tokens.push({ kind: "space", text: ch, runIndex, sourceStart: offset });
+    } else if (isEastAsianChar(ch)) {
+      flushWord();
+      tokens.push({ kind: "word", text: ch, runIndex, sourceStart: offset });
+    } else {
+      if (!word) wordStart = offset;
+      word += ch;
+      if (ch === "-") flushWord();
+    }
+    offset += ch.length;
+  }
+  flushWord();
+  return tokens;
+}
+function appendBreakMarker(tokens, runIndex, sourceStart, kind) {
+  tokens.push({ kind: kind === "page" ? "pageBreak" : "columnBreak", runIndex, sourceStart });
+}
+
+// src/docx/layout/tab-stops.ts
+function placeTab(positionPx, stops, hangingStopPx, followingPx, beforeDecimalPx) {
+  const epsilon = 0.5;
+  const custom = stops.filter((stop) => stop.align !== "clear" && stop.align !== "bar").sort((a, b) => a.posPx - b.posPx).find((stop) => stop.posPx > positionPx + epsilon);
+  if (custom) {
+    const distance = custom.posPx - positionPx;
+    const shift = custom.align === "right" || custom.align === "end" ? followingPx : custom.align === "center" ? followingPx / 2 : custom.align === "decimal" ? beforeDecimalPx : 0;
+    return {
+      widthPx: Math.max(0, distance - shift),
+      ...custom.leader && custom.leader !== "none" ? { leader: custom.leader } : {}
+    };
+  }
+  if (hangingStopPx !== void 0 && hangingStopPx > positionPx + epsilon)
+    return { widthPx: hangingStopPx - positionPx };
+  const next = (Math.floor(positionPx / DEFAULT_TAB_STOP_PX) + 1) * DEFAULT_TAB_STOP_PX;
+  return { widthPx: next - positionPx };
+}
+
+// src/docx/layout/paragraph-tokens.ts
+var SCRIPT_SCALE = 0.65;
+function fontOf(run) {
+  return {
+    family: run.fontFamily || DEFAULT_FONT_FAMILY,
+    sizePx: ptToPx(run.fontSizePt ?? DEFAULT_FONT_SIZE_PT) * (run.script ? SCRIPT_SCALE : 1),
+    ...definedProps({ bold: run.bold, italic: run.italic, ligatures: run.ligatures }),
+    ...run.kerningThresholdPt === void 0 ? {} : {
+      kerning: run.kerningThresholdPt > 0 && (run.fontSizePt ?? DEFAULT_FONT_SIZE_PT) >= run.kerningThresholdPt ? "normal" : "none"
+    }
+  };
+}
+var graphemes = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function runTextWidth(text, run, measurer) {
+  return Math.max(
+    0,
+    measurer.widthOf(text, fontOf(run)) * (run.textScalePercent ?? 100) / 100 + [...graphemes.segment(text)].length * (run.characterSpacingPx ?? 0)
+  );
+}
+function resolveIndents(paragraph) {
+  const rtl = paragraph.direction === "rtl";
+  const startTwips = paragraph.indentStartTwips ?? (rtl ? paragraph.indentRightTwips : paragraph.indentLeftTwips) ?? NO_TWIPS;
+  const endTwips = paragraph.indentEndTwips ?? (rtl ? paragraph.indentLeftTwips : paragraph.indentRightTwips) ?? NO_TWIPS;
+  const leftTwips = rtl ? endTwips : startTwips;
+  const rightTwips = rtl ? startTwips : endTwips;
+  const firstLineExtraPx = paragraph.hangingTwips != null ? -twipsToPx(paragraph.hangingTwips) : twipsToPx(paragraph.firstLineTwips ?? NO_TWIPS);
+  return {
+    leftPx: twipsToPx(leftTwips),
+    rightPx: twipsToPx(rightTwips),
+    firstLineExtraPx
+  };
+}
+function tokenizeParagraph(paragraph) {
+  const tokens = [];
+  const runOffsets = [];
+  let cursor = 0;
+  paragraph.runs.forEach((run, runIndex) => {
+    runOffsets.push(cursor);
+    if (run.object) tokens.push({ kind: "object", runIndex, sourceStart: 0 });
+    else if (run.marker) {
+      tokens.push({
+        kind: "word",
+        runIndex,
+        sourceStart: 0,
+        text: run.text.slice(0, run.marker.length)
+      });
+      tokens.push(...tokenizeRun(run.text.slice(run.marker.length), runIndex));
+    } else tokens.push(...tokenizeRun(run.text, runIndex));
+    if (run.breakAfter) appendBreakMarker(tokens, runIndex, run.text.length, run.breakAfter);
+    if (run.synthetic) {
+      for (const token of tokens) if (token.runIndex === runIndex) token.sourceStart = 0;
+    } else cursor += run.text.length;
+  });
+  return { tokens, runOffsets };
+}
+
+// src/docx/layout/line-metrics.ts
+var SUPER_RAISE = 0.33;
+function tokenExtent(token, paragraph, fonts, measurer) {
+  const run = paragraph.runs[token.runIndex];
+  if (token.kind === "object" && run?.object)
+    return { above: run.object.heightPx, below: 0, ascent: run.object.heightPx, descent: 0 };
+  const { ascent, descent } = fontMetrics(measurer, fonts[token.runIndex] ?? fontOf({ }));
+  const size = ptToPx(run?.fontSizePt ?? DEFAULT_FONT_SIZE_PT);
+  const scriptShift = run?.script === "super" ? SUPER_RAISE * size : run?.script === "sub" ? -0.14 * size : 0;
+  const shift = scriptShift + (run?.positionPx ?? 0);
+  return { above: ascent + shift, below: descent - shift, ascent, descent };
+}
+function lineMetrics(placed, fonts, paragraph, measurer) {
+  const tokens = placed.length ? placed.map((p) => p.token) : [{ kind: "space", text: " ", runIndex: 0, sourceStart: 0 }];
+  let above = 0;
+  let below = 0;
+  for (const token of tokens) {
+    const extent = tokenExtent(token, paragraph, fonts, measurer);
+    above = Math.max(above, extent.above);
+    below = Math.max(below, extent.below);
+  }
+  const natural = above + below;
+  const rule = paragraph.lineSpacingRule ?? "auto";
+  const spacingTwips = paragraph.lineSpacingTwips;
+  const heightPx = rule === "exact" ? spacingTwips != null ? twipsToPx(spacingTwips) : natural : rule === "atLeast" ? Math.max(natural, spacingTwips != null ? twipsToPx(spacingTwips) : 0) : natural * ((spacingTwips ?? 240) / 240);
+  return { heightPx, baselinePx: heightPx - below };
+}
+
+// src/docx/layout/paragraph-fragments.ts
+function buildFragments(tokensOnLine, paragraph) {
+  const fragments = [];
+  let x = 0;
+  for (const { token, widthPx, leader, xOffsetPx, advancePx } of tokensOnLine) {
+    const run = paragraph.runs[token.runIndex];
+    const text = token.kind === "word" || token.kind === "space" ? token.text : "";
+    fragments.push({
+      text,
+      xPx: x + (xOffsetPx ?? 0),
+      widthPx,
+      runIndex: token.runIndex,
+      ...definedProps({
+        bold: run?.bold,
+        italic: run?.italic,
+        fontFamily: run?.fontFamily,
+        fontSizePt: run?.fontSizePt,
+        textScalePercent: run?.textScalePercent,
+        ligatures: run?.ligatures,
+        characterSpacingPx: run?.characterSpacingPx,
+        kerningThresholdPt: run?.kerningThresholdPt
+      }),
+      ...leader ? { leader } : {},
+      ...run?.script ? { script: run.script } : {},
+      ...run?.color ? { color: run.color } : {},
+      ...run?.underline ? { underline: true } : {},
+      ...run?.strike ? { strike: true } : {},
+      ...token.kind === "object" && run?.object ? { object: run.object } : {}
+    });
+    x += advancePx ?? widthPx;
+  }
+  return fragments;
+}
+function justify(fragments, width) {
+  const spaceIndices = fragments.map((f, i) => f.text === " " ? i : -1).filter((i) => i >= 0);
+  if (!spaceIndices.length || !fragments.length) return fragments;
+  const natural = fragments.at(-1).xPx + fragments.at(-1).widthPx;
+  const extra = Math.max(0, width - natural) / spaceIndices.length;
+  if (extra <= 0) return fragments;
+  let shift = 0;
+  return fragments.map((fragment, index) => {
+    const placedFragment = { ...fragment, xPx: fragment.xPx + shift };
+    if (spaceIndices.includes(index)) {
+      placedFragment.widthPx += extra;
+      shift += extra;
+    }
+    return placedFragment;
+  });
+}
+function alignFragments(fragments, width, isLastLine, effectiveAlign) {
+  if (!fragments.length) return fragments;
+  if (effectiveAlign === "justify" && !isLastLine) return justify(fragments, width);
+  const natural = fragments.at(-1).xPx + fragments.at(-1).widthPx;
+  const offset = effectiveAlign === "center" ? Math.max(0, width - natural) / 2 : effectiveAlign === "right" ? Math.max(0, width - natural) : 0;
+  return offset === 0 ? fragments : fragments.map((f) => ({ ...f, xPx: f.xPx + offset }));
+}
+
+// src/docx/layout/paragraph-layout.ts
+function layoutParagraph(paragraph, contentWidthPx, measurer, note, lineBox, startToken = 0) {
+  const { leftPx, rightPx, firstLineExtraPx: initialIndent } = resolveIndents(paragraph);
+  const firstLineExtraPx = startToken ? 0 : initialIndent;
+  const bodyWidth = Math.max(1, contentWidthPx - leftPx - rightPx);
+  const fonts = paragraph.runs.map(fontOf);
+  const { tokens, runOffsets } = tokenizeParagraph(paragraph);
+  const globalOffset = (token) => expectDefined(runOffsets[token.runIndex], "run offset index") + token.sourceStart;
+  const effectiveAlign = paragraph.align ?? (paragraph.direction === "rtl" ? "right" : "left");
+  const lines = [];
+  const pageBreakAfterLine = /* @__PURE__ */ new Set();
+  const columnBreakAfterLine = /* @__PURE__ */ new Set();
+  let widthOverflowNoted = false;
+  let placed = [];
+  let lineWidthPx = 0;
+  let tokenCursor = startToken;
+  let firstToken = startToken;
+  const boxes = [];
+  let runningY = 0;
+  const guessHeight = measurer.lineHeightOf(fonts[0] ?? fontOf({ }));
+  const boxFor = (lineIndex) => {
+    if (!boxes[lineIndex]) {
+      let gap = 0;
+      let box = lineBox?.(runningY, guessHeight);
+      for (let step = 0; box && box.gapBeforePx > 0 && step < 8; step++) {
+        gap += box.gapBeforePx;
+        box = lineBox(runningY + gap, guessHeight);
+      }
+      boxes[lineIndex] = {
+        leftInsetPx: box?.leftInsetPx ?? 0,
+        rightInsetPx: box?.rightInsetPx ?? 0,
+        gapBeforePx: gap
+      };
+    }
+    return expectDefined(boxes[lineIndex], "line box");
+  };
+  const availableWidth = (lineIndex) => {
+    const box = boxFor(lineIndex);
+    return Math.max(
+      1,
+      bodyWidth - (lineIndex === 0 ? firstLineExtraPx : 0) - box.leftInsetPx - box.rightInsetPx
+    );
+  };
+  const lineStart = (lineIndex) => leftPx + (lineIndex === 0 ? firstLineExtraPx : 0) + boxFor(lineIndex).leftInsetPx;
+  const tokenWidth = (token) => token.kind === "word" || token.kind === "space" ? runTextWidth(
+    token.text,
+    expectDefined(paragraph.runs[token.runIndex], "token run"),
+    measurer
+  ) : token.kind === "object" ? paragraph.runs[token.runIndex]?.object?.widthPx ?? 0 : 0;
+  const widths = tokens.map(tokenWidth);
+  const ends = /* @__PURE__ */ new Set(["tab", "lineBreak", "pageBreak", "columnBreak"]);
+  function segmentAfter(index) {
+    let followingPx = 0;
+    let beforeDecimalPx;
+    for (let next = index + 1; next < tokens.length; next++) {
+      const token = expectDefined(tokens[next], "token index");
+      if (ends.has(token.kind)) break;
+      if (beforeDecimalPx === void 0 && token.kind === "word" && /[.,]/.test(token.text)) {
+        const prefix = token.text.slice(0, token.text.search(/[.,]/));
+        beforeDecimalPx = followingPx + runTextWidth(
+          prefix,
+          expectDefined(paragraph.runs[token.runIndex], "decimal run"),
+          measurer
+        );
+      }
+      followingPx += widths[next] ?? 0;
+    }
+    return { followingPx, beforeDecimalPx: beforeDecimalPx ?? followingPx };
+  }
+  const hangingStopPx = firstLineExtraPx < 0 ? leftPx : void 0;
+  function flushLine(forceEmpty, forcedByBreak) {
+    if (!placed.length && !forceEmpty) return;
+    const lineIndex = lines.length;
+    const rendered = [...placed];
+    while (rendered.length && rendered.at(-1).token.kind === "space") rendered.pop();
+    const fragments = buildFragments(rendered, paragraph);
+    const [firstPlaced] = placed;
+    const start = firstPlaced ? globalOffset(firstPlaced.token) : 0;
+    const last = placed.at(-1)?.token;
+    const end = last ? globalOffset(last) + (last.kind === "word" || last.kind === "space" ? last.text.length : 1) : start;
+    const gapBeforePx = boxFor(lineIndex).gapBeforePx;
+    const { heightPx, baselinePx } = lineMetrics(placed, fonts, paragraph, measurer);
+    rendered.forEach(({ token }, index) => {
+      const extent2 = tokenExtent(token, paragraph, fonts, measurer);
+      const fragment = expectDefined(fragments[index], "fragment for rendered token");
+      fragment.topPx = baselinePx - extent2.above;
+      if (token.kind !== "object") fragment.boxHeightPx = extent2.ascent + extent2.descent;
+    });
+    lines.push({
+      yPx: 0,
+      heightPx,
+      baselinePx,
+      fragments,
+      sourceStart: start,
+      sourceEnd: end,
+      nextToken: tokenCursor,
+      firstToken,
+      ...gapBeforePx ? { gapBeforePx } : {}
+    });
+    runningY += gapBeforePx + heightPx;
+    if (forcedByBreak === "page") pageBreakAfterLine.add(lineIndex);
+    if (forcedByBreak === "column") columnBreakAfterLine.add(lineIndex);
+    placed = [];
+    lineWidthPx = 0;
+  }
+  for (const [tokenIndex, token] of tokens.entries()) {
+    if (tokenIndex < startToken) continue;
+    tokenCursor = tokenIndex + 1;
+    if (token.kind === "lineBreak") {
+      if (!placed.length) firstToken = tokenIndex;
+      flushLine(true, void 0);
+      continue;
+    }
+    if (token.kind === "pageBreak" || token.kind === "columnBreak") {
+      if (!placed.length) firstToken = tokenIndex;
+      flushLine(true, token.kind === "pageBreak" ? "page" : "column");
+      continue;
+    }
+    let leader;
+    let width = expectDefined(widths[tokenIndex], "token width");
+    const marker = paragraph.runs[token.runIndex]?.marker;
+    const markerFactor = marker && token.kind === "word" && tokenIndex === 0 ? marker.alignment === "right" ? 1 : marker.alignment === "center" ? 0.5 : 0 : 0;
+    const advance = width * (1 - markerFactor);
+    if (token.kind === "tab") {
+      const { followingPx, beforeDecimalPx } = segmentAfter(tokenIndex);
+      const tab = placeTab(
+        lineStart(lines.length) + lineWidthPx,
+        paragraph.tabStops ?? [],
+        hangingStopPx,
+        followingPx,
+        beforeDecimalPx
+      );
+      width = tab.widthPx;
+      leader = tab.leader === "none" ? void 0 : tab.leader;
+    }
+    const lineIndex = lines.length;
+    const limit = availableWidth(lineIndex);
+    const wouldFit = lineWidthPx + (token.kind === "tab" ? width : advance) <= limit || placed.every((placed2) => paragraph.runs[placed2.token.runIndex]?.synthetic);
+    if (!wouldFit && token.kind !== "space") {
+      tokenCursor = tokenIndex;
+      flushLine(false, void 0);
+      tokenCursor = tokenIndex + 1;
+      if (width > availableWidth(lines.length) && !widthOverflowNoted) {
+        widthOverflowNoted = true;
+        note(
+          "A word wider than its line/column was not split mid-word; it overflows the line box."
+        );
+      }
+    }
+    if (token.kind === "space" && placed.length === 0) continue;
+    if (!placed.length) firstToken = tokenIndex;
+    placed.push({
+      token,
+      widthPx: width,
+      ...leader ? { leader } : {},
+      ...markerFactor ? { xOffsetPx: -width * markerFactor, advancePx: advance } : {}
+    });
+    lineWidthPx += token.kind === "tab" ? width : advance;
+  }
+  flushLine(lines.length === 0, void 0);
+  const lastIndex = lines.length - 1;
+  for (const [index, line] of lines.entries()) {
+    lines[index] = {
+      ...line,
+      fragments: alignFragments(
+        line.fragments,
+        availableWidth(index),
+        index === lastIndex,
+        effectiveAlign
+      ).map((fragment) => ({ ...fragment, xPx: fragment.xPx + lineStart(index) }))
+    };
+  }
+  const borders = paragraph.borders;
+  const extent = (side) => borders?.[side] ? borders[side].widthPx + borders[side].spacePx : 0;
+  const insetTopPx = extent("top");
+  const insetBottomPx = extent("bottom");
+  let y = insetTopPx;
+  for (const line of lines) {
+    y += line.gapBeforePx ?? 0;
+    line.yPx = y;
+    y += line.heightPx;
+  }
+  const frame = borders || paragraph.shading ? {
+    leftPx: leftPx - extent("left"),
+    widthPx: bodyWidth + extent("left") + extent("right"),
+    ...borders ? { borders } : {},
+    ...paragraph.shading ? { shading: paragraph.shading } : {}
+  } : void 0;
+  return {
+    lines,
+    spacingBeforePx: twipsToPx(paragraph.spacingBeforeTwips ?? NO_TWIPS),
+    spacingAfterPx: twipsToPx(paragraph.spacingAfterTwips ?? NO_TWIPS),
+    contentHeightPx: y + insetBottomPx,
+    insetTopPx,
+    insetBottomPx,
+    ...frame ? { frame } : {},
+    pageBreakAfterLine,
+    columnBreakAfterLine
+  };
+}
+
+// src/docx/layout/keep-rules.ts
+function adjustForWidowOrphan(totalLines, fittingLines, widowControl) {
+  if (!widowControl) return fittingLines;
+  if (fittingLines <= 0 || fittingLines >= totalLines) return fittingLines;
+  const remaining = totalLines - fittingLines;
+  if (fittingLines === 1) return 0;
+  if (remaining === 1) return fittingLines - 1;
+  return fittingLines;
+}
+function suppressesSpacing(previous, current) {
+  if (!previous || !previous.styleId || previous.styleId !== current.styleId) return false;
+  return Boolean(previous.contextualSpacing) || Boolean(current.contextualSpacing);
+}
+function widowControlEnabled(value) {
+  return value !== false;
+}
+
+// src/docx/layout/table-layout.ts
+function stackParagraphs(paragraphs, widthPx, measurer, note, topPx = 0, startTokens) {
+  let y = topPx;
+  const boxes = [];
+  for (const paragraph of paragraphs) {
+    const layout = layoutParagraph(
+      paragraph,
+      widthPx,
+      measurer,
+      note,
+      void 0,
+      startTokens?.get(paragraph.id) ?? 0
+    );
+    y += layout.spacingBeforePx;
+    const top = y;
+    const lines = layout.lines.map((line) => ({ ...line, yPx: line.yPx + top }));
+    boxes.push({
+      kind: "paragraph",
+      blockId: paragraph.id,
+      yPx: top,
+      heightPx: layout.contentHeightPx,
+      lines
+    });
+    y += layout.contentHeightPx + layout.spacingAfterPx;
+  }
+  return { heightPx: y, boxes };
+}
+function layoutRow(row, tableWidthPx, measurer, note, remaining) {
+  const count = row.cells.length || 1;
+  let x = 0;
+  const geometry = [];
+  const laidOut = row.cells.map((cell) => {
+    const continuation = remaining?.[geometry.length];
+    const starts = continuation ? new Map(continuation.map((box) => [box.blockId, box.lines[0]?.firstToken ?? 0])) : void 0;
+    const widthPx = cell.widthPx ?? tableWidthPx / count;
+    const padding = cell.padding ?? { top: 0, right: 0, bottom: 0, left: 0 };
+    const content2 = stackParagraphs(
+      starts ? cell.paragraphs.filter((paragraph) => starts.has(paragraph.id)) : cell.paragraphs,
+      Math.max(1, widthPx - padding.left - padding.right),
+      measurer,
+      note,
+      padding.top,
+      starts
+    );
+    const heightPx2 = content2.heightPx + padding.bottom;
+    geometry.push({
+      xPx: cell.xPx ?? x,
+      widthPx,
+      paddingLeftPx: padding.left,
+      paddingRightPx: padding.right,
+      contentHeightPx: heightPx2,
+      ...cell.borders ? { borders: cell.borders } : {},
+      ...cell.shading ? { shading: cell.shading } : {},
+      ...cell.verticalAlign ? { verticalAlign: cell.verticalAlign } : {}
+    });
+    x = (cell.xPx ?? x) + widthPx;
+    return { heightPx: heightPx2, boxes: content2.boxes };
+  });
+  const content = Math.max(0, ...laidOut.map((cell) => cell.heightPx));
+  const heightPx = row.heightPx === void 0 ? content : row.heightRule === "exact" ? row.heightPx : Math.max(content, row.heightPx);
+  return { heightPx, cells: laidOut.map((cell) => cell.boxes), geometry };
+}
+function splitCellAtHeight(boxes, cutHeightPx) {
+  const before = [];
+  const after = [];
+  let afterOrigin = null;
+  let beforeHeightPx = 0;
+  for (const box of boxes) {
+    if (afterOrigin !== null) {
+      after.push({ ...box, yPx: box.yPx - afterOrigin });
+      continue;
+    }
+    if (box.yPx + box.heightPx <= cutHeightPx) {
+      before.push(box);
+      beforeHeightPx = box.yPx + box.heightPx;
+      continue;
+    }
+    if (box.yPx >= cutHeightPx) {
+      afterOrigin = box.yPx;
+      after.push({ ...box, yPx: 0 });
+      continue;
+    }
+    const beforeLines = box.lines.filter(
+      (line) => box.yPx + line.yPx + line.heightPx <= cutHeightPx
+    );
+    const afterLines = box.lines.slice(beforeLines.length);
+    if (beforeLines.length) {
+      const bottom = beforeLines.at(-1).yPx + beforeLines.at(-1).heightPx;
+      before.push({ ...box, heightPx: bottom, lines: beforeLines });
+      beforeHeightPx = box.yPx + bottom;
+    }
+    if (afterLines.length) {
+      const shift = expectDefined(afterLines[0], "first line after split").yPx;
+      afterOrigin = box.yPx + shift;
+      after.push({
+        ...box,
+        yPx: 0,
+        heightPx: afterLines.at(-1).yPx + afterLines.at(-1).heightPx - shift,
+        lines: afterLines.map((line) => ({ ...line, yPx: line.yPx - shift }))
+      });
+    } else {
+      afterOrigin = box.yPx + box.heightPx;
+    }
+  }
+  return { before, after, beforeHeightPx };
+}
+function splitRowAtHeight(row, cutHeightPx) {
+  const splits = row.cells.map((cell) => splitCellAtHeight(cell, cutHeightPx));
+  const anyAfter = splits.some((split) => split.after.length > 0);
+  const before = {
+    heightPx: Math.max(0, ...splits.map((split) => split.beforeHeightPx)),
+    cells: splits.map((split) => split.before),
+    geometry: row.geometry
+  };
+  if (!anyAfter) return { before, after: null };
+  const after = {
+    heightPx: Math.max(
+      0,
+      ...splits.map(
+        (split) => split.after.reduce((max, box) => Math.max(max, box.yPx + box.heightPx), 0)
+      )
+    ),
+    cells: splits.map((split) => split.after),
+    geometry: row.geometry
+  };
+  return { before, after };
+}
+
+// src/docx/layout/page-cursor.ts
+var FOOTNOTE_SEPARATOR_PX = 12;
+var PageCursor = class {
+  pages;
+  equalColumnWidthPx;
+  columnHeightPx;
+  geometry;
+  columns;
+  columnIndex = 0;
+  yPx = 0;
+  sectionIndex;
+  pageInSection = 0;
+  /** Height taken by footnotes (and their separator) at the bottom of the current page. */
+  reservedPx = 0;
+  /** Footnotes of the paragraph about to be placed; they join the page its first box lands on. */
+  pending;
+  constructor(pages, geometry, columns, sectionIndex = 0) {
+    this.sectionIndex = sectionIndex;
+    this.pages = pages;
+    this.geometry = geometry;
+    this.columns = columns;
+    const contentWidth = geometry.widthPx - geometry.marginLeftPx - geometry.marginRightPx;
+    this.equalColumnWidthPx = Math.max(
+      1,
+      (contentWidth - columns.gapPx * (columns.count - 1)) / columns.count
+    );
+    this.columnHeightPx = Math.max(
+      1,
+      geometry.heightPx - geometry.marginTopPx - geometry.marginBottomPx
+    );
+    this.pushPage();
+  }
+  pushPage() {
+    const columnBoxes = [];
+    let xPx = 0;
+    for (let i = 0; i < this.columns.count; i++) {
+      const explicit = this.columns.widths?.[i];
+      const widthPx = Math.max(1, explicit?.widthPx ?? this.equalColumnWidthPx);
+      columnBoxes.push({
+        xPx,
+        widthPx,
+        blocks: []
+      });
+      xPx += widthPx + (explicit?.gapPx ?? this.columns.gapPx);
+    }
+    this.pages.push({
+      index: this.pages.length,
+      sectionIndex: this.sectionIndex,
+      pageInSection: this.pageInSection++,
+      widthPx: this.geometry.widthPx,
+      heightPx: this.geometry.heightPx,
+      marginTopPx: this.geometry.marginTopPx,
+      marginRightPx: this.geometry.marginRightPx,
+      marginBottomPx: this.geometry.marginBottomPx,
+      marginLeftPx: this.geometry.marginLeftPx,
+      columns: columnBoxes,
+      ...this.columns.separator ? { columnSeparator: true } : {}
+    });
+    this.columnIndex = 0;
+    this.yPx = 0;
+    this.reservedPx = 0;
+  }
+  get page() {
+    return this.pages.at(-1);
+  }
+  get column() {
+    return expectDefined(this.page.columns[this.columnIndex], "current page column");
+  }
+  get columnWidthPx() {
+    return this.column.widthPx;
+  }
+  get y() {
+    return this.yPx;
+  }
+  get atColumnTop() {
+    return this.yPx === 0;
+  }
+  remainingHeightPx() {
+    return this.columnHeightPx - this.yPx - this.reservedPx - this.pendingHeightPx();
+  }
+  pendingHeightPx() {
+    if (!this.pending) return 0;
+    return this.pending.heightPx + (this.page.footnotes?.length ? 0 : FOOTNOTE_SEPARATOR_PX);
+  }
+  /**
+   * Reserves room for a paragraph's footnotes on whichever page its first box is placed, so the
+   * notes print on the same page as their reference, as Word does.
+   */
+  holdFootnotes(blockId, notes) {
+    const heightPx = notes.reduce((sum, note) => sum + note.heightPx, 0);
+    this.pending = notes.length ? { blockId, notes, heightPx } : void 0;
+  }
+  newPage() {
+    this.pushPage();
+  }
+  /** Advances to the next column, or a new page when the section has no more columns. */
+  newColumn() {
+    if (this.columnIndex + 1 < this.columns.count) {
+      this.columnIndex++;
+      this.yPx = 0;
+    } else {
+      this.pushPage();
+    }
+  }
+  /** Places a box at the current fill position (sets its `yPx`) and advances by `advancePx`. */
+  place(box, advancePx) {
+    box.yPx = this.yPx;
+    this.column.blocks.push(box);
+    this.yPx += advancePx;
+    if (this.pending && this.pending.blockId === box.blockId) {
+      this.reservedPx += this.pendingHeightPx();
+      const page = this.page;
+      let top = page.footnotes?.reduce((sum, note) => sum + note.heightPx, 0) ?? 0;
+      for (const note of this.pending.notes) {
+        (page.footnotes ??= []).push({ ...note, yPx: top });
+        top += note.heightPx;
+      }
+      this.pending = void 0;
+    }
+  }
+};
+
+// src/docx/layout/flow-paragraph.ts
+function placeParagraph(cursor, placement, note) {
+  const { paragraph, spacingBeforePx, requiredTogetherPx, reflow } = placement;
+  let layout = placement.layout;
+  let width = cursor.columnWidthPx;
+  if (paragraph.pageBreakBefore && !cursor.atColumnTop) cursor.newPage();
+  if (requiredTogetherPx > 0 && requiredTogetherPx <= cursor.columnHeightPx && requiredTogetherPx > cursor.remainingHeightPx() && !cursor.atColumnTop) {
+    cursor.newColumn();
+  }
+  const widow = widowControlEnabled(paragraph.widowControl);
+  let lineCursor = 0;
+  let nextToken = 0;
+  let firstSegment = true;
+  const reflowIfNeeded = () => {
+    if (!reflow || cursor.columnWidthPx === width) return;
+    layout = reflow(nextToken);
+    lineCursor = 0;
+    width = cursor.columnWidthPx;
+  };
+  reflowIfNeeded();
+  if (!layout.lines.length) {
+    cursor.place(
+      { kind: "paragraph", blockId: paragraph.id, yPx: 0, heightPx: 0, lines: [] },
+      spacingBeforePx + layout.spacingAfterPx
+    );
+    return;
+  }
+  while (lineCursor < layout.lines.length) {
+    reflowIfNeeded();
+    const budget = cursor.remainingHeightPx() - (firstSegment ? spacingBeforePx : 0);
+    let cumulative = 0;
+    let end = lineCursor;
+    let forced;
+    for (let i = lineCursor; i < layout.lines.length; i++) {
+      const line = expectDefined(layout.lines[i], "paragraph line index");
+      const gap = i === lineCursor && !firstSegment ? 0 : line.gapBeforePx ?? 0;
+      const height = line.heightPx + gap;
+      if (cumulative + height > budget && (end > lineCursor || !cursor.atColumnTop)) break;
+      cumulative += height;
+      end = i + 1;
+      if (layout.pageBreakAfterLine.has(i)) {
+        forced = "page";
+        break;
+      }
+      if (layout.columnBreakAfterLine.has(i)) {
+        forced = "column";
+        break;
+      }
+    }
+    let placedCount = end - lineCursor;
+    if (!forced && end < layout.lines.length)
+      placedCount = adjustForWidowOrphan(layout.lines.length - lineCursor, placedCount, widow);
+    if (placedCount === 0) {
+      if (!cursor.atColumnTop) {
+        cursor.newColumn();
+        continue;
+      }
+      note(
+        "A paragraph line was taller than an empty page/column and was placed without splitting."
+      );
+      placedCount = Math.max(1, end - lineCursor);
+    }
+    const first = expectDefined(layout.lines[lineCursor], "first line of paragraph segment");
+    const origin = first.yPx - (firstSegment ? (first.gapBeforePx ?? 0) + layout.insetTopPx : 0);
+    const segmentLines = layout.lines.slice(lineCursor, lineCursor + placedCount).map((line) => ({ ...line, yPx: line.yPx - origin }));
+    const isFinal = lineCursor + placedCount >= layout.lines.length;
+    const lastLine = segmentLines.at(-1);
+    const isLastSegment = lineCursor + placedCount >= layout.lines.length;
+    const segmentHeight = (lastLine ? lastLine.yPx + lastLine.heightPx : 0) + (isLastSegment ? layout.insetBottomPx : 0);
+    const box = {
+      kind: "paragraph",
+      blockId: paragraph.id,
+      yPx: 0,
+      heightPx: segmentHeight,
+      lines: segmentLines,
+      ...layout.frame ? { frame: layout.frame } : {}
+    };
+    const advance = (firstSegment ? spacingBeforePx : 0) + segmentHeight + (isFinal ? layout.spacingAfterPx : 0);
+    cursor.place(box, advance);
+    nextToken = layout.lines[lineCursor + placedCount - 1]?.nextToken ?? nextToken;
+    lineCursor += placedCount;
+    firstSegment = false;
+    if (forced === "page") cursor.newPage();
+    else if (forced === "column") cursor.newColumn();
+    else if (lineCursor < layout.lines.length) cursor.newColumn();
+  }
+}
+
+// src/docx/layout/flow-table.ts
+function placeTable(cursor, table, measurer, note) {
+  const headerRows = table.rows.filter((row) => row.isHeader);
+  const xPosition = () => {
+    const width = table.widthPx ?? cursor.columnWidthPx;
+    return table.alignment === "center" ? Math.max(0, (cursor.columnWidthPx - width) / 2) : table.alignment === "right" ? Math.max(0, cursor.columnWidthPx - width) : table.indentPx ?? 0;
+  };
+  let fragmentRows = [];
+  let fragmentHeight = 0;
+  const toRowBox = (layout, repeated) => {
+    const box = {
+      yPx: fragmentHeight,
+      heightPx: layout.heightPx,
+      repeated,
+      cells: layout.cells,
+      geometry: layout.geometry
+    };
+    fragmentHeight += layout.heightPx;
+    return box;
+  };
+  function flushFragment() {
+    if (!fragmentRows.length) return;
+    const box = {
+      kind: "table",
+      blockId: table.id,
+      ...xPosition() ? { xPx: xPosition() } : {},
+      yPx: 0,
+      heightPx: fragmentHeight,
+      rows: fragmentRows
+    };
+    cursor.place(box, fragmentHeight);
+    fragmentRows = [];
+    fragmentHeight = 0;
+  }
+  function startNewFragment() {
+    flushFragment();
+    cursor.newColumn();
+    for (const header of headerRows)
+      fragmentRows.push(toRowBox(layoutRow(header, cursor.columnWidthPx, measurer, note), true));
+  }
+  function placeRow(row, initial, cantSplit) {
+    let remainingRow = initial;
+    while (remainingRow) {
+      const remaining = cursor.remainingHeightPx() - fragmentHeight;
+      if (remainingRow.heightPx <= remaining) {
+        fragmentRows.push(toRowBox(remainingRow, false));
+        remainingRow = null;
+        continue;
+      }
+      if (cantSplit) {
+        if (fragmentRows.length || !cursor.atColumnTop) {
+          startNewFragment();
+          remainingRow = layoutRow(row, cursor.columnWidthPx, measurer, note);
+        }
+        const freshRemaining = cursor.remainingHeightPx() - fragmentHeight;
+        if (remainingRow.heightPx > freshRemaining)
+          note('A table row marked "keep row together" is taller than an empty page/column.');
+        fragmentRows.push(toRowBox(remainingRow, false));
+        remainingRow = null;
+        continue;
+      }
+      const { before, after } = splitRowAtHeight(remainingRow, Math.max(0, remaining));
+      const previousWidth = cursor.columnWidthPx;
+      if (before.cells.some((cell) => cell.length)) fragmentRows.push(toRowBox(before, false));
+      startNewFragment();
+      remainingRow = after && previousWidth !== cursor.columnWidthPx ? layoutRow(
+        { ...row, heightPx: 0, heightRule: "atLeast" },
+        cursor.columnWidthPx,
+        measurer,
+        note,
+        after.cells
+      ) : after;
+    }
+  }
+  for (const row of table.rows) {
+    const layout = layoutRow(row, cursor.columnWidthPx, measurer, note);
+    placeRow(row, layout, Boolean(row.cantSplit) || row.isHeader === true);
+  }
+  flushFragment();
+}
+
+// src/docx/layout/wrap.ts
+var SIDE_DISTANCE_PX = 12;
+var MIN_SIDE_WIDTH_PX = 48;
+function wrapExclusions(pages) {
+  const exclusions = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const list = (page.floats ?? []).filter((float) => float.wrap && float.wrap !== "none").map((float) => ({
+      xPx: float.xPx - SIDE_DISTANCE_PX,
+      yPx: float.yPx,
+      widthPx: float.widthPx + SIDE_DISTANCE_PX * 2,
+      heightPx: float.heightPx,
+      topAndBottom: float.wrap === "topAndBottom"
+    }));
+    if (list.length) exclusions.set(page.index, list);
+  }
+  return exclusions;
+}
+function sameExclusions(a, b) {
+  const key = (map) => JSON.stringify(
+    [...map].map(([page, list]) => [
+      page,
+      list.map((item) => [Math.round(item.xPx), Math.round(item.yPx), item.topAndBottom])
+    ])
+  );
+  return key(a) === key(b);
+}
+function lineBoxesFor(exclusions, topPx, columnLeftPx, columnWidthPx) {
+  return (yPx, heightPx) => {
+    const top = topPx + yPx;
+    let leftInsetPx = 0;
+    let rightInsetPx = 0;
+    let gapBeforePx = 0;
+    for (const exclusion of exclusions) {
+      const overlapsLine = exclusion.yPx < top + heightPx && exclusion.yPx + exclusion.heightPx > top;
+      const start = exclusion.xPx - columnLeftPx;
+      const end = start + exclusion.widthPx;
+      if (!overlapsLine || end <= 0 || start >= columnWidthPx) continue;
+      const left = Math.max(0, start);
+      const right = Math.max(0, columnWidthPx - end);
+      if (exclusion.topAndBottom || Math.max(left, right) < MIN_SIDE_WIDTH_PX) {
+        gapBeforePx = Math.max(gapBeforePx, exclusion.yPx + exclusion.heightPx - top);
+        continue;
+      }
+      if (left >= right) rightInsetPx = Math.max(rightInsetPx, columnWidthPx - start);
+      else leftInsetPx = Math.max(leftInsetPx, end);
+    }
+    return { leftInsetPx, rightInsetPx, gapBeforePx };
+  };
+}
+
+// src/docx/layout/page-flow.ts
+var CONTINUOUS_BREAK_NOTE = "Continuous section breaks are rendered as page breaks; changing page size, margins or column count without starting a new page is not modeled.";
+var SectionFlow = class {
+  constructor(section, pages, measurer, note, sectionIndex = 0, exclusions) {
+    this.exclusions = exclusions;
+    this.blocks = section.blocks;
+    this.measurer = measurer;
+    this.note = note;
+    this.cursor = new PageCursor(
+      pages,
+      section.page,
+      section.columns ?? { count: 1, gapPx: 0 },
+      sectionIndex
+    );
+    if (section.break === "continuous") note(CONTINUOUS_BREAK_NOTE);
+  }
+  exclusions;
+  cursor;
+  blocks;
+  measurer;
+  note;
+  paragraphCache = /* @__PURE__ */ new Map();
+  firstRowHeightCache = /* @__PURE__ */ new Map();
+  paragraphLayout(index) {
+    const key = `${index}:${this.cursor.columnWidthPx}`;
+    let cached = this.paragraphCache.get(key);
+    if (!cached) {
+      cached = layoutParagraph(
+        this.blocks[index],
+        this.cursor.columnWidthPx,
+        this.measurer,
+        this.note
+      );
+      this.paragraphCache.set(key, cached);
+    }
+    return cached;
+  }
+  firstRowHeight(index) {
+    const key = `${index}:${this.cursor.columnWidthPx}`;
+    let cached = this.firstRowHeightCache.get(key);
+    if (cached === void 0) {
+      const table = this.blocks[index];
+      const [firstRow] = table.rows;
+      cached = firstRow ? layoutRow(firstRow, this.cursor.columnWidthPx, this.measurer, this.note).heightPx : 0;
+      this.firstRowHeightCache.set(key, cached);
+    }
+    return cached;
+  }
+  spacingBeforeFor(index) {
+    const block = this.blocks[index];
+    if (block?.kind !== "paragraph") return 0;
+    const layout = this.paragraphLayout(index);
+    const previous = index > 0 ? this.blocks[index - 1] : void 0;
+    if (previous?.kind === "paragraph" && suppressesSpacing(previous, block)) return 0;
+    return layout.spacingBeforePx;
+  }
+  /** Minimum height that must fit before `index` may start, walking a `keepNext` chain. */
+  requiredKeepHeight(index, depth = 0) {
+    if (index >= this.blocks.length || depth > 64) return 0;
+    const block = expectDefined(this.blocks[index], "keep-chain block index");
+    if (block.kind === "table") return this.firstRowHeight(index);
+    const layout = this.paragraphLayout(index);
+    const before = this.spacingBeforeFor(index);
+    const own = before + (block.keepLines ? layout.contentHeightPx + layout.spacingAfterPx : layout.lines[0]?.heightPx ?? 0);
+    return block.keepNext ? own + this.requiredKeepHeight(index + 1, depth + 1) : own;
+  }
+  /**
+   * The paragraph laid out around wrapped pictures on the current page, when any of them reaches
+   * the paragraph's lines; lines continuing onto a later page keep these widths.
+   */
+  wrappedLayout(index, spacingBeforePx) {
+    const page = this.cursor.page;
+    const exclusions = this.exclusions?.get(page.index);
+    if (!exclusions) return void 0;
+    const plain = this.paragraphLayout(index);
+    const topPx = page.marginTopPx + this.cursor.y + spacingBeforePx;
+    const bottomPx = topPx + plain.contentHeightPx;
+    if (!exclusions.some((item) => item.yPx < bottomPx && item.yPx + item.heightPx > topPx))
+      return void 0;
+    return layoutParagraph(
+      this.blocks[index],
+      this.cursor.columnWidthPx,
+      this.measurer,
+      this.note,
+      lineBoxesFor(
+        exclusions,
+        topPx,
+        page.marginLeftPx + this.cursor.column.xPx,
+        this.cursor.columnWidthPx
+      )
+    );
+  }
+  run() {
+    for (let index = 0; index < this.blocks.length; index++) {
+      const block = expectDefined(this.blocks[index], "flow block index");
+      if (block.kind === "table") {
+        placeTable(this.cursor, block, this.measurer, this.note);
+        continue;
+      }
+      const spacingBeforePx = this.spacingBeforeFor(index);
+      const layout = this.wrappedLayout(index, spacingBeforePx) ?? this.paragraphLayout(index);
+      if (block.footnotes?.length)
+        this.cursor.holdFootnotes(
+          block.id,
+          block.footnotes.map((note) => {
+            const stacked = stackParagraphs(
+              note.paragraphs,
+              this.cursor.columnWidthPx,
+              this.measurer,
+              this.note
+            );
+            return { id: note.id, yPx: 0, heightPx: stacked.heightPx, paragraphs: stacked.boxes };
+          })
+        );
+      const requiredTogetherPx = block.keepNext ? this.requiredKeepHeight(index) : block.keepLines ? spacingBeforePx + layout.contentHeightPx + layout.spacingAfterPx : 0;
+      placeParagraph(
+        this.cursor,
+        {
+          paragraph: block,
+          layout,
+          spacingBeforePx,
+          requiredTogetherPx,
+          reflow: (token) => layoutParagraph(
+            block,
+            this.cursor.columnWidthPx,
+            this.measurer,
+            this.note,
+            void 0,
+            token
+          )
+        },
+        this.note
+      );
+    }
+  }
+};
+function insertParityBlank(pages, section) {
+  const previous = pages.at(-1);
+  if (!previous || section.break !== "evenPage" && section.break !== "oddPage") return;
+  const nextNumber = pages.length + 1;
+  const wanted = section.break === "evenPage" ? 0 : 1;
+  if (nextNumber % 2 === wanted) return;
+  pages.push({
+    ...previous,
+    index: pages.length,
+    pageInSection: previous.pageInSection + 1,
+    columns: previous.columns.map((column) => ({ ...column, blocks: [] }))
+  });
+}
+function alignVertically(pages, section, note) {
+  const align = section.verticalAlign;
+  if (!align || align === "top") return;
+  if (align === "both") {
+    note("Vertically justified sections are laid out top-aligned.");
+    return;
+  }
+  for (const page of pages) {
+    const available = page.heightPx - page.marginTopPx - page.marginBottomPx;
+    const used = Math.max(
+      0,
+      ...page.columns.flatMap((column) => column.blocks.map((block) => block.yPx + block.heightPx))
+    );
+    const shift = (available - used) / (align === "center" ? 2 : 1);
+    if (shift <= 0) continue;
+    for (const column of page.columns) for (const block of column.blocks) block.yPx += shift;
+  }
+}
+function layoutSections(input, measurer, exclusions) {
+  const approximations = /* @__PURE__ */ new Set();
+  const note = (message) => approximations.add(message);
+  const pages = [];
+  input.sections.forEach((section, index) => {
+    insertParityBlank(pages, section);
+    const first = pages.length;
+    new SectionFlow(section, pages, measurer, note, index, exclusions).run();
+    alignVertically(pages.slice(first), section, note);
+  });
+  return { pages, approximations: [...approximations] };
+}
+
+// src/docx/layout/adapt-floats.ts
+function paragraphFloats(paragraph) {
+  const floats = [];
+  for (const run of paragraph.runs) {
+    const image = run.image;
+    if (!image?.anchored || !image.partName) continue;
+    const placement = image.placement;
+    floats.push({
+      partName: image.partName,
+      contentType: image.contentType,
+      widthPx: image.widthPx,
+      heightPx: image.heightPx,
+      ...placement?.relativeFrom ? { relativeFromH: placement.relativeFrom } : {},
+      ...placement?.align ? { alignH: placement.align } : {},
+      ...placement?.offsetXPx !== void 0 ? { offsetXPx: placement.offsetXPx } : {},
+      ...placement?.relativeFromV ? { relativeFromV: placement.relativeFromV } : {},
+      ...placement?.alignV ? { alignV: placement.alignV } : {},
+      ...placement?.offsetYPx !== void 0 ? { offsetYPx: placement.offsetYPx } : {},
+      ...placement?.behindText ? { behindText: true } : {},
+      ...placement?.wrap ? { wrap: placement.wrap } : {}
+    });
+  }
+  return floats;
+}
+function floatsOf(paragraph) {
+  const floats = paragraphFloats(paragraph);
+  return floats.length ? { floats } : {};
+}
+
+// src/docx/layout/adapt-table.ts
+var twipsToPx2 = twipsToPixels;
+var DEFAULT_PADDING_TWIPS = {
+  top: twips(0),
+  right: twips(108),
+  bottom: twips(0),
+  left: twips(108)
+};
+function cssHex(value) {
+  const hex = value?.replace(/^#/, "");
+  return hex && /^[0-9a-f]{6}$/i.test(hex) ? `#${hex}` : void 0;
+}
+function border(side, theme) {
+  if (!side?.style || side.style === "none" || side.style === "nil") return void 0;
+  const style = side.style.startsWith("double") ? "double" : /dot/i.test(side.style) ? "dotted" : /dash/i.test(side.style) ? "dashed" : "solid";
+  const themed = side.themeColor && theme ? resolveThemeColorReference({ token: side.themeColor }, theme) : void 0;
+  const hex = cssHex(side.color);
+  const widthPx = Math.max(
+    style === "double" ? 3 : 1,
+    (side.sizeEighthPoints ?? 4) / 8 * 96 / 72
+  );
+  return { widthPx, style, color: themed ?? hex ?? "#000000" };
+}
+function rowLayout(props) {
+  if (!props) return {};
+  return {
+    ...props.heightTwips ? { heightPx: twipsToPx2(props.heightTwips), heightRule: props.heightRule ?? "atLeast" } : {},
+    ...props.cantSplit ? { cantSplit: true } : {},
+    ...props.header ? { isHeader: true } : {}
+  };
+}
+function adaptTable(table, model, adaptParagraph) {
+  const grid = table.grid?.map(twipsToPx2);
+  const columnCount = grid?.length ?? Math.max(1, ...table.rows.map((row) => row.length));
+  const gridWidth = (start, span) => grid ? grid.slice(start, start + span).reduce((sum, width) => sum + width, 0) : void 0;
+  const gridIndexes = table.rows.map((row) => {
+    let index = 0;
+    return row.map((cell) => {
+      const start = index;
+      index += cell.gridSpan ?? 1;
+      return start;
+    });
+  });
+  const cellAt = (rowIndex, gridIndex) => {
+    const position = gridIndexes[rowIndex]?.indexOf(gridIndex) ?? -1;
+    return position >= 0 ? table.rows[rowIndex]?.[position] : void 0;
+  };
+  return {
+    kind: "table",
+    id: table.id,
+    ...grid ? { widthPx: grid.reduce((sum, width) => sum + width, 0) } : {},
+    ...table.indentTwips ? { indentPx: twipsToPx2(table.indentTwips) } : {},
+    ...table.alignment ? { alignment: table.alignment } : {},
+    rows: table.rows.map((row, rowIndex) => ({
+      ...rowLayout(table.rowProperties?.[rowIndex]),
+      cells: row.map((cell, cellIndex) => {
+        const start = expectDefined(gridIndexes[rowIndex]?.[cellIndex], "table cell grid index");
+        const span = cell.gridSpan ?? 1;
+        const visuals = resolveCellVisuals(
+          table,
+          cell,
+          {
+            row: rowIndex,
+            lastRow: rowIndex,
+            column: start,
+            lastColumn: start + span - 1,
+            rowCount: table.rows.length,
+            columnCount
+          },
+          model.tableStyles
+        );
+        const borders = {};
+        for (const side of ["top", "right", "bottom", "left"]) {
+          const resolved = border(visuals.borders?.[side], model.theme);
+          if (resolved) borders[side] = resolved;
+        }
+        if (cell.verticalMerge === "continue") delete borders.top;
+        if (cellAt(rowIndex + 1, start)?.verticalMerge === "continue") delete borders.bottom;
+        const margins = { ...DEFAULT_PADDING_TWIPS, ...table.cellMargins, ...cell.margins };
+        const padding = {
+          top: twipsToPx2(margins.top),
+          right: twipsToPx2(margins.right),
+          bottom: twipsToPx2(margins.bottom),
+          left: twipsToPx2(margins.left)
+        };
+        const width = gridWidth(start, span) ?? (cell.widthTwips ? twipsToPx2(cell.widthTwips) : void 0);
+        const xPx = grid ? gridWidth(0, start) : void 0;
+        const fill = cssHex(visuals.shadingFill);
+        return {
+          paragraphs: cell.paragraphs.map(adaptParagraph),
+          ...width !== void 0 ? { widthPx: width } : {},
+          ...grid && xPx !== void 0 ? { xPx } : {},
+          padding,
+          ...Object.keys(borders).length ? { borders } : {},
+          ...fill ? { shading: fill } : {},
+          // `both` (vertically justified) has no layout support yet and renders as top, as before.
+          ...cell.verticalAlign ? { verticalAlign: cell.verticalAlign === "both" ? "top" : cell.verticalAlign } : {}
+        };
+      })
+    }))
+  };
+}
+
+// src/docx/layout/adapt-drop-cap.ts
+function foldDropCaps(source, blocks) {
+  const folded = /* @__PURE__ */ new Set();
+  source.forEach((block, index) => {
+    if (block.type !== "paragraph" || !block.dropCap) return;
+    const cap = blocks[index];
+    const next = blocks[index + 1];
+    if (cap?.kind !== "paragraph" || next?.kind !== "paragraph") return;
+    next.runs = [...cap.runs, ...next.runs];
+    folded.add(cap);
+  });
+  return folded;
+}
+
+// src/docx/layout/adapt-paragraph-box.ts
+var pointsToPx = (points) => points * 96 / 72;
+function paragraphBox(formatting, theme) {
+  const borders = {};
+  let betweenBorder;
+  for (const side of ["top", "bottom", "left", "right", "between"]) {
+    const source = formatting.borders?.[side];
+    const line = border(source, theme);
+    if (!line) continue;
+    const resolved = { ...line, spacePx: pointsToPx(source?.spacePoints ?? 0) };
+    if (side === "between") betweenBorder = resolved;
+    else borders[side] = resolved;
+  }
+  const shading = cssHex(formatting.shadingFill);
+  return {
+    ...Object.keys(borders).length ? { borders } : {},
+    ...shading ? { shading } : {},
+    ...betweenBorder ? { betweenBorder } : {}
+  };
+}
+function groupParagraphBorders(blocks, between) {
+  const keys = blocks.map(
+    (block) => block.kind === "paragraph" && block.borders ? JSON.stringify(block.borders) : void 0
+  );
+  blocks.forEach((block, index) => {
+    if (block.kind !== "paragraph" || !block.borders) return;
+    const sameAsPrevious = keys[index - 1] === keys[index];
+    const sameAsNext = keys[index + 1] === keys[index];
+    if (!sameAsPrevious && !sameAsNext) return;
+    const borders = { ...block.borders };
+    if (sameAsNext) delete borders.bottom;
+    if (sameAsPrevious) {
+      const line = between.get(block);
+      if (line) borders.top = line;
+      else delete borders.top;
+    }
+    block.borders = borders;
+  });
+}
+
+// src/docx/layout/adapt-notes.ts
+function noteLabels(model) {
+  const order = {
+    footnote: numberNotesInOrder(model.blocks, "footnote"),
+    endnote: numberNotesInOrder(model.blocks, "endnote")
+  };
+  return (kind, id) => {
+    const number = order[kind].get(id);
+    if (number === void 0) return "";
+    return formatNoteNumber(
+      number,
+      kind === "footnote" ? model.footnoteNumFmt ?? "decimal" : model.endnoteNumFmt ?? "lowerRoman"
+    );
+  };
+}
+function adaptNote(note, label, adaptParagraph) {
+  return note.blocks.flatMap(
+    (block) => block.type === "paragraph" ? [adaptParagraph(block, label)] : block.rows.flatMap(
+      (row) => row.flatMap(
+        (cell) => cell.paragraphs.map((paragraph) => adaptParagraph(paragraph, label))
+      )
+    )
+  );
+}
+function paragraphFootnotes(paragraph, model, label, adaptParagraph) {
+  const notes = [];
+  for (const run of paragraph.runs) {
+    const reference = run.noteReference;
+    if (reference?.kind !== "footnote") continue;
+    const note = model.footnotes?.find((item) => item.id === reference.id);
+    if (note)
+      notes.push({
+        id: note.id,
+        paragraphs: adaptNote(note, label("footnote", note.id), adaptParagraph)
+      });
+  }
+  return notes;
+}
+function endnoteParagraphs(model, label, adaptParagraph) {
+  const order = numberNotesInOrder(model.blocks, "endnote");
+  return [...order.keys()].flatMap((id) => {
+    const note = model.endnotes?.find((item) => item.id === id);
+    return note ? adaptNote(note, label("endnote", id), adaptParagraph) : [];
+  });
+}
+
+// src/docx/layout/adapter.ts
+var TABLE_ROW_NOTE = "Table rows with an exact height clip content that does not fit; text in them is not shrunk.";
+var VERTICAL_MERGE_NOTE = "Vertically merged table cells are drawn as one cell, but their text stays in the first row of the merge.";
+var DROP_CAP_NOTE = "Drop caps are laid out as an enlarged first letter (a raised cap), not as a dropped cap.";
+var TEXT_BOX_NOTE = "Text boxes are shown on the editing surface but are not drawn in Print Layout.";
+var NEXT_COLUMN_NOTE = 'A "next column" section break is laid out as a continuous section break.';
+var twipsToPx3 = twipsToPixels;
+function sectionBreak(type, note) {
+  if (type === "nextColumn") {
+    note(NEXT_COLUMN_NOTE);
+    return "continuous";
+  }
+  return type;
+}
+function adaptDocumentModel(model, note = () => {
+}) {
+  const catalog = model.paragraphStyles;
+  const noted = /* @__PURE__ */ new Set();
+  const reportOnce = (message) => {
+    if (!noted.has(message)) {
+      noted.add(message);
+      note(message);
+    }
+  };
+  const now = /* @__PURE__ */ new Date();
+  const theme = model.theme;
+  function effective(run, paragraphStyleId) {
+    const formatting = resolveRunFormatting(run, {
+      runCatalog: model.characterStyles,
+      paragraphCatalog: catalog,
+      paragraphStyleId
+    });
+    const role = formatting.fontTheme?.ascii ?? formatting.fontTheme?.hAnsi;
+    const family = formatting.fontFamily ?? (role && theme ? theme.fonts[role]?.latin : void 0);
+    const color = formatting.color ?? (formatting.colorTheme && theme ? resolveThemeColorReference(formatting.colorTheme, theme) : void 0);
+    return { formatting, family, color };
+  }
+  const noteLabel = noteLabels(model);
+  function adaptRun(run, paragraphStyleId, markLabel) {
+    const { formatting, family, color } = effective(run, paragraphStyleId);
+    const name = run.field ? fieldName(run.field.instr) : "";
+    const noteText = run.noteReference ? noteLabel(run.noteReference.kind, run.noteReference.id) : run.noteMark ? markLabel ?? "" : void 0;
+    const text = noteText ?? (run.field && (name === "DATE" || name === "TIME") ? dateFieldResult(name, run.field.instr, now) : run.text);
+    const script = formatting.verticalAlign === "superscript" || noteText !== void 0 && formatting.verticalAlign === void 0 ? "super" : formatting.verticalAlign === "subscript" ? "sub" : void 0;
+    const image = run.image;
+    if (image?.unsupported === "Text box") reportOnce(TEXT_BOX_NOTE);
+    const object = image && !image.anchored ? {
+      partName: image.partName,
+      contentType: image.contentType,
+      widthPx: image.widthPx,
+      heightPx: image.heightPx
+    } : void 0;
+    return {
+      // Hidden text (`w:vanish`) takes no space when printed, as in Word by default.
+      text: image || formatting.vanish ? "" : formatting.caps ? text.toUpperCase() : text,
+      ...object ? { object } : {},
+      ...definedProps({
+        bold: formatting.bold,
+        italic: formatting.italic,
+        fontFamily: family,
+        fontSizePt: formatting.fontSize,
+        textScalePercent: formatting.textScalePercent,
+        ligatures: formatting.ligatures,
+        characterSpacingPx: formatting.characterSpacingTwips === void 0 ? void 0 : formatting.characterSpacingTwips / 15,
+        kerningThresholdPt: formatting.kerningHalfPoints === void 0 ? void 0 : formatting.kerningHalfPoints / 2,
+        positionPx: formatting.positionHalfPoints === void 0 ? void 0 : formatting.positionHalfPoints * 2 / 3
+      }),
+      ...color && /^#[0-9a-f]{6}$/i.test(color) ? { color } : {},
+      ...formatting.underline ? { underline: true } : {},
+      ...formatting.strike || formatting.doubleStrike ? { strike: true } : {},
+      ...run.break ? { breakAfter: run.break } : {},
+      ...script ? { script } : {}
+    };
+  }
+  const labels = computeListLabels(model);
+  function labelRun(paragraph, label) {
+    const first = adaptRun(paragraph.runs[0] ?? { text: "" }, paragraph.style);
+    const marker = label.markerFormat;
+    const suffix = label.suffix === "tab" ? "	" : label.suffix === "space" ? " " : "";
+    return {
+      text: `${displayListLabel(label.text)}${suffix}`,
+      synthetic: true,
+      marker: { length: displayListLabel(label.text).length, alignment: label.alignment ?? "left" },
+      ...definedProps({
+        bold: marker?.bold ?? first.bold,
+        italic: marker?.italic ?? first.italic,
+        fontFamily: marker?.fontFamily ?? first.fontFamily,
+        fontSizePt: marker?.fontSizeHalfPoints ? marker.fontSizeHalfPoints / 2 : first.fontSizePt
+      }),
+      ...marker?.color || first.color ? { color: marker?.color ?? first.color } : {}
+    };
+  }
+  const betweenBorders = /* @__PURE__ */ new Map();
+  function adaptParagraph(paragraph, markLabel) {
+    const adapted = adaptParagraphOnly(paragraph, markLabel);
+    const between = paragraphBox(
+      catalog ? resolveParagraphFormatting(paragraph, catalog) : paragraph,
+      model.theme
+    ).betweenBorder;
+    if (between) betweenBorders.set(adapted, between);
+    return adapted;
+  }
+  function adaptParagraphOnly(paragraph, markLabel) {
+    const resolved = catalog ? resolveParagraphFormatting(paragraph, catalog) : paragraph;
+    const label = labels.get(paragraph.id);
+    const ownFirstLine = resolved.firstLineTwips !== void 0 || resolved.hangingTwips !== void 0;
+    const runs = paragraph.runs.map((run) => adaptRun(run, paragraph.style, markLabel));
+    const footnotes = paragraphFootnotes(paragraph, model, noteLabel, adaptParagraph);
+    const { betweenBorder: _between, ...box } = paragraphBox(resolved, model.theme);
+    return {
+      kind: "paragraph",
+      id: paragraph.id,
+      runs: label ? [labelRun(paragraph, label), ...runs] : runs,
+      ...footnotes.length ? { footnotes } : {},
+      ...box,
+      ...paragraph.tabStops?.length || label?.tabStopTwips !== void 0 ? {
+        tabStops: [
+          ...(paragraph.tabStops ?? []).map((stop) => ({
+            posPx: twipsToPx3(stop.posTwips),
+            align: stop.align,
+            ...stop.leader ? { leader: stop.leader } : {}
+          })),
+          ...label?.tabStopTwips !== void 0 ? [{ posPx: twipsToPx3(label.tabStopTwips), align: "left" }] : []
+        ].sort((a, b) => a.posPx - b.posPx)
+      } : {},
+      ...floatsOf(paragraph),
+      ...definedProps({
+        align: resolved.align,
+        direction: resolved.direction,
+        spacingBeforeTwips: resolved.spacingBeforeTwips,
+        spacingAfterTwips: resolved.spacingAfterTwips,
+        lineSpacingTwips: resolved.lineSpacingTwips,
+        lineSpacingRule: resolved.lineSpacingRule,
+        indentLeftTwips: resolved.indentLeftTwips ?? label?.indentLeftTwips,
+        indentRightTwips: resolved.indentRightTwips,
+        indentStartTwips: resolved.indentStartTwips,
+        indentEndTwips: resolved.indentEndTwips,
+        firstLineTwips: ownFirstLine ? resolved.firstLineTwips : label?.firstLineTwips,
+        hangingTwips: ownFirstLine ? resolved.hangingTwips : label?.hangingTwips,
+        styleId: paragraph.style
+      }),
+      ...paragraph.pageBreakBefore ? { pageBreakBefore: true } : {},
+      ...resolved.keepNext ? { keepNext: true } : {},
+      ...resolved.keepLines ? { keepLines: true } : {},
+      ...resolved.widowControl === false ? { widowControl: false } : {},
+      ...resolved.contextualSpacing ? { contextualSpacing: true } : {}
+    };
+  }
+  function adaptBlock(block) {
+    if (block.type === "paragraph") return adaptParagraph(block);
+    reportOnce(TABLE_ROW_NOTE);
+    reportOnce(VERTICAL_MERGE_NOTE);
+    return adaptTable(block, model, adaptParagraph);
+  }
+  const blocks = [
+    ...model.blocks.map(adaptBlock),
+    ...endnoteParagraphs(model, noteLabel, adaptParagraph)
+  ];
+  groupParagraphBorders(blocks, betweenBorders);
+  const folded = foldDropCaps(model.blocks, blocks);
+  if (folded.size) reportOnce(DROP_CAP_NOTE);
+  const sections = model.sections;
+  if (!sections || !sections.length) {
+    return {
+      sections: [
+        {
+          page: {
+            widthPx: model.page.width,
+            heightPx: model.page.height,
+            marginTopPx: model.page.marginTop,
+            marginRightPx: model.page.marginRight,
+            marginBottomPx: model.page.marginBottom,
+            marginLeftPx: model.page.marginLeft
+          },
+          blocks: blocks.filter((block) => !folded.has(block))
+        }
+      ]
+    };
+  }
+  const indexById = new Map(model.blocks.map((block, index) => [block.id, index]));
+  let start = 0;
+  const result = sections.map((section, index) => {
+    const last = index === sections.length - 1;
+    const endIndex = last ? blocks.length : (indexById.get(section.endsAtBlockId) ?? start - 1) + 1;
+    const end = Math.max(start, endIndex);
+    const slice = blocks.slice(start, end);
+    start = end;
+    const sectionStart = index === 0 ? void 0 : sectionBreak(section.type, reportOnce);
+    return {
+      page: {
+        widthPx: twipsToPx3(section.pageWidthTwips),
+        heightPx: twipsToPx3(section.pageHeightTwips),
+        marginTopPx: twipsToPx3(section.marginTopTwips),
+        marginRightPx: twipsToPx3(section.marginRightTwips),
+        marginBottomPx: twipsToPx3(section.marginBottomTwips),
+        marginLeftPx: twipsToPx3(section.marginLeftTwips)
+      },
+      ...section.columns.count > 1 ? {
+        columns: {
+          count: section.columns.count,
+          gapPx: twipsToPx3(section.columns.spacingTwips ?? twips(720)),
+          ...section.columns.separator ? { separator: true } : {},
+          ...!section.columns.equalWidth && section.columns.widths?.length ? {
+            widths: section.columns.widths.map((column) => ({
+              widthPx: twipsToPx3(column.widthTwips),
+              gapPx: twipsToPx3(
+                column.spacingTwips ?? section.columns.spacingTwips ?? twips(720)
+              )
+            }))
+          } : {}
+        }
+      } : {},
+      ...sectionStart && { break: sectionStart },
+      ...section.verticalAlign ? { verticalAlign: section.verticalAlign } : {},
+      blocks: slice.filter((block) => !folded.has(block))
+    };
+  });
+  return { sections: result };
+}
+
+// src/docx/layout/floats.ts
+var FLOAT_WRAP_NOTE = "Text wraps around floating pictures on their largest side (square, tight and through wrapping use the picture\u2019s rectangle, not its outline); lines continuing onto a later page keep their wrapped widths.";
+function horizontalArea(float, page, column) {
+  const contentLeft = page.marginLeftPx;
+  switch (float.relativeFromH) {
+    case "page":
+      return { start: 0, size: page.widthPx };
+    case "margin":
+      return { start: contentLeft, size: page.widthPx - contentLeft - page.marginRightPx };
+    case "leftMargin":
+    case "insideMargin":
+      return { start: 0, size: contentLeft };
+    case "rightMargin":
+    case "outsideMargin":
+      return { start: page.widthPx - page.marginRightPx, size: page.marginRightPx };
+    default:
+      return { start: contentLeft + column.xPx, size: column.widthPx };
+  }
+}
+function verticalArea(float, page, paragraphTopPx, paragraphHeightPx) {
+  switch (float.relativeFromV) {
+    case "page":
+      return { start: 0, size: page.heightPx };
+    case "margin":
+      return {
+        start: page.marginTopPx,
+        size: page.heightPx - page.marginTopPx - page.marginBottomPx
+      };
+    case "topMargin":
+    case "insideMargin":
+      return { start: 0, size: page.marginTopPx };
+    case "bottomMargin":
+    case "outsideMargin":
+      return { start: page.heightPx - page.marginBottomPx, size: page.marginBottomPx };
+    default:
+      return { start: paragraphTopPx, size: paragraphHeightPx };
+  }
+}
+function place(area, size, align, offset) {
+  if (align === "center") return area.start + (area.size - size) / 2;
+  if (align === "right" || align === "bottom" || align === "outside")
+    return area.start + area.size - size;
+  if (align) return area.start;
+  return area.start + (offset ?? 0);
+}
+function floatPosition(float, page, column, paragraph) {
+  const h = horizontalArea(float, page, column);
+  const v = verticalArea(float, page, paragraph.topPx, paragraph.heightPx);
+  return {
+    xPx: place(h, float.widthPx, float.alignH, float.offsetXPx),
+    yPx: place(v, float.heightPx, float.alignV, float.offsetYPx)
+  };
+}
+function positionFloats(input, pages) {
+  const floatsById = /* @__PURE__ */ new Map();
+  for (const section of input.sections)
+    for (const block of section.blocks)
+      if (block.kind === "paragraph" && block.floats?.length)
+        floatsById.set(block.id, block.floats);
+  if (!floatsById.size) return false;
+  const placed = /* @__PURE__ */ new Set();
+  for (const page of pages) {
+    const boxes = [];
+    for (const column of page.columns)
+      for (const block of column.blocks) {
+        const floats = block.kind === "paragraph" ? floatsById.get(block.blockId) : void 0;
+        if (!floats || placed.has(block.blockId)) continue;
+        placed.add(block.blockId);
+        const top = page.marginTopPx + block.yPx;
+        for (const float of floats) {
+          const position = floatPosition(float, page, column, {
+            topPx: top,
+            heightPx: block.heightPx
+          });
+          boxes.push({
+            blockId: block.blockId,
+            ...position,
+            widthPx: float.widthPx,
+            heightPx: float.heightPx,
+            partName: float.partName,
+            contentType: float.contentType,
+            behindText: Boolean(float.behindText),
+            ...float.wrap ? { wrap: float.wrap } : {}
+          });
+        }
+      }
+    if (boxes.length) page.floats = boxes;
+  }
+  return true;
+}
+
+// src/docx/layout/layout.ts
+function layoutDocument(input, measurer) {
+  let result = layoutSections(input, measurer);
+  if (!positionFloats(input, result.pages)) return result;
+  let exclusions = wrapExclusions(result.pages);
+  for (let pass = 0; exclusions.size && pass < 3; pass++) {
+    result = layoutSections(input, measurer, exclusions);
+    positionFloats(input, result.pages);
+    const next = wrapExclusions(result.pages);
+    if (sameExclusions(next, exclusions)) break;
+    exclusions = next;
+  }
+  return { ...result, approximations: [.../* @__PURE__ */ new Set([...result.approximations, FLOAT_WRAP_NOTE])] };
+}
+function layoutDocumentModel(model, measurer) {
+  const approximations = [];
+  const input = adaptDocumentModel(model, (message) => approximations.push(message));
+  const result = layoutDocument(input, measurer);
+  return {
+    pages: result.pages,
+    approximations: [.../* @__PURE__ */ new Set([...approximations, ...result.approximations])]
+  };
+}
+
+// src/docx/layout/fonts.ts
+var SUBSTITUTES = {
+  calibri: { fallbacks: ["Carlito"], generic: "sans-serif" },
+  "calibri light": { fallbacks: ["Carlito"], generic: "sans-serif" },
+  cambria: { fallbacks: ["Caladea"], generic: "serif" },
+  arial: { fallbacks: ["Arimo", "Liberation Sans"], generic: "sans-serif" },
+  helvetica: { fallbacks: ["Arimo", "Liberation Sans"], generic: "sans-serif" },
+  "times new roman": { fallbacks: ["Tinos", "Liberation Serif"], generic: "serif" },
+  times: { fallbacks: ["Tinos", "Liberation Serif"], generic: "serif" },
+  "courier new": { fallbacks: ["Cousine", "Liberation Mono"], generic: "monospace" },
+  courier: { fallbacks: ["Cousine", "Liberation Mono"], generic: "monospace" },
+  georgia: { fallbacks: ["Gelasio"], generic: "serif" },
+  consolas: { fallbacks: ["Inconsolata"], generic: "monospace" }
+};
+var quote = (family) => `"${family.replace(/["\\]/g, "")}"`;
+function cssFontStack(family) {
+  const name = family?.trim() || DEFAULT_FONT_FAMILY;
+  const known = SUBSTITUTES[name.toLowerCase()];
+  return [quote(name), ...(known?.fallbacks ?? []).map(quote), known?.generic ?? "sans-serif"].join(
+    ", "
+  );
+}
+
+exports.DEFAULT_FONT_FAMILY = DEFAULT_FONT_FAMILY;
+exports.DEFAULT_FONT_SIZE_PT = DEFAULT_FONT_SIZE_PT;
+exports.DEFAULT_TAB_STOP_PX = DEFAULT_TAB_STOP_PX;
+exports.FLOAT_WRAP_NOTE = FLOAT_WRAP_NOTE;
+exports.NO_TWIPS = NO_TWIPS;
+exports.PageCursor = PageCursor;
+exports.SINGLE_LINE_SPACING_UNITS = SINGLE_LINE_SPACING_UNITS;
+exports.adaptDocumentModel = adaptDocumentModel;
+exports.adjustForWidowOrphan = adjustForWidowOrphan;
+exports.appendBreakMarker = appendBreakMarker;
+exports.createFakeMeasurer = createFakeMeasurer;
+exports.cssFontStack = cssFontStack;
+exports.floatPosition = floatPosition;
+exports.fontMetrics = fontMetrics;
+exports.isEastAsianChar = isEastAsianChar;
+exports.layoutDocument = layoutDocument;
+exports.layoutDocumentModel = layoutDocumentModel;
+exports.layoutParagraph = layoutParagraph;
+exports.layoutRow = layoutRow;
+exports.layoutSections = layoutSections;
+exports.ligatureCss = ligatureCss;
+exports.paragraphFloats = paragraphFloats;
+exports.placeParagraph = placeParagraph;
+exports.placeTab = placeTab;
+exports.placeTable = placeTable;
+exports.positionFloats = positionFloats;
+exports.ptToPx = ptToPx;
+exports.pxToTwips = pxToTwips;
+exports.splitRowAtHeight = splitRowAtHeight;
+exports.suppressesSpacing = suppressesSpacing;
+exports.tokenizeRun = tokenizeRun;
+exports.twipsToPx = twipsToPx;
+exports.widowControlEnabled = widowControlEnabled;