@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,108 @@
+import {
+  SemanticValidationError,
+  validateDocumentArchive
+} from "./chunk-3SEQG5JH.js";
+import {
+  DocumentXmlEditor
+} from "./chunk-YPVBU7QF.js";
+import {
+  compatibilityProfileForPart,
+  compatibilitySettings
+} from "./chunk-GZ2N24A2.js";
+import {
+  asciiKey,
+  normalizePartName
+} from "./chunk-WAKYUXVQ.js";
+import {
+  documentXmlSettings
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocumentBudget,
+  InputTypeError,
+  InvalidValueError
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/package-write.ts
+var DocumentArchiveEditor = class {
+  #profile;
+  #archive;
+  #editors = /* @__PURE__ */ new Map();
+  #limits;
+  #budget;
+  constructor(archive, limits = {}, profile, budget = new DocumentBudget()) {
+    this.#budget = budget;
+    this.#profile = profile === void 0 ? void 0 : compatibilitySettings(profile);
+    if (!archive || !Array.isArray(archive.members) || !(archive.comment instanceof Uint8Array))
+      throw new InputTypeError("Expected an owned document archive.");
+    this.#limits = documentXmlSettings(limits, budget);
+    budget.check("zipEntries", archive.members.length);
+    let total = archive.comment.length;
+    for (const member of archive.members) {
+      if (!(member?.bytes instanceof Uint8Array)) throw new InputTypeError("Expected typed archive members.");
+      total += member.bytes.length;
+    }
+    budget.check("expandedPackage", total);
+    budget.charge("retainedBytes", total);
+    budget.charge("work", total);
+    const names = /* @__PURE__ */ new Set();
+    this.#archive = {
+      comment: new Uint8Array(archive.comment),
+      members: archive.members.map((member) => {
+        if (!member || typeof member.name !== "string" || !(member.bytes instanceof Uint8Array) || typeof member.directory !== "boolean" || !(member.modified instanceof Date))
+          throw new InputTypeError("Expected typed archive members.");
+        if (names.has(member.name)) throw new InvalidValueError("Duplicate archive member.");
+        names.add(member.name);
+        return { ...member, bytes: new Uint8Array(member.bytes), modified: new Date(member.modified.getTime()) };
+      })
+    };
+  }
+  get dirtyParts() {
+    return this.#archive.members.filter((member) => this.#editors.get(member.name)?.dirtyNodes.length).map((member) => member.name);
+  }
+  xml(name) {
+    if (typeof name !== "string") throw new InputTypeError("Expected an XML member name.");
+    let member = this.#archive.members.find((member2) => member2.name === name && !member2.directory);
+    if (!member) {
+      const key = asciiKey(normalizePartName(name.startsWith("/") ? name : "/" + name));
+      member = this.#archive.members.find((candidate) => {
+        this.#budget.charge("work", 1 + candidate.name.length);
+        return !candidate.directory && asciiKey(candidate.name) !== "[content_types].xml" && asciiKey(normalizePartName("/" + candidate.name)) === key;
+      });
+    }
+    if (!member) throw new InvalidValueError("Archive part was not found.");
+    const existing = this.#editors.get(member.name);
+    if (existing) return existing;
+    const editor = new DocumentXmlEditor(member.bytes, this.#limits, this.#profile ?? compatibilityProfileForPart("/" + member.name), this.#budget);
+    this.#editors.set(member.name, editor);
+    return editor;
+  }
+  snapshot() {
+    const copiedBytes = this.#archive.comment.length + this.#archive.members.reduce(
+      (sum, member) => sum + (this.#editors.has(member.name) ? 0 : member.bytes.length),
+      0
+    );
+    this.#budget.charge("work", copiedBytes);
+    this.#budget.charge("retainedBytes", copiedBytes);
+    const staged = {
+      comment: new Uint8Array(this.#archive.comment),
+      members: this.#archive.members.map((member) => ({
+        ...member,
+        bytes: this.#editors.get(member.name)?.serialize() ?? new Uint8Array(member.bytes),
+        modified: new Date(member.modified.getTime())
+      }))
+    };
+    if (staged.members.some((member) => member.name.toLowerCase() === "[content_types].xml")) {
+      const report = validateDocumentArchive(staged, {
+        maxNodes: this.#limits.maxNodes ?? this.#budget.limits.xmlNodes,
+        maxBytes: this.#budget.limits.expandedPackage,
+        maxParts: this.#budget.limits.zipEntries
+      }, this.#budget);
+      if (!report.valid) throw new SemanticValidationError(report.diagnostics);
+    }
+    return staged;
+  }
+};
+
+export {
+  DocumentArchiveEditor
+};

