@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,311 @@
+import {
+  noteAttribute,
+  openNotes
+} from "./chunk-Y6KHC3JB.js";
+import {
+  assertOutsideFields,
+  parseFields
+} from "./chunk-6EHVFKM7.js";
+import {
+  resolveDocxSelection
+} from "./chunk-LHDB4QO5.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  paragraphTextRun,
+  replaceParagraphContent
+} from "./chunk-GGOZXIGH.js";
+import {
+  findRelationshipPart
+} from "./chunk-4LXDJES2.js";
+import {
+  LocationIndex
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  removeNoteBodyXml,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  compatibilityContainers
+} from "./chunk-GZ2N24A2.js";
+import {
+  SelectionError,
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  relativePartTarget
+} from "./chunk-WAKYUXVQ.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/notes.ts
+function selectedNotes(state, operation, options) {
+  let notes = state.records.filter((n) => n.type === "normal").sort((a, b) => a.kind === b.kind ? a.id - b.id : a.kind === "footnote" ? -1 : 1);
+  if (options.select) {
+    const location = state.document.resolve(options.select);
+    if (location.value.range !== null) throw new DocxUsageError("Note operations require whole note or reference locations.");
+    const reference = state.references.find((ref) => ref.location?.token === location.token);
+    notes = notes.filter((n) => n.location?.token === location.token || reference?.kind === n.kind && reference.id === n.id);
+    if (options.kind) notes = notes.filter((n) => n.kind === options.kind);
+    if (!notes.length) throw new SelectionError("missing-selection");
+    if (reference && state.references.filter((ref) => ref.location?.token === location.token).length !== 1) throw new SelectionError("ambiguous-selection");
+    return { notes, ...reference ? { reference } : {} };
+  }
+  const kind = options.kind ?? (options.scope === "endnotes" ? "endnote" : options.scope === "footnotes" || operation !== "notes.list" && options.scope !== "all-stories" ? "footnote" : void 0);
+  if (kind) notes = notes.filter((n) => n.kind === kind);
+  if (options.note !== void 0) notes = notes.slice(options.note - 1, options.note);
+  if (!notes.length && operation !== "notes.list" && !options.allowEmpty) throw new SelectionError("missing-selection");
+  if (notes.length > 1 && operation !== "notes.list" && !options.all) throw new SelectionError("ambiguous-selection");
+  return { notes };
+}
+async function inspectDocumentNotes(input, request, context) {
+  closedRecord(request, ["operation", "options"]);
+  if (!["notes.list", "notes.get"].includes(request.operation)) throw new DocxUsageError("Expected a note read operation.");
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: request.operation, inputs: ["document"], options: request.options }, settings.budget);
+  request = { operation: request.operation, options: invocation.options };
+  const budget = settings.budget.lower(Object.fromEntries((request.options.limit ?? []).map((i) => [i.name, i.value])));
+  const state = await openNotes(input, { ...settings, budget });
+  const options = request.options;
+  const { notes } = selectedNotes(state, request.operation, options);
+  budget.check("matches", notes.length);
+  const data = {
+    items: notes.map((n) => {
+      if (!n.location) throw new UnsupportedEditError("Note body is outside the supported story profile.");
+      return { kind: n.kind, id: n.id, type: n.type, text: state.document.text({ select: n.location.token }).text, location: n.location, references: n.references.flatMap((ref) => ref.location ? [ref.location] : []) };
+    }),
+    separators: state.records.filter((n) => n.type !== "normal" && (!options.kind || n.kind === options.kind) && (options.scope !== "footnotes" || n.kind === "footnote") && (options.scope !== "endnotes" || n.kind === "endnote")).map((n) => ({ kind: n.kind, id: n.id, type: n.type })),
+    numbering: state.numbering
+  };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: request.operation, ok: true, data, affected: 0, locations: data.items.map((n) => n.location), warnings: [], errors: [] }) + "\n").length);
+  return data;
+}
+async function editDocumentNotes(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  if (!["notes.add", "notes.set", "notes.remove"].includes(request.operation)) throw new DocxUsageError("Expected a note edit operation.");
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: request.operation, inputs: [request.input?.path ?? "document"], options: request.options }, settings.budget);
+  request = { operation: request.operation, options: invocation.options, ...request.input ? { input: { ...request.input, stat: { ...request.input.stat } } } : {} };
+  const budget = settings.budget.lower(Object.fromEntries((request.options.limit ?? []).map((i) => [i.name, i.value])));
+  const state = await openNotes(input, { ...settings, budget });
+  const { archive, graph, editors, main, w, r } = state;
+  const memberNames = new Map(graph.parts.map((part) => [part.partname, part.name]));
+  const memberName = (part) => memberNames.get(part) ?? part.slice(1);
+  assertDocumentEditable(archive, { ...settings, budget });
+  const options = request.options;
+  const staged = /* @__PURE__ */ new Map();
+  const updates = [];
+  const removedRefs = /* @__PURE__ */ new Set();
+  const touched = /* @__PURE__ */ new Set();
+  let added;
+  const editPart = (part, initial) => {
+    const existing = editors.get(part);
+    if (existing) return existing;
+    const editor = new DocumentXmlEditor(archive.members.find((m) => m.name === memberName(part))?.bytes ?? new TextEncoder().encode(initial), {}, void 0, budget);
+    editors.set(part, editor);
+    return editor;
+  };
+  if (request.operation === "notes.add") {
+    const { kind, text = "" } = request.options;
+    const { paragraph, table, cell, section, select, scope } = request.options;
+    const locations = resolveDocxSelection(state.document, { operation: "fields.add", inputs: ["document"], options: { kind: "PAGE", dryRun: true, paragraph, table, cell, section, select, scope } });
+    if (locations.length !== 1) throw new SelectionError("missing-selection");
+    const before = locations[0];
+    if (before.value.story !== main + "#body" || before.value.range !== null) throw new UnsupportedEditError("Note references require a whole body paragraph.");
+    let parent = editors.get(main).root;
+    const ancestors = [parent];
+    for (const i of before.value.path) {
+      parent = parent.children[i];
+      ancestors.push(parent);
+    }
+    if (parent.localName !== "p" || ancestors.some((n) => n.namespace !== w || ["sdt", "ins", "del", "moveFrom", "moveTo", "fldSimple"].includes(n.localName))) throw new UnsupportedEditError("Note insertion requires an uncontrolled body paragraph.");
+    const owner = state.document.list("story", { scope: "body" })[0];
+    const body = ancestors[owner.value.path.length];
+    assertOutsideFields(parseFields(body, owner.value.path, budget, editors.get(main).compatibility.content), [...before.value.path, parent.children.length]);
+    const used = new Set(state.reservedIds.get(kind));
+    let id = 1;
+    while (used.has(id)) {
+      id++;
+      budget.charge("work", 1);
+    }
+    let part = state.parts.get(kind);
+    if (!part) {
+      part = graph.allocatePartName(main.slice(0, main.lastIndexOf("/") + 1) + kind + "s", ".xml");
+      state.parts.set(kind, part);
+      const relationshipPart = findRelationshipPart(graph, main, budget)?.partname ?? main.slice(0, main.lastIndexOf("/") + 1) + "_rels/" + main.slice(main.lastIndexOf("/") + 1) + ".rels";
+      const relNamespace = "http://schemas.openxmlformats.org/package/2006/relationships";
+      const rels = editPart(relationshipPart, `<Relationships xmlns="${relNamespace}"/>`);
+      rels.insertChildren(rels.root, `<Relationship xmlns="${relNamespace}" Id="${graph.allocateRelationshipId(main)}" Type="${r}/${kind}s" Target="${xmlValue(relativePartTarget(main, part))}"/>`);
+      const types = editPart("/[Content_Types].xml", "");
+      types.insertChildren(types.root, `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="${xmlValue(part)}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.${kind}s+xml"/>`);
+    }
+    const editor = editPart(part, `<w:${kind}s xmlns:w="${w}"/>`);
+    editor.insertChildren(editor.root, `<nt:${kind} xmlns:nt="${w}" nt:id="${id}"><nt:p><nt:r><nt:${kind}Ref/></nt:r>${paragraphTextRun(w, text)}</nt:p></nt:${kind}>`);
+    editors.get(main).insertChildren(parent, `<nt:r xmlns:nt="${w}"><nt:${kind}Reference nt:id="${id}"/></nt:r>`);
+    added = { kind, id, part };
+    touched.add(kind);
+    updates.push({ before, kind: "insert", noteKind: kind, id });
+  } else {
+    const { notes, reference } = selectedNotes(state, request.operation, options);
+    budget.check("matches", notes.length);
+    for (const note of notes) {
+      await budget.checkpoint();
+      if (!note.location) throw new UnsupportedEditError("Selected note is outside the editable story profile.");
+      if (request.operation === "notes.set") {
+        if (note.references.length > 1 && !options.shared) throw new SelectionError("ambiguous-selection");
+        const projected = activeXmlChildren(note.editor, budget), children = projected(note.node);
+        const containers = new Set(note.editor.compatibility[compatibilityContainers]);
+        if (children.some((n) => n.namespace !== w || n.localName !== "p") || note.node.children.some((n) => !containers.has(n) && (n.namespace !== w || n.localName !== "p")))
+          throw new UnsupportedEditError("Note text assignment cannot discard tables or opaque blocks; use scoped story editing.");
+        const replacements = children.map((p, i) => {
+          if (i && p.content.some((content) => content.kind !== "element" && (content.kind !== "text" || content.text.trim())))
+            throw new UnsupportedEditError("Note text assignment cannot discard XML annotations in removed paragraphs.");
+          const props = projected(p).find((n) => n.namespace === w && n.localName === "pPr");
+          const replacement = replaceParagraphContent(note.editor, p, props ? note.editor.sourceXml(props) : "", i === 0 ? options.text : "", budget);
+          if (i && p.children.some((n) => !["pPr", "r", "hyperlink"].includes(n.localName) || n.children.some((c) => ["footnoteRef", "endnoteRef"].includes(c.localName))))
+            throw new UnsupportedEditError("Note text assignment cannot remove annotation-bearing paragraphs.");
+          return i ? "" : replacement;
+        });
+        if (state.document.text({ select: note.location.token }).text === options.text && children.length === 1) continue;
+        children.forEach((p, i) => note.editor.replaceElement(p, replacements[i]));
+        if (!children.length) note.editor.insertChildren(note.node, `<nt:p xmlns:nt="${w}"><nt:r><nt:${note.kind}Ref/></nt:r>${paragraphTextRun(w, options.text)}</nt:p>`);
+        touched.add(note.kind);
+        updates.push({ before: note.location, kind: "replace", noteKind: note.kind, id: note.id });
+      } else {
+        let refs = reference ? [reference] : note.references;
+        if (options.reference !== void 0) refs = refs.slice(options.reference - 1, options.reference);
+        if (options.reference !== void 0 && !refs.length) throw new SelectionError("missing-selection");
+        if (refs.length > 1 && options.references !== "all" && (options.references === "single" || !options.all)) throw new SelectionError("ambiguous-selection");
+        if (refs.some((ref) => !ref.safe)) throw new UnsupportedEditError("Selected note references include unsupported or inactive content.");
+        for (const ref of refs) {
+          ref.editor.replaceElement(ref.node, "");
+          removedRefs.add(ref);
+        }
+        const annotation = (node) => {
+          budget.charge("work", 1);
+          return node.namespace === w && ["bookmarkStart", "commentRangeStart", "commentReference", "permStart"].includes(node.localName) || node.children.some(annotation);
+        };
+        const removeBody = note.references.every((ref) => removedRefs.has(ref)) && !annotation(note.node);
+        if (removeBody) note.editor[removeNoteBodyXml](note.node);
+        if (!refs.length && !removeBody) {
+          if (!options.allowEmpty) throw new SelectionError("missing-selection");
+          continue;
+        }
+        touched.add(note.kind);
+        updates.push({ before: reference?.location ?? note.location, kind: "remove", noteKind: note.kind, id: note.id, removed: removeBody });
+      }
+    }
+  }
+  for (const kind of touched) {
+    const part = state.parts.get(kind), editor = new DocumentXmlEditor(editors.get(part).serialize(), {}, void 0, budget);
+    editors.set(part, editor);
+    const used = new Set(state.reservedIds.get(kind));
+    if (added?.kind === kind) used.add(added.id);
+    const missing = [];
+    for (const [type, preferred] of [["separator", -1], ["continuationSeparator", 0]]) {
+      if (state.records.some((n) => n.kind === kind && n.type === type)) continue;
+      let id = preferred;
+      if (used.has(id)) {
+        id = 1;
+        while (used.has(id)) {
+          id++;
+          budget.charge("work", 1);
+        }
+      }
+      used.add(id);
+      missing.push(`<nt:${kind} xmlns:nt="${w}" nt:id="${id}" nt:type="${type}"><nt:p><nt:r><nt:${type}/></nt:r></nt:p></nt:${kind}>`);
+    }
+    if (missing.length) editor.insertChildren(editor.root, missing.join(""), editor.root.children[0]);
+    staged.set(memberName(part), editor.serialize());
+  }
+  for (const [part, editor] of editors) if (editor.dirtyNodes.length || !memberNames.has(part)) staged.set(memberName(part), editor.serialize());
+  const snapshot = () => ({ ...archive, members: [
+    ...archive.members.map((m) => ({ ...m, bytes: staged.get(m.name) ?? m.bytes })),
+    ...[...staged].filter(([name]) => !archive.members.some((m) => m.name === name)).map(([name, bytes]) => ({ name, bytes, directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") }))
+  ] });
+  const remapping = /* @__PURE__ */ new Map();
+  if (options.renumber === "document-order") {
+    const referenceOrder = /* @__PURE__ */ new Map();
+    const orderedParts = [...new Set(state.document.list("story", { scope: "all-stories" }).map((story) => story.value.part))];
+    for (const part of orderedParts) {
+      const editor = new DocumentXmlEditor(staged.get(memberName(part)) ?? graph.getPart(part).bytes, {}, void 0, budget);
+      const visit = (node) => {
+        budget.charge("work", 1);
+        if (node.namespace === w && ["footnoteReference", "endnoteReference"].includes(node.localName)) {
+          const kind = node.localName === "footnoteReference" ? "footnote" : "endnote";
+          const order = referenceOrder.get(kind) ?? [];
+          const id = Number(noteAttribute(node, "id"));
+          if (!order.includes(id)) order.push(id);
+          referenceOrder.set(kind, order);
+        }
+        node.children.forEach(visit);
+      };
+      visit(editor.root);
+    }
+    for (const kind of touched) {
+      if (state.references.some((ref) => ref.kind === kind && !removedRefs.has(ref) && !ref.safe)) throw new UnsupportedEditError("ID renumbering requires every reference to be editable.");
+      const part = state.parts.get(kind), noteEditor = new DocumentXmlEditor(staged.get(memberName(part)) ?? graph.getPart(part).bytes, {}, void 0, budget);
+      const nodes = activeXmlChildren(noteEditor, budget)(noteEditor.root).filter((n) => n.namespace === w && n.localName === kind);
+      const used = /* @__PURE__ */ new Set([...state.inactiveNotes.get(kind)?.keys() ?? [], ...nodes.filter((n) => (noteAttribute(n, "type") ?? "normal") !== "normal").map((n) => Number(noteAttribute(n, "id")))]);
+      const order = referenceOrder.get(kind) ?? [];
+      for (const n of nodes) if ((noteAttribute(n, "type") ?? "normal") === "normal" && !order.includes(Number(noteAttribute(n, "id")))) order.push(Number(noteAttribute(n, "id")));
+      let next = 1;
+      for (const id of order) {
+        while (used.has(next)) next++;
+        remapping.set(kind + ":" + id, next);
+        used.add(next++);
+        budget.charge("work", 1);
+      }
+      for (const n of nodes) if ((noteAttribute(n, "type") ?? "normal") === "normal") noteEditor.setAttribute(n, { namespace: w, localName: "id" }, String(remapping.get(kind + ":" + Number(noteAttribute(n, "id")))));
+      staged.set(memberName(part), noteEditor.serialize());
+    }
+    const editedMembers = new Set([...editors.keys()].map(memberName));
+    for (const member of snapshot().members) {
+      if (!editedMembers.has(member.name) || member.name.toLowerCase().endsWith(".rels") || member.name === "[Content_Types].xml") continue;
+      const editor = new DocumentXmlEditor(member.bytes, {}, void 0, budget);
+      const visit = (node) => {
+        budget.charge("work", 1);
+        if (node.namespace === w && ["footnoteReference", "endnoteReference"].includes(node.localName)) {
+          const kind = node.localName === "footnoteReference" ? "footnote" : "endnote";
+          const id = remapping.get(kind + ":" + Number(noteAttribute(node, "id")));
+          if (id !== void 0) editor.setAttribute(node, { namespace: w, localName: "id" }, String(id));
+        }
+        node.children.forEach(visit);
+      };
+      visit(editor.root);
+      if (editor.dirtyNodes.length) staged.set(member.name, editor.serialize());
+    }
+  }
+  const finalArchive = snapshot();
+  const index = new LocationIndex(finalArchive, settings.limits, main.slice(1), state.dialect, budget);
+  const changes = updates.map((update) => {
+    const id = remapping.get(update.noteKind + ":" + update.id) ?? update.id;
+    const entry = index.entries.find((e) => e.kind === "story" && e.part === state.parts.get(update.noteKind) && e.node?.localName === update.noteKind && Number(noteAttribute(e.node, "id")) === id);
+    const value = entry && { ...update.before.value, generation: 1, part: entry.part, story: entry.story, path: entry.path, range: null };
+    const after = update.removed || !entry || !value ? null : { kind: entry.kind, value, token: encodeGeneratedLocation(value), positions: entry.positions };
+    return { kind: update.kind, before: update.before, after };
+  });
+  const publication = { ...request.input ? { input: request.input } : {}, ...options.output === void 0 ? {} : { output: options.output }, ...options.inPlace === void 0 ? {} : { inPlace: options.inPlace }, ...options.force === void 0 ? {} : { force: options.force }, ...options.dryRun === void 0 ? {} : { dryRun: options.dryRun }, ...options.json === void 0 ? {} : { json: options.json } };
+  const prospective = { changed: changes.length > 0, changes, dryRun: options.dryRun ?? false, output: options.dryRun ? null : { path: options.output ?? request.input?.path ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: request.operation, ok: true, data: prospective, affected: changes.length, locations: changes.flatMap((c) => c.after ? [c.after] : []), warnings: [], errors: [] }) + "\n").length);
+  const result = await publishDocumentArchive(finalArchive, publication, { ...context, budget });
+  return { changed: changes.length > 0, changes, dryRun: options.dryRun ?? false, output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null };
+}
+
+export {
+  inspectDocumentNotes,
+  editDocumentNotes
+};

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

