@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,410 @@
+import {
+  nodeFor,
+  selected,
+  validateSelection
+} from "./chunk-QHS7PDG3.js";
+import {
+  applyShapeUpdate,
+  readShape
+} from "./chunk-HHLVI2CB.js";
+import {
+  Length
+} from "./chunk-I6AMDG2T.js";
+import {
+  attr,
+  child,
+  loadShared,
+  required
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError,
+  readSelectionIndex
+} from "./chunk-CKEODJVT.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/shape-selection.ts
+var kinds = ["sp", "pic", "cxnSp", "graphicFrame", "grpSp"];
+var bound = 27273042316900;
+function invalid(message) {
+  throw new OfficeError("invalid-value", message, "usage");
+}
+function unsupported(message) {
+  throw new OfficeError("unsupported-edit", message, "validate-intent");
+}
+function data(value, keys) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Reflect.ownKeys(value).some(
+    (key) => typeof key !== "string" || !keys.includes(key) || !("value" in Object.getOwnPropertyDescriptor(value, key))
+  ))
+    invalid("Expected exact stored selection data fields.");
+}
+function length(value) {
+  if (!(value instanceof Length) || !("value" in (Object.getOwnPropertyDescriptor(value, "emu") ?? {})) || !Number.isSafeInteger(value.emu) || Math.abs(value.emu) > bound)
+    invalid("An explicit bounded offset Length is required.");
+}
+function validateShapeSelectionOptions(options) {
+  data(options, [
+    "action",
+    "coordinateSystem",
+    "shapes",
+    "scope",
+    "slide",
+    "part",
+    "shape",
+    "select",
+    "all",
+    "allowEmpty",
+    "order",
+    "position",
+    "alignment",
+    "axis",
+    "offsetX",
+    "offsetY"
+  ]);
+  if (!["slide", "group"].includes(options.coordinateSystem))
+    invalid("Explicit slide or group coordinate space is required.");
+  const actionKeys = {
+    move: ["order", "position"],
+    align: ["alignment"],
+    distribute: ["axis"],
+    duplicate: ["offsetX", "offsetY"]
+  };
+  if (!Object.hasOwn(actionKeys, options.action)) invalid("Unknown selection action.");
+  const allowed = actionKeys[options.action];
+  for (const key of ["order", "position", "alignment", "axis", "offsetX", "offsetY"])
+    if (Object.hasOwn(options, key) && !allowed.includes(key))
+      invalid("Unexpected selection action option.");
+  if (options.action === "move") {
+    if (options.order === void 0 === (options.position === void 0))
+      invalid("Exactly one order or position is required.");
+    if (options.order !== void 0 && !["front", "back", "forward", "backward"].includes(options.order))
+      invalid("Invalid sibling order.");
+    if (options.position !== void 0 && (!Number.isSafeInteger(options.position) || options.position < 1))
+      invalid("Position requires a positive one-based integer.");
+  } else if (options.action === "align") {
+    if (!["left", "center", "right", "top", "middle", "bottom"].includes(options.alignment))
+      invalid("Invalid alignment.");
+  } else if (options.action === "distribute") {
+    if (!["horizontal", "vertical"].includes(options.axis)) invalid("Invalid distribution axis.");
+  } else {
+    length(options.offsetX);
+    length(options.offsetY);
+  }
+  if (options.shapes !== void 0) {
+    if (!Array.isArray(options.shapes) || !options.shapes.length)
+      throw new SelectionError("invalid-selection");
+    const descriptors = Object.getOwnPropertyDescriptors(options.shapes);
+    const arrayKeys = Reflect.ownKeys(descriptors);
+    if (arrayKeys.length !== options.shapes.length + 1 || arrayKeys.some(
+      (key) => typeof key !== "string" || key !== "length" && (!Number.isSafeInteger(Number(key)) || Number(key) < 0 || String(Number(key)) !== key || Number(key) >= options.shapes.length) || !("value" in descriptors[key])
+    ))
+      invalid("Identity arrays require dense stored entries.");
+    for (const location of options.shapes) {
+      const keys = ["fingerprint", "scope", "owner", "objectId", "coordinateSystem"];
+      data(location, keys);
+      if (keys.some(
+        (key) => typeof location[key] !== "string" || !location[key].length
+      ) || location.coordinateSystem !== "identity")
+        invalid("Invalid identity location.");
+    }
+    if (["slide", "part", "shape", "select", "all", "allowEmpty"].some(
+      (key) => Object.hasOwn(options, key)
+    ))
+      throw new SelectionError("invalid-selection");
+  }
+  const selection = Object.fromEntries(
+    Object.entries(options).filter(
+      ([key]) => ["scope", "slide", "part", "shape", "select", "all", "allowEmpty"].includes(key)
+    )
+  );
+  validateSelection(selection, "set");
+}
+function walk(root) {
+  const nodes = [], pending = [root];
+  while (pending.length) {
+    const node = pending.pop();
+    nodes.push(node);
+    pending.push(...[...node.children].reverse());
+  }
+  return nodes;
+}
+function identity(node) {
+  const nv = node.children.find(
+    (n) => n.name.namespace === node.name.namespace && ["nvSpPr", "nvPicPr", "nvCxnSpPr", "nvGraphicFramePr", "nvGrpSpPr"].includes(n.name.localName)
+  );
+  return attr(required(nv ?? unsupported("Missing shape identity."), "cNvPr"), "id") ?? unsupported("Missing shape identity.");
+}
+function admitted(doc, ids, options) {
+  if (!ids.length || new Set(ids).size !== ids.length)
+    throw new SelectionError("invalid-selection");
+  const nodes = ids.map((id) => nodeFor(doc.root, id)), all = walk(doc.root);
+  const parents = /* @__PURE__ */ new Map();
+  for (const node of all) for (const child2 of node.children) parents.set(child2, node);
+  const parent = parents.get(nodes[0]);
+  if (!parent || !["spTree", "grpSp"].includes(parent.name.localName) || nodes.some((node) => parents.get(node) !== parent) || (parent.name.localName === "grpSp" ? "group" : "slide") !== options.coordinateSystem)
+    throw new SelectionError("invalid-selection");
+  const selectedNodes = new Set(nodes);
+  const ordered = parent.children.filter((n) => selectedNodes.has(n));
+  for (const root of ordered) {
+    const affected = walk(root);
+    let ancestor = parents.get(root);
+    while (ancestor) {
+      if (ancestor.name.localName === "grpSp")
+        affected.push(
+          ...ancestor.children.filter((n) => n.name.localName === "nvGrpSpPr").flatMap(walk)
+        );
+      ancestor = parents.get(ancestor);
+    }
+    for (const n of affected)
+      if ([
+        "http://schemas.openxmlformats.org/drawingml/2006/main",
+        "http://purl.oclc.org/ooxml/drawingml/main"
+      ].includes(n.name.namespace) && ["spLocks", "picLocks", "cxnSpLocks", "graphicFrameLocks", "grpSpLocks"].includes(
+        n.name.localName
+      ) && n.attributes.some(
+        (a) => a.name.namespace === "" && ["noSelect", options.action === "duplicate" ? "noCopy" : "noMove"].includes(
+          a.name.localName
+        ) && ["1", "true"].includes(a.value)
+      ))
+        unsupported("The selection contains locked objects.");
+  }
+  return { parent, ordered, all };
+}
+function box(node) {
+  const shape = readShape(node);
+  const values = [shape.left, shape.top, shape.width, shape.height];
+  if (values.some((v) => v === null || !Number.isSafeInteger(v) || Math.abs(v) > bound) || shape.width <= 0 || shape.height <= 0)
+    unsupported("Selection operations require explicit bounded geometry.");
+  return { id: identity(node), x: shape.left, y: shape.top, w: shape.width, h: shape.height };
+}
+function round(n, d = 1n) {
+  const sign = n < 0n ? -1n : 1n, abs = n * sign;
+  const result = Number(sign * ((abs + d / 2n) / d));
+  if (!Number.isSafeInteger(result) || Math.abs(result) > bound)
+    invalid("Selection coordinates exceed the admitted bounds.");
+  return result;
+}
+function applyShapeSelection(doc, ids, options) {
+  validateShapeSelectionOptions(options);
+  const { parent, ordered, all } = admitted(doc, ids, options), originalIds = ordered.map(identity);
+  if (options.action === "move") {
+    const siblings = parent.children.filter(
+      (n) => n.name.namespace === parent.name.namespace && kinds.includes(n.name.localName)
+    ), chosen = new Set(ordered);
+    let next = [...siblings];
+    if (options.order === "front" || options.order === "back" || options.position !== void 0) {
+      next = siblings.filter((n) => !chosen.has(n));
+      const index2 = options.position !== void 0 ? options.position - 1 : options.order === "back" ? 0 : next.length;
+      if (index2 > next.length) invalid("Sibling position exceeds the available insertion range.");
+      next.splice(index2, 0, ...ordered);
+    } else if (options.order === "forward") {
+      for (let i = next.length - 2; i >= 0; i--)
+        if (chosen.has(next[i]) && !chosen.has(next[i + 1]))
+          [next[i], next[i + 1]] = [next[i + 1], next[i]];
+    } else {
+      for (let i = 1; i < next.length; i++)
+        if (chosen.has(next[i]) && !chosen.has(next[i - 1]))
+          [next[i - 1], next[i]] = [next[i], next[i - 1]];
+    }
+    let index = 0;
+    return {
+      doc: doc.reorderChildren(
+        parent,
+        parent.children.map((n) => siblings.includes(n) ? next[index++] : n)
+      ),
+      ids: originalIds
+    };
+  }
+  if (options.action === "duplicate") {
+    const used = /* @__PURE__ */ new Set();
+    for (const n of all.filter(
+      (n2) => n2.name.namespace === doc.root.name.namespace && n2.name.localName === "cNvPr"
+    )) {
+      const value = attr(n, "id");
+      if (!value?.length || [...value].some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(value)) || Number(value) > 4294967295 || used.has(Number(value)))
+        unsupported("Invalid or duplicate shape identity.");
+      used.add(Number(value));
+    }
+    let next = 1;
+    for (const id of used) next = Math.max(next, id + 1);
+    const drawing = doc.root.name.namespace === "http://purl.oclc.org/ooxml/presentationml/main" ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+    const relationships = doc.root.name.namespace === "http://purl.oclc.org/ooxml/presentationml/main" ? "http://purl.oclc.org/ooxml/officeDocument/relationships" : "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+    const mapping = /* @__PURE__ */ new Map();
+    for (const node of ordered.flatMap(walk)) {
+      if (![doc.root.name.namespace, drawing].includes(node.name.namespace) || node.attributes.some(
+        (a) => ![
+          "",
+          relationships,
+          "http://www.w3.org/XML/1998/namespace",
+          "http://www.w3.org/2000/xmlns/"
+        ].includes(a.name.namespace)
+      ))
+        unsupported("Opaque copied namespaces or attributes cannot be duplicated safely.");
+      if (node.name.localName === "extLst" && node.children.length)
+        unsupported("Opaque duplicate-local extensions cannot be remapped safely.");
+      if (node.name.namespace === doc.root.name.namespace && kinds.includes(node.name.localName)) {
+        if (next > 4294967295) {
+          next = 1;
+          while (used.has(next)) next++;
+        }
+        if (next > 4294967295) unsupported("No available shape identity.");
+        mapping.set(String(Number(identity(node))), String(next));
+        used.add(next++);
+      }
+      if (node.attributes.some((a) => ["spid", "spId", "shapeId"].includes(a.name.localName)))
+        unsupported("Duplicate-local timing references are unsupported.");
+    }
+    const copies = [];
+    for (const original of ordered) {
+      let copy = parseXmlPart(new TextEncoder().encode(doc.markup(original, true)), {
+        maxBytes: doc.bytes().length * 2 + 1024,
+        maxNodes: doc.nodeCount + 1,
+        maxDepth: doc.nodeCount + 1
+      });
+      const originalNodes = walk(copy.root);
+      for (let i = 0; i < originalNodes.length; i++) {
+        const node = walk(copy.root)[i];
+        if (node.name.localName === "cNvPr" && node.name.namespace === doc.root.name.namespace)
+          copy = copy.merge(node, {
+            attributes: [
+              {
+                namespace: "",
+                localName: "id",
+                value: mapping.get(String(Number(attr(node, "id"))))
+              }
+            ]
+          });
+        else if (["stCxn", "endCxn"].includes(node.name.localName) && node.name.namespace === drawing && mapping.has(String(Number(attr(node, "id")))))
+          copy = copy.merge(node, {
+            attributes: [
+              {
+                namespace: "",
+                localName: "id",
+                value: mapping.get(String(Number(attr(node, "id"))))
+              }
+            ]
+          });
+      }
+      const g = box(copy.root);
+      const owner = copy.root.name.localName === "graphicFrame" ? copy.root : required(copy.root, copy.root.name.localName === "grpSp" ? "grpSpPr" : "spPr");
+      const transform = child(
+        owner,
+        "xfrm",
+        copy.root.name.localName === "graphicFrame" ? copy.root.name.namespace : drawing
+      );
+      const off = child(transform, "off", drawing);
+      copy = copy.merge(off, {
+        attributes: [
+          {
+            namespace: "",
+            localName: "x",
+            value: String(round(BigInt(g.x) + BigInt(options.offsetX.emu)))
+          },
+          {
+            namespace: "",
+            localName: "y",
+            value: String(round(BigInt(g.y) + BigInt(options.offsetY.emu)))
+          }
+        ]
+      });
+      copies.push(copy.markup(copy.root, true));
+    }
+    const last = parent.children.reduce(
+      (index, n, i) => n.name.namespace === parent.name.namespace && kinds.includes(n.name.localName) ? i : index,
+      -1
+    );
+    return {
+      doc: doc.spliceChildren(parent, last + 1, 0, copies),
+      ids: originalIds.map((id) => mapping.get(String(Number(id))))
+    };
+  }
+  const boxes = ordered.map(box);
+  if (boxes.length < (options.action === "align" ? 2 : 3))
+    throw new SelectionError("invalid-selection");
+  const horizontal = options.action === "align" ? ["left", "center", "right"].includes(options.alignment) : options.axis === "horizontal";
+  const start = (b) => BigInt(horizontal ? b.x : b.y), size = (b) => BigInt(horizontal ? b.w : b.h);
+  const positions = /* @__PURE__ */ new Map();
+  if (options.action === "align") {
+    const lo = boxes.reduce((v, b) => start(b) < v ? start(b) : v, start(boxes[0])), hi = boxes.reduce(
+      (v, b) => start(b) + size(b) > v ? start(b) + size(b) : v,
+      start(boxes[0]) + size(boxes[0])
+    );
+    for (const b of boxes)
+      positions.set(
+        b.id,
+        ["left", "top"].includes(options.alignment) ? round(lo) : ["right", "bottom"].includes(options.alignment) ? round(hi - size(b)) : round(lo + hi - size(b), 2n)
+      );
+  } else {
+    const sorted = [...boxes].sort((a, b) => Number(start(a) - start(b))), first = sorted[0], last = sorted.at(-1), count = BigInt(sorted.length - 1);
+    const total = sorted.reduce((n, b) => n + size(b), 0n), gap = start(last) + size(last) - start(first) - total;
+    let widths = 0n;
+    for (let i = 0; i < sorted.length; i++) {
+      const b = sorted[i];
+      positions.set(
+        b.id,
+        i === sorted.length - 1 ? Number(start(last)) : round((start(first) + widths) * count + BigInt(i) * gap, count)
+      );
+      widths += size(b);
+    }
+  }
+  let changed = doc;
+  for (const b of boxes)
+    changed = applyShapeUpdate(
+      changed,
+      nodeFor(changed.root, b.id),
+      horizontal ? { left: new Length(positions.get(b.id)) } : { top: new Length(positions.get(b.id)) }
+    );
+  return { doc: changed, ids: originalIds };
+}
+async function mutateShapeSelection(input, options, context) {
+  validateShapeSelectionOptions(options);
+  if (!options.shapes && !options.select && options.shape === void 0 && options.slide === void 0 && !options.part && !options.all)
+    throw new SelectionError("invalid-selection");
+  const s = await loadShared(input, context), allowed = selected(s, options);
+  const records = options.shapes ? options.shapes.map((location) => {
+    if (location.fingerprint !== s.index.fingerprint)
+      throw new SelectionError("stale-selection");
+    const record = allowed.find(
+      (r) => r.location.scope === location.scope && r.location.owner === location.owner && r.location.objectId === location.objectId
+    );
+    if (!record) throw new SelectionError("invalid-selection");
+    return record;
+  }) : allowed;
+  if (!records.length) {
+    if (!options.allowEmpty) throw new SelectionError("missing-selection");
+    return { bytes: s.source, part: s.main, affectedSlides: [], affected: 0, records: [] };
+  }
+  if (records.length > 1 && !options.shapes && !options.all)
+    throw new SelectionError(
+      "ambiguous-selection",
+      records.map((r) => r.location)
+    );
+  const part = records[0].part;
+  if (records.some((r) => r.part !== part)) throw new SelectionError("invalid-selection");
+  const result = applyShapeSelection(
+    s.doc(part),
+    records.map((r) => r.id),
+    options
+  );
+  s.save(part, result.doc);
+  const finished = await s.finish(
+    part,
+    s.index.inventory.slides.filter((x) => [x.part, x.master, x.layout].includes(part)).map((x) => x.position)
+  );
+  const index = await readSelectionIndex(finished.bytes, context);
+  return {
+    ...finished,
+    affected: records.length,
+    records: result.ids.map((id) => index.objects.find((r) => r.part === part && r.id === id))
+  };
+}
+
+export {
+  validateShapeSelectionOptions,
+  applyShapeSelection,
+  mutateShapeSelection
+};

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

