@beyondwork/docx-react-component 1.0.28 → 1.0.29

package/{src/core/commands/formatting-commands.ts → dist/chunk-TJBP2K4T.js}

@@ -1,99 +1,34 @@
-/**
- * ProseMirror formatting commands for the editor surface schema.
- *
- * Each command follows the standard ProseMirror command signature:
- *   (state, dispatch?) => boolean
- *
- * Toggle commands use the ProseMirror toggleMark helper.
- * Set commands for value-bearing marks (font, size, color) apply the mark
- * over the current selection, or remove it when the value is null.
- * The setAlignment command sets the `alignment` attr on paragraph nodes
- * that intersect the current selection.
- *
- * These commands operate on the `editorSchema` live surface. In the
- * current architecture the runtime is the canonical document authority;
- * these commands are designed to be used with the PM view's `dispatch`
- * so that mark changes are reflected on the live surface immediately.
- */
-
+// src/core/commands/formatting-commands.ts
 import { toggleMark } from "prosemirror-commands";
-import type { Command } from "prosemirror-state";
-import type { MarkType, Schema } from "prosemirror-model";
-
-import type {
-  FormattingBreadcrumbItem,
-  FormattingAlignment,
-  FormattingStateSnapshot,
-  PersistedEditorSnapshot,
-  RuntimeRenderSnapshot,
-  SurfaceBlockSnapshot,
-  SurfaceInlineSegment,
-  SurfaceTableCellSnapshot,
-} from "../../api/public-types";
-import type {
-  BlockNode,
-  DocumentRootNode,
-  InlineNode,
-  ParagraphNode,
-  TextMark,
-  TextNode,
-} from "../../model/canonical-document.ts";
-
-// ---------------------------------------------------------------------------
-// Toggle commands (boolean marks – no attrs)
-// ---------------------------------------------------------------------------
-
-export function makeToggleBold(schema: Schema): Command {
+function makeToggleBold(schema) {
   return toggleMark(schema.marks.bold);
 }
-
-export function makeToggleItalic(schema: Schema): Command {
+function makeToggleItalic(schema) {
   return toggleMark(schema.marks.italic);
 }
-
-export function makeToggleUnderline(schema: Schema): Command {
+function makeToggleUnderline(schema) {
   return toggleMark(schema.marks.underline);
 }
-
-export function makeToggleStrikethrough(schema: Schema): Command {
+function makeToggleStrikethrough(schema) {
   return toggleMark(schema.marks.strikethrough);
 }
-
-export function makeToggleSuperscript(schema: Schema): Command {
+function makeToggleSuperscript(schema) {
   return toggleMark(schema.marks.superscript);
 }
-
-export function makeToggleSubscript(schema: Schema): Command {
+function makeToggleSubscript(schema) {
   return toggleMark(schema.marks.subscript);
 }
-
-export function makeToggleSmallCaps(schema: Schema): Command {
+function makeToggleSmallCaps(schema) {
   return toggleMark(schema.marks.small_caps);
 }
-
-export function makeToggleAllCaps(schema: Schema): Command {
+function makeToggleAllCaps(schema) {
   return toggleMark(schema.marks.all_caps);
 }
-
-// ---------------------------------------------------------------------------
-// Set commands (value-bearing marks)
-// ---------------------------------------------------------------------------
-
-/**
- * Apply or remove a value-bearing mark over the current selection.
- * When `value` is null the mark is removed; otherwise it is added with the
- * given attribute key set to `value`.
- */
-function makeSetValueMark(
-  markType: MarkType,
-  attrKey: string,
-  value: string | number | null,
-): Command {
+function makeSetValueMark(markType, attrKey, value) {
   return (state, dispatch) => {
     const { from, to, empty } = state.selection;
     if (empty) return false;
     if (!dispatch) return true;
-
     const tr = state.tr;
     if (value === null) {
       tr.removeMark(from, to, markType);
@@ -105,70 +40,42 @@ function makeSetValueMark(
     return true;
   };
 }
-
-export function makeSetFontFamily(schema: Schema, family: string | null): Command {
+function makeSetFontFamily(schema, family) {
   return makeSetValueMark(schema.marks.font_family, "family", family);
 }
-
-export function makeSetFontSize(schema: Schema, size: number | null): Command {
+function makeSetFontSize(schema, size) {
   return makeSetValueMark(schema.marks.font_size, "size", size);
 }
-
-export function makeSetTextColor(schema: Schema, color: string | null): Command {
+function makeSetTextColor(schema, color) {
   return makeSetValueMark(schema.marks.text_color, "color", color);
 }
-
-export function makeSetHighlight(schema: Schema, color: string | null): Command {
+function makeSetHighlight(schema, color) {
   return makeSetValueMark(schema.marks.highlight, "color", color);
 }
-
-// ---------------------------------------------------------------------------
-// Paragraph alignment
-// ---------------------------------------------------------------------------
-
-export type Alignment = "left" | "center" | "right" | "justify";
-
-/**
- * Set the `alignment` attribute on every paragraph node that intersects
- * the current selection. Pass `null` to clear the alignment.
- */
-export function makeSetAlignment(schema: Schema, alignment: Alignment | null): Command {
+function makeSetAlignment(schema, alignment) {
   return (state, dispatch) => {
     const { from, to } = state.selection;
     if (!dispatch) return true;
-
     const tr = state.tr;
     let applied = false;
     state.doc.nodesBetween(from, to, (node, pos) => {
       if (node.type === schema.nodes.paragraph) {
-        tr.setNodeMarkup(pos, undefined, { ...node.attrs, alignment });
+        tr.setNodeMarkup(pos, void 0, { ...node.attrs, alignment });
         applied = true;
       }
     });
-
     if (!applied) return false;
     dispatch(tr);
     return true;
   };
 }
-
-// ---------------------------------------------------------------------------
-// Mark query helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Returns true if every character in the selection has the given mark active.
- * When the selection is collapsed, checks the stored marks at the cursor.
- */
-export function isMarkActive(schema: Schema, markName: keyof typeof schema.marks, state: import("prosemirror-state").EditorState): boolean {
+function isMarkActive(schema, markName, state) {
   const markType = schema.marks[markName];
   if (!markType) return false;
-
   const { from, to, empty } = state.selection;
   if (empty) {
     return Boolean(markType.isInSet(state.storedMarks ?? state.selection.$from.marks()));
   }
-
   let active = true;
   state.doc.nodesBetween(from, to, (node) => {
     if (node.isText && !markType.isInSet(node.marks)) {
@@ -178,180 +85,116 @@ export function isMarkActive(schema: Schema, markName: keyof typeof schema.marks
   });
   return active;
 }
-
-type CanonicalDocumentEnvelope = PersistedEditorSnapshot["canonicalDocument"];
-type ParagraphSurfaceBlock = Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>;
-type ToggleFormattingMark =
-  | "bold"
-  | "italic"
-  | "underline"
-  | "strikethrough"
-  | "superscript"
-  | "subscript";
-type FormattingOperation =
-  | { type: "toggle"; mark: ToggleFormattingMark }
-  | { type: "set-font-family"; fontFamily: string | null }
-  | { type: "set-font-size"; size: number | null }
-  | { type: "set-text-color"; color: string | null }
-  | { type: "set-highlight-color"; color: string | null }
-  | { type: "set-alignment"; alignment: FormattingAlignment }
-  | { type: "indent" }
-  | { type: "outdent" };
-
-export interface FormattingMutationResult {
-  document: CanonicalDocumentEnvelope;
-  selection: RuntimeRenderSnapshot["selection"];
-  changed: boolean;
-}
-
-const DEFAULT_FORMATTING_STATE: FormattingStateSnapshot = {
+var DEFAULT_FORMATTING_STATE = {
   bold: false,
   italic: false,
   underline: false,
   strikethrough: false,
   superscript: false,
   subscript: false,
-  breadcrumb: [],
+  breadcrumb: []
 };
-
-const INDENT_STEP_TWIPS = 720;
-
-export function getFormattingStateFromRenderSnapshot(
-  snapshot: RuntimeRenderSnapshot,
-): FormattingStateSnapshot {
+var INDENT_STEP_TWIPS = 720;
+function getFormattingStateFromRenderSnapshot(snapshot) {
   const surface = snapshot.surface;
   if (!surface) {
     return { ...DEFAULT_FORMATTING_STATE };
   }
-
-  const paragraphs = collectParagraphSurfaces(surface.blocks).filter((paragraph) =>
-    selectionTouchesRange(
+  const paragraphs = collectParagraphSurfaces(surface.blocks).filter(
+    (paragraph) => selectionTouchesRange(
       snapshot.selection.anchor,
       snapshot.selection.head,
       paragraph.from,
-      paragraph.to,
-    ),
+      paragraph.to
+    )
   );
   const textSegments = collectFormattingTextSegments(paragraphs, snapshot.selection);
-
   return {
-    bold: textSegments.length > 0
-      ? textSegments.every((segment) => segmentHasMark(segment, "bold"))
-      : false,
-    italic: textSegments.length > 0
-      ? textSegments.every((segment) => segmentHasMark(segment, "italic"))
-      : false,
-    underline: textSegments.length > 0
-      ? textSegments.every((segment) => segmentHasMark(segment, "underline"))
-      : false,
-    strikethrough: textSegments.length > 0
-      ? textSegments.every((segment) => segmentHasMark(segment, "strikethrough"))
-      : false,
-    superscript: textSegments.length > 0
-      ? textSegments.every((segment) => segmentHasMark(segment, "superscript"))
-      : false,
-    subscript: textSegments.length > 0
-      ? textSegments.every((segment) => segmentHasMark(segment, "subscript"))
-      : false,
+    bold: textSegments.length > 0 ? textSegments.every((segment) => segmentHasMark(segment, "bold")) : false,
+    italic: textSegments.length > 0 ? textSegments.every((segment) => segmentHasMark(segment, "italic")) : false,
+    underline: textSegments.length > 0 ? textSegments.every((segment) => segmentHasMark(segment, "underline")) : false,
+    strikethrough: textSegments.length > 0 ? textSegments.every((segment) => segmentHasMark(segment, "strikethrough")) : false,
+    superscript: textSegments.length > 0 ? textSegments.every((segment) => segmentHasMark(segment, "superscript")) : false,
+    subscript: textSegments.length > 0 ? textSegments.every((segment) => segmentHasMark(segment, "subscript")) : false,
     fontFamily: getConsistentValue(textSegments, (segment) => segment.markAttrs?.fontFamily),
     fontSize: getConsistentValue(textSegments, (segment) => {
       const size = segment.markAttrs?.fontSize;
-      return typeof size === "number" ? size / 2 : undefined;
+      return typeof size === "number" ? size / 2 : void 0;
     }),
-    textColor: getConsistentValue(textSegments, (segment) =>
-      toPublicColor(segment.markAttrs?.textColor),
+    textColor: getConsistentValue(
+      textSegments,
+      (segment) => toPublicColor(segment.markAttrs?.textColor)
     ),
     highlightColor: getConsistentValue(
       textSegments,
       (segment) => toPublicColor(segment.markAttrs?.backgroundColor) ?? null,
       {
-        emptyFallback: null,
-      },
+        emptyFallback: null
+      }
     ),
-    alignment: getConsistentValue(paragraphs, (paragraph) =>
-      toPublicAlignment(paragraph.alignment),
+    alignment: getConsistentValue(
+      paragraphs,
+      (paragraph) => toPublicAlignment(paragraph.alignment)
     ),
     paragraphStyleId: getConsistentValue(paragraphs, (paragraph) => paragraph.styleId),
-    breadcrumb: getSelectionBreadcrumb(surface.blocks, snapshot.selection),
+    breadcrumb: getSelectionBreadcrumb(surface.blocks, snapshot.selection)
   };
 }
-
-function getSelectionBreadcrumb(
-  blocks: SurfaceBlockSnapshot[],
-  selection: RuntimeRenderSnapshot["selection"],
-): FormattingBreadcrumbItem[] {
+function getSelectionBreadcrumb(blocks, selection) {
   const paths = collectSelectionBreadcrumbPaths(blocks, selection);
   if (paths.length === 0) {
     return [];
   }
-
   let commonLength = paths[0]?.length ?? 0;
   for (let pathIndex = 1; pathIndex < paths.length; pathIndex += 1) {
     const currentPath = paths[pathIndex] ?? [];
     commonLength = Math.min(commonLength, currentPath.length);
-
     let compareIndex = 0;
-    while (
-      compareIndex < commonLength &&
-      breadcrumbItemsEqual(paths[0]![compareIndex]!, currentPath[compareIndex]!)
-    ) {
+    while (compareIndex < commonLength && breadcrumbItemsEqual(paths[0][compareIndex], currentPath[compareIndex])) {
       compareIndex += 1;
     }
     commonLength = compareIndex;
   }
-
-  return paths[0]!.slice(0, commonLength);
+  return paths[0].slice(0, commonLength);
 }
-
-function collectSelectionBreadcrumbPaths(
-  blocks: SurfaceBlockSnapshot[],
-  selection: RuntimeRenderSnapshot["selection"],
-  path: FormattingBreadcrumbItem[] = [],
-  output: FormattingBreadcrumbItem[][] = [],
-): FormattingBreadcrumbItem[][] {
+function collectSelectionBreadcrumbPaths(blocks, selection, path = [], output = []) {
   for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
     const block = blocks[blockIndex];
     if (!block) {
       continue;
     }
-
-    if (
-      !selectionTouchesRange(
-        selection.anchor,
-        selection.head,
-        block.from,
-        block.to,
-      )
-    ) {
+    if (!selectionTouchesRange(
+      selection.anchor,
+      selection.head,
+      block.from,
+      block.to
+    )) {
       continue;
     }
-
     if (block.kind === "paragraph") {
       output.push([
         ...path,
         {
-          kind: "paragraph" as const,
+          kind: "paragraph",
           label: block.styleId ? `Paragraph (${block.styleId})` : "Paragraph",
           from: block.from,
-          to: block.to,
-        },
+          to: block.to
+        }
       ]);
       continue;
     }
-
     if (block.kind === "opaque_block") {
       output.push([
         ...path,
         {
-          kind: "opaque_block" as const,
+          kind: "opaque_block",
           label: block.label,
           from: block.from,
-          to: block.to,
-        },
+          to: block.to
+        }
       ]);
       continue;
     }
-
     if (block.kind === "sdt_block") {
       collectSelectionBreadcrumbPaths(
         block.children,
@@ -359,72 +202,63 @@ function collectSelectionBreadcrumbPaths(
         [
           ...path,
           {
-            kind: "sdt_block" as const,
+            kind: "sdt_block",
             label: block.alias ?? block.tag ?? block.sdtType ?? "Content control",
             from: block.from,
-            to: block.to,
-          },
+            to: block.to
+          }
         ],
-        output,
+        output
       );
       continue;
     }
-
     if (block.kind === "table") {
       const tablePath = [
         ...path,
         {
-          kind: "table" as const,
+          kind: "table",
           label: block.styleId ? `Table (${block.styleId})` : "Table",
           from: block.from,
-          to: block.to,
-        },
+          to: block.to
+        }
       ];
-
       for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
         const row = block.rows[rowIndex];
         if (!row) {
           continue;
         }
         const rowRange = getTableRowRange(block, row);
-        if (
-          !selectionTouchesRange(
-            selection.anchor,
-            selection.head,
-            rowRange.from,
-            rowRange.to,
-          )
-        ) {
+        if (!selectionTouchesRange(
+          selection.anchor,
+          selection.head,
+          rowRange.from,
+          rowRange.to
+        )) {
           continue;
         }
-
         const rowPath = [
           ...tablePath,
           {
-            kind: "table_row" as const,
+            kind: "table_row",
             label: `Row ${rowIndex + 1}`,
             from: rowRange.from,
-            to: rowRange.to,
-          },
+            to: rowRange.to
+          }
         ];
-
         for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
           const cell = row.cells[cellIndex];
           if (!cell) {
             continue;
           }
           const cellRange = getTableCellRange(block, cell);
-          if (
-            !selectionTouchesRange(
-              selection.anchor,
-              selection.head,
-              cellRange.from,
-              cellRange.to,
-            )
-          ) {
+          if (!selectionTouchesRange(
+            selection.anchor,
+            selection.head,
+            cellRange.from,
+            cellRange.to
+          )) {
             continue;
           }
-
           collectSelectionBreadcrumbPaths(
             cell.content,
             selection,
@@ -434,169 +268,113 @@ function collectSelectionBreadcrumbPaths(
                 kind: "table_cell",
                 label: `Cell ${cellIndex + 1}`,
                 from: cellRange.from,
-                to: cellRange.to,
-              },
+                to: cellRange.to
+              }
             ],
-            output,
+            output
           );
         }
       }
     }
   }
-
   return output;
 }
-
-function getTableRowRange(
-  table: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
-  row: (typeof table.rows)[number],
-): { from: number; to: number } {
+function getTableRowRange(table, row) {
   let from = Number.POSITIVE_INFINITY;
   let to = Number.NEGATIVE_INFINITY;
-
   for (const cell of row.cells) {
     const range = getTableCellRange(table, cell);
     from = Math.min(from, range.from);
     to = Math.max(to, range.to);
   }
-
-  return Number.isFinite(from) && Number.isFinite(to)
-    ? { from, to }
-    : { from: table.from, to: table.to };
+  return Number.isFinite(from) && Number.isFinite(to) ? { from, to } : { from: table.from, to: table.to };
 }
-
-function getTableCellRange(
-  table: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
-  cell: SurfaceTableCellSnapshot,
-): { from: number; to: number } {
+function getTableCellRange(table, cell) {
   if (cell.content.length === 0) {
     return { from: table.from, to: table.to };
   }
-
   let from = Number.POSITIVE_INFINITY;
   let to = Number.NEGATIVE_INFINITY;
   for (const child of cell.content) {
     from = Math.min(from, child.from);
     to = Math.max(to, child.to);
   }
-
-  return Number.isFinite(from) && Number.isFinite(to)
-    ? { from, to }
-    : { from: table.from, to: table.to };
+  return Number.isFinite(from) && Number.isFinite(to) ? { from, to } : { from: table.from, to: table.to };
 }
-
-function breadcrumbItemsEqual(
-  left: FormattingBreadcrumbItem,
-  right: FormattingBreadcrumbItem,
-): boolean {
-  return (
-    left.kind === right.kind &&
-    left.label === right.label &&
-    left.from === right.from &&
-    left.to === right.to
-  );
+function breadcrumbItemsEqual(left, right) {
+  return left.kind === right.kind && left.label === right.label && left.from === right.from && left.to === right.to;
 }
-
-export function applyFormattingOperationToDocument(
-  document: CanonicalDocumentEnvelope,
-  snapshot: RuntimeRenderSnapshot,
-  operation: FormattingOperation,
-): FormattingMutationResult {
+function applyFormattingOperationToDocument(document, snapshot, operation) {
   const surface = snapshot.surface;
   if (!surface) {
     return {
       document,
       selection: snapshot.selection,
-      changed: false,
+      changed: false
     };
   }
-
   const nextDocument = structuredClone(document);
-  const root = nextDocument.content as DocumentRootNode;
+  const root = nextDocument.content;
   let changed = false;
   const selectionFrom = Math.min(snapshot.selection.anchor, snapshot.selection.head);
   const selectionTo = Math.max(snapshot.selection.anchor, snapshot.selection.head);
-
   if (operation.type === "set-alignment" || operation.type === "indent" || operation.type === "outdent") {
     visitParagraphBindings(root.children, surface.blocks, (paragraph, paragraphSurface) => {
-      if (
-        !selectionTouchesRange(
-          snapshot.selection.anchor,
-          snapshot.selection.head,
-          paragraphSurface.from,
-          paragraphSurface.to,
-        )
-      ) {
+      if (!selectionTouchesRange(
+        snapshot.selection.anchor,
+        snapshot.selection.head,
+        paragraphSurface.from,
+        paragraphSurface.to
+      )) {
         return;
       }
-
-      const paragraphChanged =
-        operation.type === "set-alignment"
-          ? applyAlignment(paragraph, operation.alignment)
-          : applyIndentation(paragraph, operation.type === "indent" ? 1 : -1);
+      const paragraphChanged = operation.type === "set-alignment" ? applyAlignment(paragraph, operation.alignment) : applyIndentation(paragraph, operation.type === "indent" ? 1 : -1);
       changed = changed || paragraphChanged;
     });
-
     return {
       document: changed ? nextDocument : document,
       selection: snapshot.selection,
-      changed,
+      changed
     };
   }
-
   if (selectionFrom === selectionTo) {
     return {
       document,
       selection: snapshot.selection,
-      changed: false,
+      changed: false
     };
   }
-
   const nextMarks = resolveMarkUpdater(snapshot, operation);
-
   visitParagraphBindings(root.children, surface.blocks, (paragraph, paragraphSurface) => {
-    if (
-      !rangesOverlap(
-        selectionFrom,
-        selectionTo,
-        paragraphSurface.from,
-        paragraphSurface.to,
-      )
-    ) {
+    if (!rangesOverlap(
+      selectionFrom,
+      selectionTo,
+      paragraphSurface.from,
+      paragraphSurface.to
+    )) {
       return;
     }
-
     const transformed = transformInlineNodes(
       paragraph.children,
       paragraphSurface.from,
       selectionFrom,
       selectionTo,
-      nextMarks,
+      nextMarks
     );
     if (!transformed.changed) {
       return;
     }
-
     paragraph.children = transformed.nodes;
     changed = true;
   });
-
   return {
     document: changed ? nextDocument : document,
     selection: snapshot.selection,
-    changed,
+    changed
   };
 }
-
-function resolveMarkUpdater(
-  snapshot: RuntimeRenderSnapshot,
-  operation: Exclude<
-    FormattingOperation,
-    { type: "set-alignment" } | { type: "indent" } | { type: "outdent" }
-  >,
-): (marks?: TextMark[]) => TextMark[] | undefined {
+function resolveMarkUpdater(snapshot, operation) {
   const formatting = getFormattingStateFromRenderSnapshot(snapshot);
-
   switch (operation.type) {
     case "toggle":
       return (marks) => toggleMarks(marks, operation.mark, !formatting[operation.mark]);
@@ -610,65 +388,49 @@ function resolveMarkUpdater(
       return (marks) => setMarkValue(marks, "backgroundColor", sanitizeColor(operation.color));
   }
 }
-
-function applyAlignment(
-  paragraph: ParagraphNode,
-  alignment: FormattingAlignment,
-): boolean {
+function applyAlignment(paragraph, alignment) {
   const nextAlignment = alignment === "justify" ? "both" : alignment;
   if (paragraph.alignment === nextAlignment) {
     return false;
   }
-
   paragraph.alignment = nextAlignment;
   return true;
 }
-
-function applyIndentation(paragraph: ParagraphNode, delta: -1 | 1): boolean {
+function applyIndentation(paragraph, delta) {
   if (paragraph.numbering) {
     const nextLevel = clamp(paragraph.numbering.level + delta, 0, 8);
     if (nextLevel === paragraph.numbering.level) {
       return false;
     }
-
     paragraph.numbering = {
       ...paragraph.numbering,
-      level: nextLevel,
+      level: nextLevel
     };
     return true;
   }
-
   const currentLeft = paragraph.indentation?.left ?? 0;
   const nextLeft = Math.max(0, currentLeft + delta * INDENT_STEP_TWIPS);
   if (nextLeft === currentLeft) {
     return false;
   }
-
   const nextIndentation = {
-    ...(paragraph.indentation ?? {}),
+    ...paragraph.indentation ?? {}
   };
   if (nextLeft > 0) {
     nextIndentation.left = nextLeft;
     paragraph.indentation = nextIndentation;
   } else if (paragraph.indentation) {
     delete nextIndentation.left;
-    paragraph.indentation =
-      Object.keys(nextIndentation).length > 0 ? nextIndentation : undefined;
+    paragraph.indentation = Object.keys(nextIndentation).length > 0 ? nextIndentation : void 0;
   }
-
   return true;
 }
-
-function collectParagraphSurfaces(
-  blocks: SurfaceBlockSnapshot[],
-  output: ParagraphSurfaceBlock[] = [],
-): ParagraphSurfaceBlock[] {
+function collectParagraphSurfaces(blocks, output = []) {
   for (const block of blocks) {
     if (block.kind === "paragraph") {
       output.push(block);
       continue;
     }
-
     if (block.kind === "table") {
       for (const row of block.rows) {
         for (const cell of row.cells) {
@@ -677,72 +439,45 @@ function collectParagraphSurfaces(
       }
       continue;
     }
-
     if (block.kind === "sdt_block") {
       collectParagraphSurfaces(block.children, output);
     }
   }
-
   return output;
 }
-
-function collectFormattingTextSegments(
-  paragraphs: ParagraphSurfaceBlock[],
-  selection: RuntimeRenderSnapshot["selection"],
-): Array<Extract<SurfaceInlineSegment, { kind: "text" }>> {
+function collectFormattingTextSegments(paragraphs, selection) {
   const caret = selection.anchor;
   const isCollapsed = selection.isCollapsed;
   const selectionFrom = Math.min(selection.anchor, selection.head);
   const selectionTo = Math.max(selection.anchor, selection.head);
-  const segments: Array<Extract<SurfaceInlineSegment, { kind: "text" }>> = [];
-
+  const segments = [];
   for (const paragraph of paragraphs) {
     for (const segment of paragraph.segments) {
       if (segment.kind !== "text") {
         continue;
       }
-
-      if (
-        isCollapsed
-          ? segmentContainsCaret(segment, caret)
-          : rangesOverlap(selectionFrom, selectionTo, segment.from, segment.to)
-      ) {
+      if (isCollapsed ? segmentContainsCaret(segment, caret) : rangesOverlap(selectionFrom, selectionTo, segment.from, segment.to)) {
         segments.push(segment);
       }
     }
   }
-
   if (!isCollapsed || segments.length > 0) {
     return segments;
   }
-
   for (const paragraph of paragraphs) {
     const fallback = paragraph.segments.find(
-      (segment): segment is Extract<SurfaceInlineSegment, { kind: "text" }> =>
-        segment.kind === "text" && segment.to === caret,
+      (segment) => segment.kind === "text" && segment.to === caret
     );
     if (fallback) {
       return [fallback];
     }
   }
-
   return [];
 }
-
-function segmentContainsCaret(
-  segment: Extract<SurfaceInlineSegment, { kind: "text" }>,
-  caret: number,
-): boolean {
-  return (
-    segment.from <= caret &&
-    (caret < segment.to || (segment.to === caret && segment.to > segment.from))
-  );
+function segmentContainsCaret(segment, caret) {
+  return segment.from <= caret && (caret < segment.to || segment.to === caret && segment.to > segment.from);
 }
-
-function segmentHasMark(
-  segment: Extract<SurfaceInlineSegment, { kind: "text" }>,
-  mark: ToggleFormattingMark,
-): boolean {
+function segmentHasMark(segment, mark) {
   const marks = segment.marks ?? [];
   if (mark === "superscript") {
     return marks.includes("superscript");
@@ -752,21 +487,12 @@ function segmentHasMark(
   }
   return marks.includes(mark);
 }
-
-function getConsistentValue<TItem, TValue>(
-  items: readonly TItem[],
-  getter: (item: TItem) => TValue,
-  options: {
-    emptyFallback?: TValue;
-  } = {},
-): TValue | undefined {
+function getConsistentValue(items, getter, options = {}) {
   if (items.length === 0) {
     return options.emptyFallback;
   }
-
-  let value: TValue | undefined = undefined;
+  let value = void 0;
   let initialized = false;
-
   for (const item of items) {
     const next = getter(item);
     if (!initialized) {
@@ -774,32 +500,23 @@ function getConsistentValue<TItem, TValue>(
       initialized = true;
       continue;
     }
-
     if (next !== value) {
-      return undefined;
+      return void 0;
     }
   }
-
   return value;
 }
-
-function visitParagraphBindings(
-  blocks: BlockNode[],
-  surfaceBlocks: SurfaceBlockSnapshot[],
-  visitor: (paragraph: ParagraphNode, surface: ParagraphSurfaceBlock) => void,
-): void {
+function visitParagraphBindings(blocks, surfaceBlocks, visitor) {
   for (let index = 0; index < Math.min(blocks.length, surfaceBlocks.length); index += 1) {
     const block = blocks[index];
     const surface = surfaceBlocks[index];
     if (!block || !surface) {
       continue;
     }
-
     if (block.type === "paragraph" && surface.kind === "paragraph") {
       visitor(block, surface);
       continue;
     }
-
     if (block.type === "table" && surface.kind === "table") {
       for (let rowIndex = 0; rowIndex < Math.min(block.rows.length, surface.rows.length); rowIndex += 1) {
         const row = block.rows[rowIndex];
@@ -807,41 +524,26 @@ function visitParagraphBindings(
         if (!row || !surfaceRow) {
           continue;
         }
-
-        for (
-          let cellIndex = 0;
-          cellIndex < Math.min(row.cells.length, surfaceRow.cells.length);
-          cellIndex += 1
-        ) {
+        for (let cellIndex = 0; cellIndex < Math.min(row.cells.length, surfaceRow.cells.length); cellIndex += 1) {
           const cell = row.cells[cellIndex];
           const surfaceCell = surfaceRow.cells[cellIndex];
           if (!cell || !surfaceCell) {
             continue;
           }
-
           visitParagraphBindings(cell.children, surfaceCell.content, visitor);
         }
       }
       continue;
     }
-
     if (block.type === "sdt" && surface.kind === "sdt_block") {
       visitParagraphBindings(block.children, surface.children, visitor);
     }
   }
 }
-
-function transformInlineNodes(
-  nodes: InlineNode[],
-  start: number,
-  selectionFrom: number,
-  selectionTo: number,
-  updateMarks: (marks?: TextMark[]) => TextMark[] | undefined,
-): { nodes: InlineNode[]; changed: boolean; nextPosition: number } {
+function transformInlineNodes(nodes, start, selectionFrom, selectionTo, updateMarks) {
   let changed = false;
   let position = start;
-  const nextNodes: InlineNode[] = [];
-
+  const nextNodes = [];
   for (const node of nodes) {
     if (node.type === "text") {
       const transformed = transformTextNode(
@@ -849,178 +551,141 @@ function transformInlineNodes(
         position,
         selectionFrom,
         selectionTo,
-        updateMarks,
+        updateMarks
       );
       nextNodes.push(...transformed.nodes);
       position = transformed.nextPosition;
       changed = changed || transformed.changed;
       continue;
     }
-
     if (node.type === "hyperlink") {
       const transformed = transformInlineNodes(
-        node.children as InlineNode[],
+        node.children,
         position,
         selectionFrom,
         selectionTo,
-        updateMarks,
+        updateMarks
       );
       nextNodes.push(
-        transformed.changed
-          ? {
-              ...node,
-              children: transformed.nodes as typeof node.children,
-            }
-          : node,
+        transformed.changed ? {
+          ...node,
+          children: transformed.nodes
+        } : node
       );
       position = transformed.nextPosition;
       changed = changed || transformed.changed;
       continue;
     }
-
     nextNodes.push(node);
     position += inlineNodeLength(node);
   }
-
   return {
     nodes: nextNodes,
     changed,
-    nextPosition: position,
+    nextPosition: position
   };
 }
-
-function transformTextNode(
-  node: TextNode,
-  start: number,
-  selectionFrom: number,
-  selectionTo: number,
-  updateMarks: (marks?: TextMark[]) => TextMark[] | undefined,
-): { nodes: TextNode[]; changed: boolean; nextPosition: number } {
+function transformTextNode(node, start, selectionFrom, selectionTo, updateMarks) {
   const characters = Array.from(node.text);
   const end = start + characters.length;
   const overlapFrom = Math.max(selectionFrom, start);
   const overlapTo = Math.min(selectionTo, end);
-
   if (overlapFrom >= overlapTo) {
     return {
       nodes: [node],
       changed: false,
-      nextPosition: end,
+      nextPosition: end
     };
   }
-
   const localFrom = overlapFrom - start;
   const localTo = overlapTo - start;
-  const nextNodes: TextNode[] = [];
-
+  const nextNodes = [];
   if (localFrom > 0) {
     nextNodes.push(createTextNode(characters.slice(0, localFrom).join(""), node.marks));
   }
-
   const transformedMarks = updateMarks(node.marks);
   nextNodes.push(
-    createTextNode(characters.slice(localFrom, localTo).join(""), transformedMarks),
+    createTextNode(characters.slice(localFrom, localTo).join(""), transformedMarks)
   );
-
   if (localTo < characters.length) {
     nextNodes.push(createTextNode(characters.slice(localTo).join(""), node.marks));
   }
-
   return {
     nodes: nextNodes.filter((candidate) => candidate.text.length > 0),
     changed: !marksEqual(node.marks, transformedMarks) || localFrom > 0 || localTo < characters.length,
-    nextPosition: end,
+    nextPosition: end
   };
 }
-
-function createTextNode(text: string, marks?: TextMark[]): TextNode {
+function createTextNode(text, marks) {
   return {
     type: "text",
     text,
-    ...(marks && marks.length > 0 ? { marks: cloneMarks(marks) } : {}),
+    ...marks && marks.length > 0 ? { marks: cloneMarks(marks) } : {}
   };
 }
-
-function toggleMarks(
-  marks: TextMark[] | undefined,
-  mark: ToggleFormattingMark,
-  enabled: boolean,
-): TextMark[] | undefined {
+function toggleMarks(marks, mark, enabled) {
   const nextMarks = cloneMarks(marks);
-
   if (mark === "superscript" || mark === "subscript") {
-    const filtered: TextMark[] = nextMarks.filter((candidate) => candidate.type !== "position");
+    const filtered2 = nextMarks.filter((candidate) => candidate.type !== "position");
     if (enabled) {
-      filtered.push({
+      filtered2.push({
         type: "position",
-        val: mark === "superscript" ? 1 : -1,
+        val: mark === "superscript" ? 1 : -1
       });
     }
-    return filtered.length > 0 ? filtered : undefined;
+    return filtered2.length > 0 ? filtered2 : void 0;
   }
-
   const filtered = nextMarks.filter((candidate) => candidate.type !== mark);
   if (enabled) {
     filtered.push({ type: mark });
   }
-  return filtered.length > 0 ? filtered : undefined;
+  return filtered.length > 0 ? filtered : void 0;
 }
-
-function setMarkValue(
-  marks: TextMark[] | undefined,
-  markType: "fontFamily" | "fontSize" | "textColor" | "backgroundColor",
-  value: string | number | null,
-): TextMark[] | undefined {
+function setMarkValue(marks, markType, value) {
   const nextMarks = cloneMarks(marks).filter((candidate) => {
     if (markType === "backgroundColor") {
       return candidate.type !== "backgroundColor" && candidate.type !== "highlight";
     }
     return candidate.type !== markType;
   });
-
   if (value !== null) {
     switch (markType) {
       case "fontFamily":
-        nextMarks.push({ type: "fontFamily", val: value as string });
+        nextMarks.push({ type: "fontFamily", val: value });
         break;
       case "fontSize":
-        nextMarks.push({ type: "fontSize", val: value as number });
+        nextMarks.push({ type: "fontSize", val: value });
         break;
       case "textColor":
-        nextMarks.push({ type: "textColor", color: value as string });
+        nextMarks.push({ type: "textColor", color: value });
         break;
       case "backgroundColor":
-        nextMarks.push({ type: "backgroundColor", color: value as string });
+        nextMarks.push({ type: "backgroundColor", color: value });
         break;
     }
   }
-
-  return nextMarks.length > 0 ? nextMarks : undefined;
+  return nextMarks.length > 0 ? nextMarks : void 0;
 }
-
-function cloneMarks(marks?: TextMark[]): TextMark[] {
+function cloneMarks(marks) {
   return marks ? marks.map((mark) => ({ ...mark })) : [];
 }
-
-function marksEqual(left?: TextMark[], right?: TextMark[]): boolean {
+function marksEqual(left, right) {
   if (!left?.length && !right?.length) {
     return true;
   }
   if (!left || !right || left.length !== right.length) {
     return false;
   }
-
   return left.every((mark, index) => JSON.stringify(mark) === JSON.stringify(right[index]));
 }
-
-function inlineNodeLength(node: InlineNode): number {
+function inlineNodeLength(node) {
   switch (node.type) {
     case "text":
       return Array.from(node.text).length;
     case "hyperlink":
-      return node.children.reduce< number >(
-        (total, child) => total + inlineNodeLength(child as InlineNode),
-        0,
+      return node.children.reduce(
+        (total, child) => total + inlineNodeLength(child),
+        0
       );
     case "hard_break":
     case "column_break":
@@ -1036,19 +701,16 @@ function inlineNodeLength(node: InlineNode): number {
     case "vml_shape":
       return 1;
     case "field":
-      return node.children.reduce<number>(
-        (total, child) => total + inlineNodeLength(child as InlineNode),
-        0,
+      return node.children.reduce(
+        (total, child) => total + inlineNodeLength(child),
+        0
       );
     case "bookmark_start":
     case "bookmark_end":
       return 0;
   }
 }
-
-function toPublicAlignment(
-  alignment: ParagraphNode["alignment"] | undefined,
-): FormattingAlignment | undefined {
+function toPublicAlignment(alignment) {
   switch (alignment) {
     case "both":
     case "distribute":
@@ -1058,49 +720,34 @@ function toPublicAlignment(
     case "right":
       return alignment;
     default:
-      return undefined;
+      return void 0;
   }
 }
-
-function toPublicColor(color: string | undefined): string | undefined {
+function toPublicColor(color) {
   if (!color) {
-    return undefined;
+    return void 0;
   }
-
-  return /^[0-9A-F]{3,8}$/iu.test(color)
-    ? `#${color.toUpperCase()}`
-    : color;
+  return /^[0-9A-F]{3,8}$/iu.test(color) ? `#${color.toUpperCase()}` : color;
 }
-
-function sanitizeFontFamily(fontFamily: string | null): string | null {
+function sanitizeFontFamily(fontFamily) {
   const normalized = fontFamily?.trim();
   return normalized ? normalized : null;
 }
-
-function sanitizeFontSize(size: number | null): number | null {
+function sanitizeFontSize(size) {
   if (typeof size !== "number" || !Number.isFinite(size) || size <= 0) {
     return null;
   }
-
   return Math.round(size * 2);
 }
-
-function sanitizeColor(color: string | null): string | null {
+function sanitizeColor(color) {
   const normalized = color?.trim();
   if (!normalized) {
     return null;
   }
-
   const raw = normalized.startsWith("#") ? normalized.slice(1) : normalized;
   return /^[0-9A-F]{3,8}$/iu.test(raw) ? raw.toUpperCase() : null;
 }
-
-function selectionTouchesRange(
-  anchor: number,
-  head: number,
-  rangeFrom: number,
-  rangeTo: number,
-): boolean {
+function selectionTouchesRange(anchor, head, rangeFrom, rangeTo) {
   const selectionFrom = Math.min(anchor, head);
   const selectionTo = Math.max(anchor, head);
   if (selectionFrom === selectionTo) {
@@ -1108,13 +755,7 @@ function selectionTouchesRange(
   }
   return rangesOverlap(selectionFrom, selectionTo, rangeFrom, rangeTo);
 }
-
-function rangesOverlap(
-  leftFrom: number,
-  leftTo: number,
-  rightFrom: number,
-  rightTo: number,
-): boolean {
+function rangesOverlap(leftFrom, leftTo, rightFrom, rightTo) {
   if (leftFrom === leftTo) {
     return leftFrom >= rightFrom && leftFrom <= rightTo;
   }
@@ -1123,7 +764,26 @@ function rangesOverlap(
   }
   return leftFrom < rightTo && leftTo > rightFrom;
 }
-
-function clamp(value: number, min: number, max: number): number {
+function clamp(value, min, max) {
   return Math.min(max, Math.max(min, value));
 }
+
+export {
+  makeToggleBold,
+  makeToggleItalic,
+  makeToggleUnderline,
+  makeToggleStrikethrough,
+  makeToggleSuperscript,
+  makeToggleSubscript,
+  makeToggleSmallCaps,
+  makeToggleAllCaps,
+  makeSetFontFamily,
+  makeSetFontSize,
+  makeSetTextColor,
+  makeSetHighlight,
+  makeSetAlignment,
+  isMarkActive,
+  getFormattingStateFromRenderSnapshot,
+  applyFormattingOperationToDocument
+};
+//# sourceMappingURL=chunk-TJBP2K4T.js.map