@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,473 @@
+import {
+  openDocumentLocations,
+  resolveDocxSelection
+} from "./chunk-LHDB4QO5.js";
+import {
+  DocumentArchiveEditor
+} from "./chunk-MAHX3IW3.js";
+import {
+  measurePackageResourceSerialization
+} from "./chunk-W6DV2CLS.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  Image,
+  acquireImageModelInput
+} from "./chunk-A7EMM3SB.js";
+import {
+  retainedRelationshipTargets
+} from "./chunk-4LXDJES2.js";
+import {
+  characterizeRasterHeader
+} from "./chunk-FZSQMMYV.js";
+import {
+  LocationIndex,
+  addressKey
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  assertOutsideRevisionRanges,
+  editActiveRelationshipXml,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  relationshipXmlRows
+} from "./chunk-2PSVE7I5.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  asciiKey,
+  relativePartTarget
+} from "./chunk-WAKYUXVQ.js";
+import {
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  InputTypeError,
+  InvalidValueError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/image-replacement.ts
+var attribute = (node, name, namespace = "") => node.attributes.find((value) => value.localName === name && value.namespace === namespace)?.value;
+function extent(value) {
+  const rounded = Math.round(value);
+  if (!Number.isFinite(value) || !Number.isSafeInteger(rounded) || rounded <= 0)
+    throw new InvalidValueError("Image extents must be positive safe EMUs.");
+  return rounded;
+}
+async function replaceDocumentImage(input, request, context) {
+  if (!request || ![Object.prototype, null].includes(Object.getPrototypeOf(request)))
+    throw new InputTypeError("Expected a closed image replacement request.");
+  closedRecord(request, ["operation", "options", "input"]);
+  if (request.operation !== "images.replace")
+    throw new DocxUsageError("Expected image replacement.");
+  if (request.input !== void 0) {
+    if (!request.input || ![Object.prototype, null].includes(Object.getPrototypeOf(request.input)))
+      throw new InputTypeError("Expected a closed input identity.");
+    closedRecord(request.input, ["path", "stat"]);
+    if (!request.input.stat || ![Object.prototype, null].includes(Object.getPrototypeOf(request.input.stat)))
+      throw new InputTypeError("Expected a closed file stat.");
+    closedRecord(request.input.stat, [
+      "type",
+      "filesystemType",
+      "size",
+      "allocatedBytes",
+      "ioBlockSize",
+      "preferredIoBlockSize",
+      "mode",
+      "mtimeMs",
+      "atimeMs",
+      "ctimeMs",
+      "birthtimeMs",
+      "revision",
+      "identityScope",
+      "ino",
+      "dev",
+      "rdevMajor",
+      "rdevMinor",
+      "nlink",
+      "uid",
+      "gid"
+    ]);
+    request = { ...request, input: { path: request.input.path, stat: { ...request.input.stat } } };
+  }
+  const settings = archiveSettings(context), invocation = validateDocxInvocation(
+    {
+      operation: request.operation,
+      inputs: [request.input?.path ?? "document"],
+      options: request.options
+    },
+    settings.budget
+  ), options = invocation.options;
+  const budget = settings.budget.lower(
+    Object.fromEntries((options.limit ?? []).map((item) => [item.name, item.value]))
+  ), scoped = { ...settings, budget };
+  if (options.fallback !== void 0)
+    throw new UnsupportedEditError("Fallback-bearing replacement is unsupported.");
+  const document = await openDocumentLocations(input, scoped), selected = resolveDocxSelection(document, invocation), archive = document.snapshot();
+  assertDocumentEditable(archive, scoped);
+  const graph = new DocumentPackage(archive, settings.limits, budget);
+  const main = document.list("story", { scope: "body" })[0].value.part, dialect = dialectForNamespace(
+    parseDocumentXml(
+      graph.getPart(main).bytes,
+      {},
+      budget
+    ).root.namespace
+  ), ns = documentDialects[dialect];
+  const editor = new DocumentArchiveEditor(archive, {}, void 0, budget);
+  const resizeEditors = /* @__PURE__ */ new Map();
+  const unusedRelationships = [];
+  const admitted = [];
+  for (const before of selected) {
+    if (before.kind !== "image" || before.value.range !== null)
+      throw new UnsupportedEditError("Replacement requires a whole image drawing.");
+    const xml = editor.xml(before.value.part.slice(1));
+    let node = xml.root;
+    const ancestors = [node];
+    for (const index2 of before.value.path) {
+      node = node.children[index2];
+      ancestors.push(node);
+    }
+    if (ancestors.some(
+      (value) => value.namespace === ns.w && (["ins", "del", "moveFrom", "moveTo"].includes(value.localName) || value.children.some(
+        (child) => child.namespace === ns.w && ["pPr", "tcPr"].includes(child.localName) && child.children.some((property) => property.localName.endsWith("Change"))
+      ))
+    ))
+      throw new UnsupportedEditError("Tracked containers require explicit revision operations.");
+    assertOutsideRevisionRanges(xml.root, node, budget, xml.compatibility.branches);
+    const frame = ancestors.find(
+      (value) => value.namespace === ns.wp && ["inline", "anchor"].includes(value.localName)
+    );
+    const id = attribute(node, "embed", ns.r), edge = graph.relationships(before.value.part).find((value) => value.rId === id);
+    const descendants = [];
+    const visit = (value) => {
+      budget.charge("work", 1);
+      descendants.push(value);
+      value.children.forEach(visit);
+    };
+    visit(node);
+    if (node.namespace !== ns.a || node.localName !== "blip" || !frame || !id || !edge || edge.is_external || edge.reltype !== ns.r + "/image" || attribute(node, "link", ns.r) !== void 0 || descendants.some(
+      (value) => value.namespace === "http://schemas.microsoft.com/office/drawing/2016/SVG/main" && value.localName === "svgBlip"
+    ))
+      throw new UnsupportedEditError(
+        "Replacement requires an unambiguous embedded raster drawing without alternates or links."
+      );
+    try {
+      const header = characterizeRasterHeader(edge.target_part.bytes, scoped);
+      if (header.mime !== parseMediaType(edge.target_part.content_type))
+        throw new UnsupportedEditError("Image content type conflicts with its byte signature.");
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && ["limit-exceeded", "cancelled"].includes(String(error.code)))
+        throw error;
+      throw new UnsupportedEditError("Existing image is not an admitted raster resource.");
+    }
+    if (!xml.compatibility.canEdit(
+      node.attributes.find((value) => value.namespace === ns.r && value.localName === "embed")
+    ))
+      throw new UnsupportedEditError(
+        "Image carrier contains unsupported preservation-sensitive markup."
+      );
+    admitted.push({
+      before,
+      node,
+      frame,
+      id,
+      target: edge.target_part.partname,
+      owner: before.value.part
+    });
+  }
+  let media, bytes, mime;
+  if (admitted.length) {
+    const acquired = await acquireImageModelInput(options.file, {
+      ...scoped,
+      ...context.binaryResolver ? { binaryResolver: context.binaryResolver } : {},
+      ...context.registerCleanup ? { registerCleanup: context.registerCleanup } : {}
+    });
+    const image = await Image.from_blob(acquired.bytes, scoped);
+    bytes = image.blob;
+    mime = image.content_type;
+    if (acquired.filename !== null) {
+      const dot = acquired.filename.lastIndexOf("."), suffix2 = dot < 0 ? "" : asciiKey(acquired.filename.slice(dot + 1)), assertion = {
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        gif: "image/gif",
+        bmp: "image/bmp",
+        tif: "image/tiff",
+        tiff: "image/tiff"
+      }[suffix2];
+      if (assertion && assertion !== mime)
+        throw new InvalidValueError("Image filename suffix conflicts with its byte signature.");
+    }
+    const suffix = {
+      "image/png": "png",
+      "image/jpeg": "jpg",
+      "image/gif": "gif",
+      "image/bmp": "bmp",
+      "image/tiff": "tiff"
+    }[mime];
+    const taken = new Set(graph.parts.map((part) => asciiKey(part.partname)));
+    let ordinal = 1;
+    do {
+      budget.charge("work", 1);
+      media = main.slice(0, main.lastIndexOf("/")) + `/media/image-${ordinal++}.${suffix}`;
+    } while (taken.has(asciiKey(media)));
+    const changedTargets = new Set(admitted.map((item) => item.target));
+    if (options.shared) {
+      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)) {
+          budget.charge("work", 1);
+          if (edge.is_external || !changedTargets.has(edge.target_part.partname)) continue;
+          const relname = owner === "/" ? "_rels/.rels" : owner.slice(1, owner.lastIndexOf("/") + 1) + "_rels/" + owner.slice(owner.lastIndexOf("/") + 1) + ".rels", xml = editor.xml(relname), node = relationshipXmlRows(xml.root, budget).find((row) => row.rId === edge.rId).element;
+          xml[editActiveRelationshipXml](node, { Target: relativePartTarget(owner, media) + (edge.fragment === null ? "" : "#" + edge.fragment) });
+        }
+    } else {
+      for (const item of admitted) {
+        const relname = item.owner.slice(1, item.owner.lastIndexOf("/") + 1) + "_rels/" + item.owner.slice(item.owner.lastIndexOf("/") + 1) + ".rels", rels = editor.xml(relname), id = graph.allocateRelationshipId(item.owner);
+        rels.insertChildren(
+          rels.root,
+          `<Relationship xmlns="http://schemas.openxmlformats.org/package/2006/relationships" Id="${id}" Type="${ns.r}/image" Target="${xmlValue(relativePartTarget(item.owner, media))}"/>`
+        );
+        editor.xml(item.owner.slice(1)).setAttribute(item.node, { namespace: ns.r, localName: "embed" }, id);
+        const uses = (node) => {
+          budget.charge("work", 1);
+          return node.attributes.some((value) => value.namespace === ns.r && value.value === item.id) || node.children.some(uses);
+        };
+        const root = parseDocumentXml(editor.xml(item.owner.slice(1)).serialize(), {}, budget).root;
+        if (!uses(root)) unusedRelationships.push({ name: relname, id: item.id });
+      }
+    }
+    if (options.width !== void 0 || options.height !== void 0) {
+      const length = (value) => value === void 0 ? void 0 : extent(
+        value.value * { emu: 1, in: 914400, cm: 36e4, mm: 36e3, pt: 12700 }[value.unit]
+      );
+      const width = length(options.width), height = length(options.height), nx = image.px_width / image.horz_dpi * 914400, ny = image.px_height / image.vert_dpi * 914400;
+      let x = width ?? extent(height * nx / ny), y = height ?? extent(width * ny / nx);
+      let horizontal = 0, vertical = 0;
+      if (options.fit === "contain") {
+        const scale = Math.min(x / nx, y / ny);
+        x = extent(nx * scale);
+        y = extent(ny * scale);
+      }
+      if (options.fit === "cover") {
+        const scale = Math.max(x / nx, y / ny);
+        horizontal = Math.round((1 - x / (nx * scale)) * 5e4);
+        vertical = Math.round((1 - y / (ny * scale)) * 5e4);
+        if (horizontal * 2 >= 1e5 || vertical * 2 >= 1e5)
+          throw new InvalidValueError("Image crop is empty.");
+      }
+      for (const item of admitted) {
+        const name = graph.getPart(item.owner).name;
+        let xml = resizeEditors.get(name);
+        if (!xml) {
+          xml = new DocumentXmlEditor(editor.xml(name).serialize(), {}, void 0, budget);
+          resizeEditors.set(name, xml);
+        }
+        let node = xml.root;
+        const ancestors = [node];
+        for (const index2 of item.before.value.path) {
+          node = node.children[index2];
+          ancestors.push(node);
+        }
+        const frame = ancestors.find(
+          (value) => value.namespace === ns.wp && ["inline", "anchor"].includes(value.localName)
+        );
+        const nodes = [];
+        const walk = (node2) => {
+          budget.charge("work", 1);
+          nodes.push(node2);
+          node2.children.forEach(walk);
+        };
+        walk(frame);
+        const outer = frame.children.filter(
+          (node2) => node2.namespace === ns.wp && node2.localName === "extent"
+        ), inner = nodes.filter((node2) => node2.namespace === ns.a && node2.localName === "ext");
+        if (outer.length !== 1 || inner.length !== 1)
+          throw new UnsupportedEditError("Ambiguous drawing extents.");
+        for (const node2 of [...outer, ...inner]) {
+          xml.setAttribute(node2, "cx", String(x));
+          xml.setAttribute(node2, "cy", String(y));
+        }
+        if (options.fit) {
+          const nodeCarrier = node;
+          const parent = nodes.find((node2) => node2.children.includes(nodeCarrier)), crop = parent.children.filter(
+            (node2) => node2.namespace === ns.a && node2.localName === "srcRect"
+          );
+          if (crop.length > 1) throw new UnsupportedEditError("Ambiguous drawing crop.");
+          const markup = `<a:srcRect xmlns:a="${ns.a}" l="${horizontal}" r="${horizontal}" t="${vertical}" b="${vertical}"/>`;
+          if (crop[0]) xml.replaceElement(crop[0], markup);
+          else
+            xml.insertChildren(
+              parent,
+              markup,
+              parent.children[parent.children.indexOf(nodeCarrier) + 1]
+            );
+        }
+      }
+    }
+    editor.xml("[Content_Types].xml").insertChildren(
+      editor.xml("[Content_Types].xml").root,
+      `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="${xmlValue(media)}" ContentType="${mime}"/>`
+    );
+  }
+  const dirty = new Set(editor.dirtyParts);
+  budget.charge(
+    "retainedBytes",
+    archive.members.reduce((sum, member) => sum + member.bytes.length + 128, 0) + (bytes?.length ?? 0)
+  );
+  budget.charge(
+    "work",
+    archive.members.reduce((sum, member) => sum + member.bytes.length, 0)
+  );
+  let candidate = {
+    comment: new Uint8Array(archive.comment),
+    members: [
+      ...archive.members.map((member) => ({
+        ...member,
+        bytes: resizeEditors.has(member.name) ? resizeEditors.get(member.name).serialize() : dirty.has(member.name) ? editor.xml(member.name).serialize() : new Uint8Array(member.bytes)
+      })),
+      ...media && bytes ? [
+        {
+          name: media.slice(1),
+          bytes,
+          directory: false,
+          modified: new Date(archive.members[0].modified)
+        }
+      ] : []
+    ]
+  };
+  for (const name of new Set(unusedRelationships.map((item) => item.name))) {
+    const fresh = new DocumentArchiveEditor(candidate, {}, void 0, budget).xml(name);
+    for (const item of unusedRelationships.filter((item2) => item2.name === name)) {
+      const old = relationshipXmlRows(fresh.root, budget).find((row) => row.rId === item.id);
+      if (old) fresh[editActiveRelationshipXml](old.element, null);
+    }
+    candidate = {
+      ...candidate,
+      members: candidate.members.map(
+        (member) => member.name === name ? { ...member, bytes: fresh.serialize() } : member
+      )
+    };
+  }
+  if (admitted.length) {
+    const nextGraph = new DocumentPackage(candidate, settings.limits, budget), incoming = retainedRelationshipTargets(nextGraph, budget);
+    const retired = new Set(
+      admitted.map((item) => item.target).filter(
+        (target) => !incoming.has(asciiKey(target)) && !candidate.members.some(
+          (member) => member.name === target.slice(1, target.lastIndexOf("/") + 1) + "_rels/" + target.slice(target.lastIndexOf("/") + 1) + ".rels"
+        )
+      )
+    ), types = new DocumentArchiveEditor(candidate, {}, void 0, budget).xml(
+      "[Content_Types].xml"
+    );
+    for (const node of types.root.children)
+      if (attribute(node, "PartName") && retired.has(attribute(node, "PartName")))
+        types.replaceElement(node, "");
+    candidate = {
+      ...candidate,
+      members: candidate.members.filter((member) => !retired.has("/" + member.name)).map(
+        (member) => member.name === "[Content_Types].xml" ? { ...member, bytes: types.serialize() } : member
+      )
+    };
+  }
+  const index = new LocationIndex(candidate, settings.limits, main.slice(1), dialect, budget);
+  const changes = admitted.map(({ before }) => {
+    const entry = index.byAddress.get(addressKey(before.value))?.find((value2) => value2.kind === "image");
+    if (!entry) throw new UnsupportedEditError("Replaced image location cannot be resolved.");
+    const value = { ...before.value, generation: before.value.generation + 1 };
+    return {
+      kind: "replace",
+      before,
+      after: {
+        kind: "image",
+        value,
+        token: encodeGeneratedLocation(value),
+        positions: entry.positions
+      }
+    };
+  });
+  const planned = {
+    changed: changes.length > 0,
+    changes,
+    dryRun: options.dryRun ?? false,
+    output: options.dryRun ? null : {
+      path: options.inPlace ? request.input?.path ?? null : options.output === "-" ? null : options.output ?? null,
+      bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER),
+      sha256: "0".repeat(64)
+    }
+  };
+  if (options.json) {
+    const size = measurePackageResourceSerialization(
+      {
+        version: 1,
+        operation: request.operation,
+        ok: true,
+        data: planned,
+        affected: changes.length,
+        locations: changes.map((change) => change.after),
+        warnings: [],
+        errors: []
+      },
+      budget
+    ) + 1;
+    budget.check("serializedOutput", size);
+    budget.charge("retainedBytes", size * 8);
+    budget.charge("work", size * 8);
+  }
+  if (context.admitPublication) {
+    const result2 = context.admitPublication(planned);
+    if (result2 !== void 0) {
+      if (result2 && typeof result2.then === "function")
+        void Promise.resolve(result2).catch(() => {
+        });
+      throw new InputTypeError("Image admission must be synchronous.");
+    }
+  }
+  const result = await publishDocumentArchive(
+    candidate,
+    {
+      ...request.input ? { input: request.input } : {},
+      ...options.output === void 0 ? {} : { output: options.output },
+      ...options.inPlace === void 0 ? {} : { inPlace: options.inPlace },
+      ...options.force === void 0 ? {} : { force: options.force },
+      ...options.dryRun === void 0 ? {} : { dryRun: options.dryRun },
+      ...options.json === void 0 ? {} : { json: options.json }
+    },
+    { ...context, budget }
+  );
+  return {
+    ...planned,
+    output: result.published.length ? {
+      path: result.published[0].path,
+      bytes: result.published[0].bytes,
+      sha256: result.archiveSha256
+    } : null
+  };
+}
+
+export {
+  replaceDocumentImage
+};

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