@@ -0,0 +1,169 @@
+import {
+  UnsupportedEditError,
+  paragraphUnits,
+  runElementOpen,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  storedBooleanValue,
+  trimXmlWhitespace
+} from "./chunk-VEUQWV2V.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  InvalidDocumentError
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/section-properties.ts
+var sectionPropertyOrder = "headerReference footerReference footnotePr endnotePr type pgSz pgMar paperSrc pgBorders lnNumType pgNumType cols formProt vAlign noEndnote titlePg textDirection bidi rtlGutter docGrid printerSettings sectPrChange".split(" ");
+var sectionStarts = { CONTINUOUS: "continuous", NEW_COLUMN: "nextColumn", NEW_PAGE: "nextPage", EVEN_PAGE: "evenPage", ODD_PAGE: "oddPage" };
+function sectionAttribute(node, key) {
+  return node?.attributes.find((a) => a.namespace === node.namespace && a.localName === key)?.value;
+}
+function sectionChild(node, key, children = (node2) => node2.children) {
+  const matches = node ? children(node).filter((c) => c.namespace === node.namespace && c.localName === key) : [];
+  if (matches.length > 1) throw new UnsupportedEditError("Duplicate section properties cannot be interpreted.");
+  return matches[0];
+}
+function sectionInteger(node, key, fallback = null, scale = 1) {
+  const raw = sectionAttribute(node, key);
+  if (raw === void 0) return fallback;
+  const value = trimXmlWhitespace(raw);
+  const digits = value.startsWith("-") || value.startsWith("+") ? value.slice(1) : value;
+  if (!digits || [...digits].some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(value)) || !Number.isSafeInteger(Number(value) * scale))
+    throw new InvalidDocumentError("Section properties require valid integer storage.");
+  return Number(value);
+}
+function sectionOrientation(node) {
+  const value = sectionAttribute(node, "orient") ?? "portrait";
+  if (value !== "portrait" && value !== "landscape")
+    throw new InvalidDocumentError("Invalid stored section orientation.");
+  return value;
+}
+function sectionBoolean(node, attribute = "val", absent = false) {
+  if (node === void 0) return absent;
+  const value = sectionAttribute(node, attribute);
+  if (value === void 0) return attribute === "val" || absent;
+  const decoded = storedBooleanValue(value);
+  if (decoded === null) throw new UnsupportedEditError("Invalid section policy value.");
+  return decoded;
+}
+function readSectionProperties(node, children = (node2) => node2.children) {
+  const size = sectionChild(node, "pgSz", children), margin = sectionChild(node, "pgMar", children), columns = sectionChild(node, "cols", children), numbers = sectionChild(node, "pgNumType", children);
+  const equalWidth = sectionBoolean(columns, "equalWidth", true);
+  return {
+    equalWidth,
+    pageWidth: sectionInteger(size, "w", null, 635),
+    pageHeight: sectionInteger(size, "h", null, 635),
+    orientation: sectionAttribute(size, "orient") ?? "portrait",
+    topMargin: sectionInteger(margin, "top", null, 635),
+    bottomMargin: sectionInteger(margin, "bottom", null, 635),
+    leftMargin: sectionInteger(margin, "left", null, 635),
+    rightMargin: sectionInteger(margin, "right", null, 635),
+    gutter: sectionInteger(margin, "gutter", 0, 635),
+    headerDistance: sectionInteger(margin, "header", null, 635),
+    footerDistance: sectionInteger(margin, "footer", null, 635),
+    startType: sectionAttribute(sectionChild(node, "type", children), "val") ?? "nextPage",
+    columns: equalWidth ? sectionInteger(columns, "num", 1) : children(columns).filter((c) => c.namespace === columns.namespace && c.localName === "col").length,
+    columnGap: equalWidth ? sectionInteger(columns, "space", 720, 635) : null,
+    columnSeparator: sectionBoolean(columns, "sep"),
+    pageNumberStart: sectionInteger(numbers, "start"),
+    pageNumberFormat: sectionAttribute(numbers, "fmt") ?? "decimal",
+    differentFirstPage: sectionBoolean(sectionChild(node, "titlePg", children))
+  };
+}
+function formatSectionProperties(xml, node, options, omitReferences = false, gutterAtTop = false, children = (node2) => node2.children) {
+  const w = xml.root.namespace;
+  if (sectionChild(node, "sectPrChange", children)) throw new UnsupportedEditError("Revised section properties require a revision operation.");
+  const direct = readSectionProperties(node, children);
+  const replacements = /* @__PURE__ */ new Map();
+  const additions = /* @__PURE__ */ new Map();
+  const set = (name, attrs, removeColumns = false) => {
+    const old = sectionChild(node, name, children);
+    if (old && (!removeColumns || !children(old).some((c) => c.namespace === w && c.localName === "col")) && Object.entries(attrs).every(([k, v]) => sectionAttribute(old, k) === v)) return;
+    const prefix = old?.name.includes(":") ? old.name.split(":")[0] : "sp";
+    const namespaces = new Map(old?.namespaces ?? node?.namespaces);
+    namespaces.set(prefix, w);
+    const bindings = [...namespaces].filter(([p]) => p !== "xml").map(([p, uri]) => ` ${p ? "xmlns:" + p : "xmlns"}="${xmlValue(uri)}"`).join("");
+    const retained = old?.attributes.filter((a) => a.namespace !== "http://www.w3.org/2000/xmlns/" && !(a.namespace === w && Object.hasOwn(attrs, a.localName))).map((a) => ` ${a.name}="${xmlValue(a.value)}"`).join("") ?? "";
+    const inner = old ? xml.sourceXml(old, new Map(removeColumns ? children(old).filter((c) => c.namespace === w && c.localName === "col").map((c) => [c, ""]) : []), true) : "";
+    const value = `<${prefix}:${name}${bindings}${retained}${Object.entries(attrs).map(([k, v]) => ` ${prefix}:${k}="${xmlValue(v)}"`).join("")}>${inner}</${prefix}:${name}>`;
+    if (old) replacements.set(old, value);
+    else additions.set(name, value);
+  };
+  const sizes = {}, margins = {};
+  for (const [field, name] of [["pageWidth", "w"], ["pageHeight", "h"]]) {
+    const value = options[field];
+    if (value === void 0) continue;
+    const count = paragraphUnits(value);
+    if (count < 1) throw new DocxUsageError("Page dimensions must round to positive twips.");
+    sizes[name] = String(count);
+    direct[field] = count;
+  }
+  if (options.orientation !== void 0) sizes.orient = options.orientation.name === "LANDSCAPE" ? "landscape" : "portrait";
+  for (const [field, name] of [["topMargin", "top"], ["bottomMargin", "bottom"], ["leftMargin", "left"], ["rightMargin", "right"], ["gutter", "gutter"], ["headerDistance", "header"], ["footerDistance", "footer"]]) {
+    const value = options[field];
+    if (value === void 0) continue;
+    const count = paragraphUnits(value);
+    if (value.value < 0 || count < 0) throw new DocxUsageError("Section margins and distances must be nonnegative.");
+    margins[name] = String(count);
+    direct[field] = count;
+  }
+  const geometryEdit = Object.keys(sizes).some((k) => k !== "orient") || Object.keys(margins).some((k) => !["header", "footer"].includes(k)) || options.columns !== void 0 || options.columnGap !== void 0;
+  if (geometryEdit && !direct.equalWidth && options.columns === void 0) throw new UnsupportedEditError("Geometry edits over custom columns require explicit conversion with a column count.");
+  if (geometryEdit) {
+    const { pageWidth, pageHeight, leftMargin, rightMargin, topMargin, bottomMargin, gutter } = direct;
+    if ([pageWidth, pageHeight, leftMargin, rightMargin, topMargin, bottomMargin].some((n) => n === null)) throw new UnsupportedEditError("Geometry edits require explicit dimensions and margins; unresolved layout inheritance cannot be inferred.");
+    const horizontalGutter = gutterAtTop ? 0 : gutter;
+    const verticalGutter = gutterAtTop ? gutter : 0;
+    if (pageWidth - leftMargin - rightMargin - horizontalGutter <= 0 || pageHeight - topMargin - bottomMargin - verticalGutter <= 0)
+      throw new DocxUsageError("Margins and gutter must leave positive content extent.");
+    const count = options.columns ?? direct.columns;
+    const gap = options.columnGap ? paragraphUnits(options.columnGap) : direct.columnGap ?? 720;
+    if (gap < 0 || options.columnGap && options.columnGap.value < 0 || pageWidth - leftMargin - rightMargin - horizontalGutter - (count - 1) * gap < count)
+      throw new DocxUsageError("Columns must leave positive content widths.");
+  }
+  if (Object.keys(sizes).length) set("pgSz", sizes);
+  if (Object.keys(margins).length) set("pgMar", margins);
+  if (options.startType) set("type", { val: sectionStarts[options.startType.name] });
+  const numbers = {};
+  if (options.pageNumberStart !== void 0) numbers.start = String(options.pageNumberStart);
+  if (options.pageNumberFormat !== void 0) numbers.fmt = options.pageNumberFormat;
+  if (Object.keys(numbers).length) set("pgNumType", numbers);
+  if (options.columns !== void 0 || options.columnGap !== void 0 || options.columnSeparator !== void 0) {
+    const attrs = {};
+    if (options.columns !== void 0) Object.assign(attrs, { num: String(options.columns), equalWidth: "1", space: String(options.columnGap ? paragraphUnits(options.columnGap) : direct.columnGap ?? 720) });
+    else if (options.columnGap !== void 0) attrs.space = String(paragraphUnits(options.columnGap));
+    if (options.columnSeparator !== void 0) attrs.sep = String(Number(options.columnSeparator));
+    set("cols", attrs, options.columns !== void 0);
+  }
+  if (options.differentFirstPage !== void 0 && options.differentFirstPage !== direct.differentFirstPage) set("titlePg", { val: String(Number(options.differentFirstPage)) });
+  if (omitReferences) {
+    for (const child of node ? children(node) : []) if (child.namespace === w && ["headerReference", "footerReference"].includes(child.localName)) replacements.set(child, "");
+  }
+  let tail = "";
+  const prefixes = /* @__PURE__ */ new Map();
+  for (const name of sectionPropertyOrder) {
+    const markup = additions.get(name);
+    if (markup === void 0) continue;
+    const next = (node ? children(node) : []).find((c) => c.namespace === w && sectionPropertyOrder.indexOf(c.localName) > sectionPropertyOrder.indexOf(name));
+    if (next) prefixes.set(next, (prefixes.get(next) ?? "") + markup);
+    else tail += markup;
+  }
+  for (const [next, prefix] of prefixes) replacements.set(next, prefix + (replacements.get(next) ?? xml.sourceXml(next)));
+  if (!replacements.size && !tail) return node ? xml.sourceXml(node) : "";
+  return (node ? runElementOpen(node) : `<sp:sectPr xmlns:sp="${w}">`) + (node ? xml.sourceXml(node, replacements, true) : "") + tail + `</${node?.name ?? "sp:sectPr"}>`;
+}
+
+export {
+  sectionPropertyOrder,
+  sectionStarts,
+  sectionAttribute,
+  sectionChild,
+  sectionInteger,
+  sectionOrientation,
+  sectionBoolean,
+  readSectionProperties,
+  formatSectionProperties
+};

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

