@beyondwork/docx-react-component 1.0.29 → 1.0.30

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

@@ -1,34 +1,99 @@
-// src/core/commands/formatting-commands.ts
+/**
+ * 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.
+ */
+
 import { toggleMark } from "prosemirror-commands";
-function makeToggleBold(schema) {
+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 {
   return toggleMark(schema.marks.bold);
 }
-function makeToggleItalic(schema) {
+
+export function makeToggleItalic(schema: Schema): Command {
   return toggleMark(schema.marks.italic);
 }
-function makeToggleUnderline(schema) {
+
+export function makeToggleUnderline(schema: Schema): Command {
   return toggleMark(schema.marks.underline);
 }
-function makeToggleStrikethrough(schema) {
+
+export function makeToggleStrikethrough(schema: Schema): Command {
   return toggleMark(schema.marks.strikethrough);
 }
-function makeToggleSuperscript(schema) {
+
+export function makeToggleSuperscript(schema: Schema): Command {
   return toggleMark(schema.marks.superscript);
 }
-function makeToggleSubscript(schema) {
+
+export function makeToggleSubscript(schema: Schema): Command {
   return toggleMark(schema.marks.subscript);
 }
-function makeToggleSmallCaps(schema) {
+
+export function makeToggleSmallCaps(schema: Schema): Command {
   return toggleMark(schema.marks.small_caps);
 }
-function makeToggleAllCaps(schema) {
+
+export function makeToggleAllCaps(schema: Schema): Command {
   return toggleMark(schema.marks.all_caps);
 }
-function makeSetValueMark(markType, attrKey, value) {
+
+// ---------------------------------------------------------------------------
+// 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 {
   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);
@@ -40,42 +105,70 @@ function makeSetValueMark(markType, attrKey, value) {
     return true;
   };
 }
-function makeSetFontFamily(schema, family) {
+
+export function makeSetFontFamily(schema: Schema, family: string | null): Command {
   return makeSetValueMark(schema.marks.font_family, "family", family);
 }
-function makeSetFontSize(schema, size) {
+
+export function makeSetFontSize(schema: Schema, size: number | null): Command {
   return makeSetValueMark(schema.marks.font_size, "size", size);
 }
-function makeSetTextColor(schema, color) {
+
+export function makeSetTextColor(schema: Schema, color: string | null): Command {
   return makeSetValueMark(schema.marks.text_color, "color", color);
 }
-function makeSetHighlight(schema, color) {
+
+export function makeSetHighlight(schema: Schema, color: string | null): Command {
   return makeSetValueMark(schema.marks.highlight, "color", color);
 }
-function makeSetAlignment(schema, alignment) {
+
+// ---------------------------------------------------------------------------
+// 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 {
   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, void 0, { ...node.attrs, alignment });
+        tr.setNodeMarkup(pos, undefined, { ...node.attrs, alignment });
         applied = true;
       }
     });
+
     if (!applied) return false;
     dispatch(tr);
     return true;
   };
 }
-function isMarkActive(schema, markName, state) {
+
+// ---------------------------------------------------------------------------
+// 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 {
   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)) {
@@ -85,116 +178,180 @@ function isMarkActive(schema, markName, state) {
   });
   return active;
 }
-var DEFAULT_FORMATTING_STATE = {
+
+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 = {
   bold: false,
   italic: false,
   underline: false,
   strikethrough: false,
   superscript: false,
   subscript: false,
-  breadcrumb: []
+  breadcrumb: [],
 };
-var INDENT_STEP_TWIPS = 720;
-function getFormattingStateFromRenderSnapshot(snapshot) {
+
+const INDENT_STEP_TWIPS = 720;
+
+export function getFormattingStateFromRenderSnapshot(
+  snapshot: RuntimeRenderSnapshot,
+): FormattingStateSnapshot {
   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 : void 0;
+      return typeof size === "number" ? size / 2 : undefined;
     }),
-    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, selection) {
+
+function getSelectionBreadcrumb(
+  blocks: SurfaceBlockSnapshot[],
+  selection: RuntimeRenderSnapshot["selection"],
+): FormattingBreadcrumbItem[] {
   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, selection, path = [], output = []) {
+
+function collectSelectionBreadcrumbPaths(
+  blocks: SurfaceBlockSnapshot[],
+  selection: RuntimeRenderSnapshot["selection"],
+  path: FormattingBreadcrumbItem[] = [],
+  output: FormattingBreadcrumbItem[][] = [],
+): FormattingBreadcrumbItem[][] {
   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",
+          kind: "paragraph" as const,
           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",
+          kind: "opaque_block" as const,
           label: block.label,
           from: block.from,
-          to: block.to
-        }
+          to: block.to,
+        },
       ]);
       continue;
     }
+
     if (block.kind === "sdt_block") {
       collectSelectionBreadcrumbPaths(
         block.children,
@@ -202,63 +359,72 @@ function collectSelectionBreadcrumbPaths(blocks, selection, path = [], output =
         [
           ...path,
           {
-            kind: "sdt_block",
+            kind: "sdt_block" as const,
             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",
+          kind: "table" as const,
           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",
+            kind: "table_row" as const,
             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,
@@ -268,113 +434,169 @@ function collectSelectionBreadcrumbPaths(blocks, selection, path = [], output =
                 kind: "table_cell",
                 label: `Cell ${cellIndex + 1}`,
                 from: cellRange.from,
-                to: cellRange.to
-              }
+                to: cellRange.to,
+              },
             ],
-            output
+            output,
           );
         }
       }
     }
   }
