pptx-glimpse 3.1.0 → 3.2.0

package/dist/browser.js

@@ -1,6 +1,6 @@
 import {
   collectUsedFonts
-} from "./chunk-ZZKN4U5J.js";
+} from "./chunk-KY3SYR3V.js";
 import {
   DEFAULT_OUTPUT_WIDTH,
   addConnector,
@@ -10,22 +10,27 @@ import {
   asPartPath,
   asRelationshipId,
   asSourceNodeId,
+  clearParagraphProperties,
   clearTextRunProperties,
   convertPptxToSvg,
   deleteShape,
   deleteSlide,
   duplicateSlide,
   findShapeNodeBySourceHandle,
+  moveSlide,
   readPptx,
   renderPptxSourceModelToSvg,
   replaceImageBytes,
   replaceParagraphPlainText,
   replaceTextRunPlainText,
+  setParagraphProperties,
+  setShapeFill,
+  setShapeOutline,
   setTextRunProperties,
   unsafeBrandAssertion,
   updateShapeTransform,
   writePptx
-} from "./chunk-NMAO44T7.js";
+} from "./chunk-CX4ZDTKK.js";
 import {
   DEFAULT_FONT_MAPPING,
   clearFontCache,
@@ -2542,6 +2547,23 @@ var pptxTextBodySchema = new Schema({
     }
   }
 });
