@beyondwork/docx-react-component 1.0.128 → 1.0.129

package/dist/{chunk-LCYYR57Q.js → chunk-XQCAMKIQ.js}

@@ -9,6 +9,7 @@ import {
   enumerateScopes,
   findParagraphByBlockId,
   getAIActionPolicy,
+  getListKind,
   parseCanonicalFragmentFromWordML,
   resolveDirectRunFormattingAtSegment,
   resolveEditableTableStructureTarget,
@@ -17,7 +18,7 @@ import {
   resolveScopeRange,
   scopeSpecificity,
   searchDocument
-} from "./chunk-XRACP43Q.js";
+} from "./chunk-SKPTKQHF.js";
 import {
   BROADCAST_COMMAND_TYPES,
   COMMAND_EVENT_SCHEMA_VERSION,
@@ -36,23 +37,24 @@ import {
   LAYCACHE_SCHEMA_VERSION,
   LAYOUT_ENGINE_VERSION,
   createScopeTagRegistry
-} from "./chunk-YHZHPXDB.js";
+} from "./chunk-RMRTQGW3.js";
 import {
   chartModelStore,
   createFormattingContext
-} from "./chunk-CXSYRB37.js";
+} from "./chunk-HUIHBBAQ.js";
 import {
+  createSelectionSnapshot,
   deriveDocumentStats
 } from "./chunk-OYGMRRR7.js";
 import {
   DocxSession
-} from "./chunk-TQDQU2E3.js";
+} from "./chunk-63FYIGCT.js";
 import {
   WORKFLOW_PAYLOAD_PART_PATH,
   buildEditorStateXml,
   parseEditorStateXml,
   parseWorkflowPayloadEnvelopeFromPackage
-} from "./chunk-V6XVZFFH.js";
+} from "./chunk-XMHSGPLN.js";
 import {
   EMU_PER_PX,
   GRADIENT_STOP_UNITS,
@@ -864,6 +866,10 @@ function extractNLHaystack(entry) {
       }
       return out.slice(0, 200).toLowerCase();
     }
+    case "image": {
+      const text = entry.image.type === "image" ? entry.image.altText ?? "" : entry.image.anchor.docPr?.descr ?? entry.image.anchor.docPr?.name ?? "";
+      return text.slice(0, 200).toLowerCase();
+    }
     case "table":
     case "table-row":
     case "table-cell":
@@ -3993,6 +3999,391 @@ function createViewportFamily(runtime) {
   };
 }
 
