@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,241 @@
+import {
+  imageMetadata
+} from "./chunk-UPXFSGQG.js";
+import {
+  readShapeGeometry
+} from "./chunk-TGHQGJNR.js";
+import {
+  attr,
+  child
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError,
+  readSelectionIndex
+} from "./chunk-CKEODJVT.js";
+import {
+  readPackage
+} from "./chunk-FRZ5P5AB.js";
+import {
+  readBinary
+} from "./chunk-TL3KDYEM.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/images.ts
+import { sha1 } from "@noble/hashes/legacy.js";
+var p = [
+  "http://schemas.openxmlformats.org/presentationml/2006/main",
+  "http://purl.oclc.org/ooxml/presentationml/main"
+];
+var a = [
+  "http://schemas.openxmlformats.org/drawingml/2006/main",
+  "http://purl.oclc.org/ooxml/drawingml/main"
+];
+var r = [
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  "http://purl.oclc.org/ooxml/officeDocument/relationships"
+];
+var svg = "http://schemas.microsoft.com/office/drawing/2016/SVG/main";
+var mc = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+var scopes = [
+  "slides",
+  "layouts",
+  "masters",
+  "notes",
+  "notes-master",
+  "handout-master",
+  "shared"
+];
+function descendants(node) {
+  return node.children.flatMap((x) => [x, ...descendants(x)]);
+}
+function validateImageSelectionOptions(options) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some(
+    (x) => !["scope", "slide", "image", "select", "unique"].includes(x)
+  ) || options.scope !== void 0 && !scopes.includes(options.scope) || options.unique !== void 0 && typeof options.unique !== "boolean" || options.select !== void 0 && (typeof options.select !== "string" || !options.select.length))
+    throw new OfficeError("invalid-value", "Invalid image selection options.", "usage");
+  for (const key of ["slide", "image"])
+    if (options[key] !== void 0 && (!Number.isSafeInteger(options[key]) || options[key] < 1))
+      throw new OfficeError(
+        "invalid-value",
+        "Image positions require positive safe integers.",
+        "usage"
+      );
+  if (options.select && (options.scope !== void 0 || options.slide !== void 0 || options.image !== void 0))
+    throw new SelectionError("invalid-selection");
+}
+async function readImages(input, options, context) {
+  validateImageSelectionOptions(options);
+  const source = await readBinary(input, context);
+  const reader = await readPackage(source, context);
+  const index = await readSelectionIndex(source, context);
+  const selected = options.select ? index.select({ token: options.select }) : void 0;
+  if (selected && options.scope !== void 0 && options.scope !== "shared" && selected.some((x) => x.scope !== options.scope))
+    throw new SelectionError("invalid-selection");
+  const relationships = index.inventory.relationships;
+  const related = (owner, type) => relationships.filter((x) => x.owner === owner && r.some((ns) => x.type === `${ns}/${type}`) && !x.external).map((x) => x.targetPart);
+  const owners = index.parts.filter(
+    (owner) => owner.scope !== "shared" && scopes.includes(owner.scope) && (selected ? selected.some((x) => x.part === owner.part) : options.scope === "shared" || owner.scope === (options.scope ?? "slides"))
+  );
+  owners.sort((left, right) => {
+    const leftSlide = index.slides.findIndex((x) => x.part === left.part);
+    const rightSlide = index.slides.findIndex((x) => x.part === right.part);
+    if (leftSlide >= 0 || rightSlide >= 0)
+      return (leftSlide < 0 ? Number.MAX_SAFE_INTEGER : leftSlide) - (rightSlide < 0 ? Number.MAX_SAFE_INTEGER : rightSlide);
+    return left.part < right.part ? -1 : left.part > right.part ? 1 : 0;
+  });
+  const occurrences = [];
+  for (const owner of owners) {
+    context.signal?.throwIfAborted();
+    const slidePositions = index.inventory.slides.filter(
+      (slide) => slide.part === owner.part || slide.layout === owner.part || slide.master === owner.part || related(slide.part, "notesSlide").some(
+        (notes) => notes === owner.part || notes && related(notes, "notesMaster").includes(owner.part)
+      )
+    ).map((x) => x.position);
+    if (options.slide !== void 0 && !slidePositions.includes(options.slide)) continue;
+    const root = parseXmlPart(reader.get(owner.part), context.xmlLimits).root;
+    let picturePosition = 0;
+    let otherPosition = 0;
+    let referencePosition = 0;
+    const positions = /* @__PURE__ */ new Map();
+    const visit = (node, shape, fill, background, fallback) => {
+      if (p.includes(node.name.namespace) && ["pic", "sp", "cxnSp", "graphicFrame", "grpSp"].includes(node.name.localName))
+        shape = node;
+      if (p.includes(node.name.namespace) && node.name.localName === "bg") {
+        background = true;
+        shape = null;
+      }
+      if ((a.includes(node.name.namespace) || p.includes(node.name.namespace)) && node.name.localName === "blipFill")
+        fill = node;
+      if (node.name.namespace === mc && node.name.localName === "Fallback") fallback = true;
+      const isSvg = node.name.namespace === svg && node.name.localName === "svgBlip";
+      if (isSvg || a.includes(node.name.namespace) && node.name.localName === "blip") {
+        const nv = shape?.children.find(
+          (x) => p.includes(x.name.namespace) && ["nvPicPr", "nvSpPr", "nvCxnSpPr", "nvGraphicFramePr", "nvGrpSpPr"].includes(
+            x.name.localName
+          )
+        );
+        const identity = nv && child(nv, "cNvPr");
+        const shapeId = identity ? attr(identity, "id") ?? null : null;
+        const bindings = node.attributes.filter(
+          (x) => r.includes(x.name.namespace) && ["embed", "link"].includes(x.name.localName)
+        );
+        const cropNode = fill?.children.find(
+          (x) => a.includes(x.name.namespace) && x.name.localName === "srcRect"
+        );
+        const fraction = (key) => {
+          const raw = cropNode && attr(cropNode, key);
+          if (raw === void 0) return 0;
+          const trimmed = raw.trim();
+          const percent = trimmed.endsWith("%");
+          const value = percent ? trimmed.slice(0, -1) : trimmed;
+          const unsigned = value.startsWith("-") || value.startsWith("+") ? value.slice(1) : value;
+          const components = unsigned.split(".");
+          if (components.length > (percent ? 2 : 1) || components.some(
+            (component) => !component || [...component].some((c) => !"0123456789".includes(c))
+          ) || !Number.isFinite(Number(value)) || (percent ? Math.abs(Number(value)) > Number.MAX_SAFE_INTEGER : !Number.isSafeInteger(Number(value))))
+            throw new OfficeError("invalid-xml", "Invalid image crop metadata.", "index");
+          return Number(value) / (percent ? 100 : 1e5);
+        };
+        const positionOwner = shape?.name.localName === "pic" && shapeId !== null ? shapeId : shape ?? fill ?? node;
+        let currentPosition = positions.get(positionOwner);
+        if (currentPosition === void 0) {
+          currentPosition = shape?.name.localName === "pic" ? ++picturePosition : ++otherPosition;
+          positions.set(positionOwner, currentPosition);
+        }
+        for (const binding of bindings) {
+          const referenceId = ++referencePosition;
+          const edge = relationships.find((x) => x.owner === owner.part && x.id === binding.value);
+          if (!edge || !r.some((ns) => edge.type === `${ns}/image`))
+            throw new OfficeError(
+              "missing-binding",
+              "Image relationship is absent or has the wrong type.",
+              "index"
+            );
+          const media2 = edge.targetPart === null ? void 0 : index.inventory.parts.find((x) => x.part === edge.targetPart);
+          if (!edge.external && !media2)
+            throw new OfficeError("missing-binding", "Image media part is absent.", "index");
+          if (options.image !== void 0 && (shape?.name.localName !== "pic" || options.image !== currentPosition) || selected && !selected.some(
+            (x) => x.part === owner.part && (x.kind !== "object" || x.id === shapeId)
+          ))
+            continue;
+          const hasSvg = descendants(node).some(
+            (x) => x.name.namespace === svg && x.name.localName === "svgBlip"
+          );
+          occurrences.push({
+            id: `${owner.part}#image-${referenceId}-${binding.name.localName}`,
+            location: index.objects.find((x) => x.part === owner.part && x.id === shapeId)?.location ?? owner.location,
+            sourcePart: owner.part,
+            relationshipId: edge.id,
+            target: edge.target,
+            external: edge.external,
+            mediaPart: edge.targetPart,
+            shapeId,
+            shapeName: identity ? attr(identity, "name") ?? null : null,
+            scope: owner.scope,
+            inheritedBy: ["layouts", "masters", "notes-master"].includes(owner.scope) ? slidePositions : [],
+            kind: background ? "background" : shape?.name.localName === "pic" ? "picture" : "fill",
+            role: isSvg ? "svg" : fallback || hasSvg ? "fallback" : "primary",
+            position: currentPosition,
+            crop: {
+              left: fraction("l"),
+              top: fraction("t"),
+              right: fraction("r"),
+              bottom: fraction("b")
+            },
+            altText: identity ? attr(identity, "descr") ?? null : null,
+            title: identity ? attr(identity, "title") ?? null : null,
+            geometry: shape ? readShapeGeometry(root, shape) : null,
+            sha256: media2?.sha256 ?? null,
+            contentType: media2?.contentType ?? null,
+            bytes: media2?.bytes ?? null
+          });
+        }
+      }
+      for (const next of node.children) visit(next, shape, fill, background, fallback);
+    };
+    visit(root, null, null, false, false);
+  }
+  const media = [];
+  for (const part of [
+    ...new Set(occurrences.flatMap((x) => x.mediaPart ? [x.mediaPart] : []))
+  ].sort()) {
+    const metadata = index.inventory.parts.find((x) => x.part === part);
+    const ids = occurrences.filter((x) => x.mediaPart === part).map((x) => x.id);
+    const existing = options.unique ? media.find((x) => x.sha256 === metadata.sha256) : void 0;
+    if (existing) {
+      const contentTypes = [.../* @__PURE__ */ new Set([...existing.contentTypes, metadata.contentType])];
+      const offset = media.indexOf(existing);
+      media[offset] = {
+        ...existing,
+        ...contentTypes.length > 1 ? { pixelWidth: null, pixelHeight: null, dpiX: 72, dpiY: 72 } : {},
+        contentTypes,
+        contentType: contentTypes.length === 1 ? contentTypes[0] : null,
+        parts: [...existing.parts, part],
+        occurrenceIds: [...existing.occurrenceIds, ...ids]
+      };
+    } else
+      media.push({
+        parts: [part],
+        sha1: Array.from(sha1(reader.get(part)), (byte) => byte.toString(16).padStart(2, "0")).join(
+          ""
+        ),
+        contentTypes: [metadata.contentType],
+        sha256: metadata.sha256,
+        contentType: metadata.contentType,
+        bytes: metadata.bytes,
+        occurrenceIds: ids,
+        ...imageMetadata(reader.get(part), metadata.contentType ?? "")
+      });
+  }
+  return { occurrences, media };
+}
+
+export {
+  validateImageSelectionOptions,
+  readImages
+};

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

