@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,481 @@
+import {
+  writePackageArchive
+} from "./chunk-YRNBIU5U.js";
+import {
+  readPackage
+} from "./chunk-FRZ5P5AB.js";
+import {
+  readBinary
+} from "./chunk-TL3KDYEM.js";
+import {
+  validatePresentation
+} from "./chunk-XDEA3TL5.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  parseContentTypes
+} from "./chunk-N74TJL6X.js";
+import {
+  readRelationshipGraph
+} from "./chunk-5GEFJROP.js";
+import {
+  relativePartReference
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/settings-scaling.ts
+function unsupported() {
+  throw new OfficeError(
+    "unsupported-edit",
+    "Content scaling requires explicit unrotated shape or group geometry without conditional content or animation.",
+    "validate-intent"
+  );
+}
+function child(node, name, namespace) {
+  const found = node.children.filter(
+    (c) => c.name.localName === name && c.name.namespace === namespace
+  );
+  if (found.length !== 1) unsupported();
+  return found[0];
+}
+function scaleDrawingCanvas(document, sx, sy) {
+  if (!Number.isFinite(sx) || !Number.isFinite(sy) || sx <= 0 || sy <= 0) unsupported();
+  const p = document.root.name.namespace;
+  const a = p === "http://purl.oclc.org/ooxml/presentationml/main" ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+  const pending = [document.root];
+  while (pending.length) {
+    const node = pending.pop();
+    if (node.name.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006" || node.name.namespace === p && ["timing", "transition", "oleObj"].includes(node.name.localName))
+      unsupported();
+    if (node.name.namespace === a && node.name.localName === "xfrm" && node.attributes.some((attr2) => attr2.name.localName === "rot" && Number(attr2.value) !== 0))
+      unsupported();
+    pending.push(...node.children);
+  }
+  const tree = child(child(document.root, "cSld", p), "spTree", p);
+  const rootGroup = child(tree, "grpSpPr", p);
+  const rootTransform = rootGroup.children.find(
+    (c) => c.name.namespace === a && c.name.localName === "xfrm"
+  );
+  if (rootTransform && (rootTransform.attributes.some((attr2) => Number(attr2.value) !== 0) || rootTransform.children.some(
+    (node) => node.attributes.some((attr2) => Number(attr2.value) !== 0)
+  )))
+    unsupported();
+  for (let index = 0; index < tree.children.length; index++) {
+    const currentTree = child(child(document.root, "cSld", p), "spTree", p);
+    const shape = currentTree.children[index];
+    if (shape.name.namespace !== p) unsupported();
+    if (["nvGrpSpPr", "grpSpPr", "extLst"].includes(shape.name.localName)) continue;
+    if (!["sp", "pic", "cxnSp", "grpSp"].includes(shape.name.localName)) unsupported();
+    const group = shape.name.localName === "grpSp";
+    const transform = child(child(shape, group ? "grpSpPr" : "spPr", p), "xfrm", a);
+    if (group) {
+      for (const name of ["chOff", "chExt"]) {
+        const node = child(transform, name, a);
+        for (const axis of name === "chOff" ? ["x", "y"] : ["cx", "cy"]) {
+          const value = node.attributes.find(
+            (attribute) => attribute.name.namespace === "" && attribute.name.localName === axis
+          )?.value;
+          if (value === void 0 || !value.trim() || [...value.trim()].some(
+            (character, index2) => !(character >= "0" && character <= "9") && !(index2 === 0 && (character === "-" || character === "+"))
+          ))
+            unsupported();
+          const number = Number(value);
+          if (!Number.isSafeInteger(number) || Math.abs(number) > 27273042316900 || name === "chExt" && number <= 0)
+            unsupported();
+        }
+      }
+    }
+    const changes = ["off", "ext"].map((name) => {
+      const node = child(transform, name, a);
+      const attrs = (name === "off" ? ["x", "y"] : ["cx", "cy"]).map((localName, i) => {
+        const value = node.attributes.find(
+          (v) => v.name.namespace === "" && v.name.localName === localName
+        )?.value;
+        if (value === void 0 || !value.trim() || [...value.trim()].some(
+          (c, j) => !(c >= "0" && c <= "9") && !(j === 0 && (c === "-" || c === "+"))
+        ))
+          unsupported();
+        const number = Number(value);
+        const scaled = Math.sign(number) * Math.round(Math.abs(number) * (i === 0 ? sx : sy));
+        if (!Number.isSafeInteger(number) || !Number.isSafeInteger(scaled) || Math.abs(scaled) > 27273042316900 || name === "ext" && scaled < 0)
+          unsupported();
+        return { namespace: "", localName, value: String(scaled) };
+      });
+      return { name: { namespace: a, localName: name }, merge: { attributes: attrs } };
+    });
+    document = document.merge(transform, {
+      children: {
+        sequence: ["off", "ext", "chOff", "chExt"].map((localName) => ({
+          namespace: a,
+          localName
+        })),
+        upsert: changes
+      }
+    });
+  }
+  return document;
+}
+
+// packages/safe-bash-presentation-engine/src/presentation-settings.ts
+var dialects = [
+  {
+    p: "http://schemas.openxmlformats.org/presentationml/2006/main",
+    r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+  },
+  {
+    p: "http://purl.oclc.org/ooxml/presentationml/main",
+    r: "http://purl.oclc.org/ooxml/officeDocument/relationships"
+  }
+];
+function escapeAttribute(value) {
+  return [...value].map((c) => ({ "&": "&amp;", "<": "&lt;", '"': "&quot;" })[c] ?? c).join("");
+}
+function invalid(message) {
+  throw new OfficeError("invalid-value", message, "usage");
+}
+function unsupported2(message) {
+  throw new OfficeError("unsupported-edit", message, "validate-intent");
+}
+function attr(node, localName) {
+  return node.attributes.find((a) => a.name.namespace === "" && a.name.localName === localName)?.value;
+}
+function child2(node, name) {
+  const found = node.children.filter(
+    (c) => c.name.namespace === node.name.namespace && c.name.localName === name
+  );
+  if (found.length > 1)
+    throw new OfficeError("invalid-opc", "Duplicate presentation setting.", "index");
+  return found[0];
+}
+function numeric(value) {
+  if (value === void 0) return null;
+  const text = value.trim();
+  if (!text || [...text].some((c, i) => !(c >= "0" && c <= "9") && !(i === 0 && (c === "-" || c === "+"))) || !Number.isSafeInteger(Number(text)))
+    throw new OfficeError("invalid-opc", "Invalid numeric presentation setting.", "index");
+  return Number(text);
+}
+async function load(input, context) {
+  if (!context?.xmlLimits || !context.relationshipLimits)
+    invalid("Explicit XML and relationship limits are required.");
+  const source = await readBinary(input, context);
+  const reader = await readPackage(source, context);
+  const limits = {
+    ...context.xmlLimits,
+    ...context.relationshipLimits,
+    maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes),
+    maxEntries: context.archiveLimits.maxMembers
+  };
+  if (!validatePresentation(reader, limits).valid)
+    throw new OfficeError(
+      "invalid-opc",
+      "Settings require a valid presentation graph.",
+      "validate-intent"
+    );
+  const types = parseContentTypes(reader.get("/[Content_Types].xml"), limits);
+  const graph = readRelationshipGraph(reader, context.relationshipLimits);
+  const main = graph.outgoing("/").find((e) => dialects.some((d) => e.type === `${d.r}/officeDocument`)).targetPart;
+  const document = parseXmlPart(reader.get(main), context.xmlLimits);
+  const dialect = dialects.find((d) => d.p === document.root.name.namespace);
+  const properties = graph.outgoing(main).filter((e) => e.type === `${dialect.r}/presProps`);
+  if (properties.length > 1 || properties.some((e) => e.external))
+    throw new OfficeError("invalid-opc", "Ambiguous presentation properties.", "index");
+  const propertyPart = properties[0]?.targetPart ?? null;
+  if (propertyPart && types.get(propertyPart) !== "application/vnd.openxmlformats-officedocument.presentationml.presProps+xml")
+    throw new OfficeError("invalid-opc", "Invalid presentation properties content type.", "index");
+  const propertyDocument = propertyPart ? parseXmlPart(reader.get(propertyPart), context.xmlLimits) : null;
+  if (propertyDocument && (propertyDocument.root.name.namespace !== dialect.p || propertyDocument.root.name.localName !== "presentationPr"))
+    throw new OfficeError("invalid-opc", "Invalid presentation properties root.", "index");
+  return { source, reader, limits, graph, main, document, dialect, propertyPart, propertyDocument };
+}
+function settings(document, properties) {
+  const slide = child2(document, "sldSz"), notes = child2(document, "notesSz");
+  const width = slide ? numeric(attr(slide, "cx")) : null, height = slide ? numeric(attr(slide, "cy")) : null;
+  const notesWidth = notes ? numeric(attr(notes, "cx")) : null, notesHeight = notes ? numeric(attr(notes, "cy")) : null;
+  const show = properties && child2(properties, "showPr");
+  const loop = show && attr(show, "loop")?.trim();
+  if (loop !== void 0 && !["0", "1", "true", "false"].includes(loop.trim()))
+    throw new OfficeError("invalid-opc", "Invalid slideshow loop setting.", "index");
+  const modes = show ? ["present", "browse", "kiosk"].filter((n) => child2(show, n)) : [];
+  if (modes.length > 1) throw new OfficeError("invalid-opc", "Ambiguous slideshow mode.", "index");
+  const slideNumberStart = numeric(attr(document, "firstSlideNum")) ?? 1;
+  if (slideNumberStart < -2147483648 || slideNumberStart > 2147483647)
+    throw new OfficeError("invalid-opc", "Invalid slide numbering value.", "index");
+  return {
+    width,
+    height,
+    orientation: width === null || height === null ? null : width >= height ? "landscape" : "portrait",
+    notesWidth,
+    notesHeight,
+    notesOrientation: notesWidth === null || notesHeight === null ? null : notesWidth >= notesHeight ? "landscape" : "portrait",
+    slideNumberStart,
+    loop: loop === "1" || loop === "true",
+    showType: modes[0] === "browse" ? "window" : modes[0] === "kiosk" ? "kiosk" : "speaker"
+  };
+}
+async function readPresentationSettings(input, context) {
+  const loaded = await load(input, context);
+  const { graph, main, dialect, reader, limits, propertyDocument, propertyPart } = loaded;
+  const views = graph.outgoing(main).filter((edge) => edge.type === `${dialect.r}/viewProps`);
+  if (views.length > 1 || views.some((edge) => edge.external))
+    throw new OfficeError("invalid-opc", "Ambiguous view properties.", "index");
+  const viewPart = views[0]?.targetPart;
+  let viewProperties = null;
+  if (viewPart) {
+    const types = parseContentTypes(reader.get("/[Content_Types].xml"), limits);
+    if (types.get(viewPart) !== "application/vnd.openxmlformats-officedocument.presentationml.viewProps+xml")
+      throw new OfficeError("invalid-opc", "Invalid view properties content type.", "index");
+    const view = parseXmlPart(reader.get(viewPart), context.xmlLimits);
+    if (view.root.name.namespace !== dialect.p || view.root.name.localName !== "viewPr")
+      throw new OfficeError("invalid-opc", "Invalid view properties root.", "index");
+    viewProperties = { part: viewPart, xml: view.markup(view.root, true) };
+  }
+  const print = propertyDocument && child2(propertyDocument.root, "prnPr");
+  return {
+    ...settings(loaded.document.root, propertyDocument?.root),
+    printProperties: print ? { part: propertyPart, xml: propertyDocument.markup(print, true) } : null,
+    viewProperties
+  };
+}
+function applyPresentationCanvasSettings(document, options, propertyDocument) {
+  const pending = [document.root, ...propertyDocument ? [propertyDocument.root] : []];
+  while (pending.length) {
+    const node = pending.pop();
+    if (node.name.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006" || node.name.namespace === document.root.name.namespace && node.name.localName === "modifyVerifier")
+      unsupported2("Protected or conditional presentation settings cannot be changed.");
+    pending.push(...node.children);
+  }
+  const previous = settings(document.root, propertyDocument?.root);
+  const pn = (localName) => ({ namespace: document.root.name.namespace, localName });
+  const dimensions = [];
+  for (const [name, w, h, o, pw, ph] of [
+    ["sldSz", options.width, options.height, options.orientation, previous.width, previous.height],
+    [
+      "notesSz",
+      options.notesWidth,
+      options.notesHeight,
+      options.notesOrientation,
+      previous.notesWidth,
+      previous.notesHeight
+    ]
+  ]) {
+    if (w === void 0 && h === void 0 && o === void 0) continue;
+    let width = w ?? pw, height = h ?? ph;
+    if (width === null || height === null)
+      invalid("Both dimensions are required when canvas dimensions are absent.");
+    if (o === "portrait" && width === height)
+      invalid("Square dimensions have landscape orientation.");
+    if (o && (o === "landscape" ? width < height : width > height)) {
+      if (w !== void 0 || h !== void 0)
+        invalid("Explicit dimensions contradict orientation.");
+      [width, height] = [height, width];
+    }
+    const slideSize = name === "sldSz";
+    if ([width, height].some(
+      (value) => !Number.isSafeInteger(value) || value < (slideSize ? 914400 : 0) || value > (slideSize ? 51206400 : 27273042316900)
+    ))
+      invalid("Resulting canvas dimensions are outside supported edit bounds.");
+    dimensions.push({
+      name: pn(name),
+      merge: {
+        attributes: [
+          { namespace: "", localName: "cx", value: String(width) },
+          { namespace: "", localName: "cy", value: String(height) }
+        ]
+      }
+    });
+  }
+  if (dimensions.length || options.slideNumberStart !== void 0)
+    document = document.merge(document.root, {
+      attributes: options.slideNumberStart === void 0 ? [] : [
+        { namespace: "", localName: "firstSlideNum", value: String(options.slideNumberStart) }
+      ],
+      children: {
+        sequence: [
+          "sldMasterIdLst",
+          "notesMasterIdLst",
+          "handoutMasterIdLst",
+          "sldIdLst",
+          "sldSz",
+          "notesSz",
+          "smartTags",
+          "embeddedFontLst",
+          "custShowLst",
+          "photoAlbum",
+          "custDataLst",
+          "kinsoku",
+          "defaultTextStyle",
+          "modifyVerifier",
+          "extLst"
+        ].map(pn),
+        upsert: dimensions
+      }
+    });
+  return document;
+}
+async function mutatePresentationSettings(input, options, context) {
+  const keys = [
+    "width",
+    "height",
+    "orientation",
+    "notesWidth",
+    "notesHeight",
+    "notesOrientation",
+    "slideNumberStart",
+    "loop",
+    "showType",
+    "scaleContent"
+  ];
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some((k) => !keys.includes(k)))
+    invalid("Invalid presentation settings object.");
+  if (!Object.entries(options).some(([key, value]) => key !== "scaleContent" && value !== void 0))
+    invalid("At least one setting is required.");
+  for (const key of ["orientation", "notesOrientation"])
+    if (options[key] !== void 0 && !["portrait", "landscape"].includes(options[key]))
+      invalid("Invalid orientation.");
+  for (const key of ["width", "height", "notesWidth", "notesHeight"]) {
+    const value = options[key];
+    const slide = key === "width" || key === "height";
+    if (value !== void 0 && (!Number.isSafeInteger(value) || value < (slide ? 914400 : 0) || value > (slide ? 51206400 : 27273042316900)))
+      invalid("Invalid EMU dimensions.");
+  }
+  if (options.slideNumberStart !== void 0 && (!Number.isSafeInteger(options.slideNumberStart) || options.slideNumberStart < -2147483648 || options.slideNumberStart > 2147483647))
+    invalid("Slide numbering requires a signed 32-bit integer.");
+  for (const value of [options.loop, options.scaleContent])
+    if (value !== void 0 && typeof value !== "boolean") invalid("Expected a boolean setting.");
+  if (options.showType !== void 0 && !["speaker", "window", "kiosk"].includes(options.showType))
+    invalid("Invalid slideshow type.");
+  const loaded = await load(input, context);
+  const { reader, graph, main, dialect, limits, source } = loaded;
+  const pn = (localName) => ({ namespace: dialect.p, localName });
+  const types = parseContentTypes(reader.get("/[Content_Types].xml"), limits);
+  for (const name of reader.names) {
+    if (name === "/[Content_Types].xml") continue;
+    const type = types.get(name).toLowerCase();
+    if (type.includes("digital-signature") || type.includes("macroenabled") || type.includes("vbaproject"))
+      unsupported2("Signed and macro-enabled packages cannot be changed.");
+  }
+  for (const owner of ["/", ...graph.parts])
+    if (graph.outgoing(owner).some((e) => e.type.includes("/digital-signature/") || e.type.endsWith("/vbaProject")))
+      unsupported2("Signed and macro-enabled packages cannot be changed.");
+  const previous = settings(loaded.document.root, loaded.propertyDocument?.root);
+  const document = applyPresentationCanvasSettings(
+    loaded.document,
+    options,
+    loaded.propertyDocument
+  );
+  const changes = /* @__PURE__ */ new Map([[main, document.bytes()]]);
+  if (options.scaleContent) {
+    if (options.width === void 0 && options.height === void 0 && options.orientation === void 0)
+      invalid("Content scaling requires a slide canvas change.");
+    const next = settings(document.root, loaded.propertyDocument?.root);
+    if (!previous.width || !previous.height || !next.width || !next.height)
+      unsupported2("Content scaling requires complete nonzero slide dimensions.");
+    const sx = next.width / previous.width, sy = next.height / previous.height;
+    for (const name of reader.names) {
+      if (name === "/[Content_Types].xml") continue;
+      const type = types.get(name);
+      if (["slide", "slideLayout", "slideMaster"].some(
+        (kind) => type === `application/vnd.openxmlformats-officedocument.presentationml.${kind}+xml`
+      )) {
+        const drawing = parseXmlPart(reader.get(name), context.xmlLimits);
+        changes.set(name, scaleDrawingCanvas(drawing, sx, sy).bytes());
+      }
+    }
+  }
+  if (options.loop !== void 0 || options.showType !== void 0) {
+    let propertyPart = loaded.propertyPart;
+    let properties = loaded.propertyDocument;
+    if (!propertyPart) {
+      const folder = main.slice(0, main.lastIndexOf("/"));
+      propertyPart = `${folder}/presProps.xml`;
+      let suffix = 1;
+      while (reader.names.some((n) => n.toLowerCase() === propertyPart.toLowerCase()))
+        propertyPart = `${folder}/presProps${suffix++}.xml`;
+      properties = parseXmlPart(
+        new TextEncoder().encode(`<p:presentationPr xmlns:p="${dialect.p}"/>`),
+        context.xmlLimits
+      );
+      const relationshipPart = `${folder}/_rels/${main.slice(main.lastIndexOf("/") + 1)}.rels`;
+      let rels = parseXmlPart(
+        reader.names.includes(relationshipPart) ? reader.get(relationshipPart) : new TextEncoder().encode(
+          '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"/>'
+        ),
+        context.xmlLimits
+      );
+      const ids = new Set(graph.outgoing(main).map((e) => e.id));
+      let id = 1;
+      while (ids.has(`rId${id}`)) id++;
+      rels = rels.spliceChildren(rels.root, rels.root.children.length, 0, [
+        `<Relationship xmlns="http://schemas.openxmlformats.org/package/2006/relationships" Id="rId${id}" Type="${dialect.r}/presProps" Target="${escapeAttribute(relativePartReference(propertyPart, folder || "/"))}"/>`
+      ]);
+      changes.set(relationshipPart, rels.bytes());
+      let content = parseXmlPart(reader.get("/[Content_Types].xml"), context.xmlLimits);
+      content = content.spliceChildren(content.root, content.root.children.length, 0, [
+        `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="${escapeAttribute(propertyPart)}" ContentType="application/vnd.openxmlformats-officedocument.presentationml.presProps+xml"/>`
+      ]);
+      changes.set("/[Content_Types].xml", content.bytes());
+    }
+    const mode = options.showType && { speaker: "present", window: "browse", kiosk: "kiosk" }[options.showType];
+    properties = properties.merge(properties.root, {
+      children: {
+        sequence: ["htmlPubPr", "webPr", "prnPr", "showPr", "clrMru", "extLst"].map(pn),
+        upsert: [
+          {
+            name: pn("showPr"),
+            merge: {
+              attributes: options.loop === void 0 ? [] : [{ namespace: "", localName: "loop", value: options.loop ? "1" : "0" }],
+              ...mode ? {
+                children: {
+                  sequence: [
+                    "present",
+                    "browse",
+                    "kiosk",
+                    "sldAll",
+                    "sldRg",
+                    "custShow",
+                    "penClr",
+                    "extLst"
+                  ].map(pn),
+                  remove: ["present", "browse", "kiosk"].filter((n) => n !== mode).map(pn),
+                  upsert: [{ name: pn(mode), merge: {} }]
+                }
+              } : {}
+            }
+          }
+        ]
+      }
+    });
+    changes.set(propertyPart, properties.bytes());
+  }
+  if ([...changes].every(
+    ([name, bytes]) => reader.names.includes(name) && (() => {
+      const original = reader.get(name);
+      return bytes.length === original.length && bytes.every((value, index) => value === original[index]);
+    })()
+  ))
+    return source;
+  const output = await writePackageArchive(
+    [.../* @__PURE__ */ new Set([...reader.names, ...changes.keys()])].map((name) => ({
+      name: name.slice(1),
+      bytes: changes.get(name) ?? reader.get(name)
+    })),
+    context,
+    { compression: "auto", source }
+  );
+  if (!validatePresentation(await readPackage(output, context), limits).valid)
+    throw new OfficeError(
+      "invalid-opc",
+      "Changed settings fail graph validation.",
+      "validate-result"
+    );
+  return output;
+}
+
+export {
+  readPresentationSettings,
+  applyPresentationCanvasSettings,
+  mutatePresentationSettings
+};

package/dist/safe-bash/command-chunks/{chunk-2AKKYY5G.js → chunk-ASZ4EMKE.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-72XKZU7O.js";
 import {
   boundedCodec
-} from "./chunk-JW3KIZU6.js";
+} from "./chunk-RUXY7GN5.js";
 
 // packages/safe-bash-compression-engine/src/zstd-decode.ts
 import { PublicDiagnostic } from "../../safe-bash-contracts/diagnostics.js";

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

@@ -0,0 +1,144 @@
+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 {
+  paragraphTextRun
+} from "./chunk-GGOZXIGH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  UnsupportedEditError,
+  runElementOpen
+} from "./chunk-YPVBU7QF.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  SelectionError,
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/shape-edit.ts
+function plainParagraph(body, w) {
+  const clean = (node) => node.content.every((n) => n.kind === "element" || n.kind === "text" && !n.text.trim());
+  const pNames = ["pStyle", "bidi", "jc", "spacing", "ind", "keepNext", "keepLines", "pageBreakBefore", "widowControl", "outlineLvl", "tabs"];
+  const rNames = ["b", "i", "u", "color", "sz", "szCs", "bCs", "iCs", "rtl", "vanish", "rFonts", "lang", "rStyle", "highlight", "strike", "dstrike", "caps", "smallCaps", "vertAlign"];
+  const properties = (node, names) => clean(node) && node.children.every((n) => n.namespace === w && names.includes(n.localName) && clean(n) && (n.localName === "tabs" ? n.children.every((t) => t.namespace === w && t.localName === "tab" && !t.children.length && clean(t)) : !n.children.length));
+  if (!clean(body) || body.children.length !== 1) return void 0;
+  const p = body.children[0];
+  if (p.namespace !== w || p.localName !== "p" || !clean(p)) return void 0;
+  if (p.children.filter((n) => n.localName === "pPr").length > 1 || p.children.some((n, i) => n.localName === "pPr" && i !== 0)) return void 0;
+  for (const n of p.children) {
+    if (n.namespace !== w) return void 0;
+    if (n.localName === "pPr") {
+      if (!properties(n, pNames)) return void 0;
+      continue;
+    }
+    if (n.localName !== "r" || !clean(n) || n.children.filter((c) => c.localName === "rPr").length > 1) return void 0;
+    for (let i = 0; i < n.children.length; i++) {
+      const c = n.children[i];
+      if (c.namespace !== w) return void 0;
+      if (c.localName === "rPr") {
+        if (i !== 0 || !properties(c, rNames)) return void 0;
+      } else if (c.localName === "t") {
+        if (c.children.length || c.content.some((t) => t.kind !== "text" && t.kind !== "cdata")) return void 0;
+      } else if (!["tab", "br", "cr"].includes(c.localName) || c.content.length) return void 0;
+    }
+  }
+  return p;
+}
+async function inspectDocumentShapes(input, options, context) {
+  const settings = archiveSettings(context), invocation = validateDocxInvocation({ operation: "shapes.list", inputs: ["document"], options }, settings.budget);
+  const opts = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((item) => [item.name, item.value])));
+  const document = await openDocumentLocations(input, { ...settings, budget }, "inventory");
+  const all = document.list("shape", { scope: "all-stories" });
+  const headerShapes = new Set(document.list("shape", { scope: "headers" }).map((location) => location.token));
+  const selected = resolveDocxSelection(document, invocation);
+  const items = selected.map((location) => {
+    const carrier = document.shapeCarrier(location.token);
+    const containingGroup = carrier.group ? all.find((candidate) => document.shapeCarrier(candidate.token).node === carrier.group) ?? null : null;
+    const name = carrier.node.attributes.find((a) => !a.namespace && a.localName === "id")?.value;
+    const stories = document.list("story", { owner: location.token });
+    const plain = carrier.bodies.length === 1 && plainParagraph(carrier.bodies[0].node, carrier.bodies[0].wordNamespace);
+    const shared = document.references(location.token).length > 1;
+    const editable = carrier.support === "supported" && !!plain && !shared;
+    const sectionReferences = document.references(location.token);
+    const watermarkEvidence = [];
+    if (headerShapes.has(location.token)) watermarkEvidence.push("header-story");
+    const stack = [carrier.node];
+    while (stack.length) {
+      const node = stack.pop();
+      budget.charge("work", 1);
+      if (node.namespace === "urn:schemas-microsoft-com:vml" && node.localName === "textpath" && !watermarkEvidence.includes("text-path-declaration")) watermarkEvidence.push("text-path-declaration");
+      for (const child of node.children) stack.push(child);
+    }
+    const refusalReasons = [...carrier.refusalReasons, ...shared ? ["shared-owner"] : [], ...carrier.bodies.length && !plain ? ["plain-assignment-profile"] : []];
+    return { kind: "shape", location, ...name ? { name } : {}, properties: [], references: [], support: editable ? "edit" : "preserve", details: { representation: carrier.representation, kind: carrier.kind, containingGroup, textBoxStories: stories, ownerPart: location.value.part, sectionReferences, refusalReasons, watermarkEvidence, editSupport: editable ? "supported" : "unsupported" } };
+  });
+  const data = { items, warnings: [] };
+  measurePackageResourceSerialization(data, budget);
+  return data;
+}
+async function editDocumentShapes(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  const settings = archiveSettings(context), invocation = validateDocxInvocation({ operation: request.operation, inputs: [request.input?.path ?? "document"], options: request.options }, settings.budget);
+  const identity = request.input ? { path: request.input.path, stat: { ...request.input.stat } } : void 0;
+  const opts = invocation.options, budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((item) => [item.name, item.value])));
+  const document = await openDocumentLocations(input, { ...settings, budget });
+  const selected = resolveDocxSelection(document, invocation);
+  const archive = document.snapshot();
+  assertDocumentEditable(archive, { ...settings, budget });
+  const editor = new DocumentArchiveEditor(archive, {}, void 0, budget);
+  const changes = [];
+  for (const before of selected) {
+    if (document.references(before.token).length > 1) throw new SelectionError("ambiguous-selection");
+    const carrier = document.shapeCarrier(before.token);
+    if (carrier.kind !== "shape" || carrier.refusalReasons.length || carrier.bodies.length !== 1) throw new UnsupportedEditError("The selected shape does not admit text assignment.");
+    const xml = editor.xml(before.value.part.slice(1));
+    let node = xml.root;
+    for (const index of before.value.path) node = node.children[index];
+    xml.assertShapeEditAllowed(node);
+    const bodyLocation = document.shapeStory(before.token);
+    let body = xml.root;
+    for (const index of bodyLocation.value.path) body = body.children[index];
+    const dialect = dialectForNamespace(xml.root.namespace), w = documentDialects[dialect].w;
+    const paragraph = plainParagraph(body, w);
+    if (!paragraph) throw new UnsupportedEditError("Shape assignment requires one plain paragraph and supported properties.");
+    const props = paragraph.children.find((n) => n.localName === "pPr");
+    const replacement = runElementOpen(paragraph) + (props ? xml.sourceXml(props) : "") + paragraphTextRun(w, opts.text ?? "") + "</" + paragraph.name + ">";
+    if (replacement === xml.sourceXml(paragraph)) continue;
+    xml.replaceElement(paragraph, replacement);
+    const value = { ...before.value, generation: 1 };
+    changes.push({ kind: "replace", before, after: { ...before, value, token: encodeGeneratedLocation(value) } });
+  }
+  const candidate = editor.snapshot();
+  const publication = { ...identity ? { input: identity } : {}, ...opts.output === void 0 ? {} : { output: opts.output }, ...opts.inPlace === void 0 ? {} : { inPlace: opts.inPlace }, ...opts.force === void 0 ? {} : { force: opts.force }, ...opts.dryRun === void 0 ? {} : { dryRun: opts.dryRun }, ...opts.json === void 0 ? {} : { json: opts.json } };
+  const prospective = { changed: !!changes.length, changes, dryRun: opts.dryRun ?? false, output: opts.dryRun ? null : { path: opts.inPlace ? identity?.path ?? null : opts.output === "-" ? null : opts.output ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } };
+  measurePackageResourceSerialization(prospective, budget);
+  context.admitPublication?.(prospective);
+  const result = await publishDocumentArchive(candidate, publication, { ...context, budget });
+  return { ...prospective, output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null };
+}
+
+export {
+  inspectDocumentShapes,
+  editDocumentShapes
+};

package/dist/safe-bash/command-chunks/{chunk-MRFW2E6B.js → chunk-B4UWZCQR.js}

@@ -1,4 +1,4 @@
-// packages/safe-bash-command-node/src/commands/safejs/options.ts
+// packages/safe-bash-command-safejs/src/options.ts
 import { UsageError } from "../../safe-bash-io-engine/internal.js";
 var defaultSafeJsLimits = Object.freeze({});
 var unlimitedLimits = Object.freeze({