package/dist/safe-bash/command-chunks/{chunk-LQZSR6DT.js → chunk-MDV7W5AS.js}

@@ -4,7 +4,7 @@ import {
 import {
   helpText,
   parse
-} from "./chunk-XKZWUMH4.js";
+} from "./chunk-JN7GNI2C.js";
 import {
   Budget,
   DuLimitError
@@ -35,7 +35,7 @@ var Walker = class {
   root;
   failed = false;
   duplicate(stat) {
-    if (this.args.countLinks || stat.type === "directory") return false;
+    if (this.args.countLinks) return false;
     const { identityScope: scope, dev, ino } = stat;
     if ((typeof scope !== "object" || scope === null) && typeof scope !== "symbol") return false;
     if (dev === void 0 || ino === void 0 || !Number.isSafeInteger(dev) || dev < 0 || !Number.isSafeInteger(ino) || ino < 0) return false;

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

@@ -0,0 +1,168 @@
+import {
+  MarkupCompatibility,
+  compatibilityProfileForPart,
+  documentCompatibilityProfile
+} from "./chunk-GZ2N24A2.js";
+import {
+  InvalidPackageError,
+  UnsupportedProfileError,
+  isXmlContentType,
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocumentBudget
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/comment-extension-parts.ts
+var commentExtensionParts = [
+  { kind: "commentsExtended", root: "commentsEx", namespace: "http://schemas.microsoft.com/office/word/2012/wordml", relationship: "http://schemas.microsoft.com/office/2011/relationships/commentsExtended", entry: "commentEx" },
+  { kind: "commentsIds", root: "commentsIds", namespace: "http://schemas.microsoft.com/office/word/2016/wordml/cid", relationship: "http://schemas.microsoft.com/office/2016/09/relationships/commentsIds", entry: "commentId" },
+  { kind: "commentsExtensible", root: "commentsExtensible", namespace: "http://schemas.microsoft.com/office/word/2018/wordml/cex", relationship: "http://schemas.microsoft.com/office/2018/08/relationships/commentsExtensible", entry: "commentExtensible" },
+  { kind: "people", root: "people", namespace: "http://schemas.microsoft.com/office/word/2012/wordml", relationship: "http://schemas.microsoft.com/office/2011/relationships/people", entry: "person" }
+].map((part) => ({ ...part, contentType: `application/vnd.openxmlformats-officedocument.wordprocessingml.${part.kind}+xml` }));
+
+// packages/safe-bash-docx-engine/src/dialect.ts
+var documentDialects = Object.freeze({
+  strict: Object.freeze({
+    w: "http://purl.oclc.org/ooxml/wordprocessingml/main",
+    r: "http://purl.oclc.org/ooxml/officeDocument/relationships",
+    a: "http://purl.oclc.org/ooxml/drawingml/main",
+    wp: "http://purl.oclc.org/ooxml/drawingml/wordprocessingDrawing",
+    pic: "http://purl.oclc.org/ooxml/drawingml/picture",
+    c: "http://purl.oclc.org/ooxml/drawingml/chart",
+    dgm: "http://purl.oclc.org/ooxml/drawingml/diagram",
+    m: "http://purl.oclc.org/ooxml/officeDocument/math",
+    ep: "http://purl.oclc.org/ooxml/officeDocument/extendedProperties",
+    cus: "http://purl.oclc.org/ooxml/officeDocument/customProperties",
+    vt: "http://purl.oclc.org/ooxml/officeDocument/docPropsVTypes"
+  }),
+  transitional: Object.freeze({
+    w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+    r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+    a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+    wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+    pic: "http://schemas.openxmlformats.org/drawingml/2006/picture",
+    c: "http://schemas.openxmlformats.org/drawingml/2006/chart",
+    dgm: "http://schemas.openxmlformats.org/drawingml/2006/diagram",
+    m: "http://schemas.openxmlformats.org/officeDocument/2006/math",
+    ep: "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties",
+    cus: "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties",
+    vt: "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"
+  })
+});
+function dialectForNamespace(namespace) {
+  for (const dialect of ["strict", "transitional"])
+    if (Object.values(documentDialects[dialect]).includes(namespace)) return dialect;
+  return void 0;
+}
+function validateXmlDialect(root, dialect, profile = documentCompatibilityProfile, budget = new DocumentBudget()) {
+  const view = new MarkupCompatibility(root, profile, budget);
+  budget.charge("work", view.branches.length);
+  if (view.branches.some((branch) => branch.selected === void 0))
+    throw new UnsupportedProfileError("Active alternate content has no eligible choice or fallback.");
+  const stack = [...view.content];
+  while (stack.length) {
+    budget.charge("work", 1);
+    const node = stack.pop();
+    if (!("source" in node) || node.disposition === "extension") continue;
+    const element = node.source;
+    const elementDialect = dialectForNamespace(element.namespace);
+    if (elementDialect && elementDialect !== dialect)
+      throw new InvalidPackageError("Active XML uses a namespace from the opposite document dialect.");
+    if (dialect === "strict" && (element.namespace === "urn:schemas-microsoft-com:vml" || element.namespace === "urn:schemas-microsoft-com:office:office" || element.namespace === "urn:schemas-microsoft-com:office:word" || element.namespace === documentDialects.strict.w && ["pict", "hMerge", "legacy", "shapeDefaults", "hdrShapeDefaults"].includes(element.localName)))
+      throw new InvalidPackageError("Active legacy markup is not valid in the Strict dialect.");
+    if (!elementDialect && node.disposition === "opaque") continue;
+    for (const attribute of node.attributes) {
+      const attributeDialect = dialectForNamespace(attribute.namespace);
+      const valueDialect = element.namespace === documentDialects[dialect].a && element.localName === "graphicData" && !attribute.namespace && attribute.localName === "uri" ? dialectForNamespace(attribute.value) : void 0;
+      if (attributeDialect && attributeDialect !== dialect || valueDialect && valueDialect !== dialect)
+        throw new InvalidPackageError("Active XML uses a namespace from the opposite document dialect.");
+    }
+    for (const child of node.content) stack.push(child);
+  }
+  return view;
+}
+var wordRoots = {
+  "document.main": "document",
+  "template.main": "document",
+  styles: "styles",
+  settings: "settings",
+  numbering: "numbering",
+  fonttable: "fonts",
+  websettings: "webSettings",
+  header: "hdr",
+  footer: "ftr",
+  comments: "comments",
+  footnotes: "footnotes",
+  endnotes: "endnotes"
+};
+function validatePackageDialect(graph, mainEdge, root, budget = new DocumentBudget(), parsed = /* @__PURE__ */ new Map()) {
+  const main = mainEdge.target_part;
+  const dialect = dialectForNamespace(root.namespace);
+  if (!dialect || root.namespace !== documentDialects[dialect].w || root.localName !== "document")
+    throw new InvalidPackageError("The main part must have a WordprocessingML document root.");
+  if (mainEdge.reltype !== `${documentDialects[dialect].r}/officeDocument`)
+    throw new InvalidPackageError("The main relationship dialect disagrees with the document namespace.");
+  const opposite = documentDialects[dialect === "strict" ? "transitional" : "strict"];
+  for (const owner of ["/", ...graph.parts.filter((part) => part.content_type.toLowerCase() !== "application/vnd.openxmlformats-package.relationships+xml").map((part) => part.partname)]) {
+    for (const edge of graph.relationships(owner)) {
+      if (edge.reltype.startsWith(opposite.r + "/"))
+        throw new InvalidPackageError("A package relationship uses the opposite document dialect.", owner, "/", "relationship-dialect");
+      const prefix = documentDialects[dialect].r + "/";
+      const relationshipName = edge.reltype.startsWith(prefix) ? edge.reltype.slice(prefix.length).toLowerCase() : "";
+      if (Object.hasOwn(wordRoots, relationshipName) && !relationshipName.includes(".") && (edge.is_external || parseMediaType(edge.target_part.content_type) !== `application/vnd.openxmlformats-officedocument.wordprocessingml.${relationshipName}+xml`))
+        throw new InvalidPackageError("A WordprocessingML relationship target has an incompatible content type.", owner, "/", "relationship-content-type");
+    }
+  }
+  for (const part of graph.parts) {
+    const type = parseMediaType(part.content_type);
+    const prefix = "application/vnd.openxmlformats-officedocument.wordprocessingml.";
+    const word = type.startsWith(prefix) && type.endsWith("+xml");
+    const officeXml = type.startsWith("application/vnd.openxmlformats-officedocument.") && type.endsWith("+xml");
+    if (part !== main && !officeXml) {
+      if (isXmlContentType(type)) {
+        const genericRoot = parsed.get(part.bytes) ?? parseDocumentXml(part.bytes, {}, budget).root;
+        const view2 = new MarkupCompatibility(genericRoot, compatibilityProfileForPart(part.partname), budget);
+        budget.charge("work", view2.branches.length);
+        if (view2.branches.some((branch) => branch.selected === void 0))
+          throw new UnsupportedProfileError("Active alternate content has no eligible choice or fallback.");
+      }
+      continue;
+    }
+    const partRoot = part === main ? root : parsed.get(part.bytes) ?? parseDocumentXml(part.bytes, {}, budget).root;
+    budget.charge("work", part.bytes.length * 8);
+    const partDialect = dialectForNamespace(partRoot.namespace);
+    if (partDialect && partDialect !== dialect)
+      throw new InvalidPackageError("A document part root uses the opposite document dialect.", part.partname, "/", "part-root");
+    const name = type.slice(prefix.length, -4);
+    const expected = word && Object.hasOwn(wordRoots, name) ? wordRoots[name] : void 0;
+    const extension = commentExtensionParts.find((e) => e.contentType.toLowerCase() === type);
+    if (extension && (partRoot.namespace !== extension.namespace || partRoot.localName !== extension.root))
+      throw new InvalidPackageError("A comment extension root disagrees with its content type.", part.partname, "/", "part-root");
+    if (word && !extension && (partRoot.namespace !== documentDialects[dialect].w || expected && partRoot.localName !== expected))
+      throw new InvalidPackageError("A WordprocessingML part root disagrees with its content type.", part.partname, "/", "part-root");
+    let view;
+    try {
+      view = validateXmlDialect(partRoot, dialect, documentCompatibilityProfile, budget);
+    } catch (error) {
+      if (!(error instanceof InvalidPackageError)) throw error;
+      throw new InvalidPackageError(error.message, error.part ?? part.partname, error.location, error.diagnosticCode);
+    }
+    if (part === main) {
+      const document = view.content.find((node) => "source" in node && node.source === root);
+      const bodies = document && "source" in document ? document.content.filter((node) => "source" in node && node.source.namespace === documentDialects[dialect].w && node.source.localName === "body") : [];
+      if (bodies.length !== 1)
+        throw new InvalidPackageError("The main document must contain exactly one active body.");
+    }
+  }
+  return dialect;
+}
+
+export {
+  commentExtensionParts,
+  documentDialects,
+  dialectForNamespace,
+  validateXmlDialect,
+  validatePackageDialect
+};

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

@@ -0,0 +1,213 @@
+import {
+  attr,
+  invalid
+} 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/animations.ts
+async function readAnimations(input, options, context) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).some(
+    (k) => k !== "selection" || !Object.hasOwn(Object.getOwnPropertyDescriptor(options, k), "value")
+  ))
+    invalid("Invalid animation query.");
+  if (options.selection !== void 0 && (!options.selection || typeof options.selection !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options.selection)) || Reflect.ownKeys(options.selection).some(
+    (k) => typeof k !== "string" || !["kind", "scope", "owner", "position", "id", "name", "part", "token", "all"].includes(
+      k
+    ) || !Object.hasOwn(Object.getOwnPropertyDescriptor(options.selection, k), "value")
+  )))
+    throw new SelectionError("invalid-selection");
+  if (options.selection?.kind && !["slide", "object"].includes(options.selection.kind))
+    throw new SelectionError("invalid-selection");
+  if (options.selection?.scope && options.selection.scope !== "slides")
+    throw new SelectionError("invalid-selection");
+  const source = await readBinary(input, context);
+  const reader = await readPackage(source, context);
+  const index = await readSelectionIndex(source, context);
+  const selected = options.selection ? index.select(
+    options.selection.token ? options.selection : { ...options.selection, kind: options.selection.kind ?? "slide" }
+  ) : index.slides;
+  if (selected.some((n) => !["slide", "object"].includes(n.kind) || n.scope !== "slides"))
+    throw new SelectionError("invalid-selection");
+  const slides = index.slides.filter((n) => selected.some((v) => v.part === n.part));
+  const records = [];
+  for (const slide of slides) {
+    const doc = parseXmlPart(reader.get(slide.part), context.xmlLimits);
+    const nodes = [];
+    const roots = [];
+    const xml = [];
+    const diagnostics = [];
+    const timingIds = /* @__PURE__ */ new Map();
+    const shapeIds = /* @__PURE__ */ new Map();
+    const targets = /* @__PURE__ */ new Set();
+    const targetNodes = /* @__PURE__ */ new Map();
+    const references = [];
+    const stack = [{ element: doc.root, parentId: null, owner: null, active: false }];
+    while (stack.length) {
+      if (context.signal?.aborted)
+        throw new OfficeError("cancelled", "Operation cancelled.", "parse");
+      const item = stack.pop(), element = item.element;
+      const local = element.name.localName, native = element.name.namespace === doc.root.name.namespace;
+      if (native && local === "cNvPr") {
+        const id = attr(element, "id");
+        if (id !== void 0) shapeIds.set(id, (shapeIds.get(id) ?? 0) + 1);
+      }
+      const active = item.active || native && local === "timing";
+      let parentId = item.parentId, owner = item.owner;
+      if (active) {
+        const id = `${slide.token}/timing/${nodes.length + 1}`;
+        const timingId = native && local === "cTn" ? attr(element, "id") ?? null : null;
+        if (timingId !== null) {
+          const ids = timingIds.get(timingId) ?? [];
+          ids.push(id);
+          timingIds.set(timingId, ids);
+          owner = id;
+        }
+        const targetShapeId = native && local === "spTgt" ? attr(element, "spid") ?? null : null;
+        if (targetShapeId !== null) {
+          targets.add(targetShapeId);
+          const ids = targetNodes.get(targetShapeId) ?? [];
+          ids.push(id);
+          targetNodes.set(targetShapeId, ids);
+        }
+        const effect = native && [
+          "anim",
+          "animClr",
+          "animEffect",
+          "animMotion",
+          "animRot",
+          "animScale",
+          "set",
+          "cmd"
+        ].includes(local);
+        const media = native && ["audio", "video", "cMediaNode", "sndTgt", "cmd"].includes(local);
+        const node = {
+          id,
+          parentId,
+          children: [],
+          namespace: element.name.namespace,
+          type: local,
+          kind: native && local === "seq" ? "sequence" : native && local === "par" ? "parallel" : effect ? "effect" : native && local === "cond" ? "trigger" : media ? "media" : native && local === "cTn" ? "timing" : "opaque",
+          timingId,
+          targetShapeId,
+          effectType: effect ? local : native && local === "cTn" ? attr(element, "presetClass") ?? null : null,
+          triggerType: native && local === "cond" ? attr(element, "evt") ?? null : native && local === "cTn" ? attr(element, "nodeType") ?? null : null,
+          mediaInteraction: media ? local === "cmd" ? attr(element, "cmd") ?? "cmd" : local : null,
+          motionPath: native && local === "animMotion" ? attr(element, "path") ?? null : null,
+          attributes: element.attributes,
+          timingReferences: []
+        };
+        if (parentId === null) {
+          roots.push(id);
+          xml.push(doc.markup(element, true));
+        } else nodes[Number(parentId.slice(parentId.lastIndexOf("/") + 1)) - 1].children.push(id);
+        nodes.push(node);
+        if (native && local === "tn" && attr(element, "val") !== void 0)
+          references.push({ nodeId: id, owner, timingId: attr(element, "val") });
+        parentId = id;
+      }
+      for (let i = element.children.length - 1; i >= 0; i--)
+        stack.push({ element: element.children[i], parentId, owner, active });
+    }
+    for (const [id, ids] of timingIds)
+      if (ids.length > 1)
+        diagnostics.push({ code: "duplicate-timing-id", nodeIds: ids, reference: id });
+    for (const [id, count] of shapeIds)
+      if (count > 1)
+        diagnostics.push({
+          code: "duplicate-shape-id",
+          nodeIds: targetNodes.get(id) ?? [],
+          reference: id
+        });
+    for (const node of nodes)
+      if (node.targetShapeId !== null && !shapeIds.has(node.targetShapeId))
+        diagnostics.push({
+          code: "missing-target",
+          nodeIds: [node.id],
+          reference: node.targetShapeId
+        });
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    const edges = /* @__PURE__ */ new Map();
+    let resolvedDestinations = 0;
+    for (const reference of references) {
+      const ids = timingIds.get(reference.timingId) ?? [];
+      resolvedDestinations += ids.length;
+      if (resolvedDestinations > context.xmlLimits.maxNodes)
+        throw new OfficeError(
+          "resource-limit",
+          "Animation reference expansion exceeds the XML node budget.",
+          "parse"
+        );
+      byId.get(reference.nodeId).timingReferences.push({ timingId: reference.timingId, nodeIds: ids });
+      if (ids.length !== 1)
+        diagnostics.push({
+          code: ids.length ? "ambiguous-timing-reference" : "missing-timing-reference",
+          nodeIds: [reference.nodeId, ...ids],
+          reference: reference.timingId
+        });
+      else if (reference.owner) {
+        const list = edges.get(reference.owner) ?? [];
+        list.push(ids[0]);
+        edges.set(reference.owner, list);
+      }
+    }
+    const state = /* @__PURE__ */ new Map();
+    for (const start of edges.keys()) {
+      if (state.has(start)) continue;
+      const pending = [{ id: start, cursor: 0 }];
+      state.set(start, 1);
+      while (pending.length) {
+        if (context.signal?.aborted)
+          throw new OfficeError("cancelled", "Operation cancelled.", "parse");
+        const frame = pending[pending.length - 1], next = (edges.get(frame.id) ?? [])[frame.cursor++];
+        if (next === void 0) {
+          state.set(frame.id, 2);
+          pending.pop();
+          continue;
+        }
+        if (state.get(next) === 1)
+          diagnostics.push({
+            code: "timing-cycle",
+            nodeIds: [frame.id, next],
+            reference: byId.get(next).timingId
+          });
+        else if (!state.has(next)) {
+          state.set(next, 1);
+          pending.push({ id: next, cursor: 0 });
+        }
+      }
+    }
+    if (selected.some((n) => n.kind === "slide" && n.part === slide.part) || selected.some((n) => n.part === slide.part && targets.has(n.id)))
+      records.push({
+        selector: slide.token,
+        location: slide.location,
+        slide: slide.position,
+        part: slide.part,
+        roots,
+        xml,
+        nodes,
+        diagnostics,
+        targetShapeIds: [...targets],
+        executionVerified: false
+      });
+  }
+  return records;
+}
+
+export {
+  readAnimations
+};