@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,1739 @@
+import {
+  BubbleChartData,
+  CategoryChartData,
+  XyChartData,
+  chartTypes,
+  toChartData
+} from "./chunk-F2ORFLCH.js";
+import {
+  applyPictureUpdate
+} from "./chunk-OP6J3OLL.js";
+import {
+  applyConnectorUpdate,
+  createConnectorXml,
+  readConnector
+} from "./chunk-UJTJFMIN.js";
+import {
+  XL_CHART_TYPE
+} from "./chunk-ZTAFAHY3.js";
+import {
+  PROG_ID
+} from "./chunk-7OXNWLSL.js";
+import {
+  Image
+} from "./chunk-HUNXIAOL.js";
+import {
+  applyTableStructure
+} from "./chunk-7PZASWL6.js";
+import {
+  applyTableUpdate,
+  createTableXml,
+  readTable
+} from "./chunk-MQU6Q75R.js";
+import {
+  nodeFor
+} from "./chunk-QHS7PDG3.js";
+import {
+  FillFormat,
+  LineFormat,
+  MSO_SHAPE_TYPE,
+  MSO_VERTICAL_ANCHOR,
+  PP_PLACEHOLDER_TYPE,
+  ShadowFormat,
+  Shape,
+  TextFrame,
+  applyShapeUpdate,
+  createShapeXml,
+  readShape,
+  textLinkCapabilities
+} from "./chunk-HHLVI2CB.js";
+import {
+  ShapeIdAllocator
+} from "./chunk-RZC7QHL6.js";
+import {
+  defineEnum
+} from "./chunk-SEK43FRN.js";
+import {
+  Length
+} from "./chunk-I6AMDG2T.js";
+import {
+  attr,
+  child,
+  required
+} from "./chunk-RAXJVM4U.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  IndexError,
+  InvalidHandleError,
+  KeyError,
+  OfficeError,
+  PropertyAccessError,
+  TypeError,
+  ValueError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/indexed-collection.ts
+function indexed(target) {
+  return new Proxy(target, {
+    get(object, key) {
+      if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+        return object.get(Number(key));
+      const value = Reflect.get(object, key, object);
+      return typeof value === "function" ? value.bind(object) : value;
+    },
+    set(object, key, value) {
+      if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+        throw new ValueError("Collection entries are read-only.");
+      return Reflect.set(object, key, value, object);
+    },
+    defineProperty(object, key, descriptor) {
+      if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+        throw new ValueError("Collection entries are read-only.");
+      return Reflect.defineProperty(object, key, descriptor);
+    },
+    deleteProperty(object, key) {
+      if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+        throw new ValueError("Collection entries are read-only.");
+      return Reflect.deleteProperty(object, key);
+    }
+  });
+}
+
+// packages/safe-bash-presentation-engine/src/media-enum.ts
+var PP_MEDIA_TYPEValues = /* @__PURE__ */ ((PP_MEDIA_TYPEValues2) => {
+  PP_MEDIA_TYPEValues2[PP_MEDIA_TYPEValues2["MOVIE"] = 3] = "MOVIE";
+  PP_MEDIA_TYPEValues2[PP_MEDIA_TYPEValues2["OTHER"] = 1] = "OTHER";
+  PP_MEDIA_TYPEValues2[PP_MEDIA_TYPEValues2["SOUND"] = 1 /* OTHER */] = "SOUND";
+  PP_MEDIA_TYPEValues2[PP_MEDIA_TYPEValues2["MIXED"] = -2] = "MIXED";
+  return PP_MEDIA_TYPEValues2;
+})(PP_MEDIA_TYPEValues || {});
+var PP_MEDIA_TYPE = defineEnum(PP_MEDIA_TYPEValues);
+
+// packages/safe-bash-presentation-engine/src/shape-owner-token.ts
+var shapeOwnerTokens = /* @__PURE__ */ new WeakMap();
+
+// packages/safe-bash-presentation-engine/src/tables-model.ts
+function position(index2, length) {
+  if (!Number.isSafeInteger(index2) || index2 < 0 || index2 >= length)
+    throw new IndexError("Table position is outside the collection.");
+}
+function indexed2(collection) {
+  return new Proxy(collection, {
+    get(target, key) {
+      if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+        return target.get(Number(key));
+      const value = Reflect.get(target, key, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+    defineProperty(target, key, descriptor) {
+      if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+        throw new OfficeError(
+          "invalid-value",
+          "Table collections cannot replace entries.",
+          "usage"
+        );
+      return Reflect.defineProperty(target, key, descriptor);
+    },
+    deleteProperty(target, key) {
+      if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+        throw new OfficeError("invalid-value", "Table collections cannot remove entries.", "usage");
+      return Reflect.deleteProperty(target, key);
+    },
+    set(target, key, value, receiver) {
+      if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+        throw new OfficeError(
+          "invalid-value",
+          "Table collections cannot replace entries.",
+          "usage"
+        );
+      return Reflect.set(target, key, value, receiver);
+    }
+  });
+}
+var Table = class {
+  #storedXml;
+  #owner;
+  get #xml() {
+    return this.#owner?.read() ?? this.#storedXml;
+  }
+  set #xml(value) {
+    if (this.#owner) this.#owner.write(value);
+    else this.#storedXml = value;
+  }
+  #id;
+  #cells = /* @__PURE__ */ new Map();
+  #generation = 0;
+  get generation() {
+    return this.#generation;
+  }
+  constructor(xml, shapeId, owner) {
+    this.#storedXml = xml;
+    this.#owner = owner;
+    this.#id = shapeId ?? readTable(xml.root, xml).shapeId;
+    readTable(this.element, xml);
+  }
+  get xml() {
+    return this.#xml;
+  }
+  get element() {
+    return nodeFor(this.#xml.root, String(this.#id));
+  }
+  get rows() {
+    return new TableRows(this);
+  }
+  get columns() {
+    return new TableColumns(this);
+  }
+  cell(row, column) {
+    position(row, this.rows.length);
+    position(column, this.columns.length);
+    const key = `${row}:${column}`;
+    let cell = this.#cells.get(key);
+    if (!cell) {
+      cell = new TableCell(this, row, column);
+      this.#cells.set(key, cell);
+    }
+    return cell;
+  }
+  *iter_cells() {
+    for (let row = 0; row < this.rows.length; row++)
+      for (let column = 0; column < this.columns.length; column++) yield this.cell(row, column);
+  }
+  get first_row() {
+    return readTable(this.element, this.#xml).firstRow;
+  }
+  set first_row(value) {
+    this.#xml = applyTableUpdate(this.#xml, this.element, { firstRow: value });
+  }
+  get last_row() {
+    return readTable(this.element, this.#xml).lastRow;
+  }
+  set last_row(value) {
+    this.#xml = applyTableUpdate(this.#xml, this.element, { lastRow: value });
+  }
+  get first_col() {
+    return readTable(this.element, this.#xml).firstCol;
+  }
+  set first_col(value) {
+    this.#xml = applyTableUpdate(this.#xml, this.element, { firstCol: value });
+  }
+  get last_col() {
+    return readTable(this.element, this.#xml).lastCol;
+  }
+  set last_col(value) {
+    this.#xml = applyTableUpdate(this.#xml, this.element, { lastCol: value });
+  }
+  get horz_banding() {
+    return readTable(this.element, this.#xml).horzBand;
+  }
+  set horz_banding(value) {
+    this.#xml = applyTableUpdate(this.#xml, this.element, { horzBand: value });
+  }
+  get vert_banding() {
+    return readTable(this.element, this.#xml).vertBand;
+  }
+  set vert_banding(value) {
+    this.#xml = applyTableUpdate(this.#xml, this.element, { vertBand: value });
+  }
+  /** Applies one validated change while keeping previously returned cell handles live. */
+  update(options) {
+    this.#xml = applyTableUpdate(this.#xml, this.element, options);
+  }
+  structure(operation) {
+    this.#xml = applyTableStructure(this.#xml, this.element, operation);
+    if (operation.kind !== "merge" && operation.kind !== "split") {
+      this.#generation++;
+      this.#cells.clear();
+    }
+  }
+  bindFill(row, column) {
+    const cell = this.cell(row, column);
+    const target = () => {
+      void cell.table;
+      const graphic = this.element.children.find((node) => node.name.localName === "graphic");
+      const table = required(required(graphic, "graphicData"), "tbl");
+      const owner = table.children.filter((n) => n.name.localName === "tr")[row];
+      return owner.children.filter((n) => n.name.localName === "tc")[column];
+    };
+    const edit = (transform) => {
+      void cell.table;
+      applyTableUpdate(this.#xml, this.element, { cell: { row, column } });
+      this.#xml = transform(this.#xml, target());
+    };
+    if (!child(target(), "tcPr"))
+      edit(
+        (xml, node) => xml.merge(node, {
+          children: {
+            sequence: ["txBody", "tcPr", "extLst"].map((localName) => ({
+              namespace: node.name.namespace,
+              localName
+            })),
+            upsert: [{ name: { namespace: node.name.namespace, localName: "tcPr" }, merge: {} }]
+          }
+        })
+      );
+    const read = () => this.#xml.subtree(target());
+    return new FillFormat(read, void 0, false, edit, (node) => child(node, "tcPr"));
+  }
+  bindTextFrame(row, column, parent) {
+    const generation = this.#generation;
+    const validate = () => {
+      if (generation !== this.#generation) throw new InvalidHandleError();
+    };
+    const body = () => {
+      validate();
+      const frame2 = this.element;
+      const graphic = frame2.children.find((node2) => node2.name.localName === "graphic");
+      const data = required(graphic, "graphicData");
+      const tbl = required(data, "tbl");
+      const tr = tbl.children.filter((n) => n.name.localName === "tr")[row];
+      const cell = tr.children.filter((n) => n.name.localName === "tc")[column];
+      const node = required(cell, "txBody");
+      const ancestors = [frame2, graphic, data, tbl, tr, cell, node];
+      return { node, path: ancestors.slice(1).map((child2, i) => ancestors[i].children.indexOf(child2)) };
+    };
+    let source, cached;
+    const read = () => {
+      validate();
+      if (source !== this.#xml) {
+        source = this.#xml;
+        cached = this.#xml.subtree(body().node);
+      }
+      return cached;
+    };
+    const frame = new TextFrame(read(), void 0, {
+      parent,
+      read,
+      write: (xml) => {
+        applyTableUpdate(this.#xml, this.element, {
+          cell: { row, column },
+          text: this.cell(row, column).text
+        });
+        const target = body().node;
+        const find = (node) => node.children.includes(target) ? node : node.children.map(find).find(Boolean);
+        const owner = find(this.#xml.root);
+        this.#xml = this.#xml.spliceChildren(owner, owner.children.indexOf(target), 1, [
+          xml.markup(xml.root, true)
+        ]);
+      }
+    });
+    const hyperlink = this.#owner?.hyperlink;
+    if (hyperlink) textLinkCapabilities.set(frame, (path) => hyperlink(() => [...body().path, ...path()]));
+    return frame;
+  }
+};
+var TableCell = class _TableCell {
+  constructor(table, row, column) {
+    this.row = row;
+    this.column = column;
+    this.#table = table;
+    this.#generation = table.generation;
+    position(row, table.rows.length);
+    position(column, table.columns.length);
+  }
+  row;
+  column;
+  #table;
+  #generation;
+  #frame;
+  #fill;
+  get table() {
+    if (this.#generation !== this.#table.generation) throw new InvalidHandleError();
+    return this.#table;
+  }
+  equals(other) {
+    const table = this.table;
+    return other instanceof _TableCell && other.table === table && other.row === this.row && other.column === this.column;
+  }
+  get fill() {
+    const table = this.table;
+    return this.#fill ??= table.bindFill(this.row, this.column);
+  }
+  merge(other) {
+    if (!(other instanceof _TableCell) || other.table !== this.table)
+      throw new OfficeError("invalid-value", "Merge cells must belong to the same table.", "usage");
+    this.table.structure({
+      kind: "merge",
+      from: { row: Math.min(this.row, other.row), column: Math.min(this.column, other.column) },
+      to: { row: Math.max(this.row, other.row), column: Math.max(this.column, other.column) }
+    });
+  }
+  split() {
+    this.table.structure({ kind: "split", cell: { row: this.row, column: this.column } });
+  }
+  get text() {
+    return readTable(this.table.element, this.table.xml).cells[this.row * this.table.columns.length + this.column].text;
+  }
+  set text(value) {
+    this.text_frame.text = value;
+  }
+  get text_frame() {
+    const table = this.table;
+    return this.#frame ??= table.bindTextFrame(this.row, this.column, this);
+  }
+  get is_spanned() {
+    return readTable(this.table.element, this.table.xml).cells[this.row * this.table.columns.length + this.column].isSpanned;
+  }
+  get is_merge_origin() {
+    return readTable(this.table.element, this.table.xml).cells[this.row * this.table.columns.length + this.column].isMergeOrigin;
+  }
+  get span_height() {
+    return readTable(this.table.element, this.table.xml).cells[this.row * this.table.columns.length + this.column].spanHeight;
+  }
+  get span_width() {
+    return readTable(this.table.element, this.table.xml).cells[this.row * this.table.columns.length + this.column].spanWidth;
+  }
+  get margin_left() {
+    return new Length(
+      readTable(this.table.element, this.table.xml).cells[this.row * this.table.columns.length + this.column].marginLeft ?? 91440
+    );
+  }
+  set margin_left(value) {
+    this.table.update({ cell: { row: this.row, column: this.column }, marginLeft: value });
+  }
+  get margin_right() {
+    return new Length(
+      readTable(this.table.element, this.table.xml).cells[this.row * this.table.columns.length + this.column].marginRight ?? 91440
+    );
+  }
+  set margin_right(value) {
+    this.table.update({ cell: { row: this.row, column: this.column }, marginRight: value });
+  }
+  get margin_top() {
+    return new Length(
+      readTable(this.table.element, this.table.xml).cells[this.row * this.table.columns.length + this.column].marginTop ?? 45720
+    );
+  }
+  set margin_top(value) {
+    this.table.update({ cell: { row: this.row, column: this.column }, marginTop: value });
+  }
+  get margin_bottom() {
+    return new Length(
+      readTable(this.table.element, this.table.xml).cells[this.row * this.table.columns.length + this.column].marginBottom ?? 45720
+    );
+  }
+  set margin_bottom(value) {
+    this.table.update({ cell: { row: this.row, column: this.column }, marginBottom: value });
+  }
+  get vertical_anchor() {
+    const value = readTable(this.table.element, this.table.xml).cells[this.row * this.table.columns.length + this.column].verticalAnchor;
+    if (value === null) return null;
+    if (value === "top") return MSO_VERTICAL_ANCHOR.TOP;
+    if (value === "middle") return MSO_VERTICAL_ANCHOR.MIDDLE;
+    if (value === "bottom") return MSO_VERTICAL_ANCHOR.BOTTOM;
+    throw new OfficeError("unsupported-edit", "Cell anchor is preserve-only.", "validate-intent");
+  }
+  set vertical_anchor(value) {
+    const anchor = value === null ? null : value === MSO_VERTICAL_ANCHOR.TOP ? "top" : value === MSO_VERTICAL_ANCHOR.MIDDLE ? "middle" : value === MSO_VERTICAL_ANCHOR.BOTTOM ? "bottom" : void 0;
+    if (anchor === void 0)
+      throw new OfficeError("invalid-value", "Invalid cell anchor.", "usage");
+    this.table.update({ cell: { row: this.row, column: this.column }, verticalAnchor: anchor });
+  }
+};
+var TableRows = class {
+  constructor(table) {
+    this.table = table;
+    return indexed2(this);
+  }
+  table;
+  get length() {
+    return readTable(this.table.element, this.table.xml).rows;
+  }
+  get = this.at;
+  at(index2) {
+    position(index2, this.length);
+    return new TableRow(this.table, index2);
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.length; i++) yield this.get(i);
+  }
+};
+var TableColumns = class {
+  constructor(table) {
+    this.table = table;
+    return indexed2(this);
+  }
+  table;
+  get length() {
+    return readTable(this.table.element, this.table.xml).columns;
+  }
+  get = this.at;
+  at(index2) {
+    position(index2, this.length);
+    return new TableColumn(this.table, index2);
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.length; i++) yield this.get(i);
+  }
+};
+var TableRow = class {
+  constructor(table, index2) {
+    this.index = index2;
+    this.#table = table;
+    this.#generation = table.generation;
+    position(index2, table.rows.length);
+  }
+  index;
+  #table;
+  #generation;
+  get table() {
+    if (this.#generation !== this.#table.generation) throw new InvalidHandleError();
+    return this.#table;
+  }
+  get height() {
+    return new Length(readTable(this.table.element, this.table.xml).rowHeights[this.index]);
+  }
+  set height(value) {
+    this.table.update({ cell: { row: this.index, column: 0 }, rowHeight: value });
+  }
+  get cells() {
+    return new TableCells(this.table, this.index);
+  }
+};
+var TableColumn = class {
+  constructor(table, index2) {
+    this.index = index2;
+    this.#table = table;
+    this.#generation = table.generation;
+    position(index2, table.columns.length);
+  }
+  index;
+  #table;
+  #generation;
+  get table() {
+    if (this.#generation !== this.#table.generation) throw new InvalidHandleError();
+    return this.#table;
+  }
+  get width() {
+    return new Length(readTable(this.table.element, this.table.xml).columnWidths[this.index]);
+  }
+  set width(value) {
+    this.table.update({ cell: { row: 0, column: this.index }, columnWidth: value });
+  }
+};
+var TableCells = class {
+  constructor(table, row) {
+    this.row = row;
+    this.#table = table;
+    this.#generation = table.generation;
+    position(row, table.rows.length);
+    return indexed2(this);
+  }
+  row;
+  #table;
+  #generation;
+  get table() {
+    if (this.#generation !== this.#table.generation) throw new InvalidHandleError();
+    return this.#table;
+  }
+  get length() {
+    return this.table.columns.length;
+  }
+  get = this.at;
+  at(index2) {
+    position(index2, this.length);
+    return this.table.cell(this.row, index2);
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.length; i++) yield this.get(i);
+  }
+};
+
+// packages/safe-bash-presentation-engine/src/group-model.ts
+var GroupShape = class extends Shape {
+  constructor(xml, shapes2, owner) {
+    if (xml.root.name.localName !== "grpSp") throw new TypeError("Expected a group shape.");
+    super(xml, owner);
+    this.shapes = shapes2;
+  }
+  shapes;
+  get shape_type() {
+    return MSO_SHAPE_TYPE.GROUP;
+  }
+  get click_action() {
+    throw new TypeError("Group shapes cannot have click actions.");
+  }
+};
+
+// packages/safe-bash-presentation-engine/src/connectors-model.ts
+var Connector = class {
+  #snapshot;
+  #owner;
+  get #xml() {
+    return this.#owner?.read() ?? this.#snapshot;
+  }
+  set #xml(xml) {
+    if (this.#owner) this.#owner.write(xml);
+    else this.#snapshot = xml;
+  }
+  #id;
+  #shadow;
+  constructor(xml, shapeId, owner) {
+    this.#snapshot = xml;
+    this.#owner = owner;
+    this.#id = String(shapeId ?? readConnector(xml.root).shapeId);
+    readConnector(this.element);
+  }
+  get xml() {
+    return this.#xml;
+  }
+  get element() {
+    return nodeFor(this.#xml.root, this.#id);
+  }
+  get shape_id() {
+    return readConnector(this.element).shapeId;
+  }
+  get name() {
+    return readConnector(this.element).name;
+  }
+  set name(value) {
+    this.#xml = applyConnectorUpdate(this.#xml, this.element, { name: value });
+  }
+  get line() {
+    return new LineFormat(
+      () => ({ ...this.#xml, root: this.element }),
+      (update) => {
+        this.#xml = applyConnectorUpdate(this.#xml, this.element, {
+          ...update.lineColor === void 0 ? {} : { lineColor: update.lineColor },
+          ...update.lineWidth === void 0 ? {} : { lineWidth: update.lineWidth }
+        });
+      },
+      (transform) => {
+        this.#xml = transform(this.#xml, this.element);
+      }
+    );
+  }
+  get shape_type() {
+    return 9;
+  }
+  get has_text_frame() {
+    return false;
+  }
+  get has_chart() {
+    return false;
+  }
+  get has_table() {
+    return false;
+  }
+  get is_placeholder() {
+    return readConnector(this.element).placeholder !== null;
+  }
+  get placeholder_format() {
+    const placeholder = readConnector(this.element).placeholder;
+    if (!placeholder) throw new ValueError("Connector is not a placeholder.");
+    return { ...placeholder, type: PP_PLACEHOLDER_TYPE.from_xml(placeholder.type) };
+  }
+  get shadow() {
+    this.#shadow ??= new ShadowFormat(
+      () => this.#xml.subtree(this.element),
+      (transform) => {
+        this.#xml = transform(this.#xml, this.element);
+      }
+    );
+    return this.#shadow;
+  }
+  get begin_x() {
+    return new Length(readConnector(this.element).beginX);
+  }
+  set begin_x(value) {
+    this.#xml = applyConnectorUpdate(this.#xml, this.element, { beginX: value });
+  }
+  get begin_y() {
+    return new Length(readConnector(this.element).beginY);
+  }
+  set begin_y(value) {
+    this.#xml = applyConnectorUpdate(this.#xml, this.element, { beginY: value });
+  }
+  get end_x() {
+    return new Length(readConnector(this.element).endX);
+  }
+  set end_x(value) {
+    this.#xml = applyConnectorUpdate(this.#xml, this.element, { endX: value });
+  }
+  get end_y() {
+    return new Length(readConnector(this.element).endY);
+  }
+  set end_y(value) {
+    this.#xml = applyConnectorUpdate(this.#xml, this.element, { endY: value });
+  }
+  get left() {
+    return new Length(readConnector(this.element).left ?? 0);
+  }
+  set left(value) {
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { left: value });
+  }
+  get top() {
+    return new Length(readConnector(this.element).top ?? 0);
+  }
+  set top(value) {
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { top: value });
+  }
+  get width() {
+    return new Length(readConnector(this.element).width ?? 0);
+  }
+  set width(value) {
+    if (!(value instanceof Length) || value.emu < 0)
+      throw new OfficeError(
+        "invalid-value",
+        "Connector width requires a nonnegative length.",
+        "usage"
+      );
+    const current = readConnector(this.element), left = current.left ?? 0;
+    this.#xml = applyConnectorUpdate(this.#xml, this.element, {
+      beginX: new Length(left + (current.flipHorizontal ? value.emu : 0)),
+      endX: new Length(left + (current.flipHorizontal ? 0 : value.emu))
+    });
+  }
+  get height() {
+    return new Length(readConnector(this.element).height ?? 0);
+  }
+  set height(value) {
+    if (!(value instanceof Length) || value.emu < 0)
+      throw new OfficeError(
+        "invalid-value",
+        "Connector height requires a nonnegative length.",
+        "usage"
+      );
+    const current = readConnector(this.element), top = current.top ?? 0;
+    this.#xml = applyConnectorUpdate(this.#xml, this.element, {
+      beginY: new Length(top + (current.flipVertical ? value.emu : 0)),
+      endY: new Length(top + (current.flipVertical ? 0 : value.emu))
+    });
+  }
+  get rotation() {
+    return readConnector(this.element).rotation;
+  }
+  set rotation(value) {
+    this.#xml = applyShapeUpdate(this.#xml, this.element, { rotation: value });
+  }
+  #target(shape) {
+    const element = shape.element;
+    const xml = shape.xml;
+    if (this.#owner && xml && shapeOwnerTokens.get(xml) === this.#owner && xml.root === element)
+      return nodeFor(this.#xml.root, String(readShape(element).shapeId));
+    return element;
+  }
+  begin_connect(shape, connectionSiteIdx) {
+    if (!shape || typeof shape !== "object" || !shape.element)
+      throw new OfficeError("invalid-value", "A current target XML view is required.", "usage");
+    this.#xml = applyConnectorUpdate(
+      this.#xml,
+      this.element,
+      { site: connectionSiteIdx },
+      { begin: this.#target(shape) }
+    );
+  }
+  end_connect(shape, connectionSiteIdx) {
+    if (!shape || typeof shape !== "object" || !shape.element)
+      throw new OfficeError("invalid-value", "A current target XML view is required.", "usage");
+    this.#xml = applyConnectorUpdate(
+      this.#xml,
+      this.element,
+      { site: connectionSiteIdx },
+      { end: this.#target(shape) }
+    );
+  }
+};
+
+// packages/safe-bash-presentation-engine/src/freeform-builder.ts
+function coordinate(value) {
+  const result = new Length(value).emu;
+  if (Math.abs(result) > 27273042316900)
+    throw new ValueError("Freeform coordinate exceeds DrawingML bounds.");
+  return result;
+}
+function index(value, length) {
+  if (!Number.isSafeInteger(value) || value < 0 || value >= length) throw new IndexError();
+  return value;
+}
+function budget(length) {
+  if (length > 4096)
+    throw new OfficeError("resource-limit", "Freeform operation limit exceeded.", "usage");
+}
+var FreeformPath = class {
+  #commands = [];
+  get commands() {
+    return Object.freeze([...this.#commands]);
+  }
+  append(command) {
+    budget(this.#commands.length + 1);
+    if (!command || !["move", "line", "close"].includes(command.type)) throw new TypeError();
+    if (command.type === "close") this.#commands.push(Object.freeze({ type: "close" }));
+    else
+      this.#commands.push(
+        Object.freeze({ type: command.type, x: coordinate(command.x), y: coordinate(command.y) })
+      );
+  }
+};
+var DrawingOperation = class {
+  constructor(type, x, y, offset = () => [0, 0]) {
+    this.type = type;
+    this.#offset = offset;
+    if (!["move", "line", "close"].includes(type)) throw new TypeError();
+    if (type !== "close") {
+      this.x = new Length(coordinate(x));
+      this.y = new Length(coordinate(y));
+    }
+    Object.freeze(this);
+  }
+  type;
+  #offset;
+  x;
+  y;
+  apply_operation_to(path) {
+    if (!(path instanceof FreeformPath))
+      throw new TypeError("Expected a bounded freeform path.");
+    path.append(
+      this.type === "close" ? { type: "close" } : {
+        type: this.type,
+        x: this.x.emu - this.#offset()[0],
+        y: this.y.emu - this.#offset()[1]
+      }
+    );
+  }
+};
+var FreeformBuilder = class {
+  #insert;
+  #operations = [];
+  #view;
+  #startX;
+  #startY;
+  #scaleX;
+  #scaleY;
+  constructor(insert, start_x = 0, start_y = 0, scale = 1) {
+    this.#insert = insert;
+    this.#startX = coordinate(start_x);
+    this.#startY = coordinate(start_y);
+    if (typeof insert !== "function") throw new TypeError();
+    if (typeof scale !== "number" && (!Array.isArray(scale) || scale.length !== 2))
+      throw new TypeError();
+    [this.#scaleX, this.#scaleY] = typeof scale === "number" ? [scale, scale] : scale;
+    if (![this.#scaleX, this.#scaleY].every(
+      (v) => typeof v === "number" && Number.isFinite(v) && v > 0
+    ))
+      throw new ValueError("Freeform scale must be positive and finite.");
+    this.#view = new Proxy(this, {
+      get(target, key) {
+        if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+          return target.#operations[index(Number(key), target.length)];
+        const value = Reflect.get(target, key, target);
+        return typeof value === "function" ? value.bind(target) : value;
+      },
+      set() {
+        throw new ValueError("Freeform builder members are read-only.");
+      },
+      defineProperty() {
+        throw new ValueError("Freeform builder members are read-only.");
+      },
+      deleteProperty() {
+        throw new ValueError("Freeform builder members are read-only.");
+      }
+    });
+    return this.#view;
+  }
+  get length() {
+    return this.#operations.length;
+  }
+  get shape_offset_x() {
+    return new Length(
+      Math.min(this.#startX, ...this.#operations.flatMap((op) => op.x ? [op.x.emu] : []))
+    );
+  }
+  get shape_offset_y() {
+    return new Length(
+      Math.min(this.#startY, ...this.#operations.flatMap((op) => op.y ? [op.y.emu] : []))
+    );
+  }
+  at(position2) {
+    if (!Number.isSafeInteger(position2)) throw new IndexError();
+    return this.#operations[index(position2 < 0 ? this.length + position2 : position2, this.length)];
+  }
+  *[Symbol.iterator]() {
+    yield* this.#operations;
+  }
+  includes(value) {
+    return this.#operations.includes(value);
+  }
+  count(value) {
+    return this.#operations.filter((op) => op === value).length;
+  }
+  index(value, start = 0, stop = this.length) {
+    if (![start, stop].every(Number.isSafeInteger)) throw new ValueError();
+    const first = start < 0 ? Math.max(0, this.length + start) : start;
+    const end = stop < 0 ? Math.max(0, this.length + stop) : Math.min(this.length, stop);
+    for (let i = first; i < end; i++) if (this.#operations[i] === value) return i;
+    throw new ValueError("Drawing operation is not in the selected sequence.");
+  }
+  *reversed() {
+    yield* [...this.#operations].reverse();
+  }
+  slice(start, end, step = 1) {
+    if (![...start === void 0 ? [] : [start], ...end === void 0 ? [] : [end], step].every(
+      Number.isSafeInteger
+    ) || step === 0)
+      throw new ValueError();
+    const normalize = (v) => Math.max(
+      step > 0 ? 0 : -1,
+      Math.min(step > 0 ? this.length : this.length - 1, v < 0 ? this.length + v : v)
+    );
+    const first = start === void 0 ? step > 0 ? 0 : this.length - 1 : normalize(start);
+    const last = end === void 0 ? step > 0 ? this.length : -1 : normalize(end);
+    const result = [];
+    for (let i = first; step > 0 ? i < last : i > last; i += step)
+      result.push(this.#operations[i]);
+    return Object.freeze(result);
+  }
+  add_line_segments(vertices, close = true) {
+    if (typeof close !== "boolean" || !vertices || typeof vertices[Symbol.iterator] !== "function")
+      throw new TypeError();
+    const additions = [];
+    for (const vertex of vertices) {
+      budget(this.length + additions.length + 2 + Number(close));
+      if (!Array.isArray(vertex) || vertex.length !== 2) throw new TypeError();
+      additions.push(
+        new DrawingOperation("line", vertex[0], vertex[1], () => [
+          this.shape_offset_x.emu,
+          this.shape_offset_y.emu
+        ])
+      );
+    }
+    if (close) additions.push(new DrawingOperation("close"));
+    budget(this.length + additions.length + 1);
+    this.#operations.push(...additions);
+    return this.#view;
+  }
+  move_to(x, y) {
+    budget(this.length + 2);
+    this.#operations.push(
+      new DrawingOperation("move", x, y, () => [this.shape_offset_x.emu, this.shape_offset_y.emu])
+    );
+    return this.#view;
+  }
+  convert_to_shape(origin_x = new Length(0), origin_y = new Length(0)) {
+    if (!(origin_x instanceof Length) || !(origin_y instanceof Length))
+      throw new TypeError("Freeform origins require Length values.");
+    const minX = this.shape_offset_x.emu, minY = this.shape_offset_y.emu;
+    const maxX = Math.max(
+      this.#startX,
+      ...this.#operations.flatMap((op) => op.x ? [op.x.emu] : [])
+    );
+    const maxY = Math.max(
+      this.#startY,
+      ...this.#operations.flatMap((op) => op.y ? [op.y.emu] : [])
+    );
+    const path = new FreeformPath();
+    path.append({ type: "move", x: this.#startX - minX, y: this.#startY - minY });
+    for (const operation of this) operation.apply_operation_to(path);
+    return this.#insert(
+      Object.freeze({
+        left: coordinate(origin_x.emu + coordinate(minX * this.#scaleX)),
+        top: coordinate(origin_y.emu + coordinate(minY * this.#scaleY)),
+        width: coordinate((maxX - minX) * this.#scaleX),
+        height: coordinate((maxY - minY) * this.#scaleY),
+        localWidth: coordinate(maxX - minX),
+        localHeight: coordinate(maxY - minY),
+        commands: Object.freeze(
+          path.commands.map(
+            (c) => Object.freeze(
+              c.type === "close" ? c : { type: c.type, x: coordinate(c.x), y: coordinate(c.y) }
+            )
+          )
+        )
+      })
+    );
+  }
+};
+
+// packages/safe-bash-presentation-engine/src/slide-model.ts
+function tree(xml, groupId) {
+  if (groupId !== void 0) {
+    const pending = [xml.root];
+    while (pending.length) {
+      const node = pending.pop();
+      if (node.name.localName === "grpSp" && readShape(node).shapeId === groupId) return node;
+      pending.push(...node.children);
+    }
+    throw new InvalidHandleError();
+  }
+  return required(required(xml.root, "cSld"), "spTree");
+}
+function shapes(xml, groupId) {
+  return tree(xml, groupId).children.filter(
+    (n) => ["sp", "pic", "graphicFrame", "cxnSp", "grpSp"].includes(n.name.localName)
+  );
+}
+function descendants(xml) {
+  const nodes = [], pending = [xml.root];
+  while (pending.length) {
+    const node = pending.pop();
+    nodes.push(node);
+    pending.push(...node.children);
+  }
+  return nodes;
+}
+function binding(owner, id, kind, _groupId) {
+  const node = (xml) => {
+    const matches = descendants(xml).filter(
+      (n) => ["sp", "grpSp", "pic", "graphicFrame"].includes(n.name.localName) && readShape(n).shapeId === id
+    );
+    if (matches.length !== 1 || matches[0].name.localName !== kind) throw new InvalidHandleError();
+    return matches[0];
+  };
+  let source, cached;
+  return {
+    ...owner.part === void 0 ? {} : { part: owner.part },
+    ...owner.hyperlink === void 0 ? {} : { hyperlink: (path) => owner.hyperlink(id, path) },
+    read() {
+      const xml = owner.read();
+      if (xml === source && cached) return cached;
+      cached = xml.subtree(node(xml));
+      shapeOwnerTokens.set(cached, owner);
+      source = xml;
+      return cached;
+    },
+    write(replacement) {
+      const xml = owner.read(), previous = node(xml), parent = descendants(xml).find((n) => n.children.includes(previous));
+      owner.write(
+        xml.spliceChildren(parent, parent.children.indexOf(previous), 1, [
+          replacement.markup(replacement.root, true)
+        ])
+      );
+    }
+  };
+}
+var InheritedShape = class extends Shape {
+  #owner;
+  #binding;
+  constructor(owner, id, kind, groupId) {
+    const bound = binding(owner, id, kind, groupId);
+    super(bound.read(), bound);
+    this.#owner = owner;
+    this.#binding = bound;
+  }
+  #dimension(key) {
+    const own = readShape(this.element)[key];
+    if (own !== null) return new Length(own);
+    if (!this.is_placeholder) return null;
+    const idx = this.placeholder_format.idx;
+    for (const inherited of this.#owner.inherited?.(idx) ?? []) {
+      const matches = shapes(inherited).filter((n) => readShape(n).placeholder?.idx === idx);
+      if (matches.length > 1)
+        throw new OfficeError(
+          "ambiguous-selection",
+          "Duplicate inherited placeholder key.",
+          "select"
+        );
+      const value = matches[0] && readShape(matches[0])[key];
+      if (value !== void 0 && value !== null) return new Length(value);
+    }
+    return null;
+  }
+  #setDimension(key, value) {
+    if (!(value instanceof Length)) throw new ValueError("Expected a Length.");
+    const pair = key === "left" ? "top" : key === "top" ? "left" : key === "width" ? "height" : "width";
+    const xml = this.#binding.read();
+    this.#binding.write(
+      applyShapeUpdate(xml, xml.root, {
+        [key]: value,
+        [pair]: this.#dimension(pair) ?? new Length(0)
+      })
+    );
+  }
+  get left() {
+    return this.#dimension("left");
+  }
+  set left(v) {
+    this.#setDimension("left", v);
+  }
+  get top() {
+    return this.#dimension("top");
+  }
+  set top(v) {
+    this.#setDimension("top", v);
+  }
+  get width() {
+    return this.#dimension("width");
+  }
+  set width(v) {
+    this.#setDimension("width", v);
+  }
+  get height() {
+    return this.#dimension("height");
+  }
+  set height(v) {
+    this.#setDimension("height", v);
+  }
+};
+var SlidePlaceholder = class extends InheritedShape {
+  #owner;
+  #binding;
+  constructor(owner, id, groupId) {
+    super(owner, id, "sp", groupId);
+    this.#owner = owner;
+    this.#binding = binding(owner, id, "sp", groupId);
+  }
+  #geometry() {
+    const values = {
+      left: this.left?.emu,
+      top: this.top?.emu,
+      width: this.width?.emu,
+      height: this.height?.emu
+    };
+    if (Object.values(values).some((v) => v === void 0))
+      throw new PropertyAccessError("Placeholder geometry is unresolved.");
+    return values;
+  }
+  insert_table(rows, cols) {
+    if (this.placeholder_format.type !== 12)
+      throw new ValueError("A table placeholder is required.");
+    const id = this.shape_id, xml = this.#binding.read();
+    let replacement = parseXmlPart(
+      new TextEncoder().encode(
+        createTableXml(
+          id,
+          {
+            rows,
+            columns: cols,
+            left: this.left,
+            top: this.top,
+            width: this.width,
+            height: new Length(rows * 370840)
+          },
+          xml.root.name.namespace
+        )
+      ),
+      xml.limits
+    );
+    replacement = preservePlaceholder(xml, replacement);
+    this.#binding.write(replacement);
+    return new GraphicFrame(this.#owner, id);
+  }
+  async insert_picture(input) {
+    if (this.placeholder_format.type !== 18)
+      throw new ValueError("A picture placeholder is required.");
+    const id = this.shape_id;
+    if (!this.#owner.insertRich)
+      throw new PropertyAccessError("Picture insertion requires a package owner.");
+    await this.#owner.insertRich(id, "picture", { input, ...this.#geometry(), fit: "cover" });
+    return new Picture(this.#owner, id);
+  }
+  insert_chart(type, data) {
+    const creationType = typeof type === "number" ? chartTypes.find((name) => XL_CHART_TYPE[name] === type) : chartTypes.find((name) => name === type);
+    if (!creationType) throw new ValueError("Unsupported chart creation type.");
+    if (this.placeholder_format.type !== 8)
+      throw new ValueError("A chart placeholder is required.");
+    const id = this.shape_id;
+    if (!this.#owner.insertChart)
+      throw new PropertyAccessError("Chart insertion requires a package owner.");
+    this.#owner.insertChart(id, {
+      type: creationType,
+      data: toChartData(data),
+      ...this.#geometry()
+    });
+    return new GraphicFrame(this.#owner, id);
+  }
+};
+function preservePlaceholder(previous, replacement) {
+  const oldNv = previous.root.children.find((n) => n.name.localName.startsWith("nv"));
+  const newNv = replacement.root.children.find((n) => n.name.localName.startsWith("nv"));
+  const identity = required(oldNv, "cNvPr"), target = required(newNv, "cNvPr");
+  replacement = replacement.merge(target, {
+    attributes: ["id", "name"].map((localName) => ({
+      namespace: "",
+      localName,
+      value: attr(identity, localName) ?? ""
+    }))
+  });
+  const nv = replacement.root.children.find((n) => n.name.localName.startsWith("nv"));
+  const props = required(nv, "nvPr"), oldProps = required(oldNv, "nvPr");
+  return replacement.spliceChildren(nv, nv.children.indexOf(props), 1, [
+    previous.markup(oldProps, true)
+  ]);
+}
+var GraphicFrame = class extends InheritedShape {
+  #table;
+  #owner;
+  #chart;
+  constructor(owner, id, groupId) {
+    const bound = binding(owner, id, "graphicFrame", groupId);
+    super(owner, id, "graphicFrame", groupId);
+    this.#owner = owner;
+    if (this.has_table) this.#table = new Table(bound.read(), void 0, bound);
+  }
+  get has_table() {
+    return this.element.children.some(
+      (n) => n.name.localName === "graphic" && n.children.some((d) => d.children.some((t) => t.name.localName === "tbl"))
+    );
+  }
+  get has_chart() {
+    return this.element.children.some(
+      (n) => n.name.localName === "graphic" && n.children.some((d) => d.children.some((t) => t.name.localName === "chart"))
+    );
+  }
+  get shape_type() {
+    if (this.is_placeholder) return 14;
+    const ole = descendants(this.xml).find((node) => node.name.localName === "oleObj");
+    if (ole) return ole.children.some((node) => node.name.localName === "link") ? 10 : 7;
+    return this.has_table ? 19 : 3;
+  }
+  get ole_format() {
+    if (!descendants(this.xml).some((node) => node.name.localName === "oleObj"))
+      throw new PropertyAccessError("Graphic frame has no OLE object.");
+    return new OleFormat(this, this.#owner);
+  }
+  get chart() {
+    if (!this.has_chart || !this.#owner.chart)
+      throw new PropertyAccessError("Graphic frame has no accessible chart.");
+    return this.#chart ??= this.#owner.chart(this.shape_id);
+  }
+  get table() {
+    void this.element;
+    if (!this.#table) throw new PropertyAccessError("Graphic frame has no table.");
+    return this.#table;
+  }
+};
+var Picture = class extends InheritedShape {
+  #owner;
+  #binding;
+  constructor(owner, id, groupId) {
+    const bound = binding(owner, id, "pic", groupId);
+    super(owner, id, "pic", groupId);
+    this.#binding = bound;
+    this.#owner = owner;
+  }
+  get image() {
+    const blip = required(this.element, "blipFill").children.find(
+      (node) => node.name.localName === "blip"
+    );
+    if (!blip) throw new PropertyAccessError("Picture has no image reference.");
+    const id = blip.attributes.find(
+      (attribute) => attribute.name.localName === "embed" && attribute.name.namespace.endsWith("/relationships")
+    )?.value;
+    if (!id || !this.#owner.resource)
+      throw new PropertyAccessError("Picture has no embedded image.");
+    const resource = this.#owner.resource(id);
+    return new Image(
+      resource.blob,
+      null,
+      resource.content_type === "image/jpg" ? "image/jpeg" : resource.content_type
+    );
+  }
+  get shape_type() {
+    return this.is_placeholder ? 14 : 13;
+  }
+  #crop(side) {
+    const fill = required(this.element, "blipFill");
+    const crop = fill.children.find((n) => n.name.localName === "srcRect");
+    return Number(crop && attr(crop, side) || 0) / 1e5;
+  }
+  #setCrop(key, value) {
+    const xml = this.#binding.read();
+    this.#binding.write(applyPictureUpdate(xml, xml.root, { [key]: value }, "signed-fraction"));
+  }
+  get crop_left() {
+    return this.#crop("l");
+  }
+  set crop_left(v) {
+    this.#setCrop("cropLeft", v);
+  }
+  get crop_right() {
+    return this.#crop("r");
+  }
+  set crop_right(v) {
+    this.#setCrop("cropRight", v);
+  }
+  get crop_top() {
+    return this.#crop("t");
+  }
+  set crop_top(v) {
+    this.#setCrop("cropTop", v);
+  }
+  get crop_bottom() {
+    return this.#crop("b");
+  }
+  set crop_bottom(v) {
+    this.#setCrop("cropBottom", v);
+  }
+};
+var MediaFormat = class {
+  constructor(parent) {
+    this.parent = parent;
+  }
+  parent;
+  get element() {
+    return this.parent.element;
+  }
+  get part() {
+    return this.parent.part;
+  }
+};
+var Movie = class extends Picture {
+  get shape_type() {
+    return 16;
+  }
+  get media_type() {
+    void this.element;
+    return PP_MEDIA_TYPE.MOVIE;
+  }
+  get media_format() {
+    return new MediaFormat(this);
+  }
+  get poster_frame() {
+    const fill = this.element.children.find(
+      (node) => node.name.localName === "blipFill" && node.name.namespace === this.element.name.namespace
+    );
+    const a = this.element.name.namespace.includes("purl") ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+    const blip = fill?.children.find(
+      (node) => node.name.localName === "blip" && node.name.namespace === a
+    );
+    if (!blip?.attributes.some(
+      (attribute) => attribute.name.localName === "embed" && attribute.name.namespace.endsWith("/relationships")
+    ))
+      return null;
+    return this.image;
+  }
+};
+var OleFormat = class {
+  constructor(parent, owner) {
+    this.parent = parent;
+    this.owner = owner;
+  }
+  parent;
+  owner;
+  get element() {
+    const graphic = this.parent.element.children.find((node) => node.name.localName === "graphic");
+    if (!graphic) throw new PropertyAccessError("Graphic frame has no graphic data.");
+    return required(graphic, "graphicData");
+  }
+  get part() {
+    return this.parent.part;
+  }
+  get prog_id() {
+    return attr(this.element.children.find((node) => node.name.localName === "oleObj"), "progId") ?? null;
+  }
+  get show_as_icon() {
+    return ["1", "true"].includes(
+      attr(this.element.children.find((node) => node.name.localName === "oleObj"), "showAsIcon") ?? "0"
+    );
+  }
+  get blob() {
+    const ole = this.element.children.find((node) => node.name.localName === "oleObj");
+    if (!ole.children.some((node) => node.name.localName === "embed")) return null;
+    const id = ole.attributes.find(
+      (attribute) => attribute.name.localName === "id" && attribute.name.namespace.endsWith("/relationships")
+    )?.value;
+    if (!id) return null;
+    if (!this.owner.resource) throw new PropertyAccessError("OLE object has no embedded resource.");
+    return new Uint8Array(this.owner.resource(id).blob);
+  }
+};
+function recalculateGroups(document, initialId) {
+  let groupId = initialId;
+  while (groupId !== void 0) {
+    let group = tree(document, groupId);
+    const ancestor = descendants(document).find(
+      (node) => node.name.localName === "grpSp" && node.children.includes(group)
+    );
+    const children = shapes(document, groupId).map(readShape);
+    if (children.length && children.every(
+      (shape) => [shape.left, shape.top, shape.width, shape.height].every((value) => value !== null)
+    )) {
+      const left = Math.min(...children.map((shape) => shape.left)), top = Math.min(...children.map((shape) => shape.top));
+      const width = Math.max(...children.map((shape) => shape.left + shape.width)) - left, height = Math.max(...children.map((shape) => shape.top + shape.height)) - top;
+      const namespace = group.name.namespace.includes("purl") ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+      for (const [name, values] of [
+        ["off", { x: left, y: top }],
+        ["ext", { cx: width, cy: height }],
+        ["chOff", { x: left, y: top }],
+        ["chExt", { cx: width, cy: height }]
+      ]) {
+        group = tree(document, groupId);
+        const props = required(group, "grpSpPr"), transform = props.children.find((node2) => node2.name.localName === "xfrm");
+        if (!transform) {
+          document = document.spliceChildren(props, 0, 0, [`<a:xfrm xmlns:a="${namespace}"/>`]);
+        }
+        const xfrm = required(tree(document, groupId), "grpSpPr").children.find(
+          (node2) => node2.name.localName === "xfrm" && node2.name.namespace === namespace
+        );
+        const node = xfrm.children.find(
+          (node2) => node2.name.localName === name && node2.name.namespace === namespace
+        );
+        const attributes = Object.entries(values).map(([localName, value]) => ({
+          namespace: "",
+          localName,
+          value: String(value)
+        }));
+        if (node) document = document.merge(node, { attributes });
+        else
+          document = document.spliceChildren(xfrm, xfrm.children.length, 0, [
+            `<a:${name} xmlns:a="${namespace}" ${Object.entries(values).map(([key, value]) => `${key}="${value}"`).join(" ")}/>`
+          ]);
+      }
+    }
+    groupId = ancestor ? readShape(ancestor).shapeId : void 0;
+  }
+  return document;
+}
+function reparentInsertedAsset(document, id, groupId) {
+  const root = tree(document);
+  const node = shapes(document).find((node2) => readShape(node2).shapeId === id);
+  if (!node) throw new InvalidHandleError();
+  const markup = document.markup(node, true);
+  document = document.spliceChildren(root, root.children.indexOf(node), 1, []);
+  const group = tree(document, groupId);
+  const extension = group.children.findIndex((node2) => node2.name.localName === "extLst");
+  document = document.spliceChildren(group, extension < 0 ? group.children.length : extension, 0, [
+    markup
+  ]);
+  return recalculateGroups(document, groupId);
+}
+var SlideShapes = class _SlideShapes {
+  #owner;
+  #groupId;
+  #allocator;
+  constructor(owner, groupId) {
+    this.#owner = owner;
+    this.#groupId = groupId;
+    this.#allocator = new ShapeIdAllocator(owner.read);
+    return indexed(this);
+  }
+  get length() {
+    return shapes(this.#owner.read(), this.#groupId).length;
+  }
+  at(index2) {
+    if (!Number.isSafeInteger(index2)) throw new IndexError();
+    return this.get(index2 < 0 ? this.length + index2 : index2);
+  }
+  get_by_id(id) {
+    const position2 = shapes(this.#owner.read(), this.#groupId).findIndex(
+      (node) => readShape(node).shapeId === id
+    );
+    return position2 < 0 ? null : this.get(position2);
+  }
+  get title() {
+    const position2 = shapes(this.#owner.read(), this.#groupId).findIndex(
+      (node) => ["title", "ctrTitle"].includes(readShape(node).placeholder?.type ?? "")
+    );
+    return position2 < 0 ? null : this.get(position2);
+  }
+  get turbo_add_enabled() {
+    return this.#allocator.turbo_add_enabled;
+  }
+  set turbo_add_enabled(value) {
+    this.#allocator.turbo_add_enabled = value;
+  }
+  get(index2) {
+    const nodes = shapes(this.#owner.read(), this.#groupId);
+    if (!Number.isSafeInteger(index2) || index2 < 0 || index2 >= nodes.length) throw new IndexError();
+    const node = nodes[index2], id = readShape(node).shapeId;
+    if (node.name.localName === "cxnSp") {
+      const xml = this.#owner.read();
+      shapeOwnerTokens.set(xml, this.#owner);
+      return new Connector(xml, id, this.#owner);
+    }
+    if (node.name.localName === "grpSp") {
+      const bound2 = binding(this.#owner, id, "grpSp", this.#groupId);
+      return new GroupShape(bound2.read(), new _SlideShapes(this.#owner, id), bound2);
+    }
+    if (node.name.localName === "graphicFrame")
+      return new GraphicFrame(this.#owner, id, this.#groupId);
+    if (node.name.localName === "pic") {
+      const a = node.name.namespace.includes("purl") ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+      const props = required(required(node, "nvPicPr"), "nvPr");
+      const media = props.children.some(
+        (child2) => child2.name.localName === "videoFile" && child2.name.namespace === a
+      );
+      return media ? new Movie(this.#owner, id, this.#groupId) : new Picture(this.#owner, id, this.#groupId);
+    }
+    if (readShape(node).placeholder) return new SlidePlaceholder(this.#owner, id, this.#groupId);
+    const bound = binding(this.#owner, id, node.name.localName, this.#groupId);
+    return new Shape(bound.read(), bound);
+  }
+  #append(makeMarkup) {
+    const xml = this.#owner.read(), parent = tree(xml, this.#groupId);
+    let updated = this.#allocator.append(parent, makeMarkup).xml;
+    if (this.#groupId !== void 0) updated = recalculateGroups(updated, this.#groupId);
+    this.#owner.write(updated);
+    return this.get(this.length - 1);
+  }
+  add_chart(chart_type, x, y, cx, cy, chart_data) {
+    if (this.#groupId !== void 0)
+      throw new OfficeError(
+        "unsupported-edit",
+        "Chart insertion into groups is unsupported.",
+        "validate-intent"
+      );
+    if (![x, y, cx, cy].every((value) => value instanceof Length))
+      throw new TypeError("Chart geometry requires Length values.");
+    if (typeof chart_type !== "number" && typeof chart_type !== "string")
+      throw new TypeError("Chart type requires an enum value or registered name.");
+    if (!(chart_data instanceof CategoryChartData) && !(chart_data instanceof XyChartData) && !(chart_data instanceof BubbleChartData))
+      throw new TypeError("Chart data requires a chart data builder.");
+    const type = typeof chart_type === "number" ? chartTypes.find((name) => XL_CHART_TYPE[name] === chart_type) : chartTypes.find((name) => name === chart_type);
+    if (!type) throw new ValueError("Unsupported chart creation type.");
+    if (!this.#owner.addChart)
+      throw new PropertyAccessError("Chart insertion requires a package owner.");
+    const id = this.#owner.addChart({
+      type,
+      data: toChartData(chart_data),
+      left: x.emu,
+      top: y.emu,
+      width: cx.emu,
+      height: cy.emu
+    });
+    return new GraphicFrame(this.#owner, id);
+  }
+  async add_picture(input, left, top, width = null, height = null) {
+    if (!this.#owner.insertAsset)
+      throw new PropertyAccessError("Insertion requires a package owner.");
+    const id = await this.#owner.insertAsset(
+      "picture",
+      { input, left, top, width, height },
+      this.#groupId
+    );
+    return this.get_by_id(id);
+  }
+  async add_movie(input, left, top, width, height, options) {
+    if (!this.#owner.insertAsset)
+      throw new PropertyAccessError("Insertion requires a package owner.");
+    if (!options || !options.poster_frame_image || typeof options.mime_type !== "string")
+      throw new ValueError("Movie insertion requires an explicit poster and MIME type.");
+    const id = await this.#owner.insertAsset(
+      "movie",
+      { input, left, top, width, height, ...options },
+      this.#groupId
+    );
+    return this.get_by_id(id);
+  }
+  async add_ole_object(input, prog_id, left, top, options) {
+    if (!this.#owner.insertAsset)
+      throw new PropertyAccessError("Insertion requires a package owner.");
+    if (!options || !options.icon_file)
+      throw new ValueError("OLE insertion requires an explicit icon.");
+    const application = Object.values(PROG_ID).find((value) => value === prog_id);
+    if (typeof prog_id !== "string" && !application)
+      throw new ValueError("Expected a program ID or registered application.");
+    const id = await this.#owner.insertAsset(
+      "ole",
+      {
+        input,
+        prog_id,
+        left,
+        top,
+        ...application ? { width: application.width, height: application.height } : {},
+        ...options
+      },
+      this.#groupId
+    );
+    return this.get_by_id(id);
+  }
+  add_shape(kind, left, top, width, height) {
+    return this.#append(
+      (id) => createShapeXml(kind, id, { left, top, width, height }, this.#owner.read().root.name.namespace)
+    );
+  }
+  add_table(rows, cols, left, top, width, height) {
+    return this.#append(
+      (id) => createTableXml(
+        id,
+        { rows, columns: cols, left, top, width, height },
+        this.#owner.read().root.name.namespace
+      )
+    );
+  }
+  add_textbox(left, top, width, height) {
+    return this.#append(
+      (id) => createShapeXml(
+        "text-box",
+        id,
+        { left, top, width, height },
+        this.#owner.read().root.name.namespace
+      )
+    );
+  }
+  add_connector(kind, begin_x, begin_y, end_x, end_y) {
+    return this.#append(
+      (id) => createConnectorXml(
+        id,
+        { kind, beginX: begin_x, beginY: begin_y, endX: end_x, endY: end_y },
+        this.#owner.read().root.name.namespace
+      )
+    );
+  }
+  add_group_shape(selected = []) {
+    const source = this.#owner.read(), parent = tree(source, this.#groupId), members = [], ids = /* @__PURE__ */ new Set();
+    for (const handle of selected) {
+      if (members.length >= 4096)
+        throw new OfficeError("resource-limit", "Group child limit exceeded.", "usage");
+      if (!(handle instanceof Shape) && !(handle instanceof Connector))
+        throw new ValueError("Expected an owned shape handle.");
+      const id2 = handle.shape_id;
+      const member = shapes(source, this.#groupId).find((node) => readShape(node).shapeId === id2);
+      if (shapeOwnerTokens.get(handle.xml) !== this.#owner || !member || ids.has(id2))
+        throw new ValueError("Group members must be distinct direct children of this collection.");
+      const geometry = readShape(member);
+      if ([geometry.left, geometry.top, geometry.width, geometry.height].some((v) => v === null))
+        throw new PropertyAccessError("Grouping requires explicit geometry.");
+      ids.add(id2);
+      members.push(member);
+    }
+    const p = source.root.name.namespace, a = p.includes("purl") ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+    const values = members.map(readShape), left = values.length ? Math.min(...values.map((x) => x.left)) : 0, top = values.length ? Math.min(...values.map((x) => x.top)) : 0;
+    const width = values.length ? Math.max(...values.map((x) => x.left + x.width)) - left : 0, height = values.length ? Math.max(...values.map((x) => x.top + x.height)) - top : 0;
+    const markup = (id2) => `<p:grpSp xmlns:p="${p}" xmlns:a="${a}"><p:nvGrpSpPr><p:cNvPr id="${id2}" name="Group ${id2}"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr><a:xfrm><a:off x="${left}" y="${top}"/><a:ext cx="${width}" cy="${height}"/><a:chOff x="${left}" y="${top}"/><a:chExt cx="${width}" cy="${height}"/></a:xfrm></p:grpSpPr>${members.map((node) => source.markup(node, true)).join("")}</p:grpSp>`;
+    if (!members.length) return this.#append(markup);
+    const id = this.#allocator.next();
+    const retained = parent.children.filter((node) => !members.includes(node));
+    const extension = retained.findIndex((node) => node.name.localName === "extLst");
+    const children = retained.map((node) => source.markup(node, true));
+    children.splice(extension < 0 ? children.length : extension, 0, markup(id));
+    let updated = source.spliceChildren(parent, 0, parent.children.length, children);
+    if (this.#groupId !== void 0) updated = recalculateGroups(updated, this.#groupId);
+    this.#owner.write(updated);
+    return this.get_by_id(id);
+  }
+  build_freeform(start_x = 0, start_y = 0, scale = 1) {
+    return new FreeformBuilder(
+      (geometry) => {
+        const p = this.#owner.read().root.name.namespace, a = p.includes("purl") ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+        const commands = geometry.commands.map(
+          (command) => command.type === "close" ? "<a:close/>" : `<a:${command.type === "move" ? "moveTo" : "lnTo"}><a:pt x="${command.x}" y="${command.y}"/></a:${command.type === "move" ? "moveTo" : "lnTo"}>`
+        ).join("");
+        return this.#append(
+          (id) => `<p:sp xmlns:p="${p}" xmlns:a="${a}"><p:nvSpPr><p:cNvPr id="${id}" name="Freeform ${id}"/><p:cNvSpPr/><p:nvPr/></p:nvSpPr><p:spPr><a:xfrm><a:off x="${geometry.left}" y="${geometry.top}"/><a:ext cx="${geometry.width}" cy="${geometry.height}"/></a:xfrm><a:custGeom><a:avLst/><a:gdLst/><a:ahLst/><a:cxnLst/><a:rect l="0" t="0" r="r" b="b"/><a:pathLst><a:path w="${geometry.localWidth}" h="${geometry.localHeight}">${commands}</a:path></a:pathLst></a:custGeom></p:spPr></p:sp>`
+        );
+      },
+      start_x,
+      start_y,
+      scale
+    );
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.length; i++) yield this.get(i);
+  }
+};
+var SlidePlaceholders = class {
+  #owner;
+  constructor(owner) {
+    this.#owner = owner;
+    return indexed(this);
+  }
+  #entries() {
+    const entries = shapes(this.#owner.read()).map((node, index2) => ({ node, index: index2, ph: readShape(node).placeholder })).filter((x) => x.ph !== null);
+    const keys = /* @__PURE__ */ new Set();
+    for (const x of entries) {
+      if (!Number.isSafeInteger(x.ph.idx) || x.ph.idx < 0 || x.ph.idx > 4294967295)
+        throw new ValueError("Invalid placeholder key.");
+      if (keys.has(x.ph.idx))
+        throw new OfficeError("ambiguous-selection", "Duplicate placeholder key.", "select");
+      keys.add(x.ph.idx);
+    }
+    return entries.sort((a, b) => a.ph.idx - b.ph.idx);
+  }
+  get length() {
+    return this.#entries().length;
+  }
+  get(idx) {
+    const entry = this.#entries().find((x) => x.ph.idx === idx);
+    if (!Number.isSafeInteger(idx) || !entry) throw new KeyError();
+    return new SlideShapes(this.#owner).get(entry.index);
+  }
+  *[Symbol.iterator]() {
+    for (const entry of this.#entries()) yield this.get(entry.ph.idx);
+  }
+};
+var Slide = class {
+  constructor(slide_id, owner) {
+    this.slide_id = slide_id;
+    this.#owner = owner;
+    this.shapes = new SlideShapes(owner);
+    this.placeholders = new SlidePlaceholders(owner);
+  }
+  slide_id;
+  shapes;
+  placeholders;
+  #owner;
+  get element() {
+    return this.#owner.read().root;
+  }
+  get part() {
+    this.#owner.read();
+    if (!this.#owner.part) throw new PropertyAccessError("Slide has no package part.");
+    return this.#owner.part;
+  }
+  get name() {
+    return attr(required(this.element, "cSld"), "name") ?? "";
+  }
+  set name(value) {
+    if (typeof value !== "string") throw new ValueError("Expected slide name text.");
+    const xml = this.#owner.read();
+    this.#owner.write(
+      xml.merge(required(xml.root, "cSld"), {
+        attributes: [{ namespace: "", localName: "name", value }]
+      })
+    );
+  }
+};
+var Slides = class {
+  #items;
+  #add;
+  constructor(items, add) {
+    this.#items = [...items];
+    this.#add = add;
+    return indexed(this);
+  }
+  add_slide(slide_layout) {
+    if (!this.#add) throw new PropertyAccessError("Slide insertion requires a presentation owner.");
+    const slide = this.#add(slide_layout);
+    this.#items.push(slide);
+    return slide;
+  }
+  get length() {
+    return this.#items.length;
+  }
+  get(index2) {
+    if (!Number.isSafeInteger(index2) || index2 < 0 || index2 >= this.length) throw new IndexError();
+    return this.#items[index2];
+  }
+  at(index2) {
+    if (!Number.isSafeInteger(index2)) throw new IndexError();
+    return this.get(index2 < 0 ? this.length + index2 : index2);
+  }
+  get_by_id(id) {
+    return this.#items.find((slide) => slide.slide_id === id) ?? null;
+  }
+  *[Symbol.iterator]() {
+    yield* this.#items;
+  }
+};
+
+export {
+  indexed,
+  PP_MEDIA_TYPE,
+  Table,
+  TableCell,
+  TableRows,
+  TableColumns,
+  TableRow,
+  TableColumn,
+  TableCells,
+  GroupShape,
+  Connector,
+  FreeformPath,
+  DrawingOperation,
+  FreeformBuilder,
+  SlidePlaceholder,
+  preservePlaceholder,
+  GraphicFrame,
+  Picture,
+  MediaFormat,
+  Movie,
+  OleFormat,
+  reparentInsertedAsset,
+  SlideShapes,
+  SlidePlaceholders,
+  Slide,
+  Slides
+};