@@ -0,0 +1,27 @@
+import {
+  findRelationshipPart
+} from "./chunk-4LXDJES2.js";
+import {
+  DocumentXmlEditor,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  propertyGroupDefinition
+} from "./chunk-VEUQWV2V.js";
+
+// packages/safe-bash-docx-engine/src/property-part.ts
+function createPropertyPart(archive, group, budget) {
+  const definition = propertyGroupDefinition(group, archive.dialect), name = archive.package.allocatePartName(definition.base, ".xml");
+  const types = archive.members.find((m) => m.name === "[Content_Types].xml"), typesEditor = new DocumentXmlEditor(types.bytes, {}, void 0, budget);
+  typesEditor.insertChildren(typesEditor.root, `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="${xmlValue(name)}" ContentType="${definition.contentType}"/>`);
+  const rootRelationships = findRelationshipPart(archive.package, "/", budget);
+  const relationships = archive.members.find((m) => m.name === rootRelationships.name), relEditor = new DocumentXmlEditor(relationships.bytes, {}, void 0, budget), id = archive.package.allocateRelationshipId("/");
+  relEditor.insertChildren(relEditor.root, `<Relationship xmlns="http://schemas.openxmlformats.org/package/2006/relationships" Id="${id}" Type="${definition.relationship}" Target="${xmlValue(name.slice(1))}"/>`);
+  const members = archive.members.map((m) => m === types ? { ...m, bytes: typesEditor.serialize() } : m === relationships ? { ...m, bytes: relEditor.serialize() } : m);
+  members.push({ name: name.slice(1), bytes: new TextEncoder().encode(`<p:${definition.root} xmlns:p="${definition.namespace}"/>`), directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") });
+  return { archive: { ...archive, members }, name };
+}
+
+export {
+  createPropertyPart
+};