ooxml-core 1.19.2 → 1.21.0

package/dist/pptx/automation/index.cjs

@@ -4180,13 +4180,14 @@ var init_SlideBuilder = __esm({
   "pptx/core/builders/sdk/SlideBuilder.ts"() {
     init_ElementFactory();
     SlideBuilder = class {
-      slide;
       /**
        * @param slideNumber - 1-based slide number.
        * @param layoutPath - Optional layout archive path.
        * @param layoutName - Optional layout display name.
+       * @param handler - Loaded deck context for placeholder geometry and text styles.
        */
-      constructor(slideNumber, layoutPath, layoutName) {
+      constructor(slideNumber, layoutPath, layoutName, handler) {
+        this.handler = handler;
         this.slide = {
           id: `slide${slideNumber}`,
           rId: `rId${slideNumber + 1}`,
@@ -4196,11 +4197,52 @@ var init_SlideBuilder = __esm({
           layoutName: layoutName ?? "Title Slide"
         };
       }
+      handler;
+      slide;
       /** Add a text box to the slide. */
       addText(text2, options) {
         this.slide.elements.push(createTextElement(text2, options));
         return this;
       }
+      /**
+       * Fill a layout placeholder, inheriting its frame and text styles.
+       *
+       * Unlike addText, this writes a real p:ph binding, not a free text box.
+       * Use idx to select repeated slots (for example, Two Content's 1 and 2).
+       * Explicit frame fields override the layout; all other fields inherit.
+       * A standalone builder requires the fourth constructor argument (a loaded
+       * handler), even with an explicit frame, so text styles resolve consistently.
+       * Missing slots without a complete frame throw instead of creating a text box.
+       * Master frames requiring compatible-role fallback are materialized locally
+       * for new content only, keeping existing-deck loading unchanged.
+       *
+       * @example
+       * ```ts
+       * createSlide('Title Slide')
+       *   .addPlaceholder('ctrTitle', 'Quarterly review')
+       *   .addPlaceholder('subTitle', 'October 2026');
+       * createSlide('Two Content').addPlaceholder('body', 'Right column', { idx: 2 });
+       * ```
+       */
+      addPlaceholder(type, text2, options = {}) {
+        const input = createTextElement(text2);
+        const context = `Slide ${this.slide.slideNumber} (${this.slide.id}), placeholder ${type} idx=${options.idx ?? "auto"}, layout ${this.slide.layoutName} (${this.slide.layoutPath})`;
+        try {
+          if (!this.handler) {
+            throw new Error(
+              "addPlaceholder requires a loaded handler as the fourth SlideBuilder constructor argument"
+            );
+          }
+          this.slide.elements.push(
+            this.handler.createPlaceholderElement(this.slide.layoutPath, input, type, options)
+          );
+        } catch (error) {
+          throw new Error(`${context}: ${error instanceof Error ? error.message : String(error)}`, {
+            cause: error
+          });
+        }
+        return this;
+      }
       /** Add a shape to the slide. */
       addShape(shapeType, options) {
         this.slide.elements.push(createShapeElement(shapeType, options));
@@ -4440,6 +4482,254 @@ var init_SlideBuilder = __esm({
     };
   }
 });
+function isSafePartName(name) {
+  if (name.includes("\0") || name.includes("\\")) return false;
+  if (/^[A-Za-z]:/u.test(name)) return false;
+  const body = name.startsWith("/") ? name.slice(1) : name;
+  if (body.startsWith("/")) return false;
+  return !body.split("/").some((segment) => segment === "..");
+}
+function declaredEntrySize(entry2) {
+  const data = entry2._data;
+  const size = Number(data?.uncompressedSize ?? 0);
+  return Number.isFinite(size) && size > 0 ? size : 0;
+}
+function resolveLimits(limits) {
+  const create = limits.createError;
+  return {
+    maxEntries: limits.maxEntries ?? DEFAULT_ZIP_LIMITS.maxEntries,
+    maxEntryBytes: limits.maxEntryBytes ?? DEFAULT_ZIP_LIMITS.maxEntryBytes,
+    maxTotalBytes: limits.maxTotalBytes ?? DEFAULT_ZIP_LIMITS.maxTotalBytes,
+    label: limits.label ?? "ZIP",
+    fail: (message, limit, kind) => create ? create(message, { limit, kind }) : new ZipLimitError(message, { limit, kind })
+  };
+}
+function inflateEntryGuarded(entry2, alreadyRead, limits) {
+  const r = resolveLimits(limits);
+  const declared = declaredEntrySize(entry2);
+  return new Promise((resolvePromise, reject) => {
+    const chunks = [];
+    let size = 0;
+    let done = false;
+    const stream = entry2.internalStream("uint8array");
+    const abort = (error) => {
+      if (done) return;
+      done = true;
+      stream.pause();
+      chunks.length = 0;
+      reject(error);
+    };
+    stream.on("data", (chunk2) => {
+      if (done) return;
+      size += chunk2.byteLength;
+      if (size > declared || size > r.maxEntryBytes)
+        return abort(
+          r.fail(
+            `${r.label} part ${entry2.name} inflates past its declared size`,
+            r.maxEntryBytes,
+            size > declared ? "declaredSize" : "maxEntryBytes"
+          )
+        );
+      if (alreadyRead + size > r.maxTotalBytes)
+        return abort(
+          r.fail(
+            `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
+            r.maxTotalBytes,
+            "maxTotalBytes"
+          )
+        );
+      chunks.push(chunk2);
+    });
+    stream.on("error", (error) => abort(error));
+    stream.on("end", () => {
+      if (done) return;
+      done = true;
+      if (chunks.length === 1 && chunks[0]) return resolvePromise(chunks[0]);
+      const out = new Uint8Array(size);
+      let offset = 0;
+      for (const chunk2 of chunks) {
+        out.set(chunk2, offset);
+        offset += chunk2.byteLength;
+      }
+      resolvePromise(out);
+    });
+    stream.resume();
+  });
+}
+function toBase64(bytes) {
+  let binary = "";
+  for (let i2 = 0; i2 < bytes.length; i2 += 32768)
+    binary += String.fromCharCode(...bytes.subarray(i2, i2 + 32768));
+  return btoa(binary);
+}
+function guardZip(zip, limits = {}) {
+  const r = resolveLimits(limits);
+  const entries = Object.values(zip.files);
+  if (entries.length > r.maxEntries)
+    throw r.fail(
+      `${r.label} package exceeds the ${r.maxEntries.toLocaleString("en-US")} part limit`,
+      r.maxEntries,
+      "maxEntries"
+    );
+  let declared = 0;
+  for (const entry2 of entries) {
+    const original = entry2.unsafeOriginalName;
+    if (!isSafePartName(entry2.name) || original !== void 0 && !isSafePartName(original))
+      throw r.fail(`${r.label} package has an unsafe part name`, r.maxEntries, "partName");
+    if (entry2.dir) continue;
+    const size = declaredEntrySize(entry2);
+    if (size > r.maxEntryBytes)
+      throw r.fail(
+        `${r.label} part ${entry2.name} exceeds the uncompressed part size limit`,
+        r.maxEntryBytes,
+        "maxEntryBytes"
+      );
+    declared += size;
+  }
+  if (declared > r.maxTotalBytes)
+    throw r.fail(
+      `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
+      r.maxTotalBytes,
+      "maxTotalBytes"
+    );
+  const produced = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (const entry2 of entries) {
+    if (entry2.dir) continue;
+    const inflateOriginal = entry2.async.bind(entry2);
+    entry2.async = async (type, onUpdate) => {
+      const previous = produced.get(entry2.name) ?? 0;
+      const bytes = await inflateEntryGuarded(entry2, total - previous, limits);
+      if (bytes.byteLength > previous) {
+        total += bytes.byteLength - previous;
+        produced.set(entry2.name, bytes.byteLength);
+      }
+      switch (type) {
+        case "uint8array":
+          return bytes;
+        case "string":
+        case "text":
+          return new TextDecoder("utf-8", { ignoreBOM: true }).decode(bytes);
+        case "arraybuffer":
+          return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+        case "base64":
+          return toBase64(bytes);
+        default:
+          return inflateOriginal(type, onUpdate);
+      }
+    };
+  }
+  return zip;
+}
+async function openZip(input, limits = {}) {
+  const r = resolveLimits(limits);
+  const maxInput = limits.maxInputBytes ?? DEFAULT_ZIP_LIMITS.maxInputBytes;
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  if (bytes.byteLength > maxInput)
+    throw r.fail(
+      `${r.label} package exceeds the ${mib(maxInput)} MiB compressed input limit`,
+      maxInput,
+      "maxInputBytes"
+    );
+  return guardZip(await JSZip__default.default.loadAsync(bytes), limits);
+}
+var DEFAULT_ZIP_LIMITS, ZipLimitError, mib;
+var init_zip_limits = __esm({
+  "opc/zip-limits.ts"() {
+    DEFAULT_ZIP_LIMITS = {
+      maxInputBytes: 100 * 1024 * 1024,
+      maxEntries: 1e4,
+      maxEntryBytes: 100 * 1024 * 1024,
+      maxTotalBytes: 100 * 1024 * 1024
+    };
+    ZipLimitError = class extends Error {
+      code = "ZIP_BOMB";
+      limit;
+      /** The check that failed (absent when the error was built without one). */
+      kind;
+      constructor(message, details) {
+        super(message);
+        this.name = "ZipLimitError";
+        this.limit = details.limit;
+        this.kind = details.kind;
+      }
+    };
+    mib = (bytes) => Math.round(bytes / 1048576);
+  }
+});
+
+// pptx/core/core/types.ts
+var DEFAULT_MAX_UNCOMPRESSED_BYTES, MAX_ZIP_ENTRY_COUNT, ZipBombError;
+var init_types2 = __esm({
+  "pptx/core/core/types.ts"() {
+    DEFAULT_MAX_UNCOMPRESSED_BYTES = 500 * 1024 * 1024;
+    MAX_ZIP_ENTRY_COUNT = 65536;
+    ZipBombError = class extends Error {
+      code = "ZIP_BOMB";
+      uncompressedBytes;
+      limit;
+      entryCount;
+      constructor(message, details) {
+        super(message);
+        this.name = "ZipBombError";
+        this.uncompressedBytes = details.uncompressedBytes;
+        this.limit = details.limit;
+        this.entryCount = details.entryCount;
+      }
+    };
+  }
+});
+
+// pptx/core/utils/zip-open.ts
+function openPptxZip(bytes) {
+  return openZip(bytes, {
+    label: "PPTX",
+    maxInputBytes: DEFAULT_MAX_UNCOMPRESSED_BYTES,
+    maxEntries: MAX_ZIP_ENTRY_COUNT,
+    maxEntryBytes: DEFAULT_MAX_UNCOMPRESSED_BYTES,
+    maxTotalBytes: DEFAULT_MAX_UNCOMPRESSED_BYTES,
+    createError
+  });
+}
+function openNestedZip(bytes) {
+  return openZip(bytes, { label: "Embedded", createError });
+}
+var createError;
+var init_zip_open = __esm({
+  "pptx/core/utils/zip-open.ts"() {
+    init_zip_limits();
+    init_types2();
+    createError = (message, details) => new ZipBombError(message, details);
+  }
+});
+
+// pptx/core/builders/sdk/layout-operations.ts
+function pxToEmu(px2) {
+  return Math.round(px2 * EMU_PER_PIXEL2);
+}
+function placeholderSpXml(ph, shapeId) {
+  const name = ph.name ?? `${ph.type.charAt(0).toUpperCase() + ph.type.slice(1)} Placeholder ${shapeId - 1}`;
+  const x = pxToEmu(ph.x);
+  const y = pxToEmu(ph.y);
+  const cx = pxToEmu(ph.width);
+  const cy = pxToEmu(ph.height);
+  const idxAttr = ph.idx !== void 0 ? ` idx="${Math.max(0, Math.round(ph.idx))}"` : "";
+  return `      <p:sp>
+        <p:nvSpPr>
+          <p:cNvPr id="${shapeId}" name="${escAttr(name)}"/>
+          <p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr>
+          <p:nvPr><p:ph type="${escAttr(ph.type)}"${idxAttr}/></p:nvPr>
+        </p:nvSpPr>
+        <p:spPr>
+          <a:xfrm><a:off x="${x}" y="${y}"/><a:ext cx="${cx}" cy="${cy}"/></a:xfrm>
+        </p:spPr>
+        <p:txBody>
+          <a:bodyPr/>
+          <a:lstStyle/>
+          <a:p><a:endParaRPr lang="en-US"/></a:p>
+        </p:txBody>
+      </p:sp>`;
+}
 function normalizeSrgbHex(color2) {
   if (!color2) {
     return void 0;
@@ -4453,10 +4743,134 @@ function normalizeSrgbHex(color2) {
   }
   return void 0;
 }
+function generateLayoutXml(definition) {
+  const layoutType = definition.type ?? "obj";
+  const placeholders = definition.placeholders ?? [];
+  const phShapes = placeholders.map((ph, i2) => placeholderSpXml(ph, i2 + 2)).join("\n");
+  let bgXml = "";
+  const hex3 = normalizeSrgbHex(definition.backgroundColor);
+  if (hex3) {
+    bgXml = `    <p:bg><p:bgPr><a:solidFill><a:srgbClr val="${hex3}"/></a:solidFill><a:effectLst/></p:bgPr></p:bg>
+`;
+  }
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<p:sldLayout xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+  xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main"
+  type="${escAttr(layoutType)}" preserve="1">
+  <p:cSld name="${escAttr(definition.name)}">
+${bgXml}    <p:spTree>
+      <p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr>
+      <p:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/><a:chOff x="0" y="0"/><a:chExt cx="0" cy="0"/></a:xfrm></p:grpSpPr>
+${phShapes}
+    </p:spTree>
+  </p:cSld>
+  <p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr>
+</p:sldLayout>`;
+}
+function findLayoutByName(data, name) {
+  const lowerName = name.toLowerCase();
+  const fromOptions = data.layoutOptions?.find((l) => l.name.toLowerCase() === lowerName);
+  if (fromOptions) {
+    return fromOptions;
+  }
+  if (data.slideMasters) {
+    for (const master of data.slideMasters) {
+      const layout = master.layouts?.find((l) => l.name?.toLowerCase() === lowerName);
+      if (layout) {
+        return { path: layout.path, name: layout.name ?? name };
+      }
+    }
+  }
+  return void 0;
+}
+function findLayoutByType(data, type) {
+  const fromOptions = data.layoutOptions?.find((l) => l.type === type);
+  if (fromOptions) {
+    return fromOptions;
+  }
+  return void 0;
+}
+var EMU_PER_PIXEL2;
+var init_layout_operations = __esm({
+  "pptx/core/builders/sdk/layout-operations.ts"() {
+    init_xml_utils();
+    EMU_PER_PIXEL2 = 9525;
+  }
+});
+
+// pptx/core/builders/sdk/standard-layout-placeholders.ts
+function standardLayoutPlaceholders(type, width, height) {
+  if (type === "blank") return [];
+  const box = (type2, idx, x, y, w, h2) => ({
+    type: type2,
+    idx,
+    x: x * width,
+    y: y * height,
+    width: w * width,
+    height: h2 * height
+  });
+  const title = box("title", 0, 0.05, 0.04, 0.9, 0.15);
+  const content2 = box("obj", 1, 0.05, 0.23, 0.9, 0.64);
+  let slots;
+  switch (type) {
+    case "title":
+      slots = [
+        box("ctrTitle", 0, 0.08, 0.24, 0.84, 0.22),
+        box("subTitle", 1, 0.12, 0.49, 0.76, 0.2)
+      ];
+      break;
+    case "secHead":
+      slots = [box("title", 0, 0.05, 0.37, 0.9, 0.2), box("body", 1, 0.05, 0.6, 0.9, 0.23)];
+      break;
+    case "twoObj":
+    case "twoTxTwoObj":
+      slots = [title, box("obj", 1, 0.05, 0.27, 0.43, 0.6), box("obj", 2, 0.52, 0.27, 0.43, 0.6)];
+      if (type === "twoTxTwoObj")
+        slots.push(box("body", 3, 0.05, 0.2, 0.43, 0.07), box("body", 4, 0.52, 0.2, 0.43, 0.07));
+      break;
+    case "titleOnly":
+      slots = [title];
+      break;
+    case "objTx":
+    case "picTx":
+      slots = [
+        title,
+        box(type === "picTx" ? "pic" : "obj", 1, 0.36, 0.23, 0.59, 0.64),
+        box("body", 2, 0.05, 0.23, 0.27, 0.64)
+      ];
+      break;
+    default:
+      slots = [title, content2];
+  }
+  return [
+    ...slots,
+    box("dt", 10, 0.05, 0.92, 0.25, 0.04),
+    box("ftr", 11, 0.33, 0.92, 0.34, 0.04),
+    box("sldNum", 12, 0.75, 0.92, 0.2, 0.04)
+  ];
+}
+var init_standard_layout_placeholders = __esm({
+  "pptx/core/builders/sdk/standard-layout-placeholders.ts"() {
+  }
+});
+function normalizeSrgbHex2(color2) {
+  if (!color2) {
+    return void 0;
+  }
+  const raw = color2.trim().replace(/^#/, "").toUpperCase();
+  if (/^[0-9A-F]{6}$/.test(raw)) {
+    return raw;
+  }
+  if (/^[0-9A-F]{3}$/.test(raw)) {
+    return raw.replace(/./g, (ch) => ch + ch);
+  }
+  return void 0;
+}
 function resolveThemeColors(overrides) {
   const resolved = {};
   for (const [key2, fallback] of Object.entries(DEFAULT_COLORS)) {
-    resolved[key2] = normalizeSrgbHex(overrides?.[key2]) ?? normalizeSrgbHex(fallback) ?? "000000";
+    resolved[key2] = normalizeSrgbHex2(overrides?.[key2]) ?? normalizeSrgbHex2(fallback) ?? "000000";
   }
   return resolved;
 }
@@ -4596,21 +5010,6 @@ ${layoutRels}
   <Relationship Id="rId${layoutCount + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme" Target="../theme/theme1.xml"/>
 </Relationships>`;
 }
-function slideLayoutXml(name, layoutType) {
-  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<p:sldLayout xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
-  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
-  xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main"
-  type="${escAttr(layoutType)}" preserve="1">
-  <p:cSld name="${escAttr(name)}">
-    <p:spTree>
-      <p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr>
-      <p:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/><a:chOff x="0" y="0"/><a:chExt cx="0" cy="0"/></a:xfrm></p:grpSpPr>
-    </p:spTree>
-  </p:cSld>
-  <p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr>
-</p:sldLayout>`;
-}
 function slideLayoutRelsXml() {
   return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
@@ -4759,7 +5158,14 @@ async function buildBlankPresentationArchive(options) {
   zip.file("ppt/slideMasters/_rels/slideMaster1.xml.rels", slideMasterRelsXml(layoutCount));
   for (let i2 = 0; i2 < layoutCount; i2++) {
     const layout = STANDARD_LAYOUTS[i2];
-    zip.file(`ppt/slideLayouts/slideLayout${i2 + 1}.xml`, slideLayoutXml(layout.name, layout.type));
+    zip.file(
+      `ppt/slideLayouts/slideLayout${i2 + 1}.xml`,
+      generateLayoutXml({
+        name: layout.name,
+        type: layout.type,
+        placeholders: standardLayoutPlaceholders(layout.type, width / 9525, height / 9525)
+      })
+    );
     zip.file(`ppt/slideLayouts/_rels/slideLayout${i2 + 1}.xml.rels`, slideLayoutRelsXml());
   }
   for (let i2 = 0; i2 < initialSlideCount; i2++) {
@@ -4780,6 +5186,8 @@ var init_PresentationBuilder = __esm({
     init_xml_utils();
     init_PptxHandler();
     init_SlideBuilder();
+    init_layout_operations();
+    init_standard_layout_placeholders();
     DEFAULT_WIDTH = 12192e3;
     DEFAULT_HEIGHT = 6858e3;
     DEFAULT_COLORS = {
@@ -4837,7 +5245,7 @@ var init_PresentationBuilder = __esm({
           const layoutIdx = STANDARD_LAYOUTS.findIndex((l) => l.name === layoutName) + 1 || 7;
           const layoutPath = `ppt/slideLayouts/slideLayout${layoutIdx}.xml`;
           const resolvedName = layoutName ?? STANDARD_LAYOUTS[layoutIdx - 1]?.name ?? "Blank";
-          return new SlideBuilder(slideNum, layoutPath, resolvedName);
+          return new SlideBuilder(slideNum, layoutPath, resolvedName, handler);
         };
         return { handler, data, createSlide };
       }
@@ -14718,7 +15126,7 @@ function getShapeType(shapeType) {
   if (normalized === "downarrow") {
     return "downArrow";
   }
-  if (normalized.includes("connector")) {
+  if (normalized.includes("connector") && !normalized.startsWith("flowchart")) {
     return "connector";
   }
   if (PRESET_SHAPE_CLIP_PATHS[normalized] !== void 0) {
@@ -17239,214 +17647,6 @@ var init_ole_embedded_replace = __esm({
     CONTENTS_STREAM2 = "CONTENTS";
   }
 });
-function isSafePartName(name) {
-  if (name.includes("\0") || name.includes("\\")) return false;
-  if (/^[A-Za-z]:/u.test(name)) return false;
-  const body = name.startsWith("/") ? name.slice(1) : name;
-  if (body.startsWith("/")) return false;
-  return !body.split("/").some((segment) => segment === "..");
-}
-function declaredEntrySize(entry2) {
-  const data = entry2._data;
-  const size = Number(data?.uncompressedSize ?? 0);
-  return Number.isFinite(size) && size > 0 ? size : 0;
-}
-function resolveLimits(limits) {
-  const create = limits.createError;
-  return {
-    maxEntries: limits.maxEntries ?? DEFAULT_ZIP_LIMITS.maxEntries,
-    maxEntryBytes: limits.maxEntryBytes ?? DEFAULT_ZIP_LIMITS.maxEntryBytes,
-    maxTotalBytes: limits.maxTotalBytes ?? DEFAULT_ZIP_LIMITS.maxTotalBytes,
-    label: limits.label ?? "ZIP",
-    fail: (message, limit) => create ? create(message, { limit }) : new ZipLimitError(message, { limit })
-  };
-}
-function inflateEntryGuarded(entry2, alreadyRead, limits) {
-  const r = resolveLimits(limits);
-  const declared = declaredEntrySize(entry2);
-  return new Promise((resolvePromise, reject) => {
-    const chunks = [];
-    let size = 0;
-    let done = false;
-    const stream = entry2.internalStream("uint8array");
-    const abort = (error) => {
-      if (done) return;
-      done = true;
-      stream.pause();
-      chunks.length = 0;
-      reject(error);
-    };
-    stream.on("data", (chunk2) => {
-      if (done) return;
-      size += chunk2.byteLength;
-      if (size > declared || size > r.maxEntryBytes)
-        return abort(
-          r.fail(`${r.label} part ${entry2.name} inflates past its declared size`, r.maxEntryBytes)
-        );
-      if (alreadyRead + size > r.maxTotalBytes)
-        return abort(
-          r.fail(
-            `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
-            r.maxTotalBytes
-          )
-        );
-      chunks.push(chunk2);
-    });
-    stream.on("error", (error) => abort(error));
-    stream.on("end", () => {
-      if (done) return;
-      done = true;
-      if (chunks.length === 1 && chunks[0]) return resolvePromise(chunks[0]);
-      const out = new Uint8Array(size);
-      let offset = 0;
-      for (const chunk2 of chunks) {
-        out.set(chunk2, offset);
-        offset += chunk2.byteLength;
-      }
-      resolvePromise(out);
-    });
-    stream.resume();
-  });
-}
-function toBase64(bytes) {
-  let binary = "";
-  for (let i2 = 0; i2 < bytes.length; i2 += 32768)
-    binary += String.fromCharCode(...bytes.subarray(i2, i2 + 32768));
-  return btoa(binary);
-}
-function guardZip(zip, limits = {}) {
-  const r = resolveLimits(limits);
-  const entries = Object.values(zip.files);
-  if (entries.length > r.maxEntries)
-    throw r.fail(
-      `${r.label} package exceeds the ${r.maxEntries.toLocaleString("en-US")} part limit`,
-      r.maxEntries
-    );
-  let declared = 0;
-  for (const entry2 of entries) {
-    const original = entry2.unsafeOriginalName;
-    if (!isSafePartName(entry2.name) || original !== void 0 && !isSafePartName(original))
-      throw r.fail(`${r.label} package has an unsafe part name`, r.maxEntries);
-    if (entry2.dir) continue;
-    const size = declaredEntrySize(entry2);
-    if (size > r.maxEntryBytes)
-      throw r.fail(
-        `${r.label} part ${entry2.name} exceeds the uncompressed part size limit`,
-        r.maxEntryBytes
-      );
-    declared += size;
-  }
-  if (declared > r.maxTotalBytes)
-    throw r.fail(
-      `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
-      r.maxTotalBytes
-    );
-  const produced = /* @__PURE__ */ new Map();
-  let total = 0;
-  for (const entry2 of entries) {
-    if (entry2.dir) continue;
-    const inflateOriginal = entry2.async.bind(entry2);
-    entry2.async = async (type, onUpdate) => {
-      const previous = produced.get(entry2.name) ?? 0;
-      const bytes = await inflateEntryGuarded(entry2, total - previous, limits);
-      if (bytes.byteLength > previous) {
-        total += bytes.byteLength - previous;
-        produced.set(entry2.name, bytes.byteLength);
-      }
-      switch (type) {
-        case "uint8array":
-          return bytes;
-        case "string":
-        case "text":
-          return new TextDecoder("utf-8", { ignoreBOM: true }).decode(bytes);
-        case "arraybuffer":
-          return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-        case "base64":
-          return toBase64(bytes);
-        default:
-          return inflateOriginal(type, onUpdate);
-      }
-    };
-  }
-  return zip;
-}
-async function openZip(input, limits = {}) {
-  const r = resolveLimits(limits);
-  const maxInput = limits.maxInputBytes ?? DEFAULT_ZIP_LIMITS.maxInputBytes;
-  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
-  if (bytes.byteLength > maxInput)
-    throw r.fail(
-      `${r.label} package exceeds the ${mib(maxInput)} MiB compressed input limit`,
-      maxInput
-    );
-  return guardZip(await JSZip__default.default.loadAsync(bytes), limits);
-}
-var DEFAULT_ZIP_LIMITS, ZipLimitError, mib;
-var init_zip_limits = __esm({
-  "opc/zip-limits.ts"() {
-    DEFAULT_ZIP_LIMITS = {
-      maxInputBytes: 100 * 1024 * 1024,
-      maxEntries: 1e4,
-      maxEntryBytes: 100 * 1024 * 1024,
-      maxTotalBytes: 100 * 1024 * 1024
-    };
-    ZipLimitError = class extends Error {
-      code = "ZIP_BOMB";
-      limit;
-      constructor(message, details) {
-        super(message);
-        this.name = "ZipLimitError";
-        this.limit = details.limit;
-      }
-    };
-    mib = (bytes) => Math.round(bytes / 1048576);
-  }
-});
-
-// pptx/core/core/types.ts
-var DEFAULT_MAX_UNCOMPRESSED_BYTES, MAX_ZIP_ENTRY_COUNT, ZipBombError;
-var init_types2 = __esm({
-  "pptx/core/core/types.ts"() {
-    DEFAULT_MAX_UNCOMPRESSED_BYTES = 500 * 1024 * 1024;
-    MAX_ZIP_ENTRY_COUNT = 65536;
-    ZipBombError = class extends Error {
-      code = "ZIP_BOMB";
-      uncompressedBytes;
-      limit;
-      entryCount;
-      constructor(message, details) {
-        super(message);
-        this.name = "ZipBombError";
-        this.uncompressedBytes = details.uncompressedBytes;
-        this.limit = details.limit;
-        this.entryCount = details.entryCount;
-      }
-    };
-  }
-});
-
-// pptx/core/utils/zip-open.ts
-function openPptxZip(bytes) {
-  return openZip(bytes, {
-    label: "PPTX",
-    maxInputBytes: DEFAULT_MAX_UNCOMPRESSED_BYTES,
-    maxEntries: MAX_ZIP_ENTRY_COUNT,
-    maxEntryBytes: DEFAULT_MAX_UNCOMPRESSED_BYTES,
-    maxTotalBytes: DEFAULT_MAX_UNCOMPRESSED_BYTES,
-    createError
-  });
-}
-function openNestedZip(bytes) {
-  return openZip(bytes, { label: "Embedded", createError });
-}
-var createError;
-var init_zip_open = __esm({
-  "pptx/core/utils/zip-open.ts"() {
-    init_zip_limits();
-    init_types2();
-    createError = (message, details) => new ZipBombError(message, details);
-  }
-});
 
 // pptx/core/utils/ole-payload-kind.ts
 function isZipMagic(bytes) {
@@ -39397,9 +39597,18 @@ function checkXmlLimits(xml, label, limits = {}) {
       continue;
     }
     nodes++;
-    if (nodes > maxNodes) throw new Error(`${label} XML exceeds the limit of ${maxNodes} elements`);
+    if (nodes > maxNodes)
+      throw new XmlLimitError(
+        `${label} XML exceeds the limit of ${maxNodes} elements`,
+        "maxNodes",
+        maxNodes
+      );
     if (!selfClosing && ++depth > maxDepth2)
-      throw new Error(`${label} XML exceeds the nesting depth limit of ${maxDepth2}`);
+      throw new XmlLimitError(
+        `${label} XML exceeds the nesting depth limit of ${maxDepth2}`,
+        "maxDepth",
+        maxDepth2
+      );
   }
 }
 function parseXml(xml, options = {}) {
@@ -39423,6 +39632,7 @@ function parseXml(xml, options = {}) {
   }
   if (parseError || !parsed.documentElement)
     throw new Error(`Invalid ${label} XML: ${parseError || "missing root element"}`);
+  if (CRLF_DECLARATION.test(xml)) crlfDeclarations.add(parsed);
   return parsed;
 }
 function named(element, local, ns, lenient = true) {
@@ -39432,7 +39642,7 @@ function named(element, local, ns, lenient = true) {
 function attr(element, local, ns, prefix) {
   return element?.getAttributeNS(ns, local) ?? element?.getAttribute(`${prefix}:${local}`) ?? void 0;
 }
-var DEFAULT_XML_LIMITS, TAG_RE, MARKUP_SKIPS, buildXml, isElement, elements, children2, first, relAttr;
+var DEFAULT_XML_LIMITS, XmlLimitError, TAG_RE, MARKUP_SKIPS, CRLF_DECLARATION, crlfDeclarations, buildXml, isElement, elements, children2, first, relAttr;
 var init_xml = __esm({
   "xml/xml.ts"() {
     init_namespaces();
@@ -39440,13 +39650,31 @@ var init_xml = __esm({
       maxDepth: 512,
       maxNodes: 5e6
     };
+    XmlLimitError = class extends Error {
+      code = "xml-limit";
+      /** The limit that was exceeded. */
+      limit;
+      /** Its value: the largest depth or element count allowed. */
+      maximum;
+      constructor(message, limit, maximum) {
+        super(message);
+        this.name = "XmlLimitError";
+        this.limit = limit;
+        this.maximum = maximum;
+      }
+    };
     TAG_RE = /<(\/?)([^\s\/><]+)(?:\s+[^\s=\/><]+\s*=\s*(?:"[^"<]*"|'[^'<]*'))*\s*(\/?)>/y;
     MARKUP_SKIPS = [
       ["<!--", "-->"],
       ["<![CDATA[", "]]>"],
       ["<?", "?>"]
     ];
-    buildXml = (node) => new xmldom.XMLSerializer().serializeToString(node);
+    CRLF_DECLARATION = /^<\?xml[^>]*\?>\r\n/;
+    crlfDeclarations = /* @__PURE__ */ new WeakSet();
+    buildXml = (node) => {
+      const xml = new xmldom.XMLSerializer().serializeToString(node);
+      return crlfDeclarations.has(node) ? xml.replace(/^(<\?xml[^>]*\?>)\n/, "$1\r\n") : xml;
+    };
     isElement = (node) => node.nodeType === 1;
     elements = (parent) => Array.from(parent.childNodes).filter(isElement);
     children2 = (parent, local, ns, lenient = true) => elements(parent).filter((element) => named(element, local, ns, lenient));
@@ -51053,17 +51281,24 @@ var init_body_properties_parser = __esm({
 function stripFontStyleSuffix(fontName) {
   let name = fontName.trim();
   let stripped = false;
-  for (let i2 = 0; i2 < 2; i2++) {
+  let previous = "";
+  let tokens = 0;
+  for (; ; ) {
     const idx = name.lastIndexOf(" ");
     if (idx <= 0) {
       break;
     }
     const token2 = name.slice(idx + 1).toLowerCase().replace(/-/g, "");
-    if (!FONT_STYLE_SUFFIX_TOKENS.has(token2)) {
+    const prefix = FONT_WEIGHT_PREFIX_TOKENS.has(token2) && FONT_PREFIXED_WEIGHT_TOKENS.has(previous);
+    if (!prefix && (tokens >= 2 || !FONT_STYLE_SUFFIX_TOKENS.has(token2))) {
       break;
     }
     name = name.slice(0, idx).trim();
     stripped = true;
+    previous = prefix ? "" : token2;
+    if (!prefix) {
+      tokens++;
+    }
   }
   return stripped && name.length > 0 ? name : void 0;
 }
@@ -51104,7 +51339,7 @@ function quoteFontName(name) {
   }
   return `"${trimmed2}"`;
 }
-var FONT_SUBSTITUTION_MAP, FONT_STYLE_SUFFIX_TOKENS, CSS_GENERIC_FAMILIES;
+var FONT_SUBSTITUTION_MAP, FONT_STYLE_SUFFIX_TOKENS, FONT_WEIGHT_PREFIX_TOKENS, FONT_PREFIXED_WEIGHT_TOKENS, CSS_GENERIC_FAMILIES;
 var init_font_substitution = __esm({
   "pptx/core/utils/font-substitution.ts"() {
     FONT_SUBSTITUTION_MAP = {
@@ -51292,6 +51527,8 @@ var init_font_substitution = __esm({
       "italic",
       "oblique"
     ]);
+    FONT_WEIGHT_PREFIX_TOKENS = /* @__PURE__ */ new Set(["semi", "demi", "extra", "ultra"]);
+    FONT_PREFIXED_WEIGHT_TOKENS = /* @__PURE__ */ new Set(["bold", "light", "black"]);
     CSS_GENERIC_FAMILIES = /* @__PURE__ */ new Set([
       "serif",
       "sans-serif",
@@ -61672,6 +61909,165 @@ var init_inherited_shape_transform = __esm({
   }
 });
 
+// pptx/core/utils/placeholder-xml.ts
+function findNonVisualProps(rawXml) {
+  for (const container2 of ["p:nvSpPr", "p:nvPicPr", "p:nvGraphicFramePr"]) {
+    const parent = rawXml[container2];
+    const nvPr = parent?.["p:nvPr"];
+    if (nvPr) {
+      return nvPr;
+    }
+  }
+  return void 0;
+}
+function retargetPlaceholder(rawXml, target) {
+  const nvPr = findNonVisualProps(rawXml);
+  if (!nvPr) {
+    return;
+  }
+  const ph = nvPr["p:ph"] ?? {};
+  nvPr["p:ph"] = ph;
+  if (target.type) {
+    ph["@_type"] = target.type;
+  } else {
+    delete ph["@_type"];
+  }
+  if (target.idx !== void 0) {
+    ph["@_idx"] = target.idx;
+  } else {
+    delete ph["@_idx"];
+  }
+}
+function setRawXmlTransform(rawXml, xEmu, yEmu, cxEmu, cyEmu) {
+  const spPr = rawXml["p:spPr"];
+  if (!spPr) {
+    return;
+  }
+  const xfrm = spPr["a:xfrm"] ?? {};
+  spPr["a:xfrm"] = xfrm;
+  const off = xfrm["a:off"] ?? {};
+  xfrm["a:off"] = off;
+  off["@_x"] = String(xEmu);
+  off["@_y"] = String(yEmu);
+  const ext = xfrm["a:ext"] ?? {};
+  xfrm["a:ext"] = ext;
+  ext["@_cx"] = String(cxEmu);
+  ext["@_cy"] = String(cyEmu);
+}
+function createEmptyPlaceholderElement(target, xEmu, yEmu, cxEmu, cyEmu, uniqueId) {
+  if (cxEmu <= 0 || cyEmu <= 0) {
+    return null;
+  }
+  const phNode = {};
+  if (target.type) {
+    phNode["@_type"] = target.type;
+  }
+  if (target.idx !== void 0) {
+    phNode["@_idx"] = target.idx;
+  }
+  const rawXml = {
+    "p:nvSpPr": {
+      "p:cNvPr": {
+        "@_id": uniqueId,
+        "@_name": `Placeholder ${target.type || "content"}`
+      },
+      "p:cNvSpPr": {
+        "a:spLocks": { "@_noGrp": "1" }
+      },
+      "p:nvPr": {
+        "p:ph": phNode
+      }
+    },
+    "p:spPr": {
+      "a:xfrm": {
+        "a:off": { "@_x": String(xEmu), "@_y": String(yEmu) },
+        "a:ext": { "@_cx": String(cxEmu), "@_cy": String(cyEmu) }
+      }
+    },
+    "p:txBody": {
+      "a:bodyPr": {},
+      "a:lstStyle": {},
+      "a:p": { "a:endParaRPr": { "@_lang": "en-US" } }
+    }
+  };
+  return {
+    type: "text",
+    id: `ph-${target.type || "content"}-${target.idx ?? "0"}-${uniqueId}`,
+    x: Math.round(xEmu / EMU_PER_PX),
+    y: Math.round(yEmu / EMU_PER_PX),
+    width: Math.round(cxEmu / EMU_PER_PX),
+    height: Math.round(cyEmu / EMU_PER_PX),
+    text: "",
+    rawXml
+  };
+}
+var init_placeholder_xml = __esm({
+  "pptx/core/utils/placeholder-xml.ts"() {
+    init_constants2();
+  }
+});
+
+// pptx/core/core/runtime/save-geometry-validation.ts
+function omitsInheritedFrame(element) {
+  if (!["text", "shape", "picture", "media"].includes(element.type) || !element.rawXml)
+    return false;
+  if (!xmlHasChild(findNonVisualProps(element.rawXml), "p:ph")) return false;
+  if (xmlHasChild(xmlChild(element.rawXml, "p:spPr"), "a:xfrm") || xmlHasChild(element.rawXml, "p:xfrm"))
+    return false;
+  const baseline = element.inheritedTransform;
+  if (!baseline) return FRAME_FIELDS.every((key2) => element[key2] === void 0);
+  return FRAME_FIELDS.every(
+    (key2) => Number.isFinite(baseline[key2]) && (element[key2] === void 0 || element[key2] === baseline[key2])
+  ) && ["rotation", "skewX", "skewY", "flipHorizontal", "flipVertical"].every(
+    (key2) => (element[key2] ?? 0) === (baseline[key2] ?? 0)
+  );
+}
+function validateElementGeometry(element, context, emuPerPx = 9525) {
+  const inherited = omitsInheritedFrame(element);
+  const record2 = element;
+  const fields = [...inherited ? [] : FRAME_FIELDS, ...OPTIONAL_FIELDS];
+  for (const field of fields) {
+    const value = record2[field];
+    if (OPTIONAL_FIELDS.includes(field) && value === void 0) continue;
+    if (typeof value !== "number" || !Number.isFinite(value) || !Number.isFinite(value * emuPerPx)) {
+      throw new Error(
+        `${context}: element '${element.id}' (${element.name ?? "unnamed"}, type=${element.type}) has invalid ${field}=${String(value)}; expected a finite number`
+      );
+    }
+  }
+  if (element.type === "group") {
+    for (const child31 of element.children) validateElementGeometry(child31, context, emuPerPx);
+  }
+}
+function validateSlideGeometry(slides) {
+  for (const slide of slides) {
+    for (const element of slide.elements) {
+      validateElementGeometry(element, `Slide ${slide.slideNumber} (${slide.id})`);
+    }
+  }
+}
+var FRAME_FIELDS, OPTIONAL_FIELDS;
+var init_save_geometry_validation = __esm({
+  "pptx/core/core/runtime/save-geometry-validation.ts"() {
+    init_placeholder_xml();
+    init_xml_access();
+    FRAME_FIELDS = ["x", "y", "width", "height"];
+    OPTIONAL_FIELDS = [
+      "xEmu",
+      "yEmu",
+      "widthEmu",
+      "heightEmu",
+      "rotation",
+      "skewX",
+      "skewY",
+      "chOffXEmu",
+      "chOffYEmu",
+      "chExtWidthEmu",
+      "chExtHeightEmu"
+    ];
+  }
+});
+
 // pptx/core/core/builders/PptxElementTransformUpdater.ts
 var PptxElementTransformUpdater;
 var init_PptxElementTransformUpdater = __esm({
@@ -61681,6 +62077,7 @@ var init_PptxElementTransformUpdater = __esm({
     init_xml_access();
     init_group_tight_rewrap();
     init_inherited_shape_transform();
+    init_save_geometry_validation();
     PptxElementTransformUpdater = class {
       applyTransform(shape, element, emuPerPx, enclosingGroupChildSpace) {
         const transform7 = shape["p:spPr"]?.["a:xfrm"] || shape["p:xfrm"] || // A group's child geometry uses a different frame from the load-time baseline.
@@ -61688,6 +62085,7 @@ var init_PptxElementTransformUpdater = __esm({
         if (!transform7) {
           return;
         }
+        validateElementGeometry(element, "Transform writer", emuPerPx);
         if (!transform7["a:off"]) {
           transform7["a:off"] = {};
         }
@@ -64722,7 +65120,7 @@ function parseBorderSide(side) {
   }
   const widthEmu = parseInt(String(ln["@_w"] || "0"), 10);
   if (widthEmu > 0) {
-    border.width = Math.max(1, Math.round(widthEmu / EMU_PER_PIXEL2));
+    border.width = Math.max(1, Math.round(widthEmu / EMU_PER_PIXEL3));
     has2 = true;
   }
   const prstDash = ln["a:prstDash"];
@@ -64779,12 +65177,12 @@ function parseTableStyleSectionCell3D(tcStyle) {
   if (bevel2) {
     const bevelWidth = parseInt(String(bevel2["@_w"] || "0"), 10);
     if (bevelWidth > 0) {
-      cell3D.bevelWidth = Math.round(bevelWidth / EMU_PER_PIXEL2);
+      cell3D.bevelWidth = Math.round(bevelWidth / EMU_PER_PIXEL3);
       hasStyle = true;
     }
     const bevelHeight = parseInt(String(bevel2["@_h"] || "0"), 10);
     if (bevelHeight > 0) {
-      cell3D.bevelHeight = Math.round(bevelHeight / EMU_PER_PIXEL2);
+      cell3D.bevelHeight = Math.round(bevelHeight / EMU_PER_PIXEL3);
       hasStyle = true;
     }
     const bevelPreset = String(bevel2["@_prst"] || "").trim();
@@ -64808,11 +65206,11 @@ function parseTableStyleSectionCell3D(tcStyle) {
   }
   return hasStyle ? cell3D : void 0;
 }
-var EMU_PER_PIXEL2, BORDER_SIDES;
+var EMU_PER_PIXEL3, BORDER_SIDES;
 var init_table_style_border_parse = __esm({
   "pptx/core/core/runtime/table-style-border-parse.ts"() {
     init_color_primitives();
-    EMU_PER_PIXEL2 = 9525;
+    EMU_PER_PIXEL3 = 9525;
     BORDER_SIDES = [
       "left",
       "right",
@@ -93865,6 +94263,80 @@ var init_factories = __esm({
   }
 });
 
+// pptx/core/utils/placeholder-remap.ts
+function placeholderContentRole(type) {
+  const declared = (type ?? "").trim().toLowerCase() || "body";
+  if (TITLE_ROLE.has(declared)) {
+    return "title";
+  }
+  if (CONTENT_ROLE.has(declared)) {
+    return "content";
+  }
+  return declared;
+}
+function preferredPlaceholderTypes(element) {
+  switch (element.type) {
+    case "image":
+    case "picture":
+      return ["pic", "obj", "body"];
+    case "chart":
+      return ["chart", "obj", "body"];
+    case "table":
+      return ["tbl", "obj", "body"];
+    case "media":
+    case "model3d":
+      return ["media", "pic", "obj", "body"];
+    case "smartArt":
+      return ["dgm", "obj", "body"];
+    case "text":
+      return ["body", "subtitle", "obj"];
+    default:
+      return ["obj", "body"];
+  }
+}
+function scorePlaceholderMatch(element, source, target) {
+  if (placeholderContentRole(source.type) !== placeholderContentRole(target.type)) {
+    return -1;
+  }
+  const sourceType = normalizeType(source.type);
+  const targetType = normalizeType(target.type);
+  let score = 1;
+  if (source.idx !== void 0 && source.idx === target.idx) {
+    score += 100;
+  }
+  if (sourceType === targetType) {
+    score += 50;
+  }
+  const preferred = preferredPlaceholderTypes(element).indexOf(targetType);
+  if (preferred >= 0) {
+    score += 30 - preferred * 5;
+  }
+  if (targetType === "obj") {
+    score += 10;
+  }
+  return score;
+}
+function normalizeType(type) {
+  return (type ?? "").trim().toLowerCase() || "body";
+}
+var TITLE_ROLE, CONTENT_ROLE;
+var init_placeholder_remap = __esm({
+  "pptx/core/utils/placeholder-remap.ts"() {
+    TITLE_ROLE = /* @__PURE__ */ new Set(["title", "ctrtitle"]);
+    CONTENT_ROLE = /* @__PURE__ */ new Set([
+      "body",
+      "obj",
+      "subtitle",
+      "pic",
+      "chart",
+      "tbl",
+      "media",
+      "clipart",
+      "dgm"
+    ]);
+  }
+});
+
 // pptx/core/core/runtime/master-save-helpers.ts
 function applyHeaderFooterFlagsToNode(root, flags) {
   if (!flags || Object.keys(flags).length === 0) {
@@ -113444,178 +113916,6 @@ var init_chart_user_shapes_serializer = __esm({
   }
 });
 
-// pptx/core/utils/placeholder-remap.ts
-function placeholderContentRole(type) {
-  const declared = (type ?? "").trim().toLowerCase() || "body";
-  if (TITLE_ROLE.has(declared)) {
-    return "title";
-  }
-  if (CONTENT_ROLE.has(declared)) {
-    return "content";
-  }
-  return declared;
-}
-function preferredPlaceholderTypes(element) {
-  switch (element.type) {
-    case "image":
-    case "picture":
-      return ["pic", "obj", "body"];
-    case "chart":
-      return ["chart", "obj", "body"];
-    case "table":
-      return ["tbl", "obj", "body"];
-    case "media":
-    case "model3d":
-      return ["media", "pic", "obj", "body"];
-    case "smartArt":
-      return ["dgm", "obj", "body"];
-    case "text":
-      return ["body", "subtitle", "obj"];
-    default:
-      return ["obj", "body"];
-  }
-}
-function scorePlaceholderMatch(element, source, target) {
-  if (placeholderContentRole(source.type) !== placeholderContentRole(target.type)) {
-    return -1;
-  }
-  const sourceType = normalizeType(source.type);
-  const targetType = normalizeType(target.type);
-  let score = 1;
-  if (source.idx !== void 0 && source.idx === target.idx) {
-    score += 100;
-  }
-  if (sourceType === targetType) {
-    score += 50;
-  }
-  const preferred = preferredPlaceholderTypes(element).indexOf(targetType);
-  if (preferred >= 0) {
-    score += 30 - preferred * 5;
-  }
-  if (targetType === "obj") {
-    score += 10;
-  }
-  return score;
-}
-function normalizeType(type) {
-  return (type ?? "").trim().toLowerCase() || "body";
-}
-var TITLE_ROLE, CONTENT_ROLE;
-var init_placeholder_remap = __esm({
-  "pptx/core/utils/placeholder-remap.ts"() {
-    TITLE_ROLE = /* @__PURE__ */ new Set(["title", "ctrtitle"]);
-    CONTENT_ROLE = /* @__PURE__ */ new Set([
-      "body",
-      "obj",
-      "subtitle",
-      "pic",
-      "chart",
-      "tbl",
-      "media",
-      "clipart",
-      "dgm"
-    ]);
-  }
-});
-
-// pptx/core/utils/placeholder-xml.ts
-function findNonVisualProps(rawXml) {
-  for (const container2 of ["p:nvSpPr", "p:nvPicPr", "p:nvGraphicFramePr"]) {
-    const parent = rawXml[container2];
-    const nvPr = parent?.["p:nvPr"];
-    if (nvPr) {
-      return nvPr;
-    }
-  }
-  return void 0;
-}
-function retargetPlaceholder(rawXml, target) {
-  const nvPr = findNonVisualProps(rawXml);
-  if (!nvPr) {
-    return;
-  }
-  const ph = nvPr["p:ph"] ?? {};
-  nvPr["p:ph"] = ph;
-  if (target.type) {
-    ph["@_type"] = target.type;
-  } else {
-    delete ph["@_type"];
-  }
-  if (target.idx !== void 0) {
-    ph["@_idx"] = target.idx;
-  } else {
-    delete ph["@_idx"];
-  }
-}
-function setRawXmlTransform(rawXml, xEmu, yEmu, cxEmu, cyEmu) {
-  const spPr = rawXml["p:spPr"];
-  if (!spPr) {
-    return;
-  }
-  const xfrm = spPr["a:xfrm"] ?? {};
-  spPr["a:xfrm"] = xfrm;
-  const off = xfrm["a:off"] ?? {};
-  xfrm["a:off"] = off;
-  off["@_x"] = String(xEmu);
-  off["@_y"] = String(yEmu);
-  const ext = xfrm["a:ext"] ?? {};
-  xfrm["a:ext"] = ext;
-  ext["@_cx"] = String(cxEmu);
-  ext["@_cy"] = String(cyEmu);
-}
-function createEmptyPlaceholderElement(target, xEmu, yEmu, cxEmu, cyEmu, uniqueId) {
-  if (cxEmu <= 0 || cyEmu <= 0) {
-    return null;
-  }
-  const phNode = {};
-  if (target.type) {
-    phNode["@_type"] = target.type;
-  }
-  if (target.idx !== void 0) {
-    phNode["@_idx"] = target.idx;
-  }
-  const rawXml = {
-    "p:nvSpPr": {
-      "p:cNvPr": {
-        "@_id": uniqueId,
-        "@_name": `Placeholder ${target.type || "content"}`
-      },
-      "p:cNvSpPr": {
-        "a:spLocks": { "@_noGrp": "1" }
-      },
-      "p:nvPr": {
-        "p:ph": phNode
-      }
-    },
-    "p:spPr": {
-      "a:xfrm": {
-        "a:off": { "@_x": String(xEmu), "@_y": String(yEmu) },
-        "a:ext": { "@_cx": String(cxEmu), "@_cy": String(cyEmu) }
-      }
-    },
-    "p:txBody": {
-      "a:bodyPr": {},
-      "a:lstStyle": {},
-      "a:p": { "a:endParaRPr": { "@_lang": "en-US" } }
-    }
-  };
-  return {
-    type: "text",
-    id: `ph-${target.type || "content"}-${target.idx ?? "0"}-${uniqueId}`,
-    x: Math.round(xEmu / EMU_PER_PX),
-    y: Math.round(yEmu / EMU_PER_PX),
-    width: Math.round(cxEmu / EMU_PER_PX),
-    height: Math.round(cyEmu / EMU_PER_PX),
-    text: "",
-    rawXml
-  };
-}
-var init_placeholder_xml = __esm({
-  "pptx/core/utils/placeholder-xml.ts"() {
-    init_constants2();
-  }
-});
-
 // pptx/core/utils/text-fill-blip.ts
 function resolveTextFillBlip(blipFill, lookupTarget, resolveArchivePath, allowExternal) {
   const blip = blipFill["a:blip"];
@@ -133180,8 +133480,8 @@ function mergeBorderSideXml(border, existingSide) {
   const ln = ensureChild2(existing, "a:ln");
   if (border.width !== void 0) {
     const currentEmu = parseInt(String(ln["@_w"] || "0"), 10);
-    if (currentEmu <= 0 || Math.max(1, Math.round(currentEmu / EMU_PER_PIXEL3)) !== border.width) {
-      ln["@_w"] = String(Math.round(border.width * EMU_PER_PIXEL3));
+    if (currentEmu <= 0 || Math.max(1, Math.round(currentEmu / EMU_PER_PIXEL4)) !== border.width) {
+      ln["@_w"] = String(Math.round(border.width * EMU_PER_PIXEL4));
     }
   }
   if (border.dash) {
@@ -133237,10 +133537,10 @@ function writeTableStyleSectionCell3D(section, cell3D) {
   if (cell3D.bevelWidth !== void 0 || cell3D.bevelHeight !== void 0 || cell3D.bevelPreset !== void 0) {
     const bevel2 = {};
     if (cell3D.bevelWidth !== void 0) {
-      bevel2["@_w"] = String(Math.round(cell3D.bevelWidth * EMU_PER_PIXEL3));
+      bevel2["@_w"] = String(Math.round(cell3D.bevelWidth * EMU_PER_PIXEL4));
     }
     if (cell3D.bevelHeight !== void 0) {
-      bevel2["@_h"] = String(Math.round(cell3D.bevelHeight * EMU_PER_PIXEL3));
+      bevel2["@_h"] = String(Math.round(cell3D.bevelHeight * EMU_PER_PIXEL4));
     }
     if (cell3D.bevelPreset) {
       bevel2["@_prst"] = cell3D.bevelPreset;
@@ -133259,12 +133559,12 @@ function writeTableStyleSectionCell3D(section, cell3D) {
   }
   tcStyle["a:cell3D"] = node;
 }
-var EMU_PER_PIXEL3, BORDER_SIDE_ORDER, LN_CHILD_ORDER, LN_FILL_KEYS;
+var EMU_PER_PIXEL4, BORDER_SIDE_ORDER, LN_CHILD_ORDER, LN_FILL_KEYS;
 var init_table_style_border_write = __esm({
   "pptx/core/core/runtime/table-style-border-write.ts"() {
     init_xml_reorder();
     init_table_style_xml_helpers();
-    EMU_PER_PIXEL3 = 9525;
+    EMU_PER_PIXEL4 = 9525;
     BORDER_SIDE_ORDER = [
       "a:left",
       "a:right",
@@ -134202,6 +134502,7 @@ var init_PptxHandlerRuntimeSavePipeline = __esm({
     init_header_footer_parts();
     init_pptx_print_properties();
     init_PptxHandlerRuntimeSaveStructuralIds();
+    init_save_geometry_validation();
     PptxHandlerRuntime54 = class _PptxHandlerRuntime extends PptxHandlerRuntime53 {
       /**
        * Resolve the effective conformance class for this save operation.
@@ -134216,6 +134517,19 @@ var init_PptxHandlerRuntimeSavePipeline = __esm({
         return this.isStrictOoxml ? "strict" : "transitional";
       }
       async save(slides, options) {
+        validateSlideGeometry(slides);
+        const templates = [
+          ...options?.slideMasters ?? [],
+          ...options?.slideLayouts ?? [],
+          ...options?.slideMasters?.flatMap((master) => master.layouts ?? []) ?? [],
+          ...options?.notesMaster ? [options.notesMaster] : [],
+          ...options?.handoutMaster ? [options.handoutMaster] : []
+        ];
+        for (const template of templates) {
+          for (const element of template.elements ?? []) {
+            validateElementGeometry(element, `Template (${template.path})`);
+          }
+        }
         if (options?.outputFormat === "ppt") {
           return this.saveAsLegacyPpt(
             slides,
@@ -135183,8 +135497,7 @@ var init_PptxHandlerRuntimePlaceholderLookup = __esm({
         return this.scanPlaceholderBuckets(spTree, (info) => info?.type === type);
       }
       /** The layout and master counterparts of a placeholder, unmerged. */
-      findPlaceholderContexts(slidePath, expected) {
-        const layoutPath = this.resolveLayoutPathForSlide(slidePath);
+      findPlaceholderContexts(slidePath, expected, layoutPath = this.resolveLayoutPathForSlide(slidePath)) {
         if (!layoutPath) {
           return {};
         }
@@ -135196,10 +135509,11 @@ var init_PptxHandlerRuntimePlaceholderLookup = __esm({
         const master = this.findPlaceholderInShapeTree(masterSpTree, expected) ?? this.findSingletonPlaceholderInShapeTree(masterSpTree, expected);
         return { layout, master };
       }
-      findPlaceholderContext(slidePath, expected) {
+      findPlaceholderContext(slidePath, expected, layoutPath) {
         const { layout: layoutContext, master: masterContext } = this.findPlaceholderContexts(
           slidePath,
-          expected
+          expected,
+          layoutPath
         );
         if (!layoutContext) {
           return masterContext;
@@ -135225,8 +135539,8 @@ var init_PptxHandlerRuntimePlaceholderLookup = __esm({
        * a master `p:sp`), so the layout keeps winning exactly as it does when
        * both are shapes.
        */
-      findPlaceholderNode(slidePath, expected) {
-        const { layout, master } = this.findPlaceholderContexts(slidePath, expected);
+      findPlaceholderNode(slidePath, expected, layoutPath) {
+        const { layout, master } = this.findPlaceholderContexts(slidePath, expected, layoutPath);
         const firstNode2 = (context) => context?.shape ?? context?.picture ?? context?.graphicFrame;
         const layoutNode = firstNode2(layout);
         const masterNode = firstNode2(master);
@@ -135267,8 +135581,7 @@ var init_PptxHandlerRuntimePlaceholderLookup = __esm({
        * reference. Checks the layout cache first, then the master cache, and
        * merges them so that layout values take priority over master values.
        */
-      lookupPlaceholderDefaults(slidePath, phInfo) {
-        const layoutPath = this.resolveLayoutPathForSlide(slidePath);
+      lookupPlaceholderDefaults(slidePath, phInfo, layoutPath = this.resolveLayoutPathForSlide(slidePath)) {
         if (!layoutPath) {
           return void 0;
         }
@@ -135812,6 +136125,7 @@ var init_PptxHandlerRuntimeGeometryParsing = __esm({
 var PptxHandlerRuntime61;
 var init_PptxHandlerRuntimeShapeImageFill = __esm({
   "pptx/core/core/runtime/PptxHandlerRuntimeShapeImageFill.ts"() {
+    init_group_parsing_helpers();
     init_xml_access();
     init_group_shape_geometry();
     init_PptxHandlerRuntimeGeometryParsing();
@@ -135983,6 +136297,53 @@ var init_PptxHandlerRuntimeShapeImageFill = __esm({
           return null;
         }
       }
+      /**
+       * A text-bearing shape whose picture fill is inherited from its layout or
+       * master placeholder (`a:blipFill` absent from its own `spPr`) gets
+       * `fillMode: 'image'` from the merged properties but no image: the blip's
+       * relationship id belongs to the part that authored it, not the slide.
+       * Resolve it against the layout's, then the master's, relationships.
+       */
+      async resolveInheritedFillImage(element, shape, slidePath) {
+        const style = element?.shapeStyle;
+        if (!element || !style || style.fillMode !== "image" || style.fillImageUrl) {
+          return;
+        }
+        const placeholderInfo = this.extractPlaceholderInfo(xmlPath(shape, "p:nvSpPr", "p:nvPr"));
+        const inherited = placeholderInfo ? this.findPlaceholderContext(slidePath, placeholderInfo) : void 0;
+        const effectiveSpPr = this.mergeXmlObjects(
+          inherited?.shape?.["p:spPr"],
+          xmlChild(shape, "p:spPr")
+        );
+        const blipFill = effectiveSpPr?.["a:blipFill"];
+        const blip = blipFill?.["a:blip"];
+        const relId = String(blip?.["@_r:embed"] ?? blip?.["@_r:link"] ?? "");
+        if (!relId) {
+          return;
+        }
+        const layoutPath = this.resolveLayoutPathForSlide(slidePath);
+        const masterPath = layoutPath ? this.resolveMasterPathForLayout(layoutPath) : void 0;
+        for (const partPath of [layoutPath, masterPath]) {
+          if (!partPath || !this.slideRelsMap.get(partPath)?.has(relId)) {
+            continue;
+          }
+          const fill = await resolveGroupFillImagePure(
+            this,
+            blipFill,
+            partPath
+          );
+          if (fill) {
+            const isUrl = /^(?:data:|blob:|https?:)/u.test(fill.fillImageUrl);
+            const decoded = isUrl ? void 0 : await this.getImageData(fill.fillImageUrl);
+            style.fillImageUrl = decoded ?? fill.fillImageUrl;
+            style.fillImageMode = fill.fillImageMode;
+            if (element.type === "text") {
+              element.type = "shape";
+            }
+          }
+          return;
+        }
+      }
       textVerticalAlignFromDrawingValue(value) {
         const normalized = String(value ?? "").trim().toLowerCase();
         if (normalized.length === 0) {
@@ -137447,14 +137808,14 @@ var init_PptxHandlerRuntimeShapeParsing = __esm({
     init_element_paragraph_geometry();
     init_PptxHandlerRuntimeShapeParagraphContentParsing();
     PptxHandlerRuntime67 = class _PptxHandlerRuntime extends PptxHandlerRuntime66 {
-      parseShape(shape, id, slidePath) {
+      parseShape(shape, id, slidePath, layoutPath) {
         try {
           const spPr = shape["p:spPr"];
           const slideRelationshipMap = slidePath ? this.slideRelsMap.get(slidePath) : void 0;
           const placeholderInfo = this.extractPlaceholderInfo(
             shape?.["p:nvSpPr"]?.["p:nvPr"]
           );
-          const inheritedPlaceholder = slidePath && placeholderInfo ? this.findPlaceholderContext(slidePath, placeholderInfo) : void 0;
+          const inheritedPlaceholder = (slidePath || layoutPath) && placeholderInfo ? this.findPlaceholderContext(slidePath ?? "", placeholderInfo, layoutPath) : void 0;
           const inheritedSpPr = inheritedPlaceholder?.shape?.["p:spPr"] || inheritedPlaceholder?.picture?.["p:spPr"];
           const effectiveSpPr = spPr ? {
             ...spPr,
@@ -137580,7 +137941,7 @@ var init_PptxHandlerRuntimeShapeParsing = __esm({
           );
           const linkedTxbxId = bodyPropResult.linkedTxbxId;
           const linkedTxbxSeq = bodyPropResult.linkedTxbxSeq;
-          const phDefaults = slidePath && placeholderInfo ? this.lookupPlaceholderDefaults(slidePath, placeholderInfo) : void 0;
+          const phDefaults = (slidePath || layoutPath) && placeholderInfo ? this.lookupPlaceholderDefaults(slidePath ?? "", placeholderInfo, layoutPath) : void 0;
           if (phDefaults) {
             this.applyPlaceholderBodyDefaults(textStyle, phDefaults);
           }
@@ -138457,7 +138818,9 @@ var init_PptxHandlerRuntimeSpTreeParsing = __esm({
                 slidePath
               );
             }
-            return this.parseShape(node, `${idPrefix}shape-${indexInType}`, slidePath);
+            const parsed = this.parseShape(node, `${idPrefix}shape-${indexInType}`, slidePath);
+            await this.resolveInheritedFillImage(parsed, node, slidePath);
+            return parsed;
           }
           case "p:pic":
             return this.parsePicture(node, `${idPrefix}pic-${indexInType}`, slidePath);
@@ -146943,14 +147306,199 @@ var init_PptxHandlerRuntimeBackgroundStyles = __esm({
     };
   }
 });
+
+// pptx/core/core/runtime/sdk-placeholder.ts
+function selectTextPlaceholder(input, type, options, slots) {
+  if (!TEXT_PLACEHOLDER_TYPES.has(type.toLowerCase())) {
+    throw new Error(`Unsupported text placeholder type: ${type}`);
+  }
+  if (options.idx !== void 0 && (!Number.isInteger(options.idx) || options.idx < 0 || options.idx > 4294967295)) {
+    throw new Error("Placeholder idx must be an unsigned 32-bit integer");
+  }
+  const source = {
+    type: type.toLowerCase(),
+    ...options.idx !== void 0 ? { idx: String(options.idx) } : {}
+  };
+  let best;
+  let bestScore = 0;
+  for (const slot of slots) {
+    if (!TEXT_PLACEHOLDER_TYPES.has(slot.phInfo.type ?? "obj")) continue;
+    if (source.idx !== void 0 && source.idx !== (slot.phInfo.idx ?? "0")) continue;
+    const score = scorePlaceholderMatch(input, source, slot.phInfo);
+    if (score > bestScore) {
+      best = slot;
+      bestScore = score;
+    }
+  }
+  return best ? { type: canonicalPlaceholderType(best.phInfo.type ?? "obj"), idx: best.phInfo.idx } : { type: canonicalPlaceholderType(source.type), idx: source.idx };
+}
+function withoutFallbackLanguage(properties) {
+  const { "@_lang": language, ...rest } = properties;
+  if (language !== "en-US") return properties;
+  const keys = Object.keys(rest);
+  return keys.length === 0 || keys.length === 1 && rest["@_dirty"] === "0" ? void 0 : rest;
+}
+function stripFallbackLanguage(node, key2) {
+  const properties = node[key2];
+  if (!properties || typeof properties !== "object") return node;
+  const next = withoutFallbackLanguage(properties);
+  if (next === properties) return node;
+  const result = {};
+  for (const [name, value] of Object.entries(node)) {
+    if (name !== key2) result[name] = value;
+    else if (next) result[name] = next;
+  }
+  return result;
+}
+function withoutFallbackLanguages(paragraphs) {
+  return paragraphs.map((paragraph) => {
+    const next = { ...stripFallbackLanguage(paragraph, "a:endParaRPr") };
+    for (const child31 of ["a:r", "a:br", "a:fld"]) {
+      const nodes = next[child31];
+      if (nodes === void 0) continue;
+      next[child31] = Array.isArray(nodes) ? nodes.map((node) => stripFallbackLanguage(node, "a:rPr")) : stripFallbackLanguage(nodes, "a:rPr");
+    }
+    return next;
+  });
+}
+function placeholderShape2(identity, paragraphs) {
+  paragraphs = withoutFallbackLanguages(paragraphs);
+  return {
+    "p:nvSpPr": {
+      "p:cNvPr": { "@_id": "2", "@_name": `Placeholder ${identity.type}` },
+      "p:cNvSpPr": { "a:spLocks": { "@_noGrp": "1" } },
+      "p:nvPr": {
+        "p:ph": {
+          "@_type": identity.type,
+          ...identity.idx !== void 0 ? { "@_idx": identity.idx } : {}
+        }
+      }
+    },
+    "p:spPr": {},
+    "p:txBody": { "a:bodyPr": {}, "a:lstStyle": {}, "a:p": paragraphs }
+  };
+}
+function applyPlaceholderFrame(shape, inherited, options, emuPerPx, materializeFrame = false) {
+  for (const key2 of ["x", "y", "width", "height"]) {
+    if (options[key2] !== void 0 && !Number.isFinite(options[key2])) {
+      throw new Error(`Invalid placeholder frame for ${key2}: expected a finite number`);
+    }
+  }
+  const off = xmlPath(inherited, "p:spPr", "a:xfrm", "a:off");
+  const ext = xmlPath(inherited, "p:spPr", "a:xfrm", "a:ext");
+  const frame2 = {
+    x: options.x ?? (off?.["@_x"] !== void 0 ? Number(off["@_x"]) / emuPerPx : void 0),
+    y: options.y ?? (off?.["@_y"] !== void 0 ? Number(off["@_y"]) / emuPerPx : void 0),
+    width: options.width ?? (ext?.["@_cx"] !== void 0 ? Number(ext["@_cx"]) / emuPerPx : void 0),
+    height: options.height ?? (ext?.["@_cy"] !== void 0 ? Number(ext["@_cy"]) / emuPerPx : void 0)
+  };
+  for (const [key2, value] of Object.entries(frame2)) {
+    if (!Number.isFinite(value)) {
+      throw new Error(
+        `No matching placeholder frame for ${key2}; supply a complete explicit frame or choose a layout containing this slot`
+      );
+    }
+  }
+  if (materializeFrame || ["x", "y", "width", "height"].some((key2) => options[key2] !== void 0)) {
+    setRawXmlTransform(
+      shape,
+      ...["x", "y", "width", "height"].map(
+        (key2) => Math.round(frame2[key2] * emuPerPx)
+      )
+    );
+  }
+}
+var TEXT_PLACEHOLDER_TYPES;
+var init_sdk_placeholder = __esm({
+  "pptx/core/core/runtime/sdk-placeholder.ts"() {
+    init_placeholder_remap();
+    init_placeholder_xml();
+    init_placeholder_validation();
+    init_xml_access();
+    TEXT_PLACEHOLDER_TYPES = /* @__PURE__ */ new Set([
+      "title",
+      "ctrtitle",
+      "subtitle",
+      "body",
+      "obj",
+      "dt",
+      "ftr",
+      "hdr",
+      "sldnum"
+    ]);
+  }
+});
+
+// pptx/core/core/runtime/PptxHandlerRuntimeSdkPlaceholders.ts
 var PptxHandlerRuntime103;
+var init_PptxHandlerRuntimeSdkPlaceholders = __esm({
+  "pptx/core/core/runtime/PptxHandlerRuntimeSdkPlaceholders.ts"() {
+    init_placeholder_remap();
+    init_xml_access();
+    init_PptxHandlerRuntimeBackgroundStyles();
+    init_sdk_placeholder();
+    PptxHandlerRuntime103 = class _PptxHandlerRuntime extends PptxHandlerRuntime102 {
+      createPlaceholderElement(layoutPath, input, type, options) {
+        if (input.type !== "text") throw new Error("Placeholder input must be text");
+        const layout = this.layoutXmlMap.get(layoutPath);
+        if (!layout) throw new Error(`Unknown layout: ${layoutPath}`);
+        const identity = selectTextPlaceholder(
+          input,
+          type,
+          options,
+          this.extractLayoutPlaceholders(layout, layoutPath)
+        );
+        const shape = placeholderShape2(
+          identity,
+          this.createParagraphsFromTextContent(input.text, void 0, input.textSegments)
+        );
+        const inherited = this.findPlaceholderNode(
+          "",
+          { type: identity.type.toLowerCase(), idx: identity.idx },
+          layoutPath
+        );
+        const fallback = this.sdkMasterFrame(layoutPath, identity.type, identity.idx, inherited);
+        applyPlaceholderFrame(
+          shape,
+          fallback ?? inherited,
+          options,
+          _PptxHandlerRuntime.EMU_PER_PX,
+          fallback !== void 0
+        );
+        const element = this.parseShape(shape, input.id, void 0, layoutPath);
+        if (!element) throw new Error("Unable to resolve placeholder content");
+        if ((element.type === "text" || element.type === "shape") && !element.textStyle && element.textSegments?.[0]?.style) {
+          element.textStyle = { ...element.textSegments[0].style };
+        }
+        return element;
+      }
+      sdkMasterFrame(layoutPath, type, idx, inherited) {
+        if (!inherited) return void 0;
+        if (xmlPath(inherited, "p:spPr", "a:xfrm", "a:off") && xmlPath(inherited, "p:spPr", "a:xfrm", "a:ext"))
+          return void 0;
+        const masterPath = this.resolveMasterPathForLayout(layoutPath);
+        const tree = masterPath ? xmlPath(this.masterXmlMap.get(masterPath), "p:sldMaster", "p:cSld", "p:spTree") : void 0;
+        const role = placeholderContentRole(type.toLowerCase());
+        const candidates = this.ensureArray(tree?.["p:sp"]).filter((shape) => {
+          const info = this.extractPlaceholderInfo(xmlPath(shape, "p:nvSpPr", "p:nvPr"));
+          return info && placeholderContentRole(info.type) === role;
+        });
+        const master = candidates.find(
+          (shape) => this.extractPlaceholderInfo(xmlPath(shape, "p:nvSpPr", "p:nvPr"))?.idx === idx
+        ) ?? candidates[0];
+        return master ? this.mergeXmlObjects(master, inherited) : void 0;
+      }
+    };
+  }
+});
+var PptxHandlerRuntime104;
 var init_PptxHandlerRuntimeImplementation = __esm({
   "pptx/core/core/runtime/PptxHandlerRuntimeImplementation.ts"() {
     init_PptxElementXmlBuilder();
     init_builders();
     init_factories();
-    init_PptxHandlerRuntimeBackgroundStyles();
-    PptxHandlerRuntime103 = class _PptxHandlerRuntime extends PptxHandlerRuntime102 {
+    init_PptxHandlerRuntimeSdkPlaceholders();
+    PptxHandlerRuntime104 = class _PptxHandlerRuntime extends PptxHandlerRuntime103 {
       constructor(dependencyFactory = new PptxRuntimeDependencyFactory()) {
         super();
         this.dependencyFactory = dependencyFactory;
@@ -147090,11 +147638,11 @@ var init_PptxHandlerRuntimeImplementation = __esm({
 });
 
 // pptx/core/core/PptxHandlerRuntime.ts
-var PptxHandlerRuntime104;
+var PptxHandlerRuntime105;
 var init_PptxHandlerRuntime = __esm({
   "pptx/core/core/PptxHandlerRuntime.ts"() {
     init_PptxHandlerRuntimeImplementation();
-    PptxHandlerRuntime104 = class extends PptxHandlerRuntime103 {
+    PptxHandlerRuntime105 = class extends PptxHandlerRuntime104 {
     };
   }
 });
@@ -147104,7 +147652,7 @@ var createDefaultPptxHandlerRuntime;
 var init_PptxHandlerRuntimeFactory = __esm({
   "pptx/core/core/PptxHandlerRuntimeFactory.ts"() {
     init_PptxHandlerRuntime();
-    createDefaultPptxHandlerRuntime = () => new PptxHandlerRuntime104();
+    createDefaultPptxHandlerRuntime = () => new PptxHandlerRuntime105();
   }
 });
 
@@ -149741,7 +150289,7 @@ function slideMasterXml2(deck, ctx) {
   </p:txStyles>
 </p:sldMaster>`;
 }
-function slideLayoutXml2() {
+function slideLayoutXml() {
   return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <p:sldLayout ${XMLNS2} type="blank" preserve="1">
   <p:cSld name="Blank">
@@ -150061,7 +150609,7 @@ async function buildPptxPackage(deck) {
 ${masterRels.join("\n")}
 </Relationships>`
   );
-  zip.file("ppt/slideLayouts/slideLayout1.xml", slideLayoutXml2());
+  zip.file("ppt/slideLayouts/slideLayout1.xml", slideLayoutXml());
   zip.file(
     "ppt/slideLayouts/_rels/slideLayout1.xml.rels",
     `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
@@ -150278,6 +150826,13 @@ var init_PptxHandlerCore = __esm({
       getLayoutOptions() {
         return this.runtime.getLayoutOptions();
       }
+      /** Resolve a text placeholder in this loaded deck, preserving layout inheritance. */
+      createPlaceholderElement(layoutPath, input, type, options = {}) {
+        if (!this.runtime.createPlaceholderElement) {
+          throw new Error("This runtime does not support creating layout placeholders");
+        }
+        return this.runtime.createPlaceholderElement(layoutPath, input, type, options);
+      }
       /**
        * Build the artwork thumbnails backing the New Slide / Layout galleries.
        *
@@ -152071,30 +152626,8 @@ function removeChartUserShape(element, index) {
   element.chartData.userShapes = shapes.filter((_, i2) => i2 !== index);
 }
 
-// pptx/core/builders/sdk/layout-operations.ts
-function findLayoutByName(data, name) {
-  const lowerName = name.toLowerCase();
-  const fromOptions = data.layoutOptions?.find((l) => l.name.toLowerCase() === lowerName);
-  if (fromOptions) {
-    return fromOptions;
-  }
-  if (data.slideMasters) {
-    for (const master of data.slideMasters) {
-      const layout = master.layouts?.find((l) => l.name?.toLowerCase() === lowerName);
-      if (layout) {
-        return { path: layout.path, name: layout.name ?? name };
-      }
-    }
-  }
-  return void 0;
-}
-function findLayoutByType(data, type) {
-  const fromOptions = data.layoutOptions?.find((l) => l.type === type);
-  if (fromOptions) {
-    return fromOptions;
-  }
-  return void 0;
-}
+// pptx/core/builders/sdk/index.ts
+init_layout_operations();
 
 // pptx/core/builders/sdk/shape-operations.ts
 function replaceShapeGeometry(element, newShapeType, adjustments) {