@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,3949 @@
+import {
+  MSO_AUTO_SHAPE_TYPE,
+  shapePresets
+} from "./chunk-2FOLUJLI.js";
+import {
+  createXmlElementView
+} from "./chunk-QXCSASIE.js";
+import {
+  MSO_LANGUAGE_ID
+} from "./chunk-4ATHODCG.js";
+import {
+  bestFitText
+} from "./chunk-5HWX4XYW.js";
+import {
+  readRunFormatting,
+  runPropertiesMerge,
+  textUnderlineStyles,
+  validateTextRunOptions
+} from "./chunk-JHAY3KYC.js";
+import {
+  readTextBodies,
+  validateTextReadingOptions
+} from "./chunk-XP6BHGZ6.js";
+import {
+  applyDrawingFill,
+  applyDrawingUpdate,
+  readDrawingColor,
+  readDrawingFormat
+} from "./chunk-A3XE767Q.js";
+import {
+  ColorFormat,
+  MSO_COLOR_TYPE,
+  MSO_THEME_COLOR_INDEX,
+  RGBColor,
+  colorBrightnessMerge,
+  colorMerge,
+  defineEnum,
+  defineXmlEnum,
+  readRunColor
+} from "./chunk-SEK43FRN.js";
+import {
+  readXmlCoordinate,
+  readXmlInteger
+} from "./chunk-3W6PTHHB.js";
+import {
+  Length,
+  Pt
+} from "./chunk-I6AMDG2T.js";
+import {
+  attr,
+  child,
+  loadShared
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  protectedEquationNodes
+} from "./chunk-5DFZAJHL.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  IndexError,
+  InvalidHandleError,
+  OfficeError,
+  PropertyAccessError,
+  TypeError,
+  ValueError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/text-link-capability.ts
+var textLinkCapabilities = /* @__PURE__ */ new WeakMap();
+
+// packages/safe-bash-presentation-engine/src/shape-adjustment-defaults.ts
+var shapeAdjustmentDefaults = {
+  ARC: [
+    ["adj1", 162e5],
+    ["adj2", 0]
+  ],
+  BALLOON: [
+    ["adj1", -20833],
+    ["adj2", 62500],
+    ["adj3", 16667]
+  ],
+  BENT_ARROW: [
+    ["adj1", 25e3],
+    ["adj2", 25e3],
+    ["adj3", 25e3],
+    ["adj4", 43750]
+  ],
+  BENT_UP_ARROW: [
+    ["adj1", 25e3],
+    ["adj2", 25e3],
+    ["adj3", 25e3]
+  ],
+  BEVEL: [["adj", 12500]],
+  BLOCK_ARC: [
+    ["adj1", 108e5],
+    ["adj2", 0],
+    ["adj3", 25e3]
+  ],
+  CAN: [["adj", 25e3]],
+  CHEVRON: [["adj", 5e4]],
+  CHORD: [
+    ["adj1", 27e5],
+    ["adj2", 162e5]
+  ],
+  CIRCULAR_ARROW: [
+    ["adj1", 12500],
+    ["adj2", 1142319],
+    ["adj3", 20457681],
+    ["adj4", 108e5],
+    ["adj5", 12500]
+  ],
+  CLOUD_CALLOUT: [
+    ["adj1", -20833],
+    ["adj2", 62500]
+  ],
+  CORNER: [
+    ["adj1", 5e4],
+    ["adj2", 5e4]
+  ],
+  CROSS: [["adj", 25e3]],
+  CUBE: [["adj", 25e3]],
+  CURVED_DOWN_ARROW: [
+    ["adj1", 25e3],
+    ["adj2", 5e4],
+    ["adj3", 25e3]
+  ],
+  CURVED_DOWN_RIBBON: [
+    ["adj1", 25e3],
+    ["adj2", 5e4],
+    ["adj3", 12500]
+  ],
+  CURVED_LEFT_ARROW: [
+    ["adj1", 25e3],
+    ["adj2", 5e4],
+    ["adj3", 25e3]
+  ],
+  CURVED_RIGHT_ARROW: [
+    ["adj1", 25e3],
+    ["adj2", 5e4],
+    ["adj3", 25e3]
+  ],
+  CURVED_UP_ARROW: [
+    ["adj1", 25e3],
+    ["adj2", 5e4],
+    ["adj3", 25e3]
+  ],
+  CURVED_UP_RIBBON: [
+    ["adj1", 25e3],
+    ["adj2", 5e4],
+    ["adj3", 12500]
+  ],
+  DECAGON: [["vf", 105146]],
+  DIAGONAL_STRIPE: [["adj", 5e4]],
+  DONUT: [["adj", 25e3]],
+  DOUBLE_BRACE: [["adj", 8333]],
+  DOUBLE_BRACKET: [["adj", 16667]],
+  DOUBLE_WAVE: [
+    ["adj1", 6250],
+    ["adj2", 0]
+  ],
+  DOWN_ARROW: [
+    ["adj1", 5e4],
+    ["adj2", 5e4]
+  ],
+  DOWN_ARROW_CALLOUT: [
+    ["adj1", 25e3],
+    ["adj2", 25e3],
+    ["adj3", 25e3],
+    ["adj4", 64977]
+  ],
+  DOWN_RIBBON: [
+    ["adj1", 16667],
+    ["adj2", 5e4]
+  ],
+  FRAME: [["adj1", 12500]],
+  GEAR_6: [
+    ["adj1", 15e3],
+    ["adj2", 3526]
+  ],
+  GEAR_9: [
+    ["adj1", 1e4],
+    ["adj2", 1763]
+  ],
+  HALF_FRAME: [
+    ["adj1", 33333],
+    ["adj2", 33333]
+  ],
+  HEPTAGON: [
+    ["hf", 102572],
+    ["vf", 105210]
+  ],
+  HEXAGON: [
+    ["adj", 25e3],
+    ["vf", 115470]
+  ],
+  HORIZONTAL_SCROLL: [["adj", 12500]],
+  ISOSCELES_TRIANGLE: [["adj", 5e4]],
+  LEFT_ARROW: [
+    ["adj1", 5e4],
+    ["adj2", 5e4]
+  ],
+  LEFT_ARROW_CALLOUT: [
+    ["adj1", 25e3],
+    ["adj2", 25e3],
+    ["adj3", 25e3],
+    ["adj4", 64977]
+  ],
+  LEFT_BRACE: [
+    ["adj1", 8333],
+    ["adj2", 5e4]
+  ],
+  LEFT_BRACKET: [["adj", 8333]],
+  LEFT_CIRCULAR_ARROW: [
+    ["adj1", 12500],
+    ["adj2", -1142319],
+    ["adj3", 1142319],
+    ["adj4", 108e5],
+    ["adj5", 12500]
+  ],
+  LEFT_RIGHT_ARROW: [
+    ["adj1", 5e4],
+    ["adj2", 5e4]
+  ],
+  LEFT_RIGHT_ARROW_CALLOUT: [
+    ["adj1", 25e3],
+    ["adj2", 25e3],
+    ["adj3", 25e3],
+    ["adj4", 48123]
+  ],
+  LEFT_RIGHT_CIRCULAR_ARROW: [
+    ["adj1", 12500],
+    ["adj2", 1142319],
+    ["adj3", 20457681],
+    ["adj4", 11942319],
+    ["adj5", 12500]
+  ],
+  LEFT_RIGHT_RIBBON: [
+    ["adj1", 5e4],
+    ["adj2", 5e4],
+    ["adj3", 16667]
+  ],
+  LEFT_RIGHT_UP_ARROW: [
+    ["adj1", 25e3],
+    ["adj2", 25e3],
+    ["adj3", 25e3]
+  ],
+  LEFT_UP_ARROW: [
+    ["adj1", 25e3],
+    ["adj2", 25e3],
+    ["adj3", 25e3]
+  ],
+  LINE_CALLOUT_1: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 112500],
+    ["adj4", -38333]
+  ],
+  LINE_CALLOUT_1_ACCENT_BAR: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 112500],
+    ["adj4", -38333]
+  ],
+  LINE_CALLOUT_1_BORDER_AND_ACCENT_BAR: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 112500],
+    ["adj4", -38333]
+  ],
+  LINE_CALLOUT_1_NO_BORDER: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 112500],
+    ["adj4", -38333]
+  ],
+  LINE_CALLOUT_2: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 18750],
+    ["adj4", -16667],
+    ["adj5", 112500],
+    ["adj6", -46667]
+  ],
+  LINE_CALLOUT_2_ACCENT_BAR: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 18750],
+    ["adj4", -16667],
+    ["adj5", 112500],
+    ["adj6", -46667]
+  ],
+  LINE_CALLOUT_2_BORDER_AND_ACCENT_BAR: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 18750],
+    ["adj4", -16667],
+    ["adj5", 112500],
+    ["adj6", -46667]
+  ],
+  LINE_CALLOUT_2_NO_BORDER: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 18750],
+    ["adj4", -16667],
+    ["adj5", 112500],
+    ["adj6", -46667]
+  ],
+  LINE_CALLOUT_3: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 18750],
+    ["adj4", -16667],
+    ["adj5", 1e5],
+    ["adj6", -16667],
+    ["adj7", 112963],
+    ["adj8", -8333]
+  ],
+  LINE_CALLOUT_3_ACCENT_BAR: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 18750],
+    ["adj4", -16667],
+    ["adj5", 1e5],
+    ["adj6", -16667],
+    ["adj7", 112963],
+    ["adj8", -8333]
+  ],
+  LINE_CALLOUT_3_BORDER_AND_ACCENT_BAR: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 18750],
+    ["adj4", -16667],
+    ["adj5", 1e5],
+    ["adj6", -16667],
+    ["adj7", 112963],
+    ["adj8", -8333]
+  ],
+  LINE_CALLOUT_3_NO_BORDER: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 18750],
+    ["adj4", -16667],
+    ["adj5", 1e5],
+    ["adj6", -16667],
+    ["adj7", 112963],
+    ["adj8", -8333]
+  ],
+  LINE_CALLOUT_4: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 18750],
+    ["adj4", -16667],
+    ["adj5", 1e5],
+    ["adj6", -16667],
+    ["adj7", 112963],
+    ["adj8", -8333]
+  ],
+  LINE_CALLOUT_4_ACCENT_BAR: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 18750],
+    ["adj4", -16667],
+    ["adj5", 1e5],
+    ["adj6", -16667],
+    ["adj7", 112963],
+    ["adj8", -8333]
+  ],
+  LINE_CALLOUT_4_BORDER_AND_ACCENT_BAR: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 18750],
+    ["adj4", -16667],
+    ["adj5", 1e5],
+    ["adj6", -16667],
+    ["adj7", 112963],
+    ["adj8", -8333]
+  ],
+  LINE_CALLOUT_4_NO_BORDER: [
+    ["adj1", 18750],
+    ["adj2", -8333],
+    ["adj3", 18750],
+    ["adj4", -16667],
+    ["adj5", 1e5],
+    ["adj6", -16667],
+    ["adj7", 112963],
+    ["adj8", -8333]
+  ],
+  MATH_DIVIDE: [
+    ["adj1", 23520],
+    ["adj2", 5880],
+    ["adj3", 11760]
+  ],
+  MATH_EQUAL: [
+    ["adj1", 23520],
+    ["adj2", 11760]
+  ],
+  MATH_MINUS: [["adj1", 23520]],
+  MATH_MULTIPLY: [["adj1", 23520]],
+  MATH_NOT_EQUAL: [
+    ["adj1", 23520],
+    ["adj2", 66e5],
+    ["adj3", 11760]
+  ],
+  MATH_PLUS: [["adj1", 23520]],
+  MOON: [["adj", 5e4]],
+  NON_ISOSCELES_TRAPEZOID: [
+    ["adj1", 25e3],
+    ["adj2", 25e3]
+  ],
+  NOTCHED_RIGHT_ARROW: [
+    ["adj1", 5e4],
+    ["adj2", 5e4]
+  ],
+  NO_SYMBOL: [["adj", 18750]],
+  OCTAGON: [["adj", 29289]],
+  OVAL_CALLOUT: [
+    ["adj1", -20833],
+    ["adj2", 62500]
+  ],
+  PARALLELOGRAM: [["adj", 25e3]],
+  PENTAGON: [["adj", 5e4]],
+  PIE: [
+    ["adj1", 0],
+    ["adj2", 162e5]
+  ],
+  PLAQUE: [["adj", 16667]],
+  QUAD_ARROW: [
+    ["adj1", 22500],
+    ["adj2", 22500],
+    ["adj3", 22500]
+  ],
+  QUAD_ARROW_CALLOUT: [
+    ["adj1", 18515],
+    ["adj2", 18515],
+    ["adj3", 18515],
+    ["adj4", 48123]
+  ],
+  RECTANGULAR_CALLOUT: [
+    ["adj1", -20833],
+    ["adj2", 62500]
+  ],
+  REGULAR_PENTAGON: [
+    ["hf", 105146],
+    ["vf", 110557]
+  ],
+  RIGHT_ARROW: [
+    ["adj1", 5e4],
+    ["adj2", 5e4]
+  ],
+  RIGHT_ARROW_CALLOUT: [
+    ["adj1", 25e3],
+    ["adj2", 25e3],
+    ["adj3", 25e3],
+    ["adj4", 64977]
+  ],
+  RIGHT_BRACE: [
+    ["adj1", 8333],
+    ["adj2", 5e4]
+  ],
+  RIGHT_BRACKET: [["adj", 8333]],
+  ROUNDED_RECTANGLE: [["adj", 16667]],
+  ROUNDED_RECTANGULAR_CALLOUT: [
+    ["adj1", -20833],
+    ["adj2", 62500],
+    ["adj3", 16667]
+  ],
+  ROUND_1_RECTANGLE: [["adj", 16667]],
+  ROUND_2_DIAG_RECTANGLE: [
+    ["adj1", 16667],
+    ["adj2", 0]
+  ],
+  ROUND_2_SAME_RECTANGLE: [
+    ["adj1", 16667],
+    ["adj2", 0]
+  ],
+  SMILEY_FACE: [["adj", 4653]],
+  SNIP_1_RECTANGLE: [["adj", 16667]],
+  SNIP_2_DIAG_RECTANGLE: [
+    ["adj1", 0],
+    ["adj2", 16667]
+  ],
+  SNIP_2_SAME_RECTANGLE: [
+    ["adj1", 16667],
+    ["adj2", 0]
+  ],
+  SNIP_ROUND_RECTANGLE: [
+    ["adj1", 16667],
+    ["adj2", 16667]
+  ],
+  STAR_10_POINT: [
+    ["adj", 42533],
+    ["hf", 105146]
+  ],
+  STAR_12_POINT: [["adj", 37500]],
+  STAR_16_POINT: [["adj", 37500]],
+  STAR_24_POINT: [["adj", 37500]],
+  STAR_32_POINT: [["adj", 37500]],
+  STAR_4_POINT: [["adj", 12500]],
+  STAR_5_POINT: [
+    ["adj", 19098],
+    ["hf", 105146],
+    ["vf", 110557]
+  ],
+  STAR_6_POINT: [
+    ["adj", 28868],
+    ["hf", 115470]
+  ],
+  STAR_7_POINT: [
+    ["adj", 34601],
+    ["hf", 102572],
+    ["vf", 105210]
+  ],
+  STAR_8_POINT: [["adj", 37500]],
+  STRIPED_RIGHT_ARROW: [
+    ["adj1", 5e4],
+    ["adj2", 5e4]
+  ],
+  SUN: [["adj", 25e3]],
+  SWOOSH_ARROW: [
+    ["adj1", 25e3],
+    ["adj2", 16667]
+  ],
+  TEAR: [["adj", 1e5]],
+  TRAPEZOID: [["adj", 25e3]],
+  UP_ARROW: [
+    ["adj1", 5e4],
+    ["adj2", 5e4]
+  ],
+  UP_ARROW_CALLOUT: [
+    ["adj1", 25e3],
+    ["adj2", 25e3],
+    ["adj3", 25e3],
+    ["adj4", 64977]
+  ],
+  UP_DOWN_ARROW: [
+    ["adj1", 5e4],
+    ["adj1", 5e4],
+    ["adj2", 5e4],
+    ["adj2", 5e4]
+  ],
+  UP_DOWN_ARROW_CALLOUT: [
+    ["adj1", 25e3],
+    ["adj2", 25e3],
+    ["adj3", 25e3],
+    ["adj4", 48123]
+  ],
+  UP_RIBBON: [
+    ["adj1", 16667],
+    ["adj2", 5e4]
+  ],
+  U_TURN_ARROW: [
+    ["adj1", 25e3],
+    ["adj2", 25e3],
+    ["adj3", 25e3],
+    ["adj4", 43750],
+    ["adj5", 75e3]
+  ],
+  VERTICAL_SCROLL: [["adj", 12500]],
+  WAVE: [
+    ["adj1", 12500],
+    ["adj2", 0]
+  ]
+};
+
+// packages/safe-bash-presentation-engine/src/shape-adjustments.ts
+function raw(value) {
+  if (typeof value !== "number") throw new TypeError("Adjustment value must be numeric.");
+  const result = Math.trunc(value * 1e5);
+  if (!Number.isSafeInteger(result))
+    throw new ValueError("Adjustment value exceeds the safe numeric range.");
+  return result;
+}
+function validateAdjustmentValues(values3) {
+  if (!Array.isArray(values3)) throw new TypeError("Adjustment values require an array.");
+  if (values3.length > 4096)
+    throw new OfficeError("resource-limit", "Adjustment value limit exceeded.", "usage");
+  for (let index = 0; index < values3.length; index++) {
+    if (!Object.hasOwn(values3, index))
+      throw new ValueError("Adjustment arrays must contain every position.");
+    raw(values3[index]);
+  }
+}
+var Adjustment = class {
+  constructor(name, defaultValue, actual = null) {
+    this.name = name;
+    this.defaultValue = defaultValue;
+    if (typeof name !== "string") throw new TypeError();
+    if (!Number.isSafeInteger(defaultValue) || actual !== null && !Number.isSafeInteger(actual))
+      throw new ValueError();
+    this.#actual = actual;
+  }
+  name;
+  defaultValue;
+  #actual;
+  get effective_value() {
+    return this.val / 1e5;
+  }
+  set effective_value(value) {
+    this.#actual = raw(value);
+  }
+  get val() {
+    return this.#actual ?? this.defaultValue;
+  }
+};
+function geometry(xml) {
+  const props2 = child(xml.root, "spPr");
+  const preset2 = props2?.children.find(
+    (n) => n.name.localName === "prstGeom" && [
+      "http://schemas.openxmlformats.org/drawingml/2006/main",
+      "http://purl.oclc.org/ooxml/drawingml/main"
+    ].includes(n.name.namespace)
+  );
+  return preset2;
+}
+var AdjustmentCollection = class {
+  #preset;
+  #read;
+  #writeXml;
+  constructor(read, write) {
+    this.#read = read;
+    this.#writeXml = write;
+    const node = geometry(read());
+    this.#preset = node && attr(node, "prst");
+    return new Proxy(this, {
+      get(target, key) {
+        if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+          return target.#value(Number(key));
+        const value = Reflect.get(target, key, target);
+        return typeof value === "function" ? value.bind(target) : value;
+      },
+      set(target, key, value) {
+        if (typeof key === "string" && key !== "" && String(Number(key)) === key) {
+          target.#set(Number(key), value);
+          return true;
+        }
+        throw new ValueError("Adjustment collection members are read-only.");
+      },
+      defineProperty() {
+        throw new ValueError("Adjustment collection properties cannot be redefined.");
+      },
+      deleteProperty() {
+        throw new ValueError("Adjustment collection entries cannot be deleted.");
+      }
+    });
+  }
+  #values() {
+    const xml = this.#read(), node = geometry(xml);
+    if ((node && attr(node, "prst")) !== this.#preset) throw new InvalidHandleError();
+    if (!node) return [];
+    const key = Object.keys(shapePresets).find(
+      (key2) => shapePresets[key2] === this.#preset
+    );
+    if (!key)
+      throw new OfficeError(
+        "unsupported-edit",
+        "Unknown preset adjustment defaults.",
+        "validate-intent"
+      );
+    const values3 = (shapeAdjustmentDefaults[key] ?? []).map(([name, value]) => [
+      name,
+      value
+    ]);
+    const guides = child(node, "avLst", node.name.namespace);
+    for (const guide of guides?.children ?? []) {
+      if (guide.name.localName !== "gd" || guide.name.namespace !== node.name.namespace) continue;
+      const target = values3.find(([name]) => name === attr(guide, "name"));
+      if (!target) continue;
+      const formula = attr(guide, "fmla");
+      const token = formula?.startsWith("val ") ? formula.slice(4) : "";
+      if (!token.length || [...token].some((c, i) => !"0123456789".includes(c) && !(i === 0 && c === "-")) || !Number.isSafeInteger(Number(token)))
+        throw new OfficeError(
+          "unsupported-edit",
+          "Adjustment requires a literal integer guide.",
+          "validate-intent"
+        );
+      target[1] = Number(token);
+    }
+    return values3;
+  }
+  #value(index) {
+    const values3 = this.#values();
+    if (!Number.isSafeInteger(index) || index < 0 || index >= values3.length) throw new IndexError();
+    return values3[index][1] / 1e5;
+  }
+  #set(index, value) {
+    const values3 = this.#values();
+    if (!Number.isSafeInteger(index) || index < 0 || index >= values3.length) throw new IndexError();
+    const actual = raw(value);
+    this.#write(
+      values3.map(([name, current], position) => [name, position === index ? actual : current])
+    );
+  }
+  get length() {
+    return this.#values().length;
+  }
+  at(index) {
+    if (!Number.isSafeInteger(index)) throw new IndexError();
+    return this.#value(index < 0 ? this.length + index : index);
+  }
+  *[Symbol.iterator]() {
+    for (const [, value] of this.#values()) yield value / 1e5;
+  }
+  replace(values3) {
+    validateAdjustmentValues(values3);
+    const current = this.#values();
+    if (values3.length !== current.length)
+      throw new ValueError("Adjustment count must match the preset.");
+    const actuals = values3.map(raw);
+    this.#write(current.map(([name], index) => [name, actuals[index]]));
+  }
+  #write(current) {
+    const xml = this.#read(), node = geometry(xml);
+    if (!node) {
+      if (current.length) throw new ValueError();
+      return;
+    }
+    const namespace = node.name.namespace;
+    const guides = `<a:avLst xmlns:a="${namespace}">${current.map(([name, value]) => `<a:gd name="${name}" fmla="val ${value}"/>`).join("")}</a:avLst>`;
+    const existing = child(node, "avLst", namespace);
+    this.#writeXml(
+      xml.spliceChildren(node, existing ? node.children.indexOf(existing) : 0, existing ? 1 : 0, [
+        guides
+      ])
+    );
+  }
+};
+
+// packages/safe-bash-presentation-engine/src/text-fitting.ts
+function unsupported() {
+  throw new OfficeError(
+    "unsupported-edit",
+    "Text fitting requires supplied matching metrics and a supported horizontal single-column frame.",
+    "validate-intent"
+  );
+}
+function validateTextFitOptions(options) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)))
+    throw new OfficeError("invalid-value", "Invalid text fit options.", "usage");
+  const allowed = [
+    "metrics",
+    "fontFamily",
+    "maxSize",
+    "minSize",
+    "bold",
+    "italic",
+    "marginLeft",
+    "marginRight",
+    "marginTop",
+    "marginBottom",
+    "wrap",
+    "lineSpacing",
+    "scope",
+    "select",
+    "shape",
+    "all",
+    "allowEmpty"
+  ];
+  if (Reflect.ownKeys(options).some(
+    (k) => typeof k !== "string" || !allowed.includes(k) || !Object.hasOwn(Object.getOwnPropertyDescriptor(options, k), "value")
+  ))
+    throw new OfficeError("invalid-value", "Invalid text fit options.", "usage");
+  if (!options.metrics) unsupported();
+  for (const key of ["fontFamily", "maxSize", "minSize", "bold", "italic", "lineSpacing"])
+    if (options[key] === null)
+      throw new OfficeError("invalid-value", "Invalid text fit options.", "usage");
+  if ((options.maxSize ?? 18) > 4e3)
+    throw new OfficeError("invalid-value", "Text fit sizes must not exceed 4000 points.", "usage");
+  for (const key of ["all", "allowEmpty", "wrap"])
+    if (options[key] !== void 0 && typeof options[key] !== "boolean")
+      throw new OfficeError("invalid-value", "Invalid text fit options.", "usage");
+  for (const key of ["marginLeft", "marginRight", "marginTop", "marginBottom"])
+    if (options[key] !== void 0 && (typeof options[key] !== "number" || !Number.isFinite(options[key]) || options[key] < 0 || options[key] > 2147483647 / 12700))
+      throw new OfficeError("invalid-value", "Invalid text fit margins.", "usage");
+  validateTextReadingOptions({
+    ...options.scope === void 0 ? {} : { scope: options.scope },
+    ...options.select === void 0 ? {} : { select: options.select },
+    ...options.shape === void 0 ? {} : { shape: options.shape }
+  });
+  bestFitText(options.metrics, "", {
+    family: options.fontFamily ?? "Calibri",
+    bold: options.bold ?? false,
+    italic: options.italic ?? false,
+    maxSize: options.maxSize ?? 18,
+    minSize: options.minSize ?? 1,
+    width: 0,
+    height: 0,
+    wrap: options.wrap ?? true,
+    lineSpacing: options.lineSpacing ?? 1
+  });
+}
+function fitFrameXml(xml, options, width, height) {
+  validateTextFitOptions(options);
+  if (![width, height].every(
+    (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 1e9
+  ))
+    throw new OfficeError("invalid-value", "Invalid text frame extents.", "usage");
+  const formatting = readFrameFormatting(xml.root);
+  if ((formatting.columns ?? 1) !== 1 || ![null, "horz"].includes(formatting.verticalText) || (formatting.rotation ?? 0) !== 0)
+    unsupported();
+  const ns = xml.root.name.namespace.includes("purl.oclc.org") ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+  const name = (localName) => ({ namespace: ns, localName });
+  const check = (node) => {
+    if (node.name.namespace !== ns) return;
+    if (["buChar", "buAutoNum", "buBlip", "tabLst"].includes(node.name.localName)) unsupported();
+    if (node.attributes.some(
+      (a) => !a.name.namespace && ["marL", "marR", "indent", "lvl", "spc", "baseline"].includes(a.name.localName) && Number(a.value) !== 0
+    ))
+      unsupported();
+    if (node.attributes.some(
+      (a) => !a.name.namespace && a.name.localName === "cap" && a.value !== "none"
+    ))
+      unsupported();
+    node.children.forEach(check);
+  };
+  xml.root.children.forEach(check);
+  const margins = {
+    marginLeft: options.marginLeft ?? formatting.marginLeft ?? 7.2,
+    marginRight: options.marginRight ?? formatting.marginRight ?? 7.2,
+    marginTop: options.marginTop ?? formatting.marginTop ?? 3.6,
+    marginBottom: options.marginBottom ?? formatting.marginBottom ?? 3.6
+  };
+  for (const key of Object.keys(margins))
+    margins[key] = Math.round(margins[key] * 12700) / 12700;
+  if (Object.values(margins).some((v) => v < 0)) unsupported();
+  const family = options.fontFamily ?? "Calibri", bold = options.bold ?? false, italic = options.italic ?? false;
+  const lineSpacing = Math.round((options.lineSpacing ?? 1) * 1e5) / 1e5;
+  if (width < margins.marginLeft + margins.marginRight || height < margins.marginTop + margins.marginBottom)
+    unsupported();
+  const size = bestFitText(options.metrics, new TextFrame(xml).text, {
+    family,
+    bold,
+    italic,
+    width: width - margins.marginLeft - margins.marginRight,
+    height: height - margins.marginTop - margins.marginBottom,
+    minSize: options.minSize ?? 1,
+    maxSize: options.maxSize ?? 18,
+    wrap: options.wrap ?? true,
+    lineSpacing,
+    preserveBreaks: true,
+    preserveSpaces: true
+  });
+  if (size === null)
+    throw new OfficeError(
+      "unsupported-edit",
+      "Text does not fit within the supplied size bounds.",
+      "validate-intent"
+    );
+  let result = applyFrameFormatting(xml, xml.root, {
+    ...margins,
+    wrap: options.wrap ?? true,
+    autofit: "none"
+  });
+  const paragraphIndexes = result.root.children.flatMap(
+    (p, i) => p.name.namespace === ns && p.name.localName === "p" ? [i] : []
+  );
+  for (const index of paragraphIndexes) {
+    if (!result.root.children[index].children.some(
+      (n) => n.name.namespace === ns && n.name.localName === "pPr"
+    ))
+      result = result.spliceChildren(result.root.children[index], 0, 0, [`<pPr xmlns="${ns}"/>`]);
+    if (!result.root.children[index].children.some(
+      (n) => n.name.namespace === ns && n.name.localName === "endParaRPr"
+    ))
+      result = result.spliceChildren(
+        result.root.children[index],
+        result.root.children[index].children.length,
+        0,
+        [`<endParaRPr xmlns="${ns}"/>`]
+      );
+    result = result.merge(result.root.children[index], {
+      children: {
+        sequence: ["pPr", "endParaRPr"].map(name),
+        remove: [],
+        upsert: [
+          {
+            name: name("pPr"),
+            merge: paragraphPropertiesMerge(
+              {
+                lineSpacing: { unit: "multiple", value: lineSpacing },
+                spaceBefore: 0,
+                spaceAfter: 0
+              },
+              ns
+            )
+          },
+          {
+            name: name("endParaRPr"),
+            merge: runPropertiesMerge({ font: family, size, bold, italic }, ns)
+          }
+        ]
+      }
+    });
+    const paragraph = result.root.children[index];
+    for (const [childIndex, child2] of paragraph.children.entries()) {
+      if (child2.name.namespace !== ns || !["r", "fld", "br"].includes(child2.name.localName))
+        continue;
+      result = result.merge(result.root.children[index].children[childIndex], {
+        children: {
+          sequence: ["rPr", "pPr", "t"].map(name),
+          remove: [],
+          upsert: [
+            {
+              name: name("rPr"),
+              merge: runPropertiesMerge({ font: family, size, bold, italic }, ns)
+            }
+          ]
+        }
+      });
+    }
+  }
+  return { xml: result, size };
+}
+async function fitTextFrames(input, options, context) {
+  validateTextFitOptions(options);
+  if (!options.all && options.select === void 0 && options.shape === void 0)
+    throw new SelectionError("missing-selection");
+  const state = await loadShared(input, context);
+  const bodies = (await readTextBodies(
+    state.source,
+    {
+      ...options.scope === void 0 ? {} : { scope: options.scope },
+      ...options.select === void 0 ? {} : { select: options.select },
+      ...options.shape === void 0 ? {} : { shape: options.shape }
+    },
+    context
+  ).catch((error) => {
+    if (error instanceof SelectionError && error.code === "missing-selection") return [];
+    throw error;
+  })).filter((b) => b.segment.cell === void 0);
+  if (!bodies.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+  if (bodies.length > 1 && !options.all) throw new SelectionError("ambiguous-selection");
+  const documents = /* @__PURE__ */ new Map();
+  const sizes2 = [];
+  for (const body of bodies) {
+    let locate2 = function(node2) {
+      if (node2 === body.node) return true;
+      for (const [i, child2] of node2.children.entries()) {
+        path.push(i);
+        if (locate2(child2)) return true;
+        path.pop();
+      }
+      return false;
+    };
+    var locate = locate2;
+    context.signal?.throwIfAborted();
+    const path = [];
+    if (!locate2(body.document.root)) unsupported();
+    const parentPath = path.slice(0, -1);
+    const parent = parentPath.reduce((n, i) => n.children[i], body.document.root);
+    const shapeNs = parent.name.namespace;
+    const props2 = parent.children.find(
+      (n) => n.name.namespace === shapeNs && n.name.localName === "spPr"
+    );
+    const transform = props2?.children.find(
+      (n) => n.name.localName === "xfrm" && n.name.namespace === (shapeNs.includes("purl.oclc.org") ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main")
+    );
+    const extent = transform?.children.find(
+      (n) => n.name.namespace === transform.name.namespace && n.name.localName === "ext"
+    );
+    if (!extent) unsupported();
+    const dimension = (key) => {
+      const raw2 = extent.attributes.find(
+        (a) => !a.name.namespace && a.name.localName === key
+      )?.value;
+      if (!raw2 || [...raw2].some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(raw2)))
+        unsupported();
+      return Number(raw2) / 12700;
+    };
+    let document = documents.get(body.part) ?? body.document;
+    const node = path.reduce((n, i) => n.children[i], document.root);
+    const standalone = parseXmlPart(
+      new TextEncoder().encode(document.markup(node, true)),
+      context.xmlLimits
+    );
+    const fitted = fitFrameXml(standalone, options, dimension("cx"), dimension("cy"));
+    document = document.spliceChildren(
+      parentPath.reduce((n, i) => n.children[i], document.root),
+      path.at(-1),
+      1,
+      [new TextDecoder().decode(fitted.xml.bytes())]
+    );
+    documents.set(body.part, document);
+    sizes2.push(fitted.size);
+  }
+  for (const [part, document] of documents) state.save(part, document);
+  return {
+    bytes: bodies.length ? (await state.finish(state.main, [])).bytes : state.source,
+    affected: bodies.length,
+    locations: bodies.map((b) => b.segment.location),
+    sizes: sizes2
+  };
+}
+
+// packages/safe-bash-presentation-engine/src/text-frames.ts
+import { SaxesParser } from "saxes";
+
+// packages/safe-bash-presentation-engine/src/text-frame-enums.ts
+var AutoSizeValue = /* @__PURE__ */ ((AutoSizeValue2) => {
+  AutoSizeValue2[AutoSizeValue2["NONE"] = 0] = "NONE";
+  AutoSizeValue2[AutoSizeValue2["SHAPE_TO_FIT_TEXT"] = 1] = "SHAPE_TO_FIT_TEXT";
+  AutoSizeValue2[AutoSizeValue2["TEXT_TO_FIT_SHAPE"] = 2] = "TEXT_TO_FIT_SHAPE";
+  AutoSizeValue2[AutoSizeValue2["MIXED"] = -2] = "MIXED";
+  return AutoSizeValue2;
+})(AutoSizeValue || {});
+var VerticalAnchorValue = /* @__PURE__ */ ((VerticalAnchorValue2) => {
+  VerticalAnchorValue2[VerticalAnchorValue2["TOP"] = 1] = "TOP";
+  VerticalAnchorValue2[VerticalAnchorValue2["MIDDLE"] = 3] = "MIDDLE";
+  VerticalAnchorValue2[VerticalAnchorValue2["BOTTOM"] = 4] = "BOTTOM";
+  VerticalAnchorValue2[VerticalAnchorValue2["MIXED"] = -2] = "MIXED";
+  return VerticalAnchorValue2;
+})(VerticalAnchorValue || {});
+var sizes = [
+  { name: "NONE", value: 0 },
+  { name: "SHAPE_TO_FIT_TEXT", value: 1 },
+  { name: "TEXT_TO_FIT_SHAPE", value: 2 },
+  { name: "MIXED", value: -2 }
+].map((value) => Object.freeze(value));
+var anchors = [
+  { name: "TOP", value: 1, xml_value: "t" },
+  { name: "MIDDLE", value: 3, xml_value: "ctr" },
+  { name: "BOTTOM", value: 4, xml_value: "b" },
+  { name: "MIXED", value: -2, xml_value: null }
+].map((value) => Object.freeze(value));
+function invalid() {
+  throw new ValueError("Invalid text frame enumeration value.");
+}
+var MSO_AUTO_SIZE = Object.freeze(
+  Object.assign(AutoSizeValue, {
+    metadata(value) {
+      return sizes.find((item) => item.value === value) ?? invalid();
+    }
+  })
+);
+var MSO_VERTICAL_ANCHOR = Object.freeze(
+  Object.assign(VerticalAnchorValue, {
+    metadata(value) {
+      return anchors.find((item) => item.value === value) ?? invalid();
+    },
+    from_xml(xml_value) {
+      return anchors.find((item) => item.xml_value !== null && item.xml_value === xml_value)?.value ?? invalid();
+    },
+    to_xml(value) {
+      return anchors.find((item) => item.value === value)?.xml_value ?? invalid();
+    },
+    validate(value) {
+      if (!anchors.some((item) => item.value === value && item.xml_value !== null)) invalid();
+    }
+  })
+);
+
+// packages/safe-bash-presentation-engine/src/text-frames.ts
+var textVerticalModes = [
+  "horz",
+  "vert",
+  "vert270",
+  "wordArtVert",
+  "eaVert",
+  "mongolianVert",
+  "wordArtVertRtl"
+];
+var drawingNamespaces = [
+  "http://schemas.openxmlformats.org/drawingml/2006/main",
+  "http://purl.oclc.org/ooxml/drawingml/main"
+];
+var keys = [
+  "marginLeft",
+  "marginRight",
+  "marginTop",
+  "marginBottom",
+  "verticalAnchor",
+  "columns",
+  "wrap",
+  "verticalText",
+  "rotation",
+  "autofit",
+  "text"
+];
+var insetAttributes = {
+  marginLeft: "lIns",
+  marginRight: "rIns",
+  marginTop: "tIns",
+  marginBottom: "bIns"
+};
+var anchorValues = { top: "t", middle: "ctr", bottom: "b", 1: "t", 3: "ctr", 4: "b" };
+var fitValues = {
+  none: "noAutofit",
+  shape: "spAutoFit",
+  text: "normAutofit",
+  0: "noAutofit",
+  1: "spAutoFit",
+  2: "normAutofit"
+};
+function invalid2() {
+  throw new OfficeError("invalid-value", "Invalid text frame options.", "usage");
+}
+function malformed() {
+  throw new OfficeError("invalid-xml", "Invalid text frame properties.", "parse");
+}
+function validateTextFrameOptions(options) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some(
+    (k) => ![...keys, "scope", "select", "shape", "all", "allowEmpty"].includes(k)
+  ) || !keys.some((k) => options[k] !== void 0))
+    invalid2();
+  const { scope, select, shape } = options;
+  validateTextReadingOptions({
+    ...scope === void 0 ? {} : { scope },
+    ...select === void 0 ? {} : { select },
+    ...shape === void 0 ? {} : { shape }
+  });
+  for (const key of ["all", "allowEmpty"])
+    if (options[key] !== void 0 && typeof options[key] !== "boolean") invalid2();
+  for (const key of Object.keys(insetAttributes)) {
+    const v = options[key];
+    if (v != null && (typeof v !== "number" || !Number.isFinite(v) || v < -2147483648 / 12700 || v > 2147483647 / 12700))
+      invalid2();
+  }
+  if (options.wrap != null && typeof options.wrap !== "boolean") invalid2();
+  if (options.columns != null && (!Number.isInteger(options.columns) || options.columns < 1 || options.columns > 16))
+    invalid2();
+  if (options.rotation != null && (typeof options.rotation !== "number" || !Number.isFinite(options.rotation) || options.rotation < -2147483648 / 6e4 || options.rotation > 2147483647 / 6e4))
+    invalid2();
+  if (options.verticalText != null && !textVerticalModes.includes(options.verticalText)) invalid2();
+  if (options.verticalAnchor != null && !(typeof options.verticalAnchor === "number" ? [1, 3, 4].includes(options.verticalAnchor) : ["top", "middle", "bottom"].includes(options.verticalAnchor)))
+    invalid2();
+  if (options.autofit != null && !(typeof options.autofit === "number" ? [0, 1, 2].includes(options.autofit) : ["none", "shape", "text"].includes(options.autofit)))
+    invalid2();
+  if (options.text !== void 0 && typeof options.text !== "string") invalid2();
+}
+function bodyProperties(body) {
+  if (!(body.name.localName === "txBody" && [
+    ...drawingNamespaces,
+    "http://schemas.openxmlformats.org/presentationml/2006/main",
+    "http://purl.oclc.org/ooxml/presentationml/main"
+  ].includes(body.name.namespace)) && !(["rich", "txPr"].includes(body.name.localName) && [
+    "http://schemas.openxmlformats.org/drawingml/2006/chart",
+    "http://purl.oclc.org/ooxml/drawingml/chart"
+  ].includes(body.name.namespace)))
+    malformed();
+  const children = body.children.filter(
+    (n) => drawingNamespaces.includes(n.name.namespace) && n.name.localName === "bodyPr"
+  );
+  if (children.length > 1) malformed();
+  return children[0];
+}
+function readFrameFormatting(body) {
+  const p = bodyProperties(body);
+  const attr2 = (key) => p?.attributes.find((a) => !a.name.namespace && a.name.localName === key)?.value ?? null;
+  const number2 = (key, scale) => {
+    const raw2 = attr2(key);
+    if (raw2 === null) return null;
+    const token = raw2.trim();
+    const digits = token.startsWith("+") || token.startsWith("-") ? token.slice(1) : token;
+    if (!digits.length || Array.from(digits).some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(raw2)))
+      malformed();
+    return Number(raw2) / scale;
+  };
+  const wrap = attr2("wrap"), anchor = attr2("anchor"), vertical = attr2("vert");
+  if (wrap !== null && !["square", "none"].includes(wrap)) malformed();
+  const fits = p?.children.filter(
+    (n) => n.name.namespace === p.name.namespace && ["noAutofit", "normAutofit", "spAutoFit"].includes(n.name.localName)
+  ) ?? [];
+  if (fits.length > 1) malformed();
+  const result = {
+    marginLeft: number2("lIns", 12700),
+    marginRight: number2("rIns", 12700),
+    marginTop: number2("tIns", 12700),
+    marginBottom: number2("bIns", 12700),
+    verticalAnchor: anchor === null ? null : { t: "top", ctr: "middle", b: "bottom" }[anchor] ?? anchor,
+    columns: number2("numCol", 1),
+    wrap: wrap === null ? null : wrap === "square",
+    verticalText: vertical,
+    rotation: number2("rot", 6e4),
+    autofit: fits.length ? { noAutofit: "none", spAutoFit: "shape", normAutofit: "text" }[fits[0].name.localName] : null
+  };
+  try {
+    if (anchor !== null && !["t", "ctr", "b", "just", "dist"].includes(anchor)) malformed();
+    validateTextFrameOptions({ ...result, verticalAnchor: null });
+  } catch {
+    malformed();
+  }
+  return result;
+}
+function applyFrameFormatting(document, node, options) {
+  validateTextFrameOptions(options);
+  readFrameFormatting(node);
+  if (options.text !== void 0 && (protectedEquationNodes(node).size > 0 || protectedEquationNodes(document.root).has(node)))
+    throw new OfficeError(
+      "unsupported-edit",
+      "Whole text replacement cannot remove equations or their fallbacks.",
+      "validate-intent"
+    );
+  const path = [];
+  function locate(current2) {
+    if (current2 === node) return true;
+    for (const [i, c] of current2.children.entries()) {
+      path.push(i);
+      if (locate(c)) return true;
+      path.pop();
+    }
+    return false;
+  }
+  if (!locate(document.root)) invalid2();
+  let result = document;
+  const current = () => path.reduce((n, i) => n.children[i], result.root);
+  let p = bodyProperties(node);
+  const ns = p?.name.namespace ?? (node.name.namespace.includes("purl.oclc.org") ? drawingNamespaces[1] : drawingNamespaces[0]);
+  if (!p) {
+    result = result.spliceChildren(current(), 0, 0, [`<bodyPr xmlns="${ns}"/>`]);
+    p = bodyProperties(current());
+  }
+  const attributes = [];
+  for (const [key, localName] of Object.entries(insetAttributes)) {
+    const value = options[key];
+    if (value !== void 0)
+      attributes.push({
+        namespace: "",
+        localName,
+        value: value === null ? null : String(Math.sign(value) * Math.round(Math.abs(value) * 12700))
+      });
+  }
+  for (const [key, localName] of [
+    ["columns", "numCol"],
+    ["wrap", "wrap"],
+    ["verticalText", "vert"],
+    ["rotation", "rot"],
+    ["verticalAnchor", "anchor"]
+  ]) {
+    const value = options[key];
+    if (value === void 0) continue;
+    attributes.push({
+      namespace: "",
+      localName,
+      value: value === null ? null : key === "wrap" ? value ? "square" : "none" : key === "rotation" ? String(Math.sign(Number(value)) * Math.round(Math.abs(Number(value)) * 6e4)) : key === "verticalAnchor" ? anchorValues[value] : String(value)
+    });
+  }
+  const name = (localName) => ({ namespace: ns, localName });
+  const fit = options.autofit == null ? null : fitValues[options.autofit];
+  result = result.merge(p, {
+    attributes,
+    ...options.autofit === void 0 ? {} : {
+      children: {
+        sequence: [
+          "prstTxWarp",
+          "noAutofit",
+          "normAutofit",
+          "spAutoFit",
+          "scene3d",
+          "sp3d",
+          "flatTx",
+          "extLst"
+        ].map(name),
+        remove: ["noAutofit", "normAutofit", "spAutoFit"].filter((n) => n !== fit).map(name),
+        upsert: fit ? [{ name: name(fit), merge: {} }] : []
+      }
+    }
+  });
+  if (options.text !== void 0) {
+    const paragraphs = current().children.flatMap(
+      (n, i) => n.name.namespace === ns && n.name.localName === "p" ? [i] : []
+    );
+    const position = paragraphs[0] ?? current().children.length;
+    for (const index of paragraphs.reverse())
+      result = result.spliceChildren(current(), index, 1, []);
+    const escape = (text) => Array.from(text).map((c) => {
+      const point = c.codePointAt(0);
+      return point < 32 && ![9, 10, 13].includes(point) || point >= 55296 && point <= 57343 || [65534, 65535].includes(point) ? `_x${point.toString(16).toUpperCase().padStart(4, "0")}_` : c === "&" ? "&amp;" : c === "<" ? "&lt;" : c === "\r" ? "&#13;" : c;
+    }).join("");
+    const fragments = options.text.split("\n").map(
+      (text) => `<p xmlns="${ns}">${text.split("\v").map((piece) => piece ? `<r><t>${escape(piece)}</t></r>` : "").join("<br/>")}</p>`
+    );
+    result = result.spliceChildren(current(), position, 0, fragments);
+  }
+  return result;
+}
+async function readTextFrames(input, options, context) {
+  const bodies = await readTextBodies(input, options, context).catch((error) => {
+    if (error instanceof SelectionError && error.code === "missing-selection") return [];
+    throw error;
+  });
+  return bodies.filter((body) => body.segment.cell === void 0).map((body) => ({
+    location: body.segment.location,
+    formatting: readFrameFormatting(body.node)
+  }));
+}
+async function mutateTextFrames(input, options, context) {
+  validateTextFrameOptions(options);
+  if (!options.all && options.select === void 0 && options.shape === void 0)
+    throw new SelectionError("missing-selection");
+  const state = await loadShared(input, context);
+  const { scope, select, shape } = options;
+  const bodies = await readTextBodies(
+    state.source,
+    {
+      ...scope === void 0 ? {} : { scope },
+      ...select === void 0 ? {} : { select },
+      ...shape === void 0 ? {} : { shape }
+    },
+    context
+  ).catch((error) => {
+    if (error instanceof SelectionError && error.code === "missing-selection") return [];
+    throw error;
+  }).then((bodies2) => bodies2.filter((body) => body.segment.cell === void 0));
+  if (!bodies.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+  if (bodies.length > 1 && !options.all) throw new SelectionError("ambiguous-selection");
+  const edits = /* @__PURE__ */ new Map();
+  for (const body of bodies) {
+    const edit = edits.get(body.part) ?? { document: body.document, nodes: /* @__PURE__ */ new Set() };
+    edit.nodes.add(body.node);
+    edits.set(body.part, edit);
+  }
+  for (const [part, edit] of edits) {
+    const paths = [];
+    const visit = (node, path) => {
+      if (edit.nodes.has(node)) paths.push(path);
+      node.children.forEach((n, i) => visit(n, [...path, i]));
+    };
+    visit(edit.document.root, []);
+    let document = edit.document;
+    for (const path of paths.reverse()) {
+      context.signal?.throwIfAborted();
+      document = applyFrameFormatting(
+        document,
+        path.reduce((n, i) => n.children[i], document.root),
+        options
+      );
+    }
+    state.save(part, document);
+  }
+  return {
+    bytes: bodies.length ? (await state.finish(state.main, [])).bytes : state.source,
+    affected: bodies.length,
+    locations: bodies.map((b) => b.segment.location)
+  };
+}
+var TextFrame = class {
+  #paragraphs = [];
+  #storedXml;
+  #binding;
+  get #xml() {
+    return this.#binding?.read() ?? this.#storedXml;
+  }
+  set #xml(xml) {
+    if (this.#binding) this.#binding.write(xml);
+    else this.#storedXml = xml;
+  }
+  #extents;
+  constructor(xml, extents, binding) {
+    readFrameFormatting(xml.root);
+    this.#storedXml = xml;
+    this.#binding = binding;
+    this.#extents = extents === void 0 ? void 0 : { ...extents };
+  }
+  fit_text(font_family = "Calibri", max_size = 18, bold = false, italic = false, font_file, options = {}) {
+    if (typeof font_family !== "string" || typeof max_size !== "number" || typeof bold !== "boolean" || typeof italic !== "boolean")
+      throw new TypeError("Text fitting requires a font family, numeric size and boolean styles.");
+    if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).some(
+      (key) => typeof key !== "string" || ![
+        "minSize",
+        "marginLeft",
+        "marginRight",
+        "marginTop",
+        "marginBottom",
+        "wrap",
+        "lineSpacing"
+      ].includes(key) || !Object.hasOwn(Object.getOwnPropertyDescriptor(options, key), "value")
+    ))
+      throw new OfficeError("invalid-value", "Text fit options require stored data.", "usage");
+    const extents = this.#binding?.extents ? this.#binding.extents() : this.#extents;
+    const result = fitFrameXml(
+      this.#xml,
+      { ...options, fontFamily: font_family, maxSize: max_size, bold, italic, metrics: font_file },
+      extents?.width ?? NaN,
+      extents?.height ?? NaN
+    );
+    this.#xml = result.xml;
+  }
+  get xml() {
+    return this.#xml;
+  }
+  get parent() {
+    return this.#binding?.parent;
+  }
+  get paragraphs() {
+    const nodes = this.#xml.root.children.filter(
+      (node) => node.name.localName === "p" && drawingNamespaces.includes(node.name.namespace)
+    );
+    return Object.freeze(
+      nodes.map((_, index) => {
+        if (this.#paragraphs[index]) return this.#paragraphs[index];
+        let owner;
+        let cached;
+        const locate = () => {
+          if (this.#paragraphs[index] !== handle) throw new InvalidHandleError();
+          const xml = this.#xml;
+          const node = xml.root.children.filter(
+            (child2) => child2.name.localName === "p" && drawingNamespaces.includes(child2.name.namespace)
+          )[index];
+          if (!node) throw new InvalidHandleError();
+          return { xml, node };
+        };
+        const read = () => {
+          const { xml, node } = locate();
+          if (owner !== xml) {
+            cached = xml.subtree(node);
+            owner = xml;
+          }
+          return cached;
+        };
+        const initial = this.#xml.subtree(nodes[index]);
+        const handle = new Paragraph(initial, {
+          parent: this,
+          read,
+          write: (value) => {
+            const { xml, node } = locate();
+            this.#xml = xml.spliceChildren(xml.root, xml.root.children.indexOf(node), 1, [
+              value.markup(value.root, true)
+            ]);
+          }
+        });
+        const hyperlink = textLinkCapabilities.get(this);
+        if (hyperlink)
+          textLinkCapabilities.set(
+            handle,
+            (path) => hyperlink(() => {
+              const { xml, node } = locate();
+              return [xml.root.children.indexOf(node), ...path()];
+            })
+          );
+        this.#paragraphs[index] = handle;
+        return handle;
+      })
+    );
+  }
+  add_paragraph() {
+    const xml = this.#xml;
+    const ns = xml.root.name.namespace.includes("purl.oclc.org") ? drawingNamespaces[1] : drawingNamespaces[0];
+    const extension = xml.root.children.findIndex((node) => node.name.localName === "extLst");
+    this.#xml = xml.spliceChildren(
+      xml.root,
+      extension < 0 ? xml.root.children.length : extension,
+      0,
+      [`<p xmlns="${ns}"/>`]
+    );
+    return this.paragraphs.at(-1);
+  }
+  clear() {
+    const xml = this.#xml;
+    if (protectedEquationNodes(xml.root).size > 0)
+      throw new OfficeError(
+        "unsupported-edit",
+        "Whole text replacement cannot remove equations or their fallbacks.",
+        "validate-intent"
+      );
+    const first = this.paragraphs[0];
+    if (!first) {
+      this.add_paragraph();
+      return;
+    }
+    first.clear();
+    let current = this.#xml;
+    const indexes = current.root.children.flatMap(
+      (node, index) => node.name.localName === "p" && drawingNamespaces.includes(node.name.namespace) ? [index] : []
+    );
+    for (const index of indexes.slice(1).reverse())
+      current = current.spliceChildren(current.root, index, 1, []);
+    this.#xml = current;
+    this.#paragraphs = [first];
+  }
+  get margin_left() {
+    return new Pt(readFrameFormatting(this.#xml.root).marginLeft ?? 7.2);
+  }
+  set margin_left(value) {
+    if (!(value instanceof Length)) invalid2();
+    this.#xml = applyFrameFormatting(this.#xml, this.#xml.root, {
+      marginLeft: value.emu === 91440 ? null : value.pt
+    });
+  }
+  get margin_right() {
+    return new Pt(readFrameFormatting(this.#xml.root).marginRight ?? 7.2);
+  }
+  set margin_right(value) {
+    if (!(value instanceof Length)) invalid2();
+    this.#xml = applyFrameFormatting(this.#xml, this.#xml.root, {
+      marginRight: value.emu === 91440 ? null : value.pt
+    });
+  }
+  get margin_top() {
+    return new Pt(readFrameFormatting(this.#xml.root).marginTop ?? 3.6);
+  }
+  set margin_top(value) {
+    if (!(value instanceof Length)) invalid2();
+    this.#xml = applyFrameFormatting(this.#xml, this.#xml.root, {
+      marginTop: value.emu === 45720 ? null : value.pt
+    });
+  }
+  get margin_bottom() {
+    return new Pt(readFrameFormatting(this.#xml.root).marginBottom ?? 3.6);
+  }
+  set margin_bottom(value) {
+    if (!(value instanceof Length)) invalid2();
+    this.#xml = applyFrameFormatting(this.#xml, this.#xml.root, {
+      marginBottom: value.emu === 45720 ? null : value.pt
+    });
+  }
+  get word_wrap() {
+    return readFrameFormatting(this.#xml.root).wrap;
+  }
+  set word_wrap(value) {
+    this.#xml = applyFrameFormatting(this.#xml, this.#xml.root, { wrap: value });
+  }
+  get auto_size() {
+    const v = readFrameFormatting(this.#xml.root).autofit;
+    return v === null ? null : { none: 0, shape: 1, text: 2 }[v];
+  }
+  set auto_size(value) {
+    if (value !== null && (typeof value !== "number" || ![0, 1, 2].includes(value))) invalid2();
+    this.#xml = applyFrameFormatting(this.#xml, this.#xml.root, { autofit: value });
+  }
+  get vertical_anchor() {
+    const v = readFrameFormatting(this.#xml.root).verticalAnchor;
+    if (v === "just" || v === "dist")
+      throw new OfficeError(
+        "unsupported-profile",
+        "Extended frame anchor has no model enum value.",
+        "parse"
+      );
+    return v === null ? null : { top: 1, middle: 3, bottom: 4 }[v];
+  }
+  set vertical_anchor(value) {
+    if (value !== null && (typeof value !== "number" || ![1, 3, 4].includes(value))) invalid2();
+    this.#xml = applyFrameFormatting(this.#xml, this.#xml.root, { verticalAnchor: value });
+  }
+  get columns() {
+    return readFrameFormatting(this.#xml.root).columns ?? 1;
+  }
+  set columns(value) {
+    this.#xml = applyFrameFormatting(this.#xml, this.#xml.root, { columns: value });
+  }
+  get vertical_text() {
+    return readFrameFormatting(this.#xml.root).verticalText;
+  }
+  set vertical_text(value) {
+    this.#xml = applyFrameFormatting(this.#xml, this.#xml.root, { verticalText: value });
+  }
+  get rotation() {
+    return readFrameFormatting(this.#xml.root).rotation ?? 0;
+  }
+  set rotation(value) {
+    this.#xml = applyFrameFormatting(this.#xml, this.#xml.root, { rotation: value });
+  }
+  get text() {
+    const body = this.#xml.root;
+    const texts = (node) => {
+      if (node.name.localName === "br" && drawingNamespaces.includes(node.name.namespace))
+        return "\v";
+      if (node.name.localName === "t" && drawingNamespaces.includes(node.name.namespace)) {
+        const raw2 = this.#xml.markup(node);
+        return decodeText(raw2);
+      }
+      return node.children.map(texts).join("");
+    };
+    return body.children.filter((n) => n.name.localName === "p" && drawingNamespaces.includes(n.name.namespace)).map(texts).join("\n");
+  }
+  set text(value) {
+    this.#xml = applyFrameFormatting(this.#xml, this.#xml.root, { text: value });
+    this.#paragraphs = [];
+  }
+};
+function decodeText(markup) {
+  let result = "";
+  const parser = new SaxesParser({ xmlns: false });
+  parser.on("text", (value) => {
+    result += value;
+  });
+  parser.on("cdata", (value) => {
+    result += value;
+  });
+  parser.write(markup).close();
+  return result;
+}
+
+// packages/safe-bash-presentation-engine/src/shape-types.ts
+var values = {
+  AUTO_SHAPE: 1,
+  CALLOUT: 2,
+  CANVAS: 20,
+  CHART: 3,
+  COMMENT: 4,
+  DIAGRAM: 21,
+  EMBEDDED_OLE_OBJECT: 7,
+  FORM_CONTROL: 8,
+  FREEFORM: 5,
+  GROUP: 6,
+  IGX_GRAPHIC: 24,
+  INK: 22,
+  INK_COMMENT: 23,
+  LINE: 9,
+  LINKED_OLE_OBJECT: 10,
+  LINKED_PICTURE: 11,
+  MEDIA: 16,
+  OLE_CONTROL_OBJECT: 12,
+  PICTURE: 13,
+  PLACEHOLDER: 14,
+  SCRIPT_ANCHOR: 18,
+  TABLE: 19,
+  TEXT_BOX: 17,
+  TEXT_EFFECT: 15,
+  WEB_VIDEO: 26,
+  MIXED: -2
+};
+var entries = Object.keys(values).map(
+  (name) => Object.freeze({ name, value: values[name] })
+);
+var MSO_SHAPE_TYPE = Object.freeze(
+  Object.assign(values, {
+    metadata(value) {
+      const item = entries.find((e) => e.value === value);
+      if (!item) throw new ValueError("Unknown shape category.");
+      return item;
+    }
+  })
+);
+
+// packages/safe-bash-presentation-engine/src/shape-placeholder-types.ts
+var values2 = {
+  BITMAP: 9,
+  BODY: 2,
+  CENTER_TITLE: 3,
+  CHART: 8,
+  DATE: 16,
+  FOOTER: 15,
+  HEADER: 14,
+  MEDIA_CLIP: 10,
+  OBJECT: 7,
+  ORG_CHART: 11,
+  PICTURE: 18,
+  SLIDE_IMAGE: 101,
+  SLIDE_NUMBER: 13,
+  SUBTITLE: 4,
+  TABLE: 12,
+  TITLE: 1,
+  VERTICAL_BODY: 6,
+  VERTICAL_OBJECT: 17,
+  VERTICAL_TITLE: 5,
+  MIXED: -2
+};
+var entries2 = [
+  { name: "BITMAP", value: 9, xml_value: "clipArt" },
+  { name: "BODY", value: 2, xml_value: "body" },
+  { name: "CENTER_TITLE", value: 3, xml_value: "ctrTitle" },
+  { name: "CHART", value: 8, xml_value: "chart" },
+  { name: "DATE", value: 16, xml_value: "dt" },
+  { name: "FOOTER", value: 15, xml_value: "ftr" },
+  { name: "HEADER", value: 14, xml_value: "hdr" },
+  { name: "MEDIA_CLIP", value: 10, xml_value: "media" },
+  { name: "OBJECT", value: 7, xml_value: "obj" },
+  { name: "ORG_CHART", value: 11, xml_value: "dgm" },
+  { name: "PICTURE", value: 18, xml_value: "pic" },
+  { name: "SLIDE_IMAGE", value: 101, xml_value: "sldImg" },
+  { name: "SLIDE_NUMBER", value: 13, xml_value: "sldNum" },
+  { name: "SUBTITLE", value: 4, xml_value: "subTitle" },
+  { name: "TABLE", value: 12, xml_value: "tbl" },
+  { name: "TITLE", value: 1, xml_value: "title" },
+  { name: "VERTICAL_BODY", value: 6, xml_value: null },
+  { name: "VERTICAL_OBJECT", value: 17, xml_value: null },
+  { name: "VERTICAL_TITLE", value: 5, xml_value: null },
+  { name: "MIXED", value: -2, xml_value: null }
+];
+function invalid3() {
+  throw new ValueError("Unsupported placeholder type.");
+}
+var PP_PLACEHOLDER_TYPE = Object.freeze(
+  Object.assign(values2, {
+    metadata(value) {
+      const item = entries2.find((e) => e.value === value);
+      return item ? Object.freeze({ ...item }) : invalid3();
+    },
+    from_xml(value) {
+      return entries2.find((e) => e.xml_value !== null && e.xml_value === value)?.value ?? invalid3();
+    },
+    to_xml(value) {
+      return entries2.find((e) => e.value === value)?.xml_value ?? invalid3();
+    },
+    validate(value) {
+      if (!entries2.some((e) => e.value === value && e.xml_value !== null)) invalid3();
+    }
+  })
+);
+
+// packages/safe-bash-presentation-engine/src/drawing-enums.ts
+var MSO_FILL_TYPE = defineEnum({
+  SOLID: 1,
+  PATTERNED: 2,
+  GRADIENT: 3,
+  TEXTURED: 4,
+  BACKGROUND: 5,
+  PICTURE: 6,
+  GROUP: 101
+});
+var MSO_FILL = MSO_FILL_TYPE;
+var lineValues = {
+  SOLID: 1,
+  SQUARE_DOT: 2,
+  ROUND_DOT: 3,
+  DASH: 4,
+  DASH_DOT: 5,
+  DASH_DOT_DOT: 6,
+  LONG_DASH: 7,
+  LONG_DASH_DOT: 8,
+  DASH_STYLE_MIXED: -2
+};
+var dashTokens = Object.freeze({
+  1: "solid",
+  2: "sysDash",
+  3: "sysDot",
+  4: "dash",
+  5: "dashDot",
+  6: "lgDashDotDot",
+  7: "lgDash",
+  8: "lgDashDot"
+});
+var patternValues = {
+  PERCENT_5: 1,
+  PERCENT_10: 2,
+  PERCENT_20: 3,
+  PERCENT_25: 4,
+  PERCENT_30: 5,
+  PERCENT_40: 6,
+  PERCENT_50: 7,
+  PERCENT_60: 8,
+  PERCENT_70: 9,
+  PERCENT_75: 10,
+  PERCENT_80: 11,
+  PERCENT_90: 12,
+  DARK_HORIZONTAL: 13,
+  DARK_VERTICAL: 14,
+  DARK_DOWNWARD_DIAGONAL: 15,
+  DARK_UPWARD_DIAGONAL: 16,
+  SMALL_CHECKER_BOARD: 17,
+  TRELLIS: 18,
+  LIGHT_HORIZONTAL: 19,
+  LIGHT_VERTICAL: 20,
+  LIGHT_DOWNWARD_DIAGONAL: 21,
+  LIGHT_UPWARD_DIAGONAL: 22,
+  SMALL_GRID: 23,
+  DOTTED_DIAMOND: 24,
+  WIDE_DOWNWARD_DIAGONAL: 25,
+  WIDE_UPWARD_DIAGONAL: 26,
+  DASHED_UPWARD_DIAGONAL: 27,
+  DASHED_DOWNWARD_DIAGONAL: 28,
+  NARROW_VERTICAL: 29,
+  NARROW_HORIZONTAL: 30,
+  DASHED_VERTICAL: 31,
+  DASHED_HORIZONTAL: 32,
+  LARGE_CONFETTI: 33,
+  LARGE_GRID: 34,
+  HORIZONTAL_BRICK: 35,
+  LARGE_CHECKER_BOARD: 36,
+  SMALL_CONFETTI: 37,
+  ZIG_ZAG: 38,
+  SOLID_DIAMOND: 39,
+  DIAGONAL_BRICK: 40,
+  OUTLINED_DIAMOND: 41,
+  PLAID: 42,
+  SPHERE: 43,
+  WEAVE: 44,
+  DOTTED_GRID: 45,
+  DIVOT: 46,
+  SHINGLE: 47,
+  WAVE: 48,
+  HORIZONTAL: 49,
+  VERTICAL: 50,
+  CROSS: 51,
+  DOWNWARD_DIAGONAL: 52,
+  UPWARD_DIAGONAL: 53,
+  DIAGONAL_CROSS: 54,
+  MIXED: -2
+};
+var patternTokens = Object.freeze({
+  1: "pct5",
+  2: "pct10",
+  3: "pct20",
+  4: "pct25",
+  5: "pct30",
+  6: "pct40",
+  7: "pct50",
+  8: "pct60",
+  9: "pct70",
+  10: "pct75",
+  11: "pct80",
+  12: "pct90",
+  13: "dkHorz",
+  14: "dkVert",
+  15: "dkDnDiag",
+  16: "dkUpDiag",
+  17: "smCheck",
+  18: "trellis",
+  19: "ltHorz",
+  20: "ltVert",
+  21: "ltDnDiag",
+  22: "ltUpDiag",
+  23: "smGrid",
+  24: "dotDmnd",
+  25: "wdDnDiag",
+  26: "wdUpDiag",
+  27: "dashUpDiag",
+  28: "dashDnDiag",
+  29: "narVert",
+  30: "narHorz",
+  31: "dashVert",
+  32: "dashHorz",
+  33: "lgConfetti",
+  34: "lgGrid",
+  35: "horzBrick",
+  36: "lgCheck",
+  37: "smConfetti",
+  38: "zigZag",
+  39: "solidDmnd",
+  40: "diagBrick",
+  41: "openDmnd",
+  42: "plaid",
+  43: "sphere",
+  44: "weave",
+  45: "dotGrid",
+  46: "divot",
+  47: "shingle",
+  48: "wave",
+  49: "horz",
+  50: "vert",
+  51: "cross",
+  52: "dnDiag",
+  53: "upDiag",
+  54: "diagCross"
+});
+var MSO_LINE_DASH_STYLE = defineXmlEnum(lineValues, dashTokens);
+var MSO_LINE = MSO_LINE_DASH_STYLE;
+var MSO_PATTERN_TYPE = defineXmlEnum(patternValues, patternTokens);
+var MSO_PATTERN = MSO_PATTERN_TYPE;
+
+// packages/safe-bash-presentation-engine/src/shapes.ts
+var pns = "http://schemas.openxmlformats.org/presentationml/2006/main";
+var ans = "http://schemas.openxmlformats.org/drawingml/2006/main";
+function drawing(node) {
+  if ([ans, "http://purl.oclc.org/ooxml/drawingml/main"].includes(node.name.namespace))
+    return node.name.namespace;
+  if (![
+    pns,
+    "http://purl.oclc.org/ooxml/presentationml/main",
+    "http://schemas.openxmlformats.org/drawingml/2006/chart",
+    "http://purl.oclc.org/ooxml/drawingml/chart"
+  ].includes(node.name.namespace))
+    invalid4("Unsupported shape namespace.");
+  return [
+    "http://purl.oclc.org/ooxml/presentationml/main",
+    "http://purl.oclc.org/ooxml/drawingml/chart"
+  ].includes(node.name.namespace) ? "http://purl.oclc.org/ooxml/drawingml/main" : ans;
+}
+function invalid4(message = "Invalid shape properties.") {
+  throw new OfficeError("invalid-value", message, "usage");
+}
+function unsupported2(message) {
+  throw new OfficeError("unsupported-edit", message, "validate-intent");
+}
+function preset(kind) {
+  if (kind === "text-box") return null;
+  const name = typeof kind === "number" ? Object.keys(shapePresets).find(
+    (k) => MSO_AUTO_SHAPE_TYPE[k] === kind
+  ) : kind;
+  if (!name || !Object.hasOwn(shapePresets, name)) invalid4("Unknown preset shape.");
+  return name;
+}
+function emu(value) {
+  if (value instanceof Length) return value.emu;
+  if (!value || typeof value !== "object" || Object.keys(value).some((k) => !["value", "unit"].includes(k)) || typeof value.value !== "number")
+    invalid4();
+  const factors = { emu: 1, in: 914400, cm: 36e4, mm: 36e3, pt: 12700 };
+  if (!Object.hasOwn(factors, value.unit)) invalid4();
+  const result = new Length(value.value * factors[value.unit]).emu;
+  return result;
+}
+function escaped(value) {
+  let text = "";
+  for (const c of value) {
+    const cp = c.codePointAt(0);
+    if (cp < 32 && ![9, 10, 13].includes(cp) || cp >= 55296 && cp <= 57343 || cp === 65534 || cp === 65535)
+      invalid4();
+    text += c === "&" ? "&amp;" : c === "<" ? "&lt;" : c === '"' ? "&quot;" : c === "\r" ? "&#13;" : c === "\n" ? "&#10;" : c === "	" ? "&#9;" : c;
+  }
+  return text;
+}
+function validateShapeOptions(options, adding = false) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some(
+    (k) => ![
+      "kind",
+      "name",
+      "title",
+      "description",
+      "altText",
+      "locked",
+      "left",
+      "top",
+      "width",
+      "height",
+      "rotation",
+      "flipHorizontal",
+      "flipVertical",
+      "fill",
+      "lineColor",
+      "lineWidth",
+      "text",
+      "adjustments"
+    ].includes(k)
+  ))
+    invalid4();
+  if (options.adjustments !== void 0) validateAdjustmentValues(options.adjustments);
+  if (options.kind !== void 0) preset(options.kind);
+  for (const key of ["flipHorizontal", "flipVertical"])
+    if (options[key] !== void 0 && typeof options[key] !== "boolean") invalid4();
+  if (adding && options.kind === void 0) invalid4("Shape creation requires a kind.");
+  if (adding && ["left", "top", "width", "height"].some((k) => options[k] === void 0))
+    invalid4("Shape creation requires explicit geometry.");
+  for (const k of ["left", "top", "width", "height", "lineWidth"]) {
+    if (options[k] === null && k !== "lineWidth") invalid4();
+    if (options[k] !== void 0 && options[k] !== null) {
+      const n = emu(options[k]);
+      if (Math.abs(n) > 27273042316900) invalid4("Shape geometry exceeds DrawingML bounds.");
+      if ((k === "width" || k === "height") && n <= 0 || k === "lineWidth" && n < 0) invalid4();
+    }
+  }
+  for (const k of ["name", "text", "title", "description", "altText"]) {
+    const v = options[k];
+    if (v !== void 0 && v !== null) {
+      if (typeof v !== "string") invalid4();
+      if (k !== "text") escaped(v);
+    } else if (v === null && (k === "name" || k === "text")) invalid4();
+  }
+  if (options.description !== void 0 && options.altText !== void 0)
+    invalid4("Use description or altText, not both.");
+  if (options.locked !== void 0 && options.locked !== null && typeof options.locked !== "boolean")
+    invalid4();
+  if (options.rotation !== void 0 && (typeof options.rotation !== "number" || !Number.isFinite(options.rotation) || Math.abs(options.rotation) > 36e4))
+    invalid4();
+  for (const k of ["fill", "lineColor"]) {
+    const v = options[k];
+    if (v !== void 0 && v !== null && v !== "solid" && (typeof v !== "string" || v.length !== 6 || Array.from(v).some((c) => !"0123456789abcdefABCDEF".includes(c))))
+      invalid4();
+  }
+}
+function nv(node) {
+  return node.children.find(
+    (n) => n.name.namespace === node.name.namespace && ["nvSpPr", "nvPicPr", "nvGraphicFramePr", "nvGrpSpPr", "nvCxnSpPr"].includes(n.name.localName)
+  );
+}
+function props(node) {
+  return child(node, node.name.localName === "grpSp" ? "grpSpPr" : "spPr");
+}
+function num(node, key) {
+  const v = node && attr(node, key);
+  if (v === void 0) return null;
+  return ["x", "y"].includes(key) ? readXmlCoordinate(v) : readXmlInteger(v);
+}
+function readShape(node) {
+  const a = drawing(node), n = nv(node), cn = n && child(n, "cNvPr"), pr = props(node), x = node.name.localName === "graphicFrame" ? child(node, "xfrm") : pr && child(pr, "xfrm", a), off = x && child(x, "off", a), ext = x && child(x, "ext", a), geom = pr && child(pr, "prstGeom", a), raw2 = geom && attr(geom, "prst"), cp = n && child(n, "cNvSpPr"), ph = n && child(n, "nvPr") && child(child(n, "nvPr"), "ph"), locks = cp && child(cp, "spLocks", a), line = pr && child(pr, "ln", a);
+  const readColor = (v) => {
+    const sf = v && child(v, "solidFill", a), rgb = sf && child(sf, "srgbClr", a);
+    return rgb ? attr(rgb, "val") ?? null : null;
+  };
+  const found = raw2 ? Object.keys(shapePresets).find(
+    (k) => shapePresets[k] === raw2
+  ) : void 0;
+  const unknown = [];
+  for (const [label, owner] of [
+    ["fill", pr],
+    ["line", line]
+  ]) {
+    const fill = owner && child(owner, "solidFill", a);
+    for (const color of fill?.children ?? [])
+      if (color.name.namespace === a && color.name.localName !== "srgbClr")
+        unknown.push(`${label}:${color.name.localName}`);
+  }
+  if (raw2 && !found) unknown.push(`preset:${raw2}`);
+  for (const v of pr?.children ?? [])
+    if (v.name.namespace === a && ["gradFill", "pattFill", "blipFill", "grpFill", "custGeom"].includes(v.name.localName))
+      unknown.push(v.name.localName);
+  const lock = locks && attr(locks, "noSelect");
+  return {
+    shapeId: cn ? num(cn, "id") ?? 0 : 0,
+    name: cn ? attr(cn, "name") ?? "" : "",
+    title: cn ? attr(cn, "title") ?? null : null,
+    description: cn ? attr(cn, "descr") ?? null : null,
+    kind: cp && ["1", "true"].includes(attr(cp, "txBox") ?? "") ? "text-box" : found ?? null,
+    left: num(off, "x"),
+    top: num(off, "y"),
+    width: num(ext, "cx"),
+    height: num(ext, "cy"),
+    rotation: ((num(x, "rot") ?? 0) % 216e5 + 216e5) % 216e5 / 6e4,
+    flipHorizontal: x ? ["true", "1"].includes(attr(x, "flipH") ?? "0") : false,
+    flipVertical: x ? ["true", "1"].includes(attr(x, "flipV") ?? "0") : false,
+    locked: lock === void 0 ? null : ["1", "true"].includes(lock),
+    fill: readColor(pr),
+    fillType: pr?.children.find(
+      (n2) => n2.name.namespace === a && ["noFill", "solidFill", "gradFill", "pattFill", "blipFill", "grpFill"].includes(
+        n2.name.localName
+      )
+    )?.name.localName ?? null,
+    lineColor: readColor(line),
+    lineFillType: line?.children.find(
+      (n2) => n2.name.namespace === a && ["noFill", "solidFill", "gradFill", "pattFill"].includes(n2.name.localName)
+    )?.name.localName ?? null,
+    lineWidth: num(line, "w"),
+    unsupported: unknown,
+    placeholder: ph ? {
+      idx: num(ph, "idx") ?? 0,
+      type: attr(ph, "type") ?? "obj",
+      orient: attr(ph, "orient") ?? "horz",
+      sz: attr(ph, "sz") ?? "full"
+    } : null
+  };
+}
+var propertyOrder = [
+  "xfrm",
+  "prstGeom",
+  "custGeom",
+  "noFill",
+  "solidFill",
+  "gradFill",
+  "blipFill",
+  "pattFill",
+  "grpFill",
+  "ln",
+  "effectLst",
+  "effectDag",
+  "scene3d",
+  "sp3d",
+  "extLst"
+];
+function applyShapeUpdate(document, node, options) {
+  validateShapeOptions(options);
+  if (node.name.localName !== "sp" && Object.keys(options).length && Object.keys(options).every((key) => ["name", "title", "description", "altText"].includes(key))) {
+    const identity = nv(node);
+    const properties = identity && child(identity, "cNvPr");
+    if (!properties) unsupported2("Shape identity is required for metadata edits.");
+    return document.merge(properties, {
+      attributes: Object.entries(options).map(([key, value]) => ({
+        namespace: "",
+        localName: key === "description" || key === "altText" ? "descr" : key,
+        value
+      }))
+    });
+  }
+  if (node.name.localName !== "sp" && (!["pic", "cxnSp", "graphicFrame", "grpSp"].includes(node.name.localName) || Object.keys(options).some(
+    (key) => ![
+      "left",
+      "top",
+      "width",
+      "height",
+      "rotation",
+      "flipHorizontal",
+      "flipVertical"
+    ].includes(key)
+  )))
+    unsupported2("This object supports only position, size, rotation and flip edits.");
+  const p = node.name.namespace, a = drawing(node);
+  const at = (name, value) => ({ namespace: "", localName: name, value });
+  const ch = (namespace, order, upsert, remove = []) => ({
+    children: {
+      sequence: order.map((localName) => ({ namespace, localName })),
+      remove: remove.filter((localName) => !upsert.some((item) => item.name.localName === localName)).map((localName) => ({ namespace, localName })),
+      upsert
+    }
+  });
+  const u = (namespace, localName, merge) => ({
+    name: { namespace, localName },
+    merge
+  });
+  const nvEdits = [];
+  const attrs = [];
+  for (const [key, xmlKey] of [
+    ["name", "name"],
+    ["title", "title"],
+    ["description", "descr"],
+    ["altText", "descr"]
+  ])
+    if (options[key] !== void 0) attrs.push(at(xmlKey, options[key]));
+  if (attrs.length) nvEdits.push(u(p, "cNvPr", { attributes: attrs }));
+  if (options.locked !== void 0 || options.kind !== void 0) {
+    const lock = options.locked === void 0 ? {} : ch(
+      a,
+      ["spLocks", "extLst"],
+      [
+        u(a, "spLocks", {
+          attributes: [
+            at("noSelect", options.locked === null ? null : options.locked ? "1" : "0")
+          ]
+        })
+      ]
+    );
+    nvEdits.push(
+      u(p, "cNvSpPr", {
+        ...lock,
+        ...options.kind === void 0 ? {} : { attributes: [at("txBox", options.kind === "text-box" ? "1" : null)] }
+      })
+    );
+  }
+  const propEdits = [];
+  const removes = [];
+  const coords = [];
+  for (const [name, keys2] of [
+    [
+      "off",
+      [
+        ["left", "x"],
+        ["top", "y"]
+      ]
+    ],
+    [
+      "ext",
+      [
+        ["width", "cx"],
+        ["height", "cy"]
+      ]
+    ]
+  ]) {
+    const values3 = keys2.filter(([k]) => options[k] !== void 0).map(([k, v]) => at(v, String(emu(options[k]))));
+    if (values3.length) {
+      const existingProperties = props(node);
+      const existingTransform = node.name.localName === "graphicFrame" ? child(node, "xfrm") : existingProperties && child(existingProperties, "xfrm", a);
+      const existingPair = existingTransform && child(existingTransform, name, a);
+      for (const [key, attribute] of keys2) {
+        if (options[key] === void 0 && (!existingPair || attr(existingPair, attribute) === void 0)) {
+          if (name === "ext") invalid4("Creating dimensions requires both width and height.");
+          values3.push(at(attribute, "0"));
+        }
+      }
+    }
+    if (values3.length) coords.push(u(a, name, { attributes: values3 }));
+  }
+  const transformAttributes = [];
+  if (options.rotation !== void 0) {
+    const angle = Math.sign(options.rotation) * Math.round(Math.abs(options.rotation) * 6e4);
+    transformAttributes.push(at("rot", String((angle % 216e5 + 216e5) % 216e5)));
+  }
+  for (const [key, name] of [
+    ["flipHorizontal", "flipH"],
+    ["flipVertical", "flipV"]
+  ])
+    if (options[key] !== void 0) transformAttributes.push(at(name, options[key] ? "1" : "0"));
+  if (coords.length || transformAttributes.length)
+    propEdits.push(
+      u(a, "xfrm", {
+        ...ch(a, ["off", "ext", "chOff", "chExt"], coords),
+        attributes: transformAttributes
+      })
+    );
+  if (options.kind !== void 0) {
+    const key = preset(options.kind);
+    propEdits.push(
+      u(a, "prstGeom", {
+        attributes: [at("prst", key ? shapePresets[key] : "rect")],
+        ...ch(a, ["avLst"], [u(a, "avLst", {})])
+      })
+    );
+    removes.push("custGeom");
+  }
+  const fill = (color) => color === null || color === "solid" ? {} : ch(
+    a,
+    ["srgbClr", "schemeClr", "scrgbClr", "hslClr", "sysClr", "prstClr"],
+    [u(a, "srgbClr", { attributes: [at("val", color.toUpperCase())] })],
+    ["schemeClr", "scrgbClr", "hslClr", "sysClr", "prstClr"]
+  );
+  if (options.fill !== void 0) {
+    removes.push("noFill", "solidFill", "gradFill", "blipFill", "pattFill", "grpFill");
+    propEdits.push(u(a, options.fill === null ? "noFill" : "solidFill", fill(options.fill)));
+  }
+  if (options.lineColor !== void 0 || options.lineWidth !== void 0) {
+    const lineChildren = options.lineColor === void 0 ? {} : ch(
+      a,
+      [
+        "noFill",
+        "solidFill",
+        "gradFill",
+        "pattFill",
+        "prstDash",
+        "custDash",
+        "round",
+        "bevel",
+        "miter",
+        "headEnd",
+        "tailEnd",
+        "extLst"
+      ],
+      [u(a, options.lineColor === null ? "noFill" : "solidFill", fill(options.lineColor))],
+      ["noFill", "solidFill", "gradFill", "pattFill"]
+    );
+    propEdits.push(
+      u(a, "ln", {
+        ...lineChildren,
+        ...options.lineWidth === void 0 ? {} : {
+          attributes: [
+            at("w", options.lineWidth === null ? null : String(emu(options.lineWidth)))
+          ]
+        }
+      })
+    );
+  }
+  const top = [];
+  if (node.name.localName === "graphicFrame")
+    return document.merge(node, {
+      children: {
+        sequence: ["nvGraphicFramePr", "xfrm", "graphic", "extLst"].map((localName) => ({
+          namespace: localName === "graphic" ? a : p,
+          localName
+        })),
+        upsert: propEdits.map((edit) => u(p, "xfrm", edit.merge))
+      }
+    });
+  if (node.name.localName !== "sp") {
+    const existing = props(node);
+    if (!existing) unsupported2("Transform edits require existing shape properties.");
+    return document.merge(existing, ch(a, propertyOrder, propEdits));
+  }
+  if (nvEdits.length) top.push(u(p, "nvSpPr", ch(p, ["cNvPr", "cNvSpPr", "nvPr"], nvEdits)));
+  if (propEdits.length) top.push(u(p, "spPr", ch(a, propertyOrder, propEdits, removes)));
+  let updated = document.merge(node, ch(p, ["nvSpPr", "spPr", "style", "txBody", "extLst"], top));
+  if (options.text !== void 0) {
+    let locate2 = function(n) {
+      if (n === node) return true;
+      for (let i = 0; i < n.children.length; i++) {
+        path.push(i);
+        if (locate2(n.children[i])) return true;
+        path.pop();
+      }
+      return false;
+    };
+    var locate = locate2;
+    const path = [];
+    locate2(document.root);
+    const target = path.reduce((n, i) => n.children[i], updated.root);
+    let body = child(target, "txBody");
+    if (!body) {
+      const extensionIndex = target.children.findIndex(
+        (n) => n.name.namespace === p && n.name.localName === "extLst"
+      );
+      updated = updated.spliceChildren(
+        target,
+        extensionIndex < 0 ? target.children.length : extensionIndex,
+        0,
+        [`<p:txBody xmlns:p="${p}" xmlns:a="${a}"><a:bodyPr/><a:lstStyle/><a:p/></p:txBody>`]
+      );
+      body = child(
+        path.reduce((n, i) => n.children[i], updated.root),
+        "txBody"
+      );
+    }
+    updated = applyFrameFormatting(updated, body, { text: options.text });
+  }
+  if (options.adjustments !== void 0) {
+    const path = [];
+    const locate2 = (current) => {
+      if (current === node) return true;
+      for (let i = 0; i < current.children.length; i++) {
+        path.push(i);
+        if (locate2(current.children[i])) return true;
+        path.pop();
+      }
+      return false;
+    };
+    if (!locate2(document.root)) invalid4("Shape does not belong to its document.");
+    const target = path.reduce((current, i) => current.children[i], updated.root);
+    const adjustments = new AdjustmentCollection(
+      () => updated.subtree(target),
+      (xml) => {
+        if (!path.length) updated = xml;
+        else {
+          const parent = path.slice(0, -1).reduce((current, i) => current.children[i], updated.root);
+          updated = updated.spliceChildren(parent, path.at(-1), 1, [xml.markup(xml.root, true)]);
+        }
+      }
+    );
+    adjustments.replace(options.adjustments);
+  }
+  return updated;
+}
+function createShapeXml(kind, id, options, presentationNamespace = pns, limits = {}) {
+  validateShapeOptions({ ...options, kind }, true);
+  if (!Number.isInteger(id) || id < 1 || id > 4294967295)
+    invalid4("Shape identity must be a positive unsigned 32-bit integer.");
+  if (![pns, "http://purl.oclc.org/ooxml/presentationml/main"].includes(presentationNamespace))
+    invalid4();
+  const a = presentationNamespace === pns ? ans : "http://purl.oclc.org/ooxml/drawingml/main";
+  let doc = parseXmlPart(
+    new TextEncoder().encode(
+      `<p:sp xmlns:p="${presentationNamespace}" xmlns:a="${a}"><p:nvSpPr><p:cNvPr id="${id}" name="Shape ${id}"/><p:cNvSpPr/><p:nvPr/></p:nvSpPr><p:spPr/></p:sp>`
+    ),
+    limits
+  );
+  doc = applyShapeUpdate(doc, doc.root, { ...options, kind, text: options.text ?? "" });
+  return doc.markup(doc.root, true);
+}
+var Shape = class _Shape {
+  #snapshot;
+  #owner;
+  get #xml() {
+    return this.#owner?.read() ?? this.#snapshot;
+  }
+  set #xml(xml) {
+    if (this.#owner) this.#owner.write(xml);
+    else this.#snapshot = xml;
+  }
+  #textFrame;
+  #adjustments;
+  constructor(xml, owner) {
+    if (!["sp", "grpSp"].includes(xml.root.name.localName) && (new.target === _Shape || !["pic", "graphicFrame"].includes(xml.root.name.localName)))
+      invalid4();
+    drawing(xml.root);
+    this.#snapshot = xml;
+    this.#owner = owner;
+  }
+  get xml() {
+    return this.#xml;
+  }
+  get element() {
+    return this.#xml.root;
+  }
+  get part() {
+    void this.element;
+    if (!this.#owner?.part) throw new PropertyAccessError("Shape has no package part.");
+    return this.#owner.part;
+  }
+  get shape_id() {
+    return readShape(this.element).shapeId;
+  }
+  get name() {
+    return readShape(this.element).name;
+  }
+  set name(v) {
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { name: v });
+  }
+  get title() {
+    return readShape(this.element).title;
+  }
+  set title(v) {
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { title: v });
+  }
+  get description() {
+    return readShape(this.element).description;
+  }
+  set description(v) {
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { description: v });
+  }
+  get locked() {
+    return readShape(this.element).locked;
+  }
+  set locked(v) {
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { locked: v });
+  }
+  get left() {
+    const v = readShape(this.element).left;
+    return v === null ? null : new Length(v);
+  }
+  set left(v) {
+    if (!(v instanceof Length)) invalid4();
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { left: v });
+  }
+  get top() {
+    const v = readShape(this.element).top;
+    return v === null ? null : new Length(v);
+  }
+  set top(v) {
+    if (!(v instanceof Length)) invalid4();
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { top: v });
+  }
+  get width() {
+    const v = readShape(this.element).width;
+    return v === null ? null : new Length(v);
+  }
+  set width(v) {
+    if (!(v instanceof Length)) invalid4();
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { width: v });
+  }
+  get height() {
+    const v = readShape(this.element).height;
+    return v === null ? null : new Length(v);
+  }
+  set height(v) {
+    if (!(v instanceof Length)) invalid4();
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { height: v });
+  }
+  get rotation() {
+    return readShape(this.element).rotation;
+  }
+  set rotation(v) {
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { rotation: v });
+  }
+  get flip_horizontal() {
+    return readShape(this.element).flipHorizontal;
+  }
+  set flip_horizontal(v) {
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { flipHorizontal: v });
+  }
+  get flip_vertical() {
+    return readShape(this.element).flipVertical;
+  }
+  set flip_vertical(v) {
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { flipVertical: v });
+  }
+  get is_placeholder() {
+    return readShape(this.element).placeholder !== null;
+  }
+  get placeholder_format() {
+    const ph = readShape(this.element).placeholder;
+    if (!ph) invalid4("Shape is not a placeholder.");
+    return { ...ph, type: PP_PLACEHOLDER_TYPE.from_xml(ph.type) };
+  }
+  get adjustments() {
+    return this.#adjustments ??= new AdjustmentCollection(
+      () => this.#xml,
+      (xml) => {
+        this.#xml = xml;
+      }
+    );
+  }
+  get auto_shape_type() {
+    const kind = readShape(this.element).kind;
+    if (!kind || kind === "text-box") invalid4("Shape has no supported preset type.");
+    return MSO_AUTO_SHAPE_TYPE[kind];
+  }
+  get has_text_frame() {
+    return this.element.name.localName === "sp";
+  }
+  get text_frame() {
+    if (!this.has_text_frame) unsupported2("This shape has no text frame.");
+    if (this.#textFrame) return this.#textFrame;
+    if (!child(this.element, "txBody"))
+      this.#xml = applyShapeUpdate(this.#xml, this.element, { text: "" });
+    let owner;
+    let cached;
+    const read = () => {
+      if (owner === this.#xml && cached) return cached;
+      const body = child(this.element, "txBody");
+      if (!body) unsupported2("Text frame no longer exists.");
+      cached = this.#xml.subtree(body);
+      owner = this.#xml;
+      return cached;
+    };
+    const write = (xml) => {
+      const body = child(this.element, "txBody");
+      if (!body) unsupported2("Text frame no longer exists.");
+      this.#xml = this.#xml.spliceChildren(this.element, this.element.children.indexOf(body), 1, [
+        xml.markup(xml.root, true)
+      ]);
+    };
+    const extents = () => {
+      const shape = readShape(this.element);
+      return shape.width === null || shape.height === null ? void 0 : { width: shape.width / 12700, height: shape.height / 12700 };
+    };
+    this.#textFrame = new TextFrame(read(), extents(), { read, write, extents, parent: this });
+    if (this.#owner?.hyperlink) {
+      const hyperlink = this.#owner.hyperlink;
+      textLinkCapabilities.set(
+        this.#textFrame,
+        (path) => hyperlink(() => {
+          const body = child(this.element, "txBody");
+          if (!body) throw new InvalidHandleError();
+          return [this.element.children.indexOf(body), ...path()];
+        })
+      );
+    }
+    return this.#textFrame;
+  }
+  get fill() {
+    return new FillFormat(
+      () => this.#xml,
+      (update) => {
+        this.#xml = applyShapeUpdate(this.#xml, this.element, update);
+      },
+      false,
+      (transform) => {
+        this.#xml = transform(this.#xml, this.element);
+      }
+    );
+  }
+  get shadow() {
+    return new ShadowFormat(
+      () => this.#xml,
+      (transform) => {
+        this.#xml = transform(this.#xml, this.element);
+      }
+    );
+  }
+  get line() {
+    return new LineFormat(
+      () => this.#xml,
+      (update) => {
+        this.#xml = applyShapeUpdate(this.#xml, this.element, update);
+      },
+      (transform) => {
+        this.#xml = transform(this.#xml, this.element);
+      }
+    );
+  }
+  get shape_type() {
+    const record = readShape(this.element);
+    if (record.placeholder) return MSO_SHAPE_TYPE.PLACEHOLDER;
+    if (record.kind === "text-box") return MSO_SHAPE_TYPE.TEXT_BOX;
+    const pr = props(this.element);
+    if (pr && child(pr, "custGeom", drawing(this.element))) return MSO_SHAPE_TYPE.FREEFORM;
+    if (record.kind) return MSO_SHAPE_TYPE.AUTO_SHAPE;
+    unsupported2("Shape category is unsupported.");
+  }
+  get has_chart() {
+    readShape(this.element);
+    return false;
+  }
+  get has_table() {
+    readShape(this.element);
+    return false;
+  }
+  get text() {
+    return this.text_frame.text;
+  }
+  set text(v) {
+    this.text_frame.text = v;
+  }
+};
+var ShapeColorFormat = class {
+  constructor(read, edit, owner) {
+    this.read = read;
+    this.edit = edit;
+    this.owner = owner;
+  }
+  read;
+  edit;
+  owner;
+  get type() {
+    const type = readRunColor(this.owner(this.read().root))?.type;
+    return type === void 0 ? null : MSO_COLOR_TYPE[type];
+  }
+  get rgb() {
+    const v = readRunColor(this.owner(this.read().root))?.rgb;
+    if (!v) throw new PropertyAccessError("RGB color is unavailable.");
+    return RGBColor.from_string(v);
+  }
+  set rgb(v) {
+    if (!(v instanceof RGBColor)) invalid4();
+    this.edit((doc, node) => {
+      const owner = this.owner(node);
+      return doc.merge(owner, colorMerge(v.toString(), owner.name.namespace));
+    });
+  }
+  get theme_color() {
+    const c = readRunColor(this.owner(this.read().root));
+    if (!c) throw new PropertyAccessError("Theme color is unavailable.");
+    return c.theme === null ? MSO_THEME_COLOR_INDEX.NOT_THEME_COLOR : MSO_THEME_COLOR_INDEX.from_xml(c.theme);
+  }
+  set theme_color(v) {
+    const theme = MSO_THEME_COLOR_INDEX.to_xml(v);
+    this.edit((doc, node) => {
+      const owner = this.owner(node);
+      return doc.merge(owner, colorMerge({ theme }, owner.name.namespace));
+    });
+  }
+  get brightness() {
+    return readRunColor(this.owner(this.read().root))?.brightness ?? 0;
+  }
+  set brightness(v) {
+    this.edit((doc, node) => {
+      const owner = this.owner(node), color = owner.children.find(
+        (n) => n.name.namespace === owner.name.namespace && ["srgbClr", "schemeClr", "scrgbClr", "hslClr", "sysClr", "prstClr"].includes(
+          n.name.localName
+        )
+      );
+      if (!color) invalid4("Brightness requires a color.");
+      return doc.merge(color, colorBrightnessMerge(v, color.name.namespace));
+    });
+  }
+  get opacity() {
+    return readDrawingColor(this.owner(this.read().root))?.opacity ?? null;
+  }
+  set opacity(v) {
+    if (v !== null && (!Number.isFinite(v) || v < 0 || v > 1)) invalid4();
+    this.edit((doc, node) => {
+      const owner = this.owner(node), color = owner.children.find(
+        (n) => n.name.namespace === owner.name.namespace && ["srgbClr", "schemeClr", "scrgbClr", "hslClr", "sysClr", "prstClr"].includes(
+          n.name.localName
+        )
+      );
+      if (!color) invalid4("Alpha requires a color.");
+      return doc.merge(color, {
+        children: {
+          sequence: [{ namespace: color.name.namespace, localName: "alpha" }],
+          remove: v === null ? [{ namespace: color.name.namespace, localName: "alpha" }] : [],
+          upsert: v === null ? [] : [
+            {
+              name: { namespace: color.name.namespace, localName: "alpha" },
+              merge: {
+                attributes: [
+                  { namespace: "", localName: "val", value: String(Math.round(v * 1e5)) }
+                ]
+              }
+            }
+          ]
+        }
+      });
+    });
+  }
+};
+function fillPosition(owner, fill, namespace) {
+  if (fill) return owner.children.indexOf(fill);
+  const after = owner.children.findIndex(
+    (node) => node.name.namespace === namespace && [
+      "ln",
+      "prstDash",
+      "custDash",
+      "round",
+      "bevel",
+      "miter",
+      "headEnd",
+      "tailEnd",
+      "effectLst",
+      "effectDag",
+      "scene3d",
+      "sp3d",
+      "extLst"
+    ].includes(node.name.localName)
+  );
+  return after < 0 ? owner.children.length : after;
+}
+function gradientNodes(owner) {
+  return owner.children.filter(
+    (node) => node.name.namespace === owner.name.namespace && node.name.localName === "gs"
+  );
+}
+var FillFormat = class {
+  constructor(read, update, line, edit, fillOwner) {
+    this.read = read;
+    this.update = update;
+    this.line = line;
+    this.edit = edit;
+    this.fillOwner = fillOwner;
+  }
+  read;
+  update;
+  line;
+  edit;
+  fillOwner;
+  owner(node) {
+    if (this.fillOwner) return this.fillOwner(node);
+    const pr = props(node);
+    const result = this.line ? pr && child(pr, "ln", drawing(node)) : pr;
+    return result;
+  }
+  fill(node) {
+    const owner = this.owner(node);
+    return owner?.children.find(
+      (n) => n.name.namespace === drawing(node) && ["solidFill", "gradFill", "pattFill", "blipFill", "noFill", "grpFill"].includes(
+        n.name.localName
+      )
+    );
+  }
+  change(transform) {
+    if (!this.edit) unsupported2("This view does not support extended drawing edits.");
+    this.edit(transform);
+  }
+  apply(value) {
+    this.change((document, node) => {
+      const owner = this.owner(node);
+      if (!owner) invalid4("Fill owner is unavailable.");
+      return applyDrawingFill(document, owner, value);
+    });
+  }
+  get type() {
+    const f = this.fill(this.read().root);
+    return f ? { solidFill: 1, pattFill: 2, gradFill: 3, blipFill: 6, noFill: 5, grpFill: 101 }[f.name.localName] ?? null : null;
+  }
+  solid() {
+    if (this.fillOwner) {
+      if (this.type !== 1)
+        this.change((doc, node) => {
+          const owner = this.owner(node), fill = this.fill(node);
+          return doc.spliceChildren(owner, fillPosition(owner, fill, drawing(node)), fill ? 1 : 0, [
+            `<a:solidFill xmlns="${escaped(doc.resolveNamespace(owner, "") ?? "")}" xmlns:a="${drawing(node)}"/>`
+          ]);
+        });
+      return;
+    }
+    if (this.type !== 1) {
+      if (!this.update) unsupported2("This view does not support drawing edits.");
+      this.update(this.line ? { lineColor: "solid" } : { fill: "solid" });
+    }
+  }
+  background() {
+    if (this.fillOwner) {
+      this.change((doc, node) => {
+        const owner = this.owner(node), fill = this.fill(node);
+        return doc.spliceChildren(owner, fillPosition(owner, fill, drawing(node)), fill ? 1 : 0, [
+          `<a:noFill xmlns="${escaped(doc.resolveNamespace(owner, "") ?? "")}" xmlns:a="${drawing(node)}"/>`
+        ]);
+      });
+      return;
+    }
+    if (!this.update) unsupported2("This view does not support drawing edits.");
+    this.update(this.line ? { lineColor: null } : { fill: null });
+  }
+  gradient() {
+    if (this.type === 3) return;
+    if (!this.owner(this.read().root)) this.solid();
+    this.change((doc, node) => {
+      const owner = this.owner(node), fill = this.fill(node), a = drawing(node);
+      return doc.spliceChildren(owner, fillPosition(owner, fill, drawing(node)), fill ? 1 : 0, [
+        `<a:gradFill xmlns="${escaped(doc.resolveNamespace(owner, "") ?? "")}" xmlns:a="${a}" rotWithShape="1"><a:gsLst><a:gs pos="0"><a:schemeClr val="accent1"><a:tint val="100000"/><a:shade val="100000"/><a:satMod val="130000"/></a:schemeClr></a:gs><a:gs pos="100000"><a:schemeClr val="accent1"><a:tint val="50000"/><a:shade val="100000"/><a:satMod val="350000"/></a:schemeClr></a:gs></a:gsLst><a:lin ang="16200000" scaled="1"/></a:gradFill>`
+      ]);
+    });
+  }
+  patterned() {
+    if (this.type === 2) return;
+    if (!this.owner(this.read().root)) this.solid();
+    this.change((doc, node) => {
+      const owner = this.owner(node), fill = this.fill(node);
+      return doc.spliceChildren(owner, fillPosition(owner, fill, drawing(node)), fill ? 1 : 0, [
+        `<a:pattFill xmlns="${escaped(doc.resolveNamespace(owner, "") ?? "")}" xmlns:a="${drawing(node)}"/>`
+      ]);
+    });
+  }
+  get gradient_angle() {
+    const fill = this.fill(this.read().root);
+    if (fill?.name.localName !== "gradFill" || child(fill, "path"))
+      throw new PropertyAccessError("Linear gradient angle is unavailable.");
+    const lin = child(fill, "lin");
+    return lin ? ((360 - Number(attr(lin, "ang")) / 6e4) % 360 + 360) % 360 : null;
+  }
+  set gradient_angle(v) {
+    void this.gradient_angle;
+    if (!Number.isFinite(v) || Math.abs(v) > 36e4) invalid4();
+    this.change((doc, node) => {
+      const fill = this.fill(node);
+      return doc.merge(fill, {
+        children: {
+          sequence: ["gsLst", "lin", "path", "tileRect"].map((localName) => ({
+            namespace: fill.name.namespace,
+            localName
+          })),
+          upsert: [
+            {
+              name: { namespace: fill.name.namespace, localName: "lin" },
+              merge: {
+                attributes: [
+                  {
+                    namespace: "",
+                    localName: "ang",
+                    value: String(
+                      Math.round(((360 - v % 360) % 360 + 360) % 360 * 6e4) % 216e5
+                    )
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      });
+    });
+  }
+  get gradient_stops() {
+    if (this.type !== 3) throw new PropertyAccessError("Gradient stops are unavailable.");
+    if (!child(this.fill(this.read().root), "gsLst"))
+      this.change((doc, node) => {
+        const fill = this.fill(node);
+        return doc.spliceChildren(fill, 0, 0, [
+          `<a:gsLst xmlns:a="${fill.name.namespace}"><a:gs pos="0"><a:schemeClr val="accent1"><a:tint val="100000"/><a:shade val="100000"/><a:satMod val="130000"/></a:schemeClr></a:gs><a:gs pos="100000"><a:schemeClr val="accent1"><a:tint val="50000"/><a:shade val="100000"/><a:satMod val="350000"/></a:schemeClr></a:gs></a:gsLst>`
+        ]);
+      });
+    return new GradientStops(
+      this.read,
+      (t) => this.change(t),
+      (node) => child(this.fill(node), "gsLst")
+    );
+  }
+  get pattern() {
+    if (this.type !== 2) throw new PropertyAccessError("Pattern is unavailable.");
+    const token = attr(this.fill(this.read().root), "prst");
+    const key = Object.keys(patternTokens).find((k) => patternTokens[Number(k)] === token);
+    return key === void 0 ? null : Number(key);
+  }
+  set pattern(v) {
+    if (this.type !== 2) throw new PropertyAccessError("Pattern is unavailable.");
+    if (v !== null && (typeof v !== "number" || !Object.hasOwn(patternTokens, v))) invalid4();
+    this.change(
+      (doc, node) => doc.merge(this.fill(node), {
+        attributes: [
+          { namespace: "", localName: "prst", value: v === null ? null : patternTokens[v] }
+        ]
+      })
+    );
+  }
+  color(back) {
+    if (this.type !== 1 && this.type !== 2 || back && this.type !== 2)
+      throw new PropertyAccessError("Fill color is unavailable.");
+    if (this.type === 2) {
+      const tag = back ? "bgClr" : "fgClr";
+      if (!child(this.fill(this.read().root), tag))
+        this.change((doc, node) => {
+          const fill = this.fill(node);
+          const afterForeground = fill.children.findIndex(
+            (n) => n.name.namespace !== fill.name.namespace || n.name.localName !== "fgClr"
+          );
+          return doc.spliceChildren(
+            fill,
+            back ? afterForeground < 0 ? fill.children.length : afterForeground : 0,
+            0,
+            [
+              `<a:${tag} xmlns:a="${fill.name.namespace}"><a:srgbClr val="${back ? "FFFFFF" : "000000"}"/></a:${tag}>`
+            ]
+          );
+        });
+    }
+    return new ShapeColorFormat(
+      this.read,
+      (t) => this.change(t),
+      (node) => {
+        const f = this.fill(node);
+        return f.name.localName === "pattFill" ? child(f, back ? "bgClr" : "fgClr") : f;
+      }
+    );
+  }
+  get fore_color() {
+    return this.color(false);
+  }
+  get back_color() {
+    return this.color(true);
+  }
+};
+var GradientStop = class _GradientStop {
+  constructor(read, edit, owner, index) {
+    this.read = read;
+    this.edit = edit;
+    this.owner = owner;
+    this.index = index;
+  }
+  read;
+  edit;
+  owner;
+  index;
+  node(shape) {
+    const n = gradientNodes(this.owner(shape))[this.index];
+    if (!n) invalid4("Gradient stop is unavailable.");
+    return n;
+  }
+  get element() {
+    return createXmlElementView(
+      {
+        read: this.read,
+        commit: (expected, next) => this.edit((document) => {
+          if (document !== expected) throw new InvalidHandleError();
+          return next;
+        })
+      },
+      this.node(this.read().root)
+    );
+  }
+  equals(other) {
+    return other instanceof _GradientStop && this.node(this.read().root) === other.node(other.read().root);
+  }
+  get position() {
+    return Number(attr(this.node(this.read().root), "pos")) / 1e5;
+  }
+  set position(v) {
+    if (!Number.isFinite(v) || v < 0 || v > 1) invalid4();
+    this.edit(
+      (doc, node) => doc.merge(this.node(node), {
+        attributes: [{ namespace: "", localName: "pos", value: String(Math.round(v * 1e5)) }]
+      })
+    );
+  }
+  get color() {
+    return new ShapeColorFormat(this.read, this.edit, (node) => this.node(node));
+  }
+};
+var GradientStops = class {
+  constructor(read, edit, owner) {
+    this.read = read;
+    this.edit = edit;
+    this.owner = owner;
+    return new Proxy(this, {
+      get(target, key) {
+        if (typeof key === "string" && key !== "" && String(Number(key)) === key) {
+          if (Number(key) < 0) throw new IndexError("Gradient stop index is out of range.");
+          return target.at(Number(key));
+        }
+        const value = Reflect.get(target, key, target);
+        return typeof value === "function" ? value.bind(target) : value;
+      },
+      set(target, key, value, receiver) {
+        if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+          invalid4("Gradient stops cannot replace entries.");
+        return Reflect.set(target, key, value, receiver);
+      },
+      defineProperty(target, key, descriptor) {
+        if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+          invalid4("Gradient stops cannot replace entries.");
+        return Reflect.defineProperty(target, key, descriptor);
+      },
+      deleteProperty(target, key) {
+        if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+          invalid4("Gradient stops cannot remove entries.");
+        return Reflect.deleteProperty(target, key);
+      }
+    });
+  }
+  read;
+  edit;
+  owner;
+  cache = /* @__PURE__ */ new Map();
+  get length() {
+    return gradientNodes(this.owner(this.read().root)).length;
+  }
+  at(index) {
+    if (!Number.isInteger(index) || index < -this.length || index >= this.length)
+      throw new IndexError("Gradient stop index is out of range.");
+    const i = index < 0 ? index + this.length : index;
+    let stop = this.cache.get(i);
+    if (!stop) {
+      stop = new GradientStop(this.read, this.edit, this.owner, i);
+      this.cache.set(i, stop);
+    }
+    return stop;
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.length; i++) yield this.at(i);
+  }
+  includes(value) {
+    return Array.from(this).some((stop) => stop.equals(value));
+  }
+  count(value) {
+    return this.includes(value) ? 1 : 0;
+  }
+  index(value, start = 0, stop = this.length) {
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(stop))
+      throw new ValueError("Gradient stop search bounds must be integers.");
+    const lower = Math.max(0, start < 0 ? this.length + start : start);
+    const upper = Math.min(this.length, stop < 0 ? this.length + stop : stop);
+    for (let i = lower; i < upper; i++) if (this.at(i).equals(value)) return i;
+    throw new ValueError("Gradient stop is not in this collection.");
+  }
+  reversed() {
+    return Array.from(this).reverse();
+  }
+};
+var ShadowFormat = class {
+  constructor(read, edit) {
+    this.read = read;
+    this.edit = edit;
+  }
+  read;
+  edit;
+  get inherit() {
+    return readDrawingFormat(this.read().root).shadowInherit;
+  }
+  set inherit(value) {
+    this.edit((doc, node) => applyDrawingUpdate(doc, node, { shadowInherit: value }));
+  }
+};
+var LineFormat = class {
+  constructor(read, update, edit) {
+    this.read = read;
+    this.update = update;
+    this.edit = edit;
+  }
+  read;
+  update;
+  edit;
+  get width() {
+    return new Length(readDrawingFormat(this.read().root).line.width ?? 0);
+  }
+  set width(value) {
+    if (value !== null && !(value instanceof Length)) invalid4();
+    this.update({ lineWidth: value });
+  }
+  get fill() {
+    return new FillFormat(this.read, this.update, true, this.edit);
+  }
+  get color() {
+    if (this.fill.type !== 1) this.fill.solid();
+    return this.fill.fore_color;
+  }
+  get dash_style() {
+    const token = readDrawingFormat(this.read().root).line.dash;
+    const key = Object.keys(dashTokens).find((k) => dashTokens[Number(k)] === token);
+    return key === void 0 ? null : Number(key);
+  }
+  set dash_style(v) {
+    if (v !== null && (typeof v !== "number" || !Object.hasOwn(dashTokens, v))) invalid4();
+    if (!this.edit) unsupported2("Extended line editing is unavailable.");
+    this.edit(
+      (doc, node) => applyDrawingUpdate(doc, node, { line: { dash: v === null ? null : dashTokens[v] } })
+    );
+  }
+};
+
+// packages/safe-bash-presentation-engine/src/text-paragraphs.ts
+import { SaxesParser as SaxesParser2 } from "saxes";
+
+// packages/safe-bash-presentation-engine/src/paragraph-alignment.ts
+var AlignmentValue = /* @__PURE__ */ ((AlignmentValue2) => {
+  AlignmentValue2[AlignmentValue2["LEFT"] = 1] = "LEFT";
+  AlignmentValue2[AlignmentValue2["CENTER"] = 2] = "CENTER";
+  AlignmentValue2[AlignmentValue2["RIGHT"] = 3] = "RIGHT";
+  AlignmentValue2[AlignmentValue2["JUSTIFY"] = 4] = "JUSTIFY";
+  AlignmentValue2[AlignmentValue2["DISTRIBUTE"] = 5] = "DISTRIBUTE";
+  AlignmentValue2[AlignmentValue2["THAI_DISTRIBUTE"] = 6] = "THAI_DISTRIBUTE";
+  AlignmentValue2[AlignmentValue2["JUSTIFY_LOW"] = 7] = "JUSTIFY_LOW";
+  AlignmentValue2[AlignmentValue2["MIXED"] = -2] = "MIXED";
+  return AlignmentValue2;
+})(AlignmentValue || {});
+var alignmentMetadata = [
+  { name: "LEFT", value: 1, xml_value: "l" },
+  { name: "CENTER", value: 2, xml_value: "ctr" },
+  { name: "RIGHT", value: 3, xml_value: "r" },
+  { name: "JUSTIFY", value: 4, xml_value: "just" },
+  { name: "DISTRIBUTE", value: 5, xml_value: "dist" },
+  { name: "THAI_DISTRIBUTE", value: 6, xml_value: "thaiDist" },
+  { name: "JUSTIFY_LOW", value: 7, xml_value: "justLow" },
+  { name: "MIXED", value: -2, xml_value: null }
+].map((value) => Object.freeze(value));
+function invalid5() {
+  throw new ValueError("Invalid paragraph alignment value.");
+}
+var PP_PARAGRAPH_ALIGNMENT = Object.freeze(
+  Object.assign(AlignmentValue, {
+    metadata(value) {
+      const found = alignmentMetadata.find((item) => item.value === value);
+      return found ?? invalid5();
+    },
+    from_xml(xml_value) {
+      const found = alignmentMetadata.find(
+        (item) => item.xml_value !== null && item.xml_value === xml_value
+      );
+      return found?.value ?? invalid5();
+    },
+    to_xml(value) {
+      const found = alignmentMetadata.find((item) => item.value === value);
+      return found?.xml_value ?? invalid5();
+    },
+    validate(value) {
+      if (!alignmentMetadata.some((item) => item.value === value && item.xml_value !== null))
+        invalid5();
+    }
+  })
+);
+
+// packages/safe-bash-presentation-engine/src/text-paragraphs.ts
+var paragraphAlignments = [
+  "left",
+  "center",
+  "right",
+  "justify",
+  "distributed",
+  "thaiDistributed",
+  "justifyLow"
+];
+var paragraphNumberingSchemes = [
+  "alphaLcParenBoth",
+  "alphaUcParenBoth",
+  "alphaLcParenR",
+  "alphaUcParenR",
+  "alphaLcPeriod",
+  "alphaUcPeriod",
+  "arabicParenBoth",
+  "arabicParenR",
+  "arabicPeriod",
+  "arabicPlain",
+  "romanLcParenBoth",
+  "romanUcParenBoth",
+  "romanLcParenR",
+  "romanUcParenR",
+  "romanLcPeriod",
+  "romanUcPeriod",
+  "circleNumDbPlain",
+  "circleNumWdBlackPlain",
+  "circleNumWdWhitePlain",
+  "arabicDbPeriod",
+  "arabicDbPlain",
+  "ea1ChsPeriod",
+  "ea1ChsPlain",
+  "ea1ChtPeriod",
+  "ea1ChtPlain",
+  "ea1JpnChsDbPeriod",
+  "ea1JpnKorPlain",
+  "ea1JpnKorPeriod",
+  "arabic1Minus",
+  "arabic2Minus",
+  "hebrew2Minus",
+  "thaiAlphaPeriod",
+  "thaiAlphaParenR",
+  "thaiAlphaParenBoth",
+  "thaiNumPeriod",
+  "thaiNumParenR",
+  "thaiNumParenBoth",
+  "hindiAlphaPeriod",
+  "hindiNumPeriod",
+  "hindiNumParenR",
+  "hindiAlpha1Period"
+];
+var formatKeys = [
+  "alignment",
+  "marginLeft",
+  "marginRight",
+  "indent",
+  "defaultTabSize",
+  "lineSpacing",
+  "spaceBefore",
+  "spaceAfter",
+  "level",
+  "rtl",
+  "bullet",
+  "tabs"
+];
+var alignmentTokens = ["l", "ctr", "r", "just", "dist", "thaiDist", "justLow"];
+function alignmentIndex(value) {
+  return typeof value === "number" ? value - 1 : paragraphAlignments.includes(value) ? paragraphAlignments.indexOf(value) : Number(PP_PARAGRAPH_ALIGNMENT[value]) - 1;
+}
+function invalid6() {
+  throw new OfficeError("invalid-value", "Invalid paragraph formatting options.", "usage");
+}
+function object(value, keys2) {
+  return !!value && typeof value === "object" && [Object.prototype, null].includes(Object.getPrototypeOf(value)) && Object.keys(value).every((k) => keys2.includes(k));
+}
+function number(value, min, max) {
+  return typeof value === "number" && Number.isFinite(value) && value >= min && value <= max;
+}
+function validateTextParagraphOptions(options) {
+  if (!object(options, [...formatKeys, "paragraph", "all", "allowEmpty", "scope", "select", "shape"]))
+    invalid6();
+  const { scope, select, shape } = options;
+  validateTextReadingOptions({
+    ...scope === void 0 ? {} : { scope },
+    ...select === void 0 ? {} : { select },
+    ...shape === void 0 ? {} : { shape }
+  });
+  if (!formatKeys.some((k) => options[k] !== void 0)) invalid6();
+  if (options.paragraph !== void 0 && (!Number.isSafeInteger(options.paragraph) || options.paragraph < 0))
+    invalid6();
+  for (const key of ["all", "allowEmpty"])
+    if (options[key] !== void 0 && typeof options[key] !== "boolean") invalid6();
+  for (const key of ["rtl"])
+    if (options[key] != null && typeof options[key] !== "boolean") invalid6();
+  if (options.alignment != null && !alignmentTokens[alignmentIndex(options.alignment)]) invalid6();
+  for (const key of ["marginLeft", "marginRight", "indent", "defaultTabSize"])
+    if (options[key] != null && !number(options[key], key === "indent" ? -51206400 / 12700 : 0, 51206400 / 12700))
+      invalid6();
+  for (const key of ["spaceBefore", "spaceAfter"])
+    if (options[key] != null && !number(options[key], 0, 20116800 / 100)) invalid6();
+  if (options.level != null && (!Number.isInteger(options.level) || !number(options.level, 0, 8)))
+    invalid6();
+  if (options.lineSpacing != null) {
+    const s = options.lineSpacing;
+    if (!object(s, ["unit", "value"]) || !["pt", "multiple"].includes(s.unit) || !number(s.value, 0, s.unit === "pt" ? 201168 : 132))
+      invalid6();
+  }
+  if (options.bullet != null) {
+    const b = options.bullet;
+    if (!object(b, ["kind", "character", "scheme", "startAt"])) invalid6();
+    if (b.kind === "none") {
+      if (Object.keys(b).length !== 1) invalid6();
+    } else if (b.kind === "character") {
+      if (Object.keys(b).some((k) => !["kind", "character"].includes(k)) || typeof b.character !== "string" || Array.from(b.character).length !== 1 || b.character.codePointAt(0) < 32 || b.character.codePointAt(0) >= 55296 && b.character.codePointAt(0) <= 57343 || [65534, 65535].includes(b.character.codePointAt(0)))
+        invalid6();
+    } else if (b.kind === "numbered") {
+      if (Object.keys(b).some((k) => !["kind", "scheme", "startAt"].includes(k)) || !paragraphNumberingSchemes.includes(b.scheme) || b.startAt !== void 0 && (!Number.isInteger(b.startAt) || !number(b.startAt, 1, 32767)))
+        invalid6();
+    } else invalid6();
+  }
+  if (options.tabs != null) {
+    if (!Array.isArray(options.tabs) || options.tabs.length > 1e4) invalid6();
+    let previous = -1;
+    for (const tab of options.tabs) {
+      if (!object(tab, ["position", "alignment"]) || !number(tab.position, 0, 51206400 / 12700) || !["left", "center", "right", "decimal"].includes(tab.alignment) || Math.round(tab.position * 12700) <= previous)
+        invalid6();
+      previous = Math.round(tab.position * 12700);
+    }
+  }
+}
+var sequence = [
+  "lnSpc",
+  "spcBef",
+  "spcAft",
+  "buClrTx",
+  "buClr",
+  "buSzTx",
+  "buSzPct",
+  "buSzPts",
+  "buFontTx",
+  "buFont",
+  "buNone",
+  "buAutoNum",
+  "buChar",
+  "buBlip",
+  "tabLst",
+  "defRPr",
+  "extLst"
+];
+function paragraphPropertiesMerge(options, namespace) {
+  const name = (localName) => ({ namespace, localName });
+  const attributes = [];
+  for (const [key, localName] of Object.entries({
+    alignment: "algn",
+    marginLeft: "marL",
+    marginRight: "marR",
+    indent: "indent",
+    defaultTabSize: "defTabSz",
+    level: "lvl",
+    rtl: "rtl"
+  })) {
+    const value = options[key];
+    if (value === void 0) continue;
+    attributes.push({
+      namespace: "",
+      localName,
+      value: value === null ? null : key === "alignment" ? alignmentTokens[alignmentIndex(value)] : key === "rtl" ? value ? "1" : "0" : String(
+        ["marginLeft", "marginRight", "indent", "defaultTabSize"].includes(key) ? Math.sign(Number(value)) * Math.round(Math.abs(Number(value)) * 12700) : value
+      )
+    });
+  }
+  const remove = [];
+  const upsert = [];
+  for (const [key, local] of [
+    ["lineSpacing", "lnSpc"],
+    ["spaceBefore", "spcBef"],
+    ["spaceAfter", "spcAft"]
+  ]) {
+    const value = options[key];
+    if (value === void 0) continue;
+    if (value === null) {
+      remove.push(name(local));
+      continue;
+    }
+    const spacing = typeof value === "number" ? { unit: "pt", value } : value;
+    const child2 = spacing.unit === "pt" ? "spcPts" : "spcPct";
+    upsert.push({
+      name: name(local),
+      merge: {
+        children: {
+          sequence: [name("spcPct"), name("spcPts")],
+          remove: [name(child2 === "spcPts" ? "spcPct" : "spcPts")],
+          upsert: [
+            {
+              name: name(child2),
+              merge: {
+                attributes: [
+                  {
+                    namespace: "",
+                    localName: "val",
+                    value: String(
+                      Math.round(spacing.value * (spacing.unit === "pt" ? 100 : 1e5))
+                    )
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      }
+    });
+  }
+  if (options.bullet !== void 0) {
+    const b = options.bullet;
+    const selected = b?.kind === "none" ? "buNone" : b?.kind === "character" ? "buChar" : b?.kind === "numbered" ? "buAutoNum" : null;
+    remove.push(
+      ...["buNone", "buAutoNum", "buChar", "buBlip"].filter((n) => n !== selected).map(name)
+    );
+    if (b) {
+      const local = b.kind === "none" ? "buNone" : b.kind === "character" ? "buChar" : "buAutoNum";
+      const values3 = b.kind === "none" ? {} : b.kind === "character" ? { char: b.character } : {
+        type: b.scheme,
+        ...b.startAt === void 0 ? {} : { startAt: String(b.startAt) }
+      };
+      upsert.push({
+        name: name(local),
+        merge: {
+          attributes: Object.entries(values3).map(([localName, value]) => ({
+            namespace: "",
+            localName,
+            value
+          }))
+        }
+      });
+    }
+  }
+  if (options.tabs !== void 0) {
+    if (options.tabs === null) remove.push(name("tabLst"));
+    else upsert.push({ name: name("tabLst"), merge: {} });
+  }
+  return { attributes, children: { sequence: sequence.map(name), remove, upsert } };
+}
+function applyParagraphFormatting(document, node, options) {
+  validateTextParagraphOptions(options);
+  if (node.name.localName !== "p" || ![
+    "http://schemas.openxmlformats.org/drawingml/2006/main",
+    "http://purl.oclc.org/ooxml/drawingml/main"
+  ].includes(node.name.namespace))
+    invalid6();
+  const path = [];
+  function locate(current) {
+    if (current === node) return true;
+    for (const [i, c] of current.children.entries()) {
+      path.push(i);
+      if (locate(c)) return true;
+      path.pop();
+    }
+    return false;
+  }
+  if (!locate(document.root)) invalid6();
+  const ns = node.name.namespace;
+  let result = document;
+  if (!node.children.some((n) => n.name.namespace === ns && n.name.localName === "pPr")) {
+    result = result.spliceChildren(node, 0, 0, [`<pPr xmlns="${ns}"/>`]);
+    node = path.reduce((n, i) => n.children[i], result.root);
+  }
+  result = result.merge(
+    node.children.find((n) => n.name.namespace === ns && n.name.localName === "pPr"),
+    paragraphPropertiesMerge(options, ns)
+  );
+  if (options.tabs != null) {
+    const p = path.reduce((n, i) => n.children[i], result.root);
+    let list = p.children.find((n) => n.name.namespace === ns && n.name.localName === "pPr").children.find((n) => n.name.namespace === ns && n.name.localName === "tabLst");
+    const tokens = { left: "l", center: "ctr", right: "r", decimal: "dec" };
+    const removed = list.children.flatMap(
+      (child2, index) => child2.name.namespace === ns && child2.name.localName === "tab" ? [index] : []
+    );
+    for (const index of removed.reverse()) {
+      result = result.spliceChildren(list, index, 1, []);
+      list = path.reduce((n, i) => n.children[i], result.root).children.find((n) => n.name.namespace === ns && n.name.localName === "pPr").children.find((n) => n.name.namespace === ns && n.name.localName === "tabLst");
+    }
+    result = result.spliceChildren(
+      list,
+      0,
+      0,
+      options.tabs.map(
+        (t) => `<tab xmlns="${ns}" pos="${Math.round(t.position * 12700)}" algn="${tokens[t.alignment]}"/>`
+      )
+    );
+  }
+  return result;
+}
+function readParagraphFormatting(paragraph) {
+  const ns = paragraph.name.namespace;
+  const candidates = paragraph.children.filter(
+    (n) => n.name.namespace === ns && n.name.localName === "pPr"
+  );
+  if (candidates.length > 1)
+    throw new OfficeError("invalid-xml", "Ambiguous paragraph properties.", "parse");
+  const p = candidates[0];
+  const attr2 = (n, key) => n?.attributes.find((a) => !a.name.namespace && a.name.localName === key)?.value ?? null;
+  const child2 = (key) => p?.children.find((n) => n.name.namespace === ns && n.name.localName === key);
+  const numeric = (value, scale) => {
+    if (value === null) return null;
+    if (!value.trim() || !Number.isFinite(Number(value)))
+      throw new OfficeError("invalid-xml", "Invalid paragraph number.", "parse");
+    return Number(value) / scale;
+  };
+  const spacing = (key) => {
+    const n = child2(key)?.children.find(
+      (n2) => n2.name.namespace === ns && ["spcPts", "spcPct"].includes(n2.name.localName)
+    );
+    if (!n) return null;
+    const value = attr2(n, "val");
+    if (value === null) return null;
+    return {
+      unit: n.name.localName === "spcPts" ? "pt" : "multiple",
+      value: n.name.localName === "spcPts" ? numeric(value, 100) : value.endsWith("%") ? numeric(value.slice(0, -1), 100) : numeric(value, 1e5)
+    };
+  };
+  const bulletNode = p?.children.find(
+    (n) => n.name.namespace === ns && ["buNone", "buAutoNum", "buChar", "buBlip"].includes(n.name.localName)
+  );
+  const bullet = bulletNode?.name.localName === "buNone" ? { kind: "none" } : bulletNode?.name.localName === "buChar" ? { kind: "character", character: attr2(bulletNode, "char") } : bulletNode?.name.localName === "buAutoNum" ? {
+    kind: "numbered",
+    scheme: attr2(bulletNode, "type"),
+    ...attr2(bulletNode, "startAt") === null ? {} : { startAt: Number(attr2(bulletNode, "startAt")) }
+  } : bulletNode ? { kind: "picture" } : null;
+  const before = spacing("spcBef"), after = spacing("spcAft");
+  const align = attr2(p, "algn");
+  const rtl = attr2(p, "rtl");
+  if (rtl !== null && !["0", "1", "false", "true"].includes(rtl))
+    throw new OfficeError("invalid-xml", "Invalid paragraph direction.", "parse");
+  return {
+    alignment: align === null ? null : paragraphAlignments[alignmentTokens.indexOf(align)] ?? align,
+    marginLeft: numeric(attr2(p, "marL"), 12700),
+    marginRight: numeric(attr2(p, "marR"), 12700),
+    indent: numeric(attr2(p, "indent"), 12700),
+    defaultTabSize: numeric(attr2(p, "defTabSz"), 12700),
+    level: numeric(attr2(p, "lvl"), 1),
+    rtl: rtl === null ? null : ["1", "true"].includes(rtl),
+    lineSpacing: spacing("lnSpc"),
+    spaceBefore: before?.unit === "pt" ? before.value : null,
+    spaceAfter: after?.unit === "pt" ? after.value : null,
+    bullet,
+    tabs: child2("tabLst")?.children.filter((n) => n.name.namespace === ns && n.name.localName === "tab").map((n) => ({
+      position: numeric(attr2(n, "pos"), 12700),
+      alignment: { l: "left", ctr: "center", r: "right", dec: "decimal" }[attr2(n, "algn") ?? "l"] ?? attr2(n, "algn")
+    })) ?? null
+  };
+}
+async function readTextParagraphs(input, options, context) {
+  const { paragraph, ...reading } = options;
+  if (paragraph !== void 0 && (!Number.isSafeInteger(paragraph) || paragraph < 0)) invalid6();
+  const bodies = await readTextBodies(input, reading, context);
+  return bodies.flatMap(
+    (body) => body.paragraphs.flatMap(
+      (p, i) => paragraph !== void 0 && paragraph !== i ? [] : [
+        {
+          location: body.segment.location,
+          paragraph: i,
+          coordinateSystem: "zero-based",
+          formatting: readParagraphFormatting(p.node)
+        }
+      ]
+    )
+  );
+}
+async function mutateTextParagraphs(input, options, context) {
+  validateTextParagraphOptions(options);
+  if (!options.all && options.select === void 0 && options.shape === void 0 && options.paragraph === void 0)
+    throw new SelectionError("missing-selection");
+  const state = await loadShared(input, context);
+  const { scope, select, shape } = options;
+  const bodies = await readTextBodies(
+    state.source,
+    {
+      ...scope === void 0 ? {} : { scope },
+      ...select === void 0 ? {} : { select },
+      ...shape === void 0 ? {} : { shape }
+    },
+    context
+  );
+  const edits = /* @__PURE__ */ new Map();
+  const locations = [];
+  let affected = 0;
+  for (const body of bodies)
+    for (const [i, p] of body.paragraphs.entries()) {
+      if (options.paragraph !== void 0 && options.paragraph !== i) continue;
+      const edit = edits.get(body.part) ?? {
+        document: body.document,
+        nodes: /* @__PURE__ */ new Set()
+      };
+      if (!edit.nodes.has(p.node)) {
+        edit.nodes.add(p.node);
+        affected++;
+      }
+      edits.set(body.part, edit);
+      if (!locations.includes(body.segment.location)) locations.push(body.segment.location);
+    }
+  if (!affected && !options.allowEmpty) throw new SelectionError("missing-selection");
+  const singleShapeFormatting = options.shape !== void 0 && options.paragraph === void 0 && bodies.length === 1;
+  if (affected > 1 && !options.all && !singleShapeFormatting) throw new SelectionError("ambiguous-selection");
+  for (const [part, edit] of edits) {
+    const paths = [];
+    const visit = (node, path) => {
+      if (edit.nodes.has(node)) paths.push(path);
+      node.children.forEach((n, i) => visit(n, [...path, i]));
+    };
+    visit(edit.document.root, []);
+    let document = edit.document;
+    for (const path of paths.reverse()) {
+      context.signal?.throwIfAborted();
+      document = applyParagraphFormatting(
+        document,
+        path.reduce((n, i) => n.children[i], document.root),
+        options
+      );
+    }
+    state.save(part, document);
+  }
+  if (!affected) return { bytes: state.source, affected, locations };
+  return { bytes: (await state.finish(state.main, [])).bytes, affected, locations };
+}
+var Paragraph = class {
+  #storedXml;
+  #binding;
+  #generation = 0;
+  #runs = [];
+  #font;
+  get #xml() {
+    return this.#binding?.read() ?? this.#storedXml;
+  }
+  set #xml(xml) {
+    if (this.#binding) this.#binding.write(xml);
+    else this.#storedXml = xml;
+  }
+  constructor(xml, binding) {
+    if (xml.root.name.localName !== "p" || ![
+      "http://schemas.openxmlformats.org/drawingml/2006/main",
+      "http://purl.oclc.org/ooxml/drawingml/main"
+    ].includes(xml.root.name.namespace))
+      invalid6();
+    readParagraphFormatting(xml.root);
+    this.#storedXml = xml;
+    this.#binding = binding;
+  }
+  get xml() {
+    return this.#xml;
+  }
+  get parent() {
+    this.#binding?.read();
+    return this.#binding?.parent;
+  }
+  get runs() {
+    const xml = this.#xml;
+    const count = xml.root.children.filter(
+      (n) => n.name.namespace === xml.root.name.namespace && n.name.localName === "r"
+    ).length;
+    const generation = this.#generation;
+    for (let i = this.#runs.length; i < count; i++) {
+      this.#runs.push(
+        new Run({
+          parent: this,
+          read: () => {
+            if (generation !== this.#generation) throw new InvalidHandleError();
+            const document = this.#xml;
+            const node = document.root.children.filter(
+              (n) => n.name.namespace === document.root.name.namespace && n.name.localName === "r"
+            )[i];
+            if (!node) throw new InvalidHandleError();
+            return { document, node };
+          },
+          write: (xml2) => {
+            this.#xml = xml2;
+          }
+        })
+      );
+    }
+    return Object.freeze(this.#runs.slice(0, count));
+  }
+  add_run() {
+    const xml = this.#xml;
+    const end = xml.root.children.findIndex(
+      (n) => n.name.namespace === xml.root.name.namespace && n.name.localName === "endParaRPr"
+    );
+    this.#xml = xml.spliceChildren(xml.root, end < 0 ? xml.root.children.length : end, 0, [
+      `<r xmlns="${xml.root.name.namespace}"><t/></r>`
+    ]);
+    return this.runs.at(-1);
+  }
+  add_line_break() {
+    const xml = this.#xml;
+    const end = xml.root.children.findIndex(
+      (n) => n.name.namespace === xml.root.name.namespace && n.name.localName === "endParaRPr"
+    );
+    this.#xml = xml.spliceChildren(xml.root, end < 0 ? xml.root.children.length : end, 0, [
+      `<br xmlns="${xml.root.name.namespace}"/>`
+    ]);
+  }
+  clear() {
+    this.#xml = replaceParagraphContent(this.#xml, []);
+    this.#generation++;
+    this.#runs = [];
+    return this;
+  }
+  get text() {
+    const xml = this.#xml;
+    return xml.root.children.filter(
+      (n) => n.name.namespace === xml.root.name.namespace && ["r", "br", "fld"].includes(n.name.localName)
+    ).map((n) => n.name.localName === "br" ? "\v" : nodeText(xml, n)).join("");
+  }
+  set text(value) {
+    if (typeof value !== "string") invalid6();
+    const ns = this.#xml.root.name.namespace;
+    const fragments = value.split("\n").join("\v").split("\v").flatMap((piece, index) => [
+      ...index ? [`<br xmlns="${ns}"/>`] : [],
+      ...piece ? [`<r xmlns="${ns}"><t>${escapeModelText(piece)}</t></r>`] : []
+    ]);
+    this.#xml = replaceParagraphContent(this.#xml, fragments);
+    this.#generation++;
+    this.#runs = [];
+  }
+  get font() {
+    let xml = this.#xml;
+    const ns = xml.root.name.namespace;
+    let properties = xml.root.children.find(
+      (n) => n.name.namespace === ns && n.name.localName === "pPr"
+    );
+    if (!properties) {
+      xml = xml.spliceChildren(xml.root, 0, 0, [`<pPr xmlns="${ns}"/>`]);
+      properties = xml.root.children[0];
+    }
+    if (!properties.children.some((n) => n.name.namespace === ns && n.name.localName === "defRPr")) {
+      xml = xml.merge(properties, {
+        children: {
+          sequence: sequence.map((localName) => ({ namespace: ns, localName })),
+          upsert: [{ name: { namespace: ns, localName: "defRPr" }, merge: {} }]
+        }
+      });
+    }
+    this.#xml = xml;
+    return this.#font ??= new Font({
+      read: () => {
+        const document = this.#xml;
+        const node = document.root.children.find(
+          (n) => n.name.namespace === document.root.name.namespace && n.name.localName === "pPr"
+        )?.children.find(
+          (n) => n.name.namespace === document.root.name.namespace && n.name.localName === "defRPr"
+        );
+        if (!node) throw new InvalidHandleError();
+        return { document, node };
+      },
+      write: (xml2) => {
+        this.#xml = xml2;
+      }
+    });
+  }
+  get alignment() {
+    const value = readParagraphFormatting(this.#xml.root).alignment;
+    if (value === null) return null;
+    const index = paragraphAlignments.indexOf(value);
+    if (index < 0) throw new OfficeError("invalid-xml", "Unknown paragraph alignment.", "parse");
+    return index + 1;
+  }
+  set alignment(value) {
+    this.#xml = applyParagraphFormatting(this.#xml, this.#xml.root, { alignment: value });
+  }
+  get level() {
+    return readParagraphFormatting(this.#xml.root).level ?? 0;
+  }
+  set level(value) {
+    this.#xml = applyParagraphFormatting(this.#xml, this.#xml.root, { level: value });
+  }
+  get line_spacing() {
+    const value = readParagraphFormatting(this.#xml.root).lineSpacing;
+    return value === null ? null : value.unit === "multiple" ? value.value : new Pt(value.value);
+  }
+  set line_spacing(value) {
+    if (value !== null && typeof value !== "number" && !(value instanceof Length)) invalid6();
+    this.#xml = applyParagraphFormatting(this.#xml, this.#xml.root, {
+      lineSpacing: value === null ? null : typeof value === "number" ? { unit: "multiple", value } : { unit: "pt", value: value.pt }
+    });
+  }
+  get space_before() {
+    const value = readParagraphFormatting(this.#xml.root).spaceBefore;
+    return value === null ? null : new Pt(value);
+  }
+  set space_before(value) {
+    if (value !== null && !(value instanceof Length)) invalid6();
+    this.#xml = applyParagraphFormatting(this.#xml, this.#xml.root, {
+      spaceBefore: value === null ? null : value.pt
+    });
+  }
+  get space_after() {
+    const value = readParagraphFormatting(this.#xml.root).spaceAfter;
+    return value === null ? null : new Pt(value);
+  }
+  set space_after(value) {
+    if (value !== null && !(value instanceof Length)) invalid6();
+    this.#xml = applyParagraphFormatting(this.#xml, this.#xml.root, {
+      spaceAfter: value === null ? null : value.pt
+    });
+  }
+};
+function nodeText(document, node) {
+  let text = "";
+  for (const child2 of node.children.filter(
+    (n) => n.name.namespace === node.name.namespace && n.name.localName === "t"
+  )) {
+    const parser = new SaxesParser2({ xmlns: false });
+    parser.on("text", (value) => {
+      text += value;
+    });
+    parser.on("cdata", (value) => {
+      text += value;
+    });
+    parser.write(document.markup(child2)).close();
+  }
+  return text;
+}
+function escapeModelText(value) {
+  return Array.from(value).map((c) => {
+    const code = c.codePointAt(0);
+    if (code < 32 && ![9, 10, 13].includes(code) || code >= 55296 && code <= 57343 || [65534, 65535].includes(code))
+      return `_x${code.toString(16).toUpperCase().padStart(4, "0")}_`;
+    return c === "&" ? "&amp;" : c === "<" ? "&lt;" : c === ">" ? "&gt;" : c === "\r" ? "&#13;" : c;
+  }).join("");
+}
+function replaceParagraphContent(xml, fragments) {
+  if (protectedEquationNodes(xml.root).size)
+    throw new OfficeError(
+      "unsupported-edit",
+      "Whole text replacement cannot remove equations or their fallbacks.",
+      "validate-intent"
+    );
+  const ns = xml.root.name.namespace;
+  const indexes = xml.root.children.flatMap(
+    (n, i) => n.name.namespace === ns && ["r", "br", "fld"].includes(n.name.localName) ? [i] : []
+  );
+  let result = xml;
+  for (const i of indexes.reverse()) result = result.spliceChildren(result.root, i, 1, []);
+  if (fragments.length) {
+    const end = result.root.children.findIndex(
+      (n) => n.name.namespace === ns && n.name.localName === "endParaRPr"
+    );
+    result = result.spliceChildren(
+      result.root,
+      end < 0 ? result.root.children.length : end,
+      0,
+      fragments
+    );
+  }
+  return result;
+}
+var Run = class {
+  #binding;
+  #font;
+  #hyperlink;
+  constructor(binding) {
+    this.#binding = binding;
+  }
+  get parent() {
+    this.#binding.read();
+    return this.#binding.parent;
+  }
+  get text() {
+    const { document, node } = this.#binding.read();
+    return nodeText(document, node);
+  }
+  set text(value) {
+    if (typeof value !== "string") invalid6();
+    const { document, node } = this.#binding.read();
+    if (protectedEquationNodes(node).size)
+      throw new OfficeError(
+        "unsupported-edit",
+        "Text replacement cannot remove equations.",
+        "validate-intent"
+      );
+    const texts = node.children.flatMap(
+      (n, i) => n.name.namespace === node.name.namespace && n.name.localName === "t" ? [i] : []
+    );
+    if (texts.length !== 1)
+      throw new OfficeError("invalid-xml", "A text run requires one text element.", "parse");
+    this.#binding.write(
+      document.spliceChildren(node, texts[0], 1, [
+        `<t xmlns="${node.name.namespace}">${escapeModelText(value)}</t>`
+      ])
+    );
+  }
+  get hyperlink() {
+    this.#binding.read();
+    const capability = textLinkCapabilities.get(this.#binding.parent);
+    if (!capability) throw new PropertyAccessError("Run has no package hyperlink owner.");
+    void this.font;
+    return this.#hyperlink ??= capability(() => {
+      const { document, node } = this.#binding.read();
+      const properties = node.children.findIndex(
+        (child2) => child2.name.namespace === node.name.namespace && child2.name.localName === "rPr"
+      );
+      if (properties < 0) throw new InvalidHandleError();
+      return [document.root.children.indexOf(node), properties];
+    });
+  }
+  get font() {
+    const { document, node } = this.#binding.read();
+    if (!node.children.some(
+      (n) => n.name.namespace === node.name.namespace && n.name.localName === "rPr"
+    ))
+      this.#binding.write(
+        document.spliceChildren(node, 0, 0, [`<rPr xmlns="${node.name.namespace}"/>`])
+      );
+    return this.#font ??= new Font({
+      read: () => {
+        const { document: document2, node: node2 } = this.#binding.read();
+        const properties = node2.children.find(
+          (n) => n.name.namespace === node2.name.namespace && n.name.localName === "rPr"
+        );
+        if (!properties) throw new InvalidHandleError();
+        return { document: document2, node: properties };
+      },
+      write: this.#binding.write
+    });
+  }
+};
+var Font = class {
+  #binding;
+  #color;
+  #fill;
+  constructor(binding) {
+    this.#binding = binding;
+  }
+  get #format() {
+    const { node } = this.#binding.read();
+    return readRunFormatting({
+      name: { namespace: node.name.namespace, localName: "r" },
+      attributes: [],
+      children: [{ ...node, name: { namespace: node.name.namespace, localName: "rPr" } }]
+    });
+  }
+  #set(options) {
+    validateTextRunOptions(options);
+    const { document, node } = this.#binding.read();
+    this.#binding.write(document.merge(node, runPropertiesMerge(options, node.name.namespace)));
+  }
+  get fill() {
+    this.#binding.read();
+    return this.#fill ??= new FillFormat(
+      () => {
+        const { document, node } = this.#binding.read();
+        return document.subtree(node);
+      },
+      void 0,
+      false,
+      (transform) => {
+        const { document, node } = this.#binding.read();
+        this.#binding.write(transform(document, node));
+      },
+      (node) => node
+    );
+  }
+  get color() {
+    this.fill.solid();
+    const read = () => {
+      const { document, node } = this.#binding.read();
+      const selected = node.children.find(
+        (n) => n.name.namespace === node.name.namespace && n.name.localName === "solidFill"
+      );
+      if (!selected) throw new InvalidHandleError();
+      return document.subtree(selected);
+    };
+    return this.#color ??= new ColorFormat(read(), {
+      read,
+      write: (xml) => {
+        const { document, node } = this.#binding.read();
+        const index = node.children.findIndex(
+          (n) => n.name.namespace === node.name.namespace && n.name.localName === "solidFill"
+        );
+        if (index < 0) throw new InvalidHandleError();
+        this.#binding.write(document.spliceChildren(node, index, 1, [xml.markup(xml.root, true)]));
+      }
+    });
+  }
+  get bold() {
+    return this.#format.bold;
+  }
+  set bold(value) {
+    this.#set({ bold: value });
+  }
+  get language_id() {
+    const value = this.#format.language;
+    return value === null ? MSO_LANGUAGE_ID.NONE : MSO_LANGUAGE_ID.from_xml(value);
+  }
+  set language_id(value) {
+    this.#set({
+      language: value === null || value === MSO_LANGUAGE_ID.NONE ? null : MSO_LANGUAGE_ID.to_xml(value)
+    });
+  }
+  get italic() {
+    return this.#format.italic;
+  }
+  set italic(value) {
+    this.#set({ italic: value });
+  }
+  get strike() {
+    const value = this.#format.strike;
+    if (value === null || value === "none" || value === "single" || value === "double") return value;
+    throw new OfficeError("invalid-xml", "Unknown text strikeout.", "parse");
+  }
+  set strike(value) {
+    this.#set({ strike: value });
+  }
+  get baseline() {
+    return this.#format.baseline;
+  }
+  set baseline(value) {
+    this.#set({ baseline: value });
+  }
+  get name() {
+    return this.#format.font;
+  }
+  set name(value) {
+    this.#set({ font: value });
+  }
+  get size() {
+    const value = this.#format.size;
+    return value === null ? null : new Pt(value);
+  }
+  set size(value) {
+    if (value !== null && !(value instanceof Length)) invalid6();
+    this.#set({ size: value === null ? null : value.pt });
+  }
+  get underline() {
+    const value = this.#format.underline;
+    if (value === null) return null;
+    if (value === "none") return false;
+    if (value === "sng") return true;
+    const index = textUnderlineStyles.indexOf(value);
+    if (index < 0) throw new OfficeError("invalid-xml", "Unknown text underline.", "parse");
+    return index;
+  }
+  set underline(value) {
+    this.#set({ underline: value });
+  }
+};
+
+export {
+  textLinkCapabilities,
+  Adjustment,
+  AdjustmentCollection,
+  PP_PARAGRAPH_ALIGNMENT,
+  paragraphAlignments,
+  paragraphNumberingSchemes,
+  validateTextParagraphOptions,
+  paragraphPropertiesMerge,
+  applyParagraphFormatting,
+  readParagraphFormatting,
+  readTextParagraphs,
+  mutateTextParagraphs,
+  Paragraph,
+  Run,
+  Font,
+  validateTextFitOptions,
+  fitFrameXml,
+  fitTextFrames,
+  MSO_AUTO_SIZE,
+  MSO_VERTICAL_ANCHOR,
+  textVerticalModes,
+  validateTextFrameOptions,
+  readFrameFormatting,
+  applyFrameFormatting,
+  readTextFrames,
+  mutateTextFrames,
+  TextFrame,
+  MSO_SHAPE_TYPE,
+  PP_PLACEHOLDER_TYPE,
+  MSO_FILL_TYPE,
+  MSO_FILL,
+  MSO_LINE_DASH_STYLE,
+  MSO_LINE,
+  MSO_PATTERN_TYPE,
+  MSO_PATTERN,
+  validateShapeOptions,
+  readShape,
+  applyShapeUpdate,
+  createShapeXml,
+  Shape,
+  ShapeColorFormat,
+  FillFormat,
+  GradientStop,
+  GradientStops,
+  ShadowFormat,
+  LineFormat
+};