@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,387 @@
+import {
+  attr,
+  escape,
+  invalid,
+  loadShared,
+  nextRel
+} from "./chunk-RAXJVM4U.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/properties.ts
+import { SaxesParser } from "saxes";
+var cp = "http://schemas.openxmlformats.org/package/2006/metadata/core-properties";
+var dc = "http://purl.org/dc/elements/1.1/";
+var terms = "http://purl.org/dc/terms/";
+var custom = "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties";
+var vt = "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes";
+var strictCustom = "http://purl.oclc.org/ooxml/officeDocument/customProperties";
+var strictVt = "http://purl.oclc.org/ooxml/officeDocument/docPropsVTypes";
+var relationships = "http://schemas.openxmlformats.org/package/2006/relationships";
+var core = Object.freeze({
+  author: [dc, "creator", "string"],
+  category: [cp, "category", "string"],
+  comments: [dc, "description", "string"],
+  content_status: [cp, "contentStatus", "string"],
+  created: [terms, "created", "date"],
+  identifier: [dc, "identifier", "string"],
+  keywords: [cp, "keywords", "string"],
+  language: [dc, "language", "string"],
+  last_modified_by: [cp, "lastModifiedBy", "string"],
+  last_printed: [cp, "lastPrinted", "date"],
+  modified: [terms, "modified", "date"],
+  revision: [cp, "revision", "number"],
+  subject: [dc, "subject", "string"],
+  title: [dc, "title", "string"],
+  version: [cp, "version", "string"]
+});
+function coreDefinition(name) {
+  return Object.hasOwn(core, name) ? core[name] : void 0;
+}
+function text(doc, node) {
+  let value = "";
+  const parser = new SaxesParser({ xmlns: true });
+  parser.on("text", (s) => value += s);
+  parser.on("cdata", (s) => value += s);
+  parser.write(doc.markup(node, true)).close();
+  return value;
+}
+function validatePropertyValue(name, type, value) {
+  const known = coreDefinition(name);
+  for (const input of [name, ...typeof value === "string" ? [value] : []])
+    for (const c of input) {
+      const p = c.codePointAt(0);
+      if (p < 32 && p !== 9 && p !== 10 && p !== 13 || p >= 55296 && p <= 57343 || p === 65534 || p === 65535)
+        invalid("Invalid XML property text.");
+    }
+  if (!name || !["string", "number", "boolean", "date"].includes(type) || known && known[2] !== type)
+    invalid("Invalid property name or type.");
+  if (type === "string" && (typeof value !== "string" || known && [...value].length > 255))
+    invalid("Core strings allow at most 255 Unicode code points.");
+  if (type === "number" && (typeof value !== "number" || !Number.isFinite(value) || name === "revision" && (!Number.isSafeInteger(value) || value < 0)))
+    invalid("Invalid numeric property.");
+  if (type === "boolean" && typeof value !== "boolean") invalid("Expected a boolean property.");
+  if (type === "date") {
+    if (typeof value !== "string" || value.length !== 20 || value.startsWith("0000") || !value.endsWith("Z"))
+      invalid("Expected UTC date in whole seconds.");
+    const date = new Date(value);
+    if (!Number.isFinite(date.getTime()) || date.toISOString() !== value.slice(0, -1) + ".000Z")
+      invalid("Invalid UTC date.");
+  }
+}
+function decode(type, value) {
+  if (type === "number")
+    return value.trim() !== "" && Number.isFinite(Number(value)) ? Number(value) : null;
+  if (type === "boolean")
+    return value === "true" || value === "1" ? true : value === "false" || value === "0" ? false : null;
+  if (type === "date") {
+    const segments = value.split("T");
+    if (segments.length > 2) return null;
+    const calendar = segments[0].split("-");
+    if (calendar.length > 3 || calendar[0]?.length !== 4 || calendar.some(
+      (v, i) => v.length !== (i === 0 ? 4 : 2) || [...v].some((c) => c < "0" || c > "9")
+    ))
+      return null;
+    const year = Number(calendar[0]), month = Number(calendar[1] ?? 1), day = Number(calendar[2] ?? 1);
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    if (year < 1 || month < 1 || month > 12 || day < 1 || day > [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1])
+      return null;
+    if (segments.length === 2 && (calendar.length !== 3 || !(value.endsWith("Z") || value.slice(19).includes("+") || value.slice(19).includes("-"))))
+      return null;
+    const date = new Date(
+      segments.length === 1 ? `${calendar[0]}-${calendar[1] ?? "01"}-${calendar[2] ?? "01"}T00:00:00Z` : value
+    );
+    return Number.isFinite(date.getTime()) ? date.toISOString().slice(0, 19) + "Z" : null;
+  }
+  return value;
+}
+function parts(s) {
+  return s.index.inventory.relationships.filter(
+    (e) => e.owner === "/" && !e.external && (e.type === `${relationships}/metadata/core-properties` || e.type === `${s.r}/custom-properties`)
+  ).map((e) => ({
+    part: e.targetPart,
+    kind: e.type === `${relationships}/metadata/core-properties` ? "core" : "custom"
+  }));
+}
+function records(s) {
+  return parts(s).flatMap(({ part, kind }) => {
+    const doc = s.doc(part);
+    if ((kind === "core" ? doc.root.name.namespace !== cp : ![custom, strictCustom].includes(doc.root.name.namespace)) || doc.root.name.localName !== (kind === "core" ? "coreProperties" : "Properties"))
+      throw new OfficeError("invalid-opc", "Invalid metadata root.", "index");
+    return doc.root.children.map((node) => {
+      const definition = kind === "core" ? Object.entries(core).find(
+        ([, d]) => d[0] === node.name.namespace && d[1] === node.name.localName
+      ) : void 0;
+      const customNode = kind === "custom" && node.name.namespace === doc.root.name.namespace && node.name.localName === "property";
+      const valueNode = customNode && node.children.length === 1 ? node.children[0] : void 0;
+      const types = {
+        lpwstr: "string",
+        lpstr: "string",
+        bstr: "string",
+        i4: "number",
+        int: "number",
+        r8: "number",
+        bool: "boolean",
+        filetime: "date"
+      };
+      const type = unknownDeclaredType(doc, node) ? "unknown" : definition?.[1][2] ?? (valueNode && [vt, strictVt].includes(valueNode.name.namespace) && Object.hasOwn(types, valueNode.name.localName) ? types[valueNode.name.localName] : void 0) ?? "unknown";
+      const name = definition?.[0] ?? (customNode ? attr(node, "name") : void 0) ?? node.name.localName;
+      return {
+        doc,
+        node,
+        record: {
+          name,
+          kind: definition ? "core" : customNode ? "custom" : "unknown",
+          type,
+          value: decode(type, text(doc, valueNode ?? node)),
+          part,
+          namespace: node.name.namespace
+        }
+      };
+    });
+  });
+}
+function options(value, keys) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Object.keys(value).some((k) => !keys.includes(k)))
+    invalid("Invalid property options.");
+}
+async function readProperties(input, query, context) {
+  options(query, ["name"]);
+  if (query.name !== void 0 && (typeof query.name !== "string" || !query.name))
+    invalid("Expected property name.");
+  return records(await loadShared(input, context, false)).map((x) => x.record).filter((x) => query.name === void 0 || x.name === query.name);
+}
+function createPropertyPart(s, kind, context) {
+  let part = `/docProps/${kind}.xml`;
+  let suffix = 1;
+  while (s.reader.has(part)) part = `/docProps/${kind}${suffix++}.xml`;
+  const doc = parseXmlPart(
+    new TextEncoder().encode(
+      `<${kind === "core" ? "coreProperties" : "Properties"} xmlns="${kind === "core" ? cp : s.r.startsWith("http://purl.oclc.org/") ? strictCustom : custom}"/>`
+    ),
+    context.xmlLimits
+  );
+  s.save(part, doc);
+  const rel = s.doc("/_rels/.rels");
+  s.save(
+    "/_rels/.rels",
+    rel.spliceChildren(rel.root, rel.root.children.length, 0, [
+      `<Relationship xmlns="${relationships}" Id="${nextRel(rel)}" Type="${kind === "core" ? `${relationships}/metadata/core-properties` : `${s.r}/custom-properties`}" Target="${part.slice(1)}"/>`
+    ])
+  );
+  const types = s.doc("/[Content_Types].xml");
+  s.save(
+    "/[Content_Types].xml",
+    types.spliceChildren(types.root, types.root.children.length, 0, [
+      `<Override xmlns="${types.root.name.namespace}" PartName="${part}" ContentType="application/vnd.openxmlformats-${kind === "core" ? "package.core-properties" : "officedocument.custom-properties"}+xml"/>`
+    ])
+  );
+  return part;
+}
+async function mutateProperty(input, action, query, context) {
+  options(query, action === "set" ? ["name", "value", "type"] : ["name"]);
+  if (typeof query.name !== "string" || !query.name || !["set", "remove"].includes(action))
+    invalid("Invalid property operation.");
+  const s = await loadShared(input, context);
+  const matches = records(s).filter((x) => x.record.name === query.name);
+  if (matches.length > 1)
+    throw new OfficeError("ambiguous-selection", "Property name is ambiguous.", "select");
+  const found = matches[0];
+  if (action === "remove") {
+    if (!found) throw new OfficeError("missing-selection", "Property is absent.", "select");
+    if (found.record.type === "unknown" || !safeRemoval(found.node, found.record.kind))
+      throw new OfficeError(
+        "unsupported-edit",
+        "Unknown property is preserved.",
+        "validate-intent"
+      );
+    s.save(
+      found.record.part,
+      found.doc.spliceChildren(found.doc.root, found.doc.root.children.indexOf(found.node), 1, [])
+    );
+    return s.finish(found.record.part, []);
+  }
+  const type = query.type ?? found?.record.type ?? coreDefinition(query.name)?.[2];
+  if (found?.record.type === "unknown")
+    throw new OfficeError("unsupported-edit", "Unknown property is preserved.", "validate-intent");
+  if (!type || type === "unknown") invalid("New properties require an explicit supported type.");
+  if (found && found.record.type !== type) invalid("Property type cannot be coerced.");
+  validatePropertyValue(query.name, type, query.value);
+  if (found?.record.kind === "custom" && ["i4", "int"].includes(found.node.children[0]?.name.localName ?? "") && (!Number.isInteger(query.value) || query.value < -2147483648 || query.value > 2147483647))
+    invalid("Integer property exceeds signed 32-bit bounds.");
+  const definition = coreDefinition(query.name);
+  if (found && definition && found.record.kind !== "core")
+    invalid("Custom names cannot collide with core names.");
+  const kind = definition ? "core" : "custom";
+  const candidates = parts(s).filter((p) => p.kind === kind);
+  if (candidates.length > 1)
+    throw new OfficeError("ambiguous-selection", "Multiple property parts.", "select");
+  const part = found?.record.part ?? candidates[0]?.part ?? createPropertyPart(s, kind, context);
+  let doc = s.doc(part);
+  if (found && kind === "core")
+    doc = setCoreText(
+      doc,
+      doc.root.children[found.doc.root.children.indexOf(found.node)],
+      String(query.value)
+    );
+  else if (found) {
+    const node = doc.root.children[found.doc.root.children.indexOf(found.node)];
+    doc = doc.setText(node.children[0], String(query.value));
+  } else {
+    let markup;
+    if (definition) {
+      const [ns, local] = definition;
+      markup = `<m:${local} xmlns="" xmlns:m="${ns}"${type === "date" && ns === terms ? ` xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dcterms="${terms}" xsi:type="dcterms:W3CDTF"` : ""}>${escape(String(query.value))}</m:${local}>`;
+    } else {
+      let pid = 2;
+      const ids = new Set(doc.root.children.map((n) => attr(n, "pid")));
+      while (ids.has(String(pid))) pid++;
+      const tag = { string: "lpwstr", number: "r8", boolean: "bool", date: "filetime" }[type];
+      markup = `<property xmlns="${doc.root.name.namespace}" fmtid="{D5CDD505-2E9C-101B-9397-08002B2CF9AE}" pid="${pid}" name="${escape(query.name)}"><vt:${tag} xmlns:vt="${doc.root.name.namespace === strictCustom ? strictVt : vt}">${escape(String(query.value))}</vt:${tag}></property>`;
+    }
+    doc = doc.spliceChildren(doc.root, doc.root.children.length, 0, [markup]);
+  }
+  s.save(part, doc);
+  return s.finish(part, []);
+}
+function unknownDeclaredType(doc, node) {
+  const annotation = node.attributes.find(
+    (a) => a.name.namespace === "http://www.w3.org/2001/XMLSchema-instance" && a.name.localName === "type"
+  );
+  if (!annotation) return false;
+  const names = annotation.value.split(":");
+  const prefix = names.length === 2 ? names[0] : "";
+  const local = names.at(-1);
+  return node.name.namespace !== terms || names.length > 2 || local !== "W3CDTF" || doc.resolveNamespace(node, prefix) !== terms;
+}
+function setCoreText(doc, node, value) {
+  if (unknownDeclaredType(doc, node))
+    throw new OfficeError(
+      "unsupported-edit",
+      "Unknown declared property type is preserved.",
+      "validate-intent"
+    );
+  const index = doc.root.children.indexOf(node);
+  let updated = doc.setText(node, value);
+  if (node.name.namespace !== terms) return updated;
+  let qname = "";
+  const parser = new SaxesParser({ xmlns: true });
+  parser.on("opentag", (tag) => {
+    if (!qname) qname = tag.name;
+  });
+  parser.write(doc.markup(node, true)).close();
+  const colon = qname.indexOf(":");
+  const prefix = colon < 0 ? "" : qname.slice(0, colon) + ":";
+  updated = updated.merge(updated.root.children[index], {
+    attributes: [
+      {
+        namespace: "http://www.w3.org/2001/XMLSchema-instance",
+        localName: "type",
+        value: prefix + "W3CDTF"
+      }
+    ]
+  });
+  return updated;
+}
+function safeRemoval(node, kind) {
+  return kind === "core" ? node.children.length === 0 && node.attributes.every(
+    (a) => a.name.namespace === "http://www.w3.org/2001/XMLSchema-instance" && a.name.localName === "type"
+  ) : node.children.length === 1 && node.children[0].children.length === 0 && node.children[0].attributes.length === 0 && node.attributes.every(
+    (a) => a.name.namespace === "" && ["name", "pid", "fmtid"].includes(a.name.localName)
+  );
+}
+async function sanitizeProperties(input, context) {
+  const s = await loadShared(input, context);
+  const known = records(s).filter(
+    (x) => x.record.type !== "unknown" && safeRemoval(x.node, x.record.kind)
+  );
+  for (const part of new Set(known.map((x) => x.record.part))) {
+    let doc = s.doc(part);
+    const indices = known.filter((x) => x.record.part === part).map((x) => x.doc.root.children.indexOf(x.node)).sort((a, b) => b - a);
+    for (const index of indices) doc = doc.spliceChildren(doc.root, index, 1, []);
+    s.save(part, doc);
+  }
+  return s.finish(s.main, []);
+}
+var CoreProperties = class {
+  #read;
+  constructor(read, write) {
+    this.#read = read;
+    for (const [name, [namespace, localName, type]] of Object.entries(core))
+      Object.defineProperty(this, name, {
+        enumerable: true,
+        get: () => {
+          const doc = read();
+          const matches = doc.root.children.filter(
+            (n) => n.name.namespace === namespace && n.name.localName === localName
+          );
+          if (matches.length > 1)
+            throw new OfficeError("ambiguous-selection", "Duplicate core property.", "select");
+          const raw = matches[0] ? text(doc, matches[0]) : "";
+          if (type === "string") return raw;
+          if (type === "number") {
+            const value2 = Number(raw);
+            const digits = raw.trim();
+            const unsigned = digits.startsWith("+") ? digits.slice(1) : digits;
+            return unsigned && [...unsigned].every((c) => c >= "0" && c <= "9") && Number.isSafeInteger(value2) && value2 >= 0 ? value2 : 0;
+          }
+          const value = decode("date", raw);
+          return value === null ? null : new Date(value);
+        },
+        set: (value) => {
+          const serialized = type === "date" ? value instanceof Date && Number.isFinite(value.getTime()) ? value.toISOString().slice(0, 19) + "Z" : invalid("Expected valid UTC Date.") : value;
+          validatePropertyValue(name, type, serialized);
+          let doc = read();
+          const matches = doc.root.children.filter(
+            (n) => n.name.namespace === namespace && n.name.localName === localName
+          );
+          if (matches.length > 1)
+            throw new OfficeError("ambiguous-selection", "Duplicate core property.", "select");
+          if (matches[0]) doc = setCoreText(doc, matches[0], String(serialized));
+          else
+            doc = doc.spliceChildren(doc.root, doc.root.children.length, 0, [
+              `<m:${localName} xmlns="" xmlns:m="${namespace}"${type === "date" && namespace === terms ? ` xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dcterms="${terms}" xsi:type="dcterms:W3CDTF"` : ""}>${escape(String(serialized))}</m:${localName}>`
+            ]);
+          write(doc);
+        }
+      });
+  }
+  get part() {
+    return this.#read();
+  }
+};
+async function openPropertySession(input, context) {
+  const s = await loadShared(input, context);
+  const candidates = parts(s).filter((p) => p.kind === "core");
+  if (candidates.length > 1)
+    throw new OfficeError("ambiguous-selection", "Multiple core property parts.", "select");
+  let part = candidates[0]?.part;
+  let model;
+  return {
+    get core_properties() {
+      part ??= createPropertyPart(s, "core", context);
+      return model ??= new CoreProperties(
+        () => s.doc(part),
+        (doc) => s.save(part, doc)
+      );
+    },
+    async save() {
+      return (await s.finish(s.main, [])).bytes;
+    }
+  };
+}
+
+export {
+  coreDefinition,
+  validatePropertyValue,
+  readProperties,
+  createPropertyPart,
+  mutateProperty,
+  sanitizeProperties,
+  CoreProperties,
+  openPropertySession
+};

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

