@beyondwork/docx-react-component 1.0.28 → 1.0.29

package/dist/chunk-GBVOWFIK.js

@@ -0,0 +1,1237 @@
+import {
+  parseTextStory
+} from "./chunk-KLMXQVYK.js";
+import {
+  createEditorSurfaceSnapshot,
+  resolveSectionVariants,
+  sectionSupportsStoryTarget,
+  storyTargetKey
+} from "./chunk-EILUG3VB.js";
+import {
+  createSelectionSnapshot
+} from "./chunk-5FN54NDH.js";
+import {
+  MAIN_STORY_TARGET,
+  createDetachedAnchor,
+  mapAnchor,
+  normalizeRange
+} from "./chunk-EBI3BX6U.js";
+
+// src/core/selection/review-anchors.ts
+function detachReviewAnchor(lastKnownRange, reason) {
+  return createDetachedAnchor(lastKnownRange, reason);
+}
+function mapReviewAnchor(anchor, mapping) {
+  return mapAnchor(anchor, mapping);
+}
+function getAnchorRange(anchor) {
+  if (anchor.kind === "range") {
+    return normalizeRange(anchor.range);
+  }
+  if (anchor.kind === "node") {
+    return { from: anchor.at, to: anchor.at };
+  }
+  return normalizeRange(anchor.lastKnownRange);
+}
+function mappingTouchesAnchorContent(anchor, mapping) {
+  const range = getAnchorRange(anchor);
+  if (range.from === range.to) {
+    return mapping.steps.some(
+      (step) => step.from <= range.from && step.to >= range.to
+    );
+  }
+  return mapping.steps.some(
+    (step) => step.from < range.to && step.to > range.from
+  );
+}
+function rangeStaysWithinSingleParagraph(content, range) {
+  const normalized = normalizeRange(range);
+  if (normalized.from === normalized.to) {
+    return true;
+  }
+  const surfaceBlocks = readSurfaceBlocks(content);
+  if (surfaceBlocks) {
+    return surfaceBlocks.some(
+      (block) => block.kind === "paragraph" && normalized.from >= block.from && normalized.to <= block.to
+    );
+  }
+  const story = parseTextStory(content);
+  const upperBound = Math.min(normalized.to, story.units.length);
+  for (let index = Math.max(0, normalized.from); index < upperBound; index += 1) {
+    const unit = story.units[index];
+    if (!unit) {
+      continue;
+    }
+    if (unit.kind === "paragraph_break" || unit.kind === "opaque_block") {
+      return false;
+    }
+  }
+  return true;
+}
+function canCreateDocxCommentAnchor(content, anchor) {
+  if (anchor.kind !== "range") {
+    return false;
+  }
+  const normalized = normalizeRange(anchor.range);
+  if (normalized.from === normalized.to) {
+    return false;
+  }
+  return rangeStaysWithinSingleParagraph(content, normalized);
+}
+function readSurfaceBlocks(content) {
+  if (!content || typeof content !== "object" || !("blocks" in content)) {
+    return void 0;
+  }
+  const blocks = content.blocks;
+  if (!Array.isArray(blocks)) {
+    return void 0;
+  }
+  const normalized = flattenSurfaceBlocks(blocks);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function flattenSurfaceBlocks(blocks) {
+  const flattened = [];
+  for (const block of blocks) {
+    if (!block || typeof block !== "object" || typeof block.kind !== "string" || typeof block.from !== "number" || typeof block.to !== "number") {
+      continue;
+    }
+    flattened.push({
+      kind: block.kind,
+      from: block.from,
+      to: block.to
+    });
+    if (block.kind === "table" && Array.isArray(block.rows)) {
+      for (const row of block.rows) {
+        for (const cell of row.cells ?? []) {
+          if (cell && typeof cell === "object" && Array.isArray(cell.content)) {
+            flattened.push(...flattenSurfaceBlocks(cell.content));
+          }
+        }
+      }
+    }
+    if (block.kind === "sdt_block" && Array.isArray(block.children)) {
+      flattened.push(...flattenSurfaceBlocks(block.children));
+    }
+  }
+  return flattened;
+}
+
+// src/runtime/document-layout.ts
+function buildResolvedSections(document) {
+  const mainSurface = createEditorSurfaceSnapshot(
+    document,
+    createSelectionSnapshot(0, 0),
+    MAIN_STORY_TARGET
+  );
+  const sections = [];
+  let sectionStart = 0;
+  let sectionIndex = 0;
+  for (const [index, block] of document.content.children.entries()) {
+    if (block.type !== "section_break") {
+      continue;
+    }
+    const surfaceBlock = mainSurface.blocks[index];
+    sections.push({
+      index: sectionIndex,
+      start: sectionStart,
+      end: surfaceBlock?.from ?? sectionStart,
+      properties: block.sectionProperties
+    });
+    sectionStart = surfaceBlock?.to ?? sectionStart;
+    sectionIndex += 1;
+  }
+  sections.push({
+    index: sectionIndex,
+    start: sectionStart,
+    end: mainSurface.storySize,
+    properties: document.subParts?.finalSectionProperties
+  });
+  return sections;
+}
+function findSectionForPosition(sections, position) {
+  for (const section of sections) {
+    if (position < section.end) {
+      return section;
+    }
+  }
+  return sections[sections.length - 1] ?? {
+    index: 0,
+    start: 0,
+    end: 0
+  };
+}
+function buildPageLayoutSnapshot(sectionIndex, properties, subParts) {
+  const pageSize = properties?.pageSize ?? {
+    width: 12240,
+    height: 15840,
+    orientation: "portrait"
+  };
+  const margins = properties?.pageMargins ?? {
+    top: 1440,
+    right: 1440,
+    bottom: 1440,
+    left: 1440,
+    header: 720,
+    footer: 720,
+    gutter: 0
+  };
+  const columns = properties?.columns;
+  const explicitColumns = columns?.columns ?? [];
+  const differentOddEvenPages = Boolean(subParts?.settings?.evenAndOddHeaders);
+  return {
+    sectionIndex,
+    ...properties?.sectionType ? { sectionType: properties.sectionType } : {},
+    pageWidth: pageSize.width,
+    pageHeight: pageSize.height,
+    marginTop: margins.top,
+    marginBottom: margins.bottom,
+    marginLeft: margins.left,
+    marginRight: margins.right,
+    headerMargin: margins.header ?? 720,
+    footerMargin: margins.footer ?? 720,
+    gutter: margins.gutter ?? 0,
+    orientation: pageSize.orientation ?? "portrait",
+    columns: explicitColumns.length > 0 ? explicitColumns.length : columns?.count ?? 1,
+    differentFirstPage: Boolean(properties?.titlePage),
+    differentOddEvenPages,
+    ...properties?.pageNumbering ? {
+      pageNumbering: {
+        ...properties.pageNumbering.format ? { format: properties.pageNumbering.format } : {},
+        ...properties.pageNumbering.start !== void 0 ? { start: properties.pageNumbering.start } : {},
+        ...properties.pageNumbering.chapStyle ? { chapterStyle: properties.pageNumbering.chapStyle } : {},
+        ...properties.pageNumbering.chapSep ? { chapterSeparator: properties.pageNumbering.chapSep } : {}
+      }
+    } : {},
+    ...properties?.lineNumbering ? {
+      lineNumbering: {
+        ...properties.lineNumbering.countBy !== void 0 ? { countBy: properties.lineNumbering.countBy } : {},
+        ...properties.lineNumbering.start !== void 0 ? { start: properties.lineNumbering.start } : {},
+        ...properties.lineNumbering.distance !== void 0 ? { distance: properties.lineNumbering.distance } : {},
+        ...properties.lineNumbering.restart ? { restart: properties.lineNumbering.restart } : {}
+      }
+    } : {},
+    ...properties?.pageBorders ? {
+      pageBorders: {
+        ...properties.pageBorders.top ? { top: { ...properties.pageBorders.top } } : {},
+        ...properties.pageBorders.left ? { left: { ...properties.pageBorders.left } } : {},
+        ...properties.pageBorders.bottom ? { bottom: { ...properties.pageBorders.bottom } } : {},
+        ...properties.pageBorders.right ? { right: { ...properties.pageBorders.right } } : {},
+        ...properties.pageBorders.offsetFrom ? { offsetFrom: properties.pageBorders.offsetFrom } : {},
+        ...properties.pageBorders.display ? { display: properties.pageBorders.display } : {},
+        ...properties.pageBorders.zOrder ? { zOrder: properties.pageBorders.zOrder } : {}
+      }
+    } : {},
+    ...properties?.documentGrid ? {
+      documentGrid: {
+        ...properties.documentGrid.type ? { type: properties.documentGrid.type } : {},
+        ...properties.documentGrid.linePitch !== void 0 ? { linePitch: properties.documentGrid.linePitch } : {},
+        ...properties.documentGrid.charSpace !== void 0 ? { charSpace: properties.documentGrid.charSpace } : {}
+      }
+    } : {},
+    columnDefinitions: explicitColumns,
+    equalWidthColumns: columns?.equalWidth ?? (explicitColumns.length === 0 || explicitColumns.length <= 1),
+    columnSeparator: Boolean(columns?.separator),
+    headerVariants: resolveSectionVariants(
+      "header",
+      sectionIndex,
+      properties?.headerReferences,
+      subParts?.headers ?? []
+    ),
+    footerVariants: resolveSectionVariants(
+      "footer",
+      sectionIndex,
+      properties?.footerReferences,
+      subParts?.footers ?? []
+    )
+  };
+}
+function resolveSectionForStoryTarget(document, sections, target) {
+  if (target.kind === "main" || sections.length === 0) {
+    return sections[0];
+  }
+  if (target.kind === "header") {
+    if (target.sectionIndex !== void 0) {
+      const section = sections.find((candidate) => candidate.index === target.sectionIndex);
+      return section && sectionSupportsStoryTarget(document, target.sectionIndex, target) ? section : void 0;
+    }
+    return findSectionByStoryReference(
+      document,
+      sections,
+      target,
+      "header"
+    ) ?? sections[0];
+  }
+  if (target.kind === "footer") {
+    if (target.sectionIndex !== void 0) {
+      const section = sections.find((candidate) => candidate.index === target.sectionIndex);
+      return section && sectionSupportsStoryTarget(document, target.sectionIndex, target) ? section : void 0;
+    }
+    return findSectionByStoryReference(
+      document,
+      sections,
+      target,
+      "footer"
+    ) ?? sections[0];
+  }
+  return void 0;
+}
+function resolveActiveSection(state, activeStory, sections, storySelections) {
+  if (sections.length === 0) {
+    return void 0;
+  }
+  if (activeStory.kind === "main") {
+    return findSectionForPosition(sections, state.selection.head);
+  }
+  const referencedSection = resolveSectionForStoryTarget(
+    state.document,
+    sections,
+    activeStory
+  );
+  if (referencedSection) {
+    return referencedSection;
+  }
+  const mainSelection = storySelections?.get(storyTargetKey(MAIN_STORY_TARGET)) ?? state.selection;
+  return findSectionForPosition(sections, mainSelection.head);
+}
+function findSectionByStoryReference(document, sections, target, kind) {
+  const propertyKey = kind === "header" ? "headerReferences" : "footerReferences";
+  const documents = kind === "header" ? document.subParts?.headers ?? [] : document.subParts?.footers ?? [];
+  return sections.find(
+    (section) => section.properties?.[propertyKey]?.some(
+      (ref) => ref.relationshipId === target.relationshipId && ref.variant === target.variant
+    )
+  ) ?? sections.find(
+    (section) => documents.some(
+      (entry) => entry.relationshipId === target.relationshipId && entry.variant === target.variant && entry.sectionIndex === section.index
+    )
+  );
+}
+
+// src/runtime/view-state.ts
+var MIN_ZOOM_PERCENT = 50;
+var MAX_ZOOM_PERCENT = 200;
+var DEFAULT_VIEW_STATE = {
+  viewMode: "editing",
+  documentMode: "editing",
+  workspaceMode: "canvas",
+  zoomLevel: 100,
+  isFocused: false,
+  caretAffinity: "none",
+  activePageRegion: null,
+  activeObjectFrame: null
+};
+function createViewState(initial) {
+  return { ...DEFAULT_VIEW_STATE, ...initial };
+}
+function setViewMode(state, mode) {
+  if (state.viewMode === mode) return state;
+  return { ...state, viewMode: mode };
+}
+function setDocumentMode(state, mode) {
+  if (state.documentMode === mode) return state;
+  return { ...state, documentMode: mode };
+}
+function setWorkspaceMode(state, workspaceMode) {
+  if (state.workspaceMode === workspaceMode) {
+    return state;
+  }
+  return { ...state, workspaceMode };
+}
+function setZoomLevel(state, zoomLevel) {
+  const normalizedZoom = normalizeZoomLevel(zoomLevel, state.zoomLevel);
+  if (state.zoomLevel === normalizedZoom) {
+    return state;
+  }
+  return { ...state, zoomLevel: normalizedZoom };
+}
+function setFocused(state, focused) {
+  if (state.isFocused === focused) return state;
+  return { ...state, isFocused: focused };
+}
+function deriveActiveListContext(surface, selectionHead, numberingCatalog) {
+  if (!surface) return null;
+  const block = findBlockAtPosition(surface.blocks, selectionHead);
+  if (!block || block.kind !== "paragraph" || !block.numbering) return null;
+  const isOrdered = resolveListOrdering(block.numbering, numberingCatalog);
+  return {
+    numberingInstanceId: block.numbering.numberingInstanceId,
+    level: block.numbering.level,
+    isOrdered,
+    ...block.numberingPrefix ? { markerText: block.numberingPrefix } : {}
+  };
+}
+function deriveActiveNoteContext(activeStory, mainSurface) {
+  if (activeStory.kind !== "footnote" && activeStory.kind !== "endnote") {
+    return null;
+  }
+  const referencePosition = findNoteReferencePosition(mainSurface, activeStory);
+  return {
+    noteKind: activeStory.kind,
+    noteId: activeStory.noteId,
+    referencePosition
+  };
+}
+function deriveLayoutMeasurement(surface, selectionOrPosition, viewState) {
+  const selectionHead = typeof selectionOrPosition === "number" ? selectionOrPosition : selectionOrPosition.activeRange.kind === "node" ? selectionOrPosition.activeRange.at : selectionOrPosition.head;
+  const block = surface ? findBlockAtPosition(surface.blocks, selectionHead) : null;
+  const tabStops = block?.kind === "paragraph" && block.tabStops ? block.tabStops : [];
+  const listMarkerLane = deriveListMarkerLane(block);
+  return {
+    pageRegions: viewState.activePageRegion ? [viewState.activePageRegion] : [],
+    caretAffinity: viewState.caretAffinity,
+    tabStops,
+    listMarkerLane: listMarkerLane ?? void 0,
+    objectFrame: viewState.activeObjectFrame ?? void 0
+  };
+}
+function createEditorViewStateSnapshot(viewState, activeStory, selection, surface, mainSurface, pageLayout, numberingCatalog) {
+  const selectionPosition = selection.activeRange.kind === "node" ? selection.activeRange.at : selection.head;
+  const derivedViewState = deriveInteractionViewState(
+    viewState,
+    activeStory,
+    selection,
+    surface,
+    pageLayout
+  );
+  const activeListContext = deriveActiveListContext(surface, selectionPosition, numberingCatalog);
+  const activeNoteContext = deriveActiveNoteContext(activeStory, mainSurface);
+  const measurement = deriveLayoutMeasurement(surface, selection, derivedViewState);
+  return {
+    viewMode: derivedViewState.viewMode,
+    documentMode: derivedViewState.documentMode,
+    workspaceMode: derivedViewState.workspaceMode,
+    zoomLevel: derivedViewState.zoomLevel,
+    activeStory,
+    selection,
+    caretAffinity: derivedViewState.caretAffinity,
+    activeListContext,
+    activeNoteContext,
+    activePageRegion: derivedViewState.activePageRegion,
+    activeObjectFrame: derivedViewState.activeObjectFrame,
+    measurement,
+    isFocused: derivedViewState.isFocused
+  };
+}
+function findBlockAtPosition(blocks, position) {
+  for (const block of blocks) {
+    if (position >= block.from && position <= block.to) {
+      if (block.kind === "sdt_block") {
+        const inner = findBlockAtPosition(block.children, position);
+        if (inner) return inner;
+      }
+      if (block.kind === "table") {
+        for (const row of block.rows) {
+          for (const cell of row.cells) {
+            const inner = findBlockAtPosition(cell.content, position);
+            if (inner) return inner;
+          }
+        }
+      }
+      return block;
+    }
+  }
+  return null;
+}
+function resolveListOrdering(numbering, numberingCatalog) {
+  if (!numberingCatalog) {
+    return true;
+  }
+  const instance = numberingCatalog.instances[numbering.numberingInstanceId];
+  const definition = instance ? numberingCatalog.abstractDefinitions[instance.abstractNumberingId] : void 0;
+  const levelDefinition = definition?.levels.find((level) => level.level === numbering.level);
+  if (!levelDefinition) {
+    return true;
+  }
+  return levelDefinition.format !== "bullet";
+}
+function deriveInteractionViewState(viewState, activeStory, selection, surface, pageLayout) {
+  const activePageRegion = deriveActivePageRegion(activeStory, pageLayout) ?? viewState.activePageRegion;
+  const activeObjectFrame = deriveActiveObjectFrame(surface, selection);
+  const caretAffinity = deriveCaretAffinity(surface, selection);
+  return {
+    ...viewState,
+    caretAffinity,
+    activePageRegion,
+    activeObjectFrame
+  };
+}
+function deriveActivePageRegion(activeStory, pageLayout) {
+  if (!pageLayout) {
+    return null;
+  }
+  const sectionIndex = pageLayout?.sectionIndex ?? 0;
+  switch (activeStory.kind) {
+    case "header":
+      return { region: "header", sectionIndex, columnIndex: 0 };
+    case "footer":
+      return { region: "footer", sectionIndex, columnIndex: 0 };
+    default:
+      return { region: "body", sectionIndex, columnIndex: 0 };
+  }
+}
+function deriveActiveObjectFrame(surface, selection) {
+  if (!surface) {
+    return null;
+  }
+  const position = selection.activeRange.kind === "node" ? selection.activeRange.at : selection.head;
+  const block = findBlockAtPosition(surface.blocks, position);
+  if (!block || block.kind !== "paragraph") {
+    return null;
+  }
+  const segment = findObjectSegmentAtPosition(block.segments, position);
+  if (!segment) {
+    return null;
+  }
+  if (segment.kind === "image") {
+    return {
+      kind: "image",
+      anchorPos: segment.from,
+      display: segment.display === "floating" ? "floating" : "inline"
+    };
+  }
+  const objectKind = inferOpaqueObjectKind(segment);
+  if (!objectKind) {
+    return null;
+  }
+  return {
+    kind: objectKind,
+    anchorPos: segment.from,
+    display: "inline"
+  };
+}
+function deriveCaretAffinity(surface, selection) {
+  if (selection.activeRange.kind === "node") {
+    return selection.activeRange.assoc < 0 ? "backward" : "forward";
+  }
+  if (!selection.isCollapsed || !surface) {
+    return "none";
+  }
+  const block = findBlockAtPosition(surface.blocks, selection.head);
+  if (!block || block.kind !== "paragraph") {
+    return "none";
+  }
+  for (const segment of block.segments) {
+    if (!isObjectLikeSegment(segment)) {
+      continue;
+    }
+    if (selection.head === segment.from) {
+      return "forward";
+    }
+    if (selection.head === segment.to) {
+      return "backward";
+    }
+  }
+  return "none";
+}
+function findNoteReferencePosition(mainSurface, target) {
+  if (!mainSurface) return 0;
+  for (const block of mainSurface.blocks) {
+    if (block.kind === "paragraph") {
+      for (const segment of block.segments) {
+        if (segment.kind === "note_ref" && segment.noteKind === target.kind && segment.noteId === target.noteId) {
+          return segment.from;
+        }
+        if (segment.kind === "opaque_inline" && segment.label.toLowerCase().includes(target.kind) && segment.detail.includes(target.noteId)) {
+          return segment.from;
+        }
+      }
+    }
+  }
+  return 0;
+}
+function normalizeZoomLevel(zoomLevel, currentZoom) {
+  if (zoomLevel === "pageWidth" || zoomLevel === "onePage") {
+    return zoomLevel;
+  }
+  if (!Number.isFinite(zoomLevel) || zoomLevel <= 0) {
+    return currentZoom;
+  }
+  return Math.max(
+    MIN_ZOOM_PERCENT,
+    Math.min(MAX_ZOOM_PERCENT, Math.round(zoomLevel))
+  );
+}
+function findObjectSegmentAtPosition(segments, position) {
+  for (const segment of segments) {
+    if (!isObjectLikeSegment(segment)) {
+      continue;
+    }
+    if (position >= segment.from && position <= segment.to) {
+      return segment;
+    }
+  }
+  return null;
+}
+function isObjectLikeSegment(segment) {
+  if (segment.kind === "image") {
+    return true;
+  }
+  if (segment.kind !== "opaque_inline") {
+    return false;
+  }
+  return inferOpaqueObjectKind(segment) !== null;
+}
+function inferOpaqueObjectKind(segment) {
+  if (segment.label === "Text box") {
+    return "textbox";
+  }
+  if (segment.label === "Drawing shape") {
+    return "shape";
+  }
+  if (segment.label === "Legacy VML drawing") {
+    return segment.detail.includes("#_x0000_t202") ? "textbox" : "shape";
+  }
+  return null;
+}
+function deriveListMarkerLane(block) {
+  if (!block || block.kind !== "paragraph" || !block.numbering) return null;
+  const indent = block.indentation?.hanging ?? block.indentation?.left ?? 360;
+  return {
+    indent,
+    markerWidth: Math.min(indent, 360)
+  };
+}
+
+// src/runtime/page-layout-estimation.ts
+var DEFAULT_FONT_SIZE_POINTS = 12;
+var DEFAULT_LINE_HEIGHT_TWIPS = 280;
+var MIN_BLOCK_HEIGHT_TWIPS = 240;
+var TABLE_ROW_PADDING_TWIPS = 120;
+var DEFAULT_PAGE_ESTIMATE_PX_PER_TWIP = 1 / 15;
+function estimateBlockHeight(block, columnWidth) {
+  if (!block) {
+    return 0;
+  }
+  switch (block.kind) {
+    case "paragraph":
+      return estimateParagraphHeight(block, columnWidth);
+    case "table":
+      return estimateTableHeight(block, columnWidth);
+    case "sdt_block":
+      return Math.max(
+        MIN_BLOCK_HEIGHT_TWIPS,
+        block.children.reduce((total, child) => total + estimateBlockHeight(child, columnWidth), 0)
+      );
+    case "opaque_block":
+      return block.label === "Section break" ? 0 : MIN_BLOCK_HEIGHT_TWIPS;
+  }
+}
+function estimateParagraphHeight(block, columnWidth) {
+  const lineHeight = estimateParagraphLineHeight(block);
+  const lineCount = estimateParagraphLineCount(block, columnWidth);
+  const spacingBefore = block.spacing?.before ?? 0;
+  const spacingAfter = block.spacing?.after ?? 0;
+  return Math.max(
+    MIN_BLOCK_HEIGHT_TWIPS,
+    lineHeight * lineCount + spacingBefore + spacingAfter
+  );
+}
+function estimateParagraphLineHeight(block) {
+  const explicitLine = block.spacing?.line;
+  if (typeof explicitLine === "number" && explicitLine > 0) {
+    return explicitLine;
+  }
+  const fontSizeHalfPoints = block.segments.find(
+    (segment) => segment.kind === "text" && typeof segment.markAttrs?.fontSize === "number"
+  )?.markAttrs?.fontSize;
+  const fontSizePoints = typeof fontSizeHalfPoints === "number" ? fontSizeHalfPoints / 2 : DEFAULT_FONT_SIZE_POINTS;
+  return Math.max(
+    DEFAULT_LINE_HEIGHT_TWIPS,
+    Math.round(fontSizePoints * 20 * 1.35)
+  );
+}
+function estimateParagraphLineCount(block, columnWidth) {
+  const averageCharWidth = estimateAverageCharWidth(block);
+  const charsPerLine = Math.max(12, Math.floor(columnWidth / averageCharWidth));
+  let lineCount = 1;
+  let currentLineChars = estimatedPrefixLength(block);
+  for (const segment of block.segments) {
+    switch (segment.kind) {
+      case "text":
+        currentLineChars += Array.from(segment.text).length;
+        while (currentLineChars > charsPerLine) {
+          lineCount += 1;
+          currentLineChars -= charsPerLine;
+        }
+        break;
+      case "tab":
+        currentLineChars += 4;
+        break;
+      case "hard_break":
+        lineCount += 1;
+        currentLineChars = 0;
+        break;
+      case "image":
+        lineCount += Math.max(1, Math.round(segment.display === "floating" ? 2 : 1));
+        currentLineChars = 0;
+        break;
+      case "note_ref":
+        currentLineChars += 1;
+        break;
+      case "opaque_inline":
+        if (segment.presentation !== "quiet-marker") {
+          currentLineChars += segment.label.length > 0 ? 1 : 0;
+        }
+        break;
+    }
+  }
+  return Math.max(1, lineCount);
+}
+function getUsablePageHeight(layout) {
+  return Math.max(
+    1440,
+    layout.pageHeight - layout.marginTop - layout.marginBottom
+  );
+}
+function getUsableColumnMetrics(layout) {
+  const usableWidth = Math.max(
+    1440,
+    layout.pageWidth - layout.marginLeft - layout.marginRight - layout.gutter
+  );
+  const columnCount = Math.max(1, layout.columns);
+  if (!layout.equalWidthColumns && layout.columnDefinitions.length > 0) {
+    return layout.columnDefinitions.map((column, index) => ({
+      width: Math.max(720, column.width),
+      space: index < layout.columnDefinitions.length - 1 ? Math.max(0, column.space ?? 0) : 0
+    }));
+  }
+  const width = columnCount <= 1 ? usableWidth : Math.max(720, Math.floor(usableWidth / columnCount));
+  return Array.from({ length: columnCount }, () => ({
+    width,
+    space: 0
+  }));
+}
+function getUsableColumnWidth(layout) {
+  return getUsableColumnMetrics(layout)[0]?.width ?? 1440;
+}
+function estimateTableHeight(block, columnWidth) {
+  let totalHeight = 0;
+  for (const row of block.rows) {
+    const explicitHeight = row.height ?? 0;
+    if (explicitHeight > 0) {
+      totalHeight += explicitHeight;
+      continue;
+    }
+    let rowHeight = MIN_BLOCK_HEIGHT_TWIPS;
+    for (const cell of row.cells) {
+      const cellHeight = cell.content.reduce(
+        (total, child) => total + estimateBlockHeight(child, columnWidth),
+        0
+      );
+      rowHeight = Math.max(rowHeight, cellHeight + TABLE_ROW_PADDING_TWIPS);
+    }
+    totalHeight += rowHeight;
+  }
+  return Math.max(MIN_BLOCK_HEIGHT_TWIPS, totalHeight);
+}
+function estimateAverageCharWidth(block) {
+  const fontSizeHalfPoints = block.segments.find(
+    (segment) => segment.kind === "text" && typeof segment.markAttrs?.fontSize === "number"
+  )?.markAttrs?.fontSize;
+  const fontSizePoints = typeof fontSizeHalfPoints === "number" ? fontSizeHalfPoints / 2 : DEFAULT_FONT_SIZE_POINTS;
+  return Math.max(96, Math.round(fontSizePoints * 12));
+}
+function estimatedPrefixLength(block) {
+  const prefix = block.numberingPrefix ?? "";
+  const suffix = block.numberingSuffix === "space" ? 1 : block.numberingSuffix === "tab" ? 4 : 0;
+  return prefix.length + suffix;
+}
+
+// src/runtime/document-navigation.ts
+var MIN_BLOCK_HEIGHT_TWIPS2 = 240;
+var FOOTNOTE_REFERENCE_RESERVATION_TWIPS = 180;
+var navigationBaseCache = /* @__PURE__ */ new WeakMap();
+function createDocumentNavigationSnapshot(document, selectionHead, activeStory) {
+  const base = getNavigationBaseSnapshot(document);
+  const navigationContext = resolveActiveNavigationContext(
+    document,
+    base.pages,
+    base.sections,
+    base.mainSurface,
+    selectionHead,
+    activeStory
+  );
+  return {
+    pageCount: base.pages.length,
+    pages: base.pages,
+    headings: base.headings,
+    activePageIndex: navigationContext.activePageIndex,
+    activeSectionIndex: navigationContext.activeSectionIndex
+  };
+}
+function getNavigationBaseSnapshot(document) {
+  const cached = navigationBaseCache.get(document.content);
+  if (cached && cached.styles === document.styles && cached.subParts === document.subParts) {
+    return cached;
+  }
+  const mainSurface = createEditorSurfaceSnapshot(
+    document,
+    createSelectionSnapshot(0, 0),
+    MAIN_STORY_TARGET
+  );
+  const sections = buildResolvedSections(document);
+  const pages = buildPageStack(document, sections, mainSurface);
+  const headings = buildHeadingOutline(document, mainSurface, sections, pages);
+  const next = {
+    mainSurface,
+    sections,
+    pages,
+    headings,
+    styles: document.styles,
+    subParts: document.subParts
+  };
+  navigationBaseCache.set(document.content, next);
+  return next;
+}
+function findPageForOffset(pages, offset) {
+  for (let i = 0; i < pages.length; i++) {
+    if (offset < pages[i].endOffset) {
+      return i;
+    }
+  }
+  return Math.max(0, pages.length - 1);
+}
+function findSectionForOffset(sections, offset) {
+  return sections.length > 0 ? findSectionForPosition(sections, offset).index : 0;
+}
+function buildPageStack(document, sections, mainSurface) {
+  const pages = [];
+  let globalPageIndex = 0;
+  for (const section of sections) {
+    const layout = buildPageLayoutSnapshot(
+      section.index,
+      section.properties ?? document.subParts?.finalSectionProperties,
+      document.subParts
+    );
+    const sectionBlocks = collectSectionBlocks(mainSurface.blocks, section.start, section.end);
+    const paginated = paginateSectionBlocks(
+      section,
+      sectionBlocks,
+      layout,
+      document.subParts?.footnoteCollection
+    );
+    for (const page of paginated) {
+      pages.push({
+        ...page,
+        pageIndex: globalPageIndex
+      });
+      globalPageIndex += 1;
+    }
+  }
+  if (pages.length === 0) {
+    pages.push({
+      pageIndex: 0,
+      sectionIndex: 0,
+      pageInSection: 0,
+      startOffset: 0,
+      endOffset: mainSurface.storySize,
+      layout: buildPageLayoutSnapshot(
+        0,
+        document.subParts?.finalSectionProperties,
+        document.subParts
+      )
+    });
+  }
+  return pages;
+}
+function collectSectionBlocks(blocks, start, end) {
+  return blocks.filter((block) => block.to > start && block.from < end);
+}
+function paginateSectionBlocks(section, blocks, layout, footnotes) {
+  if (blocks.length === 0) {
+    return [
+      {
+        sectionIndex: section.index,
+        pageInSection: 0,
+        startOffset: section.start,
+        endOffset: section.end,
+        layout
+      }
+    ];
+  }
+  const pages = [];
+  const usableHeight = getUsablePageHeight(layout);
+  const columnMetrics = getUsableColumnMetrics(layout);
+  const maxColumns = Math.max(1, columnMetrics.length);
+  let pageStart = section.start;
+  let columnHeight = 0;
+  let columnIndex = 0;
+  let pageInSection = 0;
+  let reservedNoteHeight = 0;
+  const reservedNotes = /* @__PURE__ */ new Set();
+  const pushPage = (endOffset) => {
+    const boundedEnd = Math.max(pageStart, Math.min(endOffset, section.end));
+    if (boundedEnd === pageStart && pages.length > 0) {
+      return;
+    }
+    pages.push({
+      sectionIndex: section.index,
+      pageInSection,
+      startOffset: pageStart,
+      endOffset: boundedEnd,
+      layout
+    });
+    pageInSection += 1;
+    pageStart = boundedEnd;
+    columnHeight = 0;
+    columnIndex = 0;
+    reservedNoteHeight = 0;
+    reservedNotes.clear();
+  };
+  for (let index = 0; index < blocks.length; index += 1) {
+    const block = blocks[index];
+    const nextBoundary = blocks[index + 1]?.from ?? section.end;
+    while (true) {
+      const columnWidth = columnMetrics[Math.min(columnIndex, columnMetrics.length - 1)]?.width ?? getUsableColumnWidth(layout);
+      const baseHeight = estimateBlockHeight(block, columnWidth);
+      const keepWithNextHeight = block.kind === "paragraph" && block.keepNext ? baseHeight + estimateBlockHeight(blocks[index + 1], columnWidth) : baseHeight;
+      const noteHeight = estimateFootnoteReservation(block, footnotes, columnWidth, reservedNotes);
+      const projectedHeight = columnHeight + keepWithNextHeight + reservedNoteHeight + noteHeight;
+      if (block.kind === "paragraph" && block.pageBreakBefore && pageStart < block.from) {
+        pushPage(block.from);
+        continue;
+      }
+      if (projectedHeight > usableHeight && pageStart < block.from) {
+        if (columnIndex < maxColumns - 1) {
+          columnIndex += 1;
+          columnHeight = 0;
+          reservedNoteHeight = 0;
+          reservedNotes.clear();
+          continue;
+        }
+        pushPage(block.from);
+        continue;
+      }
+      const effectiveNoteHeight = estimateFootnoteReservation(
+        block,
+        footnotes,
+        columnWidth,
+        reservedNotes
+      );
+      columnHeight += baseHeight;
+      reservedNoteHeight += effectiveNoteHeight;
+      currentPageNoteIds(block).forEach((noteKey) => reservedNotes.add(noteKey));
+      if (hasColumnBreak(block)) {
+        if (columnIndex < maxColumns - 1) {
+          columnIndex += 1;
+          columnHeight = 0;
+          reservedNoteHeight = 0;
+          reservedNotes.clear();
+        } else {
+          pushPage(nextBoundary);
+        }
+        break;
+      }
+      if (index === blocks.length - 1) {
+        pushPage(section.end);
+      }
+      break;
+    }
+  }
+  return pages.length > 0 ? pages : [
+    {
+      sectionIndex: section.index,
+      pageInSection: 0,
+      startOffset: section.start,
+      endOffset: section.end,
+      layout
+    }
+  ];
+}
+function resolveActiveNavigationContext(document, pages, sections, mainSurface, selectionHead, activeStory) {
+  if (activeStory.kind === "main") {
+    const activePageIndex = findPageForOffset(pages, selectionHead);
+    return {
+      activePageIndex,
+      activeSectionIndex: pages[activePageIndex]?.sectionIndex ?? 0
+    };
+  }
+  if (activeStory.kind === "header" || activeStory.kind === "footer") {
+    const section = resolveSectionForStoryTarget(document, sections, activeStory);
+    if (section) {
+      return {
+        activePageIndex: findFirstPageIndexForSection(pages, section.index),
+        activeSectionIndex: section.index
+      };
+    }
+  }
+  if (activeStory.kind === "footnote" || activeStory.kind === "endnote") {
+    const referencePosition = findNoteReferencePosition(mainSurface, activeStory);
+    const activePageIndex = findPageForOffset(pages, referencePosition);
+    return {
+      activePageIndex,
+      activeSectionIndex: pages[activePageIndex]?.sectionIndex ?? findSectionForOffset(sections, referencePosition)
+    };
+  }
+  return {
+    activePageIndex: 0,
+    activeSectionIndex: 0
+  };
+}
+function findFirstPageIndexForSection(pages, sectionIndex) {
+  const match = pages.findIndex((page) => page.sectionIndex === sectionIndex);
+  return match >= 0 ? match : 0;
+}
+function estimateFootnoteReservation(block, footnotes, columnWidth, reservedNotes) {
+  if (!footnotes || block.kind !== "paragraph") {
+    return 0;
+  }
+  let reservation = 0;
+  for (const noteKey of currentPageNoteIds(block)) {
+    if (reservedNotes.has(noteKey)) {
+      continue;
+    }
+    const [noteKind, noteId] = noteKey.split(":");
+    const noteCollection = noteKind === "endnote" ? footnotes.endnotes : footnotes.footnotes;
+    const note = noteCollection[noteId];
+    reservation += FOOTNOTE_REFERENCE_RESERVATION_TWIPS;
+    if (note) {
+      reservation += note.blocks.reduce(
+        (total, child) => total + estimateCanonicalNoteBlockHeight(child, columnWidth),
+        0
+      );
+    }
+  }
+  return reservation;
+}
+function estimateCanonicalNoteBlockHeight(block, columnWidth) {
+  switch (block.type) {
+    case "paragraph":
+      return estimateParagraphHeight(
+        {
+          blockId: "note",
+          kind: "paragraph",
+          from: 0,
+          to: 0,
+          ...block.styleId ? { styleId: block.styleId } : {},
+          segments: createEstimatedNoteSegments(block.children)
+        },
+        columnWidth
+      );
+    case "table":
+      return MIN_BLOCK_HEIGHT_TWIPS2 * Math.max(1, block.rows.length);
+    default:
+      return MIN_BLOCK_HEIGHT_TWIPS2;
+  }
+}
+function createEstimatedNoteSegments(children) {
+  const segments = [];
+  children.forEach((child, index) => {
+    if (child.type === "text") {
+      segments.push({
+        segmentId: `note-${index}`,
+        kind: "text",
+        from: 0,
+        to: Array.from(child.text).length,
+        text: child.text
+      });
+      return;
+    }
+    if (child.type === "hard_break" || child.type === "tab") {
+      segments.push({
+        segmentId: `note-${index}`,
+        kind: child.type,
+        from: 0,
+        to: 1
+      });
+    }
+  });
+  return segments;
+}
+function currentPageNoteIds(block) {
+  const notes = /* @__PURE__ */ new Set();
+  if (block.kind !== "paragraph") {
+    return notes;
+  }
+  for (const segment of block.segments) {
+    if (segment.kind === "note_ref" && segment.noteId) {
+      notes.add(`${segment.noteKind}:${segment.noteId}`);
+    }
+  }
+  return notes;
+}
+function hasColumnBreak(block) {
+  return block.kind === "paragraph" && block.segments.some(
+    (segment) => segment.kind === "opaque_inline" && segment.label === "Column break"
+  );
+}
+var HEADING_STYLE_PATTERN = /^heading\s*(\d+)$/i;
+function headingLevelFromStyleId(styleId) {
+  if (!styleId) return null;
+  const match = HEADING_STYLE_PATTERN.exec(styleId);
+  if (match) {
+    const level = parseInt(match[1], 10);
+    return level >= 1 && level <= 9 ? level : null;
+  }
+  return null;
+}
+function buildHeadingOutline(document, mainSurface, sections, pages) {
+  const headings = [];
+  for (const block of mainSurface.blocks) {
+    if (block.kind !== "paragraph") continue;
+    const outlineLevel = block.outlineLevel;
+    const styleLevel = resolveHeadingLevelFromStyle(document, block.styleId);
+    const level = outlineLevel !== void 0 && outlineLevel >= 0 ? outlineLevel + 1 : styleLevel;
+    if (level === null) continue;
+    const text = extractParagraphText(block);
+    if (!text.trim()) continue;
+    const offset = block.from;
+    const pageIndex = findPageForOffset(pages, offset);
+    const sectionIndex = findSectionForOffset(sections, offset);
+    headings.push({
+      headingId: `heading-${block.blockId}-${offset}`,
+      level,
+      text: text.trim(),
+      offset,
+      pageIndex,
+      sectionIndex
+    });
+  }
+  return headings;
+}
+function resolveHeadingLevelFromStyle(document, styleId) {
+  if (!styleId) {
+    return null;
+  }
+  const visited = /* @__PURE__ */ new Set();
+  let currentStyleId = styleId;
+  while (currentStyleId && !visited.has(currentStyleId)) {
+    visited.add(currentStyleId);
+    const style = document.styles.paragraphs[currentStyleId];
+    if (!style) {
+      break;
+    }
+    if (typeof style.outlineLevel === "number" && style.outlineLevel >= 0 && style.outlineLevel <= 8) {
+      return style.outlineLevel + 1;
+    }
+    currentStyleId = style.basedOn;
+  }
+  return headingLevelFromStyleId(styleId);
+}
+function extractParagraphText(block) {
+  let text = "";
+  for (const segment of block.segments) {
+    switch (segment.kind) {
+      case "text":
+        text += segment.text;
+        break;
+      case "tab":
+        text += "	";
+        break;
+      case "hard_break":
+        text += "\n";
+        break;
+    }
+  }
+  return text;
+}
+
+// src/ui-tailwind/editor-surface/perf-probe.ts
+function startPerfProbe(kind) {
+  const state = getEnabledState();
+  if (!state) {
+    return null;
+  }
+  const token = `${kind}-${state.nextToken ?? 0}`;
+  state.nextToken = (state.nextToken ?? 0) + 1;
+  state.pending ??= {};
+  state.pending[token] = {
+    kind,
+    startedAt: performance.now()
+  };
+  return token;
+}
+function finishPerfProbe(token) {
+  if (!token) {
+    return null;
+  }
+  const state = getEnabledState();
+  if (!state?.pending?.[token]) {
+    return null;
+  }
+  const pending = state.pending[token];
+  delete state.pending[token];
+  const sample = {
+    token,
+    kind: pending.kind,
+    durationMs: performance.now() - pending.startedAt,
+    recordedAt: Date.now()
+  };
+  pushSample(state, sample);
+  return sample;
+}
+function recordPerfSample(kind, durationMs = 0) {
+  const state = getEnabledState();
+  if (!state) {
+    return null;
+  }
+  const token = `${kind}-${state.nextToken ?? 0}`;
+  state.nextToken = (state.nextToken ?? 0) + 1;
+  const sample = {
+    token,
+    kind,
+    durationMs,
+    recordedAt: Date.now()
+  };
+  pushSample(state, sample);
+  return sample;
+}
+function incrementInvalidationCounter(counter, amount = 1) {
+  const state = getEnabledState();
+  if (!state) {
+    return 0;
+  }
+  state.invalidationCounts ??= {};
+  state.invalidationCounts[counter] = (state.invalidationCounts[counter] ?? 0) + amount;
+  return state.invalidationCounts[counter];
+}
+function getEnabledState() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const state = window.__DOCX_REACT_PERF_PROBE__;
+  if (!state?.enabled) {
+    return null;
+  }
+  return state;
+}
+function pushSample(state, sample) {
+  state.samples ??= [];
+  state.samples.push(sample);
+  const maxSamples = state.maxSamples ?? 20;
+  if (state.samples.length > maxSamples) {
+    state.samples.splice(0, state.samples.length - maxSamples);
+  }
+}
+
+export {
+  detachReviewAnchor,
+  mapReviewAnchor,
+  getAnchorRange,
+  mappingTouchesAnchorContent,
+  rangeStaysWithinSingleParagraph,
+  canCreateDocxCommentAnchor,
+  DEFAULT_PAGE_ESTIMATE_PX_PER_TWIP,
+  estimateBlockHeight,
+  estimateParagraphLineHeight,
+  estimateParagraphLineCount,
+  getUsableColumnWidth,
+  buildResolvedSections,
+  buildPageLayoutSnapshot,
+  resolveSectionForStoryTarget,
+  resolveActiveSection,
+  createViewState,
+  setViewMode,
+  setDocumentMode,
+  setWorkspaceMode,
+  setZoomLevel,
+  setFocused,
+  createEditorViewStateSnapshot,
+  createDocumentNavigationSnapshot,
+  findPageForOffset,
+  startPerfProbe,
+  finishPerfProbe,
+  recordPerfSample,
+  incrementInvalidationCounter
+};
+//# sourceMappingURL=chunk-GBVOWFIK.js.map