@pptx-glimpse/editor 0.1.0

package/dist/index.cjs

@@ -0,0 +1,719 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EditorSession: () => EditorSession,
+  createEditorSession: () => createEditorSession
+});
+module.exports = __toCommonJS(index_exports);
+var import_document = require("@pptx-glimpse/document");
+var EditorSession = class {
+  #document;
+  #selection;
+  #undoStack = [];
+  #redoStack = [];
+  constructor(document) {
+    this.#document = document;
+  }
+  get document() {
+    return this.#document;
+  }
+  get selection() {
+    return this.#selection;
+  }
+  get canUndo() {
+    return this.#undoStack.length > 0;
+  }
+  get canRedo() {
+    return this.#redoStack.length > 0;
+  }
+  get undoDepth() {
+    return this.#undoStack.length;
+  }
+  get redoDepth() {
+    return this.#redoStack.length;
+  }
+  selectShape(handle) {
+    if ((0, import_document.findShapeNodeBySourceHandle)(this.#document, handle) === void 0) {
+      return {
+        ok: false,
+        code: "invalid-selection",
+        message: "selectShape: shape handle was not found in PptxSourceModel source"
+      };
+    }
+    const selection = { shapeHandle: handle };
+    this.#selection = selection;
+    return { ok: true, selection };
+  }
+  deselectShape() {
+    this.#selection = void 0;
+  }
+  apply(command) {
+    return this.applyAll([command]);
+  }
+  applyAll(commands) {
+    const before = this.#document;
+    if (commands.length === 0) return { ok: true, document: before };
+    try {
+      let after = before;
+      const warnings = [];
+      for (const command of commands) {
+        after = applyCommandToDocument(after, command);
+        warnings.push(...collectCommandWarnings(after, [command]));
+      }
+      assertNoConflictingParagraphAndRunEdits(after.edits);
+      after = normalizeEditorEdits(after);
+      const dedupedWarnings = dedupeCommandWarnings(warnings);
+      if (after === before) {
+        return {
+          ok: true,
+          document: before,
+          ...dedupedWarnings.length > 0 ? { warnings: dedupedWarnings } : {}
+        };
+      }
+      this.#document = after;
+      this.reconcileSelectionAfterDocumentChange();
+      this.#undoStack.push({ before, after });
+      this.#redoStack.length = 0;
+      return {
+        ok: true,
+        document: after,
+        ...dedupedWarnings.length > 0 ? { warnings: dedupedWarnings } : {}
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        code: "invalid-command",
+        message: error instanceof Error ? error.message : "Editor command was rejected.",
+        cause: error
+      };
+    }
+  }
+  undo() {
+    const entry = this.#undoStack.pop();
+    if (entry === void 0) return { ok: false, reason: "empty-undo-stack" };
+    this.#document = entry.before;
+    this.reconcileSelectionAfterDocumentChange();
+    this.#redoStack.push(entry);
+    return { ok: true, document: entry.before };
+  }
+  redo() {
+    const entry = this.#redoStack.pop();
+    if (entry === void 0) return { ok: false, reason: "empty-redo-stack" };
+    this.#document = entry.after;
+    this.reconcileSelectionAfterDocumentChange();
+    this.#undoStack.push(entry);
+    return { ok: true, document: entry.after };
+  }
+  reconcileSelectionAfterDocumentChange() {
+    if (this.#selection === void 0) return;
+    if ((0, import_document.findShapeNodeBySourceHandle)(this.#document, this.#selection.shapeHandle) === void 0) {
+      this.#selection = void 0;
+    }
+  }
+};
+function createEditorSession(document) {
+  return new EditorSession(document);
+}
+function applyCommandToDocument(document, command) {
+  switch (command.kind) {
+    case "replaceTextRunPlainText":
+      return replaceTextRunPlainTextCommand(document, command);
+    case "replaceParagraphPlainText":
+      return replaceParagraphPlainTextCommand(document, command);
+    case "setTextRunProperties":
+      return setTextRunPropertiesCommand(document, command);
+    case "clearTextRunProperties":
+      return clearTextRunPropertiesCommand(document, command);
+    case "setParagraphProperties":
+      return setParagraphPropertiesCommand(document, command);
+    case "clearParagraphProperties":
+      return clearParagraphPropertiesCommand(document, command);
+    case "moveShape":
+      return moveShape(document, command);
+    case "resizeShape":
+      return resizeShape(document, command);
+    case "setShapeTransform":
+      return setShapeTransform(document, command);
+    case "setShapeFill":
+      return setShapeFillCommand(document, command);
+    case "setShapeOutline":
+      return setShapeOutlineCommand(document, command);
+    case "addTextBox":
+      return addTextBoxCommand(document, command);
+    case "addConnector":
+      return addConnectorCommand(document, command);
+    case "deleteShape":
+      return (0, import_document.deleteShape)(document, command.handle);
+    case "replaceImage":
+      return (0, import_document.replaceImageBytes)(document, command.handle, command.bytes);
+    case "addEmptySlideFromLayout":
+      return (0, import_document.addEmptySlideFromLayout)(document, command);
+    case "duplicateSlide":
+      return (0, import_document.duplicateSlide)(document, command.handle);
+    case "moveSlide":
+      return (0, import_document.moveSlide)(document, command.handle, command);
+    case "deleteSlide":
+      return (0, import_document.deleteSlide)(document, command.handle);
+  }
+}
+function replaceTextRunPlainTextCommand(document, command) {
+  if (typeof command.text !== "string") {
+    throw new Error("replaceTextRunPlainText: text must be a string");
+  }
+  return (0, import_document.replaceTextRunPlainText)(document, command.handle, command.text);
+}
+function replaceParagraphPlainTextCommand(document, command) {
+  if (typeof command.text !== "string") {
+    throw new Error("replaceParagraphPlainText: text must be a string");
+  }
+  return (0, import_document.replaceParagraphPlainText)(document, command.handle, command.text);
+}
+function collectCommandWarnings(document, commands) {
+  if (!commands.some((command) => command.kind === "replaceImage")) return [];
+  const warnings = [];
+  const imageEdits = document.edits?.filter((edit) => edit.kind === "replaceImage") ?? [];
+  for (const command of commands) {
+    if (command.kind !== "replaceImage") continue;
+    let edit;
+    for (let index = imageEdits.length - 1; index >= 0; index -= 1) {
+      const candidate = imageEdits[index];
+      if (candidate.handle.partPath === command.handle.partPath && candidate.handle.nodeId === command.handle.nodeId && candidate.handle.relationshipId === command.handle.relationshipId && candidate.handle.orderingSlot === command.handle.orderingSlot) {
+        edit = candidate;
+        break;
+      }
+    }
+    if (edit === void 0 || edit.sharedReferenceCount <= 1) continue;
+    warnings.push({
+      code: "shared-media-part",
+      mediaPartPath: edit.mediaPartPath,
+      referenceCount: edit.sharedReferenceCount,
+      message: `replaceImage: media part '${edit.mediaPartPath}' is referenced by ${edit.sharedReferenceCount} pic shapes; all references now use the replacement image.`
+    });
+  }
+  return warnings;
+}
+function dedupeCommandWarnings(warnings) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const warning of warnings) {
+    const key = `${warning.code}\0${warning.mediaPartPath}`;
+    if (!deduped.has(key)) deduped.set(key, warning);
+  }
+  return [...deduped.values()];
+}
+function addTextBoxCommand(document, command) {
+  requireFiniteEmu(command.offsetX, "addTextBox", "offsetX");
+  requireFiniteEmu(command.offsetY, "addTextBox", "offsetY");
+  requirePositiveFiniteEmu(command.width, "addTextBox", "width");
+  requirePositiveFiniteEmu(command.height, "addTextBox", "height");
+  if (command.text !== void 0 && typeof command.text !== "string") {
+    throw new Error("addTextBox: text must be a string");
+  }
+  if (command.name !== void 0 && command.name.trim() === "") {
+    throw new Error("addTextBox: name must be a non-empty string when provided");
+  }
+  return (0, import_document.addTextBox)(document, command.slideHandle, command);
+}
+function addConnectorCommand(document, command) {
+  requireFiniteEmu(command.offsetX, "addConnector", "offsetX");
+  requireFiniteEmu(command.offsetY, "addConnector", "offsetY");
+  requirePositiveFiniteEmu(command.width, "addConnector", "width");
+  requirePositiveFiniteEmu(command.height, "addConnector", "height");
+  return (0, import_document.addConnector)(document, command.slideHandle, command);
+}
+function setTextRunPropertiesCommand(document, command) {
+  requireNonEmptyPropertySet(command.properties, "setTextRunProperties");
+  validateTextRunPropertySet(command.properties, "setTextRunProperties");
+  return (0, import_document.setTextRunProperties)(document, command.handle, command.properties);
+}
+function clearTextRunPropertiesCommand(document, command) {
+  if (command.properties.length === 0) {
+    throw new Error("clearTextRunProperties: properties must contain at least one property name");
+  }
+  for (const property of command.properties) {
+    if (!EDITABLE_TEXT_RUN_PROPERTY_SET.has(property)) {
+      throw new Error(`clearTextRunProperties: unsupported text run property '${property}'`);
+    }
+  }
+  return (0, import_document.clearTextRunProperties)(document, command.handle, command.properties);
+}
+function setParagraphPropertiesCommand(document, command) {
+  requireNonEmptyParagraphPropertySet(command.properties, "setParagraphProperties");
+  validateParagraphPropertySet(command.properties, "setParagraphProperties");
+  return (0, import_document.setParagraphProperties)(document, command.handle, command.properties);
+}
+function clearParagraphPropertiesCommand(document, command) {
+  if (command.properties.length === 0) {
+    throw new Error("clearParagraphProperties: properties must contain at least one property name");
+  }
+  for (const property of command.properties) {
+    if (!EDITABLE_PARAGRAPH_PROPERTY_SET.has(property)) {
+      throw new Error(`clearParagraphProperties: unsupported paragraph property '${property}'`);
+    }
+  }
+  return (0, import_document.clearParagraphProperties)(document, command.handle, command.properties);
+}
+function moveShape(document, command) {
+  requireFiniteEmu(command.offsetX, "moveShape", "offsetX");
+  requireFiniteEmu(command.offsetY, "moveShape", "offsetY");
+  const current = requireEditableShapeTransform(document, command.handle, "moveShape");
+  return (0, import_document.updateShapeTransform)(document, command.handle, {
+    offsetX: command.offsetX,
+    offsetY: command.offsetY,
+    width: current.width,
+    height: current.height
+  });
+}
+function resizeShape(document, command) {
+  requirePositiveFiniteEmu(command.width, "resizeShape", "width");
+  requirePositiveFiniteEmu(command.height, "resizeShape", "height");
+  const current = requireEditableShapeTransform(document, command.handle, "resizeShape");
+  return (0, import_document.updateShapeTransform)(document, command.handle, {
+    offsetX: current.offsetX,
+    offsetY: current.offsetY,
+    width: command.width,
+    height: command.height
+  });
+}
+function setShapeTransform(document, command) {
+  requireFiniteEmu(command.offsetX, "setShapeTransform", "offsetX");
+  requireFiniteEmu(command.offsetY, "setShapeTransform", "offsetY");
+  requirePositiveFiniteEmu(command.width, "setShapeTransform", "width");
+  requirePositiveFiniteEmu(command.height, "setShapeTransform", "height");
+  requireEditableShapeTransform(document, command.handle, "setShapeTransform");
+  return (0, import_document.updateShapeTransform)(document, command.handle, {
+    offsetX: command.offsetX,
+    offsetY: command.offsetY,
+    width: command.width,
+    height: command.height
+  });
+}
+function setShapeFillCommand(document, command) {
+  validateShapeFill(command.fill, "setShapeFill");
+  return (0, import_document.setShapeFill)(document, command.handle, command.fill);
+}
+function setShapeOutlineCommand(document, command) {
+  validateShapeOutline(command.outline, "setShapeOutline");
+  return (0, import_document.setShapeOutline)(document, command.handle, command.outline);
+}
+var EDITABLE_TEXT_RUN_PROPERTIES = [
+  "bold",
+  "italic",
+  "underline",
+  "fontSize",
+  "color",
+  "typeface"
+];
+var EDITABLE_TEXT_RUN_PROPERTY_SET = new Set(EDITABLE_TEXT_RUN_PROPERTIES);
+var EDITABLE_PARAGRAPH_PROPERTIES = [
+  "align",
+  "level",
+  "bullet"
+];
+var EDITABLE_PARAGRAPH_PROPERTY_SET = new Set(EDITABLE_PARAGRAPH_PROPERTIES);
+var PARAGRAPH_ALIGN_VALUES = /* @__PURE__ */ new Set(["left", "center", "right", "justify"]);
+var AUTO_NUM_SCHEMES = /* @__PURE__ */ new Set([
+  "arabicPeriod",
+  "arabicParenR",
+  "romanUcPeriod",
+  "romanLcPeriod",
+  "alphaUcPeriod",
+  "alphaLcPeriod",
+  "alphaLcParenR",
+  "alphaUcParenR",
+  "arabicPlain"
+]);
+function requireNonEmptyPropertySet(properties, commandName) {
+  if (Object.values(properties).every((value) => value === void 0)) {
+    throw new Error(`${commandName}: properties must contain at least one defined property`);
+  }
+}
+function validateTextRunPropertySet(properties, commandName) {
+  for (const property of Object.keys(properties)) {
+    if (!EDITABLE_TEXT_RUN_PROPERTY_SET.has(property)) {
+      throw new Error(`${commandName}: unsupported text run property '${property}'`);
+    }
+  }
+  requireBooleanOrUndefined(properties.bold, commandName, "bold");
+  requireBooleanOrUndefined(properties.italic, commandName, "italic");
+  requireBooleanOrUndefined(properties.underline, commandName, "underline");
+  if (properties.fontSize !== void 0 && (!Number.isFinite(properties.fontSize) || properties.fontSize <= 0)) {
+    throw new Error(`${commandName}: fontSize must be a finite positive pt value`);
+  }
+  if (properties.typeface !== void 0 && properties.typeface.trim() === "") {
+    throw new Error(`${commandName}: typeface must be a non-empty string`);
+  }
+  if (properties.color !== void 0) {
+    if (properties.color.kind !== "srgb") {
+      throw new Error(`${commandName}: only srgb text run color is supported`);
+    }
+    if (!/^[0-9A-Fa-f]{6}$/.test(properties.color.hex)) {
+      throw new Error(`${commandName}: color.hex must be a 6-digit hex value`);
+    }
+  }
+}
+function requireNonEmptyParagraphPropertySet(properties, commandName) {
+  if (Object.values(properties).every((value) => value === void 0)) {
+    throw new Error(`${commandName}: properties must contain at least one defined property`);
+  }
+}
+function validateParagraphPropertySet(properties, commandName) {
+  for (const property of Object.keys(properties)) {
+    if (!EDITABLE_PARAGRAPH_PROPERTY_SET.has(property)) {
+      throw new Error(`${commandName}: unsupported paragraph property '${property}'`);
+    }
+  }
+  if (properties.align !== void 0 && !PARAGRAPH_ALIGN_VALUES.has(properties.align)) {
+    throw new Error(`${commandName}: align must be left, center, right, or justify`);
+  }
+  if (properties.level !== void 0 && (!Number.isInteger(properties.level) || properties.level < 0 || properties.level > 8)) {
+    throw new Error(`${commandName}: level must be an integer from 0 to 8`);
+  }
+  if (properties.bullet !== void 0) {
+    validateParagraphBullet(properties.bullet, commandName);
+  }
+}
+function validateParagraphBullet(bullet, commandName) {
+  if (bullet.type === "none") return;
+  if (bullet.type === "char") {
+    if (bullet.char.length === 0) {
+      throw new Error(`${commandName}: bullet.char must be a non-empty string`);
+    }
+    return;
+  }
+  if (bullet.type === "autoNum") {
+    if (!AUTO_NUM_SCHEMES.has(bullet.scheme)) {
+      throw new Error(`${commandName}: unsupported bullet auto-numbering scheme`);
+    }
+    if (!Number.isInteger(bullet.startAt) || bullet.startAt < 1) {
+      throw new Error(`${commandName}: bullet.startAt must be a positive integer`);
+    }
+    return;
+  }
+  throw new Error(`${commandName}: unsupported bullet type`);
+}
+function requireBooleanOrUndefined(value, commandName, fieldName) {
+  if (value !== void 0 && typeof value !== "boolean") {
+    throw new Error(`${commandName}: ${fieldName} must be a boolean value`);
+  }
+}
+function validateShapeOutline(outline, commandName) {
+  if (outline.width === void 0 && outline.fill === void 0) {
+    throw new Error(`${commandName}: outline must set width or fill`);
+  }
+  if (outline.width !== void 0) {
+    requirePositiveFiniteEmu(outline.width, commandName, "width");
+  }
+  if (outline.fill !== void 0) validateShapeFill(outline.fill, commandName);
+}
+function validateShapeFill(fill, commandName) {
+  if (fill.kind === "none") return;
+  if (fill.kind !== "solid") {
+    throw new Error(`${commandName}: only solid and none fills are supported`);
+  }
+  if (fill.color.kind !== "srgb") {
+    throw new Error(`${commandName}: only srgb solid fill colors are supported`);
+  }
+  if (!/^[0-9A-Fa-f]{6}$/.test(fill.color.hex)) {
+    throw new Error(`${commandName}: color.hex must be a 6-digit hex value`);
+  }
+}
+function requireEditableShapeTransform(document, handle, commandName) {
+  const shape = (0, import_document.findShapeNodeBySourceHandle)(document, handle);
+  if (shape === void 0) {
+    throw new Error(`${commandName}: shape handle was not found in PptxSourceModel source`);
+  }
+  if (!hasTransform(shape)) {
+    throw new Error(`${commandName}: shape handle does not reference a shape with xfrm`);
+  }
+  return shape.transform;
+}
+function requireFiniteEmu(value, commandName, fieldName) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`${commandName}: ${fieldName} must be a finite EMU value`);
+  }
+}
+function requirePositiveFiniteEmu(value, commandName, fieldName) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${commandName}: ${fieldName} must be a finite positive EMU value`);
+  }
+}
+function hasTransform(shape) {
+  return shape.kind !== "raw" && shape.transform !== void 0;
+}
+function normalizeEditorEdits(document) {
+  const edits = document.edits;
+  if (edits === void 0) return document;
+  const seenTextRuns = /* @__PURE__ */ new Set();
+  const seenTextRunProperties = /* @__PURE__ */ new Map();
+  const seenParagraphProperties = /* @__PURE__ */ new Map();
+  const seenParagraphs = /* @__PURE__ */ new Set();
+  const seenShapeTransforms = /* @__PURE__ */ new Set();
+  const seenShapeFills = /* @__PURE__ */ new Set();
+  const seenShapeOutlineProperties = /* @__PURE__ */ new Map();
+  const normalizedShapeOutlineEdits = /* @__PURE__ */ new Map();
+  const normalizedReversed = [];
+  let changed = false;
+  for (let index = edits.length - 1; index >= 0; index -= 1) {
+    const edit = edits[index];
+    if (edit.kind === "replaceTextRunPlainText") {
+      const key = editHandleNodeKey(edit);
+      const paragraphKey = textRunParagraphEditKey(edit);
+      if (paragraphKey !== void 0 && seenParagraphs.has(paragraphKey)) {
+        changed = true;
+        continue;
+      }
+      if (seenTextRuns.has(key)) {
+        changed = true;
+        continue;
+      }
+      seenTextRuns.add(key);
+    }
+    if (edit.kind === "updateTextRunProperties") {
+      const paragraphKey = textRunParagraphEditKey(edit);
+      if (paragraphKey !== void 0 && seenParagraphs.has(paragraphKey)) {
+        changed = true;
+        continue;
+      }
+      const normalized = normalizeTextRunPropertiesEdit(edit, seenTextRunProperties);
+      if (normalized === void 0) {
+        changed = true;
+        continue;
+      }
+      if (!editorEditsEqual(normalized, edit)) changed = true;
+      normalizedReversed.push(normalized);
+      continue;
+    }
+    if (edit.kind === "updateParagraphProperties") {
+      const normalized = normalizeParagraphPropertiesEdit(edit, seenParagraphProperties);
+      if (normalized === void 0) {
+        changed = true;
+        continue;
+      }
+      if (!editorEditsEqual(normalized, edit)) changed = true;
+      normalizedReversed.push(normalized);
+      continue;
+    }
+    if (edit.kind === "replaceParagraphPlainText") {
+      const key = editHandleNodeKey(edit);
+      if (seenParagraphs.has(key)) {
+        changed = true;
+        continue;
+      }
+      seenParagraphs.add(key);
+    }
+    if (edit.kind === "updateShapeTransform") {
+      const key = editHandleNodeKey(edit);
+      if (seenShapeTransforms.has(key)) {
+        changed = true;
+        continue;
+      }
+      seenShapeTransforms.add(key);
+    }
+    if (edit.kind === "updateShapeFill") {
+      const key = editHandleNodeKey(edit);
+      if (seenShapeFills.has(key)) {
+        changed = true;
+        continue;
+      }
+      seenShapeFills.add(key);
+    }
+    if (edit.kind === "updateShapeOutline") {
+      const normalized = normalizeShapeOutlineEdit(
+        edit,
+        seenShapeOutlineProperties,
+        normalizedShapeOutlineEdits
+      );
+      if (normalized === void 0) {
+        changed = true;
+        continue;
+      }
+      if (normalized.merged) {
+        changed = true;
+        continue;
+      }
+      if (!editorEditsEqual(normalized.edit, edit)) changed = true;
+      normalizedReversed.push(normalized.edit);
+      continue;
+    }
+    normalizedReversed.push(edit);
+  }
+  if (!changed && normalizedReversed.length === edits.length) return document;
+  return {
+    ...document,
+    edits: normalizedReversed.reverse()
+  };
+}
+function assertNoConflictingParagraphAndRunEdits(edits) {
+  if (edits === void 0) return;
+  const paragraphEditIndexes = /* @__PURE__ */ new Map();
+  edits.forEach((edit, index) => {
+    if (edit.kind === "replaceParagraphPlainText") {
+      paragraphEditIndexes.set(editHandleNodeKey(edit), index);
+    }
+  });
+  for (const [index, edit] of edits.entries()) {
+    if (edit.kind !== "replaceTextRunPlainText" && edit.kind !== "updateTextRunProperties") {
+      continue;
+    }
+    const paragraphKey = textRunParagraphEditKey(edit);
+    const paragraphIndex = paragraphKey === void 0 ? void 0 : paragraphEditIndexes.get(paragraphKey);
+    if (paragraphIndex !== void 0 && (edit.kind === "updateTextRunProperties" || paragraphIndex < index)) {
+      throw new Error(
+        `${edit.kind}: run edits cannot be combined with replaceParagraphPlainText for the same paragraph`
+      );
+    }
+  }
+}
+function editorEditsEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function editHandleNodeKey(edit) {
+  return [
+    edit.handle.partPath,
+    edit.handle.nodeId ?? "",
+    edit.handle.relationshipId ?? "",
+    edit.handle.orderingSlot ?? ""
+  ].join("\0");
+}
+function textRunParagraphEditKey(edit) {
+  const nodeId = String(edit.handle.nodeId ?? "");
+  const byShapeId = /^(text:shape:.+:p:(\d+)):r:\d+$/.exec(nodeId);
+  const byShapeSlot = /^(text:shapeSlot:\d+:p:(\d+)):r:\d+$/.exec(nodeId);
+  const paragraphNodeId = byShapeId?.[1] ?? byShapeSlot?.[1];
+  const paragraphOrderingSlot = byShapeId?.[2] ?? byShapeSlot?.[2] ?? "";
+  if (paragraphNodeId === void 0) return void 0;
+  return [
+    edit.handle.partPath,
+    paragraphNodeId,
+    edit.handle.relationshipId ?? "",
+    paragraphOrderingSlot
+  ].join("\0");
+}
+function normalizeTextRunPropertiesEdit(edit, seenTextRunProperties) {
+  const key = editHandleNodeKey(edit);
+  let seenProperties = seenTextRunProperties.get(key);
+  if (seenProperties === void 0) {
+    seenProperties = /* @__PURE__ */ new Set();
+    seenTextRunProperties.set(key, seenProperties);
+  }
+  const set = {};
+  if (edit.set?.bold !== void 0 && !seenProperties.has("bold")) {
+    seenProperties.add("bold");
+    set.bold = edit.set.bold;
+  }
+  if (edit.set?.italic !== void 0 && !seenProperties.has("italic")) {
+    seenProperties.add("italic");
+    set.italic = edit.set.italic;
+  }
+  if (edit.set?.underline !== void 0 && !seenProperties.has("underline")) {
+    seenProperties.add("underline");
+    set.underline = edit.set.underline;
+  }
+  if (edit.set?.fontSize !== void 0 && !seenProperties.has("fontSize")) {
+    seenProperties.add("fontSize");
+    set.fontSize = edit.set.fontSize;
+  }
+  if (edit.set?.color !== void 0 && !seenProperties.has("color")) {
+    seenProperties.add("color");
+    set.color = edit.set.color;
+  }
+  if (edit.set?.typeface !== void 0 && !seenProperties.has("typeface")) {
+    seenProperties.add("typeface");
+    set.typeface = edit.set.typeface;
+  }
+  const clear = (edit.clear ?? []).filter((property) => !seenProperties.has(property));
+  for (const property of clear) seenProperties.add(property);
+  if (clear.length === 0 && Object.keys(set).length === 0) return void 0;
+  const normalized = {
+    kind: "updateTextRunProperties",
+    handle: edit.handle,
+    ...Object.keys(set).length > 0 ? { set } : {},
+    ...clear.length > 0 ? { clear } : {}
+  };
+  return normalized;
+}
+function normalizeParagraphPropertiesEdit(edit, seenParagraphProperties) {
+  const key = editHandleNodeKey(edit);
+  let seenProperties = seenParagraphProperties.get(key);
+  if (seenProperties === void 0) {
+    seenProperties = /* @__PURE__ */ new Set();
+    seenParagraphProperties.set(key, seenProperties);
+  }
+  const set = {};
+  if (edit.set?.align !== void 0 && !seenProperties.has("align")) {
+    seenProperties.add("align");
+    set.align = edit.set.align;
+  }
+  if (edit.set?.level !== void 0 && !seenProperties.has("level")) {
+    seenProperties.add("level");
+    set.level = edit.set.level;
+  }
+  if (edit.set?.bullet !== void 0 && !seenProperties.has("bullet")) {
+    seenProperties.add("bullet");
+    set.bullet = edit.set.bullet;
+  }
+  const clear = (edit.clear ?? []).filter((property) => !seenProperties.has(property));
+  for (const property of clear) seenProperties.add(property);
+  if (clear.length === 0 && Object.keys(set).length === 0) return void 0;
+  const normalized = {
+    kind: "updateParagraphProperties",
+    handle: edit.handle,
+    ...Object.keys(set).length > 0 ? { set } : {},
+    ...clear.length > 0 ? { clear } : {}
+  };
+  return normalized;
+}
+function normalizeShapeOutlineEdit(edit, seenShapeOutlineProperties, normalizedShapeOutlineEdits) {
+  const key = editHandleNodeKey(edit);
+  let seenProperties = seenShapeOutlineProperties.get(key);
+  if (seenProperties === void 0) {
+    seenProperties = /* @__PURE__ */ new Set();
+    seenShapeOutlineProperties.set(key, seenProperties);
+  }
+  const outline = {};
+  if (edit.outline.width !== void 0 && !seenProperties.has("width")) {
+    seenProperties.add("width");
+    outline.width = edit.outline.width;
+  }
+  if (edit.outline.fill !== void 0 && !seenProperties.has("fill")) {
+    seenProperties.add("fill");
+    outline.fill = edit.outline.fill;
+  }
+  if (Object.keys(outline).length === 0) return void 0;
+  const existing = normalizedShapeOutlineEdits.get(key);
+  if (existing !== void 0) {
+    existing.outline = { ...outline, ...existing.outline };
+    return { merged: true };
+  }
+  const normalized = {
+    kind: "updateShapeOutline",
+    handle: edit.handle,
+    outline
+  };
+  normalizedShapeOutlineEdits.set(key, normalized);
+  return { edit: normalized, merged: false };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EditorSession,
+  createEditorSession
+});