@@ -0,0 +1,267 @@
+import {
+  customXmlDataNamespaces,
+  customXmlRelationshipNamespaces
+} from "./chunk-2A6TBB4F.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  documentPartRole
+} from "./chunk-DXX2Z2QA.js";
+import {
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  activeXmlChildren
+} from "./chunk-YPVBU7QF.js";
+import {
+  compareInventoryNames
+} from "./chunk-2EUH5B6A.js";
+import {
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  asciiKey,
+  relationshipOwner
+} from "./chunk-WAKYUXVQ.js";
+import {
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  InputTypeError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/ancillary-resources.ts
+function packageResourceWarnings(data) {
+  return data.items.some((item) => item.details.kind === "custom-xml" ? item.details.storeItemId === null : item.details.buildingBlocks.length === 0 || item.details.buildingBlocks.some((block) => block.name === null || block.guid === null || block.category === null || block.gallery === null)) ? [{ code: "unrecognized-resource-metadata", message: "Resource metadata is missing, ambiguous or unrecognized; resources remain preserved." }] : [];
+}
+function attribute(node, name) {
+  return node?.attributes.find((attribute2) => attribute2.namespace === node.namespace && attribute2.localName === name)?.value ?? null;
+}
+function child(node, name) {
+  const matches = node?.children.filter((child2) => child2.namespace === node.namespace && child2.localName === name) ?? [];
+  return matches.length === 1 ? matches[0] : void 0;
+}
+async function hash(bytes, budget) {
+  budget.charge("work", bytes.length);
+  budget.charge("retainedBytes", bytes.length + 96);
+  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new Uint8Array(bytes)));
+  return [...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function glossaryBuildingBlocks(root, budget) {
+  const children = activeXmlChildren(root, budget);
+  const one = (node, name) => {
+    const matches = node ? children(node).filter((child2) => child2.namespace === root.namespace && child2.localName === name) : [];
+    return matches.length === 1 ? matches[0] : void 0;
+  };
+  const container = one(root, "docParts");
+  if (!container) return [];
+  const parents = /* @__PURE__ */ new Map();
+  const pending = [root];
+  budget.charge("retainedBytes", 8);
+  while (pending.length) {
+    const node = pending.pop();
+    budget.charge("work", node.children.length + 1);
+    budget.charge("retainedBytes", node.children.length * 64);
+    for (const [index, child2] of node.children.entries()) {
+      parents.set(child2, { parent: node, index });
+      pending.push(child2);
+    }
+  }
+  const values = (owner, name) => owner ? children(owner).filter((node) => node.namespace === root.namespace && node.localName === name).map((node) => attribute(node, "val")).filter((value) => value !== null) : [];
+  const blocks = [];
+  for (const block of children(container)) {
+    if (block.namespace !== root.namespace || block.localName !== "docPart") continue;
+    const path = [];
+    for (let node = block; node !== root; ) {
+      const position = parents.get(node);
+      budget.charge("work", 1);
+      budget.charge("retainedBytes", 8);
+      path.push(position.index);
+      node = position.parent;
+    }
+    const properties = one(block, "docPartPr"), category = one(properties, "category");
+    budget.charge("retainedBytes", 256);
+    blocks.push({
+      path: path.reverse(),
+      name: attribute(one(properties, "name"), "val"),
+      guid: attribute(one(properties, "guid"), "val"),
+      category: attribute(one(category, "name"), "val"),
+      gallery: attribute(one(category, "gallery"), "val"),
+      types: values(one(properties, "types"), "type"),
+      behaviors: values(one(properties, "behaviors"), "behavior")
+    });
+  }
+  return blocks;
+}
+function measurePackageResourceSerialization(value, budget) {
+  let bytes = 0;
+  const add = (amount) => {
+    bytes += amount;
+    budget.check("serializedOutput", bytes);
+  };
+  const string = (value2) => {
+    budget.charge("work", value2.length + 1);
+    add(2);
+    for (let index = 0; index < value2.length; ) {
+      const end = Math.min(value2.length, index + 512);
+      let amount = 0;
+      for (; index < end; index++) {
+        const code = value2.charCodeAt(index);
+        if (code === 34 || code === 92) amount += 2;
+        else if (code < 32) amount += [8, 9, 10, 12, 13].includes(code) ? 2 : 6;
+        else if (code < 128) amount++;
+        else if (code < 2048) amount += 2;
+        else if (code >= 55296 && code <= 56319 && value2.charCodeAt(index + 1) >= 56320 && value2.charCodeAt(index + 1) <= 57343) {
+          amount += 4;
+          index++;
+        } else amount += code >= 55296 && code <= 57343 ? 6 : 3;
+      }
+      add(amount);
+    }
+  };
+  const visit = (value2) => {
+    budget.charge("work", 1);
+    if (typeof value2 === "string") string(value2);
+    else if (value2 === null) add(4);
+    else if (typeof value2 === "boolean") add(value2 ? 4 : 5);
+    else if (typeof value2 === "number") add(String(value2).length);
+    else if (Array.isArray(value2)) {
+      add(2);
+      for (let index = 0; index < value2.length; ) {
+        if (typeof value2[index] === "number") {
+          const start = index, end = Math.min(value2.length, index + 512);
+          while (index < end && typeof value2[index] === "number") index++;
+          budget.charge("work", index - start);
+          let amount = index - start - (start === 0 ? 1 : 0);
+          for (let item = start; item < index; item++) amount += String(value2[item]).length;
+          add(amount);
+        } else {
+          if (index) add(1);
+          visit(value2[index++]);
+        }
+      }
+    } else if (value2 && typeof value2 === "object") {
+      add(2);
+      let count = 0;
+      for (const key in value2) if (Object.hasOwn(value2, key) && value2[key] !== void 0) {
+        if (count++) add(1);
+        string(key);
+        add(1);
+        visit(value2[key]);
+      }
+    }
+  };
+  visit(value);
+  return bytes;
+}
+async function inspectDocumentPackageResources(input, operation, options, context) {
+  const settings = archiveSettings(context), invocation = validateDocxInvocation({ operation, inputs: ["document"], options }, settings.budget);
+  const budget = settings.budget.lower(Object.fromEntries((invocation.options.limit ?? []).map((limit) => [limit.name, limit.value])));
+  if (!(input instanceof Uint8Array)) throw new InputTypeError("Expected archive bytes.");
+  budget.check("compressedInput", input.length);
+  budget.charge("retainedBytes", input.length);
+  budget.charge("work", input.length);
+  const owned = new Uint8Array(input);
+  const archive = await readDocumentArchive(owned, { ...settings, budget }), graph = archive.package;
+  budget.charge("work", 1);
+  budget.charge("retainedBytes", archive.members.length * 96);
+  const parts = new Map(graph.parts.filter((part) => parseMediaType(part.content_type) !== "application/vnd.openxmlformats-package.relationships+xml").map((part) => [part.partname, part]));
+  const edges = ["/", ...parts.keys()].flatMap((owner) => {
+    const references = graph.relationships(owner);
+    budget.charge("work", references.length);
+    budget.charge("retainedBytes", references.length * 32);
+    return references.map((edge) => ({ owner, edge }));
+  });
+  const relation = (type, name) => customXmlRelationshipNamespaces.some((namespace) => type === namespace + name);
+  const itemNames = new Set(edges.filter(({ edge }) => !edge.is_external && relation(edge.reltype, "customXml")).map(({ edge }) => edge.target_part.partname));
+  const associated = new Set(edges.filter(({ owner, edge }) => itemNames.has(owner) && !edge.is_external && relation(edge.reltype, "customXmlProps")).map(({ edge }) => edge.target_part.partname));
+  const candidates = operation === "custom-xml.list" ? [...itemNames, ...[...parts.values()].filter((part) => parseMediaType(part.content_type) === "application/vnd.openxmlformats-officedocument.customxmlproperties+xml" && !associated.has(part.partname)).map((part) => part.partname)] : [...parts.values()].filter((part) => parseMediaType(part.content_type) === "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml").map((part) => part.partname);
+  budget.check("matches", candidates.length);
+  budget.charge("retainedBytes", candidates.length * 64);
+  const roots = /* @__PURE__ */ new Map(), metadata = /* @__PURE__ */ new Map();
+  const root = (name) => {
+    const part = parts.get(name);
+    if (!parseMediaType(part.content_type).endsWith("+xml") && !["application/xml", "text/xml"].includes(parseMediaType(part.content_type))) return void 0;
+    let value = roots.get(name);
+    if (!value) {
+      value = parseDocumentXml(part.bytes, {}, budget).root;
+      roots.set(name, value);
+    }
+    return value;
+  };
+  const sourceSha256 = await hash(owned, budget), records = [];
+  for (const name of [...new Set(candidates)].sort(compareInventoryNames)) {
+    budget.charge("work", 1);
+    const pending = [name], closure = /* @__PURE__ */ new Set();
+    while (pending.length) {
+      budget.charge("work", 1);
+      const owner = pending.pop();
+      if (closure.has(owner)) continue;
+      budget.charge("retainedBytes", 32);
+      closure.add(owner);
+      for (const edge of graph.relationships(owner)) {
+        budget.charge("work", 1);
+        if (!edge.is_external && !closure.has(edge.target_part.partname)) {
+          budget.charge("retainedBytes", 8);
+          pending.push(edge.target_part.partname);
+        }
+      }
+    }
+    const inventory = [];
+    for (const partName of [...closure].sort(compareInventoryNames)) {
+      let item = metadata.get(partName);
+      if (!item) {
+        const part = parts.get(partName);
+        item = { name: partName, contentType: part.content_type, bytes: part.bytes.length, sha256: await hash(part.bytes, budget) };
+        metadata.set(partName, item);
+      }
+      budget.charge("retainedBytes", 8);
+      inventory.push(item);
+    }
+    const references = edges.filter(({ owner, edge }) => closure.has(owner) || !edge.is_external && edge.target_part.partname === name).map(({ owner, edge }) => ({ owner, id: edge.rId, type: edge.reltype, target: edge.target_ref, external: edge.is_external })).sort((a, b) => compareInventoryNames(a.owner, b.owner) || compareInventoryNames(a.id, b.id));
+    budget.charge("retainedBytes", references.length * 64);
+    const value = { version: 1, sourceSha256, generation: 0, part: name, story: name, path: [], range: null }, token = encodeGeneratedLocation(value);
+    budget.charge("retainedBytes", token.length * 4);
+    const location = { kind: "part", token, value, positions: {} };
+    let details;
+    const itemRoot = root(name);
+    if (operation === "custom-xml.list") {
+      const propertiesParts = itemNames.has(name) ? graph.relationships(name).filter((edge) => !edge.is_external && relation(edge.reltype, "customXmlProps")).map((edge) => edge.target_part.partname).sort(compareInventoryNames) : [name];
+      const propertyRoots = propertiesParts.map(root).filter((node) => node !== void 0 && customXmlDataNamespaces.includes(node.namespace) && node.localName === "datastoreItem");
+      const storeIds = propertyRoots.map((node) => attribute(node, "itemID"));
+      const schemaReferences = [...new Set(propertyRoots.flatMap((node) => child(node, "schemaRefs")?.children.filter((child2) => child2.namespace === node.namespace && child2.localName === "schemaRef").map((node2) => attribute(node2, "uri")).filter((uri) => uri !== null) ?? []))].sort(compareInventoryNames);
+      details = { kind: "custom-xml", parts: inventory, root: itemNames.has(name) && itemRoot ? { namespace: itemRoot.namespace, localName: itemRoot.localName } : null, storeItemId: propertiesParts.length === 1 && propertyRoots.length === 1 ? storeIds[0] ?? null : null, propertiesParts, namespaces: itemRoot ? [...itemRoot.namespaces].map(([prefix, uri]) => ({ prefix, uri })).sort((a, b) => compareInventoryNames(a.prefix, b.prefix)) : [], schemaReferences };
+    } else {
+      const buildingBlocks = itemRoot && documentPartRole(parts.get(name).content_type, itemRoot) === "glossary" ? glossaryBuildingBlocks(itemRoot, budget) : [];
+      details = { kind: "glossary", parts: inventory, buildingBlocks };
+    }
+    records.push({ kind: details.kind, name, location, properties: [], references, support: "preserve", details });
+  }
+  const data = { items: records };
+  measurePackageResourceSerialization({ version: 1, operation, ok: true, data, warnings: [], errors: [], affected: 0, locations: records.map((record) => record.location) }, budget);
+  return data;
+}
+function incomingResourceReferences(graph, part, budget) {
+  const references = [];
+  const owners = ["/", ...graph.parts.filter((candidate) => relationshipOwner(candidate.partname) === null).map((candidate) => candidate.partname)];
+  owners.sort(compareInventoryNames);
+  for (const owner of owners) {
+    for (const edge of graph.relationships(owner)) {
+      budget.charge("work", 1);
+      if (edge.is_external || asciiKey(edge.target_part.partname) !== asciiKey(part)) continue;
+      budget.charge("retainedBytes", 160 + (owner.length + edge.rId.length + edge.reltype.length + edge.target_ref.length) * 2);
+      references.push({ owner, id: edge.rId, type: edge.reltype, target: edge.target_ref, external: false });
+    }
+  }
+  return references;
+}
+
+export {
+  packageResourceWarnings,
+  measurePackageResourceSerialization,
+  inspectDocumentPackageResources,
+  incomingResourceReferences
+};