@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,992 @@
+import {
+  readPackage
+} from "./chunk-FRZ5P5AB.js";
+import {
+  readBinary
+} from "./chunk-TL3KDYEM.js";
+import {
+  equationOpaqueElements,
+  interpretCompatibility
+} from "./chunk-5DFZAJHL.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  parseContentTypes
+} from "./chunk-N74TJL6X.js";
+import {
+  readRelationshipGraph
+} from "./chunk-5GEFJROP.js";
+import {
+  asciiKey,
+  partName
+} from "./chunk-XXFHTGV2.js";
+import {
+  resourceContext
+} from "./chunk-FOO3AXFK.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/selectors.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+
+// packages/safe-bash-presentation-engine/src/diagram-resources.ts
+var diagramContentTypes = {
+  data: "application/vnd.openxmlformats-officedocument.drawingml.diagramData+xml",
+  layout: "application/vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml",
+  style: "application/vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml",
+  colors: "application/vnd.openxmlformats-officedocument.drawingml.diagramColors+xml",
+  drawing: "application/vnd.ms-office.drawingml.diagramDrawing+xml"
+};
+var diagramRelationshipKinds = Object.freeze({
+  ...Object.fromEntries(
+    [
+      "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+      "http://purl.oclc.org/ooxml/officeDocument/relationships"
+    ].flatMap(
+      (namespace) => Object.entries({
+        diagramData: "data",
+        diagramLayout: "layout",
+        diagramQuickStyle: "style",
+        diagramColors: "colors"
+      }).map(([name, kind]) => [`${namespace}/${name}`, kind])
+    )
+  ),
+  "http://schemas.microsoft.com/office/2007/relationships/diagramDrawing": "drawing"
+});
+function inspectDiagrams(parts, graph) {
+  const present = new Set(graph.parts);
+  return Object.freeze(
+    parts.flatMap((part) => {
+      const kind = Object.keys(diagramContentTypes).find(
+        (key) => diagramContentTypes[key] === part.contentType
+      ) ?? graph.incoming(part.part).map((edge) => diagramRelationshipKinds[edge.type]).find((value) => value !== void 0);
+      if (!kind) return [];
+      const visited = /* @__PURE__ */ new Set([part.part]);
+      const missing = /* @__PURE__ */ new Set();
+      const pending = [part.part];
+      for (let index = 0; index < pending.length; index++) {
+        for (const edge of graph.outgoing(pending[index])) {
+          if (edge.external || edge.targetPart === null) continue;
+          if (!present.has(edge.targetPart)) missing.add(edge.targetPart);
+          else if (!visited.has(edge.targetPart)) {
+            visited.add(edge.targetPart);
+            pending.push(edge.targetPart);
+          }
+        }
+      }
+      return [
+        Object.freeze({
+          part: part.part,
+          kind,
+          owners: Object.freeze(
+            [...new Set(graph.incoming(part.part).map((edge) => edge.owner))].sort()
+          ),
+          dependencies: Object.freeze(pending.slice(1).sort()),
+          missing: Object.freeze([...missing].sort()),
+          semanticEditing: false
+        })
+      ];
+    })
+  );
+}
+
+// packages/safe-bash-presentation-engine/src/text-style-resolution.ts
+var drawingNamespaces = [
+  "http://schemas.openxmlformats.org/drawingml/2006/main",
+  "http://purl.oclc.org/ooxml/drawingml/main"
+];
+function attr(node, name) {
+  return node?.attributes.find((a) => a.name.namespace === "" && a.name.localName === name)?.value;
+}
+function children(node, name, ns = node?.name.namespace) {
+  return node?.children.filter((n) => n.name.localName === name && n.name.namespace === ns) ?? [];
+}
+function one(node, name, ns = node?.name.namespace) {
+  const found = children(node, name, ns);
+  if (found.length > 1) throw new OfficeError("invalid-xml", "Ambiguous style structure.", "index");
+  return found[0];
+}
+function shapes(root) {
+  const result = [];
+  const pending = [...one(one(root, "cSld"), "spTree")?.children ?? []];
+  while (pending.length) {
+    const node = pending.pop();
+    if (node.name.namespace !== root.name.namespace) continue;
+    if (node.name.localName === "sp") result.push(node);
+    if (node.name.localName === "grpSp") pending.push(...node.children);
+  }
+  return result.reverse();
+}
+function placeholder(shape) {
+  return one(one(one(shape, "nvSpPr"), "nvPr"), "ph");
+}
+function match(part, predicate) {
+  const found = part ? shapes(part.root).filter((s) => {
+    const ph = placeholder(s);
+    return ph && predicate(ph);
+  }) : [];
+  if (found.length > 1)
+    throw new OfficeError("ambiguous-selection", "Ambiguous style placeholder.", "index");
+  return found[0];
+}
+function baseType(type) {
+  return type === "ctrTitle" ? "title" : ["subTitle", "obj", "chart", "tbl", "clipArt", "dgm", "media", "pic"].includes(type) ? "body" : type;
+}
+function resolveProperty(layers, property, context, a) {
+  const absent = {
+    value: null,
+    token: null,
+    status: "absent",
+    source: null,
+    references: [],
+    reason: null
+  };
+  for (const layer of layers) {
+    const attribute2 = {
+      bold: "b",
+      italic: "i",
+      size: "sz",
+      language: "lang",
+      underline: "u",
+      strike: "strike",
+      baseline: "baseline",
+      capitalization: "cap",
+      spacing: "spc"
+    }[property];
+    const font = { latin: "latin", eastAsia: "ea", complex: "cs" }[property];
+    const fill = one(layer.node, property === "highlight" ? "highlight" : "solidFill", a);
+    const color = fill?.children.find((n) => n.name.namespace === a);
+    const token = attribute2 ? attr(layer.node, attribute2) : font ? attr(one(layer.node, font, a), "typeface") : color ? attr(color, "val") ?? color.name.localName : void 0;
+    if (property === "color" && !color) {
+      const other = layer.node.children.find(
+        (n) => n.name.namespace === a && ["noFill", "gradFill", "pattFill", "blipFill", "grpFill"].includes(n.name.localName)
+      );
+      if (other)
+        return {
+          ...absent,
+          token: other.name.localName,
+          status: "unresolved",
+          source: layer.source,
+          reason: "non-solid-color"
+        };
+    }
+    if (token === void 0) continue;
+    const references = [];
+    const result = (value, reason = null) => ({
+      value,
+      token,
+      source: layer.source,
+      status: reason ? "unresolved" : "resolved",
+      references,
+      reason
+    });
+    if (attribute2) {
+      if (property === "language") return token ? result(token) : result(null, "invalid-language");
+      if (["underline", "strike", "capitalization"].includes(property)) {
+        const values = {
+          underline: [
+            "none",
+            "words",
+            "sng",
+            "dbl",
+            "heavy",
+            "dotted",
+            "dottedHeavy",
+            "dash",
+            "dashHeavy",
+            "dashLong",
+            "dashLongHeavy",
+            "dotDash",
+            "dotDashHeavy",
+            "dotDotDash",
+            "dotDotDashHeavy",
+            "wavy",
+            "wavyHeavy",
+            "wavyDbl"
+          ],
+          strike: ["noStrike", "sngStrike", "dblStrike"],
+          capitalization: ["none", "small", "all"]
+        };
+        if (!values[property].includes(token)) return result(null, "invalid-character-format");
+        return result(
+          property === "strike" ? { noStrike: "none", sngStrike: "single", dblStrike: "double" }[token] : token
+        );
+      }
+      if (property === "baseline" || property === "spacing") {
+        const digits = token.startsWith("-") || token.startsWith("+") ? token.slice(1) : token;
+        const value = Number(token), max = property === "baseline" ? 1e5 : 4e5;
+        return digits.length > 0 && [...digits].every((c) => c >= "0" && c <= "9") && Number.isInteger(value) && Math.abs(value) <= max ? result(value / (property === "baseline" ? 1e3 : 100)) : result(null, "invalid-character-format");
+      }
+      if (property !== "size")
+        return ["0", "1", "true", "false"].includes(token) ? result(token === "1" || token === "true") : result(null, "invalid-boolean");
+      return token.length > 0 && [...token].every((c) => c >= "0" && c <= "9") && Number(token) >= 100 && Number(token) <= 4e5 ? result(Number(token) / 100) : result(null, "invalid-font-size");
+    }
+    const themeParts = [
+      ...context.themeOverrides ?? [],
+      ...context.theme ? [context.theme] : []
+    ];
+    const scheme = (name) => {
+      for (const part of themeParts) {
+        const container = part.root.name.localName === "themeOverride" ? part.root : one(part.root, "themeElements", a);
+        const node = one(container, name, a);
+        if (node) return { part, node };
+      }
+      return void 0;
+    };
+    if (font) {
+      if (!token.startsWith("+")) return result(token);
+      const variants = {
+        "+mj-lt": ["majorFont", "latin"],
+        "+mn-lt": ["minorFont", "latin"],
+        "+mj-ea": ["majorFont", "ea"],
+        "+mn-ea": ["minorFont", "ea"],
+        "+mj-cs": ["majorFont", "cs"],
+        "+mn-cs": ["minorFont", "cs"]
+      };
+      const variant = variants[token];
+      const selected = scheme("fontScheme");
+      if (!variant || !selected) return result(null, "theme-font-unavailable");
+      references.push({
+        part: selected.part.part,
+        layer: "theme",
+        path: `fontScheme/${variant.join("/")}`
+      });
+      const value = attr(one(one(selected.node, variant[0], a), variant[1], a), "typeface");
+      return value ? result(value) : result(null, "theme-font-unavailable");
+    }
+    if (!color) return result(null, "color-unavailable");
+    if (color.children.length) return result(null, "color-transform");
+    let resolvedColor = color;
+    if (color.name.localName === "schemeClr") {
+      let slot = token;
+      let mapping;
+      for (const part of [context.slide, context.layout]) {
+        if (!part) continue;
+        const override = one(part.root, "clrMapOvr");
+        const map = one(override, "overrideClrMapping", a);
+        if (map) {
+          mapping = { part, node: map };
+          break;
+        }
+        if (one(override, "masterClrMapping", a)) break;
+      }
+      if (!mapping && context.master) {
+        const map = one(context.master.root, "clrMap");
+        if (map) mapping = { part: context.master, node: map };
+      }
+      if (mapping) {
+        slot = attr(mapping.node, token) ?? token;
+        references.push({
+          part: mapping.part.part,
+          layer: "color-map",
+          path: `${mapping.node.name.localName}/@${token}`
+        });
+      }
+      const selected = scheme("clrScheme");
+      const entry = selected && one(selected.node, slot, a);
+      const candidate = entry?.children.find((n) => n.name.namespace === a);
+      if (!candidate || !selected) return result(null, "theme-color-unavailable");
+      references.push({ part: selected.part.part, layer: "theme", path: `clrScheme/${slot}` });
+      resolvedColor = candidate;
+    }
+    if (resolvedColor.children.length) return result(null, "color-transform");
+    if (resolvedColor.name.localName !== "srgbClr") return result(null, "color-kind-unavailable");
+    const rgb = attr(resolvedColor, "val");
+    return rgb?.length === 6 && [...rgb.toUpperCase()].every((c) => "0123456789ABCDEF".includes(c)) ? result(rgb.toUpperCase()) : result(null, "invalid-rgb");
+  }
+  return absent;
+}
+function resolveTextStyles(context) {
+  const p = context.slide.root.name.namespace;
+  const a = p === "http://purl.oclc.org/ooxml/presentationml/main" ? drawingNamespaces[1] : drawingNamespaces[0];
+  const result = [];
+  for (const shape of shapes(context.slide.root)) {
+    const shapeId = attr(one(one(shape, "nvSpPr"), "cNvPr"), "id") ?? "";
+    const ph = placeholder(shape);
+    const layoutShape = ph ? match(context.layout, (n) => (attr(n, "idx") ?? "0") === (attr(ph, "idx") ?? "0")) : void 0;
+    const type = attr(placeholder(layoutShape), "type") ?? attr(ph, "type") ?? "obj";
+    const masterShape = ph ? match(context.master, (n) => (attr(n, "type") ?? "obj") === baseType(type)) : void 0;
+    const body = one(shape, "txBody");
+    const paragraphs = children(body, "p", a);
+    for (const [paragraph, node] of paragraphs.entries()) {
+      const pPr = one(node, "pPr", a);
+      const rawLevel = attr(pPr, "lvl") ?? "0";
+      const level = rawLevel.length === 1 && "012345678".includes(rawLevel) ? Number(rawLevel) + 1 : null;
+      if (level === null) throw new OfficeError("invalid-xml", "Invalid paragraph level.", "index");
+      const runs = node.children.filter(
+        (n) => n.name.namespace === a && ["r", "fld", "br"].includes(n.name.localName)
+      );
+      for (const [run, runNode] of (runs.length ? runs : [void 0]).entries()) {
+        const layers = [];
+        const add = (node2, part, layer, path2) => {
+          if (node2 && part) layers.push({ node: node2, source: { part: part.part, layer, path: path2 } });
+        };
+        const path = `shape[${shapeId}]/p[${paragraph}]`;
+        add(one(runNode, "rPr", a), context.slide, "run", `${path}/run[${run}]/rPr`);
+        if (!runNode)
+          add(one(node, "endParaRPr", a), context.slide, "paragraph", `${path}/endParaRPr`);
+        add(one(pPr, "defRPr", a), context.slide, "paragraph", `${path}/pPr/defRPr`);
+        for (const [ownerShape, part, layer] of [
+          [shape, context.slide, "shape"],
+          [layoutShape, context.layout, "layout"],
+          [masterShape, context.master, "master"]
+        ]) {
+          const list = one(one(ownerShape, "txBody"), "lstStyle", a);
+          for (const key of [`lvl${level}pPr`, "defPPr"])
+            add(
+              one(one(list, key, a), "defRPr", a),
+              part,
+              layer,
+              `shape[${attr(one(one(ownerShape, "nvSpPr"), "cNvPr"), "id") ?? ""}]/lstStyle/${key}/defRPr`
+            );
+        }
+        const masterStyle = one(
+          one(context.master?.root, "txStyles"),
+          ph && baseType(type) === "title" ? "titleStyle" : ph && baseType(type) === "body" ? "bodyStyle" : "otherStyle"
+        );
+        for (const key of [`lvl${level}pPr`, "defPPr"]) {
+          add(
+            one(one(masterStyle, key, a), "defRPr", a),
+            context.master,
+            "master-text",
+            `txStyles/${masterStyle?.name.localName}/${key}/defRPr`
+          );
+        }
+        for (const key of [`lvl${level}pPr`, "defPPr"]) {
+          add(
+            one(one(one(context.presentation?.root, "defaultTextStyle"), key, a), "defRPr", a),
+            context.presentation,
+            "presentation",
+            `defaultTextStyle/${key}/defRPr`
+          );
+        }
+        for (const [ownerShape, part] of [
+          [shape, context.slide],
+          [layoutShape, context.layout],
+          [masterShape, context.master]
+        ]) {
+          const reference = one(one(ownerShape, "style"), "fontRef", a);
+          if (!reference) continue;
+          const idx = attr(reference, "idx");
+          const prefix = idx === "major" ? "+mj" : idx === "minor" ? "+mn" : null;
+          const fonts = prefix ? [
+            ["latin", "lt"],
+            ["ea", "ea"],
+            ["cs", "cs"]
+          ].map(([name, suffix]) => ({
+            name: { namespace: a, localName: name },
+            attributes: [
+              { name: { namespace: "", localName: "typeface" }, value: `${prefix}-${suffix}` }
+            ],
+            children: []
+          })) : [];
+          add(
+            {
+              name: { namespace: a, localName: "defRPr" },
+              attributes: [],
+              children: [
+                ...fonts,
+                {
+                  name: { namespace: a, localName: "solidFill" },
+                  attributes: [],
+                  children: reference.children
+                }
+              ]
+            },
+            part,
+            "font-reference",
+            `shape[${attr(one(one(ownerShape, "nvSpPr"), "cNvPr"), "id") ?? ""}]/style/fontRef`
+          );
+        }
+        const properties = Object.fromEntries(
+          [
+            "bold",
+            "italic",
+            "size",
+            "latin",
+            "eastAsia",
+            "complex",
+            "color",
+            "language",
+            "underline",
+            "strike",
+            "baseline",
+            "capitalization",
+            "spacing",
+            "highlight"
+          ].map((property) => [property, resolveProperty(layers, property, context, a)])
+        );
+        result.push({
+          part: context.slide.part,
+          shapeId,
+          paragraph,
+          run: runNode ? run : null,
+          properties
+        });
+      }
+    }
+  }
+  return result;
+}
+
+// packages/safe-bash-presentation-engine/src/inventory.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+var relationshipNamespaces = [
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  "http://purl.oclc.org/ooxml/officeDocument/relationships"
+];
+function hasType(edge, type) {
+  return relationshipNamespaces.some((namespace) => edge.type === `${namespace}/${type}`);
+}
+function inspectInventory(reader, graph, records, root, context) {
+  const names = [...graph.parts].sort();
+  const relationships = Object.freeze(
+    ["/", ...names].flatMap(
+      (owner) => [...graph.outgoing(owner)].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+    )
+  );
+  const targets = (type) => Object.freeze(
+    [
+      ...new Set(
+        relationships.filter(
+          (edge) => hasType(edge, type) && edge.targetPart !== null && reader.has(edge.targetPart)
+        ).map((edge) => edge.targetPart)
+      )
+    ].sort()
+  );
+  const masters = targets("slideMaster");
+  const layouts = targets("slideLayout");
+  const themes = targets("theme");
+  const target = (owner, type) => {
+    if (owner === null) return null;
+    const edges = graph.outgoing(owner).filter((edge) => hasType(edge, type));
+    if (edges.length > 1)
+      throw new OfficeError(
+        "invalid-opc",
+        "Ambiguous presentation inheritance relationship.",
+        "index"
+      );
+    const part = edges[0]?.targetPart;
+    return part && reader.has(part) ? part : null;
+  };
+  const slides = Object.freeze(
+    records.slides.map((slide) => {
+      const layout = target(slide.part, "slideLayout");
+      const master = target(layout, "slideMaster");
+      const value = root(slide.part).attributes.find(
+        (attribute2) => attribute2.name.namespace === "" && attribute2.name.localName === "show"
+      )?.value.trim();
+      if (value !== void 0 && !["true", "false", "1", "0"].includes(value))
+        throw new OfficeError("invalid-xml", "Invalid slide visibility.", "index");
+      const explicit = value === void 0 ? null : value === "true" || value === "1";
+      return Object.freeze({
+        id: slide.id,
+        part: slide.part,
+        position: slide.position,
+        shapeCount: records.objects.filter(
+          (object) => object.scope === "slides" && object.part === slide.part
+        ).length,
+        layout,
+        master,
+        theme: target(master, "theme"),
+        show: Object.freeze({ explicit, effective: explicit ?? true })
+      });
+    })
+  );
+  const stylePart = (part) => part ? { part, root: root(part) } : void 0;
+  const presentation = stylePart(target("/", "officeDocument"));
+  const handoutMasters = Object.freeze(
+    (presentation?.root.children ?? []).filter(
+      (node) => node.name.namespace === presentation.root.name.namespace && node.name.localName === "handoutMasterIdLst"
+    ).flatMap(
+      (list) => list.children.filter(
+        (node) => node.name.namespace === list.name.namespace && node.name.localName === "handoutMasterId"
+      )
+    ).map((node) => {
+      const id = node.attributes.find(
+        (attribute2) => relationshipNamespaces.includes(attribute2.name.namespace) && attribute2.name.localName === "id"
+      )?.value;
+      const edges = graph.outgoing(presentation.part).filter((edge) => edge.id === id && hasType(edge, "handoutMaster") && !edge.external);
+      if (edges.length !== 1 || !edges[0].targetPart || !reader.has(edges[0].targetPart))
+        throw new OfficeError("invalid-opc", "Invalid handout master reference.", "index");
+      return edges[0].targetPart;
+    })
+  );
+  const textStyles = slides.flatMap(
+    (slide) => resolveTextStyles({
+      slide: { part: slide.part, root: root(slide.part) },
+      layout: stylePart(slide.layout),
+      master: stylePart(slide.master),
+      theme: stylePart(slide.theme),
+      themeOverrides: [slide.part, slide.layout, slide.master].map((part) => stylePart(target(part, "themeOverride"))).filter((part) => part !== void 0),
+      presentation
+    })
+  );
+  const contentTypes = reader.has("/[Content_Types].xml") ? parseContentTypes(reader.get("/[Content_Types].xml"), {
+    maxBytes: context.xmlLimits.maxBytes,
+    maxEntries: context.relationshipLimits.maxParts
+  }) : null;
+  const unsupported = [];
+  const parts = Object.freeze(
+    names.map((part) => {
+      context.signal?.throwIfAborted();
+      const bytes = reader.get(part);
+      let contentType = null;
+      if (contentTypes) {
+        try {
+          contentType = contentTypes.get(part);
+        } catch (error) {
+          if (!(error instanceof OfficeError) || error.code !== "missing-binding") throw error;
+        }
+      }
+      if (contentType === null)
+        unsupported.push(Object.freeze({ part, reason: "content-type-unavailable" }));
+      unsupported.push(Object.freeze({ part, reason: "semantic-content-not-inspected" }));
+      return Object.freeze({
+        part,
+        contentType,
+        bytes: bytes.length,
+        sha256: Array.from(sha256(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("")
+      });
+    })
+  );
+  const mediaTargets = new Set(
+    relationships.filter((edge) => ["image", "audio", "video", "media"].some((type) => hasType(edge, type))).map((edge) => edge.targetPart)
+  );
+  const media = Object.freeze(
+    parts.filter(
+      (part) => mediaTargets.has(part.part) || ["image/", "audio/", "video/"].some(
+        (prefix) => part.contentType?.toLowerCase().startsWith(prefix)
+      )
+    )
+  );
+  for (const edge of relationships) {
+    if (edge.external)
+      unsupported.push(
+        Object.freeze({ part: edge.owner, reason: `external-relationship:${edge.id}` })
+      );
+    else if (edge.targetPart !== null && !reader.has(edge.targetPart))
+      unsupported.push(
+        Object.freeze({ part: edge.owner, reason: `missing-relationship-target:${edge.id}` })
+      );
+  }
+  return Object.freeze({
+    slides,
+    diagrams: inspectDiagrams(parts, graph),
+    textStyles: Object.freeze(textStyles),
+    masters,
+    handoutMasters,
+    layouts,
+    themes,
+    parts,
+    media,
+    relationships,
+    unsupported: Object.freeze(unsupported),
+    features: Object.freeze({
+      structure: true,
+      slideVisibility: true,
+      effectiveFormatting: false,
+      mediaMetadata: false,
+      editing: false
+    }),
+    counts: Object.freeze({
+      slides: slides.length,
+      masters: masters.length,
+      layouts: layouts.length,
+      themes: themes.length,
+      slideShapes: slides.reduce((count, slide) => count + slide.shapeCount, 0),
+      parts: parts.length,
+      media: media.length
+    })
+  });
+}
+
+// packages/safe-bash-presentation-engine/src/selectors.ts
+var SelectionError = class extends OfficeError {
+  constructor(code, candidates = []) {
+    super(
+      code,
+      {
+        "invalid-selection": "Invalid selection.",
+        "missing-selection": "Selection has no matching location.",
+        "ambiguous-selection": "Selection matches multiple locations.",
+        "stale-selection": "Selection belongs to stale or invalidated state."
+      }[code],
+      "select"
+    );
+    this.candidates = candidates;
+  }
+  candidates;
+};
+var scopes = [
+  "slides",
+  "notes",
+  "layouts",
+  "masters",
+  "notes-master",
+  "handout-master",
+  "presentation",
+  "shared"
+];
+var presentationNamespaces = [
+  "http://schemas.openxmlformats.org/presentationml/2006/main",
+  "http://purl.oclc.org/ooxml/presentationml/main"
+];
+var relationshipNamespaces2 = [
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  "http://purl.oclc.org/ooxml/officeDocument/relationships"
+];
+function attribute(element, name, namespaces = [""]) {
+  return element.attributes.find(
+    (a) => a.name.localName === name && namespaces.includes(a.name.namespace)
+  )?.value ?? "";
+}
+function numericIdentity(value, minimum, maximum) {
+  const text = value.trim();
+  const digits = text.startsWith("+") ? text.slice(1) : text;
+  const number = Number(text);
+  if (!digits || [...digits].some((character) => !"0123456789".includes(character)) || !Number.isSafeInteger(number) || number < minimum || number > maximum)
+    throw new OfficeError("invalid-opc", "Invalid numeric identity.", "index");
+  return String(number);
+}
+function isPresentation(element, name) {
+  return presentationNamespaces.includes(element.name.namespace) && element.name.localName === name;
+}
+function encodeLocation(location) {
+  return JSON.stringify({
+    fingerprint: location.fingerprint,
+    scope: location.scope,
+    owner: location.owner,
+    objectId: location.objectId,
+    coordinateSystem: "identity"
+  });
+}
+function validLocation(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new SelectionError("invalid-selection");
+  const location = value;
+  if (Object.keys(value).length !== 5 || typeof location.fingerprint !== "string" || location.fingerprint.length !== 64 || [...location.fingerprint].some((c) => !"0123456789abcdef".includes(c)) || !scopes.includes(location.scope) || typeof location.owner !== "string" || typeof location.objectId !== "string" || !location.objectId || location.coordinateSystem !== "identity")
+    throw new SelectionError("invalid-selection");
+  try {
+    if (partName(location.owner, false) !== location.owner) throw new Error();
+  } catch {
+    throw new SelectionError("invalid-selection");
+  }
+}
+function decodeSelectionToken(token) {
+  if (typeof token !== "string") throw new SelectionError("invalid-selection");
+  let location;
+  try {
+    location = JSON.parse(token);
+  } catch {
+    throw new SelectionError("invalid-selection");
+  }
+  validLocation(location);
+  if (encodeLocation(location) !== token) throw new SelectionError("invalid-selection");
+  return Object.freeze(location);
+}
+async function readSelectionIndex(input, settings = {}) {
+  const context = resourceContext(settings);
+  const bytes = await readBinary(input, context, {
+    maxBytes: Math.min(context.limits.maxBytes, context.archiveLimits.maxArchiveBytes)
+  });
+  const fingerprint = Array.from(sha2562(bytes), (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+  const reader = await readPackage(bytes, context);
+  return buildSelectionIndex(reader, fingerprint, context);
+}
+function buildSelectionIndex(reader, fingerprint, settings = {}) {
+  const context = resourceContext(settings);
+  const graph = readRelationshipGraph(reader, context.relationshipLimits);
+  const roots = graph.outgoing("/").filter((edge) => relationshipNamespaces2.some((ns) => edge.type === `${ns}/officeDocument`));
+  if (roots.length !== 1 || !roots[0].targetPart || !reader.has(roots[0].targetPart))
+    throw new OfficeError(
+      "invalid-opc",
+      "Presentation relationship is missing or ambiguous.",
+      "index"
+    );
+  const presentation = roots[0].targetPart;
+  const parsed = /* @__PURE__ */ new Map();
+  const view = (part) => {
+    let found = parsed.get(part);
+    if (!found) {
+      found = interpretCompatibility(
+        parseXmlPart(reader.get(part), context.xmlLimits),
+        [
+          ...presentationNamespaces,
+          ...relationshipNamespaces2,
+          "http://schemas.openxmlformats.org/drawingml/2006/main",
+          "http://purl.oclc.org/ooxml/drawingml/main"
+        ],
+        [
+          ...equationOpaqueElements,
+          ...presentationNamespaces.map((namespace) => ({ namespace, localName: "ext" })),
+          ...[
+            "http://schemas.openxmlformats.org/drawingml/2006/main",
+            "http://purl.oclc.org/ooxml/drawingml/main"
+          ].flatMap(
+            (namespace) => ["ext", "graphicData"].map((localName) => ({ namespace, localName }))
+          )
+        ]
+      );
+      parsed.set(part, found);
+    }
+    return found;
+  };
+  const document = view(presentation);
+  if (!isPresentation(document.part.root, "presentation"))
+    throw new OfficeError("invalid-opc", "Invalid presentation root.", "index");
+  const lists = document.children(document.part.root).filter((element) => isPresentation(element, "sldIdLst"));
+  if (lists.length > 1) throw new OfficeError("invalid-opc", "Duplicate slide list.", "index");
+  const slideElements = lists[0] ? document.children(lists[0]).filter((element) => isPresentation(element, "sldId")) : [];
+  const slides = [];
+  const objects = [];
+  const parts = [];
+  const ownerScopes = /* @__PURE__ */ new Map([[presentation, "presentation"]]);
+  const record = (kind, id, name, part, scope, position, owner, objectType) => {
+    const location = Object.freeze({
+      fingerprint,
+      scope,
+      owner,
+      objectId: id,
+      coordinateSystem: "identity"
+    });
+    return Object.freeze({
+      kind,
+      id,
+      name,
+      part,
+      scope,
+      position,
+      ...objectType === void 0 ? {} : { objectType },
+      location,
+      token: encodeLocation(location)
+    });
+  };
+  for (const element of slideElements) {
+    const id = numericIdentity(attribute(element, "id"), 256, 2147483647);
+    const rid = attribute(element, "id", relationshipNamespaces2);
+    const relationship = graph.outgoing(presentation).find(
+      (edge) => edge.id === rid && relationshipNamespaces2.some((ns) => edge.type === `${ns}/slide`)
+    );
+    const part = relationship?.targetPart;
+    if (!id || !part || !reader.has(part) || slides.some((slide2) => slide2.id === id || slide2.part === part))
+      throw new OfficeError("invalid-opc", "Invalid slide identity or relationship.", "index");
+    const slide = view(part);
+    if (!isPresentation(slide.part.root, "sld"))
+      throw new OfficeError("invalid-opc", "Invalid slide root.", "index");
+    const common = slide.children(slide.part.root).find((child) => isPresentation(child, "cSld"));
+    slides.push(
+      record(
+        "slide",
+        id,
+        common ? attribute(common, "name") : "",
+        part,
+        "slides",
+        slides.length + 1,
+        presentation
+      )
+    );
+    ownerScopes.set(part, "slides");
+  }
+  const scopeTypes = {
+    notesSlide: "notes",
+    slideLayout: "layouts",
+    slideMaster: "masters",
+    notesMaster: "notes-master",
+    handoutMaster: "handout-master"
+  };
+  for (const owner of ["/", ...graph.parts])
+    for (const edge of graph.outgoing(owner)) {
+      if (!edge.targetPart) continue;
+      for (const [type, scope] of Object.entries(scopeTypes))
+        if (relationshipNamespaces2.some((ns) => edge.type === `${ns}/${type}`)) {
+          const previous = ownerScopes.get(edge.targetPart);
+          if (previous && previous !== scope)
+            throw new OfficeError("invalid-opc", "Conflicting drawing owner scopes.", "index");
+          ownerScopes.set(edge.targetPart, scope);
+        }
+    }
+  for (const part of graph.parts) {
+    const scope = ownerScopes.get(part) ?? "shared";
+    parts.push(
+      record(
+        "part",
+        "@part",
+        part,
+        part,
+        scope,
+        parts.filter((item) => item.scope === scope).length + 1,
+        part
+      )
+    );
+  }
+  const drawingOwners = [
+    ...slides.map((slide) => slide.part),
+    ...graph.parts.filter(
+      (part) => ownerScopes.has(part) && !["slides", "presentation"].includes(ownerScopes.get(part))
+    )
+  ];
+  for (const part of drawingOwners) {
+    const drawing = view(part);
+    const common = drawing.children(drawing.part.root).find((child) => isPresentation(child, "cSld"));
+    const tree = common && drawing.children(common).find((child) => isPresentation(child, "spTree"));
+    if (!tree) continue;
+    let position = 0;
+    const identities = /* @__PURE__ */ new Set();
+    const visit = (parent) => {
+      for (const element of drawing.children(parent)) {
+        if (!presentationNamespaces.includes(element.name.namespace) || !["sp", "cxnSp", "graphicFrame", "grpSp", "pic"].includes(element.name.localName))
+          continue;
+        const nonVisual = drawing.children(element).find(
+          (child) => presentationNamespaces.includes(child.name.namespace) && ["nvSpPr", "nvCxnSpPr", "nvGraphicFramePr", "nvGrpSpPr", "nvPicPr"].includes(
+            child.name.localName
+          )
+        );
+        const identity = nonVisual && drawing.children(nonVisual).find((child) => isPresentation(child, "cNvPr"));
+        if (!identity || !attribute(identity, "id"))
+          throw new OfficeError("invalid-opc", "Drawing object has no identity.", "index");
+        const objectId = numericIdentity(attribute(identity, "id"), 0, 4294967295);
+        if (identities.has(objectId))
+          throw new OfficeError(
+            "invalid-opc",
+            "Invalid or duplicate drawing object identity.",
+            "index"
+          );
+        identities.add(objectId);
+        objects.push(
+          record(
+            "object",
+            objectId,
+            attribute(identity, "name"),
+            part,
+            ownerScopes.get(part),
+            ++position,
+            part,
+            element.name.localName
+          )
+        );
+        if (isPresentation(element, "grpSp")) visit(element);
+      }
+    };
+    visit(tree);
+  }
+  const records = [...slides, ...parts, ...objects];
+  return Object.freeze({
+    fingerprint,
+    inventory: inspectInventory(
+      reader,
+      graph,
+      { slides, objects },
+      (part) => view(part).part.root,
+      context
+    ),
+    slides: Object.freeze(slides),
+    parts: Object.freeze(parts),
+    objects: Object.freeze(objects),
+    select(query) {
+      if (!query || typeof query !== "object" || Array.isArray(query) || Object.keys(query).some(
+        (key) => !["kind", "scope", "owner", "position", "id", "name", "part", "token", "all"].includes(
+          key
+        )
+      ) || query.kind !== void 0 && !["slide", "part", "object"].includes(query.kind))
+        throw new SelectionError("invalid-selection");
+      let selected = query.kind ? records.filter((item) => item.kind === query.kind) : records;
+      if (query.token !== void 0) {
+        if (typeof query.token !== "string" || Object.keys(query).some((key) => !["kind", "token"].includes(key)))
+          throw new SelectionError("invalid-selection");
+        const location = decodeSelectionToken(query.token);
+        if (location.fingerprint !== fingerprint) throw new SelectionError("stale-selection");
+        selected = selected.filter((item) => item.token === query.token);
+      } else {
+        if (!query.kind || query.scope !== void 0 && !scopes.includes(query.scope) || query.all !== void 0 && typeof query.all !== "boolean")
+          throw new SelectionError("invalid-selection");
+        for (const key of ["owner", "id", "name", "part"])
+          if (query[key] !== void 0 && (typeof query[key] !== "string" || key !== "name" && !query[key]))
+            throw new SelectionError("invalid-selection");
+        if ([query.position, query.id, query.name, query.part].filter((value) => value !== void 0).length > 1)
+          throw new SelectionError("invalid-selection");
+        if (query.kind === "slide" && query.scope !== void 0 && query.scope !== "slides")
+          throw new SelectionError("invalid-selection");
+        if (query.kind === "object" && !query.owner) throw new SelectionError("invalid-selection");
+        if (query.kind !== "part" && query.part !== void 0)
+          throw new SelectionError("invalid-selection");
+        selected = selected.filter((item) => item.scope === (query.scope ?? "slides"));
+        if (query.owner !== void 0) {
+          let owner;
+          try {
+            owner = asciiKey(partName(query.owner, false));
+          } catch {
+            throw new SelectionError("invalid-selection");
+          }
+          selected = selected.filter((item) => asciiKey(item.location.owner) === owner);
+        }
+        if (query.id !== void 0) selected = selected.filter((item) => item.id === query.id);
+        if (query.name !== void 0)
+          selected = selected.filter((item) => item.name === query.name);
+        if (query.part !== void 0) {
+          let part;
+          try {
+            part = asciiKey(partName(query.part, false));
+          } catch {
+            throw new SelectionError("invalid-selection");
+          }
+          selected = selected.filter((item) => asciiKey(item.part) === part);
+        }
+        if (query.position !== void 0) {
+          const position = query.position;
+          if (!position || typeof position !== "object" || Object.keys(position).length !== 2 || !["one-based", "zero-based"].includes(position.coordinateSystem) || !Number.isSafeInteger(position.value) || position.value < (position.coordinateSystem === "one-based" ? 1 : 0))
+            throw new SelectionError("invalid-selection");
+          selected = selected.filter(
+            (item) => item.position === position.value + (position.coordinateSystem === "zero-based" ? 1 : 0)
+          );
+        }
+      }
+      if (!selected.length) throw new SelectionError("missing-selection");
+      if (selected.length > 1 && !query.all)
+        throw new SelectionError(
+          "ambiguous-selection",
+          Object.freeze(selected.slice(0, 20).map((item) => item.location))
+        );
+      return Object.freeze(selected);
+    }
+  });
+}
+function createBatchHandles(fingerprint) {
+  if (typeof fingerprint !== "string" || fingerprint.length !== 64 || [...fingerprint].some((character) => !"0123456789abcdef".includes(character)))
+    throw new SelectionError("invalid-selection");
+  const handles = /* @__PURE__ */ new Map();
+  return Object.freeze({
+    register(name, location) {
+      if (typeof name !== "string" || !name || handles.has(name))
+        throw new SelectionError("invalid-selection");
+      validLocation(location);
+      if (location.fingerprint !== fingerprint) throw new SelectionError("stale-selection");
+      handles.set(name, Object.freeze({ ...location }));
+    },
+    resolve(name, owner) {
+      const location = handles.get(name);
+      if (location === void 0) throw new SelectionError("missing-selection");
+      if (location === null) throw new SelectionError("stale-selection");
+      if (location.owner !== owner) throw new SelectionError("invalid-selection");
+      return location;
+    },
+    invalidate(name) {
+      if (!handles.has(name)) throw new SelectionError("missing-selection");
+      handles.set(name, null);
+    }
+  });
+}
+
+export {
+  diagramContentTypes,
+  diagramRelationshipKinds,
+  SelectionError,
+  decodeSelectionToken,
+  readSelectionIndex,
+  buildSelectionIndex,
+  createBatchHandles
+};