@beyondwork/docx-react-component 1.0.29 → 1.0.31

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

@@ -1,828 +0,0 @@
-"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