@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,276 @@
+import {
+  UnsupportedEditError
+} from "./chunk-YPVBU7QF.js";
+import {
+  InputTypeError,
+  ResourceLimitError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+import {
+  crc32
+} from "./chunk-XIC45QAG.js";
+
+// packages/safe-bash-docx-engine/src/raster-header.ts
+function unsupported() {
+  throw new UnsupportedEditError("Raster header or density metadata is invalid or unsupported.");
+}
+var HeaderReader = class {
+  constructor(bytes, budget) {
+    this.bytes = bytes;
+    this.budget = budget;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+  bytes;
+  budget;
+  view;
+  interval(offset, length) {
+    this.budget.charge("work", 1);
+    if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset > this.bytes.length || length > this.bytes.length - offset) unsupported();
+  }
+  u16(offset, little = false) {
+    this.interval(offset, 2);
+    return this.view.getUint16(offset, little);
+  }
+  u32(offset, little = false) {
+    this.interval(offset, 4);
+    return this.view.getUint32(offset, little);
+  }
+  i32(offset) {
+    this.interval(offset, 4);
+    return this.view.getInt32(offset, true);
+  }
+  text(offset, length) {
+    this.interval(offset, length);
+    let text = "";
+    for (let i = offset; i < offset + length; i++) text += String.fromCharCode(this.bytes[i]);
+    return text;
+  }
+};
+function dimensions(width, height, maximum = 4294967295) {
+  if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width <= 0 || height <= 0 || width > maximum || height > maximum) unsupported();
+}
+function density(x, y, factor) {
+  const axis = (value) => {
+    if (value === null || value === 0) return null;
+    const dpi = value * factor;
+    if (value < 0 || !Number.isFinite(dpi) || dpi <= 0) unsupported();
+    return dpi;
+  };
+  return { horizontalDpi: axis(x), verticalDpi: axis(y) };
+}
+function mergeDensity(before, after) {
+  const merge = (a, b) => {
+    if (a !== null && b !== null && a !== b) unsupported();
+    return b ?? a;
+  };
+  return { horizontalDpi: merge(before.horizontalDpi, after.horizontalDpi), verticalDpi: merge(before.verticalDpi, after.verticalDpi) };
+}
+function png(reader) {
+  let offset = 8, width = 0, height = 0, color = 0, depth = 0, sawData = false, dataLength = 0, closedData = false, sawPalette = false, sawDensity = false, ended = false;
+  let dpi = { horizontalDpi: null, verticalDpi: null };
+  while (offset < reader.bytes.length) {
+    reader.interval(offset, 12);
+    const length = reader.u32(offset);
+    reader.interval(offset + 8, length + 4);
+    const name = reader.text(offset + 4, 4), start = offset + 8;
+    if ([...name].some((c) => !(c >= "A" && c <= "Z") && !(c >= "a" && c <= "z")) || name[2] >= "a") unsupported();
+    reader.budget.charge("work", length + 4);
+    if (crc32(reader.bytes.subarray(offset + 4, start + length)) !== reader.u32(start + length)) unsupported();
+    if (name === "IHDR") {
+      if (offset !== 8 || length !== 13) unsupported();
+      width = reader.u32(start);
+      height = reader.u32(start + 4);
+      dimensions(width, height, 2147483647);
+      depth = reader.bytes[start + 8];
+      color = reader.bytes[start + 9];
+      const depths = { 0: [1, 2, 4, 8, 16], 2: [8, 16], 3: [1, 2, 4, 8], 4: [8, 16], 6: [8, 16] };
+      if (!depths[color]?.includes(depth) || reader.bytes[start + 10] !== 0 || reader.bytes[start + 11] !== 0 || ![0, 1].includes(reader.bytes[start + 12])) unsupported();
+    } else if (!width) unsupported();
+    else if (name === "PLTE") {
+      if (sawPalette || sawData || color === 0 || color === 4 || length === 0 || length > 768 || length % 3 !== 0 || color === 3 && length / 3 > 2 ** depth) unsupported();
+      sawPalette = true;
+    } else if (name === "pHYs") {
+      if (length !== 9 || sawData || sawDensity) unsupported();
+      sawDensity = true;
+      const unit = reader.bytes[start + 8];
+      if (unit !== 0 && unit !== 1) unsupported();
+      if (unit === 1) dpi = density(reader.u32(start), reader.u32(start + 4), 0.0254);
+    } else if (name === "IDAT") {
+      if (closedData || color === 3 && !sawPalette) unsupported();
+      sawData = true;
+      dataLength += length;
+    } else if (name === "IEND") {
+      if (length !== 0 || !sawData || dataLength === 0 || start + 4 !== reader.bytes.length) unsupported();
+      ended = true;
+    } else if (name[0] >= "A" && name[0] <= "Z") unsupported();
+    if (sawData && name !== "IDAT") closedData = true;
+    offset = start + length + 4;
+  }
+  if (!ended) unsupported();
+  return { mime: "image/png", pixelWidth: width, pixelHeight: height, ...dpi };
+}
+function tiff(reader, base = 0, length = reader.bytes.length) {
+  reader.interval(base, length);
+  if (length < 8) unsupported();
+  const byteOrder = reader.text(base, 2), little = byteOrder === "II";
+  if (byteOrder !== "II" && byteOrder !== "MM" || reader.u16(base + 2, little) !== 42) unsupported();
+  const check = (offset, size) => {
+    if (offset < 0 || offset > length || size > length - offset) unsupported();
+    reader.interval(base + offset, size);
+  };
+  const u16 = (offset) => {
+    check(offset, 2);
+    return reader.u16(base + offset, little);
+  };
+  const u32 = (offset) => {
+    check(offset, 4);
+    return reader.u32(base + offset, little);
+  };
+  const pending = [u32(4)], visited = /* @__PURE__ */ new Set(), values = /* @__PURE__ */ new Map();
+  const sizes = { 1: 1, 2: 1, 3: 2, 4: 4, 5: 8, 6: 1, 7: 1, 8: 2, 9: 4, 10: 8, 11: 4, 12: 8 };
+  while (pending.length) {
+    const offset = pending.pop();
+    if (!offset) continue;
+    if (offset < 8) unsupported();
+    if (visited.has(offset)) unsupported();
+    reader.budget.charge("retainedBytes", 32);
+    visited.add(offset);
+    const count = u16(offset);
+    check(offset + 2, count * 12 + 4);
+    for (let i = 0; i < count; i++) {
+      reader.budget.charge("work", 12);
+      const start = offset + 2 + i * 12;
+      const tag = u16(start), type = u16(start + 2), items = u32(start + 4), size = sizes[type];
+      if (!size || items === 0) unsupported();
+      const total = items * size;
+      if (!Number.isSafeInteger(total)) unsupported();
+      const address = total <= 4 ? start + 8 : u32(start + 8);
+      if (total > 4 && address < 8) unsupported();
+      check(address, total);
+      if (![256, 257, 282, 283, 296, 34665].includes(tag)) continue;
+      if (items !== 1) unsupported();
+      let value;
+      if (tag === 282 || tag === 283) {
+        if (type !== 5) unsupported();
+        value = [u32(address), u32(address + 4)];
+      } else {
+        if (type !== 3 && type !== 4 || tag === 34665 && type !== 4 || tag === 296 && type !== 3) unsupported();
+        value = type === 3 ? u16(address) : u32(address);
+      }
+      const before = values.get(tag);
+      if (before !== void 0 && JSON.stringify(before) !== JSON.stringify(value)) unsupported();
+      reader.budget.charge("retainedBytes", 32);
+      values.set(tag, value);
+      if (tag === 34665) {
+        if (!value) unsupported();
+        reader.budget.charge("retainedBytes", 8);
+        pending.push(value);
+      }
+    }
+    const next = u32(offset + 2 + count * 12);
+    if (next) {
+      reader.budget.charge("retainedBytes", 8);
+      pending.push(next);
+    }
+  }
+  const unit = values.get(296) ?? 2;
+  if (unit !== 1 && unit !== 2 && unit !== 3) unsupported();
+  const resolution = (tag) => {
+    const value = values.get(tag);
+    if (!value) return null;
+    if (!Array.isArray(value) || value[1] === 0) unsupported();
+    if (unit === 1) return null;
+    const result = value[0] / value[1] * (unit === 3 ? 2.54 : 1);
+    if (value[0] === 0 || !Number.isFinite(result) || result <= 0) unsupported();
+    return result;
+  };
+  return { width: values.get(256) ?? null, height: values.get(257) ?? null, horizontalDpi: resolution(282), verticalDpi: resolution(283) };
+}
+function jpeg(reader) {
+  let offset = 2, width = 0, height = 0, sawScan = false;
+  let dpi = { horizontalDpi: null, verticalDpi: null };
+  const frames = /* @__PURE__ */ new Set([192, 193, 194, 195, 197, 198, 199, 201, 202, 203, 205, 206, 207]);
+  while (offset < reader.bytes.length) {
+    reader.interval(offset, 2);
+    if (reader.bytes[offset] !== 255) unsupported();
+    while (reader.bytes[offset] === 255) {
+      reader.interval(offset, 1);
+      offset++;
+    }
+    reader.interval(offset, 1);
+    const marker = reader.bytes[offset++];
+    if (marker === 217) break;
+    if (marker === 216 || marker === 0 || marker >= 208 && marker <= 215) unsupported();
+    if (marker === 1) continue;
+    const length = reader.u16(offset);
+    if (length < 2) unsupported();
+    reader.interval(offset, length);
+    const start = offset + 2, payload = length - 2;
+    if (marker === 224 && payload >= 5 && reader.text(start, 5) === "JFIF\0") {
+      if (payload < 14) unsupported();
+      const unit = reader.bytes[start + 7];
+      if (unit !== 0 && unit !== 1 && unit !== 2) unsupported();
+      const thumbnail = reader.bytes[start + 12] * reader.bytes[start + 13] * 3;
+      if (thumbnail > payload - 14) unsupported();
+      if (unit) dpi = mergeDensity(dpi, density(reader.u16(start + 8), reader.u16(start + 10), unit === 2 ? 2.54 : 1));
+    } else if (marker === 225 && payload >= 6 && reader.text(start, 6) === "Exif\0\0") {
+      dpi = mergeDensity(dpi, tiff(reader, start + 6, payload - 6));
+    } else if (frames.has(marker)) {
+      if (payload < 6 || reader.bytes[start] !== 8 || !reader.bytes[start + 5] || payload !== 6 + reader.bytes[start + 5] * 3) unsupported();
+      const h = reader.u16(start + 1), w = reader.u16(start + 3);
+      dimensions(w, h, 65535);
+      if (width && (width !== w || height !== h)) unsupported();
+      width = w;
+      height = h;
+    } else if (marker === 218) {
+      if (!width || payload < 4 || !reader.bytes[start] || payload !== 4 + reader.bytes[start] * 2) unsupported();
+      sawScan = true;
+      break;
+    }
+    offset += length;
+  }
+  if (!width || !sawScan || reader.bytes.length < 2 || reader.u16(reader.bytes.length - 2) !== 65497) unsupported();
+  return { mime: "image/jpeg", pixelWidth: width, pixelHeight: height, ...dpi };
+}
+function characterizeRasterHeader(input, context) {
+  const { limits, budget } = archiveSettings(context);
+  if (!(input instanceof Uint8Array)) throw new InputTypeError("Expected raster bytes.");
+  budget.check("embeddedMediaBytes", input.length);
+  if (input.length > limits.maxEntryBytes) throw new ResourceLimitError("Raster entry byte limit exceeded.");
+  budget.charge("work", input.length);
+  budget.charge("retainedBytes", 128);
+  const reader = new HeaderReader(input, budget), begins = (...bytes) => input.length >= bytes.length && bytes.every((value, index) => input[index] === value);
+  if (begins(137, 80, 78, 71, 13, 10, 26, 10)) return png(reader);
+  if (begins(255, 216)) return jpeg(reader);
+  if (begins(71, 73, 70, 56, 55, 97) || begins(71, 73, 70, 56, 57, 97)) {
+    reader.interval(0, 13);
+    const width = reader.u16(6, true), height = reader.u16(8, true);
+    dimensions(width, height, 65535);
+    const packed = input[10];
+    if (packed & 128) reader.interval(13, 3 * 2 ** ((packed & 7) + 1));
+    return { mime: "image/gif", pixelWidth: width, pixelHeight: height, horizontalDpi: null, verticalDpi: null };
+  }
+  if (begins(66, 77)) {
+    reader.interval(0, 18);
+    const size = reader.u32(14, true);
+    if (size < 40) unsupported();
+    reader.interval(14, size);
+    const width = reader.i32(18), height = reader.i32(22);
+    if (width <= 0 || height === 0 || reader.u16(26, true) !== 1) unsupported();
+    dimensions(width, Math.abs(height));
+    const pixelOffset = reader.u32(10, true);
+    if (pixelOffset < 14 + size || pixelOffset > input.length) unsupported();
+    return { mime: "image/bmp", pixelWidth: width, pixelHeight: Math.abs(height), ...density(reader.i32(38), reader.i32(42), 0.0254) };
+  }
+  if (begins(73, 73, 42, 0) || begins(77, 77, 0, 42)) {
+    const metadata = tiff(reader);
+    if (metadata.width === null || metadata.height === null) unsupported();
+    dimensions(metadata.width, metadata.height);
+    return { mime: "image/tiff", pixelWidth: metadata.width, pixelHeight: metadata.height, horizontalDpi: metadata.horizontalDpi, verticalDpi: metadata.verticalDpi };
+  }
+  unsupported();
+}
+
+export {
+  characterizeRasterHeader
+};

