@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,1376 @@
+import {
+  validateXmlPartReplacement,
+  validateXmlViewReplacement
+} from "./chunk-3CHQG25N.js";
+import {
+  Slide,
+  Slides,
+  indexed,
+  preservePlaceholder,
+  reparentInsertedAsset
+} from "./chunk-EUXUCRCI.js";
+import {
+  Chart,
+  insertChartIntoState,
+  inspectWorkbook,
+  replaceChartData
+} from "./chunk-F2ORFLCH.js";
+import {
+  createPresentation
+} from "./chunk-326A5G42.js";
+import {
+  addOleObject
+} from "./chunk-KDKQ5D55.js";
+import {
+  createLiveLinkSession,
+  isOrdinaryLinkUrl
+} from "./chunk-2UUFZMOH.js";
+import {
+  applyPresentationCanvasSettings
+} from "./chunk-AQNFEGMZ.js";
+import {
+  prepareSlideInsertion
+} from "./chunk-763ECQWB.js";
+import {
+  CoreProperties,
+  createPropertyPart
+} from "./chunk-W5YFDYHO.js";
+import {
+  Image
+} from "./chunk-HUNXIAOL.js";
+import {
+  addMedia
+} from "./chunk-PQOIOVF2.js";
+import {
+  addImage
+} from "./chunk-KS6WUDPM.js";
+import {
+  readShape
+} from "./chunk-HHLVI2CB.js";
+import {
+  createXmlElementView
+} from "./chunk-QXCSASIE.js";
+import {
+  Length
+} from "./chunk-I6AMDG2T.js";
+import {
+  attr,
+  child,
+  editContent,
+  loadShared,
+  relPart,
+  required
+} from "./chunk-RAXJVM4U.js";
+import {
+  writePackageArchive
+} from "./chunk-YRNBIU5U.js";
+import {
+  buildSelectionIndex
+} from "./chunk-CKEODJVT.js";
+import {
+  readPackage
+} from "./chunk-FRZ5P5AB.js";
+import {
+  readBinary,
+  writeBinary
+} from "./chunk-TL3KDYEM.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  parseContentTypes
+} from "./chunk-N74TJL6X.js";
+import {
+  parseRelationships,
+  readRelationshipGraph
+} from "./chunk-5GEFJROP.js";
+import {
+  packageUri,
+  partName,
+  resolvePartReference
+} from "./chunk-XXFHTGV2.js";
+import {
+  resourceContext
+} from "./chunk-FOO3AXFK.js";
+import {
+  IndexError,
+  InvalidHandleError,
+  OfficeError,
+  PropertyAccessError,
+  TypeError,
+  ValueError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/links-model.ts
+var values = {
+  END_SHOW: 6,
+  FIRST_SLIDE: 3,
+  HYPERLINK: 7,
+  LAST_SLIDE: 4,
+  LAST_SLIDE_VIEWED: 5,
+  NAMED_SLIDE: 101,
+  NAMED_SLIDE_SHOW: 10,
+  NEXT_SLIDE: 1,
+  NONE: 0,
+  OPEN_FILE: 102,
+  OLE_VERB: 11,
+  PLAY: 12,
+  PREVIOUS_SLIDE: 2,
+  RUN_MACRO: 8,
+  RUN_PROGRAM: 9
+};
+var PP_ACTION_TYPE = Object.freeze(
+  Object.fromEntries(
+    Object.entries(values).map(([name, value]) => [name, Object.freeze({ name, value })])
+  )
+);
+var PP_ACTION = PP_ACTION_TYPE;
+var verbs = {
+  hlinksldjump: "NAMED_SLIDE",
+  hlinkfile: "OPEN_FILE",
+  hlinkpres: "PLAY",
+  customshow: "NAMED_SLIDE_SHOW",
+  ole: "OLE_VERB",
+  macro: "RUN_MACRO",
+  program: "RUN_PROGRAM"
+};
+var jumps = {
+  firstslide: "FIRST_SLIDE",
+  lastslide: "LAST_SLIDE",
+  nextslide: "NEXT_SLIDE",
+  previousslide: "PREVIOUS_SLIDE",
+  endshow: "END_SHOW",
+  lastslideviewed: "LAST_SLIDE_VIEWED"
+};
+function editable(link) {
+  if (link?.requiresSanitization)
+    throw new OfficeError(
+      "unsupported-edit",
+      "Remove the unsupported action with explicit sanitization first.",
+      "validate-intent"
+    );
+}
+var Hyperlink = class {
+  #owner;
+  constructor(owner) {
+    this.#owner = owner;
+  }
+  get #current() {
+    return typeof this.#owner === "function" ? this.#owner() : this.#owner;
+  }
+  get part() {
+    return this.#current.part;
+  }
+  get address() {
+    const link = this.#current.read();
+    return link?.url ?? link?.targetReference ?? null;
+  }
+  set address(value) {
+    const owner = this.#current;
+    editable(owner.read());
+    if (value === null || value === "") {
+      owner.remove();
+      return;
+    }
+    if (!isOrdinaryLinkUrl(value))
+      throw new OfficeError("invalid-value", "An ordinary inert URL is required.", "usage");
+    owner.set({ url: value });
+  }
+};
+var ActionSetting = class {
+  #owner;
+  #hyperlink;
+  constructor(owner) {
+    this.#owner = owner;
+    this.#hyperlink = new Hyperlink(owner);
+  }
+  get part() {
+    return this.#owner.part;
+  }
+  get hyperlink() {
+    return this.#hyperlink;
+  }
+  get action() {
+    const link = this.#owner.read();
+    if (!link) return PP_ACTION.NONE;
+    if (!link.action) return PP_ACTION.HYPERLINK;
+    if (!link.action.startsWith("ppaction://")) return PP_ACTION.NONE;
+    const [verb, query = ""] = link.action.slice(11).split("?");
+    if (verb === "hlinkshowjump")
+      return PP_ACTION[jumps[new URLSearchParams(query).get("jump") ?? ""] ?? "NONE"];
+    return PP_ACTION[verbs[verb] ?? "NONE"];
+  }
+  get target_slide() {
+    const action = this.action.name;
+    if (!["FIRST_SLIDE", "LAST_SLIDE", "NEXT_SLIDE", "PREVIOUS_SLIDE", "NAMED_SLIDE"].includes(action))
+      return null;
+    const slides = this.#owner.slides;
+    const current = slides.indexOf(this.#owner.slide);
+    if (current < 0)
+      throw new OfficeError(
+        "invalid-selection",
+        "The action owner slide is no longer present.",
+        "select"
+      );
+    const index = action === "FIRST_SLIDE" ? 0 : action === "LAST_SLIDE" ? slides.length - 1 : action === "NEXT_SLIDE" ? current + 1 : action === "PREVIOUS_SLIDE" ? current - 1 : (this.#owner.read()?.targetSlide ?? 0) - 1;
+    if (index < 0 || index >= slides.length)
+      throw new OfficeError(
+        "invalid-value",
+        "The navigation target is outside this presentation.",
+        "usage"
+      );
+    return slides[index];
+  }
+  set target_slide(value) {
+    editable(this.#owner.read());
+    if (value === null) {
+      this.#owner.remove();
+      return;
+    }
+    const index = this.#owner.slides.indexOf(value);
+    if (index < 0)
+      throw new OfficeError(
+        "invalid-value",
+        "The target slide must belong to this presentation.",
+        "usage"
+      );
+    this.#owner.set({ targetSlide: index + 1 });
+  }
+};
+var LinkShape = class {
+  #session;
+  #identity;
+  constructor(session, identity) {
+    this.#session = session;
+    this.#identity = Object.freeze({ ...identity });
+    session.getPart(identity.owner);
+  }
+  owner(path, trigger = "click") {
+    const session = this.#session, identity = this.#identity;
+    const slide = session.slides.find((item) => item.part === identity.owner);
+    if (!slide)
+      throw new OfficeError("invalid-selection", "The link shape has no owning slide.", "select");
+    const xml = session.getPart(slide.part);
+    let shape;
+    let propertyPath;
+    const visit = (node, route, parent) => {
+      if (node.name.namespace === xml.root.name.namespace && node.name.localName === "cNvPr" && node.attributes.some(
+        (attr2) => attr2.name.namespace === "" && attr2.name.localName === "id" && attr2.value === identity.id
+      )) {
+        if (propertyPath)
+          throw new OfficeError("invalid-selection", "The shape identity is ambiguous.", "select");
+        propertyPath = route;
+        shape = parent;
+      }
+      node.children.forEach((child3, index) => visit(child3, [...route, index], node));
+    };
+    visit(xml.root, []);
+    if (!propertyPath)
+      throw new OfficeError("invalid-selection", "The link shape is no longer present.", "select");
+    if (shape?.name.localName === "nvGrpSpPr" && path === void 0)
+      throw new OfficeError("invalid-value", "Group shapes do not expose a click action.", "usage");
+    if (path !== void 0) {
+      const shapePath = propertyPath.slice(0, -2);
+      let target = xml.root;
+      if (!shapePath.every((index, offset) => path[offset] === index))
+        throw new OfficeError("invalid-selection", "The run belongs to another shape.", "select");
+      let depth = 0;
+      for (const index of path) {
+        if (!Number.isSafeInteger(index) || index < 0 || !target.children[index])
+          throw new OfficeError("invalid-selection", "The run property path is invalid.", "select");
+        target = target.children[index];
+        depth++;
+        if (depth > shapePath.length && target.name.namespace === xml.root.name.namespace && ["sp", "pic", "cxnSp", "graphicFrame", "grpSp"].includes(target.name.localName))
+          throw new OfficeError(
+            "invalid-selection",
+            "The run belongs to a nested shape.",
+            "select"
+          );
+      }
+      if (!["rPr", "defRPr", "endParaRPr"].includes(target.name.localName) || ![
+        "http://schemas.openxmlformats.org/drawingml/2006/main",
+        "http://purl.oclc.org/ooxml/drawingml/main"
+      ].includes(target.name.namespace))
+        throw new OfficeError("invalid-selection", "Select owned run properties.", "select");
+    }
+    const selectedPath = Object.freeze([...path ?? propertyPath]);
+    const options = {
+      selection: { kind: "object", owner: identity.owner, id: identity.id },
+      path: selectedPath,
+      trigger
+    };
+    return {
+      get part() {
+        return session.getPart(slide.part);
+      },
+      get slides() {
+        return session.slides;
+      },
+      slide,
+      read() {
+        const records = session.list(options.selection).filter(
+          (link) => link.trigger === trigger && link.path.length === selectedPath.length + 1 && selectedPath.every((index, offset) => link.path[offset] === index)
+        );
+        if (records.length > 1)
+          throw new OfficeError(
+            "unsupported-edit",
+            "Duplicate link nodes require explicit repair.",
+            "validate-intent"
+          );
+        return records[0] ?? null;
+      },
+      set(value) {
+        session.set({ ...options, ...value });
+      },
+      remove() {
+        session.remove(options);
+      }
+    };
+  }
+  get click_action() {
+    return new ActionSetting(this.owner());
+  }
+  run(path) {
+    return new LinkRun(this, path);
+  }
+};
+var LinkRun = class {
+  #hyperlink;
+  constructor(shape, path) {
+    this.#hyperlink = new Hyperlink(shape.owner(path));
+  }
+  get hyperlink() {
+    return this.#hyperlink;
+  }
+};
+
+// packages/safe-bash-presentation-engine/src/slide-layout-model.ts
+function child2(element, localName) {
+  const matches = element.children.filter(
+    (node) => node.tag.namespace === element.tag.namespace && node.tag.localName === localName
+  );
+  if (matches.length > 1) throw new ValueError("Ambiguous layout structure.");
+  return matches[0];
+}
+function related(part, id, type) {
+  const edges = part.rels.filter(
+    (edge) => edge.id === id && edge.type.endsWith(`/${type}`) && edge.mode === "internal"
+  );
+  if (edges.length !== 1) throw new InvalidHandleError();
+  const target = part.package.get_part(
+    resolvePartReference(packageUri(part.partname).baseURI, edges[0].target)
+  );
+  if (!target) throw new InvalidHandleError();
+  return target;
+}
+function relationshipId(node) {
+  return node.attrib.find(
+    (attribute) => attribute.name.localName === "id" && [
+      "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+      "http://purl.oclc.org/ooxml/officeDocument/relationships"
+    ].includes(attribute.name.namespace)
+  )?.value ?? null;
+}
+var SlideLayout = class {
+  constructor(part, setName) {
+    this.part = part;
+    this.#setName = setName;
+  }
+  part;
+  #setName;
+  get element() {
+    return this.part.element;
+  }
+  get name() {
+    return child2(this.element, "cSld")?.get({ namespace: "", localName: "name" }) ?? "";
+  }
+  set name(value) {
+    if (value !== null && typeof value !== "string")
+      throw new TypeError("Expected layout name text or null.");
+    this.#setName(value);
+  }
+};
+var SlideLayouts = class {
+  #presentation;
+  #views = /* @__PURE__ */ new Map();
+  #setName;
+  constructor(presentation, setName) {
+    this.#presentation = presentation;
+    this.#setName = setName;
+    return indexed(this);
+  }
+  #parts() {
+    const masterList = child2(this.#presentation.element, "sldMasterIdLst");
+    const masterId = masterList?.children.find(
+      (node) => node.tag.localName === "sldMasterId" && node.tag.namespace === masterList.tag.namespace
+    );
+    if (!masterId) throw new IndexError();
+    const master = related(this.#presentation, relationshipId(masterId), "slideMaster");
+    const layouts = child2(master.element, "sldLayoutIdLst");
+    return layouts?.children.filter(
+      (node) => node.tag.namespace === layouts.tag.namespace && node.tag.localName === "sldLayoutId"
+    ).map((node) => related(master, relationshipId(node), "slideLayout")) ?? [];
+  }
+  get length() {
+    return this.#parts().length;
+  }
+  get(index) {
+    const parts = this.#parts();
+    if (!Number.isSafeInteger(index) || index < 0 || index >= parts.length) throw new IndexError();
+    const part = parts[index];
+    let layout = this.#views.get(part.partname);
+    if (!layout) {
+      layout = new SlideLayout(part, (value) => this.#setName(part.partname, value));
+      this.#views.set(part.partname, layout);
+    }
+    return layout;
+  }
+  at(index) {
+    if (!Number.isSafeInteger(index)) throw new IndexError();
+    return this.get(index < 0 ? this.length + index : index);
+  }
+  get_by_name(name, default_value = null) {
+    if (typeof name !== "string" || default_value !== null && !(default_value instanceof SlideLayout))
+      throw new TypeError("Expected a layout name and optional layout fallback.");
+    return [...this].find((layout) => layout.name === name) ?? default_value;
+  }
+  index(slide_layout) {
+    if (!(slide_layout instanceof SlideLayout))
+      throw new TypeError("Expected an owned slide layout.");
+    const index = [...this].findIndex((layout) => layout.part === slide_layout.part);
+    if (index < 0) throw new ValueError("Layout is not in this collection.");
+    return index;
+  }
+  *[Symbol.iterator]() {
+    for (let index = 0; index < this.length; index++) yield this.get(index);
+  }
+};
+function prepareLayoutInsertion(state, presentation, layout, context, fingerprint) {
+  if (!(layout instanceof SlideLayout)) throw new TypeError("Expected an owned slide layout.");
+  if (layout.part.package !== presentation.package)
+    throw new ValueError("Layout belongs to another presentation.");
+  const parts = new Map(
+    [.../* @__PURE__ */ new Set([...state.reader.names, ...state.changes.keys()])].filter((name) => !state.deleted.has(name)).map((name) => [name, state.changes.get(name) ?? state.reader.get(name)])
+  );
+  const reader = {
+    get names() {
+      return [...parts.keys()];
+    },
+    has: (name) => parts.has(name),
+    get: (name) => {
+      const bytes = parts.get(name);
+      if (!bytes) throw new InvalidHandleError();
+      return bytes;
+    },
+    relsXmlFor: (name) => {
+      const slash = name.lastIndexOf("/");
+      return parts.get(
+        name === "/" ? "/_rels/.rels" : `${name.slice(0, slash)}/_rels/${name.slice(slash + 1)}.rels`
+      ) ?? null;
+    }
+  };
+  const prepared = prepareSlideInsertion(reader, { layout: layout.part.partname }, context);
+  for (const [name, bytes] of prepared.changes) parts.set(name, bytes);
+  const index = buildSelectionIndex(reader, fingerprint, context);
+  return { ...prepared, index };
+}
+
+// packages/safe-bash-presentation-engine/src/package-view.ts
+function createPackageView(state, context, changed) {
+  const views = /* @__PURE__ */ new Map();
+  const limits = {
+    ...context.xmlLimits,
+    ...context.relationshipLimits,
+    maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes),
+    maxEntries: context.archiveLimits.maxMembers
+  };
+  function current() {
+    if (context.signal?.aborted)
+      throw new OfficeError("cancelled", "Operation cancelled.", "select");
+    const names = [.../* @__PURE__ */ new Set([...state.reader.names, ...state.changes.keys()])].filter(
+      (name) => !state.deleted.has(name)
+    );
+    const get = (name) => {
+      if (!names.includes(name)) throw new InvalidHandleError();
+      return new Uint8Array(state.changes.get(name) ?? state.reader.get(name));
+    };
+    return {
+      names,
+      has: (name) => names.includes(name),
+      get,
+      relsXmlFor: (name) => {
+        const rels = name === "/" ? "/_rels/.rels" : relPart(name);
+        return names.includes(rels) ? get(rels) : null;
+      }
+    };
+  }
+  function view(name) {
+    const existing = views.get(name);
+    if (existing) return existing;
+    const initialBytes = state.changes.get(name) ?? state.reader.get(name);
+    let cachedBytes;
+    let cachedDocument;
+    let root;
+    let rootDocument;
+    const owner = {
+      read() {
+        if (!current().has(name)) throw new InvalidHandleError();
+        const bytes = state.changes.get(name) ?? initialBytes;
+        if (bytes !== cachedBytes) {
+          cachedDocument = parseXmlPart(bytes, context.xmlLimits);
+          cachedBytes = bytes;
+        }
+        return cachedDocument;
+      },
+      commit(expected, next) {
+        if (owner.read() !== expected) throw new InvalidHandleError();
+        part.blob = next.bytes();
+        cachedBytes = state.changes.get(name);
+        cachedDocument = next;
+      }
+    };
+    const part = Object.freeze({
+      get element() {
+        const type = part.content_type.split(";", 1)[0].trim().toLowerCase();
+        if (type !== "application/xml" && type !== "text/xml" && !type.endsWith("+xml"))
+          throw new PropertyAccessError("The part does not contain XML.");
+        const document = owner.read();
+        if (!root || rootDocument !== document) {
+          root = createXmlElementView(owner);
+          rootDocument = document;
+        }
+        return root;
+      },
+      get partname() {
+        current().get(name);
+        return name;
+      },
+      get content_type() {
+        const reader = current();
+        reader.get(name);
+        return parseContentTypes(reader.get("/[Content_Types].xml"), limits).get(name);
+      },
+      get blob() {
+        return current().get(name);
+      },
+      set blob(value) {
+        if (!(value instanceof Uint8Array)) throw new TypeError("Expected part bytes.");
+        if (value.length > Math.min(context.limits.maxBytes, context.archiveLimits.maxEntryBytes, limits.maxBytes))
+          throw new OfficeError("resource-limit", "Part byte limit exceeded.", "validate-intent");
+        const bytes = new Uint8Array(value);
+        validateXmlViewReplacement(
+          current(),
+          name,
+          bytes,
+          {
+            ...context,
+            validationLimits: limits
+          },
+          validateXmlPartReplacement
+        );
+        state.changes.set(name, bytes);
+        changed();
+      },
+      get rels() {
+        return Object.freeze(
+          readRelationshipGraph(current(), limits).outgoing(name).map(
+            (edge) => Object.freeze({
+              id: edge.id,
+              type: edge.type,
+              target: edge.target,
+              mode: edge.external ? "external" : "internal"
+            })
+          )
+        );
+      },
+      get package() {
+        current().get(name);
+        return result;
+      }
+    });
+    views.set(name, part);
+    return part;
+  }
+  const result = Object.freeze({
+    get parts() {
+      return Object.freeze(readRelationshipGraph(current(), limits).parts.map(view));
+    },
+    get_part(name) {
+      if (typeof name !== "string") throw new TypeError("Expected a package part URI.");
+      const canonical = partName(name, false);
+      const parts = readRelationshipGraph(current(), limits).parts;
+      return parts.includes(canonical) ? view(canonical) : null;
+    }
+  });
+  return result;
+}
+
+// packages/safe-bash-presentation-engine/src/presentation-model.ts
+function contextDefaults(context) {
+  if (!context || typeof context !== "object") throw new TypeError("Expected model context.");
+  if (context.author !== void 0 && typeof context.author !== "string")
+    throw new TypeError("Expected author text.");
+  if (context.timestamp !== void 0 && (!(context.timestamp instanceof Date) || !Number.isFinite(context.timestamp.getTime())))
+    throw new ValueError("Expected a valid explicit timestamp.");
+  return {
+    ...resourceContext(context),
+    author: context.author ?? "",
+    ...context.timestamp === void 0 ? {} : { timestamp: new Date(context.timestamp.getTime()) }
+  };
+}
+function cancelled(context) {
+  if (context.signal?.aborted)
+    throw new OfficeError("cancelled", "Operation cancelled.", "publish");
+}
+function workbookMembersReader(members) {
+  const entries = new Map(
+    members.map((member) => ["/" + member.name, new Uint8Array(member.bytes)])
+  );
+  const get = (name) => {
+    const bytes = entries.get(name);
+    if (!bytes)
+      throw new OfficeError("invalid-opc", "Workbook part is missing.", "validate-intent");
+    return new Uint8Array(bytes);
+  };
+  return {
+    names: Object.freeze([...entries.keys()]),
+    has: (name) => entries.has(name),
+    get,
+    relsXmlFor: (name) => {
+      const part = name === "/" ? "/_rels/.rels" : relPart(name);
+      return entries.has(part) ? get(part) : null;
+    }
+  };
+}
+var LivePresentation = class {
+  #part;
+  #slides;
+  #slideLayouts;
+  get slide_layouts() {
+    void this.#slideLayouts.length;
+    return this.#slideLayouts;
+  }
+  get slides() {
+    return this.#slides;
+  }
+  #state;
+  #context;
+  #inputPath;
+  #properties;
+  #propertyPart;
+  #revision = 0;
+  #pendingWorkbooks = /* @__PURE__ */ new Map();
+  #workbookFlush;
+  #publishedSource;
+  #workbooks;
+  constructor(state, context, inputPath, workbooks = /* @__PURE__ */ new Map()) {
+    this.#state = state;
+    this.#workbooks = workbooks;
+    this.#context = context;
+    this.#inputPath = inputPath;
+    this.#publishedSource = state.source;
+    this.#part = createPackageView(state, context, () => {
+      this.#revision++;
+    }).get_part(state.main);
+    const parts = state.index.inventory.relationships.filter(
+      (edge) => edge.owner === "/" && edge.type.endsWith("/metadata/core-properties") && !edge.external
+    );
+    if (parts.length > 1)
+      throw new OfficeError("ambiguous-selection", "Multiple core property parts.", "select");
+    this.#propertyPart = parts[0]?.targetPart ?? void 0;
+    this.#slideLayouts = new SlideLayouts(this.#part, (part, value) => {
+      let updated = editContent(
+        state.doc(part),
+        { name: value ?? "" },
+        state.p,
+        state.a,
+        context.xmlLimits.maxBytes,
+        context.xmlLimits.maxNodes
+      );
+      if (value === null)
+        updated = updated.merge(required(updated.root, "cSld"), {
+          attributes: [{ namespace: "", localName: "name", value: null }]
+        });
+      state.save(part, updated);
+      this.#revision++;
+    });
+    const linkSession = createLiveLinkSession(state, context, () => {
+      this.#revision++;
+    });
+    const createSlide = (record) => {
+      let latestBytes;
+      let latestXml;
+      const owner = {
+        part: this.#part.package.get_part(record.part),
+        hyperlink: (shapeId, path) => new Hyperlink(() => {
+          const relative = path();
+          const xml = state.doc(record.part);
+          const matches = [];
+          const visit = (node, route) => {
+            if (node.name.namespace === state.p && ["sp", "pic", "graphicFrame", "grpSp"].includes(node.name.localName) && readShape(node).shapeId === shapeId)
+              matches.push(route);
+            node.children.forEach((child3, index) => visit(child3, [...route, index]));
+          };
+          visit(xml.root, []);
+          if (matches.length !== 1)
+            throw new OfficeError(
+              "invalid-handle",
+              "Run shape is no longer available.",
+              "select"
+            );
+          return new LinkShape(linkSession, { owner: record.part, id: String(shapeId) }).owner([
+            ...matches[0],
+            ...relative
+          ]);
+        }),
+        resource: (id) => {
+          const edge = parseRelationships(
+            state.doc(relPart(record.part)).bytes(),
+            context.relationshipLimits
+          ).find((edge2) => edge2.id === id);
+          if (!edge || edge.external)
+            throw new OfficeError(
+              "unsupported-edit",
+              "Only embedded resources are accessible.",
+              "select"
+            );
+          const name = resolvePartReference(packageUri(record.part).baseURI, edge.target);
+          const part = this.#part.package.get_part(name);
+          if (!part)
+            throw new OfficeError("invalid-opc", "Embedded resource is missing.", "select");
+          return part;
+        },
+        insertAsset: async (kind, options, groupId) => {
+          const revision = this.#revision;
+          const geometry = {};
+          for (const key of [
+            "left",
+            "top",
+            "width",
+            "height",
+            "icon_width",
+            "icon_height"
+          ]) {
+            const value = options[key];
+            if (value === void 0 || value === null) continue;
+            if (!(value instanceof Length))
+              throw new ValueError("Expected explicit Length geometry.");
+            geometry[key] = value.emu;
+          }
+          if (geometry.left === void 0 || geometry.top === void 0)
+            throw new ValueError("Expected explicit placement.");
+          const suppliedPoster = kind === "movie" ? options.poster_frame_image : options.icon_file;
+          const posterInput = suppliedPoster instanceof Uint8Array ? new Uint8Array(suppliedPoster) : suppliedPoster;
+          const bytes = await readBinary(options.input, context);
+          let poster;
+          if (kind !== "picture")
+            poster = new Image(await readBinary(posterInput, context));
+          await this.#flushWorkbooks();
+          if (revision !== this.#revision)
+            throw new OfficeError(
+              "stale-selection",
+              "Presentation changed during insertion.",
+              "publish"
+            );
+          const before = owner.read();
+          const ids = new Set(
+            required(required(before.root, "cSld"), "spTree").children.map(
+              (node) => readShape(node).shapeId
+            )
+          );
+          const snapshot = await state.finish(state.main, []);
+          let inserted;
+          if (kind === "picture") {
+            const image = new Image(bytes);
+            inserted = await addImage(
+              snapshot.bytes,
+              { slide: record.position, bytes, contentType: image.content_type, ...geometry },
+              context
+            );
+          } else if (kind === "movie") {
+            inserted = await addMedia(
+              snapshot.bytes,
+              {
+                slide: record.position,
+                bytes,
+                contentType: options.mime_type,
+                kind: "video",
+                poster: { bytes: poster.blob, contentType: poster.content_type },
+                left: geometry.left,
+                top: geometry.top,
+                width: geometry.width,
+                height: geometry.height
+              },
+              context
+            );
+          } else {
+            const { icon_width, icon_height, ...bounds } = geometry;
+            inserted = await addOleObject(
+              snapshot.bytes,
+              {
+                slide: record.position,
+                bytes,
+                progId: options.prog_id,
+                iconBytes: poster.blob,
+                iconContentType: poster.content_type,
+                ...bounds,
+                ...icon_width === void 0 ? {} : { iconWidth: icon_width },
+                ...icon_height === void 0 ? {} : { iconHeight: icon_height }
+              },
+              context
+            );
+          }
+          const updated = await loadShared(inserted, context);
+          if (revision !== this.#revision)
+            throw new OfficeError(
+              "stale-selection",
+              "Presentation changed during insertion.",
+              "publish"
+            );
+          const doc = updated.doc(record.part);
+          const added = required(required(doc.root, "cSld"), "spTree").children.find(
+            (node) => !ids.has(readShape(node).shapeId)
+          );
+          if (!added)
+            throw new OfficeError(
+              "invalid-opc",
+              "Asset insertion produced no shape.",
+              "validate-result"
+            );
+          const final = groupId === void 0 ? doc : reparentInsertedAsset(doc, readShape(added).shapeId, groupId);
+          for (const name of updated.reader.names)
+            state.changes.set(name, updated.reader.get(name));
+          owner.write(final);
+          return readShape(added).shapeId;
+        },
+        read: () => {
+          const bytes = state.changes.get(record.part);
+          if (latestXml && bytes === latestBytes) return latestXml;
+          latestBytes = bytes;
+          latestXml = state.doc(record.part);
+          return latestXml;
+        },
+        write: (xml) => {
+          state.save(record.part, xml);
+          latestBytes = state.changes.get(record.part);
+          latestXml = xml;
+          this.#revision++;
+        },
+        inherited: (idx) => {
+          const result = [];
+          const layout = record.layout ? state.doc(record.layout) : void 0;
+          if (layout) result.push(layout);
+          if (record.master) {
+            const master = state.doc(record.master);
+            const layoutShapes = layout && required(required(layout.root, "cSld"), "spTree").children;
+            const ph = layoutShapes?.map(readShape).find((shape) => shape.placeholder?.idx === idx)?.placeholder;
+            const category = ph?.type === "ctrTitle" ? "title" : ["tbl", "obj", "subTitle", "chart", "pic"].includes(ph?.type ?? "") ? "body" : ph?.type;
+            const candidates = required(required(master.root, "cSld"), "spTree").children.filter(
+              (node) => readShape(node).placeholder?.type === category
+            );
+            if (candidates.length > 1)
+              throw new OfficeError(
+                "ambiguous-selection",
+                "Duplicate inherited master placeholder type.",
+                "select"
+              );
+            if (candidates[0]) {
+              const original = master.subtree(candidates[0]);
+              const nv = original.root.children.find(
+                (node) => node.name.localName.startsWith("nv")
+              );
+              const placeholder = required(required(nv, "nvPr"), "ph");
+              const remapped = original.merge(placeholder, {
+                attributes: [{ namespace: "", localName: "idx", value: String(idx) }]
+              });
+              const tree = required(required(master.root, "cSld"), "spTree");
+              result.push(
+                master.spliceChildren(tree, 0, tree.children.length, [
+                  remapped.markup(remapped.root, true)
+                ])
+              );
+            }
+          }
+          return result;
+        },
+        chart: (shapeId) => {
+          let cachedBytes, cachedXml;
+          const chartPart = () => {
+            const shape = required(required(owner.read().root, "cSld"), "spTree").children.find(
+              (node) => readShape(node).shapeId === shapeId
+            );
+            if (!shape || shape.name.localName !== "graphicFrame")
+              throw new OfficeError("invalid-handle", "Chart frame was replaced.", "select");
+            const pending = [shape];
+            let relationId;
+            while (pending.length) {
+              const node = pending.pop();
+              if (node.name.localName === "chart")
+                relationId = node.attributes.find(
+                  (a) => a.name.localName === "id" && a.name.namespace === state.r
+                )?.value;
+              pending.push(...node.children);
+            }
+            const relations = parseRelationships(
+              state.doc(relPart(record.part)).bytes(),
+              context.relationshipLimits
+            );
+            const relation = relations.find(
+              (edge) => edge.id === relationId && edge.type.endsWith("/chart") && !edge.external
+            );
+            if (!relation)
+              throw new OfficeError(
+                "invalid-handle",
+                "Chart relationship is unavailable.",
+                "select"
+              );
+            return resolvePartReference(packageUri(record.part).baseURI, relation.target);
+          };
+          return new Chart(
+            () => {
+              const part = chartPart(), bytes = state.changes.get(part);
+              if (cachedXml && cachedBytes === bytes) return cachedXml;
+              cachedBytes = bytes;
+              cachedXml = state.doc(part);
+              return cachedXml;
+            },
+            (xml) => {
+              state.save(chartPart(), xml);
+              cachedXml = xml;
+              cachedBytes = state.changes.get(chartPart());
+              this.#revision++;
+            },
+            {
+              part: () => this.#part.package.get_part(chartPart()),
+              replaceData: (data) => {
+                cancelled(context);
+                const part = chartPart();
+                const xml = state.doc(part);
+                const externalData = child(xml.root, "externalData");
+                const id = externalData?.attributes.find(
+                  (attribute) => attribute.name.localName === "id" && attribute.name.namespace === state.r
+                )?.value;
+                const relations = parseRelationships(
+                  state.doc(relPart(part)).bytes(),
+                  context.relationshipLimits
+                );
+                const relation = relations.find(
+                  (edge) => edge.id === id && edge.type.endsWith("/package") && !edge.external
+                );
+                if (!relation)
+                  throw new OfficeError(
+                    "unsupported-edit",
+                    "Data replacement requires one owned embedded workbook.",
+                    "validate-intent"
+                  );
+                const workbookPart = resolvePartReference(
+                  packageUri(part).baseURI,
+                  relation.target
+                );
+                const owners = this.#part.package.parts.flatMap(
+                  (ownerPart) => ownerPart.rels.filter(
+                    (edge) => edge.mode === "internal" && resolvePartReference(packageUri(ownerPart.partname).baseURI, edge.target) === workbookPart
+                  )
+                );
+                if (owners.length !== 1)
+                  throw new OfficeError(
+                    "unsupported-edit",
+                    "Shared chart workbook ownership is ambiguous.",
+                    "validate-intent"
+                  );
+                const pending = this.#pendingWorkbooks.get(workbookPart);
+                let source;
+                if (pending) {
+                  source = workbookMembersReader(pending);
+                } else {
+                  const cached = this.#workbooks.get(workbookPart);
+                  if (cached instanceof Error) throw cached;
+                  if (!cached)
+                    throw new OfficeError(
+                      "unsupported-edit",
+                      "Workbook was not admitted for synchronous replacement.",
+                      "validate-intent"
+                    );
+                  const current = state.changes.get(workbookPart) ?? state.reader.get(workbookPart);
+                  if (current.length !== cached.bytes.length || current.some((byte, index) => byte !== cached.bytes[index]))
+                    throw new OfficeError(
+                      "invalid-handle",
+                      "Workbook changed after admission.",
+                      "select"
+                    );
+                  source = cached.reader;
+                }
+                const result = replaceChartData(
+                  xml,
+                  data,
+                  context,
+                  source,
+                  inspectWorkbook(source, context)
+                );
+                state.save(part, result.doc);
+                this.#pendingWorkbooks.set(workbookPart, result.members);
+                cachedXml = result.doc;
+                cachedBytes = state.changes.get(part);
+                this.#revision++;
+              }
+            }
+          );
+        },
+        addChart: (options) => {
+          cancelled(context);
+          const workbooks2 = /* @__PURE__ */ new Map();
+          const id = insertChartIntoState(
+            state,
+            { ...options, slide: record.position },
+            context,
+            (part, members) => workbooks2.set(part, members)
+          );
+          for (const [part, members] of workbooks2) this.#pendingWorkbooks.set(part, members);
+          this.#revision++;
+          return id;
+        },
+        insertChart: (shapeId, options) => {
+          cancelled(context);
+          const old = owner.read(), tree = required(required(old.root, "cSld"), "spTree"), previous = tree.children.find((node) => readShape(node).shapeId === shapeId);
+          if (!previous || previous.name.localName !== "sp")
+            throw new OfficeError("invalid-handle", "Placeholder was replaced.", "select");
+          const changes = new Map(state.changes), workbooks2 = /* @__PURE__ */ new Map();
+          try {
+            insertChartIntoState(
+              state,
+              { ...options, slide: record.position },
+              context,
+              (part, members) => workbooks2.set(
+                part,
+                members.map((member) => ({
+                  name: member.name,
+                  bytes: new Uint8Array(member.bytes)
+                }))
+              )
+            );
+            const doc = state.doc(record.part), newTree = required(required(doc.root, "cSld"), "spTree"), originalIds = new Set(tree.children.map((node) => readShape(node).shapeId));
+            const added = newTree.children.find(
+              (node) => !originalIds.has(readShape(node).shapeId)
+            );
+            if (!added)
+              throw new OfficeError(
+                "invalid-opc",
+                "Chart insertion produced no frame.",
+                "validate-result"
+              );
+            const replacement = preservePlaceholder(old.subtree(previous), doc.subtree(added));
+            let final = doc.spliceChildren(newTree, newTree.children.indexOf(added), 1, []);
+            const finalTree = required(required(final.root, "cSld"), "spTree");
+            final = final.spliceChildren(finalTree, tree.children.indexOf(previous), 1, [
+              replacement.markup(replacement.root, true)
+            ]);
+            owner.write(final);
+            for (const [part, members] of workbooks2) this.#pendingWorkbooks.set(part, members);
+          } catch (error) {
+            state.changes.clear();
+            for (const [part, bytes] of changes) state.changes.set(part, bytes);
+            throw error;
+          }
+        },
+        insertRich: async (shapeId, kind, options) => {
+          const revision = this.#revision;
+          const old = owner.read();
+          const tree = required(required(old.root, "cSld"), "spTree");
+          const previous = tree.children.find((node) => readShape(node).shapeId === shapeId);
+          if (!previous || previous.name.localName !== "sp")
+            throw new OfficeError("invalid-handle", "Placeholder was replaced.", "select");
+          if (kind === "picture") {
+            const picture = options;
+            const bytes = await readBinary(picture.input, context);
+            const contentType = new Image(bytes).content_type;
+            const { input: ignored, ...geometry } = picture;
+            void ignored;
+            options = { ...geometry, bytes, contentType };
+          }
+          await this.#flushWorkbooks();
+          if (revision !== this.#revision)
+            throw new OfficeError(
+              "stale-selection",
+              "Presentation changed during insertion.",
+              "publish"
+            );
+          const snapshot = await this.#state.finish(this.#state.main, []);
+          const inserted = await addImage(
+            snapshot.bytes,
+            { ...options, slide: record.position },
+            context
+          );
+          const updated = await loadShared(inserted, context);
+          if (revision !== this.#revision)
+            throw new OfficeError(
+              "stale-selection",
+              "Presentation changed during insertion.",
+              "publish"
+            );
+          const doc = updated.doc(record.part);
+          const newTree = required(required(doc.root, "cSld"), "spTree");
+          const originalIds = new Set(tree.children.map((node) => readShape(node).shapeId));
+          const added = newTree.children.find((node) => !originalIds.has(readShape(node).shapeId));
+          if (!added)
+            throw new OfficeError(
+              "invalid-opc",
+              "Rich insertion produced no shape.",
+              "validate-result"
+            );
+          const replacement = preservePlaceholder(old.subtree(previous), doc.subtree(added));
+          let final = doc.spliceChildren(newTree, newTree.children.indexOf(added), 1, []);
+          const finalTree = required(required(final.root, "cSld"), "spTree");
+          final = final.spliceChildren(finalTree, tree.children.indexOf(previous), 1, [
+            replacement.markup(replacement.root, true)
+          ]);
+          for (const name of updated.reader.names)
+            state.changes.set(name, updated.reader.get(name));
+          owner.write(final);
+        }
+      };
+      return new Slide(Number(record.id), owner);
+    };
+    this.#slides = new Slides(state.index.inventory.slides.map(createSlide), (layout) => {
+      const prepared = prepareLayoutInsertion(
+        state,
+        this.#part,
+        layout,
+        context,
+        state.index.fingerprint
+      );
+      const previousIndex = state.index;
+      const previousChanges = new Map(state.changes);
+      try {
+        for (const [name, bytes] of prepared.changes) state.changes.set(name, bytes);
+        state.index = prepared.index;
+        const record = prepared.index.inventory.slides.find(
+          (slide2) => slide2.part === prepared.part
+        );
+        const slide = createSlide(record);
+        this.#revision++;
+        return slide;
+      } catch (error) {
+        state.index = previousIndex;
+        state.changes.clear();
+        for (const [name, bytes] of previousChanges) state.changes.set(name, bytes);
+        throw error;
+      }
+    });
+  }
+  get part() {
+    return this.#part;
+  }
+  get element() {
+    return this.#part.element;
+  }
+  get core_properties() {
+    if (!this.#properties) {
+      if (!this.#propertyPart) {
+        this.#propertyPart = createPropertyPart(this.#state, "core", this.#context);
+        this.#revision++;
+      }
+      const part = this.#propertyPart;
+      this.#properties = new CoreProperties(
+        () => this.#state.doc(part),
+        (doc) => {
+          this.#state.save(part, doc);
+          this.#revision++;
+        }
+      );
+    }
+    return this.#properties;
+  }
+  #dimension(attribute) {
+    const doc = this.#state.doc(this.#state.main);
+    const size = child(doc.root, "sldSz");
+    if (!size) return null;
+    const raw = attr(size, attribute);
+    if (raw === void 0 || !raw.length || [...raw].some((c) => c < "0" || c > "9"))
+      throw new OfficeError("invalid-opc", "Invalid slide dimension.", "parse");
+    return new Length(Number(raw));
+  }
+  #setDimension(attribute, value) {
+    if (!(value instanceof Length)) throw new TypeError("Slide dimensions require a Length.");
+    if (value.emu < 914400 || value.emu > 51206400)
+      throw new ValueError("Slide dimensions must be between 1 and 56 inches.");
+    const doc = this.#state.doc(this.#state.main);
+    const missing = !child(doc.root, "sldSz");
+    const propertyEdge = this.#state.index.inventory.relationships.find(
+      (edge) => edge.owner === this.#state.main && edge.type.endsWith("/presProps") && !edge.external
+    );
+    const updated = applyPresentationCanvasSettings(
+      doc,
+      {
+        ...missing ? { width: 9144e3, height: 6858e3 } : {},
+        [attribute === "cx" ? "width" : "height"]: value.emu
+      },
+      propertyEdge?.targetPart ? this.#state.doc(propertyEdge.targetPart) : void 0
+    );
+    this.#state.save(this.#state.main, updated);
+    this.#revision++;
+  }
+  get slide_width() {
+    return this.#dimension("cx");
+  }
+  set slide_width(value) {
+    this.#setDimension("cx", value);
+  }
+  get slide_height() {
+    return this.#dimension("cy");
+  }
+  set slide_height(value) {
+    this.#setDimension("cy", value);
+  }
+  async #flushWorkbooks() {
+    if (this.#workbookFlush) return this.#workbookFlush;
+    if (!this.#pendingWorkbooks.size) return;
+    const pending = [...this.#pendingWorkbooks];
+    this.#workbookFlush = (async () => {
+      const encoded = await Promise.all(
+        pending.map(async ([part, members]) => ({
+          part,
+          members,
+          bytes: await writePackageArchive(members, this.#context, { compression: "store" })
+        }))
+      );
+      for (const { part, members, bytes } of encoded)
+        if (this.#pendingWorkbooks.get(part) === members) {
+          this.#state.changes.set(part, bytes);
+          this.#pendingWorkbooks.delete(part);
+          this.#workbooks.set(part, {
+            bytes: new Uint8Array(bytes),
+            reader: workbookMembersReader(members)
+          });
+        }
+    })();
+    try {
+      await this.#workbookFlush;
+    } finally {
+      this.#workbookFlush = void 0;
+    }
+  }
+  async save(destination) {
+    if (destination !== void 0 && (!destination || typeof destination !== "object"))
+      throw new TypeError("Expected an explicit publication capability.");
+    if (destination && "publishOutput" in destination) {
+      if (typeof destination.publishOutput !== "function" || typeof destination.outputPath !== "string" || !destination.outputPath.length || destination.inPlace !== void 0 && typeof destination.inPlace !== "boolean" || destination.force !== void 0 && typeof destination.force !== "boolean" || destination.inPlace && (!this.#inputPath || destination.outputPath !== this.#inputPath || destination.force) || !destination.inPlace && this.#inputPath === destination.outputPath)
+        throw new ValueError("Invalid explicit publication destination.");
+      destination = {
+        outputPath: destination.outputPath,
+        inPlace: destination.inPlace ?? false,
+        force: destination.force ?? false,
+        publishOutput: destination.publishOutput.bind(destination)
+      };
+    } else if (destination && (typeof destination.write !== "function" || destination.close !== void 0 && typeof destination.close !== "function")) {
+      throw new TypeError("Expected an explicit byte sink.");
+    }
+    cancelled(this.#context);
+    const revision = this.#revision;
+    await this.#flushWorkbooks();
+    if (revision !== this.#revision)
+      throw new OfficeError(
+        "stale-selection",
+        "Presentation changed during serialization.",
+        "publish"
+      );
+    const { bytes } = await this.#state.finish(this.#state.main, []);
+    cancelled(this.#context);
+    if (revision !== this.#revision)
+      throw new OfficeError(
+        "stale-selection",
+        "Presentation changed during serialization.",
+        "publish"
+      );
+    if (destination === void 0) return new Uint8Array(bytes);
+    if ("publishOutput" in destination) {
+      try {
+        await destination.publishOutput(
+          {
+            ...this.#inputPath === void 0 ? {} : { inputPath: this.#inputPath },
+            outputPath: destination.outputPath,
+            bytes: new Uint8Array(bytes),
+            originalBytes: new Uint8Array(this.#publishedSource),
+            inPlace: destination.inPlace ?? false,
+            force: destination.force ?? false,
+            dryRun: false
+          },
+          this.#context.signal
+        );
+        if (destination.inPlace) this.#publishedSource = new Uint8Array(bytes);
+      } catch (error) {
+        cancelled(this.#context);
+        if (error && typeof error === "object" && "code" in error && error.code === "stale-selection")
+          throw new OfficeError("stale-selection", "Publication source changed.", "publish");
+        throw new OfficeError("io-failure", "Presentation publication failed.", "publish");
+      }
+      cancelled(this.#context);
+      return;
+    }
+    await writeBinary(bytes, destination, this.#context);
+  }
+};
+async function Presentation(input, context = {}) {
+  const admittedContext = contextDefaults(context);
+  const inputPath = input && typeof input === "object" && "path" in input ? input.path : void 0;
+  const bytes = input === void 0 || input === null ? await createPresentation(
+    {
+      width: 9144e3,
+      height: 6858e3,
+      ...admittedContext.author === void 0 ? {} : { author: admittedContext.author },
+      ...admittedContext.timestamp === void 0 ? {} : { timestamp: admittedContext.timestamp }
+    },
+    admittedContext
+  ) : await readBinary(input, admittedContext);
+  const state = await loadShared(bytes, admittedContext);
+  const chartParts = new Set(
+    state.index.inventory.relationships.filter((edge) => edge.type.endsWith("/chart") && !edge.external).map((edge) => edge.targetPart)
+  );
+  const workbooks = /* @__PURE__ */ new Map();
+  let workbookBytes = 0;
+  let workbookMembers = 0;
+  for (const edge of state.index.inventory.relationships) {
+    if (!chartParts.has(edge.owner) || !edge.type.endsWith("/package") || edge.external || !edge.targetPart || workbooks.has(edge.targetPart))
+      continue;
+    const bytes2 = state.reader.get(edge.targetPart);
+    try {
+      const remainingBytes = admittedContext.archiveLimits.maxTotalBytes - workbookBytes;
+      const remainingMembers = admittedContext.archiveLimits.maxMembers - workbookMembers;
+      if (remainingBytes < 1 || remainingMembers < 1)
+        throw new OfficeError(
+          "resource-limit",
+          "Embedded workbook admission budget exceeded.",
+          "admit"
+        );
+      const reader = await readPackage(bytes2, {
+        ...admittedContext,
+        archiveLimits: {
+          ...admittedContext.archiveLimits,
+          maxTotalBytes: remainingBytes,
+          maxEntryBytes: Math.min(admittedContext.archiveLimits.maxEntryBytes, remainingBytes),
+          maxMembers: remainingMembers
+        }
+      });
+      workbookBytes += reader.names.reduce((total, name) => total + reader.byteLength(name), 0);
+      workbookMembers += reader.entryCount;
+      workbooks.set(edge.targetPart, { bytes: bytes2, reader });
+    } catch (error) {
+      if (error instanceof OfficeError && (error.code === "cancelled" || error.code === "resource-limit"))
+        throw error;
+      if (!(error instanceof Error)) throw error;
+      workbooks.set(edge.targetPart, error);
+    }
+  }
+  return new LivePresentation(state, admittedContext, inputPath, workbooks);
+}
+
+export {
+  SlideLayout,
+  SlideLayouts,
+  PP_ACTION_TYPE,
+  PP_ACTION,
+  Hyperlink,
+  ActionSetting,
+  LinkShape,
+  LinkRun,
+  Presentation
+};