@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,287 @@
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  compareInventoryNames
+} from "./chunk-2EUH5B6A.js";
+import {
+  validateDocxValue
+} from "./chunk-R4TYL2G6.js";
+import {
+  MarkupCompatibility
+} from "./chunk-GZ2N24A2.js";
+import {
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  InvalidDocumentError,
+  InvalidValueError
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/stored-date-time.ts
+function parseStoredDateTime(raw, flavor) {
+  if (flavor === "xsd") {
+    let start = 0, end = raw.length;
+    while (start < end && " 	\r\n".includes(raw[start])) start++;
+    while (end > start && " 	\r\n".includes(raw[end - 1])) end--;
+    raw = raw.slice(start, end);
+    if (raw.slice(0, 4) === "0000") throw new InvalidValueError("XML dateTime values require a nonzero native year.");
+  }
+  let wall, offset = 0;
+  if (raw.endsWith("Z")) wall = raw.slice(0, -1);
+  else {
+    const zone = raw.slice(-6);
+    if (!["+", "-"].includes(zone[0]) || zone[3] !== ":" || [...zone.slice(1)].some((char, index) => index !== 2 && !"0123456789".includes(char)))
+      throw new InvalidValueError("Expected an explicit stored property timezone.");
+    const hours = Number(zone.slice(1, 3)), minutes = Number(zone.slice(4));
+    if (hours > 23 || minutes > 59 || flavor === "xsd" && hours * 60 + minutes > 840)
+      throw new InvalidValueError("Expected a valid stored property timezone.");
+    wall = raw.slice(0, -6);
+    offset = (hours * 60 + minutes) * (zone[0] === "+" ? 1 : -1);
+  }
+  if (flavor === "w3cdtf" && wall.length === 16) wall += ":00";
+  let nextDay = false;
+  if (flavor === "xsd" && wall.slice(11, 13) === "24") {
+    const fraction = wall.slice(19);
+    if (wall.slice(13, 19) !== ":00:00" || fraction && (fraction[0] !== "." || fraction.length === 1 || [...fraction.slice(1)].some((char) => char !== "0")))
+      throw new InvalidValueError("Expected zero fields after stored midnight24.");
+    wall = wall.slice(0, 11) + "00" + wall.slice(13);
+    nextDay = true;
+  }
+  if (!validateDocxValue("UTC instant", wall + "Z")) throw new InvalidValueError("Expected a valid stored calendar instant.");
+  return new Date((/* @__PURE__ */ new Date(wall + "Z")).getTime() + (nextDay ? 864e5 : 0) - offset * 6e4);
+}
+
+// packages/safe-bash-docx-engine/src/stored-lexical.ts
+function trimXmlWhitespace(raw) {
+  let first = 0, last = raw.length;
+  while (first < last && [" ", "	", "\r", "\n"].includes(raw[first])) first++;
+  while (last > first && [" ", "	", "\r", "\n"].includes(raw[last - 1])) last--;
+  return raw.slice(first, last);
+}
+function storedIntegerIdentity(raw) {
+  if (raw === void 0) return void 0;
+  const token = trimXmlWhitespace(raw);
+  const sign = token[0] === "-" || token[0] === "+";
+  const digits = sign ? token.slice(1) : token;
+  if (!digits.length || [...digits].some((character) => character < "0" || character > "9")) return void 0;
+  let first = 0;
+  while (first < digits.length - 1 && digits[first] === "0") first++;
+  const magnitude = digits.slice(first);
+  return token[0] === "-" && magnitude !== "0" ? "-" + magnitude : magnitude;
+}
+function storedBoolean(raw, message = "Invalid stored document boolean.") {
+  const value = storedBooleanValue(raw);
+  if (value !== null) return value;
+  throw new InvalidDocumentError(message);
+}
+function storedBooleanValue(raw) {
+  if (raw === "on") return true;
+  if (raw === "off") return false;
+  const token = trimXmlWhitespace(raw);
+  if (["1", "true"].includes(token)) return true;
+  if (["0", "false"].includes(token)) return false;
+  return null;
+}
+
+// packages/safe-bash-docx-engine/src/property-values.ts
+var corePropertyNamespace = "http://schemas.openxmlformats.org/package/2006/metadata/core-properties";
+var customPropertyFormatId = "{D5CDD505-2E9C-101B-9397-08002B2CF9AE}";
+var dc = "http://purl.org/dc/elements/1.1/";
+var terms = "http://purl.org/dc/terms/";
+var corePropertyKeys = Object.freeze(Object.fromEntries([
+  ["title", dc, "title", "string"],
+  ["subject", dc, "subject", "string"],
+  ["author", dc, "creator", "string"],
+  ["keywords", corePropertyNamespace, "keywords", "string"],
+  ["comments", dc, "description", "string"],
+  ["lastModifiedBy", corePropertyNamespace, "lastModifiedBy", "string"],
+  ["category", corePropertyNamespace, "category", "string"],
+  ["contentStatus", corePropertyNamespace, "contentStatus", "string"],
+  ["identifier", dc, "identifier", "string"],
+  ["language", dc, "language", "string"],
+  ["version", corePropertyNamespace, "version", "string"],
+  ["revision", corePropertyNamespace, "revision", "integer"],
+  ["created", terms, "created", "date"],
+  ["modified", terms, "modified", "date"],
+  ["lastPrinted", corePropertyNamespace, "lastPrinted", "date"]
+].map(([key, namespace, localName, type]) => [key, { namespace, localName, type }])));
+var extendedPropertyKeys = Object.freeze(Object.fromEntries([
+  ["company", "Company", "string", false],
+  ["manager", "Manager", "string", false],
+  ["template", "Template", "string", false],
+  ["pages", "Pages", "integer", true],
+  ["words", "Words", "integer", true],
+  ["characters", "Characters", "integer", true],
+  ["charactersWithSpaces", "CharactersWithSpaces", "integer", true],
+  ["lines", "Lines", "integer", true],
+  ["paragraphs", "Paragraphs", "integer", true],
+  ["totalTime", "TotalTime", "integer", true],
+  ["application", "Application", "string", true],
+  ["appVersion", "AppVersion", "string", true]
+].map(([key, localName, type, cached]) => [key, { localName, type, cached }])));
+function propertyAttribute(node, name) {
+  return node.attributes.find((a) => a.namespace === "" && a.localName === name)?.value ?? null;
+}
+function normalizePropertyDate(value) {
+  if (!validateDocxValue("UTC instant", value)) throw new InvalidValueError("Expected a valid explicit UTC property instant.");
+  return value.slice(0, 19) + "Z";
+}
+function readCorePropertyDate(raw, key) {
+  if (raw.length === 4) raw += "-01-01T00:00:00Z";
+  else if (raw.length === 7) raw += "-01T00:00:00Z";
+  else if (raw.length === 10) raw += "T00:00:00Z";
+  else if (raw.length === 19) raw += "Z";
+  else if (raw.length > 20 && raw[19] === "." && [...raw.slice(20)].every((char) => "0123456789".includes(char))) raw += "Z";
+  try {
+    return new Date(normalizePropertyDate(parseStoredDateTime(raw, key === "lastPrinted" ? "xsd" : "w3cdtf").toISOString()));
+  } catch {
+    return null;
+  }
+}
+function propertyDeclaration(group, key, dialect) {
+  if (group === "core") {
+    const entry = Object.hasOwn(corePropertyKeys, key) ? corePropertyKeys[key] : void 0;
+    return entry ? { ...entry, cached: false } : null;
+  }
+  if (group === "extended") {
+    const entry = Object.hasOwn(extendedPropertyKeys, key) ? extendedPropertyKeys[key] : void 0;
+    return entry ? { ...entry, namespace: documentDialects[dialect].ep } : null;
+  }
+  return null;
+}
+function propertyGroupDefinition(group, dialect) {
+  const vocab = documentDialects[dialect];
+  return group === "core" ? { namespace: corePropertyNamespace, root: "coreProperties", contentType: "application/vnd.openxmlformats-package.core-properties+xml", relationship: "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties", base: "/docProps/core" } : group === "extended" ? { namespace: vocab.ep, root: "Properties", contentType: "application/vnd.openxmlformats-officedocument.extended-properties+xml", relationship: `${vocab.r}/extended-properties`, base: "/docProps/app" } : { namespace: vocab.cus, root: "Properties", contentType: "application/vnd.openxmlformats-officedocument.custom-properties+xml", relationship: `${vocab.r}/custom-properties`, base: "/docProps/custom" };
+}
+var integerRanges = { i1: [-128n, 127n], i2: [-32768n, 32767n], i4: [-2147483648n, 2147483647n], int: [-2147483648n, 2147483647n], i8: [-9223372036854775808n, 9223372036854775807n], ui1: [0n, 255n], ui2: [0n, 65535n], ui4: [0n, 4294967295n], uint: [0n, 4294967295n], ui8: [0n, 18446744073709551615n] };
+function customPropertyType(localName) {
+  return ["lpstr", "lpwstr", "bstr"].includes(localName) ? "string" : Object.hasOwn(integerRanges, localName) ? "integer" : ["r4", "r8", "decimal"].includes(localName) ? "number" : localName === "bool" ? "boolean" : ["date", "filetime"].includes(localName) ? "date" : null;
+}
+function propertyNumberFits(value, variant) {
+  const range = Object.hasOwn(integerRanges, variant) ? integerRanges[variant] : void 0;
+  if (range) return Number.isSafeInteger(value) && BigInt(value) >= range[0] && BigInt(value) <= range[1];
+  return Number.isFinite(value) && (variant !== "r4" || Number.isFinite(Math.fround(value)));
+}
+function serializePropertyScalar(value, variant) {
+  const text = String(value);
+  if (variant !== "decimal" || typeof value !== "number" || !text.toLowerCase().includes("e")) return text;
+  const [mantissa, exponent] = text.toLowerCase().split("e"), negative = mantissa[0] === "-", unsigned = negative ? mantissa.slice(1) : mantissa;
+  const [whole, fraction = ""] = unsigned.split("."), digits = whole + fraction, point = whole.length + Number(exponent);
+  const decimal = point <= 0 ? "0." + "0".repeat(-point) + digits : point >= digits.length ? digits + "0".repeat(point - digits.length) : digits.slice(0, point) + "." + digits.slice(point);
+  return (negative ? "-" : "") + decimal;
+}
+function lexicalValue(raw, type, variant, group) {
+  if (type === "string") return validateDocxValue("string", raw) && (group !== "core" || [...raw].length <= 255) ? raw : null;
+  if (type !== "date") raw = trimXmlWhitespace(raw);
+  if (type === "boolean") return raw === "true" || raw === "1" ? true : raw === "false" || raw === "0" ? false : null;
+  if (type === "date") {
+    try {
+      return normalizePropertyDate(parseStoredDateTime(raw, group === "custom" || group === "core" && variant === "lastPrinted" ? "xsd" : "w3cdtf").toISOString());
+    } catch {
+      return null;
+    }
+  }
+  const unsigned = raw[0] === "-" || raw[0] === "+" ? raw.slice(1) : raw;
+  if (!unsigned || [...unsigned].some((c) => !(type === "integer" ? "0123456789" : variant === "decimal" ? "0123456789." : "0123456789.eE+-").includes(c))) return null;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || type === "integer" && !Number.isSafeInteger(value) || group === "core" && value < 0 || group === "extended" && (value < 0 || value > 2147483647) || group === "custom" && !propertyNumberFits(value, variant)) return null;
+  return value;
+}
+function readPropertyNodes(root, group, dialect, budget) {
+  const vocab = documentDialects[dialect];
+  const content = /* @__PURE__ */ new Map();
+  const projected = new MarkupCompatibility(root, void 0, budget).content;
+  budget.charge("retainedBytes", projected.length * 8);
+  const pending = [...projected].reverse();
+  while (pending.length) {
+    const item = pending.pop();
+    if (!("source" in item)) continue;
+    budget.charge("work", item.content.length + 1);
+    budget.charge("retainedBytes", 96 + item.content.length * 16);
+    content.set(item.source, item.content);
+    for (let index = item.content.length - 1; index >= 0; index--) pending.push(item.content[index]);
+  }
+  const children = (node) => (content.get(node) ?? []).filter((item) => "source" in item).map((item) => item.source);
+  return children(root).map((node) => {
+    let name = null, type = null, cached = false;
+    const custom = group === "custom" && node.namespace === vocab.cus && node.localName === "property";
+    const values = children(node);
+    const valueNode = group === "custom" ? custom && values.length === 1 && values[0].namespace === vocab.vt ? values[0] : null : node;
+    if (custom) {
+      name = propertyAttribute(node, "name");
+      type = valueNode ? customPropertyType(valueNode.localName) : null;
+    } else if (group !== "custom") {
+      for (const key of Object.keys(group === "core" ? corePropertyKeys : extendedPropertyKeys)) {
+        const entry = propertyDeclaration(group, key, dialect);
+        if (entry.namespace === node.namespace && entry.localName === node.localName) {
+          name = key;
+          type = entry.type;
+          cached = entry.cached;
+          break;
+        }
+      }
+      const keys = group === "core" ? corePropertyKeys : extendedPropertyKeys;
+      const knownSpelling = Object.hasOwn(keys, node.localName) || Object.values(keys).some((entry) => entry.localName === node.localName);
+      const nativeNamespace = group === "core" ? [corePropertyNamespace, dc, terms].includes(node.namespace) : node.namespace === vocab.ep;
+      if (name === null && nativeNamespace && !knownSpelling) name = node.localName;
+    }
+    const projected2 = valueNode ? content.get(valueNode) ?? [] : [];
+    const valueContent = projected2.some((item) => "source" in item) ? null : projected2.filter((item) => !("source" in item));
+    const raw = valueContent?.filter((n) => n.kind === "text" || n.kind === "cdata").map((n) => n.text).join("") ?? "";
+    const value = type && name && valueNode && valueContent ? lexicalValue(raw, type, valueNode.localName, group) : null;
+    return { node, valueNode, valueContent, name, storedType: valueNode ? { namespace: valueNode.namespace, localName: valueNode.localName } : null, id: custom ? propertyAttribute(node, "pid") : null, value: type && name ? { name, type, value, writable: !cached && value !== null, cached } : null };
+  });
+}
+function validCustomId(value) {
+  if (value === null) return false;
+  const raw = trimXmlWhitespace(value), digits = raw[0] === "+" || raw[0] === "-" ? raw.slice(1) : raw;
+  return !!digits && [...digits].every((c) => "0123456789".includes(c)) && Number.isSafeInteger(Number(raw)) && Number(raw) >= 2 && Number(raw) <= 2147483647;
+}
+function readPropertyParts(archive, budget, roots) {
+  const parts = [], edges = archive.package.relationships("/");
+  for (const group of ["core", "extended", "custom"]) {
+    const definition = propertyGroupDefinition(group, archive.dialect), declarations = edges.filter((edge) => edge.reltype === definition.relationship);
+    for (const part of archive.package.parts) {
+      if (parseMediaType(part.content_type) !== definition.contentType) continue;
+      const root = roots?.get(part.partname) ?? parseDocumentXml(part.bytes, {}, budget).root;
+      if (root.namespace !== definition.namespace || root.localName !== definition.root) continue;
+      const owned = declarations.some((edge) => !edge.is_external && edge.target_part.partname === part.partname), properties = readPropertyNodes(root, group, archive.dialect, budget);
+      budget.charge("work", properties.length);
+      budget.charge("retainedBytes", properties.length * 128);
+      const ids = /* @__PURE__ */ new Set(), names = /* @__PURE__ */ new Set();
+      let safeCustom = true;
+      if (group === "custom") for (const property of properties) {
+        const id = Number(property.id);
+        if (property.node.namespace !== definition.namespace || property.node.localName !== "property" || !validCustomId(property.id) || !property.name || propertyAttribute(property.node, "fmtid")?.toUpperCase() !== customPropertyFormatId || ids.has(id) || names.has(property.name)) safeCustom = false;
+        ids.add(id);
+        if (property.name) names.add(property.name);
+      }
+      parts.push({ name: part.partname, group, root, properties, owned, ambiguous: declarations.length > 1, safeCustom });
+    }
+  }
+  return parts.sort((a, b) => compareInventoryNames(a.name, b.name));
+}
+
+export {
+  trimXmlWhitespace,
+  storedIntegerIdentity,
+  storedBoolean,
+  storedBooleanValue,
+  parseStoredDateTime,
+  corePropertyNamespace,
+  customPropertyFormatId,
+  corePropertyKeys,
+  extendedPropertyKeys,
+  propertyAttribute,
+  normalizePropertyDate,
+  readCorePropertyDate,
+  propertyDeclaration,
+  propertyGroupDefinition,
+  customPropertyType,
+  propertyNumberFits,
+  serializePropertyScalar,
+  readPropertyNodes,
+  readPropertyParts
+};

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

