pptx-glimpse 3.0.0 → 3.1.0

package/dist/browser.js

@@ -1,17 +1,31 @@
+import {
+  collectUsedFonts
+} from "./chunk-ZZKN4U5J.js";
 import {
   DEFAULT_OUTPUT_WIDTH,
+  addConnector,
+  addEmptySlideFromLayout,
+  addTextBox,
+  asEmu,
   asPartPath,
   asRelationshipId,
   asSourceNodeId,
-  collectUsedFonts,
+  clearTextRunProperties,
   convertPptxToSvg,
+  deleteShape,
+  deleteSlide,
+  duplicateSlide,
   findShapeNodeBySourceHandle,
   readPptx,
+  renderPptxSourceModelToSvg,
+  replaceImageBytes,
   replaceParagraphPlainText,
   replaceTextRunPlainText,
+  setTextRunProperties,
+  unsafeBrandAssertion,
   updateShapeTransform,
   writePptx
-} from "./chunk-KMSN55AE.js";
+} from "./chunk-NMAO44T7.js";
 import {
   DEFAULT_FONT_MAPPING,
   clearFontCache,
@@ -21,7 +35,7 @@ import {
   getMappedFont,
   getWarningEntries,
   getWarningSummary
-} from "./chunk-2AYNMYMC.js";
+} from "./chunk-PGCREQQU.js";
 import {
   renderSvgToPng
 } from "./chunk-QPT6BMN5.js";
@@ -2795,13 +2809,23 @@ var EditorSession = class {
     const before = this.#document;
     if (commands.length === 0) return { ok: true, document: before };
     try {
-      const after = normalizeEditorEdits(
-        commands.reduce((document, command) => applyCommandToDocument(document, command), before)
-      );
+      let after = before;
+      const warnings = [];
+      for (const command of commands) {
+        after = applyCommandToDocument(after, command);
+        warnings.push(...collectCommandWarnings(after, [command]));
+      }
+      after = normalizeEditorEdits(after);
+      const dedupedWarnings = dedupeCommandWarnings(warnings);
       this.#document = after;
+      this.reconcileSelectionAfterDocumentChange();
       this.#undoStack.push({ before, after });
       this.#redoStack.length = 0;
-      return { ok: true, document: after };
+      return {
+        ok: true,
+        document: after,
+        ...dedupedWarnings.length > 0 ? { warnings: dedupedWarnings } : {}
+      };
     } catch (error) {
       return {
         ok: false,
@@ -2815,6 +2839,7 @@ var EditorSession = class {
     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 };
   }
@@ -2822,9 +2847,16 @@ var EditorSession = class {
     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 (findShapeNodeBySourceHandle(this.#document, this.#selection.shapeHandle) === void 0) {
+      this.#selection = void 0;
+    }
+  }
 };
 function createEditorSession(document) {
   return new EditorSession(document);
@@ -2835,13 +2867,99 @@ function applyCommandToDocument(document, command) {
       return replaceTextRunPlainText(document, command.handle, command.text);
     case "replaceParagraphPlainText":
       return replaceParagraphPlainText(document, command.handle, command.text);
+    case "setTextRunProperties":
+      return setTextRunPropertiesCommand(document, command);
+    case "clearTextRunProperties":
+      return clearTextRunPropertiesCommand(document, command);
     case "moveShape":
       return moveShape(document, command);
     case "resizeShape":
       return resizeShape(document, command);
     case "setShapeTransform":
       return setShapeTransform(document, command);
+    case "addTextBox":
+      return addTextBoxCommand(document, command);
+    case "addConnector":
+      return addConnectorCommand(document, command);
+    case "deleteShape":
+      return deleteShape(document, command.handle);
+    case "replaceImage":
+      return replaceImageBytes(document, command.handle, command.bytes);
+    case "addEmptySlideFromLayout":
+      return addEmptySlideFromLayout(document, command);
+    case "duplicateSlide":
+      return duplicateSlide(document, command.handle);
+    case "deleteSlide":
+      return deleteSlide(document, command.handle);
+  }
+}
+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 (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 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 addConnector(document, command.slideHandle, command);
+}
+function setTextRunPropertiesCommand(document, command) {
+  requireNonEmptyPropertySet(command.properties, "setTextRunProperties");
+  validateTextRunPropertySet(command.properties, "setTextRunProperties");
+  return 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 clearTextRunProperties(document, command.handle, command.properties);
 }
 function moveShape(document, command) {
   requireFiniteEmu(command.offsetX, "moveShape", "offsetX");
@@ -2878,6 +2996,49 @@ function setShapeTransform(document, command) {
     height: command.height
   });
 }
+var EDITABLE_TEXT_RUN_PROPERTIES = [
+  "bold",
+  "italic",
+  "underline",
+  "fontSize",
+  "color",
+  "typeface"
+];
+var EDITABLE_TEXT_RUN_PROPERTY_SET = new Set(EDITABLE_TEXT_RUN_PROPERTIES);
+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 requireBooleanOrUndefined(value, commandName, fieldName) {
+  if (value !== void 0 && typeof value !== "boolean") {
+    throw new Error(`${commandName}: ${fieldName} must be a boolean value`);
+  }
+}
 function requireEditableShapeTransform(document, handle, commandName) {
   const shape = findShapeNodeBySourceHandle(document, handle);
   if (shape === void 0) {
@@ -2905,36 +3066,68 @@ function normalizeEditorEdits(document) {
   const edits = document.edits;
   if (edits === void 0) return document;
   const seenTextRuns = /* @__PURE__ */ new Set();
+  const seenTextRunProperties = /* @__PURE__ */ new Map();
   const seenParagraphs = /* @__PURE__ */ new Set();
   const seenShapeTransforms = /* @__PURE__ */ new Set();
   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)) continue;
-      if (seenTextRuns.has(key)) continue;
+      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 === "replaceParagraphPlainText") {
       const key = editHandleNodeKey(edit);
-      if (seenParagraphs.has(key)) continue;
+      if (seenParagraphs.has(key)) {
+        changed = true;
+        continue;
+      }
       seenParagraphs.add(key);
     }
     if (edit.kind === "updateShapeTransform") {
       const key = editHandleNodeKey(edit);
-      if (seenShapeTransforms.has(key)) continue;
+      if (seenShapeTransforms.has(key)) {
+        changed = true;
+        continue;
+      }
       seenShapeTransforms.add(key);
     }
     normalizedReversed.push(edit);
   }