+
   return output;
 }
-function getTableRowRange(table, row) {
+
+function getTableRowRange(
+  table: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+  row: (typeof table.rows)[number],
+): { from: number; to: number } {
   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, cell) {
+
+function getTableCellRange(
+  table: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+  cell: SurfaceTableCellSnapshot,
+): { from: number; to: number } {
   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, right) {
-  return left.kind === right.kind && left.label === right.label && left.from === right.from && left.to === right.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 applyFormattingOperationToDocument(document, snapshot, operation) {
+
+export function applyFormattingOperationToDocument(
+  document: CanonicalDocumentEnvelope,
+  snapshot: RuntimeRenderSnapshot,
+  operation: FormattingOperation,
+): FormattingMutationResult {
   const surface = snapshot.surface;
   if (!surface) {
     return {
       document,
       selection: snapshot.selection,
-      changed: false
+      changed: false,
     };
   }
+
   const nextDocument = structuredClone(document);
-  const root = nextDocument.content;
+  const root = nextDocument.content as DocumentRootNode;
   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, operation) {
+
+function resolveMarkUpdater(
+  snapshot: RuntimeRenderSnapshot,
+  operation: Exclude<
+    FormattingOperation,
+    { type: "set-alignment" } | { type: "indent" } | { type: "outdent" }
+  >,
+): (marks?: TextMark[]) => TextMark[] | undefined {
   const formatting = getFormattingStateFromRenderSnapshot(snapshot);
+
   switch (operation.type) {
     case "toggle":
       return (marks) => toggleMarks(marks, operation.mark, !formatting[operation.mark]);
@@ -388,49 +610,65 @@ function resolveMarkUpdater(snapshot, operation) {
       return (marks) => setMarkValue(marks, "backgroundColor", sanitizeColor(operation.color));
   }
 }
-function applyAlignment(paragraph, alignment) {
+
+function applyAlignment(
+  paragraph: ParagraphNode,
+  alignment: FormattingAlignment,
+): boolean {
   const nextAlignment = alignment === "justify" ? "both" : alignment;
   if (paragraph.alignment === nextAlignment) {
     return false;
   }
+
   paragraph.alignment = nextAlignment;
   return true;
 }
-function applyIndentation(paragraph, delta) {
+
+function applyIndentation(paragraph: ParagraphNode, delta: -1 | 1): boolean {
   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 : void 0;
+    paragraph.indentation =
+      Object.keys(nextIndentation).length > 0 ? nextIndentation : undefined;
   }
+
   return true;
 }
-function collectParagraphSurfaces(blocks, output = []) {
+
+function collectParagraphSurfaces(
+  blocks: SurfaceBlockSnapshot[],
+  output: ParagraphSurfaceBlock[] = [],
+): ParagraphSurfaceBlock[] {
   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) {
@@ -439,45 +677,72 @@ function collectParagraphSurfaces(blocks, output = []) {
       }
       continue;
     }
+
     if (block.kind === "sdt_block") {
       collectParagraphSurfaces(block.children, output);
     }
   }
+
   return output;
 }
-function collectFormattingTextSegments(paragraphs, selection) {
+
+function collectFormattingTextSegments(
+  paragraphs: ParagraphSurfaceBlock[],
+  selection: RuntimeRenderSnapshot["selection"],
+): Array<Extract<SurfaceInlineSegment, { kind: "text" }>> {
   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 = [];
+  const segments: Array<Extract<SurfaceInlineSegment, { kind: "text" }>> = [];
+
   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.kind === "text" && segment.to === caret
+      (segment): segment is Extract<SurfaceInlineSegment, { kind: "text" }> =>
+        segment.kind === "text" && segment.to === caret,
     );
     if (fallback) {
       return [fallback];
     }
   }
+
   return [];
 }
-function segmentContainsCaret(segment, caret) {
-  return segment.from <= caret && (caret < segment.to || segment.to === caret && segment.to > segment.from);
+
+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 segmentHasMark(segment, mark) {
+
+function segmentHasMark(
+  segment: Extract<SurfaceInlineSegment, { kind: "text" }>,
+  mark: ToggleFormattingMark,
+): boolean {
   const marks = segment.marks ?? [];
   if (mark === "superscript") {
     return marks.includes("superscript");
@@ -487,12 +752,21 @@ function segmentHasMark(segment, mark) {
   }
   return marks.includes(mark);
 }
-function getConsistentValue(items, getter, options = {}) {
+
+function getConsistentValue<TItem, TValue>(
+  items: readonly TItem[],
+  getter: (item: TItem) => TValue,
+  options: {
+    emptyFallback?: TValue;
+  } = {},
+): TValue | undefined {
   if (items.length === 0) {
     return options.emptyFallback;
   }
-  let value = void 0;
+
+  let value: TValue | undefined = undefined;
   let initialized = false;
+
   for (const item of items) {
     const next = getter(item);
     if (!initialized) {
@@ -500,23 +774,32 @@ function getConsistentValue(items, getter, options = {}) {
       initialized = true;
       continue;
     }
+
     if (next !== value) {
-      return void 0;
+      return undefined;
     }
   }
+
   return value;
 }
-function visitParagraphBindings(blocks, surfaceBlocks, visitor) {
+
+function visitParagraphBindings(
+  blocks: BlockNode[],
+  surfaceBlocks: SurfaceBlockSnapshot[],
+  visitor: (paragraph: ParagraphNode, surface: ParagraphSurfaceBlock) => void,
+): void {
   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];
@@ -524,26 +807,41 @@ function visitParagraphBindings(blocks, surfaceBlocks, visitor) {
         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, start, selectionFrom, selectionTo, updateMarks) {
+
+function transformInlineNodes(
+  nodes: InlineNode[],
+  start: number,
+  selectionFrom: number,
+  selectionTo: number,
+  updateMarks: (marks?: TextMark[]) => TextMark[] | undefined,
+): { nodes: InlineNode[]; changed: boolean; nextPosition: number } {
   let changed = false;
   let position = start;
-  const nextNodes = [];
+  const nextNodes: InlineNode[] = [];
+
   for (const node of nodes) {
     if (node.type === "text") {
       const transformed = transformTextNode(
@@ -551,141 +849,178 @@ function transformInlineNodes(nodes, start, selectionFrom, selectionTo, updateMa
         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,
+        node.children as InlineNode[],
         position,
         selectionFrom,
         selectionTo,
-        updateMarks
+        updateMarks,
       );
       nextNodes.push(
-        transformed.changed ? {
-          ...node,
-          children: transformed.nodes
-        } : node
+        transformed.changed
+          ? {
+              ...node,
+              children: transformed.nodes as typeof node.children,
+            }
+          : 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, start, selectionFrom, selectionTo, updateMarks) {
+
+function transformTextNode(
+  node: TextNode,
+  start: number,
+  selectionFrom: number,
+  selectionTo: number,
+  updateMarks: (marks?: TextMark[]) => TextMark[] | undefined,
+): { nodes: TextNode[]; changed: boolean; nextPosition: number } {
   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 = [];
+  const nextNodes: TextNode[] = [];
+
   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, marks) {
+
+function createTextNode(text: string, marks?: TextMark[]): TextNode {
   return {
     type: "text",
     text,
-    ...marks && marks.length > 0 ? { marks: cloneMarks(marks) } : {}
+    ...(marks && marks.length > 0 ? { marks: cloneMarks(marks) } : {}),
   };
 }
-function toggleMarks(marks, mark, enabled) {
+
+function toggleMarks(
+  marks: TextMark[] | undefined,
+  mark: ToggleFormattingMark,
+  enabled: boolean,
+): TextMark[] | undefined {
   const nextMarks = cloneMarks(marks);
+
   if (mark === "superscript" || mark === "subscript") {
-    const filtered2 = nextMarks.filter((candidate) => candidate.type !== "position");
+    const filtered: TextMark[] = nextMarks.filter((candidate) => candidate.type !== "position");
     if (enabled) {
-      filtered2.push({
+      filtered.push({
         type: "position",
-        val: mark === "superscript" ? 1 : -1
+        val: mark === "superscript" ? 1 : -1,
       });
     }
-    return filtered2.length > 0 ? filtered2 : void 0;
+    return filtered.length > 0 ? filtered : undefined;
   }
+
   const filtered = nextMarks.filter((candidate) => candidate.type !== mark);
   if (enabled) {
     filtered.push({ type: mark });
   }
-  return filtered.length > 0 ? filtered : void 0;
+  return filtered.length > 0 ? filtered : undefined;
 }
-function setMarkValue(marks, markType, value) {
+
+function setMarkValue(
+  marks: TextMark[] | undefined,
+  markType: "fontFamily" | "fontSize" | "textColor" | "backgroundColor",
+  value: string | number | null,
+): TextMark[] | undefined {
   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 });
+        nextMarks.push({ type: "fontFamily", val: value as string });
         break;
       case "fontSize":
-        nextMarks.push({ type: "fontSize", val: value });
+        nextMarks.push({ type: "fontSize", val: value as number });
         break;
       case "textColor":
-        nextMarks.push({ type: "textColor", color: value });
+        nextMarks.push({ type: "textColor", color: value as string });
         break;
       case "backgroundColor":
-        nextMarks.push({ type: "backgroundColor", color: value });
+        nextMarks.push({ type: "backgroundColor", color: value as string });
         break;
     }
   }
-  return nextMarks.length > 0 ? nextMarks : void 0;
+
+  return nextMarks.length > 0 ? nextMarks : undefined;
 }
-function cloneMarks(marks) {
+
+function cloneMarks(marks?: TextMark[]): TextMark[] {
   return marks ? marks.map((mark) => ({ ...mark })) : [];
 }
-function marksEqual(left, right) {
+
+function marksEqual(left?: TextMark[], right?: TextMark[]): boolean {
   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) {
+
+function inlineNodeLength(node: InlineNode): number {
   switch (node.type) {
     case "text":
       return Array.from(node.text).length;
     case "hyperlink":
-      return node.children.reduce(
-        (total, child) => total + inlineNodeLength(child),
-        0
+      return node.children.reduce< number >(
+        (total, child) => total + inlineNodeLength(child as InlineNode),
+        0,
       );
     case "hard_break":
     case "column_break":
@@ -701,16 +1036,19 @@ function inlineNodeLength(node) {
     case "vml_shape":
       return 1;
     case "field":
-      return node.children.reduce(
-        (total, child) => total + inlineNodeLength(child),
-        0
+      return node.children.reduce<number>(
+        (total, child) => total + inlineNodeLength(child as InlineNode),
+        0,
       );
     case "bookmark_start":
     case "bookmark_end":
       return 0;
   }
 }
-function toPublicAlignment(alignment) {
+
+function toPublicAlignment(
+  alignment: ParagraphNode["alignment"] | undefined,
+): FormattingAlignment | undefined {
   switch (alignment) {
     case "both":
     case "distribute":
@@ -720,34 +1058,49 @@ function toPublicAlignment(alignment) {
     case "right":
       return alignment;
     default:
-      return void 0;
+      return undefined;
   }
 }
-function toPublicColor(color) {
+
+function toPublicColor(color: string | undefined): string | undefined {
   if (!color) {
-    return void 0;
+    return undefined;
   }
-  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) {
+
+function sanitizeFontFamily(fontFamily: string | null): string | null {
   const normalized = fontFamily?.trim();
   return normalized ? normalized : null;
 }
-function sanitizeFontSize(size) {
+
+function sanitizeFontSize(size: number | null): number | null {
   if (typeof size !== "number" || !Number.isFinite(size) || size <= 0) {
     return null;
   }
+
   return Math.round(size * 2);
 }
-function sanitizeColor(color) {
+
+function sanitizeColor(color: string | null): string | null {
   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, head, rangeFrom, rangeTo) {
+
+function selectionTouchesRange(
+  anchor: number,
+  head: number,
+  rangeFrom: number,
+  rangeTo: number,
+): boolean {
   const selectionFrom = Math.min(anchor, head);
   const selectionTo = Math.max(anchor, head);
   if (selectionFrom === selectionTo) {
@@ -755,7 +1108,13 @@ function selectionTouchesRange(anchor, head, rangeFrom, rangeTo) {
   }
   return rangesOverlap(selectionFrom, selectionTo, rangeFrom, rangeTo);
 }
-function rangesOverlap(leftFrom, leftTo, rightFrom, rightTo) {
+
+function rangesOverlap(
+  leftFrom: number,
+  leftTo: number,
+  rightFrom: number,
+  rightTo: number,
+): boolean {
   if (leftFrom === leftTo) {
     return leftFrom >= rightFrom && leftFrom <= rightTo;
   }
@@ -764,26 +1123,7 @@ function rangesOverlap(leftFrom, leftTo, rightFrom, rightTo) {
   }
   return leftFrom < rightTo && leftTo > rightFrom;
 }
-function clamp(value, min, max) {
+
+function clamp(value: number, min: number, max: number): number {
   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