@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,463 @@
+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 {
+  inlineImageRun
+} from "./chunk-WVESNAND.js";
+import {
+  findRelationshipPart
+} from "./chunk-4LXDJES2.js";
+import {
+  characterizeRasterHeader
+} from "./chunk-FZSQMMYV.js";
+import {
+  LocationIndex,
+  addressKey
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  UnsupportedEditError,
+  assertOutsideRevisionRanges,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  asciiKey,
+  relativePartTarget
+} from "./chunk-WAKYUXVQ.js";
+import {
+  isXmlContentType,
+  parseDocumentXml
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  InputTypeError,
+  InvalidValueError,
+  ResourceLimitError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/svg-image.ts
+var svg = "http://www.w3.org/2000/svg";
+var xml = "http://www.w3.org/XML/1998/namespace";
+var xlink = "http://www.w3.org/1999/xlink";
+var elements = new Set("svg g defs symbol use rect circle ellipse line polyline polygon path title desc text tspan textPath linearGradient radialGradient stop clipPath mask pattern marker".split(" "));
+var attributes = new Set("id version x y width height viewBox preserveAspectRatio transform cx cy r rx ry x1 y1 x2 y2 points d dx dy rotate textLength lengthAdjust fill fill-rule fill-opacity stroke stroke-width stroke-opacity stroke-linecap stroke-linejoin stroke-miterlimit stroke-dasharray stroke-dashoffset opacity color clip-rule clip-path mask marker-start marker-mid marker-end markerWidth markerHeight refX refY orient markerUnits gradientUnits gradientTransform spreadMethod offset stop-color stop-opacity fx fy fr patternUnits patternContentUnits patternTransform clipPathUnits maskUnits maskContentUnits font-family font-size font-weight font-style text-anchor dominant-baseline visibility".split(" "));
+var hrefElements = /* @__PURE__ */ new Set(["use", "textPath", "linearGradient", "radialGradient", "pattern"]);
+var paints = /* @__PURE__ */ new Set(["fill", "stroke", "color", "stop-color"]);
+var references = /* @__PURE__ */ new Set(["clip-path", "mask", "marker-start", "marker-mid", "marker-end"]);
+var whitespace = (char) => char !== void 0 && " 	\r\n".includes(char);
+var letter = (char) => char !== void 0 && (char >= "a" && char <= "z" || char >= "A" && char <= "Z");
+var digit = (char) => char !== void 0 && char >= "0" && char <= "9";
+function reject() {
+  throw new UnsupportedEditError("SVG input exceeds the admitted static XML profile.");
+}
+function id(value) {
+  if (!(letter(value[0]) || value[0] === "_") || [...value].some((char) => !letter(char) && !digit(char) && !"_-.:".includes(char))) reject();
+  return value;
+}
+function resource(value) {
+  if (!value.startsWith("url(")) reject();
+  let index = 4;
+  while (whitespace(value[index])) index++;
+  const quote = value[index] === "'" || value[index] === '"' ? value[index++] : void 0;
+  if (value[index++] !== "#") reject();
+  const start = index;
+  while (index < value.length && !whitespace(value[index]) && value[index] !== ")" && value[index] !== quote) index++;
+  const target = id(value.slice(start, index));
+  if (quote && value[index++] !== quote) reject();
+  while (whitespace(value[index])) index++;
+  if (value[index++] !== ")" || index !== value.length) reject();
+  return target;
+}
+function numeric(value) {
+  let index = 0;
+  while (whitespace(value[index])) index++;
+  const start = index;
+  if (value[index] === "+" || value[index] === "-") index++;
+  let digits = 0;
+  while (digit(value[index])) {
+    digits++;
+    index++;
+  }
+  if (value[index] === ".") {
+    index++;
+    while (digit(value[index])) {
+      digits++;
+      index++;
+    }
+  }
+  if (!digits) reject();
+  if (value[index] === "e" || value[index] === "E") {
+    index++;
+    if (value[index] === "+" || value[index] === "-") index++;
+    const start2 = index;
+    while (digit(value[index])) index++;
+    if (index === start2) reject();
+  }
+  const result = Number(value.slice(start, index));
+  const percentage = value[index] === "%";
+  if (percentage) index++;
+  while (whitespace(value[index])) index++;
+  if (index !== value.length || !Number.isFinite(result)) reject();
+  return { value: result, percentage };
+}
+function color(value) {
+  if (["none", "currentColor", "transparent"].includes(value) || value.length && [...value].every(letter)) return;
+  if (value[0] === "#" && [4, 5, 7, 9].includes(value.length) && [...value.slice(1)].every((char) => digit(char) || char >= "a" && char <= "f" || char >= "A" && char <= "F")) return;
+  const name = value.slice(0, value.indexOf("("));
+  if (!["rgb", "rgba", "hsl", "hsla"].includes(name) || !value.endsWith(")")) reject();
+  const parts = value.slice(name.length + 1, -1).split(",");
+  const alpha = name === "rgba" || name === "hsla";
+  if (parts.length !== (alpha ? 4 : 3)) reject();
+  const tokens = parts.map(numeric);
+  const within = (token, maximum) => token.value >= 0 && token.value <= (token.percentage ? 100 : maximum);
+  if (name.startsWith("rgb")) {
+    if (tokens.slice(0, 3).some((token) => token.percentage !== tokens[0].percentage || !within(token, 255))) reject();
+  } else if (tokens[0].percentage || Math.abs(tokens[0].value) > Number.MAX_SAFE_INTEGER || tokens.slice(1, 3).some((token) => !token.percentage || !within(token, 100))) reject();
+  if (alpha && !within(tokens[3], 1)) reject();
+}
+function admitSvgImage(input, context) {
+  const { budget, limits } = archiveSettings(context);
+  budget.check("embeddedMediaBytes", input.length);
+  if (input.length > limits.maxEntryBytes) reject();
+  const root = parseDocumentXml(input, {}, budget).root;
+  if (root.namespace !== svg || root.localName !== "svg") reject();
+  const ids = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const pending = [];
+  const stack = [root];
+  while (stack.length) {
+    const node = stack.pop();
+    budget.charge("work", node.attributes.length + node.children.length + 1);
+    budget.charge("retainedBytes", 128 + node.children.length * 16);
+    if (node.namespace !== svg || !elements.has(node.localName)) reject();
+    for (const content of [node.content, node.prolog ?? [], node.epilog ?? []]) if (content.some((item) => item.kind === "processing-instruction")) reject();
+    edges.set(node, [...node.children]);
+    let href = false;
+    for (const attribute of node.attributes) {
+      const { namespace, localName, value } = attribute;
+      budget.charge("work", value.length + 1);
+      if (namespace === "http://www.w3.org/2000/xmlns/") continue;
+      if (namespace === xml && ["lang", "space"].includes(localName)) continue;
+      let target;
+      if ((namespace === "" || namespace === xlink) && localName === "href") {
+        if (href || !hrefElements.has(node.localName) || value[0] !== "#") reject();
+        href = true;
+        target = id(value.slice(1));
+      } else {
+        if (namespace || !attributes.has(localName)) reject();
+        if (localName === "id") {
+          const name = id(value);
+          if (ids.has(name)) reject();
+          budget.charge("retainedBytes", value.length * 2 + 64);
+          ids.set(name, node);
+        } else if (paints.has(localName) || references.has(localName)) {
+          if (value.includes("\\") || value.includes("%") && !["rgb(", "rgba(", "hsl(", "hsla("].some((prefix) => value.startsWith(prefix))) reject();
+          if (value.startsWith("url(")) target = resource(value);
+          else if (references.has(localName)) {
+            if (value !== "none") reject();
+          } else color(value);
+        }
+      }
+      if (target !== void 0) {
+        budget.charge("retainedBytes", target.length * 2 + 64);
+        pending.push({ source: node, target });
+      }
+    }
+    for (const child of node.children) stack.push(child);
+  }
+  for (const reference of pending) {
+    budget.charge("work", 1);
+    const target = ids.get(reference.target);
+    if (!target) reject();
+    edges.get(reference.source).push(target);
+  }
+  const state = /* @__PURE__ */ new Map();
+  const work = [{ node: root, exit: false }];
+  while (work.length) {
+    budget.charge("work", 1);
+    const { node, exit } = work.pop();
+    if (exit) {
+      state.set(node, "done");
+      continue;
+    }
+    if (state.get(node) === "visiting") reject();
+    if (state.has(node)) continue;
+    state.set(node, "visiting");
+    budget.charge("retainedBytes", 64 + edges.get(node).length * 32);
+    work.push({ node, exit: true });
+    for (const child of edges.get(node)) work.push({ node: child, exit: false });
+  }
+}
+
+// packages/safe-bash-docx-engine/src/image-insertion.ts
+async function acquireImage(input, context) {
+  closedRecord(input, ["kind", "base64", "path", "capability"]);
+  const { limits, signal, budget } = archiveSettings(context), maxBytes = Math.min(limits.maxEntryBytes, budget.limits.embeddedMediaBytes - budget.usage.embeddedMediaBytes);
+  let bytes;
+  if (input.kind === "bytes") {
+    closedRecord(input, ["kind", "base64"]);
+    const encoded = input.base64;
+    if (typeof encoded !== "string" || encoded.length % 4 !== 0) throw new InvalidValueError("Expected canonical image bytes.");
+    const padding = encoded.endsWith("==") ? 2 : encoded.endsWith("=") ? 1 : 0, size = encoded.length / 4 * 3 - padding;
+    if (size > maxBytes) throw new ResourceLimitError("Image bytes exceed the media limit.");
+    budget.charge("work", encoded.length);
+    budget.charge("retainedBytes", size * 3);
+    let decoded;
+    try {
+      decoded = atob(encoded);
+      if (btoa(decoded) !== encoded) throw new Error();
+    } catch {
+      throw new InvalidValueError("Expected canonical image bytes.");
+    }
+    bytes = Uint8Array.from(decoded, (c) => c.charCodeAt(0));
+  } else if (input.kind === "vfs") {
+    closedRecord(input, ["kind", "path", "capability"]);
+    if (typeof input.path !== "string" || !input.path || typeof input.capability !== "string" || !input.capability) throw new InvalidValueError("Expected an explicit image path capability.");
+    const resolver = context.binaryResolver;
+    if (!resolver || resolver.capability !== input.capability) throw new UnsupportedEditError("Image input requires a matching explicit VFS capability.");
+    signal.throwIfAborted();
+    const source = await resolver.open(input.path, { signal, maxBytes }), chunks = [];
+    let total = 0;
+    for await (const chunk of source) {
+      budget.check("work", 0);
+      if (!(chunk instanceof Uint8Array)) throw new InputTypeError("Expected image byte fragments.");
+      if (chunk.length > maxBytes - total) throw new ResourceLimitError("Image bytes exceed the media limit.");
+      total += chunk.length;
+      budget.charge("work", chunk.length + 1);
+      budget.charge("retainedBytes", chunk.length + 64);
+      if (chunk.length) chunks.push(new Uint8Array(chunk));
+    }
+    budget.check("work", 0);
+    budget.charge("retainedBytes", total);
+    bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.length;
+    }
+  } else throw new InvalidValueError("Expected explicit image binary input.");
+  budget.charge("embeddedMediaBytes", bytes.length);
+  budget.check("work", 0);
+  return bytes;
+}
+function checkedExtent(value) {
+  if (!Number.isFinite(value) || value <= 0 || value > Number.MAX_SAFE_INTEGER) throw new InvalidValueError("Image dimensions must be positive safe EMUs.");
+  const result = Math.round(value);
+  if (!Number.isSafeInteger(result) || result <= 0) throw new InvalidValueError("Image dimensions must be positive safe EMUs.");
+  return result;
+}
+function xmlTextSize(value, utf8, escaped = false) {
+  let bytes = 0, characters = 0;
+  for (let index = 0; index < value.length; index++) {
+    const point = value.codePointAt(index);
+    if (escaped && !(point === 9 || point === 10 || point === 13 || point >= 32 && point <= 55295 || point >= 57344 && point <= 65533 || point >= 65536 && point <= 1114111)) throw new InvalidValueError("Invalid XML character in image alternative text.");
+    const expansion = escaped ? point === 38 ? 5 : point === 60 || point === 62 || point === 9 ? 4 : point === 34 ? 6 : point === 10 || point === 13 ? 5 : 0 : 0;
+    const units = expansion || (point > 65535 ? 2 : 1);
+    characters += units;
+    bytes += utf8 ? expansion || (point < 128 ? 1 : point < 2048 ? 2 : point < 65536 ? 3 : 4) : units * 2;
+    if (point > 65535) index++;
+  }
+  return { bytes, characters };
+}
+function imageSize(header, options) {
+  const length = (value) => value === void 0 ? void 0 : checkedExtent(value.value * { emu: 1, in: 914400, cm: 36e4, mm: 36e3, pt: 12700 }[value.unit]);
+  const nativeWidth = header.pixelWidth / (header.horizontalDpi ?? 72) * 914400, nativeHeight = header.pixelHeight / (header.verticalDpi ?? 72) * 914400;
+  const width = length(options.width), height = length(options.height);
+  let x = width ?? nativeWidth, y = height ?? nativeHeight, crop = "";
+  if (options.fit && (width === void 0 || height === void 0)) throw new DocxUsageError("Explicit fit requires both box dimensions.");
+  if ((width === void 0 || height === void 0 || options.fit === "contain" || options.fit === "cover") && (!Number.isFinite(nativeWidth) || nativeWidth <= 0 || !Number.isFinite(nativeHeight) || nativeHeight <= 0)) throw new InvalidValueError("Native image dimensions must form a finite positive ratio.");
+  if (!options.fit && width === void 0 && height !== void 0) x = checkedExtent(height * (nativeWidth / nativeHeight));
+  if (!options.fit && height === void 0 && width !== void 0) y = checkedExtent(width * (nativeHeight / nativeWidth));
+  if (options.fit === "contain") {
+    const scale = Math.min(x / nativeWidth, y / nativeHeight);
+    x = checkedExtent(nativeWidth * scale);
+    y = checkedExtent(nativeHeight * scale);
+  }
+  if (options.fit === "cover") {
+    const scale = Math.max(x / nativeWidth, y / nativeHeight), horizontal = Math.round((1 - x / (nativeWidth * scale)) * 5e4), vertical = Math.round((1 - y / (nativeHeight * scale)) * 5e4);
+    if (horizontal * 2 >= 1e5 || vertical * 2 >= 1e5) throw new InvalidValueError("Image crop cannot retain an empty source.");
+    crop = `<di:srcRect xmlns:di="${documentDialects.transitional.a}" l="${horizontal}" r="${horizontal}" t="${vertical}" b="${vertical}"/>`;
+  }
+  return { width: checkedExtent(x), height: checkedExtent(y), crop };
+}
+async function insertDocumentImage(input, request, context) {
+  if (!request || ![Object.prototype, null].includes(Object.getPrototypeOf(request))) throw new InputTypeError("Expected a closed image insertion request.");
+  closedRecord(request, ["operation", "options", "input"]);
+  if (request.operation !== "images.add") throw new DocxUsageError("Expected image insertion.");
+  if (request.input !== void 0) {
+    if (![Object.prototype, null].includes(Object.getPrototypeOf(request.input))) throw new InputTypeError("Expected a closed file 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 = { operation: request.operation, options: request.options, input: { path: request.input.path, stat: { ...request.input.stat } } };
+  }
+  const settings = archiveSettings(context), invocation = validateDocxInvocation({ operation: request.operation, inputs: [request.input?.path ?? "document"], options: request.options }, settings.budget), options = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((item) => [item.name, item.value]))), scoped = { ...settings, budget };
+  if (options.placement === "floating") throw new UnsupportedEditError("This insertion profile admits inline pictures only.");
+  const document = await openDocumentLocations(input, scoped), selected = resolveDocxSelection(document, invocation), archive = document.snapshot();
+  assertDocumentEditable(archive, scoped);
+  if (selected.some((item) => item.value.range !== null || !["paragraph", "story", "cell"].includes(item.kind))) throw new DocxUsageError("Image insertion requires a whole paragraph or supported block container.");
+  const source = await acquireImage(options.file, { ...scoped, ...context.binaryResolver ? { binaryResolver: context.binaryResolver } : {} });
+  let vector;
+  if (options.fallback !== void 0) {
+    admitSvgImage(source, scoped);
+    vector = source;
+  }
+  const bytes = options.fallback === void 0 ? source : await acquireImage(options.fallback, { ...scoped, ...context.binaryResolver ? { binaryResolver: context.binaryResolver } : {} });
+  const header = characterizeRasterHeader(bytes, scoped);
+  for (const [descriptor, mime] of [[options.file, vector ? "image/svg+xml" : header.mime], ...options.fallback ? [[options.fallback, header.mime]] : []]) {
+    if (descriptor.kind !== "vfs") continue;
+    const name = descriptor.path.slice(descriptor.path.lastIndexOf("/") + 1), suffix = asciiKey(name.slice(name.lastIndexOf(".") + 1));
+    const expected = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", bmp: "image/bmp", tif: "image/tiff", tiff: "image/tiff", svg: "image/svg+xml" }[suffix];
+    if (expected && expected !== mime) throw new InvalidValueError("Image filename type conflicts with its admitted signature.");
+  }
+  const graph = new DocumentPackage(archive, settings.limits, budget);
+  const size = imageSize(header, options), main = document.list("story", { scope: "body" })[0].value.part, dialect = dialectForNamespace(parseDocumentXml(graph.getPart(main).bytes, {}, budget).root.namespace), ns = documentDialects[dialect];
+  const takenNames = new Set(graph.parts.map((part) => asciiKey(part.partname)));
+  const extension = { "image/png": "png", "image/jpeg": "jpg", "image/gif": "gif", "image/bmp": "bmp", "image/tiff": "tiff" }[header.mime];
+  let mediaOrdinal = 1, media;
+  do {
+    media = `${main.slice(0, main.lastIndexOf("/"))}/media/image-${mediaOrdinal++}.${extension}`;
+  } while (takenNames.has(asciiKey(media)));
+  takenNames.add(asciiKey(media));
+  let vectorPart;
+  if (vector) {
+    do {
+      vectorPart = `${main.slice(0, main.lastIndexOf("/"))}/media/image-${mediaOrdinal++}.svg`;
+    } while (takenNames.has(asciiKey(vectorPart)));
+  }
+  const drawingIds = /* @__PURE__ */ new Set();
+  for (const part of graph.parts) {
+    if (!isXmlContentType(part.content_type)) continue;
+    const visit = (node) => {
+      budget.charge("work", 1);
+      if (node.namespace === ns.wp && node.localName === "docPr") {
+        const id2 = node.attributes.find((a) => a.namespace === "" && a.localName === "id")?.value;
+        if (id2) drawingIds.add(String(Number(id2)));
+      }
+      for (const child of node.children) visit(child);
+    };
+    visit(parseDocumentXml(part.bytes, {}, budget).root);
+  }
+  const additions = /* @__PURE__ */ new Map(), editor = new DocumentArchiveEditor(archive, {}, void 0, budget), updates = [];
+  for (const before of selected) {
+    const xml2 = editor.xml(before.value.part.slice(1));
+    let node = xml2.root;
+    const ancestors = [node];
+    for (const index2 of before.value.path) {
+      node = node.children[index2];
+      ancestors.push(node);
+    }
+    if (ancestors.some((n) => n.namespace === ns.w && (["ins", "del", "moveFrom", "moveTo"].includes(n.localName) || n.children.some((c) => c.namespace === ns.w && ["pPr", "tcPr"].includes(c.localName) && c.children.some((p) => p.localName.endsWith("Change")))))) throw new UnsupportedEditError("Tracked containers require explicit revision operations.");
+    assertOutsideRevisionRanges(xml2.root, node, budget, xml2.compatibility.branches);
+    if (node.namespace !== ns.w || !["p", "body", "tc", "hdr", "ftr", "footnote", "endnote", "comment", "txbxContent"].includes(node.localName)) throw new UnsupportedEditError("Unsupported image insertion container.");
+    const ownerMember = graph.getPart(before.value.part), utf8 = parseDocumentXml(ownerMember.bytes, {}, budget).encoding === "UTF-8", alt = options.alt ?? "";
+    budget.charge("work", alt.length);
+    const alternativeSize = xmlTextSize(alt, utf8, true);
+    budget.check("xmlPartBytes", ownerMember.bytes.length + alternativeSize.bytes);
+    const owner = before.value.part, slash = ownerMember.name.lastIndexOf("/"), relname = findRelationshipPart(graph, owner, budget)?.name ?? ownerMember.name.slice(0, slash + 1) + "_rels/" + ownerMember.name.slice(slash + 1) + ".rels";
+    let idOrdinal = 1;
+    const taken = new Set(graph.relationships(owner).map((edge) => edge.rId));
+    while (taken.has(`rId${idOrdinal}`)) idOrdinal++;
+    const relationshipId = `rId${idOrdinal}`;
+    taken.add(relationshipId);
+    while (taken.has(`rId${idOrdinal}`)) idOrdinal++;
+    const vectorRelationshipId = vectorPart ? `rId${idOrdinal}` : void 0;
+    const relationship = `<Relationship xmlns="http://schemas.openxmlformats.org/package/2006/relationships" Id="${relationshipId}" Type="${ns.r}/image" Target="${xmlValue(relativePartTarget(owner, media))}"/>` + (vectorPart ? `<Relationship xmlns="http://schemas.openxmlformats.org/package/2006/relationships" Id="${vectorRelationshipId}" Type="${ns.r}/image" Target="${xmlValue(relativePartTarget(owner, vectorPart))}"/>` : "");
+    if (archive.members.some((m) => m.name === relname)) {
+      const rels = editor.xml(relname);
+      rels.insertChildren(rels.root, relationship);
+    } else additions.set(owner, { name: relname, xml: `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${relationship}</Relationships>` });
+    let drawingId = 1;
+    while (drawingIds.has(String(drawingId))) drawingId++;
+    if (drawingId > 4294967295) throw new ResourceLimitError("No drawing identifier is available.");
+    drawingIds.add(String(drawingId));
+    const picture = inlineImageRun(ns, drawingId, relationshipId, size, { alt, decorative: options.decorative, ...vectorRelationshipId ? { vectorRelationshipId } : {} });
+    const { prefix, suffix } = picture;
+    const containerPrefix = before.kind === "paragraph" ? "" : `<wi:p xmlns:wi="${ns.w}">`, containerSuffix = before.kind === "paragraph" ? "" : "</wi:p>";
+    const fragments = [containerPrefix, prefix, suffix, containerSuffix];
+    let markupBytes = alternativeSize.bytes, markupCharacters = alternativeSize.characters;
+    for (const fragment of fragments) {
+      budget.charge("work", fragment.length);
+      const measured = xmlTextSize(fragment, utf8);
+      markupBytes += measured.bytes;
+      markupCharacters += measured.characters;
+    }
+    const emptyExpansion = xml2.sourceXml(node).endsWith("/>") ? xmlTextSize(node.name, utf8).bytes + (utf8 ? 2 : 4) : 0;
+    const ownerBytes = ownerMember.bytes.length + markupBytes + emptyExpansion;
+    budget.check("xmlPartBytes", ownerBytes);
+    budget.charge("retainedBytes", markupCharacters * 8 + ownerBytes * 8);
+    budget.charge("work", markupCharacters * 8 + ownerBytes * 4);
+    const section = node.children.find((c) => c.namespace === ns.w && c.localName === "sectPr"), paragraphPath = before.kind === "paragraph" ? before.value.path : [...before.value.path, section ? node.children.indexOf(section) : node.children.length];
+    const runIndex = before.kind === "paragraph" ? node.children.length : 0;
+    const run = picture.run;
+    xml2.insertChildren(node, before.kind === "paragraph" ? run : containerPrefix + run + containerSuffix, section);
+    updates.push({ before, path: [...paragraphPath, runIndex, 0, 0, 3, 0, 0, 1, 0] });
+  }
+  if (updates.length) {
+    const types = editor.xml("[Content_Types].xml");
+    types.insertChildren(types.root, `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="${xmlValue(media)}" ContentType="${header.mime}"/>` + (vectorPart ? `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="${xmlValue(vectorPart)}" ContentType="image/svg+xml"/>` : ""));
+  }
+  const dirty = new Set(editor.dirtyParts), copied = archive.comment.length + archive.members.reduce((n, m) => n + (dirty.has(m.name) ? 0 : m.bytes.length) + 128, 0) + [...additions.values()].reduce((n, a) => n + a.xml.length * 3 + 128, 0);
+  budget.charge("retainedBytes", copied);
+  budget.charge("work", copied);
+  const candidate = { comment: new Uint8Array(archive.comment), members: [...archive.members.map((m) => ({ ...m, bytes: dirty.has(m.name) ? editor.xml(m.name).serialize() : new Uint8Array(m.bytes) })), ...[...additions.values()].map((a) => ({ name: a.name, bytes: new TextEncoder().encode(a.xml), directory: false, modified: new Date(archive.members[0].modified) })), ...updates.length ? [{ name: media.slice(1), bytes, directory: false, modified: new Date(archive.members[0].modified) }, ...vectorPart && vector ? [{ name: vectorPart.slice(1), bytes: vector, directory: false, modified: new Date(archive.members[0].modified) }] : []] : []] };
+  const index = new LocationIndex(candidate, settings.limits, main.slice(1), dialect, budget);
+  budget.charge("retainedBytes", updates.length * 4096);
+  budget.charge("work", updates.length * 4096);
+  const changes = updates.map(({ before, path }) => {
+    const entry = index.byAddress.get(addressKey({ ...before.value, path }))?.find((e) => e.kind === "image");
+    if (!entry) throw new UnsupportedEditError("Inserted image location could not be resolved.");
+    const value = { ...before.value, path, generation: 1, range: null };
+    const after = { kind: "image", value, token: encodeGeneratedLocation(value), positions: entry.positions };
+    return { kind: "add", 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 responseSize = measurePackageResourceSerialization({ version: 1, operation: request.operation, ok: true, data: planned, affected: changes.length, locations: changes.map((c) => c.after), warnings: [], errors: [] }, budget) + 1;
+    budget.check("serializedOutput", responseSize);
+    budget.charge("retainedBytes", responseSize * 8);
+    budget.charge("work", responseSize * 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 publication admission must be synchronous.");
+    }
+  }
+  const result = await publishDocumentArchive(candidate, { ...request.input ? { input: request.input } : {}, ...options.output === void 0 ? {} : { output: options.output }, ...options.inPlace === void 0 ? {} : { inPlace: options.inPlace }, ...options.force === void 0 ? {} : { force: options.force }, ...options.dryRun === void 0 ? {} : { dryRun: options.dryRun }, ...options.json === void 0 ? {} : { json: options.json } }, { ...context, budget });
+  return { ...planned, output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null };
+}
+
+export {
+  insertDocumentImage
+};

package/dist/safe-bash/command-chunks/{chunk-MN3BB4WW.js → chunk-YP3WWV5N.js}

@@ -1,12 +1,12 @@
 import {
   diagnostic
-} from "./chunk-OOB7YCFQ.js";
-import {
-  scheduleNetworkDeadline
-} from "./chunk-3CDNIV7C.js";
+} from "./chunk-FMJKCVSQ.js";
 import {
   CurlError
 } from "./chunk-QYXWTNUN.js";
+import {
+  scheduleNetworkDeadline
+} from "./chunk-3CDNIV7C.js";
 
 // packages/safe-bash-network-engine/src/aggregate.ts
 import { createOutputOperation } from "../../safe-bash-contracts/index.js";