@@ -0,0 +1,159 @@
+import {
+  equationNamespaces
+} from "./chunk-5DFZAJHL.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/slide-copy-xml.ts
+function attr(node, name, namespace = "") {
+  return node.attributes.find((x) => x.name.localName === name && x.name.namespace === namespace)?.value;
+}
+function unsupported() {
+  throw new OfficeError(
+    "unsupported-edit",
+    "Slide copying cannot safely remap this structure or dependency.",
+    "validate-intent"
+  );
+}
+function elements(xml) {
+  const result = [];
+  const visit = (node, path) => {
+    result.push({ node, path });
+    node.children.forEach((child, i) => visit(child, [...path, i]));
+  };
+  visit(xml.root, []);
+  return result;
+}
+function remapCopiedXml(bytes, edges, ids, options) {
+  let xml = parseXmlPart(bytes, options.xmlLimits);
+  const diagramNamespace = `${options.dialect.a.slice(0, options.dialect.a.lastIndexOf("/"))}/diagram`;
+  const original = xml;
+  const nodes = elements(xml);
+  const compatibilityNamespace = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+  const mathWrappers = /* @__PURE__ */ new Set();
+  for (const { node, path } of nodes) {
+    if (!equationNamespaces.includes(node.name.namespace)) continue;
+    let ancestor = xml.root;
+    for (const index of path) {
+      if (ancestor.name.namespace === compatibilityNamespace) {
+        mathWrappers.add(ancestor);
+        if (ancestor.name.localName === "AlternateContent")
+          for (const branch of ancestor.children) mathWrappers.add(branch);
+      }
+      ancestor = ancestor.children[index];
+    }
+  }
+  const diagramPresent = nodes.some(
+    ({ node }) => node.name.namespace === diagramNamespace && node.name.localName === "relIds"
+  );
+  const shapeIds = /* @__PURE__ */ new Map();
+  const shapePaths = /* @__PURE__ */ new Map();
+  let maximum = 0;
+  for (const { node, path } of nodes)
+    if (node.name.namespace === options.dialect.p && node.name.localName === "cNvPr") {
+      const id = attr(node, "id");
+      if (!Number.isSafeInteger(Number(id)) || Number(id) < 1 || Number(id) > 4294967295)
+        unsupported();
+      const previousPaths = shapePaths.get(id) ?? [];
+      for (const previous of previousPaths) {
+        if (!options.preserveShapeIds || !diagramPresent) unsupported();
+        let ancestor = xml.root;
+        let depth = 0;
+        while (depth < Math.min(previous.length, path.length) && previous[depth] === path[depth]) {
+          ancestor = ancestor.children[path[depth]];
+          depth++;
+        }
+        if (ancestor.name.namespace !== "http://schemas.openxmlformats.org/markup-compatibility/2006" || ancestor.name.localName !== "AlternateContent" || ![previous[depth], path[depth]].every(
+          (index) => index !== void 0 && ancestor.children[index]?.name.namespace === ancestor.name.namespace && ["Choice", "Fallback"].includes(ancestor.children[index].name.localName)
+        ))
+          unsupported();
+      }
+      shapePaths.set(id, [...previousPaths, path]);
+      maximum = Math.max(maximum, Number(id));
+      shapeIds.set(id, id);
+    }
+  if (!options.preserveShapeIds)
+    for (const id of shapeIds.keys()) {
+      if (++maximum > 4294967295)
+        throw new OfficeError("resource-limit", "Shape IDs exhausted.", "validate-intent");
+      shapeIds.set(id, String(maximum));
+    }
+  for (const { node, path } of nodes) {
+    if (![options.dialect.p, options.dialect.a, options.dialect.c].includes(node.name.namespace) && !((diagramPresent || mathWrappers.has(node)) && node.name.namespace === compatibilityNamespace && ["AlternateContent", "Choice", "Fallback"].includes(node.name.localName)) && !equationNamespaces.includes(node.name.namespace) && !(node.name.namespace === "http://schemas.microsoft.com/office/drawing/2010/main" && node.name.localName === "m") && !(node.name.namespace === diagramNamespace && node.name.localName === "relIds") && !(node.name.namespace === "http://schemas.microsoft.com/office/drawing/2014/chartex" && node.name.localName === "chart") || ["extLst", "oleObj", "control", "contentPart"].includes(node.name.localName))
+      unsupported();
+    if (node.name.namespace === options.dialect.a && ["hlinkClick", "hlinkHover", "hlinkMouseOver"].includes(node.name.localName)) {
+      const action = attr(node, "action");
+      if (action && action !== "ppaction://hlinksldjump") unsupported();
+      const relationship = attr(node, "id", options.dialect.r);
+      if (action && !edges.some(
+        (edge) => edge.id === relationship && edge.type === `${options.dialect.r}/slide` && !edge.external
+      ))
+        unsupported();
+    }
+    if (node.name.namespace === diagramNamespace && node.name.localName === "relIds" && ["dm", "lo", "qs", "cs"].some((name) => !attr(node, name, options.dialect.r)))
+      unsupported();
+    const attributes = [];
+    for (const attribute of node.attributes) {
+      const { namespace, localName } = attribute.name;
+      let value;
+      if (namespace === options.dialect.r) {
+        const diagramReference = node.name.namespace === diagramNamespace && node.name.localName === "relIds";
+        if (!(diagramReference ? ["dm", "lo", "qs", "cs"] : ["id", "embed", "link"]).includes(
+          localName
+        ))
+          unsupported();
+        if (diagramReference) {
+          const kind = {
+            dm: "diagramData",
+            lo: "diagramLayout",
+            qs: "diagramQuickStyle",
+            cs: "diagramColors"
+          }[localName];
+          if (!edges.some(
+            (edge) => edge.id === attribute.value && edge.type === `${options.dialect.r}/${kind}` && !edge.external
+          ))
+            unsupported();
+        }
+        value = ids.get(attribute.value);
+        if (!value) unsupported();
+      } else if (!namespace && node.name.namespace === options.dialect.p && node.name.localName === "sldLayoutId" && localName === "id" && options.allocateLayoutId) {
+        value = options.allocateLayoutId();
+      } else if (namespace === compatibilityNamespace && localName === "Ignorable") {
+        const prefixes = attribute.value.split(" ").flatMap((value2) => value2.split("	")).flatMap((value2) => value2.split("\n")).flatMap((value2) => value2.split("\r")).filter(Boolean);
+        if (!prefixes.length || prefixes.some(
+          (prefix) => ![
+            ...equationNamespaces,
+            "http://schemas.microsoft.com/office/drawing/2010/main"
+          ].includes(original.resolveNamespace(node, prefix) ?? "")
+        ))
+          unsupported();
+      } else if (namespace && !(equationNamespaces.includes(node.name.namespace) && namespace === node.name.namespace) && !["http://www.w3.org/2000/xmlns/", "http://www.w3.org/XML/1998/namespace"].includes(
+        namespace
+      ))
+        unsupported();
+      else if (!namespace && (node.name.namespace === options.dialect.p && node.name.localName === "cNvPr" && localName === "id" || node.name.namespace === options.dialect.a && ["stCxn", "endCxn"].includes(node.name.localName) && localName === "id" || node.name.namespace === options.dialect.p && localName === "spid")) {
+        if (localName === "spid" && !["spTgt", "subSp", "bldP", "bldDgm", "bldOleChart", "bldGraphic"].includes(
+          node.name.localName
+        ))
+          unsupported();
+        value = shapeIds.get(attribute.value);
+        if (!value) unsupported();
+      }
+      if (value !== void 0) attributes.push({ namespace, localName, value });
+    }
+    if (attributes.length) {
+      let current = xml.root;
+      for (const i of path) current = current.children[i];
+      xml = xml.merge(current, { attributes });
+    }
+  }
+  return xml.bytes();
+}
+
+export {
+  remapCopiedXml
+};

