@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-P42REFYL.js

@@ -0,0 +1,228 @@
+import {
+  readPackage
+} from "./chunk-FRZ5P5AB.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  parseContentTypes
+} from "./chunk-N74TJL6X.js";
+import {
+  readRelationshipGraph
+} from "./chunk-5GEFJROP.js";
+import {
+  partName
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/opaque-objects.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+var relationships = [
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  "http://purl.oclc.org/ooxml/officeDocument/relationships"
+];
+var relationshipKinds = Object.fromEntries([
+  ...relationships.flatMap(
+    (namespace) => Object.entries({ oleObject: "ole", package: "package", control: "control", font: "font" }).map(
+      ([suffix, kind]) => [`${namespace}/${suffix}`, kind]
+    )
+  ),
+  ["http://schemas.microsoft.com/office/2006/relationships/activeXControlBinary", "control"],
+  ["http://schemas.microsoft.com/office/2006/relationships/vbaProject", "active-payload"],
+  ["http://schemas.microsoft.com/office/2011/relationships/webextension", "web-extension"],
+  ["http://schemas.microsoft.com/office/2011/relationships/webextensiontaskpanes", "web-extension"],
+  ["http://schemas.microsoft.com/office/2017/06/relationships/model3d", "model3d"]
+]);
+var contentKinds = {
+  "application/vnd.openxmlformats-officedocument.oleobject": "ole",
+  "application/vnd.ms-office.activex+xml": "control",
+  "application/vnd.ms-office.activex": "control",
+  "application/vnd.ms-office.webextension+xml": "web-extension",
+  "application/vnd.ms-office.webextensiontaskpanes+xml": "web-extension",
+  "application/x-fontdata": "font",
+  "application/vnd.openxmlformats-officedocument.obfuscatedfont": "font",
+  "application/font-sfnt": "font",
+  "application/vnd.ms-opentype": "font",
+  "model/gltf-binary": "model3d",
+  "model/gltf+json": "model3d",
+  "application/vnd.ms-office.model3d": "model3d",
+  "application/vnd.ms-office.vbaproject": "active-payload"
+};
+function digest(bytes) {
+  return Array.from(sha256(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function activeSignatures(bytes) {
+  return [
+    { bytes: [77, 90], reason: "executable-header" },
+    { bytes: [127, 69, 76, 70], reason: "executable-header" },
+    { bytes: [208, 207, 17, 224, 161, 177, 26, 225], reason: "compound-container" }
+  ].filter((signature) => signature.bytes.every((byte, index) => bytes[index] === byte)).map((signature) => signature.reason);
+}
+function inspectObjects(reader, graph, context) {
+  const types = parseContentTypes(reader.get("/[Content_Types].xml"), {
+    maxBytes: context.xmlLimits.maxBytes,
+    maxEntries: context.relationshipLimits.maxParts
+  });
+  const objects = [];
+  for (const part of [...graph.parts].sort()) {
+    context.signal?.throwIfAborted();
+    const contentType = types.get(part);
+    const mediaType = contentType.split(";", 1)[0].trim().toLowerCase();
+    const bytes = reader.get(part);
+    const activeReasons = activeSignatures(bytes);
+    const incoming = graph.incoming(part);
+    const kind = contentKinds[mediaType] ?? incoming.map((edge) => relationshipKinds[edge.type]).find((value) => value !== void 0) ?? (mediaType.startsWith("font/") ? "font" : activeReasons.length ? "active-payload" : void 0);
+    if (!kind) continue;
+    if (["ole", "package", "control", "web-extension", "active-payload"].includes(kind))
+      activeReasons.push(`potentially-active-${kind}`);
+    const pending = [part];
+    const seen = new Set(pending);
+    const missing = /* @__PURE__ */ new Set();
+    const external = [];
+    for (let cursor = 0; cursor < pending.length; cursor++) {
+      context.signal?.throwIfAborted();
+      for (const edge of graph.outgoing(pending[cursor])) {
+        if (edge.external) external.push(edge);
+        else if (edge.targetPart !== null) {
+          if (!reader.has(edge.targetPart)) missing.add(edge.targetPart);
+          else if (!seen.has(edge.targetPart)) {
+            seen.add(edge.targetPart);
+            pending.push(edge.targetPart);
+          }
+        }
+      }
+    }
+    objects.push(
+      Object.freeze({
+        part,
+        kind,
+        contentType,
+        bytes: bytes.length,
+        sha256: digest(bytes),
+        activeContent: activeReasons.length > 0,
+        activeReasons: Object.freeze(activeReasons),
+        owners: Object.freeze([...new Set(incoming.map((edge) => edge.owner))].sort()),
+        dependencies: Object.freeze(pending.slice(1).sort()),
+        missing: Object.freeze([...missing].sort()),
+        externalRelationships: Object.freeze(external)
+      })
+    );
+  }
+  return Object.freeze({
+    objects: Object.freeze(objects),
+    activationPerformed: false,
+    recursiveParsingPerformed: false
+  });
+}
+async function readObjects(input, context) {
+  const reader = await readPackage(input, context);
+  return inspectObjects(reader, readRelationshipGraph(reader, context.relationshipLimits), context);
+}
+async function extractObject(input, options, context) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).length !== 1 || !Object.hasOwn(options, "part") || !("value" in Object.getOwnPropertyDescriptor(options, "part")) || typeof options.part !== "string")
+    throw new OfficeError(
+      "invalid-value",
+      "Object extraction requires an exact package part.",
+      "usage"
+    );
+  const selected = partName(options.part, false);
+  const reader = await readPackage(input, context);
+  const graph = readRelationshipGraph(reader, context.relationshipLimits);
+  const inventory = inspectObjects(reader, graph, context);
+  const object = inventory.objects.find((row) => row.part === selected);
+  if (!object) throw new OfficeError("missing-binding", "Opaque object part is absent.", "index");
+  if (object.missing.length)
+    throw new OfficeError("missing-binding", "Opaque object dependency is absent.", "index");
+  const parts = [object.part, ...object.dependencies];
+  const dependencies = [...object.dependencies];
+  const edges = [];
+  for (const part of parts) {
+    context.signal?.throwIfAborted();
+    edges.push(...graph.outgoing(part));
+    const slash = part.lastIndexOf("/");
+    const rels = `${part.slice(0, slash + 1)}_rels/${part.slice(slash + 1)}.rels`;
+    if (reader.has(rels)) dependencies.push(rels);
+  }
+  const extracted = (part) => Object.freeze({
+    part,
+    name: `opaque-${digest(new TextEncoder().encode(part))}.bin`,
+    bytes: reader.get(part)
+  });
+  return Object.freeze({
+    ...extracted(object.part),
+    dependencies: Object.freeze(dependencies.sort().map(extracted)),
+    relationships: Object.freeze(edges)
+  });
+}
+async function readFonts(input, context) {
+  const reader = await readPackage(input, context);
+  const graph = readRelationshipGraph(reader, context.relationshipLimits);
+  const inventory = inspectObjects(reader, graph, context);
+  const declarations = [];
+  for (const main of graph.outgoing("/").filter(
+    (edge) => !edge.external && relationships.some((namespace) => edge.type === `${namespace}/officeDocument`)
+  )) {
+    if (!main.targetPart || !reader.has(main.targetPart))
+      throw new OfficeError("missing-binding", "Presentation part is absent.", "index");
+    const root = parseXmlPart(reader.get(main.targetPart), context.xmlLimits).root;
+    const namespace = root.name.namespace;
+    if (![
+      "http://schemas.openxmlformats.org/presentationml/2006/main",
+      "http://purl.oclc.org/ooxml/presentationml/main"
+    ].includes(namespace))
+      continue;
+    for (const list of root.children.filter(
+      (node) => node.name.namespace === namespace && node.name.localName === "embeddedFontLst"
+    )) {
+      for (const node of list.children.filter(
+        (node2) => node2.name.namespace === namespace && node2.name.localName === "embeddedFont"
+      )) {
+        const font = node.children.find(
+          (child) => child.name.namespace === namespace && child.name.localName === "font"
+        );
+        const attr = (name) => font?.attributes.find(
+          (attribute) => attribute.name.namespace === "" && attribute.name.localName === name
+        )?.value ?? null;
+        const variants = node.children.filter(
+          (child) => child.name.namespace === namespace && ["regular", "bold", "italic", "boldItalic"].includes(child.name.localName)
+        ).map((child) => {
+          const relationshipId = child.attributes.find(
+            (attribute) => relationships.includes(attribute.name.namespace) && attribute.name.localName === "id"
+          )?.value ?? null;
+          const edge = graph.outgoing(main.targetPart).find(
+            (edge2) => edge2.id === relationshipId && !edge2.external && relationshipKinds[edge2.type] === "font"
+          );
+          const part = edge?.targetPart ?? null;
+          return Object.freeze({
+            variant: child.name.localName,
+            relationshipId,
+            part,
+            missing: part === null || !reader.has(part)
+          });
+        });
+        declarations.push(
+          Object.freeze({
+            part: main.targetPart,
+            typeface: attr("typeface"),
+            charset: attr("charset"),
+            pitchFamily: attr("pitchFamily"),
+            variants: Object.freeze(variants)
+          })
+        );
+      }
+    }
+  }
+  return Object.freeze({
+    declarations: Object.freeze(declarations),
+    fonts: Object.freeze(inventory.objects.filter((object) => object.kind === "font")),
+    installationPerformed: false
+  });
+}
+
+export {
+  readObjects,
+  extractObject,
+  readFonts
+};

package/dist/safe-bash/command-chunks/{chunk-YJ3TFZB2.js → chunk-PQOAM5SC.js}

@@ -1,4 +1,4 @@
-// packages/safe-bash-command-node/src/integrations/safejs/values.ts
+// packages/safe-bash-command-safejs/src/values.ts
 function record(value, name) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new TypeError(`${name} must be a plain object`);

package/dist/safe-bash/command-chunks/chunk-PQOIOVF2.js

@@ -0,0 +1,444 @@
+import {
+  addImage
+} from "./chunk-KS6WUDPM.js";
+import {
+  readMedia
+} from "./chunk-IW7PEB4I.js";
+import {
+  readImages
+} from "./chunk-GIESJLR2.js";
+import {
+  admitImage
+} from "./chunk-45BW6MGM.js";
+import {
+  attr,
+  child,
+  escape,
+  invalid,
+  loadShared,
+  nextRel,
+  relPart,
+  required
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  packageUri,
+  relativePartReference
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/media-editing.ts
+var mediaNs = "http://schemas.microsoft.com/office/powerpoint/2010/main";
+var mediaRel = "http://schemas.microsoft.com/office/2007/relationships/media";
+var relNs = "http://schemas.openxmlformats.org/package/2006/relationships";
+function fields(value, names) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Reflect.ownKeys(value).some(
+    (key) => typeof key !== "string" || !names.includes(key) || !("value" in Object.getOwnPropertyDescriptor(value, key))
+  ))
+    invalid("Invalid media options.");
+}
+function budget(bytes, context) {
+  if (!(bytes instanceof Uint8Array) || !bytes.byteLength)
+    invalid("Media requires nonempty supplied bytes.");
+  if (bytes.byteLength > Math.min(context.limits.maxBytes, context.archiveLimits.maxEntryBytes))
+    throw new OfficeError("resource-limit", "Media exceeds the admitted byte budget.", "admit");
+}
+function admit(bytes, type, kind, context) {
+  context.signal?.throwIfAborted();
+  budget(bytes, context);
+  if (typeof type !== "string" || !["audio", "video"].includes(kind))
+    invalid("Invalid media kind or content type.");
+  const profiles = {
+    "video/mp4": ["video", "mp4"],
+    "audio/mp4": ["audio", "m4a"],
+    "video/quicktime": ["video", "mov"],
+    "video/mpeg": ["video", "mpg"],
+    "audio/mpeg": ["audio", "mp3"],
+    "audio/wav": ["audio", "wav"],
+    "audio/x-wav": ["audio", "wav"],
+    "video/x-msvideo": ["video", "avi"],
+    "video/x-ms-wmv": ["video", "wmv"],
+    "audio/x-ms-wma": ["audio", "wma"]
+  };
+  const profile = Object.hasOwn(profiles, type) ? profiles[type] : void 0;
+  if (!profile || profile[0] !== kind) invalid("Unsupported media content type or kind mismatch.");
+  const ascii = (offset, n) => String.fromCharCode(...bytes.subarray(offset, offset + n));
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let valid = false;
+  if (["mp4", "m4a", "mov"].includes(profile[1])) {
+    let offset = 0, header = false;
+    while (offset + 8 <= bytes.length) {
+      const size = view.getUint32(offset);
+      const name = ascii(offset + 4, 4);
+      if (size < 8 || size > bytes.length - offset) break;
+      if (name === "ftyp" && size >= 16) header = true;
+      offset += size;
+    }
+    valid = header && offset === bytes.length;
+  } else if (["wav", "avi"].includes(profile[1]))
+    valid = bytes.length >= 12 && ascii(0, 4) === "RIFF" && view.getUint32(4, true) === bytes.length - 8 && ascii(8, 4) === (profile[1] === "wav" ? "WAVE" : "AVI ");
+  else if (profile[1] === "mpg")
+    valid = bytes.length >= 12 && bytes[0] === 0 && bytes[1] === 0 && bytes[2] === 1 && [186, 179].includes(bytes[3]);
+  else if (profile[1] === "mp3")
+    valid = bytes.length >= 10 && ascii(0, 3) === "ID3" && bytes[3] >= 2 && bytes[3] <= 4 && bytes.subarray(6, 10).every((x) => x < 128) && (bytes[6] << 21 | bytes[7] << 14 | bytes[8] << 7 | bytes[9]) <= bytes.length - 10 || bytes.length >= 4 && bytes[0] === 255 && (bytes[1] & 224) === 224 && (bytes[1] & 6) !== 0 && (bytes[2] & 240) !== 240 && (bytes[2] & 12) !== 12;
+  else
+    valid = bytes.length >= 30 && [
+      48,
+      38,
+      178,
+      117,
+      142,
+      102,
+      207,
+      17,
+      166,
+      217,
+      0,
+      170,
+      0,
+      98,
+      206,
+      108
+    ].every((x, i) => bytes[i] === x) && view.getBigUint64(16, true) <= BigInt(bytes.length);
+  if (!valid) invalid("Media bytes do not match the declared container type.");
+  return profile[1];
+}
+function poster(value, context) {
+  if (value === void 0) invalid("Media requires an explicit poster.");
+  fields(value, ["bytes", "contentType"]);
+  budget(value.bytes, context);
+  admitImage(value.bytes, value.contentType);
+  return { bytes: new Uint8Array(value.bytes), contentType: value.contentType };
+}
+function walk(node) {
+  return [node, ...node.children.flatMap(walk)];
+}
+function store(s, bytes, type, extension, deduplicate = false) {
+  if (deduplicate)
+    for (const candidate of s.index.inventory.parts) {
+      if (candidate.contentType !== type || candidate.bytes !== bytes.byteLength) continue;
+      const existing = s.reader.get(candidate.part);
+      if (existing.every((value, index) => value === bytes[index])) return candidate.part;
+    }
+  let i = 1;
+  const names = [...s.reader.names, ...s.changes.keys()].map((x) => x.toLowerCase());
+  while (names.includes(`/ppt/media/clip${i}.${extension}`)) i++;
+  const part = `/ppt/media/clip${i}.${extension}`;
+  s.changes.set(part, new Uint8Array(bytes));
+  const types = s.doc("/[Content_Types].xml");
+  s.save(
+    "/[Content_Types].xml",
+    types.spliceChildren(types.root, types.root.children.length, 0, [
+      `<Override xmlns="${types.root.name.namespace}" PartName="${part}" ContentType="${escape(type)}"/>`
+    ])
+  );
+  return part;
+}
+function edge(s, owner, part, type) {
+  const path = relPart(owner), doc = s.doc(path), id = nextRel(doc);
+  s.save(
+    path,
+    doc.spliceChildren(doc.root, doc.root.children.length, 0, [
+      `<Relationship xmlns="${relNs}" Id="${id}" Type="${type}" Target="${escape(relativePartReference(part, packageUri(owner).baseURI))}"/>`
+    ])
+  );
+  return id;
+}
+async function addMedia(input, options, context) {
+  fields(options, [
+    "slide",
+    "bytes",
+    "contentType",
+    "kind",
+    "poster",
+    "left",
+    "top",
+    "width",
+    "height",
+    "trimStart",
+    "trimEnd",
+    "loop",
+    "volume"
+  ]);
+  const extension = admit(options.bytes, options.contentType, options.kind, context), icon = poster(options.poster, context), bytes = new Uint8Array(options.bytes);
+  for (const key of ["left", "top", "width", "height"])
+    if (!Number.isSafeInteger(options[key]) || Math.abs(options[key]) > 27273042316900 || ["width", "height"].includes(key) && options[key] <= 0)
+      invalid("Media requires explicit bounded EMU geometry.");
+  for (const key of ["trimStart", "trimEnd", "volume"])
+    if (options[key] !== void 0 && (!Number.isSafeInteger(options[key]) || options[key] < 0 || options[key] > (key === "volume" ? 1e5 : 2147483647)))
+      invalid("Invalid media playback metadata.");
+  if (options.loop !== void 0 && typeof options.loop !== "boolean")
+    invalid("Loop requires a boolean.");
+  const pictured = await addImage(
+    input,
+    {
+      slide: options.slide,
+      bytes: icon.bytes,
+      contentType: icon.contentType,
+      left: options.left,
+      top: options.top,
+      width: options.width,
+      height: options.height
+    },
+    context
+  );
+  const image = (await readImages(pictured, { slide: options.slide }, context)).occurrences.at(-1);
+  const s = await loadShared(pictured, context), owner = image.sourcePart, part = store(s, bytes, options.contentType, extension, true);
+  const legacy = edge(s, owner, part, `${s.r}/${options.kind}`), modern = edge(s, owner, part, mediaRel);
+  let doc = s.doc(owner);
+  const shape = walk(doc.root).find(
+    (node2) => node2.name.localName === "pic" && node2.name.namespace === s.p && child(child(node2, "nvPicPr"), "cNvPr") && attr(child(child(node2, "nvPicPr"), "cNvPr"), "id") === image.shapeId
+  );
+  const identity = required(required(shape, "nvPicPr"), "cNvPr");
+  s.save(
+    owner,
+    doc.merge(identity, {
+      attributes: [{ namespace: "", localName: "name", value: `Media ${image.shapeId}` }]
+    })
+  );
+  doc = s.doc(owner);
+  const nv = walk(doc.root).find(
+    (node2) => node2.name.localName === "nvPicPr" && attr(required(node2, "cNvPr"), "id") === image.shapeId
+  );
+  const clickable = required(nv, "cNvPr");
+  s.save(
+    owner,
+    doc.spliceChildren(clickable, 0, 0, [
+      `<a:hlinkClick xmlns:a="${s.a}" action="ppaction://media"/>`
+    ])
+  );
+  doc = s.doc(owner);
+  const currentNv = walk(doc.root).find(
+    (n) => n.name.namespace === s.p && n.name.localName === "nvPicPr" && attr(required(n, "cNvPr"), "id") === image.shapeId
+  );
+  const nvPr = required(currentNv, "nvPr");
+  s.save(
+    owner,
+    doc.spliceChildren(nvPr, 0, 0, [
+      `<a:${options.kind}File xmlns:a="${s.a}" xmlns:r="${s.r}" r:link="${legacy}"/>`,
+      `<p:extLst xmlns:p="${s.p}"><p:ext uri="{DAA4B4D4-6D71-4841-9C94-3DE7FCFB9230}"><m:media xmlns:m="${mediaNs}" xmlns:r="${s.r}" r:embed="${modern}">${options.trimStart !== void 0 || options.trimEnd !== void 0 ? `<m:trim st="${options.trimStart ?? 0}" end="${options.trimEnd ?? 0}"/>` : ""}</m:media></p:ext></p:extLst>`
+    ])
+  );
+  doc = s.doc(owner);
+  const timing = child(doc.root, "timing");
+  let id = 1;
+  const used = new Set(
+    walk(doc.root).filter((n) => n.name.namespace === s.p && n.name.localName === "cTn").map((n) => attr(n, "id"))
+  );
+  while (used.has(String(id))) id++;
+  const node = `<p:${options.kind} xmlns:p="${s.p}"><p:cMediaNode${options.volume !== void 0 ? ` vol="${options.volume}"` : ""}><p:cTn id="${id}" fill="hold" display="0"${options.loop === true ? ' repeatCount="indefinite"' : options.loop === false ? ' repeatCount="1000"' : ""}><p:stCondLst><p:cond delay="indefinite"/></p:stCondLst></p:cTn><p:tgtEl><p:spTgt spid="${image.shapeId}"/></p:tgtEl></p:cMediaNode></p:${options.kind}>`;
+  if (timing) {
+    const list = child(timing, "tnLst");
+    s.save(
+      owner,
+      list ? doc.spliceChildren(list, list.children.length, 0, [node]) : doc.spliceChildren(timing, 0, 0, [`<p:tnLst xmlns:p="${s.p}">${node}</p:tnLst>`])
+    );
+  } else {
+    const ext = child(doc.root, "extLst");
+    s.save(
+      owner,
+      doc.spliceChildren(
+        doc.root,
+        ext ? doc.root.children.indexOf(ext) : doc.root.children.length,
+        0,
+        [`<p:timing xmlns:p="${s.p}"><p:tnLst>${node}</p:tnLst></p:timing>`]
+      )
+    );
+  }
+  return (await s.finish(owner, [options.slide])).bytes;
+}
+async function replaceMedia(input, options, context) {
+  fields(options, [
+    "scope",
+    "slide",
+    "shape",
+    "select",
+    "bytes",
+    "poster",
+    "contentType",
+    "kind",
+    "shared",
+    "all",
+    "allowEmpty"
+  ]);
+  for (const key of ["shared", "all", "allowEmpty"])
+    if (options[key] !== void 0 && typeof options[key] !== "boolean")
+      invalid("Media replacement policies require booleans.");
+  if (options.poster === void 0) invalid("Media replacement requires an explicit poster.");
+  const icon = poster(options.poster, context);
+  budget(options.bytes, context);
+  const bytes = new Uint8Array(options.bytes);
+  const s = await loadShared(input, context);
+  const selector = {
+    ...options.scope !== void 0 ? { scope: options.scope } : {},
+    ...options.slide !== void 0 ? { slide: options.slide } : {},
+    ...options.shape !== void 0 ? { shape: options.shape } : {},
+    ...options.select !== void 0 ? { select: options.select } : {}
+  };
+  let selected = [...(await readMedia(s.source, selector, context)).occurrences];
+  if (!selected.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+  if (selected.length > 1 && !options.all) throw new SelectionError("ambiguous-selection");
+  const all = (await readMedia(s.source, { scope: "shared" }, context)).occurrences;
+  const oldParts = new Set(
+    selected.flatMap((x) => x.relationships.map((r) => r.mediaPart).filter((x2) => x2 !== null))
+  );
+  if (options.shared)
+    selected = all.filter(
+      (x) => selected.some((y) => y.id === x.id) || x.relationships.some((r) => r.mediaPart !== null && oldParts.has(r.mediaPart))
+    );
+  for (const occurrence of selected) {
+    if (!occurrence.shapeId || !occurrence.posters.length || [...occurrence.relationships, ...occurrence.posters].some((x) => x.external))
+      throw new OfficeError(
+        "unsupported-edit",
+        "Replacement requires an embedded media shape with an existing poster graph.",
+        "validate-intent"
+      );
+    if (new Set(occurrence.relationships.map((x) => x.mediaPart)).size !== 1)
+      invalid("Replacement requires one unambiguous media resource per shape.");
+    const type = options.contentType ?? occurrence.relationships[0].contentType;
+    if (!type) invalid("Replacement requires a media content type.");
+    const kind = options.kind ?? occurrence.kind;
+    if (kind !== occurrence.kind) invalid("Replacement cannot change media kind.");
+    admit(bytes, type, kind, context);
+    const doc = s.doc(occurrence.sourcePart);
+    const shape = walk(doc.root).find(
+      (node) => node.name.namespace === s.p && ["pic", "sp", "graphicFrame"].includes(node.name.localName) && node.children.some(
+        (nv) => nv.children.some(
+          (identity) => identity.name.namespace === s.p && identity.name.localName === "cNvPr" && attr(identity, "id") === occurrence.shapeId
+        )
+      )
+    );
+    if (!shape) throw new SelectionError("missing-selection");
+    const bindings = /* @__PURE__ */ new Map();
+    for (const container of shape.children.filter((node) => node.name.namespace === s.p)) {
+      if (container.name.localName === "blipFill") {
+        for (const node of container.children)
+          if (node.name.namespace === s.a && node.name.localName === "blip")
+            bindings.set(node, "embed");
+      }
+      if (!["nvPicPr", "nvSpPr", "nvGraphicFramePr"].includes(container.name.localName)) continue;
+      for (const nv of container.children.filter(
+        (node) => node.name.namespace === s.p && node.name.localName === "nvPr"
+      )) {
+        for (const node of nv.children) {
+          if (node.name.namespace === s.a) {
+            if (["videoFile", "audioFile"].includes(node.name.localName))
+              bindings.set(node, "link");
+            if (node.name.localName === "wavAudioFile") bindings.set(node, "embed");
+          }
+          if (node.name.namespace !== s.p || node.name.localName !== "extLst") continue;
+          for (const ext of node.children.filter(
+            (element) => element.name.namespace === s.p && element.name.localName === "ext"
+          ))
+            for (const media of ext.children)
+              if (media.name.namespace === mediaNs && media.name.localName === "media")
+                bindings.set(media, "embed");
+        }
+      }
+    }
+    const replacedIds = new Set(
+      [...occurrence.relationships, ...occurrence.posters].map(
+        (reference) => reference.relationshipId
+      )
+    );
+    if (walk(shape).some(
+      (node) => node.attributes.some(
+        (attribute) => attribute.name.namespace === s.r && replacedIds.has(attribute.value) && bindings.get(node) !== attribute.name.localName
+      )
+    ))
+      throw new OfficeError(
+        "unsupported-edit",
+        "Replacement would rebind unsupported media or track metadata.",
+        "validate-intent"
+      );
+  }
+  const posters = admitImage(icon.bytes, icon.contentType);
+  const affectedSlides = /* @__PURE__ */ new Set();
+  const replacementParts = /* @__PURE__ */ new Map();
+  for (const occurrence of selected) {
+    const owner = occurrence.sourcePart;
+    const type = options.contentType ?? occurrence.relationships[0].contentType;
+    const resourceKey = `${occurrence.relationships[0].mediaPart}#${type}`;
+    const part = (options.shared ? replacementParts.get(resourceKey) : void 0) ?? store(s, bytes, type, admit(bytes, type, occurrence.kind, context));
+    replacementParts.set(resourceKey, part);
+    const image = store(s, icon.bytes, icon.contentType, posters.extension);
+    for (const reference of [...occurrence.relationships, ...occurrence.posters]) {
+      const newPart = occurrence.posters.includes(reference) ? image : part;
+      const ownerDoc = s.doc(owner);
+      const ownerNodes = walk(ownerDoc.root);
+      const selectedShape = ownerNodes.find(
+        (n) => n.name.namespace === s.p && ["pic", "sp", "graphicFrame"].includes(n.name.localName) && n.children.some(
+          (nv) => nv.children.some(
+            (c) => c.name.namespace === s.p && c.name.localName === "cNvPr" && attr(c, "id") === occurrence.shapeId
+          )
+        )
+      );
+      const inside = new Set(walk(selectedShape));
+      const sharedBinding = ownerNodes.some(
+        (n) => !inside.has(n) && n.attributes.some((a) => a.name.namespace === s.r && a.value === reference.relationshipId)
+      );
+      if (!sharedBinding) {
+        const path = relPart(owner), doc = s.doc(path), node = doc.root.children.find((n) => attr(n, "Id") === reference.relationshipId);
+        s.save(
+          path,
+          doc.merge(node, {
+            attributes: [
+              {
+                namespace: "",
+                localName: "Target",
+                value: relativePartReference(newPart, packageUri(owner).baseURI)
+              }
+            ]
+          })
+        );
+      } else {
+        const rid = edge(s, owner, newPart, reference.relationshipType);
+        let doc = s.doc(owner);
+        const shape = walk(doc.root).find(
+          (n) => n.name.namespace === s.p && ["pic", "sp", "graphicFrame"].includes(n.name.localName) && n.children.some(
+            (nv) => nv.children.some(
+              (c) => c.name.localName === "cNvPr" && attr(c, "id") === occurrence.shapeId
+            )
+          )
+        );
+        const matches = walk(shape).flatMap(
+          (n) => n.attributes.filter((a) => a.name.namespace === s.r && a.value === reference.relationshipId).map((a) => ({ index: walk(doc.root).indexOf(n), local: a.name.localName }))
+        );
+        for (const match of matches) {
+          doc = s.doc(owner);
+          const node = walk(doc.root)[match.index];
+          s.save(
+            owner,
+            doc.merge(node, {
+              attributes: [{ namespace: s.r, localName: match.local, value: rid }]
+            })
+          );
+        }
+      }
+    }
+    for (const slide of s.index.inventory.slides) {
+      const notes = s.index.inventory.relationships.filter(
+        (edge2) => edge2.owner === slide.part && !edge2.external && edge2.type === `${s.r}/notesSlide`
+      ).flatMap((edge2) => edge2.targetPart ? [edge2.targetPart] : []);
+      if ([slide.part, slide.layout, slide.master, ...notes].includes(owner) || s.index.inventory.relationships.some(
+        (edge2) => notes.includes(edge2.owner) && !edge2.external && edge2.type === `${s.r}/notesMaster` && edge2.targetPart === owner
+      ))
+        affectedSlides.add(slide.position);
+    }
+  }
+  if (!selected.length) return { bytes: s.source, affected: 0, affectedSlides: [] };
+  return {
+    bytes: (await s.finish(selected[0].sourcePart, [...affectedSlides])).bytes,
+    affected: selected.length,
+    affectedSlides: [...affectedSlides]
+  };
+}
+
+export {
+  addMedia,
+  replaceMedia
+};