-  if (normalizedReversed.length === edits.length) return document;
+  if (!changed && normalizedReversed.length === edits.length) return document;
   return {
     ...document,
     edits: normalizedReversed.reverse()
   };
 }
+function editorEditsEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
 function editHandleNodeKey(edit) {
   return [
     edit.handle.partPath,
@@ -2957,10 +3150,70 @@ function textRunParagraphEditKey(edit) {
     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;
+}
 
 // src/browser-editor.ts
 var EMU_PER_INCH = 914400;
 var DEFAULT_DPI = 96;
+var EMU_PER_PIXEL = EMU_PER_INCH / DEFAULT_DPI;
+var DEFAULT_TEXT_BOX_BOUNDS_PX = {
+  x: 96,
+  y: 96,
+  width: 288,
+  height: 72
+};
+var DEFAULT_TEXT_BOX_TEXT = "New text box";
+var IMAGE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+var IMAGE_ACCEPT_BY_CONTENT_TYPE = {
+  "image/png": "image/png,.png",
+  "image/jpeg": "image/jpeg,.jpg,.jpeg",
+  "image/gif": "image/gif,.gif",
+  "image/bmp": "image/bmp,.bmp",
+  "image/tiff": "image/tiff,.tif,.tiff",
+  "image/webp": "image/webp,.webp"
+};
 var BrowserPptxEditorSession = class _BrowserPptxEditorSession {
   #session;
   #slides = [];
@@ -2991,25 +3244,31 @@ var BrowserPptxEditorSession = class _BrowserPptxEditorSession {
   get selection() {
     return this.#session.selection;
   }
-  response() {
+  response(warnings) {
     return {
       slides: this.#slides,
       history: this.history,
-      ...this.selection !== void 0 ? { selection: this.selection } : {}
+      ...this.selection !== void 0 ? { selection: this.selection } : {},
+      ...warnings !== void 0 && warnings.length > 0 ? { warnings } : {}
     };
   }
   shapes(slideNumber) {
     const slide = this.#session.document.slides[slideNumber - 1];
     if (slide === void 0) return [];
-    return slide.shapes.flatMap((shape, index) => shapeInfo(shape, index));
+    return slide.shapes.flatMap(
+      (shape, index) => shapeInfo(this.#session.document, shape, index, true, slide.shapes)
+    );
   }
   async renderCurrentSlides() {
-    const report = await convertPptxToSvg(writePptx(this.#session.document), {
+    const report = await renderPptxSourceModelToSvg(this.#session.document, {
       textOutput: "text",
       skipSystemFonts: true,
       ...this.#renderOptions
     });
-    this.#slides = report.slides;
+    this.#slides = report.slides.map((slide) => ({
+      ...slide,
+      ...this.#session.document.slides[slide.slideNumber - 1]?.handle !== void 0 ? { handle: this.#session.document.slides[slide.slideNumber - 1]?.handle } : {}
+    }));
     return this.#slides;
   }
   async apply(command) {
@@ -3018,7 +3277,45 @@ var BrowserPptxEditorSession = class _BrowserPptxEditorSession {
       throw new Error(result.message);
     }
     await this.renderCurrentSlides();
-    return this.response();
+    return this.response(result.warnings);
+  }
+  async addTextBox(slideNumber = 1, options = {}) {
+    const slide = this.#session.document.slides[slideNumber - 1];
+    if (slide?.handle === void 0) {
+      throw new Error("addTextBox: slide handle was not found in PptxSourceModel source");
+    }
+    const existingShapeKeys = new Set(slide.shapes.map(shapeSourceKey));
+    const result = this.#session.apply({
+      kind: "addTextBox",
+      slideHandle: slide.handle,
+      offsetX: pxToEmu(options.x ?? DEFAULT_TEXT_BOX_BOUNDS_PX.x),
+      offsetY: pxToEmu(options.y ?? DEFAULT_TEXT_BOX_BOUNDS_PX.y),
+      width: pxToEmu(options.width ?? DEFAULT_TEXT_BOX_BOUNDS_PX.width),
+      height: pxToEmu(options.height ?? DEFAULT_TEXT_BOX_BOUNDS_PX.height),
+      text: options.text ?? DEFAULT_TEXT_BOX_TEXT,
+      ...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) {
+      throw new Error(result.message);
+    }
+    await this.renderCurrentSlides();
+    return this.response(result.warnings);
+  }
+  async deleteSelectedShape() {
+    const selection = this.#session.selection;
+    if (selection === void 0) {
+      throw new Error("deleteShape: no selected shape");
+    }
+    return this.deleteShape(selection.shapeHandle);
   }
   async applyTextBodyDocJson(handle, docJson) {
     const textBody = this.#requireEditableShapeTextBody(handle);
@@ -3029,7 +3326,7 @@ var BrowserPptxEditorSession = class _BrowserPptxEditorSession {
       throw new Error(result.message);
     }
     await this.renderCurrentSlides();
-    return this.response();
+    return this.response(result.warnings);
   }
   selectShape(handle) {
     const result = this.#session.selectShape(handle);
@@ -3069,11 +3366,17 @@ var BrowserPptxEditorSession = class _BrowserPptxEditorSession {
     }
     return shape.textBody;
   }
+  #selectNewShape(slideNumber, existingShapeKeys) {
+    const slide = this.#session.document.slides[slideNumber - 1];
+    const addedShape = slide?.shapes.find((shape) => !existingShapeKeys.has(shapeSourceKey(shape)));
+    if (addedShape?.handle === void 0) return;
+    this.#session.selectShape(addedShape.handle);
+  }
 };
 function createBrowserPptxEditorSession(input, renderOptions) {
   return BrowserPptxEditorSession.create(input, renderOptions);
 }
-function shapeInfo(shape, index, editableTransform = true) {
+function shapeInfo(source, shape, index, editableTransform = true, slideShapes = []) {
   const canEditTransform = shape.kind !== "raw" && shape.transform !== void 0 && editableTransform && isEditableTransformShape(shape);
   const base = {
     id: String(shape.nodeId ?? shape.handle?.nodeId ?? `${shape.kind}:${String(index)}`),
@@ -3084,17 +3387,21 @@ function shapeInfo(shape, index, editableTransform = true) {
       bounds: transformBoundsPx(shape.transform),
       editableTransform: true
     } : {},
+    ...editableTransform && isDeletableShape(shape, slideShapes) ? { editableDelete: true } : {},
     ..."textBody" in shape && shape.textBody !== void 0 ? {
       textRuns: collectTextRuns(
         shape.textBody.paragraphs.flatMap((paragraph) => paragraph.runs)
       )
     } : {},
-    ...shape.kind === "shape" && canEditTransform && shape.textBody !== void 0 ? editableTextBody(shape.textBody) : {}
+    ...shape.kind === "shape" && canEditTransform && shape.textBody !== void 0 ? editableTextBody(shape.textBody) : {},
+    ...shape.kind === "image" ? editableImageReplacement(source, shape) : {}
   };
   if (shape.kind !== "group") return [base];
   return [
     base,
-    ...shape.children.flatMap((child, childIndex) => shapeInfo(child, childIndex, false))
+    ...shape.children.flatMap(
+      (child, childIndex) => shapeInfo(source, child, childIndex, false, slideShapes)
+    )
   ];
 }
 function shapeName(shape) {
@@ -3106,6 +3413,20 @@ 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) {
+    return false;
+  }
+  if (isShapeReferencedByConnector(shape, slideShapes)) {
+    return false;
+  }
+  return !shape.rawSidecars?.some((sidecar) => sidecar.node.name === "mc:AlternateContent");
+}
+function isShapeReferencedByConnector(shape, slideShapes) {
+  return slideShapes.some(
+    (candidate) => candidate.kind === "connector" && (candidate.connection?.start?.shapeId === shape.nodeId || candidate.connection?.end?.shapeId === shape.nodeId)
+  );
+}
 function collectTextRuns(runs) {
   return runs.flatMap((run) => {
     if (run.handle === void 0) return [];
@@ -3119,6 +3440,134 @@ function editableTextBody(textBody) {
     return {};
   }
 }
+function editableImageReplacement(source, image) {
+  const media = imageMediaPart(source, image);
+  if (media === void 0) return {};
+  const accept = IMAGE_ACCEPT_BY_CONTENT_TYPE[media.contentType];
+  if (accept === void 0) return {};
+  return {
+    editableImageReplacement: {
+      contentType: media.contentType,
+      accept,
+      mediaPartPath: media.partPath,
+      sharedReferenceCount: countImageReferencesToMedia(source, media.partPath)
+    }
+  };
+}
+function imageMediaPart(source, image) {
+  if (image.blipRelationshipId === void 0 || image.handle?.partPath === void 0) {
+    return void 0;
+  }
+  const mediaPartPath = imageMediaPartPath(source, image.handle.partPath, image.blipRelationshipId);
+  if (mediaPartPath === void 0) return void 0;
+  return source.packageGraph.media.find((part) => part.partPath === mediaPartPath);
+}
+function imageMediaPartPath(source, sourcePartPath, relationshipId) {
+  const relationships = source.packageGraph.relationships.find(
+    (candidate) => candidate.sourcePartPath === sourcePartPath
+  );
+  const relationship = relationships?.relationships.find(
+    (candidate) => candidate.id === relationshipId && candidate.type === IMAGE_REL_TYPE
+  );
+  if (relationship === void 0) return void 0;
+  return resolveInternalRelationshipTarget(sourcePartPath, relationship);
+}
+function countImageReferencesToMedia(source, mediaPartPath) {
+  const parsedImageRelationshipKeys = /* @__PURE__ */ new Set();
+  let count = 0;
+  for (const slide of source.slides) {
+    count += countImageReferencesInTree(
+      source,
+      slide.partPath,
+      slide.shapes,
+      mediaPartPath,
+      parsedImageRelationshipKeys
+    );
+  }
+  for (const layout of source.slideLayouts) {
+    count += countImageReferencesInTree(
+      source,
+      layout.partPath,
+      layout.shapes,
+      mediaPartPath,
+      parsedImageRelationshipKeys
+    );
+  }
+  for (const master of source.slideMasters) {
+    count += countImageReferencesInTree(
+      source,
+      master.partPath,
+      master.shapes,
+      mediaPartPath,
+      parsedImageRelationshipKeys
+    );
+  }
+  for (const relationships of source.packageGraph.relationships) {
+    for (const relationship of relationships.relationships) {
+      if (relationship.type !== IMAGE_REL_TYPE) continue;
+      if (parsedImageRelationshipKeys.has(
+        imageRelationshipKey(relationships.sourcePartPath, relationship.id)
+      )) {
+        continue;
+      }
+      if (resolveInternalRelationshipTarget(relationships.sourcePartPath, relationship) === mediaPartPath) {
+        count += 1;
+      }
+    }
+  }
+  return count;
+}
+function countImageReferencesInTree(source, sourcePartPath, shapes, mediaPartPath, parsedImageRelationshipKeys) {
+  let count = 0;
+  for (const shape of shapes) {
+    if (shape.kind === "group") {
+      count += countImageReferencesInTree(
+        source,
+        sourcePartPath,
+        shape.children,
+        mediaPartPath,
+        parsedImageRelationshipKeys
+      );
+      continue;
+    }
+    if (shape.kind !== "image" || shape.blipRelationshipId === void 0) continue;
+    if (imageMediaPartPath(source, sourcePartPath, shape.blipRelationshipId) === mediaPartPath) {
+      count += 1;
+      parsedImageRelationshipKeys.add(
+        imageRelationshipKey(sourcePartPath, shape.blipRelationshipId)
+      );
+    }
+  }
+  return count;
+}
+function imageRelationshipKey(partPath, relationshipId) {
+  return `${partPath}\0${relationshipId}`;
+}
+function resolveInternalRelationshipTarget(sourcePartPath, relationship) {
+  if (relationship.targetMode === "External") return void 0;
+  return unsafeBrandAssertion(
+    normalizePackagePath(
+      relationship.target.startsWith("/") ? relationship.target.slice(1) : joinPackageRelativeTarget(sourcePartPath, relationship.target)
+    )
+  );
+}
+function joinPackageRelativeTarget(sourcePartPath, target) {
+  const slash = sourcePartPath.lastIndexOf("/");
+  const baseDir = slash === -1 ? "" : sourcePartPath.slice(0, slash);
+  return baseDir === "" ? target : `${baseDir}/${target}`;
+}
+function normalizePackagePath(path) {
+  const segments = [];
+  for (const segment of path.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  return segments.join("/");
+}
 function transformBoundsPx(transform) {
   return {
     x: emuToPixels(transform.offsetX),
@@ -3130,6 +3579,19 @@ function transformBoundsPx(transform) {
 function emuToPixels(value) {
   return value / EMU_PER_INCH * DEFAULT_DPI;
 }
+function pxToEmu(value) {
+  return asEmu(Math.round(value * EMU_PER_PIXEL));
+}
+function shapeSourceKey(shape) {
+  const handle = shape.handle;
+  return [
+    shape.kind,
+    handle?.partPath ?? "",
+    handle?.nodeId ?? "",
+    handle?.relationshipId ?? "",
+    handle?.orderingSlot ?? ""
+  ].join("\0");
+}
 
 // src/browser.ts
 async function convertPptxToPng(input, options) {
@@ -3176,5 +3638,6 @@ export {
   getMappedFont,
   getWarningEntries,
   getWarningSummary,
-  initResvgWasm2 as initResvgWasm
+  initResvgWasm2 as initResvgWasm,
+  renderPptxSourceModelToSvg
 };