@xignature/docx-editor 1.0.0

package/dist/chunk-VOCY4R5S.mjs

@@ -0,0 +1,1642 @@
+// src/core/layout-engine/paginator.ts
+function calculateColumnWidth(pageWidth, leftMargin, rightMargin, columns) {
+  const contentWidth = pageWidth - leftMargin - rightMargin;
+  const totalGaps = (columns.count - 1) * columns.gap;
+  return (contentWidth - totalGaps) / columns.count;
+}
+function createPaginator(options) {
+  const { pageSize, margins } = options;
+  let columns = options.columns ?? { count: 1, gap: 0 };
+  const pages = [];
+  const states = [];
+  const topMargin = margins.top;
+  const contentBottom = pageSize.h - margins.bottom;
+  const contentHeight = contentBottom - topMargin;
+  if (contentHeight <= 0) {
+    throw new Error("Paginator: page size and margins yield no content area");
+  }
+  let columnWidth = calculateColumnWidth(pageSize.w, margins.left, margins.right, columns);
+  let columnRegionTop = topMargin;
+  function getColumnX(columnIndex) {
+    return margins.left + columnIndex * (columnWidth + columns.gap);
+  }
+  function createNewPage() {
+    const pageNumber = pages.length + 1;
+    const footnoteHeight = options.footnoteReservedHeights?.get(pageNumber) ?? 0;
+    const pageContentBottom = contentBottom - footnoteHeight;
+    const page = {
+      number: pageNumber,
+      fragments: [],
+      margins: { ...margins },
+      size: { ...pageSize },
+      footnoteReservedHeight: footnoteHeight > 0 ? footnoteHeight : void 0,
+      // Set initial columns; may be overwritten by updateColumns() for continuous section breaks
+      columns: columns.count > 1 ? { ...columns } : void 0
+    };
+    const state = {
+      page,
+      cursorY: topMargin,
+      columnIndex: 0,
+      topMargin,
+      contentBottom: pageContentBottom,
+      trailingSpacing: 0
+    };
+    pages.push(page);
+    states.push(state);
+    columnRegionTop = topMargin;
+    if (options.onNewPage) {
+      options.onNewPage(state);
+    }
+    return state;
+  }
+  function getCurrentState() {
+    if (states.length === 0) {
+      return createNewPage();
+    }
+    return states[states.length - 1];
+  }
+  function getAvailableHeight(state) {
+    return state.contentBottom - state.cursorY;
+  }
+  function fits(height, state) {
+    const s = state || getCurrentState();
+    return getAvailableHeight(s) >= height;
+  }
+  function advanceColumn(state) {
+    if (state.columnIndex < columns.count - 1) {
+      state.columnIndex += 1;
+      state.cursorY = columnRegionTop;
+      state.trailingSpacing = 0;
+      return state;
+    }
+    return createNewPage();
+  }
+  function ensureFits(height) {
+    let state = getCurrentState();
+    const safeHeight = Number.isFinite(height) && height > 0 ? height : 0;
+    const columnCapacity = state.contentBottom - state.topMargin;
+    if (safeHeight > columnCapacity) {
+      if (state.cursorY !== state.topMargin) {
+        state = advanceColumn(state);
+      }
+      return state;
+    }
+    while (!fits(safeHeight, state)) {
+      state = advanceColumn(state);
+    }
+    return state;
+  }
+  function addFragment(fragment, height, spaceBefore = 0, spaceAfter = 0) {
+    const effectiveSpaceBefore = Math.max(spaceBefore, getCurrentState().trailingSpacing);
+    const totalHeight = effectiveSpaceBefore + height;
+    const state = ensureFits(totalHeight);
+    const isAtTop = state.cursorY === state.topMargin;
+    const actualSpaceBefore = isAtTop ? 0 : effectiveSpaceBefore;
+    const x = getColumnX(state.columnIndex);
+    const y = state.cursorY + actualSpaceBefore;
+    fragment.x = x;
+    fragment.y = y;
+    state.page.fragments.push(fragment);
+    state.cursorY = y + height;
+    state.trailingSpacing = spaceAfter;
+    return { state, x, y };
+  }
+  function forcePageBreak() {
+    return createNewPage();
+  }
+  function forceColumnBreak() {
+    const state = getCurrentState();
+    return advanceColumn(state);
+  }
+  function updateColumns(newColumns) {
+    columns = newColumns;
+    columnWidth = calculateColumnWidth(pageSize.w, margins.left, margins.right, columns);
+    const state = getCurrentState();
+    state.page.columns = columns.count > 1 ? { ...columns } : void 0;
+    columnRegionTop = state.cursorY;
+    state.columnIndex = 0;
+  }
+  return {
+    /** All pages created so far. */
+    pages,
+    /** All page states. */
+    states,
+    /** Column width in pixels (use getColumnWidth() for current value after updates). */
+    get columnWidth() {
+      return columnWidth;
+    },
+    /** Get current column layout (returns copy to prevent external mutation). */
+    get columns() {
+      return { ...columns };
+    },
+    /** Get current state. */
+    getCurrentState,
+    /** Get available height in current column. */
+    getAvailableHeight: () => getAvailableHeight(getCurrentState()),
+    /** Check if height fits in current column. */
+    fits: (height) => fits(height),
+    /** Ensure height fits, advancing if needed. */
+    ensureFits,
+    /** Add a fragment to current page. */
+    addFragment,
+    /** Force a page break. */
+    forcePageBreak,
+    /** Force a column break. */
+    forceColumnBreak,
+    /** Get X position for column. */
+    getColumnX,
+    /** Update column layout (for section breaks). */
+    updateColumns
+  };
+}
+
+// src/core/layout-engine/keep-together.ts
+function computeKeepNextChains(blocks) {
+  const chains = /* @__PURE__ */ new Map();
+  const processed = /* @__PURE__ */ new Set();
+  for (let i = 0; i < blocks.length; i++) {
+    if (processed.has(i)) continue;
+    const block = blocks[i];
+    if (block.kind !== "paragraph") continue;
+    const para = block;
+    if (!para.attrs?.keepNext) continue;
+    const memberIndices = [i];
+    let endIndex = i;
+    for (let j = i + 1; j < blocks.length; j++) {
+      const nextBlock = blocks[j];
+      if (nextBlock.kind === "sectionBreak" || nextBlock.kind === "pageBreak" || nextBlock.kind === "columnBreak") {
+        break;
+      }
+      if (nextBlock.kind !== "paragraph") {
+        break;
+      }
+      const nextPara = nextBlock;
+      if (nextPara.attrs?.keepNext) {
+        memberIndices.push(j);
+        endIndex = j;
+        processed.add(j);
+      } else {
+        break;
+      }
+    }
+    const potentialAnchor = endIndex + 1;
+    let anchorIndex = -1;
+    if (potentialAnchor < blocks.length) {
+      const anchorBlock = blocks[potentialAnchor];
+      if (anchorBlock.kind !== "sectionBreak" && anchorBlock.kind !== "pageBreak" && anchorBlock.kind !== "columnBreak") {
+        anchorIndex = potentialAnchor;
+      }
+    }
+    chains.set(i, {
+      startIndex: i,
+      endIndex,
+      memberIndices,
+      anchorIndex
+    });
+  }
+  return chains;
+}
+function calculateChainHeight(chain, blocks, measures) {
+  let totalHeight = 0;
+  for (const memberIndex of chain.memberIndices) {
+    const block = blocks[memberIndex];
+    const measure = measures[memberIndex];
+    if (block.kind !== "paragraph" || measure.kind !== "paragraph") continue;
+    const para = block;
+    const paraMeasure = measure;
+    const spacingBefore = para.attrs?.spacing?.before ?? 0;
+    totalHeight += spacingBefore;
+    totalHeight += paraMeasure.totalHeight;
+    const spacingAfter = para.attrs?.spacing?.after ?? 0;
+    totalHeight += spacingAfter;
+  }
+  if (chain.anchorIndex !== -1) {
+    const anchorMeasure = measures[chain.anchorIndex];
+    if (anchorMeasure?.kind === "paragraph") {
+      const anchorPara = anchorMeasure;
+      if (anchorPara.lines.length > 0) {
+        totalHeight += anchorPara.lines[0].lineHeight;
+      }
+    }
+  }
+  return totalHeight;
+}
+function getMidChainIndices(chains) {
+  const midChain = /* @__PURE__ */ new Set();
+  for (const chain of chains.values()) {
+    for (let i = 1; i < chain.memberIndices.length; i++) {
+      midChain.add(chain.memberIndices[i]);
+    }
+  }
+  return midChain;
+}
+function hasPageBreakBefore(block) {
+  if (block.kind !== "paragraph") return false;
+  const para = block;
+  return para.attrs?.pageBreakBefore === true;
+}
+
+// src/core/layout-engine/types.ts
+var DEFAULT_TEXTBOX_MARGINS = { top: 4, bottom: 4, left: 7, right: 7 };
+var DEFAULT_TEXTBOX_WIDTH = 200;
+
+// src/core/layout-engine/findPageIndexContainingPmPos.ts
+function findPageIndexContainingPmPos(layout, pmPos) {
+  for (let pi = 0; pi < layout.pages.length; pi++) {
+    for (const frag of layout.pages[pi].fragments) {
+      if (frag.pmStart == null) continue;
+      const start = frag.pmStart;
+      const end = frag.pmEnd ?? start + 1;
+      if (pmPos >= start && pmPos < end) {
+        return pi;
+      }
+    }
+  }
+  return null;
+}
+
+// src/core/layout-engine/index.ts
+var DEFAULT_PAGE_SIZE = { w: 816, h: 1056 };
+var DEFAULT_MARGINS = {
+  top: 96,
+  right: 96,
+  bottom: 96,
+  left: 96
+};
+function getSpacingBefore(block) {
+  return block.attrs?.spacing?.before ?? 0;
+}
+function getSpacingAfter(block) {
+  return block.attrs?.spacing?.after ?? 0;
+}
+function applyContextualSpacing(blocks) {
+  for (let i = 0; i < blocks.length - 1; i++) {
+    const curr = blocks[i];
+    const next = blocks[i + 1];
+    if (curr.kind !== "paragraph" || next.kind !== "paragraph") continue;
+    const currAttrs = curr.attrs;
+    const nextAttrs = next.attrs;
+    if (currAttrs?.contextualSpacing && nextAttrs?.contextualSpacing && currAttrs.styleId && currAttrs.styleId === nextAttrs.styleId) {
+      if (currAttrs.spacing) {
+        currAttrs.spacing = { ...currAttrs.spacing, after: 0 };
+      }
+      if (nextAttrs.spacing) {
+        nextAttrs.spacing = { ...nextAttrs.spacing, before: 0 };
+      }
+    }
+  }
+}
+function layoutDocument(blocks, measures, options = {}) {
+  if (blocks.length !== measures.length) {
+    throw new Error(
+      `layoutDocument: expected one measure per block (blocks=${blocks.length}, measures=${measures.length})`
+    );
+  }
+  const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+  const baseMargins = {
+    top: options.margins?.top ?? DEFAULT_MARGINS.top,
+    right: options.margins?.right ?? DEFAULT_MARGINS.right,
+    bottom: options.margins?.bottom ?? DEFAULT_MARGINS.bottom,
+    left: options.margins?.left ?? DEFAULT_MARGINS.left,
+    header: options.margins?.header ?? options.margins?.top ?? DEFAULT_MARGINS.top,
+    footer: options.margins?.footer ?? options.margins?.bottom ?? DEFAULT_MARGINS.bottom
+  };
+  void options.headerContentHeights;
+  void options.footerContentHeights;
+  void options.titlePage;
+  void options.evenAndOddHeaders;
+  const margins = { ...baseMargins };
+  const contentWidth = pageSize.w - margins.left - margins.right;
+  if (contentWidth <= 0) {
+    throw new Error("layoutDocument: page size and margins yield no content area");
+  }
+  const defaultColumns = { count: 1, gap: 0 };
+  const sectionColumnConfigs = [];
+  const sectionBreakTypes = [];
+  for (let i = 0; i < blocks.length; i++) {
+    if (blocks[i].kind === "sectionBreak") {
+      const sb = blocks[i];
+      sectionColumnConfigs.push(sb.columns ?? defaultColumns);
+      sectionBreakTypes.push(sb.type);
+    }
+  }
+  sectionColumnConfigs.push(options.columns ?? defaultColumns);
+  sectionBreakTypes.push(options.bodyBreakType);
+  const initialColumns = sectionColumnConfigs.length > 0 ? sectionColumnConfigs[0] : options.columns;
+  const paginator = createPaginator({
+    pageSize,
+    margins,
+    columns: initialColumns,
+    footnoteReservedHeights: options.footnoteReservedHeights
+  });
+  applyContextualSpacing(blocks);
+  const keepNextChains = computeKeepNextChains(blocks);
+  const midChainIndices = getMidChainIndices(keepNextChains);
+  let sectionIdx = 0;
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    const measure = measures[i];
+    if (hasPageBreakBefore(block)) {
+      paginator.forcePageBreak();
+    }
+    const chain = keepNextChains.get(i);
+    if (chain && !midChainIndices.has(i)) {
+      const chainHeight = calculateChainHeight(chain, blocks, measures);
+      const state = paginator.getCurrentState();
+      const availableHeight = paginator.getAvailableHeight();
+      const pageContentHeight = state.contentBottom - state.topMargin;
+      if (chainHeight <= pageContentHeight && chainHeight > availableHeight && state.page.fragments.length > 0) {
+        paginator.forcePageBreak();
+      }
+    }
+    switch (block.kind) {
+      case "paragraph":
+        layoutParagraph(block, measure, paginator, contentWidth);
+        break;
+      case "table":
+        if (block.floating) {
+          layoutFloatingTable(block, measure, paginator, contentWidth);
+        } else {
+          layoutTable(block, measure, paginator);
+        }
+        break;
+      case "image":
+        layoutImage(block, measure, paginator);
+        break;
+      case "textBox":
+        layoutTextBox(block, measure, paginator);
+        break;
+      case "pageBreak":
+        paginator.forcePageBreak();
+        break;
+      case "columnBreak":
+        paginator.forceColumnBreak();
+        break;
+      case "sectionBreak": {
+        const nextType = sectionBreakTypes[sectionIdx + 1] ?? sectionBreakTypes[sectionIdx];
+        handleSectionBreak(
+          block,
+          paginator,
+          sectionColumnConfigs[sectionIdx + 1] ?? defaultColumns,
+          nextType
+        );
+        sectionIdx++;
+        break;
+      }
+    }
+  }
+  if (paginator.pages.length === 0) {
+    paginator.getCurrentState();
+  }
+  return {
+    pageSize,
+    pages: paginator.pages,
+    columns: options.columns,
+    pageGap: options.pageGap
+  };
+}
+function layoutParagraph(block, measure, paginator, contentWidth) {
+  if (measure.kind !== "paragraph") {
+    throw new Error(`layoutParagraph: expected paragraph measure`);
+  }
+  const lines = measure.lines;
+  if (lines.length === 0) {
+    const spaceBefore2 = getSpacingBefore(block);
+    const spaceAfter2 = getSpacingAfter(block);
+    const state = paginator.getCurrentState();
+    const fragment = {
+      kind: "paragraph",
+      blockId: block.id,
+      x: paginator.getColumnX(state.columnIndex),
+      y: state.cursorY + spaceBefore2,
+      width: contentWidth,
+      height: 0,
+      fromLine: 0,
+      toLine: 0,
+      pmStart: block.pmStart,
+      pmEnd: block.pmEnd
+    };
+    paginator.addFragment(fragment, 0, spaceBefore2, spaceAfter2);
+    return;
+  }
+  const spaceBefore = getSpacingBefore(block);
+  const spaceAfter = getSpacingAfter(block);
+  let currentLineIndex = 0;
+  while (currentLineIndex < lines.length) {
+    const state = paginator.getCurrentState();
+    const availableHeight = paginator.getAvailableHeight();
+    let linesHeight = 0;
+    let fittingLines = 0;
+    for (let j = currentLineIndex; j < lines.length; j++) {
+      const lineHeight = lines[j].lineHeight;
+      const totalWithLine = linesHeight + lineHeight;
+      const withSpacing = currentLineIndex === 0 && j === currentLineIndex ? totalWithLine + spaceBefore : totalWithLine;
+      if (withSpacing <= availableHeight || fittingLines === 0) {
+        linesHeight = totalWithLine;
+        fittingLines++;
+      } else {
+        break;
+      }
+    }
+    const isFirstFragment = currentLineIndex === 0;
+    const isLastFragment = currentLineIndex + fittingLines >= lines.length;
+    const effectiveSpaceBefore = isFirstFragment ? spaceBefore : 0;
+    const effectiveSpaceAfter = isLastFragment ? spaceAfter : 0;
+    const fragment = {
+      kind: "paragraph",
+      blockId: block.id,
+      x: paginator.getColumnX(state.columnIndex),
+      y: 0,
+      // Will be set by addFragment
+      width: contentWidth,
+      height: linesHeight,
+      fromLine: currentLineIndex,
+      toLine: currentLineIndex + fittingLines,
+      pmStart: block.pmStart,
+      pmEnd: block.pmEnd,
+      continuesFromPrev: !isFirstFragment,
+      continuesOnNext: !isLastFragment
+    };
+    const result = paginator.addFragment(
+      fragment,
+      linesHeight,
+      effectiveSpaceBefore,
+      effectiveSpaceAfter
+    );
+    fragment.y = result.y;
+    currentLineIndex += fittingLines;
+    if (currentLineIndex < lines.length) {
+      paginator.ensureFits(lines[currentLineIndex].lineHeight);
+    }
+  }
+}
+function countHeaderRows(block) {
+  let count = 0;
+  for (const row of block.rows) {
+    if (row.isHeader) {
+      count++;
+    } else {
+      break;
+    }
+  }
+  return count;
+}
+function getHeaderRowsHeight(measure, headerRowCount) {
+  let height = 0;
+  for (let i = 0; i < headerRowCount && i < measure.rows.length; i++) {
+    height += measure.rows[i].height;
+  }
+  return height;
+}
+function layoutTable(block, measure, paginator) {
+  if (measure.kind !== "table") {
+    throw new Error(`layoutTable: expected table measure`);
+  }
+  const rows = measure.rows;
+  if (rows.length === 0) {
+    return;
+  }
+  const headerRowCount = countHeaderRows(block);
+  const headerRowsHeight = getHeaderRowsHeight(measure, headerRowCount);
+  let currentRowIndex = 0;
+  while (currentRowIndex < rows.length) {
+    const state = paginator.getCurrentState();
+    const rawAvailableHeight = paginator.getAvailableHeight();
+    const isFirstFragment = currentRowIndex === 0;
+    const pendingSpacing = isFirstFragment ? state.trailingSpacing : 0;
+    const availableHeight = rawAvailableHeight - pendingSpacing;
+    const headerOverhead = !isFirstFragment && headerRowCount > 0 ? headerRowsHeight : 0;
+    let rowsHeight = 0;
+    let fittingRows = 0;
+    for (let j = currentRowIndex; j < rows.length; j++) {
+      const rowHeight = rows[j].height;
+      const totalWithRow = rowsHeight + rowHeight + headerOverhead;
+      if (totalWithRow <= availableHeight || fittingRows === 0) {
+        rowsHeight += rowHeight;
+        fittingRows++;
+      } else {
+        break;
+      }
+    }
+    const fragmentHeight = rowsHeight + headerOverhead;
+    const isLastFragment = currentRowIndex + fittingRows >= rows.length;
+    let desiredX = paginator.getColumnX(state.columnIndex);
+    if (block.justification === "center") {
+      desiredX = desiredX + (paginator.columnWidth - measure.totalWidth) / 2;
+    } else if (block.justification === "right") {
+      desiredX = desiredX + paginator.columnWidth - measure.totalWidth;
+    } else if (block.indent) {
+      desiredX += block.indent;
+    }
+    const fragment = {
+      kind: "table",
+      blockId: block.id,
+      x: desiredX,
+      y: 0,
+      // Will be set by addFragment
+      width: measure.totalWidth,
+      height: fragmentHeight,
+      fromRow: currentRowIndex,
+      toRow: currentRowIndex + fittingRows,
+      pmStart: block.pmStart,
+      pmEnd: block.pmEnd,
+      continuesFromPrev: !isFirstFragment,
+      continuesOnNext: !isLastFragment,
+      headerRowCount: !isFirstFragment && headerRowCount > 0 ? headerRowCount : void 0
+    };
+    const result = paginator.addFragment(fragment, fragmentHeight, 0, 0);
+    fragment.y = result.y;
+    fragment.x = desiredX;
+    currentRowIndex += fittingRows;
+    if (currentRowIndex < rows.length) {
+      const nextRowHeight = rows[currentRowIndex].height + (headerRowCount > 0 ? headerRowsHeight : 0);
+      paginator.ensureFits(nextRowHeight);
+    }
+  }
+}
+function layoutFloatingTable(block, measure, paginator, contentWidth) {
+  if (measure.kind !== "table") {
+    throw new Error(`layoutFloatingTable: expected table measure`);
+  }
+  const state = paginator.getCurrentState();
+  const floating = block.floating;
+  const page = state.page;
+  const margins = page.margins;
+  const tableWidth = measure.totalWidth;
+  const tableHeight = measure.totalHeight;
+  const contentHeight = page.size.h - margins.top - margins.bottom;
+  let baseX = margins.left;
+  let baseY = margins.top;
+  if (floating?.horzAnchor === "page") baseX = 0;
+  if (floating?.vertAnchor === "page") baseY = 0;
+  let x = paginator.getColumnX(state.columnIndex);
+  if (floating?.tblpX !== void 0) {
+    x = baseX + floating.tblpX;
+  } else if (floating?.tblpXSpec) {
+    const spec = floating.tblpXSpec;
+    if (spec === "left" || spec === "inside") {
+      x = baseX;
+    } else if (spec === "right" || spec === "outside") {
+      x = baseX + contentWidth - tableWidth;
+    } else if (spec === "center") {
+      x = baseX + (contentWidth - tableWidth) / 2;
+    }
+  } else if (block.justification === "center") {
+    x = baseX + (contentWidth - tableWidth) / 2;
+  } else if (block.justification === "right") {
+    x = baseX + contentWidth - tableWidth;
+  }
+  let y = state.cursorY;
+  let usedExplicitY = false;
+  if (floating?.tblpY !== void 0) {
+    y = baseY + floating.tblpY;
+    usedExplicitY = true;
+  } else if (floating?.tblpYSpec) {
+    usedExplicitY = true;
+    const spec = floating.tblpYSpec;
+    if (spec === "top") {
+      y = baseY;
+    } else if (spec === "bottom") {
+      y = baseY + contentHeight - tableHeight;
+    } else if (spec === "center") {
+      y = baseY + (contentHeight - tableHeight) / 2;
+    }
+  }
+  if (!usedExplicitY) {
+    const fitState = paginator.ensureFits(tableHeight);
+    y = fitState.cursorY;
+  }
+  const minX = margins.left;
+  const maxX = margins.left + contentWidth - tableWidth;
+  if (Number.isFinite(maxX)) {
+    x = Math.max(minX, Math.min(x, maxX));
+  }
+  const fragment = {
+    kind: "table",
+    blockId: block.id,
+    x,
+    y,
+    width: tableWidth,
+    height: tableHeight,
+    fromRow: 0,
+    toRow: block.rows.length,
+    pmStart: block.pmStart,
+    pmEnd: block.pmEnd,
+    isFloating: true
+  };
+  state.page.fragments.push(fragment);
+}
+function layoutImage(block, measure, paginator) {
+  if (measure.kind !== "image") {
+    throw new Error(`layoutImage: expected image measure`);
+  }
+  if (block.anchor?.isAnchored) {
+    layoutAnchoredImage(block, measure, paginator);
+    return;
+  }
+  const state = paginator.ensureFits(measure.height);
+  const fragment = {
+    kind: "image",
+    blockId: block.id,
+    x: paginator.getColumnX(state.columnIndex),
+    y: 0,
+    // Will be set by addFragment
+    width: measure.width,
+    height: measure.height,
+    pmStart: block.pmStart,
+    pmEnd: block.pmEnd
+  };
+  const result = paginator.addFragment(fragment, measure.height, 0, 0);
+  fragment.y = result.y;
+}
+function layoutAnchoredImage(block, measure, paginator) {
+  const state = paginator.getCurrentState();
+  const anchor = block.anchor;
+  const x = anchor.offsetH ?? paginator.getColumnX(state.columnIndex);
+  const y = anchor.offsetV ?? state.cursorY;
+  const fragment = {
+    kind: "image",
+    blockId: block.id,
+    x,
+    y,
+    width: measure.width,
+    height: measure.height,
+    pmStart: block.pmStart,
+    pmEnd: block.pmEnd,
+    isAnchored: true,
+    zIndex: anchor.behindDoc ? -1 : 1
+  };
+  state.page.fragments.push(fragment);
+}
+function layoutTextBox(block, measure, paginator) {
+  if (measure.kind !== "textBox") {
+    throw new Error(`layoutTextBox: expected textBox measure`);
+  }
+  const state = paginator.ensureFits(measure.height);
+  const fragment = {
+    kind: "textBox",
+    blockId: block.id,
+    x: paginator.getColumnX(state.columnIndex),
+    y: 0,
+    width: measure.width,
+    height: measure.height,
+    pmStart: block.pmStart,
+    pmEnd: block.pmEnd
+  };
+  const result = paginator.addFragment(fragment, measure.height, 0, 0);
+  fragment.y = result.y;
+}
+function handleSectionBreak(_block, paginator, nextSectionColumns, nextSectionType) {
+  const breakType = nextSectionType ?? "nextPage";
+  switch (breakType) {
+    case "nextPage":
+      paginator.forcePageBreak();
+      break;
+    case "evenPage": {
+      const state = paginator.forcePageBreak();
+      if (state.page.number % 2 !== 0) {
+        paginator.forcePageBreak();
+      }
+      break;
+    }
+    case "oddPage": {
+      const state = paginator.forcePageBreak();
+      if (state.page.number % 2 === 0) {
+        paginator.forcePageBreak();
+      }
+      break;
+    }
+    case "continuous":
+      break;
+  }
+  paginator.updateColumns(nextSectionColumns);
+}
+
+// src/core/utils/fontResolver.ts
+var DEFAULT_SINGLE_LINE_RATIO = 1.15;
+var FONT_MAPPINGS = {
+  // Microsoft Office fonts -> Google equivalents (via Croscore)
+  calibri: {
+    googleFont: "Carlito",
+    category: "sans-serif",
+    fallbackStack: ["Calibri", "Carlito", "Arial", "Helvetica", "sans-serif"],
+    singleLineRatio: 1.2207
+    // 2500/2048
+  },
+  cambria: {
+    googleFont: "Caladea",
+    category: "serif",
+    fallbackStack: ["Cambria", "Caladea", "Georgia", "serif"],
+    singleLineRatio: 1.2676
+    // 2596/2048
+  },
+  arial: {
+    googleFont: "Arimo",
+    category: "sans-serif",
+    fallbackStack: ["Arial", "Arimo", "Helvetica", "sans-serif"],
+    singleLineRatio: 1.1172
+    // (1854+434)/2048 — no sTypoLineGap
+  },
+  "times new roman": {
+    googleFont: "Tinos",
+    category: "serif",
+    fallbackStack: ["Times New Roman", "Tinos", "Times", "serif"],
+    singleLineRatio: 1.1074
+    // (1825+443)/2048 — no sTypoLineGap
+  },
+  "courier new": {
+    googleFont: "Cousine",
+    category: "monospace",
+    fallbackStack: ["Courier New", "Cousine", "Courier", "monospace"],
+    singleLineRatio: 1.1328
+    // 2320/2048
+  },
+  // Additional common fonts
+  georgia: {
+    googleFont: "Tinos",
+    // Similar but not perfect match
+    category: "serif",
+    fallbackStack: ["Georgia", "Tinos", "Times New Roman", "serif"],
+    singleLineRatio: 1.1362
+    // 2327/2048
+  },
+  verdana: {
+    googleFont: "Open Sans",
+    // Similar sans-serif
+    category: "sans-serif",
+    fallbackStack: ["Verdana", "Open Sans", "Arial", "sans-serif"],
+    singleLineRatio: 1.2153
+    // 2489/2048
+  },
+  tahoma: {
+    googleFont: "Open Sans",
+    category: "sans-serif",
+    fallbackStack: ["Tahoma", "Open Sans", "Arial", "sans-serif"],
+    singleLineRatio: 1.2075
+    // 2472/2048
+  },
+  "trebuchet ms": {
+    googleFont: "Fira Sans",
+    category: "sans-serif",
+    fallbackStack: ["Trebuchet MS", "Fira Sans", "Arial", "sans-serif"],
+    singleLineRatio: 1.1431
+    // 2341/2048
+  },
+  "comic sans ms": {
+    googleFont: "Comic Neue",
+    category: "cursive",
+    fallbackStack: ["Comic Sans MS", "Comic Neue", "cursive"],
+    singleLineRatio: 1.3936
+    // 2854/2048
+  },
+  impact: {
+    googleFont: "Anton",
+    category: "sans-serif",
+    fallbackStack: ["Impact", "Anton", "Arial Black", "sans-serif"],
+    singleLineRatio: 1.2197
+    // 2498/2048
+  },
+  "palatino linotype": {
+    googleFont: "EB Garamond",
+    category: "serif",
+    fallbackStack: ["Palatino Linotype", "EB Garamond", "Palatino", "Georgia", "serif"],
+    singleLineRatio: 1.0259
+    // 2101/2048
+  },
+  "book antiqua": {
+    googleFont: "EB Garamond",
+    category: "serif",
+    fallbackStack: ["Book Antiqua", "EB Garamond", "Palatino", "Georgia", "serif"],
+    singleLineRatio: 1.0259
+    // 2101/2048
+  },
+  garamond: {
+    googleFont: "EB Garamond",
+    category: "serif",
+    fallbackStack: ["Garamond", "EB Garamond", "Georgia", "serif"],
+    singleLineRatio: 1.068
+    // 1068/1000
+  },
+  "century gothic": {
+    googleFont: "Questrial",
+    category: "sans-serif",
+    fallbackStack: ["Century Gothic", "Questrial", "Arial", "sans-serif"],
+    singleLineRatio: 1.1611
+    // 2378/2048
+  },
+  "lucida sans": {
+    googleFont: "Open Sans",
+    category: "sans-serif",
+    fallbackStack: ["Lucida Sans", "Open Sans", "Arial", "sans-serif"],
+    singleLineRatio: 1.1655
+    // 2387/2048
+  },
+  "lucida console": {
+    googleFont: "Cousine",
+    category: "monospace",
+    fallbackStack: ["Lucida Console", "Cousine", "Courier New", "monospace"],
+    singleLineRatio: 1.1387
+    // 2332/2048
+  },
+  consolas: {
+    googleFont: "Inconsolata",
+    category: "monospace",
+    fallbackStack: ["Consolas", "Inconsolata", "Cousine", "Courier New", "monospace"],
+    singleLineRatio: 1.1626
+    // 2381/2048
+  },
+  // CJK fonts
+  "ms mincho": {
+    googleFont: "Noto Serif JP",
+    category: "serif",
+    fallbackStack: ["MS Mincho", "Noto Serif JP", "serif"],
+    singleLineRatio: DEFAULT_SINGLE_LINE_RATIO
+  },
+  "ms gothic": {
+    googleFont: "Noto Sans JP",
+    category: "sans-serif",
+    fallbackStack: ["MS Gothic", "Noto Sans JP", "sans-serif"],
+    singleLineRatio: DEFAULT_SINGLE_LINE_RATIO
+  },
+  simhei: {
+    googleFont: "Noto Sans SC",
+    category: "sans-serif",
+    fallbackStack: ["SimHei", "Noto Sans SC", "sans-serif"],
+    singleLineRatio: DEFAULT_SINGLE_LINE_RATIO
+  },
+  simsun: {
+    googleFont: "Noto Serif SC",
+    category: "serif",
+    fallbackStack: ["SimSun", "Noto Serif SC", "serif"],
+    singleLineRatio: DEFAULT_SINGLE_LINE_RATIO
+  },
+  "malgun gothic": {
+    googleFont: "Noto Sans KR",
+    category: "sans-serif",
+    fallbackStack: ["Malgun Gothic", "Noto Sans KR", "sans-serif"],
+    singleLineRatio: DEFAULT_SINGLE_LINE_RATIO
+  }
+};
+var DEFAULT_FALLBACKS = {
+  "sans-serif": "Arial, Helvetica, sans-serif",
+  serif: "Times New Roman, Times, serif",
+  monospace: "Courier New, Courier, monospace",
+  cursive: "cursive",
+  fantasy: "fantasy",
+  "system-ui": "system-ui, sans-serif"
+};
+function detectFontCategory(fontName) {
+  const lower = fontName.toLowerCase();
+  if (lower.includes("mono") || lower.includes("courier") || lower.includes("consolas") || lower.includes("console") || lower.includes("code") || lower.includes("terminal")) {
+    return "monospace";
+  }
+  if (lower.includes("times") || lower.includes("georgia") || lower.includes("garamond") || lower.includes("palatino") || lower.includes("baskerville") || lower.includes("bodoni") || lower.includes("cambria") || lower.includes("mincho") || lower.includes("ming") || lower.includes("song") || lower.includes("serif")) {
+    return "serif";
+  }
+  if (lower.includes("script") || lower.includes("cursive") || lower.includes("comic") || lower.includes("brush") || lower.includes("hand")) {
+    return "cursive";
+  }
+  return "sans-serif";
+}
+function resolveFontFamily(docxFontName) {
+  const normalizedName = docxFontName.trim().toLowerCase();
+  const mapping = FONT_MAPPINGS[normalizedName];
+  if (mapping) {
+    return {
+      googleFont: mapping.googleFont,
+      cssFallback: mapping.fallbackStack.map(quoteFontName).join(", "),
+      originalFont: docxFontName,
+      hasGoogleEquivalent: true,
+      singleLineRatio: mapping.singleLineRatio
+    };
+  }
+  const category = detectFontCategory(docxFontName);
+  const defaultFallback = DEFAULT_FALLBACKS[category];
+  return {
+    googleFont: null,
+    cssFallback: `${quoteFontName(docxFontName)}, ${defaultFallback}`,
+    originalFont: docxFontName,
+    hasGoogleEquivalent: false,
+    singleLineRatio: DEFAULT_SINGLE_LINE_RATIO
+  };
+}
+function quoteFontName(fontName) {
+  if (["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui"].includes(
+    fontName.toLowerCase()
+  )) {
+    return fontName;
+  }
+  if (/[\s,'"()]/.test(fontName)) {
+    return `"${fontName.replace(/"/g, '\\"')}"`;
+  }
+  return fontName;
+}
+function resolveThemeFont(themeRef, fontScheme) {
+  if (!fontScheme) {
+    return null;
+  }
+  const isMajor = themeRef.toLowerCase().startsWith("major");
+  const themeFont = isMajor ? fontScheme.majorFont : fontScheme.minorFont;
+  if (!themeFont) {
+    return null;
+  }
+  const ref = themeRef.toLowerCase();
+  if (ref.includes("eastasia") || ref.includes("ea")) {
+    return themeFont.ea ?? themeFont.latin ?? null;
+  }
+  if (ref.includes("cs") || ref.includes("bidi")) {
+    return themeFont.cs ?? themeFont.latin ?? null;
+  }
+  return themeFont.latin ?? null;
+}
+
+// src/core/layout-bridge/measuring/measureContainer.ts
+var TWIPS_PER_INCH = 1440;
+var PX_PER_INCH = 96;
+var TWIPS_PER_PX = TWIPS_PER_INCH / PX_PER_INCH;
+var DEFAULT_FONT_SIZE = 11;
+var DEFAULT_FONT_FAMILY = "Calibri";
+var DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
+var DEFAULT_ASCENT_RATIO = 0.8;
+var DEFAULT_DESCENT_RATIO = 0.2;
+var canvasContext = null;
+function getCanvasContext() {
+  if (!canvasContext) {
+    const canvas = typeof document !== "undefined" ? document.createElement("canvas") : null;
+    if (!canvas) {
+      throw new Error("Canvas not available. Ensure this runs in a DOM environment.");
+    }
+    canvasContext = canvas.getContext("2d");
+    if (!canvasContext) {
+      throw new Error("Failed to get 2D context from canvas");
+    }
+  }
+  return canvasContext;
+}
+function resetCanvasContext() {
+  canvasContext = null;
+}
+var fontResolvedCache = /* @__PURE__ */ new Map();
+function getResolvedData(fontFamily) {
+  let cached = fontResolvedCache.get(fontFamily);
+  if (cached === void 0) {
+    const resolved = resolveFontFamily(fontFamily);
+    cached = { cssFallback: resolved.cssFallback, singleLineRatio: resolved.singleLineRatio };
+    fontResolvedCache.set(fontFamily, cached);
+  }
+  return cached;
+}
+function getResolvedFallback(fontFamily) {
+  return getResolvedData(fontFamily).cssFallback;
+}
+function buildFontString(style) {
+  const parts = [];
+  if (style.italic) parts.push("italic");
+  if (style.bold) parts.push("bold");
+  const fontSizePt = style.fontSize ?? DEFAULT_FONT_SIZE;
+  const fontSizePx = ptToPx(fontSizePt);
+  parts.push(`${fontSizePx}px`);
+  const fontFamily = style.fontFamily ?? DEFAULT_FONT_FAMILY;
+  parts.push(getResolvedFallback(fontFamily));
+  return parts.join(" ");
+}
+function getFontMetrics(style) {
+  const fontSize = style.fontSize ?? DEFAULT_FONT_SIZE;
+  const fontFamily = style.fontFamily ?? DEFAULT_FONT_FAMILY;
+  const fontSizePx = ptToPx(fontSize);
+  let ascent = fontSizePx * DEFAULT_ASCENT_RATIO;
+  let descent = fontSizePx * DEFAULT_DESCENT_RATIO;
+  let lineHeight = fontSizePx * DEFAULT_LINE_HEIGHT_MULTIPLIER;
+  try {
+    const ctx = getCanvasContext();
+    ctx.font = buildFontString(style);
+    const metrics = ctx.measureText("Hg");
+    if (typeof metrics.actualBoundingBoxAscent === "number" && typeof metrics.actualBoundingBoxDescent === "number") {
+      ascent = metrics.actualBoundingBoxAscent;
+      descent = metrics.actualBoundingBoxDescent;
+    }
+  } catch {
+  }
+  lineHeight = Math.max(lineHeight, ascent + descent);
+  const singleLineRatio = getResolvedData(fontFamily).singleLineRatio;
+  return {
+    fontSize,
+    // Keep in points for reference
+    ascent,
+    descent,
+    lineHeight,
+    fontFamily,
+    singleLineRatio
+  };
+}
+function measureTextWidth(text, style) {
+  if (!text) return 0;
+  const ctx = getCanvasContext();
+  ctx.font = buildFontString(style);
+  const metrics = ctx.measureText(text);
+  let width = metrics.width;
+  if (style.letterSpacing && text.length > 1) {
+    width += style.letterSpacing * (text.length - 1);
+  }
+  return width;
+}
+function measureRun(text, style) {
+  const metrics = getFontMetrics(style);
+  if (!text) {
+    return {
+      width: 0,
+      charWidths: [],
+      metrics
+    };
+  }
+  const ctx = getCanvasContext();
+  ctx.font = buildFontString(style);
+  const letterSpacing = style.letterSpacing ?? 0;
+  const charWidths = [];
+  let totalWidth = 0;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    const charMetrics = ctx.measureText(char);
+    let charWidth = charMetrics.width;
+    if (letterSpacing && i < text.length - 1) {
+      charWidth += letterSpacing;
+    }
+    charWidths.push(charWidth);
+    totalWidth += charWidth;
+  }
+  return {
+    width: totalWidth,
+    charWidths,
+    metrics
+  };
+}
+function findCharacterAtX(x, charWidths) {
+  if (charWidths.length === 0) return 0;
+  if (x <= 0) return 0;
+  let accumulatedWidth = 0;
+  for (let i = 0; i < charWidths.length; i++) {
+    const charWidth = charWidths[i];
+    const charMidpoint = accumulatedWidth + charWidth / 2;
+    if (x <= charMidpoint) {
+      return i;
+    }
+    accumulatedWidth += charWidth;
+  }
+  return charWidths.length;
+}
+function twipsToPx(twips) {
+  return twips / TWIPS_PER_PX;
+}
+function ptToPx(pt) {
+  return pt * PX_PER_INCH / 72;
+}
+
+// src/core/layout-bridge/hitTest.ts
+function getPageTop(layout, pageIndex) {
+  const pageGap = layout.pageGap ?? 0;
+  let y = 0;
+  for (let i = 0; i < pageIndex && i < layout.pages.length; i++) {
+    const page = layout.pages[i];
+    const pageHeight = page.size?.h ?? layout.pageSize.h;
+    y += pageHeight + pageGap;
+  }
+  return y;
+}
+function findBlockIndexById(blocks, blockId) {
+  return blocks.findIndex((block) => block.id === blockId);
+}
+function calculateParagraphFragmentHeight(fragment, measure) {
+  let height = 0;
+  for (let i = fragment.fromLine; i < fragment.toLine && i < measure.lines.length; i++) {
+    height += measure.lines[i].lineHeight;
+  }
+  return height;
+}
+function hitTestFragment(pageHit, blocks, measures, pagePoint) {
+  const sortedFragments = [...pageHit.page.fragments].sort((a, b) => {
+    const dy = a.y - b.y;
+    if (Math.abs(dy) > 0.5) return dy;
+    return a.x - b.x;
+  });
+  for (const fragment of sortedFragments) {
+    const blockIndex = findBlockIndexById(blocks, fragment.blockId);
+    if (blockIndex === -1) continue;
+    const block = blocks[blockIndex];
+    const measure = measures[blockIndex];
+    if (!block || !measure) continue;
+    let fragmentHeight;
+    if (fragment.kind === "paragraph") {
+      if (block.kind !== "paragraph" || measure.kind !== "paragraph") continue;
+      fragmentHeight = calculateParagraphFragmentHeight(fragment, measure);
+    } else if (fragment.kind === "table") {
+      fragmentHeight = fragment.height;
+    } else if (fragment.kind === "image") {
+      fragmentHeight = fragment.height;
+    } else {
+      continue;
+    }
+    const withinX = pagePoint.x >= fragment.x && pagePoint.x <= fragment.x + fragment.width;
+    const withinY = pagePoint.y >= fragment.y && pagePoint.y <= fragment.y + fragmentHeight;
+    if (withinX && withinY) {
+      return {
+        fragment,
+        block,
+        measure,
+        pageIndex: pageHit.pageIndex,
+        localX: pagePoint.x - fragment.x,
+        localY: pagePoint.y - fragment.y
+      };
+    }
+  }
+  return null;
+}
+function hitTestTableCell(pageHit, blocks, measures, pagePoint) {
+  for (const fragment of pageHit.page.fragments) {
+    if (fragment.kind !== "table") continue;
+    const tableFragment = fragment;
+    const withinX = pagePoint.x >= tableFragment.x && pagePoint.x <= tableFragment.x + tableFragment.width;
+    const withinY = pagePoint.y >= tableFragment.y && pagePoint.y <= tableFragment.y + tableFragment.height;
+    if (!withinX || !withinY) continue;
+    const blockIndex = findBlockIndexById(blocks, tableFragment.blockId);
+    if (blockIndex === -1) continue;
+    const block = blocks[blockIndex];
+    const measure = measures[blockIndex];
+    if (!block || block.kind !== "table" || !measure || measure.kind !== "table") continue;
+    const tableBlock = block;
+    const tableMeasure = measure;
+    const localX = pagePoint.x - tableFragment.x;
+    const localY = pagePoint.y - tableFragment.y;
+    const headerRowCount = tableFragment.headerRowCount ?? 0;
+    const headerHeight = headerRowCount > 0 && tableFragment.continuesFromPrev ? getHeaderRowsHeight(tableMeasure, headerRowCount) : 0;
+    let rowY = 0;
+    let rowIndex = -1;
+    if (tableMeasure.rows.length === 0 || tableBlock.rows.length === 0) continue;
+    if (headerHeight > 0 && localY < headerHeight) {
+      let hdrY = 0;
+      for (let h = 0; h < headerRowCount && h < tableMeasure.rows.length; h++) {
+        const hdrRowMeasure = tableMeasure.rows[h];
+        if (localY >= hdrY && localY < hdrY + hdrRowMeasure.height) {
+          rowIndex = h;
+          break;
+        }
+        hdrY += hdrRowMeasure.height;
+      }
+      if (rowIndex === -1) rowIndex = 0;
+    } else {
+      const adjustedLocalY = localY - headerHeight;
+      for (let r = tableFragment.fromRow; r < tableFragment.toRow && r < tableMeasure.rows.length; r++) {
+        const rowMeasure2 = tableMeasure.rows[r];
+        if (adjustedLocalY >= rowY && adjustedLocalY < rowY + rowMeasure2.height) {
+          rowIndex = r;
+          break;
+        }
+        rowY += rowMeasure2.height;
+      }
+    }
+    if (rowIndex === -1) {
+      rowIndex = Math.min(tableFragment.toRow - 1, tableMeasure.rows.length - 1);
+      if (rowIndex < tableFragment.fromRow) continue;
+    }
+    const rowMeasure = tableMeasure.rows[rowIndex];
+    const row = tableBlock.rows[rowIndex];
+    if (!rowMeasure || !row) continue;
+    let colX = 0;
+    let colIndex = -1;
+    if (rowMeasure.cells.length === 0 || row.cells.length === 0) continue;
+    for (let c = 0; c < rowMeasure.cells.length; c++) {
+      const cellMeasure2 = rowMeasure.cells[c];
+      if (localX >= colX && localX < colX + cellMeasure2.width) {
+        colIndex = c;
+        break;
+      }
+      colX += cellMeasure2.width;
+    }
+    if (colIndex === -1) {
+      colIndex = rowMeasure.cells.length - 1;
+      if (colIndex < 0) continue;
+    }
+    const cellMeasure = rowMeasure.cells[colIndex];
+    const cell = row.cells[colIndex];
+    if (!cellMeasure || !cell) continue;
+    let rowTop = 0;
+    const isClickOnHeader = headerHeight > 0 && rowIndex < headerRowCount;
+    if (isClickOnHeader) {
+      for (let r = 0; r < rowIndex; r++) {
+        rowTop += tableMeasure.rows[r]?.height ?? 0;
+      }
+    } else {
+      rowTop = headerHeight;
+      for (let r = tableFragment.fromRow; r < rowIndex; r++) {
+        rowTop += tableMeasure.rows[r]?.height ?? 0;
+      }
+    }
+    let colLeft = 0;
+    for (let c = 0; c < colIndex; c++) {
+      colLeft += rowMeasure.cells[c]?.width ?? 0;
+    }
+    let cellBlock;
+    let cellBlockMeasure;
+    if (cell.blocks && cell.blocks.length > 0) {
+      const firstBlock = cell.blocks[0];
+      const firstMeasure = cellMeasure.blocks[0];
+      if (firstBlock.kind === "paragraph" && firstMeasure?.kind === "paragraph") {
+        cellBlock = firstBlock;
+        cellBlockMeasure = firstMeasure;
+      }
+    }
+    const cellLocalX = localX - colLeft;
+    const cellLocalY = localY - rowTop;
+    return {
+      fragment: tableFragment,
+      block: tableBlock,
+      measure: tableMeasure,
+      pageIndex: pageHit.pageIndex,
+      rowIndex,
+      colIndex,
+      cellBlock,
+      cellMeasure: cellBlockMeasure,
+      cellLocalX: Math.max(0, cellLocalX),
+      cellLocalY: Math.max(0, cellLocalY)
+    };
+  }
+  return null;
+}
+
+// src/core/layout-bridge/selectionRects.ts
+function runToFontStyle(run) {
+  return {
+    fontFamily: run.fontFamily ?? "Arial",
+    fontSize: run.fontSize ?? 12,
+    bold: run.bold,
+    italic: run.italic,
+    letterSpacing: run.letterSpacing
+  };
+}
+function findBlockById(blocks, blockId) {
+  return blocks.findIndex((block) => block.id === blockId);
+}
+function computeLinePmRange(block, line) {
+  const blockPmStart = block.pmStart ?? 0;
+  const contentStart = blockPmStart + 1;
+  let charOffset = 0;
+  let pmStart;
+  for (let runIndex = 0; runIndex < block.runs.length && runIndex <= line.toRun; runIndex++) {
+    const run = block.runs[runIndex];
+    if (!run) continue;
+    if (runIndex < line.fromRun) {
+      if (run.kind === "text") {
+        charOffset += (run.text ?? "").length;
+      } else {
+        charOffset += 1;
+      }
+    } else if (runIndex === line.fromRun) {
+      charOffset += line.fromChar;
+      pmStart = contentStart + charOffset;
+      break;
+    }
+  }
+  if (pmStart === void 0) {
+    pmStart = contentStart;
+  }
+  let lineLength = 0;
+  for (let runIndex = line.fromRun; runIndex <= line.toRun && runIndex < block.runs.length; runIndex++) {
+    const run = block.runs[runIndex];
+    if (!run) continue;
+    if (run.kind === "text") {
+      const text = run.text ?? "";
+      const start = runIndex === line.fromRun ? line.fromChar : 0;
+      const end = runIndex === line.toRun ? line.toChar : text.length;
+      lineLength += end - start;
+    } else {
+      lineLength += 1;
+    }
+  }
+  const pmEnd = pmStart + lineLength;
+  return { pmStart, pmEnd };
+}
+function findLinesInRange(block, measure, from, to) {
+  const result = [];
+  for (let i = 0; i < measure.lines.length; i++) {
+    const line = measure.lines[i];
+    const range = computeLinePmRange(block, line);
+    if (range.pmStart === void 0 || range.pmEnd === void 0) continue;
+    if (range.pmEnd > from && range.pmStart < to) {
+      result.push({ line, index: i });
+    }
+  }
+  return result;
+}
+function pmPosToCharOffset(block, line, pmPos) {
+  const range = computeLinePmRange(block, line);
+  if (range.pmStart === void 0) return 0;
+  return Math.max(0, pmPos - range.pmStart);
+}
+function charOffsetToX(block, line, charOffset, _availableWidth) {
+  let x = 0;
+  let charsProcessed = 0;
+  for (let runIndex = line.fromRun; runIndex <= line.toRun && runIndex < block.runs.length; runIndex++) {
+    const run = block.runs[runIndex];
+    if (!run) continue;
+    if (run.kind === "tab") {
+      const tabWidth = run.width ?? 48;
+      if (charsProcessed + 1 >= charOffset) {
+        if (charOffset <= charsProcessed) return x;
+        return x + tabWidth;
+      }
+      x += tabWidth;
+      charsProcessed += 1;
+      continue;
+    }
+    if (run.kind === "image") {
+      const imageWidth = run.width;
+      if (charsProcessed + 1 >= charOffset) {
+        if (charOffset <= charsProcessed) return x;
+        return x + imageWidth;
+      }
+      x += imageWidth;
+      charsProcessed += 1;
+      continue;
+    }
+    if (run.kind === "lineBreak") {
+      if (charOffset <= charsProcessed) return x;
+      charsProcessed += 1;
+      continue;
+    }
+    if (run.kind === "text") {
+      const text = run.text ?? "";
+      const isFirstRun = runIndex === line.fromRun;
+      const isLastRun = runIndex === line.toRun;
+      const start = isFirstRun ? line.fromChar : 0;
+      const end = isLastRun ? line.toChar : text.length;
+      const lineText = text.slice(start, end);
+      if (charsProcessed + lineText.length >= charOffset) {
+        const charInRun = charOffset - charsProcessed;
+        const style2 = runToFontStyle(run);
+        const measurement2 = measureRun(lineText.slice(0, charInRun), style2);
+        return x + measurement2.width;
+      }
+      const style = runToFontStyle(run);
+      const measurement = measureRun(lineText, style);
+      x += measurement.width;
+      charsProcessed += lineText.length;
+    }
+  }
+  return x;
+}
+function lineHeightBefore(measure, lineIndex) {
+  let height = 0;
+  for (let i = 0; i < lineIndex && i < measure.lines.length; i++) {
+    height += measure.lines[i].lineHeight;
+  }
+  return height;
+}
+function selectionToRects(layout, blocks, measures, from, to) {
+  if (from === to) {
+    return [];
+  }
+  const selFrom = Math.min(from, to);
+  const selTo = Math.max(from, to);
+  const rects = [];
+  for (let pageIndex = 0; pageIndex < layout.pages.length; pageIndex++) {
+    const page = layout.pages[pageIndex];
+    const pageTopY = getPageTop(layout, pageIndex);
+    for (const fragment of page.fragments) {
+      if (fragment.kind === "paragraph") {
+        const blockIndex = findBlockById(blocks, fragment.blockId);
+        if (blockIndex === -1) continue;
+        const block = blocks[blockIndex];
+        const measure = measures[blockIndex];
+        if (!block || block.kind !== "paragraph") continue;
+        if (!measure || measure.kind !== "paragraph") continue;
+        const paragraphBlock = block;
+        const paragraphMeasure = measure;
+        const paragraphFragment = fragment;
+        const intersectingLines = findLinesInRange(
+          paragraphBlock,
+          paragraphMeasure,
+          selFrom,
+          selTo
+        );
+        for (const { line, index } of intersectingLines) {
+          if (index < paragraphFragment.fromLine || index >= paragraphFragment.toLine) {
+            continue;
+          }
+          const range = computeLinePmRange(paragraphBlock, line);
+          if (range.pmStart === void 0 || range.pmEnd === void 0) continue;
+          const sliceFrom = Math.max(range.pmStart, selFrom);
+          const sliceTo = Math.min(range.pmEnd, selTo);
+          if (sliceFrom >= sliceTo) continue;
+          const charOffsetFrom = pmPosToCharOffset(paragraphBlock, line, sliceFrom);
+          const charOffsetTo = pmPosToCharOffset(paragraphBlock, line, sliceTo);
+          const indent = paragraphBlock.attrs?.indent;
+          const indentLeft = indent?.left ?? 0;
+          const indentRight = indent?.right ?? 0;
+          const availableWidth = Math.max(0, fragment.width - indentLeft - indentRight);
+          const startX = charOffsetToX(paragraphBlock, line, charOffsetFrom, availableWidth);
+          const endX = charOffsetToX(paragraphBlock, line, charOffsetTo, availableWidth);
+          const alignment = paragraphBlock.attrs?.alignment ?? "left";
+          let alignmentOffset = 0;
+          if (alignment === "center") {
+            alignmentOffset = Math.max(0, (availableWidth - line.width) / 2);
+          } else if (alignment === "right") {
+            alignmentOffset = Math.max(0, availableWidth - line.width);
+          }
+          const lineOffset = lineHeightBefore(paragraphMeasure, index) - lineHeightBefore(paragraphMeasure, paragraphFragment.fromLine);
+          const rectX = fragment.x + indentLeft + alignmentOffset + Math.min(startX, endX);
+          const rectWidth = Math.max(1, Math.abs(endX - startX));
+          const rectY = fragment.y + lineOffset;
+          rects.push({
+            x: rectX,
+            y: rectY + pageTopY,
+            width: rectWidth,
+            height: line.lineHeight,
+            pageIndex
+          });
+        }
+      }
+      if (fragment.kind === "table") {
+        const blockIndex = findBlockById(blocks, fragment.blockId);
+        if (blockIndex === -1) continue;
+        const block = blocks[blockIndex];
+        const measure = measures[blockIndex];
+        if (!block || block.kind !== "table") continue;
+        if (!measure || measure.kind !== "table") continue;
+        const tableBlock = block;
+        const tableMeasure = measure;
+        const tableFragment = fragment;
+        const hdrCount = tableFragment.headerRowCount ?? 0;
+        const headerOffset = hdrCount > 0 && tableFragment.continuesFromPrev ? getHeaderRowsHeight(tableMeasure, hdrCount) : 0;
+        let rowY = headerOffset;
+        for (let rowIndex = tableFragment.fromRow; rowIndex < tableFragment.toRow && rowIndex < tableBlock.rows.length; rowIndex++) {
+          const row = tableBlock.rows[rowIndex];
+          const rowMeasure = tableMeasure.rows[rowIndex];
+          if (!row || !rowMeasure) continue;
+          let cellX = 0;
+          for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex++) {
+            const cell = row.cells[cellIndex];
+            const cellMeasure = rowMeasure.cells[cellIndex];
+            if (!cell || !cellMeasure) continue;
+            for (let blockIdx = 0; blockIdx < cell.blocks.length; blockIdx++) {
+              const cellBlock = cell.blocks[blockIdx];
+              const cellBlockMeasure = cellMeasure.blocks[blockIdx];
+              if (!cellBlock || cellBlock.kind !== "paragraph") continue;
+              if (!cellBlockMeasure || cellBlockMeasure.kind !== "paragraph") continue;
+              const paragraphBlock = cellBlock;
+              const paragraphMeasure = cellBlockMeasure;
+              const intersectingLines = findLinesInRange(
+                paragraphBlock,
+                paragraphMeasure,
+                selFrom,
+                selTo
+              );
+              let blockY = 0;
+              for (const { line, index } of intersectingLines) {
+                const range = computeLinePmRange(paragraphBlock, line);
+                if (range.pmStart === void 0 || range.pmEnd === void 0) continue;
+                const sliceFrom = Math.max(range.pmStart, selFrom);
+                const sliceTo = Math.min(range.pmEnd, selTo);
+                if (sliceFrom >= sliceTo) continue;
+                const charOffsetFrom = pmPosToCharOffset(paragraphBlock, line, sliceFrom);
+                const charOffsetTo = pmPosToCharOffset(paragraphBlock, line, sliceTo);
+                const startX = charOffsetToX(
+                  paragraphBlock,
+                  line,
+                  charOffsetFrom,
+                  cellMeasure.width
+                );
+                const endX = charOffsetToX(paragraphBlock, line, charOffsetTo, cellMeasure.width);
+                const lineY = lineHeightBefore(paragraphMeasure, index);
+                rects.push({
+                  x: tableFragment.x + cellX + Math.min(startX, endX),
+                  y: tableFragment.y + rowY + blockY + lineY + pageTopY,
+                  width: Math.max(1, Math.abs(endX - startX)),
+                  height: line.lineHeight,
+                  pageIndex
+                });
+              }
+              blockY += paragraphMeasure.totalHeight;
+            }
+            cellX += cellMeasure.width;
+          }
+          rowY += rowMeasure.height;
+        }
+      }
+      if (fragment.kind === "image") {
+        const blockPmStart = fragment.pmStart ?? 0;
+        const blockPmEnd = fragment.pmEnd ?? blockPmStart + 1;
+        if (blockPmEnd > selFrom && blockPmStart < selTo) {
+          rects.push({
+            x: fragment.x,
+            y: fragment.y + pageTopY,
+            width: fragment.width,
+            height: fragment.height,
+            pageIndex
+          });
+        }
+      }
+    }
+  }
+  return rects;
+}
+function getCaretPosition(layout, blocks, measures, pmPosition) {
+  for (let pageIndex = 0; pageIndex < layout.pages.length; pageIndex++) {
+    const page = layout.pages[pageIndex];
+    const pageTopY = getPageTop(layout, pageIndex);
+    for (const fragment of page.fragments) {
+      if (fragment.kind === "paragraph") {
+        const blockIndex = findBlockById(blocks, fragment.blockId);
+        if (blockIndex === -1) continue;
+        const block = blocks[blockIndex];
+        const measure = measures[blockIndex];
+        if (!block || block.kind !== "paragraph") continue;
+        if (!measure || measure.kind !== "paragraph") continue;
+        const paragraphBlock = block;
+        const paragraphMeasure = measure;
+        const paragraphFragment = fragment;
+        const blockPmStart = paragraphBlock.pmStart ?? 0;
+        const blockPmEnd = paragraphBlock.pmEnd ?? blockPmStart;
+        if (pmPosition < blockPmStart || pmPosition > blockPmEnd) continue;
+        for (let lineIndex = paragraphFragment.fromLine; lineIndex < paragraphFragment.toLine; lineIndex++) {
+          const line = paragraphMeasure.lines[lineIndex];
+          if (!line) continue;
+          const range = computeLinePmRange(paragraphBlock, line);
+          if (range.pmStart === void 0 || range.pmEnd === void 0) continue;
+          if (pmPosition >= range.pmStart && pmPosition <= range.pmEnd) {
+            const charOffset = pmPosToCharOffset(paragraphBlock, line, pmPosition);
+            const indent = paragraphBlock.attrs?.indent;
+            const indentLeft = indent?.left ?? 0;
+            const indentRight = indent?.right ?? 0;
+            const availableWidth = Math.max(0, fragment.width - indentLeft - indentRight);
+            const x = charOffsetToX(paragraphBlock, line, charOffset, availableWidth);
+            const alignment = paragraphBlock.attrs?.alignment ?? "left";
+            let alignmentOffset = 0;
+            if (alignment === "center") {
+              alignmentOffset = Math.max(0, (availableWidth - line.width) / 2);
+            } else if (alignment === "right") {
+              alignmentOffset = Math.max(0, availableWidth - line.width);
+            }
+            const lineOffset = lineHeightBefore(paragraphMeasure, lineIndex) - lineHeightBefore(paragraphMeasure, paragraphFragment.fromLine);
+            return {
+              x: fragment.x + indentLeft + alignmentOffset + x,
+              y: fragment.y + lineOffset + pageTopY,
+              height: line.lineHeight,
+              pageIndex
+            };
+          }
+        }
+      }
+      if (fragment.kind === "image") {
+        const fragPmStart = fragment.pmStart ?? 0;
+        const fragPmEnd = fragment.pmEnd ?? fragPmStart + 1;
+        if (pmPosition >= fragPmStart && pmPosition <= fragPmEnd) {
+          const xOffset = pmPosition === fragPmStart ? 0 : fragment.width;
+          return {
+            x: fragment.x + xOffset,
+            y: fragment.y + pageTopY,
+            height: fragment.height,
+            pageIndex
+          };
+        }
+      }
+    }
+  }
+  return null;
+}
+function isMultiPageSelection(rects) {
+  if (rects.length <= 1) return false;
+  const pageIndices = new Set(rects.map((r) => r.pageIndex));
+  return pageIndices.size > 1;
+}
+function groupRectsByPage(rects) {
+  const map = /* @__PURE__ */ new Map();
+  for (const rect of rects) {
+    const pageRects = map.get(rect.pageIndex) ?? [];
+    pageRects.push(rect);
+    map.set(rect.pageIndex, pageRects);
+  }
+  return map;
+}
+
+export {
+  DEFAULT_SINGLE_LINE_RATIO,
+  resolveFontFamily,
+  resolveThemeFont,
+  DEFAULT_TEXTBOX_MARGINS,
+  DEFAULT_TEXTBOX_WIDTH,
+  findPageIndexContainingPmPos,
+  layoutDocument,
+  resetCanvasContext,
+  getFontMetrics,
+  measureTextWidth,
+  measureRun,
+  findCharacterAtX,
+  twipsToPx,
+  ptToPx,
+  getPageTop,
+  hitTestFragment,
+  hitTestTableCell,
+  selectionToRects,
+  getCaretPosition,
+  isMultiPageSelection,
+  groupRectsByPage
+};