@@ -0,0 +1,385 @@
+import {
+  relationshipXmlIds,
+  relationshipXmlRows
+} from "./chunk-2PSVE7I5.js";
+import {
+  validatePackageDialect
+} from "./chunk-MG7AJD5E.js";
+import {
+  asciiKey,
+  invalidPackage,
+  normalizePartName,
+  relationshipOwner,
+  relativePartTarget,
+  resolvePartTarget
+} from "./chunk-WAKYUXVQ.js";
+import {
+  InvalidPackageError,
+  UnsupportedProfileError,
+  isXmlContentType,
+  parseDocumentXml,
+  parseDocumentXmlAsync,
+  parseMediaType,
+  xml
+} from "./chunk-MWAAMNAM.js";
+import {
+  CancellationError,
+  DocumentBudget,
+  InputTypeError,
+  InvalidValueError,
+  ResourceLimitError,
+  archiveSettings,
+  documentByteView,
+  documentSession,
+  documentXmlCache,
+  readArchive
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/package.ts
+var contentTypesNamespace = "http://schemas.openxmlformats.org/package/2006/content-types";
+var relationshipContentType = "application/vnd.openxmlformats-package.relationships+xml";
+function assertOpcXmlDeclaration(root, part, budget) {
+  if (!root.declaration) return;
+  budget.charge("work", root.declaration.length);
+  budget.charge("retainedBytes", root.declaration.length * 2);
+  const declaration = root.declaration.toUpperCase();
+  if (declaration.includes("UTF-16LE") || declaration.includes("UTF-16BE"))
+    throw new InvalidPackageError("OPC XML declarations must name UTF-8 or UTF-16.", part, "/", "opc-xml-encoding");
+}
+function metadataXml(part, bytes, budget, parsed, visit) {
+  let location = "/";
+  let index = 0;
+  try {
+    xml(bytes, (tag, depth) => {
+      location = `/${tag.localName}[${++index}]`;
+      visit(tag, depth);
+    }, true, budget, parsed.get(bytes));
+  } catch (error) {
+    if (error instanceof InvalidPackageError)
+      throw new InvalidPackageError(error.message, part, location, error.diagnosticCode);
+    throw error;
+  }
+}
+function attributes(tag, allowed) {
+  for (const attribute of tag.attributes) {
+    if (attribute.namespace === "http://www.w3.org/2000/xmlns/") continue;
+    if (attribute.namespace || !allowed.includes(attribute.localName)) invalidPackage();
+  }
+}
+function required(tag, name, allowEmpty = false) {
+  const value = tag.attributes.find((attribute) => attribute.name === name);
+  if (!value || value.namespace || !allowEmpty && !value.value) return invalidPackage();
+  return value.value;
+}
+var DocumentPackage = class {
+  parts;
+  defaults;
+  overrides;
+  byName = /* @__PURE__ */ new Map();
+  edges = /* @__PURE__ */ new Map();
+  reservedIds = /* @__PURE__ */ new Map();
+  reservedNames = /* @__PURE__ */ new Set();
+  limits;
+  remainingMembers;
+  #budget;
+  constructor(archive, limits, budget = new DocumentBudget(), parsed = /* @__PURE__ */ new Map()) {
+    this.#budget = budget;
+    budget.check("zipEntries", archive.members.length);
+    budget.charge("retainedBytes", archive.members.length * 1024);
+    budget.charge("work", archive.members.reduce((sum, member) => sum + member.name.length * 8, 0));
+    this.limits = { ...limits };
+    this.remainingMembers = limits.maxMembers - archive.members.length;
+    const members = /* @__PURE__ */ new Map();
+    const names = /* @__PURE__ */ new Map();
+    for (const member of archive.members) {
+      if (member.directory) continue;
+      const partname = asciiKey(member.name) === "[content_types].xml" ? "/[Content_Types].xml" : normalizePartName("/" + member.name);
+      const key = asciiKey(partname);
+      const collision = asciiKey(partname.normalize("NFC"));
+      if (members.has(key) || this.reservedNames.has(collision)) invalidPackage();
+      members.set(key, member);
+      names.set(key, partname);
+      this.reservedNames.add(collision);
+    }
+    for (const key of this.reservedNames) {
+      const segments = key.split("/");
+      segments.pop();
+      while (segments.length > 1) {
+        if (this.reservedNames.has(segments.join("/"))) invalidPackage();
+        segments.pop();
+      }
+    }
+    const types = members.get("/[content_types].xml");
+    if (!types || !members.has("/_rels/.rels")) invalidPackage();
+    const defaults = /* @__PURE__ */ new Map();
+    const overrides = /* @__PURE__ */ new Map();
+    const defaultValues = [];
+    const overrideValues = [];
+    metadataXml(
+      "/[Content_Types].xml",
+      types.bytes,
+      budget,
+      parsed,
+      (tag, depth) => {
+        if (tag.namespace !== contentTypesNamespace) invalidPackage();
+        if (depth === 1) {
+          assertOpcXmlDeclaration(tag, "/[Content_Types].xml", budget);
+          if (tag.localName !== "Types") invalidPackage();
+          attributes(tag, []);
+          return;
+        }
+        if (depth !== 2 || tag.localName !== "Default" && tag.localName !== "Override") invalidPackage();
+        const override = tag.localName === "Override";
+        attributes(tag, [override ? "PartName" : "Extension", "ContentType"]);
+        const content_type = required(tag, "ContentType");
+        budget.charge("work", content_type.length);
+        parseMediaType(content_type);
+        const name = required(tag, override ? "PartName" : "Extension");
+        if (override) {
+          const partname = normalizePartName(name);
+          const key = asciiKey(partname);
+          if (!members.has(key) || overrides.has(key) || key === "/[content_types].xml")
+            invalidPackage();
+          overrides.set(key, content_type);
+          overrideValues.push(Object.freeze({ partname, content_type }));
+        } else {
+          for (let index = 0; index < name.length; index++) {
+            const char = name[index];
+            if (char === "%") {
+              const digits = name.slice(index + 1, index + 3);
+              if (digits.length !== 2 || [...digits].some((digit) => !"0123456789abcdefABCDEF".includes(digit)))
+                invalidPackage();
+              index += 2;
+            } else if (!(char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9" || "!$&'()*+,:=@-_~".includes(char)))
+              invalidPackage();
+          }
+          const key = asciiKey(name);
+          if (defaults.has(key)) invalidPackage();
+          defaults.set(key, content_type);
+          defaultValues.push(Object.freeze({ extension: name, content_type }));
+        }
+      }
+    );
+    this.defaults = Object.freeze(defaultValues);
+    this.overrides = Object.freeze(overrideValues);
+    const parts = [];
+    for (const [key, member] of members) {
+      if (key === "/[content_types].xml") continue;
+      const filename = key.slice(key.lastIndexOf("/") + 1);
+      const extension = filename.includes(".") ? filename.slice(filename.lastIndexOf(".") + 1) : "";
+      const content_type = overrides.get(key) ?? defaults.get(extension);
+      if (!content_type) invalidPackage();
+      const part = Object.freeze({ ...member, partname: names.get(key), content_type });
+      parts.push(part);
+      this.byName.set(key, part);
+    }
+    this.parts = Object.freeze(parts);
+    for (const part of parts) {
+      const type = parseMediaType(part.content_type);
+      if (type !== "application/vnd.openxmlformats-package.core-properties+xml" && type !== "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml") continue;
+      const root = parsed.get(part.bytes) ?? parseDocumentXml(part.bytes, {}, budget).root;
+      assertOpcXmlDeclaration(root, part.partname, budget);
+      if (type !== "application/vnd.openxmlformats-package.core-properties+xml") continue;
+      xml(part.bytes, (tag) => {
+        budget.charge("work", tag.attributes.length);
+        const mce = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+        if (tag.namespace === mce || tag.attributes.some((attribute) => attribute.namespace === mce))
+          throw new InvalidPackageError("Core properties cannot contain markup compatibility elements or attributes.", part.partname, "/", "core-properties-mce");
+      }, false, budget, root);
+    }
+    for (const part of parts) {
+      const owner = relationshipOwner(part.partname);
+      if (owner === null) {
+        if (asciiKey(part.content_type) === relationshipContentType) invalidPackage();
+        continue;
+      }
+      if (asciiKey(part.content_type) !== relationshipContentType) invalidPackage();
+      if (owner !== "/" && (!this.byName.has(asciiKey(owner)) || relationshipOwner(owner) !== null))
+        invalidPackage();
+      const relationships = [];
+      const root = parsed.get(part.bytes) ?? parseDocumentXml(part.bytes, {}, budget).root;
+      assertOpcXmlDeclaration(root, part.partname, budget);
+      const ids = relationshipXmlIds(root, budget);
+      for (const { rId, reltype, target_ref, is_external } of relationshipXmlRows(root, budget, part.partname)) {
+        ids.add(rId);
+        try {
+          const resolved = is_external ? null : resolvePartTarget(owner, target_ref);
+          const target = resolved ? this.byName.get(asciiKey(resolved.partname)) : void 0;
+          if (!is_external && (!target || relationshipOwner(target.partname) !== null)) invalidPackage();
+          relationships.push(Object.freeze({
+            rId,
+            reltype,
+            target_ref,
+            is_external,
+            fragment: resolved?.fragment ?? null,
+            get target_part() {
+              if (!target) throw new InvalidValueError("External relationships have no package target.");
+              return target;
+            }
+          }));
+        } catch (error) {
+          if (error instanceof InvalidPackageError)
+            throw new InvalidPackageError(error.message, part.partname, `/Relationship[${relationships.length + 1}]`, error.diagnosticCode);
+          throw error;
+        }
+      }
+      this.edges.set(asciiKey(owner), Object.freeze(relationships));
+      this.reservedIds.set(asciiKey(owner), ids);
+    }
+  }
+  getPart(partname) {
+    if (typeof partname !== "string") throw new InputTypeError("Expected a part name.");
+    if ((partname.length - 1) / 3 > this.limits.maxPathBytes) throw new ResourceLimitError("Package part path limit exceeded.");
+    this.#budget.charge("work", partname.length);
+    const name = normalizePartName(partname);
+    if (new TextEncoder().encode(name.slice(1)).length > this.limits.maxPathBytes) throw new ResourceLimitError("Package part path limit exceeded.");
+    const part = this.byName.get(asciiKey(name));
+    if (!part) throw new InvalidValueError("Package part was not found.");
+    return part;
+  }
+  relationships(owner) {
+    this.#budget.charge("work", 1);
+    const key = owner === "/" ? "/" : asciiKey(this.getPart(owner).partname);
+    if (owner !== "/" && relationshipOwner(owner) !== null)
+      throw new InvalidValueError("Relationships cannot own relationships.");
+    return this.edges.get(key) ?? [];
+  }
+  *iterParts() {
+    const visited = /* @__PURE__ */ new Set();
+    const stack = [...this.relationships("/")].reverse();
+    while (stack.length) {
+      this.#budget.charge("work", 1);
+      const edge = stack.pop();
+      if (edge.is_external || visited.has(edge.target_part)) continue;
+      const part = edge.target_part;
+      visited.add(part);
+      yield part;
+      const children = this.relationships(part.partname);
+      for (let index = children.length - 1; index >= 0; index--) stack.push(children[index]);
+    }
+  }
+  allocateRelationshipId(owner) {
+    const edges = this.relationships(owner);
+    const key = owner === "/" ? "/" : asciiKey(this.getPart(owner).partname);
+    const ids = this.reservedIds.get(key) ?? new Set(edges.map((edge) => edge.rId));
+    let index = 1;
+    while (ids.has(`rId${index}`)) {
+      this.#budget.charge("work", 1);
+      index++;
+    }
+    this.#budget.charge("retainedBytes", 2 * (3 + String(index).length));
+    const id = `rId${index}`;
+    ids.add(id);
+    this.reservedIds.set(key, ids);
+    return id;
+  }
+  allocatePartName(prefix, suffix) {
+    if (typeof prefix !== "string" || typeof suffix !== "string")
+      throw new InputTypeError("Expected a part name prefix and suffix.");
+    if (this.remainingMembers <= 0 || prefix.length + suffix.length > this.limits.maxPathBytes)
+      throw new ResourceLimitError("Package part reservation limit exceeded.");
+    for (let index = 1; index <= this.reservedNames.size + 1; index++) {
+      this.#budget.charge("work", prefix.length + suffix.length + 1);
+      const name = normalizePartName(`${prefix}${index}${suffix}`);
+      if (relativePartTarget("/", name).length > this.limits.maxPathBytes || name.split("/").length - 1 > this.limits.maxDepth)
+        throw new ResourceLimitError("Package part path limit exceeded.");
+      if (relationshipOwner(name) !== null)
+        throw new InvalidValueError("Cannot allocate a relationship part name.");
+      const key = asciiKey(name.normalize("NFC"));
+      if (this.reservedNames.has(key)) continue;
+      for (const existing of this.reservedNames) {
+        this.#budget.charge("work", existing.length + key.length);
+        if (existing.startsWith(key + "/") || key.startsWith(existing + "/"))
+          throw new InvalidValueError("Allocated part name conflicts with a package part.");
+      }
+      this.#budget.charge("retainedBytes", key.length * 2);
+      this.reservedNames.add(key);
+      this.remainingMembers--;
+      return name;
+    }
+    throw new InvalidValueError("No package part name is available.");
+  }
+};
+
+// packages/safe-bash-docx-engine/src/admission.ts
+var documentTypes = Object.freeze({
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml",
+  dotx: "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml"
+});
+var macroTypes = /* @__PURE__ */ new Set([
+  "application/vnd.ms-word.document.macroenabled.main+xml",
+  "application/vnd.ms-word.template.macroenabledtemplate.main+xml",
+  "application/vnd.ms-office.vbaproject",
+  "application/vnd.ms-word.vbadata+xml"
+]);
+var officeRelationships = /* @__PURE__ */ new Set([
+  "http://purl.oclc.org/ooxml/officeDocument/relationships/officeDocument",
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"
+]);
+async function readDocumentArchive(input, context) {
+  input = documentByteView(input);
+  const settings = archiveSettings(context);
+  if (settings[documentSession]) return settings[documentSession].read(input);
+  const { limits, signal, budget } = settings;
+  if (signal.aborted) throw new CancellationError("Document admission cancelled.");
+  if (input instanceof Uint8Array && input.length >= 8 && [208, 207, 17, 224, 161, 177, 26, 225].every((value, index) => input[index] === value)) {
+    if (input.length > limits.maxArchiveBytes)
+      throw new ResourceLimitError("Archive byte budget exceeded.");
+    throw new UnsupportedProfileError(
+      "Compound binary Word or encrypted Office containers are unsupported."
+    );
+  }
+  const archive = await readArchive(input, { limits, signal, budget });
+  budget[documentXmlCache].entries ??= /* @__PURE__ */ new Map();
+  budget[documentXmlCache].admitted ??= /* @__PURE__ */ new WeakSet();
+  return admitDocumentArchive(archive, { limits, signal, budget }, input.length);
+}
+var admittedXml = /* @__PURE__ */ Symbol("admitted-xml");
+async function admitDocumentArchive(archive, context, inputBytes = 0, parsed = /* @__PURE__ */ new Map()) {
+  const { limits, signal, budget } = archiveSettings(context);
+  for (const member of archive.members) budget[documentXmlCache].admitted?.add(member.bytes);
+  const total = archive.members.reduce((sum, member) => sum + member.bytes.length, 0);
+  if (inputBytes * 4 + total * 16 + archive.members.length * 1024 + 65536 > limits.maxRetainedBytes)
+    throw new ResourceLimitError("Document admission retained byte budget exceeded.");
+  for (const member of archive.members) {
+    if (member.name.toLowerCase() === "[content_types].xml" || member.name.toLowerCase().endsWith(".rels")) {
+      if (!parsed.has(member.bytes)) parsed.set(member.bytes, (await parseDocumentXmlAsync(member.bytes, {}, budget)).root);
+    }
+  }
+  const graph = new DocumentPackage(archive, limits, budget, parsed);
+  for (const part of graph.parts) {
+    const type2 = part.content_type.toLowerCase();
+    if (type2.startsWith("image/") || type2.startsWith("audio/") || type2.startsWith("video/"))
+      budget.check("embeddedMediaBytes", part.bytes.length);
+  }
+  for (const declaration of [...graph.defaults, ...graph.overrides]) {
+    if (macroTypes.has(parseMediaType(declaration.content_type)))
+      throw new UnsupportedProfileError("Macro-enabled document containers are unsupported.");
+  }
+  const mainRelationships = graph.relationships("/").filter((edge) => officeRelationships.has(edge.reltype));
+  if (mainRelationships.length !== 1)
+    throw new InvalidPackageError("The package must contain exactly one main document relationship.");
+  if (mainRelationships[0].is_external || mainRelationships[0].fragment !== null)
+    throw new InvalidPackageError("The main document relationship must be internal and have no fragment.");
+  const main = mainRelationships[0].target_part;
+  const type = parseMediaType(main.content_type);
+  const kind = type === documentTypes.docx ? "docx" : type === documentTypes.dotx ? "dotx" : void 0;
+  if (!kind)
+    throw new UnsupportedProfileError("The package is not a supported Word document or template.");
+  for (const part of graph.parts) {
+    if (!parsed.has(part.bytes) && isXmlContentType(part.content_type))
+      parsed.set(part.bytes, (await parseDocumentXmlAsync(part.bytes, {}, budget)).root);
+  }
+  const dialect = validatePackageDialect(graph, mainRelationships[0], parsed.get(main.bytes), budget, parsed);
+  if (signal.aborted) throw new CancellationError("Document admission cancelled.");
+  return { ...archive, kind, dialect, mainPart: main.name, package: graph, [admittedXml]: parsed };
+}
+
+export {
+  DocumentPackage,
+  documentTypes,
+  macroTypes,
+  readDocumentArchive,
+  admittedXml,
+  admitDocumentArchive
+};