@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,639 @@
+import {
+  requireLegacyCommentRemapping
+} from "./chunk-6JTPLJ3B.js";
+import {
+  attr,
+  child,
+  escape,
+  invalid,
+  loadShared,
+  nextRel,
+  relPart
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError,
+  decodeSelectionToken
+} from "./chunk-CKEODJVT.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  parseContentTypes
+} from "./chunk-N74TJL6X.js";
+import {
+  relativePartReference
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/modern-comments.ts
+import { SaxesParser } from "saxes";
+var modernCommentsRelationship = "http://schemas.microsoft.com/office/2018/10/relationships/comments";
+var namespace = "http://schemas.microsoft.com/office/powerpoint/2018/8/main";
+var reactionNamespace = "http://schemas.microsoft.com/office/powerpoint/2022/03/main";
+function children(node, local, ns = namespace) {
+  return node.children.filter((n) => n.name.namespace === ns && n.name.localName === local);
+}
+function required(node, name) {
+  const value = attr(node, name);
+  if (value === void 0) invalid("Modern comment metadata is missing.");
+  return value;
+}
+function content(doc, body) {
+  if (!body) return "";
+  const a = "http://schemas.openxmlformats.org/drawingml/2006/main";
+  return children(body, "p", a).map(
+    (p) => p.children.map((n) => {
+      if (n.name.namespace !== a) return "";
+      if (n.name.localName === "br") return "\v";
+      if (!["r", "fld"].includes(n.name.localName)) return "";
+      return children(n, "t", a).map((t) => {
+        let value = "";
+        const parser = new SaxesParser({ xmlns: true });
+        parser.on("text", (v) => value += v);
+        parser.on("cdata", (v) => value += v);
+        parser.write(doc.markup(t, true)).close();
+        return value;
+      }).join("");
+    }).join("")
+  ).join("\n");
+}
+function modernCommentAuthors(s) {
+  const authors2 = [];
+  for (const edge of s.index.inventory.relationships.filter(
+    (e) => e.owner === s.main && !e.external && e.type === "http://schemas.microsoft.com/office/2018/10/relationships/authors"
+  )) {
+    const doc = s.doc(edge.targetPart);
+    if (doc.root.name.namespace !== namespace || doc.root.name.localName !== "authorLst")
+      invalid("Invalid modern author list.");
+    for (const node of children(doc.root, "author"))
+      authors2.push({
+        id: required(node, "id"),
+        name: required(node, "name"),
+        initials: attr(node, "initials") ?? null,
+        userId: required(node, "userId"),
+        providerId: required(node, "providerId"),
+        part: edge.targetPart,
+        xml: doc.markup(node, true)
+      });
+  }
+  if (new Set(authors2.map((a) => a.id)).size !== authors2.length)
+    invalid("Duplicate modern author identities.");
+  return authors2;
+}
+function modernCommentRecords(s, slides) {
+  const authors2 = modernCommentAuthors(s);
+  return slides.flatMap(
+    (slide) => s.index.inventory.relationships.filter((e) => e.owner === slide.part && !e.external && e.type === modernCommentsRelationship).flatMap((edge) => {
+      const part = edge.targetPart, doc = s.doc(part);
+      if (doc.root.name.namespace !== namespace || doc.root.name.localName !== "cmLst")
+        invalid("Invalid modern comment list.");
+      const ids = /* @__PURE__ */ new Set();
+      function record(node, threadId, parentId) {
+        const id = required(node, "id"), authorId = required(node, "authorId");
+        if (ids.has(id)) invalid("Duplicate modern comment identities.");
+        ids.add(id);
+        const authorIdentity = authors2.find((a) => a.id === authorId) ?? null;
+        const location = {
+          fingerprint: s.index.fingerprint,
+          scope: "slides",
+          owner: part,
+          objectId: id,
+          coordinateSystem: "identity"
+        };
+        const pos = children(node, "pos")[0];
+        const coordinate2 = (key) => {
+          const value = pos ? attr(pos, key) : void 0;
+          if (value === void 0) return 0;
+          const digits = value.startsWith("-") || value.startsWith("+") ? value.slice(1) : value;
+          if (!digits || [...digits].some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(value)))
+            invalid("Invalid modern comment position.");
+          return Number(value);
+        };
+        const reactions = [];
+        for (const list of children(node, "extLst"))
+          for (const ext of children(
+            list,
+            "ext",
+            "http://schemas.openxmlformats.org/presentationml/2006/main"
+          ))
+            for (const group of children(ext, "reactions", reactionNamespace))
+              for (const reaction of children(group, "rxn", reactionNamespace))
+                reactions.push({
+                  type: required(reaction, "type"),
+                  instances: children(reaction, "instance", reactionNamespace).map((n) => ({
+                    authorId: required(n, "authorId"),
+                    timestamp: required(n, "time")
+                  }))
+                });
+        return {
+          id,
+          selector: JSON.stringify(location),
+          location,
+          slide: slide.position,
+          part,
+          authorId,
+          index: null,
+          author: authorIdentity?.name ?? "",
+          initials: authorIdentity?.initials ?? "",
+          text: content(doc, children(node, "txBody")[0]),
+          timestamp: required(node, "created"),
+          left: coordinate2("x"),
+          top: coordinate2("y"),
+          format: "modern",
+          status: attr(node, "status") ?? "active",
+          threadId,
+          parentId,
+          authorIdentity,
+          replies: children(node, "replyLst").flatMap(
+            (list) => children(list, "reply").map((reply) => record(reply, threadId, id))
+          ),
+          reactions,
+          opaqueXml: doc.markup(node, true)
+        };
+      }
+      return children(doc.root, "cm").map((node) => record(node, required(node, "id"), null));
+    })
+  );
+}
+
+// packages/safe-bash-presentation-engine/src/comments.ts
+import { SaxesParser as SaxesParser2 } from "saxes";
+function ticks(emu) {
+  return Math.sign(emu) * Math.round(Math.abs(emu) / 1587.5);
+}
+var relns = "http://schemas.openxmlformats.org/package/2006/relationships";
+function plain(value, keys) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Object.keys(value).some((k) => !keys.includes(k)))
+    invalid("Invalid comment options.");
+}
+function text(value) {
+  if (typeof value !== "string") invalid("Comment fields require text.");
+  for (const c of value) {
+    const n = c.codePointAt(0);
+    if (n < 32 && ![9, 10, 13].includes(n) || n >= 55296 && n <= 57343 || n === 65534 || n === 65535)
+      invalid("Comment text requires valid XML characters.");
+  }
+}
+function uint(value) {
+  if (!value || [...value].some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(value)) || Number(value) > 4294967295)
+    invalid("Invalid comment identity.");
+  return Number(value);
+}
+function coordinate(value) {
+  if (value === void 0) return 0;
+  const digits = value.startsWith("-") || value.startsWith("+") ? value.slice(1) : value;
+  const n = Number(value);
+  if (!digits || [...digits].some((c) => c < "0" || c > "9") || !Number.isInteger(n) || n < -2147483648 || n > 2147483647)
+    invalid("Invalid comment position.");
+  return n * 1587.5;
+}
+function xmlNames(reader, changes, deleted, limits) {
+  const names = /* @__PURE__ */ new Set([...reader.names, ...changes.keys()]);
+  const types = parseContentTypes(
+    changes.get("/[Content_Types].xml") ?? reader.get("/[Content_Types].xml"),
+    { ...limits, maxEntries: names.size }
+  );
+  return [...names].filter(
+    (name) => !deleted.has(name) && name !== "/[Content_Types].xml" && (types.get(name).endsWith("+xml") || ["application/xml", "text/xml"].includes(types.get(name)))
+  );
+}
+function authorsPart(s) {
+  const edges = s.index.inventory.relationships.filter(
+    (e) => e.owner === s.main && e.type === `${s.r}/commentAuthors` && !e.external
+  );
+  if (edges.length > 1) invalid("Multiple comment author lists.");
+  return edges[0]?.targetPart ?? [...s.changes.keys()].find((n) => n === "/ppt/commentAuthors.xml");
+}
+function authors(s) {
+  const part = authorsPart(s);
+  if (!part) return [];
+  const doc = s.doc(part);
+  if (doc.root.name.namespace !== s.p || doc.root.name.localName !== "cmAuthorLst")
+    invalid("Invalid comment author list.");
+  const result = doc.root.children.filter(
+    (n) => n.name.namespace === s.p && n.name.localName === "cmAuthor"
+  );
+  const ids = result.map((n) => String(uint(attr(n, "id"))));
+  if (new Set(ids).size !== ids.length) invalid("Duplicate comment author IDs.");
+  return result;
+}
+function resolveSelection(s, selection) {
+  if (selection.token === void 0) return { selection };
+  const location = decodeSelectionToken(selection.token);
+  if (location.fingerprint !== s.index.fingerprint) throw new SelectionError("stale-selection");
+  const edge = s.index.inventory.relationships.find(
+    (e) => e.targetPart === location.owner && [`${s.r}/comments`, modernCommentsRelationship].includes(e.type) && !e.external
+  );
+  if (!edge) return { selection };
+  if (Object.keys(selection).some((k) => !["kind", "token"].includes(k)) || location.scope !== "slides")
+    throw new SelectionError("invalid-selection");
+  const slide = s.index.slides.find((n) => n.part === edge.owner);
+  if (!slide) throw new SelectionError("missing-selection");
+  return { selection: { kind: "slide", token: slide.token }, location };
+}
+function records(s, selection) {
+  const resolved = selection ? resolveSelection(s, selection) : void 0;
+  const query = resolved?.selection;
+  const selected = query ? s.index.select({ ...query, kind: query.kind ?? "slide" }) : s.index.slides;
+  if (selected.some((n) => n.kind !== "slide")) throw new SelectionError("invalid-selection");
+  const authorNodes = authors(s);
+  const result = selected.flatMap(
+    (slide) => s.index.inventory.relationships.filter((e) => e.owner === slide.part && e.type === `${s.r}/comments` && !e.external).flatMap((edge) => {
+      const part = edge.targetPart;
+      const doc = s.doc(part);
+      if (doc.root.name.namespace !== s.p || doc.root.name.localName !== "cmLst")
+        invalid("Invalid legacy comment list.");
+      return doc.root.children.filter((n) => n.name.namespace === s.p && n.name.localName === "cm").map((n) => {
+        const authorId = String(uint(attr(n, "authorId"))), index = uint(attr(n, "idx"));
+        const author = authorNodes.find((a) => String(uint(attr(a, "id"))) === authorId);
+        if (!author) invalid("Comment author is missing.");
+        const position = child(n, "pos"), content2 = child(n, "text");
+        let value = "";
+        if (content2) {
+          const parser = new SaxesParser2({ xmlns: true });
+          parser.on("text", (v) => value += v);
+          parser.on("cdata", (v) => value += v);
+          parser.write(doc.markup(content2, true)).close();
+        }
+        const location = {
+          fingerprint: s.index.fingerprint,
+          scope: "slides",
+          owner: part,
+          objectId: `${authorId}:${index}`,
+          coordinateSystem: "identity"
+        };
+        return {
+          id: `${authorId}:${index}`,
+          selector: JSON.stringify(location),
+          location,
+          slide: slide.position,
+          part,
+          authorId,
+          index,
+          author: attr(author, "name") ?? "",
+          initials: attr(author, "initials") ?? "",
+          text: value,
+          timestamp: attr(n, "dt") ?? "",
+          left: coordinate(position ? attr(position, "x") : void 0),
+          top: coordinate(position ? attr(position, "y") : void 0)
+        };
+      });
+    })
+  );
+  const identities = result.map((r) => `${r.slide}:${r.part}:${r.id}`);
+  if (new Set(identities).size !== identities.length)
+    throw new SelectionError("ambiguous-selection");
+  return resolved?.location ? result.filter(
+    (r) => r.part === resolved.location.owner && r.id === resolved.location.objectId
+  ) : result;
+}
+async function readCommentAuthors(input, context) {
+  const state = await loadShared(input, context, false);
+  const part = authorsPart(state);
+  authors(state);
+  const doc = part ? state.doc(part) : void 0;
+  const legacy = (doc?.root.children.filter(
+    (node) => node.name.namespace === state.p && node.name.localName === "cmAuthor"
+  ) ?? []).map((node) => ({
+    id: String(uint(attr(node, "id"))),
+    name: attr(node, "name") ?? "",
+    initials: attr(node, "initials") ?? "",
+    part,
+    xml: doc.markup(node, true)
+  }));
+  return [...legacy, ...modernCommentAuthors(state)];
+}
+async function readComments(input, options, context) {
+  plain(options, ["selection", "id"]);
+  if (options.id !== void 0) text(options.id);
+  const state = await loadShared(input, context, false);
+  const resolved = options.selection ? resolveSelection(state, options.selection) : void 0;
+  const slides = resolved ? state.index.select({ ...resolved.selection, kind: resolved.selection.kind ?? "slide" }) : state.index.slides;
+  if (slides.some((s) => s.kind !== "slide")) throw new SelectionError("invalid-selection");
+  const modern = modernCommentRecords(state, slides);
+  const flatten = (rows) => rows.flatMap((row) => [row, ...flatten(row.replies)]);
+  const modernMatches = resolved?.location || options.id !== void 0 ? flatten(modern).filter(
+    (row) => !resolved?.location || row.part === resolved.location.owner && row.id === resolved.location.objectId
+  ) : modern;
+  const found = [...records(state, options.selection), ...modernMatches].sort(
+    (a, b) => a.slide - b.slide
+  );
+  return options.id === void 0 ? found : found.filter((r) => r.id === options.id);
+}
+function validateCommentsOptions(action, options) {
+  plain(options, [
+    "selection",
+    "id",
+    "text",
+    "author",
+    "authorId",
+    "initials",
+    "timestamp",
+    "left",
+    "top",
+    "all",
+    "allowEmpty"
+  ]);
+  if (!["add", "set", "remove"].includes(action) || !options.selection || typeof options.selection !== "object")
+    invalid("Comment selection is required.");
+  for (const key of ["id", "text", "author", "authorId", "initials", "timestamp"])
+    if (options[key] !== void 0) text(options[key]);
+  if (options.authorId !== void 0) uint(options.authorId);
+  if (options.timestamp !== void 0) {
+    const t = options.timestamp;
+    const parsed = new Date(t);
+    if (!t.endsWith("Z") || t.length < 20 || !Number.isFinite(parsed.getTime()) || parsed.toISOString().slice(0, 19) !== t.slice(0, 19))
+      invalid("Timestamp must be an explicit valid UTC date-time.");
+  }
+  for (const key of ["left", "top"])
+    if (options[key] !== void 0 && (!Number.isFinite(options[key]) || !Number.isSafeInteger(options[key]) || Math.abs(options[key] / 1587.5) > 2147483647))
+      invalid("Comment positions require representable eighth-point lengths.");
+  for (const key of ["all", "allowEmpty"])
+    if (options[key] !== void 0 && typeof options[key] !== "boolean")
+      invalid("Comment cardinality flags require booleans.");
+  if (action === "add" && (options.text === void 0 || !options.author || options.timestamp === void 0 || options.id !== void 0))
+    invalid("Comment creation requires text, author and timestamp.");
+  if (action === "remove" && ["text", "author", "authorId", "initials", "timestamp", "left", "top"].some(
+    (k) => options[k] !== void 0
+  ))
+    invalid("Comment removal forbids edit fields.");
+  if (action === "set" && !["text", "author", "authorId", "initials", "timestamp", "left", "top"].some(
+    (k) => options[k] !== void 0
+  ))
+    invalid("Comment edit requires a field.");
+  if (options.initials !== void 0 && options.author === void 0 && options.authorId === void 0)
+    invalid("Initials require an explicit author.");
+}
+function createPart(s, part, root, kind, owner, context) {
+  s.save(
+    part,
+    parseXmlPart(new TextEncoder().encode(`<p:${root} xmlns:p="${s.p}"/>`), context.xmlLimits)
+  );
+  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-officedocument.presentationml.${kind}+xml"/>`
+    ])
+  );
+  const name = relPart(owner), rel = s.reader.has(name) || s.changes.has(name) ? s.doc(name) : parseXmlPart(
+    new TextEncoder().encode(`<Relationships xmlns="${relns}"/>`),
+    context.xmlLimits
+  );
+  s.save(
+    name,
+    rel.spliceChildren(rel.root, rel.root.children.length, 0, [
+      `<Relationship xmlns="${relns}" Id="${nextRel(rel)}" Type="${s.r}/${kind}" Target="${escape(relativePartReference(part, owner.slice(0, owner.lastIndexOf("/"))))}"/>`
+    ])
+  );
+}
+function authorFor(s, options, context) {
+  let part = authorsPart(s);
+  if (!part) {
+    part = "/ppt/commentAuthors.xml";
+    if (s.reader.has(part)) invalid("Comment author part is already occupied.");
+    createPart(s, part, "cmAuthorLst", "commentAuthors", s.main, context);
+  }
+  const nodes = authors(s);
+  const matches = options.authorId !== void 0 ? nodes.filter((n) => uint(attr(n, "id")) === uint(options.authorId)) : nodes.filter((n) => attr(n, "name") === options.author);
+  if (matches.length > 1) throw new SelectionError("ambiguous-selection");
+  if (matches[0]) {
+    const n = matches[0];
+    if (options.author !== void 0 && options.author !== attr(n, "name") || options.initials !== void 0 && options.initials !== attr(n, "initials"))
+      invalid("An existing author identity has different details.");
+    return String(uint(attr(n, "id")));
+  }
+  if (!options.author) invalid("New authors require a display name.");
+  const used = new Set(nodes.map((n) => uint(attr(n, "id"))));
+  let id = options.authorId === void 0 ? 0 : uint(options.authorId);
+  while (used.has(id)) id++;
+  if (id > 4294967295) invalid("Comment author IDs exhausted.");
+  const doc = s.doc(part);
+  s.save(
+    part,
+    doc.spliceChildren(doc.root, doc.root.children.length, 0, [
+      `<p:cmAuthor xmlns:p="${s.p}" id="${id}" name="${escape(options.author)}" initials="${escape(options.initials ?? "")}" lastIdx="0" clrIdx="${id}"/>`
+    ])
+  );
+  return String(id);
+}
+function nextIndex(s, authorId, context) {
+  const part = authorsPart(s);
+  let doc = s.doc(part);
+  const node = authors(s).find((n) => String(uint(attr(n, "id"))) === authorId);
+  let index = uint(attr(node, "lastIdx"));
+  for (const name of xmlNames(s.reader, s.changes, s.deleted, context.xmlLimits)) {
+    const parsed = s.doc(name);
+    if (parsed.root.name.namespace !== s.p || parsed.root.name.localName !== "cmLst") continue;
+    for (const cm of parsed.root.children)
+      if (cm.name.namespace === s.p && cm.name.localName === "cm" && String(uint(attr(cm, "authorId"))) === authorId)
+        index = Math.max(index, uint(attr(cm, "idx")));
+  }
+  if (index === 4294967295) invalid("Comment indices exhausted.");
+  index++;
+  const target = doc.root.children.find((n) => String(uint(attr(n, "id"))) === authorId);
+  doc = doc.merge(target, {
+    attributes: [{ namespace: "", localName: "lastIdx", value: String(index) }]
+  });
+  s.save(part, doc);
+  return index;
+}
+async function mutateComments(input, action, options, context) {
+  validateCommentsOptions(action, options);
+  const s = await loadShared(input, context);
+  let slides;
+  try {
+    const resolved = resolveSelection(s, options.selection);
+    if (action === "add" && resolved.location) throw new SelectionError("invalid-selection");
+    slides = s.index.select({ ...resolved.selection, kind: resolved.selection.kind ?? "slide" });
+  } catch (e) {
+    if (!(e instanceof SelectionError) || e.code !== "missing-selection" || !options.allowEmpty)
+      throw e;
+    slides = [];
+  }
+  if (slides.some((n) => n.kind !== "slide")) throw new SelectionError("invalid-selection");
+  const modern = modernCommentRecords(s, slides);
+  const modernIds = modern.flatMap((row) => [row.id, ...row.replies.map((reply) => reply.id)]);
+  const targetId = options.id ?? (options.selection.token ? decodeSelectionToken(options.selection.token).objectId : void 0);
+  if (modern.length && (action === "add" || targetId === void 0 || modernIds.includes(targetId)))
+    throw new OfficeError(
+      "unsupported-edit",
+      "Modern comments are preserved and cannot be edited.",
+      "validate-intent"
+    );
+  const matches = action === "add" || !slides.length ? [] : records(s, options.selection).filter(
+    (r) => options.id === void 0 || r.id === options.id
+  );
+  const count = action === "add" ? slides.length : matches.length;
+  if (!count) {
+    if (!options.allowEmpty) throw new SelectionError("missing-selection");
+    return { bytes: s.source, affected: 0, locations: [] };
+  }
+  if (count > 1 && !options.all) throw new SelectionError("ambiguous-selection");
+  const touchedParts = action === "add" ? s.index.inventory.relationships.filter(
+    (e) => slides.some((slide) => slide.part === e.owner) && e.type === `${s.r}/comments` && !e.external
+  ).map((e) => e.targetPart) : matches.map((r) => r.part);
+  for (const part of new Set(touchedParts)) {
+    const incoming = s.index.inventory.relationships.filter((e) => e.targetPart === part);
+    if (incoming.length !== 1 || incoming[0].type !== `${s.r}/comments` || !slides.some((slide) => slide.part === incoming[0].owner))
+      throw new OfficeError(
+        "unsupported-edit",
+        "Shared comment parts cannot be edited safely.",
+        "validate-intent"
+      );
+  }
+  const changedAuthors = /* @__PURE__ */ new Set();
+  const locations = [];
+  if (action === "add") {
+    const authorId = authorFor(s, options, context);
+    for (const slide of slides) {
+      let part = s.index.inventory.relationships.find(
+        (e) => e.owner === slide.part && e.type === `${s.r}/comments` && !e.external
+      )?.targetPart;
+      if (!part) {
+        let i = 1;
+        while (s.reader.has(`/ppt/comments/comment${i}.xml`) || s.changes.has(`/ppt/comments/comment${i}.xml`))
+          i++;
+        part = `/ppt/comments/comment${i}.xml`;
+        createPart(s, part, "cmLst", "comments", slide.part, context);
+      }
+      const index = nextIndex(s, authorId, context), doc = s.doc(part);
+      s.save(
+        part,
+        doc.spliceChildren(doc.root, doc.root.children.length, 0, [
+          `<p:cm xmlns:p="${s.p}" authorId="${authorId}" dt="${escape(options.timestamp.slice(0, 19) + "Z")}" idx="${index}"><p:pos x="${ticks(options.left ?? 0)}" y="${ticks(options.top ?? 0)}"/><p:text>${escape(options.text)}</p:text></p:cm>`
+        ])
+      );
+      locations.push(slide.location);
+    }
+  } else
+    for (const record of matches) {
+      let doc = s.doc(record.part);
+      const find = () => doc.root.children.find(
+        (n) => n.name.namespace === s.p && n.name.localName === "cm" && String(uint(attr(n, "authorId"))) === record.authorId && Number(attr(n, "idx")) === record.index
+      );
+      let node = find();
+      if (action === "remove") {
+        doc = doc.spliceChildren(doc.root, doc.root.children.indexOf(node), 1, []);
+        changedAuthors.add(record.authorId);
+      } else {
+        if (options.author !== void 0 || options.authorId !== void 0) {
+          const authorId = authorFor(s, options, context);
+          if (authorId !== record.authorId) {
+            requireLegacyCommentRemapping(doc.root, s.p);
+            const authorPart = authorsPart(s);
+            if (authorPart) requireLegacyCommentRemapping(s.doc(authorPart).root, s.p);
+            const index = nextIndex(s, authorId, context);
+            doc = doc.merge(node, {
+              attributes: [
+                { namespace: "", localName: "authorId", value: authorId },
+                { namespace: "", localName: "idx", value: String(index) }
+              ]
+            });
+            node = doc.root.children.find(
+              (n) => String(uint(attr(n, "authorId"))) === authorId && Number(attr(n, "idx")) === index
+            );
+            changedAuthors.add(record.authorId);
+          }
+        }
+        const at = doc.root.children.indexOf(node);
+        if (options.timestamp !== void 0)
+          doc = doc.merge(node, {
+            attributes: [
+              { namespace: "", localName: "dt", value: options.timestamp.slice(0, 19) + "Z" }
+            ]
+          });
+        if (options.text !== void 0) {
+          node = doc.root.children[at];
+          const old = child(node, "text");
+          doc = doc.spliceChildren(
+            node,
+            old ? node.children.indexOf(old) : node.children.length,
+            old ? 1 : 0,
+            [`<p:text xmlns:p="${s.p}">${escape(options.text)}</p:text>`]
+          );
+        }
+        if (options.left !== void 0 || options.top !== void 0) {
+          node = doc.root.children[at];
+          const old = child(node, "pos");
+          doc = old ? doc.merge(old, {
+            attributes: [
+              {
+                namespace: "",
+                localName: "x",
+                value: String(ticks(options.left ?? record.left))
+              },
+              { namespace: "", localName: "y", value: String(ticks(options.top ?? record.top)) }
+            ]
+          }) : doc.spliceChildren(node, 0, 0, [
+            `<p:pos xmlns:p="${s.p}" x="${ticks(options.left ?? record.left)}" y="${ticks(options.top ?? record.top)}"/>`
+          ]);
+        }
+      }
+      s.save(record.part, doc);
+      locations.push(record.location);
+    }
+  cleanupCommentAuthors(
+    s.reader,
+    s.changes,
+    s.deleted,
+    changedAuthors,
+    s.p,
+    context.xmlLimits,
+    authorsPart(s)
+  );
+  return {
+    bytes: (await s.finish(
+      s.main,
+      slides.map((n) => n.position)
+    )).bytes,
+    affected: count,
+    locations
+  };
+}
+function cleanupCommentAuthors(reader, changes, deleted, candidates, namespace2, xmlLimits, authorPart) {
+  if (candidates.size) {
+    const used = /* @__PURE__ */ new Set();
+    let safe = true;
+    for (const name of xmlNames(reader, changes, deleted, xmlLimits)) {
+      const doc = parseXmlPart(changes.get(name) ?? reader.get(name), xmlLimits);
+      if (doc.root.name.namespace !== namespace2 || doc.root.name.localName !== "cmLst") continue;
+      for (const n of doc.root.children) {
+        if (n.name.namespace !== namespace2 || n.name.localName !== "cm") {
+          safe = false;
+          continue;
+        }
+        used.add(String(uint(attr(n, "authorId"))));
+        if (n.children.some(
+          (c) => c.name.namespace !== namespace2 || !["pos", "text"].includes(c.name.localName)
+        ))
+          safe = false;
+      }
+    }
+    const part = authorPart;
+    if (safe && part) {
+      let doc = parseXmlPart(changes.get(part) ?? reader.get(part), xmlLimits);
+      if (doc.root.children.some(
+        (n) => n.name.namespace !== namespace2 || n.name.localName !== "cmAuthor"
+      ))
+        return;
+      for (let i = doc.root.children.length - 1; i >= 0; i--) {
+        const n = doc.root.children[i];
+        const id = String(uint(attr(n, "id")));
+        if (n.name.namespace === namespace2 && n.name.localName === "cmAuthor" && id && candidates.has(id) && !used.has(id) && !n.children.length)
+          doc = doc.spliceChildren(doc.root, i, 1, []);
+      }
+      changes.set(part, doc.bytes());
+    }
+  }
+}
+
+export {
+  readCommentAuthors,
+  readComments,
+  validateCommentsOptions,
+  mutateComments,
+  cleanupCommentAuthors
+};