@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-7MMSBVUP.js

@@ -0,0 +1,732 @@
+import {
+  openDocumentLocations,
+  resolveDocxSelection
+} from "./chunk-LHDB4QO5.js";
+import {
+  measurePackageResourceSerialization
+} from "./chunk-W6DV2CLS.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  LocationIndex
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  assertOutsideRevisionRanges,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  parseDocumentXml
+} 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-layout.ts
+var attr = (node, name) => node.attributes.find((value) => value.namespace === "" && value.localName === name)?.value;
+var horizontalFrames = [
+  "page",
+  "margin",
+  "column",
+  "character",
+  "leftMargin",
+  "rightMargin",
+  "insideMargin",
+  "outsideMargin"
+];
+var verticalFrames = [
+  "page",
+  "margin",
+  "paragraph",
+  "line",
+  "topMargin",
+  "bottomMargin",
+  "insideMargin",
+  "outsideMargin"
+];
+var horizontalAlign = ["left", "right", "center", "inside", "outside"];
+var verticalAlign = ["top", "bottom", "center", "inside", "outside"];
+var wraps = {
+  none: "wrapNone",
+  square: "wrapSquare",
+  tight: "wrapTight",
+  through: "wrapThrough",
+  "top-bottom": "wrapTopAndBottom"
+};
+var wrapSides = ["bothSides", "left", "right", "largest"];
+var decorativeNamespace = "http://schemas.microsoft.com/office/drawing/2017/decorative";
+function unsupported() {
+  throw new UnsupportedEditError("Selected image metadata cannot be edited coherently.");
+}
+function nativeToken(value) {
+  if (value === void 0) return void 0;
+  let start = 0, end = value.length;
+  while (start < end && " 	\r\n".includes(value[start])) start++;
+  while (end > start && " 	\r\n".includes(value[end - 1])) end--;
+  return value.slice(start, end);
+}
+function integer(value, min, max) {
+  const token = nativeToken(value);
+  if (token === void 0 || token.length === 0 || token.length > 32 || [...token].some(
+    (char, index) => !(char >= "0" && char <= "9") && !(index === 0 && ["-", "+"].includes(char))
+  ))
+    unsupported();
+  const result = Number(token);
+  if (!Number.isSafeInteger(result) || result < min || result > max) unsupported();
+  return result;
+}
+function boolean(value) {
+  const token = nativeToken(value);
+  if (token === "1" || token === "true") return true;
+  if (token === "0" || token === "false") return false;
+  return unsupported();
+}
+function one(parent, namespace, name, optional = false) {
+  const matches = parent.children.filter(
+    (node) => node.namespace === namespace && node.localName === name
+  );
+  if (matches.length > 1 || !optional && !matches.length) unsupported();
+  return matches[0];
+}
+function rounded(value, min, max) {
+  if (!Number.isFinite(value) || (min === 1 ? value <= 0 : value < min) || value > max)
+    throw new InvalidValueError("Image layout value exceeds its native range.");
+  const result = Math.sign(value) * Math.round(Math.abs(value));
+  if (!Number.isSafeInteger(result) || result < min || result > max)
+    throw new InvalidValueError("Rounded image layout value exceeds its native range.");
+  return result;
+}
+function length(value, min, max) {
+  return rounded(
+    value.value * { emu: 1, in: 914400, cm: 36e4, mm: 36e3, pt: 12700 }[value.unit],
+    min,
+    max
+  );
+}
+function picture(frame, dialect, budget) {
+  const ns = documentDialects[dialect], graphic = one(frame, ns.a, "graphic"), data = one(graphic, ns.a, "graphicData"), pic = one(data, ns.pic, "pic");
+  if (data.children.length !== 1 || attr(data, "uri") !== ns.pic) unsupported();
+  const fill = one(pic, ns.pic, "blipFill"), blip = one(fill, ns.a, "blip"), sp = one(pic, ns.pic, "spPr"), transform = one(sp, ns.a, "xfrm"), nv = one(pic, ns.pic, "nvPicPr");
+  if (transform.children.some(
+    (node) => node.namespace === ns.a && ["chOff", "chExt"].includes(node.localName)
+  ))
+    unsupported();
+  budget.charge(
+    "work",
+    frame.children.length + pic.children.length + fill.children.length + transform.children.length
+  );
+  return {
+    frame,
+    picture: pic,
+    fill,
+    blip,
+    transform,
+    extent: one(frame, ns.wp, "extent"),
+    innerExtent: one(transform, ns.a, "ext"),
+    docPr: one(frame, ns.wp, "docPr"),
+    frameProperties: one(frame, ns.wp, "cNvGraphicFramePr", true),
+    pictureProperties: one(nv, ns.pic, "cNvPicPr")
+  };
+}
+function polygon(node, wp, budget) {
+  const start = one(node, wp, "start"), lines = node.children.filter((child) => child.namespace === wp && child.localName === "lineTo");
+  if (lines.length < 2 || node.children.length !== lines.length + 1 || node.children[0] !== start)
+    unsupported();
+  budget.charge("work", lines.length + 1);
+  budget.check("matches", lines.length + 1);
+  for (const point of [start, ...lines]) {
+    integer(attr(point, "x"), -27273042329600, 27273042316900);
+    integer(attr(point, "y"), -27273042329600, 27273042316900);
+    if (point.children.length) unsupported();
+  }
+}
+function put(xml, node, values, budget) {
+  const numeric = [
+    "cx",
+    "cy",
+    "rot",
+    "l",
+    "r",
+    "t",
+    "b",
+    "relativeHeight",
+    "distT",
+    "distB",
+    "distL",
+    "distR"
+  ];
+  const logical = ["allowOverlap", "behindDoc", "noChangeAspect", "flipH", "flipV", "val"];
+  const changes = Object.entries(values).filter(([name, value]) => {
+    const previous = attr(node, name);
+    if (previous === value) return false;
+    if (logical.includes(name) && previous !== void 0)
+      return boolean(previous) !== boolean(value);
+    if (numeric.includes(name) && previous !== void 0) {
+      const token = nativeToken(previous);
+      if (token.length > 0 && token.length <= 32 && [...token].every(
+        (char, index) => char >= "0" && char <= "9" || index === 0 && ["-", "+"].includes(char)
+      ) && Number.isSafeInteger(Number(token)))
+        return Number(token) !== Number(value);
+    }
+    return true;
+  });
+  if (!changes.length) return;
+  if (changes.every(([name]) => attr(node, name) !== void 0)) {
+    for (const [name, value] of changes) xml.setAttribute(node, name, value);
+    return;
+  }
+  const source = xml.sourceXml(node), namespaceBytes = [...node.namespaces].reduce(
+    (sum, [name, value]) => sum + name.length + value.length * 6 + 12,
+    0
+  ), missing = [];
+  budget.charge("retainedBytes", namespaceBytes * 12 + source.length * 8);
+  budget.charge("work", namespaceBytes * 8 + source.length * 4);
+  const prefix = `<h${[...node.namespaces].filter(([name]) => name !== "xml").map(([name, value]) => ` xmlns${name ? ":" + name : ""}="${xmlValue(value)}"`).join("")}>`, fragment = new DocumentXmlEditor(
+    new TextEncoder().encode(prefix + source + "</h>"),
+    {},
+    void 0,
+    budget
+  ), target = fragment.root.children[0];
+  for (const [name, value] of changes) {
+    if (attr(node, name) !== void 0) fragment.setAttribute(target, name, value);
+    else missing.push([name, value]);
+  }
+  let markup = new TextDecoder().decode(fragment.serialize()).slice(prefix.length, -4), quote = "", end = -1;
+  for (let index = 1; index < markup.length; index++) {
+    const char = markup[index];
+    if (quote) {
+      if (char === quote) quote = "";
+    } else if (char === '"' || char === "'") quote = char;
+    else if (char === ">") {
+      end = index;
+      break;
+    }
+  }
+  if (end < 0) unsupported();
+  const extraSize = missing.reduce(
+    (sum, [name, value]) => sum + name.length + value.length * 6 + 4,
+    0
+  );
+  budget.check("xmlPartBytes", source.length + extraSize);
+  budget.charge("retainedBytes", extraSize * 12);
+  budget.charge("work", extraSize * 8);
+  const insertion = markup[end - 1] === "/" ? end - 1 : end, extra = missing.map(([name, value]) => ` ${name}="${xmlValue(value)}"`).join("");
+  markup = markup.slice(0, insertion) + extra + markup.slice(insertion);
+  xml.replaceElement(node, markup);
+}
+async function setDocumentImageLayout(input, request, context) {
+  if (!request || ![Object.prototype, null].includes(Object.getPrototypeOf(request)))
+    throw new InputTypeError("Expected closed image layout data.");
+  closedRecord(request, ["operation", "options", "input"]);
+  if (request.operation !== "images.set") throw new DocxUsageError("Expected image layout set.");
+  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: "images.set",
+      inputs: [request.input?.path ?? "document"],
+      options: request.options
+    },
+    settings.budget
+  ), options = invocation.options, budget = settings.budget.lower(
+    Object.fromEntries((options.limit ?? []).map((item) => [item.name, item.value]))
+  ), scoped = { ...settings, budget };
+  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], staged = /* @__PURE__ */ new Map();
+  const plans = [];
+  const anchorFields = [
+    "x",
+    "y",
+    "relativeTo",
+    "horizontalRelativeFrom",
+    "verticalRelativeFrom",
+    "horizontalAlignment",
+    "verticalAlignment",
+    "wrap",
+    "wrapText",
+    "wrapPolygon",
+    "distanceTop",
+    "distanceBottom",
+    "distanceLeft",
+    "distanceRight",
+    "allowOverlap",
+    "behindText",
+    "zOrder"
+  ];
+  for (const before of selected) {
+    if (before.kind !== "image" || before.value.range !== null) unsupported();
+    const member = graph.getPart(before.value.part), xml = new DocumentXmlEditor(member.bytes, {}, void 0, budget);
+    let node = xml.root;
+    const ancestors = [node];
+    for (const index2 of before.value.path) {
+      node = node.children[index2];
+      ancestors.push(node);
+    }
+    const frameIndex = ancestors.findIndex(
+      (value) => value.namespace === ns.wp && ["inline", "anchor"].includes(value.localName)
+    );
+    if (frameIndex < 0) unsupported();
+    const frame = ancestors[frameIndex], p = picture(frame, dialect, budget);
+    if (node !== p.blip) unsupported();
+    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"))
+      ))
+    ))
+      unsupported();
+    assertOutsideRevisionRanges(xml.root, node, budget, xml.compatibility.branches);
+    if (frame.localName === "inline" && anchorFields.some((key) => options[key] !== void 0))
+      unsupported();
+    const resizing = options.width !== void 0 || options.height !== void 0;
+    if (resizing) {
+      const x = integer(attr(p.extent, "cx"), 1, 2147483647), y = integer(attr(p.extent, "cy"), 1, 2147483647);
+      if (x !== integer(attr(p.innerExtent, "cx"), 1, 2147483647) || y !== integer(attr(p.innerExtent, "cy"), 1, 2147483647))
+        unsupported();
+    }
+    const existingAlt = attr(p.docPr, "descr") ?? "", decorative = [];
+    const scan = (value) => {
+      budget.charge("work", 1);
+      if (value.namespace === decorativeNamespace && value.localName === "decorative")
+        decorative.push(value);
+      value.children.forEach(scan);
+    };
+    scan(p.docPr);
+    if (decorative.length > 1) unsupported();
+    const state = options.decorative ?? (decorative.length ? boolean(attr(decorative[0], "val")) : false), alt = options.alt ?? existingAlt;
+    if (state && alt.length)
+      throw new DocxUsageError("Decorative content conflicts with retained nonempty alt text.");
+    plans.push({
+      before,
+      framePath: before.value.path.slice(0, frameIndex),
+      changed: false
+    });
+  }
+  for (const plan of plans) {
+    const member = graph.getPart(plan.before.value.part), name = member.name;
+    const edit = (action) => {
+      const before = staged.get(name) ?? member.bytes, xml = new DocumentXmlEditor(before, {}, void 0, budget);
+      let frame = xml.root;
+      for (const index2 of plan.framePath) frame = frame.children[index2];
+      const p = picture(frame, dialect, budget);
+      action(xml, p);
+      const after = xml.serialize();
+      budget.charge("work", Math.max(before.length, after.length));
+      if (before.length !== after.length || before.some((byte, index2) => byte !== after[index2]))
+        plan.changed = true;
+      staged.set(name, after);
+    };
+    for (const [field, native, min, max] of [
+      ["zOrder", "relativeHeight", 0, 4294967295],
+      ["distanceTop", "distT", 0, 4294967295],
+      ["distanceBottom", "distB", 0, 4294967295],
+      ["distanceLeft", "distL", 0, 4294967295],
+      ["distanceRight", "distR", 0, 4294967295]
+    ]) {
+      const value = options[field];
+      if (value === void 0) continue;
+      const numeric = typeof value === "number" ? rounded(value, min, max) : length(value, min, max);
+      edit((xml, p) => put(xml, p.frame, { [native]: String(numeric) }, budget));
+    }
+    for (const [field, native] of [
+      ["allowOverlap", "allowOverlap"],
+      ["behindText", "behindDoc"]
+    ])
+      if (options[field] !== void 0)
+        edit((xml, p) => put(xml, p.frame, { [native]: options[field] ? "1" : "0" }, budget));
+    for (const horizontal of [true, false]) {
+      const offset = horizontal ? options.x : options.y, alignment = horizontal ? options.horizontalAlignment : options.verticalAlignment, relative = options.relativeTo ?? (horizontal ? options.horizontalRelativeFrom : options.verticalRelativeFrom);
+      if (offset === void 0 && alignment === void 0 && relative === void 0) continue;
+      edit((xml, p) => {
+        if (attr(p.frame, "simplePos") !== void 0 && boolean(attr(p.frame, "simplePos")))
+          unsupported();
+        const axis = one(p.frame, ns.wp, horizontal ? "positionH" : "positionV"), choice = axis.children;
+        if (choice.length !== 1 || choice[0].namespace !== ns.wp || !["align", "posOffset"].includes(choice[0].localName))
+          unsupported();
+        const frames = horizontal ? horizontalFrames : verticalFrames, aligns = horizontal ? horizontalAlign : verticalAlign;
+        if (!frames.includes(attr(axis, "relativeFrom") ?? "")) unsupported();
+        if (choice[0].localName === "align") {
+          if (!aligns.includes(choice[0].text)) unsupported();
+        } else integer(choice[0].text, -2147483648, 2147483647);
+        if (relative !== void 0) put(xml, axis, { relativeFrom: relative }, budget);
+      });
+      if (offset !== void 0 || alignment !== void 0)
+        edit((xml, p) => {
+          const axis = one(p.frame, ns.wp, horizontal ? "positionH" : "positionV"), choice = axis.children[0], markup = offset !== void 0 ? `<wp:posOffset xmlns:wp="${ns.wp}">${length(offset, -2147483648, 2147483647)}</wp:posOffset>` : `<wp:align xmlns:wp="${ns.wp}">${alignment}</wp:align>`;
+          if (offset !== void 0 && choice.localName === "posOffset" && integer(choice.text, -2147483648, 2147483647) === length(offset, -2147483648, 2147483647) || alignment !== void 0 && choice.localName === "align" && choice.text === alignment)
+            return;
+          const target = offset === void 0 ? "align" : "posOffset";
+          if (choice.localName === target && choice.content.length === 1 && choice.content[0].kind === "text")
+            xml.setText(
+              choice.content[0],
+              offset === void 0 ? alignment : String(length(offset, -2147483648, 2147483647))
+            );
+          else xml.replaceElement(choice, markup);
+        });
+    }
+    const wrapFields = [
+      "wrap",
+      "wrapText",
+      "wrapPolygon",
+      "distanceTop",
+      "distanceBottom",
+      "distanceLeft",
+      "distanceRight"
+    ];
+    if (wrapFields.some((key) => options[key] !== void 0))
+      edit((xml, p) => {
+        const choices = p.frame.children.filter(
+          (node) => node.namespace === ns.wp && Object.values(wraps).includes(node.localName)
+        );
+        if (choices.length !== 1) unsupported();
+        const current = choices[0], mode = options.wrap ?? Object.keys(wraps).find(
+          (key) => wraps[key] === current.localName
+        ), resultName = wraps[mode], sideMode = ["square", "tight", "through"].includes(mode), tight = ["tight", "through"].includes(mode);
+        if (options.wrapText !== void 0 && !sideMode || options.wrapPolygon !== void 0 && !tight)
+          throw new DocxUsageError("Inapplicable wrap metadata.");
+        const text = options.wrapText ?? attr(current, "wrapText");
+        if (sideMode && !wrapSides.includes(text ?? "")) unsupported();
+        const existing = one(current, ns.wp, "wrapPolygon", true);
+        if (existing) polygon(existing, ns.wp, budget);
+        if (tight && !options.wrapPolygon && !existing) unsupported();
+        const attrs = {};
+        if (sideMode) attrs.wrapText = text;
+        for (const attribute of current.attributes) {
+          if (attribute.namespace === "http://www.w3.org/2000/xmlns/") {
+            attrs[attribute.name] = attribute.value;
+            continue;
+          }
+          if (attribute.namespace !== "" || !["wrapText", "distT", "distB", "distL", "distR"].includes(attribute.localName))
+            unsupported();
+          if (attribute.localName.startsWith("dist")) {
+            const allowed = mode === "square" || (["tight", "through"].includes(mode) ? ["distL", "distR"].includes(attribute.localName) : mode === "top-bottom" && ["distT", "distB"].includes(attribute.localName));
+            if (!allowed) {
+              const field = {
+                distT: "distanceTop",
+                distB: "distanceBottom",
+                distL: "distanceLeft",
+                distR: "distanceRight"
+              }[attribute.localName];
+              if (options[field] === void 0 && integer(attribute.value, 0, 4294967295) !== integer(attr(p.frame, attribute.localName), 0, 4294967295))
+                unsupported();
+              continue;
+            }
+            attrs[attribute.localName] = attribute.value;
+          }
+        }
+        for (const [field, native] of [
+          ["distanceTop", "distT"],
+          ["distanceBottom", "distB"],
+          ["distanceLeft", "distL"],
+          ["distanceRight", "distR"]
+        ]) {
+          if (options[field] !== void 0 && attrs[native] !== void 0)
+            attrs[native] = String(length(options[field], 0, 4294967295));
+        }
+        const children = current.children.filter((node) => node !== existing);
+        if (children.some((node) => node.namespace !== ns.wp || node.localName !== "effectExtent") || children.length && !(mode === "square" || mode === "top-bottom"))
+          unsupported();
+        let childMarkup = children.map((node) => xml.sourceXml(node)).join("");
+        if (tight) {
+          if (options.wrapPolygon) {
+            const points = [options.wrapPolygon.start, ...options.wrapPolygon.lineTo];
+            budget.check("matches", points.length);
+            budget.charge("retainedBytes", points.length * 512);
+            budget.charge("work", points.length * 128);
+            childMarkup = `<wp:wrapPolygon xmlns:wp="${ns.wp}" edited="1"><wp:start x="${points[0].x}" y="${points[0].y}"/>${points.slice(1).map((point) => `<wp:lineTo x="${point.x}" y="${point.y}"/>`).join("")}</wp:wrapPolygon>`;
+          } else childMarkup += xml.sourceXml(existing);
+        }
+        if (resultName === current.localName && options.wrapPolygon === void 0) {
+          put(
+            xml,
+            current,
+            Object.fromEntries(Object.entries(attrs).filter(([key]) => !key.startsWith("xmlns"))),
+            budget
+          );
+          return;
+        }
+        const values = Object.entries(attrs).map(([key, value]) => ` ${key}="${xmlValue(value)}"`).join("");
+        xml.replaceElement(
+          current,
+          `<wp:${resultName}${attrs["xmlns:wp"] === void 0 ? ` xmlns:wp="${ns.wp}"` : ""}${values}>${childMarkup}</wp:${resultName}>`
+        );
+      });
+    const resize = options.width !== void 0 || options.height !== void 0;
+    if (resize) {
+      let x = 0, y = 0, crop;
+      edit((xml, p) => {
+        const oldX = integer(attr(p.extent, "cx"), 1, 2147483647), oldY = integer(attr(p.extent, "cy"), 1, 2147483647), width = options.width === void 0 ? void 0 : length(options.width, 1, 2147483647), height = options.height === void 0 ? void 0 : length(options.height, 1, 2147483647);
+        x = width ?? rounded(height * oldX / oldY, 1, 2147483647);
+        y = height ?? rounded(width * oldY / oldX, 1, 2147483647);
+        if (options.fit === "contain") {
+          const scale = Math.min(x / oldX, y / oldY);
+          x = rounded(oldX * scale, 1, 2147483647);
+          y = rounded(oldY * scale, 1, 2147483647);
+        }
+        if (options.fit === "cover") {
+          const scale = Math.max(x / oldX, y / oldY), h = Math.round((1 - x / (oldX * scale)) * 5e4), v = Math.round((1 - y / (oldY * scale)) * 5e4);
+          if (h * 2 >= 1e5 || v * 2 >= 1e5) unsupported();
+          crop = [h, h, v, v];
+        } else if (options.fit) crop = [0, 0, 0, 0];
+        put(xml, p.extent, { cx: String(x), cy: String(y) }, budget);
+      });
+      edit((xml, p) => put(xml, p.innerExtent, { cx: String(x), cy: String(y) }, budget));
+      if (crop)
+        edit((xml, p) => {
+          const node = one(p.fill, ns.a, "srcRect", true), values = {
+            l: String(crop[0]),
+            r: String(crop[1]),
+            t: String(crop[2]),
+            b: String(crop[3])
+          };
+          if (node) put(xml, node, values, budget);
+          else
+            xml.insertChildren(
+              p.fill,
+              `<a:srcRect xmlns:a="${ns.a}" l="${values.l}" r="${values.r}" t="${values.t}" b="${values.b}"/>`,
+              p.fill.children[p.fill.children.indexOf(p.blip) + 1]
+            );
+        });
+    }
+    const cropKeys = ["cropLeft", "cropRight", "cropTop", "cropBottom"];
+    if (cropKeys.some((key) => options[key] !== void 0))
+      edit((xml, p) => {
+        const node = one(p.fill, ns.a, "srcRect", true), names = ["l", "r", "t", "b"], merged = names.map(
+          (name2) => node && attr(node, name2) !== void 0 ? integer(attr(node, name2), 0, 1e5) : 0
+        ), values = {};
+        for (let index2 = 0; index2 < 4; index2++) {
+          const value = options[cropKeys[index2]];
+          if (value !== void 0) {
+            merged[index2] = value * 1e5;
+            values[names[index2]] = String(Math.round(merged[index2]));
+          }
+        }
+        if (merged[0] + merged[1] >= 1e5 || merged[2] + merged[3] >= 1e5 || Math.round(merged[0]) + Math.round(merged[1]) >= 1e5 || Math.round(merged[2]) + Math.round(merged[3]) >= 1e5)
+          throw new DocxUsageError("Merged opposing crops must leave a nonempty source.");
+        if (node) put(xml, node, values, budget);
+        else {
+          const all = names.map((name2, index2) => `${name2}="${Math.round(merged[index2])}"`).join(" ");
+          xml.insertChildren(
+            p.fill,
+            `<a:srcRect xmlns:a="${ns.a}" ${all}/>`,
+            p.fill.children[p.fill.children.indexOf(p.blip) + 1]
+          );
+        }
+      });
+    const transformValues = {};
+    if (options.rotation !== void 0)
+      transformValues.rot = String(rounded(options.rotation * 6e4, -216e5, 216e5));
+    if (options.flipHorizontal !== void 0)
+      transformValues.flipH = options.flipHorizontal ? "1" : "0";
+    if (options.flipVertical !== void 0)
+      transformValues.flipV = options.flipVertical ? "1" : "0";
+    if (Object.keys(transformValues).length)
+      edit((xml, p) => put(xml, p.transform, transformValues, budget));
+    if (options.lockAspect !== void 0) {
+      edit((xml, p) => {
+        if (!p.frameProperties) {
+          xml.insertChildren(
+            p.frame,
+            `<wp:cNvGraphicFramePr xmlns:wp="${ns.wp}"><a:graphicFrameLocks xmlns:a="${ns.a}" noChangeAspect="${options.lockAspect ? "1" : "0"}"/></wp:cNvGraphicFramePr>`,
+            one(p.frame, ns.a, "graphic")
+          );
+          return;
+        }
+        const lock = one(p.frameProperties, ns.a, "graphicFrameLocks", true);
+        if (lock) put(xml, lock, { noChangeAspect: options.lockAspect ? "1" : "0" }, budget);
+        else
+          xml.insertChildren(
+            p.frameProperties,
+            `<a:graphicFrameLocks xmlns:a="${ns.a}" noChangeAspect="${options.lockAspect ? "1" : "0"}"/>`
+          );
+      });
+      edit((xml, p) => {
+        const lock = one(p.pictureProperties, ns.a, "picLocks", true);
+        if (lock) put(xml, lock, { noChangeAspect: options.lockAspect ? "1" : "0" }, budget);
+        else
+          xml.insertChildren(
+            p.pictureProperties,
+            `<a:picLocks xmlns:a="${ns.a}" noChangeAspect="${options.lockAspect ? "1" : "0"}"/>`,
+            p.pictureProperties.children[0]
+          );
+      });
+    }
+    if (options.alt !== void 0)
+      edit((xml, p) => put(xml, p.docPr, { descr: options.alt }, budget));
+    if (options.decorative !== void 0)
+      edit((xml, p) => {
+        const nodes = [];
+        const visit = (node) => {
+          budget.charge("work", 1);
+          if (node.namespace === decorativeNamespace && node.localName === "decorative")
+            nodes.push(node);
+          node.children.forEach(visit);
+        };
+        visit(p.docPr);
+        if (nodes.length > 1) unsupported();
+        if (nodes[0]) put(xml, nodes[0], { val: options.decorative ? "1" : "0" }, budget);
+        else if (options.decorative) {
+          const list = one(p.docPr, ns.a, "extLst", true), markup = `<a:ext xmlns:a="${ns.a}" uri="{C183D7F6-B498-43B3-948B-1728B52AA6E4}"><d:decorative xmlns:d="${decorativeNamespace}" val="1"/></a:ext>`;
+          if (list) xml.insertChildren(list, markup);
+          else xml.insertChildren(p.docPr, `<a:extLst xmlns:a="${ns.a}">${markup}</a:extLst>`);
+        }
+      });
+  }
+  budget.charge(
+    "retainedBytes",
+    archive.comment.length + archive.members.reduce(
+      (sum, member) => sum + (staged.get(member.name) ?? member.bytes).length + 128,
+      0
+    )
+  );
+  budget.charge(
+    "work",
+    archive.members.reduce((sum, member) => sum + member.bytes.length, 0)
+  );
+  const candidate = {
+    comment: new Uint8Array(archive.comment),
+    members: archive.members.map((member) => ({
+      ...member,
+      bytes: new Uint8Array(staged.get(member.name) ?? member.bytes),
+      modified: new Date(member.modified)
+    }))
+  };
+  const index = new LocationIndex(candidate, settings.limits, main.slice(1), dialect, budget), changes = [];
+  for (const plan of plans.filter((plan2) => plan2.changed)) {
+    const entries = index.entries.filter(
+      (entry2) => entry2.kind === "image" && entry2.part === plan.before.value.part && plan.framePath.every((part, index2) => entry2.path[index2] === part)
+    );
+    if (entries.length !== 1) unsupported();
+    const entry = entries[0], value = {
+      ...plan.before.value,
+      path: entry.path,
+      generation: plan.before.value.generation + 1
+    }, after = {
+      kind: "image",
+      value,
+      token: encodeGeneratedLocation(value),
+      positions: entry.positions
+    };
+    changes.push({ kind: "set", before: plan.before, after });
+  }
+  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: "images.set",
+        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 layout 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 },
+    void 0,
+    changes.length === 0 ? input : void 0
+  );
+  return {
+    ...planned,
+    output: result.published.length ? {
+      path: result.published[0].path,
+      bytes: result.published[0].bytes,
+      sha256: result.archiveSha256
+    } : null
+  };
+}
+
+export {
+  setDocumentImageLayout
+};