package/dist/safe-bash/command-chunks/{chunk-UQ3KEUCF.js → chunk-ESD5ZD74.js}

@@ -14,6 +14,7 @@ function createChmodCommand(configuration = {}) {
     const budget = new MetadataBudget(context, configured.limits);
     const modeOptions = [];
     let ended = false, referenceValue = false;
+    let preserveRoot = true;
     const args = context.args.flatMap((argument) => {
       if (referenceValue) {
         referenceValue = false;
@@ -21,6 +22,10 @@ function createChmodCommand(configuration = {}) {
       }
       if (argument === "--") ended = true;
       if (ended) return [argument];
+      if (argument === "--preserve-root" || argument === "--no-preserve-root") {
+        preserveRoot = argument === "--preserve-root";
+        return [];
+      }
       if (argument === "--reference") referenceValue = true;
       if (argument.startsWith("-") && argument.length > 1 && "rwxXstugo01234567".includes(argument[1])) {
         modeOptions.push(argument);
@@ -48,7 +53,7 @@ function createChmodCommand(configuration = {}) {
       const target = link.type === "symlink" ? await context.fs.realpath(path, { signal: context.signal }) : path;
       const stat = link.type === "symlink" ? await context.fs.stat(target, { signal: context.signal }) : link;
       const mode2 = referenceMode ?? change(stat);
-      if (parsed.flags.has("R") && stat.type === "directory" && await context.fs.realpath(target, { signal: context.signal }) === "/") throw new FsError("EBUSY", { syscall: "chmod", path, message: "refusing recursive mode changes at virtual root" });
+      if (preserveRoot && parsed.flags.has("R") && stat.type === "directory" && await context.fs.realpath(target, { signal: context.signal }) === "/") throw new FsError("EBUSY", { syscall: "chmod", path, message: "refusing recursive mode changes at virtual root" });
       const canonicalTarget = await context.fs.realpath(target, { signal: context.signal });
       const apply = async () => {
         context.signal.throwIfAborted();
@@ -139,6 +144,7 @@ function evalSyncChmod(opArgs, umask, chmodNodeSync) {
         args.push(argument);
         continue;
       }
+      if (!ended && (argument === "--preserve-root" || argument === "--no-preserve-root")) continue;
       if (!ended && argument === "--reference") {
         referenceValue = true;
         args.push(argument);