@@ -0,0 +1,47 @@
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/resource-limits.ts
+function resourceContext(context = {}) {
+  if (!context || typeof context !== "object" || Array.isArray(context))
+    throw new OfficeError("invalid-type", "Expected a resource context.", "usage");
+  for (const key of Reflect.ownKeys(context)) {
+    if (!("value" in Object.getOwnPropertyDescriptor(context, key)))
+      throw new OfficeError("invalid-value", "Resource context requires stored data.", "usage");
+  }
+  for (const limits of [context.limits, context.archiveLimits, context.xmlLimits, context.relationshipLimits]) {
+    if (limits === void 0) continue;
+    if (!limits || typeof limits !== "object" || Array.isArray(limits) || Reflect.ownKeys(limits).some((key) => !("value" in Object.getOwnPropertyDescriptor(limits, key))))
+      throw new OfficeError("invalid-value", "Limits require stored data.", "usage");
+  }
+  const resolved = {
+    ...context,
+    limits: { maxBytes: Infinity, maxReads: Infinity, chunkBytes: 65536, ...context.limits },
+    archiveLimits: {
+      maxArchiveBytes: Infinity,
+      maxEntryBytes: Infinity,
+      maxTotalBytes: Infinity,
+      maxMembers: Infinity,
+      maxPathBytes: Infinity,
+      maxDepth: Infinity,
+      maxPaxBytes: Infinity,
+      maxTextBytes: Infinity,
+      chunkSize: 65536,
+      ...context.archiveLimits
+    },
+    xmlLimits: { maxBytes: Infinity, maxNodes: Infinity, maxDepth: Infinity, ...context.xmlLimits },
+    relationshipLimits: { maxBytes: Infinity, maxParts: Infinity, maxRelationships: Infinity, ...context.relationshipLimits }
+  };
+  for (const limits of [resolved.limits, resolved.archiveLimits, resolved.xmlLimits, resolved.relationshipLimits]) {
+    for (const [key, value] of Object.entries(limits)) {
+      if (value !== Infinity && !Number.isSafeInteger(value) || value < 1 || (key === "chunkSize" || key === "chunkBytes") && !Number.isSafeInteger(value))
+        throw new OfficeError("invalid-value", "Limits must be positive safe integers or unlimited.", "usage");
+    }
+  }
+  return resolved;
+}
+
+export {
+  resourceContext
+};

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

