@poe-platform/safe-bash 0.1.818 → 0.1.820

package/dist/safe-bash/command-chunks/chunk-2H6RJPCQ.js

@@ -0,0 +1,721 @@
+import {
+  rawJson,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-R36PDP3L.js";
+import {
+  RetainedOrder
+} from "./chunk-7JTJQKIV.js";
+import {
+  readPackage
+} from "./chunk-KVTZJBLM.js";
+import {
+  openRetainedContentTypes,
+  openRetainedRelationshipGraph
+} from "./chunk-O4H7HPMP.js";
+import {
+  parseXmlPart
+} from "./chunk-YWP62BAZ.js";
+import {
+  readRelationshipGraph
+} from "./chunk-QMXOKYMJ.js";
+import {
+  parseContentTypes
+} from "./chunk-6ZHNKHQQ.js";
+import {
+  partName
+} from "./chunk-PZVFNPRC.js";
+import {
+  OfficeError,
+  RetainedValues,
+  characters,
+  digest,
+  equal,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources
+} from "./chunk-VJQ5OWS5.js";
+
+// packages/safe-bash-presentation-engine/src/opaque-objects.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+
+// packages/safe-bash-presentation-engine/src/opaque-kinds.ts
+var relationships = [
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  "http://purl.oclc.org/ooxml/officeDocument/relationships"
+];
+var relationshipKinds = Object.fromEntries([
+  ...relationships.flatMap(
+    (namespace) => Object.entries({ oleObject: "ole", package: "package", control: "control", font: "font" }).map(
+      ([suffix, kind]) => [`${namespace}/${suffix}`, kind]
+    )
+  ),
+  ["http://schemas.microsoft.com/office/2006/relationships/activeXControlBinary", "control"],
+  ["http://schemas.microsoft.com/office/2006/relationships/vbaProject", "active-payload"],
+  ["http://schemas.microsoft.com/office/2011/relationships/webextension", "web-extension"],
+  ["http://schemas.microsoft.com/office/2011/relationships/webextensiontaskpanes", "web-extension"],
+  ["http://schemas.microsoft.com/office/2017/06/relationships/model3d", "model3d"]
+]);
+var contentKinds = {
+  "application/vnd.openxmlformats-officedocument.oleobject": "ole",
+  "application/vnd.ms-office.activex+xml": "control",
+  "application/vnd.ms-office.activex": "control",
+  "application/vnd.ms-office.webextension+xml": "web-extension",
+  "application/vnd.ms-office.webextensiontaskpanes+xml": "web-extension",
+  "application/x-fontdata": "font",
+  "application/vnd.openxmlformats-officedocument.obfuscatedfont": "font",
+  "application/font-sfnt": "font",
+  "application/vnd.ms-opentype": "font",
+  "model/gltf-binary": "model3d",
+  "model/gltf+json": "model3d",
+  "application/vnd.ms-office.model3d": "model3d",
+  "application/vnd.ms-office.vbaproject": "active-payload"
+};
+
+// packages/safe-bash-presentation-engine/src/retained-objects.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+async function openRetainedObjects(archive, settings) {
+  const context = { ...resolveOfficeResources(settings), workingStorage: { ...settings.workingStorage } }, signal = context.signal ?? new AbortController().signal;
+  const graph = await openRetainedRelationshipGraph(archive, context);
+  const pages = new PagedStorage({ fs: context.workingStorage.fs, cwd: context.workingStorage.directory, env: {}, signal }, (context.workingStorage.cacheBytes ?? 1024 * 1024) / 16384);
+  let types, closed = false, closing, head = 0, tail = 0, count = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Opaque inventory is closed.", "index");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "index");
+  };
+  const failure = (error) => error instanceof OfficeError ? error : new OfficeError(signal.aborted ? "cancelled" : "io-failure", "Opaque inventory storage operation failed.", "index");
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([types?.close(), graph.close(), pages.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  const values = new RetainedValues(pages, check, signal), parts = new RetainedOrder(pages, values, check);
+  async function text(range) {
+    let result = "";
+    const decoder = new TextDecoder();
+    for await (const bytes of values.read(range)) result += decoder.decode(bytes, { stream: true });
+    return result + decoder.decode();
+  }
+  async function write(pointer, row2) {
+    const bytes = new Uint8Array(row2.length * 8), view = new DataView(bytes.buffer);
+    row2.forEach((n, i) => view.setFloat64(i * 8, n, true));
+    await pages.write(pointer, bytes);
+  }
+  async function row(pointer, count2) {
+    check();
+    const bytes = await pages.read(pointer, count2 * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length: count2 }, (_, i) => view.getFloat64(i * 8, true));
+  }
+  async function* ordered(order) {
+    for await (const value of order.entries()) yield () => values.read(value);
+  }
+  try {
+    types = await openRetainedContentTypes(archive.read("/[Content_Types].xml"), context, { maxBytes: context.xmlLimits.maxBytes, maxEntries: context.relationshipLimits.maxParts });
+    for await (const part of graph.parts()) {
+      const name = await values.store(literal(part));
+      await parts.add(literal(part), name);
+      await values.insert("present", name, name);
+    }
+    await parts.seal();
+    for await (const name of parts.entries()) {
+      check();
+      const part = await text(name), contentType = await values.store(await types.get(part));
+      let essence = "", overflow = false, pending = 0;
+      for await (const c of characters(values.read(contentType))) {
+        if (c === ";") break;
+        if (c.trim() === "") {
+          if (essence || overflow) pending++;
+          continue;
+        }
+        if (pending) {
+          if (essence.length + pending > 128) overflow = true;
+          else essence += " ".repeat(pending);
+          pending = 0;
+        }
+        if (essence.length + c.length > 128) overflow = true;
+        else if (!overflow) essence += c.toLowerCase();
+      }
+      let kind = !overflow ? contentKinds[essence] : void 0;
+      const header = new Uint8Array(8);
+      let used = 0;
+      for await (const chunk of archive.read(part)) {
+        check();
+        const n = Math.min(8 - used, chunk.length);
+        header.set(chunk.subarray(0, n), used);
+        used += n;
+        if (used === 8) break;
+      }
+      const activeReasons = [{ bytes: [77, 90], reason: "executable-header" }, { bytes: [127, 69, 76, 70], reason: "executable-header" }, { bytes: [208, 207, 17, 224, 161, 177, 26, 225], reason: "compound-container" }].filter((s) => used >= s.bytes.length && s.bytes.every((b, i) => header[i] === b)).map((s) => s.reason);
+      if (!kind) for await (const edge of graph.incoming(part)) {
+        for (const [type, value] of Object.entries(relationshipKinds)) if (await equal(edge.type(), literal(type))) {
+          kind = value;
+          break;
+        }
+        if (kind) break;
+      }
+      if (!kind) kind = essence.startsWith("font/") ? "font" : activeReasons.length ? "active-payload" : void 0;
+      if (!kind) continue;
+      if (["ole", "package", "control", "web-extension", "active-payload"].includes(kind)) activeReasons.push(`potentially-active-${kind}`);
+      const owners = new RetainedOrder(pages, values, check), dependencies = new RetainedOrder(pages, values, check), missing = new RetainedOrder(pages, values, check), external = new RetainedOrder(pages, values, check);
+      const namespace = `object${++count}`;
+      let queueHead = 0, queueTail = 0, externalCount = 0;
+      async function enqueue(value) {
+        if (!await values.insert(namespace + "seen", value, value)) return;
+        const pointer2 = pages.allocate(24);
+        await write(pointer2, [0, value.start, value.length]);
+        if (queueTail) await write(queueTail, [pointer2]);
+        else queueHead = pointer2;
+        queueTail = pointer2;
+      }
+      await enqueue(name);
+      for await (const edge of graph.incoming(part)) {
+        const owner = await values.store(literal(edge.owner));
+        if (await values.insert(namespace + "owners", owner, owner)) await owners.add(values.read(owner), owner);
+      }
+      for (let pointer2 = queueHead; pointer2; ) {
+        const current = await row(pointer2, 3), owner = await text({ start: current[1], length: current[2] });
+        for await (const edge of graph.outgoing(owner)) {
+          if (edge.external) {
+            const value = await values.store(streamJson({ id: edge.id, type: edge.type, target: edge.target, external: true, owner: edge.owner, targetPart: null }));
+            await external.add(literal(String(externalCount++).padStart(16, "0")), value);
+          } else if (edge.targetPart) {
+            const present = await values.find("present", edge.targetPart);
+            if (!present) {
+              const target = await values.store(edge.targetPart());
+              if (await values.insert(namespace + "missing", target, target)) await missing.add(values.read(target), target);
+            } else if (!await values.find(namespace + "seen", () => values.read(present))) {
+              await enqueue(present);
+              await dependencies.add(values.read(present), present);
+            }
+          }
+        }
+        pointer2 = (await row(pointer2, 1))[0];
+      }
+      await owners.seal();
+      await dependencies.seal();
+      await missing.seal();
+      await external.seal();
+      async function* edges() {
+        for await (const value of external.entries()) yield { [rawJson]: () => values.read(value) };
+      }
+      const size = await archive.byteLength(part), hash = await digest(archive.read(part));
+      const json = await values.store(streamJson({ part, kind, contentType: () => values.read(contentType), bytes: size, sha256: hash, activeContent: activeReasons.length > 0, activeReasons, owners: ordered(owners), dependencies: ordered(dependencies), missing: ordered(missing), externalRelationships: edges() }));
+      const metadata = await values.store(literal(JSON.stringify({ part, kind, bytes: size, activeContent: activeReasons.length > 0 }))), pointer = pages.allocate(40);
+      await write(pointer, [0, json.start, json.length, metadata.start, metadata.length]);
+      if (tail) await write(tail, [pointer]);
+      else head = pointer;
+      tail = pointer;
+    }
+    await types.close();
+    types = void 0;
+    await graph.close();
+    check();
+    return Object.freeze({
+      close,
+      count,
+      async *objects(kind) {
+        try {
+          check();
+          for (let pointer = head; pointer; ) {
+            const item = await row(pointer, 5);
+            pointer = item[0];
+            if (kind && JSON.parse(await text({ start: item[3], length: item[4] })).kind !== kind) continue;
+            const value = { start: item[1], length: item[2] };
+            yield { [rawJson]: () => values.read(value) };
+          }
+          check();
+        } catch (error) {
+          throw failure(error);
+        }
+      },
+      async *summaries() {
+        try {
+          check();
+          for (let pointer = head; pointer; ) {
+            const item = await row(pointer, 5);
+            pointer = item[0];
+            yield JSON.parse(await text({ start: item[3], length: item[4] }));
+          }
+          check();
+        } catch (error) {
+          throw failure(error);
+        }
+      }
+    });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw failure(error);
+  }
+}
+async function stageRetainedObjects(archive, settings, output) {
+  const format = { ...output }, reader = await openRetainedObjects(archive, settings);
+  let staged;
+  async function* render() {
+    if (format.json) {
+      yield* streamJson({ version: 1, operation: "objects.list", ok: true, affected: 0, warnings: [], errors: [], locations: [], data: { objects: reader.objects(), activationPerformed: false, recursiveParsingPerformed: false } });
+      yield* literal("\n");
+    } else for await (const item of reader.summaries()) yield* literal(`${item.part} ${item.kind} ${item.bytes} bytes${item.activeContent ? " active-content" : ""}
+`);
+  }
+  try {
+    staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
+    await reader.close();
+    return staged;
+  } catch (error) {
+    await Promise.allSettled([reader.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/retained-object-extraction.ts
+import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+async function openRetainedObjectExtraction(archive, options, settings) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).length !== 1 || !Object.hasOwn(options, "part") || !("value" in Object.getOwnPropertyDescriptor(options, "part")) || typeof options.part !== "string")
+    throw new OfficeError("invalid-value", "Object extraction requires an exact package part.", "usage");
+  const selected = partName(options.part, false), context = { ...resolveOfficeResources(settings), workingStorage: { ...settings.workingStorage } }, signal = context.signal ?? new AbortController().signal;
+  const inventory = await openRetainedObjects(archive, context);
+  let present = false, failed = false;
+  try {
+    for await (const object of inventory.summaries()) if (object.part === selected) present = true;
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    try {
+      await inventory.close();
+    } catch (error) {
+      if (!failed) await Promise.reject(error);
+    }
+  }
+  if (!present) throw new OfficeError("missing-binding", "Opaque object part is absent.", "index");
+  const graph = await openRetainedRelationshipGraph(archive, context);
+  const pages = new PagedStorage2({ fs: context.workingStorage.fs, cwd: context.workingStorage.directory, env: {}, signal }, (context.workingStorage.cacheBytes ?? 1024 * 1024) / 16384);
+  let closed = false, closing, count = 0, edgeCount = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Object extraction is closed.", "index");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "index");
+  };
+  const failure = (error) => error instanceof OfficeError ? error : new OfficeError(signal.aborted ? "cancelled" : "io-failure", "Object extraction storage operation failed.", "index");
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([graph.close(), pages.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  const values = new RetainedValues(pages, check, signal), dependencies = new RetainedOrder(pages, values, check), files = new RetainedOrder(pages, values, check), members = new RetainedOrder(pages, values, check), edges = new RetainedOrder(pages, values, check);
+  async function text(range) {
+    let result = "";
+    const decoder = new TextDecoder();
+    for await (const bytes of values.read(range)) result += decoder.decode(bytes, { stream: true });
+    return result + decoder.decode();
+  }
+  try {
+    try {
+      for await (const part of graph.closure([selected])) if (part !== selected) {
+        const value = await values.store(literal(part));
+        await dependencies.add(literal(part), value);
+        await files.add(literal(part), value);
+      }
+    } catch (error) {
+      if (error instanceof OfficeError && error.code === "missing-binding") throw new OfficeError("missing-binding", "Opaque object dependency is absent.", "index");
+      throw error;
+    }
+    await dependencies.seal();
+    async function* parts() {
+      yield selected;
+      for await (const value of dependencies.entries()) yield await text(value);
+    }
+    for await (const part of parts()) {
+      for await (const edge of graph.outgoing(part)) {
+        const value = await values.store(streamJson({ id: edge.id, type: edge.type, target: edge.target, external: edge.external, owner: edge.owner, targetPart: edge.targetPart }));
+        await edges.add(literal(String(edgeCount++).padStart(16, "0")), value);
+      }
+      const slash = part.lastIndexOf("/"), relationships2 = `${part.slice(0, slash + 1)}_rels/${part.slice(slash + 1)}.rels`;
+      if (await archive.has(relationships2)) {
+        const value = await values.store(literal(relationships2));
+        await files.add(literal(relationships2), value);
+      }
+    }
+    await files.seal();
+    await edges.seal();
+    async function* all() {
+      yield selected;
+      for await (const value of files.entries()) yield await text(value);
+    }
+    for await (const part of all()) {
+      check();
+      const record = { part, name: `opaque-${await digest(literal(part))}.bin`, size: await archive.byteLength(part), sha256: await digest(archive.read(part)) };
+      const value = await values.store(literal(JSON.stringify(record)));
+      await members.add(literal(String(count++).padStart(16, "0")), value);
+    }
+    await members.seal();
+    await graph.close();
+    check();
+    return Object.freeze({ close, count, async *members() {
+      try {
+        check();
+        for await (const value of members.entries()) {
+          const metadata = JSON.parse(await text(value));
+          yield Object.freeze({ ...metadata, async *bytes() {
+            try {
+              check();
+              yield* archive.read(metadata.part);
+              check();
+            } catch (error) {
+              throw failure(error);
+            }
+          } });
+        }
+        check();
+      } catch (error) {
+        throw failure(error);
+      }
+    }, async *relationships() {
+      try {
+        check();
+        for await (const value of edges.entries()) yield { [rawJson]: () => values.read(value) };
+        check();
+      } catch (error) {
+        throw failure(error);
+      }
+    } });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw failure(error);
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/retained-fonts.ts
+import { PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
+async function openRetainedFonts(archive, settings) {
+  const context = { ...resolveOfficeResources(settings), workingStorage: { ...settings.workingStorage } }, signal = context.signal ?? new AbortController().signal;
+  const inventory = await openRetainedObjects(archive, context);
+  const pages = new PagedStorage3({ fs: context.workingStorage.fs, cwd: context.workingStorage.directory, env: {}, signal }, (context.workingStorage.cacheBytes ?? 1024 * 1024) / 16384);
+  let graph, closed = false, closing, head = 0, tail = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Font inventory is closed.", "index");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "index");
+  };
+  const failure = (error) => error instanceof OfficeError ? error : new OfficeError(signal.aborted ? "cancelled" : "io-failure", "Font inventory storage operation failed.", "index");
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([graph?.close(), inventory.close(), pages.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  const values = new RetainedValues(pages, check, signal);
+  async function write(pointer, data) {
+    const bytes = new Uint8Array(data.length * 8), view = new DataView(bytes.buffer);
+    data.forEach((n, i) => view.setFloat64(i * 8, n, true));
+    await pages.write(pointer, bytes);
+  }
+  try {
+    graph = await openRetainedRelationshipGraph(archive, context);
+    for await (const part of archive.parts()) {
+      const value = await values.store(literal(part));
+      await values.insert("present", value, value);
+    }
+    for await (const main of graph.outgoing("/")) {
+      if (main.external) continue;
+      let recognized = false;
+      for (const namespace of relationships) if (await equal(main.type(), literal(`${namespace}/officeDocument`))) recognized = true;
+      if (!recognized) continue;
+      const name = main.targetPart ? await values.find("present", main.targetPart) : void 0;
+      if (!name) throw new OfficeError("missing-binding", "Presentation part is absent.", "index");
+      let part = "";
+      const decoder = new TextDecoder();
+      for await (const bytes of values.read(name)) part += decoder.decode(bytes, { stream: true });
+      part += decoder.decode();
+      const doc = await openRetainedXmlDocument(archive.read(part), context);
+      let failed = false;
+      try {
+        let native = false;
+        for (const ns of ["http://schemas.openxmlformats.org/presentationml/2006/main", "http://purl.oclc.org/ooxml/presentationml/main"]) if (await equal(doc.namespace(doc.root), literal(ns))) native = true;
+        if (!native) continue;
+        async function named(node, name2) {
+          return node.kind === "element" && await equal(doc.namespace(node), doc.namespace(doc.root)) && await equal(doc.raw(node.localName), literal(name2));
+        }
+        async function attr(node, name2) {
+          if (node) {
+            for await (const value of doc.attributes(node)) if (await equal(doc.namespace(value), literal("")) && await equal(doc.raw(value.localName), literal(name2))) return () => doc.text(value);
+          }
+          return null;
+        }
+        for await (const list of doc.children(doc.root)) if (await named(list, "embeddedFontLst")) {
+          for await (const node of doc.children(list)) if (await named(node, "embeddedFont")) {
+            let font;
+            for await (const child of doc.children(node)) if (await named(child, "font")) {
+              font = child;
+              break;
+            }
+            async function* variants() {
+              for await (const child of doc.children(node)) {
+                let variant;
+                for (const name2 of ["regular", "bold", "italic", "boldItalic"]) if (await named(child, name2)) variant = name2;
+                if (!variant) continue;
+                let id;
+                for await (const attribute of doc.attributes(child)) {
+                  if (!await equal(doc.raw(attribute.localName), literal("id"))) continue;
+                  for (const namespace of relationships) if (await equal(doc.namespace(attribute), literal(namespace))) id = attribute;
+                  if (id) break;
+                }
+                const edge = id ? await graph.get(part, () => doc.text(id)) : void 0;
+                let fontEdge = false;
+                if (edge && !edge.external) {
+                  for (const namespace of relationships) if (await equal(edge.type(), literal(`${namespace}/font`))) fontEdge = true;
+                }
+                const target = fontEdge ? edge.targetPart : null;
+                yield { variant, relationshipId: id ? () => doc.text(id) : null, part: target, missing: !target || !await values.find("present", target) };
+              }
+            }
+            const value = await values.store(streamJson({ part, typeface: await attr(font, "typeface"), charset: await attr(font, "charset"), pitchFamily: await attr(font, "pitchFamily"), variants: variants() })), pointer = pages.allocate(24);
+            await write(pointer, [0, value.start, value.length]);
+            if (tail) await write(tail, [pointer]);
+            else head = pointer;
+            tail = pointer;
+          }
+        }
+      } catch (error) {
+        failed = true;
+        throw error;
+      } finally {
+        try {
+          await doc.close();
+        } catch (error) {
+          if (!failed) await Promise.reject(error);
+        }
+      }
+    }
+    await graph.close();
+    graph = void 0;
+    check();
+    return Object.freeze({ close, fonts: inventory.objects.bind(void 0, "font"), async *summaries() {
+      for await (const item of inventory.summaries()) if (item.kind === "font") yield item;
+    }, async *declarations() {
+      try {
+        check();
+        for (let pointer = head; pointer; ) {
+          const bytes = await pages.read(pointer, 24), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+          pointer = view.getFloat64(0, true);
+          const value = { start: view.getFloat64(8, true), length: view.getFloat64(16, true) };
+          yield { [rawJson]: () => values.read(value) };
+        }
+        check();
+      } catch (error) {
+        throw failure(error);
+      }
+    } });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw failure(error);
+  }
+}
+async function stageRetainedFonts(archive, settings, output) {
+  const format = { ...output }, reader = await openRetainedFonts(archive, settings);
+  let staged;
+  async function* render() {
+    if (format.json) {
+      yield* streamJson({ version: 1, operation: "fonts.list", ok: true, affected: 0, warnings: [], errors: [], locations: [], data: { declarations: reader.declarations(), fonts: reader.fonts(), installationPerformed: false } });
+      yield* literal("\n");
+    } else for await (const item of reader.summaries()) yield* literal(`${item.part} ${item.bytes} bytes
+`);
+  }
+  try {
+    staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
+    await reader.close();
+    return staged;
+  } catch (error) {
+    await Promise.allSettled([reader.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/opaque-objects.ts
+function digest2(bytes) {
+  return Array.from(sha256(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function activeSignatures(bytes) {
+  return [
+    { bytes: [77, 90], reason: "executable-header" },
+    { bytes: [127, 69, 76, 70], reason: "executable-header" },
+    { bytes: [208, 207, 17, 224, 161, 177, 26, 225], reason: "compound-container" }
+  ].filter((signature) => signature.bytes.every((byte, index) => bytes[index] === byte)).map((signature) => signature.reason);
+}
+function inspectObjects(reader, graph, context) {
+  const types = parseContentTypes(reader.get("/[Content_Types].xml"), {
+    maxBytes: context.xmlLimits.maxBytes,
+    maxEntries: context.relationshipLimits.maxParts
+  });
+  const objects = [];
+  for (const part of [...graph.parts].sort()) {
+    context.signal?.throwIfAborted();
+    const contentType = types.get(part);
+    const mediaType = contentType.split(";", 1)[0].trim().toLowerCase();
+    const bytes = reader.get(part);
+    const activeReasons = activeSignatures(bytes);
+    const incoming = graph.incoming(part);
+    const kind = contentKinds[mediaType] ?? incoming.map((edge) => relationshipKinds[edge.type]).find((value) => value !== void 0) ?? (mediaType.startsWith("font/") ? "font" : activeReasons.length ? "active-payload" : void 0);
+    if (!kind) continue;
+    if (["ole", "package", "control", "web-extension", "active-payload"].includes(kind))
+      activeReasons.push(`potentially-active-${kind}`);
+    const pending = [part];
+    const seen = new Set(pending);
+    const missing = /* @__PURE__ */ new Set();
+    const external = [];
+    for (let cursor = 0; cursor < pending.length; cursor++) {
+      context.signal?.throwIfAborted();
+      for (const edge of graph.outgoing(pending[cursor])) {
+        if (edge.external) external.push(edge);
+        else if (edge.targetPart !== null) {
+          if (!reader.has(edge.targetPart)) missing.add(edge.targetPart);
+          else if (!seen.has(edge.targetPart)) {
+            seen.add(edge.targetPart);
+            pending.push(edge.targetPart);
+          }
+        }
+      }
+    }
+    objects.push(
+      Object.freeze({
+        part,
+        kind,
+        contentType,
+        bytes: bytes.length,
+        sha256: digest2(bytes),
+        activeContent: activeReasons.length > 0,
+        activeReasons: Object.freeze(activeReasons),
+        owners: Object.freeze([...new Set(incoming.map((edge) => edge.owner))].sort()),
+        dependencies: Object.freeze(pending.slice(1).sort()),
+        missing: Object.freeze([...missing].sort()),
+        externalRelationships: Object.freeze(external)
+      })
+    );
+  }
+  return Object.freeze({
+    objects: Object.freeze(objects),
+    activationPerformed: false,
+    recursiveParsingPerformed: false
+  });
+}
+async function readObjects(input, context) {
+  const reader = await readPackage(input, context);
+  return inspectObjects(reader, readRelationshipGraph(reader, context.relationshipLimits), context);
+}
+async function extractObject(input, options, context) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).length !== 1 || !Object.hasOwn(options, "part") || !("value" in Object.getOwnPropertyDescriptor(options, "part")) || typeof options.part !== "string")
+    throw new OfficeError(
+      "invalid-value",
+      "Object extraction requires an exact package part.",
+      "usage"
+    );
+  const selected = partName(options.part, false);
+  const reader = await readPackage(input, context);
+  const graph = readRelationshipGraph(reader, context.relationshipLimits);
+  const inventory = inspectObjects(reader, graph, context);
+  const object = inventory.objects.find((row) => row.part === selected);
+  if (!object) throw new OfficeError("missing-binding", "Opaque object part is absent.", "index");
+  if (object.missing.length)
+    throw new OfficeError("missing-binding", "Opaque object dependency is absent.", "index");
+  const parts = [object.part, ...object.dependencies];
+  const dependencies = [...object.dependencies];
+  const edges = [];
+  for (const part of parts) {
+    context.signal?.throwIfAborted();
+    edges.push(...graph.outgoing(part));
+    const slash = part.lastIndexOf("/");
+    const rels = `${part.slice(0, slash + 1)}_rels/${part.slice(slash + 1)}.rels`;
+    if (reader.has(rels)) dependencies.push(rels);
+  }
+  const extracted = (part) => Object.freeze({
+    part,
+    name: `opaque-${digest2(new TextEncoder().encode(part))}.bin`,
+    bytes: reader.get(part)
+  });
+  return Object.freeze({
+    ...extracted(object.part),
+    dependencies: Object.freeze(dependencies.sort().map(extracted)),
+    relationships: Object.freeze(edges)
+  });
+}
+async function readFonts(input, context) {
+  const reader = await readPackage(input, context);
+  const graph = readRelationshipGraph(reader, context.relationshipLimits);
+  const inventory = inspectObjects(reader, graph, context);
+  const declarations = [];
+  for (const main of graph.outgoing("/").filter(
+    (edge) => !edge.external && relationships.some((namespace) => edge.type === `${namespace}/officeDocument`)
+  )) {
+    if (!main.targetPart || !reader.has(main.targetPart))
+      throw new OfficeError("missing-binding", "Presentation part is absent.", "index");
+    const root = parseXmlPart(reader.get(main.targetPart), context.xmlLimits).root;
+    const namespace = root.name.namespace;
+    if (![
+      "http://schemas.openxmlformats.org/presentationml/2006/main",
+      "http://purl.oclc.org/ooxml/presentationml/main"
+    ].includes(namespace))
+      continue;
+    for (const list of root.children.filter(
+      (node) => node.name.namespace === namespace && node.name.localName === "embeddedFontLst"
+    )) {
+      for (const node of list.children.filter(
+        (node2) => node2.name.namespace === namespace && node2.name.localName === "embeddedFont"
+      )) {
+        const font = node.children.find(
+          (child) => child.name.namespace === namespace && child.name.localName === "font"
+        );
+        const attr = (name) => font?.attributes.find(
+          (attribute) => attribute.name.namespace === "" && attribute.name.localName === name
+        )?.value ?? null;
+        const variants = node.children.filter(
+          (child) => child.name.namespace === namespace && ["regular", "bold", "italic", "boldItalic"].includes(child.name.localName)
+        ).map((child) => {
+          const relationshipId = child.attributes.find(
+            (attribute) => relationships.includes(attribute.name.namespace) && attribute.name.localName === "id"
+          )?.value ?? null;
+          const edge = graph.outgoing(main.targetPart).find(
+            (edge2) => edge2.id === relationshipId && !edge2.external && relationshipKinds[edge2.type] === "font"
+          );
+          const part = edge?.targetPart ?? null;
+          return Object.freeze({
+            variant: child.name.localName,
+            relationshipId,
+            part,
+            missing: part === null || !reader.has(part)
+          });
+        });
+        declarations.push(
+          Object.freeze({
+            part: main.targetPart,
+            typeface: attr("typeface"),
+            charset: attr("charset"),
+            pitchFamily: attr("pitchFamily"),
+            variants: Object.freeze(variants)
+          })
+        );
+      }
+    }
+  }
+  return Object.freeze({
+    declarations: Object.freeze(declarations),
+    fonts: Object.freeze(inventory.objects.filter((object) => object.kind === "font")),
+    installationPerformed: false
+  });
+}
+
+export {
+  openRetainedObjects,
+  stageRetainedObjects,
+  openRetainedObjectExtraction,
+  openRetainedFonts,
+  stageRetainedFonts,
+  readObjects,
+  extractObject,
+  readFonts
+};