package/dist/safe-bash/command-chunks/{chunk-P6NUIMMX.js → chunk-G5F2VSQ7.js}

@@ -11,7 +11,7 @@ import {
 import {
   collectNetworkBytes,
   encode
-} from "./chunk-OOB7YCFQ.js";
+} from "./chunk-FMJKCVSQ.js";
 import {
   CurlError
 } from "./chunk-QYXWTNUN.js";

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

@@ -0,0 +1,299 @@
+import {
+  characterizeRasterHeader
+} from "./chunk-FZSQMMYV.js";
+import {
+  UnsupportedEditError,
+  activeXmlChildren,
+  assertFormattingHistoryEditable,
+  assertOutsideRevisionRanges,
+  revisionInfo,
+  runElementOpen,
+  splitNativeTextRunXml,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  compatibilityContainers
+} from "./chunk-GZ2N24A2.js";
+import {
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+
+// packages/safe-bash-docx-engine/src/text-comment-reference.ts
+function assertTextCommentReference(node, xml, policy) {
+  const fail = () => {
+    throw new UnsupportedEditError("Whole text assignment requires a verified classic comment reference.");
+  };
+  const id = node.attributes.find((attribute) => attribute.namespace === node.namespace && attribute.localName === "id")?.value;
+  if (!id || [...id].some((character) => character < "0" || character > "9") || !Number.isSafeInteger(Number(id)) || node.children.length || node.content.some((item) => item.kind !== "text" || item.text.trim()) || !xml.compatibility.canEdit(node) || node.attributes.some((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/" && !xml.compatibility.canEdit(attribute))) fail();
+  const role = documentDialects[dialectForNamespace(node.namespace)].r + "/comments";
+  const edges = policy.graph().relationships(policy.owner).filter((edge) => edge.reltype === role);
+  if (edges.length !== 1 || edges[0].is_external || edges[0].fragment !== null) fail();
+  const root = parseDocumentXml(edges[0].target_part.bytes, {}, policy.context.budget).root;
+  if (root.namespace !== node.namespace || root.localName !== "comments" || activeXmlChildren(root, policy.context.budget)(root).filter((child) => child.namespace === node.namespace && child.localName === "comment" && child.attributes.some((attribute) => attribute.namespace === node.namespace && attribute.localName === "id" && attribute.value.length > 0 && [...attribute.value].every((character) => character >= "0" && character <= "9") && Number.isSafeInteger(Number(attribute.value)) && Number(attribute.value) === Number(id))).length !== 1) fail();
+}
+
+// packages/safe-bash-docx-engine/src/text-raster-content.ts
+function assertTextRasterDrawing(drawing, xml, policy) {
+  const ns = documentDialects[dialectForNamespace(drawing.namespace)];
+  const fail = () => {
+    throw new UnsupportedEditError("Whole text assignment requires an admitted embedded raster picture.");
+  };
+  const elements = [];
+  const pending = [drawing];
+  while (pending.length) {
+    const node = pending.pop();
+    policy.context.budget.charge("work", 1);
+    policy.context.budget.charge("retainedBytes", 32);
+    if (!xml.compatibility.canEdit(node) || node.attributes.some((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/" && !xml.compatibility.canEdit(attribute)) || node.content.some((content) => content.kind !== "element" && (content.kind !== "text" || content.text.trim() && !(node.namespace === ns.wp && ["posOffset", "align"].includes(node.localName))))) fail();
+    elements.push(node);
+    for (let index = node.children.length - 1; index >= 0; index--) pending.push(node.children[index]);
+  }
+  const frames = drawing.children.filter((node) => node.namespace === ns.wp && ["inline", "anchor"].includes(node.localName));
+  const graphics = elements.filter((node) => node.namespace === ns.a && node.localName === "graphicData");
+  const pictures = elements.filter((node) => node.namespace === ns.pic && node.localName === "pic");
+  const blips = elements.filter((node) => node.namespace === ns.a && node.localName === "blip");
+  if (drawing.localName !== "drawing" || frames.length !== 1 || drawing.children.length !== 1 || graphics.length !== 1 || pictures.length !== 1 || blips.length !== 1 || graphics[0].attributes.find((attribute) => !attribute.namespace && attribute.localName === "uri")?.value !== ns.pic || graphics[0].children.length !== 1 || graphics[0].children[0] !== pictures[0] || elements.some((node) => ![ns.w, ns.wp, ns.a, ns.pic].some((namespace) => namespace === node.namespace) || node.namespace === ns.w && node !== drawing || node.namespace === ns.wp && !["inline", "anchor", "extent", "docPr", "cNvGraphicFramePr", "effectExtent", "simplePos", "positionH", "positionV", "posOffset", "align", "wrapNone", "wrapSquare", "wrapTight", "wrapThrough", "wrapTopAndBottom", "wrapPolygon", "start", "lineTo"].includes(node.localName) || ["extLst", "AlternateContent"].includes(node.localName))) fail();
+  const blip = blips[0], embed = blip.attributes.find((attribute) => attribute.namespace === ns.r && attribute.localName === "embed")?.value;
+  if (!embed || blip.children.some((child) => child.namespace !== ns.a || !["alphaBiLevel", "alphaCeiling", "alphaFloor", "alphaInv", "alphaMod", "alphaModFix", "alphaRepl", "biLevel", "blur", "clrChange", "clrRepl", "duotone", "fillOverlay", "grayscl", "hsl", "lum", "tint"].includes(child.localName)) || blip.attributes.some((attribute) => attribute.namespace === ns.r && attribute.localName !== "embed")) fail();
+  const edge = policy.graph().relationships(policy.owner).find((edge2) => edge2.rId === embed);
+  if (!edge || edge.is_external || edge.reltype !== ns.r + "/image" || edge.fragment !== null) fail();
+  const header = characterizeRasterHeader(edge.target_part.bytes, policy.context);
+  if (header.mime !== parseMediaType(edge.target_part.content_type)) fail();
+}
+
+// packages/safe-bash-docx-engine/src/paragraph-content.ts
+function paragraphTextRun(w, text, style, kind) {
+  let pending = "", content = "";
+  const flush = () => {
+    if (pending) {
+      content += `<pi:t xml:space="preserve">${xmlValue(pending)}</pi:t>`;
+      pending = "";
+    }
+  };
+  for (const char of text) {
+    if (["	", "\r", "\n"].includes(char)) {
+      flush();
+      content += char === "	" ? "<pi:tab/>" : "<pi:br/>";
+    } else pending += char;
+  }
+  flush();
+  if (kind) content += `<pi:br pi:type="${kind === "line" ? "textWrapping" : kind}"/>`;
+  return `<pi:r xmlns:pi="${w}">${style === void 0 ? "" : `<pi:rPr><pi:rStyle pi:val="${xmlValue(style)}"/></pi:rPr>`}${content}</pi:r>`;
+}
+var markers = /* @__PURE__ */ new Set(["bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "proofErr", "permStart", "permEnd"]);
+function replaceParagraphContent(xml, p, properties, text, budget, raster, history) {
+  const children = activeXmlChildren(xml, budget);
+  const verified = history?.root === xml.root && history.paragraphs.has(p);
+  if (!verified) assertOutsideRevisionRanges(xml.root, p, budget, xml.compatibility.branches, children);
+  const patches = /* @__PURE__ */ new Map();
+  const containers = children(p).filter((child) => child.namespace === p.namespace && child.localName === "pPr");
+  if (containers.length > 1) throw new UnsupportedEditError("Paragraph text requires one owning property container.");
+  const props = containers[0];
+  if (!verified) assertFormattingHistoryEditable(xml.root, p, children, budget);
+  const revisionNodes = [p];
+  while (revisionNodes.length) {
+    const node = revisionNodes.pop();
+    budget.charge("work", 1);
+    if (node === props) continue;
+    if (revisionInfo(node) !== void 0) throw new UnsupportedEditError("Whole paragraph text cannot discard review history.");
+    const active = children(node);
+    for (let index = active.length - 1; index >= 0; index--) revisionNodes.push(active[index]);
+  }
+  const wordDrawingNamespace = documentDialects[dialectForNamespace(p.namespace)].wp;
+  const commentOwnsParagraph = (node, owner = false) => {
+    const pending = [{ node, owner }];
+    while (pending.length) {
+      const frame = pending.pop();
+      node = frame.node;
+      owner = frame.owner;
+      budget.charge("work", 1);
+      if (node.namespace === p.namespace && ["body", "hdr", "ftr", "comment", "footnote", "endnote", "txbxContent"].includes(node.localName) || node.namespace === wordDrawingNamespace && node.localName === "txbxContent") owner = node.localName === "comment";
+      if (node === p) return owner;
+      for (let index = node.children.length - 1; index >= 0; index--) pending.push({ node: node.children[index], owner });
+    }
+    return void 0;
+  };
+  const ownCommentParagraph = xml.root.namespace === p.namespace && xml.root.localName === "comments" && commentOwnsParagraph(xml.root) === true;
+  const isReferenceMarker = (node) => node.namespace === p.namespace && (["footnoteRef", "endnoteRef"].includes(node.localName) || node.localName === "commentReference" && raster !== void 0 || node.localName === "annotationRef" && ownCommentParagraph && !node.children.length && !node.text.trim());
+  let hasReferenceMarker = false;
+  const referenceNodes = [...children(p)].reverse();
+  while (referenceNodes.length) {
+    const node = referenceNodes.pop();
+    budget.charge("work", 1);
+    if (isReferenceMarker(node) && node.localName !== "commentReference") {
+      hasReferenceMarker = true;
+      break;
+    }
+    const active = children(node);
+    for (let index = active.length - 1; index >= 0; index--) referenceNodes.push(active[index]);
+  }
+  const assigned = hasReferenceMarker ? "" : text;
+  let inserted = false;
+  for (const child of children(p)) {
+    if (child.namespace !== p.namespace) throw new UnsupportedEditError("Whole paragraph text cannot replace opaque content.");
+    if (child === props) {
+      patches.set(child, properties);
+      continue;
+    }
+    if (markers.has(child.localName)) continue;
+    const check = (node) => {
+      if (node.namespace === p.namespace && node.localName === "commentReference" && raster) {
+        assertTextCommentReference(node, xml, raster);
+        if (child.localName !== "r") throw new UnsupportedEditError("Whole paragraph text cannot discard linked reference markers.");
+        return;
+      }
+      if (node.namespace === p.namespace && node.localName === "drawing" && raster) {
+        assertTextRasterDrawing(node, xml, raster);
+        return;
+      }
+      if (isReferenceMarker(node) && child.localName !== "r")
+        throw new UnsupportedEditError("Whole paragraph text cannot discard linked reference markers.");
+      if (node.localName !== "rPr" && node.content.some((c) => c.kind !== "element" && c.kind !== "text"))
+        throw new UnsupportedEditError("Whole paragraph text cannot discard XML annotations.");
+      if (node.namespace !== p.namespace || !["r", "rPr", "t", "tab", "ptab", "noBreakHyphen", "softHyphen", "br", "cr", "lastRenderedPageBreak", "hyperlink", "footnoteRef", "endnoteRef", "annotationRef"].includes(node.localName) || node.localName === "annotationRef" && !isReferenceMarker(node)) {
+        throw new UnsupportedEditError("Whole paragraph text cannot replace fields, objects or review content.");
+      }
+      if (node.localName !== "rPr") for (const c of children(node)) check(c);
+    };
+    check(child);
+    const retained = /* @__PURE__ */ new Map();
+    let referenceMarker = false;
+    const preserveSlots = child.children.some((node) => node.namespace !== p.namespace);
+    const collect = (node) => {
+      budget.charge("work", 1);
+      if (node.localName === "rPr") return;
+      if (isReferenceMarker(node)) {
+        referenceMarker = true;
+        return;
+      }
+      if (!["r", "hyperlink"].includes(node.localName)) {
+        retained.set(node, preserveSlots ? `<pc:t xmlns:pc="${p.namespace}"/>` : "");
+        return;
+      }
+      children(node).forEach(collect);
+    };
+    collect(child);
+    if (referenceMarker) {
+      patches.set(child, xml.sourceXml(child, retained));
+      continue;
+    }
+    if (child.localName === "r" && child.children.some((node) => node.namespace !== p.namespace)) {
+      patches.set(child, replaceRunContent(xml, child, "", inserted ? "" : assigned, budget, raster));
+      inserted = true;
+      continue;
+    }
+    patches.set(child, inserted || !assigned ? "" : paragraphTextRun(p.namespace, assigned));
+    inserted = true;
+  }
+  return runElementOpen(p) + (props ? "" : properties) + xml.sourceXml(p, patches, true) + ((hasReferenceMarker || !inserted) && text ? paragraphTextRun(p.namespace, text) : "") + `</${p.name}>`;
+}
+function splitParagraphContent(xml, p, caret, budget, properties) {
+  if (p.content.some((c) => !["element", "comment", "processing-instruction"].includes(c.kind) && (c.kind !== "text" || c.text.trim())))
+    throw new UnsupportedEditError("Caret insertion requires simple paragraph content.");
+  const children = activeXmlChildren(xml, budget), active = children(p);
+  if (active.filter((node) => node.namespace === p.namespace && node.localName === "pPr").length > 1) throw new UnsupportedEditError("Caret insertion requires one paragraph-property owner.");
+  const selected = new Set(active), paths = /* @__PURE__ */ new Set(), containers = new Set(xml.compatibility[compatibilityContainers]);
+  const patches = [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()];
+  let offset = 0;
+  for (const node of active) {
+    budget.charge("work", 1);
+    assertFormattingHistoryEditable(xml.root, node, children, budget);
+    if (node.namespace !== p.namespace) throw new UnsupportedEditError("Caret insertion cannot split opaque content.");
+    if (node.localName === "pPr") {
+      patches[0].set(node, properties[0]);
+      patches[1].set(node, properties[1]);
+      continue;
+    }
+    if (["bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "proofErr", "permStart", "permEnd"].includes(node.localName)) {
+      for (const side of [0, 1]) patches[side].set(node, side === (offset < caret ? 0 : 1) ? xml.sourceXml(node) : "");
+      continue;
+    }
+    const props = children(node).filter((child) => child.namespace === p.namespace && child.localName === "rPr"), leaves = children(node).filter((child) => !props.includes(child));
+    if (node.localName !== "r" || props.length > 1 || leaves.some((leaf) => leaf.namespace !== p.namespace || !["t", "tab", "ptab", "br", "cr", "noBreakHyphen", "softHyphen", "lastRenderedPageBreak", "footnoteRef", "endnoteRef", "annotationRef"].includes(leaf.localName) || leaf.content.some((item) => item.kind !== "text"))) throw new UnsupportedEditError("Caret insertion cannot split fields, objects, links or review content.");
+    const fragments = [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()];
+    for (const leaf of leaves) {
+      budget.charge("work", 1);
+      if (["lastRenderedPageBreak", "footnoteRef", "endnoteRef", "annotationRef"].includes(leaf.localName)) {
+        fragments[(leaf.localName === "lastRenderedPageBreak" ? offset < caret : offset <= caret) ? 0 : 1].set(leaf, xml.sourceXml(leaf));
+        continue;
+      }
+      const scalars = leaf.localName === "t" ? [...leaf.text] : [" "], count = Math.max(0, Math.min(scalars.length, caret - offset));
+      for (const [side, from, to] of [[0, 0, count], [1, count, scalars.length]]) {
+        if (from === to) continue;
+        const markup = to - from === scalars.length ? xml.sourceXml(leaf) : runElementOpen({ ...leaf, attributes: leaf.attributes.filter((attribute) => !(attribute.namespace === "http://www.w3.org/XML/1998/namespace" && attribute.localName === "space")) }).slice(0, -1) + ` xml:space="preserve">${xmlValue(scalars.slice(from, to).join(""))}</${leaf.name}>`;
+        fragments[side].set(leaf, markup);
+      }
+      offset += scalars.length;
+    }
+    const sides = [0, 1].filter((side) => fragments[side].size);
+    if (sides.length < 2) {
+      const side = sides[0] ?? (offset < caret ? 0 : 1);
+      for (const index of [0, 1]) patches[index].set(node, index === side ? xml.sourceXml(node) : "");
+    } else {
+      const rendered = xml[splitNativeTextRunXml](node, sides.map((side) => ({ properties: props[0] ? xml.sourceXml(props[0]) : "", content: fragments[side] })), false);
+      sides.forEach((side, index) => patches[side].set(node, rendered[index]));
+    }
+  }
+  if (caret > offset) throw new UnsupportedEditError("Caret exceeds paragraph text.");
+  const collect = (node) => {
+    budget.charge("work", 1);
+    if (selected.has(node)) {
+      paths.add(node);
+      return true;
+    }
+    const found = node.children.map(collect).some(Boolean);
+    if (found) {
+      if (node !== p && (!containers.has(node) || node.attributes.some((attribute) => !["http://www.w3.org/2000/xmlns/", "http://www.w3.org/XML/1998/namespace", "http://schemas.openxmlformats.org/markup-compatibility/2006"].includes(attribute.namespace) && !(attribute.namespace === "" && node.localName === "Choice" && attribute.localName === "Requires")))) throw new UnsupportedEditError("Caret insertion cannot duplicate opaque carrier attributes.");
+      paths.add(node);
+    }
+    return found;
+  };
+  collect(p);
+  const render = (node, side) => {
+    budget.charge("work", 1);
+    const replacement = patches[side].get(node);
+    if (replacement !== void 0) return replacement;
+    if (side && !paths.has(node)) {
+      if (node.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006" && ["Choice", "Fallback"].includes(node.localName)) return runElementOpen({ ...node, attributes: node.attributes.filter((attribute) => ["http://www.w3.org/2000/xmlns/", "http://www.w3.org/XML/1998/namespace", "http://schemas.openxmlformats.org/markup-compatibility/2006"].includes(attribute.namespace) || attribute.namespace === "" && node.localName === "Choice" && attribute.localName === "Requires") }) + `</${node.name}>`;
+      return "";
+    }
+    if (!paths.has(node)) return xml.sourceXml(node);
+    if (node !== p && !containers.has(node)) throw new UnsupportedEditError("Caret insertion cannot reconstruct an unsupported physical owner.");
+    const direct = new Map(node.children.map((child) => [child, render(child, side)]));
+    if (side) return runElementOpen(node) + node.content.map((item) => item.kind === "element" ? direct.get(item) : item.kind === "text" || item.kind === "cdata" ? xmlValue(item.text) : "").join("") + `</${node.name}>`;
+    return xml.sourceXml(node, direct);
+  };
+  return [
+    xml.sourceXml(p, new Map(p.children.map((child) => [child, render(child, 0)])), true),
+    p.content.map((item) => item.kind === "element" ? render(item, 1) : item.kind === "text" ? xmlValue(item.text) : "").join("")
+  ];
+}
+function replaceRunContent(xml, run, properties, text, budget, raster) {
+  const children = activeXmlChildren(xml, budget);
+  assertFormattingHistoryEditable(xml.root, run, children, budget);
+  const active = children(run);
+  const drawings = active.filter((child) => child.namespace === run.namespace && child.localName === "drawing" && raster);
+  for (const drawing of drawings) assertTextRasterDrawing(drawing, xml, raster);
+  const containers = active.filter((child) => child.namespace === run.namespace && child.localName === "rPr");
+  if (containers.length > 1 || active.some((child) => !drawings.includes(child) && (child.namespace !== run.namespace || !["rPr", "t", "tab", "ptab", "br", "cr", "noBreakHyphen", "softHyphen", "lastRenderedPageBreak"].includes(child.localName) || child.localName !== "rPr" && child.content.some((content2) => content2.kind !== "text" || child.localName !== "t" && content2.text.trim()))))
+    throw new UnsupportedEditError("Whole run text cannot discard owned resources or unsupported content.");
+  const props = containers[0];
+  const preserveSlots = run.children.some((child) => child.namespace !== run.namespace);
+  const patches = new Map(active.filter((child) => child !== props).map((child) => [child, preserveSlots ? `<pc:t xmlns:pc="${run.namespace}"/>` : ""]));
+  if (props && properties !== xml.sourceXml(props)) patches.set(props, properties);
+  const fragment = parseDocumentXml(new TextEncoder().encode(paragraphTextRun(run.namespace, text)), {}, budget).root;
+  const content = fragment.children.map((child) => runElementOpen(child) + xmlValue(child.text) + `</${child.name}>`).join("");
+  return runElementOpen(run) + (props ? "" : properties) + xml.sourceXml(run, patches, true) + content + `</${run.name}>`;
+}
+
+export {
+  paragraphTextRun,
+  replaceParagraphContent,
+  splitParagraphContent,
+  replaceRunContent
+};