@@ -0,0 +1,131 @@
+import {
+  readBinary
+} from "./chunk-TL3KDYEM.js";
+import {
+  asciiKey,
+  partName
+} from "./chunk-XXFHTGV2.js";
+import {
+  resourceContext
+} from "./chunk-FOO3AXFK.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+import {
+  createZipCodec
+} from "./chunk-XIC45QAG.js";
+
+// packages/safe-bash-presentation-engine/src/package-reader.ts
+var zip = createZipCodec(void 0, {
+  zip64: true,
+  rejectDuplicateNames: true,
+  utcDates: true
+});
+async function readPackage(input, settings = {}) {
+  const context = resourceContext(settings);
+  if (!context?.limits) {
+    throw new OfficeError("invalid-type", "Explicit byte limits are required.", "usage");
+  }
+  const limits = { ...context?.archiveLimits };
+  const keys = [
+    "maxArchiveBytes",
+    "maxEntryBytes",
+    "maxTotalBytes",
+    "maxMembers",
+    "maxPathBytes",
+    "maxDepth",
+    "maxPaxBytes",
+    "maxTextBytes",
+    "chunkSize"
+  ];
+  if (Object.keys(limits).some((key) => !keys.some((known) => known === key)) || keys.some((key) => limits[key] !== Infinity && !Number.isSafeInteger(limits[key]) || limits[key] < 1) || limits.chunkSize < 512 || limits.chunkSize > 1024 * 1024) {
+    throw new OfficeError("invalid-value", "Invalid package byte limits.", "usage");
+  }
+  const bytes = await readBinary(input, context, {
+    maxBytes: Math.min(context.limits.maxBytes, limits.maxArchiveBytes)
+  });
+  const signal = context.signal ?? new AbortController().signal;
+  const parts = /* @__PURE__ */ new Map();
+  const names = [];
+  let entryCount = 0;
+  try {
+    const archive = await zip.readZipArchive(bytes, limits, signal);
+    entryCount = archive.entries.length;
+    const identities = /* @__PURE__ */ new Set();
+    const parents = /* @__PURE__ */ new Set();
+    const entries = archive.entries.map((entry) => {
+      if (entry.symlink)
+        throw new OfficeError("unsafe-path", "Invalid package part name.", "index");
+      const name = partName(entry.directory && entry.name.endsWith("/") ? entry.name.slice(0, -1) : entry.name, true);
+      const key = asciiKey(name);
+      if (identities.has(key) || !entry.directory && parents.has(key)) {
+        throw new OfficeError("invalid-opc", "Colliding package part names.", "index");
+      }
+      let parent = key.slice(0, key.lastIndexOf("/"));
+      while (parent) {
+        if (identities.has(parent)) {
+          throw new OfficeError("invalid-opc", "Colliding package part names.", "index");
+        }
+        parents.add(parent);
+        parent = parent.slice(0, parent.lastIndexOf("/"));
+      }
+      if (entry.directory) {
+        parents.add(key);
+        return { entry, name: null, key: null };
+      }
+      identities.add(key);
+      return { entry, name, key };
+    });
+    for (const { entry, name, key } of entries) {
+      const data = new Uint8Array(entry.size);
+      let offset = 0;
+      for await (const chunk of zip.decodeZipEntry(entry, limits, signal)) {
+        if (chunk.length > data.length - offset) {
+          throw new OfficeError("invalid-archive", "Invalid package entry size.", "parse");
+        }
+        data.set(chunk, offset);
+        offset += chunk.length;
+      }
+      if (name !== null && key !== null) {
+        names.push(name);
+        parts.set(key, data);
+      }
+    }
+    signal.throwIfAborted();
+  } catch (error) {
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "parse");
+    if (error instanceof OfficeError) throw error;
+    if (error instanceof Error && "code" in error && error.code === "resource-limit") {
+      throw new OfficeError("resource-limit", "Package byte limit exceeded.", "parse");
+    }
+    throw new OfficeError("invalid-archive", "Invalid package archive.", "parse");
+  }
+  return Object.freeze({
+    names: Object.freeze(names),
+    entryCount,
+    byteLength(partname) {
+      const data = parts.get(asciiKey(partName(partname, false)));
+      if (!data) throw new OfficeError("missing-binding", "Package member is absent.", "index");
+      return data.length;
+    },
+    has(partname) {
+      return parts.has(asciiKey(partName(partname, false)));
+    },
+    get(partname) {
+      const data = parts.get(asciiKey(partName(partname, false)));
+      if (!data) throw new OfficeError("missing-binding", "Package member is absent.", "index");
+      return new Uint8Array(data);
+    },
+    relsXmlFor(partname) {
+      const owner = partname === "/" ? "/" : partName(partname, false);
+      const slash = owner.lastIndexOf("/");
+      const name = `${owner.slice(0, slash + 1)}_rels/${owner.slice(slash + 1)}.rels`;
+      const data = parts.get(asciiKey(name));
+      return data ? new Uint8Array(data) : null;
+    }
+  });
+}
+
+export {
+  readPackage
+};