@superdoc-dev/cli 0.16.0-next.27 → 0.16.0-next.28

package/dist/index.js

@@ -10805,7 +10805,10 @@ var init_schemas = __esm(() => {
           "sectionDefaults"
         ]
       };
-      const scopeReportSchema = objectSchema({ scope: scopeEnum, part: { type: "string" }, detail: { type: "string" } }, ["scope", "part"]);
+      const scopeReportSchema = objectSchema({ scope: scopeEnum, part: { type: "string" }, detail: { type: "string" } }, [
+        "scope",
+        "part"
+      ]);
       const scopeSkipSchema = objectSchema({
         scope: { type: "string" },
         part: { type: "string" },
@@ -68345,7 +68348,7 @@ var init_remark_gfm_BhnWr3yf_es = __esm(() => {
   emptyOptions2 = {};
 });
 
-// ../../packages/superdoc/dist/chunks/SuperConverter-DBsJeu9t.es.js
+// ../../packages/superdoc/dist/chunks/SuperConverter-D2zNnC50.es.js
 function getExtensionConfigField(extension$1, field, context = { name: "" }) {
   const fieldValue = extension$1.config[field];
   if (typeof fieldValue === "function")
@@ -76839,8 +76842,8 @@ function createBorderPropertyHandler(xmlName, sdName = null) {
       createAttributeHandler("w:themeColor"),
       createAttributeHandler("w:themeTint"),
       createAttributeHandler("w:themeShade"),
-      createAttributeHandler("w:sz", "size", parseInteger, integerToString),
-      createAttributeHandler("w:space", null, parseInteger, integerToString),
+      createAttributeHandler("w:sz", "size", parseInteger$1, integerToString),
+      createAttributeHandler("w:space", null, parseInteger$1, integerToString),
       createAttributeHandler("w:shadow", null, parseBoolean, booleanToString),
       createAttributeHandler("w:frame", null, parseBoolean, booleanToString)
     ],
@@ -77045,7 +77048,7 @@ function readAttr(attributes, key) {
   return attributes?.[`w14:${key}`] ?? attributes?.[`w:${key}`];
 }
 function encodeStylisticSet(node3) {
-  const id2 = parseInteger(readAttr(node3?.attributes, "id"));
+  const id2 = parseInteger$1(readAttr(node3?.attributes, "id"));
   if (id2 == null)
     return;
   const valRaw = readAttr(node3?.attributes, "val");
@@ -78370,11 +78373,25 @@ function widthsEqual(a, b) {
       return false;
   return true;
 }
+function usableExplicitWidths(input) {
+  if (!input || input.equalWidth !== false || !Array.isArray(input.widths))
+    return [];
+  return input.widths.filter((width) => typeof width === "number" && Number.isFinite(width) && width > 0);
+}
+function resolveColumnMode(input) {
+  return usableExplicitWidths(input).length > 0 ? "explicit" : "equal";
+}
+function resolveColumnCount(input) {
+  const rawCount = input && Number.isFinite(input.count) ? Math.max(1, Math.floor(input.count)) : 1;
+  const explicit = usableExplicitWidths(input);
+  return explicit.length > 0 ? Math.min(rawCount, explicit.length) : rawCount;
+}
 function cloneColumnLayout(columns) {
   return columns ? {
     count: columns.count,
     gap: columns.gap,
     ...Array.isArray(columns.widths) ? { widths: [...columns.widths] } : {},
+    ...Array.isArray(columns.gaps) ? { gaps: [...columns.gaps] } : {},
     ...columns.equalWidth !== undefined ? { equalWidth: columns.equalWidth } : {},
     ...columns.withSeparator !== undefined ? { withSeparator: columns.withSeparator } : {}
   } : {
@@ -78382,13 +78399,45 @@ function cloneColumnLayout(columns) {
     gap: 0
   };
 }
+function resolveColumnLayout(input) {
+  const count2 = resolveColumnCount(input);
+  const resolved = cloneColumnLayout(input);
+  resolved.count = count2;
+  if (resolveColumnMode(input) === "explicit") {
+    if (Array.isArray(resolved.widths))
+      resolved.widths = resolved.widths.slice(0, count2);
+    if (Array.isArray(resolved.gaps))
+      resolved.gaps = resolved.gaps.slice(0, Math.max(0, count2 - 1));
+  } else {
+    delete resolved.widths;
+    delete resolved.gaps;
+  }
+  return resolved;
+}
+function buildColumnGeometry(widths, gap, withSeparator) {
+  const geometry = [];
+  let x = 0;
+  for (let i$1 = 0;i$1 < widths.length; i$1 += 1) {
+    const width = widths[i$1];
+    const isLast = i$1 === widths.length - 1;
+    const gapAfter = isLast ? 0 : gap;
+    const col = {
+      index: i$1,
+      x,
+      width,
+      gapAfter
+    };
+    if (withSeparator && !isLast)
+      col.separatorX = x + width + gap / 2;
+    geometry.push(col);
+    x += width + gapAfter;
+  }
+  return geometry;
+}
 function normalizeColumnLayout(input, contentWidth, epsilon = 0.0001) {
-  const rawCount = input && Number.isFinite(input.count) ? Math.floor(input.count) : 1;
-  let count2 = Math.max(1, rawCount || 1);
+  const count2 = resolveColumnCount(input);
   const gap = Math.max(0, input?.gap ?? 0);
-  const explicitWidths = input?.equalWidth === false && Array.isArray(input?.widths) && input.widths.length > 0 ? input.widths.filter((width$1) => typeof width$1 === "number" && Number.isFinite(width$1) && width$1 > 0) : [];
-  if (explicitWidths.length > 0 && explicitWidths.length < count2)
-    count2 = explicitWidths.length;
+  const explicitWidths = usableExplicitWidths(input);
   const availableWidth = contentWidth - gap * (count2 - 1);
   let widths = explicitWidths.length > 0 ? explicitWidths.slice(0, count2) : Array.from({ length: count2 }, () => availableWidth > 0 ? availableWidth / count2 : contentWidth);
   if (widths.length < count2) {
@@ -78418,6 +78467,45 @@ function normalizeColumnLayout(input, contentWidth, epsilon = 0.0001) {
     width
   };
 }
+function getColumnGeometry(normalized) {
+  return buildColumnGeometry(Array.isArray(normalized.widths) && normalized.widths.length > 0 ? normalized.widths : [normalized.width], normalized.gap, Boolean(normalized.withSeparator));
+}
+function clampColumnIndex(geometry, index2) {
+  if (geometry.length === 0)
+    return 0;
+  return Math.max(0, Math.min(index2, geometry.length - 1));
+}
+function getColumnWidth(geometry, index2) {
+  return geometry[clampColumnIndex(geometry, index2)]?.width ?? 0;
+}
+function getColumnX(geometry, index2, originX = 0) {
+  return originX + (geometry[clampColumnIndex(geometry, index2)]?.x ?? 0);
+}
+function getColumnSeparatorPositions(geometry, originX = 0) {
+  return geometry.filter((col) => typeof col.separatorX === "number").map((col) => originX + col.separatorX);
+}
+function columnRenderLayoutsEqual(a, b) {
+  if (!a && !b)
+    return true;
+  if (!a || !b)
+    return false;
+  const mode = resolveColumnMode(a);
+  if (mode !== resolveColumnMode(b))
+    return false;
+  if (resolveColumnCount(a) !== resolveColumnCount(b))
+    return false;
+  if ((a.gap ?? 0) !== (b.gap ?? 0))
+    return false;
+  if (Boolean(a.withSeparator) !== Boolean(b.withSeparator))
+    return false;
+  if (mode === "explicit") {
+    const ra = resolveColumnLayout(a);
+    const rb = resolveColumnLayout(b);
+    if (!widthsEqual(ra.widths, rb.widths))
+      return false;
+  }
+  return true;
+}
 function getIdlessSdtContainerKey(metadata) {
   const existingKey = idlessSdtContainerKeys.get(metadata);
   if (existingKey)
@@ -78524,6 +78612,21 @@ function toUpperLetter$1(value) {
   const repeatCount = Math.floor((normalized - 1) / 26) + 1;
   return String.fromCharCode(65 + index2).repeat(repeatCount);
 }
+function toOrdinal(value) {
+  const remainder = value % 100;
+  if (remainder >= 11 && remainder <= 13)
+    return `${value}th`;
+  switch (value % 10) {
+    case 1:
+      return `${value}st`;
+    case 2:
+      return `${value}nd`;
+    case 3:
+      return `${value}rd`;
+    default:
+      return `${value}th`;
+  }
+}
 function formatPageNumber(pageNumber, format) {
   const value = Math.max(1, Math.trunc(Number.isFinite(pageNumber) ? pageNumber : 1));
   switch (format) {
@@ -78537,12 +78640,16 @@ function formatPageNumber(pageNumber, format) {
       return toUpperLetter$1(value).toLowerCase();
     case "numberInDash":
       return `- ${value} -`;
+    case "ordinal":
+      return toOrdinal(value);
     case "decimal":
     default:
       return String(value);
   }
 }
-function formatPageNumberFieldValue$1(pageNumber, fieldFormat) {
+function formatPageNumberFieldValue(pageNumber, fieldFormat) {
+  if (fieldFormat?.numericPicture)
+    return formatIntegerWithNumericPicture(Math.max(1, Math.trunc(Number.isFinite(pageNumber) ? pageNumber : 1)), fieldFormat.numericPicture);
   const format = fieldFormat?.format ?? "decimal";
   const formatted = formatPageNumber(pageNumber, format);
   return fieldFormat?.zeroPadding && format === "decimal" ? formatted.padStart(fieldFormat.zeroPadding, "0") : formatted;
@@ -78574,6 +78681,373 @@ function formatSectionPageNumberText(args2) {
     chapterSeparator: args2.chapterSeparator
   });
 }
+function formatIntegerWithNumericPicture(value, picture) {
+  const integerValue = Math.trunc(Number.isFinite(value) ? value : 0);
+  const sections = splitPictureSections(typeof picture === "string" && picture.length > 0 ? picture : "0");
+  const hasExplicitNegativeSection = integerValue < 0 && sections[1] != null;
+  const section = integerValue > 0 ? sections[0] : integerValue < 0 ? sections[1] ?? sections[0] : sections[2] ?? sections[0];
+  return formatNumericPictureSection(Math.abs(integerValue), integerValue < 0, section ?? "0", hasExplicitNegativeSection);
+}
+function splitPictureSections(picture) {
+  const sections = [];
+  let current = "";
+  let inQuote = false;
+  for (let index2 = 0;index2 < picture.length; index2 += 1) {
+    const char = picture[index2];
+    if (char === "'") {
+      inQuote = !inQuote;
+      current += char;
+      continue;
+    }
+    if (char === ";" && !inQuote) {
+      sections.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  sections.push(current);
+  return sections;
+}
+function tokenizePicture(section) {
+  const tokens = [];
+  for (let index2 = 0;index2 < section.length; index2 += 1) {
+    const char = section[index2];
+    if (char === "'") {
+      let literal = "";
+      index2 += 1;
+      while (index2 < section.length && section[index2] !== "'") {
+        literal += section[index2];
+        index2 += 1;
+      }
+      tokens.push({
+        kind: "literal",
+        value: literal
+      });
+      continue;
+    }
+    if (char === "0" || char === "#" || char === "x" || char === "," || char === "." || char === "+" || char === "-")
+      tokens.push({
+        kind: "placeholder",
+        value: char
+      });
+    else
+      tokens.push({
+        kind: "literal",
+        value: char
+      });
+  }
+  return tokens;
+}
+function formatNumericPictureSection(value, isNegative, section, suppressDefaultNegative = false) {
+  const tokens = tokenizePicture(section);
+  const decimalIndex = tokens.findIndex((token) => token.kind === "placeholder" && token.value === ".");
+  const integerTokens = decimalIndex >= 0 ? tokens.slice(0, decimalIndex) : tokens;
+  const fractionalTokens = decimalIndex >= 0 ? tokens.slice(decimalIndex + 1) : [];
+  const integerPart = formatIntegerPictureTokens(value, isNegative, integerTokens, suppressDefaultNegative);
+  const fractionalPart = formatFractionalPictureTokens(fractionalTokens);
+  return fractionalTokens.length > 0 ? `${integerPart}.${fractionalPart}` : integerPart;
+}
+function formatIntegerPictureTokens(value, isNegative, tokens, suppressDefaultNegative) {
+  let xIndex = -1;
+  for (let index2 = tokens.length - 1;index2 >= 0; index2 -= 1) {
+    const token = tokens[index2];
+    if (token.kind === "placeholder" && token.value === "x") {
+      xIndex = index2;
+      break;
+    }
+  }
+  const activeTokens = xIndex >= 0 ? tokens.slice(xIndex + 1) : tokens;
+  const placeholderCount = activeTokens.filter((token) => token.kind === "placeholder" && (token.value === "0" || token.value === "#")).length;
+  const rawDigits = String(value);
+  const digits = xIndex >= 0 && placeholderCount > 0 ? rawDigits.slice(-placeholderCount) : rawDigits;
+  let digitIndex = digits.length - 1;
+  let output = "";
+  let signSlot = null;
+  const hasGrouping = activeTokens.some((token) => token.kind === "placeholder" && token.value === ",");
+  for (let index2 = activeTokens.length - 1;index2 >= 0; index2 -= 1) {
+    const token = activeTokens[index2];
+    if (token.kind === "literal") {
+      output = token.value + output;
+      continue;
+    }
+    switch (token.value) {
+      case "0":
+        output = (digitIndex >= 0 ? digits[digitIndex] : "0") + output;
+        digitIndex -= 1;
+        break;
+      case "#":
+        if (digitIndex >= 0) {
+          output = digits[digitIndex] + output;
+          digitIndex -= 1;
+        }
+        break;
+      case "+":
+      case "-":
+        signSlot = token.value;
+        break;
+      case ",":
+      case "x":
+      case ".":
+        break;
+    }
+  }
+  if (placeholderCount > 0 && xIndex < 0 && digitIndex >= 0)
+    output = digits.slice(0, digitIndex + 1) + output;
+  if (hasGrouping)
+    output = applyGrouping(output);
+  if (signSlot === "+")
+    output = `${isNegative ? "-" : "+"}${output}`;
+  else if (signSlot === "-")
+    output = `${isNegative ? "-" : " "}${output}`;
+  else if (isNegative && !suppressDefaultNegative)
+    output = `-${output}`;
+  return output;
+}
+function formatFractionalPictureTokens(tokens) {
+  let output = "";
+  for (const token of tokens) {
+    if (token.kind === "literal") {
+      output += token.value;
+      continue;
+    }
+    if (token.value === "0")
+      output += "0";
+    else if (token.value !== "#")
+      output += token.value;
+  }
+  return output;
+}
+function applyGrouping(value) {
+  const match = value.match(/^([^0-9]*)([0-9]+)(.*)$/);
+  if (!match)
+    return value;
+  return `${match[1]}${match[2].replace(/\B(?=(\d{3})+(?!\d))/g, ",")}${match[3]}`;
+}
+function buildPageRefAnchorMap(bookmarks, layout, blocks = [], measures = []) {
+  const anchors = /* @__PURE__ */ new Map;
+  if (bookmarks.size === 0)
+    return anchors;
+  const blockById = /* @__PURE__ */ new Map;
+  const measureById = /* @__PURE__ */ new Map;
+  for (const block of blocks)
+    blockById.set(block.id, block);
+  for (let index2 = 0;index2 < blocks.length; index2 += 1) {
+    const block = blocks[index2];
+    const measure = measures[index2];
+    if (block && measure)
+      measureById.set(block.id, measure);
+  }
+  for (const [bookmarkName, pmPosition] of bookmarks) {
+    const location2 = findPageRefLocation(pmPosition, layout, blockById, measureById);
+    if (location2)
+      anchors.set(bookmarkName, {
+        ...location2,
+        pmPosition
+      });
+  }
+  return anchors;
+}
+function findPageRefLocation(pmPosition, layout, blockById, measureById) {
+  let nextLocation = null;
+  let nextDistance = Number.POSITIVE_INFINITY;
+  let hasPriorVisibleRange = false;
+  for (const page of layout.pages)
+    for (const fragment2 of page.fragments) {
+      if (fragmentContainsPosition(fragment2, pmPosition))
+        return pageRefLocationFromPage(page, pmPosition);
+      const block = blockById.get(fragment2.blockId);
+      if (fragment2.kind === "para" && block?.kind === "paragraph" && blockContainsPosition(block, pmPosition))
+        return pageRefLocationFromPage(page, pmPosition);
+      if (fragment2.kind === "table" && block?.kind === "table" && tableContainsPosition(block, fragment2, pmPosition, measureById.get(fragment2.blockId)))
+        return pageRefLocationFromPage(page, pmPosition);
+      if (fragment2.kind === "list-item" && block?.kind === "list" && listItemContainsPosition(block, fragment2.itemId, pmPosition))
+        return pageRefLocationFromPage(page, pmPosition);
+      const fragmentRange = fragmentPositionRange(fragment2, block);
+      if (fragmentRange?.end != null && fragmentRange.end <= pmPosition)
+        hasPriorVisibleRange = true;
+      const fragmentStart = fragmentRange?.start ?? null;
+      if (fragmentStart != null && fragmentStart > pmPosition) {
+        const distance2 = fragmentStart - pmPosition;
+        if ((!hasPriorVisibleRange || distance2 <= MAX_BOOKMARK_MARKER_LEAD_DISTANCE) && distance2 < nextDistance) {
+          nextDistance = distance2;
+          nextLocation = pageRefLocationFromPage(page, pmPosition);
+        }
+      }
+    }
+  return nextLocation;
+}
+function pageRefLocationFromPage(page, pmPosition) {
+  const displayNumber = Math.max(1, page.displayNumber ?? page.effectivePageNumber ?? page.number);
+  return {
+    physicalPage: page.number,
+    displayNumber,
+    displayText: page.numberText ?? String(displayNumber),
+    pageFormat: page.pageNumberFormat,
+    chapterNumberText: page.pageNumberChapterText,
+    chapterSeparator: page.pageNumberChapterSeparator,
+    sectionIndex: page.sectionIndex,
+    pmPosition
+  };
+}
+function fragmentContainsPosition(fragment2, pmPosition) {
+  const range = fragment2;
+  return range.pmStart != null && range.pmEnd != null && pmPosition >= range.pmStart && pmPosition < range.pmEnd;
+}
+function blockContainsPosition(block, pmPosition) {
+  const range = runRange(block.runs);
+  return range != null && pmPosition >= range.start && pmPosition < range.end;
+}
+function tableContainsPosition(block, fragment2, pmPosition, measure) {
+  const fromRow = Math.max(0, fragment2.fromRow);
+  const toRow = Math.min(block.rows.length, fragment2.toRow);
+  const tableMeasure = measure?.kind === "table" ? measure : undefined;
+  for (let rowIndex = fromRow;rowIndex < toRow; rowIndex += 1) {
+    const row = block.rows[rowIndex];
+    if (!row)
+      continue;
+    const isPartialRow = fragment2.partialRow?.rowIndex === rowIndex;
+    for (let cellIndex = 0;cellIndex < row.cells.length; cellIndex += 1) {
+      const cell = row.cells[cellIndex];
+      if (!cell)
+        continue;
+      if (isPartialRow && tableMeasure) {
+        const cellMeasure = tableMeasure.rows[rowIndex]?.cells[cellIndex];
+        if (cellContainsPositionInLineRange(cell, cellMeasure, fragment2.partialRow, cellIndex, pmPosition))
+          return true;
+        continue;
+      }
+      const blocks = cell.blocks ?? (cell.paragraph ? [cell.paragraph] : []);
+      for (const childBlock of blocks) {
+        if (childBlock.kind === "paragraph" && blockContainsPosition(childBlock, pmPosition))
+          return true;
+        if (childBlock.kind === "table" && tableBlockContainsPosition(childBlock, pmPosition))
+          return true;
+      }
+    }
+  }
+  return false;
+}
+function cellContainsPositionInLineRange(cell, cellMeasure, partialRow, cellIndex, pmPosition) {
+  if (!cellMeasure)
+    return false;
+  const totalLines = getCellTotalLines(cellMeasure);
+  const rawFromLine = partialRow.fromLineByCell[cellIndex];
+  const rawToLine = partialRow.toLineByCell[cellIndex];
+  const fromLine = typeof rawFromLine === "number" && rawFromLine >= 0 ? Math.min(rawFromLine, totalLines) : 0;
+  const toLine = typeof rawToLine === "number" ? Math.max(0, Math.min(rawToLine === -1 ? totalLines : rawToLine, totalLines)) : totalLines;
+  const range = computeCellLineRange(cell, cellMeasure, fromLine, Math.max(fromLine, toLine));
+  return range != null && pmPosition >= range.start && pmPosition < range.end;
+}
+function computeCellLineRange(cell, cellMeasure, fromLine, toLine) {
+  let start = Number.POSITIVE_INFINITY;
+  let end = Number.NEGATIVE_INFINITY;
+  const blocks = cell.blocks ?? (cell.paragraph ? [cell.paragraph] : []);
+  const measures = cellMeasure.blocks ?? (cellMeasure.paragraph ? [cellMeasure.paragraph] : []);
+  const blockCount = Math.min(blocks.length, measures.length);
+  let lineOffset = 0;
+  for (let blockIndex = 0;blockIndex < blockCount; blockIndex += 1) {
+    const childBlock = blocks[blockIndex];
+    const childMeasure = measures[blockIndex];
+    const lineCount = getBlockLineCount(childMeasure);
+    const blockFromLine = Math.max(fromLine, lineOffset) - lineOffset;
+    const blockToLine = Math.min(toLine, lineOffset + lineCount) - lineOffset;
+    if (childBlock?.kind === "paragraph" && childMeasure?.kind === "paragraph" && blockFromLine < blockToLine) {
+      const range = computeFragmentPmRange(childBlock, childMeasure.lines, blockFromLine, blockToLine);
+      if (range.pmStart != null)
+        start = Math.min(start, range.pmStart);
+      if (range.pmEnd != null)
+        end = Math.max(end, range.pmEnd);
+    }
+    lineOffset += lineCount;
+  }
+  return Number.isFinite(start) && Number.isFinite(end) && start < end ? {
+    start,
+    end
+  } : null;
+}
+function getCellTotalLines(cellMeasure) {
+  return (cellMeasure.blocks ?? (cellMeasure.paragraph ? [cellMeasure.paragraph] : [])).reduce((total, measure) => total + getBlockLineCount(measure), 0);
+}
+function getBlockLineCount(measure) {
+  if (!measure)
+    return 0;
+  if (measure.kind === "paragraph")
+    return measure.lines.length;
+  if (measure.kind === "table")
+    return measure.rows.length;
+  return 1;
+}
+function tableBlockContainsPosition(block, pmPosition) {
+  for (const row of block.rows)
+    for (const cell of row.cells) {
+      const blocks = cell.blocks ?? (cell.paragraph ? [cell.paragraph] : []);
+      for (const childBlock of blocks) {
+        if (childBlock.kind === "paragraph" && blockContainsPosition(childBlock, pmPosition))
+          return true;
+        if (childBlock.kind === "table" && tableBlockContainsPosition(childBlock, pmPosition))
+          return true;
+      }
+    }
+  return false;
+}
+function fragmentPositionRange(fragment2, block) {
+  const fullRange = fragment2;
+  if (fullRange.pmStart != null && fullRange.pmEnd != null)
+    return {
+      start: fullRange.pmStart,
+      end: fullRange.pmEnd
+    };
+  if (block?.kind === "paragraph")
+    return runRange(block.runs);
+  if (block?.kind === "table")
+    return tableRunRange(block);
+  if (fragment2.kind === "list-item" && block?.kind === "list")
+    return listItemRunRange(block, fragment2.itemId);
+  return null;
+}
+function listItemContainsPosition(block, itemId, pmPosition) {
+  const range = listItemRunRange(block, itemId);
+  return range != null && pmPosition >= range.start && pmPosition < range.end;
+}
+function listItemRunRange(block, itemId) {
+  const item = block.items.find((candidate) => candidate.id === itemId);
+  return item ? runRange(item.paragraph.runs) : null;
+}
+function tableRunRange(block) {
+  let start = Number.POSITIVE_INFINITY;
+  let end = Number.NEGATIVE_INFINITY;
+  for (const row of block.rows)
+    for (const cell of row.cells) {
+      const blocks = cell.blocks ?? (cell.paragraph ? [cell.paragraph] : []);
+      for (const childBlock of blocks) {
+        const range = childBlock.kind === "paragraph" ? runRange(childBlock.runs) : childBlock.kind === "table" ? tableRunRange(childBlock) : null;
+        if (!range)
+          continue;
+        start = Math.min(start, range.start);
+        end = Math.max(end, range.end);
+      }
+    }
+  return Number.isFinite(start) && Number.isFinite(end) && start < end ? {
+    start,
+    end
+  } : null;
+}
+function runRange(runs) {
+  let start = Number.POSITIVE_INFINITY;
+  let end = Number.NEGATIVE_INFINITY;
+  for (const run$1 of runs) {
+    const range = run$1;
+    if (range.pmStart != null)
+      start = Math.min(start, range.pmStart);
+    if (range.pmEnd != null)
+      end = Math.max(end, range.pmEnd);
+  }
+  return Number.isFinite(start) && Number.isFinite(end) && start < end ? {
+    start,
+    end
+  } : null;
+}
 function resolveSpacingIndent(style, numbering) {
   const spacing = {
     before: style.spacing?.before ?? 0,
@@ -82963,11 +83437,12 @@ function convertTiffToPng(data) {
   }
 }
 function parsePageNumberFieldSwitches(instruction, fieldType) {
-  const normalizedInstruction = typeof instruction === "string" ? instruction.trim().replace(/\s+/g, " ") : fieldType;
+  const switchInstruction = typeof instruction === "string" ? instruction.trim() : fieldType;
+  const normalizedInstruction = normalizeInstructionWhitespace(switchInstruction);
   const result = {};
   if (normalizedInstruction && normalizedInstruction !== fieldType)
     result.instruction = normalizedInstruction;
-  for (const match of normalizedInstruction.matchAll(/\\\*\s+("[^"]+"|\S+)/g)) {
+  for (const match of switchInstruction.matchAll(/\\\*\s+("[^"]+"|\S+)/g)) {
     const rawValue = unquote(match[1]);
     const mapped = GENERAL_FORMATS.get(rawValue) ?? CASE_INSENSITIVE_GENERAL_FORMATS.get(rawValue.toLowerCase());
     if (mapped) {
@@ -82975,25 +83450,55 @@ function parsePageNumberFieldSwitches(instruction, fieldType) {
       break;
     }
   }
-  for (const match of normalizedInstruction.matchAll(/\\#\s+("[^"]+"|\S+)/g)) {
+  for (const match of switchInstruction.matchAll(/\\#\s+("[^"]+"|\S+)/g)) {
     const picture = unquote(match[1]);
+    if (!picture)
+      continue;
     if (/^0+$/.test(picture)) {
       result.pageNumberFormat ??= "decimal";
       result.pageNumberZeroPadding = picture.length;
-      break;
-    }
+    } else
+      result.pageNumberNumericPicture = picture;
+    break;
   }
   return result;
 }
-function formatPageNumberFieldValue(pageNumber, attrs = {}) {
-  return formatPageNumberFieldValue$1(pageNumber, {
+function formatPageNumberFieldValue$1(pageNumber, attrs = {}) {
+  return formatPageNumberFieldValue(pageNumber, {
     format: attrs.pageNumberFormat || "decimal",
-    zeroPadding: attrs.pageNumberZeroPadding ?? undefined
+    zeroPadding: attrs.pageNumberZeroPadding ?? undefined,
+    numericPicture: attrs.pageNumberNumericPicture ?? undefined
   });
 }
 function unquote(value) {
   return value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
 }
+function normalizeInstructionWhitespace(instruction) {
+  let normalized = "";
+  let inQuote = false;
+  let pendingSpace = false;
+  for (const char of instruction) {
+    if (char === '"') {
+      if (pendingSpace && normalized.length > 0) {
+        normalized += " ";
+        pendingSpace = false;
+      }
+      normalized += char;
+      inQuote = !inQuote;
+      continue;
+    }
+    if (!inQuote && /\s/.test(char)) {
+      pendingSpace = true;
+      continue;
+    }
+    if (pendingSpace && normalized.length > 0) {
+      normalized += " ";
+      pendingSpace = false;
+    }
+    normalized += char;
+  }
+  return normalized;
+}
 function preProcessPageInstruction(nodesToCombine, instrText = "PAGE", options = {}) {
   const fieldRunRPr = options.fieldRunRPr ?? null;
   const normalizedInstruction = typeof instrText === "string" && instrText.trim() ? instrText.trim().replace(/\s+/g, " ") : "PAGE";
@@ -83091,11 +83596,123 @@ function extractCachedText$1(nodes) {
   }
   return texts.join("");
 }
+function parsePageRefInstruction(instruction) {
+  const rawInstruction = typeof instruction === "string" ? instruction.trim() : "";
+  const tokens = tokenizeInstruction$1(rawInstruction);
+  const result = {
+    instruction: rawInstruction,
+    bookmarkId: "",
+    hasHyperlinkSwitch: false,
+    hasRelativePositionSwitch: false,
+    rawSwitches: []
+  };
+  if (!tokens.length || !/^PAGEREF$/i.test(tokens[0].value))
+    return result;
+  for (let index2 = 1;index2 < tokens.length; index2 += 1) {
+    const token = tokens[index2].value;
+    if (!token)
+      continue;
+    if (token.startsWith("\\")) {
+      const normalized = token.toLowerCase();
+      if (normalized === "\\h") {
+        result.hasHyperlinkSwitch = true;
+        result.rawSwitches.push({ switch: token });
+        continue;
+      }
+      if (normalized === "\\p") {
+        result.hasRelativePositionSwitch = true;
+        result.rawSwitches.push({ switch: token });
+        continue;
+      }
+      if (token === "\\*") {
+        const value = tokens[index2 + 1]?.value;
+        if (value != null) {
+          result.rawSwitches.push({
+            switch: token,
+            value
+          });
+          applyGeneralFormat$1(result, value);
+          index2 += 1;
+        } else
+          result.rawSwitches.push({ switch: token });
+        continue;
+      }
+      if (token === "\\#") {
+        const value = tokens[index2 + 1]?.value;
+        if (value != null) {
+          result.rawSwitches.push({
+            switch: token,
+            value
+          });
+          result.numericPictureFormat = { picture: value };
+          if (/^0+$/.test(value))
+            result.pageNumberFieldFormat = {
+              ...result.pageNumberFieldFormat ?? {},
+              zeroPadding: value.length
+            };
+          index2 += 1;
+        } else
+          result.rawSwitches.push({ switch: token });
+        continue;
+      }
+      result.rawSwitches.push({ switch: token });
+      continue;
+    }
+    if (!result.bookmarkId)
+      result.bookmarkId = token;
+  }
+  return result;
+}
+function tokenizeInstruction$1(instruction) {
+  const tokens = [];
+  for (const match of instruction.matchAll(TOKEN_PATTERN$1))
+    tokens.push({ value: unescapeQuotedToken$1(match[1] ?? match[2] ?? match[0]) });
+  return tokens;
+}
+function unescapeQuotedToken$1(value) {
+  return value.replace(/\\(["'\\])/g, "$1");
+}
+function applyGeneralFormat$1(result, value) {
+  const normalized = value.toLowerCase();
+  if (normalized === "charformat") {
+    result.fieldResultFormat = "charformat";
+    return;
+  }
+  if (normalized === "mergeformat") {
+    result.fieldResultFormat = "mergeformat";
+    return;
+  }
+  const mapped = GENERAL_FORMATS.get(value) ?? CASE_INSENSITIVE_GENERAL_FORMATS.get(normalized);
+  if (mapped)
+    result.pageNumberFieldFormat = {
+      ...result.pageNumberFieldFormat ?? {},
+      format: mapped
+    };
+  else
+    result.unsupportedGeneralFormat = value;
+}
 function preProcessPageRefInstruction(nodesToCombine, instrText, options = {}) {
+  const parsed = parsePageRefInstruction(instrText);
+  const instructionTokens = options.instructionTokens ?? null;
+  const firstInstrTextRunRPr = options.firstInstrTextRunRPr ?? null;
+  const fieldRunProperties = parsed.fieldResultFormat === "charformat" && firstInstrTextRunRPr ? translator$133.encode({
+    ...options.docx ? { docx: options.docx } : {},
+    nodes: [firstInstrTextRunRPr]
+  }) : null;
   return [{
     name: "sd:pageReference",
     type: "element",
-    attributes: { instruction: instrText },
+    attributes: {
+      instruction: parsed.instruction,
+      ...instructionTokens?.length ? { instructionTokens } : {},
+      ...parsed.bookmarkId ? { bookmarkId: parsed.bookmarkId } : {},
+      ...parsed.hasHyperlinkSwitch ? { hasHyperlinkSwitch: true } : {},
+      ...parsed.hasRelativePositionSwitch ? { hasRelativePositionSwitch: true } : {},
+      ...parsed.pageNumberFieldFormat ? { pageNumberFieldFormat: parsed.pageNumberFieldFormat } : {},
+      ...parsed.numericPictureFormat ? { numericPictureFormat: parsed.numericPictureFormat } : {},
+      ...parsed.fieldResultFormat ? { fieldResultFormat: parsed.fieldResultFormat } : {},
+      ...fieldRunProperties ? { fieldRunProperties } : {}
+    },
     elements: nodesToCombine
   }];
 }
@@ -83340,8 +83957,10 @@ function scanFieldSequence(nodes, beginIndex) {
     const node3 = nodes[i$1];
     const fldType = node3.elements?.find((el) => el.name === "w:fldChar")?.attributes?.["w:fldCharType"];
     const instrTextEl = node3.elements?.find((el) => el.name === "w:instrText");
-    if (instrTextEl)
-      instrText += (instrTextEl.elements?.[0]?.text || "") + " ";
+    if (instrTextEl) {
+      const fragment2 = instrTextEl.elements?.[0]?.text || "";
+      instrText += shouldInsertSwitchBoundarySpace(instrText, fragment2) ? ` ${fragment2}` : fragment2;
+    }
     if (!fieldRunRPr || separateIndex === -1 && fldType !== "end") {
       const rPrNode = node3.elements?.find((el) => el.name === "w:rPr");
       if (rPrNode && hasSignificantStyling(rPrNode))
@@ -83365,6 +83984,9 @@ function scanFieldSequence(nodes, beginIndex) {
     endIndex
   };
 }
+function shouldInsertSwitchBoundarySpace(existingInstruction, nextFragment) {
+  return /\w$/.test(existingInstruction) && /^\\/.test(nextFragment) || /(^|\s)\\[#*]$/.test(existingInstruction) && /^\S/.test(nextFragment);
+}
 function getHeaderFooterFieldPreprocessor(fieldType) {
   switch (fieldType) {
     case "PAGE":
@@ -98835,22 +99457,201 @@ function parseTaInstruction(instruction) {
   };
 }
 function parseSeqInstruction(instruction) {
-  const parts = instruction.trim().split(/\s+/);
-  const identifier = parts[1] || "";
-  let format = "ARABIC";
-  let restartLevel = null;
-  for (let i$1 = 2;i$1 < parts.length; i$1++)
-    if (parts[i$1] === "\\*" && parts[i$1 + 1]) {
-      format = parts[i$1 + 1];
-      i$1++;
-    } else if (parts[i$1] === "\\s" && parts[i$1 + 1]) {
-      restartLevel = parseInt(parts[i$1 + 1], 10) || null;
-      i$1++;
+  const rawInstruction = typeof instruction === "string" ? instruction : "";
+  const tokens = tokenizeInstruction(rawInstruction);
+  const result = createEmptyParse(rawInstruction, tokens[0]?.value ?? "");
+  if (extractFieldKeyword(rawInstruction) !== "SEQ")
+    return result;
+  let sawSwitch = false;
+  for (let index2 = 1;index2 < tokens.length; index2 += 1) {
+    const token = tokens[index2].value;
+    if (!token)
+      continue;
+    if (token.startsWith("\\")) {
+      sawSwitch = true;
+      const attachedValueSwitch = parseAttachedNumericSwitch(token);
+      const normalized = (attachedValueSwitch?.switchToken ?? token).toLowerCase();
+      if (normalized === "\\n") {
+        result.sequenceMode = "next";
+        continue;
+      }
+      if (normalized === "\\c") {
+        result.sequenceMode = "current";
+        continue;
+      }
+      if (normalized === "\\h") {
+        result.hideResult = true;
+        continue;
+      }
+      if (normalized === "\\r") {
+        const value$1 = attachedValueSwitch?.value ?? tokens[index2 + 1]?.value;
+        if (value$1 != null && (attachedValueSwitch || !value$1.startsWith("\\"))) {
+          const parsed = parseInteger(value$1);
+          if (parsed != null)
+            result.restartNumber = parsed;
+          if (!attachedValueSwitch)
+            index2 += 1;
+        }
+        continue;
+      }
+      if (normalized === "\\s") {
+        const value$1 = attachedValueSwitch?.value ?? tokens[index2 + 1]?.value;
+        if (value$1 != null && (attachedValueSwitch || !value$1.startsWith("\\"))) {
+          const parsed = parseInteger(value$1);
+          if (parsed != null && parsed >= 1 && parsed <= 9)
+            result.restartLevel = parsed;
+          if (!attachedValueSwitch)
+            index2 += 1;
+        }
+        continue;
+      }
+      const attachedGeneralFormat = parseAttachedGeneralFormatSwitch(token);
+      if (normalized === "\\*" || attachedGeneralFormat != null) {
+        const value$1 = attachedGeneralFormat ?? tokens[index2 + 1]?.value;
+        if (value$1 != null && (attachedGeneralFormat != null || !value$1.startsWith("\\"))) {
+          result.format = value$1;
+          result.hasGeneralFormat = true;
+          applyGeneralFormat(result, value$1);
+          if (attachedGeneralFormat == null)
+            index2 += 1;
+        } else
+          result.unknownSwitches.push(token);
+        continue;
+      }
+      const attachedNumericPicture = parseAttachedNumericPictureSwitch(token);
+      if (normalized === "\\#" || attachedNumericPicture != null) {
+        const value$1 = attachedNumericPicture ?? tokens[index2 + 1]?.value;
+        if (value$1 != null && (attachedNumericPicture != null || !value$1.startsWith("\\"))) {
+          if (result.numericPictureFormat == null)
+            result.numericPictureFormat = { picture: value$1 };
+          else
+            result.unknownSwitches.push(token, value$1);
+          if (attachedNumericPicture == null)
+            index2 += 1;
+        } else
+          result.unknownSwitches.push(token);
+        continue;
+      }
+      result.unknownSwitches.push(token);
+      const value = tokens[index2 + 1]?.value;
+      if (value != null && !value.startsWith("\\")) {
+        result.unknownSwitches.push(value);
+        index2 += 1;
+      }
+      continue;
     }
+    if (!result.identifier) {
+      result.identifier = normalizeSeqIdentifier(token);
+      continue;
+    }
+    if (!sawSwitch && !result.fieldArgument)
+      result.fieldArgument = token;
+  }
+  return result;
+}
+function isSeqInstruction(instruction) {
+  return extractFieldKeyword(instruction) === "SEQ";
+}
+function normalizeSeqIdentifier(identifier) {
+  return typeof identifier === "string" ? identifier.trim() : "";
+}
+function sequenceFieldAttrsFromParsed(parsed) {
   return {
-    identifier,
-    format,
-    restartLevel
+    identifier: parsed.identifier,
+    fieldArgument: parsed.fieldArgument,
+    sequenceMode: parsed.sequenceMode,
+    hideResult: parsed.hideResult,
+    restartNumber: parsed.restartNumber,
+    restartLevel: parsed.restartLevel,
+    format: parsed.hasGeneralFormat ? parsed.format : "ARABIC",
+    hasGeneralFormat: parsed.hasGeneralFormat,
+    pageNumberFieldFormat: parsed.pageNumberFieldFormat ?? null,
+    numericPictureFormat: parsed.numericPictureFormat
+  };
+}
+function tokenizeInstruction(instruction) {
+  const tokens = [];
+  for (const match of instruction.matchAll(TOKEN_PATTERN))
+    tokens.push({ value: match[1] !== undefined ? unescapeQuotedToken(match[1]) : match[0] });
+  return tokens;
+}
+function createEmptyParse(instruction, keyword) {
+  return {
+    instruction,
+    keyword,
+    identifier: "",
+    fieldArgument: "",
+    sequenceMode: "next",
+    hideResult: false,
+    restartNumber: null,
+    restartLevel: null,
+    format: "Arabic",
+    numericPictureFormat: null,
+    hasGeneralFormat: false,
+    unknownSwitches: []
+  };
+}
+function parseInteger(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || !Number.isInteger(number))
+    return null;
+  return Math.trunc(number);
+}
+function parseAttachedNumericSwitch(token) {
+  const match = /^\\([rRsS])([+-]?\d+(?:\.\d+)?)$/.exec(token);
+  if (!match)
+    return null;
+  return {
+    switchToken: `\\${match[1]}`,
+    value: match[2]
+  };
+}
+function parseAttachedGeneralFormatSwitch(token) {
+  return normalizeAttachedSwitchValue(/^\\\*(\S+)$/.exec(token)?.[1]);
+}
+function parseAttachedNumericPictureSwitch(token) {
+  return normalizeAttachedSwitchValue(/^\\#(\S+)$/.exec(token)?.[1]);
+}
+function normalizeAttachedSwitchValue(value) {
+  if (value == null)
+    return null;
+  if (value.startsWith('"') && value.endsWith('"'))
+    return unescapeQuotedToken(value.slice(1, -1));
+  return value;
+}
+function applyGeneralFormat(result, value) {
+  const mapped = GENERAL_FORMATS.get(value) ?? CASE_INSENSITIVE_GENERAL_FORMATS.get(value.toLowerCase());
+  if (mapped)
+    result.pageNumberFieldFormat = { format: mapped };
+}
+function unescapeQuotedToken(value) {
+  return value.replace(/\\(["\\])/g, "$1");
+}
+function buildResultContentNodes(params3, outputMarks) {
+  const { node: node3 } = params3;
+  const resolvedNumber = node3.attrs?.resolvedNumber;
+  if (node3.attrs?.resolvedNumberIsCurrent === true)
+    return typeof resolvedNumber === "string" && resolvedNumber.length > 0 ? [buildResolvedNumberRun(resolvedNumber, outputMarks)] : [];
+  if (Array.isArray(node3.content) && node3.content.length > 0)
+    return node3.content.flatMap((n) => exportSchemaToJson({
+      ...params3,
+      node: n
+    }));
+  return typeof resolvedNumber === "string" && resolvedNumber.length > 0 ? [buildResolvedNumberRun(resolvedNumber, outputMarks)] : [];
+}
+function buildResolvedNumberRun(text$2, outputMarks) {
+  return {
+    name: "w:r",
+    elements: [{
+      name: "w:rPr",
+      elements: outputMarks
+    }, {
+      name: "w:t",
+      elements: [{
+        type: "text",
+        text: text$2
+      }]
+    }]
   };
 }
 function extractResolvedText(content$2) {
@@ -98976,14 +99777,16 @@ function getPageNumberFieldAttrs(node3) {
     attrs.pageNumberFormat = node3.attributes.pageNumberFormat;
   if (node3.attributes?.pageNumberZeroPadding != null)
     attrs.pageNumberZeroPadding = Number(node3.attributes.pageNumberZeroPadding);
+  if (node3.attributes?.pageNumberNumericPicture)
+    attrs.pageNumberNumericPicture = node3.attributes.pageNumberNumericPicture;
   return attrs;
 }
 function resolveCachedPageCount(params3, node3) {
   const cacheMap = params3.statFieldCacheMap;
   if (cacheMap?.has?.("NUMPAGES")) {
     const pageCount = Number(cacheMap.get("NUMPAGES"));
-    if (node3.attrs?.pageNumberFormat || node3.attrs?.pageNumberZeroPadding)
-      return formatPageNumberFieldValue(pageCount, node3.attrs);
+    if (node3.attrs?.pageNumberFormat || node3.attrs?.pageNumberZeroPadding || node3.attrs?.pageNumberNumericPicture)
+      return formatPageNumberFieldValue$1(pageCount, node3.attrs);
     return String(cacheMap.get("NUMPAGES"));
   }
   if (node3.attrs?.resolvedText)
@@ -101902,16 +102705,26 @@ function extractColumns(elements) {
   const equalWidth = equalWidthRaw === "0" || equalWidthRaw === 0 || equalWidthRaw === false ? false : equalWidthRaw === "1" || equalWidthRaw === 1 || equalWidthRaw === true ? true : undefined;
   const columnChildren = Array.isArray(cols.elements) ? cols.elements.filter((child) => child?.name === "w:col") : [];
   const isExplicit = equalWidth === false;
-  const firstChildSpace = columnChildren.find((child) => child?.attributes?.["w:space"] != null)?.attributes?.["w:space"];
-  const gapInches = parseColumnGap(isExplicit ? firstChildSpace ?? 0 : cols.attributes["w:space"]);
-  const widths = columnChildren.map((child) => Number(child.attributes?.["w:w"])).filter((widthTwips) => Number.isFinite(widthTwips) && widthTwips > 0).map((widthTwips) => widthTwips / 1440 * PX_PER_INCH$1);
-  if (isExplicit && widths.length > 0)
-    count2 = Math.min(count2, widths.length);
+  const toPx = (twips) => twips / TWIPS_PER_INCH$2 * PX_PER_INCH$1;
+  const columnRecords = columnChildren.map((child) => {
+    const widthTwips = Number(child.attributes?.["w:w"]);
+    const spaceTwips = Number(child.attributes?.["w:space"]);
+    return {
+      widthTwips,
+      spaceTwips: Number.isFinite(spaceTwips) && spaceTwips > 0 ? spaceTwips : 0
+    };
+  }).filter((record) => Number.isFinite(record.widthTwips) && record.widthTwips > 0);
+  if (isExplicit && columnRecords.length > 0)
+    count2 = Math.min(count2, columnRecords.length);
+  const widths = columnRecords.slice(0, count2).map((record) => toPx(record.widthTwips));
+  const gaps = columnRecords.slice(0, Math.max(0, count2 - 1)).map((record) => toPx(record.spaceTwips));
+  const gapPx = isExplicit ? toPx(columnRecords[0]?.spaceTwips ?? 0) : parseColumnGap(cols.attributes["w:space"]) * PX_PER_INCH$1;
   return {
     count: count2,
-    gap: gapInches * PX_PER_INCH$1,
+    gap: gapPx,
     withSeparator,
     ...isExplicit && widths.length > 0 ? { widths } : {},
+    ...isExplicit && gaps.length > 0 ? { gaps } : {},
     ...equalWidth !== undefined ? { equalWidth } : {}
   };
 }
@@ -102790,6 +103603,64 @@ function normalizeTextInsets(value) {
     left
   };
 }
+function isValidHeadingLevel(value) {
+  return Number.isInteger(value) && value >= 1 && value <= 9;
+}
+function normalizeRestartLevel(value) {
+  return isValidHeadingLevel(value) ? value : null;
+}
+function normalizeRestartNumber(value) {
+  return Number.isFinite(value) && Number.isInteger(value) ? Math.trunc(value) : null;
+}
+function hasFieldArgument(field) {
+  return typeof field?.fieldArgument === "string" && field.fieldArgument.trim().length > 0;
+}
+function formatSeqValue(value, field) {
+  const picture = field?.numericPictureFormat?.picture;
+  if (picture)
+    return formatIntegerWithNumericPicture(value, picture);
+  if (field?.pageNumberFieldFormat)
+    return formatPageNumberFieldValue(value, field.pageNumberFieldFormat);
+  return String(value);
+}
+function resolveSequenceFieldTokens(blocks) {
+  const evaluator = new SequenceFieldEvaluator;
+  for (const block of blocks)
+    resolveBlock$1(block, evaluator);
+}
+function resolveBlock$1(block, evaluator) {
+  if (block.kind === "paragraph") {
+    resolveParagraph(block, evaluator);
+    return;
+  }
+  if (block.kind === "table") {
+    resolveTable2(block, evaluator);
+    return;
+  }
+  if (block.kind === "list")
+    resolveList(block, evaluator);
+}
+function resolveParagraph(block, evaluator) {
+  evaluator.enterParagraph({ paragraphHeadingLevel: block.attrs?.headingLevel });
+  for (const run$1 of block.runs)
+    resolveRun(run$1, evaluator);
+}
+function resolveTable2(block, evaluator) {
+  for (const row of block.rows)
+    for (const cell of row.cells) {
+      const childBlocks = cell.blocks ?? (cell.paragraph ? [cell.paragraph] : []);
+      for (const childBlock of childBlocks)
+        resolveBlock$1(childBlock, evaluator);
+    }
+}
+function resolveList(block, evaluator) {
+  for (const item of block.items)
+    resolveParagraph(item.paragraph, evaluator);
+}
+function resolveRun(run$1, evaluator) {
+  if ("token" in run$1 && run$1.token === "seq" && run$1.seqMetadata)
+    run$1.text = evaluator.evaluateField(run$1.seqMetadata).text;
+}
 function shiftBlockPositions(block, delta) {
   if (block.kind === "paragraph") {
     const paragraphBlock = block;
@@ -103064,11 +103935,13 @@ function getPageNumberFieldFormat(attrs) {
     return;
   const format = typeof attrs.pageNumberFormat === "string" ? attrs.pageNumberFormat : undefined;
   const zeroPadding = typeof attrs.pageNumberZeroPadding === "number" && Number.isFinite(attrs.pageNumberZeroPadding) ? attrs.pageNumberZeroPadding : undefined;
-  if (!format && !zeroPadding)
+  const numericPicture = typeof attrs.pageNumberNumericPicture === "string" && attrs.pageNumberNumericPicture.length > 0 ? attrs.pageNumberNumericPicture : undefined;
+  if (!format && !zeroPadding && !numericPicture)
     return;
   return {
     ...format ? { format } : {},
-    ...zeroPadding ? { zeroPadding } : {}
+    ...zeroPadding != null ? { zeroPadding } : {},
+    ...numericPicture ? { numericPicture } : {}
   };
 }
 function textNodeToRun({ node: node3, positions, storyKey, defaultFont, defaultSize, inheritedMarks = [], sdtMetadata, hyperlinkConfig = DEFAULT_HYPERLINK_CONFIG, themeColors, enableComments, runProperties, inlineRunProperties, converterContext }) {
@@ -104033,10 +104906,17 @@ function pageReferenceNodeToBlock(params3) {
   const instruction = getNodeInstruction(node3) || "";
   const nodeAttrs = typeof node3.attrs === "object" && node3.attrs !== null ? node3.attrs : {};
   const mergedMarks = [...Array.isArray(nodeAttrs.marksAsAttrs) ? nodeAttrs.marksAsAttrs : [], ...inheritedMarks ?? []];
-  const bookmarkMatch = instruction.match(/PAGEREF\s+"?([^"\s\\]+)"?/i);
-  const bookmarkId = bookmarkMatch ? bookmarkMatch[1] : "";
+  const parsed = parsePageRefInstruction(instruction);
+  const bookmarkId = readStringAttr(nodeAttrs.bookmarkId) || parsed.bookmarkId;
+  const hasHyperlinkSwitch = readBooleanAttr(nodeAttrs.hasHyperlinkSwitch) || parsed.hasHyperlinkSwitch;
+  const hasRelativePositionSwitch = readBooleanAttr(nodeAttrs.hasRelativePositionSwitch) || parsed.hasRelativePositionSwitch;
+  const pageNumberFieldFormat = readObjectAttr$1(nodeAttrs.pageNumberFieldFormat) ?? parsed.pageNumberFieldFormat;
+  const numericPictureFormat = readObjectAttr$1(nodeAttrs.numericPictureFormat) ?? parsed.numericPictureFormat;
+  const attrFieldResultFormat = readStringAttr(nodeAttrs.fieldResultFormat);
+  const fieldResultFormat = attrFieldResultFormat === "charformat" || attrFieldResultFormat === "mergeformat" ? attrFieldResultFormat : parsed.fieldResultFormat;
   let runProperties = {};
   if (bookmarkId) {
+    const fieldRunProperties = readObjectAttr$1(nodeAttrs.fieldRunProperties);
     let fallbackText = "??";
     if (Array.isArray(node3.content) && node3.content.length > 0) {
       const extractText = (n) => {
@@ -104050,6 +104930,10 @@ function pageReferenceNodeToBlock(params3) {
       };
       fallbackText = node3.content.map(extractText).join("").trim() || "??";
     }
+    if (fieldResultFormat === "charformat" && fieldRunProperties)
+      runProperties = fieldRunProperties;
+    else if (Object.keys(runProperties).length === 0 && fieldRunProperties)
+      runProperties = fieldRunProperties;
     const pageRefPos = positions.get(node3);
     const resolvedRunProperties = resolveRunProperties(converterContext, runProperties, paragraphProperties, null, false, false);
     const tokenRun = textNodeToRun({
@@ -104069,9 +104953,13 @@ function pageReferenceNodeToBlock(params3) {
     tokenRun.token = "pageReference";
     tokenRun.pageRefMetadata = {
       bookmarkId,
-      instruction
+      instruction,
+      ...hasRelativePositionSwitch ? { relativePosition: true } : {},
+      ...pageNumberFieldFormat ? { pageNumberFieldFormat } : {},
+      ...numericPictureFormat ? { numericPictureFormat } : {},
+      ...fieldResultFormat ? { fieldResultFormat } : {}
     };
-    if (/\\h\b/i.test(instruction)) {
+    if (hasHyperlinkSwitch) {
       const synthesized = buildFlowRunLink({ anchor: bookmarkId });
       if (synthesized)
         tokenRun.link = tokenRun.link ? {
@@ -104086,6 +104974,15 @@ function pageReferenceNodeToBlock(params3) {
   } else if (Array.isArray(node3.content))
     node3.content.forEach((child) => visitNode(child, mergedMarks, sdtMetadata, runProperties, false, parentInlineRunProperties));
 }
+function readStringAttr(value) {
+  return typeof value === "string" ? value : "";
+}
+function readBooleanAttr(value) {
+  return typeof value === "boolean" ? value : undefined;
+}
+function readObjectAttr$1(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
 function fieldAnnotationNodeToRun({ node: node3, positions }) {
   const fieldMetadata = resolveNodeSdtMetadata(node3, "fieldAnnotation");
   let contentText;
@@ -104439,15 +105336,31 @@ function crossReferenceNodeToRun(params3) {
 }
 function sequenceFieldNodeToRun(params3) {
   const { node: node3, positions, sdtMetadata } = params3;
-  const resolvedNumber = (node3.attrs ?? {}).resolvedNumber || "0";
+  const attrs = node3.attrs ?? {};
+  const cachedText = typeof attrs.resolvedNumber === "string" ? attrs.resolvedNumber : "";
   const run$1 = textNodeToRun({
     ...params3,
     node: {
       type: "text",
-      text: resolvedNumber,
+      text: cachedText || "1",
       marks: [...node3.marks ?? []]
     }
   });
+  run$1.token = "seq";
+  run$1.seqMetadata = {
+    identifier: String(attrs.identifier ?? ""),
+    instruction: String(attrs.instruction ?? ""),
+    fieldArgument: String(attrs.fieldArgument ?? ""),
+    sequenceMode: attrs.sequenceMode === "current" ? "current" : "next",
+    hideResult: attrs.hideResult === true,
+    restartNumber: typeof attrs.restartNumber === "number" ? attrs.restartNumber : null,
+    restartLevel: typeof attrs.restartLevel === "number" ? attrs.restartLevel : null,
+    format: typeof attrs.format === "string" ? attrs.format : undefined,
+    hasGeneralFormat: attrs.hasGeneralFormat === true,
+    pageNumberFieldFormat: readObjectAttr(attrs.pageNumberFieldFormat),
+    numericPictureFormat: readObjectAttr(attrs.numericPictureFormat),
+    cachedText
+  };
   const pos = positions.get(node3);
   if (pos) {
     run$1.pmStart = pos.start;
@@ -104457,6 +105370,9 @@ function sequenceFieldNodeToRun(params3) {
     run$1.sdt = sdtMetadata;
   return run$1;
 }
+function readObjectAttr(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
 function documentStatFieldNodeToRun(params3) {
   const { node: node3, positions, sdtMetadata } = params3;
   const attrs = node3.attrs ?? {};
@@ -105718,6 +106634,7 @@ function toFlowBlocks(pmDoc, options) {
   });
   const mergedBlocks = mergeFusedParagraphs(mergeDropCapParagraphs(hydrateImageBlocks(blocks, options?.mediaFiles)));
   stampTrackedChangeColors(mergedBlocks, options?.resolveTrackedChangeColor);
+  resolveSequenceFieldTokens(mergedBlocks);
   flowBlockCache?.commit();
   return {
     blocks: mergedBlocks,
@@ -107363,6 +108280,20 @@ function pxToInches(value) {
     return;
   return value / PIXELS_PER_INCH;
 }
+function toSectionPageNumbering(numbering) {
+  if (!numbering)
+    return;
+  const format = SECTION_PAGE_NUMBER_FORMATS.includes(numbering.format) ? numbering.format : undefined;
+  const result = {
+    start: numbering.start,
+    format,
+    chapterStyle: numbering.chapterStyle,
+    chapterSeparator: numbering.chapterSeparator
+  };
+  if (result.start === undefined && result.format === undefined && result.chapterStyle === undefined && result.chapterSeparator === undefined)
+    return;
+  return result;
+}
 function buildSectionId(index2) {
   return `section-${index2}`;
 }
@@ -107539,7 +108470,7 @@ function sectionRangeToSectionDomain(range, address2, oddEvenHeadersFooters) {
     headerFooterMargins: hasHeaderFooterMargins ? headerFooterMargins : undefined,
     columns: hasColumns ? columns : undefined,
     lineNumbering: parsedLineNumbering,
-    pageNumbering: range.numbering ?? parsedPageNumbering,
+    pageNumbering: toSectionPageNumbering(range.numbering) ?? parsedPageNumbering,
     titlePage: range.titlePg,
     oddEvenHeadersFooters,
     verticalAlign: range.vAlign ?? parsedVerticalAlign,
@@ -113529,7 +114460,7 @@ var isRegExp = (value) => {
       consumed: 1
     };
   }
-}), createSingleIntegerPropertyHandler = (xmlName, sdName = null) => createSingleAttrPropertyHandler(xmlName, sdName, "w:val", parseInteger, integerToString), UNSUPPORTED_TABLE_IDENTITY_ATTRS, parseMeasurementValue = (value, type) => {
+}), createSingleIntegerPropertyHandler = (xmlName, sdName = null) => createSingleAttrPropertyHandler(xmlName, sdName, "w:val", parseInteger$1, integerToString), UNSUPPORTED_TABLE_IDENTITY_ATTRS, parseMeasurementValue = (value, type) => {
   if (value == null)
     return;
   const strValue = String(value);
@@ -113553,19 +114484,19 @@ var isRegExp = (value) => {
     encode: (attributes) => transformEncode(attributes[xmlName]),
     decode: (attributes) => transformDecode(attributes[sdName])
   };
-}, createIntegerAttributeHandler = (xmlName, sdName = null) => createAttributeHandler(xmlName, sdName, parseInteger, integerToString), createBooleanAttributeHandler = (xmlName, sdName = null) => createAttributeHandler(xmlName, sdName, parseBoolean, booleanToString), parseBoolean = (value) => value != null ? [
+}, createIntegerAttributeHandler = (xmlName, sdName = null) => createAttributeHandler(xmlName, sdName, parseInteger$1, integerToString), createBooleanAttributeHandler = (xmlName, sdName = null) => createAttributeHandler(xmlName, sdName, parseBoolean, booleanToString), parseBoolean = (value) => value != null ? [
   "1",
   "true",
   "on",
   1,
   true
-].includes(value) : undefined, booleanToString = (value) => value != null ? value ? "1" : "0" : undefined, parseInteger = (value) => {
+].includes(value) : undefined, booleanToString = (value) => value != null ? value ? "1" : "0" : undefined, parseInteger$1 = (value) => {
   if (value == null)
     return;
   const intValue = parseInt(value, 10);
   return isNaN(intValue) ? undefined : intValue;
 }, integerToString = (value) => {
-  const intValue = parseInteger(value);
+  const intValue = parseInteger$1(value);
   return intValue != null ? String(intValue) : undefined;
 }, translator$46, translator$50, translator$48, translator$79, encode$73 = (attributes) => attributes?.["w:val"], decode$75 = (attrs) => attrs?.underline, attrConfig$29, encode$72 = (attributes) => attributes?.["w:color"], decode$74 = (attrs) => attrs?.color, attrConfig$30, encode$71 = (attributes) => attributes?.["w:themeColor"], decode$73 = (attrs) => attrs?.themeColor, attrConfig$31, encode$70 = (attributes) => attributes?.["w:themeTint"], decode$72 = (attrs) => attrs?.themeTint, attrConfig$32, encode$69 = (attributes) => attributes?.["w:themeShade"], decode$71 = (attrs) => attrs?.themeShade, attributes_default$7, XML_NODE_NAME$41 = "w:u", SD_ATTR_KEY$3 = "underline", encode$68 = (params3, encodedAttrs = {}) => {
   const { nodes } = params3;
@@ -114030,7 +114961,7 @@ var isRegExp = (value) => {
 }, stampTrackedChangeColors = (blocks, resolve2) => {
   for (const block of blocks)
     stampBlockTrackedChangeColors(block, resolve2);
-}, idlessSdtContainerKeys, nextIdlessSdtContainerKey = 0, engines_exports, EMPTY_SDT_PLACEHOLDER_TEXT = "Click or tap here to enter text", FONT_SLOT_THEME_PAIRS, TABLE_STYLE_ID_TABLE_GRID = "TableGrid", TABLE_FALLBACK_BORDER, TABLE_FALLBACK_BORDERS, TABLE_FALLBACK_CELL_PADDING, DEFAULT_TBL_LOOK, CNF_STYLE_MAP, TABLE_STYLE_PRECEDENCE, getToCssFontFamily = () => {
+}, idlessSdtContainerKeys, nextIdlessSdtContainerKey = 0, MAX_BOOKMARK_MARKER_LEAD_DISTANCE = 3, engines_exports, EMPTY_SDT_PLACEHOLDER_TEXT = "Click or tap here to enter text", FONT_SLOT_THEME_PAIRS, TABLE_STYLE_ID_TABLE_GRID = "TableGrid", TABLE_FALLBACK_BORDER, TABLE_FALLBACK_BORDERS, TABLE_FALLBACK_CELL_PADDING, DEFAULT_TBL_LOOK, CNF_STYLE_MAP, TABLE_STYLE_PRECEDENCE, getToCssFontFamily = () => {
   return SuperConverter.toCssFontFamily;
 }, getSpacingStyle = (spacing, isListItem$1) => {
   let { before: before2, after: after2, line, lineRule, beforeAutospacing, afterAutospacing } = spacing;
@@ -119694,8 +120625,7 @@ var isRegExp = (value) => {
   domEnvironment$1 = env || null;
 }, MM_ANISOTROPIC = 8, EMF_SIGNATURE = 1179469088, EMF_PLUS_SIGNATURE = 726027589, EMR_COMMENT = 70, EMF_PLUS_OBJECT = 16392, EMF_PLUS_OBJECT_TYPE_IMAGE = 5, EMF_PLUS_IMAGE_TYPE_BITMAP = 1, EMF_PLUS_BITMAP_TYPE_PIXEL = 0, EMF_PLUS_BITMAP_TYPE_COMPRESSED = 1, EMF_PLUS_PIXEL_FORMAT_INDEXED_FLAG = 65536, EMF_PLUS_PIXEL_FORMAT_24BPP_RGB = 137224, EMF_PLUS_PIXEL_FORMAT_32BPP_RGB = 139273, EMF_PLUS_PIXEL_FORMAT_32BPP_ARGB = 2498570, EMF_PLUS_PIXEL_FORMAT_32BPP_PARGB = 925707, MAX_PIXEL_BITMAP_PIXELS = 1e8, base64ToArrayBuffer, require_common, require_trees, require_adler32, require_crc32, require_messages, require_deflate$1, require_strings, require_zstream, require_deflate, require_inffast, require_inftrees, require_inflate$1, require_constants2, require_gzheader, require_inflate, require_pako, import_UTIF, domEnvironment = null, MAX_PIXEL_COUNT = 1e8, setTiffDomEnvironment = (env) => {
   domEnvironment = env || null;
-}, GENERAL_FORMATS, CASE_INSENSITIVE_GENERAL_FORMATS, getInstructionPreProcessor = (instruction) => {
-  const rawInstructionType = String(instruction ?? "").trim().split(/\s+/)[0];
+}, GENERAL_FORMATS, CASE_INSENSITIVE_GENERAL_FORMATS, TOKEN_PATTERN$1, getInstructionPreProcessor = (instruction) => {
   switch (extractFieldKeyword(instruction)) {
     case "PAGE":
       return preProcessPageInstruction;
@@ -119725,8 +120655,6 @@ var isRegExp = (value) => {
     case "STYLEREF":
       return preProcessStylerefInstruction;
     case "SEQ":
-      if (rawInstructionType !== "SEQ")
-        return null;
       return preProcessSeqInstruction;
     case "CITATION":
       return preProcessCitationInstruction;
@@ -119744,6 +120672,8 @@ var isRegExp = (value) => {
   let collectedNodesStack = [];
   let rawCollectedNodesStack = [];
   let fieldRunRPrStack = [];
+  let firstInstrTextRunRPrStack = [];
+  let firstInstrTextRunSeenStack = [];
   let currentFieldStack = [];
   let unpairedEnd = null;
   let unpairedEndPreserveRaw = null;
@@ -119754,10 +120684,12 @@ var isRegExp = (value) => {
       const collectedNodes = collectedNodesStack.pop().filter((n) => n !== null);
       const rawCollectedNodes = rawCollectedNodesStack.pop().filter((n) => n !== null);
       const fieldRunRPr = fieldRunRPrStack.pop() ?? null;
+      const firstInstrTextRunRPr = firstInstrTextRunRPrStack.pop() ?? null;
+      firstInstrTextRunSeenStack.pop();
       const currentField = currentFieldStack.pop();
       let outputNodes = rawCollectedNodes;
       if (!currentField.preserveRaw) {
-        const combinedResult = _processCombinedNodesForFldChar(collectedNodes, currentField.instrText.trim(), docx, currentField.instructionTokens, fieldRunRPr);
+        const combinedResult = _processCombinedNodesForFldChar(collectedNodes, currentField.instrText.trim(), docx, currentField.instructionTokens, fieldRunRPr, firstInstrTextRunRPr);
         outputNodes = combinedResult.handled ? combinedResult.nodes : rawCollectedNodes;
       } else if (currentField.preserveRawConstructive)
         applyConstructiveFieldInterpretation(outputNodes, currentField.instrText.trim(), docx);
@@ -119819,6 +120751,8 @@ var isRegExp = (value) => {
       rawNodeSourceTokens.set(rawNode, rawSourceToken);
       capturedRawNodes.add(rawNode);
       fieldRunRPrStack.push(extractFieldRunRPr(node3));
+      firstInstrTextRunRPrStack.push(null);
+      firstInstrTextRunSeenStack.push(false);
       currentFieldStack.push({
         instrText: "",
         instructionTokens: [],
@@ -119835,6 +120769,10 @@ var isRegExp = (value) => {
           const fieldRunRPr = extractFieldRunRPr(node3);
           if (fieldRunRPr)
             fieldRunRPrStack[fieldRunRPrStack.length - 1] = fieldRunRPr;
+          if (instrTextEl && !firstInstrTextRunSeenStack[firstInstrTextRunSeenStack.length - 1]) {
+            firstInstrTextRunSeenStack[firstInstrTextRunSeenStack.length - 1] = true;
+            firstInstrTextRunRPrStack[firstInstrTextRunRPrStack.length - 1] = fieldRunRPr;
+          }
           currentField.instructionTokens.push(...instructionTokens);
           const instrTextValue = instrTextEl?.elements?.[0]?.text;
           if (instrTextValue != null)
@@ -119933,14 +120871,15 @@ var isRegExp = (value) => {
     unpairedEnd,
     unpairedEndPreserveRaw
   };
-}, _processCombinedNodesForFldChar = (nodesToCombine = [], instrText, docx, instructionTokens, fieldRunRPr) => {
+}, _processCombinedNodesForFldChar = (nodesToCombine = [], instrText, docx, instructionTokens, fieldRunRPr, firstInstrTextRunRPr) => {
   const instructionPreProcessor = getInstructionPreProcessor(instrText);
   if (instructionPreProcessor)
     return {
       nodes: instructionPreProcessor(nodesToCombine, instrText, {
         docx,
         instructionTokens,
-        fieldRunRPr
+        fieldRunRPr,
+        firstInstrTextRunRPr
       }),
       handled: true
     };
@@ -125310,11 +126249,11 @@ var isRegExp = (value) => {
 }, decode$29 = (attrs) => {
   return attrs.ed;
 }, attrConfig$8, encode$28 = (attributes) => {
-  return parseInteger(attributes["w:colFirst"]);
+  return parseInteger$1(attributes["w:colFirst"]);
 }, decode$28 = (attrs) => {
   return integerToString(attrs.colFirst);
 }, attrConfig$9, encode$27 = (attributes) => {
-  return parseInteger(attributes["w:colLast"]);
+  return parseInteger$1(attributes["w:colLast"]);
 }, decode$27 = (attrs) => {
   return integerToString(attrs.colLast);
 }, attributes_default$3, XML_NODE_NAME$20 = "w:permStart", SD_NODE_NAME$20, encode$26 = (params3, encodedAttrs = {}) => {
@@ -125353,7 +126292,44 @@ var isRegExp = (value) => {
   if (decodedAttrs && Object.keys(decodedAttrs).length)
     result.attributes = decodedAttrs;
   return result;
-}, config$20, translator$16, XML_NODE_NAME$18 = "sd:pageReference", SD_NODE_NAME$18 = "pageReference", encode$22 = (params3) => {
+}, config$20, translator$16, buildInstructionElements = (instruction, instructionTokens) => {
+  const tokens = Array.isArray(instructionTokens) ? instructionTokens : [];
+  if (tokens.length > 0)
+    return tokens.map((tokenLike) => {
+      if (typeof tokenLike === "string")
+        return {
+          name: "w:instrText",
+          attributes: { "xml:space": "preserve" },
+          elements: [{
+            type: "text",
+            text: tokenLike
+          }]
+        };
+      const token = tokenLike;
+      if (token?.type === "tab")
+        return {
+          name: "w:tab",
+          elements: []
+        };
+      const text$2 = token?.text ?? "";
+      return {
+        name: "w:instrText",
+        attributes: { "xml:space": "preserve" },
+        elements: [{
+          type: "text",
+          text: text$2
+        }]
+      };
+    });
+  return [{
+    name: "w:instrText",
+    attributes: { "xml:space": "preserve" },
+    elements: [{
+      type: "text",
+      text: instruction ?? ""
+    }]
+  }];
+}, XML_NODE_NAME$18 = "sd:pageReference", SD_NODE_NAME$18 = "pageReference", encode$22 = (params3) => {
   const { nodes = [], nodeListHandler } = params3 || {};
   const node3 = nodes[0];
   const processedText = nodeListHandler.handler({
@@ -125364,7 +126340,15 @@ var isRegExp = (value) => {
     type: "pageReference",
     attrs: {
       instruction: node3.attributes?.instruction || "",
-      marksAsAttrs: node3.marks || []
+      marksAsAttrs: node3.marks || [],
+      ...node3.attributes?.instructionTokens ? { instructionTokens: node3.attributes.instructionTokens } : {},
+      ...node3.attributes?.bookmarkId ? { bookmarkId: node3.attributes.bookmarkId } : {},
+      ...node3.attributes?.hasHyperlinkSwitch ? { hasHyperlinkSwitch: true } : {},
+      ...node3.attributes?.hasRelativePositionSwitch ? { hasRelativePositionSwitch: true } : {},
+      ...node3.attributes?.pageNumberFieldFormat ? { pageNumberFieldFormat: node3.attributes.pageNumberFieldFormat } : {},
+      ...node3.attributes?.numericPictureFormat ? { numericPictureFormat: node3.attributes.numericPictureFormat } : {},
+      ...node3.attributes?.fieldResultFormat ? { fieldResultFormat: node3.attributes.fieldResultFormat } : {},
+      ...node3.attributes?.fieldRunProperties ? { fieldRunProperties: node3.attributes.fieldRunProperties } : {}
     },
     content: processedText
   };
@@ -125375,6 +126359,8 @@ var isRegExp = (value) => {
     ...params3,
     node: n
   }));
+  const instructionElements = buildInstructionElements(node3.attrs?.instruction, node3.attrs?.instructionTokens);
+  const instructionRunProperties = resolveInstructionRunProperties(params3, outputMarks);
   return [
     {
       name: "w:r",
@@ -125390,15 +126376,8 @@ var isRegExp = (value) => {
       name: "w:r",
       elements: [{
         name: "w:rPr",
-        elements: outputMarks
-      }, {
-        name: "w:instrText",
-        attributes: { "xml:space": "preserve" },
-        elements: [{
-          type: "text",
-          text: `${node3.attrs.instruction}`
-        }]
-      }]
+        elements: instructionRunProperties
+      }, ...instructionElements]
     },
     {
       name: "w:r",
@@ -125422,44 +126401,17 @@ var isRegExp = (value) => {
       }]
     }
   ];
-}, config$19, translator$17, buildInstructionElements = (instruction, instructionTokens) => {
-  const tokens = Array.isArray(instructionTokens) ? instructionTokens : [];
-  if (tokens.length > 0)
-    return tokens.map((tokenLike) => {
-      if (typeof tokenLike === "string")
-        return {
-          name: "w:instrText",
-          attributes: { "xml:space": "preserve" },
-          elements: [{
-            type: "text",
-            text: tokenLike
-          }]
-        };
-      const token = tokenLike;
-      if (token?.type === "tab")
-        return {
-          name: "w:tab",
-          elements: []
-        };
-      const text$2 = token?.text ?? "";
-      return {
-        name: "w:instrText",
-        attributes: { "xml:space": "preserve" },
-        elements: [{
-          type: "text",
-          text: text$2
-        }]
-      };
-    });
-  return [{
-    name: "w:instrText",
-    attributes: { "xml:space": "preserve" },
-    elements: [{
-      type: "text",
-      text: instruction ?? ""
-    }]
-  }];
-}, XML_NODE_NAME$17 = "sd:crossReference", SD_NODE_NAME$17 = "crossReference", encode$21 = (params3) => {
+}, resolveInstructionRunProperties = (params3, outputMarks) => {
+  const { node: node3 } = params3;
+  const fieldRunProperties = node3.attrs?.fieldRunProperties;
+  if (!(node3.attrs?.fieldResultFormat === "charformat" && fieldRunProperties && typeof fieldRunProperties === "object" && !Array.isArray(fieldRunProperties) && Object.keys(fieldRunProperties).length > 0))
+    return outputMarks;
+  const fieldRunPropertiesNode = translator$133.decode({
+    ...params3,
+    node: { attrs: { runProperties: fieldRunProperties } }
+  });
+  return Array.isArray(fieldRunPropertiesNode?.elements) ? fieldRunPropertiesNode.elements : outputMarks;
+}, config$19, translator$17, XML_NODE_NAME$17 = "sd:crossReference", SD_NODE_NAME$17 = "crossReference", encode$21 = (params3) => {
   const { nodes = [], nodeListHandler } = params3 || {};
   const node3 = nodes[0];
   const processedText = nodeListHandler.handler({
@@ -125703,7 +126655,7 @@ var isRegExp = (value) => {
     ...params3,
     node: n
   })), buildInstructionElements(node3.attrs?.instruction, node3.attrs?.instructionTokens), node3.attrs?.wrapperParagraphProperties ?? null);
-}, config$14, translator$22, XML_NODE_NAME$12 = "sd:sequenceField", SD_NODE_NAME$12 = "sequenceField", encode$16 = (params3) => {
+}, config$14, translator$22, TOKEN_PATTERN, XML_NODE_NAME$12 = "sd:sequenceField", SD_NODE_NAME$12 = "sequenceField", encode$16 = (params3) => {
   const { nodes = [], nodeListHandler } = params3 || {};
   const node3 = nodes[0];
   const processedText = nodeListHandler.handler({
@@ -125711,16 +126663,15 @@ var isRegExp = (value) => {
     nodes: node3.elements || []
   });
   const instruction = node3.attributes?.instruction || "";
-  const { identifier, format, restartLevel } = parseSeqInstruction(instruction);
+  const parsedAttrs = sequenceFieldAttrsFromParsed(parseSeqInstruction(instruction));
   return {
     type: SD_NODE_NAME$12,
     attrs: {
       instruction,
       instructionTokens: node3.attributes?.instructionTokens || null,
-      identifier,
-      format,
-      restartLevel,
+      ...parsedAttrs,
       resolvedNumber: extractResolvedText(processedText),
+      resolvedNumberIsCurrent: false,
       marksAsAttrs: node3.marks || []
     },
     content: processedText
@@ -125728,10 +126679,7 @@ var isRegExp = (value) => {
 }, decode$16 = (params3) => {
   const { node: node3 } = params3;
   const outputMarks = processOutputMarks(node3.attrs?.marksAsAttrs || []);
-  const contentNodes = (node3.content ?? []).flatMap((n) => exportSchemaToJson({
-    ...params3,
-    node: n
-  }));
+  const contentNodes = buildResultContentNodes(params3, outputMarks);
   const instructionElements = buildInstructionElements(node3.attrs?.instruction, node3.attrs?.instructionTokens);
   return [
     {
@@ -126671,7 +127619,7 @@ var isRegExp = (value) => {
     }),
     consumed: 1
   };
-}, alternateChoiceHandler, autoPageHandlerEntity, autoTotalPageCountEntity, sectionPageCountEntity, documentStatFieldHandlerEntity, pageReferenceEntity, crossReferenceEntity, handlePictNode = (params3) => {
+}, alternateChoiceHandler, autoPageHandlerEntity, autoTotalPageCountEntity, sectionPageCountEntity, documentStatFieldHandlerEntity, pageReferenceEntity, crossReferenceEntity, sequenceFieldEntity, handlePictNode = (params3) => {
   const { nodes } = params3;
   if (!Array.isArray(nodes) || nodes.length === 0 || nodes[0]?.name !== "w:pict")
     return {
@@ -127584,6 +128532,7 @@ var isRegExp = (value) => {
     documentStatFieldHandlerEntity,
     pageReferenceEntity,
     crossReferenceEntity,
+    sequenceFieldEntity,
     permStartHandlerEntity,
     permEndHandlerEntity,
     mathNodeHandlerEntity,
@@ -128951,6 +129900,83 @@ var isRegExp = (value) => {
     width: typeof maybe.width === "string" && LINE_END_SIZES.has(maybe.width) ? maybe.width : undefined,
     length: typeof maybe.length === "string" && LINE_END_SIZES.has(maybe.length) ? maybe.length : undefined
   };
+}, SequenceFieldEvaluator = class {
+  constructor(options = {}) {
+    this.counters = new Map(options.initialCounters ?? []);
+    this.headingSerialsByLevel = /* @__PURE__ */ new Map;
+    this.lastResetSerialByIdentifierLevel = /* @__PURE__ */ new Map;
+  }
+  enterParagraph(context = {}) {
+    const level = context.paragraphHeadingLevel;
+    if (!isValidHeadingLevel(level))
+      return;
+    this.headingSerialsByLevel.set(level, (this.headingSerialsByLevel.get(level) ?? 0) + 1);
+    for (let deeperLevel = level + 1;deeperLevel <= 9; deeperLevel += 1)
+      this.headingSerialsByLevel.delete(deeperLevel);
+  }
+  evaluateField(field) {
+    const identifier = normalizeSeqIdentifier(field?.identifier);
+    const cachedText = typeof field?.cachedText === "string" ? field.cachedText : "";
+    if (!identifier)
+      return {
+        value: null,
+        text: cachedText,
+        hidden: false
+      };
+    if (hasFieldArgument(field)) {
+      if (cachedText)
+        return {
+          value: null,
+          text: cachedText,
+          hidden: false
+        };
+      if (!this.counters.has(identifier))
+        return {
+          value: null,
+          text: "",
+          hidden: false
+        };
+      const value$1 = this.counters.get(identifier);
+      return {
+        value: value$1,
+        text: formatSeqValue(value$1, field),
+        hidden: false
+      };
+    }
+    const restartLevel = normalizeRestartLevel(field?.restartLevel);
+    if (restartLevel != null) {
+      const key = `${identifier}|${restartLevel}`;
+      const serial = this.headingSerialsByLevel.get(restartLevel) ?? 0;
+      const previousSerial = this.lastResetSerialByIdentifierLevel.get(key);
+      if (previousSerial === undefined || serial !== previousSerial) {
+        this.counters.set(identifier, 0);
+        this.lastResetSerialByIdentifierLevel.set(key, serial);
+      }
+    }
+    const restartNumber = normalizeRestartNumber(field?.restartNumber);
+    let value;
+    if (restartNumber != null) {
+      this.counters.set(identifier, restartNumber);
+      value = restartNumber;
+    } else if (field?.sequenceMode === "current") {
+      if (!this.counters.has(identifier))
+        return {
+          value: 0,
+          text: cachedText,
+          hidden: false
+        };
+      value = this.counters.get(identifier);
+    } else {
+      value = (this.counters.get(identifier) ?? 0) + 1;
+      this.counters.set(identifier, value);
+    }
+    const hidden = Boolean(field?.hideResult && !field.hasGeneralFormat && !field.numericPictureFormat);
+    return {
+      value,
+      text: hidden ? "" : formatSeqValue(value, field),
+      hidden
+    };
+  }
 }, getNodeRevision = (node3) => {
   const attrs = node3?.attrs;
   if (!attrs)
@@ -129516,6 +130542,10 @@ var isRegExp = (value) => {
   const styleOutlineLevel = styleDefinition?.paragraphProperties?.outlineLvl;
   if (typeof styleOutlineLevel === "number" && Number.isInteger(styleOutlineLevel))
     return normalizeHeadingLevel(styleOutlineLevel + 1);
+}, resolveParagraphHeadingLevel = (paragraphProperties, converterContext) => {
+  const properties = paragraphProperties ?? {};
+  const resolvedParagraphProperties = converterContext ? resolveParagraphProperties(converterContext, properties, converterContext.tableInfo) : properties;
+  return resolveHeadingLevel(resolvedParagraphProperties.styleId, resolvedParagraphProperties, converterContext);
 }, TRACKED_CHANGE_KEYS, hasExplicitParagraphRunProperties = (paragraphProperties) => {
   if (paragraphProperties?.runProperties == null)
     return false;
@@ -131618,7 +132648,7 @@ var isRegExp = (value) => {
     return;
   updateGhostListMarkerOffsets(node3, paragraphBlocks, context);
   applyGhostListMarkerOffsets(node3, paragraphBlocks, context);
-}, INLINE_CONVERTERS_REGISTRY, SHAPE_CONVERTERS_REGISTRY, JUSTIFICATION_TO_ALIGN, DEFAULT_FONT = "Times New Roman", DEFAULT_SIZE2, nodeHandlers, converters, CommentMarkName = "commentMark", LINK_MARK_NAME = "link", COMMENT_MARK_NAME, SUPPORTED_INLINE_TYPES, FALLBACK_PREFIX, UUID_LIKE_PATTERN, ALIAS_ELIGIBLE_TYPES, cacheByEditor, OBJECT_REPLACEMENT_CHAR = "", LINE_NUMBER_RESTART_VALUES, PAGE_NUMBER_FORMAT_VALUES, PAGE_NUMBER_CHAPTER_SEPARATOR_VALUES, SECTION_ORIENTATION_VALUES, SECTION_VERTICAL_ALIGN_VALUES, readSectPrHeaderFooterRefs, PIXELS_PER_INCH = 96, SETTINGS_PART_PATH = "word/settings.xml", VALID_EDIT_MODES, DOCUMENT_RELS_PATH = "word/_rels/document.xml.rels", RELS_XMLNS = "http://schemas.openxmlformats.org/package/2006/relationships", HEADER_RELATIONSHIP_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_RELATIONSHIP_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", WORDPROCESSINGML_XMLNS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", OFFICE_DOCUMENT_RELS_XMLNS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", RELATIONSHIP_ID_PATTERN, HEADER_FILE_PATTERN, FOOTER_FILE_PATTERN, SOURCE_HEADER_FOOTER_LOCAL = "header-footer-sync:local", HEADER_PATTERN, FOOTER_PATTERN, DEFAULT_HDR_FTR_ATTRS, HEADER_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", VALID_VARIANTS, FOOTNOTES_PART_ID = "word/footnotes.xml", ENDNOTES_PART_ID = "word/endnotes.xml", FOOTNOTES_CONFIG, ENDNOTES_CONFIG, NOTES_XMLNS, footnotesPartDescriptor, endnotesPartDescriptor, storeByEditor, liveSessionsByHost, cacheByHost, hostStoreSyncedKeys, BODY_LOCATOR, findMarkPosition = (doc$2, pos, markName) => {
+}, INLINE_CONVERTERS_REGISTRY, SHAPE_CONVERTERS_REGISTRY, JUSTIFICATION_TO_ALIGN, DEFAULT_FONT = "Times New Roman", DEFAULT_SIZE2, nodeHandlers, converters, CommentMarkName = "commentMark", LINK_MARK_NAME = "link", COMMENT_MARK_NAME, SUPPORTED_INLINE_TYPES, FALLBACK_PREFIX, UUID_LIKE_PATTERN, ALIAS_ELIGIBLE_TYPES, cacheByEditor, OBJECT_REPLACEMENT_CHAR = "", LINE_NUMBER_RESTART_VALUES, PAGE_NUMBER_FORMAT_VALUES, PAGE_NUMBER_CHAPTER_SEPARATOR_VALUES, SECTION_ORIENTATION_VALUES, SECTION_VERTICAL_ALIGN_VALUES, readSectPrHeaderFooterRefs, PIXELS_PER_INCH = 96, SECTION_PAGE_NUMBER_FORMATS, SETTINGS_PART_PATH = "word/settings.xml", VALID_EDIT_MODES, DOCUMENT_RELS_PATH = "word/_rels/document.xml.rels", RELS_XMLNS = "http://schemas.openxmlformats.org/package/2006/relationships", HEADER_RELATIONSHIP_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_RELATIONSHIP_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", WORDPROCESSINGML_XMLNS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", OFFICE_DOCUMENT_RELS_XMLNS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", RELATIONSHIP_ID_PATTERN, HEADER_FILE_PATTERN, FOOTER_FILE_PATTERN, SOURCE_HEADER_FOOTER_LOCAL = "header-footer-sync:local", HEADER_PATTERN, FOOTER_PATTERN, DEFAULT_HDR_FTR_ATTRS, HEADER_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", VALID_VARIANTS, FOOTNOTES_PART_ID = "word/footnotes.xml", ENDNOTES_PART_ID = "word/endnotes.xml", FOOTNOTES_CONFIG, ENDNOTES_CONFIG, NOTES_XMLNS, footnotesPartDescriptor, endnotesPartDescriptor, storeByEditor, liveSessionsByHost, cacheByHost, hostStoreSyncedKeys, BODY_LOCATOR, findMarkPosition = (doc$2, pos, markName) => {
   const $pos = doc$2.resolve(pos);
   const parent = $pos.parent;
   const start = parent.childAfter($pos.parentOffset);
@@ -131723,7 +132753,7 @@ var isRegExp = (value) => {
       state.kern = kernNode.attributes["w:val"];
   }
 }, SuperConverter;
-var init_SuperConverter_DBsJeu9t_es = __esm(() => {
+var init_SuperConverter_D2zNnC50_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
@@ -148190,7 +149220,7 @@ var init_SuperConverter_DBsJeu9t_es = __esm(() => {
     translator$114
   ];
   translator$116 = NodeTranslator.from(createNestedPropertiesTranslator("w:numPr", "numberingProperties", propertyTranslators$15));
-  translator$121 = NodeTranslator.from(createSingleAttrPropertyHandler("w:outlineLvl", "outlineLvl", "w:val", parseInteger, integerToString));
+  translator$121 = NodeTranslator.from(createSingleAttrPropertyHandler("w:outlineLvl", "outlineLvl", "w:val", parseInteger$1, integerToString));
   translator$122 = NodeTranslator.from(createSingleBooleanPropertyHandler("w:overflowPunct"));
   translator$49 = NodeTranslator.from(createBorderPropertyHandler("w:bar"));
   translator$213 = NodeTranslator.from(createBorderPropertyHandler("w:between"));
@@ -148497,7 +149527,7 @@ var init_SuperConverter_DBsJeu9t_es = __esm(() => {
   };
   translator$6 = NodeTranslator.from(config$32);
   translator$186 = NodeTranslator.from(createMeasurementPropertyHandler("w:tcW", "cellWidth"));
-  translator$73 = NodeTranslator.from(createSingleAttrPropertyHandler("w:gridSpan", null, "w:val", (v) => parseInteger(v) ?? undefined, (v) => integerToString(v)));
+  translator$73 = NodeTranslator.from(createSingleAttrPropertyHandler("w:gridSpan", null, "w:val", (v) => parseInteger$1(v) ?? undefined, (v) => integerToString(v)));
   translator$181 = NodeTranslator.from(createSingleAttrPropertyHandler("w:vMerge", null, "w:val", (val) => !val ? "continue" : val));
   translator$67 = NodeTranslator.from(createBorderPropertyHandler("w:end"));
   translator$206 = NodeTranslator.from(createMeasurementPropertyHandler("w:end", "marginEnd"));
@@ -148611,8 +149641,8 @@ var init_SuperConverter_DBsJeu9t_es = __esm(() => {
     encode: ({ nodes }) => ["1", "true"].includes(nodes[0].attributes?.["w:val"] ?? "1"),
     decode: ({ node: node3 }) => node3.attrs?.cantSplit ? { attributes: {} } : undefined
   });
-  translator$70 = NodeTranslator.from(createSingleAttrPropertyHandler("w:gridAfter", null, "w:val", (v) => parseInteger(v) ?? undefined, (v) => integerToString(v)));
-  translator$71 = NodeTranslator.from(createSingleAttrPropertyHandler("w:gridBefore", null, "w:val", (v) => parseInteger(v) ?? undefined, (v) => integerToString(v)));
+  translator$70 = NodeTranslator.from(createSingleAttrPropertyHandler("w:gridAfter", null, "w:val", (v) => parseInteger$1(v) ?? undefined, (v) => integerToString(v)));
+  translator$71 = NodeTranslator.from(createSingleAttrPropertyHandler("w:gridBefore", null, "w:val", (v) => parseInteger$1(v) ?? undefined, (v) => integerToString(v)));
   translator$76 = NodeTranslator.from(createSingleBooleanPropertyHandler("w:hidden"));
   translator$159 = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "tableCellSpacing"));
   translator$162 = NodeTranslator.from({
@@ -160526,9 +161556,11 @@ var init_SuperConverter_DBsJeu9t_es = __esm(() => {
     ["ROMAN", "upperRoman"],
     ["alphabetic", "lowerLetter"],
     ["ALPHABETIC", "upperLetter"],
-    ["ArabicDash", "numberInDash"]
+    ["ArabicDash", "numberInDash"],
+    ["Ordinal", "ordinal"]
   ]);
   CASE_INSENSITIVE_GENERAL_FORMATS = new Map([["arabic", "decimal"], ["arabicdash", "numberInDash"]]);
+  TOKEN_PATTERN$1 = /"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)'|\\[#*]|\\[^\s]+|[^\s]+/g;
   TRACK_CHANGE_ELEMENT_NAMES = new Set([
     "w:del",
     "w:ins",
@@ -167890,7 +168922,7 @@ var init_SuperConverter_DBsJeu9t_es = __esm(() => {
       "w:bottomFromText",
       "w:tblpX",
       "w:tblpY"
-    ].map((attr) => createAttributeHandler(attr, null, parseInteger, integerToString)).concat([
+    ].map((attr) => createAttributeHandler(attr, null, parseInteger$1, integerToString)).concat([
       "w:horzAnchor",
       "w:vertAnchor",
       "w:tblpXSpec",
@@ -167963,7 +168995,7 @@ var init_SuperConverter_DBsJeu9t_es = __esm(() => {
   translator$204 = NodeTranslator.from(createNestedPropertiesTranslator("w:tblStylePr", "tableStyleProperties", propertyTranslators$2, {}, attributeHandlers$1));
   DEFAULT_CONTENT_WIDTH_TWIPS = 12240 - 2 * 1440;
   MIN_COLUMN_WIDTH_TWIPS = pixelsToTwips(10);
-  translator$72 = NodeTranslator.from(createSingleAttrPropertyHandler("w:gridCol", "col", "w:w", parseInteger, integerToString));
+  translator$72 = NodeTranslator.from(createSingleAttrPropertyHandler("w:gridCol", "col", "w:w", parseInteger$1, integerToString));
   cellMinWidth = pixelsToTwips(10);
   config$25 = {
     xmlName: XML_NODE_NAME$25,
@@ -168199,6 +169231,7 @@ var init_SuperConverter_DBsJeu9t_es = __esm(() => {
     decode: decode$17
   };
   translator$22 = NodeTranslator.from(config$14);
+  TOKEN_PATTERN = /"((?:[^"\\]|\\.)*)"|\\[#*](?=\s|$)|\\[^\s]+|[^\s]+/g;
   config$13 = {
     xmlName: XML_NODE_NAME$12,
     sdNodeOrKeyName: SD_NODE_NAME$12,
@@ -168893,6 +169926,7 @@ var init_SuperConverter_DBsJeu9t_es = __esm(() => {
   documentStatFieldHandlerEntity = generateV2HandlerEntity("documentStatFieldHandler", translator$30);
   pageReferenceEntity = generateV2HandlerEntity("pageReferenceNodeHandler", translator$17);
   crossReferenceEntity = generateV2HandlerEntity("crossReferenceNodeHandler", translator$18);
+  sequenceFieldEntity = generateV2HandlerEntity("sequenceFieldNodeHandler", translator$23);
   pictNodeHandlerEntity = {
     handlerName: "handlePictNode",
     handler: handlePictNode
@@ -169523,6 +170557,14 @@ var init_SuperConverter_DBsJeu9t_es = __esm(() => {
     "both"
   ];
   readSectPrHeaderFooterRefs = readSectPrRefsByKind;
+  SECTION_PAGE_NUMBER_FORMATS = [
+    "decimal",
+    "lowerLetter",
+    "upperLetter",
+    "lowerRoman",
+    "upperRoman",
+    "numberInDash"
+  ];
   VALID_EDIT_MODES = new Set([
     "readOnly",
     "comments",
@@ -170758,7 +171800,7 @@ var init_SuperConverter_DBsJeu9t_es = __esm(() => {
   };
 });
 
-// ../../packages/superdoc/dist/chunks/create-headless-toolbar-BiY_0zZP.es.js
+// ../../packages/superdoc/dist/chunks/create-headless-toolbar-COmoIa5Q.es.js
 function parseSizeUnit(val = "0") {
   const length3 = val.toString() || "0";
   const value = Number.parseFloat(length3);
@@ -181091,8 +182133,8 @@ var CSS_DIMENSION_REGEX, DOM_SIZE_UNITS, normalizeActorId = (value) => {
     }
   };
 };
-var init_create_headless_toolbar_BiY_0zZP_es = __esm(() => {
-  init_SuperConverter_DBsJeu9t_es();
+var init_create_headless_toolbar_COmoIa5Q_es = __esm(() => {
+  init_SuperConverter_D2zNnC50_es();
   init_uuid_qzgm05fK_es();
   init_constants_D9qj59G2_es();
   init_dist_B8HfvhaK_es();
@@ -230255,7 +231297,7 @@ var init_remark_gfm_eZN6yzWQ_es = __esm(() => {
   init_remark_gfm_BhnWr3yf_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-MLERudib.es.js
+// ../../packages/superdoc/dist/chunks/src-eTZqPcFn.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -235236,7 +236278,7 @@ function tableStartFromCell($cell) {
       return $cell.before(d) + 1;
   return null;
 }
-function resolveTable2(tr, tablePos, tableNode) {
+function resolveTable3(tr, tablePos, tableNode) {
   if (tableNode && tableNode.type && tableNode.type.name === "table")
     return tableNode;
   if (typeof tablePos === "number") {
@@ -236277,8 +237319,10 @@ function createTextElement2(textContent$1, textAlign, width, height, options = {
         chapterSeparator: pageNumberChapterSeparator
       });
     }
-    if (part.fieldType === "NUMPAGES")
-      return totalPages != null ? String(totalPages) : "1";
+    if (part.fieldType === "NUMPAGES") {
+      const count2 = totalPages ?? 1;
+      return part.pageNumberFormat ? formatPageNumber(count2, part.pageNumberFormat) : String(count2);
+    }
     if (part.fieldType === "SECTIONPAGES") {
       if (sectionPageCount == null)
         return part.text ?? "1";
@@ -236494,7 +237538,7 @@ function findAllFields(doc$12) {
     const counter = blockOccurrenceCounters.get(blockId) ?? 0;
     blockOccurrenceCounters.set(blockId, counter + 1);
     const fieldType = extractFieldType$1(instruction);
-    const resolvedText = node3.attrs?.resolvedText ?? "";
+    const resolvedText = node3.type.name === "sequenceField" ? node3.attrs?.resolvedNumber ?? "" : node3.attrs?.resolvedText ?? "";
     results.push({
       pos,
       blockId,
@@ -236579,12 +237623,130 @@ function resolveSectionPageCountFieldValue(editor, node3) {
   const pageNumberFormat = typeof node3.attrs?.pageNumberFormat === "string" && node3.attrs.pageNumberFormat ? node3.attrs.pageNumberFormat : undefined;
   const pageNumberZeroPadding = typeof node3.attrs?.pageNumberZeroPadding === "number" && Number.isFinite(node3.attrs.pageNumberZeroPadding) ? node3.attrs.pageNumberZeroPadding : undefined;
   if (pageNumberFormat || pageNumberZeroPadding != null)
-    return formatPageNumberFieldValue$1(Number(sectionPageCount) || 1, {
+    return formatPageNumberFieldValue(Number(sectionPageCount) || 1, {
       ...pageNumberFormat ? { format: pageNumberFormat } : {},
       ...pageNumberZeroPadding != null ? { zeroPadding: pageNumberZeroPadding } : {}
     });
   return String(sectionPageCount);
 }
+function updateSequenceFieldsInTransaction(args$1) {
+  const { tr, scope = { kind: "all" }, converterContext } = args$1;
+  const sequenceFieldType = args$1.schema.nodes.sequenceField;
+  if (!sequenceFieldType)
+    return {
+      changed: false,
+      updated: 0
+    };
+  const evaluator = new SequenceFieldEvaluator;
+  let changed = false;
+  let updated = 0;
+  tr.doc.descendants((node3, pos) => {
+    if (node3.type.name === "paragraph") {
+      evaluator.enterParagraph({ paragraphHeadingLevel: resolveNodeHeadingLevel(node3, converterContext) });
+      return true;
+    }
+    if (node3.type !== sequenceFieldType)
+      return true;
+    const nextAttrs = buildEvaluatedSequenceAttrs(node3);
+    const evaluation = evaluator.evaluateField({
+      identifier: nextAttrs.identifier,
+      instruction: nextAttrs.instruction,
+      fieldArgument: nextAttrs.fieldArgument,
+      sequenceMode: nextAttrs.sequenceMode,
+      hideResult: nextAttrs.hideResult,
+      restartNumber: nextAttrs.restartNumber,
+      restartLevel: nextAttrs.restartLevel,
+      format: nextAttrs.format,
+      hasGeneralFormat: nextAttrs.hasGeneralFormat,
+      pageNumberFieldFormat: nextAttrs.pageNumberFieldFormat,
+      numericPictureFormat: nextAttrs.numericPictureFormat,
+      cachedText: typeof node3.attrs.resolvedNumber === "string" ? node3.attrs.resolvedNumber : ""
+    });
+    if (!shouldWriteSequenceField(node3, pos, scope, nextAttrs.identifier))
+      return true;
+    nextAttrs.resolvedNumber = evaluation.text;
+    nextAttrs.resolvedNumberIsCurrent = true;
+    if (!attrsEqual(node3.attrs, nextAttrs)) {
+      tr.setNodeMarkup(resolveCurrentTransactionPos(tr, pos, node3), undefined, nextAttrs);
+      changed = true;
+    }
+    updated += 1;
+    return true;
+  });
+  return {
+    changed,
+    updated
+  };
+}
+function getSequenceFieldUpdaterConverterContext(editor) {
+  const converter = editor?.converter;
+  if (!converter?.translatedLinkedStyles)
+    return;
+  return {
+    translatedLinkedStyles: converter.translatedLinkedStyles,
+    translatedNumbering: converter.translatedNumbering ?? {},
+    docx: converter.docx
+  };
+}
+function resolveNodeHeadingLevel(node3, converterContext) {
+  const paragraphProperties = node3.attrs?.paragraphProperties;
+  if (converterContext)
+    return resolveParagraphHeadingLevel(isRecord$3(paragraphProperties) ? paragraphProperties : undefined, converterContext);
+}
+function buildEvaluatedSequenceAttrs(node3) {
+  const instruction = typeof node3.attrs.instruction === "string" ? node3.attrs.instruction : "";
+  const parsedAttrs = sequenceFieldAttrsFromParsed(parseSeqInstruction(instruction));
+  return {
+    ...node3.attrs,
+    instruction,
+    ...parsedAttrs,
+    identifier: parsedAttrs.identifier || readStringAttr2(node3, "identifier")
+  };
+}
+function shouldWriteSequenceField(node3, pos, scope, identifier) {
+  if (scope.kind === "all")
+    return true;
+  if (scope.kind === "range") {
+    const end$1 = pos + node3.nodeSize;
+    return pos < scope.to && end$1 > scope.from;
+  }
+  return normalizeSeqIdentifier(identifier) === normalizeSeqIdentifier(scope.identifier);
+}
+function readStringAttr2(node3, key2) {
+  const value = node3.attrs?.[key2];
+  return typeof value === "string" ? value : "";
+}
+function attrsEqual(left$1, right$1) {
+  const keys$1 = new Set([...Object.keys(left$1), ...Object.keys(right$1)]);
+  for (const key2 of keys$1)
+    if (!valuesEqual(left$1[key2], right$1[key2]))
+      return false;
+  return true;
+}
+function valuesEqual(left$1, right$1) {
+  if (Object.is(left$1, right$1))
+    return true;
+  if (!isRecord$3(left$1) || !isRecord$3(right$1))
+    return false;
+  const keys$1 = new Set([...Object.keys(left$1), ...Object.keys(right$1)]);
+  for (const key2 of keys$1)
+    if (!valuesEqual(left$1[key2], right$1[key2]))
+      return false;
+  return true;
+}
+function resolveCurrentTransactionPos(tr, pos, node3) {
+  if (tr.doc.nodeAt(pos)?.type === node3.type)
+    return pos;
+  return tr.mapping.map(pos);
+}
+function isRecord$3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function resolveTotalPageNumberFieldValue(stats, node3) {
+  if (stats.pages == null)
+    return null;
+  return formatPageNumberFieldValue(stats.pages, getPageNumberFieldFormat(node3.attrs));
+}
 function createCascadeToggleCommands({ markName, setCommand, unsetCommand, toggleCommand, negationAttrs, isNegation, extendEmptyMarkRange } = {}) {
   if (!markName)
     throw new Error("createCascadeToggleCommands requires a markName");
@@ -266119,7 +267281,7 @@ function isCaptionParagraph(node3) {
   const seqField = findSeqField(node3);
   if (!seqField)
     return false;
-  return (seqField.attrs?.instruction ?? "").trim().startsWith("SEQ ");
+  return isSeqInstruction(seqField.attrs?.instruction ?? "");
 }
 function findSeqField(node3) {
   let seqNode = null;
@@ -266271,14 +267433,17 @@ function captionsInsertWrapper(editor, input2, options) {
     const children = [];
     const schema = editor.schema;
     children.push(schema.text(`${label} `));
-    if (schema.nodes.sequenceField)
+    if (schema.nodes.sequenceField) {
+      const instruction = `SEQ ${label} \\* ARABIC`;
+      const parsed = parseSeqInstruction(instruction);
       children.push(schema.nodes.sequenceField.create({
-        instruction: `SEQ ${label} \\* ARABIC`,
-        identifier: label,
-        format: "ARABIC",
+        instruction,
+        ...sequenceFieldAttrsFromParsed(parsed),
         resolvedNumber: "",
+        resolvedNumberIsCurrent: false,
         sdBlockId: `seq-${Date.now()}`
       }));
+    }
     if (input2.text) {
       const captionContent = buildTextWithTabs(schema, `: ${input2.text}`, undefined);
       if (captionContent instanceof Fragment)
@@ -266289,6 +267454,15 @@ function captionsInsertWrapper(editor, input2, options) {
     const captionParagraph = schema.nodes.paragraph.create(buildCaptionParagraphAttrs(nodeId), children);
     const { tr } = editor.state;
     tr.insert(pos, captionParagraph);
+    updateSequenceFieldsInTransaction({
+      tr,
+      schema,
+      scope: {
+        kind: "identifier",
+        identifier: label
+      },
+      converterContext: getSequenceFieldUpdaterConverterContext(editor)
+    });
     editor.dispatch(tr);
     clearIndexCache(editor);
     return true;
@@ -266365,18 +267539,29 @@ function captionsConfigureWrapper(editor, input2, options) {
         return true;
       const format = CAPTION_FORMAT_TO_OOXML[input2.format ?? "decimal"] ?? "ARABIC";
       const newInstruction = `SEQ ${input2.label} \\* ${format}`;
-      if (node3.attrs.instruction === newInstruction && node3.attrs.format === format)
+      const parsedAttrs = sequenceFieldAttrsFromParsed(parseSeqInstruction(newInstruction));
+      if (node3.attrs.instruction === newInstruction && node3.attrs.format === format && JSON.stringify(node3.attrs.pageNumberFieldFormat) === JSON.stringify(parsedAttrs.pageNumberFieldFormat))
         return true;
       tr.setNodeMarkup(tr.mapping.map(pos), undefined, {
         ...node3.attrs,
         instruction: newInstruction,
-        format
+        ...parsedAttrs,
+        resolvedNumberIsCurrent: false
       });
       changed = true;
       return true;
     });
     if (!changed)
       return false;
+    updateSequenceFieldsInTransaction({
+      tr,
+      schema: editor.schema,
+      scope: {
+        kind: "identifier",
+        identifier: input2.label
+      },
+      converterContext: getSequenceFieldUpdaterConverterContext(editor)
+    });
     editor.dispatch(tr);
     clearIndexCache(editor);
     return true;
@@ -266437,7 +267622,7 @@ function fieldsInsertWrapper(editor, input2, options) {
   if (DOCUMENT_STAT_FIELD_TYPES.has(fieldType))
     return insertDocumentStatField(editor, input2, resolved, options);
   if (fieldType === "NUMPAGES")
-    return insertNumPagesField(editor, resolved, options);
+    return insertNumPagesField(editor, input2, resolved, options);
   if (fieldType === "SECTIONPAGES")
     return insertSectionPagesField(editor, input2, resolved, options);
   return insertRawField(editor, input2, resolved, options);
@@ -266463,14 +267648,15 @@ function insertDocumentStatField(editor, input2, resolved, options) {
     return fieldFailure("NO_OP", "Insert produced no change.");
   return fieldSuccess(computeFieldAddress(editor.state.doc, resolved.from));
 }
-function insertNumPagesField(editor, resolved, options) {
+function insertNumPagesField(editor, input2, resolved, options) {
   if (!Boolean(editor.options?.isHeaderOrFooter))
     return fieldFailure("INVALID_INPUT", "fields.insert: NUMPAGES insertion is only supported in headers/footers.");
   const nodeType = editor.schema.nodes["total-page-number"];
   if (!nodeType)
     throw new DocumentApiAdapterError("CAPABILITY_UNAVAILABLE", "fields.insert: total-page-number node type not in schema.");
+  const parsedInstruction = parsePageNumberFieldSwitches(input2.instruction, "NUMPAGES");
   if (!receiptApplied$2(executeDomainCommand(editor, () => {
-    const node3 = nodeType.create({});
+    const node3 = nodeType.create(parsedInstruction);
     const { tr } = editor.state;
     tr.insert(resolved.from, node3);
     editor.dispatch(tr);
@@ -266513,7 +267699,14 @@ function insertRawField(editor, input2, resolved, options) {
     throw new DocumentApiAdapterError("CAPABILITY_UNAVAILABLE", "fields.insert: sequenceField node type not in schema.");
   if (!receiptApplied$2(executeDomainCommand(editor, () => {
     const fieldType = extractFieldType(input2.instruction);
-    const node3 = fieldNodeType.create({
+    const parsed = isSeqInstruction(input2.instruction) ? parseSeqInstruction(input2.instruction) : null;
+    const node3 = fieldNodeType.create(parsed ? {
+      instruction: input2.instruction,
+      ...sequenceFieldAttrsFromParsed(parsed),
+      resolvedNumber: "",
+      resolvedNumberIsCurrent: false,
+      sdBlockId: `field-${Date.now()}`
+    } : {
       instruction: input2.instruction,
       identifier: fieldType,
       format: "ARABIC",
@@ -266522,6 +267715,16 @@ function insertRawField(editor, input2, resolved, options) {
     });
     const { tr } = editor.state;
     tr.insert(resolved.from, node3);
+    if (parsed)
+      updateSequenceFieldsInTransaction({
+        tr,
+        schema: editor.schema,
+        scope: {
+          kind: "identifier",
+          identifier: parsed.identifier
+        },
+        converterContext: getSequenceFieldUpdaterConverterContext(editor)
+      });
     editor.dispatch(tr);
     clearIndexCache(editor);
     return true;
@@ -266549,6 +267752,8 @@ function fieldsRebuildWrapper(editor, input2, options) {
     return rebuildTotalPageNumber(editor, resolved, address2, options);
   if (node3.type.name === "section-page-count")
     return rebuildSectionPageCount(editor, resolved, address2, options);
+  if (node3.type.name === "sequenceField" && isSeqInstruction(node3.attrs?.instruction ?? ""))
+    return rebuildSequenceFields(editor, address2, options);
   if (!receiptApplied$2(executeDomainCommand(editor, () => {
     const { tr } = editor.state;
     const currentNode = tr.doc.nodeAt(resolved.pos);
@@ -266565,6 +267770,22 @@ function fieldsRebuildWrapper(editor, input2, options) {
     return fieldFailure("NO_OP", "Rebuild produced no change.");
   return fieldSuccess(address2);
 }
+function rebuildSequenceFields(editor, address2, options) {
+  executeDomainCommand(editor, () => {
+    const { tr } = editor.state;
+    if (updateSequenceFieldsInTransaction({
+      tr,
+      schema: editor.schema,
+      scope: { kind: "all" },
+      converterContext: getSequenceFieldUpdaterConverterContext(editor)
+    }).changed) {
+      editor.dispatch(tr);
+      clearIndexCache(editor);
+    }
+    return true;
+  }, { expectedRevision: options?.expectedRevision });
+  return fieldSuccess(address2);
+}
 function rebuildDocumentStatField(editor, resolved, address2, options) {
   const stats = getWordStatistics(resolveMainBodyEditor(editor));
   const node3 = editor.state.doc.nodeAt(resolved.pos);
@@ -266591,7 +267812,10 @@ function rebuildTotalPageNumber(editor, resolved, address2, options) {
   const stats = getWordStatistics(resolveMainBodyEditor(editor));
   if (stats.pages == null)
     return fieldSuccess(address2);
-  const freshValue = String(stats.pages);
+  const node3 = editor.state.doc.nodeAt(resolved.pos);
+  if (!node3)
+    return fieldFailure("TARGET_NOT_FOUND", "Node not found.");
+  const freshValue = formatPageNumberFieldValue(stats.pages, getPageNumberFieldFormat(node3.attrs));
   if (!receiptApplied$2(executeDomainCommand(editor, () => {
     const { tr } = editor.state;
     const currentNode = tr.doc.nodeAt(resolved.pos);
@@ -271874,6 +273098,30 @@ function resolveDrawingItem(fragment2, fragmentIndex, pageIndex, blockMap) {
     item.pmEnd = fragment2.pmEnd;
   return item;
 }
+function resolvePageRefText(args$1) {
+  const formattedTargetPageText = formatTargetPageText(args$1.target, args$1.metadata);
+  if (!args$1.metadata.relativePosition)
+    return formattedTargetPageText;
+  if (args$1.sourcePage !== args$1.target.physicalPage)
+    return `on page ${formattedTargetPageText}`;
+  return args$1.target.pmPosition != null && args$1.sourcePmPosition != null && args$1.target.pmPosition < args$1.sourcePmPosition ? "above" : "below";
+}
+function formatTargetPageText(target, metadata) {
+  const displayNumber = Math.max(1, Math.trunc(Number.isFinite(target.displayNumber) ? target.displayNumber : 1));
+  if (metadata.numericPictureFormat)
+    return formatChapterPageNumberText({
+      pageComponent: formatIntegerWithNumericPicture(displayNumber, metadata.numericPictureFormat.picture),
+      chapterNumberText: target.chapterNumberText,
+      chapterSeparator: target.chapterSeparator
+    });
+  if (metadata.pageNumberFieldFormat)
+    return formatChapterPageNumberText({
+      pageComponent: formatPageNumberFieldValue(displayNumber, metadata.pageNumberFieldFormat),
+      chapterNumberText: target.chapterNumberText,
+      chapterSeparator: target.chapterSeparator
+    });
+  return target.displayText;
+}
 function buildBlockMap(blocks2, measures) {
   const map$12 = /* @__PURE__ */ new Map;
   for (let i4 = 0;i4 < blocks2.length; i4++)
@@ -271883,6 +273131,257 @@ function buildBlockMap(blocks2, measures) {
     });
   return map$12;
 }
+function resolveParagraphPageRefs(fragment2, block, measure, context) {
+  const runTexts = collectResolvedPageRefRunTexts(block, context);
+  if (runTexts.size === 0)
+    return {
+      block,
+      fragment: fragment2,
+      changed: false
+    };
+  const nextRuns = resolvePageRefRuns(block, runTexts);
+  const nextLines = (fragment2.lines ?? measure.lines.slice(fragment2.fromLine, fragment2.toLine)).map((line) => adjustLineForResolvedPageRefs(line, runTexts));
+  return {
+    block: {
+      ...block,
+      runs: nextRuns
+    },
+    fragment: {
+      ...fragment2,
+      lines: nextLines
+    },
+    changed: true
+  };
+}
+function resolveParagraphPageRefBlock(block, measure, context) {
+  const runTexts = collectResolvedPageRefRunTexts(block, context);
+  if (runTexts.size === 0)
+    return {
+      block,
+      changed: false
+    };
+  return {
+    block: {
+      ...block,
+      runs: resolvePageRefRuns(block, runTexts)
+    },
+    measure: measure ? {
+      ...measure,
+      lines: measure.lines.map((line) => adjustLineForResolvedPageRefs(line, runTexts))
+    } : undefined,
+    changed: true
+  };
+}
+function collectResolvedPageRefRunTexts(block, context) {
+  const runTexts = /* @__PURE__ */ new Map;
+  if (!context?.anchorMap?.size)
+    return runTexts;
+  block.runs.forEach((run2, index2) => {
+    if (!isPageReferenceTextRun(run2))
+      return;
+    const target = context.anchorMap?.get(run2.pageRefMetadata.bookmarkId);
+    if (!target)
+      return;
+    const resolvedText = resolvePageRefText({
+      sourcePage: context.sourcePage,
+      sourcePmPosition: run2.pmStart,
+      target,
+      metadata: run2.pageRefMetadata
+    });
+    if (resolvedText !== run2.text)
+      runTexts.set(index2, {
+        text: resolvedText,
+        originalLength: run2.text.length
+      });
+  });
+  return runTexts;
+}
+function resolvePageRefRuns(block, runTexts) {
+  return block.runs.map((run2, index2) => runTexts.has(index2) && isTextRun$5(run2) ? {
+    ...run2,
+    text: runTexts.get(index2).text
+  } : run2);
+}
+function resolveTablePageRefs(block, measure, context) {
+  if (!context?.anchorMap?.size)
+    return {
+      block,
+      changed: false
+    };
+  let changed = false;
+  let measureChanged = false;
+  const measureRows = measure?.rows.slice();
+  const rows = block.rows.map((row2, rowIndex) => {
+    let rowChanged = false;
+    const measureRow = measureRows?.[rowIndex];
+    const measureCells = measureRow?.cells.slice();
+    const cells = row2.cells.map((cell2, cellIndex) => {
+      let cellChanged = false;
+      let nextParagraph = cell2.paragraph;
+      let nextCellMeasure = measureCells?.[cellIndex];
+      if (cell2.paragraph) {
+        const resolved = resolveParagraphPageRefBlock(cell2.paragraph, nextCellMeasure?.paragraph, context);
+        nextParagraph = resolved.block;
+        if (resolved.measure && nextCellMeasure)
+          nextCellMeasure = {
+            ...nextCellMeasure,
+            paragraph: resolved.measure
+          };
+        cellChanged ||= resolved.changed;
+      }
+      let nextBlocks = cell2.blocks;
+      let nextBlockMeasures = nextCellMeasure?.blocks;
+      if (cell2.blocks)
+        nextBlocks = cell2.blocks.map((childBlock, childIndex) => {
+          const childMeasure = nextBlockMeasures?.[childIndex];
+          if (childBlock.kind === "paragraph") {
+            const resolved = resolveParagraphPageRefBlock(childBlock, childMeasure?.kind === "paragraph" ? childMeasure : undefined, context);
+            if (resolved.measure && nextBlockMeasures) {
+              nextBlockMeasures = nextBlockMeasures.slice();
+              nextBlockMeasures[childIndex] = resolved.measure;
+            }
+            cellChanged ||= resolved.changed;
+            return resolved.block;
+          }
+          if (childBlock.kind === "table") {
+            const resolved = resolveTablePageRefs(childBlock, childMeasure?.kind === "table" ? childMeasure : undefined, context);
+            if (resolved.measure && nextBlockMeasures) {
+              nextBlockMeasures = nextBlockMeasures.slice();
+              nextBlockMeasures[childIndex] = resolved.measure;
+            }
+            cellChanged ||= resolved.changed;
+            return resolved.block;
+          }
+          return childBlock;
+        });
+      if (!cellChanged)
+        return cell2;
+      rowChanged = true;
+      if (nextCellMeasure && measureCells) {
+        if (nextBlockMeasures && nextBlockMeasures !== nextCellMeasure.blocks)
+          nextCellMeasure = {
+            ...nextCellMeasure,
+            blocks: nextBlockMeasures
+          };
+        measureCells[cellIndex] = nextCellMeasure;
+        measureChanged = true;
+      }
+      return {
+        ...cell2,
+        ...nextParagraph ? { paragraph: nextParagraph } : {},
+        ...nextBlocks ? { blocks: nextBlocks } : {}
+      };
+    });
+    if (!rowChanged)
+      return row2;
+    changed = true;
+    if (measureRow && measureCells && measureCells !== measureRow.cells)
+      measureRows[rowIndex] = {
+        ...measureRow,
+        cells: measureCells
+      };
+    return {
+      ...row2,
+      cells
+    };
+  });
+  return changed ? {
+    block: {
+      ...block,
+      rows
+    },
+    measure: measure && measureChanged && measureRows ? {
+      ...measure,
+      rows: measureRows
+    } : measure,
+    changed: true
+  } : {
+    block,
+    changed: false
+  };
+}
+function resolveListItemPageRefs(block, itemId, measure, context) {
+  if (!context?.anchorMap?.size)
+    return {
+      block,
+      changed: false
+    };
+  let changed = false;
+  let measureChanged = false;
+  const measureItems = measure?.items.slice();
+  const items = block.items.map((item) => {
+    if (item.id !== itemId)
+      return item;
+    const itemMeasureIndex = measureItems?.findIndex((candidate) => candidate.itemId === itemId) ?? -1;
+    const itemMeasure = itemMeasureIndex >= 0 ? measureItems?.[itemMeasureIndex] : undefined;
+    const resolved = resolveParagraphPageRefBlock(item.paragraph, itemMeasure?.paragraph, context);
+    if (!resolved.changed)
+      return item;
+    if (resolved.measure && itemMeasure && measureItems) {
+      measureItems[itemMeasureIndex] = {
+        ...itemMeasure,
+        paragraph: resolved.measure
+      };
+      measureChanged = true;
+    }
+    changed = true;
+    return {
+      ...item,
+      paragraph: resolved.block
+    };
+  });
+  return changed ? {
+    block: {
+      ...block,
+      items
+    },
+    measure: measure && measureChanged && measureItems ? {
+      ...measure,
+      items: measureItems
+    } : measure,
+    changed: true
+  } : {
+    block,
+    changed: false
+  };
+}
+function isTextRun$5(run2) {
+  return (run2.kind === "text" || run2.kind === undefined) && "text" in run2;
+}
+function isPageReferenceTextRun(run2) {
+  return isTextRun$5(run2) && run2.token === "pageReference" && run2.pageRefMetadata != null;
+}
+function adjustLineForResolvedPageRefs(line, runTexts) {
+  let changed = false;
+  const nextLine = { ...line };
+  for (const [runIndex, resolved] of runTexts) {
+    if (runIndex < line.fromRun || runIndex > line.toRun)
+      continue;
+    changed = true;
+    if (line.fromRun === runIndex)
+      nextLine.fromChar = clampResolvedRunBoundary(line.fromChar, resolved);
+    if (line.toRun === runIndex)
+      nextLine.toChar = clampResolvedRunBoundary(line.toChar, resolved);
+  }
+  if (line.segments?.length)
+    nextLine.segments = line.segments.map((segment) => {
+      const resolved = runTexts.get(segment.runIndex);
+      if (resolved == null)
+        return segment;
+      changed = true;
+      return {
+        ...segment,
+        fromChar: clampResolvedRunBoundary(segment.fromChar, resolved),
+        toChar: clampResolvedRunBoundary(segment.toChar, resolved)
+      };
+    });
+  return changed ? nextLine : line;
+}
+function clampResolvedRunBoundary(offset$1, resolved) {
+  if (offset$1 === resolved.originalLength)
+    return resolved.text.length;
+  return Math.min(offset$1, resolved.text.length);
+}
 function sumLineHeights$2(lines, from$1, to) {
   let total = 0;
   for (let i4 = from$1;i4 < to && i4 < lines.length; i4++)
@@ -271937,13 +273436,16 @@ function resolveFragmentId(fragment2) {
     }
   }
 }
-function resolveParagraphContentIfApplicable(fragment2, blockMap) {
+function resolveParagraphContentIfApplicable(fragment2, blockMap, pageRefContext) {
   if (fragment2.kind !== "para")
     return;
   const entry = blockMap.get(fragment2.blockId);
   if (!entry || entry.block.kind !== "paragraph" || entry.measure.kind !== "paragraph")
     return;
-  return resolveParagraphContent(fragment2, entry.block, entry.measure);
+  const paragraphBlock = entry.block;
+  const paragraphMeasure = entry.measure;
+  const resolvedPageRefs = resolveParagraphPageRefs(fragment2, paragraphBlock, paragraphMeasure, pageRefContext);
+  return resolveParagraphContent(resolvedPageRefs.fragment, resolvedPageRefs.block, paragraphMeasure);
 }
 function resolveFragmentParagraphBorders(fragment2, blockMap) {
   const entry = blockMap.get(fragment2.blockId);
@@ -271978,11 +273480,14 @@ function computeBlockVersion(blockId, blockMap, cache$2, fontSignature = "") {
     cache$2.set(blockId, "missing");
     return "missing";
   }
-  const version$1 = deriveBlockVersion(entry.block);
-  const versioned = fontSignature ? `${fontSignature}|${version$1}` : version$1;
+  const versioned = deriveFontAwareBlockVersion(entry.block, fontSignature);
   cache$2.set(blockId, versioned);
   return versioned;
 }
+function deriveFontAwareBlockVersion(block, fontSignature = "") {
+  const version$1 = deriveBlockVersion(block);
+  return fontSignature ? `${fontSignature}|${version$1}` : version$1;
+}
 function applyPaintVersions(item, visualVersion) {
   const evidenceVersion = sourceAnchorSignature(item.sourceAnchor);
   item.version = visualVersion;
@@ -271992,19 +273497,25 @@ function applyPaintVersions(item, visualVersion) {
   } else
     item.paintCacheVersion = visualVersion;
 }
-function resolveFragmentItem(fragment2, fragmentIndex, pageIndex, blockMap, blockVersionCache, story, fontSignature = "") {
+function resolveFragmentItem(fragment2, fragmentIndex, pageIndex, blockMap, blockVersionCache, story, fontSignature = "", pageRefContext) {
   const sdtContainerKey = resolveFragmentSdtContainerKey(fragment2, blockMap);
   const version$1 = fragmentSignature(fragment2, computeBlockVersion(fragment2.blockId, blockMap, blockVersionCache, fontSignature));
   const layoutSourceIdentity = resolveFragmentLayoutIdentity(fragment2, story);
   switch (fragment2.kind) {
     case "table": {
       const item = resolveTableItem(fragment2, fragmentIndex, pageIndex, blockMap);
+      const tablePageRefs = resolveTablePageRefs(item.block, item.measure, pageRefContext);
+      if (tablePageRefs.changed) {
+        item.block = tablePageRefs.block;
+        if (tablePageRefs.measure)
+          item.measure = tablePageRefs.measure;
+      }
       if (sdtContainerKey != null)
         item.sdtContainerKey = sdtContainerKey;
       if (fragment2.sourceAnchor != null)
         item.sourceAnchor = fragment2.sourceAnchor;
       item.layoutSourceIdentity = layoutSourceIdentity;
-      applyPaintVersions(item, version$1);
+      applyPaintVersions(item, tablePageRefs.changed ? fragmentSignature(fragment2, deriveFontAwareBlockVersion(tablePageRefs.block, fontSignature)) : version$1);
       return item;
     }
     case "image": {
@@ -272028,6 +273539,10 @@ function resolveFragmentItem(fragment2, fragmentIndex, pageIndex, blockMap, bloc
       return item;
     }
     default: {
+      const entry = blockMap.get(fragment2.blockId);
+      const paragraphPageRefs = fragment2.kind === "para" && entry?.block.kind === "paragraph" && entry.measure.kind === "paragraph" ? resolveParagraphPageRefs(fragment2, entry.block, entry.measure, pageRefContext) : null;
+      const listPageRefs = fragment2.kind === "list-item" && entry?.block.kind === "list" ? resolveListItemPageRefs(entry.block, fragment2.itemId, entry.measure.kind === "list" ? entry.measure : undefined, pageRefContext) : null;
+      const itemVersion = paragraphPageRefs?.changed ? fragmentSignature(paragraphPageRefs.fragment, deriveFontAwareBlockVersion(paragraphPageRefs.block, fontSignature)) : listPageRefs?.changed ? fragmentSignature(fragment2, deriveFontAwareBlockVersion(listPageRefs.block, fontSignature)) : version$1;
       const item = {
         kind: "fragment",
         id: resolveFragmentId(fragment2),
@@ -272041,25 +273556,24 @@ function resolveFragmentItem(fragment2, fragmentIndex, pageIndex, blockMap, bloc
         fragment: fragment2,
         blockId: fragment2.blockId,
         fragmentIndex,
-        content: resolveParagraphContentIfApplicable(fragment2, blockMap),
+        content: paragraphPageRefs ? resolveParagraphContent(paragraphPageRefs.fragment, paragraphPageRefs.block, entry.measure) : resolveParagraphContentIfApplicable(fragment2, blockMap, pageRefContext),
         layoutSourceIdentity
       };
       if (sdtContainerKey != null)
         item.sdtContainerKey = sdtContainerKey;
       if (fragment2.sourceAnchor != null)
         item.sourceAnchor = fragment2.sourceAnchor;
-      const entry = blockMap.get(fragment2.blockId);
       if (entry) {
         if (fragment2.kind === "para" && entry.block.kind === "paragraph" && entry.measure.kind === "paragraph") {
-          item.block = entry.block;
+          item.block = paragraphPageRefs?.block ?? entry.block;
           item.measure = entry.measure;
           if (item.sourceAnchor == null)
             item.sourceAnchor = entry.block.sourceAnchor;
         } else if (fragment2.kind === "list-item" && entry.block.kind === "list" && entry.measure.kind === "list") {
-          const listBlock = entry.block;
+          const listBlock = listPageRefs?.block ?? entry.block;
           const listItem2 = listBlock.items.find((candidate) => candidate.id === fragment2.itemId);
           item.block = listBlock;
-          item.measure = entry.measure;
+          item.measure = listPageRefs?.measure ?? entry.measure;
           if (item.sourceAnchor == null)
             item.sourceAnchor = listItem2?.sourceAnchor ?? listItem2?.paragraph.sourceAnchor ?? listBlock.sourceAnchor;
         }
@@ -272090,16 +273604,17 @@ function resolveFragmentItem(fragment2, fragmentIndex, pageIndex, blockMap, bloc
         if (listItem2.markerWidth != null)
           item.markerWidth = listItem2.markerWidth;
       }
-      applyPaintVersions(item, version$1);
+      applyPaintVersions(item, itemVersion);
       return item;
     }
   }
 }
 function resolveLayout(input2) {
-  const { layout, flowMode, blocks: blocks2, measures } = input2;
+  const { layout, flowMode, blocks: blocks2, measures, bookmarks } = input2;
   const fontSignature = input2.fontSignature ?? "";
   const blockMap = buildBlockMap(blocks2, measures);
   const blockVersionCache = /* @__PURE__ */ new Map;
+  const pageRefAnchorMap = bookmarks?.size ? buildPageRefAnchorMap(bookmarks, layout, blocks2, measures) : undefined;
   const pages = layout.pages.map((page, pageIndex) => ({
     id: `page-${pageIndex}`,
     index: pageIndex,
@@ -272108,7 +273623,10 @@ function resolveLayout(input2) {
     number: page.number,
     width: page.size?.w ?? layout.pageSize.w,
     height: page.size?.h ?? layout.pageSize.h,
-    items: page.fragments.map((fragment2, fragmentIndex) => resolveFragmentItem(fragment2, fragmentIndex, pageIndex, blockMap, blockVersionCache, undefined, fontSignature)),
+    items: page.fragments.map((fragment2, fragmentIndex) => resolveFragmentItem(fragment2, fragmentIndex, pageIndex, blockMap, blockVersionCache, undefined, fontSignature, pageRefAnchorMap ? {
+      sourcePage: page.number,
+      anchorMap: pageRefAnchorMap
+    } : undefined)),
     margins: page.margins,
     footnoteReserved: page.footnoteReserved,
     displayNumber: page.displayNumber,
@@ -272413,8 +273931,8 @@ function getColumnConfig(blockColumns) {
 }
 function isColumnConfigChanging(blockColumns, activeColumns) {
   if (blockColumns)
-    return blockColumns.count !== activeColumns.count || blockColumns.gap !== activeColumns.gap || Boolean(blockColumns.withSeparator) !== Boolean(activeColumns.withSeparator) || blockColumns.equalWidth !== activeColumns.equalWidth || !widthsEqual(blockColumns.widths, activeColumns.widths);
-  return activeColumns.count > 1 || Boolean(activeColumns.withSeparator);
+    return !columnRenderLayoutsEqual(blockColumns, activeColumns);
+  return resolveColumnCount(activeColumns) > 1 || Boolean(activeColumns.withSeparator);
 }
 function scheduleSectionBreak(block, state, baseMargins, maxHeaderContentHeight = 0, maxFooterContentHeight = 0) {
   const next2 = { ...state };
@@ -272745,7 +274263,7 @@ function layoutParagraphBlock(ctx$1, anchors) {
       const anchorX = entry.block.anchor ? resolveAnchoredGraphicX(entry.block.anchor, state.columnIndex, anchors.columns, entry.measure.width, {
         left: anchors.pageMargins.left,
         right: anchors.pageMargins.right
-      }, anchors.pageWidth) : columnX(state.columnIndex);
+      }, anchors.pageWidth) : columnX(state);
       const pmRange = extractBlockPmRange(entry.block);
       if (entry.block.kind === "image" && entry.measure.kind === "image") {
         const pageContentHeight = Math.max(0, state.contentBottom - state.topMargin);
@@ -272821,7 +274339,7 @@ function layoutParagraphBlock(ctx$1, anchors) {
     if (state.cursorY >= state.contentBottom)
       state = advanceColumn(state);
     const fragmentWidth = lines.reduce((max$2, line) => Math.max(max$2, line.width ?? 0), 0) || columnWidth;
-    let x = columnX(state.columnIndex);
+    let x = columnX(state);
     if (frame.xAlign === "right")
       x += columnWidth - fragmentWidth;
     else if (frame.xAlign === "center")
@@ -273030,9 +274548,9 @@ function layoutParagraphBlock(ctx$1, anchors) {
             state.footnoteAnchorsThisPage.push(a2);
       }
     }
-    const floatAdjustedX = columnX(state.columnIndex) + offsetX;
+    const floatAdjustedX = columnX(state) + offsetX;
     const adjustedX = didRemeasureForFloats ? floatAdjustedX + Math.max(negativeLeftIndent, 0) : floatAdjustedX + negativeLeftIndent;
-    const columnRight = columnX(state.columnIndex) + columnWidth;
+    const columnRight = columnX(state) + columnWidth;
     let adjustedWidth = didRemeasureForFloats ? effectiveColumnWidth : effectiveColumnWidth - negativeLeftIndent - negativeRightIndent;
     if (didRemeasureForFloats)
       adjustedWidth = Math.min(adjustedWidth, Math.max(1, columnRight - adjustedX));
@@ -273069,9 +274587,9 @@ function layoutParagraphBlock(ctx$1, anchors) {
         if (lines[i4].width > maxLineWidth)
           maxLineWidth = lines[i4].width;
       if (floatAlignment === "right")
-        fragment2.x = columnX(state.columnIndex) + offsetX + (effectiveColumnWidth - maxLineWidth);
+        fragment2.x = columnX(state) + offsetX + (effectiveColumnWidth - maxLineWidth);
       else if (floatAlignment === "center")
-        fragment2.x = columnX(state.columnIndex) + offsetX + (effectiveColumnWidth - maxLineWidth) / 2;
+        fragment2.x = columnX(state) + offsetX + (effectiveColumnWidth - maxLineWidth) / 2;
     }
     state.page.fragments.push(fragment2);
     state.cursorY += borderExpansion.top + fragmentHeight + borderExpansion.bottom;
@@ -273139,7 +274657,7 @@ function layoutImageBlock({ block, measure, columns, ensurePage, advanceColumn,
   const fragment2 = {
     kind: "image",
     blockId: block.id,
-    x: columnX(state.columnIndex) + marginLeft,
+    x: columnX(state) + marginLeft,
     y: state.cursorY + marginTop,
     width,
     height,
@@ -273185,7 +274703,7 @@ function layoutDrawingBlock({ block, measure, columns, ensurePage, advanceColumn
   if (state.cursorY + requiredHeight > state.contentBottom && state.cursorY > state.topMargin)
     state = advanceColumn(state);
   const pmRange = extractBlockPmRange(block);
-  let x = columnX(state.columnIndex) + marginLeft + indentLeft;
+  let x = columnX(state) + marginLeft + indentLeft;
   if (isInlineShapeGroup && inlineParagraphAlignment) {
     const pIndentLeft = typeof attrs?.paragraphIndentLeft === "number" ? attrs.paragraphIndentLeft : 0;
     const pIndentRight = typeof attrs?.paragraphIndentRight === "number" ? attrs.paragraphIndentRight : 0;
@@ -273695,7 +275213,7 @@ function getCellPadding(cellIdx, blockRow) {
     right: padding.right ?? 4
   };
 }
-function getCellTotalLines(cell2) {
+function getCellTotalLines2(cell2) {
   return getCellLines(cell2).length;
 }
 function getRowContentHeight(blockRow, rowMeasure) {
@@ -273781,7 +275299,7 @@ function computeTableFragmentPmRange(block, measure, fromRow, toRow, partialRow)
       const cellMeasure = rowMeasure.cells[cellIndex];
       if (!cell2 || !cellMeasure)
         continue;
-      const totalLines = getCellTotalLines(cellMeasure);
+      const totalLines = getCellTotalLines2(cellMeasure);
       let fromLine = 0;
       let toLine = totalLines;
       if (isPartial) {
@@ -273859,7 +275377,7 @@ function computePartialRow(rowIndex, blockRow, measure, availableHeight, fromLin
   const madeProgress = toLineByCell.some((cutLine, idx) => cutLine > (startLines[idx] || 0));
   const isFirstPart = startLines.every((l) => l === 0);
   const isLastPart = toLineByCell.every((cutLine, idx) => {
-    return cutLine >= getCellTotalLines(row2.cells[idx]);
+    return cutLine >= getCellTotalLines2(row2.cells[idx]);
   }) || !madeProgress;
   if (actualPartialHeight === 0 && isFirstPart)
     actualPartialHeight = maxPaddingTotal;
@@ -273964,7 +275482,7 @@ function layoutMonolithicTable(context) {
     state = context.advanceColumn(state);
   state = context.ensurePage();
   const height = Math.min(context.measure.totalHeight, state.contentBottom - state.cursorY);
-  const baseX = context.columnX(state.columnIndex);
+  const baseX = context.columnX(state);
   const baseWidth = Math.max(0, context.measure.totalWidth || context.columnWidth);
   const { x, width } = resolveTableFrame(baseX, context.columnWidth, baseWidth, context.block.attrs);
   const columnWidths = rescaleColumnWidths(context.measure.columnWidths, context.measure.totalWidth, width);
@@ -274044,7 +275562,7 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
   let pendingPartialRow = null;
   if (block.rows.length === 0 && measure.totalHeight > 0) {
     const height = Math.min(measure.totalHeight, state.contentBottom - state.cursorY);
-    const { x, width } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.max(0, measure.totalWidth || columnWidth), block.attrs);
+    const { x, width } = resolveTableFrame(columnX(state), columnWidth, Math.max(0, measure.totalWidth || columnWidth), block.attrs);
     const columnWidths = rescaleColumnWidths(measure.columnWidths, measure.totalWidth, width);
     const metadata = generateFragmentMetadata(measure, block, 0, 0, 0, columnWidths);
     const fragment2 = {
@@ -274108,14 +275626,14 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
       const continuationPartialRow = computePartialRow(rowIndex, block.rows[rowIndex], measure, availableForBody, fromLineByCell, fullPageHeightForBody);
       const madeProgress = continuationPartialRow.toLineByCell.some((toLine, idx) => toLine > (fromLineByCell[idx] || 0));
       const hasRemainingLinesAfterContinuation = continuationPartialRow.toLineByCell.some((toLine, idx) => {
-        return toLine < getCellTotalLines(measure.rows[rowIndex].cells[idx]);
+        return toLine < getCellTotalLines2(measure.rows[rowIndex].cells[idx]);
       });
       const hadRemainingLinesBefore = fromLineByCell.some((fromLine, idx) => {
-        return fromLine < getCellTotalLines(measure.rows[rowIndex].cells[idx]);
+        return fromLine < getCellTotalLines2(measure.rows[rowIndex].cells[idx]);
       });
       const fragmentHeight$1 = computeFragmentHeight(measure, rowIndex, rowIndex + 1, repeatHeaderCount, borderCollapse, continuationPartialRow);
       if (fragmentHeight$1 > 0 && madeProgress) {
-        const { x: x$1, width: width$1 } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.max(0, measure.totalWidth || columnWidth), block.attrs);
+        const { x: x$1, width: width$1 } = resolveTableFrame(columnX(state), columnWidth, Math.max(0, measure.totalWidth || columnWidth), block.attrs);
         const scaledWidths$1 = rescaleColumnWidths(measure.columnWidths, measure.totalWidth, width$1);
         const fragment$1 = {
           kind: "table",
@@ -274172,7 +275690,7 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
       }
       const forcedEndRow = bodyStartRow + 1;
       const fragmentHeight$1 = computeFragmentHeight(measure, bodyStartRow, forcedEndRow, repeatHeaderCount, borderCollapse, forcedPartialRow);
-      const { x: x$1, width: width$1 } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.max(0, measure.totalWidth || columnWidth), block.attrs);
+      const { x: x$1, width: width$1 } = resolveTableFrame(columnX(state), columnWidth, Math.max(0, measure.totalWidth || columnWidth), block.attrs);
       const scaledWidths$1 = rescaleColumnWidths(measure.columnWidths, measure.totalWidth, width$1);
       const fragment$1 = {
         kind: "table",
@@ -274202,7 +275720,7 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
       continue;
     }
     const fragmentHeight = computeFragmentHeight(measure, bodyStartRow, endRow, repeatHeaderCount, borderCollapse, partialRow);
-    const { x, width } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.max(0, measure.totalWidth || columnWidth), block.attrs);
+    const { x, width } = resolveTableFrame(columnX(state), columnWidth, Math.max(0, measure.totalWidth || columnWidth), block.attrs);
     const scaledWidths = rescaleColumnWidths(measure.columnWidths, measure.totalWidth, width);
     const fragment2 = {
       kind: "table",
@@ -274429,16 +275947,6 @@ function createPaginator(opts) {
       return state.constraintBoundaries[state.activeConstraintIndex].columns;
     return opts.getActiveColumns();
   };
-  const columnX = (columnIndex) => {
-    const cols = opts.getCurrentColumns();
-    const widths = Array.isArray(cols.widths) && cols.widths.length > 0 ? cols.widths : null;
-    if (!widths)
-      return opts.margins.left + columnIndex * (cols.width + cols.gap);
-    let x = opts.margins.left;
-    for (let index2 = 0;index2 < columnIndex; index2 += 1)
-      x += (widths[index2] ?? cols.width) + cols.gap;
-    return x;
-  };
   const startNewPage = () => {
     if (opts.onNewPage)
       opts.onNewPage(undefined);
@@ -274493,7 +276001,7 @@ function createPaginator(opts) {
   };
   const advanceColumn = (state) => {
     const activeCols = getActiveColumnsForState(state);
-    if (state.columnIndex < activeCols.count - 1) {
+    if (state.columnIndex < resolveColumnCount(activeCols) - 1) {
       state.maxCursorY = Math.max(state.maxCursorY, state.cursorY);
       state.columnIndex += 1;
       if (state.activeConstraintIndex >= 0 && state.constraintBoundaries[state.activeConstraintIndex])
@@ -274518,7 +276026,6 @@ function createPaginator(opts) {
     startNewPage,
     ensurePage,
     advanceColumn,
-    columnX,
     getActiveColumnsForState,
     getPageByNumber,
     pruneTrailingEmptyPages
@@ -275166,7 +276673,7 @@ function cloneBlockWithResolvedTokens(block, displayPageInfo, totalPagesStr, tot
     if ("token" in run2 && run2.token) {
       if (run2.token === "pageNumber") {
         const resolvedText = run2.pageNumberFieldFormat ? formatChapterPageNumberText({
-          pageComponent: formatPageNumberFieldValue$1(displayPageInfo.displayNumber, run2.pageNumberFieldFormat),
+          pageComponent: formatPageNumberFieldValue(displayPageInfo.displayNumber, run2.pageNumberFieldFormat),
           chapterNumberText: displayPageInfo.chapterNumberText,
           chapterSeparator: displayPageInfo.chapterSeparator
         }) : displayPageInfo.chapterNumberText ? formatSectionPageNumberText({
@@ -275181,14 +276688,14 @@ function cloneBlockWithResolvedTokens(block, displayPageInfo, totalPagesStr, tot
           text: resolvedText
         };
       } else if (run2.token === "totalPageCount") {
-        const resolvedText = run2.pageNumberFieldFormat ? formatPageNumberFieldValue$1(totalPages, run2.pageNumberFieldFormat) : totalPagesStr;
+        const resolvedText = run2.pageNumberFieldFormat ? formatPageNumberFieldValue(totalPages, run2.pageNumberFieldFormat) : totalPagesStr;
         changed ||= run2.text !== resolvedText;
         return {
           ...run2,
           text: resolvedText
         };
       } else if (run2.token === "sectionPageCount") {
-        const resolvedText = run2.pageNumberFieldFormat ? formatPageNumberFieldValue$1(sectionPageCount, run2.pageNumberFieldFormat) : String(sectionPageCount);
+        const resolvedText = run2.pageNumberFieldFormat ? formatPageNumberFieldValue(sectionPageCount, run2.pageNumberFieldFormat) : String(sectionPageCount);
         changed ||= run2.text !== resolvedText;
         return {
           ...run2,
@@ -275613,7 +277120,7 @@ function layoutDocument(blocks2, measures, options = {}) {
     if (block.orientation)
       next2.pendingOrientation = block.orientation;
     const sectionType = block.type ?? "continuous";
-    const isColumnsChanging = block.columns && (block.columns.count !== next2.activeColumns.count || block.columns.gap !== next2.activeColumns.gap || Boolean(block.columns.withSeparator) !== Boolean(next2.activeColumns.withSeparator) || block.columns.equalWidth !== next2.activeColumns.equalWidth || !widthsEqual(block.columns.widths, next2.activeColumns.widths)) || !block.columns && (next2.activeColumns.count > 1 || Boolean(next2.activeColumns.withSeparator));
+    const isColumnsChanging = block.columns && !columnRenderLayoutsEqual(block.columns, next2.activeColumns) || !block.columns && (resolveColumnCount(next2.activeColumns) > 1 || Boolean(next2.activeColumns.withSeparator));
     const sectionIndexRaw = block.attrs?.sectionIndex;
     const metadataIndex = typeof sectionIndexRaw === "number" ? sectionIndexRaw : Number(sectionIndexRaw ?? NaN);
     if (Number.isFinite(metadataIndex))
@@ -275702,8 +277209,8 @@ function layoutDocument(blocks2, measures, options = {}) {
       page.size = pageSizeOverride;
     if (activeOrientation)
       page.orientation = activeOrientation;
-    if (activeColumns.count > 1)
-      page.columns = cloneColumnLayout(activeColumns);
+    if (resolveColumnCount(activeColumns) > 1)
+      page.columns = resolveColumnLayout(activeColumns);
     if (activeVAlign && activeVAlign !== "top") {
       page.vAlign = activeVAlign;
       page.baseMargins = {
@@ -275923,7 +277430,6 @@ function layoutDocument(blocks2, measures, options = {}) {
     getActivePageSize: () => activePageSize,
     getDefaultPageSize: () => pageSize,
     getActiveColumns: () => activeColumns,
-    getCurrentColumns: () => getCurrentColumns(),
     createPage,
     onNewPage: (state) => {
       if (!state) {
@@ -276077,7 +277583,7 @@ function layoutDocument(blocks2, measures, options = {}) {
     const state = states[states.length - 1] ?? null;
     const colsConfig = state ? getActiveColumnsForState(state) : activeColumns;
     const constraintIndex = state ? state.activeConstraintIndex : -1;
-    if (cachedColumnsState.state === state && cachedColumnsState.constraintIndex === constraintIndex && cachedColumnsState.contentWidth === currentContentWidth && cachedColumnsState.colsConfig?.count === colsConfig.count && cachedColumnsState.colsConfig?.gap === colsConfig.gap && cachedColumnsState.colsConfig?.equalWidth === colsConfig.equalWidth && widthsEqual(cachedColumnsState.colsConfig?.widths, colsConfig.widths) && cachedColumnsState.normalized)
+    if (cachedColumnsState.state === state && cachedColumnsState.constraintIndex === constraintIndex && cachedColumnsState.contentWidth === currentContentWidth && columnRenderLayoutsEqual(cachedColumnsState.colsConfig ?? undefined, colsConfig) && cachedColumnsState.normalized)
       return cachedColumnsState.normalized;
     const normalized = normalizeColumns(colsConfig, currentContentWidth);
     cachedColumnsState = {
@@ -276089,10 +277595,19 @@ function layoutDocument(blocks2, measures, options = {}) {
     };
     return normalized;
   };
+  const getColumnGeometryForState = (state) => {
+    return getColumnGeometry(normalizeColumns(state.activeConstraintIndex >= 0 && state.constraintBoundaries[state.activeConstraintIndex] ? state.constraintBoundaries[state.activeConstraintIndex].columns : state.page.columns ?? {
+      count: 1,
+      gap: 0
+    }, (state.page.size?.w ?? pageSize.w) - ((state.page.margins?.left ?? activeLeftMargin) + (state.page.margins?.right ?? activeRightMargin))));
+  };
+  const columnWidthForState = (state, columnIndex = state.columnIndex) => getColumnWidth(getColumnGeometryForState(state), columnIndex);
+  const columnXForState = (state, columnIndex = state.columnIndex) => getColumnX(getColumnGeometryForState(state), columnIndex, state.page.margins?.left ?? activeLeftMargin);
   const getCurrentColumnWidth = () => {
-    return getColumnWidthAt(getCurrentColumns(), (states[states.length - 1] ?? null)?.columnIndex ?? 0);
+    const state = states[states.length - 1] ?? null;
+    return state ? columnWidthForState(state) : getColumnWidthAt(getCurrentColumns(), 0);
   };
-  const columnX = paginator.columnX;
+  const columnX = columnXForState;
   const advanceColumn = paginator.advanceColumn;
   const startMidPageRegion = (state, newColumns) => {
     const regionStartY = Math.max(state.cursorY, state.maxCursorY);
@@ -276360,7 +277875,7 @@ function layoutDocument(blocks2, measures, options = {}) {
           }
         }
         const endingSectionColumns = endingSectionIndex !== null ? sectionColumnsMap.get(endingSectionIndex) : undefined;
-        const willBalance = endingSectionIndex !== null && !!endingSectionColumns && endingSectionColumns.count > 1 && !sectionHasExplicitColumnBreak.has(endingSectionIndex);
+        const willBalance = endingSectionIndex !== null && !!endingSectionColumns && resolveColumnCount(endingSectionColumns) > 1 && !sectionHasExplicitColumnBreak.has(endingSectionIndex);
         let balanceResult = null;
         if (willBalance) {
           const activeRegionTop = state.constraintBoundaries[state.constraintBoundaries.length - 1]?.y ?? activeTopMargin;
@@ -276391,7 +277906,7 @@ function layoutDocument(blocks2, measures, options = {}) {
             alreadyBalancedSections.add(endingSectionIndex);
           }
         }
-        if (balanceResult === null && columnIndexBefore >= newColumns.count)
+        if (balanceResult === null && columnIndexBefore >= resolveColumnCount(newColumns))
           state = paginator.startNewPage();
         startMidPageRegion(state, newColumns);
       }
@@ -276546,7 +278061,7 @@ function layoutDocument(blocks2, measures, options = {}) {
           const offsetV = tableBlock.anchor?.offsetV ?? 0;
           const anchorY = Math.max(anchorParagraphTopY, nextStackY) + offsetV;
           floatManager.registerTable(tableBlock, tableMeasure, anchorY, state.columnIndex, state.page.number);
-          const tableFragment = createAnchoredTableFragment(tableBlock, tableMeasure, tableBlock.anchor?.offsetH ?? columnX(state.columnIndex), anchorY);
+          const tableFragment = createAnchoredTableFragment(tableBlock, tableMeasure, tableBlock.anchor?.offsetH ?? columnX(state), anchorY);
           state.page.fragments.push(tableFragment);
           placedAnchoredTableIds.add(tableBlock.id);
           if ((tableBlock.wrap?.type ?? "None") !== "None") {
@@ -276579,7 +278094,7 @@ function layoutDocument(blocks2, measures, options = {}) {
         else if (relativeFrom === "margin")
           maxWidth = activePageSize.w - (activeLeftMargin + activeRightMargin);
         else
-          maxWidth = getColumnWidthAt(cols, state.columnIndex);
+          maxWidth = columnWidthForState(state);
         const aspectRatio = imgMeasure.width > 0 && imgMeasure.height > 0 ? imgMeasure.width / imgMeasure.height : 1;
         const minWidth = 20;
         const minHeight = minWidth / aspectRatio;
@@ -276694,7 +278209,7 @@ function layoutDocument(blocks2, measures, options = {}) {
         throw new Error(`layoutDocument: expected columnBreak measure for block ${block.id}`);
       const state = paginator.ensurePage();
       const activeCols = getActiveColumnsForState(state);
-      if (state.columnIndex < activeCols.count - 1)
+      if (state.columnIndex < resolveColumnCount(activeCols) - 1)
         advanceColumn(state);
       else
         paginator.startNewPage();
@@ -276718,7 +278233,7 @@ function layoutDocument(blocks2, measures, options = {}) {
       if (columnWidthForTable > 0 && totalWidth >= columnWidthForTable * 0.99)
         continue;
       const anchorY = resolveParagraphlessAnchoredTableY(tableBlock, tableMeasure, state);
-      const anchorX = tableBlock.anchor?.offsetH ?? columnX(state.columnIndex);
+      const anchorX = tableBlock.anchor?.offsetH ?? columnX(state);
       floatManager.registerTable(tableBlock, tableMeasure, anchorY, state.columnIndex, state.page.number);
       state.page.fragments.push(createAnchoredTableFragment(tableBlock, tableMeasure, anchorX, anchorY));
       placedAnchoredTableIds.add(tableBlock.id);
@@ -276766,13 +278281,13 @@ function layoutDocument(blocks2, measures, options = {}) {
         fragment2.y += yOffset;
   }
   const FALLBACK_SECTION_IDX = -1;
-  if (sectionColumnsMap.size === 0 && !documentHasAnySectionBreak && activeColumns.count > 1 && !documentHasExplicitColumnBreak) {
+  if (sectionColumnsMap.size === 0 && !documentHasAnySectionBreak && resolveColumnCount(activeColumns) > 1 && !documentHasExplicitColumnBreak) {
     sectionColumnsMap.set(FALLBACK_SECTION_IDX, cloneColumnLayout(activeColumns));
     for (const block of blocks2)
       blockSectionMap.set(block.id, FALLBACK_SECTION_IDX);
   }
   for (const [sectionIdx, sectionCols] of sectionColumnsMap) {
-    if (sectionCols.count <= 1)
+    if (resolveColumnCount(sectionCols) <= 1)
       continue;
     if (sectionHasExplicitColumnBreak.has(sectionIdx))
       continue;
@@ -276854,7 +278369,7 @@ function layoutDocument(blocks2, measures, options = {}) {
       regions.push({
         yStart: start$1.y,
         yEnd: end$1 ? end$1.y : state.contentBottom,
-        columns: start$1.columns
+        columns: resolveColumnLayout(start$1.columns)
       });
     }
     state.page.columnRegions = regions;
@@ -276871,7 +278386,7 @@ function layoutDocument(blocks2, measures, options = {}) {
     pageSize,
     pages,
     ...options.documentBackground ? { documentBackground: options.documentBackground } : {},
-    columns: activeColumns.count > 1 ? cloneColumnLayout(activeColumns) : undefined
+    columns: resolveColumnCount(activeColumns) > 1 ? resolveColumnLayout(activeColumns) : undefined
   };
 }
 function computeFragmentBottom(fragment2, block, measure) {
@@ -277451,7 +278966,7 @@ function resolveHeaderFooterTokens(blocks2, pageNumber, totalPages, pageNumberTe
       if ("token" in run2 && run2.token) {
         if (run2.token === "pageNumber")
           run2.text = run2.pageNumberFieldFormat ? formatChapterPageNumberText({
-            pageComponent: formatPageNumberFieldValue$1(displayNumber, run2.pageNumberFieldFormat),
+            pageComponent: formatPageNumberFieldValue(displayNumber, run2.pageNumberFieldFormat),
             chapterNumberText,
             chapterSeparator
           }) : chapterNumberText ? formatSectionPageNumberText({
@@ -277461,9 +278976,9 @@ function resolveHeaderFooterTokens(blocks2, pageNumber, totalPages, pageNumberTe
             chapterSeparator
           }) : pageNumberStr;
         else if (run2.token === "totalPageCount")
-          run2.text = run2.pageNumberFieldFormat ? formatPageNumberFieldValue$1(totalPages, run2.pageNumberFieldFormat) : totalPagesStr;
+          run2.text = run2.pageNumberFieldFormat ? formatPageNumberFieldValue(totalPages, run2.pageNumberFieldFormat) : totalPagesStr;
         else if (run2.token === "sectionPageCount")
-          run2.text = run2.pageNumberFieldFormat ? formatPageNumberFieldValue$1(sectionPageCountNumber, run2.pageNumberFieldFormat) : sectionPageCountStr;
+          run2.text = run2.pageNumberFieldFormat ? formatPageNumberFieldValue(sectionPageCountNumber, run2.pageNumberFieldFormat) : sectionPageCountStr;
       }
   });
 }
@@ -277608,7 +279123,7 @@ function canUseDigitBucketingForVariant(blocks2, docTotalPages, pageResolver) {
   const renderedBucketForPage = (pageNumber) => {
     const pageInfo = pageResolver(pageNumber);
     const renderedText = strategy.kind === "fieldFormat" ? Number.isFinite(pageInfo.displayNumber) ? formatChapterPageNumberText({
-      pageComponent: formatPageNumberFieldValue$1(pageInfo.displayNumber ?? pageNumber, strategy.fieldFormat),
+      pageComponent: formatPageNumberFieldValue(pageInfo.displayNumber ?? pageNumber, strategy.fieldFormat),
       chapterNumberText: pageInfo.chapterNumberText,
       chapterSeparator: pageInfo.chapterSeparator
     }) : null : pageInfo.displayText;
@@ -287402,6 +288917,10 @@ async function measureParagraphBlock(block, maxWidth, fontContext) {
     }
     lastFontSize = run2.fontSize;
     hasSeenTextRun = true;
+    if (run2.text === "") {
+      pendingRunSpacing = 0;
+      continue;
+    }
     const { font } = buildFontString(run2, fontContext);
     const tabSegments = run2.text.split("\t");
     let charPosInRun = 0;
@@ -296930,7 +298449,7 @@ var Node$13 = class Node$14 {
     }
     case "total-page-number":
       return {
-        text: editor.options.totalPageCount || editor.options.parentEditor?.currentTotalPages || "1",
+        text: formatPageNumberFieldValue(Number(editor.options.totalPageCount || editor.options.parentEditor?.currentTotalPages || 1) || 1, getPageNumberFieldFormat(node3?.attrs)),
         className: "sd-editor-auto-total-pages",
         dataId: "auto-total-pages",
         ariaLabel: "Total page count node"
@@ -296941,7 +298460,7 @@ var Node$13 = class Node$14 {
       const pageNumberFormat = typeof node3?.attrs?.pageNumberFormat === "string" ? node3.attrs.pageNumberFormat : undefined;
       const pageNumberZeroPadding = typeof node3?.attrs?.pageNumberZeroPadding === "number" && Number.isFinite(node3.attrs.pageNumberZeroPadding) ? node3.attrs.pageNumberZeroPadding : undefined;
       return {
-        text: sectionPageCount != null ? pageNumberFormat || pageNumberZeroPadding != null ? formatPageNumberFieldValue$1(Number(sectionPageCount) || 1, {
+        text: sectionPageCount != null ? pageNumberFormat || pageNumberZeroPadding != null ? formatPageNumberFieldValue(Number(sectionPageCount) || 1, {
           ...pageNumberFormat ? { format: pageNumberFormat } : {},
           ...pageNumberZeroPadding != null ? { zeroPadding: pageNumberZeroPadding } : {}
         }) : sectionPageCount : cachedText,
@@ -313163,7 +314682,7 @@ menclose::after {
   if (runToken === "pageNumber") {
     if (run2.pageNumberFieldFormat)
       return formatChapterPageNumberText({
-        pageComponent: formatPageNumberFieldValue$1(context.displayPageNumber ?? context.pageNumber, run2.pageNumberFieldFormat),
+        pageComponent: formatPageNumberFieldValue(context.displayPageNumber ?? context.pageNumber, run2.pageNumberFieldFormat),
         chapterNumberText: context.pageNumberChapterText,
         chapterSeparator: context.pageNumberChapterSeparator
       });
@@ -313178,7 +314697,7 @@ menclose::after {
   }
   if (runToken === "totalPageCount") {
     if (run2.pageNumberFieldFormat)
-      return formatPageNumberFieldValue$1(context.totalPages || 1, run2.pageNumberFieldFormat);
+      return formatPageNumberFieldValue(context.totalPages || 1, run2.pageNumberFieldFormat);
     return context.totalPages ? String(context.totalPages) : run2.text ?? "";
   }
   if (runToken === "sectionPageCount") {
@@ -313186,7 +314705,7 @@ menclose::after {
     if (sectionPageCount == null)
       return run2.text ?? "";
     if (run2.pageNumberFieldFormat)
-      return formatPageNumberFieldValue$1(sectionPageCount, run2.pageNumberFieldFormat);
+      return formatPageNumberFieldValue(sectionPageCount, run2.pageNumberFieldFormat);
     return String(sectionPageCount);
   }
   return run2.text ?? "";
@@ -314108,7 +315627,7 @@ menclose::after {
       break;
     }
   return merged;
-}, isTextRun$5 = (run2) => (run2.kind === "text" || run2.kind === undefined) && ("text" in run2), isOverlaySafeRunKind = (run2) => {
+}, isTextRun$6 = (run2) => (run2.kind === "text" || run2.kind === undefined) && ("text" in run2), isOverlaySafeRunKind = (run2) => {
   const kind = run2.kind ?? "text";
   return kind === "text" || kind === "tab" || kind === "lineBreak" || kind === "break";
 }, shouldUseLineUnderlineOverlay = (runsForLine) => runsForLine.every(isOverlaySafeRunKind) && runsForLine.some((run2) => run2.kind === "tab" && canPaintUnderlineOverlay(run2)), cloneRunWithoutUnderline = (run2) => ({
@@ -314133,7 +315652,7 @@ menclose::after {
   const segments = segmentsByRun.get(runIndex);
   if (segments?.length)
     return segments.reduce((sum, segment) => {
-      const text5 = isTextRun$5(run2) ? (run2.text ?? "").slice(segment.fromChar, segment.toChar) : "";
+      const text5 = isTextRun$6(run2) ? (run2.text ?? "").slice(segment.fromChar, segment.toChar) : "";
       return sum + segment.width + spacingPerSpace * countSpaces$1(text5);
     }, 0);
   if ("width" in run2 && typeof run2.width === "number")
@@ -315566,29 +317085,17 @@ menclose::after {
     }
   }
   getColumnSeparatorPositions(columns, leftMargin, contentWidth) {
-    if (!(Array.isArray(columns.widths) && columns.widths.length > 0)) {
-      const equalWidth = (contentWidth - columns.gap * (columns.count - 1)) / columns.count;
-      if (equalWidth <= 1)
+    const normalized = normalizeColumnLayout(columns, contentWidth);
+    if (resolveColumnMode(columns) === "equal") {
+      if ((contentWidth - columns.gap * (normalized.count - 1)) / normalized.count <= 1)
         return [];
-      const separatorPositions$1 = [];
-      for (let index2 = 0;index2 < columns.count - 1; index2 += 1)
-        separatorPositions$1.push(leftMargin + (index2 + 1) * equalWidth + index2 * columns.gap + columns.gap / 2);
-      return separatorPositions$1;
     }
-    const normalizedColumns = normalizeColumnLayout(columns, contentWidth);
-    if (normalizedColumns.count <= 1)
+    const geometry = getColumnGeometry(normalized);
+    if (geometry.length <= 1)
       return [];
-    const columnWidths = normalizedColumns.widths ?? Array.from({ length: normalizedColumns.count }, () => normalizedColumns.width);
-    if (columnWidths.some((columnWidth) => columnWidth <= 1))
+    if (geometry.some((column) => column.width <= 1))
       return [];
-    const separatorPositions = [];
-    let cursorX = leftMargin;
-    for (let index2 = 0;index2 < normalizedColumns.count - 1; index2 += 1) {
-      const currentColumnWidth = columnWidths[index2] ?? normalizedColumns.width;
-      separatorPositions.push(cursorX + currentColumnWidth + normalizedColumns.gap / 2);
-      cursorX += currentColumnWidth + normalizedColumns.gap;
-    }
-    return separatorPositions;
+    return getColumnSeparatorPositions(geometry, leftMargin);
   }
   renderDecorationsForPage(pageEl, page, pageIndex) {
     if (this.isSemanticFlow)
@@ -316291,8 +317798,10 @@ menclose::after {
         });
       return context?.pageNumberText ?? String(context?.pageNumber ?? 1);
     }
-    if (part.fieldType === "NUMPAGES")
-      return String(context?.totalPages ?? 1);
+    if (part.fieldType === "NUMPAGES") {
+      const totalPages = context?.totalPages ?? 1;
+      return part.pageNumberFormat ? formatPageNumber(totalPages, part.pageNumberFormat) : String(totalPages);
+    }
     if (part.fieldType === "SECTIONPAGES") {
       if (context?.sectionPageCount == null)
         return part.text ?? "1";
@@ -326550,13 +328059,13 @@ menclose::after {
     return;
   console.log(...args$1);
 }, HEADER_FOOTER_INIT_BUDGET_MS = 200, MAX_ZOOM_WARNING_THRESHOLD = 10, MAX_SELECTION_RECTS_PER_USER = 100, SEMANTIC_RESIZE_DEBOUNCE_MS = 120, MIN_SEMANTIC_CONTENT_WIDTH_PX = 1, GLOBAL_PERFORMANCE, PresentationEditor, ICONS, TEXTS, tableActionsOptions, TRACKED_MARK_NAMES;
-var init_src_MLERudib_es = __esm(() => {
+var init_src_eTZqPcFn_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
-  init_SuperConverter_DBsJeu9t_es();
+  init_SuperConverter_D2zNnC50_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
   init_uuid_qzgm05fK_es();
-  init_create_headless_toolbar_BiY_0zZP_es();
+  init_create_headless_toolbar_COmoIa5Q_es();
   init_constants_D9qj59G2_es();
   init_dist_B8HfvhaK_es();
   init_unified_Dsuw2be5_es();
@@ -331040,7 +332549,7 @@ ${err.toString()}`);
           if (typeof tablePos !== "number" && !tableNode || !Array.isArray(valueRows) || !valueRows.length)
             return false;
           return chain().command(({ tr, dispatch }) => {
-            const workingTable = resolveTable2(tr, tablePos, tableNode);
+            const workingTable = resolveTable3(tr, tablePos, tableNode);
             if (!workingTable)
               return false;
             const templateRow = pickTemplateRowForAppend(workingTable, editor.schema);
@@ -333537,6 +335046,10 @@ ${err.toString()}`);
           default: null,
           rendered: false
         },
+        pageNumberNumericPicture: {
+          default: null,
+          rendered: false
+        },
         importedCachedText: {
           default: null,
           rendered: false
@@ -333697,6 +335210,38 @@ ${err.toString()}`);
         instruction: {
           default: "",
           rendered: false
+        },
+        instructionTokens: {
+          default: null,
+          rendered: false
+        },
+        bookmarkId: {
+          default: "",
+          rendered: false
+        },
+        hasHyperlinkSwitch: {
+          default: false,
+          rendered: false
+        },
+        hasRelativePositionSwitch: {
+          default: false,
+          rendered: false
+        },
+        pageNumberFieldFormat: {
+          default: null,
+          rendered: false
+        },
+        numericPictureFormat: {
+          default: null,
+          rendered: false
+        },
+        fieldResultFormat: {
+          default: null,
+          rendered: false
+        },
+        fieldRunProperties: {
+          default: null,
+          rendered: false
         }
       };
     },
@@ -337262,6 +338807,22 @@ ${err.toString()}`);
           default: "",
           rendered: false
         },
+        fieldArgument: {
+          default: "",
+          rendered: false
+        },
+        sequenceMode: {
+          default: "next",
+          rendered: false
+        },
+        hideResult: {
+          default: false,
+          rendered: false
+        },
+        restartNumber: {
+          default: null,
+          rendered: false
+        },
         format: {
           default: "ARABIC",
           rendered: false
@@ -337270,10 +338831,26 @@ ${err.toString()}`);
           default: null,
           rendered: false
         },
+        hasGeneralFormat: {
+          default: false,
+          rendered: false
+        },
+        pageNumberFieldFormat: {
+          default: null,
+          rendered: false
+        },
+        numericPictureFormat: {
+          default: null,
+          rendered: false
+        },
         resolvedNumber: {
           default: "",
           rendered: false
         },
+        resolvedNumberIsCurrent: {
+          default: false,
+          rendered: false
+        },
         sdBlockId: {
           default: null,
           rendered: false
@@ -337288,7 +338865,7 @@ ${err.toString()}`);
       return [{ tag: 'span[data-id="sequence-field"]' }];
     },
     renderDOM({ node: node3, htmlAttributes }) {
-      const text5 = node3.attrs.resolvedNumber || "0";
+      const text5 = node3.attrs.resolvedNumber || "";
       return [
         "span",
         Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes),
@@ -337358,7 +338935,8 @@ ${err.toString()}`);
   SYNTHETIC_FIELD_NODE_TYPES = {
     "total-page-number": {
       fieldType: "NUMPAGES",
-      instruction: "NUMPAGES"
+      instruction: "NUMPAGES",
+      resolveInstruction: (node3) => typeof node3.attrs?.instruction === "string" && node3.attrs.instruction.trim() ? node3.attrs.instruction : "NUMPAGES"
     },
     "section-page-count": {
       fieldType: "SECTIONPAGES",
@@ -337377,6 +338955,7 @@ ${err.toString()}`);
     addCommands() {
       return { updateFieldsInSelection: () => ({ editor, state, tr: outerTr, dispatch }) => {
         const { from: from$1, to } = state.selection;
+        const selectionHadSeq = findFieldsInRange(state.doc, from$1, to).some((field) => field.fieldType === "SEQ");
         let tocPathRan = false;
         if (editor?.doc?.toc?.update) {
           const tocTargets = findAllTocNodes(state.doc).map((toc) => toc.commandNodeId).filter((id2) => typeof id2 === "string" && id2);
@@ -337407,22 +338986,27 @@ ${err.toString()}`);
             tocPathRan = true;
           }
         }
-        const updatable = findFieldsInRange(state.doc, from$1, to).filter((f2) => UPDATABLE_FIELD_TYPES.has(f2.fieldType));
-        if (updatable.length === 0)
+        const activeState = tocPathRan && editor?.state?.doc ? editor.state : state;
+        const activeDoc = activeState.doc ?? state.doc;
+        const activeSchema = activeState.schema ?? state.schema;
+        const fields = findFieldsInRange(activeDoc, Math.min(from$1, activeDoc.content.size), to >= state.doc.content.size ? activeDoc.content.size : Math.min(to, activeDoc.content.size));
+        const updatable = fields.filter((f2) => UPDATABLE_FIELD_TYPES.has(f2.fieldType));
+        const hasSeqSelection = selectionHadSeq || fields.some((field) => field.fieldType === "SEQ");
+        if (updatable.length === 0 && !hasSeqSelection)
           return tocPathRan;
         const stats = getWordStatistics(resolveMainBodyEditor(editor));
-        const tr = state.tr;
+        const tr = activeState.tr;
         let changed = false;
         const sorted = [...updatable].sort((a2, b$1) => b$1.pos - a2.pos);
         for (const field of sorted) {
           const node3 = tr.doc.nodeAt(field.pos);
           if (!node3)
             continue;
-          const freshValue = field.fieldType === "SECTIONPAGES" ? resolveSectionPageCountFieldValue(editor, node3) : resolveDocumentStatFieldValue(field.fieldType, stats);
+          const freshValue = field.fieldType === "SECTIONPAGES" ? resolveSectionPageCountFieldValue(editor, node3) : field.fieldType === "NUMPAGES" && node3.type.name === "total-page-number" ? resolveTotalPageNumberFieldValue(stats, node3) : resolveDocumentStatFieldValue(field.fieldType, stats);
           if (freshValue == null)
             continue;
           if (node3.type.name === "total-page-number" || node3.type.name === "section-page-count") {
-            const textChild = freshValue ? state.schema.text(freshValue) : null;
+            const textChild = freshValue ? activeSchema.text(freshValue) : null;
             const newNode = node3.type.create({
               ...node3.attrs,
               resolvedText: freshValue
@@ -337439,6 +339023,15 @@ ${err.toString()}`);
             changed = true;
           }
         }
+        if (hasSeqSelection) {
+          const result = updateSequenceFieldsInTransaction({
+            tr,
+            schema: activeSchema,
+            scope: { kind: "all" },
+            converterContext: getSequenceFieldUpdaterConverterContext(editor)
+          });
+          changed = changed || result.changed;
+        }
         if (!changed)
           return tocPathRan;
         if (dispatch)
@@ -354364,7 +355957,7 @@ function print() { __p += __j.call(arguments, '') }
       const currentPageNumber = Number(opts.currentPageDisplayNumber || opts.currentPageNumber || 1);
       const chapterNumberText = typeof opts.currentPageChapterNumberText === "string" ? opts.currentPageChapterNumberText : undefined;
       const chapterSeparator = typeof opts.currentPageChapterSeparator === "string" ? opts.currentPageChapterSeparator : undefined;
-      const totalPages = String(opts.totalPageCount || parentEditor?.currentTotalPages || "1");
+      const totalPages = Number(opts.totalPageCount || parentEditor?.currentTotalPages || 1) || 1;
       const sectionPages = opts.sectionPageCount;
       const pageNumberEls = container.querySelectorAll('[data-id="auto-page-number"]');
       const totalPagesEls = container.querySelectorAll('[data-id="auto-total-pages"]');
@@ -354381,8 +355974,9 @@ function print() { __p += __j.call(arguments, '') }
           el.textContent = text5;
       });
       totalPagesEls.forEach((el) => {
-        if (el.textContent !== totalPages)
-          el.textContent = totalPages;
+        const text5 = formatPageNumberFieldValue(totalPages, this.#getPageNumberFieldFormatForDomNode(editor, el));
+        if (el.textContent !== text5)
+          el.textContent = text5;
       });
       sectionPagesEls.forEach((el) => {
         if (sectionPages == null)
@@ -354406,6 +356000,17 @@ function print() { __p += __j.call(arguments, '') }
         return null;
       }
     }
+    #getPageNumberFieldFormatForDomNode(editor, el) {
+      try {
+        const view = editor.view;
+        if (!view)
+          return;
+        const pos = view.posAtDOM(el, 0);
+        return getPageNumberFieldFormat(editor.state.doc.nodeAt(pos)?.attrs);
+      } catch {
+        return;
+      }
+    }
     getEditor(descriptor) {
       if (!descriptor?.id)
         return null;
@@ -356444,7 +358049,8 @@ function print() { __p += __j.call(arguments, '') }
         flowMode: this.#layoutOptions.flowMode ?? "paginated",
         blocks: blocks2,
         measures,
-        fontSignature: this.#layoutFontSignature
+        fontSignature: this.#layoutFontSignature,
+        bookmarks: this.#layoutState.bookmarks
       });
       const isSemanticFlow = this.#layoutOptions.flowMode === "semantic";
       this.#ensurePainter();
@@ -358720,7 +360326,8 @@ function print() { __p += __j.call(arguments, '') }
             flowMode: this.#layoutOptions.flowMode ?? "paginated",
             blocks: bodyBlocksForPaint,
             measures: bodyMeasuresForPaint,
-            fontSignature
+            fontSignature,
+            bookmarks
           });
           headerLayouts = result.headers;
           footerLayouts = result.footers;
@@ -361496,11 +363103,11 @@ function print() { __p += __j.call(arguments, '') }
   ]);
 });
 
-// ../../packages/superdoc/dist/chunks/create-super-doc-ui-k5vyPmpN.es.js
+// ../../packages/superdoc/dist/chunks/create-super-doc-ui-BOYlxpy0.es.js
 var MOD_ALIASES, ALT_ALIASES, CTRL_ALIASES, SHIFT_ALIASES, BUILTIN_CONTEXT_MENU_GROUPS, BUILTIN_GROUP_ORDER, RESERVED_PROXY_PROPERTY_NAMES, ALL_TOOLBAR_COMMAND_IDS, EMPTY_ACTIVE_IDS;
-var init_create_super_doc_ui_k5vyPmpN_es = __esm(() => {
-  init_SuperConverter_DBsJeu9t_es();
-  init_create_headless_toolbar_BiY_0zZP_es();
+var init_create_super_doc_ui_BOYlxpy0_es = __esm(() => {
+  init_SuperConverter_D2zNnC50_es();
+  init_create_headless_toolbar_COmoIa5Q_es();
   MOD_ALIASES = new Set([
     "Mod",
     "Meta",
@@ -361542,16 +363149,16 @@ var init_zipper_yaJVJ4z9_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_MLERudib_es();
-  init_SuperConverter_DBsJeu9t_es();
+  init_src_eTZqPcFn_es();
+  init_SuperConverter_D2zNnC50_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
-  init_create_headless_toolbar_BiY_0zZP_es();
+  init_create_headless_toolbar_COmoIa5Q_es();
   init_constants_D9qj59G2_es();
   init_dist_B8HfvhaK_es();
   init_unified_Dsuw2be5_es();
   init_DocxZipper_Bu2Fhqkw_es();
-  init_create_super_doc_ui_k5vyPmpN_es();
+  init_create_super_doc_ui_BOYlxpy0_es();
   init_ui_C5PAS9hY_es();
   init_eventemitter3_BnGqBE_Q_es();
   init_errors_CNaD6vcg_es();