+// src/api/v3/runtime/lists.ts
+var SUPPORTED_COMMANDS = [
+  "toggle-numbered",
+  "toggle-bulleted",
+  "indent",
+  "outdent",
+  "restart-numbering",
+  "continue-numbering"
+];
+var UNSUPPORTED_COMMANDS = [
+  "create",
+  "attach",
+  "detach",
+  "join",
+  "separate",
+  "split",
+  "set-value",
+  "apply-template",
+  "capture-template",
+  "apply-preset",
+  "set-level-numbering",
+  "set-level-bullet",
+  "set-level-picture-bullet",
+  "set-level-alignment",
+  "set-level-indents",
+  "set-level-trailing-character",
+  "set-level-marker-font",
+  "set-level-text",
+  "set-level-start",
+  "set-level-layout",
+  "convert-to-text",
+  "paste-fragment",
+  "drop-fragment"
+];
+var applyCommandMetadata = {
+  name: "runtime.lists.applyCommand",
+  status: "live-with-adapter",
+  sourceLayer: "runtime-core",
+  liveEvidence: {
+    runnerTest: "test/api/v3/runtime/lists.test.ts",
+    commit: "refactor-07-runtime-lists-namespace"
+  },
+  uxIntent: {
+    uiVisible: true,
+    expectsUxResponse: "surface-refresh",
+    expectedDelta: "list structure changes through the L07 list command surface"
+  },
+  agentMetadata: { readOrMutate: "mutate", boundedScope: "scope", auditCategory: "list-command" },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  broadcastsVia: "crdt",
+  rwdReference: "\xA7Runtime API \xA7 runtime.lists.applyCommand. Dispatches only proven L07 list commands through opaque list targets; future commands return owner-routed blockers until command/export/readback support lands."
+};
+function createListsFamily(runtime) {
+  return {
+    list(input = {}) {
+      const document = runtime.getCanonicalDocument();
+      const rows = currentListTargets(document).filter((entry) => input.storyKey === void 0 || entry.target.storyKey === input.storyKey).map((entry) => toReadback(document, entry.target, entry.paragraph));
+      return input.limit === void 0 ? rows : rows.slice(0, Math.max(0, input.limit));
+    },
+    get(input) {
+      const resolved = resolveCurrentListTarget(runtime.getCanonicalDocument(), input);
+      return resolved.kind === "resolved" ? toReadback(runtime.getCanonicalDocument(), resolved.target, resolved.paragraph) : null;
+    },
+    previewCommand(input) {
+      return previewListCommand(runtime.getCanonicalDocument(), input);
+    },
+    applyCommand(input) {
+      const preview = previewListCommand(runtime.getCanonicalDocument(), input);
+      if (!preview.supported || !preview.target) {
+        return {
+          applied: false,
+          command: input.command,
+          before: preview.target,
+          blockers: preview.blockers
+        };
+      }
+      const resolved = resolveCurrentListTarget(runtime.getCanonicalDocument(), {
+        addressKey: preview.target.addressKey
+      });
+      if (resolved.kind !== "resolved") {
+        return {
+          applied: false,
+          command: input.command,
+          before: preview.target,
+          blockers: [resolved.blocker]
+        };
+      }
+      const command = editorCommandForListCommand(
+        input.command,
+        resolved.target,
+        runtime.now(),
+        input.startAt
+      );
+      if (!command) {
+        return {
+          applied: false,
+          command: input.command,
+          before: preview.target,
+          blockers: [
+            unsupportedCommandBlocker(input.command, {
+              targetKey: preview.target.targetKey,
+              addressKey: preview.target.addressKey
+            })
+          ]
+        };
+      }
+      const beforeDocument = runtime.getCanonicalDocument();
+      runtime.dispatch(command);
+      const afterDocument = runtime.getCanonicalDocument();
+      const after = resolveCurrentListTarget(afterDocument, { targetKey: preview.target.targetKey });
+      emitUxResponse(runtime, {
+        apiFn: applyCommandMetadata.name,
+        intent: applyCommandMetadata.uxIntent.expectedDelta ?? "",
+        mockOrLive: "live",
+        uiVisible: true,
+        expectedDelta: applyCommandMetadata.uxIntent.expectedDelta
+      });
+      return {
+        applied: beforeDocument !== afterDocument,
+        command: input.command,
+        before: preview.target,
+        ...after.kind === "resolved" ? { after: toReadback(afterDocument, after.target, after.paragraph) } : {},
+        blockers: []
+      };
+    }
+  };
+}
+function previewListCommand(document, input) {
+  const resolved = resolveCurrentListTarget(document, input);
+  if (resolved.kind !== "resolved") {
+    return {
+      command: input.command,
+      supported: false,
+      affectedTargets: [],
+      blockers: [resolved.blocker]
+    };
+  }
+  const target = toReadback(document, resolved.target, resolved.paragraph);
+  const targetRef = { targetKey: target.targetKey, addressKey: target.addressKey };
+  if (!SUPPORTED_COMMANDS.includes(input.command)) {
+    return {
+      command: input.command,
+      supported: false,
+      target,
+      affectedTargets: [target],
+      blockers: [unsupportedCommandBlocker(input.command, targetRef)]
+    };
+  }
+  const canContinuePrevious = canContinuePreviousSequence(document, resolved.paragraphIndex);
+  const canJoin = canJoinPreviousSequence(document, resolved.paragraphIndex);
+  const blockers = [];
+  if (input.command === "continue-numbering" && !canContinuePrevious) {
+    blockers.push({
+      code: "list-continue-target-missing",
+      ownerLayer: "L07",
+      message: "No previous compatible list sequence is available for continue-numbering.",
+      ...targetRef
+    });
+  }
+  return {
+    command: input.command,
+    supported: blockers.length === 0,
+    target,
+    affectedTargets: [target],
+    blockers,
+    canJoin,
+    canContinuePrevious
+  };
+}
+function editorCommandForListCommand(command, editableTarget, timestamp, startAt) {
+  const origin = { source: "api", timestamp };
+  switch (command) {
+    case "toggle-numbered":
+      return { type: "list.toggle", kind: "numbered", editableTargets: [editableTarget], origin };
+    case "toggle-bulleted":
+      return { type: "list.toggle", kind: "bulleted", editableTargets: [editableTarget], origin };
+    case "indent":
+      return { type: "list.indent", editableTargets: [editableTarget], origin };
+    case "outdent":
+      return { type: "list.outdent", editableTargets: [editableTarget], origin };
+    case "restart-numbering":
+      return {
+        type: "list.restart-numbering",
+        editableTarget,
+        ...startAt !== void 0 ? { startAt } : {},
+        origin
+      };
+    case "continue-numbering":
+      return { type: "list.continue-numbering", editableTarget, origin };
+    default:
+      return void 0;
+  }
+}
+function resolveCurrentListTarget(document, input) {
+  if (input.editableTarget) {
+    const shapeIssues = validateEditableTargetRef(input.editableTarget);
+    if (shapeIssues.length > 0) {
+      return {
+        kind: "blocked",
+        blocker: {
+          code: "list-target-malformed",
+          ownerLayer: "L07",
+          message: `List target is malformed: ${shapeIssues[0]?.path ?? "$"}.`,
+          targetKey: input.editableTarget.targetKey,
+          addressKey: input.editableTarget.listAddress?.addressKey
+        }
+      };
+    }
+  }
+  const requestedTargetKey = input.editableTarget?.targetKey ?? input.targetKey;
+  const requestedAddressKey = input.editableTarget?.listAddress?.addressKey ?? input.addressKey;
+  if (!requestedTargetKey && !requestedAddressKey) {
+    return {
+      kind: "blocked",
+      blocker: {
+        code: "list-target-required",
+        ownerLayer: "L07",
+        message: "runtime.lists requires a targetKey, addressKey, or editableTarget."
+      }
+    };
+  }
+  const currentTargets = currentListTargets(document);
+  const resolved = currentTargets.find(
+    ({ target }) => requestedTargetKey !== void 0 && target.targetKey === requestedTargetKey || requestedAddressKey !== void 0 && target.listAddress?.addressKey === requestedAddressKey
+  );
+  if (!resolved) {
+    return {
+      kind: "blocked",
+      blocker: {
+        code: "list-target-not-found",
+        ownerLayer: "L07",
+        message: "List target no longer resolves in the current canonical document.",
+        ...requestedTargetKey !== void 0 ? { targetKey: requestedTargetKey } : {},
+        ...requestedAddressKey !== void 0 ? { addressKey: requestedAddressKey } : {}
+      }
+    };
+  }
+  if (input.editableTarget && !sameTargetStaleHash(input.editableTarget, resolved.target)) {
+    return {
+      kind: "blocked",
+      blocker: {
+        code: "list-target-stale",
+        ownerLayer: "L07",
+        message: "List target resolved by identity but stale discriminators changed.",
+        targetKey: input.editableTarget.targetKey,
+        addressKey: input.editableTarget.listAddress?.addressKey
+      }
+    };
+  }
+  if (resolved.target.editability !== "editable" || resolved.target.posture.blockers.length > 0) {
+    return {
+      kind: "blocked",
+      blocker: {
+        code: "list-target-non-editable",
+        ownerLayer: "L07",
+        message: resolved.target.posture.blockers.length > 0 ? `List target is not editable: ${resolved.target.posture.blockers.join(", ")}.` : "List target is not editable.",
+        targetKey: resolved.target.targetKey,
+        addressKey: resolved.target.listAddress?.addressKey
+      }
+    };
+  }
+  return { kind: "resolved", ...resolved };
+}
+function currentListTargets(document) {
+  const paragraphs = collectParagraphEntries(document.content.children, "main");
+  const targets = collectEditableTargetRefs(document).filter(isListTextTarget);
+  const byBlockPath = /* @__PURE__ */ new Map();
+  for (const target of targets) byBlockPath.set(target.blockPath, target);
+  const out = [];
+  for (let paragraphIndex = 0; paragraphIndex < paragraphs.length; paragraphIndex += 1) {
+    const entry = paragraphs[paragraphIndex];
+    if (!entry?.paragraph.numbering) continue;
+    const target = byBlockPath.get(entry.blockPath);
+    if (!target) continue;
+    out.push({ target, paragraph: entry.paragraph, paragraphIndex });
+  }
+  return out;
+}
+function collectParagraphEntries(blocks, basePath) {
+  const out = [];
+  collectParagraphEntriesInto(blocks, basePath, out);
+  return out;
+}
+function collectParagraphEntriesInto(blocks, basePath, out) {
+  for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
+    const block = blocks[blockIndex];
+    if (!block) continue;
+    const blockPath = `${basePath}/block[${blockIndex}]`;
+    switch (block.type) {
+      case "paragraph":
+        out.push({ paragraph: block, blockPath });
+        break;
+      case "table":
+        for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+          const row = block.rows[rowIndex];
+          if (!row) continue;
+          for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
+            const cell = row.cells[cellIndex];
+            if (!cell) continue;
+            collectParagraphEntriesInto(
+              cell.children,
+              `${blockPath}/row[${rowIndex}]/cell[${cellIndex}]`,
+              out
+            );
+          }
+        }
+        break;
+      case "sdt":
+        collectParagraphEntriesInto(block.children, blockPath, out);
+        break;
+      case "custom_xml":
+        break;
+      default:
+        break;
+    }
+  }
+}
+function isListTextTarget(target) {
+  return target.commandFamily === "text-leaf" && target.listAddress?.operationScope === "list-text" && target.listAddress.addressKind === "list-item-text";
+}
+function sameTargetStaleHash(left, right) {
+  return left.targetKey === right.targetKey && left.listAddress?.addressKey === right.listAddress?.addressKey && left.listAddress?.resolver?.staleHash === right.listAddress?.resolver?.staleHash && left.staleCheck.paragraphTextHash === right.staleCheck.paragraphTextHash && left.staleCheck.paragraphTextLength === right.staleCheck.paragraphTextLength && left.staleCheck.inlineCount === right.staleCheck.inlineCount;
+}
+function toReadback(document, target, paragraph) {
+  const numbering = paragraph.numbering;
+  const instance = document.numbering.instances[numbering.numberingInstanceId];
+  const listKind = instance ? getListKind(document.numbering, numbering.numberingInstanceId) : void 0;
+  return {
+    targetKey: target.targetKey,
+    actionHandle: `list-action:${target.listAddress.addressKey}`,
+    kind: target.kind,
+    storyKey: target.storyKey,
+    blockPath: target.blockPath,
+    leafPath: target.leafPath,
+    addressKey: target.listAddress.addressKey,
+    numberingInstanceId: numbering.numberingInstanceId,
+    ...instance?.abstractNumberingId ? { abstractNumberingId: instance.abstractNumberingId } : {},
+    level: numbering.level,
+    ...listKind ? { listKind } : {},
+    editability: target.editability,
+    blockers: target.posture.blockers,
+    supportedCommands: SUPPORTED_COMMANDS,
+    unsupportedCommands: UNSUPPORTED_COMMANDS,
+    staleDiscriminators: {
+      paragraphTextHash: target.staleCheck.paragraphTextHash,
+      paragraphTextLength: target.staleCheck.paragraphTextLength,
+      inlineCount: target.staleCheck.inlineCount,
+      listAddressStaleHash: target.listAddress?.resolver?.staleHash
+    }
+  };
+}
+function canContinuePreviousSequence(document, paragraphIndex) {
+  const paragraphs = collectParagraphEntries(document.content.children, "main");
+  const current = paragraphs[paragraphIndex]?.paragraph;
+  if (!current?.numbering) return false;
+  const currentKind = getListKind(document.numbering, current.numbering.numberingInstanceId);
+  if (!currentKind) return false;
+  for (let index = paragraphIndex - 1; index >= 0; index -= 1) {
+    const previous = paragraphs[index]?.paragraph;
+    if (!previous?.numbering) continue;
+    const previousKind = getListKind(document.numbering, previous.numbering.numberingInstanceId);
+    return previousKind === currentKind && previous.numbering.numberingInstanceId !== current.numbering.numberingInstanceId;
+  }
+  return false;
+}
+function canJoinPreviousSequence(document, paragraphIndex) {
+  const paragraphs = collectParagraphEntries(document.content.children, "main");
+  const current = paragraphs[paragraphIndex]?.paragraph;
+  const previous = paragraphs[paragraphIndex - 1]?.paragraph;
+  if (!current?.numbering || !previous?.numbering) return false;
+  const currentKind = getListKind(document.numbering, current.numbering.numberingInstanceId);
+  const previousKind = getListKind(document.numbering, previous.numbering.numberingInstanceId);
+  return Boolean(currentKind) && currentKind === previousKind && current.numbering.numberingInstanceId !== previous.numbering.numberingInstanceId;
+}
+function unsupportedCommandBlocker(command, target) {
+  return {
+    code: "list-command-unsupported",
+    ownerLayer: "L07",
+    message: `runtime.lists.${command} is reserved but not implemented by the L07 command surface yet.`,
+    ...target.targetKey !== void 0 ? { targetKey: target.targetKey } : {},
+    ...target.addressKey !== void 0 ? { addressKey: target.addressKey } : {}
+  };
+}
+
 // src/api/v3/ai/_pe2-evidence.ts
 function copyCoverage(coverage) {
   return {
@@ -5720,6 +6111,17 @@ function createTableActionFamily(runtime) {
             operationScope: target.table?.operationScope
           });
         }
