@beyondwork/docx-react-component 1.0.27 → 1.0.29

package/dist/core/commands/formatting-commands.cjs

@@ -0,0 +1,828 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/commands/formatting-commands.ts
+var formatting_commands_exports = {};
+__export(formatting_commands_exports, {
+  applyFormattingOperationToDocument: () => applyFormattingOperationToDocument,
+  getFormattingStateFromRenderSnapshot: () => getFormattingStateFromRenderSnapshot,
+  isMarkActive: () => isMarkActive,
+  makeSetAlignment: () => makeSetAlignment,
+  makeSetFontFamily: () => makeSetFontFamily,
+  makeSetFontSize: () => makeSetFontSize,
+  makeSetHighlight: () => makeSetHighlight,
+  makeSetTextColor: () => makeSetTextColor,
+  makeToggleAllCaps: () => makeToggleAllCaps,
+  makeToggleBold: () => makeToggleBold,
+  makeToggleItalic: () => makeToggleItalic,
+  makeToggleSmallCaps: () => makeToggleSmallCaps,
+  makeToggleStrikethrough: () => makeToggleStrikethrough,
+  makeToggleSubscript: () => makeToggleSubscript,
+  makeToggleSuperscript: () => makeToggleSuperscript,
+  makeToggleUnderline: () => makeToggleUnderline
+});
+module.exports = __toCommonJS(formatting_commands_exports);
+var import_prosemirror_commands = require("prosemirror-commands");
+function makeToggleBold(schema) {
+  return (0, import_prosemirror_commands.toggleMark)(schema.marks.bold);
+}
+function makeToggleItalic(schema) {
+  return (0, import_prosemirror_commands.toggleMark)(schema.marks.italic);
+}
+function makeToggleUnderline(schema) {
+  return (0, import_prosemirror_commands.toggleMark)(schema.marks.underline);
+}
+function makeToggleStrikethrough(schema) {
+  return (0, import_prosemirror_commands.toggleMark)(schema.marks.strikethrough);
+}
+function makeToggleSuperscript(schema) {
+  return (0, import_prosemirror_commands.toggleMark)(schema.marks.superscript);
+}
+function makeToggleSubscript(schema) {
+  return (0, import_prosemirror_commands.toggleMark)(schema.marks.subscript);
+}
+function makeToggleSmallCaps(schema) {
+  return (0, import_prosemirror_commands.toggleMark)(schema.marks.small_caps);
+}
+function makeToggleAllCaps(schema) {
+  return (0, import_prosemirror_commands.toggleMark)(schema.marks.all_caps);
+}
+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);
+    } else {
+      const mark = markType.create({ [attrKey]: value });
+      tr.addMark(from, to, mark);
+    }
+    dispatch(tr);
+    return true;
+  };
+}
+function makeSetFontFamily(schema, family) {
+  return makeSetValueMark(schema.marks.font_family, "family", family);
+}
+function makeSetFontSize(schema, size) {
+  return makeSetValueMark(schema.marks.font_size, "size", size);
+}
+function makeSetTextColor(schema, color) {
+  return makeSetValueMark(schema.marks.text_color, "color", color);
+}
+function makeSetHighlight(schema, color) {
+  return makeSetValueMark(schema.marks.highlight, "color", color);
+}
+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, void 0, { ...node.attrs, alignment });
+        applied = true;
+      }
+    });
+    if (!applied) return false;
+    dispatch(tr);
+    return true;
+  };
+}
+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)) {
+      active = false;
+      return false;
+    }
+  });
+  return active;
+}
+var DEFAULT_FORMATTING_STATE = {
+  bold: false,
+  italic: false,
+  underline: false,
+  strikethrough: false,
+  superscript: false,
+  subscript: false,
+  breadcrumb: []
+};
+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(
+      snapshot.selection.anchor,
+      snapshot.selection.head,
+      paragraph.from,
+      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,
+    fontFamily: getConsistentValue(textSegments, (segment) => segment.markAttrs?.fontFamily),
+    fontSize: getConsistentValue(textSegments, (segment) => {
+      const size = segment.markAttrs?.fontSize;
+      return typeof size === "number" ? size / 2 : void 0;
+    }),
+    textColor: getConsistentValue(
+      textSegments,
+      (segment) => toPublicColor(segment.markAttrs?.textColor)
+    ),
+    highlightColor: getConsistentValue(
+      textSegments,
+      (segment) => toPublicColor(segment.markAttrs?.backgroundColor) ?? null,
+      {
+        emptyFallback: null
+      }
+    ),
+    alignment: getConsistentValue(
+      paragraphs,
+      (paragraph) => toPublicAlignment(paragraph.alignment)
+    ),
+    paragraphStyleId: getConsistentValue(paragraphs, (paragraph) => paragraph.styleId),
+    breadcrumb: getSelectionBreadcrumb(surface.blocks, snapshot.selection)
+  };
+}
+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])) {
+      compareIndex += 1;
+    }
+    commonLength = compareIndex;
+  }
+  return paths[0].slice(0, commonLength);
+}
+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
+    )) {
+      continue;
+    }
+    if (block.kind === "paragraph") {
+      output.push([
+        ...path,
+        {
+          kind: "paragraph",
+          label: block.styleId ? `Paragraph (${block.styleId})` : "Paragraph",
+          from: block.from,
+          to: block.to
+        }
+      ]);
+      continue;
+    }
+    if (block.kind === "opaque_block") {
+      output.push([
+        ...path,
+        {
+          kind: "opaque_block",
+          label: block.label,
+          from: block.from,
+          to: block.to
+        }
+      ]);
+      continue;
+    }
+    if (block.kind === "sdt_block") {
+      collectSelectionBreadcrumbPaths(
+        block.children,
+        selection,
+        [
+          ...path,
+          {
+            kind: "sdt_block",
+            label: block.alias ?? block.tag ?? block.sdtType ?? "Content control",
+            from: block.from,
+            to: block.to
+          }
+        ],
+        output
+      );
+      continue;
+    }
+    if (block.kind === "table") {
+      const tablePath = [
+        ...path,
+        {
+          kind: "table",
+          label: block.styleId ? `Table (${block.styleId})` : "Table",
+          from: block.from,
+          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
+        )) {
+          continue;
+        }
+        const rowPath = [
+          ...tablePath,
+          {
+            kind: "table_row",
+            label: `Row ${rowIndex + 1}`,
+            from: rowRange.from,
+            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
+          )) {
+            continue;
+          }
+          collectSelectionBreadcrumbPaths(
+            cell.content,
+            selection,
+            [
+              ...rowPath,
+              {
+                kind: "table_cell",
+                label: `Cell ${cellIndex + 1}`,
+                from: cellRange.from,
+                to: cellRange.to
+              }
+            ],
+            output
+          );
+        }
+      }
+    }
+  }
+  return output;
+}
+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 };
+}
+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 };
+}
+function breadcrumbItemsEqual(left, right) {
+  return left.kind === right.kind && left.label === right.label && left.from === right.from && left.to === right.to;
+}
+function applyFormattingOperationToDocument(document, snapshot, operation) {
+  const surface = snapshot.surface;
+  if (!surface) {
+    return {
+      document,
+      selection: snapshot.selection,
+      changed: false
+    };
+  }
+  const nextDocument = structuredClone(document);
+  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
+      )) {
+        return;
+      }
+      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
+    };
+  }
+  if (selectionFrom === selectionTo) {
+    return {
+      document,
+      selection: snapshot.selection,
+      changed: false
+    };
+  }
+  const nextMarks = resolveMarkUpdater(snapshot, operation);
+  visitParagraphBindings(root.children, surface.blocks, (paragraph, paragraphSurface) => {
+    if (!rangesOverlap(
+      selectionFrom,
+      selectionTo,
+      paragraphSurface.from,
+      paragraphSurface.to
+    )) {
+      return;
+    }
+    const transformed = transformInlineNodes(
+      paragraph.children,
+      paragraphSurface.from,
+      selectionFrom,
+      selectionTo,
+      nextMarks
+    );
+    if (!transformed.changed) {
+      return;
+    }
+    paragraph.children = transformed.nodes;
+    changed = true;
+  });
+  return {
+    document: changed ? nextDocument : document,
+    selection: snapshot.selection,
+    changed
+  };
+}
+function resolveMarkUpdater(snapshot, operation) {
+  const formatting = getFormattingStateFromRenderSnapshot(snapshot);
+  switch (operation.type) {
+    case "toggle":
+      return (marks) => toggleMarks(marks, operation.mark, !formatting[operation.mark]);
+    case "set-font-family":
+      return (marks) => setMarkValue(marks, "fontFamily", sanitizeFontFamily(operation.fontFamily));
+    case "set-font-size":
+      return (marks) => setMarkValue(marks, "fontSize", sanitizeFontSize(operation.size));
+    case "set-text-color":
+      return (marks) => setMarkValue(marks, "textColor", sanitizeColor(operation.color));
+    case "set-highlight-color":
+      return (marks) => setMarkValue(marks, "backgroundColor", sanitizeColor(operation.color));
+  }
+}
+function applyAlignment(paragraph, alignment) {
+  const nextAlignment = alignment === "justify" ? "both" : alignment;
+  if (paragraph.alignment === nextAlignment) {
+    return false;
+  }
+  paragraph.alignment = nextAlignment;
+  return true;
+}
+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
+    };
+    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 ?? {}
+  };
+  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;
+  }
+  return true;
+}
+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) {
+          collectParagraphSurfaces(cell.content, output);
+        }
+      }
+      continue;
+    }
+    if (block.kind === "sdt_block") {
+      collectParagraphSurfaces(block.children, output);
+    }
+  }
+  return output;
+}
+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 = [];
+  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)) {
+        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
+    );
+    if (fallback) {
+      return [fallback];
+    }
+  }
+  return [];
+}
+function segmentContainsCaret(segment, caret) {
+  return segment.from <= caret && (caret < segment.to || segment.to === caret && segment.to > segment.from);
+}
+function segmentHasMark(segment, mark) {
+  const marks = segment.marks ?? [];
+  if (mark === "superscript") {
+    return marks.includes("superscript");
+  }
+  if (mark === "subscript") {
+    return marks.includes("subscript");
+  }
+  return marks.includes(mark);
+}
+function getConsistentValue(items, getter, options = {}) {
+  if (items.length === 0) {
+    return options.emptyFallback;
+  }
+  let value = void 0;
+  let initialized = false;
+  for (const item of items) {
+    const next = getter(item);
+    if (!initialized) {
+      value = next;
+      initialized = true;
+      continue;
+    }
+    if (next !== value) {
+      return void 0;
+    }
+  }
+  return value;
+}
+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];
+        const surfaceRow = surface.rows[rowIndex];
+        if (!row || !surfaceRow) {
+          continue;
+        }
+        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) {
+  let changed = false;
+  let position = start;
+  const nextNodes = [];
+  for (const node of nodes) {
+    if (node.type === "text") {
+      const transformed = transformTextNode(
+        node,
+        position,
+        selectionFrom,
+        selectionTo,
+        updateMarks
+      );
+      nextNodes.push(...transformed.nodes);
+      position = transformed.nextPosition;
+      changed = changed || transformed.changed;
+      continue;
+    }
+    if (node.type === "hyperlink") {
+      const transformed = transformInlineNodes(
+        node.children,
+        position,
+        selectionFrom,
+        selectionTo,
+        updateMarks
+      );
+      nextNodes.push(
+        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
+  };
+}
+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
+    };
+  }
+  const localFrom = overlapFrom - start;
+  const localTo = overlapTo - start;
+  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)
+  );
+  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
+  };
+}
+function createTextNode(text, marks) {
+  return {
+    type: "text",
+    text,
+    ...marks && marks.length > 0 ? { marks: cloneMarks(marks) } : {}
+  };
+}
+function toggleMarks(marks, mark, enabled) {
+  const nextMarks = cloneMarks(marks);
+  if (mark === "superscript" || mark === "subscript") {
+    const filtered2 = nextMarks.filter((candidate) => candidate.type !== "position");
+    if (enabled) {
+      filtered2.push({
+        type: "position",
+        val: mark === "superscript" ? 1 : -1
+      });
+    }
+    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 : void 0;
+}
+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 });
+        break;
+      case "fontSize":
+        nextMarks.push({ type: "fontSize", val: value });
+        break;
+      case "textColor":
+        nextMarks.push({ type: "textColor", color: value });
+        break;
+      case "backgroundColor":
+        nextMarks.push({ type: "backgroundColor", color: value });
+        break;
+    }
+  }
+  return nextMarks.length > 0 ? nextMarks : void 0;
+}
+function cloneMarks(marks) {
+  return marks ? marks.map((mark) => ({ ...mark })) : [];
+}
+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) {
+  switch (node.type) {
+    case "text":
+      return Array.from(node.text).length;
+    case "hyperlink":
+      return node.children.reduce(
+        (total, child) => total + inlineNodeLength(child),
+        0
+      );
+    case "hard_break":
+    case "column_break":
+    case "tab":
+    case "symbol":
+    case "image":
+    case "opaque_inline":
+    case "footnote_ref":
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape":
+      return 1;
+    case "field":
+      return node.children.reduce(
+        (total, child) => total + inlineNodeLength(child),
+        0
+      );
+    case "bookmark_start":
+    case "bookmark_end":
+      return 0;
+  }
+}
+function toPublicAlignment(alignment) {
+  switch (alignment) {
+    case "both":
+    case "distribute":
+      return "justify";
+    case "left":
+    case "center":
+    case "right":
+      return alignment;
+    default:
+      return void 0;
+  }
+}
+function toPublicColor(color) {
+  if (!color) {
+    return void 0;
+  }
+  return /^[0-9A-F]{3,8}$/iu.test(color) ? `#${color.toUpperCase()}` : color;
+}
+function sanitizeFontFamily(fontFamily) {
+  const normalized = fontFamily?.trim();
+  return normalized ? normalized : null;
+}
+function sanitizeFontSize(size) {
+  if (typeof size !== "number" || !Number.isFinite(size) || size <= 0) {
+    return null;
+  }
+  return Math.round(size * 2);
+}
+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, head, rangeFrom, rangeTo) {
+  const selectionFrom = Math.min(anchor, head);
+  const selectionTo = Math.max(anchor, head);
+  if (selectionFrom === selectionTo) {
+    return selectionFrom >= rangeFrom && selectionFrom <= rangeTo;
+  }
+  return rangesOverlap(selectionFrom, selectionTo, rangeFrom, rangeTo);
+}
+function rangesOverlap(leftFrom, leftTo, rightFrom, rightTo) {
+  if (leftFrom === leftTo) {
+    return leftFrom >= rightFrom && leftFrom <= rightTo;
+  }
+  if (rightFrom === rightTo) {
+    return rightFrom >= leftFrom && rightFrom <= leftTo;
+  }
+  return leftFrom < rightTo && leftTo > rightFrom;
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyFormattingOperationToDocument,
+  getFormattingStateFromRenderSnapshot,
+  isMarkActive,
+  makeSetAlignment,
+  makeSetFontFamily,
+  makeSetFontSize,
+  makeSetHighlight,
+  makeSetTextColor,
+  makeToggleAllCaps,
+  makeToggleBold,
+  makeToggleItalic,
+  makeToggleSmallCaps,
+  makeToggleStrikethrough,
+  makeToggleSubscript,
+  makeToggleSuperscript,
+  makeToggleUnderline
+});
+//# sourceMappingURL=formatting-commands.cjs.map