+var EDITABLE_PARAGRAPH_PROPERTIES = [
+  "align",
+  "level",
+  "bullet"
+];
+var AUTO_NUM_SCHEMES = [
+  "arabicPeriod",
+  "arabicParenR",
+  "romanUcPeriod",
+  "romanLcPeriod",
+  "alphaUcPeriod",
+  "alphaLcPeriod",
+  "alphaLcParenR",
+  "alphaUcParenR",
+  "arabicPlain"
+];
+var AUTO_NUM_SCHEME_SET = new Set(AUTO_NUM_SCHEMES);
 function textBodyToProseMirrorDocJson(textBody) {
   assertSupportedTextBody(textBody);
   return {
@@ -2607,8 +2629,12 @@ function proseMirrorDocJsonToEditorCommands(originalTextBody, docJson) {
     (editedParagraph, paragraphIndex) => {
       const originalParagraph = originalTextBody.paragraphs[paragraphIndex];
       if (originalParagraph === void 0) return [];
+      const paragraphPropertyCommands = paragraphPropertiesToEditorCommands(
+        originalParagraph,
+        editedParagraph
+      );
       if (paragraphRunHandlesMatch(originalParagraph, editedParagraph)) {
-        return editedParagraph.runs.flatMap(
+        const textRunCommands = editedParagraph.runs.flatMap(
           (editedRun, runIndex) => {
             const originalRun = originalParagraph.runs[runIndex];
             if (originalRun === void 0 || editedRun.text === originalRun.text) return [];
@@ -2626,6 +2652,7 @@ function proseMirrorDocJsonToEditorCommands(originalTextBody, docJson) {
             ];
           }
         );
+        return [...paragraphPropertyCommands, ...textRunCommands];
       }
       if (editedParagraph.handle === void 0) {
         throw new Error(
@@ -2633,6 +2660,7 @@ function proseMirrorDocJsonToEditorCommands(originalTextBody, docJson) {
         );
       }
       return [
+        ...paragraphPropertyCommands,
         {
           kind: "replaceParagraphPlainText",
           handle: editedParagraph.handle,
@@ -2648,10 +2676,14 @@ function validateProseMirrorDocJson(docJson) {
 }
 function paragraphJsonToSourceParagraph(originalParagraph, paragraphJson) {
   const groups = collectRunGroups(paragraphJson, originalParagraph);
+  const properties = paragraphPropertiesFromJson(
+    originalParagraph?.properties,
+    paragraphJson.attrs?.properties
+  );
   return {
-    ...originalParagraph ?? {},
     runs: groups.map(sourceRunFromGroup),
-    ...originalParagraph?.properties !== void 0 ? { properties: originalParagraph.properties } : {},
+    ...originalParagraph?.rawSidecars !== void 0 ? { rawSidecars: originalParagraph.rawSidecars } : {},
+    ...properties !== void 0 ? { properties } : {},
     ...originalParagraph?.handle !== void 0 ? { handle: originalParagraph.handle } : sourceHandleFromUnknown(paragraphJson.attrs?.handle) !== void 0 ? { handle: sourceHandleFromUnknown(paragraphJson.attrs?.handle) } : {}
   };
 }
@@ -2701,6 +2733,107 @@ function paragraphRunHandlesMatch(originalParagraph, editedParagraph) {
 function paragraphPlainText(paragraph) {
   return paragraph.runs.map((run) => run.text).join("");
 }
+function paragraphPropertiesToEditorCommands(originalParagraph, editedParagraph) {
+  if (editedParagraph.handle === void 0) {
+    if (paragraphEditablePropertiesEqual(originalParagraph.properties, editedParagraph.properties)) {
+      return [];
+    }
+    throw new Error("proseMirrorDocJsonToEditorCommands: changed paragraph has no source handle");
+  }
+  const set = {};
+  const clear = [];
+  if (!stableValueEqual(originalParagraph.properties?.align, editedParagraph.properties?.align)) {
+    if (editedParagraph.properties?.align === void 0) clear.push("align");
+    else set.align = editedParagraph.properties.align;
+  }
+  if (!stableValueEqual(originalParagraph.properties?.level, editedParagraph.properties?.level)) {
+    if (editedParagraph.properties?.level === void 0) clear.push("level");
+    else set.level = editedParagraph.properties.level;
+  }
+  if (!stableValueEqual(originalParagraph.properties?.bullet, editedParagraph.properties?.bullet)) {
+    if (editedParagraph.properties?.bullet === void 0) clear.push("bullet");
+    else set.bullet = editedParagraph.properties.bullet;
+  }
+  const commands = [];
+  if (clear.length > 0) {
+    commands.push({
+      kind: "clearParagraphProperties",
+      handle: editedParagraph.handle,
+      properties: clear
+    });
+  }
+  if (Object.keys(set).length > 0) {
+    commands.push({
+      kind: "setParagraphProperties",
+      handle: editedParagraph.handle,
+      properties: set
+    });
+  }
+  return commands;
+}
+function paragraphPropertiesFromJson(originalProperties, value) {
+  if (!isRecord(value)) return originalProperties;
+  const next = { ...originalProperties ?? {} };
+  for (const property of EDITABLE_PARAGRAPH_PROPERTIES) {
+    if (!Object.prototype.hasOwnProperty.call(value, property)) {
+      delete next[property];
+      continue;
+    }
+    const propertyValue = value[property];
+    if (propertyValue === null || propertyValue === void 0) {
+      delete next[property];
+    } else if (property === "align") {
+      next.align = paragraphAlignFromUnknown(propertyValue);
+    } else if (property === "level") {
+      next.level = paragraphLevelFromUnknown(propertyValue);
+    } else {
+      next.bullet = paragraphBulletFromUnknown(propertyValue);
+    }
+  }
+  return Object.keys(next).length > 0 ? next : void 0;
+}
+function paragraphAlignFromUnknown(value) {
+  if (value === "left" || value === "center" || value === "right" || value === "justify") {
+    return value;
+  }
+  throw new Error("ProseMirror paragraph properties align must be left, center, right, or justify");
+}
+function paragraphLevelFromUnknown(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 8) {
+    return value;
+  }
+  throw new Error("ProseMirror paragraph properties level must be an integer from 0 to 8");
+}
+function paragraphBulletFromUnknown(value) {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    throw new Error("ProseMirror paragraph properties bullet must be an object");
+  }
+  if (value.type === "none") return { type: "none" };
+  if (value.type === "char") {
+    if (typeof value.char !== "string" || value.char.length === 0) {
+      throw new Error("ProseMirror paragraph properties bullet.char must be a non-empty string");
+    }
+    return { type: "char", char: value.char };
+  }
+  if (value.type === "autoNum") {
+    if (!isAutoNumScheme(value.scheme)) {
+      throw new Error("ProseMirror paragraph properties bullet.scheme is unsupported");
+    }
+    if (typeof value.startAt !== "number" || !Number.isInteger(value.startAt) || value.startAt < 1) {
+      throw new Error("ProseMirror paragraph properties bullet.startAt must be positive");
+    }
+    return { type: "autoNum", scheme: value.scheme, startAt: value.startAt };
+  }
+  throw new Error("ProseMirror paragraph properties bullet.type is unsupported");
+}
+function isAutoNumScheme(value) {
+  return typeof value === "string" && AUTO_NUM_SCHEME_SET.has(value);
+}
+function paragraphEditablePropertiesEqual(left, right) {
+  return EDITABLE_PARAGRAPH_PROPERTIES.every(
+    (property) => stableValueEqual(left?.[property], right?.[property])
+  );
+}
 function parsePptxTextBodyProseMirrorDocJson(value) {
   if (!isRecord(value) || value.type !== "doc") {
     throw new Error("ProseMirror text body doc JSON must be a doc node");
@@ -2708,7 +2841,7 @@ function parsePptxTextBodyProseMirrorDocJson(value) {
   if (value.content !== void 0 && readArray(value.content, isParagraphJson) === void 0) {
     throw new Error("ProseMirror text body doc JSON content must contain paragraph nodes");
   }
-  const content = readArray(value.content, isParagraphJson);
+  const content = readArray(value.content, isParagraphJson)?.map(normalizeParagraphJson);
   return {
     type: "doc",
     ...content !== void 0 ? { content } : {}
@@ -2721,6 +2854,13 @@ function isParagraphJson(value) {
   }
   return value.attrs === void 0 || isRecord(value.attrs);
 }
+function normalizeParagraphJson(value) {
+  return {
+    type: "paragraph",
+    ...value.attrs !== void 0 ? { attrs: value.attrs } : {},
+    ...value.content !== void 0 ? { content: value.content } : {}
+  };
+}
 function isTextJson(value) {
   if (!isRecord(value) || value.type !== "text" || typeof value.text !== "string") return false;
   if (value.marks === void 0) return true;
@@ -2758,6 +2898,22 @@ function sourceHandleKey(handle) {
     handle.orderingSlot ?? ""
   ].join("\0");
 }
+function stableValueEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right)) return false;
+    if (left.length !== right.length) return false;
+    return left.every((value, index) => stableValueEqual(value, right[index]));
+  }
+  if (isRecord(left) || isRecord(right)) {
+    if (!isRecord(left) || !isRecord(right)) return false;
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    if (!stableValueEqual(leftKeys, rightKeys)) return false;
+    return leftKeys.every((key) => stableValueEqual(left[key], right[key]));
+  }
+  return false;
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -2871,12 +3027,20 @@ function applyCommandToDocument(document, command) {
       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":
@@ -2889,6 +3053,8 @@ function applyCommandToDocument(document, command) {
       return addEmptySlideFromLayout(document, command);
     case "duplicateSlide":
       return duplicateSlide(document, command.handle);
+    case "moveSlide":
+      return moveSlide(document, command.handle, command);
     case "deleteSlide":
       return deleteSlide(document, command.handle);
   }
@@ -2961,6 +3127,22 @@ function clearTextRunPropertiesCommand(document, command) {
   }
   return clearTextRunProperties(document, command.handle, command.properties);
 }
+function setParagraphPropertiesCommand(document, command) {
+  requireNonEmptyParagraphPropertySet(command.properties, "setParagraphProperties");
+  validateParagraphPropertySet(command.properties, "setParagraphProperties");
+  return 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 clearParagraphProperties(document, command.handle, command.properties);
+}
 function moveShape(document, command) {
   requireFiniteEmu(command.offsetX, "moveShape", "offsetX");
   requireFiniteEmu(command.offsetY, "moveShape", "offsetY");
@@ -2996,6 +3178,14 @@ function setShapeTransform(document, command) {
     height: command.height
   });
 }
+function setShapeFillCommand(document, command) {
+  validateShapeFill(command.fill, "setShapeFill");
+  return setShapeFill(document, command.handle, command.fill);
+}
+function setShapeOutlineCommand(document, command) {
+  validateShapeOutline(command.outline, "setShapeOutline");
+  return setShapeOutline(document, command.handle, command.outline);
+}
 var EDITABLE_TEXT_RUN_PROPERTIES = [
   "bold",
   "italic",
@@ -3005,6 +3195,24 @@ var EDITABLE_TEXT_RUN_PROPERTIES = [
   "typeface"
 ];
 var EDITABLE_TEXT_RUN_PROPERTY_SET = new Set(EDITABLE_TEXT_RUN_PROPERTIES);
+var EDITABLE_PARAGRAPH_PROPERTIES2 = [
+  "align",
+  "level",
+  "bullet"
+];
+var EDITABLE_PARAGRAPH_PROPERTY_SET = new Set(EDITABLE_PARAGRAPH_PROPERTIES2);
+var PARAGRAPH_ALIGN_VALUES = /* @__PURE__ */ new Set(["left", "center", "right", "justify"]);
+var AUTO_NUM_SCHEMES2 = /* @__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`);
@@ -3034,11 +3242,72 @@ function validateTextRunPropertySet(properties, commandName) {
     }
   }
 }
+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_SCHEMES2.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 = findShapeNodeBySourceHandle(document, handle);
   if (shape === void 0) {
@@ -3067,8 +3336,12 @@ function normalizeEditorEdits(document) {
   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) {
@@ -3101,6 +3374,16 @@ function normalizeEditorEdits(document) {
       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)) {
@@ -3117,6 +3400,32 @@ function normalizeEditorEdits(document) {
       }
       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;
@@ -3193,6 +3502,67 @@ function normalizeTextRunPropertiesEdit(edit, seenTextRunProperties) {
   };
   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 };
+}
 
 // src/browser-editor.ts
 var EMU_PER_INCH = 914400;
@@ -3205,6 +3575,12 @@ var DEFAULT_TEXT_BOX_BOUNDS_PX = {
   height: 72
 };
 var DEFAULT_TEXT_BOX_TEXT = "New text box";
+var DEFAULT_CONNECTOR_BOUNDS_PX = {
+  x: 144,
+  y: 144,
+  width: 288,
+  height: 96
+};
 var IMAGE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
 var IMAGE_ACCEPT_BY_CONTENT_TYPE = {
   "image/png": "image/png,.png",
@@ -3302,6 +3678,32 @@ var BrowserPptxEditorSession = class _BrowserPptxEditorSession {
     await this.renderCurrentSlides();
     return this.response(result.warnings);
   }
+  async addConnector(slideNumber = 1, options = {}) {
+    const slide = this.#session.document.slides[slideNumber - 1];
+    if (slide?.handle === void 0) {
+      throw new Error("addConnector: slide handle was not found in PptxSourceModel source");
+    }
+    const existingShapeKeys = new Set(slide.shapes.map(shapeSourceKey));
+    const result = this.#session.apply({
+      kind: "addConnector",
+      slideHandle: slide.handle,
+      preset: "straightConnector1",
+      offsetX: pxToEmu(options.x ?? DEFAULT_CONNECTOR_BOUNDS_PX.x),
+      offsetY: pxToEmu(options.y ?? DEFAULT_CONNECTOR_BOUNDS_PX.y),
+      width: pxToEmu(options.width ?? DEFAULT_CONNECTOR_BOUNDS_PX.width),
+      height: pxToEmu(options.height ?? DEFAULT_CONNECTOR_BOUNDS_PX.height),
+      outline: {
+        tailEnd: { type: "triangle", width: "med", length: "med" }
+      },
+      ...options.name !== void 0 ? { name: options.name } : {}
+    });
+    if (!result.ok) {
+      throw new Error(result.message);
+    }
+    this.#selectNewShape(slideNumber, existingShapeKeys);
+    await this.renderCurrentSlides();
+    return this.response(result.warnings);
+  }
   async deleteShape(handle) {
     const result = this.#session.apply({ kind: "deleteShape", handle });
     if (!result.ok) {
@@ -3414,10 +3816,10 @@ function isEditableTransformShape(shape) {
   return !shape.rawSidecars?.some((sidecar) => sidecar.node.name === "mc:AlternateContent");
 }
 function isDeletableShape(shape, slideShapes) {
-  if (shape.kind !== "shape" || shape.handle?.nodeId === void 0) {
+  if (shape.kind !== "shape" && shape.kind !== "connector" || shape.handle?.nodeId === void 0) {
     return false;
   }
-  if (isShapeReferencedByConnector(shape, slideShapes)) {
+  if (shape.kind === "shape" && isShapeReferencedByConnector(shape, slideShapes)) {
     return false;
   }
   return !shape.rawSidecars?.some((sidecar) => sidecar.node.name === "mc:AlternateContent");