@@ -0,0 +1,161 @@
+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 {
+  relativePartReference
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/tags.ts
+var relns = "http://schemas.openxmlformats.org/package/2006/relationships";
+function validate(options, action) {
+  if (!options || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some((key) => !["scope", "selection", "name", "value", "allowEmpty"].includes(key)) || options.scope !== void 0 && !["presentation", "slides"].includes(options.scope) || options.allowEmpty !== void 0 && typeof options.allowEmpty !== "boolean") invalid("Invalid tag options.");
+  if (options.scope === "presentation" && options.selection && Object.keys(options.selection).some((key) => key !== "all" && key !== "token")) invalid("Presentation tags do not accept slide selectors.");
+  if (action === "add" && (options.name === void 0 || options.value === void 0)) invalid("New tags require name and value.");
+  if (action === "set" && options.name === void 0 && options.value === void 0) invalid("A tag edit requires name or value.");
+  for (const value of [options.name, options.value]) {
+    if (value === void 0) continue;
+    if (typeof value !== "string") invalid("Tag fields require strings.");
+    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("Tag fields require XML characters.");
+    }
+  }
+  if (options.name === "") invalid("Tag names cannot be empty.");
+  if (!action && (options.name !== void 0 || options.value !== void 0 || options.allowEmpty !== void 0)) invalid("Tag reads accept selection and scope only.");
+  if (action === "remove" && (options.name !== void 0 || options.value !== void 0)) invalid("Tag removal does not accept edit fields.");
+}
+function owners(s, options) {
+  if (options.scope === "presentation") return [{ part: s.main, slide: null }];
+  const selection = options.selection;
+  return (selection ? s.index.select({ kind: "slide", ...selection }) : s.index.slides).map((record) => {
+    if (record.kind !== "slide") throw new SelectionError("invalid-selection");
+    return { part: record.part, slide: record.position };
+  });
+}
+function association(s, owner) {
+  const doc = s.doc(owner);
+  const base = owner === s.main ? doc.root : child(doc.root, "cSld");
+  if (!base) invalid("Tag owner lacks common slide data.");
+  const list = child(base, "custDataLst");
+  const tags = list ? child(list, "tags") : void 0;
+  if (!tags) return void 0;
+  const id = tags.attributes.find((a) => a.name.namespace === s.r && a.name.localName === "id")?.value;
+  const edges = s.index.inventory.relationships.filter((e) => e.owner === owner && e.id === id && e.type === `${s.r}/tags` && !e.external);
+  if (edges.length !== 1 || !edges[0].targetPart) invalid("Invalid tag association.");
+  return edges[0].targetPart;
+}
+function records(s, options) {
+  let token;
+  if (options.selection?.token) {
+    if (Object.keys(options.selection).some((key) => key !== "token")) throw new SelectionError("invalid-selection");
+    token = decodeSelectionToken(options.selection.token);
+    if (token.fingerprint !== s.index.fingerprint) throw new SelectionError("stale-selection");
+    if (token.scope !== "slides" && token.scope !== "presentation") throw new SelectionError("invalid-selection");
+    if (options.scope !== void 0 && options.scope !== token.scope) throw new SelectionError("invalid-selection");
+  }
+  const selected = owners(s, token ? { scope: token.scope } : options);
+  const result = selected.flatMap((owner) => {
+    const part = association(s, owner.part);
+    if (!part) return [];
+    const doc = s.doc(part);
+    if (doc.root.name.namespace !== s.p || doc.root.name.localName !== "tagLst") invalid("Invalid tag list.");
+    return doc.root.children.flatMap((node, index) => {
+      if (node.name.namespace !== s.p || node.name.localName !== "tag") return [];
+      const name = attr(node, "name"), value = attr(node, "val");
+      if (name === void 0 || value === void 0) invalid("Tag requires name and value attributes.");
+      const location = { fingerprint: s.index.fingerprint, scope: owner.slide === null ? "presentation" : "slides", owner: owner.part, objectId: `tag:${part}:${index}`, coordinateSystem: "identity" };
+      return [{ name, value, part, owner: owner.part, slide: owner.slide, selector: JSON.stringify(location), location }];
+    });
+  });
+  return token ? result.filter((r) => r.selector === options.selection.token) : result;
+}
+async function readTags(input, options, context) {
+  validate(options);
+  return records(await loadShared(input, context, false), options);
+}
+function createAssociation(s, owner, context) {
+  let n = 1;
+  while (s.reader.has(`/ppt/tags/tag${n}.xml`) || s.changes.has(`/ppt/tags/tag${n}.xml`)) n++;
+  const part = `/ppt/tags/tag${n}.xml`;
+  s.save(part, parseXmlPart(new TextEncoder().encode(`<p:tagLst 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.tags+xml"/>`]));
+  const relName = relPart(owner);
+  const rels = s.reader.has(relName) ? s.doc(relName) : parseXmlPart(new TextEncoder().encode(`<Relationships xmlns="${relns}"/>`), context.xmlLimits);
+  const id = nextRel(rels);
+  s.save(relName, rels.spliceChildren(rels.root, rels.root.children.length, 0, [`<Relationship xmlns="${relns}" Id="${id}" Type="${s.r}/tags" Target="${escape(relativePartReference(part, owner.slice(0, owner.lastIndexOf("/"))))}"/>`]));
+  let doc = s.doc(owner);
+  let base = owner === s.main ? doc.root : child(doc.root, "cSld");
+  let list = child(base, "custDataLst");
+  if (!list) {
+    const order = owner === s.main ? ["sldMasterIdLst", "notesMasterIdLst", "handoutMasterIdLst", "sldIdLst", "sldSz", "notesSz", "smartTags", "embeddedFontLst", "custShowLst", "photoAlbum", "custDataLst", "kinsoku", "defaultTextStyle", "modifyVerifier", "extLst"] : ["bg", "spTree", "custDataLst", "controls", "extLst"];
+    doc = doc.merge(base, { children: { sequence: order.map((localName) => ({ namespace: s.p, localName })), upsert: [{ name: { namespace: s.p, localName: "custDataLst" }, merge: {} }] } });
+    base = owner === s.main ? doc.root : child(doc.root, "cSld");
+    list = child(base, "custDataLst");
+  }
+  s.save(owner, doc.spliceChildren(list, list.children.length, 0, [`<p:tags xmlns:p="${s.p}" xmlns:r="${s.r}" r:id="${id}"/>`]));
+  return part;
+}
+async function mutateTags(input, action, options, context) {
+  if (!["add", "set", "remove"].includes(action)) invalid("Invalid tag action.");
+  validate(options, action);
+  if ((options.name?.length ?? 0) + (options.value?.length ?? 0) > context.xmlLimits.maxBytes) throw new OfficeError("resource-limit", "Tag exceeds XML limits.", "usage");
+  if (!options.selection && options.scope !== "presentation") throw new SelectionError("missing-selection");
+  const s = await loadShared(input, context);
+  const existing = records(s, options);
+  const locations = [];
+  if (action === "add") {
+    if (options.selection?.token) throw new SelectionError("invalid-selection");
+    const selected = owners(s, options);
+    if (!selected.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+    for (const owner of selected) {
+      if (existing.some((r) => r.owner === owner.part && r.name === options.name)) invalid("Duplicate tag name.");
+      const part = association(s, owner.part) ?? createAssociation(s, owner.part, context);
+      if (s.index.inventory.relationships.filter((e) => e.targetPart === part).length > 1) throw new OfficeError("unsupported-edit", "Shared tag lists cannot be edited.", "validate-intent");
+      const doc = s.doc(part);
+      const location = { fingerprint: s.index.fingerprint, scope: owner.slide === null ? "presentation" : "slides", owner: owner.part, objectId: `tag:${part}:${doc.root.children.length}`, coordinateSystem: "identity" };
+      s.save(part, doc.spliceChildren(doc.root, doc.root.children.length, 0, [`<p:tag xmlns:p="${s.p}" name="${escape(options.name)}" val="${escape(options.value)}"/>`]));
+      locations.push(location);
+    }
+  } else {
+    if (!existing.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+    if (existing.length > 1 && !options.selection?.all) throw new SelectionError("ambiguous-selection");
+    if (options.name !== void 0) {
+      const all = records(s, { scope: existing[0]?.location.scope });
+      for (const record of existing) if (all.some((r) => r.owner === record.owner && r.name === options.name && r.selector !== record.selector)) invalid("Duplicate tag name.");
+      if (existing.some((r, i) => existing.slice(0, i).some((v) => v.owner === r.owner))) invalid("Duplicate tag name.");
+    }
+    for (const record of [...existing].reverse()) {
+      if (s.index.inventory.relationships.filter((e) => e.targetPart === record.part).length > 1) throw new OfficeError("unsupported-edit", "Shared tag lists cannot be edited.", "validate-intent");
+      const doc = s.doc(record.part);
+      const index = Number(record.location.objectId.slice(record.location.objectId.lastIndexOf(":") + 1));
+      const node = doc.root.children[index];
+      if (action === "remove" && (node.children.length || node.attributes.some((a) => a.name.namespace !== "" || !["name", "val"].includes(a.name.localName)))) throw new OfficeError("unsupported-edit", "Decorated tags are preserved on removal.", "validate-intent");
+      s.save(record.part, action === "remove" ? doc.spliceChildren(doc.root, index, 1, []) : doc.merge(doc.root.children[index], { attributes: [...options.name === void 0 ? [] : [{ namespace: "", localName: "name", value: options.name }], ...options.value === void 0 ? [] : [{ namespace: "", localName: "val", value: options.value }]] }));
+      locations.push(record.location);
+    }
+  }
+  const result = await s.finish(s.main, []);
+  return { bytes: result.bytes, affected: locations.length, locations };
+}
+
+export {
+  readTags,
+  mutateTags
+};