@poe-platform/safe-bash 0.1.816 → 0.1.818

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

@@ -0,0 +1,771 @@
+import {
+  openRetainedPresentationIndex,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-3ZGO24WG.js";
+import {
+  writePackageArchive
+} from "./chunk-TG2RVQLP.js";
+import {
+  SelectionError,
+  decodeSelectionToken
+} from "./chunk-3W3HLPCX.js";
+import {
+  readPackage
+} from "./chunk-Q65GWGQR.js";
+import {
+  readBinary
+} from "./chunk-FAU2KL6I.js";
+import {
+  validatePresentation
+} from "./chunk-N6VNHC3B.js";
+import {
+  dialects,
+  openRetainedRelationshipGraph
+} from "./chunk-6KJDTKE4.js";
+import {
+  parseXmlPart
+} from "./chunk-7PYDVQPB.js";
+import {
+  readRelationshipGraph
+} from "./chunk-4YFTJS5U.js";
+import {
+  parseContentTypes
+} from "./chunk-XFIDOCYH.js";
+import {
+  OfficeError,
+  RetainedValues,
+  characters,
+  equal,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources
+} from "./chunk-KM2SMMXZ.js";
+
+// packages/safe-bash-presentation-engine/src/retained-memberships.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+var sectionNamespace = "http://schemas.microsoft.com/office/powerpoint/2010/main";
+var sectionExtension = "{521415D9-36F7-43E2-AB2F-B90AF26B5E84}";
+function fail(code, message) {
+  throw new OfficeError(code, message, code === "invalid-value" ? "usage" : "validate-intent");
+}
+async function* upper(source) {
+  let buffer = "";
+  for await (const character of characters(source)) {
+    buffer += character.toUpperCase();
+    if (buffer.length >= 2048) {
+      yield* literal(buffer);
+      buffer = "";
+    }
+  }
+  if (buffer) yield* literal(buffer);
+}
+async function* children(document, node) {
+  for await (const child of document.children(node)) if (child.kind === "element") yield child;
+}
+async function is(document, node, name, namespace) {
+  return await equal(document.raw(node.localName), literal(name)) && await equal(document.namespace(node), literal(namespace));
+}
+async function attr(document, node, name, namespace = "") {
+  for await (const value of document.attributes(node)) if (await is(document, value, name, namespace)) return value;
+  return void 0;
+}
+async function only(document, node, name, namespace) {
+  let found;
+  for await (const child of children(document, node)) if (await is(document, child, name, namespace)) {
+    if (found) fail("unsupported-edit", "Ambiguous membership structure.");
+    found = child;
+  }
+  return found;
+}
+async function locate(document, kind, p) {
+  if (kind === "shows") return only(document, document.root, "custShowLst", p);
+  const extensions = await only(document, document.root, "extLst", p);
+  if (!extensions) return void 0;
+  let extension;
+  for await (const node of children(document, extensions)) {
+    const uri = await attr(document, node, "uri");
+    if (uri && await equal(upper(document.text(uri)), literal(sectionExtension))) {
+      if (extension) fail("unsupported-edit", "Multiple section extensions.");
+      extension = node;
+    }
+  }
+  for await (const node of children(document, extensions)) if (!extension || document.reference(node) !== document.reference(extension)) {
+    for await (const child of children(document, node)) if (await equal(document.raw(child.localName), literal("sectionLst"))) fail("unsupported-edit", "Unsupported section extension identity.");
+  }
+  if (!extension) return void 0;
+  let count = 0;
+  for await (const ignored of children(document, extension)) count++;
+  if (!await is(document, extension, "ext", p) || count !== 1) fail("unsupported-edit", "Unsupported section extension structure.");
+  const list = await only(document, extension, "sectionLst", sectionNamespace);
+  if (!list) fail("unsupported-edit", "Unsupported section extension namespace.");
+  return list;
+}
+async function openRetainedMemberships(archive, kind, settings) {
+  if (!["sections", "shows"].includes(kind)) fail("invalid-value", "Unknown membership resource.");
+  const context = { ...resolveOfficeResources(settings), workingStorage: { ...settings.workingStorage } }, working = context.workingStorage, signal = context.signal ?? new AbortController().signal;
+  const graph = await openRetainedRelationshipGraph(archive, context), pages = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, (working.cacheBytes ?? 1024 * 1024) / 16384);
+  let document, closed = false, closing, first = 0, last = 0;
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([graph.close(), document?.close(), pages.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Memberships are closed.", "index");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "index");
+  };
+  const values = new RetainedValues(pages, check, signal);
+  async function row(pointer, count = 7) {
+    check();
+    const bytes = await pages.read(pointer, count * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length: count }, (_, n) => view.getFloat64(n * 8, true));
+  }
+  async function write(pointer, data) {
+    check();
+    const bytes = new Uint8Array(data.length * 8), view = new DataView(bytes.buffer);
+    data.forEach((value, n) => view.setFloat64(n * 8, value, true));
+    await pages.write(pointer, bytes);
+  }
+  const range = (data, n) => ({ start: data[n], length: data[n + 1] });
+  async function* slides(pointer) {
+    check();
+    while (pointer) {
+      const data = await row(pointer, 2);
+      pointer = data[0];
+      yield data[1];
+    }
+    check();
+  }
+  try {
+    let main;
+    for await (const edge of graph.outgoing("/")) {
+      let match = false;
+      for (const dialect of dialects) if (await equal(edge.type(), literal(`${dialect.r}/officeDocument`))) match = true;
+      if (match) {
+        if (edge.targetPart) {
+          const decoder = new TextDecoder();
+          main = "";
+          for await (const bytes of edge.targetPart()) main += decoder.decode(bytes, { stream: true });
+          main += decoder.decode();
+        }
+        break;
+      }
+    }
+    if (!main) fail("invalid-opc", "Presentation relationship is missing.");
+    document = await openRetainedXmlDocument(archive.read(main), context);
+    const doc = document;
+    let d;
+    for (const dialect of dialects) if (await equal(doc.namespace(doc.root), literal(dialect.p))) d = dialect;
+    if (!d) fail("unsupported-edit", "Unsupported presentation namespace.");
+    const slideList = await only(doc, doc.root, "sldIdLst", d.p);
+    let slidePosition = 0;
+    if (slideList) {
+      for await (const slide of children(doc, slideList)) if (await is(doc, slide, "sldId", d.p)) {
+        slidePosition++;
+        for (const [scope, namespace2] of [["id", ""], ["rel", d.r]]) {
+          const id = await attr(doc, slide, "id", namespace2);
+          if (id) {
+            const key = await values.store(doc.text(id)), pointer = pages.allocate(8);
+            await write(pointer, [slidePosition]);
+            await values.insert(scope, key, { start: pointer, length: 8 });
+          }
+        }
+      }
+    }
+    const list = await locate(doc, kind, d.p), namespace = kind === "sections" ? sectionNamespace : d.p, itemName = kind === "sections" ? "section" : "custShow";
+    if (list) {
+      for await (const node of children(doc, list)) if (!await is(doc, node, itemName, namespace)) fail("unsupported-edit", "Unsupported membership list content.");
+    }
+    let position = 0;
+    if (list) for await (const node of children(doc, list)) {
+      const id = await attr(doc, node, "id"), name = await attr(doc, node, "name");
+      if (!id || !name || await equal(doc.text(id), literal(""))) fail("invalid-opc", "Membership identities and names must be present.");
+      let identity = "";
+      if (kind === "shows") {
+        let number = 0;
+        for await (const character of characters(doc.text(id))) {
+          if (character < "0" || character > "9") fail("invalid-opc", "Invalid custom show identity.");
+          number = number * 10 + (character.charCodeAt(0) - 48);
+          if (number > 4294967295) fail("invalid-opc", "Invalid custom show identity.");
+        }
+        identity = String(number);
+      } else {
+        for await (const character of characters(doc.text(id))) {
+          identity += character;
+          if (identity.length > 38) fail("invalid-opc", "Invalid section identity.");
+        }
+        const segments = identity.slice(1, -1).split("-");
+        if (!identity.startsWith("{") || !identity.endsWith("}") || segments.length !== 5 || segments.some((segment, n) => segment.length !== [8, 4, 4, 4, 12][n] || [...segment].some((character) => !"0123456789ABCDEF".includes(character.toUpperCase())))) fail("invalid-opc", "Invalid section identity.");
+        identity = identity.toUpperCase();
+      }
+      const identityRange = await values.store(literal(identity));
+      if (!await values.insert("seen", identityRange, identityRange)) fail("invalid-opc", "Membership identities must be unique.");
+      if (kind === "sections") {
+        for await (const value of doc.attributes(node)) if (!await is(doc, value, "id", "") && !await is(doc, value, "name", "")) fail("unsupported-edit", "Unsupported section extension content.");
+        for await (const value of children(doc, node)) if (!await is(doc, value, "sldIdLst", sectionNamespace)) fail("unsupported-edit", "Unsupported section extension content.");
+      }
+      const members = await only(doc, node, kind === "sections" ? "sldIdLst" : "sldLst", namespace);
+      if (!members) fail("unsupported-edit", "Missing membership slide list.");
+      if (kind === "sections") for await (const ignored of doc.attributes(members)) fail("unsupported-edit", "Unsupported section list attributes.");
+      let head = 0, tail = 0;
+      for await (const member of children(doc, members)) {
+        if (!await is(doc, member, kind === "sections" ? "sldId" : "sld", namespace)) fail("unsupported-edit", "Unsupported membership slide entry.");
+        if (kind === "sections") {
+          for await (const ignored of children(doc, member)) fail("unsupported-edit", "Unsupported section member extension.");
+          for await (const value of doc.attributes(member)) if (!await is(doc, value, "id", "")) fail("unsupported-edit", "Unsupported section member extension.");
+        }
+        const reference = await attr(doc, member, "id", kind === "sections" ? "" : d.r), found = await values.find(kind === "sections" ? "id" : "rel", () => reference ? doc.text(reference) : literal(""));
+        if (!found) fail("invalid-opc", "Membership references an absent slide.");
+        const memberPosition = (await row(found.start, 1))[0], pointer2 = pages.allocate(16);
+        await write(pointer2, [0, memberPosition]);
+        if (tail) await write(tail, [pointer2]);
+        else head = pointer2;
+        tail = pointer2;
+      }
+      if (kind === "sections") {
+        let previous = 0;
+        for await (const memberPosition of slides(head)) {
+          const key = await values.store(literal(String(memberPosition)));
+          if (!await values.insert("section-slides", key, key) || previous && memberPosition !== previous + 1) fail("unsupported-edit", "Existing sections must be contiguous and nonoverlapping.");
+          previous = memberPosition;
+        }
+      }
+      const idValue = await values.store(doc.text(id)), nameValue = await values.store(doc.text(name)), pointer = pages.allocate(56);
+      await write(pointer, [0, idValue.start, idValue.length, nameValue.start, nameValue.length, head, ++position]);
+      if (last) await write(last, [pointer]);
+      else first = pointer;
+      last = pointer;
+    }
+    await doc.close();
+    await graph.close();
+    return Object.freeze({ owner: main, close, async *records() {
+      check();
+      for (let pointer = first; pointer; ) {
+        const data = await row(pointer);
+        pointer = data[0];
+        yield { id: () => values.read(range(data, 1)), name: () => values.read(range(data, 3)), position: data[6], slides: () => slides(data[5]) };
+      }
+      check();
+    } });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error instanceof OfficeError ? error : new OfficeError(signal.aborted ? "cancelled" : "io-failure", "Membership storage operation failed.", "index");
+  }
+}
+async function stageRetainedMemberships(archive, fingerprint, kind, selection, settings, output) {
+  const query = { ...selection }, format = { ...output };
+  if (!["sections", "shows"].includes(kind) || ![`${kind}.list`, `${kind}.get`].includes(format.operation)) fail("invalid-value", "Unknown membership operation.");
+  const index = await openRetainedPresentationIndex(archive, fingerprint, settings);
+  let view, staged;
+  try {
+    let owner = "";
+    for await (const record of index.records.records("part")) if (record.scope === "presentation") {
+      owner = record.part;
+      break;
+    }
+    view = await openRetainedMemberships(archive, kind, settings);
+    const token = query.token ? decodeSelectionToken(query.token) : void 0;
+    if (token) {
+      if (token.fingerprint !== fingerprint) throw new SelectionError("stale-selection");
+      if (token.scope !== "presentation" || token.owner !== owner || !token.objectId?.startsWith(`${kind}:`)) throw new SelectionError("invalid-selection");
+    }
+    async function* selected() {
+      for await (const record of view.records()) {
+        if (token) {
+          if (!await equal(record.id(), literal(token.objectId.slice(kind.length + 1)))) continue;
+        } else if (query.slide !== void 0) {
+          let present = false;
+          for await (const position of record.slides()) if (position === query.slide) {
+            present = true;
+            break;
+          }
+          if (!present) continue;
+        }
+        yield record;
+      }
+    }
+    if (format.operation.endsWith(".get")) {
+      let count = 0;
+      for await (const ignored of selected()) count++;
+      if (!count) throw new SelectionError("missing-selection");
+      if (count > 1) throw new SelectionError("ambiguous-selection");
+    }
+    const location = (record) => ({ fingerprint, scope: "presentation", owner, objectId: async function* () {
+      yield* literal(`${kind}:`);
+      yield* record.id();
+    }, coordinateSystem: "identity" });
+    async function* records() {
+      for await (const record of selected()) {
+        const where = location(record);
+        yield { id: record.id, name: record.name, position: record.position, slides: record.slides(), location: where, token: () => streamJson(where) };
+      }
+    }
+    async function* locations() {
+      for await (const record of selected()) yield location(record);
+    }
+    async function* render() {
+      if (format.json) {
+        yield* streamJson({ version: 1, operation: format.operation, ok: true, data: { fingerprint, records: records() }, warnings: [], errors: [], affected: 0, locations: locations() });
+        yield* literal("\n");
+      } else {
+        let first = true;
+        for await (const record of selected()) {
+          if (!first) yield* literal("\n");
+          first = false;
+          yield* literal(`${record.position} `);
+          yield* streamJson(record.name);
+          yield* literal(" [");
+          let member = false;
+          for await (const position of record.slides()) {
+            if (member) yield* literal(", ");
+            member = true;
+            yield* literal(String(position));
+          }
+          yield* literal("]");
+        }
+        yield* literal("\n");
+      }
+    }
+    staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
+    await view.close();
+    await index.close();
+    return staged;
+  } catch (error) {
+    await Promise.allSettled([view?.close(), index.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/memberships.ts
+var sectionNamespace2 = "http://schemas.microsoft.com/office/powerpoint/2010/main";
+var sectionExtension2 = "{521415D9-36F7-43E2-AB2F-B90AF26B5E84}";
+var dialects2 = [
+  {
+    p: "http://schemas.openxmlformats.org/presentationml/2006/main",
+    r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+  },
+  {
+    p: "http://purl.oclc.org/ooxml/presentationml/main",
+    r: "http://purl.oclc.org/ooxml/officeDocument/relationships"
+  }
+];
+function fail2(code, message) {
+  throw new OfficeError(code, message, code === "invalid-value" ? "usage" : "validate-intent");
+}
+function attr2(node, name, namespace = "") {
+  return node.attributes.find((a) => a.name.namespace === namespace && a.name.localName === name)?.value;
+}
+function children2(node, name, namespace) {
+  return node.children.filter(
+    (child) => child.name.namespace === namespace && child.name.localName === name
+  );
+}
+function only2(node, name, namespace) {
+  const found = children2(node, name, namespace);
+  if (found.length > 1) fail2("unsupported-edit", "Ambiguous membership structure.");
+  return found[0];
+}
+function locate2(xml, kind) {
+  const p = xml.root.name.namespace;
+  if (kind === "shows") return only2(xml.root, "custShowLst", p);
+  const extensions = only2(xml.root, "extLst", p);
+  const matching = extensions?.children.filter((node) => attr2(node, "uri")?.toUpperCase() === sectionExtension2) ?? [];
+  if (matching.length > 1) fail2("unsupported-edit", "Multiple section extensions.");
+  const extension = matching[0];
+  if (extensions?.children.some(
+    (node) => node !== extension && node.children.some((child) => child.name.localName === "sectionLst")
+  ))
+    fail2("unsupported-edit", "Unsupported section extension identity.");
+  if (!extension) return void 0;
+  if (extension.name.namespace !== p || extension.name.localName !== "ext" || extension.children.length !== 1)
+    fail2("unsupported-edit", "Unsupported section extension structure.");
+  const list = only2(extension, "sectionLst", sectionNamespace2);
+  if (!list) fail2("unsupported-edit", "Unsupported section extension namespace.");
+  return list;
+}
+function inspect(xml, kind) {
+  const d = dialects2.find((value) => value.p === xml.root.name.namespace);
+  if (!d) fail2("unsupported-edit", "Unsupported presentation namespace.");
+  const slideList = only2(xml.root, "sldIdLst", d.p);
+  const slides = slideList ? children2(slideList, "sldId", d.p) : [];
+  const ids = slides.map((node) => attr2(node, "id"));
+  const rels = slides.map((node) => attr2(node, "id", d.r));
+  const list = locate2(xml, kind);
+  const ns = kind === "sections" ? sectionNamespace2 : d.p;
+  const itemName = kind === "sections" ? "section" : "custShow";
+  if (list?.children.some((node) => node.name.namespace !== ns || node.name.localName !== itemName))
+    fail2("unsupported-edit", "Unsupported membership list content.");
+  const seen = /* @__PURE__ */ new Set();
+  const sectionSlides = /* @__PURE__ */ new Set();
+  const records = (list?.children ?? []).map((node, i) => {
+    const id = attr2(node, "id"), name = attr2(node, "name");
+    if (id === void 0 || !id || name === void 0)
+      fail2("invalid-opc", "Membership identities and names must be present.");
+    let identity = id.toUpperCase();
+    if (kind === "shows") {
+      if (![...id].every((character) => character >= "0" && character <= "9") || !Number.isSafeInteger(Number(id)) || Number(id) > 4294967295)
+        fail2("invalid-opc", "Invalid custom show identity.");
+      identity = String(Number(id));
+    } else {
+      const segments = id.slice(1, -1).split("-");
+      if (!id.startsWith("{") || !id.endsWith("}") || segments.length !== 5 || segments.some(
+        (segment, i2) => segment.length !== [8, 4, 4, 4, 12][i2] || [...segment].some((character) => !"0123456789ABCDEF".includes(character.toUpperCase()))
+      ))
+        fail2("invalid-opc", "Invalid section identity.");
+    }
+    if (seen.has(identity)) fail2("invalid-opc", "Membership identities must be unique.");
+    seen.add(identity);
+    if (kind === "sections" && (node.attributes.some(
+      (a) => a.name.namespace !== "http://www.w3.org/2000/xmlns/" && (a.name.namespace !== "" || !["id", "name"].includes(a.name.localName))
+    ) || node.children.some(
+      (child) => child.name.namespace !== sectionNamespace2 || child.name.localName !== "sldIdLst"
+    )))
+      fail2("unsupported-edit", "Unsupported section extension content.");
+    const members = only2(node, kind === "sections" ? "sldIdLst" : "sldLst", ns);
+    if (!members) fail2("unsupported-edit", "Missing membership slide list.");
+    if (kind === "sections" && members.attributes.some((a) => a.name.namespace !== "http://www.w3.org/2000/xmlns/"))
+      fail2("unsupported-edit", "Unsupported section list attributes.");
+    const positions = members.children.map((member) => {
+      if (member.name.namespace !== ns || member.name.localName !== (kind === "sections" ? "sldId" : "sld"))
+        fail2("unsupported-edit", "Unsupported membership slide entry.");
+      if (kind === "sections" && (member.children.length || member.attributes.some(
+        (a) => a.name.namespace !== "http://www.w3.org/2000/xmlns/" && (a.name.namespace !== "" || a.name.localName !== "id")
+      )))
+        fail2("unsupported-edit", "Unsupported section member extension.");
+      const position = kind === "sections" ? ids.indexOf(attr2(member, "id") ?? "") : rels.indexOf(attr2(member, "id", d.r) ?? "");
+      if (position < 0) fail2("invalid-opc", "Membership references an absent slide.");
+      return position + 1;
+    });
+    if (kind === "sections")
+      for (const [j, position] of positions.entries()) {
+        if (sectionSlides.has(position) || j > 0 && position !== positions[j - 1] + 1)
+          fail2("unsupported-edit", "Existing sections must be contiguous and nonoverlapping.");
+        sectionSlides.add(position);
+      }
+    return { id, name, position: i + 1, slides: positions };
+  });
+  return { d, ids, rels, list, ns, records };
+}
+async function load(input, context) {
+  if (!context?.xmlLimits || !context.relationshipLimits)
+    fail2("invalid-value", "Explicit XML and relationship limits are required.");
+  const source = await readBinary(input, context);
+  const reader = await readPackage(source, context);
+  const graph = readRelationshipGraph(reader, context.relationshipLimits);
+  const main = graph.outgoing("/").find((edge) => dialects2.some((d) => edge.type === `${d.r}/officeDocument`))?.targetPart;
+  if (!main) fail2("invalid-opc", "Presentation relationship is missing.");
+  return { source, reader, graph, main, xml: parseXmlPart(reader.get(main), context.xmlLimits) };
+}
+async function readMemberships(input, kind, context) {
+  if (!["sections", "shows"].includes(kind)) fail2("invalid-value", "Unknown membership resource.");
+  return inspect((await load(input, context)).xml, kind).records;
+}
+function fields(value, allowed) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Object.keys(value).some((key) => !allowed.includes(key)))
+    fail2("invalid-value", "Invalid membership options.");
+}
+async function mutateMemberships(input, kind, options, context) {
+  fields(options, ["action", "selection", "name", "slides", "position", "allowEmpty"]);
+  if (!["sections", "shows"].includes(kind) || !["add", "set", "remove"].includes(options.action))
+    fail2("invalid-value", "Unknown membership operation.");
+  if (options.name !== void 0 && typeof options.name !== "string")
+    fail2("invalid-value", "Membership name must be text.");
+  if (options.allowEmpty !== void 0 && typeof options.allowEmpty !== "boolean")
+    fail2("invalid-value", "allowEmpty must be boolean.");
+  if (options.position !== void 0 && (!Number.isSafeInteger(options.position) || options.position < 1))
+    fail2("invalid-value", "Invalid membership position.");
+  if (options.action === "add" && (options.name === void 0 || options.slides === void 0 || options.selection !== void 0))
+    fail2("invalid-value", "Creation requires a name and slide membership.");
+  if (options.action === "set" && options.name === void 0 && options.slides === void 0 && options.position === void 0)
+    fail2("invalid-value", "At least one membership update is required.");
+  if (options.action === "remove" && [options.name, options.slides, options.position].some((value) => value !== void 0))
+    fail2("invalid-value", "Removal cannot include updates.");
+  if (options.selection !== void 0) {
+    fields(options.selection, ["id", "ids", "name", "position", "all"]);
+    const q2 = options.selection;
+    if (q2.ids !== void 0 && (!Array.isArray(q2.ids) || new Set(q2.ids).size !== q2.ids.length || q2.ids.some((id) => typeof id !== "string" || !id)) || q2.id !== void 0 && (typeof q2.id !== "string" || !q2.id) || q2.name !== void 0 && (typeof q2.name !== "string" || !q2.name) || q2.position !== void 0 && (!Number.isSafeInteger(q2.position) || q2.position < 1) || q2.all !== void 0 && typeof q2.all !== "boolean" || !q2.all && q2.ids === void 0 && q2.id === void 0 && q2.name === void 0 && q2.position === void 0)
+      throw new SelectionError("invalid-selection");
+  } else if (options.action !== "add") throw new SelectionError("invalid-selection");
+  const loaded = await load(input, context);
+  let xml = loaded.xml;
+  const { source, reader, graph, main } = loaded;
+  const limits = {
+    ...context.xmlLimits,
+    ...context.relationshipLimits,
+    maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes),
+    maxEntries: context.archiveLimits.maxMembers
+  };
+  const types = parseContentTypes(reader.get("/[Content_Types].xml"), limits);
+  for (const name of reader.names) {
+    if (name === "/[Content_Types].xml") continue;
+    const type = types.get(name).toLowerCase();
+    if (type.includes("digital-signature") || type.includes("macroenabled") || type.includes("vbaproject") || name.toLowerCase().startsWith("/_xmlsignatures/"))
+      fail2("unsupported-edit", "Signed and macro-enabled presentations cannot be changed.");
+  }
+  for (const owner of ["/", ...graph.parts])
+    if (graph.outgoing(owner).some(
+      (edge) => edge.type.includes("/digital-signature/") || edge.type.endsWith("/vbaProject")
+    ))
+      fail2("unsupported-edit", "Signed and macro-enabled presentations cannot be changed.");
+  if (!validatePresentation(reader, limits).valid)
+    fail2("invalid-opc", "Membership editing requires a valid presentation graph.");
+  const pending = [xml.root];
+  while (pending.length) {
+    const node = pending.pop();
+    if (node.name.localName === "modifyVerifier" || node.name.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006")
+      fail2(
+        "unsupported-edit",
+        "Protected or conditional presentation structures cannot be changed."
+      );
+    pending.push(...node.children);
+  }
+  if (options.name !== void 0)
+    xml.merge(xml.root, {
+      attributes: [{ namespace: "", localName: "name", value: options.name }]
+    });
+  const state = inspect(xml, kind);
+  const q = options.selection;
+  const selected = options.action === "add" ? [] : state.records.filter(
+    (record) => (!q?.id || record.id === q.id) && (q?.ids === void 0 || q.ids.includes(record.id)) && (q?.name === void 0 || record.name === q.name) && (q?.position === void 0 || record.position === q.position)
+  );
+  if (selected.length > 1 && !q?.all) throw new SelectionError("ambiguous-selection");
+  if (options.slides !== void 0) {
+    if (!Array.isArray(options.slides) || !options.slides.length || new Set(options.slides).size !== options.slides.length || options.slides.some(
+      (position) => !Number.isSafeInteger(position) || position < 1 || position > state.ids.length
+    ))
+      fail2("invalid-value", "Membership requires unique existing slide positions.");
+    if (kind === "sections" && options.slides.some((position, i) => i > 0 && position !== options.slides[i - 1] + 1))
+      fail2("invalid-value", "Section members must be ordered and contiguous.");
+  }
+  if (kind === "sections") {
+    const used = /* @__PURE__ */ new Set();
+    const records = state.records.filter(
+      (record) => options.action !== "remove" || !selected.includes(record)
+    );
+    const memberships = records.map(
+      (record) => selected.includes(record) && options.slides !== void 0 ? options.slides : record.slides
+    );
+    if (options.action === "add") memberships.push(options.slides);
+    for (const members of memberships)
+      for (const [i, slide] of members.entries()) {
+        if (used.has(slide) || i > 0 && slide !== members[i - 1] + 1)
+          fail2("invalid-value", "Section members must be contiguous and nonoverlapping.");
+        used.add(slide);
+      }
+    for (const node of state.list?.children ?? []) {
+      if (node.children.some(
+        (child) => child.name.namespace !== sectionNamespace2 || child.name.localName !== "sldIdLst"
+      ))
+        fail2("unsupported-edit", "Unsupported section extension content.");
+    }
+  }
+  const finalCount = state.records.length + (options.action === "add" ? 1 : 0);
+  if (options.position !== void 0 && options.position > finalCount - selected.length + (options.action === "add" ? 0 : 1))
+    fail2("invalid-value", "Membership position is outside the list.");
+  if (options.action !== "add" && !selected.length) {
+    if (options.allowEmpty) return source;
+    throw new SelectionError("missing-selection");
+  }
+  if (kind === "shows" && options.action === "remove") {
+    const removedIds = new Set(selected.map((record) => Number(record.id)));
+    const dangling = () => {
+      throw new OfficeError(
+        "dangling-reference",
+        "Custom show removal would leave an active or unsupported show reference.",
+        "validate-intent"
+      );
+    };
+    const checkId = (id) => {
+      if (id === void 0 || !id || [...id].some((character) => character < "0" || character > "9") || !Number.isSafeInteger(Number(id)) || Number(id) > 4294967295 || removedIds.has(Number(id)))
+        dangling();
+    };
+    for (const name of reader.names) {
+      context.signal?.throwIfAborted();
+      if (name === "/[Content_Types].xml") continue;
+      const type = types.get(name).toLowerCase();
+      if (!type.endsWith("+xml") && !type.endsWith("/xml")) continue;
+      const doc = name === main ? xml : parseXmlPart(reader.get(name), context.xmlLimits);
+      const nodes = [{ node: doc.root }];
+      while (nodes.length) {
+        const { node, parent } = nodes.pop();
+        if (node.name.namespace === state.d.p && node.name.localName === "custShow" && parent?.name.localName !== "custShowLst")
+          checkId(attr2(node, "id"));
+        for (const attribute of node.attributes) {
+          if (attribute.name.localName !== "action" || !attribute.value.toLowerCase().startsWith("ppaction://customshow"))
+            continue;
+          let action;
+          try {
+            action = new URL(attribute.value);
+          } catch {
+            dangling();
+          }
+          if (action.hostname !== "customshow" || action.pathname || action.hash || action.username || action.password || action.port)
+            dangling();
+          const ids = action.searchParams.getAll("id");
+          if (ids.length !== 1) dangling();
+          action.searchParams.forEach((_value, key) => {
+            if (!["id", "return"].includes(key)) dangling();
+          });
+          checkId(ids[0]);
+        }
+        nodes.push(...node.children.map((child) => ({ node: child, parent: node })));
+      }
+    }
+  }
+  if (options.action === "add") {
+    if (!locate2(xml, kind)) {
+      if (kind === "shows") {
+        const preceding = [
+          "sldMasterIdLst",
+          "notesMasterIdLst",
+          "handoutMasterIdLst",
+          "sldIdLst",
+          "sldSz",
+          "notesSz",
+          "smartTags",
+          "embeddedFontLst"
+        ];
+        const following = xml.root.children.findIndex(
+          (node) => !preceding.includes(node.name.localName)
+        );
+        xml = xml.spliceChildren(
+          xml.root,
+          following < 0 ? xml.root.children.length : following,
+          0,
+          [`<p:custShowLst xmlns:p="${state.d.p}"/>`]
+        );
+      } else {
+        let ext = only2(xml.root, "extLst", state.d.p);
+        if (!ext) {
+          xml = xml.spliceChildren(xml.root, xml.root.children.length, 0, [
+            `<p:extLst xmlns:p="${state.d.p}"/>`
+          ]);
+          ext = only2(xml.root, "extLst", state.d.p);
+        }
+        xml = xml.spliceChildren(ext, ext.children.length, 0, [
+          `<p:ext xmlns:p="${state.d.p}" uri="${sectionExtension2}"><s:sectionLst xmlns:s="${sectionNamespace2}"/></p:ext>`
+        ]);
+      }
+    }
+    let number = kind === "shows" ? 0 : 1;
+    const idFor = (n) => kind === "shows" ? String(n) : `{00000000-0000-0000-0000-${n.toString(16).toUpperCase().padStart(12, "0")}}`;
+    const used = new Set(
+      state.records.map(
+        (record2) => kind === "shows" ? String(Number(record2.id)) : record2.id.toUpperCase()
+      )
+    );
+    while (used.has(idFor(number))) number++;
+    if (number > 4294967295)
+      throw new OfficeError(
+        "resource-limit",
+        "Membership identities exhausted.",
+        "validate-intent"
+      );
+    const list = locate2(xml, kind);
+    const element = kind === "shows" ? `<p:custShow xmlns:p="${state.d.p}" name="" id="${idFor(number)}"><p:sldLst/></p:custShow>` : `<s:section xmlns:s="${sectionNamespace2}" name="" id="${idFor(number)}"><s:sldIdLst/></s:section>`;
+    xml = xml.spliceChildren(
+      list,
+      options.position === void 0 ? list.children.length : options.position - 1,
+      0,
+      [element]
+    );
+    const record = { id: idFor(number), name: "", position: 0, slides: [] };
+    selected.push(record);
+  }
+  for (const record of selected) {
+    let list = locate2(xml, kind);
+    const index = list.children.findIndex((node2) => attr2(node2, "id") === record.id);
+    if (options.action === "remove") {
+      xml = xml.spliceChildren(list, index, 1, []);
+      continue;
+    }
+    let node = list.children[index];
+    if (options.name !== void 0) {
+      xml = xml.merge(node, {
+        attributes: [{ namespace: "", localName: "name", value: options.name }]
+      });
+      list = locate2(xml, kind);
+      node = list.children[index];
+    }
+    if (options.slides !== void 0) {
+      const members = only2(node, kind === "shows" ? "sldLst" : "sldIdLst", state.ns);
+      if (members.attributes.some((a) => a.name.namespace !== "http://www.w3.org/2000/xmlns/") || members.children.some(
+        (child) => child.children.length || child.attributes.some(
+          (a) => a.name.namespace !== "http://www.w3.org/2000/xmlns/" && !(a.name.localName === "id" && a.name.namespace === (kind === "shows" ? state.d.r : ""))
+        )
+      ))
+        fail2("unsupported-edit", "Unsupported membership entry extension.");
+      xml = xml.spliceChildren(
+        members,
+        0,
+        members.children.length,
+        options.slides.map((position) => {
+          const member = parseXmlPart(
+            new TextEncoder().encode(
+              kind === "shows" ? `<p:sld xmlns:p="${state.d.p}" xmlns:r="${state.d.r}" r:id=""/>` : `<s:sldId xmlns:s="${sectionNamespace2}" id=""/>`
+            ),
+            context.xmlLimits
+          );
+          const edited = member.merge(member.root, {
+            attributes: [
+              {
+                namespace: kind === "shows" ? state.d.r : "",
+                localName: "id",
+                value: (kind === "shows" ? state.rels : state.ids)[position - 1]
+              }
+            ]
+          });
+          return edited.markup(edited.root);
+        })
+      );
+    }
+  }
+  if (options.action === "set" && options.position !== void 0) {
+    const list = locate2(xml, kind);
+    const ids = new Set(selected.map((record) => record.id));
+    const moving = list.children.filter((node) => ids.has(attr2(node, "id")));
+    const ordered = list.children.filter((node) => !ids.has(attr2(node, "id")));
+    ordered.splice(options.position - 1, 0, ...moving);
+    xml = xml.reorderChildren(list, ordered);
+  }
+  const remaining = locate2(xml, kind);
+  if (remaining && !remaining.children.length) {
+    if (kind === "shows")
+      xml = xml.spliceChildren(xml.root, xml.root.children.indexOf(remaining), 1, []);
+    else {
+      const ext = only2(xml.root, "extLst", state.d.p);
+      const index = ext.children.findIndex((node) => node.children.includes(remaining));
+      xml = xml.spliceChildren(ext, index, 1, []);
+      const remainingExtensions = only2(xml.root, "extLst", state.d.p);
+      if (!remainingExtensions.children.length && remainingExtensions.attributes.every(
+        (a) => a.name.namespace === "http://www.w3.org/2000/xmlns/"
+      ))
+        xml = xml.spliceChildren(xml.root, xml.root.children.indexOf(remainingExtensions), 1, []);
+    }
+  }
+  const original = reader.get(main), changed = xml.bytes();
+  if (original.length === changed.length && original.every((value, index) => value === changed[index]))
+    return source;
+  const output = await writePackageArchive(
+    reader.names.map((name) => ({
+      name: name.slice(1),
+      bytes: name === main ? xml.bytes() : reader.get(name)
+    })),
+    context,
+    { compression: "auto", source }
+  );
+  if (!validatePresentation(await readPackage(output, context), limits).valid)
+    fail2("invalid-opc", "Changed memberships fail graph validation.");
+  return output;
+}
+
+export {
+  openRetainedMemberships,
+  stageRetainedMemberships,
+  readMemberships,
+  mutateMemberships
+};