+        if (fragmentContent && fragmentContent.blocks.length === 0) {
+          return blockedResult(input, proposalId, {
+            code: `table-action-structured-fragment-empty:${input.operation.kind}`,
+            category: "unsupported-operation",
+            message: "Structured table text actions require a canonical document fragment with at least one block.",
+            nextStep: 'Retry with operation.content.kind="structured" and a CanonicalDocumentFragment whose blocks array contains the paragraph or table content to paste/drop.',
+            actionHandle: input.actionHandle,
+            operation: input.operation.kind,
+            operationScope: target.table?.operationScope
+          });
+        }
         const resolution2 = resolveEditableTextTarget({
           document: runtime.getCanonicalDocument(),
           surface: runtime.getRenderSnapshot().surface?.blocks ?? [],
@@ -5742,6 +6144,7 @@ function createTableActionFamily(runtime) {
           runtime.dispatch({
             type: "fragment.insert",
             fragment: fragmentContent,
+            selection: createSelectionSnapshot(resolution2.range.to, resolution2.range.to),
             editableTarget: target,
             origin: { source: "api", timestamp: nowUtc }
           });
@@ -5754,6 +6157,17 @@ function createTableActionFamily(runtime) {
           });
         }
         const changed2 = runtime.getCanonicalDocument() !== before2;
+        if (!changed2) {
+          return blockedResult(input, proposalId, {
+            code: `table-action-noop:${input.operation.kind}:${input.actionHandle}`,
+            category: "runtime-noop",
+            message: "The runtime accepted the table text target but the operation produced no document change.",
+            nextStep: "Refresh the table action list and verify the target is still editable, the payload is non-empty when required, and structured fragments are dispatched through a command-safe table text action.",
+            actionHandle: input.actionHandle,
+            operation: input.operation.kind,
+            operationScope: target.table?.operationScope
+          });
+        }
         const afterReadback = tableTextReadback(readEditableTargetText(runtime.getCanonicalDocument(), target));
         return {
           proposalId,
@@ -8856,7 +9270,8 @@ function createApiV3(handle, opts) {
     chart: createChartFamily(handle),
     search: createSearchFamily(handle),
     table: createTableFamily(handle),
-    viewport: createViewportFamily(handle)
+    viewport: createViewportFamily(handle),
+    lists: createListsFamily(handle)
   };
   const ui = opts?.ui ? createUiApi(handle, opts.ui) : void 0;
   const api = ui ? { runtime, ai, ui } : { runtime, ai };

package/dist/{chunk-YD2JE54B.js → chunk-YZDZ4FGR.js}

@@ -1,6 +1,6 @@
 import {
   extractBookmarksFromBodyXml
-} from "./chunk-4YJVRIUB.js";
+} from "./chunk-Q3QYGKFE.js";
 
 // src/legal/document-root.ts
 function resolveWalkableRoot(document) {

package/dist/compare.d.cts

@@ -1,4 +1,4 @@
-import { C as CanonicalDocument, B as BlockNode } from './canonical-document-CXCFCbAz.cjs';
+import { C as CanonicalDocument, B as BlockNode } from './canonical-document-BMtONpgf.cjs';
 
 type OpcCompressionMethod = "store" | "deflate";
 type OpcSurfaceKind = "content" | "relationships" | "content-types";

package/dist/compare.d.ts

@@ -1,4 +1,4 @@
-import { C as CanonicalDocument, B as BlockNode } from './canonical-document-CXCFCbAz.js';
+import { C as CanonicalDocument, B as BlockNode } from './canonical-document-BMtONpgf.js';
 
 type OpcCompressionMethod = "store" | "deflate";
 type OpcSurfaceKind = "content" | "relationships" | "content-types";

package/dist/core/commands/formatting-commands.d.cts

@@ -1,7 +1,7 @@
 import 'prosemirror-state';
 import 'prosemirror-model';
-export { g4 as Alignment, g5 as FormattingMutationResult, g6 as FormattingOperation, g7 as TextMarkClearTarget, g8 as TextMarkRangeOperation, g9 as applyFormattingOperationToDocument, ga as applyIndentation, gb as applyTextMarkOperationToDocumentRange, gc as getFormattingStateFromRenderSnapshot, gd as isMarkActive, ge as makeSetAlignment, gf as makeSetFontFamily, gg as makeSetFontSize, gh as makeSetHighlight, gi as makeSetTextColor, gj as makeToggleAllCaps, gk as makeToggleBold, gl as makeToggleItalic, gm as makeToggleSmallCaps, gn as makeToggleStrikethrough, go as makeToggleSubscript, gp as makeToggleSuperscript, gq as makeToggleUnderline } from '../../public-types-B-CskQen.cjs';
-import '../../canonical-document-CXCFCbAz.cjs';
+export { g4 as Alignment, g5 as FormattingMutationResult, g6 as FormattingOperation, g7 as TextMarkClearTarget, g8 as TextMarkRangeOperation, g9 as applyFormattingOperationToDocument, ga as applyIndentation, gb as applyTextMarkOperationToDocumentRange, gc as getFormattingStateFromRenderSnapshot, gd as isMarkActive, ge as makeSetAlignment, gf as makeSetFontFamily, gg as makeSetFontSize, gh as makeSetHighlight, gi as makeSetTextColor, gj as makeToggleAllCaps, gk as makeToggleBold, gl as makeToggleItalic, gm as makeToggleSmallCaps, gn as makeToggleStrikethrough, go as makeToggleSubscript, gp as makeToggleSuperscript, gq as makeToggleUnderline } from '../../public-types-B5CRoR6f.cjs';
+import '../../canonical-document-BMtONpgf.cjs';
 import 'react';
 import 'yjs';
 import 'y-protocols/awareness';

package/dist/core/commands/formatting-commands.d.ts

@@ -1,7 +1,7 @@
 import 'prosemirror-state';
 import 'prosemirror-model';
-export { g4 as Alignment, g5 as FormattingMutationResult, g6 as FormattingOperation, g7 as TextMarkClearTarget, g8 as TextMarkRangeOperation, g9 as applyFormattingOperationToDocument, ga as applyIndentation, gb as applyTextMarkOperationToDocumentRange, gc as getFormattingStateFromRenderSnapshot, gd as isMarkActive, ge as makeSetAlignment, gf as makeSetFontFamily, gg as makeSetFontSize, gh as makeSetHighlight, gi as makeSetTextColor, gj as makeToggleAllCaps, gk as makeToggleBold, gl as makeToggleItalic, gm as makeToggleSmallCaps, gn as makeToggleStrikethrough, go as makeToggleSubscript, gp as makeToggleSuperscript, gq as makeToggleUnderline } from '../../public-types-7KZsNGE2.js';
-import '../../canonical-document-CXCFCbAz.js';
+export { g4 as Alignment, g5 as FormattingMutationResult, g6 as FormattingOperation, g7 as TextMarkClearTarget, g8 as TextMarkRangeOperation, g9 as applyFormattingOperationToDocument, ga as applyIndentation, gb as applyTextMarkOperationToDocumentRange, gc as getFormattingStateFromRenderSnapshot, gd as isMarkActive, ge as makeSetAlignment, gf as makeSetFontFamily, gg as makeSetFontSize, gh as makeSetHighlight, gi as makeSetTextColor, gj as makeToggleAllCaps, gk as makeToggleBold, gl as makeToggleItalic, gm as makeToggleSmallCaps, gn as makeToggleStrikethrough, go as makeToggleSubscript, gp as makeToggleSuperscript, gq as makeToggleUnderline } from '../../public-types-p9b8rfy8.js';
+import '../../canonical-document-BMtONpgf.js';
 import 'react';
 import 'yjs';
 import 'y-protocols/awareness';