@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,3669 @@
+import {
+  inspectChart,
+  readCharts
+} from "./chunk-AJEYCC4X.js";
+import {
+  XL_AXIS_CROSSES,
+  XL_CATEGORY_TYPE,
+  XL_CHART_TYPE,
+  XL_DATA_LABEL_POSITION,
+  XL_LEGEND_POSITION,
+  XL_MARKER_STYLE,
+  XL_TICK_LABEL_POSITION,
+  XL_TICK_MARK,
+  applyChartFontUpdate,
+  validateChartObjectUpdates
+} from "./chunk-ZTAFAHY3.js";
+import {
+  nodeFor,
+  validateSelection
+} from "./chunk-QHS7PDG3.js";
+import {
+  FillFormat,
+  LineFormat,
+  ShadowFormat,
+  TextFrame,
+  applyFrameFormatting,
+  applyShapeUpdate
+} from "./chunk-HHLVI2CB.js";
+import {
+  createXmlElementView
+} from "./chunk-QXCSASIE.js";
+import {
+  ShapeIdAllocator
+} from "./chunk-RZC7QHL6.js";
+import {
+  applyDrawingUpdate,
+  validateDrawingUpdate
+} from "./chunk-A3XE767Q.js";
+import {
+  attr,
+  child,
+  escape,
+  loadShared,
+  nextRel,
+  relPart,
+  required
+} from "./chunk-RAXJVM4U.js";
+import {
+  writePackageArchive
+} from "./chunk-YRNBIU5U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  readPackage
+} from "./chunk-FRZ5P5AB.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  parseContentTypes
+} from "./chunk-N74TJL6X.js";
+import {
+  readRelationshipGraph
+} from "./chunk-5GEFJROP.js";
+import {
+  relativePartReference
+} from "./chunk-XXFHTGV2.js";
+import {
+  IndexError,
+  InvalidHandleError,
+  OfficeError,
+  PropertyAccessError,
+  TypeError,
+  ValueError
+} from "./chunk-RR6QQ25D.js";
+import {
+  __export
+} from "./chunk-65DS4IOB.js";
+
+// packages/safe-bash-presentation-engine/src/chart-model-core.ts
+function chartBinding(read, write) {
+  const handles = [];
+  let previous = read();
+  const synchronize = (next) => {
+    if (previous === next) return;
+    previous = next;
+    for (const handle of handles) {
+      if (!handle.valid) continue;
+      try {
+        handle.locate(next);
+      } catch {
+        handle.valid = false;
+      }
+    }
+  };
+  const trackedRead = () => {
+    const next = read();
+    synchronize(next);
+    return next;
+  };
+  const trackedWrite = (xml) => {
+    write(xml);
+    synchronize(xml);
+  };
+  const track = (locate) => {
+    const state2 = { locate, valid: true };
+    handles.push(state2);
+    return (xml) => {
+      if (!state2.valid) throw new InvalidHandleError();
+      return locate(xml);
+    };
+  };
+  return { read: trackedRead, write: trackedWrite, locate: (xml) => xml.root, track };
+}
+var order = {
+  chartSpace: [
+    "date1904",
+    "lang",
+    "roundedCorners",
+    "AlternateContent",
+    "style",
+    "clrMapOvr",
+    "pivotSource",
+    "protection",
+    "chart",
+    "spPr",
+    "txPr",
+    "externalData",
+    "printSettings",
+    "userShapes",
+    "extLst"
+  ],
+  chart: [
+    "title",
+    "autoTitleDeleted",
+    "pivotFmts",
+    "view3D",
+    "floor",
+    "sideWall",
+    "backWall",
+    "plotArea",
+    "legend",
+    "plotVisOnly",
+    "dispBlanksAs",
+    "showDLblsOverMax",
+    "extLst"
+  ],
+  title: ["tx", "layout", "overlay", "spPr", "txPr", "extLst"],
+  legend: ["legendPos", "legendEntry", "layout", "overlay", "spPr", "txPr", "extLst"],
+  catAx: [
+    "axId",
+    "scaling",
+    "delete",
+    "axPos",
+    "majorGridlines",
+    "minorGridlines",
+    "title",
+    "numFmt",
+    "majorTickMark",
+    "minorTickMark",
+    "tickLblPos",
+    "spPr",
+    "txPr",
+    "crossAx",
+    "crosses",
+    "crossesAt",
+    "auto",
+    "lblAlgn",
+    "lblOffset",
+    "tickLblSkip",
+    "tickMarkSkip",
+    "noMultiLvlLbl",
+    "extLst"
+  ],
+  valAx: [
+    "axId",
+    "scaling",
+    "delete",
+    "axPos",
+    "majorGridlines",
+    "minorGridlines",
+    "title",
+    "numFmt",
+    "majorTickMark",
+    "minorTickMark",
+    "tickLblPos",
+    "spPr",
+    "txPr",
+    "crossAx",
+    "crosses",
+    "crossesAt",
+    "crossBetween",
+    "majorUnit",
+    "minorUnit",
+    "dispUnits",
+    "extLst"
+  ],
+  dateAx: [
+    "axId",
+    "scaling",
+    "delete",
+    "axPos",
+    "majorGridlines",
+    "minorGridlines",
+    "title",
+    "numFmt",
+    "majorTickMark",
+    "minorTickMark",
+    "tickLblPos",
+    "spPr",
+    "txPr",
+    "crossAx",
+    "crosses",
+    "crossesAt",
+    "auto",
+    "lblOffset",
+    "baseTimeUnit",
+    "majorUnit",
+    "majorTimeUnit",
+    "minorUnit",
+    "minorTimeUnit",
+    "extLst"
+  ],
+  scaling: ["logBase", "orientation", "max", "min", "extLst"],
+  marker: ["symbol", "size", "spPr", "extLst"],
+  dPt: [
+    "idx",
+    "invertIfNegative",
+    "marker",
+    "bubble3D",
+    "explosion",
+    "spPr",
+    "pictureOptions",
+    "extLst"
+  ],
+  dLbl: [
+    "idx",
+    "layout",
+    "tx",
+    "numFmt",
+    "spPr",
+    "txPr",
+    "dLblPos",
+    "showLegendKey",
+    "showVal",
+    "showCatName",
+    "showSerName",
+    "showPercent",
+    "showBubbleSize",
+    "separator",
+    "extLst"
+  ],
+  dLbls: [
+    "dLbl",
+    "delete",
+    "numFmt",
+    "spPr",
+    "txPr",
+    "dLblPos",
+    "showLegendKey",
+    "showVal",
+    "showCatName",
+    "showSerName",
+    "showPercent",
+    "showBubbleSize",
+    "separator",
+    "showLeaderLines",
+    "leaderLines",
+    "extLst"
+  ],
+  ser: [
+    "idx",
+    "order",
+    "tx",
+    "spPr",
+    "invertIfNegative",
+    "pictureOptions",
+    "marker",
+    "dPt",
+    "dLbls",
+    "trendline",
+    "errBars",
+    "cat",
+    "val",
+    "xVal",
+    "yVal",
+    "bubbleSize",
+    "smooth",
+    "bubble3D",
+    "extLst"
+  ],
+  manualLayout: ["layoutTarget", "xMode", "yMode", "wMode", "hMode", "x", "y", "w", "h", "extLst"]
+};
+var plotOrder = [
+  "barDir",
+  "grouping",
+  "scatterStyle",
+  "radarStyle",
+  "varyColors",
+  "ser",
+  "dLbls",
+  "dropLines",
+  "hiLowLines",
+  "upDownBars",
+  "marker",
+  "smooth",
+  "gapWidth",
+  "gapDepth",
+  "overlap",
+  "serLines",
+  "firstSliceAng",
+  "holeSize",
+  "ofPieType",
+  "splitType",
+  "splitPos",
+  "custSplit",
+  "secondPieSize",
+  "bubbleScale",
+  "showNegBubbles",
+  "sizeRepresents",
+  "bandFmts",
+  "wireframe",
+  "axId",
+  "extLst"
+];
+function numberValue(value, min = -Infinity, max = Infinity, integer = false) {
+  if (typeof value !== "number") throw new TypeError();
+  if (!Number.isFinite(value) || value < min || value > max || integer && !Number.isInteger(value))
+    throw new ValueError();
+}
+function booleanValue(value) {
+  if (typeof value !== "boolean") throw new TypeError();
+}
+function readBoolean(node, defaultValue) {
+  if (!node) return defaultValue;
+  const token2 = attr(node, "val");
+  if (token2 === void 0 || token2 === "1" || token2 === "true") return true;
+  if (token2 === "0" || token2 === "false") return false;
+  throw new ValueError("Invalid chart boolean.");
+}
+var chartBindings = /* @__PURE__ */ new WeakMap();
+function chartNodeBinding(node) {
+  const binding = chartBindings.get(node);
+  if (!binding) throw new InvalidHandleError();
+  binding.locate(binding.read());
+  return binding;
+}
+function chartNode(node) {
+  const binding = chartNodeBinding(node);
+  return binding.locate(binding.read());
+}
+function chartDescendant(self, name, create = false) {
+  if (create && !child(chartNode(self), name)) chartPut(self, name, "");
+  const parent = chartNodeBinding(self);
+  return {
+    read: parent.read,
+    write: parent.write,
+    track: parent.track,
+    locate: (xml) => {
+      const found = child(parent.locate(xml), name);
+      if (!found) throw new InvalidHandleError();
+      return found;
+    }
+  };
+}
+function chartOptionalDescendant(self, name) {
+  const parent = chartNodeBinding(self), virtual = {
+    name: { namespace: chartNode(self).name.namespace, localName: name },
+    attributes: [],
+    children: []
+  };
+  let materialized = !!child(chartNode(self), name);
+  return {
+    read: parent.read,
+    write: parent.write,
+    track: parent.track,
+    prepare: () => {
+      parent.prepare?.();
+      if (!child(chartNode(self), name)) chartPut(self, name, "");
+    },
+    locate: (xml) => {
+      const found = child(parent.locate(xml), name);
+      if (found) {
+        materialized = true;
+        return found;
+      }
+      if (materialized) throw new InvalidHandleError();
+      return virtual;
+    }
+  };
+}
+function chartPut(self, name, content, attributes = {}) {
+  chartNodeBinding(self).prepare?.();
+  const document = chartNodeBinding(self).read(), node = chartNodeBinding(self).locate(document), existing = child(node, name);
+  if (content === null) {
+    if (existing)
+      chartNodeBinding(self).write(
+        document.spliceChildren(node, node.children.indexOf(existing), 1, [])
+      );
+    return;
+  }
+  const sequence = order[node.name.localName] ?? (node.name.localName.endsWith("Chart") ? plotOrder : [name, "extLst"]);
+  const rank = sequence.indexOf(name);
+  const next = node.children.findIndex(
+    (n) => n.name.namespace === node.name.namespace && sequence.indexOf(n.name.localName) > rank
+  );
+  const index = existing ? node.children.indexOf(existing) : next < 0 ? node.children.length : next;
+  const markup = `<c:${name} xmlns:c="${node.name.namespace}"${Object.entries(attributes).map(([key, value]) => ` ${key}="${escape(value)}"`).join("")}>${content}</c:${name}>`;
+  chartNodeBinding(self).write(document.spliceChildren(node, index, existing ? 1 : 0, [markup]));
+}
+var ChartNode = class _ChartNode {
+  #binding;
+  constructor(binding) {
+    this.#binding = { ...binding, locate: binding.track?.(binding.locate) ?? binding.locate };
+    chartBindings.set(this, this.#binding);
+  }
+  scalar(name) {
+    const n = child(chartNode(this), name);
+    return n ? attr(n, "val") ?? null : null;
+  }
+  setScalar(name, value) {
+    if (value === null) {
+      chartPut(this, name, null);
+      return;
+    }
+    const xml = this.#binding.read(), node = this.#binding.locate(xml), existing = child(node, name);
+    const encoded = typeof value === "boolean" ? value ? "1" : "0" : String(value);
+    if (existing)
+      this.#binding.write(
+        xml.merge(existing, { attributes: [{ namespace: "", localName: "val", value: encoded }] })
+      );
+    else chartPut(this, name, "", { val: encoded });
+  }
+  present(name, value) {
+    booleanValue(value);
+    if (value) {
+      if (!child(chartNode(this), name)) chartPut(this, name, "");
+    } else chartPut(this, name, null);
+  }
+  textFrame(name = "txPr") {
+    if (!child(chartNode(this), name)) {
+      const ans = chartNode(this).name.namespace.includes("purl.oclc.org") ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+      chartPut(
+        this,
+        name,
+        `<a:bodyPr xmlns:a="${ans}"/><a:lstStyle xmlns:a="${ans}"/><a:p xmlns:a="${ans}"/>`
+      );
+    }
+    const binding = chartDescendant(this, name);
+    let owner, cached;
+    const read = () => {
+      const xml = binding.read();
+      if (owner !== xml) {
+        cached = xml.subtree(binding.locate(xml));
+        owner = xml;
+      }
+      return cached;
+    };
+    return new TextFrame(read(), void 0, {
+      read,
+      write: (next) => {
+        const xml = binding.read(), parent = this.#binding.locate(xml), node = binding.locate(xml);
+        binding.write(
+          xml.spliceChildren(parent, parent.children.indexOf(node), 1, [
+            next.markup(next.root, true)
+          ])
+        );
+      }
+    });
+  }
+  get element() {
+    this.#binding.prepare?.();
+    const expected = this.#binding.read(), selected = this.#binding.locate(expected), subtree = expected.subtree(selected);
+    return createXmlElementView({
+      read: () => {
+        if (this.#binding.read() !== expected) throw new InvalidHandleError();
+        return subtree;
+      },
+      commit: (_old, next) => {
+        if (this.#binding.read() !== expected) throw new InvalidHandleError();
+        const findParent = (node) => node.children.includes(selected) ? node : node.children.map(findParent).find(Boolean);
+        const parent = findParent(expected.root);
+        if (!parent) throw new InvalidHandleError();
+        this.#binding.write(
+          expected.spliceChildren(parent, parent.children.indexOf(selected), 1, [
+            next.markup(next.root, true)
+          ])
+        );
+      }
+    });
+  }
+  equals(other) {
+    return other instanceof _ChartNode && this.#binding.read() === other.#binding.read() && chartNode(this) === chartNode(other);
+  }
+  get format() {
+    return new ChartFormat(chartNodeBinding(this));
+  }
+};
+var ChartFormat = class extends ChartNode {
+  apply(update) {
+    validateDrawingUpdate(update);
+    if (!child(chartNode(this), "spPr")) chartPut(this, "spPr", "");
+    const binding = chartNodeBinding(this);
+    const xml = binding.read();
+    binding.write(applyDrawingUpdate(xml, binding.locate(xml), update));
+  }
+  #drawing() {
+    if (!child(chartNode(this), "spPr")) chartPut(this, "spPr", "");
+    const binding = chartNodeBinding(this);
+    let owner, cached;
+    const read = () => {
+      const xml = binding.read();
+      if (owner !== xml) {
+        cached = xml.subtree(binding.locate(xml));
+        owner = xml;
+      }
+      return cached;
+    };
+    const edit = (transform) => {
+      const xml = binding.read(), selected = binding.locate(xml), local = read();
+      const next = transform(local, local.root);
+      const parentOf = (node) => {
+        if (node.children.includes(selected)) return node;
+        for (const c of node.children) {
+          const found = parentOf(c);
+          if (found) return found;
+        }
+        return void 0;
+      };
+      const parent = parentOf(xml.root);
+      if (!parent) throw new InvalidHandleError();
+      binding.write(
+        xml.spliceChildren(parent, parent.children.indexOf(selected), 1, [
+          next.markup(next.root, true)
+        ])
+      );
+    };
+    const update = (value) => edit(
+      (xml, node) => applyDrawingUpdate(xml, node, {
+        ...value.fill === void 0 ? {} : {
+          fill: value.fill === null ? { kind: "none" } : value.fill === "solid" ? { kind: "solid" } : { kind: "solid", color: value.fill }
+        },
+        ...value.lineColor === void 0 && value.lineWidth === void 0 ? {} : {
+          line: {
+            ...value.lineColor === void 0 ? {} : {
+              fill: value.lineColor === null ? { kind: "none" } : value.lineColor === "solid" ? { kind: "solid" } : { kind: "solid", color: value.lineColor }
+            },
+            ...value.lineWidth === void 0 ? {} : { width: value.lineWidth }
+          }
+        }
+      })
+    );
+    return { read, edit, update };
+  }
+  get fill() {
+    const { read, edit, update } = this.#drawing();
+    return new FillFormat(read, update, false, edit);
+  }
+  get line() {
+    const { read, edit, update } = this.#drawing();
+    return new LineFormat(read, update, edit);
+  }
+  get shadow() {
+    const { read, edit } = this.#drawing();
+    return new ShadowFormat(read, edit);
+  }
+};
+var sequences = /* @__PURE__ */ new WeakMap();
+function state(sequence) {
+  return sequences.get(sequence);
+}
+var ChartSequence = class {
+  constructor(read, negative = true, equal = (a, b) => a === b || a instanceof ChartNode && a.equals(b)) {
+    const data = { read, negative, equal };
+    const numeric2 = (key) => typeof key === "string" && key !== "" && String(Number(key)) === key;
+    const proxy = new Proxy(this, {
+      get(target, key, receiver) {
+        if (numeric2(key)) {
+          if (Number(key) < 0) throw new IndexError();
+          return target.at(Number(key));
+        }
+        return Reflect.get(target, key, receiver);
+      },
+      set(target, key, value, receiver) {
+        if (numeric2(key)) throw new ValueError("Sequence entries cannot be replaced.");
+        return Reflect.set(target, key, value, receiver);
+      },
+      defineProperty(target, key, descriptor) {
+        if (numeric2(key)) throw new ValueError("Sequence entries cannot be replaced.");
+        return Reflect.defineProperty(target, key, descriptor);
+      },
+      deleteProperty(target, key) {
+        if (numeric2(key)) throw new ValueError("Sequence entries cannot be removed.");
+        return Reflect.deleteProperty(target, key);
+      }
+    });
+    sequences.set(this, data);
+    sequences.set(proxy, data);
+    return proxy;
+  }
+  get length() {
+    return state(this).read().length;
+  }
+  at(index) {
+    if (typeof index !== "number") throw new TypeError();
+    const data = state(this), all = data.read();
+    if (!Number.isInteger(index)) throw new IndexError();
+    const offset = index < 0 && data.negative ? all.length + index : index;
+    if (offset < 0 || offset >= all.length) throw new IndexError();
+    return all[offset];
+  }
+  *[Symbol.iterator]() {
+    yield* state(this).read();
+  }
+  includes(value) {
+    return this.count(value) > 0;
+  }
+  count(value) {
+    const data = state(this);
+    return data.read().filter((item) => data.equal(item, value)).length;
+  }
+  index(value, start = 0, stop) {
+    const data = state(this), all = data.read();
+    for (const bound of [start, stop])
+      if (bound !== void 0 && !Number.isSafeInteger(bound))
+        throw new ValueError("Invalid sequence search bound.");
+    const normalize = (bound) => Math.min(all.length, Math.max(0, bound < 0 ? all.length + bound : bound));
+    const first = normalize(start), last = stop === void 0 ? all.length : normalize(stop);
+    for (let index = first; index < last; index++) if (data.equal(all[index], value)) return index;
+    throw new ValueError();
+  }
+  *reversed() {
+    yield* [...state(this).read()].reverse();
+  }
+};
+
+// packages/safe-bash-presentation-engine/src/model-sequence.ts
+function sequenceSlice(values, start, end, step = 1) {
+  if (!Number.isSafeInteger(step) || step === 0 || [start, end].some((value) => value !== void 0 && !Number.isSafeInteger(value)))
+    throw new ValueError("Invalid sequence slice bounds.");
+  const length = values.length;
+  const normalize = (value) => Math.max(
+    step > 0 ? 0 : -1,
+    Math.min(step > 0 ? length : length - 1, value < 0 ? length + value : value)
+  );
+  const first = start === void 0 ? step > 0 ? 0 : length - 1 : normalize(start);
+  const last = end === void 0 ? step > 0 ? length : -1 : normalize(end);
+  const result = [];
+  for (let i = first; step > 0 ? i < last : i > last; i += step) result.push(values[i]);
+  return Object.freeze(result);
+}
+
+// packages/safe-bash-presentation-engine/src/chart-model-axes.ts
+var RichText = class extends ChartNode {
+  get frame() {
+    return this.textFrame("rich");
+  }
+};
+var ChartTitle = class extends ChartNode {
+  get has_text_frame() {
+    const tx = child(chartNode(this), "tx");
+    return !!(tx && child(tx, "rich"));
+  }
+  set has_text_frame(value) {
+    booleanValue(value);
+    if (value) {
+      void this.text_frame;
+    } else chartPut(this, "tx", null);
+  }
+  get text_frame() {
+    if (!this.has_text_frame) chartPut(this, "tx", "");
+    return new RichText(chartDescendant(this, "tx")).frame;
+  }
+};
+var AxisTitle = class extends ChartTitle {
+};
+var Legend = class extends ChartNode {
+  get font() {
+    return this.textFrame().paragraphs[0].font;
+  }
+  get position() {
+    const value = this.scalar("legendPos");
+    return value === null ? XL_LEGEND_POSITION.RIGHT : XL_LEGEND_POSITION.from_xml(value);
+  }
+  set position(value) {
+    this.setScalar("legendPos", XL_LEGEND_POSITION.to_xml(value));
+  }
+  get include_in_layout() {
+    return readBoolean(child(chartNode(this), "overlay"), true);
+  }
+  set include_in_layout(value) {
+    if (value !== null) booleanValue(value);
+    this.setScalar("overlay", value);
+  }
+  get horz_offset() {
+    const layout = child(chartNode(this), "layout"), manual = layout && child(layout, "manualLayout"), mode = manual && child(manual, "xMode"), x = manual && child(manual, "x");
+    return x && (!mode || attr(mode, "val") === "factor") ? Number(attr(x, "val") ?? 0) : 0;
+  }
+  set horz_offset(value) {
+    if (value !== null) numberValue(value, -1, 1);
+    new Layout(chartDescendant(this, "layout", true)).offset = value;
+  }
+};
+var Layout = class extends ChartNode {
+  set offset(value) {
+    new ManualLayout(chartDescendant(this, "manualLayout", true)).offset = value;
+  }
+};
+var ManualLayout = class extends ChartNode {
+  set offset(value) {
+    this.setScalar("xMode", "factor");
+    this.setScalar("x", value);
+  }
+};
+var TickLabels = class extends ChartNode {
+  get font() {
+    return this.textFrame().paragraphs[0].font;
+  }
+  get number_format() {
+    const node = child(chartNode(this), "numFmt");
+    return node ? attr(node, "formatCode") ?? "General" : "General";
+  }
+  set number_format(value) {
+    if (typeof value !== "string") throw new TypeError();
+    this.numberFormat(value, false);
+  }
+  get number_format_is_linked() {
+    const node = child(chartNode(this), "numFmt");
+    if (!node) return true;
+    const value = attr(node, "sourceLinked");
+    return value === void 0 || value === "1" || value === "true";
+  }
+  set number_format_is_linked(value) {
+    booleanValue(value);
+    this.numberFormat(this.number_format, value);
+  }
+  numberFormat(value, linked) {
+    const binding = chartNodeBinding(this), xml = binding.read(), node = binding.locate(xml), existing = child(node, "numFmt");
+    if (existing)
+      binding.write(
+        xml.merge(existing, {
+          attributes: [
+            { namespace: "", localName: "formatCode", value },
+            { namespace: "", localName: "sourceLinked", value: linked ? "1" : "0" }
+          ]
+        })
+      );
+    else chartPut(this, "numFmt", "", { formatCode: value, sourceLinked: linked ? "1" : "0" });
+  }
+  get offset() {
+    return Number(this.scalar("lblOffset") ?? 100);
+  }
+  set offset(value) {
+    numberValue(value, 0, 1e3, true);
+    this.setScalar("lblOffset", value);
+  }
+};
+var MajorGridlines = class extends ChartNode {
+  get format() {
+    return new ChartFormat(chartOptionalDescendant(this, "majorGridlines"));
+  }
+};
+var Scaling = class extends ChartNode {
+  get min() {
+    const value = this.scalar("min");
+    return value === null ? null : Number(value);
+  }
+  set min(value) {
+    if (value !== null) numberValue(value);
+    this.setScalar("min", value);
+  }
+  get max() {
+    const value = this.scalar("max");
+    return value === null ? null : Number(value);
+  }
+  set max(value) {
+    if (value !== null) numberValue(value);
+    this.setScalar("max", value);
+  }
+  get reversed() {
+    return this.scalar("orientation") === "maxMin";
+  }
+  set reversed(value) {
+    booleanValue(value);
+    this.setScalar("orientation", value ? "maxMin" : "minMax");
+  }
+};
+var BaseAxis = class extends ChartNode {
+  get axis_title() {
+    return new AxisTitle(chartDescendant(this, "title", true));
+  }
+  get has_title() {
+    return !!child(chartNode(this), "title");
+  }
+  set has_title(value) {
+    this.present("title", value);
+  }
+  get has_major_gridlines() {
+    return !!child(chartNode(this), "majorGridlines");
+  }
+  set has_major_gridlines(value) {
+    this.present("majorGridlines", value);
+  }
+  get has_minor_gridlines() {
+    return !!child(chartNode(this), "minorGridlines");
+  }
+  set has_minor_gridlines(value) {
+    this.present("minorGridlines", value);
+  }
+  get major_gridlines() {
+    return new MajorGridlines(chartNodeBinding(this));
+  }
+  get major_tick_mark() {
+    return XL_TICK_MARK.from_xml(this.scalar("majorTickMark") ?? "none");
+  }
+  set major_tick_mark(value) {
+    this.setScalar("majorTickMark", XL_TICK_MARK.to_xml(value));
+  }
+  get minor_tick_mark() {
+    return XL_TICK_MARK.from_xml(this.scalar("minorTickMark") ?? "none");
+  }
+  set minor_tick_mark(value) {
+    this.setScalar("minorTickMark", XL_TICK_MARK.to_xml(value));
+  }
+  get maximum_scale() {
+    const scaling = child(chartNode(this), "scaling");
+    return scaling ? new Scaling(chartDescendant(this, "scaling")).max : null;
+  }
+  set maximum_scale(value) {
+    if (value !== null) numberValue(value);
+    new Scaling(chartDescendant(this, "scaling", true)).max = value;
+  }
+  get minimum_scale() {
+    const scaling = child(chartNode(this), "scaling");
+    return scaling ? new Scaling(chartDescendant(this, "scaling")).min : null;
+  }
+  set minimum_scale(value) {
+    if (value !== null) numberValue(value);
+    new Scaling(chartDescendant(this, "scaling", true)).min = value;
+  }
+  get reverse_order() {
+    return !!child(chartNode(this), "scaling") && new Scaling(chartDescendant(this, "scaling")).reversed;
+  }
+  set reverse_order(value) {
+    booleanValue(value);
+    new Scaling(chartDescendant(this, "scaling", true)).reversed = value;
+  }
+  get tick_label_position() {
+    return XL_TICK_LABEL_POSITION.from_xml(this.scalar("tickLblPos") ?? "nextTo");
+  }
+  set tick_label_position(value) {
+    this.setScalar("tickLblPos", XL_TICK_LABEL_POSITION.to_xml(value));
+  }
+  get tick_labels() {
+    return new TickLabels(chartNodeBinding(this));
+  }
+  get visible() {
+    return !readBoolean(child(chartNode(this), "delete"), false);
+  }
+  set visible(value) {
+    booleanValue(value);
+    this.setScalar("delete", !value);
+  }
+};
+var CategoryAxis = class extends BaseAxis {
+  get category_type() {
+    return XL_CATEGORY_TYPE.CATEGORY_SCALE;
+  }
+};
+var DateAxis = class extends BaseAxis {
+  get category_type() {
+    return XL_CATEGORY_TYPE.TIME_SCALE;
+  }
+};
+var ValueAxis = class extends BaseAxis {
+  #crossing() {
+    const id = this.scalar("crossAx"), binding = chartNodeBinding(this), namespace = chartNode(this).name.namespace;
+    const locate = (xml) => {
+      const visit = (node) => {
+        if (node.name.namespace === namespace && ["catAx", "dateAx", "valAx"].includes(node.name.localName) && attr(child(node, "axId") ?? node, "val") === id)
+          return node;
+        for (const c of node.children) {
+          const found2 = visit(c);
+          if (found2) return found2;
+        }
+        return void 0;
+      };
+      const found = visit(xml.root);
+      if (!found) throw new PropertyAccessError("Crossed axis is unavailable.");
+      return found;
+    };
+    return new Crossing({ read: binding.read, write: binding.write, track: binding.track, locate });
+  }
+  get crosses() {
+    return this.#crossing().crosses;
+  }
+  set crosses(value) {
+    this.#crossing().crosses = value;
+  }
+  get crosses_at() {
+    return this.#crossing().crosses_at;
+  }
+  set crosses_at(value) {
+    this.#crossing().crosses_at = value;
+  }
+  get major_unit() {
+    const v = this.scalar("majorUnit");
+    return v === null ? null : Number(v);
+  }
+  set major_unit(value) {
+    if (value !== null) numberValue(value, Number.MIN_VALUE);
+    this.setScalar("majorUnit", value);
+  }
+  get minor_unit() {
+    const v = this.scalar("minorUnit");
+    return v === null ? null : Number(v);
+  }
+  set minor_unit(value) {
+    if (value !== null) numberValue(value, Number.MIN_VALUE);
+    this.setScalar("minorUnit", value);
+  }
+};
+var Crossing = class extends ChartNode {
+  get crosses() {
+    const value = this.scalar("crosses");
+    return value === null ? XL_AXIS_CROSSES.CUSTOM : XL_AXIS_CROSSES.from_xml(value);
+  }
+  set crosses(value) {
+    if (value === XL_AXIS_CROSSES.CUSTOM) {
+      if (this.crosses_at === null) this.crosses_at = 0;
+      return;
+    }
+    const token2 = XL_AXIS_CROSSES.to_xml(value);
+    chartPut(this, "crossesAt", null);
+    this.setScalar("crosses", token2);
+  }
+  get crosses_at() {
+    const value = this.scalar("crossesAt");
+    return value === null ? null : Number(value);
+  }
+  set crosses_at(value) {
+    if (value !== null) numberValue(value);
+    chartPut(this, "crosses", null);
+    this.setScalar("crossesAt", value);
+  }
+};
+
+// packages/safe-bash-presentation-engine/src/chart-model-series.ts
+var DataLabels = class extends TickLabels {
+  get position() {
+    const value = this.scalar("dLblPos");
+    return value === null ? null : XL_DATA_LABEL_POSITION.from_xml(value);
+  }
+  set position(value) {
+    this.setScalar("dLblPos", value === null ? null : XL_DATA_LABEL_POSITION.to_xml(value));
+  }
+  get show_category_name() {
+    return readBoolean(child(chartNode(this), "showCatName"), false);
+  }
+  set show_category_name(value) {
+    booleanValue(value);
+    this.setScalar("showCatName", value);
+  }
+  get show_legend_key() {
+    return readBoolean(child(chartNode(this), "showLegendKey"), false);
+  }
+  set show_legend_key(value) {
+    booleanValue(value);
+    this.setScalar("showLegendKey", value);
+  }
+  get show_percentage() {
+    return readBoolean(child(chartNode(this), "showPercent"), false);
+  }
+  set show_percentage(value) {
+    booleanValue(value);
+    this.setScalar("showPercent", value);
+  }
+  get show_series_name() {
+    return readBoolean(child(chartNode(this), "showSerName"), false);
+  }
+  set show_series_name(value) {
+    booleanValue(value);
+    this.setScalar("showSerName", value);
+  }
+  get show_value() {
+    return readBoolean(child(chartNode(this), "showVal"), false);
+  }
+  set show_value(value) {
+    booleanValue(value);
+    this.setScalar("showVal", value);
+  }
+};
+var DataLabel = class extends ChartTitle {
+  get font() {
+    return this.textFrame().paragraphs[0].font;
+  }
+  get position() {
+    const value = this.scalar("dLblPos");
+    return value === null ? null : XL_DATA_LABEL_POSITION.from_xml(value);
+  }
+  set position(value) {
+    this.setScalar("dLblPos", value === null ? null : XL_DATA_LABEL_POSITION.to_xml(value));
+  }
+};
+var Marker = class extends ChartNode {
+  get size() {
+    const marker = child(chartNode(this), "marker"), size = marker && child(marker, "size");
+    return size ? Number(attr(size, "val")) : null;
+  }
+  set size(value) {
+    if (value !== null) numberValue(value, 2, 72, true);
+    new MarkerProperties(chartDescendant(this, "marker", true)).size = value;
+  }
+  get style() {
+    const marker = child(chartNode(this), "marker"), symbol = marker && child(marker, "symbol");
+    return symbol ? XL_MARKER_STYLE.from_xml(attr(symbol, "val") ?? "auto") : null;
+  }
+  set style(value) {
+    const token2 = value === null ? null : XL_MARKER_STYLE.to_xml(value);
+    new MarkerProperties(chartDescendant(this, "marker", true)).style = token2;
+  }
+  get format() {
+    return new ChartFormat(chartDescendant(this, "marker", true));
+  }
+};
+var MarkerProperties = class extends ChartNode {
+  set size(value) {
+    this.setScalar("size", value);
+  }
+  set style(value) {
+    this.setScalar("symbol", value);
+  }
+};
+function indexed(parent, name, index, create) {
+  const locate = (xml) => parent.locate(xml).children.find(
+    (node) => node.name.namespace === parent.locate(xml).name.namespace && node.name.localName === name && attr(child(node, "idx") ?? node, "val") === String(index)
+  );
+  if (create) parent.prepare?.();
+  if (create && !locate(parent.read())) {
+    const xml = parent.read(), node = parent.locate(xml), ns2 = node.name.namespace;
+    const next = node.children.findIndex(
+      (n) => n.name.namespace === ns2 && (n.name.localName === name && Number(attr(child(n, "idx") ?? n, "val")) > index || [
+        "dLbls",
+        "trendline",
+        "errBars",
+        "cat",
+        "val",
+        "xVal",
+        "yVal",
+        "bubbleSize",
+        "smooth",
+        "bubble3D",
+        "extLst"
+      ].includes(n.name.localName))
+    );
+    parent.write(
+      xml.spliceChildren(node, next < 0 ? node.children.length : next, 0, [
+        `<c:${name} xmlns:c="${ns2}"><c:idx val="${index}"/></c:${name}>`
+      ])
+    );
+  }
+  return {
+    read: parent.read,
+    write: parent.write,
+    track: parent.track,
+    locate: (xml) => {
+      const found = locate(xml);
+      if (!found) throw new InvalidHandleError();
+      return found;
+    }
+  };
+}
+function deferredIndexed(parent, name, index) {
+  const virtual = {
+    name: { namespace: parent.locate(parent.read()).name.namespace, localName: name },
+    attributes: [],
+    children: []
+  };
+  let materialized = false;
+  const locate = (xml) => {
+    const root = parent.locate(xml), node = root.children.find(
+      (n) => n.name.namespace === root.name.namespace && n.name.localName === name && attr(child(n, "idx") ?? n, "val") === String(index)
+    );
+    if (node) {
+      materialized = true;
+      return node;
+    }
+    if (materialized) throw new InvalidHandleError();
+    return virtual;
+  };
+  return {
+    read: parent.read,
+    write: parent.write,
+    track: parent.track,
+    locate,
+    prepare: () => {
+      indexed(parent, name, index, true);
+    }
+  };
+}
+var Point = class _Point extends ChartNode {
+  #index;
+  constructor(binding, index) {
+    super(binding);
+    this.#index = index;
+  }
+  get format() {
+    return new ChartFormat(indexed(chartNodeBinding(this), "dPt", this.#index, true));
+  }
+  get marker() {
+    return new Marker(deferredIndexed(chartNodeBinding(this), "dPt", this.#index));
+  }
+  get data_label() {
+    return new DataLabel(
+      deferredIndexed(chartOptionalDescendant(this, "dLbls"), "dLbl", this.#index)
+    );
+  }
+  equals(other) {
+    return other instanceof _Point && this.#index === other.#index && super.equals(other);
+  }
+};
+function cacheValues(xml, series2, channel) {
+  const root = child(series2, channel);
+  if (!root) return [];
+  const ref = child(root, "numRef"), cache = ref ? child(ref, "numCache") : child(root, "numLit");
+  if (!cache) return [];
+  const count = child(cache, "ptCount");
+  const points = cache.children.filter(
+    (n) => n.name.namespace === cache.name.namespace && n.name.localName === "pt"
+  );
+  const length = count ? Number(attr(count, "val")) : Math.max(0, ...points.map((n) => Number(attr(n, "idx")) + 1));
+  if (!Number.isInteger(length) || length < 0 || length > 25e4)
+    throw new ValueError("Invalid chart cache size.");
+  const values = Array.from({ length }, () => null);
+  const indexes = /* @__PURE__ */ new Set();
+  for (const point of points) {
+    const idx = Number(attr(point, "idx")), v = child(point, "v"), text = v && xml.text(v);
+    if (!Number.isInteger(idx) || idx < 0 || idx >= length || indexes.has(idx))
+      throw new ValueError("Invalid chart point index.");
+    indexes.add(idx);
+    if (text !== null && text !== void 0 && text !== "") {
+      const value = Number(text);
+      if (!Number.isFinite(value)) throw new ValueError("Invalid chart point value.");
+      values[idx] = value;
+    }
+  }
+  return Object.freeze(values);
+}
+var BaseSeries = class extends ChartNode {
+  get index() {
+    return Number(this.scalar("idx") ?? 0);
+  }
+  get name() {
+    const tx = child(chartNode(this), "tx");
+    if (!tx) return "";
+    const xml = chartNodeBinding(this).read();
+    const direct = child(tx, "v");
+    if (direct) return xml.text(direct) ?? "";
+    const ref = child(tx, "strRef"), cache = ref && child(ref, "strCache"), pt = cache && child(cache, "pt"), v = pt && child(pt, "v");
+    return v ? xml.text(v) ?? "" : "";
+  }
+};
+var Series = class extends BaseSeries {
+  get values() {
+    const binding = chartNodeBinding(this), xml = binding.read(), node = binding.locate(xml);
+    return cacheValues(xml, node, child(node, "yVal") ? "yVal" : "val");
+  }
+  get points() {
+    const binding = chartNodeBinding(this);
+    return new ChartSequence(() => this.values.map((_, index) => new Point(binding, index)), false);
+  }
+};
+var CategorySeries = class extends Series {
+  get data_labels() {
+    return new DataLabels(chartDescendant(this, "dLbls", true));
+  }
+};
+var AreaSeries = class extends CategorySeries {
+};
+var PieSeries = class extends CategorySeries {
+};
+var BarSeries = class extends CategorySeries {
+  get invert_if_negative() {
+    return readBoolean(child(chartNode(this), "invertIfNegative"), true);
+  }
+  set invert_if_negative(value) {
+    booleanValue(value);
+    this.setScalar("invertIfNegative", value);
+  }
+};
+var RadarSeries = class extends CategorySeries {
+  get marker() {
+    return new Marker(chartNodeBinding(this));
+  }
+};
+var LineSeries = class extends RadarSeries {
+  get smooth() {
+    return readBoolean(child(chartNode(this), "smooth"), false);
+  }
+  set smooth(value) {
+    booleanValue(value);
+    this.setScalar("smooth", value);
+  }
+};
+var XySeries = class extends Series {
+  get marker() {
+    return new Marker(chartNodeBinding(this));
+  }
+  *iter_values() {
+    yield* this.values;
+  }
+};
+var BubbleSeries = class extends XySeries {
+};
+function seriesFor(binding, plotName) {
+  const classes = {
+    areaChart: AreaSeries,
+    area3DChart: AreaSeries,
+    barChart: BarSeries,
+    bar3DChart: BarSeries,
+    bubbleChart: BubbleSeries,
+    doughnutChart: PieSeries,
+    lineChart: LineSeries,
+    line3DChart: LineSeries,
+    pieChart: PieSeries,
+    pie3DChart: PieSeries,
+    ofPieChart: PieSeries,
+    radarChart: RadarSeries,
+    scatterChart: XySeries,
+    stockChart: LineSeries,
+    surfaceChart: Series,
+    surface3DChart: Series
+  };
+  return new (classes[plotName] ?? Series)(binding);
+}
+var SeriesCollection = class extends ChartSequence {
+};
+var Category = class _Category {
+  idx;
+  label;
+  constructor(idx, label2) {
+    this.idx = idx;
+    this.label = label2;
+    Object.freeze(this);
+  }
+  toString() {
+    return this.label;
+  }
+  equals(other) {
+    return this.label === (other instanceof _Category ? other.label : other);
+  }
+};
+var CategoryLevel = class extends ChartSequence {
+  constructor(read) {
+    super(read, true, (a, b) => a.equals(b));
+  }
+};
+var Categories = class extends ChartSequence {
+  #levels;
+  constructor(levels) {
+    super(
+      () => [...levels()[0] ?? []],
+      true,
+      (a, b) => a.equals(b)
+    );
+    this.#levels = levels;
+  }
+  get depth() {
+    return this.#levels().length;
+  }
+  get levels() {
+    return this.#levels();
+  }
+  get flattened_labels() {
+    const levels = this.#levels();
+    if (!levels.length) return [];
+    return Object.freeze(
+      [...levels[0]].map(
+        (leaf) => Object.freeze(
+          [...levels].reverse().map((level) => [...level].filter((item) => item.idx <= leaf.idx).at(-1)?.label ?? "")
+        )
+      )
+    );
+  }
+};
+var BasePlot = class extends ChartNode {
+  #chart;
+  constructor(binding, chart) {
+    super(binding);
+    this.#chart = chart;
+  }
+  get chart() {
+    void chartNode(this);
+    return this.#chart;
+  }
+  get series() {
+    const binding = chartNodeBinding(this);
+    return new SeriesCollection(() => {
+      const xml = binding.read(), node = binding.locate(xml);
+      return node.children.filter((n) => n.name.namespace === node.name.namespace && n.name.localName === "ser").map(
+        (original, index) => seriesFor(
+          {
+            read: binding.read,
+            write: binding.write,
+            track: binding.track,
+            locate: (doc) => {
+              const parent = binding.locate(doc), found = parent.children.filter(
+                (n) => n.name.namespace === parent.name.namespace && n.name.localName === "ser"
+              )[index];
+              if (!found) throw new InvalidHandleError();
+              const signature = (part, ser) => ["idx", "order", "cat", "val", "xVal", "yVal", "bubbleSize"].map((name) => {
+                const value = child(ser, name);
+                return value ? part.markup(value) : null;
+              });
+              if (JSON.stringify(signature(doc, found)) !== JSON.stringify(signature(xml, original)))
+                throw new InvalidHandleError();
+              return found;
+            }
+          },
+          node.name.localName
+        )
+      );
+    });
+  }
+  get categories() {
+    const binding = chartNodeBinding(this);
+    return new Categories(() => {
+      const xml = binding.read(), plot = binding.locate(xml), series2 = plot.children.find(
+        (n) => n.name.namespace === plot.name.namespace && n.name.localName === "ser"
+      ), cat = series2 && child(series2, "cat");
+      if (!cat) return [];
+      const multi = child(cat, "multiLvlStrRef"), multiCache = multi && child(multi, "multiLvlStrCache");
+      const ref = child(cat, "strRef") ?? child(cat, "numRef"), cache = ref ? child(ref, "strCache") ?? child(ref, "numCache") : child(cat, "strLit") ?? child(cat, "numLit");
+      const levels = multiCache ? multiCache.children.filter(
+        (n) => n.name.localName === "lvl" && n.name.namespace === cat.name.namespace
+      ) : cache ? [cache] : [];
+      return Object.freeze(
+        levels.map(
+          (level) => new CategoryLevel(() => {
+            const indexes = /* @__PURE__ */ new Set();
+            return level.children.filter((n) => n.name.localName === "pt" && n.name.namespace === cat.name.namespace).map((pt) => {
+              const idx = Number(attr(pt, "idx")), value = child(pt, "v");
+              if (!Number.isInteger(idx) || idx < 0 || !value || indexes.has(idx))
+                throw new ValueError("Invalid category cache index.");
+              indexes.add(idx);
+              return new Category(idx, xml.text(value) ?? "");
+            });
+          })
+        )
+      );
+    });
+  }
+  get has_data_labels() {
+    return !!child(chartNode(this), "dLbls");
+  }
+  set has_data_labels(value) {
+    this.present("dLbls", value);
+  }
+  get data_labels() {
+    if (!this.has_data_labels) throw new PropertyAccessError("Plot has no data labels.");
+    return new DataLabels(chartDescendant(this, "dLbls"));
+  }
+  get vary_by_categories() {
+    return readBoolean(child(chartNode(this), "varyColors"), true);
+  }
+  set vary_by_categories(value) {
+    booleanValue(value);
+    this.setScalar("varyColors", value);
+  }
+};
+var AreaPlot = class extends BasePlot {
+};
+var Area3DPlot = class extends BasePlot {
+};
+var LinePlot = class extends BasePlot {
+};
+var PiePlot = class extends BasePlot {
+};
+var DoughnutPlot = class extends BasePlot {
+};
+var RadarPlot = class extends BasePlot {
+};
+var XyPlot = class extends BasePlot {
+};
+var BarPlot = class extends BasePlot {
+  get gap_width() {
+    return Number(this.scalar("gapWidth") ?? 150);
+  }
+  set gap_width(value) {
+    numberValue(value, 0, 500, true);
+    this.setScalar("gapWidth", value);
+  }
+  get overlap() {
+    return Number(this.scalar("overlap") ?? 0);
+  }
+  set overlap(value) {
+    numberValue(value, -100, 100, true);
+    this.setScalar("overlap", value === 0 ? null : value);
+  }
+};
+var BubblePlot = class extends BasePlot {
+  get bubble_scale() {
+    return Number(this.scalar("bubbleScale") ?? 100);
+  }
+  set bubble_scale(value) {
+    if (value !== null) numberValue(value, 0, 300, true);
+    this.setScalar("bubbleScale", value);
+  }
+};
+var plotNames = [
+  "areaChart",
+  "area3DChart",
+  "barChart",
+  "bar3DChart",
+  "bubbleChart",
+  "doughnutChart",
+  "lineChart",
+  "line3DChart",
+  "ofPieChart",
+  "pieChart",
+  "pie3DChart",
+  "radarChart",
+  "scatterChart",
+  "stockChart",
+  "surfaceChart",
+  "surface3DChart"
+];
+var Plots = class extends ChartSequence {
+  slice(start, end, step = 1) {
+    return sequenceSlice([...this], start, end, step);
+  }
+};
+function plotFor(binding, chart) {
+  const classes = {
+    areaChart: AreaPlot,
+    area3DChart: Area3DPlot,
+    barChart: BarPlot,
+    bar3DChart: BarPlot,
+    bubbleChart: BubblePlot,
+    doughnutChart: DoughnutPlot,
+    lineChart: LinePlot,
+    line3DChart: LinePlot,
+    pieChart: PiePlot,
+    pie3DChart: PiePlot,
+    ofPieChart: PiePlot,
+    radarChart: RadarPlot,
+    scatterChart: XyPlot
+  };
+  return new (classes[binding.locate(binding.read()).name.localName] ?? BasePlot)(binding, chart);
+}
+
+// packages/safe-bash-presentation-engine/src/chart-data-model.ts
+var chart_data_model_exports = {};
+__export(chart_data_model_exports, {
+  BubbleChartData: () => BubbleChartData,
+  BubbleDataPoint: () => BubbleDataPoint,
+  BubbleSeriesData: () => BubbleSeriesData,
+  Categories: () => Categories2,
+  Category: () => Category2,
+  CategoryChartData: () => CategoryChartData,
+  CategoryDataPoint: () => CategoryDataPoint,
+  CategorySeriesData: () => CategorySeriesData,
+  ChartData: () => CategoryChartData,
+  ChartDataSequence: () => ChartDataSequence,
+  XyChartData: () => XyChartData,
+  XyDataPoint: () => XyDataPoint,
+  XySeriesData: () => XySeriesData,
+  toChartData: () => toChartData
+});
+
+// packages/safe-bash-presentation-engine/src/chart-workbook.ts
+var ns = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+var relationships = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var encode = (text) => new TextEncoder().encode(text);
+function unsupported() {
+  throw new OfficeError(
+    "unsupported-edit",
+    "Chart data requires one simple owned worksheet without formulas or external dependencies.",
+    "mutate"
+  );
+}
+function attribute(node, name, namespace = "") {
+  return node.attributes.find((a) => a.name.localName === name && a.name.namespace === namespace)?.value;
+}
+function escaped(text) {
+  return text.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;").split('"').join("&quot;").split("\r").join("&#13;").split("\n").join("&#10;").split("	").join("&#9;");
+}
+function spreadsheetString(text, attribute2 = false) {
+  let result = "";
+  for (let index = 0; index < text.length; index++) {
+    const character = text[index];
+    if (character === "_" && text[index + 1] === "x" && text[index + 6] === "_" && [...text.slice(index + 2, index + 6)].every(
+      (digit) => "0123456789abcdefABCDEF".includes(digit)
+    )) {
+      result += "_x005F_";
+    } else if (character === "\r" || attribute2 && (character === "\n" || character === "	")) {
+      result += `_x${character.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")}_`;
+    } else result += character;
+  }
+  return result;
+}
+function workbookColumn(index) {
+  if (!Number.isInteger(index) || index < 0 || index >= 16384)
+    throw new OfficeError(
+      "invalid-value",
+      "Worksheet column is outside the supported grid.",
+      "usage"
+    );
+  let result = "";
+  for (let value = index + 1; value > 0; value = Math.floor((value - 1) / 26))
+    result = String.fromCharCode(65 + (value - 1) % 26) + result;
+  return result;
+}
+function cellReference(value) {
+  let position = value[0] === "$" ? 1 : 0;
+  let col = 0;
+  while (position < value.length) {
+    const code = value.charCodeAt(position);
+    if (code < 65 || code > 90) break;
+    col = col * 26 + code - 64;
+    if (col > 16384) unsupported();
+    position++;
+  }
+  if (value[position] === "$") position++;
+  const digits = value.slice(position);
+  if (!col || !digits || [...digits].some((char) => char < "0" || char > "9")) unsupported();
+  const row = Number(digits);
+  if (!Number.isSafeInteger(row) || row < 1 || row > 1048576 || String(row) !== digits)
+    unsupported();
+  return { column: col, row };
+}
+function chartWorkbookRange(formula, sheetName) {
+  const quoted = `'${sheetName.split("'").join("''")}'!`;
+  const prefix = formula.startsWith(quoted) ? quoted : `${sheetName}!`;
+  if (!formula.startsWith(prefix)) unsupported();
+  const parts = formula.slice(prefix.length).split(":");
+  if (parts.length > 2) unsupported();
+  const start = cellReference(parts[0]);
+  const end = parts.length === 2 ? cellReference(parts[1]) : start;
+  if (end.row < start.row || end.column < start.column) unsupported();
+  return { start, end };
+}
+function validateWorkbookOwnership(info, ranges) {
+  for (const cell of info.cells) {
+    if (!ranges.some(
+      ({ start, end }) => cell.row >= start.row && cell.row <= end.row && cell.column >= start.column && cell.column <= end.column
+    ))
+      unsupported();
+  }
+}
+function inspectWorkbook(pkg, context) {
+  const graph = readRelationshipGraph(pkg, context.relationshipLimits);
+  if (graph.dangling.length) unsupported();
+  for (const owner of ["/", ...graph.parts]) {
+    if (graph.outgoing(owner).some((edge) => edge.external)) unsupported();
+  }
+  const roots = graph.outgoing("/").filter((edge) => edge.type === `${relationships}/officeDocument`);
+  if (roots.length !== 1 || !roots[0].targetPart) unsupported();
+  const workbookPart = roots[0].targetPart;
+  const workbook = parseXmlPart(pkg.get(workbookPart), context.xmlLimits);
+  if (workbook.root.name.namespace !== ns || workbook.root.name.localName !== "workbook")
+    unsupported();
+  const allowed = ["fileVersion", "workbookPr", "bookViews", "sheets", "calcPr"];
+  if (workbook.root.children.some(
+    (node) => node.name.namespace !== ns || !allowed.includes(node.name.localName)
+  ))
+    unsupported();
+  const sheets = workbook.root.children.filter((node) => node.name.localName === "sheets");
+  if (sheets.length !== 1 || sheets[0].children.length !== 1) unsupported();
+  const sheet = sheets[0].children[0];
+  const sheetName = attribute(sheet, "name");
+  const id = attribute(sheet, "id", relationships);
+  const links = graph.outgoing(workbookPart);
+  if (links.some(
+    (edge) => ![
+      `${relationships}/worksheet`,
+      `${relationships}/styles`,
+      `${relationships}/sharedStrings`,
+      `${relationships}/theme`
+    ].includes(edge.type)
+  ))
+    unsupported();
+  const worksheets = links.filter((edge) => edge.type === `${relationships}/worksheet`);
+  if (sheet.name.localName !== "sheet" || !sheetName || worksheets.length !== 1 || worksheets[0].id !== id || !worksheets[0].targetPart)
+    unsupported();
+  const sheetPart = worksheets[0].targetPart;
+  const types = parseContentTypes(pkg.get("/[Content_Types].xml"), {
+    maxBytes: context.xmlLimits.maxBytes,
+    maxEntries: context.archiveLimits.maxMembers
+  });
+  for (const part of graph.parts) {
+    const type = types.get(part);
+    if ([
+      "table",
+      "calcChain",
+      "externalLink",
+      "connections",
+      "queryTable",
+      "pivotTable",
+      "pivotCacheDefinition",
+      "pivotCacheRecords"
+    ].some(
+      (kind2) => type === `application/vnd.openxmlformats-officedocument.spreadsheetml.${kind2}+xml`
+    ) || type === "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml" && part !== sheetPart)
+      unsupported();
+  }
+  if (graph.incoming(sheetPart).length !== 1 || graph.outgoing(sheetPart).length) unsupported();
+  if (pkg.names.some(
+    (name) => name.startsWith("/xl/worksheets/") && name.endsWith(".xml") && name !== sheetPart
+  ))
+    unsupported();
+  const worksheet = parseXmlPart(pkg.get(sheetPart), context.xmlLimits);
+  if (worksheet.root.name.namespace !== ns || worksheet.root.name.localName !== "worksheet")
+    unsupported();
+  const sheetChildren = [
+    "sheetPr",
+    "dimension",
+    "sheetViews",
+    "sheetFormatPr",
+    "cols",
+    "sheetData",
+    "pageMargins"
+  ];
+  if (worksheet.root.children.some(
+    (node) => node.name.namespace !== ns || !sheetChildren.includes(node.name.localName)
+  ))
+    unsupported();
+  if (worksheet.root.children.filter((node) => node.name.localName === "sheetData").length !== 1)
+    unsupported();
+  const visit = (node) => {
+    if (node.name.namespace !== ns || ["f", "extLst"].includes(node.name.localName)) unsupported();
+    node.children.forEach(visit);
+  };
+  visit(worksheet.root);
+  const cells = [];
+  const seen = /* @__PURE__ */ new Set();
+  const data = worksheet.root.children.find((node) => node.name.localName === "sheetData");
+  for (const row of data.children) {
+    if (row.name.localName !== "row") unsupported();
+    for (const cell of row.children) {
+      if (cell.name.localName !== "c") unsupported();
+      const ref = attribute(cell, "r");
+      if (!ref || seen.has(ref)) unsupported();
+      seen.add(ref);
+      const coordinate = cellReference(ref);
+      if (String(coordinate.row) !== attribute(row, "r")) unsupported();
+      if (cell.children.some((node) => node.name.localName === "v" || node.name.localName === "is"))
+        cells.push(coordinate);
+    }
+  }
+  const props = workbook.root.children.filter((node) => node.name.localName === "workbookPr");
+  if (props.length > 1) unsupported();
+  const date1904 = props[0] && attribute(props[0], "date1904");
+  if (date1904 !== void 0 && !["0", "1", "false", "true"].includes(date1904)) unsupported();
+  const styles = links.filter((edge) => edge.type === `${relationships}/styles`);
+  if (styles.length > 1) unsupported();
+  const strings = links.filter((edge) => edge.type === `${relationships}/sharedStrings`);
+  if (strings.length > 1) unsupported();
+  const stringsPart = strings[0]?.targetPart;
+  if (stringsPart) {
+    if (graph.incoming(stringsPart).length !== 1 || graph.outgoing(stringsPart).length)
+      unsupported();
+    const table = parseXmlPart(pkg.get(stringsPart), context.xmlLimits);
+    if (table.root.name.namespace !== ns || table.root.name.localName !== "sst" || table.root.children.some((node) => node.name.namespace !== ns || node.name.localName !== "si"))
+      unsupported();
+  }
+  return {
+    workbookPart,
+    ...styles[0]?.targetPart ? { stylesPart: styles[0].targetPart } : {},
+    ...stringsPart ? { stringsPart, stringsId: strings[0].id } : {},
+    sheetName,
+    sheetPart,
+    cells,
+    date1904: date1904 === "1" || date1904 === "true"
+  };
+}
+function workbookStyles(formats, context, source) {
+  if (!source && !formats.some((format2) => format2 !== void 0 && format2 !== "General"))
+    return { indices: formats.map(() => 0) };
+  let xml = parseXmlPart(
+    source ?? encode(
+      `<styleSheet xmlns="${ns}"><numFmts count="0"/><fonts count="1"><font><sz val="11"/><name val="Calibri"/></font></fonts><fills count="2"><fill><patternFill patternType="none"/></fill><fill><patternFill patternType="gray125"/></fill></fills><borders count="1"><border/></borders><cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs><cellXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/></cellXfs></styleSheet>`
+    ),
+    context.xmlLimits
+  );
+  if (xml.root.name.namespace !== ns || xml.root.name.localName !== "styleSheet") unsupported();
+  const child2 = (name) => {
+    const matches = xml.root.children.filter(
+      (node) => node.name.namespace === ns && node.name.localName === name
+    );
+    if (matches.length > 1) unsupported();
+    return matches[0];
+  };
+  if (!child2("numFmts"))
+    xml = xml.spliceChildren(xml.root, 0, 0, [`<numFmts xmlns="${ns}" count="0"/>`]);
+  if (!child2("cellXfs")?.children.length) unsupported();
+  const indices = formats.map((format2) => {
+    let numFmts = child2("numFmts");
+    const code = format2 === void 0 ? void 0 : spreadsheetString(format2, true);
+    const id = numFmts.children.find((node) => attribute(node, "formatCode") === code);
+    let number = format2 === void 0 || format2 === "General" ? "0" : id && attribute(id, "numFmtId");
+    if (!number) {
+      const used = numFmts.children.map((node) => Number(attribute(node, "numFmtId")));
+      if (used.some((value) => !Number.isSafeInteger(value) || value < 0)) unsupported();
+      number = String(Math.max(163, ...used) + 1);
+      xml = xml.spliceChildren(numFmts, numFmts.children.length, 0, [
+        `<numFmt xmlns="${ns}" numFmtId="${number}" formatCode="${escaped(code)}"/>`
+      ]);
+      numFmts = child2("numFmts");
+      xml = xml.merge(numFmts, {
+        attributes: [{ namespace: "", localName: "count", value: String(numFmts.children.length) }]
+      });
+    }
+    let xfs = child2("cellXfs");
+    const existing = xfs.children.findIndex(
+      (node) => attribute(node, "numFmtId") === number && !["0", "false"].includes(attribute(node, "applyNumberFormat") ?? "") && node.attributes.every(
+        (item) => item.name.namespace === "http://www.w3.org/2000/xmlns/" || item.name.namespace === "" && ["numFmtId", "fontId", "fillId", "borderId", "xfId", "applyNumberFormat"].includes(
+          item.name.localName
+        )
+      ) && ["fontId", "fillId", "borderId", "xfId"].every((name) => attribute(node, name) === "0") && node.children.length === 0
+    );
+    if (existing >= 0) return existing;
+    const index = xfs.children.length;
+    xml = xml.spliceChildren(xfs, index, 0, [
+      `<xf xmlns="${ns}" numFmtId="${number}" fontId="0" fillId="0" borderId="0" xfId="0" applyNumberFormat="1"/>`
+    ]);
+    xfs = child2("cellXfs");
+    xml = xml.merge(xfs, {
+      attributes: [{ namespace: "", localName: "count", value: String(xfs.children.length) }]
+    });
+    return index;
+  });
+  return { indices, bytes: xml.bytes() };
+}
+async function createChartWorkbook(data, scatter, context, options = {}) {
+  const source = options.source ? await readPackage(options.source, context) : void 0;
+  return writePackageArchive(
+    prepareChartWorkbookMembers(data, scatter, context, {
+      ...options.date1904 === void 0 ? {} : { date1904: options.date1904 },
+      ...source ? { source } : {}
+    }),
+    context,
+    { compression: "store" }
+  );
+}
+function prepareChartWorkbookMembers(data, scatter, context, options = {}) {
+  if (context.signal?.aborted)
+    throw new OfficeError("cancelled", "Workbook preparation cancelled.", "serialize");
+  const source = options.source;
+  const info = source ? inspectWorkbook(source, context) : void 0;
+  const columns = scatter ? data.series.flatMap((series2) => [
+    ["", ...series2.xValues],
+    [series2.name, ...series2.values],
+    ...series2.bubbleSizes ? [["Size", ...series2.bubbleSizes]] : []
+  ]) : [
+    ...(data.categoryLevels ?? [data.categories]).map((level) => [null, ...level]),
+    ...data.series.map((series2) => [series2.name, ...series2.values])
+  ];
+  if (columns.length > 16384 || columns.some((values) => values.length > 1048576))
+    throw new OfficeError("resource-limit", "Chart worksheet grid limit exceeded.", "serialize");
+  const formats = scatter ? data.series.flatMap((series2) => [
+    data.numberFormat,
+    series2.numberFormat ?? data.numberFormat,
+    ...series2.bubbleSizes ? [data.numberFormat] : []
+  ]) : [
+    ...(data.categoryLevels ?? [data.categories]).map(() => data.categoryNumberFormat),
+    ...data.series.map((series2) => series2.numberFormat ?? data.numberFormat)
+  ];
+  const pointFormats = scatter ? data.series.flatMap((series2) => [
+    void 0,
+    series2.pointNumberFormats,
+    ...series2.bubbleSizes ? [void 0] : []
+  ]) : [
+    ...(data.categoryLevels ?? [data.categories]).map(() => void 0),
+    ...data.series.map((series2) => series2.pointNumberFormats)
+  ];
+  const extraFormats = pointFormats.flatMap(
+    (column) => column?.filter((value) => value !== null) ?? []
+  );
+  const allFormats = [...formats, ...extraFormats];
+  const styles = workbookStyles(
+    allFormats,
+    context,
+    source && info?.stylesPart ? source.get(info.stylesPart) : void 0
+  );
+  let rows = "";
+  const count = Math.max(...columns.map((values) => values.length));
+  for (let row = 0; row < count; row++) {
+    let cells = "";
+    columns.forEach((values, col) => {
+      const value = values[row];
+      if (value === null || value === void 0) return;
+      const ref = `${workbookColumn(col)}${row + 1}`;
+      const pointFormat = row > 0 ? pointFormats[col]?.[row - 1] : void 0;
+      const styleIndex = pointFormat == null ? styles.indices[col] : styles.indices[allFormats.indexOf(pointFormat)];
+      const style = row > 0 && styleIndex ? ` s="${styleIndex}"` : "";
+      cells += typeof value === "number" ? `<c r="${ref}"${style}><v>${value}</v></c>` : `<c r="${ref}"${style} t="inlineStr"><is><t xml:space="preserve">${escaped(spreadsheetString(value))}</t></is></c>`;
+    });
+    rows += `<row r="${row + 1}">${cells}</row>`;
+    if (rows.length > context.xmlLimits.maxBytes)
+      throw new OfficeError("resource-limit", "Chart worksheet XML limit exceeded.", "serialize");
+  }
+  const sheetData = `<sheetData>${rows}</sheetData>`;
+  let worksheet = encode(`<worksheet xmlns="${ns}">${sheetData}</worksheet>`);
+  parseXmlPart(worksheet, context.xmlLimits);
+  if (source && info) {
+    let xml = parseXmlPart(source.get(info.sheetPart), context.xmlLimits);
+    const position = xml.root.children.findIndex((node) => node.name.localName === "sheetData");
+    xml = xml.spliceChildren(xml.root, position, 1, [
+      `<sheetData xmlns="${ns}">${rows}</sheetData>`
+    ]);
+    const dimension = xml.root.children.findIndex((node) => node.name.localName === "dimension");
+    if (dimension !== -1) xml = xml.spliceChildren(xml.root, dimension, 1, []);
+    worksheet = xml.bytes();
+    const entries = new Map(source.names.map((name) => [name, source.get(name)]));
+    entries.set(info.sheetPart, worksheet);
+    if (info.stringsPart) {
+      entries.delete(info.stringsPart);
+      const split = info.workbookPart.lastIndexOf("/");
+      const relsPart = `${info.workbookPart.slice(0, split)}/_rels/${info.workbookPart.slice(split + 1)}.rels`;
+      const rels = parseXmlPart(source.get(relsPart), context.xmlLimits);
+      entries.set(
+        relsPart,
+        rels.spliceChildren(
+          rels.root,
+          rels.root.children.findIndex((node) => attribute(node, "Id") === info.stringsId),
+          1,
+          []
+        ).bytes()
+      );
+      let types = parseXmlPart(source.get("/[Content_Types].xml"), context.xmlLimits);
+      const index = types.root.children.findIndex(
+        (node) => attribute(node, "PartName") === info.stringsPart
+      );
+      if (index >= 0) types = types.spliceChildren(types.root, index, 1, []);
+      entries.set("/[Content_Types].xml", types.bytes());
+    }
+    if (styles.bytes) {
+      const stylesPart = info.stylesPart ?? `${info.workbookPart.slice(0, info.workbookPart.lastIndexOf("/") + 1)}chart-styles.xml`;
+      if (!info.stylesPart) {
+        if (entries.has(stylesPart)) unsupported();
+        const split = info.workbookPart.lastIndexOf("/");
+        const relsPart = `${info.workbookPart.slice(0, split)}/_rels/${info.workbookPart.slice(split + 1)}.rels`;
+        let rels = parseXmlPart(entries.get(relsPart), context.xmlLimits);
+        let id = "chartStyles";
+        while (rels.root.children.some((node) => attribute(node, "Id") === id)) id += "_";
+        rels = rels.spliceChildren(rels.root, rels.root.children.length, 0, [
+          `<Relationship xmlns="http://schemas.openxmlformats.org/package/2006/relationships" Id="${id}" Type="${relationships}/styles" Target="chart-styles.xml"/>`
+        ]);
+        entries.set(relsPart, rels.bytes());
+        let types = parseXmlPart(entries.get("/[Content_Types].xml"), context.xmlLimits);
+        types = types.spliceChildren(types.root, types.root.children.length, 0, [
+          `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="${escaped(stylesPart)}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>`
+        ]);
+        entries.set("/[Content_Types].xml", types.bytes());
+      }
+      entries.set(stylesPart, styles.bytes);
+    }
+    return admitPreparedWorkbook(
+      [...entries].map(([name, bytes]) => ({ name: name.slice(1), bytes })),
+      context
+    );
+  }
+  return admitPreparedWorkbook(
+    [
+      {
+        name: "[Content_Types].xml",
+        bytes: encode(
+          `<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/><Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>${styles.bytes ? '<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>' : ""}</Types>`
+        )
+      },
+      {
+        name: "_rels/.rels",
+        bytes: encode(
+          `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="${relationships}/officeDocument" Target="xl/workbook.xml"/></Relationships>`
+        )
+      },
+      {
+        name: "xl/workbook.xml",
+        bytes: encode(
+          `<workbook xmlns="${ns}" xmlns:r="${relationships}"><workbookPr date1904="${options.date1904 ? "1" : "0"}"/><sheets><sheet name="Sheet1" sheetId="1" r:id="rId1"/></sheets></workbook>`
+        )
+      },
+      {
+        name: "xl/_rels/workbook.xml.rels",
+        bytes: encode(
+          `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="${relationships}/worksheet" Target="worksheets/sheet1.xml"/>${styles.bytes ? `<Relationship Id="rId2" Type="${relationships}/styles" Target="styles.xml"/>` : ""}</Relationships>`
+        )
+      },
+      { name: "xl/worksheets/sheet1.xml", bytes: worksheet },
+      ...styles.bytes ? [{ name: "xl/styles.xml", bytes: styles.bytes }] : []
+    ],
+    context
+  );
+}
+function admitPreparedWorkbook(members, context) {
+  let bytes = 22, total = 0;
+  const limits = context.archiveLimits;
+  if (members.length > Math.min(limits.maxMembers, 65534))
+    throw new OfficeError("resource-limit", "Chart workbook member limit exceeded.", "serialize");
+  for (const member of members) {
+    const pathBytes = new TextEncoder().encode(member.name).length;
+    total += member.bytes.length;
+    bytes += 76 + pathBytes * 2 + member.bytes.length;
+    if (member.bytes.length > limits.maxEntryBytes || pathBytes > limits.maxPathBytes || member.name.split("/").length > limits.maxDepth)
+      throw new OfficeError(
+        "resource-limit",
+        "Chart workbook member budget exceeded.",
+        "serialize"
+      );
+  }
+  if (total > limits.maxTotalBytes || bytes > Math.min(limits.maxArchiveBytes, context.limits.maxBytes, 4294967294))
+    throw new OfficeError("resource-limit", "Chart workbook byte budget exceeded.", "serialize");
+  return members;
+}
+
+// packages/safe-bash-presentation-engine/src/chart-data-model.ts
+function format(value) {
+  if (typeof value !== "string") throw new TypeError("Number format must be a string.");
+  return value;
+}
+function numeric(value, nullable = true) {
+  if (value === null && nullable) return null;
+  if (typeof value !== "number") throw new TypeError("Expected a numeric chart value.");
+  if (!Number.isFinite(value)) throw new ValueError("Chart values must be finite.");
+  return value;
+}
+function label(value) {
+  if (value === null) return null;
+  if (value instanceof Date) {
+    if (!Number.isFinite(value.getTime())) throw new ValueError("Invalid category date.");
+    return new Date(value.getTime());
+  }
+  if (typeof value === "number") return numeric(value, false);
+  if (typeof value !== "string") throw new TypeError("Invalid category label.");
+  return value;
+}
+function kind(value) {
+  return value instanceof Date ? "date" : value === null ? "string" : typeof value;
+}
+function bounds(value, length) {
+  if (!Number.isSafeInteger(value)) throw new IndexError();
+  return Math.max(0, Math.min(length, value < 0 ? length + value : value));
+}
+var sequenceStorage = /* @__PURE__ */ new WeakMap();
+var sequenceTargets = /* @__PURE__ */ new WeakMap();
+function sameOwner(left, right) {
+  return (sequenceTargets.get(left) ?? left) === (sequenceTargets.get(right) ?? right);
+}
+function sequenceItems(owner) {
+  return sequenceStorage.get(owner);
+}
+var ChartDataSequence = class {
+  constructor() {
+    const items = [];
+    sequenceStorage.set(this, items);
+    const proxy = new Proxy(this, {
+      get(target, key, receiver) {
+        if (typeof key === "string" && key !== "" && String(Number(key)) === key) {
+          if (Number(key) < 0) throw new IndexError();
+          return target.at(Number(key));
+        }
+        return Reflect.get(target, key, receiver);
+      },
+      set(target, key, value, receiver) {
+        if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+          throw new ValueError("Sequence entries cannot be replaced.");
+        return Reflect.set(target, key, value, receiver);
+      },
+      defineProperty(target, key, descriptor) {
+        if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+          throw new ValueError("Sequence entries cannot be replaced.");
+        return Reflect.defineProperty(target, key, descriptor);
+      },
+      deleteProperty(target, key) {
+        if (typeof key === "string" && key !== "" && String(Number(key)) === key)
+          throw new ValueError("Sequence entries cannot be removed.");
+        return Reflect.deleteProperty(target, key);
+      }
+    });
+    sequenceStorage.set(proxy, items);
+    sequenceTargets.set(proxy, this);
+    return proxy;
+  }
+  get length() {
+    return sequenceItems(this).length;
+  }
+  at(index) {
+    if (!Number.isSafeInteger(index) || index < -this.length || index >= this.length)
+      throw new IndexError();
+    return sequenceItems(this)[index < 0 ? this.length + index : index];
+  }
+  slice(start, end, step = 1) {
+    return sequenceSlice(sequenceItems(this), start, end, step);
+  }
+  [Symbol.iterator]() {
+    return sequenceItems(this)[Symbol.iterator]();
+  }
+  includes(value) {
+    return sequenceItems(this).includes(value);
+  }
+  count(value) {
+    return sequenceItems(this).filter((item) => item === value).length;
+  }
+  reversed() {
+    return Object.freeze([...sequenceItems(this)].reverse());
+  }
+};
+var Categories2 = class extends ChartDataSequence {
+  #customFormat = null;
+  add_category(value) {
+    const normalized = label(value);
+    if (this.length && kind(this.at(0).label) !== kind(normalized))
+      throw new ValueError("Category labels must have the same type.");
+    const category = new Category2(normalized, this);
+    sequenceItems(this).push(category);
+    return category;
+  }
+  index(category) {
+    let offset = 0;
+    for (const item of this) {
+      if (item === category) return offset;
+      offset += item.leaf_count;
+    }
+    throw new ValueError("Category does not belong to this hierarchy.");
+  }
+  get are_dates() {
+    return this.depth === 1 && this.length > 0 && this.at(0).label instanceof Date;
+  }
+  get are_numeric() {
+    return this.depth === 1 && this.length > 0 && (this.are_dates || typeof this.at(0).label === "number");
+  }
+  get depth() {
+    if (!this.length) return 0;
+    const depths = sequenceItems(this).map((item) => item.depth);
+    if (depths.some((depth) => depth !== depths[0]))
+      throw new ValueError("Category hierarchy must have uniform depth.");
+    return depths[0];
+  }
+  get leaf_count() {
+    return sequenceItems(this).reduce((count, item) => count + item.leaf_count, 0);
+  }
+  get levels() {
+    const levels = Array.from({ length: this.depth }, () => []);
+    const visit = (category, depth) => {
+      levels[depth].push([category.idx, category.label]);
+      for (const child2 of category.sub_categories) visit(child2, depth + 1);
+    };
+    for (const category of this) visit(category, 0);
+    return Object.freeze(
+      levels.reverse().map((level) => Object.freeze(level.map((pair) => Object.freeze(pair))))
+    );
+  }
+  get number_format() {
+    return this.#customFormat ?? (this.are_dates ? "yyyy\\-mm\\-dd" : "General");
+  }
+  set number_format(value) {
+    this.#customFormat = value === null ? null : format(value);
+  }
+};
+var Category2 = class _Category {
+  #value;
+  #children = [];
+  #parent;
+  constructor(value, parent) {
+    this.#value = label(value);
+    this.#parent = parent;
+  }
+  get label() {
+    return this.#value instanceof Date ? new Date(this.#value.getTime()) : this.#value ?? "";
+  }
+  get sub_categories() {
+    return Object.freeze([...this.#children]);
+  }
+  add_sub_category(value) {
+    if (typeof this.#value !== "string" || typeof value !== "string")
+      throw new ValueError("Hierarchical categories require string labels.");
+    const category = new _Category(value, this);
+    this.#children.push(category);
+    return category;
+  }
+  get idx() {
+    return this.#parent.index(this);
+  }
+  index(category) {
+    let offset = this.idx;
+    for (const item of this.#children) {
+      if (item === category) return offset;
+      offset += item.leaf_count;
+    }
+    throw new ValueError("Subcategory does not belong to this category.");
+  }
+  get depth() {
+    if (!this.#children.length) return 1;
+    const depths = this.#children.map((child2) => child2.depth);
+    if (depths.some((depth) => depth !== depths[0]))
+      throw new ValueError("Category hierarchy must have uniform depth.");
+    return depths[0] + 1;
+  }
+  get leaf_count() {
+    return this.#children.length ? this.#children.reduce((sum, child2) => sum + child2.leaf_count, 0) : 1;
+  }
+  numeric_str_val(date_1904 = false) {
+    if (typeof date_1904 !== "boolean") throw new TypeError();
+    if (this.#value instanceof Date) {
+      const day = Math.floor(this.#value.getTime() / 864e5);
+      const serial = date_1904 ? day - Math.floor(Date.UTC(1904, 0, 1) / 864e5) : day - Math.floor(Date.UTC(1899, 11, 31) / 864e5) + (day >= Math.floor(Date.UTC(1900, 2, 1) / 864e5) ? 1 : 0);
+      return serial.toFixed(1);
+    }
+    return String(this.#value);
+  }
+};
+var CategoryDataPoint = class {
+  value;
+  #owner;
+  #override;
+  get owner() {
+    return this.#owner;
+  }
+  constructor(owner, value, override = null) {
+    this.value = numeric(value);
+    if (override !== null) format(override);
+    this.#owner = owner;
+    this.#override = override;
+    Object.freeze(this);
+  }
+  get number_format() {
+    return this.#override ?? this.owner.number_format;
+  }
+};
+var XyDataPoint = class _XyDataPoint {
+  x;
+  y;
+  #owner;
+  #override;
+  get owner() {
+    return this.#owner;
+  }
+  constructor(owner, x, y, override = null) {
+    this.x = numeric(x, false);
+    this.y = numeric(y);
+    if (override !== null) format(override);
+    this.#owner = owner;
+    this.#override = override;
+    if (new.target === _XyDataPoint) Object.freeze(this);
+  }
+  get number_format() {
+    return this.#override ?? this.owner.number_format;
+  }
+};
+var BubbleDataPoint = class extends XyDataPoint {
+  bubble_size;
+  constructor(owner, x, y, size, number_format = null) {
+    super(owner, x, y, number_format);
+    this.bubble_size = numeric(size, false);
+    if (size < 0) throw new ValueError("Bubble size must not be negative.");
+    Object.freeze(this);
+  }
+};
+var SeriesData = class extends ChartDataSequence {
+  #name;
+  #owner;
+  #override;
+  get name() {
+    return this.#name;
+  }
+  get owner() {
+    return this.#owner;
+  }
+  constructor(owner, name, override = null) {
+    super();
+    this.#name = name === null ? "" : format(name);
+    this.#owner = owner;
+    this.#override = override;
+    if (override !== null) format(override);
+  }
+  get number_format() {
+    return this.#override ?? this.owner.number_format;
+  }
+  get index() {
+    return this.owner.series_index(this);
+  }
+  get data_point_offset() {
+    return this.owner.data_point_offset(this);
+  }
+  get name_ref() {
+    return this.owner.series_name_ref(this);
+  }
+  get x_values_ref() {
+    return this.owner.x_values_ref(this);
+  }
+  get y_values_ref() {
+    return this.owner.y_values_ref(this);
+  }
+  append(point) {
+    if (!sameOwner(point.owner, this))
+      throw new ValueError("Data point belongs to another series.");
+    sequenceItems(this).push(point);
+  }
+};
+var CategorySeriesData = class extends SeriesData {
+  add_data_point(value, number_format = null) {
+    const point = new CategoryDataPoint(this, value, number_format);
+    sequenceItems(this).push(point);
+    return point;
+  }
+  get values() {
+    return Object.freeze(sequenceItems(this).map((point) => point.value));
+  }
+  get y_values() {
+    if (this.length)
+      throw new PropertyAccessError(
+        "Category points expose value; use values for category series."
+      );
+    return Object.freeze([]);
+  }
+  get x_values() {
+    if (this.length)
+      throw new PropertyAccessError(
+        "Category points expose labels through categories, not x coordinates."
+      );
+    return Object.freeze([]);
+  }
+  get categories() {
+    return this.owner.categories;
+  }
+  get categories_ref() {
+    return this.owner.categories_ref;
+  }
+  get values_ref() {
+    return this.owner.values_ref(this);
+  }
+};
+var XySeriesData = class extends SeriesData {
+  add_data_point(x, y, number_format = null) {
+    const point = new XyDataPoint(this, x, y, number_format);
+    sequenceItems(this).push(point);
+    return point;
+  }
+  get x_values() {
+    return Object.freeze(sequenceItems(this).map((point) => point.x));
+  }
+  get y_values() {
+    return Object.freeze(sequenceItems(this).map((point) => point.y));
+  }
+};
+var BubbleSeriesData = class extends SeriesData {
+  add_data_point(x, y, size, number_format = null) {
+    const point = new BubbleDataPoint(this, x, y, size, number_format);
+    sequenceItems(this).push(point);
+    return point;
+  }
+  get x_values() {
+    return Object.freeze(sequenceItems(this).map((point) => point.x));
+  }
+  get y_values() {
+    return Object.freeze(sequenceItems(this).map((point) => point.y));
+  }
+  get bubble_sizes() {
+    return Object.freeze(sequenceItems(this).map((point) => point.bubble_size));
+  }
+  get bubble_sizes_ref() {
+    return this.owner.bubble_sizes_ref(this);
+  }
+};
+var BaseChartData = class extends ChartDataSequence {
+  #numberFormat;
+  get number_format() {
+    return this.#numberFormat;
+  }
+  constructor(number_format = "General") {
+    super();
+    this.#numberFormat = format(number_format);
+  }
+  index(series2, start = 0, stop = this.length) {
+    for (let i = bounds(start, this.length); i < bounds(stop, this.length); i++)
+      if (sequenceItems(this)[i] === series2) return i;
+    throw new ValueError("Series is not in this chart data.");
+  }
+  series_index(series2) {
+    const i = sequenceItems(this).findIndex((item) => sameOwner(item, series2));
+    if (i < 0) throw new ValueError("Series is not in this chart data.");
+    return i;
+  }
+  data_point_offset(series2) {
+    return sequenceItems(this).slice(0, this.series_index(series2)).reduce((sum, item) => sum + item.length, 0);
+  }
+  append(series2) {
+    if (!sameOwner(series2.owner, this))
+      throw new ValueError("Series belongs to another chart data.");
+    sequenceItems(this).push(series2);
+  }
+  column(series2) {
+    return this.series_index(series2) * this.columnsPerSeries;
+  }
+  reference(series2, column) {
+    const letter = workbookColumn(column);
+    const count = sequenceItems(this)[this.series_index(series2)].length;
+    return `Sheet1!$${letter}$2:$${letter}$${count + 1}`;
+  }
+  series_name_ref(series2) {
+    return `Sheet1!$${workbookColumn(this.column(series2) + 1)}$1`;
+  }
+  x_values_ref(series2) {
+    return this.reference(series2, this.column(series2));
+  }
+  y_values_ref(series2) {
+    return this.reference(series2, this.column(series2) + 1);
+  }
+  async xlsx_blob(context, date1904 = false) {
+    const data = this.to_chart_data(date1904);
+    return createChartWorkbook(
+      {
+        ...data,
+        ...this instanceof CategoryChartData && this.categories.are_dates ? {
+          categories: [...this.categories].map(
+            (category) => Number(category.numeric_str_val(date1904 ?? false))
+          )
+        } : {}
+      },
+      this.columnsPerSeries > 1,
+      context,
+      { date1904 }
+    );
+  }
+  xml_bytes(chart_type) {
+    const type = typeof chart_type === "string" ? chart_type : chartTypes.find((name) => XL_CHART_TYPE[name] === chart_type);
+    if (!type || !chartTypes.includes(type)) throw new ValueError("Unsupported chart type.");
+    return new TextEncoder().encode(createChartXml(type, this.to_chart_data()));
+  }
+};
+var CategoryChartData = class extends BaseChartData {
+  #categoryData = new Categories2();
+  get columnsPerSeries() {
+    return 1;
+  }
+  get categories() {
+    return this.#categoryData;
+  }
+  set categories(values) {
+    const next = new Categories2();
+    for (const value of values) next.add_category(value);
+    this.#categoryData = next;
+  }
+  add_category(value) {
+    return this.#categoryData.add_category(value);
+  }
+  add_series(name, values = [], number_format = null) {
+    const series2 = new CategorySeriesData(this, name, number_format);
+    for (const value of values) series2.add_data_point(value);
+    sequenceItems(this).push(series2);
+    return series2;
+  }
+  get categories_ref() {
+    if (!this.categories.length) throw new ValueError("Chart data contains no categories.");
+    return `Sheet1!$A$2:$${workbookColumn(Math.max(1, this.categories.depth) - 1)}$${this.categories.leaf_count + 1}`;
+  }
+  column(series2) {
+    return this.series_index(series2) + Math.max(1, this.categories.depth) - 1;
+  }
+  values_ref(series2) {
+    return this.reference(series2, this.column(series2) + 1);
+  }
+  x_values_ref(_series) {
+    throw new PropertyAccessError("Category chart data exposes categories_ref, not x_values_ref.");
+  }
+  y_values_ref(_series) {
+    throw new PropertyAccessError("Category chart data exposes values_ref, not y_values_ref.");
+  }
+  to_chart_data(date1904) {
+    const categories = this.categories;
+    return {
+      numberFormat: this.number_format,
+      categoryNumberFormat: categories.number_format,
+      ...date1904 === void 0 ? {} : { date1904 },
+      ...categories.depth > 1 ? {
+        categoryLevels: [...categories.levels].reverse().map((level) => {
+          const values = Array(categories.leaf_count).fill(null);
+          for (const [index, label2] of level) values[index] = String(label2);
+          return values;
+        })
+      } : {
+        categories: [...categories].map(
+          (category) => category.label instanceof Date ? category.label.toISOString() : categories.are_numeric ? Number(category.numeric_str_val(date1904 ?? false)) : String(category.label)
+        )
+      },
+      series: sequenceItems(this).map((series2) => ({
+        name: series2.name,
+        values: series2.values,
+        numberFormat: series2.number_format,
+        pointNumberFormats: [...series2].map(
+          (point) => point.number_format === series2.number_format ? null : point.number_format
+        )
+      }))
+    };
+  }
+};
+var XyChartData = class extends BaseChartData {
+  get columnsPerSeries() {
+    return 2;
+  }
+  add_series(name, number_format = null) {
+    const series2 = new XySeriesData(this, name, number_format);
+    sequenceItems(this).push(series2);
+    return series2;
+  }
+  to_chart_data() {
+    return {
+      numberFormat: this.number_format,
+      series: sequenceItems(this).map((series2) => ({
+        name: series2.name,
+        values: series2.y_values,
+        xValues: series2.x_values,
+        numberFormat: series2.number_format,
+        pointNumberFormats: [...series2].map(
+          (point) => point.number_format === series2.number_format ? null : point.number_format
+        )
+      }))
+    };
+  }
+};
+var BubbleChartData = class extends BaseChartData {
+  get columnsPerSeries() {
+    return 3;
+  }
+  add_series(name, number_format = null) {
+    const series2 = new BubbleSeriesData(this, name, number_format);
+    sequenceItems(this).push(series2);
+    return series2;
+  }
+  bubble_sizes_ref(series2) {
+    return this.reference(series2, this.column(series2) + 2);
+  }
+  to_chart_data() {
+    return {
+      numberFormat: this.number_format,
+      series: sequenceItems(this).map((series2) => ({
+        name: series2.name,
+        values: series2.y_values,
+        xValues: series2.x_values,
+        bubbleSizes: series2.bubble_sizes,
+        numberFormat: series2.number_format,
+        pointNumberFormats: [...series2].map(
+          (point) => point.number_format === series2.number_format ? null : point.number_format
+        )
+      }))
+    };
+  }
+};
+function toChartData(input) {
+  return input instanceof CategoryChartData || input instanceof XyChartData || input instanceof BubbleChartData ? input.to_chart_data() : input;
+}
+
+// packages/safe-bash-presentation-engine/src/chart-type-model.ts
+var plotTags = /* @__PURE__ */ new Set([
+  "areaChart",
+  "area3DChart",
+  "barChart",
+  "bar3DChart",
+  "bubbleChart",
+  "doughnutChart",
+  "lineChart",
+  "line3DChart",
+  "ofPieChart",
+  "pieChart",
+  "pie3DChart",
+  "radarChart",
+  "scatterChart",
+  "stockChart",
+  "surfaceChart",
+  "surface3DChart"
+]);
+function unsupported2() {
+  throw new OfficeError(
+    "unsupported-edit",
+    "Chart type cannot be classified from the retained plot properties.",
+    "validate-intent"
+  );
+}
+function token(node, localName, fallback) {
+  const matches = node.children.filter(
+    (n) => n.name.namespace === node.name.namespace && n.name.localName === localName
+  );
+  if (matches.length > 1)
+    throw new OfficeError("invalid-xml", "Duplicate chart type discriminator.", "index");
+  return matches[0] ? attr(matches[0], "val") ?? fallback : fallback;
+}
+function flag(node, localName, fallback = false) {
+  const value = token(node, localName, child(node, localName) ? "1" : void 0);
+  if (value === void 0) return fallback;
+  if (!["1", "0", "true", "false"].includes(value)) unsupported2();
+  return value === "1" || value === "true";
+}
+function series(node) {
+  return node.children.filter(
+    (n) => n.name.namespace === node.name.namespace && n.name.localName === "ser"
+  );
+}
+function enumType(name) {
+  const value = Object.hasOwn(XL_CHART_TYPE, name) ? XL_CHART_TYPE[name] : void 0;
+  if (typeof value !== "number") unsupported2();
+  return value;
+}
+function readModelChartType(doc) {
+  const ns2 = doc.root.name.namespace;
+  if (![
+    "http://schemas.openxmlformats.org/drawingml/2006/chart",
+    "http://purl.oclc.org/ooxml/drawingml/chart"
+  ].includes(ns2))
+    unsupported2();
+  const chart = child(doc.root, "chart"), area = chart && child(chart, "plotArea");
+  if (!area) unsupported2();
+  const plots = area.children.filter(
+    (n) => n.name.namespace === ns2 && plotTags.has(n.name.localName)
+  );
+  const plot = plots[0];
+  if (!plot) unsupported2();
+  const stock = plots.find((n) => n.name.localName === "stockChart");
+  if (stock && plots.length === 2 && plots.some(
+    (n) => n.name.localName === "barChart" && token(n, "barDir") === "col" && series(n).length === 1
+  )) {
+    const count = series(stock).length;
+    if (count !== 3 && count !== 4) unsupported2();
+    return count === 3 ? XL_CHART_TYPE.STOCK_VHLC : XL_CHART_TYPE.STOCK_VOHLC;
+  }
+  const tag = plot.name.localName;
+  const grouping = token(plot, "grouping", tag.startsWith("bar") ? "clustered" : "standard");
+  if (!["standard", "clustered", "stacked", "percentStacked"].includes(grouping)) unsupported2();
+  const suffix = grouping === "percentStacked" ? "_STACKED_100" : grouping === "stacked" ? "_STACKED" : "";
+  const first = series(plot)[0];
+  if (tag === "barChart" || tag === "bar3DChart") {
+    const direction = token(plot, "barDir");
+    if (direction !== "bar" && direction !== "col") unsupported2();
+    if (tag === "barChart")
+      return enumType(`${direction === "bar" ? "BAR" : "COLUMN"}${suffix || "_CLUSTERED"}`);
+    const shape = (first && token(first, "shape")) ?? token(plot, "shape", "box");
+    const prefixes = {
+      box: `THREE_D_${direction === "bar" ? "BAR" : "COLUMN"}`,
+      cone: `CONE_${direction === "bar" ? "BAR" : "COL"}`,
+      coneToMax: `CONE_${direction === "bar" ? "BAR" : "COL"}`,
+      cylinder: `CYLINDER_${direction === "bar" ? "BAR" : "COL"}`,
+      pyramid: `PYRAMID_${direction === "bar" ? "BAR" : "COL"}`,
+      pyramidToMax: `PYRAMID_${direction === "bar" ? "BAR" : "COL"}`
+    };
+    if (!shape || !Object.hasOwn(prefixes, shape)) unsupported2();
+    return enumType(`${prefixes[shape]}${suffix || (grouping === "standard" ? "" : "_CLUSTERED")}`);
+  }
+  if (tag === "areaChart" || tag === "area3DChart")
+    return enumType(`${tag === "area3DChart" ? "THREE_D_" : ""}AREA${suffix}`);
+  if (tag === "lineChart") {
+    const marker = first && child(first, "marker"), symbol = marker && token(marker, "symbol");
+    const marked = symbol === void 0 ? flag(plot, "marker") : symbol !== "none";
+    return enumType(`LINE${marked ? "_MARKERS" : ""}${suffix}`);
+  }
+  if (tag === "line3DChart") return XL_CHART_TYPE.THREE_D_LINE;
+  if (["pieChart", "pie3DChart", "doughnutChart"].includes(tag)) {
+    const exploded = series(plot).some((n) => Number(token(n, "explosion", "0")) > 0);
+    return enumType(
+      `${tag === "pie3DChart" ? "THREE_D_PIE" : tag === "pieChart" ? "PIE" : "DOUGHNUT"}${exploded ? "_EXPLODED" : ""}`
+    );
+  }
+  if (tag === "ofPieChart") {
+    const type = token(plot, "ofPieType");
+    if (type !== "bar" && type !== "pie") unsupported2();
+    return type === "bar" ? XL_CHART_TYPE.BAR_OF_PIE : XL_CHART_TYPE.PIE_OF_PIE;
+  }
+  if (tag === "bubbleChart")
+    return (first && child(first, "bubble3D") ? flag(first, "bubble3D") : flag(plot, "bubble3D")) ? XL_CHART_TYPE.BUBBLE_THREE_D_EFFECT : XL_CHART_TYPE.BUBBLE;
+  if (tag === "radarChart") {
+    const style = token(plot, "radarStyle"), types = {
+      standard: "RADAR",
+      marker: "RADAR_MARKERS",
+      filled: "RADAR_FILLED"
+    };
+    if (!style || !Object.hasOwn(types, style)) unsupported2();
+    return enumType(types[style]);
+  }
+  if (tag === "scatterChart") {
+    const style = token(plot, "scatterStyle"), types = {
+      marker: "XY_SCATTER",
+      lineMarker: "XY_SCATTER_LINES",
+      line: "XY_SCATTER_LINES_NO_MARKERS",
+      smoothMarker: "XY_SCATTER_SMOOTH",
+      smooth: "XY_SCATTER_SMOOTH_NO_MARKERS"
+    };
+    if (!style || !Object.hasOwn(types, style)) unsupported2();
+    const a = ns2 === "http://purl.oclc.org/ooxml/drawingml/chart" ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+    const props = first && child(first, "spPr"), line = props && child(props, "ln", a);
+    if (line && child(line, "noFill", a)) return XL_CHART_TYPE.XY_SCATTER;
+    return enumType(types[style]);
+  }
+  if (tag === "stockChart") {
+    const count = series(plot).length;
+    if (count !== 3 && count !== 4) unsupported2();
+    return count === 3 ? XL_CHART_TYPE.STOCK_HLC : XL_CHART_TYPE.STOCK_OHLC;
+  }
+  return enumType(
+    `SURFACE${tag === "surfaceChart" ? "_TOP_VIEW" : ""}${flag(plot, "wireframe") ? "_WIREFRAME" : ""}`
+  );
+}
+
+// packages/safe-bash-presentation-engine/src/chart-model.ts
+var ChartRoot = class extends ChartNode {
+  get title() {
+    return new ChartTitle(chartDescendant(this, "title", true));
+  }
+  get hasTitle() {
+    return !!child(chartNode(this), "title");
+  }
+  set hasTitle(value) {
+    this.present("title", value);
+  }
+  get legend() {
+    return child(chartNode(this), "legend") ? new Legend(chartDescendant(this, "legend")) : null;
+  }
+};
+var ChartSpace = class extends ChartNode {
+  get font() {
+    return this.textFrame().paragraphs[0].font;
+  }
+};
+var Chart = class {
+  #owner;
+  #options;
+  #read;
+  #write;
+  constructor(read, write, options = {}) {
+    this.#options = options;
+    this.#owner = chartBinding(read, write);
+    this.#read = this.#owner.read;
+    this.#write = this.#owner.write;
+  }
+  get part() {
+    this.#read();
+    if (!this.#options.part) throw new PropertyAccessError("Chart package part is unavailable.");
+    return this.#options.part();
+  }
+  replace_data(data) {
+    this.#read();
+    const input = toChartData(data);
+    if (!this.#options.replaceData)
+      throw new PropertyAccessError("Chart workbook ownership is unavailable.");
+    this.#options.replaceData(input);
+    this.#read();
+  }
+  #binding() {
+    return this.#owner;
+  }
+  #chart() {
+    const binding = this.#binding();
+    return new ChartRoot({ ...binding, locate: (xml) => required(xml.root, "chart") });
+  }
+  get has_title() {
+    return this.#chart().hasTitle;
+  }
+  set has_title(value) {
+    this.#chart().hasTitle = value;
+  }
+  get chart_title() {
+    return this.#chart().title;
+  }
+  get legend() {
+    return this.#chart().legend;
+  }
+  get font() {
+    return new ChartSpace(this.#binding()).font;
+  }
+  #axis(names, index = 0) {
+    const binding = this.#binding();
+    const locate = (xml) => {
+      const area = required(required(xml.root, "chart"), "plotArea");
+      const found = area.children.filter(
+        (n) => n.name.namespace === area.name.namespace && names.includes(n.name.localName)
+      )[index];
+      if (!found) throw new PropertyAccessError("Chart axis is unavailable.");
+      return found;
+    };
+    locate(this.#read());
+    return { ...binding, locate };
+  }
+  get category_axis() {
+    try {
+      const binding = this.#axis(["catAx", "dateAx"]);
+      return binding.locate(this.#read()).name.localName === "dateAx" ? new DateAxis(binding) : new CategoryAxis(binding);
+    } catch (error) {
+      if (!(error instanceof PropertyAccessError)) throw error;
+      return new ValueAxis(this.#axis(["valAx"]));
+    }
+  }
+  get value_axis() {
+    const area = required(required(this.#read().root, "chart"), "plotArea");
+    const hasCategories = area.children.some(
+      (n) => n.name.namespace === area.name.namespace && ["catAx", "dateAx"].includes(n.name.localName)
+    );
+    return new ValueAxis(this.#axis(["valAx"], hasCategories ? 0 : 1));
+  }
+  get plots() {
+    const binding = this.#binding();
+    return new Plots(() => {
+      const area = required(required(this.#read().root, "chart"), "plotArea");
+      return area.children.filter(
+        (n) => n.name.namespace === area.name.namespace && plotNames.includes(n.name.localName)
+      ).map(
+        (_, index) => plotFor(
+          {
+            ...binding,
+            locate: (xml) => {
+              const parent = required(required(xml.root, "chart"), "plotArea"), found = parent.children.filter(
+                (n) => n.name.namespace === parent.name.namespace && plotNames.includes(n.name.localName)
+              )[index];
+              if (!found) throw new InvalidHandleError();
+              return found;
+            }
+          },
+          this
+        )
+      );
+    });
+  }
+  get series() {
+    return new SeriesCollection(() => [...this.plots].flatMap((plot) => [...plot.series]));
+  }
+  get chart_type() {
+    return readModelChartType(this.#read());
+  }
+  get chart_style() {
+    const node = child(this.#read().root, "style");
+    if (!node) return null;
+    const value = Number(attr(node, "val"));
+    if (!Number.isInteger(value) || value < 1 || value > 48)
+      throw new ValueError("Invalid chart style.");
+    return value;
+  }
+  set chart_style(value) {
+    if (value !== null && typeof value !== "number") throw new TypeError();
+    this.#write(applyChartAppearance(this.#read(), { style: value }));
+  }
+  get has_legend() {
+    return !!child(required(this.#read().root, "chart"), "legend");
+  }
+  set has_legend(value) {
+    if (typeof value !== "boolean") throw new TypeError();
+    this.#write(applyChartAppearance(this.#read(), { legend: value }));
+  }
+  get element() {
+    return createXmlElementView({
+      read: this.#read,
+      commit: (expected, next) => {
+        if (this.#read() !== expected) throw new InvalidHandleError();
+        this.#write(next);
+      }
+    });
+  }
+};
+
+// packages/safe-bash-presentation-engine/src/chart-object-mutations.ts
+function applyChartObjectUpdates(document, updates) {
+  validateChartObjectUpdates(updates);
+  const chart = new Chart(
+    () => document,
+    (next) => {
+      document = next;
+    }
+  );
+  for (const edit of updates) {
+    switch (edit.target) {
+      case "font": {
+        const { target: ignoredTarget, ...font } = edit;
+        applyChartFontUpdate(chart, font);
+        break;
+      }
+      case "format": {
+        const series2 = () => chart.series.at(edit.series);
+        const owner = (() => {
+          switch (edit.owner) {
+            case "title":
+              return chart.chart_title;
+            case "legend": {
+              if (!chart.legend) throw new PropertyAccessError();
+              return chart.legend;
+            }
+            case "categoryAxis":
+              return chart.category_axis;
+            case "valueAxis":
+              return chart.value_axis;
+            case "categoryAxisTitle":
+              return chart.category_axis.axis_title;
+            case "valueAxisTitle":
+              return chart.value_axis.axis_title;
+            case "categoryMajorGridlines":
+              return chart.category_axis.major_gridlines;
+            case "valueMajorGridlines":
+              return chart.value_axis.major_gridlines;
+            case "series":
+              return series2();
+            case "point":
+              return series2().points.at(edit.point);
+            case "marker": {
+              const selected = series2();
+              if (edit.point !== void 0) return selected.points.at(edit.point).marker;
+              if (!(selected instanceof RadarSeries || selected instanceof XySeries))
+                throw new PropertyAccessError();
+              return selected.marker;
+            }
+          }
+        })();
+        owner.format.apply(edit.drawing);
+        break;
+      }
+      case "chart":
+        if (edit.hasTitle !== void 0) chart.has_title = edit.hasTitle;
+        if (edit.hasLegend !== void 0) chart.has_legend = edit.hasLegend;
+        if (edit.style !== void 0) chart.chart_style = edit.style;
+        break;
+      case "title": {
+        const title = chart.chart_title;
+        if (edit.hasTextFrame !== void 0) title.has_text_frame = edit.hasTextFrame;
+        if (edit.text !== void 0) title.text_frame.text = edit.text;
+        break;
+      }
+      case "legend": {
+        const legend = chart.legend;
+        if (!legend) throw new PropertyAccessError();
+        if (edit.position !== void 0)
+          legend.position = XL_LEGEND_POSITION[edit.position];
+        if (edit.includeInLayout !== void 0)
+          legend.include_in_layout = edit.includeInLayout;
+        if (edit.horzOffset !== void 0) legend.horz_offset = edit.horzOffset;
+        break;
+      }
+      case "categoryAxis":
+      case "valueAxis": {
+        const axis = edit.target === "categoryAxis" ? chart.category_axis : chart.value_axis;
+        if (edit.hasTitle !== void 0) axis.has_title = edit.hasTitle;
+        if (edit.hasMajorGridlines !== void 0)
+          axis.has_major_gridlines = edit.hasMajorGridlines;
+        if (edit.hasMinorGridlines !== void 0)
+          axis.has_minor_gridlines = edit.hasMinorGridlines;
+        if (edit.majorTickMark !== void 0)
+          axis.major_tick_mark = XL_TICK_MARK[edit.majorTickMark];
+        if (edit.minorTickMark !== void 0)
+          axis.minor_tick_mark = XL_TICK_MARK[edit.minorTickMark];
+        if (edit.maximumScale !== void 0)
+          axis.maximum_scale = edit.maximumScale;
+        if (edit.minimumScale !== void 0)
+          axis.minimum_scale = edit.minimumScale;
+        if (edit.reverseOrder !== void 0) axis.reverse_order = edit.reverseOrder;
+        if (edit.tickLabelPosition !== void 0)
+          axis.tick_label_position = XL_TICK_LABEL_POSITION[edit.tickLabelPosition];
+        if (edit.visible !== void 0) axis.visible = edit.visible;
+        if (edit.target === "valueAxis") {
+          const value = chart.value_axis;
+          if (edit.crosses !== void 0)
+            value.crosses = XL_AXIS_CROSSES[edit.crosses];
+          if (edit.crossesAt !== void 0) value.crosses_at = edit.crossesAt;
+          if (edit.majorUnit !== void 0) value.major_unit = edit.majorUnit;
+          if (edit.minorUnit !== void 0) value.minor_unit = edit.minorUnit;
+        }
+        break;
+      }
+      case "axisTitle": {
+        const title = (edit.axis === "category" ? chart.category_axis : chart.value_axis).axis_title;
+        if (edit.hasTextFrame !== void 0) title.has_text_frame = edit.hasTextFrame;
+        if (edit.text !== void 0) title.text_frame.text = edit.text;
+        break;
+      }
+      case "tickLabels": {
+        const labels = (edit.axis === "category" ? chart.category_axis : chart.value_axis).tick_labels;
+        if (edit.numberFormat !== void 0) labels.number_format = edit.numberFormat;
+        if (edit.numberFormatIsLinked !== void 0)
+          labels.number_format_is_linked = edit.numberFormatIsLinked;
+        if (edit.offset !== void 0) labels.offset = edit.offset;
+        break;
+      }
+      case "plot": {
+        const plot = chart.plots.at(edit.plot);
+        if (edit.hasDataLabels !== void 0) plot.has_data_labels = edit.hasDataLabels;
+        if (edit.varyByCategories !== void 0)
+          plot.vary_by_categories = edit.varyByCategories;
+        if (edit.gapWidth !== void 0) {
+          if (!(plot instanceof BarPlot)) throw new PropertyAccessError();
+          plot.gap_width = edit.gapWidth;
+        }
+        if (edit.overlap !== void 0) {
+          if (!(plot instanceof BarPlot)) throw new PropertyAccessError();
+          plot.overlap = edit.overlap;
+        }
+        if (edit.bubbleScale !== void 0) {
+          if (!(plot instanceof BubblePlot)) throw new PropertyAccessError();
+          plot.bubble_scale = edit.bubbleScale;
+        }
+        break;
+      }
+      case "series": {
+        const series2 = chart.series.at(edit.series);
+        if (edit.invertIfNegative !== void 0) {
+          if (!(series2 instanceof BarSeries)) throw new PropertyAccessError();
+          series2.invert_if_negative = edit.invertIfNegative;
+        }
+        if (edit.smooth !== void 0) {
+          if (!(series2 instanceof LineSeries)) throw new PropertyAccessError();
+          series2.smooth = edit.smooth;
+        }
+        break;
+      }
+      case "marker": {
+        const series2 = chart.series.at(edit.series);
+        if (edit.point === void 0 && !(series2 instanceof RadarSeries || series2 instanceof XySeries))
+          throw new PropertyAccessError();
+        const marker = edit.point === void 0 ? series2.marker : series2.points.at(edit.point).marker;
+        if (edit.style !== void 0)
+          marker.style = edit.style === null ? null : XL_MARKER_STYLE[edit.style];
+        if (edit.size !== void 0) marker.size = edit.size;
+        break;
+      }
+      case "dataLabels": {
+        const labels = chart.plots.at(edit.plot).data_labels;
+        if (edit.position !== void 0)
+          labels.position = edit.position === null ? null : XL_DATA_LABEL_POSITION[edit.position];
+        if (edit.numberFormat !== void 0) labels.number_format = edit.numberFormat;
+        if (edit.numberFormatIsLinked !== void 0)
+          labels.number_format_is_linked = edit.numberFormatIsLinked;
+        if (edit.showCategoryName !== void 0)
+          labels.show_category_name = edit.showCategoryName;
+        if (edit.showLegendKey !== void 0)
+          labels.show_legend_key = edit.showLegendKey;
+        if (edit.showPercentage !== void 0)
+          labels.show_percentage = edit.showPercentage;
+        if (edit.showSeriesName !== void 0)
+          labels.show_series_name = edit.showSeriesName;
+        if (edit.showValue !== void 0) labels.show_value = edit.showValue;
+        break;
+      }
+      case "dataLabel": {
+        const label2 = chart.series.at(edit.series).points.at(edit.point).data_label;
+        if (edit.position !== void 0)
+          label2.position = edit.position === null ? null : XL_DATA_LABEL_POSITION[edit.position];
+        if (edit.hasTextFrame !== void 0) label2.has_text_frame = edit.hasTextFrame;
+        if (edit.text !== void 0) label2.text_frame.text = edit.text;
+        break;
+      }
+    }
+  }
+  return document;
+}
+
+// packages/safe-bash-presentation-engine/src/chart-editing.ts
+var chartTypes = [
+  "AREA",
+  "AREA_STACKED",
+  "AREA_STACKED_100",
+  "BUBBLE",
+  "BUBBLE_THREE_D_EFFECT",
+  "DOUGHNUT",
+  "DOUGHNUT_EXPLODED",
+  "RADAR",
+  "RADAR_FILLED",
+  "RADAR_MARKERS",
+  "BAR_CLUSTERED",
+  "BAR_STACKED",
+  "BAR_STACKED_100",
+  "COLUMN_CLUSTERED",
+  "COLUMN_STACKED",
+  "COLUMN_STACKED_100",
+  "LINE",
+  "LINE_MARKERS",
+  "LINE_MARKERS_STACKED",
+  "LINE_MARKERS_STACKED_100",
+  "LINE_STACKED",
+  "LINE_STACKED_100",
+  "PIE",
+  "PIE_EXPLODED",
+  "XY_SCATTER",
+  "XY_SCATTER_LINES",
+  "XY_SCATTER_LINES_NO_MARKERS",
+  "XY_SCATTER_SMOOTH",
+  "XY_SCATTER_SMOOTH_NO_MARKERS"
+];
+function invalid(message) {
+  throw new OfficeError("invalid-value", message, "usage");
+}
+function unsupported3(message) {
+  throw new OfficeError("unsupported-edit", message, "validate-intent");
+}
+function object(value, keys) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Reflect.ownKeys(value).some(
+    (k) => typeof k !== "string" || !keys.includes(k) || !("value" in Object.getOwnPropertyDescriptor(value, k))
+  ))
+    invalid("Chart options require plain data properties.");
+}
+function array(value) {
+  if (!Array.isArray(value) || value.length === 0 || Reflect.ownKeys(value).some(
+    (k) => k !== "length" && (typeof k !== "string" || !Number.isSafeInteger(Number(k)) || String(Number(k)) !== k || !("value" in Object.getOwnPropertyDescriptor(value, k)))
+  ) || Object.keys(value).length !== value.length)
+    invalid("Chart arrays require nonempty bounded dense data.");
+}
+function dateLabel(value) {
+  return typeof value === "string" && value.length >= 20 && value[4] === "-" && value[7] === "-" && value[10] === "T" && value.endsWith("Z");
+}
+function dateSerial(value, date1904) {
+  const stamp = Date.parse(value);
+  if (!Number.isFinite(stamp) || new Date(stamp).toISOString().slice(0, 19) !== value.slice(0, 19))
+    invalid("Invalid UTC category date.");
+  const day = Math.floor(stamp / 864e5);
+  return date1904 ? day - Math.floor(Date.UTC(1904, 0, 1) / 864e5) : day - Math.floor(Date.UTC(1899, 11, 31) / 864e5) + (day >= Math.floor(Date.UTC(1900, 2, 1) / 864e5) ? 1 : 0);
+}
+function normalizedData(data, date1904 = data.date1904 ?? false) {
+  return {
+    ...data,
+    ...data.categories?.some(dateLabel) ? { categoryNumberFormat: data.categoryNumberFormat ?? "yyyy-mm-dd" } : {},
+    ...data.categories ? {
+      categories: data.categories.map(
+        (value) => dateLabel(value) ? dateSerial(value, date1904) : value
+      )
+    } : {}
+  };
+}
+function validateChartData(data, type) {
+  object(data, [
+    "categories",
+    "categoryLevels",
+    "numberFormat",
+    "categoryNumberFormat",
+    "date1904",
+    "series"
+  ]);
+  for (const format2 of [data.numberFormat, data.categoryNumberFormat])
+    if (format2 !== void 0 && typeof format2 !== "string")
+      invalid("Number formats require strings.");
+  if (data.date1904 !== void 0 && typeof data.date1904 !== "boolean")
+    invalid("Date system requires a boolean.");
+  if (data.categoryLevels !== void 0) {
+    array(data.categoryLevels);
+    for (const level of data.categoryLevels) array(level);
+    if (data.categories !== void 0)
+      invalid("Hierarchical categories cannot accompany flat categories.");
+    for (const level of data.categoryLevels) {
+      array(level);
+      if (level.length !== data.categoryLevels[0].length || level.some((value) => value !== null && typeof value !== "string"))
+        invalid("Category levels require equally sized string or null arrays.");
+    }
+  }
+  array(data.series);
+  if (type !== void 0 && !chartTypes.includes(type)) invalid("Unsupported chart creation type.");
+  if (data.categories !== void 0) {
+    array(data.categories);
+    const kinds = new Set(
+      data.categories.filter((v) => v !== null).map((v) => dateLabel(v) ? "date" : typeof v)
+    );
+    for (const value of data.categories) if (dateLabel(value)) dateSerial(value, false);
+    if (kinds.size > 1 || data.categories.some(
+      (v) => v !== null && typeof v !== "string" && (typeof v !== "number" || !Number.isFinite(v))
+    ))
+      invalid("Categories require homogeneous strings or finite numbers with optional nulls.");
+  }
+  for (const series2 of data.series) {
+    object(series2, [
+      "name",
+      "values",
+      "xValues",
+      "bubbleSizes",
+      "numberFormat",
+      "pointNumberFormats"
+    ]);
+    if (typeof series2.name !== "string" || series2.numberFormat !== void 0 && typeof series2.numberFormat !== "string")
+      invalid("Series names and number formats require strings.");
+    array(series2.values);
+    if (series2.pointNumberFormats !== void 0) {
+      array(series2.pointNumberFormats);
+      if (series2.pointNumberFormats.length !== series2.values.length || series2.pointNumberFormats.some((format2) => format2 !== null && typeof format2 !== "string"))
+        invalid("Point number formats require matching string or null entries.");
+    }
+    if (series2.values.some((v) => v !== null && (typeof v !== "number" || !Number.isFinite(v))))
+      invalid("Series values require finite numbers or nulls.");
+    if (series2.xValues !== void 0) {
+      array(series2.xValues);
+      if (series2.xValues.length !== series2.values.length || series2.xValues.some((v) => typeof v !== "number" || !Number.isFinite(v)))
+        invalid("Scatter coordinates require equal length finite x values.");
+    }
+    if (series2.bubbleSizes !== void 0) {
+      array(series2.bubbleSizes);
+      if (series2.bubbleSizes.length !== series2.values.length || series2.bubbleSizes.some(
+        (value) => typeof value !== "number" || !Number.isFinite(value) || value < 0
+      ))
+        invalid("Bubble sizes require equal length nonnegative finite values.");
+    }
+    if (type !== void 0 && !type.startsWith("BUBBLE") && series2.bubbleSizes !== void 0)
+      invalid("Bubble sizes are only supported by bubble charts.");
+    if (type?.startsWith("BUBBLE") && series2.bubbleSizes === void 0)
+      invalid("Bubble charts require sizes.");
+    if (type?.startsWith("XY_") || type?.startsWith("BUBBLE")) {
+      if (data.categories !== void 0 || data.categoryLevels !== void 0 || !series2.xValues)
+        invalid("Scatter requires x values and forbids categories.");
+    } else if (type !== void 0) {
+      if (!data.categories && !data.categoryLevels || (data.categories ?? data.categoryLevels[0]).length !== series2.values.length || series2.xValues !== void 0)
+        invalid("Category series lengths must match categories.");
+    }
+  }
+  if ((type?.startsWith("PIE") || type?.startsWith("DOUGHNUT")) && data.series.length !== 1)
+    invalid("Pie charts require exactly one series.");
+}
+function validateChartUpdate(update) {
+  object(update, ["objects", "data", "style", "title", "legend", "left", "top", "width", "height"]);
+  if (update.objects !== void 0) validateChartObjectUpdates(update.objects);
+  if (update.data !== void 0) validateChartData(update.data);
+  if (update.style !== void 0 && (!Number.isInteger(update.style) || update.style < 1 || update.style > 48))
+    invalid("Chart style requires an integer from 1 to 48.");
+  if (update.title !== void 0 && typeof update.title !== "string")
+    invalid("Chart title requires text.");
+  if (update.legend !== void 0 && typeof update.legend !== "boolean")
+    invalid("Chart legend requires a boolean.");
+  for (const k of ["left", "top", "width", "height"]) {
+    const v = update[k];
+    if (v !== void 0 && (!Number.isSafeInteger(v) || Math.abs(v) > 27273042316900 || (k === "width" || k === "height") && v <= 0))
+      invalid("Chart geometry requires bounded integer EMUs and positive extents.");
+  }
+}
+function variant(type) {
+  return {
+    scatter: type.startsWith("XY_") || type.startsWith("BUBBLE"),
+    bubble: type.startsWith("BUBBLE"),
+    area: type.startsWith("AREA"),
+    radar: type.startsWith("RADAR"),
+    doughnut: type.startsWith("DOUGHNUT"),
+    pie: type.startsWith("PIE") || type.startsWith("DOUGHNUT"),
+    bar: type.startsWith("BAR_") || type.startsWith("COLUMN_"),
+    horizontal: type.startsWith("BAR_"),
+    grouping: type.endsWith("_100") ? "percentStacked" : type.includes("STACKED") ? "stacked" : "clustered",
+    marker: !type.endsWith("NO_MARKERS"),
+    smooth: type.includes("SMOOTH")
+  };
+}
+function seriesXml(type, data, index, sheetName, date1904 = false) {
+  const dates = data.categories?.some(dateLabel) ?? false;
+  data = normalizedData(data, date1904);
+  const series2 = data.series[index], v = variant(type), xColumn = v.scatter ? index * (v.bubble ? 3 : 2) : 0, yColumn = v.scatter ? xColumn + 1 : index + (data.categoryLevels?.length ?? 1);
+  const sheet = sheetName === "Sheet1" ? sheetName : `'${sheetName.split("'").join("''")}'`;
+  const reference = (holder, values, numeric2, col) => `<c:${holder}><c:${numeric2 ? "num" : "str"}Ref><c:f>${escape(`${sheet}!$${workbookColumn(col)}$2:$${workbookColumn(col)}$${values.length + 1}`)}</c:f><c:${numeric2 ? "num" : "str"}Cache>${numeric2 ? `<c:formatCode>${escape(holder === "cat" ? data.categoryNumberFormat ?? (dates ? "yyyy-mm-dd" : "General") : holder === "xVal" || holder === "bubbleSize" ? data.numberFormat ?? "General" : series2.numberFormat ?? data.numberFormat ?? "General")}</c:formatCode>` : ""}<c:ptCount val="${values.length}"/>${values.map((n, i) => n === null ? "" : `<c:pt idx="${i}"${(holder === "val" || holder === "yVal") && series2.pointNumberFormats?.[i] !== void 0 && series2.pointNumberFormats[i] !== null ? ` formatCode="${escape(series2.pointNumberFormats[i])}"` : ""}><c:v>${escape(String(n))}</c:v></c:pt>`).join("")}</c:${numeric2 ? "num" : "str"}Cache></c:${numeric2 ? "num" : "str"}Ref></c:${holder}>`;
+  return `<c:ser><c:idx val="${index}"/><c:order val="${index}"/><c:tx><c:strRef><c:f>${escape(`${sheet}!$${workbookColumn(yColumn)}$1`)}</c:f><c:strCache><c:ptCount val="1"/><c:pt idx="0"><c:v>${escape(series2.name)}</c:v></c:pt></c:strCache></c:strRef></c:tx>${type.startsWith("LINE") || v.scatter && !v.bubble || v.radar && type !== "RADAR_FILLED" ? `<c:marker><c:symbol val="${(v.scatter ? v.marker : type.includes("MARKERS")) ? "circle" : "none"}"/></c:marker>` : ""}${type === "PIE_EXPLODED" || type === "DOUGHNUT_EXPLODED" ? '<c:explosion val="25"/>' : ""}${v.scatter ? reference("xVal", series2.xValues, true, xColumn) + reference("yVal", series2.values, true, yColumn) + (v.bubble ? reference("bubbleSize", series2.bubbleSizes, true, yColumn + 1) + `<c:bubble3D val="${type === "BUBBLE_THREE_D_EFFECT" ? 1 : 0}"/>` : "") : (data.categoryLevels ? `<c:cat><c:multiLvlStrRef><c:f>${escape(`${sheet}!$A$2:$${workbookColumn(data.categoryLevels.length - 1)}$${data.categoryLevels[0].length + 1}`)}</c:f><c:multiLvlStrCache><c:ptCount val="${data.categoryLevels[0].length}"/>${[
+    ...data.categoryLevels
+  ].reverse().map(
+    (level, reversedLevel) => `<c:lvl>${level.map((value, i) => value === null || reversedLevel > 0 && i > 0 && data.categoryLevels.slice(0, data.categoryLevels.length - reversedLevel).every((ancestor) => ancestor[i] === ancestor[i - 1]) ? "" : `<c:pt idx="${i}"><c:v>${escape(value)}</c:v></c:pt>`).join("")}</c:lvl>`
+  ).join("")}</c:multiLvlStrCache></c:multiLvlStrRef></c:cat>` : reference(
+    "cat",
+    data.categories,
+    data.categories.some((x) => typeof x === "number"),
+    0
+  )) + reference("val", series2.values, true, yColumn)}${type.startsWith("LINE") || v.scatter && !v.bubble ? `<c:smooth val="${v.smooth ? 1 : 0}"/>` : ""}</c:ser>`;
+}
+function titleXml(title, a, c) {
+  return `<c:title xmlns:c="${c}" xmlns:a="${a}"><c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${escape(title)}</a:t></a:r></a:p></c:rich></c:tx><c:overlay val="0"/></c:title>`;
+}
+function createChartXml(type, data, properties = {}, strict = false, sheetName = "Sheet1", date1904 = data.date1904 ?? false) {
+  validateChartData(data, type);
+  validateChartUpdate(properties);
+  const c = strict ? "http://purl.oclc.org/ooxml/drawingml/chart" : "http://schemas.openxmlformats.org/drawingml/2006/chart", a = strict ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main", r = strict ? "http://purl.oclc.org/ooxml/officeDocument/relationships" : "http://schemas.openxmlformats.org/officeDocument/2006/relationships", v = variant(type), plot = v.bubble ? "bubbleChart" : v.scatter ? "scatterChart" : v.doughnut ? "doughnutChart" : v.pie ? "pieChart" : v.bar ? "barChart" : v.area ? "areaChart" : v.radar ? "radarChart" : "lineChart";
+  const axisName = (category) => category ? data.categories?.some(dateLabel) && !v.radar ? "dateAx" : "catAx" : "valAx";
+  const axis = (id, cross, pos, category) => `<c:${axisName(category)}><c:axId val="${id}"/><c:scaling><c:orientation val="minMax"/></c:scaling><c:delete val="0"/><c:axPos val="${pos}"/><c:numFmt formatCode="${escape(category ? data.categoryNumberFormat ?? (data.categories?.some(dateLabel) ? "yyyy-mm-dd" : "General") : "General")}" sourceLinked="1"/><c:majorTickMark val="none"/><c:minorTickMark val="none"/><c:tickLblPos val="nextTo"/><c:crossAx val="${cross}"/><c:crosses val="autoZero"/>${category ? data.categories?.some(dateLabel) && !v.radar ? '<c:auto val="1"/><c:lblOffset val="100"/><c:baseTimeUnit val="days"/>' : '<c:auto val="1"/><c:lblAlgn val="ctr"/><c:lblOffset val="100"/>' : `<c:crossBetween val="${v.scatter ? "midCat" : "between"}"/>`}</c:${axisName(category)}>`;
+  const setup = v.bubble ? "" : v.radar ? `<c:radarStyle val="${type === "RADAR_FILLED" ? "filled" : "marker"}"/>` : v.scatter ? `<c:scatterStyle val="${type === "XY_SCATTER" ? "marker" : v.smooth ? v.marker ? "smoothMarker" : "smooth" : v.marker ? "lineMarker" : "line"}"/>` : v.bar ? `<c:barDir val="${v.horizontal ? "bar" : "col"}"/><c:grouping val="${v.grouping}"/>` : v.pie ? "" : `<c:grouping val="${v.grouping === "clustered" ? "standard" : v.grouping}"/>`;
+  return `<c:chartSpace xmlns:c="${c}" xmlns:a="${a}" xmlns:r="${r}">${date1904 ? '<c:date1904 val="1"/>' : ""}${properties.style === void 0 ? "" : `<c:style val="${properties.style}"/>`}<c:chart>${properties.title === void 0 ? "" : titleXml(properties.title, a, c)}<c:autoTitleDeleted val="${properties.title === void 0 ? 1 : 0}"/><c:plotArea><c:layout/><c:${plot}>${setup}<c:varyColors val="${v.pie ? 1 : 0}"/>${data.series.map((_, i) => seriesXml(type, data, i, sheetName, date1904)).join("")}${v.bar ? `<c:gapWidth val="150"/>${v.grouping !== "clustered" ? '<c:overlap val="100"/>' : ""}` : ""}${v.bubble ? '<c:bubbleScale val="100"/><c:showNegBubbles val="0"/>' : ""}${v.doughnut ? '<c:firstSliceAng val="0"/><c:holeSize val="50"/>' : v.pie ? '<c:firstSliceAng val="0"/>' : '<c:axId val="1"/><c:axId val="2"/>'}</c:${plot}>${v.pie ? "" : axis(1, 2, v.horizontal ? "l" : "b", !v.scatter) + axis(2, 1, v.horizontal ? "b" : "l", false)}</c:plotArea>${properties.legend ? '<c:legend><c:legendPos val="r"/><c:overlay val="0"/></c:legend>' : ""}<c:plotVisOnly val="1"/><c:dispBlanksAs val="gap"/></c:chart><c:externalData r:id="rId1"><c:autoUpdate val="0"/></c:externalData></c:chartSpace>`;
+}
+function validateAddChartOptions(options) {
+  object(options, [
+    "slide",
+    "type",
+    "data",
+    "style",
+    "title",
+    "legend",
+    "left",
+    "top",
+    "width",
+    "height"
+  ]);
+  const { slide, type, ...update } = options;
+  validateChartUpdate(update);
+  validateChartData(options.data, type);
+  if (!Number.isSafeInteger(slide) || slide < 1)
+    invalid("Chart creation requires a positive slide position.");
+  for (const key of ["left", "top", "width", "height"])
+    if (options[key] === void 0) invalid("Chart creation requires explicit geometry.");
+}
+async function addChart(input, options, context) {
+  validateAddChartOptions(options);
+  options = structuredClone(options);
+  const state2 = await loadShared(input, context);
+  const workbooks = /* @__PURE__ */ new Map();
+  insertChartIntoState(state2, options, context, (part, members) => {
+    workbooks.set(part, members);
+  });
+  for (const [part, members] of workbooks)
+    state2.changes.set(part, await writePackageArchive(members, context, { compression: "store" }));
+  const target = state2.index.inventory.slides.find((slide) => slide.position === options.slide);
+  return (await state2.finish(target.part, [options.slide])).bytes;
+}
+function insertChartIntoState(original, options, context, registerWorkbook) {
+  validateAddChartOptions(options);
+  if (context.signal?.aborted)
+    throw new OfficeError("cancelled", "Chart insertion cancelled.", "mutate");
+  options = structuredClone(options);
+  const { slide, type, ...update } = options;
+  const members = prepareChartWorkbookMembers(
+    normalizedData(options.data),
+    variant(type).scatter,
+    context,
+    { date1904: options.data.date1904 ?? false }
+  );
+  const changes = new Map(original.changes);
+  const s = {
+    ...original,
+    changes,
+    doc: (part) => parseXmlPart(changes.get(part) ?? original.reader.get(part), context.xmlLimits),
+    save: (part, xml2) => {
+      changes.set(part, xml2.bytes());
+    }
+  };
+  const target = s.index.inventory.slides.find((x) => x.position === slide);
+  if (!target) throw new SelectionError("missing-selection");
+  const doc = s.doc(target.part), tree = required(required(doc.root, "cSld"), "spTree");
+  const id = new ShapeIdAllocator(() => doc).next();
+  let n = 1;
+  while ([...s.reader.names, ...s.changes.keys()].some(
+    (x) => x.toLowerCase() === `/ppt/charts/chart${n}.xml` || x.toLowerCase() === `/ppt/embeddings/chart${n}.xlsx` || x.toLowerCase() === `/ppt/charts/_rels/chart${n}.xml.rels`
+  ))
+    n++;
+  const chartPart = `/ppt/charts/chart${n}.xml`, workbookPart = `/ppt/embeddings/chart${n}.xlsx`, relns = "http://schemas.openxmlformats.org/package/2006/relationships", slideRelPart = relPart(target.part), rels = s.reader.names.includes(slideRelPart) || s.changes.has(slideRelPart) ? s.doc(slideRelPart) : parseXmlPart(
+    new TextEncoder().encode(`<Relationships xmlns="${relns}"/>`),
+    context.xmlLimits
+  ), rid = nextRel(rels);
+  s.save(
+    slideRelPart,
+    rels.spliceChildren(rels.root, rels.root.children.length, 0, [
+      `<Relationship xmlns="${relns}" Id="${rid}" Type="${s.r}/chart" Target="${escape(relativePartReference(chartPart, target.part.slice(0, target.part.lastIndexOf("/"))))}"/>`
+    ])
+  );
+  const chartBytes = new TextEncoder().encode(
+    createChartXml(type, options.data, update, s.p.includes("purl.oclc.org"))
+  );
+  parseXmlPart(chartBytes, context.xmlLimits);
+  s.changes.set(chartPart, chartBytes);
+  s.changes.set(workbookPart, new Uint8Array());
+  s.changes.set(
+    relPart(chartPart),
+    new TextEncoder().encode(
+      `<Relationships xmlns="${relns}"><Relationship Id="rId1" Type="${s.r}/package" Target="../embeddings/chart${n}.xlsx"/></Relationships>`
+    )
+  );
+  const types = s.doc("/[Content_Types].xml");
+  s.save(
+    "/[Content_Types].xml",
+    types.spliceChildren(types.root, types.root.children.length, 0, [
+      `<Override xmlns="${types.root.name.namespace}" PartName="${chartPart}" ContentType="application/vnd.openxmlformats-officedocument.drawingml.chart+xml"/>`,
+      `<Override xmlns="${types.root.name.namespace}" PartName="${workbookPart}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"/>`
+    ])
+  );
+  const c = s.p.includes("purl.oclc.org") ? "http://purl.oclc.org/ooxml/drawingml/chart" : "http://schemas.openxmlformats.org/drawingml/2006/chart";
+  const xml = `<p:graphicFrame xmlns:p="${s.p}" xmlns:a="${s.a}" xmlns:r="${s.r}" xmlns:c="${c}"><p:nvGraphicFramePr><p:cNvPr id="${id}" name="Chart ${id}"/><p:cNvGraphicFramePr/><p:nvPr/></p:nvGraphicFramePr><p:xfrm><a:off x="${options.left}" y="${options.top}"/><a:ext cx="${options.width}" cy="${options.height}"/></p:xfrm><a:graphic><a:graphicData uri="${c}"><c:chart r:id="${rid}"/></a:graphicData></a:graphic></p:graphicFrame>`;
+  const ext = child(tree, "extLst");
+  s.save(
+    target.part,
+    doc.spliceChildren(tree, ext ? tree.children.indexOf(ext) : tree.children.length, 0, [xml])
+  );
+  registerWorkbook(workbookPart, members);
+  for (const [part, bytes] of changes)
+    if (original.changes.get(part) !== bytes) original.changes.set(part, bytes);
+  return id;
+}
+function replaceChild(doc, parent, name, xml) {
+  const old = child(parent, name), order2 = parent.name.localName === "chartSpace" ? [
+    "date1904",
+    "lang",
+    "roundedCorners",
+    "style",
+    "clrMapOvr",
+    "pivotSource",
+    "protection",
+    "chart",
+    "spPr",
+    "txPr",
+    "externalData",
+    "printSettings",
+    "userShapes",
+    "extLst"
+  ] : [
+    "title",
+    "autoTitleDeleted",
+    "pivotFmts",
+    "view3D",
+    "floor",
+    "sideWall",
+    "backWall",
+    "plotArea",
+    "legend",
+    "plotVisOnly",
+    "dispBlanksAs",
+    "showDLblsOverMax",
+    "extLst"
+  ];
+  const following = parent.children.find(
+    (n) => n.name.namespace === parent.name.namespace && order2.indexOf(n.name.localName) > order2.indexOf(name)
+  );
+  return doc.spliceChildren(
+    parent,
+    old ? parent.children.indexOf(old) : following ? parent.children.indexOf(following) : parent.children.length,
+    old ? 1 : 0,
+    xml === void 0 ? [] : [xml]
+  );
+}
+function readChartType(doc, firstPlot = false) {
+  const info = inspectChart(doc);
+  if (!info.plots.length || !firstPlot && info.plots.length !== 1)
+    unsupported3("Combination chart data is preserve-only.");
+  const plot = info.plots[0], group = plot.properties.grouping, suffix = group === "percentStacked" ? "_STACKED_100" : group === "stacked" ? "_STACKED" : "";
+  if (plot.type === "barChart")
+    return `${plot.properties.barDir === "bar" ? "BAR" : "COLUMN"}${suffix || "_CLUSTERED"}`;
+  if (plot.type === "lineChart") {
+    const marker = plot.series[0]?.marker?.children.find((n) => n.name === "symbol")?.attributes.val;
+    return `LINE${marker && marker !== "none" ? "_MARKERS" : ""}${suffix}`;
+  }
+  if (plot.type === "pieChart" || plot.type === "doughnutChart") {
+    const plotNode = required(required(required(doc.root, "chart"), "plotArea"), plot.type);
+    const exploded = plotNode.children.some((series2) => {
+      const explosion = series2.name.localName === "ser" && child(series2, "explosion");
+      return explosion && Number(attr(explosion, "val") ?? 0) > 0;
+    });
+    return `${plot.type === "pieChart" ? "PIE" : "DOUGHNUT"}${exploded ? "_EXPLODED" : ""}`;
+  }
+  if (plot.type === "areaChart") return `AREA${suffix}`;
+  if (plot.type === "radarChart") {
+    if (plot.properties.radarStyle === "filled") return "RADAR_FILLED";
+    const marker = plot.series[0]?.marker?.children.find((node) => node.name === "symbol")?.attributes.val;
+    return marker === "none" ? "RADAR" : "RADAR_MARKERS";
+  }
+  if (plot.type === "bubbleChart") {
+    const chart = required(required(doc.root, "chart"), "plotArea");
+    const series2 = required(chart, "bubbleChart").children.find(
+      (node) => node.name.namespace === doc.root.name.namespace && node.name.localName === "ser"
+    );
+    const effect = series2 && child(series2, "bubble3D");
+    return effect && ["1", "true"].includes(attr(effect, "val") ?? "") ? "BUBBLE_THREE_D_EFFECT" : "BUBBLE";
+  }
+  if (plot.type === "scatterChart") {
+    const types = {
+      marker: "XY_SCATTER",
+      lineMarker: "XY_SCATTER_LINES",
+      line: "XY_SCATTER_LINES_NO_MARKERS",
+      smoothMarker: "XY_SCATTER_SMOOTH",
+      smooth: "XY_SCATTER_SMOOTH_NO_MARKERS"
+    };
+    const type = types[plot.properties.scatterStyle ?? ""];
+    if (!type) unsupported3("Unsupported scatter style cannot be reconstructed.");
+    return type;
+  }
+  return unsupported3("Chart data reconstruction is unsupported for this plot.");
+}
+function applyChartAppearance(doc, update) {
+  if (update.style !== void 0 && update.style !== null && (!Number.isInteger(update.style) || update.style < 1 || update.style > 48))
+    invalid("Chart style requires an integer from 1 to 48.");
+  if (update.legend !== void 0 && typeof update.legend !== "boolean")
+    invalid("Chart legend requires a boolean.");
+  const ns2 = doc.root.name.namespace;
+  if (update.style !== void 0)
+    doc = replaceChild(
+      doc,
+      doc.root,
+      "style",
+      update.style === null ? void 0 : `<c:style xmlns:c="${ns2}" val="${update.style}"/>`
+    );
+  if (update.legend !== void 0 && (!update.legend || !child(required(doc.root, "chart"), "legend"))) {
+    doc = replaceChild(
+      doc,
+      required(doc.root, "chart"),
+      "legend",
+      update.legend ? `<c:legend xmlns:c="${ns2}"><c:legendPos val="r"/><c:overlay val="0"/></c:legend>` : void 0
+    );
+  }
+  return doc;
+}
+function replaceChartData(doc, data, context, source, metadata) {
+  const ns2 = doc.root.name.namespace;
+  const type = readChartType(doc);
+  validateChartData(data, type);
+  const inspection = inspectChart(doc);
+  if (inspection.unsupported.length)
+    unsupported3("Unknown chart extensions prevent data replacement.");
+  if (data.date1904 !== void 0 && data.date1904 !== metadata.date1904)
+    unsupported3("Chart replacement must retain the existing date system.");
+  const epoch = child(doc.root, "date1904");
+  const epochValue = epoch ? attr(epoch, "val") ?? "1" : "0";
+  if (!["0", "1", "false", "true"].includes(epochValue) || ["1", "true"].includes(epochValue) !== metadata.date1904)
+    unsupported3("Chart and workbook date systems must agree.");
+  const ranges = [];
+  let referenceCount = 0;
+  for (const series3 of inspection.plots[0].series) {
+    const v = variant(type);
+    const channels = [
+      series3.nameSource,
+      v.scatter ? series3.xValues : series3.categories,
+      v.scatter ? series3.yValues : series3.values,
+      ...v.bubble ? [series3.bubbleSizes] : []
+    ];
+    for (const [position, source2] of channels.entries()) {
+      if (!source2 || source2.authority !== "referenced" || !source2.cached || !source2.formula)
+        unsupported3("Chart data must have simple owned cached references.");
+      const count = Number(source2.pointCount);
+      const range = chartWorkbookRange(source2.formula, metadata.sheetName);
+      const width = position === 1 && !v.scatter ? series3.categories?.levels.length || 1 : 1;
+      if (!Number.isSafeInteger(count) || count < 1 || position === 0 && count !== 1 || range.end.row - range.start.row + 1 !== count || range.end.column - range.start.column + 1 !== width)
+        unsupported3("Chart cache cardinality must match its simple worksheet range.");
+      ranges.push(range);
+      referenceCount++;
+      if (v.scatter && position !== 0 && range.start.row > 1)
+        ranges.push({
+          start: { ...range.start, row: range.start.row - 1 },
+          end: { ...range.start, row: range.start.row - 1 }
+        });
+    }
+  }
+  let formulas = 0;
+  const countFormulas = (node) => {
+    if (node.name.namespace === ns2 && node.name.localName === "f") formulas++;
+    node.children.forEach(countFormulas);
+  };
+  countFormulas(doc.root);
+  if (formulas !== referenceCount)
+    unsupported3("Dependent chart formulas prevent data replacement.");
+  validateWorkbookOwnership(metadata, ranges);
+  const plot = child(required(doc.root, "chart"), "plotArea").children.find(
+    (x) => x.name.namespace === ns2 && x.name.localName === inspection.plots[0].type
+  );
+  const series2 = plot.children.filter((x) => x.name.namespace === ns2 && x.name.localName === "ser");
+  const identities = ["idx", "order"].map(
+    (name) => series2.map((node) => Number(attr(required(node, name), "val")))
+  );
+  if (identities.some(
+    (values) => values.some((value) => !Number.isSafeInteger(value) || value < 0 || value > 4294967295) || new Set(values).size !== values.length
+  ))
+    unsupported3("Chart series identities must be unique unsigned integers.");
+  const ordered = series2.map((node, index) => ({ node, order: identities[1][index] })).sort((left, right) => left.order - right.order);
+  if (ordered.some((item, index) => item.node !== series2[index])) {
+    let position = 0;
+    doc = doc.reorderChildren(
+      plot,
+      plot.children.map(
+        (node) => node.name.namespace === ns2 && node.name.localName === "ser" ? ordered[position++].node : node
+      )
+    );
+  }
+  const nextIdentity = identities.map((values) => Math.max(-1, ...values) + 1);
+  for (let index = 0; index < data.series.length; index++) {
+    let generated = parseXmlPart(
+      new TextEncoder().encode(
+        `<c:ser xmlns:c="${ns2}">${seriesXml(type, data, index, metadata.sheetName, metadata.date1904).slice(7, -8)}</c:ser>`
+      ),
+      context.xmlLimits
+    );
+    if (index >= series2.length) {
+      for (const [position, name] of ["idx", "order"].entries()) {
+        const value = nextIdentity[position]++;
+        if (value > 4294967295) unsupported3("Chart series identity limit exceeded.");
+        generated = generated.merge(required(generated.root, name), {
+          attributes: [{ namespace: "", localName: "val", value: String(value) }]
+        });
+      }
+      const currentPlot = required(required(doc.root, "chart"), "plotArea").children.find(
+        (x) => x.name.namespace === ns2 && x.name.localName === plot.name.localName
+      );
+      const currentSeries = currentPlot.children.filter(
+        (x) => x.name.namespace === ns2 && x.name.localName === "ser"
+      );
+      const insertion = currentSeries.length ? currentPlot.children.indexOf(currentSeries[currentSeries.length - 1]) + 1 : currentPlot.children.length;
+      doc = doc.spliceChildren(currentPlot, insertion, 0, [generated.markup(generated.root, true)]);
+      continue;
+    }
+    for (const name of [
+      "tx",
+      variant(type).scatter ? "xVal" : "cat",
+      variant(type).scatter ? "yVal" : "val",
+      ...variant(type).bubble ? ["bubbleSize"] : []
+    ]) {
+      const fresh = child(generated.root, name);
+      const updatedPlot = required(required(doc.root, "chart"), "plotArea").children.find(
+        (x) => x.name.namespace === ns2 && x.name.localName === plot.name.localName
+      ), updated = updatedPlot.children.filter(
+        (x) => x.name.namespace === ns2 && x.name.localName === "ser"
+      )[index];
+      const old = child(updated, name);
+      if (!old) unsupported3("Missing chart data structure.");
+      doc = doc.spliceChildren(updated, updated.children.indexOf(old), 1, [
+        generated.markup(fresh, true)
+      ]);
+    }
+  }
+  for (let index = series2.length - 1; index >= data.series.length; index--) {
+    const currentPlot = required(required(doc.root, "chart"), "plotArea").children.find(
+      (x) => x.name.namespace === ns2 && x.name.localName === plot.name.localName
+    );
+    const current = currentPlot.children.filter(
+      (x) => x.name.namespace === ns2 && x.name.localName === "ser"
+    )[index];
+    doc = doc.spliceChildren(currentPlot, currentPlot.children.indexOf(current), 1, []);
+  }
+  const members = prepareChartWorkbookMembers(
+    normalizedData(data, metadata.date1904),
+    variant(type).scatter,
+    context,
+    { ...source ? { source } : {}, date1904: metadata.date1904 }
+  );
+  return { doc, members };
+}
+async function setCharts(input, selection, update, context) {
+  object(selection, ["scope", "slide", "shape", "select", "all", "allowEmpty"]);
+  validateSelection(selection, "set");
+  validateChartUpdate(update);
+  if (selection.scope !== void 0 && selection.scope !== "slides")
+    throw new SelectionError("invalid-selection");
+  selection = { ...selection };
+  update = structuredClone(update);
+  const s = await loadShared(input, context), records = await readCharts(
+    s.source,
+    {
+      ...selection.scope !== void 0 ? { scope: selection.scope } : {},
+      ...selection.slide !== void 0 ? { slide: selection.slide } : {},
+      ...selection.shape !== void 0 ? { shape: selection.shape } : {},
+      ...selection.select !== void 0 ? { select: selection.select } : {}
+    },
+    context
+  );
+  if (!records.length && !selection.allowEmpty) throw new SelectionError("missing-selection");
+  if (records.length > 1 && !selection.all) throw new SelectionError("ambiguous-selection");
+  for (const record of records) {
+    let doc = s.doc(record.chartPart);
+    const ns2 = doc.root.name.namespace;
+    if (![
+      "http://schemas.openxmlformats.org/drawingml/2006/chart",
+      "http://purl.oclc.org/ooxml/drawingml/chart"
+    ].includes(ns2))
+      unsupported3("Extended chart editing is unsupported.");
+    if (update.style !== void 0 && doc.root.children.some(
+      (n) => n.name.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006" && n.name.localName === "AlternateContent"
+    ))
+      unsupported3("Conditional chart style dependencies prevent an unambiguous style edit.");
+    if (update.data !== void 0) {
+      const links = record.links.filter((x) => x.role === "workbook");
+      if (links.length !== 1 || links[0].external || !links[0].targetPart || !links[0].authoritative)
+        unsupported3("Data replacement requires one owned embedded workbook.");
+      const workbookPart = links[0].targetPart;
+      if (s.index.inventory.relationships.filter((x) => x.targetPart === workbookPart).length !== 1)
+        unsupported3("Shared chart workbook ownership is ambiguous.");
+      const workbook = await readPackage(s.reader.get(workbookPart), context);
+      const replacement = replaceChartData(
+        doc,
+        update.data,
+        context,
+        workbook,
+        inspectWorkbook(workbook, context)
+      );
+      doc = replacement.doc;
+      s.changes.set(workbookPart, await writePackageArchive(replacement.members, context, { compression: "store" }));
+    }
+    if (update.title !== void 0) {
+      const title = child(required(doc.root, "chart"), "title");
+      const replacement = parseXmlPart(
+        new TextEncoder().encode(titleXml(update.title, s.a, ns2)),
+        context.xmlLimits
+      );
+      if (title) {
+        const text = child(title, "tx");
+        const rich = text && child(text, "rich");
+        if (rich) doc = applyFrameFormatting(doc, rich, { text: update.title });
+        else
+          doc = doc.spliceChildren(title, text ? title.children.indexOf(text) : 0, text ? 1 : 0, [
+            replacement.markup(required(replacement.root, "tx"), true)
+          ]);
+      } else {
+        doc = replaceChild(
+          doc,
+          required(doc.root, "chart"),
+          "title",
+          replacement.markup(replacement.root, true)
+        );
+      }
+      doc = replaceChild(
+        doc,
+        required(doc.root, "chart"),
+        "autoTitleDeleted",
+        `<c:autoTitleDeleted xmlns:c="${ns2}" val="0"/>`
+      );
+    }
+    doc = applyChartAppearance(doc, update);
+    if (update.objects !== void 0) doc = applyChartObjectUpdates(doc, update.objects);
+    s.save(record.chartPart, doc);
+    const geometry = Object.fromEntries(
+      Object.entries(update).filter(([k]) => ["left", "top", "width", "height"].includes(k))
+    );
+    if (Object.keys(geometry).length) {
+      const slideDoc = s.doc(record.part);
+      s.save(
+        record.part,
+        applyShapeUpdate(slideDoc, nodeFor(slideDoc.root, record.shapeId), geometry)
+      );
+    }
+  }
+  return (await s.finish(
+    records[0]?.chartPart ?? s.main,
+    s.index.inventory.slides.filter((slide) => records.some((r) => r.part === slide.part)).map((slide) => slide.position)
+  )).bytes;
+}
+
+export {
+  ChartFormat,
+  ChartSequence,
+  ChartTitle,
+  AxisTitle,
+  Legend,
+  TickLabels,
+  MajorGridlines,
+  BaseAxis,
+  CategoryAxis,
+  DateAxis,
+  ValueAxis,
+  DataLabels,
+  DataLabel,
+  Marker,
+  Point,
+  BaseSeries,
+  Series,
+  CategorySeries,
+  AreaSeries,
+  PieSeries,
+  BarSeries,
+  RadarSeries,
+  LineSeries,
+  XySeries,
+  BubbleSeries,
+  SeriesCollection,
+  Category,
+  CategoryLevel,
+  Categories,
+  BasePlot,
+  AreaPlot,
+  Area3DPlot,
+  LinePlot,
+  PiePlot,
+  DoughnutPlot,
+  RadarPlot,
+  XyPlot,
+  BarPlot,
+  BubblePlot,
+  Plots,
+  inspectWorkbook,
+  chartTypes,
+  validateChartData,
+  validateChartUpdate,
+  createChartXml,
+  addChart,
+  insertChartIntoState,
+  readChartType,
+  applyChartAppearance,
+  replaceChartData,
+  setCharts,
+  CategoryChartData,
+  XyChartData,
+  BubbleChartData,
+  toChartData,
+  chart_data_model_exports,
+  Chart
+};