@poe-platform/safe-bash 0.1.815 → 0.1.816

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

@@ -0,0 +1,704 @@
+import {
+  openRetainedText
+} from "./chunk-VVWHFNHD.js";
+import {
+  openPackageArchive
+} from "./chunk-FJLSYX5P.js";
+import {
+  openRetainedProperties,
+  readProperties,
+  readRetainedPropertyValue
+} from "./chunk-AF2IO57Q.js";
+import {
+  openRetainedPresentationIndex,
+  rawJson,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-FB2WPI3M.js";
+import {
+  RetainedOrder
+} from "./chunk-XVEI4HZL.js";
+import {
+  nodeFor
+} from "./chunk-LMLBQSAM.js";
+import {
+  readPresentationText
+} from "./chunk-YKODRSGT.js";
+import {
+  SelectionError,
+  readSelectionIndex
+} from "./chunk-NCNHJRIY.js";
+import {
+  readPackage
+} from "./chunk-Q65GWGQR.js";
+import {
+  readBinary
+} from "./chunk-FAU2KL6I.js";
+import {
+  parseXmlPart
+} from "./chunk-7PYDVQPB.js";
+import {
+  OfficeError,
+  RetainedValues,
+  characters,
+  digest,
+  equal,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources
+} from "./chunk-KM2SMMXZ.js";
+
+// packages/safe-bash-presentation-engine/src/diff.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+
+// packages/safe-bash-presentation-engine/src/retained-geometry.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+async function retainedShapeNode(document, id, check) {
+  const namespace = () => document.namespace(document.root);
+  async function local(node, names) {
+    for (const name of names) if (await equal(document.raw(node.localName), literal(name))) return true;
+    return false;
+  }
+  for await (const node of document.elements(document.root)) {
+    check();
+    if (!await equal(document.namespace(node), namespace()) || !await local(node, ["sp", "pic", "graphicFrame", "cxnSp", "grpSp"])) continue;
+    let nonvisual;
+    for await (const child of document.children(node)) if (child.kind === "element" && await equal(document.namespace(child), namespace()) && await local(child, ["nvSpPr", "nvPicPr", "nvGraphicFramePr", "nvCxnSpPr", "nvGrpSpPr"])) {
+      nonvisual = child;
+      break;
+    }
+    if (!nonvisual) continue;
+    let properties;
+    for await (const child of document.children(nonvisual)) if (child.kind === "element" && await equal(document.namespace(child), namespace()) && await local(child, ["cNvPr"])) {
+      if (properties) throw new OfficeError("invalid-value", "Ambiguous shared structure.", "usage");
+      properties = child;
+    }
+    if (!properties) throw new OfficeError("unsupported-edit", "Unsupported shared structure.", "validate-intent");
+    for await (const attr of document.attributes(properties)) if (await equal(document.namespace(attr), literal("")) && await local(attr, ["id"]) && await readRetainedPropertyValue("number", document.text(attr), check) === Number(id)) return node;
+  }
+  throw new SelectionError("missing-selection");
+}
+async function* retainedGeometry(document, root, settings) {
+  const working = settings.workingStorage, signal = settings.signal ?? new AbortController().signal;
+  const pages = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, (working.cacheBytes ?? 1024 * 1024) / 16384);
+  const check = () => {
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "index");
+  };
+  const values = new RetainedValues(pages, check, signal);
+  let failed = false;
+  async function write(pointer, numbers) {
+    const bytes = new Uint8Array(numbers.length * 8), view = new DataView(bytes.buffer);
+    numbers.forEach((value, n) => view.setFloat64(n * 8, value, true));
+    await pages.write(pointer, bytes);
+  }
+  async function row(pointer, count) {
+    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));
+  }
+  const name = (node) => ({ namespace: () => document.namespace(node), localName: () => document.raw(node.localName) });
+  async function* attributeKey(node) {
+    yield* document.namespace(node);
+    yield* literal("/");
+    yield* document.raw(node.localName);
+  }
+  async function* header(node) {
+    yield* literal('{"name":');
+    yield* streamJson(name(node));
+    yield* literal(',"attributes":[');
+    const order = new RetainedOrder(pages, values, check);
+    for await (const attr of document.attributes(node)) {
+      const value = await values.store(streamJson({ name: name(attr), value: () => document.text(attr) }));
+      await order.add(attributeKey(attr), value);
+    }
+    await order.seal();
+    let first = true;
+    for await (const value of order.entries()) {
+      if (!first) yield* literal(",");
+      first = false;
+      yield* streamJson({ [rawJson]: () => values.read(value) });
+    }
+    yield* literal('],"children":[');
+  }
+  async function frame(node, parent) {
+    let head = 0, tail = 0;
+    for await (const child of document.children(node)) if (child.kind === "element") {
+      const pointer2 = pages.allocate(16);
+      await write(pointer2, [0, document.reference(child)]);
+      if (tail) await write(tail, [pointer2]);
+      else head = pointer2;
+      tail = pointer2;
+    }
+    const pointer = pages.allocate(24);
+    await write(pointer, [parent, head, 0]);
+    return pointer;
+  }
+  try {
+    check();
+    yield* header(root);
+    let top = await frame(root, 0);
+    while (top) {
+      check();
+      const data = await row(top, 3);
+      if (!data[1]) {
+        yield* literal("]}");
+        top = data[0];
+        continue;
+      }
+      const child = await row(data[1], 2);
+      await write(top + 8, [child[0], 1]);
+      if (data[2]) yield* literal(",");
+      const node = await document.node(child[1]);
+      yield* header(node);
+      top = await frame(node, top);
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    try {
+      await pages.close();
+    } catch (error) {
+      if (!failed) await Promise.reject(error);
+    }
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/retained-diff.ts
+import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+var categories = ["slides", "text", "properties", "geometry", "media", "relationships", "opaque", "raw"];
+async function* joined(...sources) {
+  for (const source of sources) yield* source;
+}
+async function* encoded(source) {
+  for await (const character of characters(source)) yield* literal(encodeURIComponent(character));
+}
+async function openRetainedDiff(left, right, options, settings) {
+  const mode = options?.mode;
+  if (!["structural", "raw", "text", "media", "relationships"].includes(mode)) throw new OfficeError("invalid-value", "Invalid retained comparison mode.", "usage");
+  const working = { ...settings.workingStorage }, signal = settings.signal ?? new AbortController().signal, cacheBytes = working.cacheBytes ?? 1024 * 1024;
+  if (!working.fs || !working.directory?.startsWith("/") || !Number.isSafeInteger(cacheBytes) || cacheBytes < 16384 || cacheBytes % 16384) throw new OfficeError("invalid-value", "Invalid comparison storage.", "usage");
+  const context = { ...resolveOfficeResources(settings), workingStorage: working, signal };
+  const pages = new PagedStorage2({ fs: working.fs, cwd: working.directory, env: {}, signal }, cacheBytes / 16384);
+  let closed = false, closing;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Comparison is closed.", "index");
+    if (signal.aborted) throw new OfficeError("cancelled", "Comparison cancelled.", "index");
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= pages.close();
+  };
+  const values = new RetainedValues(pages, check, signal);
+  async function row(pointer) {
+    check();
+    const bytes = await pages.read(pointer, 56), view = new DataView(bytes.buffer, bytes.byteOffset, 56);
+    return Array.from({ length: 7 }, (_, n) => view.getFloat64(n * 8, true));
+  }
+  async function write(pointer, numbers) {
+    check();
+    const bytes = new Uint8Array(numbers.length * 8), view = new DataView(bytes.buffer);
+    numbers.forEach((value, n) => view.setFloat64(n * 8, value, true));
+    await pages.write(pointer, bytes);
+  }
+  const range = (data, offset) => ({ start: data[offset], length: data[offset + 1] });
+  const json = (value) => ({ [rawJson]: () => values.read(value) });
+  function entries(scope) {
+    let head = 0, tail = 0;
+    const find = async (key) => {
+      const found = await values.find(scope, key);
+      return found ? row(found.start) : void 0;
+    };
+    return {
+      find,
+      async put(key, value, location = null) {
+        const k = await values.store(key), v = await values.store(streamJson(value)), l = await values.store(streamJson(location));
+        const old = await values.find(scope, () => values.read(k));
+        if (old) {
+          await write(old.start + 24, [v.start, v.length, l.start, l.length]);
+          return;
+        }
+        const pointer = pages.allocate(56);
+        await write(pointer, [0, k.start, k.length, v.start, v.length, l.start, l.length]);
+        await values.insert(scope, k, { start: pointer, length: 56 });
+        if (tail) await write(tail, [pointer]);
+        else head = pointer;
+        tail = pointer;
+      },
+      async *rows() {
+        check();
+        for (let pointer = head; pointer; ) {
+          const data = await row(pointer);
+          yield data;
+          pointer = data[0];
+        }
+        check();
+      }
+    };
+  }
+  async function fingerprint(source) {
+    check();
+    if (!source || typeof source.read !== "function" || !Number.isSafeInteger(source.size) || source.size < 0) throw new OfficeError("invalid-type", "A retained package source is required.", "usage");
+    if (source.size > Math.min(context.limits.maxBytes, context.archiveLimits.maxArchiveBytes)) throw new OfficeError("resource-limit", "Byte input exceeds its limit.", "admit");
+    async function* chunks() {
+      for (let offset = 0; offset < source.size; ) {
+        check();
+        const bytes = await source.read(offset, Math.min(16384, source.size - offset), { signal });
+        if (!bytes.length || bytes.length > Math.min(16384, source.size - offset)) throw new OfficeError("io-failure", "Invalid retained comparison read.", "admit");
+        offset += bytes.length;
+        yield bytes;
+      }
+    }
+    return digest(chunks());
+  }
+  async function snapshot2(source, fingerprint2, scope) {
+    const result = new Map(categories.map((category) => [category, entries(`${scope}/${category}`)])), archive = await openPackageArchive(source, context);
+    let index, text, failed = false;
+    try {
+      index = await openRetainedPresentationIndex(archive, fingerprint2, context);
+      const partLocation = (part) => ({ fingerprint: fingerprint2, scope: "shared", owner: part, objectId: part, coordinateSystem: "identity" });
+      for await (const slide of index.records.records("slide")) {
+        const key = await values.store(literal(slide.part)), value = await values.store(literal(`slide/${encodeURIComponent(slide.id)}`));
+        await values.insert(`${scope}/owners`, key, value);
+      }
+      async function* owner(part) {
+        const known = await values.find(`${scope}/owners`, part);
+        if (known) yield* values.read(known);
+        else {
+          yield* literal("part/");
+          yield* encoded(part());
+        }
+      }
+      if (mode === "structural") {
+        for await (const slide of index.inventory.slides) {
+          const key = await values.store(literal(slide.id)), value = await values.store(literal(JSON.stringify(slide.show.explicit)));
+          await values.insert(`${scope}/visibility`, key, value);
+        }
+        for await (const slide of index.records.records("slide")) {
+          const id = `slide/${encodeURIComponent(slide.id)}`;
+          await result.get("slides").put(literal(id), { name: slide.name }, slide.location);
+          await result.get("slides").put(literal(`${id}/position`), slide.position, slide.location);
+          await result.get("slides").put(literal(`${id}/visibility`), json(await values.find(`${scope}/visibility`, () => literal(slide.id))), slide.location);
+        }
+        const properties = await openRetainedProperties(archive, fingerprint2, {}, context);
+        let failed2 = false;
+        try {
+          const order = new RetainedOrder(pages, values, check);
+          for await (const property of properties.records()) {
+            const key = await values.store(joined(literal(`property/${property.kind}/`), encoded(property.namespace()), literal("/"), encoded(property.name())));
+            const value = await values.store(streamJson({ type: property.type, value: property.value }));
+            const location = await values.store(streamJson({ fingerprint: fingerprint2, scope: "shared", owner: property.part, objectId: property.part, coordinateSystem: "identity" }));
+            const pointer = pages.allocate(56);
+            await write(pointer, [0, key.start, key.length, value.start, value.length, location.start, location.length]);
+            await order.add(joined(literal(`${property.kind}/`), property.namespace(), literal("/"), property.name()), { start: pointer, length: 56 });
+          }
+          await order.seal();
+          for await (const pointer of order.entries()) {
+            const data = await row(pointer.start);
+            await result.get("properties").put(values.read(range(data, 1)), json(range(data, 3)), json(range(data, 5)));
+          }
+        } catch (error) {
+          failed2 = true;
+          throw error;
+        } finally {
+          try {
+            await properties.close();
+          } catch (error) {
+            if (!failed2) await Promise.reject(error);
+          }
+        }
+        let document, part, geometryFailed = false;
+        try {
+          for await (const object of index.records.records("object")) {
+            if (object.location.scope !== "slides") continue;
+            if (part !== object.part) {
+              const old = document;
+              document = void 0;
+              await old?.close();
+              part = object.part;
+              document = await openRetainedXmlDocument(archive.read(part), context);
+            }
+            const doc = document, node = await retainedShapeNode(doc, object.id, check);
+            let shapeOwner = node;
+            for await (const child of doc.children(node)) if (child.kind === "element" && await equal(doc.namespace(child), doc.namespace(node)) && (await equal(doc.raw(child.localName), literal("spPr")) || await equal(doc.raw(child.localName), literal("grpSpPr")))) {
+              shapeOwner = child;
+              break;
+            }
+            const drawing = await equal(doc.namespace(node), literal("http://purl.oclc.org/ooxml/presentationml/main")) ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+            const graphic = await equal(doc.raw(node.localName), literal("graphicFrame"));
+            async function* transforms() {
+              for await (const child of doc.children(shapeOwner)) {
+                if (child.kind !== "element" || !await equal(doc.namespace(child), graphic ? doc.namespace(node) : literal(drawing))) continue;
+                if (await equal(doc.raw(child.localName), literal("xfrm")) || await equal(doc.raw(child.localName), literal("prstGeom")) || await equal(doc.raw(child.localName), literal("custGeom"))) yield { [rawJson]: () => retainedGeometry(doc, child, context) };
+              }
+            }
+            await result.get("geometry").put(joined(owner(() => literal(object.part)), literal(`/shape/${encodeURIComponent(object.id)}/geometry`)), transforms(), object.location);
+          }
+        } catch (error) {
+          geometryFailed = true;
+          throw error;
+        } finally {
+          try {
+            await document?.close();
+          } catch (error) {
+            if (!geometryFailed) await Promise.reject(error);
+          }
+        }
+      }
+      if (mode === "raw") {
+        const order = new RetainedOrder(pages, values, check);
+        for await (const part of archive.parts()) {
+          const name = await values.store(literal(part));
+          await order.add(values.read(name), name);
+        }
+        await order.seal();
+        for await (const name of order.entries()) {
+          const decoder = new TextDecoder();
+          let part = "";
+          for await (const bytes of values.read(name)) part += decoder.decode(bytes, { stream: true });
+          part += decoder.decode();
+          await result.get("raw").put(literal(`part/${encodeURIComponent(part)}`), { sha256: await digest(archive.read(part)), bytes: await archive.byteLength(part) }, partLocation(part));
+        }
+      }
+      if (mode === "text" || mode === "structural") {
+        text = await openRetainedText(archive, fingerprint2, {}, context);
+        for await (const segment of text.segments()) {
+          const cell = segment.cell ? `/cell/${segment.cell.row}/${segment.cell.column}` : "";
+          await result.get("text").put(joined(owner(() => literal(segment.location.owner)), literal(`/shape/${encodeURIComponent(segment.location.objectId)}${cell}/text`)), segment.text, segment.location);
+        }
+        async function* keys() {
+          for await (const data of result.get("text").rows()) yield () => values.read(range(data, 1));
+        }
+        await result.get("text").put(literal("text/order"), keys());
+      }
+      if (mode === "media" || mode === "relationships" || mode === "structural") {
+        const order = new RetainedOrder(pages, values, check);
+        for await (const media of index.inventory.media) {
+          const key = await values.store(literal(media.part)), hash2 = await values.store(literal(media.sha256));
+          await values.insert(`${scope}/media`, key, hash2);
+          if (mode === "media" || mode === "structural") {
+            const known = await values.find(`${scope}/counts`, () => literal(media.sha256));
+            if (known) {
+              const bytes = await pages.read(known.start, 8), view = new DataView(bytes.buffer, bytes.byteOffset, 8);
+              await write(known.start, [view.getFloat64(0, true) + 1]);
+            } else {
+              const count = pages.allocate(16);
+              await write(count, [1, media.bytes]);
+              await values.insert(`${scope}/counts`, hash2, { start: count, length: 16 });
+              await order.add(literal(media.sha256), hash2);
+            }
+          }
+        }
+        if (mode === "media" || mode === "structural") {
+          await order.seal();
+          for await (const hash2 of order.entries()) {
+            const count = await values.find(`${scope}/counts`, () => values.read(hash2)), bytes = await pages.read(count.start, 16), view = new DataView(bytes.buffer, bytes.byteOffset, 16);
+            await result.get("media").put(joined(literal("media/"), values.read(hash2)), { sha256: () => values.read(hash2), bytes: view.getFloat64(8, true), count: view.getFloat64(0, true) });
+          }
+        }
+        if (mode === "relationships" || mode === "structural") for await (const edge of index.inventory.relationships) {
+          const media = edge.targetPart ? await values.find(`${scope}/media`, edge.targetPart) : void 0;
+          const target = edge.external ? edge.target : media ? () => joined(literal("media/"), values.read(media)) : () => owner(edge.targetPart);
+          await result.get("relationships").put(joined(owner(() => literal(edge.owner)), literal("/relationship/"), encoded(edge.id())), { type: edge.type, external: edge.external, target }, partLocation(edge.owner));
+        }
+      }
+      if (mode === "structural") {
+        for await (const part of index.inventory.parts) if (!await values.find(`${scope}/media`, () => literal(part.part))) await result.get("opaque").put(literal(`part/${encodeURIComponent(part.part)}`), { sha256: part.sha256, bytes: part.bytes, contentType: part.contentType }, partLocation(part.part));
+      }
+      return result;
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      const outcomes = await Promise.allSettled([text?.close(), index?.close(), archive.close()]);
+      if (!failed) {
+        for (const outcome of outcomes) if (outcome.status === "rejected") await Promise.reject(outcome.reason);
+      }
+    }
+  }
+  try {
+    const leftHash = await fingerprint(left), rightHash = await fingerprint(right);
+    const before = await snapshot2(left, leftHash, "left"), after = await snapshot2(right, rightHash, "right");
+    async function* changes() {
+      check();
+      for (const category of categories) {
+        const a = before.get(category), b = after.get(category);
+        async function suppressed(data2) {
+          if (category !== "slides") return false;
+          let id = "";
+          for await (const bytes of values.read(range(data2, 1))) id += new TextDecoder().decode(bytes);
+          if (!id.endsWith("/position") && !id.endsWith("/visibility")) return false;
+          const root = id.slice(0, id.lastIndexOf("/"));
+          return !await a.find(() => literal(root)) || !await b.find(() => literal(root));
+        }
+        for await (const first of a.rows()) {
+          const second = await b.find(() => values.read(range(first, 1)));
+          if (second && await equal(values.read(range(first, 3)), values.read(range(second, 3)))) continue;
+          if (await suppressed(first)) continue;
+          yield { id: () => values.read(range(first, 1)), category, kind: second ? "changed" : "removed", before: json(range(first, 3)), after: second ? json(range(second, 3)) : null, left: json(range(first, 5)), right: second ? json(range(second, 5)) : null };
+        }
+        for await (const second of b.rows()) if (!await a.find(() => values.read(range(second, 1))) && !await suppressed(second)) yield { id: () => values.read(range(second, 1)), category, kind: "added", before: null, after: json(range(second, 3)), left: null, right: json(range(second, 5)) };
+      }
+    }
+    let same = true;
+    for await (const ignoredChange of changes()) {
+      same = false;
+      break;
+    }
+    const limitations = ["No rendering or effective formatting comparison is performed.", ...mode === "structural" ? ["Nonmedia part byte hashes conservatively report raw and unsupported content changes, including parts also inspected semantically."] : [], ...mode === "text" || mode === "structural" ? ["Semantic text comparison covers slide text in structural order; other text scopes are not included."] : [], ...mode === "raw" ? ["Raw comparison covers uncompressed package members; ZIP container metadata is excluded."] : []];
+    const data = { equal: same, mode, formatting: "raw", get changes() {
+      return changes();
+    }, limitations };
+    return Object.freeze({ data, close });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error;
+  }
+}
+async function stageRetainedDiff(left, right, options, settings) {
+  const format = { ...options }, view = await openRetainedDiff(left, right, format, settings);
+  let staged;
+  try {
+    async function* render() {
+      if (format.json) {
+        yield* streamJson({ version: 1, operation: "diff", ok: true, data: view.data, affected: 0, warnings: [], errors: [], locations: [] });
+        yield* literal("\n");
+      } else {
+        yield* literal(`${view.data.equal ? "Equal" : "Different"} (${view.data.mode}; raw formatting)
+`);
+        for await (const change of view.data.changes) {
+          yield* literal(`${change.category} ${change.kind} `);
+          yield* change.id();
+          yield* literal("\n  before: ");
+          yield* streamJson(change.before);
+          yield* literal("\n  after: ");
+          yield* streamJson(change.after);
+          yield* literal("\n");
+        }
+      }
+    }
+    staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
+    await view.close();
+    return { output: staged, equal: view.data.equal };
+  } catch (error) {
+    await Promise.allSettled([view.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/diff.ts
+var categories2 = [
+  "slides",
+  "text",
+  "properties",
+  "geometry",
+  "media",
+  "relationships",
+  "opaque",
+  "raw"
+];
+function hash(bytes) {
+  return Array.from(sha256(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function geometry(node) {
+  return {
+    name: node.name,
+    attributes: [...node.attributes].sort((a, b) => {
+      const left = `${a.name.namespace}/${a.name.localName}`, right = `${b.name.namespace}/${b.name.localName}`;
+      return left < right ? -1 : left > right ? 1 : 0;
+    }),
+    children: node.children.map(geometry)
+  };
+}
+async function snapshot(input, mode, context) {
+  const bytes = await readBinary(input, context, {
+    maxBytes: Math.min(context.limits.maxBytes, context.archiveLimits.maxArchiveBytes)
+  });
+  const reader = await readPackage(bytes, context);
+  const index = await readSelectionIndex(bytes, context);
+  const result = new Map(categories2.map((category) => [category, /* @__PURE__ */ new Map()]));
+  const put = (category, id, value, location = null) => {
+    result.get(category).set(id, { value, location });
+  };
+  const slideIds = new Map(
+    index.slides.map((slide) => [slide.part, `slide/${encodeURIComponent(slide.id)}`])
+  );
+  const ownerId = (part) => slideIds.get(part) ?? `part/${encodeURIComponent(part)}`;
+  const partLocation = (part) => ({
+    fingerprint: index.fingerprint,
+    scope: "shared",
+    owner: part,
+    objectId: part,
+    coordinateSystem: "identity"
+  });
+  if (mode === "raw") {
+    for (const part of [...reader.names].sort()) {
+      const payload = reader.get(part);
+      put(
+        "raw",
+        `part/${encodeURIComponent(part)}`,
+        { sha256: hash(payload), bytes: payload.length },
+        partLocation(part)
+      );
+    }
+    return result;
+  }
+  if (mode === "structural") {
+    for (const slide of index.slides) {
+      const id = ownerId(slide.part);
+      put("slides", id, { name: slide.name }, slide.location);
+      put("slides", `${id}/position`, slide.position, slide.location);
+      const detail = index.inventory.slides.find((item) => item.id === slide.id);
+      put("slides", `${id}/visibility`, detail.show.explicit, slide.location);
+    }
+    const properties = await readProperties(bytes, {}, context);
+    for (const property of [...properties].sort((a, b) => {
+      const left = `${a.kind}/${a.namespace}/${a.name}`, right = `${b.kind}/${b.namespace}/${b.name}`;
+      return left < right ? -1 : left > right ? 1 : 0;
+    })) {
+      put(
+        "properties",
+        `property/${property.kind}/${encodeURIComponent(property.namespace)}/${encodeURIComponent(property.name)}`,
+        { type: property.type, value: property.value },
+        partLocation(property.part)
+      );
+    }
+    const roots = /* @__PURE__ */ new Map();
+    for (const object of index.objects.filter((item) => item.scope === "slides")) {
+      let root = roots.get(object.part);
+      if (!root) {
+        root = parseXmlPart(reader.get(object.part), context.xmlLimits).root;
+        roots.set(object.part, root);
+      }
+      const node = nodeFor(root, object.id);
+      const owner = node.children.find(
+        (child) => child.name.namespace === node.name.namespace && ["spPr", "grpSpPr"].includes(child.name.localName)
+      ) ?? node;
+      const drawingNamespace = node.name.namespace === "http://purl.oclc.org/ooxml/presentationml/main" ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+      const transforms = owner.children.filter(
+        (child) => ["xfrm", "prstGeom", "custGeom"].includes(child.name.localName) && child.name.namespace === (node.name.localName === "graphicFrame" ? node.name.namespace : drawingNamespace)
+      );
+      put(
+        "geometry",
+        `${ownerId(object.part)}/shape/${encodeURIComponent(object.id)}/geometry`,
+        transforms.map(geometry),
+        object.location
+      );
+    }
+  }
+  if (mode === "structural" || mode === "text") {
+    const text = await readPresentationText(bytes, {}, context);
+    for (const segment of text.segments) {
+      const cell = segment.cell ? `/cell/${segment.cell.row}/${segment.cell.column}` : "";
+      put(
+        "text",
+        `${ownerId(segment.location.owner)}/shape/${encodeURIComponent(segment.location.objectId)}${cell}/text`,
+        segment.text,
+        segment.location
+      );
+    }
+    put("text", "text/order", [...result.get("text").keys()]);
+  }
+  const media = new Map(index.inventory.media.map((part) => [part.part, part]));
+  if (mode === "structural" || mode === "media") {
+    const counts = /* @__PURE__ */ new Map();
+    for (const part of media.values()) {
+      const entry = counts.get(part.sha256) ?? { sha256: part.sha256, bytes: part.bytes, count: 0 };
+      entry.count++;
+      counts.set(part.sha256, entry);
+    }
+    for (const [digest2, value] of [...counts].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))
+      put("media", `media/${digest2}`, value);
+  }
+  if (mode === "structural" || mode === "relationships") {
+    for (const edge of index.inventory.relationships) {
+      const targetMedia = edge.targetPart === null ? void 0 : media.get(edge.targetPart);
+      const target = edge.external ? edge.target : targetMedia ? `media/${targetMedia.sha256}` : ownerId(edge.targetPart);
+      put(
+        "relationships",
+        `${ownerId(edge.owner)}/relationship/${encodeURIComponent(edge.id)}`,
+        { type: edge.type, external: edge.external, target },
+        partLocation(edge.owner)
+      );
+    }
+  }
+  if (mode === "structural") {
+    for (const part of index.inventory.parts.filter((part2) => !media.has(part2.part))) {
+      put(
+        "opaque",
+        `part/${encodeURIComponent(part.part)}`,
+        { sha256: part.sha256, bytes: part.bytes, contentType: part.contentType },
+        partLocation(part.part)
+      );
+    }
+  }
+  return result;
+}
+async function comparePresentations(left, right, options, context) {
+  const modes = [
+    "structural",
+    "text",
+    "media",
+    "relationships",
+    "effective-formatting",
+    "raw"
+  ];
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some((key) => key !== "mode") || options.mode !== void 0 && !modes.includes(options.mode))
+    throw new OfficeError("invalid-value", "Invalid comparison options.", "usage");
+  const mode = options.mode ?? "structural";
+  if (mode === "effective-formatting")
+    throw new OfficeError(
+      "unsupported-profile",
+      "Complete effective formatting comparison is unavailable; select a raw formatting mode.",
+      "usage"
+    );
+  const before = await snapshot(left, mode, context);
+  const after = await snapshot(right, mode, context);
+  const changes = [];
+  for (const category of categories2) {
+    const a = before.get(category), b = after.get(category);
+    for (const id of /* @__PURE__ */ new Set([...a.keys(), ...b.keys()])) {
+      const first = a.get(id), second = b.get(id);
+      if (JSON.stringify(first?.value) === JSON.stringify(second?.value)) continue;
+      if (category === "slides" && (id.endsWith("/position") || id.endsWith("/visibility"))) {
+        const root = id.slice(0, id.lastIndexOf("/"));
+        if (!a.has(root) || !b.has(root)) continue;
+      }
+      changes.push(
+        Object.freeze({
+          id,
+          category,
+          kind: !first ? "added" : !second ? "removed" : "changed",
+          before: first?.value ?? null,
+          after: second?.value ?? null,
+          left: first?.location ?? null,
+          right: second?.location ?? null
+        })
+      );
+    }
+  }
+  return Object.freeze({
+    equal: changes.length === 0,
+    mode,
+    formatting: "raw",
+    changes: Object.freeze(changes),
+    limitations: Object.freeze([
+      "No rendering or effective formatting comparison is performed.",
+      ...mode === "structural" ? [
+        "Nonmedia part byte hashes conservatively report raw and unsupported content changes, including parts also inspected semantically."
+      ] : [],
+      ...mode === "text" || mode === "structural" ? [
+        "Semantic text comparison covers slide text in structural order; other text scopes are not included."
+      ] : [],
+      ...mode === "raw" ? [
+        "Raw comparison covers uncompressed package members; ZIP container metadata is excluded."
+      ] : []
+    ])
+  });
+}
+
+export {
+  openRetainedDiff,
+  stageRetainedDiff,
+  comparePresentations
+};