@pptx-glimpse/document 0.1.0

package/dist/index.cjs

@@ -0,0 +1,4677 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  asEmu: () => asEmu,
+  asHundredthPt: () => asHundredthPt,
+  asOoxmlAngle: () => asOoxmlAngle,
+  asOoxmlPercent: () => asOoxmlPercent,
+  asPartPath: () => asPartPath,
+  asPt: () => asPt,
+  asRawSidecarId: () => asRawSidecarId,
+  asRelationshipId: () => asRelationshipId,
+  asSourceNodeId: () => asSourceNodeId,
+  createComputedView: () => createComputedView,
+  findParagraphBySourceHandle: () => findParagraphBySourceHandle,
+  findShapeNodeBySourceHandle: () => findShapeNodeBySourceHandle,
+  findTextRunBySourceHandle: () => findTextRunBySourceHandle,
+  readPptx: () => readPptx,
+  replaceParagraphPlainText: () => replaceParagraphPlainText,
+  replaceTextRunPlainText: () => replaceTextRunPlainText,
+  updateShapeTransform: () => updateShapeTransform,
+  writePptx: () => writePptx
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/unsafe-type-assertion.ts
+function unsafeOoxmlBoundaryAssertion(value) {
+  return value;
+}
+function unsafeBrandAssertion(value) {
+  return value;
+}
+
+// src/source/handles.ts
+function asPartPath(value) {
+  return unsafeBrandAssertion(value);
+}
+function asRelationshipId(value) {
+  return unsafeBrandAssertion(value);
+}
+function asSourceNodeId(value) {
+  return unsafeBrandAssertion(value);
+}
+function asRawSidecarId(value) {
+  return unsafeBrandAssertion(value);
+}
+
+// src/source/editing.ts
+function findTextRunBySourceHandle(source, handle) {
+  for (const slide of source.slides) {
+    for (const shape of slide.shapes) {
+      if (shape.kind !== "shape") continue;
+      const run = findTextRunInShape(shape, handle);
+      if (run !== void 0) return run;
+    }
+  }
+  return void 0;
+}
+function findParagraphBySourceHandle(source, handle) {
+  for (const slide of source.slides) {
+    for (const shape of slide.shapes) {
+      if (shape.kind !== "shape") continue;
+      const paragraph = findParagraphInShape(shape, handle);
+      if (paragraph !== void 0) return paragraph;
+    }
+  }
+  return void 0;
+}
+function replaceTextRunPlainText(source, handle, text) {
+  let replaced = false;
+  const slides = source.slides.map((slide) => ({
+    ...slide,
+    shapes: slide.shapes.map((shape) => {
+      if (shape.kind !== "shape" || shape.textBody === void 0) return shape;
+      let shapeChanged = false;
+      const paragraphs = shape.textBody.paragraphs.map((paragraph) => {
+        let paragraphChanged = false;
+        const runs = paragraph.runs.map((run) => {
+          if (!sourceHandlesEqual(run.handle, handle)) return run;
+          replaced = true;
+          paragraphChanged = true;
+          shapeChanged = true;
+          return { ...run, text };
+        });
+        return !paragraphChanged ? paragraph : { ...paragraph, runs };
+      });
+      if (!shapeChanged) return shape;
+      return {
+        ...shape,
+        textBody: {
+          ...shape.textBody,
+          paragraphs
+        }
+      };
+    })
+  }));
+  if (!replaced) {
+    throw new Error(
+      "replaceTextRunPlainText: text run handle was not found in PptxSourceModel source"
+    );
+  }
+  return {
+    ...source,
+    slides,
+    edits: [...source.edits ?? [], { kind: "replaceTextRunPlainText", handle, text }]
+  };
+}
+function replaceParagraphPlainText(source, handle, text) {
+  let replaced = false;
+  const slides = source.slides.map((slide) => ({
+    ...slide,
+    shapes: slide.shapes.map((shape) => {
+      if (shape.kind !== "shape" || shape.textBody === void 0) return shape;
+      let shapeChanged = false;
+      const paragraphs = shape.textBody.paragraphs.map((paragraph) => {
+        if (!sourceHandlesEqual(paragraph.handle, handle)) return paragraph;
+        const replacementHandle = createReplacementRunHandle(paragraph);
+        replaced = true;
+        shapeChanged = true;
+        return {
+          ...paragraph,
+          runs: [
+            {
+              kind: "textRun",
+              text,
+              ...paragraph.runs[0]?.properties !== void 0 ? { properties: paragraph.runs[0].properties } : {},
+              ...replacementHandle !== void 0 ? { handle: replacementHandle } : {}
+            }
+          ]
+        };
+      });
+      if (!shapeChanged) return shape;
+      return {
+        ...shape,
+        textBody: {
+          ...shape.textBody,
+          paragraphs
+        }
+      };
+    })
+  }));
+  if (!replaced) {
+    throw new Error(
+      "replaceParagraphPlainText: paragraph handle was not found in PptxSourceModel source"
+    );
+  }
+  return {
+    ...source,
+    slides,
+    edits: [...source.edits ?? [], { kind: "replaceParagraphPlainText", handle, text }]
+  };
+}
+function findShapeNodeBySourceHandle(source, handle) {
+  for (const slide of source.slides) {
+    const shape = findShapeNodeInTree(slide.shapes, handle);
+    if (shape !== void 0) return shape;
+  }
+  return void 0;
+}
+function updateShapeTransform(source, handle, transform) {
+  if (handle.nodeId === void 0) {
+    throw new Error("updateShapeTransform: shape transform edit requires a node id");
+  }
+  let updated = false;
+  const slides = source.slides.map((slide) => ({
+    ...slide,
+    shapes: slide.shapes.map((shape) => {
+      if (!sourceHandlesEqual(shape.handle, handle)) return shape;
+      if (hasAlternateContentSidecar(shape)) {
+        throw new Error("updateShapeTransform: shapes inside AlternateContent are not supported");
+      }
+      if (!hasEditableTransform(shape)) {
+        throw new Error("updateShapeTransform: shape handle does not reference a shape with xfrm");
+      }
+      updated = true;
+      return {
+        ...shape,
+        transform: {
+          ...shape.transform,
+          offsetX: transform.offsetX,
+          offsetY: transform.offsetY,
+          width: transform.width,
+          height: transform.height
+        }
+      };
+    })
+  }));
+  if (!updated) {
+    if (source.slides.some((slide) => hasNestedShapeNodeWithHandle(slide.shapes, handle))) {
+      throw new Error("updateShapeTransform: nested group shape editing is not supported");
+    }
+    throw new Error("updateShapeTransform: shape handle was not found in PptxSourceModel source");
+  }
+  return {
+    ...source,
+    slides,
+    edits: [
+      ...source.edits ?? [],
+      {
+        kind: "updateShapeTransform",
+        handle,
+        offsetX: transform.offsetX,
+        offsetY: transform.offsetY,
+        width: transform.width,
+        height: transform.height
+      }
+    ]
+  };
+}
+function findTextRunInShape(shape, handle) {
+  for (const paragraph of shape.textBody?.paragraphs ?? []) {
+    for (const run of paragraph.runs) {
+      if (sourceHandlesEqual(run.handle, handle)) return run;
+    }
+  }
+  return void 0;
+}
+function findParagraphInShape(shape, handle) {
+  return shape.textBody?.paragraphs.find(
+    (paragraph) => sourceHandlesEqual(paragraph.handle, handle)
+  );
+}
+function createReplacementRunHandle(paragraph) {
+  if (paragraph.runs[0]?.handle !== void 0) return paragraph.runs[0].handle;
+  if (paragraph.handle?.nodeId === void 0) return void 0;
+  return {
+    ...paragraph.handle,
+    nodeId: asSourceNodeId(`${paragraph.handle.nodeId}:r:0`),
+    orderingSlot: 0
+  };
+}
+function hasEditableTransform(shape) {
+  return shape.kind !== "raw" && shape.transform !== void 0;
+}
+function findShapeNodeInTree(shapes, handle) {
+  for (const shape of shapes) {
+    if (sourceHandlesEqual(shape.handle, handle)) return shape;
+    if (shape.kind === "group") {
+      const child = findShapeNodeInTree(shape.children, handle);
+      if (child !== void 0) return child;
+    }
+  }
+  return void 0;
+}
+function hasNestedShapeNodeWithHandle(shapes, handle) {
+  return shapes.some(
+    (shape) => shape.kind === "group" && (findShapeNodeInTree(shape.children, handle) !== void 0 || hasNestedShapeNodeWithHandle(shape.children, handle))
+  );
+}
+function hasAlternateContentSidecar(shape) {
+  if (shape.kind === "raw") return false;
+  return shape.rawSidecars?.some((sidecar) => sidecar.node.name === "mc:AlternateContent") ?? false;
+}
+function sourceHandlesEqual(left, right) {
+  if (left === void 0) return false;
+  return left.partPath === right.partPath && left.nodeId === right.nodeId && left.relationshipId === right.relationshipId && left.orderingSlot === right.orderingSlot;
+}
+
+// src/source/units.ts
+function asEmu(value) {
+  return unsafeBrandAssertion(value);
+}
+function asPt(value) {
+  return unsafeBrandAssertion(value);
+}
+function asHundredthPt(value) {
+  return unsafeBrandAssertion(value);
+}
+function asOoxmlPercent(value) {
+  return unsafeBrandAssertion(value);
+}
+function asOoxmlAngle(value) {
+  return unsafeBrandAssertion(value);
+}
+
+// src/reader/ooxml-values.ts
+function parseEnumValue(value, allowed) {
+  return value !== void 0 && allowed.has(unsafeOoxmlBoundaryAssertion(value)) ? unsafeOoxmlBoundaryAssertion(value) : void 0;
+}
+function parseEnumValueWithDefault(value, allowed, fallback) {
+  return parseEnumValue(value, allowed) ?? fallback;
+}
+
+// src/reader/xml.ts
+var import_fast_xml_parser = require("fast-xml-parser");
+var parser = new import_fast_xml_parser.XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  parseAttributeValue: false,
+  // Retain prefix. See the comment at the beginning of the file for the reason.
+  removeNSPrefix: false,
+  // Do not trim text run (`a:t`) to preserve significant white space at the beginning and end.
+  // The PPTX part has been minified, and the blank text from the indentation between the tags is
+  // This does not cause spurious text node contamination.
+  trimValues: false
+});
+var orderedParser = new import_fast_xml_parser.XMLParser({
+  preserveOrder: true,
+  removeNSPrefix: true,
+  ignoreAttributes: true,
+  trimValues: false
+});
+function parseXml(xml) {
+  return unsafeOoxmlBoundaryAssertion(parser.parse(xml));
+}
+function parseXmlOrdered(xml) {
+  return unsafeOoxmlBoundaryAssertion(orderedParser.parse(xml));
+}
+function navigateOrdered(ordered, path) {
+  let current = ordered;
+  for (const key of path) {
+    const entry = current.find((item) => key in item);
+    const value = entry?.[key];
+    if (!Array.isArray(value)) return void 0;
+    current = unsafeOoxmlBoundaryAssertion(value);
+  }
+  return [...current];
+}
+function localName(key) {
+  const colon = key.indexOf(":");
+  return colon === -1 ? key : key.slice(colon + 1);
+}
+function getChild(node, name) {
+  if (!node) return void 0;
+  for (const key of Object.keys(node)) {
+    if (key.startsWith("@_")) continue;
+    if (localName(key) === name) {
+      const value = node[key];
+      return Array.isArray(value) ? unsafeOoxmlBoundaryAssertion(value[0]) : unsafeOoxmlBoundaryAssertion(value);
+    }
+  }
+  return void 0;
+}
+function hasChild(node, name) {
+  if (!node) return false;
+  for (const key of Object.keys(node)) {
+    if (key.startsWith("@_")) continue;
+    if (localName(key) === name) return true;
+  }
+  return false;
+}
+function getChildArray(node, name) {
+  if (!node) return [];
+  for (const key of Object.keys(node)) {
+    if (key.startsWith("@_")) continue;
+    if (localName(key) === name) {
+      const value = node[key];
+      if (value === void 0 || value === null) return [];
+      return unsafeOoxmlBoundaryAssertion(Array.isArray(value) ? value : [value]);
+    }
+  }
+  return [];
+}
+function getAttr(node, name) {
+  if (!node) return void 0;
+  return scalarToString(node[`@_${name}`]);
+}
+function getNamespacedAttr(node, localAttr) {
+  if (!node) return void 0;
+  for (const key of Object.keys(node)) {
+    if (!key.startsWith("@_")) continue;
+    const attr = key.slice(2);
+    const colon = attr.indexOf(":");
+    if (colon !== -1 && attr.slice(colon + 1) === localAttr) {
+      const value = scalarToString(node[key]);
+      if (value !== void 0) return value;
+    }
+  }
+  return void 0;
+}
+function getChildText(node, name) {
+  if (!node) return void 0;
+  for (const key of Object.keys(node)) {
+    if (key.startsWith("@_")) continue;
+    if (localName(key) !== name) continue;
+    const value = node[key];
+    const item = Array.isArray(value) ? value[0] : value;
+    if (typeof item === "string") return item;
+    if (typeof item === "number" || typeof item === "boolean") return String(item);
+    if (item && typeof item === "object") {
+      return scalarToString(unsafeOoxmlBoundaryAssertion(item)["#text"]);
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function getAttrs(node) {
+  const result = {};
+  if (!node) return result;
+  for (const key of Object.keys(node)) {
+    if (!key.startsWith("@_")) continue;
+    const value = scalarToString(node[key]);
+    if (value !== void 0) result[key.slice(2)] = value;
+  }
+  return result;
+}
+function scalarToString(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return void 0;
+}
+
+// src/reader/raw-node.ts
+var ATTR_PREFIX = "@_";
+var TEXT_KEY = "#text";
+function createSidecarIdFactory(partPath) {
+  let counter = 0;
+  return () => asRawSidecarId(`${partPath}#raw-${counter++}`);
+}
+function xmlValueToRawNode(name, value) {
+  if (typeof value !== "object" || value === null) {
+    const text2 = scalarText(value);
+    return text2 !== void 0 && text2 !== "" ? { name, text: text2 } : { name };
+  }
+  const obj = unsafeOoxmlBoundaryAssertion(value);
+  const attributes = {};
+  const children = [];
+  let text;
+  for (const key of Object.keys(obj)) {
+    if (key === TEXT_KEY) {
+      text = scalarText(obj[key]);
+      continue;
+    }
+    if (key.startsWith(ATTR_PREFIX)) {
+      const attrValue = scalarText(obj[key]);
+      if (attrValue !== void 0) attributes[key.slice(ATTR_PREFIX.length)] = attrValue;
+      continue;
+    }
+    const childValue = obj[key];
+    const items = Array.isArray(childValue) ? childValue : [childValue];
+    for (const item of items) {
+      children.push(xmlValueToRawNode(key, item));
+    }
+  }
+  return {
+    name,
+    ...Object.keys(attributes).length > 0 ? { attributes } : {},
+    ...children.length > 0 ? { children } : {},
+    ...text !== void 0 && text !== "" ? { text } : {}
+  };
+}
+function makeSidecar(name, value, nextId, orderingSlot) {
+  return {
+    id: nextId(),
+    node: xmlValueToRawNode(name, value),
+    ...orderingSlot !== void 0 ? { orderingSlot } : {}
+  };
+}
+function collectUnknownSidecars(parent, knownLocalNames, nextId) {
+  if (!parent) return [];
+  const sidecars = [];
+  let slot = 0;
+  for (const key of Object.keys(parent)) {
+    if (key.startsWith(ATTR_PREFIX) || key === TEXT_KEY) continue;
+    const value = parent[key];
+    const items = Array.isArray(value) ? value : [value];
+    if (knownLocalNames.has(localName(key))) {
+      slot += items.length;
+      continue;
+    }
+    for (const item of items) {
+      sidecars.push(makeSidecar(key, item, nextId, slot));
+      slot++;
+    }
+  }
+  return sidecars;
+}
+function scalarText(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return void 0;
+}
+
+// src/reader/drawing.ts
+var RECTANGLE_ALIGNMENT_TOKENS = /* @__PURE__ */ new Set([
+  "tl",
+  "t",
+  "tr",
+  "l",
+  "ctr",
+  "r",
+  "bl",
+  "b",
+  "br"
+]);
+var COLOR_TRANSFORM_KINDS = /* @__PURE__ */ new Set([
+  "lumMod",
+  "lumOff",
+  "tint",
+  "shade",
+  "alpha"
+]);
+var RAW_FILL_LOCAL_NAMES = ["grpFill"];
+var PRESET_COLOR_HEX = {
+  black: "000000",
+  white: "FFFFFF",
+  red: "FF0000",
+  green: "008000",
+  blue: "0000FF",
+  yellow: "FFFF00",
+  cyan: "00FFFF",
+  magenta: "FF00FF"
+};
+function parseColorElement(parent) {
+  if (!parent) return void 0;
+  const srgb = getChild(parent, "srgbClr");
+  if (srgb) {
+    const hex = getAttr(srgb, "val");
+    if (hex !== void 0) {
+      return withTransforms({ kind: "srgb", hex: hex.toUpperCase() }, srgb);
+    }
+  }
+  const scheme = getChild(parent, "schemeClr");
+  if (scheme) {
+    const name = getAttr(scheme, "val");
+    if (name !== void 0) {
+      return withTransforms({ kind: "scheme", scheme: name }, scheme);
+    }
+  }
+  const sys = getChild(parent, "sysClr");
+  if (sys) {
+    const val = getAttr(sys, "val");
+    if (val !== void 0) {
+      const lastClr = getAttr(sys, "lastClr");
+      return withTransforms(
+        {
+          kind: "system",
+          value: val,
+          ...lastClr !== void 0 ? { lastColor: lastClr.toUpperCase() } : {}
+        },
+        sys
+      );
+    }
+  }
+  return void 0;
+}
+function parseEffectList(effectList) {
+  if (effectList === void 0) return void 0;
+  const outerShadow = parseOuterShadow(getChild(effectList, "outerShdw"));
+  const innerShadow = parseInnerShadow(getChild(effectList, "innerShdw"));
+  const glow = parseGlow(getChild(effectList, "glow"));
+  const softEdge = parseSoftEdge(getChild(effectList, "softEdge"));
+  const parsed = {
+    ...outerShadow !== void 0 ? { outerShadow } : {},
+    ...innerShadow !== void 0 ? { innerShadow } : {},
+    ...glow !== void 0 ? { glow } : {},
+    ...softEdge !== void 0 ? { softEdge } : {}
+  };
+  return Object.keys(parsed).length > 0 ? parsed : void 0;
+}
+function parseBlipEffects(blip) {
+  if (blip === void 0) return void 0;
+  const grayscale = getChild(blip, "grayscl") !== void 0;
+  const biLevel = parseBiLevel(getChild(blip, "biLevel"));
+  const blur = parseBlurEffect(getChild(blip, "blur"));
+  const lum = parseLumEffect(getChild(blip, "lum"));
+  const duotone = parseDuotoneEffect(getChild(blip, "duotone"));
+  const clrChange = parseColorChangeEffect(getChild(blip, "clrChange"));
+  const parsed = {
+    grayscale,
+    ...biLevel !== void 0 ? { biLevel } : {},
+    ...blur !== void 0 ? { blur } : {},
+    ...lum !== void 0 ? { lum } : {},
+    ...duotone !== void 0 ? { duotone } : {},
+    ...clrChange !== void 0 ? { clrChange } : {}
+  };
+  return grayscale || biLevel !== void 0 || blur !== void 0 || lum !== void 0 || duotone !== void 0 || clrChange !== void 0 ? parsed : void 0;
+}
+function parseOuterShadow(node) {
+  if (node === void 0) return void 0;
+  const color = parseColorElement(node);
+  if (color === void 0) return void 0;
+  return {
+    blurRadius: asEmu(numericAttr(node, "blurRad") ?? 0),
+    distance: asEmu(numericAttr(node, "dist") ?? 0),
+    direction: asOoxmlAngle(numericAttr(node, "dir") ?? 0),
+    color,
+    alignment: parseRectangleAlignment(getAttr(node, "algn"), "b"),
+    rotateWithShape: getAttr(node, "rotWithShape") !== "0"
+  };
+}
+function parseInnerShadow(node) {
+  if (node === void 0) return void 0;
+  const color = parseColorElement(node);
+  if (color === void 0) return void 0;
+  return {
+    blurRadius: asEmu(numericAttr(node, "blurRad") ?? 0),
+    distance: asEmu(numericAttr(node, "dist") ?? 0),
+    direction: asOoxmlAngle(numericAttr(node, "dir") ?? 0),
+    color
+  };
+}
+function parseGlow(node) {
+  if (node === void 0) return void 0;
+  const color = parseColorElement(node);
+  if (color === void 0) return void 0;
+  return {
+    radius: asEmu(numericAttr(node, "rad") ?? 0),
+    color
+  };
+}
+function parseSoftEdge(node) {
+  if (node === void 0) return void 0;
+  return {
+    radius: asEmu(numericAttr(node, "rad") ?? 0)
+  };
+}
+function parseBiLevel(node) {
+  if (node === void 0) return void 0;
+  return {
+    threshold: (numericAttr(node, "thresh") ?? 5e4) / 1e5
+  };
+}
+function parseBlurEffect(node) {
+  if (node === void 0) return void 0;
+  return {
+    radius: asEmu(numericAttr(node, "rad") ?? 0),
+    grow: getAttr(node, "grow") !== "0"
+  };
+}
+function parseLumEffect(node) {
+  if (node === void 0) return void 0;
+  return {
+    brightness: (numericAttr(node, "bright") ?? 0) / 1e5,
+    contrast: (numericAttr(node, "contrast") ?? 0) / 1e5
+  };
+}
+function parseDuotoneEffect(node) {
+  if (node === void 0) return void 0;
+  const colors = collectColorChildren(node);
+  if (colors.length < 2) return void 0;
+  return { color1: colors[0], color2: colors[1] };
+}
+function parseColorChangeEffect(node) {
+  if (node === void 0) return void 0;
+  const from = firstColorChild(getChild(node, "clrFrom"));
+  const to = firstColorChild(getChild(node, "clrTo"));
+  return from !== void 0 && to !== void 0 ? { from, to } : void 0;
+}
+function collectColorChildren(parent) {
+  const colors = [];
+  for (const [key, value] of Object.entries(parent)) {
+    if (key.startsWith("@_")) continue;
+    const nodes = Array.isArray(value) ? value : [value];
+    for (const node of nodes) {
+      if (!isXmlNode(node)) continue;
+      const color = parseColorChild(key, node);
+      if (color !== void 0) colors.push(color);
+    }
+  }
+  return colors;
+}
+function firstColorChild(parent) {
+  return parent !== void 0 ? collectColorChildren(parent)[0] : void 0;
+}
+function parseColorChild(key, node) {
+  const name = localName(key);
+  return name === "prstClr" ? parsePresetColor(node) : parseColorElement({ [name]: node });
+}
+function isXmlNode(value) {
+  return typeof value === "object" && value !== null;
+}
+function parsePresetColor(node) {
+  const value = getAttr(node, "val");
+  const hex = value !== void 0 ? PRESET_COLOR_HEX[value] : void 0;
+  return hex !== void 0 ? withTransforms({ kind: "srgb", hex }, node) : void 0;
+}
+function parseFill(parent, nextId) {
+  if (!parent) return void 0;
+  const solid = getChild(parent, "solidFill");
+  if (solid) {
+    const color = parseColorElement(solid);
+    if (color) return { kind: "solid", color };
+    return { kind: "raw", raw: makeSidecar("a:solidFill", solid, nextId) };
+  }
+  if (hasChild(parent, "noFill")) return { kind: "none" };
+  const grad = getChild(parent, "gradFill");
+  if (grad) {
+    const fill = parseGradientFill(grad);
+    return fill ?? { kind: "raw", raw: makeSidecar("a:gradFill", grad, nextId) };
+  }
+  const blip = getChild(parent, "blipFill");
+  if (blip) {
+    return parseBlipFill(blip) ?? { kind: "raw", raw: makeSidecar("a:blipFill", blip, nextId) };
+  }
+  const pattern = getChild(parent, "pattFill");
+  if (pattern) {
+    const fill = parsePatternFill(pattern);
+    return fill ?? { kind: "raw", raw: makeSidecar("a:pattFill", pattern, nextId) };
+  }
+  for (const name of RAW_FILL_LOCAL_NAMES) {
+    if (hasChild(parent, name)) {
+      return { kind: "raw", raw: makeSidecar(`a:${name}`, getChild(parent, name) ?? {}, nextId) };
+    }
+  }
+  return void 0;
+}
+function parseGradientFill(grad) {
+  const stops = [];
+  for (const gs of getChildArray(getChild(grad, "gsLst"), "gs")) {
+    const color = parseColorElement(gs);
+    if (color === void 0) continue;
+    stops.push({
+      position: (numericAttr(gs, "pos") ?? 0) / 1e5,
+      color
+    });
+  }
+  if (stops.length === 0) return void 0;
+  const path = getChild(grad, "path");
+  if (path !== void 0) {
+    const fillToRect = getChild(path, "fillToRect");
+    const l = numericAttr(fillToRect, "l") ?? 0;
+    const t = numericAttr(fillToRect, "t") ?? 0;
+    const r = numericAttr(fillToRect, "r") ?? 0;
+    const b = numericAttr(fillToRect, "b") ?? 0;
+    return {
+      kind: "gradient",
+      gradientType: "radial",
+      stops,
+      centerX: (l + (1e5 - r)) / 2 / 1e5,
+      centerY: (t + (1e5 - b)) / 2 / 1e5
+    };
+  }
+  return {
+    kind: "gradient",
+    gradientType: "linear",
+    stops,
+    angle: asOoxmlAngle(numericAttr(getChild(grad, "lin"), "ang") ?? 0)
+  };
+}
+function parseBlipFill(blipFill) {
+  const blip = getChild(blipFill, "blip");
+  const embed = getNamespacedAttr(blip, "embed");
+  if (embed === void 0) return void 0;
+  const tile = parseImageFillTile(getChild(blipFill, "tile"));
+  return {
+    kind: "image",
+    blipRelationshipId: asRelationshipId(embed),
+    ...tile !== void 0 ? { tile } : {}
+  };
+}
+function parseImageFillTile(tile) {
+  if (tile === void 0) return void 0;
+  const flip = getAttr(tile, "flip") ?? "none";
+  return {
+    tx: asEmu(numericAttr(tile, "tx") ?? 0),
+    ty: asEmu(numericAttr(tile, "ty") ?? 0),
+    sx: (numericAttr(tile, "sx") ?? 1e5) / 1e5,
+    sy: (numericAttr(tile, "sy") ?? 1e5) / 1e5,
+    flip: flip === "x" || flip === "y" || flip === "xy" ? flip : "none",
+    align: parseRectangleAlignment(getAttr(tile, "algn"), "tl")
+  };
+}
+function parseRectangleAlignment(value, fallback) {
+  return parseEnumValueWithDefault(value, RECTANGLE_ALIGNMENT_TOKENS, fallback);
+}
+function parsePatternFill(pattern) {
+  const foregroundColor = parseColorElement(getChild(pattern, "fgClr"));
+  const backgroundColor = parseColorElement(getChild(pattern, "bgClr"));
+  if (foregroundColor === void 0 || backgroundColor === void 0) return void 0;
+  return {
+    kind: "pattern",
+    preset: getAttr(pattern, "prst") ?? "ltDnDiag",
+    foregroundColor,
+    backgroundColor
+  };
+}
+function parseOutline(spPr, nextId) {
+  const ln = getChild(spPr, "ln");
+  return parseLine(ln, nextId);
+}
+function parseLine(ln, nextId) {
+  if (!ln) return void 0;
+  const width = numericAttr(ln, "w");
+  const fill = parseFill(ln, nextId);
+  const dashStyle = parseDashStyle(getChild(ln, "prstDash"));
+  const customDash = parseCustomDash(ln);
+  const lineCap = parseLineCap(getAttr(ln, "cap"));
+  const lineJoin = parseLineJoin(ln);
+  const headEnd = parseArrowEndpoint(getChild(ln, "headEnd"));
+  const tailEnd = parseArrowEndpoint(getChild(ln, "tailEnd"));
+  return {
+    ...width !== void 0 ? { width: asEmu(width) } : {},
+    ...fill !== void 0 ? { fill } : {},
+    ...dashStyle !== void 0 ? { dashStyle } : {},
+    ...customDash !== void 0 ? { customDash } : {},
+    ...lineCap !== void 0 ? { lineCap } : {},
+    ...lineJoin !== void 0 ? { lineJoin } : {},
+    ...headEnd !== void 0 ? { headEnd } : {},
+    ...tailEnd !== void 0 ? { tailEnd } : {}
+  };
+}
+function parseTransform(spPr) {
+  const xfrm = getChild(spPr, "xfrm");
+  if (!xfrm) return void 0;
+  const off = getChild(xfrm, "off");
+  const ext = getChild(xfrm, "ext");
+  const offsetX = numericAttr(off, "x");
+  const offsetY = numericAttr(off, "y");
+  const width = numericAttr(ext, "cx");
+  const height = numericAttr(ext, "cy");
+  if (offsetX === void 0 || offsetY === void 0 || width === void 0 || height === void 0) {
+    return void 0;
+  }
+  const rotation = numericAttr(xfrm, "rot");
+  const flipH = getAttr(xfrm, "flipH");
+  const flipV = getAttr(xfrm, "flipV");
+  return {
+    offsetX: asEmu(offsetX),
+    offsetY: asEmu(offsetY),
+    width: asEmu(width),
+    height: asEmu(height),
+    ...rotation !== void 0 ? { rotation: asOoxmlAngle(rotation) } : {},
+    ...isTrue(flipH) ? { flipHorizontal: true } : {},
+    ...isTrue(flipV) ? { flipVertical: true } : {}
+  };
+}
+function withTransforms(base, colorNode) {
+  const transforms = [];
+  for (const key of Object.keys(colorNode)) {
+    if (key.startsWith("@_")) continue;
+    const kind = localName(key);
+    const transformKind = parseEnumValue(kind, COLOR_TRANSFORM_KINDS);
+    if (transformKind === void 0) continue;
+    const value = colorNode[key];
+    const items = Array.isArray(value) ? value : [value];
+    for (const item of items) {
+      const raw = getAttr(unsafeOoxmlBoundaryAssertion(item), "val");
+      if (raw === void 0) continue;
+      const numeric = Number(raw);
+      if (!Number.isFinite(numeric)) continue;
+      transforms.push({
+        kind: transformKind,
+        value: asOoxmlPercent(numeric)
+      });
+    }
+  }
+  return transforms.length > 0 ? { ...base, transforms } : base;
+}
+function numericAttr(node, name) {
+  const raw = getAttr(node, name);
+  if (raw === void 0) return void 0;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : void 0;
+}
+function isTrue(value) {
+  return value === "1" || value === "true";
+}
+function parseDashStyle(prstDash) {
+  const value = getAttr(prstDash, "val");
+  return parseEnumValue(value, DASH_STYLES);
+}
+function parseCustomDash(ln) {
+  const custDash = getChild(ln, "custDash");
+  const segments = getChildArray(custDash, "ds");
+  if (segments.length === 0) return void 0;
+  return segments.flatMap((segment) => [
+    (numericAttr(segment, "d") ?? 1e5) / 1e5,
+    (numericAttr(segment, "sp") ?? 1e5) / 1e5
+  ]);
+}
+var LINE_CAP_MAP = {
+  flat: "butt",
+  sq: "square",
+  rnd: "round"
+};
+function parseLineCap(value) {
+  return value !== void 0 ? LINE_CAP_MAP[value] : void 0;
+}
+function parseLineJoin(ln) {
+  if (hasChild(ln, "round")) return "round";
+  if (hasChild(ln, "bevel")) return "bevel";
+  if (hasChild(ln, "miter")) return "miter";
+  return void 0;
+}
+function parseArrowEndpoint(node) {
+  if (!node) return void 0;
+  const type = parseEnumValue(getAttr(node, "type"), ARROW_TYPES);
+  if (type === void 0) return void 0;
+  const width = getAttr(node, "w") ?? "med";
+  const length = getAttr(node, "len") ?? "med";
+  return {
+    type,
+    width: parseEnumValueWithDefault(width, ARROW_SIZES, "med"),
+    length: parseEnumValueWithDefault(length, ARROW_SIZES, "med")
+  };
+}
+var DASH_STYLES = /* @__PURE__ */ new Set([
+  "solid",
+  "dash",
+  "dot",
+  "dashDot",
+  "lgDash",
+  "lgDashDot",
+  "sysDash",
+  "sysDot"
+]);
+var ARROW_TYPES = /* @__PURE__ */ new Set([
+  "triangle",
+  "stealth",
+  "diamond",
+  "oval",
+  "arrow"
+]);
+var ARROW_SIZES = /* @__PURE__ */ new Set(["sm", "med", "lg"]);
+
+// src/reader/custom-geometry.ts
+function parseCustomGeometry(custGeom, orderedCustGeom) {
+  const pathLst = getChild(custGeom, "pathLst");
+  const paths = getChildArray(pathLst, "path");
+  if (paths.length === 0) return void 0;
+  const avGuides = parseGuideList(getChild(custGeom, "avLst"));
+  const guides = parseGuideList(getChild(custGeom, "gdLst"));
+  const orderedPaths = orderedChildEntries(
+    orderedChildChildren(orderedCustGeom, "pathLst"),
+    "path"
+  );
+  const result = [];
+  for (const [index, path] of paths.entries()) {
+    const width = numericAttr2(path, "w") ?? 0;
+    const height = numericAttr2(path, "h") ?? 0;
+    if (width === 0 && height === 0) continue;
+    const variables = evaluateGuides(avGuides, guides, width, height);
+    const commands = buildPathCommands(path, variables, orderedNodeChildren(orderedPaths[index]));
+    if (commands !== void 0) result.push({ width, height, commands });
+  }
+  return result.length > 0 ? result : void 0;
+}
+function parseGuideList(parent) {
+  return getChildArray(parent, "gd").map((guide) => ({
+    name: getAttr(guide, "name") ?? "",
+    formula: getAttr(guide, "fmla") ?? ""
+  })).filter((guide) => guide.name !== "" && guide.formula !== "");
+}
+function buildPathCommands(path, variables, orderedCommands) {
+  const parts = [];
+  let currentX = 0;
+  let currentY = 0;
+  let startX = 0;
+  let startY = 0;
+  for (const { local, nodes } of pathCommandNodes(path, orderedCommands)) {
+    for (const node of nodes) {
+      if (local === "moveTo") {
+        const point = firstPoint(node, variables);
+        if (point !== void 0) {
+          parts.push(`M ${point.x} ${point.y}`);
+          currentX = point.x;
+          currentY = point.y;
+          startX = point.x;
+          startY = point.y;
+        }
+      } else if (local === "lnTo") {
+        const point = firstPoint(node, variables);
+        if (point !== void 0) {
+          parts.push(`L ${point.x} ${point.y}`);
+          currentX = point.x;
+          currentY = point.y;
+        }
+      } else if (local === "cubicBezTo") {
+        const points = allPoints(node, variables);
+        if (points.length >= 3) {
+          parts.push(`C ${points.map((point) => `${point.x} ${point.y}`).join(", ")}`);
+          currentX = points[points.length - 1].x;
+          currentY = points[points.length - 1].y;
+        }
+      } else if (local === "quadBezTo") {
+        const points = allPoints(node, variables);
+        if (points.length >= 2) {
+          parts.push(`Q ${points.map((point) => `${point.x} ${point.y}`).join(", ")}`);
+          currentX = points[points.length - 1].x;
+          currentY = points[points.length - 1].y;
+        }
+      } else if (local === "arcTo") {
+        const arc = convertArcTo(node, currentX, currentY, variables);
+        if (arc !== void 0) {
+          parts.push(arc.command);
+          currentX = arc.endX;
+          currentY = arc.endY;
+        }
+      } else if (local === "close") {
+        parts.push("Z");
+        currentX = startX;
+        currentY = startY;
+      }
+    }
+  }
+  return parts.length > 0 ? parts.join(" ") : void 0;
+}
+function pathCommandNodes(path, orderedCommands) {
+  if (orderedCommands === void 0) {
+    return Object.keys(path).filter((key) => !key.startsWith("@_")).map((key) => ({ local: localName(key), nodes: getChildArray(path, localName(key)) }));
+  }
+  const counters = {};
+  const result = [];
+  for (const command of orderedCommands) {
+    const key = orderedNodeKey(command);
+    if (key === void 0) continue;
+    const local = localName(key);
+    const index = counters[local] ?? 0;
+    counters[local] = index + 1;
+    const node = getChildArray(path, local)[index];
+    if (node !== void 0) result.push({ local, nodes: [node] });
+  }
+  return result;
+}
+function firstPoint(node, variables) {
+  return allPoints(node, variables)[0];
+}
+function allPoints(node, variables) {
+  return getChildArray(node, "pt").map((point) => ({
+    x: resolveValue(getAttr(point, "x") ?? "0", variables),
+    y: resolveValue(getAttr(point, "y") ?? "0", variables)
+  }));
+}
+function convertArcTo(arc, currentX, currentY, variables) {
+  const widthRadius = resolveValue(getAttr(arc, "wR") ?? "0", variables);
+  const heightRadius = resolveValue(getAttr(arc, "hR") ?? "0", variables);
+  const startAngle = resolveValue(getAttr(arc, "stAng") ?? "0", variables);
+  const sweepAngle = resolveValue(getAttr(arc, "swAng") ?? "0", variables);
+  if (widthRadius === 0 && heightRadius === 0 || sweepAngle === 0) return void 0;
+  const startRadians = startAngle / 6e4 * (Math.PI / 180);
+  const endRadians = (startAngle + sweepAngle) / 6e4 * (Math.PI / 180);
+  const centerX = currentX - widthRadius * Math.cos(startRadians);
+  const centerY = currentY - heightRadius * Math.sin(startRadians);
+  const endX = centerX + widthRadius * Math.cos(endRadians);
+  const endY = centerY + heightRadius * Math.sin(endRadians);
+  const largeArcFlag = Math.abs(sweepAngle / 6e4) > 180 ? 1 : 0;
+  const sweepFlag = sweepAngle > 0 ? 1 : 0;
+  return {
+    command: `A ${round(widthRadius)} ${round(heightRadius)} 0 ${largeArcFlag} ${sweepFlag} ${round(endX)} ${round(endY)}`,
+    endX,
+    endY
+  };
+}
+function evaluateGuides(avGuides, guides, width, height) {
+  const variables = createBuiltinVariables(width, height);
+  for (const guide of avGuides) variables[guide.name] = evaluateFormula(guide.formula, variables);
+  for (const guide of guides) variables[guide.name] = evaluateFormula(guide.formula, variables);
+  return variables;
+}
+function createBuiltinVariables(width, height) {
+  return {
+    w: width,
+    h: height,
+    l: 0,
+    t: 0,
+    r: width,
+    b: height,
+    wd2: width / 2,
+    hd2: height / 2,
+    wd4: width / 4,
+    hd4: height / 4,
+    ss: Math.min(width, height),
+    ls: Math.max(width, height),
+    cd2: 108e5,
+    cd4: 54e5,
+    cd8: 27e5,
+    "3cd4": 162e5
+  };
+}
+function evaluateFormula(formula, variables) {
+  const tokens = formula.trim().split(/\s+/);
+  const op = tokens[0];
+  const resolve = (token) => {
+    if (token === void 0) return 0;
+    const value = Number(token);
+    return Number.isNaN(value) ? variables[token] ?? 0 : value;
+  };
+  if (op === "val") return resolve(tokens[1]);
+  if (op === "+-") return resolve(tokens[1]) + resolve(tokens[2]) - resolve(tokens[3]);
+  if (op === "*/")
+    return Math.round(resolve(tokens[1]) * resolve(tokens[2]) / (resolve(tokens[3]) || 1));
+  if (op === "+/")
+    return Math.round((resolve(tokens[1]) + resolve(tokens[2])) / (resolve(tokens[3]) || 1));
+  if (op === "pin")
+    return Math.max(resolve(tokens[1]), Math.min(resolve(tokens[2]), resolve(tokens[3])));
+  if (op === "min") return Math.min(resolve(tokens[1]), resolve(tokens[2]));
+  if (op === "max") return Math.max(resolve(tokens[1]), resolve(tokens[2]));
+  if (op === "abs") return Math.abs(resolve(tokens[1]));
+  if (op === "sqrt") return Math.round(Math.sqrt(resolve(tokens[1])));
+  if (op === "sin") return Math.round(resolve(tokens[1]) * Math.sin(toRadians(resolve(tokens[2]))));
+  if (op === "cos") return Math.round(resolve(tokens[1]) * Math.cos(toRadians(resolve(tokens[2]))));
+  if (op === "tan") return Math.round(resolve(tokens[1]) * Math.tan(toRadians(resolve(tokens[2]))));
+  if (op === "at2")
+    return Math.round(Math.atan2(resolve(tokens[2]), resolve(tokens[1])) * (180 / Math.PI) * 6e4);
+  if (op === "mod") {
+    const a = resolve(tokens[1]);
+    const b = resolve(tokens[2]);
+    const c = resolve(tokens[3]);
+    return Math.round(Math.sqrt(a * a + b * b + c * c));
+  }
+  if (op === "cat2") {
+    return Math.round(
+      resolve(tokens[1]) * Math.cos(Math.atan2(resolve(tokens[3]), resolve(tokens[2])))
+    );
+  }
+  if (op === "sat2") {
+    return Math.round(
+      resolve(tokens[1]) * Math.sin(Math.atan2(resolve(tokens[3]), resolve(tokens[2])))
+    );
+  }
+  if (op === "?:") return resolve(tokens[1]) > 0 ? resolve(tokens[2]) : resolve(tokens[3]);
+  return 0;
+}
+function resolveValue(value, variables) {
+  const numeric = Number(value);
+  return Number.isNaN(numeric) ? variables[value] ?? 0 : numeric;
+}
+function numericAttr2(node, name) {
+  const raw = getAttr(node, name);
+  if (raw === void 0) return void 0;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : void 0;
+}
+function round(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function toRadians(ooxmlAngle) {
+  return ooxmlAngle / 6e4 * (Math.PI / 180);
+}
+function orderedChildChildren(parent, childLocalName) {
+  const child = orderedChildEntries(parent, childLocalName)[0];
+  return orderedNodeChildren(child);
+}
+function orderedChildEntries(parent, childLocalName) {
+  if (parent === void 0) return [];
+  return parent.filter((child) => {
+    const key = orderedNodeKey(child);
+    return key !== void 0 && localName(key) === childLocalName;
+  });
+}
+function orderedNodeChildren(node) {
+  const key = node !== void 0 ? orderedNodeKey(node) : void 0;
+  const value = key !== void 0 ? node?.[key] : void 0;
+  return Array.isArray(value) ? value : void 0;
+}
+function orderedNodeKey(node) {
+  return Object.keys(node).find((key) => key !== ":@");
+}
+
+// src/reader/text.ts
+var KNOWN_TXBODY_CHILDREN = /* @__PURE__ */ new Set(["bodyPr", "lstStyle", "p"]);
+var KNOWN_PARAGRAPH_CHILDREN = /* @__PURE__ */ new Set([
+  "pPr",
+  "r",
+  "fld",
+  "br",
+  "endParaRPr"
+]);
+var KNOWN_RUN_CHILDREN = /* @__PURE__ */ new Set(["rPr", "t"]);
+var KNOWN_RUN_PROPERTY_CHILDREN = /* @__PURE__ */ new Set([
+  "latin",
+  "ea",
+  "cs",
+  "solidFill"
+]);
+var ALIGN_MAP = {
+  l: "left",
+  ctr: "center",
+  r: "right",
+  just: "justify"
+};
+var ANCHOR_MAP = {
+  t: "top",
+  ctr: "middle",
+  b: "bottom"
+};
+var WRAP_VALUES = /* @__PURE__ */ new Set(["square", "none"]);
+var VERTICAL_VALUES = /* @__PURE__ */ new Set([
+  "horz",
+  "vert",
+  "vert270",
+  "eaVert",
+  "wordArtVert",
+  "mongolianVert"
+]);
+var VALID_AUTO_NUM_SCHEMES = /* @__PURE__ */ new Set([
+  "arabicPeriod",
+  "arabicParenR",
+  "romanUcPeriod",
+  "romanLcPeriod",
+  "alphaUcPeriod",
+  "alphaLcPeriod",
+  "alphaLcParenR",
+  "alphaUcParenR",
+  "arabicPlain"
+]);
+function parseTextBody(txBody, partPath, nextId, ownerNodeId, ownerOrderingSlot, orderedTxBody) {
+  if (!txBody) return void 0;
+  const properties = parseBodyProperties(getChild(txBody, "bodyPr"));
+  const listStyle = parseTextStyle(getChild(txBody, "lstStyle"));
+  const orderedParagraphs = orderedTxBody?.filter((child) => orderedLocalName(child) === "p").map((child) => {
+    const key = orderedKey(child);
+    const value = key !== void 0 ? child[key] : void 0;
+    return Array.isArray(value) ? value : void 0;
+  });
+  const paragraphs = [];
+  let logicalParagraphIndex = 0;
+  getChildArray(txBody, "p").forEach((p, paragraphIndex) => {
+    const orderedChildren = orderedParagraphs?.[paragraphIndex];
+    if (orderedChildren !== void 0 && hasMultipleBulletPPr(p, orderedChildren)) {
+      const split = splitInterleavedParagraph(
+        p,
+        orderedChildren,
+        partPath,
+        nextId,
+        ownerNodeId,
+        ownerOrderingSlot,
+        logicalParagraphIndex
+      );
+      paragraphs.push(...split);
+      logicalParagraphIndex += split.length;
+      return;
+    }
+    paragraphs.push(
+      parseParagraph(
+        p,
+        partPath,
+        nextId,
+        ownerNodeId,
+        ownerOrderingSlot,
+        logicalParagraphIndex,
+        orderedChildren
+      )
+    );
+    logicalParagraphIndex++;
+  });
+  const rawSidecars = collectUnknownSidecars(txBody, KNOWN_TXBODY_CHILDREN, nextId);
+  return {
+    paragraphs,
+    ...properties !== void 0 ? { properties } : {},
+    ...listStyle !== void 0 ? { listStyle } : {},
+    handle: { partPath },
+    ...rawSidecars.length > 0 ? { rawSidecars } : {}
+  };
+}
+function parseTextStyle(node) {
+  if (node === void 0) return void 0;
+  const defaultParagraph = parseParagraphProperties(getChild(node, "defPPr"));
+  const levels = Array.from(
+    { length: 9 },
+    (_, index) => parseParagraphProperties(getChild(node, `lvl${index + 1}pPr`))
+  );
+  if (defaultParagraph === void 0 && levels.every((level) => level === void 0)) {
+    return void 0;
+  }
+  return { ...defaultParagraph !== void 0 ? { defaultParagraph } : {}, levels };
+}
+function hasMultipleBulletPPr(p, orderedChildren) {
+  const pPrList = getChildArray(p, "pPr");
+  let bulletPPrCount = 0;
+  let pPrCounter = 0;
+  for (const child of orderedChildren) {
+    if (orderedLocalName(child) !== "pPr") continue;
+    const pPr = pPrList[pPrCounter];
+    if (pPr !== void 0 && (getChild(pPr, "buChar") !== void 0 || getChild(pPr, "buAutoNum") !== void 0)) {
+      bulletPPrCount++;
+      if (bulletPPrCount >= 2) return true;
+    }
+    pPrCounter++;
+  }
+  return false;
+}
+function splitInterleavedParagraph(p, orderedChildren, partPath, nextId, ownerNodeId, ownerOrderingSlot, paragraphIndex) {
+  const pPrList = getChildArray(p, "pPr");
+  const rList = getChildArray(p, "r");
+  const fldList = getChildArray(p, "fld");
+  const brList = getChildArray(p, "br");
+  const groups = [];
+  let currentGroup;
+  let pPrCounter = 0;
+  let runCounter = 0;
+  let fieldCounter = 0;
+  let breakCounter = 0;
+  for (const child of orderedChildren) {
+    const tag = orderedLocalName(child);
+    if (tag === "pPr") {
+      const pPr = pPrList[pPrCounter];
+      const hasBullet = pPr !== void 0 && (getChild(pPr, "buChar") !== void 0 || getChild(pPr, "buAutoNum") !== void 0);
+      if (hasBullet || currentGroup === void 0) {
+        if (currentGroup !== void 0) groups.push(currentGroup);
+        currentGroup = {
+          pPrIndex: pPrCounter,
+          rNodes: [],
+          fldNodes: [],
+          brNodes: [],
+          orderedChildren: [child]
+        };
+      } else {
+        currentGroup.orderedChildren.push(child);
+      }
+      pPrCounter++;
+    } else if (tag === "r") {
+      currentGroup ??= {
+        pPrIndex: -1,
+        rNodes: [],
+        fldNodes: [],
+        brNodes: [],
+        orderedChildren: []
+      };
+      currentGroup.orderedChildren.push(child);
+      if (rList[runCounter] !== void 0) currentGroup.rNodes.push(rList[runCounter]);
+      runCounter++;
+    } else if (tag === "fld") {
+      currentGroup ??= {
+        pPrIndex: -1,
+        rNodes: [],
+        fldNodes: [],
+        brNodes: [],
+        orderedChildren: []
+      };
+      currentGroup.orderedChildren.push(child);
+      if (fldList[fieldCounter] !== void 0) currentGroup.fldNodes.push(fldList[fieldCounter]);
+      fieldCounter++;
+    } else if (tag === "br") {
+      currentGroup ??= {
+        pPrIndex: -1,
+        rNodes: [],
+        fldNodes: [],
+        brNodes: [],
+        orderedChildren: []
+      };
+      currentGroup.orderedChildren.push(child);
+      if (brList[breakCounter] !== void 0) currentGroup.brNodes.push(brList[breakCounter]);
+      breakCounter++;
+    }
+  }
+  if (currentGroup !== void 0) groups.push(currentGroup);
+  return groups.map((group, groupIndex) => {
+    const synthetic = {};
+    if (group.pPrIndex >= 0) synthetic.pPr = pPrList[group.pPrIndex];
+    synthetic.r = group.rNodes;
+    synthetic.fld = group.fldNodes;
+    synthetic.br = group.brNodes;
+    if (groupIndex === groups.length - 1 && getChild(p, "endParaRPr") !== void 0) {
+      synthetic.endParaRPr = getChild(p, "endParaRPr");
+    }
+    const paragraph = parseParagraph(
+      synthetic,
+      partPath,
+      nextId,
+      ownerNodeId,
+      ownerOrderingSlot,
+      paragraphIndex + groupIndex,
+      group.orderedChildren
+    );
+    if (groupIndex < groups.length - 1 && paragraph.runs.length > 0) {
+      const lastRun = paragraph.runs[paragraph.runs.length - 1];
+      if (lastRun.text.endsWith("\n")) {
+        const trimmed = lastRun.text.slice(0, -1);
+        const precedingRuns = paragraph.runs.slice(0, -1);
+        return {
+          ...paragraph,
+          runs: trimmed === "" ? precedingRuns : [...precedingRuns, { ...lastRun, text: trimmed }]
+        };
+      }
+    }
+    return paragraph;
+  });
+}
+function parseBodyProperties(bodyPr) {
+  if (!bodyPr) return void 0;
+  const marginLeft = numericAttr(bodyPr, "lIns");
+  const marginRight = numericAttr(bodyPr, "rIns");
+  const marginTop = numericAttr(bodyPr, "tIns");
+  const marginBottom = numericAttr(bodyPr, "bIns");
+  const anchorToken = getAttr(bodyPr, "anchor");
+  const anchor = anchorToken !== void 0 ? ANCHOR_MAP[anchorToken] : void 0;
+  const wrap = parseWrap(getAttr(bodyPr, "wrap"));
+  const vert = parseVerticalType(getAttr(bodyPr, "vert"));
+  const numCol = numericAttr(bodyPr, "numCol");
+  const normAutofit = getChild(bodyPr, "normAutofit");
+  const hasSpAutofit = getChild(bodyPr, "spAutoFit") !== void 0;
+  const hasNoAutofit = getChild(bodyPr, "noAutofit") !== void 0;
+  const fontScale = numericAttr(normAutofit, "fontScale");
+  const lnSpcReduction = numericAttr(normAutofit, "lnSpcReduction");
+  const properties = {
+    ...marginLeft !== void 0 ? { marginLeft: emu(marginLeft) } : {},
+    ...marginRight !== void 0 ? { marginRight: emu(marginRight) } : {},
+    ...marginTop !== void 0 ? { marginTop: emu(marginTop) } : {},
+    ...marginBottom !== void 0 ? { marginBottom: emu(marginBottom) } : {},
+    ...anchor !== void 0 ? { anchor } : {},
+    ...wrap !== void 0 ? { wrap } : {},
+    ...normAutofit !== void 0 ? {
+      autoFit: "normAutofit",
+      fontScale: fontScale !== void 0 ? fontScale / 1e5 : 1,
+      lnSpcReduction: lnSpcReduction !== void 0 ? lnSpcReduction / 1e5 : 0
+    } : hasSpAutofit ? { autoFit: "spAutofit", fontScale: 1, lnSpcReduction: 0 } : hasNoAutofit ? { autoFit: "noAutofit", fontScale: 1, lnSpcReduction: 0 } : {},
+    ...numCol !== void 0 ? { numCol: Math.max(1, numCol) } : {},
+    ...vert !== void 0 ? { vert } : {}
+  };
+  return Object.keys(properties).length > 0 ? properties : void 0;
+}
+function parseWrap(value) {
+  return parseEnumValue(value, WRAP_VALUES);
+}
+function parseVerticalType(value) {
+  return parseEnumValue(value, VERTICAL_VALUES);
+}
+function parseParagraph(p, partPath, nextId, ownerNodeId, ownerOrderingSlot, paragraphIndex, orderedChildren) {
+  const properties = parseParagraphProperties(getChild(p, "pPr"));
+  const runs = parseRunsInOrder(
+    p,
+    partPath,
+    nextId,
+    ownerNodeId,
+    ownerOrderingSlot,
+    paragraphIndex,
+    orderedChildren
+  );
+  const rawSidecars = collectUnknownSidecars(p, KNOWN_PARAGRAPH_CHILDREN, nextId);
+  return {
+    runs,
+    ...properties !== void 0 ? { properties } : {},
+    handle: {
+      partPath,
+      nodeId: textNodeId("paragraph", ownerNodeId, ownerOrderingSlot, paragraphIndex),
+      orderingSlot: paragraphIndex
+    },
+    ...rawSidecars.length > 0 ? { rawSidecars } : {}
+  };
+}
+function parseRunsInOrder(p, partPath, nextId, ownerNodeId, ownerOrderingSlot, paragraphIndex, orderedChildren) {
+  const rList = getChildArray(p, "r");
+  const fldList = getChildArray(p, "fld");
+  const brList = getChildArray(p, "br");
+  if (orderedChildren === void 0) {
+    return [
+      ...rList.map(
+        (r, runIndex) => parseRun(r, partPath, nextId, ownerNodeId, ownerOrderingSlot, paragraphIndex, runIndex)
+      ),
+      ...fldList.map(
+        (fld, index) => parseRun(
+          fld,
+          partPath,
+          nextId,
+          ownerNodeId,
+          ownerOrderingSlot,
+          paragraphIndex,
+          rList.length + index
+        )
+      ),
+      ...brList.map(
+        (br, index) => parseBreakRun(
+          br,
+          partPath,
+          nextId,
+          ownerNodeId,
+          ownerOrderingSlot,
+          paragraphIndex,
+          rList.length + fldList.length + index
+        )
+      )
+    ];
+  }
+  const counters = {};
+  const runs = [];
+  for (const child of orderedChildren) {
+    const tag = orderedLocalName(child);
+    if (tag !== "r" && tag !== "fld" && tag !== "br") continue;
+    const index = counters[tag] ?? 0;
+    counters[tag] = index + 1;
+    const runIndex = runs.length;
+    if (tag === "r" && rList[index] !== void 0) {
+      runs.push(
+        parseRun(
+          rList[index],
+          partPath,
+          nextId,
+          ownerNodeId,
+          ownerOrderingSlot,
+          paragraphIndex,
+          runIndex
+        )
+      );
+    } else if (tag === "fld" && fldList[index] !== void 0) {
+      runs.push(
+        parseRun(
+          fldList[index],
+          partPath,
+          nextId,
+          ownerNodeId,
+          ownerOrderingSlot,
+          paragraphIndex,
+          runIndex
+        )
+      );
+    } else if (tag === "br" && brList[index] !== void 0) {
+      runs.push(
+        parseBreakRun(
+          brList[index],
+          partPath,
+          nextId,
+          ownerNodeId,
+          ownerOrderingSlot,
+          paragraphIndex,
+          runIndex
+        )
+      );
+    }
+  }
+  return runs;
+}
+function parseParagraphProperties(pPr) {
+  if (!pPr) return void 0;
+  const alignToken = getAttr(pPr, "algn");
+  const align = alignToken !== void 0 ? ALIGN_MAP[alignToken] : void 0;
+  const level = numericAttr(pPr, "lvl");
+  const lineSpacing = parseSpacing(getChild(pPr, "lnSpc"));
+  const spaceBefore = parseSpacing(getChild(pPr, "spcBef"));
+  const spaceAfter = parseSpacing(getChild(pPr, "spcAft"));
+  const marginLeft = numericAttr(pPr, "marL");
+  const indent = numericAttr(pPr, "indent");
+  const bullet = parseBullet(pPr);
+  const bulletFont = getAttr(getChild(pPr, "buFont"), "typeface");
+  const bulletColor = parseColorElement(getChild(pPr, "buClr"));
+  const bulletSizePct = numericAttr(getChild(pPr, "buSzPct"), "val");
+  const tabStops = parseTabStops(pPr);
+  const defaultRunProperties = parseRunProperties(getChild(pPr, "defRPr"));
+  const properties = {
+    ...align !== void 0 ? { align } : {},
+    ...level !== void 0 ? { level } : {},
+    ...lineSpacing !== void 0 ? { lineSpacing } : {},
+    ...spaceBefore !== void 0 ? { spaceBefore } : {},
+    ...spaceAfter !== void 0 ? { spaceAfter } : {},
+    ...marginLeft !== void 0 ? { marginLeft: emu(marginLeft) } : {},
+    ...indent !== void 0 ? { indent: emu(indent) } : {},
+    ...bullet !== void 0 ? { bullet } : {},
+    ...bulletFont !== void 0 ? { bulletFont } : {},
+    ...bulletColor !== void 0 ? { bulletColor } : {},
+    ...bulletSizePct !== void 0 ? { bulletSizePct } : {},
+    ...tabStops.length > 0 ? { tabStops } : {},
+    ...defaultRunProperties !== void 0 ? { defaultRunProperties } : {}
+  };
+  return Object.keys(properties).length > 0 ? properties : void 0;
+}
+function parseTabStops(pPr) {
+  return getChildArray(getChild(pPr, "tabLst"), "tab").map((tab) => ({
+    position: emu(numericAttr(tab, "pos") ?? 0),
+    alignment: unsafeOoxmlBoundaryAssertion(getAttr(tab, "algn")) ?? "l"
+  }));
+}
+function parseSpacing(node) {
+  const points = numericAttr(getChild(node, "spcPts"), "val");
+  if (points !== void 0) return { type: "pts", value: asHundredthPt(points) };
+  const percent = numericAttr(getChild(node, "spcPct"), "val");
+  if (percent !== void 0) return { type: "pct", value: percent };
+  return void 0;
+}
+function parseBullet(pPr) {
+  if (pPr === void 0) return void 0;
+  if (getChild(pPr, "buNone") !== void 0) return { type: "none" };
+  const buChar = getChild(pPr, "buChar");
+  if (buChar !== void 0) {
+    return { type: "char", char: decodeXmlCharRef(getAttr(buChar, "char") ?? "\u2022") };
+  }
+  const buAutoNum = getChild(pPr, "buAutoNum");
+  if (buAutoNum !== void 0) {
+    const scheme = getAttr(buAutoNum, "type") ?? "arabicPeriod";
+    return {
+      type: "autoNum",
+      scheme: parseEnumValueWithDefault(scheme, VALID_AUTO_NUM_SCHEMES, "arabicPeriod"),
+      startAt: numericAttr(buAutoNum, "startAt") ?? 1
+    };
+  }
+  return void 0;
+}
+function decodeXmlCharRef(value) {
+  return value.replace(
+    /&#x([0-9a-fA-F]+);|&#([0-9]+);/g,
+    (_match, hex, decimal) => String.fromCodePoint(parseInt(hex ?? decimal ?? "0", hex !== void 0 ? 16 : 10))
+  );
+}
+function parseRun(r, partPath, nextId, ownerNodeId, ownerOrderingSlot, paragraphIndex, runIndex) {
+  const properties = parseRunProperties(getChild(r, "rPr"));
+  const rawSidecars = collectRunSidecars(r, nextId);
+  return {
+    kind: "textRun",
+    text: decodeXmlCharRef(getChildText(r, "t") ?? ""),
+    ...properties !== void 0 ? { properties } : {},
+    handle: {
+      partPath,
+      nodeId: textNodeId("run", ownerNodeId, ownerOrderingSlot, paragraphIndex, runIndex),
+      orderingSlot: runIndex
+    },
+    ...rawSidecars.length > 0 ? { rawSidecars } : {}
+  };
+}
+function parseBreakRun(br, partPath, nextId, ownerNodeId, ownerOrderingSlot, paragraphIndex, runIndex) {
+  const properties = parseRunProperties(getChild(br, "rPr"));
+  return {
+    kind: "textRun",
+    text: "\n",
+    ...properties !== void 0 ? { properties } : {},
+    handle: {
+      partPath,
+      nodeId: textNodeId("run", ownerNodeId, ownerOrderingSlot, paragraphIndex, runIndex),
+      orderingSlot: runIndex
+    }
+  };
+}
+function parseRunProperties(rPr) {
+  if (!rPr) return void 0;
+  const bold = getAttr(rPr, "b");
+  const italic = getAttr(rPr, "i");
+  const underline = getAttr(rPr, "u");
+  const strike = getAttr(rPr, "strike");
+  const baseline = numericAttr(rPr, "baseline");
+  const size = numericAttr(rPr, "sz");
+  const typeface = getAttr(getChild(rPr, "latin"), "typeface");
+  const typefaceEa = getAttr(getChild(rPr, "ea"), "typeface");
+  const typefaceCs = getAttr(getChild(rPr, "cs"), "typeface");
+  const hasHyperlink = getChild(rPr, "hlinkClick") !== void 0;
+  const color = parseColorElement(getChild(rPr, "solidFill"));
+  const properties = {
+    ...bold !== void 0 ? { bold: isTrue(bold) } : {},
+    ...italic !== void 0 ? { italic: isTrue(italic) } : {},
+    ...underline !== void 0 ? { underline: underline !== "none" } : hasHyperlink ? { underline: true } : {},
+    ...strike !== void 0 ? { strikethrough: strike !== "noStrike" } : {},
+    ...baseline !== void 0 ? { baseline: baseline / 1e3 } : {},
+    // `a:rPr@sz` is in 1/100 pt unit. Convert to pt and save.
+    ...size !== void 0 ? { fontSize: asPt(size / 100) } : {},
+    ...typeface !== void 0 ? { typeface } : {},
+    ...typefaceEa !== void 0 ? { typefaceEa } : {},
+    ...typefaceCs !== void 0 ? { typefaceCs } : {},
+    ...color !== void 0 ? { color } : hasHyperlink ? { color: { kind: "scheme", scheme: "hlink" } } : {}
+  };
+  return Object.keys(properties).length > 0 ? properties : void 0;
+}
+function collectRunSidecars(r, nextId) {
+  const runLevel = collectUnknownSidecars(r, KNOWN_RUN_CHILDREN, nextId);
+  const propLevel = collectUnknownSidecars(getChild(r, "rPr"), KNOWN_RUN_PROPERTY_CHILDREN, nextId);
+  return [...runLevel, ...propLevel];
+}
+function emu(value) {
+  return asEmu(value);
+}
+function textNodeId(kind, ownerNodeId, ownerOrderingSlot, paragraphIndex, runIndex) {
+  const owner = ownerNodeId !== void 0 ? `shape:${ownerNodeId}` : `shapeSlot:${ownerOrderingSlot}`;
+  const suffix = kind === "paragraph" ? `p:${paragraphIndex}` : `p:${paragraphIndex}:r:${runIndex}`;
+  return asSourceNodeId(`text:${owner}:${suffix}`);
+}
+function orderedKey(node) {
+  return Object.keys(node).find((key) => key !== ":@");
+}
+function orderedLocalName(node) {
+  const key = orderedKey(node);
+  return key !== void 0 ? localName(key) : void 0;
+}
+
+// src/reader/shape-tree.ts
+var KNOWN_SHAPE_CHILDREN = /* @__PURE__ */ new Set(["nvSpPr", "spPr", "style", "txBody"]);
+var KNOWN_CONNECTOR_CHILDREN = /* @__PURE__ */ new Set(["nvCxnSpPr", "spPr", "style"]);
+var KNOWN_GROUP_CHILDREN = /* @__PURE__ */ new Set(["nvGrpSpPr", "grpSpPr"]);
+var KNOWN_PICTURE_CHILDREN = /* @__PURE__ */ new Set(["nvPicPr", "blipFill", "spPr"]);
+var KNOWN_BLIP_FILL_CHILDREN = /* @__PURE__ */ new Set([
+  "blip",
+  "srcRect",
+  "stretch",
+  "tile"
+]);
+var KNOWN_BLIP_CHILDREN = /* @__PURE__ */ new Set([
+  "grayscl",
+  "biLevel",
+  "blur",
+  "lum",
+  "duotone",
+  "clrChange"
+]);
+var KNOWN_EFFECT_CHILDREN = /* @__PURE__ */ new Set([
+  "outerShdw",
+  "innerShdw",
+  "glow",
+  "softEdge"
+]);
+var KNOWN_GRAPHIC_FRAME_CHILDREN = /* @__PURE__ */ new Set([
+  "nvGraphicFramePr",
+  "xfrm",
+  "graphic"
+]);
+var KNOWN_GRAPHIC_CHILDREN = /* @__PURE__ */ new Set(["graphicData"]);
+var KNOWN_GRAPHIC_DATA_CHILDREN = /* @__PURE__ */ new Set(["tbl"]);
+var KNOWN_TABLE_CHILDREN = /* @__PURE__ */ new Set(["tblPr", "tblGrid", "tr"]);
+var KNOWN_TABLE_CELL_CHILDREN = /* @__PURE__ */ new Set(["txBody", "tcPr"]);
+var KNOWN_TABLE_CELL_PROPERTIES_CHILDREN = /* @__PURE__ */ new Set([
+  "lnL",
+  "lnR",
+  "lnT",
+  "lnB",
+  "solidFill",
+  "noFill",
+  "gradFill",
+  "blipFill",
+  "pattFill",
+  "grpFill"
+]);
+var KNOWN_SP_PR_CHILDREN = /* @__PURE__ */ new Set([
+  "xfrm",
+  "prstGeom",
+  "solidFill",
+  "noFill",
+  "gradFill",
+  "blipFill",
+  "pattFill",
+  "grpFill",
+  "ln",
+  "effectLst"
+]);
+var SHAPE_TREE_NODE_TAGS = /* @__PURE__ */ new Set([
+  "sp",
+  "pic",
+  "cxnSp",
+  "grpSp",
+  "graphicFrame"
+]);
+var CHART_GRAPHIC_DATA_URIS = /* @__PURE__ */ new Set([
+  "http://schemas.openxmlformats.org/drawingml/2006/chart",
+  "http://purl.oclc.org/ooxml/drawingml/chart"
+]);
+var SMARTART_DIAGRAM_URIS = /* @__PURE__ */ new Set([
+  "http://schemas.openxmlformats.org/drawingml/2006/diagram",
+  "http://purl.oclc.org/ooxml/drawingml/diagram"
+]);
+function parseShapeTree(spTree, partPath, nextId, orderedChildren) {
+  if (!spTree) return [];
+  if (orderedChildren !== void 0) {
+    return parseShapeTreeOrdered(spTree, partPath, nextId, orderedChildren);
+  }
+  const nodes = [];
+  let orderingSlot = 0;
+  for (const key of Object.keys(spTree)) {
+    if (key.startsWith("@_")) continue;
+    if (key === "#text") continue;
+    const local = localName(key);
+    if (local === "nvGrpSpPr" || local === "grpSpPr") continue;
+    const value = spTree[key];
+    const items = Array.isArray(value) ? value : [value];
+    for (const item of items) {
+      const node = unsafeOoxmlBoundaryAssertion(item);
+      if (local === "sp") {
+        nodes.push(parseShape(node, partPath, nextId, orderingSlot));
+      } else if (local === "pic") {
+        nodes.push(parseImage(node, partPath, nextId, orderingSlot));
+      } else if (local === "cxnSp") {
+        nodes.push(parseConnector(node, partPath, nextId, orderingSlot));
+      } else if (local === "grpSp") {
+        nodes.push(parseGroup(node, partPath, nextId, orderingSlot));
+      } else if (local === "graphicFrame") {
+        nodes.push(parseGraphicFrame(node, partPath, nextId, orderingSlot));
+      } else if (local === "AlternateContent") {
+        const parsed = parseAlternateContent(node, partPath, nextId, orderingSlot);
+        nodes.push(...parsed);
+      } else {
+        nodes.push(parseRawShapeNode(key, node, partPath, nextId, orderingSlot));
+      }
+      orderingSlot++;
+    }
+  }
+  return nodes;
+}
+function parseShapeTreeOrdered(spTree, partPath, nextId, orderedChildren) {
+  const nodes = [];
+  const tagCounters = {};
+  let orderingSlot = 0;
+  for (const child of orderedChildren) {
+    const key = Object.keys(child).find((candidate) => candidate !== ":@");
+    if (key === void 0) continue;
+    const local = localName(key);
+    if (local === "AlternateContent") {
+      const index2 = tagCounters[local] ?? 0;
+      tagCounters[local] = index2 + 1;
+      const alternateContents = getChildArray(spTree, "AlternateContent");
+      const alternateContent = alternateContents[index2];
+      if (alternateContent !== void 0) {
+        nodes.push(...parseAlternateContent(alternateContent, partPath, nextId, orderingSlot));
+        orderingSlot++;
+      }
+      continue;
+    }
+    if (!SHAPE_TREE_NODE_TAGS.has(local)) continue;
+    const index = tagCounters[local] ?? 0;
+    tagCounters[local] = index + 1;
+    const node = getChildArray(spTree, local)[index];
+    if (node === void 0) continue;
+    nodes.push(parseShapeTreeNode(local, node, child, partPath, nextId, orderingSlot));
+    orderingSlot++;
+  }
+  return nodes;
+}
+function parseShapeTreeNode(local, node, orderedNode, partPath, nextId, orderingSlot) {
+  if (local === "sp") return parseShape(node, partPath, nextId, orderingSlot, orderedNode);
+  if (local === "pic") return parseImage(node, partPath, nextId, orderingSlot);
+  if (local === "cxnSp") {
+    return parseConnector(node, partPath, nextId, orderingSlot, orderedNode);
+  }
+  if (local === "grpSp") {
+    const orderedGroupChildren = unsafeOoxmlBoundaryAssertion(orderedNode?.[local]);
+    return parseGroup(node, partPath, nextId, orderingSlot, orderedGroupChildren);
+  }
+  if (local === "graphicFrame") {
+    return parseGraphicFrame(node, partPath, nextId, orderingSlot, orderedNode);
+  }
+  return parseRawShapeNode(`p:${local}`, node, partPath, nextId, orderingSlot);
+}
+function parseShape(sp, partPath, nextId, orderingSlot, orderedNode) {
+  const nvSpPr = getChild(sp, "nvSpPr");
+  const cNvPr = getChild(nvSpPr, "cNvPr");
+  const nodeId = sourceNodeId(cNvPr);
+  const name = getAttr(cNvPr, "name");
+  const placeholder = parsePlaceholder(getChild(getChild(nvSpPr, "nvPr"), "ph"));
+  const spPr = getChild(sp, "spPr");
+  const transform = parseTransform(spPr);
+  const geometry = parseGeometry(spPr, orderedNestedChildChildren(orderedNode, "sp", "spPr"));
+  const fill = parseFill(spPr, nextId);
+  const outline = parseOutline(spPr, nextId);
+  const effects = parseEffectList(getChild(spPr, "effectLst"));
+  const style = parseShapeStyle(getChild(sp, "style"));
+  const textBody = parseTextBody(
+    getChild(sp, "txBody"),
+    partPath,
+    nextId,
+    nodeId,
+    orderingSlot,
+    orderedNestedChildChildren(orderedNode, "sp", "txBody")
+  );
+  const rawSidecars = [
+    ...collectUnknownSidecars(sp, KNOWN_SHAPE_CHILDREN, nextId),
+    ...collectUnknownSidecars(spPr, KNOWN_SP_PR_CHILDREN, nextId),
+    ...collectEffectSidecars(spPr, effects, nextId)
+  ];
+  return {
+    kind: "shape",
+    ...nodeId !== void 0 ? { nodeId } : {},
+    ...name !== void 0 ? { name } : {},
+    ...transform !== void 0 ? { transform } : {},
+    ...geometry !== void 0 ? { geometry } : {},
+    ...fill !== void 0 ? { fill } : {},
+    ...outline !== void 0 ? { outline } : {},
+    ...effects !== void 0 ? { effects } : {},
+    ...style !== void 0 ? { style } : {},
+    ...textBody !== void 0 ? { textBody } : {},
+    ...placeholder !== void 0 ? { placeholder } : {},
+    handle: { partPath, ...nodeId !== void 0 ? { nodeId } : {}, orderingSlot },
+    ...rawSidecars.length > 0 ? { rawSidecars } : {}
+  };
+}
+function parseConnector(cxnSp, partPath, nextId, orderingSlot, orderedNode) {
+  const nvCxnSpPr = getChild(cxnSp, "nvCxnSpPr");
+  const cNvPr = getChild(nvCxnSpPr, "cNvPr");
+  const nodeId = sourceNodeId(cNvPr);
+  const name = getAttr(cNvPr, "name");
+  const spPr = getChild(cxnSp, "spPr");
+  const transform = parseTransform(spPr);
+  const geometry = parseGeometry(spPr, orderedNestedChildChildren(orderedNode, "cxnSp", "spPr"));
+  const outline = parseOutline(spPr, nextId);
+  const effects = parseEffectList(getChild(spPr, "effectLst"));
+  const style = parseShapeStyle(getChild(cxnSp, "style"));
+  const rawSidecars = [
+    ...collectUnknownSidecars(cxnSp, KNOWN_CONNECTOR_CHILDREN, nextId),
+    ...collectUnknownSidecars(spPr, KNOWN_SP_PR_CHILDREN, nextId),
+    ...collectEffectSidecars(spPr, effects, nextId)
+  ];
+  return {
+    kind: "connector",
+    ...nodeId !== void 0 ? { nodeId } : {},
+    ...name !== void 0 ? { name } : {},
+    ...transform !== void 0 ? { transform } : {},
+    ...geometry !== void 0 ? { geometry } : {},
+    ...outline !== void 0 ? { outline } : {},
+    ...effects !== void 0 ? { effects } : {},
+    ...style !== void 0 ? { style } : {},
+    handle: { partPath, ...nodeId !== void 0 ? { nodeId } : {}, orderingSlot },
+    ...rawSidecars.length > 0 ? { rawSidecars } : {}
+  };
+}
+function parseShapeStyle(style) {
+  if (style === void 0) return void 0;
+  const fillRef = parseStyleReference(getChild(style, "fillRef"));
+  const lineRef = parseStyleReference(getChild(style, "lnRef"));
+  const effectRef = parseStyleReference(getChild(style, "effectRef"));
+  const parsed = {
+    ...fillRef !== void 0 ? { fillRef } : {},
+    ...lineRef !== void 0 ? { lineRef } : {},
+    ...effectRef !== void 0 ? { effectRef } : {}
+  };
+  return Object.keys(parsed).length > 0 ? parsed : void 0;
+}
+function parseStyleReference(ref) {
+  if (ref === void 0) return void 0;
+  const index = numericAttr(ref, "idx") ?? 0;
+  const color = parseColorElement(ref);
+  return {
+    index,
+    ...color !== void 0 ? { color } : {}
+  };
+}
+function parseGroup(grpSp, partPath, nextId, orderingSlot, orderedChildren) {
+  const nvGrpSpPr = getChild(grpSp, "nvGrpSpPr");
+  const cNvPr = getChild(nvGrpSpPr, "cNvPr");
+  const nodeId = sourceNodeId(cNvPr);
+  const name = getAttr(cNvPr, "name");
+  const grpSpPr = getChild(grpSp, "grpSpPr");
+  const transform = parseTransform(grpSpPr);
+  const childTransform = parseChildTransform(grpSpPr, transform);
+  const fill = parseFill(grpSpPr, nextId);
+  const effects = parseEffectList(getChild(grpSpPr, "effectLst"));
+  const rawSidecars = [
+    ...collectUnknownSidecars(grpSp, KNOWN_GROUP_CHILDREN, nextId),
+    ...collectUnknownSidecars(grpSpPr, KNOWN_SP_PR_CHILDREN, nextId),
+    ...collectEffectSidecars(grpSpPr, effects, nextId)
+  ];
+  return {
+    kind: "group",
+    ...nodeId !== void 0 ? { nodeId } : {},
+    ...name !== void 0 ? { name } : {},
+    ...transform !== void 0 ? { transform } : {},
+    ...childTransform !== void 0 ? { childTransform } : {},
+    ...fill !== void 0 ? { fill } : {},
+    ...effects !== void 0 ? { effects } : {},
+    children: parseShapeTree(grpSp, partPath, nextId, orderedChildren),
+    handle: { partPath, ...nodeId !== void 0 ? { nodeId } : {}, orderingSlot },
+    ...rawSidecars.length > 0 ? { rawSidecars } : {}
+  };
+}
+function parseImage(pic, partPath, nextId, orderingSlot) {
+  const cNvPr = getChild(getChild(pic, "nvPicPr"), "cNvPr");
+  const nodeId = sourceNodeId(cNvPr);
+  const name = getAttr(cNvPr, "name");
+  const blipFill = getChild(pic, "blipFill");
+  const blip = getChild(blipFill, "blip");
+  const embed = getNamespacedAttr(blip, "embed");
+  const crop = parseCrop(getChild(blipFill, "srcRect"));
+  const stretch = parseStretch(getChild(blipFill, "stretch"));
+  const tile = parseImageFillTile(getChild(blipFill, "tile"));
+  const blipEffects = parseBlipEffects(blip);
+  const spPr = getChild(pic, "spPr");
+  const transform = parseTransform(spPr);
+  const effects = parseEffectList(getChild(spPr, "effectLst"));
+  const rawSidecars = [
+    ...collectUnknownSidecars(pic, KNOWN_PICTURE_CHILDREN, nextId),
+    ...collectUnknownSidecars(spPr, KNOWN_SP_PR_CHILDREN, nextId),
+    ...collectEffectSidecars(spPr, effects, nextId),
+    // Retains fill mode such as `a:stretch` / `a:tile` and recolor operation under blip.
+    ...collectUnknownSidecars(blipFill, KNOWN_BLIP_FILL_CHILDREN, nextId),
+    ...collectBlipEffectSidecars(blip, blipEffects, nextId)
+  ];
+  return {
+    kind: "image",
+    ...nodeId !== void 0 ? { nodeId } : {},
+    ...name !== void 0 ? { name } : {},
+    ...transform !== void 0 ? { transform } : {},
+    ...embed !== void 0 ? { blipRelationshipId: asRelationshipId(embed) } : {},
+    ...crop !== void 0 ? { crop } : {},
+    ...stretch !== void 0 ? { stretch } : {},
+    ...tile !== void 0 ? { tile } : {},
+    ...effects !== void 0 ? { effects } : {},
+    ...blipEffects !== void 0 ? { blipEffects } : {},
+    handle: {
+      partPath,
+      ...nodeId !== void 0 ? { nodeId } : {},
+      ...embed !== void 0 ? { relationshipId: asRelationshipId(embed) } : {},
+      orderingSlot
+    },
+    ...rawSidecars.length > 0 ? { rawSidecars } : {}
+  };
+}
+function collectEffectSidecars(spPr, effects, nextId) {
+  const effectList = getChild(spPr, "effectLst");
+  if (effectList === void 0) return [];
+  const sidecars = collectUnknownSidecars(effectList, KNOWN_EFFECT_CHILDREN, nextId);
+  const supportedChildren = [
+    ["outerShdw", effects?.outerShadow],
+    ["innerShdw", effects?.innerShadow],
+    ["glow", effects?.glow],
+    ["softEdge", effects?.softEdge]
+  ];
+  for (const [name, parsed] of supportedChildren) {
+    const node = getChild(effectList, name);
+    if (node !== void 0 && parsed === void 0) {
+      sidecars.push(makeSidecar(`a:${name}`, node, nextId));
+    }
+  }
+  return sidecars;
+}
+function collectBlipEffectSidecars(blip, effects, nextId) {
+  if (blip === void 0) return [];
+  const sidecars = collectUnknownSidecars(blip, KNOWN_BLIP_CHILDREN, nextId);
+  const supportedChildren = [
+    ["grayscl", effects?.grayscale === true],
+    ["biLevel", effects?.biLevel],
+    ["blur", effects?.blur],
+    ["lum", effects?.lum],
+    ["duotone", effects?.duotone],
+    ["clrChange", effects?.clrChange]
+  ];
+  for (const [name, parsed] of supportedChildren) {
+    const node = getChild(blip, name);
+    if (node !== void 0 && (parsed === void 0 || parsed === false)) {
+      sidecars.push(makeSidecar(`a:${name}`, node, nextId));
+    }
+  }
+  return sidecars;
+}
+function parseGraphicFrame(graphicFrame, partPath, nextId, orderingSlot, orderedNode) {
+  const graphic = getChild(graphicFrame, "graphic");
+  const graphicData = getChild(graphic, "graphicData");
+  const uri = getAttr(graphicData, "uri");
+  if (uri !== void 0 && CHART_GRAPHIC_DATA_URIS.has(uri)) {
+    const parsedChart = parseChartGraphicFrame(graphicFrame, partPath, nextId, orderingSlot);
+    if (parsedChart !== void 0) return parsedChart;
+  }
+  if (uri !== void 0 && SMARTART_DIAGRAM_URIS.has(uri)) {
+    const parsedSmartArt = parseSmartArtGraphicFrame(graphicFrame, partPath, nextId, orderingSlot);
+    if (parsedSmartArt !== void 0) return parsedSmartArt;
+  }
+  const table = getChild(graphicData, "tbl");
+  if (table === void 0) {
+    return parseRawShapeNode("p:graphicFrame", graphicFrame, partPath, nextId, orderingSlot);
+  }
+  const orderedGraphicChildren = orderedNestedChildChildren(orderedNode, "graphicFrame", "graphic");
+  const orderedGraphicDataChildren = orderedChildChildren2(orderedGraphicChildren, "graphicData");
+  const orderedTableChildren = orderedChildChildren2(orderedGraphicDataChildren, "tbl");
+  const parsedTable = parseTable(
+    table,
+    graphicFrame,
+    partPath,
+    nextId,
+    orderingSlot,
+    orderedTableChildren
+  );
+  if (parsedTable === void 0) {
+    return parseRawShapeNode("p:graphicFrame", graphicFrame, partPath, nextId, orderingSlot);
+  }
+  return parsedTable;
+}
+function parseAlternateContent(alternateContent, partPath, nextId, orderingSlot) {
+  const branches = [
+    ...getChildArray(alternateContent, "Choice"),
+    ...getChildArray(alternateContent, "Fallback")
+  ];
+  for (const branch of branches) {
+    const parsed = parseAlternateContentBranch(branch, partPath, nextId, orderingSlot);
+    if (parsed.length > 0) {
+      if (parsed.every((node) => node.kind === "raw")) {
+        continue;
+      }
+      return parsed.map(
+        (node) => attachRawSidecar(node, makeSidecar("mc:AlternateContent", alternateContent, nextId))
+      );
+    }
+  }
+  return [
+    parseRawShapeNode("mc:AlternateContent", alternateContent, partPath, nextId, orderingSlot)
+  ];
+}
+function attachRawSidecar(node, sidecar) {
+  if (node.kind === "raw") return node;
+  return {
+    ...node,
+    rawSidecars: [...node.rawSidecars ?? [], sidecar]
+  };
+}
+function parseAlternateContentBranch(branch, partPath, nextId, orderingSlot) {
+  const nodes = [];
+  for (const key of Object.keys(branch)) {
+    if (key.startsWith("@_") || key === "#text") continue;
+    const local = localName(key);
+    const value = branch[key];
+    const items = Array.isArray(value) ? value : [value];
+    for (const item of items) {
+      const node = unsafeOoxmlBoundaryAssertion(item);
+      if (local === "sp") nodes.push(parseShape(node, partPath, nextId, orderingSlot));
+      else if (local === "pic") nodes.push(parseImage(node, partPath, nextId, orderingSlot));
+      else if (local === "cxnSp") {
+        nodes.push(parseConnector(node, partPath, nextId, orderingSlot));
+      } else if (local === "grpSp") {
+        nodes.push(parseGroup(node, partPath, nextId, orderingSlot));
+      } else if (local === "graphicFrame") {
+        nodes.push(parseGraphicFrame(node, partPath, nextId, orderingSlot));
+      } else {
+        nodes.push(parseRawShapeNode(key, node, partPath, nextId, orderingSlot));
+      }
+    }
+  }
+  return nodes;
+}
+function parseChartGraphicFrame(graphicFrame, partPath, nextId, orderingSlot) {
+  const graphic = getChild(graphicFrame, "graphic");
+  const graphicData = getChild(graphic, "graphicData");
+  const chart = getChild(graphicData, "chart");
+  const rId = getNamespacedAttr(chart, "id") ?? getAttr(chart, "id");
+  if (rId === void 0) return void 0;
+  const nvGraphicFramePr = getChild(graphicFrame, "nvGraphicFramePr");
+  const cNvPr = getChild(nvGraphicFramePr, "cNvPr");
+  const nodeId = sourceNodeId(cNvPr);
+  const name = getAttr(cNvPr, "name");
+  const transform = parseTransform(graphicFrame);
+  const rawSidecars = [
+    ...collectUnknownSidecars(graphicFrame, KNOWN_GRAPHIC_FRAME_CHILDREN, nextId),
+    ...collectUnknownSidecars(graphic, KNOWN_GRAPHIC_CHILDREN, nextId),
+    ...collectUnknownSidecars(graphicData, EMPTY_KNOWN, nextId)
+  ];
+  return {
+    kind: "chart",
+    ...nodeId !== void 0 ? { nodeId } : {},
+    ...name !== void 0 ? { name } : {},
+    ...transform !== void 0 ? { transform } : {},
+    chartRelationshipId: asRelationshipId(rId),
+    handle: {
+      partPath,
+      ...nodeId !== void 0 ? { nodeId } : {},
+      relationshipId: asRelationshipId(rId),
+      orderingSlot
+    },
+    ...rawSidecars.length > 0 ? { rawSidecars } : {}
+  };
+}
+function parseSmartArtGraphicFrame(graphicFrame, partPath, nextId, orderingSlot) {
+  const graphic = getChild(graphicFrame, "graphic");
+  const graphicData = getChild(graphic, "graphicData");
+  const relIds = getChild(graphicData, "relIds");
+  const dmRId = getNamespacedAttr(relIds, "dm") ?? getAttr(relIds, "dm");
+  if (dmRId === void 0) return void 0;
+  const nvGraphicFramePr = getChild(graphicFrame, "nvGraphicFramePr");
+  const cNvPr = getChild(nvGraphicFramePr, "cNvPr");
+  const nodeId = sourceNodeId(cNvPr);
+  const name = getAttr(cNvPr, "name");
+  const transform = parseTransform(graphicFrame);
+  const rawSidecars = [
+    ...collectUnknownSidecars(graphicFrame, KNOWN_GRAPHIC_FRAME_CHILDREN, nextId),
+    ...collectUnknownSidecars(graphic, KNOWN_GRAPHIC_CHILDREN, nextId),
+    ...collectUnknownSidecars(graphicData, EMPTY_KNOWN, nextId)
+  ];
+  return {
+    kind: "smartArt",
+    ...nodeId !== void 0 ? { nodeId } : {},
+    ...name !== void 0 ? { name } : {},
+    ...transform !== void 0 ? { transform } : {},
+    dataRelationshipId: asRelationshipId(dmRId),
+    handle: {
+      partPath,
+      ...nodeId !== void 0 ? { nodeId } : {},
+      relationshipId: asRelationshipId(dmRId),
+      orderingSlot
+    },
+    ...rawSidecars.length > 0 ? { rawSidecars } : {}
+  };
+}
+function parseTable(tbl, graphicFrame, partPath, nextId, orderingSlot, orderedTableChildren) {
+  const columns = parseTableColumns(getChild(tbl, "tblGrid"));
+  if (columns.length === 0) return void 0;
+  const nvGraphicFramePr = getChild(graphicFrame, "nvGraphicFramePr");
+  const cNvPr = getChild(nvGraphicFramePr, "cNvPr");
+  const nodeId = sourceNodeId(cNvPr);
+  const name = getAttr(cNvPr, "name");
+  const tblPr = getChild(tbl, "tblPr");
+  const tableStyleId = getChildText(tblPr, "tableStyleId");
+  const graphic = getChild(graphicFrame, "graphic");
+  const graphicData = getChild(graphic, "graphicData");
+  const transform = parseTransform(graphicFrame);
+  const rows = parseTableRows(tbl, partPath, nextId, nodeId, orderingSlot, orderedTableChildren);
+  const rawSidecars = [
+    ...collectUnknownSidecars(graphicFrame, KNOWN_GRAPHIC_FRAME_CHILDREN, nextId),
+    ...collectUnknownSidecars(graphic, KNOWN_GRAPHIC_CHILDREN, nextId),
+    ...collectUnknownSidecars(graphicData, KNOWN_GRAPHIC_DATA_CHILDREN, nextId),
+    ...collectUnknownSidecars(tbl, KNOWN_TABLE_CHILDREN, nextId)
+  ];
+  return {
+    kind: "table",
+    ...nodeId !== void 0 ? { nodeId } : {},
+    ...name !== void 0 ? { name } : {},
+    ...transform !== void 0 ? { transform } : {},
+    table: {
+      columns,
+      rows,
+      ...tableStyleId !== void 0 ? { tableStyleId } : {}
+    },
+    handle: { partPath, ...nodeId !== void 0 ? { nodeId } : {}, orderingSlot },
+    ...rawSidecars.length > 0 ? { rawSidecars } : {}
+  };
+}
+function parseTableColumns(tblGrid) {
+  return getChildArray(tblGrid, "gridCol").map((col) => ({ width: emuAttr(col, "w") }));
+}
+function parseTableRows(tbl, partPath, nextId, tableNodeId, tableOrderingSlot, orderedTableChildren) {
+  const orderedRows = orderedChildChildrenList(orderedTableChildren, "tr");
+  return getChildArray(tbl, "tr").map((tr, rowIndex) => ({
+    height: emuAttr(tr, "h"),
+    cells: getChildArray(tr, "tc").map((tc, cellIndex) => {
+      const orderedCells = orderedChildChildrenList(orderedRows[rowIndex], "tc");
+      return parseTableCell(
+        tc,
+        partPath,
+        nextId,
+        tableNodeId,
+        tableOrderingSlot,
+        rowIndex,
+        cellIndex,
+        orderedCells[cellIndex]
+      );
+    })
+  }));
+}
+function parseTableCell(tc, partPath, nextId, tableNodeId, tableOrderingSlot, rowIndex, cellIndex, orderedCellChildren) {
+  const tcPr = getChild(tc, "tcPr");
+  const textOrderingSlot = tableOrderingSlot * 1e9 + rowIndex * 1e6 + cellIndex;
+  const textBody = parseTextBody(
+    getChild(tc, "txBody"),
+    partPath,
+    nextId,
+    tableNodeId,
+    textOrderingSlot,
+    orderedChildChildren2(orderedCellChildren, "txBody")
+  );
+  const fill = parseFill(tcPr, nextId);
+  const borders = parseCellBorders(tcPr, nextId);
+  const rawSidecars = [
+    ...collectUnknownSidecars(tc, KNOWN_TABLE_CELL_CHILDREN, nextId),
+    ...collectUnknownSidecars(tcPr, KNOWN_TABLE_CELL_PROPERTIES_CHILDREN, nextId)
+  ];
+  return {
+    ...textBody !== void 0 ? { textBody } : {},
+    ...fill !== void 0 ? { fill } : {},
+    ...borders !== void 0 ? { borders } : {},
+    gridSpan: numericAttr(tc, "gridSpan") ?? 1,
+    rowSpan: numericAttr(tc, "rowSpan") ?? 1,
+    hMerge: isTrue(getAttr(tc, "hMerge") ?? getAttr(tcPr, "hMerge")),
+    vMerge: isTrue(getAttr(tc, "vMerge") ?? getAttr(tcPr, "vMerge")),
+    ...rawSidecars.length > 0 ? { rawSidecars } : {}
+  };
+}
+function parseCellBorders(tcPr, nextId) {
+  const left = parseLine(getChild(tcPr, "lnL"), nextId);
+  const right = parseLine(getChild(tcPr, "lnR"), nextId);
+  const top = parseLine(getChild(tcPr, "lnT"), nextId);
+  const bottom = parseLine(getChild(tcPr, "lnB"), nextId);
+  if (left === void 0 && right === void 0 && top === void 0 && bottom === void 0) {
+    return void 0;
+  }
+  return {
+    ...top !== void 0 ? { top } : {},
+    ...bottom !== void 0 ? { bottom } : {},
+    ...left !== void 0 ? { left } : {},
+    ...right !== void 0 ? { right } : {}
+  };
+}
+function parseRawShapeNode(key, node, partPath, nextId, orderingSlot) {
+  const nodeId = sourceNodeId(getChild(getChild(node, "nvSpPr"), "cNvPr"));
+  return {
+    kind: "raw",
+    ...nodeId !== void 0 ? { nodeId } : {},
+    raw: makeSidecar(key, node, nextId),
+    handle: { partPath, ...nodeId !== void 0 ? { nodeId } : {}, orderingSlot }
+  };
+}
+function parsePlaceholder(ph) {
+  if (!ph) return void 0;
+  const type = getAttr(ph, "type");
+  const index = numericAttr(ph, "idx");
+  if (type === void 0 && index === void 0) return void 0;
+  return {
+    ...type !== void 0 ? { type } : {},
+    ...index !== void 0 ? { index } : {}
+  };
+}
+function parseGeometry(spPr, orderedSpPr) {
+  const prstGeom = getChild(spPr, "prstGeom");
+  if (prstGeom) {
+    const preset = getAttr(prstGeom, "prst");
+    const adjustValues = parseAdjustValues(getChild(prstGeom, "avLst"));
+    return preset !== void 0 ? {
+      preset,
+      ...Object.keys(adjustValues).length > 0 ? { adjustValues } : {}
+    } : void 0;
+  }
+  const customPaths = parseCustomGeometry(
+    getChild(spPr, "custGeom"),
+    orderedChildChildren2(orderedSpPr, "custGeom")
+  );
+  if (customPaths !== void 0) return { kind: "custom", paths: customPaths };
+  return void 0;
+}
+function parseAdjustValues(avLst) {
+  const adjustValues = {};
+  for (const guide of getChildArray(avLst, "gd")) {
+    const name = getAttr(guide, "name");
+    const formula = getAttr(guide, "fmla");
+    const match = formula?.match(/val\s+(-?\d+)/);
+    if (name !== void 0 && match !== void 0 && match !== null) {
+      adjustValues[name] = Number(match[1]);
+    }
+  }
+  return adjustValues;
+}
+function parseChildTransform(grpSpPr, fallback) {
+  const xfrm = getChild(grpSpPr, "xfrm");
+  const childOff = getChild(xfrm, "chOff");
+  const childExt = getChild(xfrm, "chExt");
+  const offsetX = numericAttr(childOff, "x") ?? 0;
+  const offsetY = numericAttr(childOff, "y") ?? 0;
+  const width = numericAttr(childExt, "cx") ?? fallback?.width;
+  const height = numericAttr(childExt, "cy") ?? fallback?.height;
+  if (width === void 0 || height === void 0) return void 0;
+  return {
+    offsetX: asEmu(offsetX),
+    offsetY: asEmu(offsetY),
+    width: asEmu(Number(width)),
+    height: asEmu(Number(height))
+  };
+}
+function parseCrop(srcRect) {
+  if (!srcRect) return void 0;
+  const left = numericAttr(srcRect, "l");
+  const top = numericAttr(srcRect, "t");
+  const right = numericAttr(srcRect, "r");
+  const bottom = numericAttr(srcRect, "b");
+  const crop = {
+    ...left !== void 0 ? { left: asOoxmlPercent(left) } : {},
+    ...top !== void 0 ? { top: asOoxmlPercent(top) } : {},
+    ...right !== void 0 ? { right: asOoxmlPercent(right) } : {},
+    ...bottom !== void 0 ? { bottom: asOoxmlPercent(bottom) } : {}
+  };
+  return Object.keys(crop).length > 0 ? crop : void 0;
+}
+function parseStretch(stretch) {
+  const fillRect = getChild(stretch, "fillRect");
+  if (fillRect === void 0) return void 0;
+  const left = (numericAttr(fillRect, "l") ?? 0) / 1e5;
+  const top = (numericAttr(fillRect, "t") ?? 0) / 1e5;
+  const right = (numericAttr(fillRect, "r") ?? 0) / 1e5;
+  const bottom = (numericAttr(fillRect, "b") ?? 0) / 1e5;
+  if (left === 0 && top === 0 && right === 0 && bottom === 0) return void 0;
+  return { left, top, right, bottom };
+}
+function sourceNodeId(cNvPr) {
+  const id = getAttr(cNvPr, "id");
+  return id !== void 0 ? asSourceNodeId(id) : void 0;
+}
+function emuAttr(node, attrName) {
+  return asEmu(numericAttr(node, attrName) ?? 0);
+}
+var EMPTY_KNOWN = /* @__PURE__ */ new Set();
+function orderedChildChildren2(parent, childLocalName) {
+  const child = parent?.find((entry) => {
+    const key2 = Object.keys(entry).find((candidate) => candidate !== ":@");
+    return key2 !== void 0 && localName(key2) === childLocalName;
+  });
+  if (child === void 0) return void 0;
+  const key = Object.keys(child).find((candidate) => candidate !== ":@");
+  const value = key !== void 0 ? child[key] : void 0;
+  return Array.isArray(value) ? value : void 0;
+}
+function orderedChildChildrenList(parent, childLocalName) {
+  if (parent === void 0) return [];
+  return parent.filter((entry) => {
+    const key = Object.keys(entry).find((candidate) => candidate !== ":@");
+    return key !== void 0 && localName(key) === childLocalName;
+  }).map((entry) => {
+    const key = Object.keys(entry).find((candidate) => candidate !== ":@");
+    const value = key !== void 0 ? entry[key] : void 0;
+    return Array.isArray(value) ? value : void 0;
+  });
+}
+function orderedNestedChildChildren(node, parentLocalName, childLocalName) {
+  if (node === void 0) return void 0;
+  const parentChildren = node[parentLocalName];
+  return orderedChildChildren2(
+    Array.isArray(parentChildren) ? parentChildren : void 0,
+    childLocalName
+  );
+}
+
+// src/computed/color.ts
+var DEFAULT_COLOR_MAP = {
+  bg1: "lt1",
+  tx1: "dk1",
+  bg2: "lt2",
+  tx2: "dk2",
+  accent1: "accent1",
+  accent2: "accent2",
+  accent3: "accent3",
+  accent4: "accent4",
+  accent5: "accent5",
+  accent6: "accent6",
+  hlink: "hlink",
+  folHlink: "folHlink"
+};
+var FALLBACK_SCHEME_COLORS = {
+  dk1: "#000000",
+  lt1: "#ffffff",
+  dk2: "#44546a",
+  lt2: "#e7e6e6",
+  accent1: "#4472c4",
+  accent2: "#ed7d31",
+  accent3: "#a5a5a5",
+  accent4: "#ffc000",
+  accent5: "#5b9bd5",
+  accent6: "#70ad47",
+  hlink: "#0563c1",
+  folHlink: "#954f72"
+};
+function buildEffectiveColorMap(master, layoutOverride, slideOverride) {
+  return {
+    ...DEFAULT_COLOR_MAP,
+    ...master?.mapping,
+    ...layoutOverride?.mapping,
+    ...slideOverride?.mapping
+  };
+}
+function buildComputedColorScheme(context) {
+  const colors = { ...FALLBACK_SCHEME_COLORS };
+  for (const [name, color] of Object.entries(context.theme?.colorScheme?.colors ?? {})) {
+    const resolved = resolveColor(context, color);
+    if (resolved !== void 0) colors[name] = resolved.hex;
+  }
+  return colors;
+}
+function resolveColor(context, color, visited = /* @__PURE__ */ new Set()) {
+  const hex = resolveBaseHex(context, color, visited);
+  if (hex === void 0) return void 0;
+  return applyColorTransforms(hex, color.transforms);
+}
+function resolveBaseHex(context, color, visited) {
+  switch (color.kind) {
+    case "srgb":
+      return normalizeHex(color.hex);
+    case "system":
+      return normalizeHex(color.lastColor ?? "000000");
+    case "scheme": {
+      const mappedName = context.colorMap[color.scheme] ?? color.scheme;
+      if (visited.has(mappedName)) return "#000000";
+      const schemeColor = context.theme?.colorScheme?.colors[mappedName];
+      return schemeColor !== void 0 ? resolveColor(context, schemeColor, /* @__PURE__ */ new Set([...visited, mappedName]))?.hex : FALLBACK_SCHEME_COLORS[mappedName];
+    }
+  }
+}
+function applyColorTransforms(initialHex, transforms) {
+  let hex = initialHex;
+  let alpha = 1;
+  for (const transform of transforms ?? []) {
+    switch (transform.kind) {
+      case "lumMod": {
+        const lumOff = transforms?.find((candidate) => candidate.kind === "lumOff");
+        hex = applyLuminance(
+          hex,
+          Number(transform.value) / 1e5,
+          Number(lumOff?.value ?? 0) / 1e5
+        );
+        break;
+      }
+      case "lumOff":
+        if (!transforms?.some((candidate) => candidate.kind === "lumMod")) {
+          hex = applyLuminance(hex, 1, Number(transform.value) / 1e5);
+        }
+        break;
+      case "tint":
+        hex = applyTint(hex, Number(transform.value) / 1e5);
+        break;
+      case "shade":
+        hex = applyShade(hex, Number(transform.value) / 1e5);
+        break;
+      case "alpha":
+        alpha = Number(transform.value) / 1e5;
+        break;
+    }
+  }
+  return { hex, alpha };
+}
+function normalizeHex(hex) {
+  const normalized = hex.replace(/^#/, "").toLowerCase();
+  return `#${normalized.padStart(6, "0").slice(0, 6)}`;
+}
+function applyLuminance(hex, lumMod, lumOff) {
+  const { h, s, l } = hexToHsl(hex);
+  return hslToHex(h, s, Math.min(1, Math.max(0, l * lumMod + lumOff)));
+}
+function applyTint(hex, tintAmount) {
+  const { r, g, b } = hexToRgb(hex);
+  return rgbToHex(
+    Math.round(r + (255 - r) * tintAmount),
+    Math.round(g + (255 - g) * tintAmount),
+    Math.round(b + (255 - b) * tintAmount)
+  );
+}
+function applyShade(hex, shadeAmount) {
+  const { r, g, b } = hexToRgb(hex);
+  return rgbToHex(
+    Math.round(r * shadeAmount),
+    Math.round(g * shadeAmount),
+    Math.round(b * shadeAmount)
+  );
+}
+function hexToRgb(hex) {
+  const normalized = hex.replace("#", "");
+  return {
+    r: parseInt(normalized.slice(0, 2), 16),
+    g: parseInt(normalized.slice(2, 4), 16),
+    b: parseInt(normalized.slice(4, 6), 16)
+  };
+}
+function rgbToHex(r, g, b) {
+  const toHex = (value) => Math.min(255, Math.max(0, value)).toString(16).padStart(2, "0");
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function hexToHsl(hex) {
+  const { r: r255, g: g255, b: b255 } = hexToRgb(hex);
+  const r = r255 / 255;
+  const g = g255 / 255;
+  const b = b255 / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  if (max === min) return { h: 0, s: 0, l };
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  const h = max === r ? ((g - b) / d + (g < b ? 6 : 0)) / 6 : max === g ? ((b - r) / d + 2) / 6 : ((r - g) / d + 4) / 6;
+  return { h, s, l };
+}
+function hslToHex(h, s, l) {
+  if (s === 0) {
+    const value = Math.round(l * 255);
+    return rgbToHex(value, value, value);
+  }
+  const hue2rgb = (p2, q2, t) => {
+    let tt = t;
+    if (tt < 0) tt += 1;
+    if (tt > 1) tt -= 1;
+    if (tt < 1 / 6) return p2 + (q2 - p2) * 6 * tt;
+    if (tt < 1 / 2) return q2;
+    if (tt < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - tt) * 6;
+    return p2;
+  };
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  return rgbToHex(
+    Math.round(hue2rgb(p, q, h + 1 / 3) * 255),
+    Math.round(hue2rgb(p, q, h) * 255),
+    Math.round(hue2rgb(p, q, h - 1 / 3) * 255)
+  );
+}
+
+// src/computed/chart-data.ts
+var ACCENT_KEYS = ["accent1", "accent2", "accent3", "accent4", "accent5", "accent6"];
+var CHART_TYPE_MAP = [
+  ["barChart", "bar"],
+  ["bar3DChart", "bar"],
+  ["lineChart", "line"],
+  ["line3DChart", "line"],
+  ["pieChart", "pie"],
+  ["pie3DChart", "pie"],
+  ["doughnutChart", "doughnut"],
+  ["scatterChart", "scatter"],
+  ["bubbleChart", "bubble"],
+  ["areaChart", "area"],
+  ["area3DChart", "area"],
+  ["radarChart", "radar"],
+  ["stockChart", "stock"],
+  ["surfaceChart", "surface"],
+  ["surface3DChart", "surface"],
+  ["ofPieChart", "ofPie"]
+];
+function parseComputedChartData(chartXml, colorContext) {
+  const parsed = parseXml(chartXml);
+  const chartSpace = getChild(parsed, "chartSpace");
+  if (chartSpace === void 0) return void 0;
+  const chart = getChild(chartSpace, "chart");
+  if (chart === void 0) return void 0;
+  const plotArea = getChild(chart, "plotArea");
+  if (plotArea === void 0) return void 0;
+  const title = parseChartTitle(getChild(chart, "title"));
+  const parsedChart = parseChartTypeAndData(plotArea, colorContext);
+  if (parsedChart.chartType === void 0) return void 0;
+  return {
+    chartType: parsedChart.chartType,
+    title,
+    series: parsedChart.series,
+    categories: parsedChart.categories,
+    ...parsedChart.barDirection !== void 0 ? { barDirection: parsedChart.barDirection } : {},
+    ...parsedChart.holeSize !== void 0 ? { holeSize: parsedChart.holeSize } : {},
+    ...parsedChart.radarStyle !== void 0 ? { radarStyle: parsedChart.radarStyle } : {},
+    ...parsedChart.ofPieType !== void 0 ? { ofPieType: parsedChart.ofPieType } : {},
+    ...parsedChart.secondPieSize !== void 0 ? { secondPieSize: parsedChart.secondPieSize } : {},
+    ...parsedChart.splitPos !== void 0 ? { splitPos: parsedChart.splitPos } : {},
+    legend: parseLegend(getChild(chart, "legend"))
+  };
+}
+function parseChartTypeAndData(plotArea, colorContext) {
+  for (const [xmlTag, chartType] of CHART_TYPE_MAP) {
+    const chartNode = getChild(plotArea, xmlTag);
+    if (chartNode === void 0) continue;
+    const serList = getChildArray(chartNode, "ser");
+    const series = serList.map((ser, index) => parseSeries(ser, chartType, index, colorContext));
+    const categories = extractCategories(serList);
+    const barDirection = chartType === "bar" ? parseBarDirection(getAttr(getChild(chartNode, "barDir"), "val")) : void 0;
+    const holeSize = chartType === "doughnut" ? parseNumberAttribute(getChild(chartNode, "holeSize"), "val", 50) : void 0;
+    const radarStyle = chartType === "radar" ? parseRadarStyle(getAttr(getChild(chartNode, "radarStyle"), "val")) : void 0;
+    const ofPieType = chartType === "ofPie" ? parseOfPieType(getAttr(getChild(chartNode, "ofPieType"), "val")) : void 0;
+    const secondPieSize = chartType === "ofPie" ? parseNumberAttribute(getChild(chartNode, "secondPieSize"), "val", 75) : void 0;
+    const splitPos = chartType === "ofPie" ? parseNumberAttribute(getChild(chartNode, "splitPos"), "val", 2) : void 0;
+    return {
+      chartType,
+      series,
+      categories,
+      ...barDirection !== void 0 ? { barDirection } : {},
+      ...holeSize !== void 0 ? { holeSize } : {},
+      ...radarStyle !== void 0 ? { radarStyle } : {},
+      ...ofPieType !== void 0 ? { ofPieType } : {},
+      ...secondPieSize !== void 0 ? { secondPieSize } : {},
+      ...splitPos !== void 0 ? { splitPos } : {}
+    };
+  }
+  return { series: [], categories: [] };
+}
+function parseSeries(ser, chartType, seriesIndex, colorContext) {
+  const name = parseSeriesName(getChild(ser, "tx"));
+  const usesXY = chartType === "scatter" || chartType === "bubble";
+  const values = parseNumericData(usesXY ? getChild(ser, "yVal") : getChild(ser, "val"));
+  const xValues = usesXY ? parseNumericData(getChild(ser, "xVal")) : void 0;
+  const bubbleSizes = chartType === "bubble" ? parseNumericData(getChild(ser, "bubbleSize")) : void 0;
+  const color = resolveSeriesColor(getChild(ser, "spPr"), seriesIndex, colorContext);
+  return {
+    name,
+    values,
+    ...xValues !== void 0 ? { xValues } : {},
+    ...bubbleSizes !== void 0 ? { bubbleSizes } : {},
+    color
+  };
+}
+function parseSeriesName(tx) {
+  if (tx === void 0) return null;
+  const strCache = getChild(getChild(tx, "strRef"), "strCache");
+  const cachedValue = firstIndexedPointText(strCache);
+  if (cachedValue !== void 0) return cachedValue;
+  return getChildText(tx, "v") ?? null;
+}
+function parseNumericData(valNode) {
+  const numCache = getChild(getChild(valNode, "numRef"), "numCache") ?? getChild(valNode, "numLit");
+  return indexedPointTexts(numCache).map(parseNumericPointValue);
+}
+function extractCategories(serList) {
+  for (const ser of serList) {
+    const cat = getChild(ser, "cat");
+    if (cat === void 0) continue;
+    const categoryCache = getChild(getChild(cat, "strRef"), "strCache") ?? getChild(cat, "strLit") ?? getChild(getChild(cat, "numRef"), "numCache") ?? getChild(cat, "numLit");
+    const values = indexedPointTexts(categoryCache).map((value) => String(value ?? ""));
+    if (values.length > 0) return values;
+    const multiCache = getChild(getChild(cat, "multiLvlStrRef"), "multiLvlStrCache") ?? getChild(cat, "multiLvlStrLit");
+    const firstLevel = getChildArray(multiCache, "lvl")[0];
+    const multiValues = indexedPointTexts(firstLevel).map((value) => String(value ?? ""));
+    if (multiValues.length > 0) return multiValues;
+  }
+  return [];
+}
+function indexedPointTexts(cache) {
+  return getChildArray(cache, "pt").slice().sort((a, b) => Number(getAttr(a, "idx")) - Number(getAttr(b, "idx"))).map((point) => getChildText(point, "v") ?? "");
+}
+function firstIndexedPointText(cache) {
+  return indexedPointTexts(cache)[0];
+}
+function parseNumericPointValue(value) {
+  const parsed = Number(value ?? 0);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function parseNumberAttribute(node, attrName, fallback) {
+  const parsed = Number(getAttr(node, attrName) ?? fallback);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function resolveSeriesColor(spPr, seriesIndex, colorContext) {
+  const sourceColor = parseSeriesSourceColor(spPr);
+  if (sourceColor !== void 0) {
+    const resolved = resolveColor(colorContext, sourceColor);
+    if (resolved !== void 0) return resolved;
+  }
+  const accentKey = ACCENT_KEYS[seriesIndex % ACCENT_KEYS.length];
+  return resolveColor(colorContext, { kind: "scheme", scheme: accentKey }) ?? {
+    hex: "#4472c4",
+    alpha: 1
+  };
+}
+function parseSeriesSourceColor(spPr) {
+  return parseColorElement(getChild(spPr, "solidFill")) ?? parseColorElement(spPr);
+}
+function parseChartTitle(titleNode) {
+  const rich = getChild(getChild(titleNode, "tx"), "rich");
+  if (rich === void 0) return null;
+  const texts = [];
+  for (const paragraph of getChildArray(rich, "p")) {
+    for (const run of getChildArray(paragraph, "r")) {
+      const text = getChildText(run, "t");
+      if (text !== void 0) texts.push(text);
+    }
+  }
+  return texts.length > 0 ? texts.join("") : null;
+}
+function parseLegend(legendNode) {
+  if (legendNode === void 0) return null;
+  return { position: parseLegendPosition(getAttr(getChild(legendNode, "legendPos"), "val")) };
+}
+function parseBarDirection(value) {
+  return value === "bar" ? "bar" : "col";
+}
+function parseRadarStyle(value) {
+  if (value === "marker" || value === "filled") return value;
+  return "standard";
+}
+function parseOfPieType(value) {
+  return value === "bar" ? "bar" : "pie";
+}
+function parseLegendPosition(value) {
+  if (value === "b" || value === "t" || value === "l" || value === "tr") return value;
+  return "r";
+}
+
+// src/computed/placeholders.ts
+function findPlaceholderMatch(context, shape) {
+  if (shape.placeholder === void 0) return void 0;
+  const type = shape.placeholder.type ?? "body";
+  const index = shape.placeholder.index;
+  const layout = findMatchingPlaceholder(type, index, context.layoutShapes);
+  const master = findMatchingPlaceholder(type, index, context.masterShapes);
+  if (layout === void 0 && master === void 0) return void 0;
+  return {
+    ...layout !== void 0 ? { layout } : {},
+    ...master !== void 0 ? { master } : {}
+  };
+}
+function findMatchingPlaceholder(type, index, shapes) {
+  const placeholders = shapes.filter(
+    (shape) => shape.kind === "shape" && shape.placeholder !== void 0
+  );
+  if (index !== void 0) {
+    const byIndexWithTransform = placeholders.find(
+      (shape) => shape.placeholder?.index === index && shape.transform !== void 0
+    );
+    if (byIndexWithTransform !== void 0) return byIndexWithTransform;
+    const byIndex = placeholders.find((shape) => shape.placeholder?.index === index);
+    if (byIndex !== void 0) return byIndex;
+  }
+  const byTypeWithTransform = placeholders.find(
+    (shape) => (shape.placeholder?.type ?? "body") === type && shape.transform !== void 0
+  );
+  if (byTypeWithTransform !== void 0) return byTypeWithTransform;
+  const fallbackType = getPlaceholderFallbackType(type);
+  if (fallbackType !== void 0) {
+    const byFallbackWithTransform = placeholders.find(
+      (shape) => (shape.placeholder?.type ?? "body") === fallbackType && shape.transform !== void 0
+    );
+    if (byFallbackWithTransform !== void 0) return byFallbackWithTransform;
+  }
+  const byType = placeholders.find((shape) => (shape.placeholder?.type ?? "body") === type);
+  if (byType !== void 0) return byType;
+  if (fallbackType !== void 0) {
+    return placeholders.find((shape) => (shape.placeholder?.type ?? "body") === fallbackType);
+  }
+  return void 0;
+}
+function getPlaceholderFallbackType(type) {
+  if (type === "ctrTitle") return "title";
+  if (type === "subTitle") return "body";
+  return void 0;
+}
+
+// src/source/package-paths.ts
+var RELS_SUFFIX = ".rels";
+var RELS_MARKER = "_rels/";
+var ABSOLUTE_URI_PATTERN = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+function isRelationshipPart(path) {
+  return path.endsWith(RELS_SUFFIX) && path.includes(RELS_MARKER);
+}
+function relationshipsPartPath(sourcePartPath) {
+  if (sourcePartPath === "") return "_rels/.rels";
+  const slash = sourcePartPath.lastIndexOf("/");
+  const dir = slash === -1 ? "" : sourcePartPath.slice(0, slash + 1);
+  const file = slash === -1 ? sourcePartPath : sourcePartPath.slice(slash + 1);
+  return `${dir}_rels/${file}.rels`;
+}
+function relationshipsSourcePartPath(relsPath) {
+  const idx = relsPath.lastIndexOf(RELS_MARKER);
+  const dir = relsPath.slice(0, idx);
+  const file = relsPath.slice(idx + RELS_MARKER.length);
+  const base = file.endsWith(RELS_SUFFIX) ? file.slice(0, -RELS_SUFFIX.length) : file;
+  return asPartPath(dir + base);
+}
+function resolveRelationshipTarget(sourcePartPath, target) {
+  if (ABSOLUTE_URI_PATTERN.test(target)) return target;
+  const combined = target.startsWith("/") ? target.slice(1) : joinPackageRelativeTarget(sourcePartPath, target);
+  return normalizePackagePath(combined);
+}
+function resolveInternalRelationshipTarget(sourcePartPath, relationship) {
+  if (relationship.targetMode === "External") return void 0;
+  return asPartPath(resolveRelationshipTarget(sourcePartPath, relationship.target));
+}
+function parseRelationshipTargetMode(value) {
+  if (value === "Internal" || value === "External") return value;
+  return void 0;
+}
+function joinPackageRelativeTarget(sourcePartPath, target) {
+  const slash = sourcePartPath.lastIndexOf("/");
+  const baseDir = slash === -1 ? "" : sourcePartPath.slice(0, slash);
+  return baseDir === "" ? target : `${baseDir}/${target}`;
+}
+function normalizePackagePath(path) {
+  const segments = [];
+  for (const segment of path.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  return segments.join("/");
+}
+
+// src/computed/relationships.ts
+function resolveComputedRelationships(source, sourcePartPath) {
+  const rels = source.packageGraph.relationships.find((entry) => entry.sourcePartPath === sourcePartPath)?.relationships ?? [];
+  return rels.map((relationship) => {
+    const external = relationship.targetMode === "External";
+    const target = external ? relationship.target : resolveRelationshipTarget(sourcePartPath, relationship.target);
+    const targetPartPath = external ? void 0 : asPartPath(target);
+    const media = targetPartPath !== void 0 ? findMedia(source.packageGraph.media, targetPartPath) : void 0;
+    return {
+      id: relationship.id,
+      type: relationship.type,
+      source: relationship,
+      target,
+      ...relationship.targetMode !== void 0 ? { targetMode: relationship.targetMode } : {},
+      ...targetPartPath !== void 0 ? { targetPartPath } : {},
+      ...media !== void 0 ? { media } : {}
+    };
+  });
+}
+function findMedia(media, partPath) {
+  return media.find((part) => part.partPath === partPath);
+}
+
+// src/computed/create-computed-view.ts
+var IMAGE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+var CHART_REL_TYPES = /* @__PURE__ */ new Set([
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart",
+  "http://purl.oclc.org/ooxml/officeDocument/relationships/chart"
+]);
+var DIAGRAM_DATA_REL_TYPES = /* @__PURE__ */ new Set([
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramData",
+  "http://purl.oclc.org/ooxml/officeDocument/relationships/diagramData"
+]);
+var DIAGRAM_DRAWING_REL_TYPES = /* @__PURE__ */ new Set([
+  "http://schemas.microsoft.com/office/2007/relationships/diagramDrawing",
+  "http://purl.oclc.org/ooxml/officeDocument/relationships/diagramDrawing"
+]);
+var textDecoder = new TextDecoder();
+var DEFAULT_TABLE_STYLE_BORDERS = {
+  top: {
+    width: asEmu(12700),
+    fill: { kind: "solid", color: { kind: "srgb", hex: "000000" } }
+  },
+  bottom: {
+    width: asEmu(12700),
+    fill: { kind: "solid", color: { kind: "srgb", hex: "000000" } }
+  },
+  left: {
+    width: asEmu(12700),
+    fill: { kind: "solid", color: { kind: "srgb", hex: "000000" } }
+  },
+  right: {
+    width: asEmu(12700),
+    fill: { kind: "solid", color: { kind: "srgb", hex: "000000" } }
+  }
+};
+function createComputedView(source, options = {}) {
+  const slidesByPath = new Map(source.slides.map((slide) => [slide.partPath, slide]));
+  const selectedSlideNumbers = options.slides !== void 0 ? new Set(options.slides) : void 0;
+  const slides = [];
+  source.presentation.slidePartPaths.forEach((partPath, index) => {
+    const slideNumber = index + 1;
+    if (selectedSlideNumbers !== void 0 && !selectedSlideNumbers.has(slideNumber)) return;
+    const slide = slidesByPath.get(partPath);
+    if (slide === void 0) return;
+    slides.push(computeSlide(source, slide, slideNumber, options));
+  });
+  return {
+    ...source.presentation.slideSize !== void 0 ? { slideSize: { ...source.presentation.slideSize } } : {},
+    slides
+  };
+}
+function computeSlide(source, slide, slideNumber, options) {
+  const layout = source.slideLayouts.find(
+    (candidate) => candidate.partPath === slide.layoutPartPath
+  );
+  const master = layout !== void 0 ? source.slideMasters.find((candidate) => candidate.partPath === layout.masterPartPath) : void 0;
+  const theme = master?.themePartPath !== void 0 ? source.themes.find((candidate) => candidate.partPath === master.themePartPath) : void 0;
+  const colorMap = buildEffectiveColorMap(
+    master?.colorMap,
+    layout?.colorMapOverride,
+    slide.colorMapOverride
+  );
+  const relationships = resolveComputedRelationships(source, slide.partPath);
+  const context = { source, layout, master, theme, colorMap, relationships };
+  const colorScheme = buildComputedColorScheme(context);
+  const layoutShowMasterShapes = layout?.showMasterShapes ?? true;
+  const showMasterShapes = slide.showMasterShapes ?? true;
+  const includeMaster = options.applyMasterVisibility === false ? true : showMasterShapes && layoutShowMasterShapes;
+  return {
+    slideNumber,
+    partPath: slide.partPath,
+    ...layout !== void 0 ? { layoutPartPath: layout.partPath } : {},
+    ...master !== void 0 ? { masterPartPath: master.partPath } : {},
+    ...theme?.partPath !== void 0 ? { themePartPath: theme.partPath } : {},
+    ...source.presentation.slideSize !== void 0 ? { slideSize: { ...source.presentation.slideSize } } : {},
+    relationships,
+    colorMap,
+    colorScheme,
+    ...computeBackground(context, slide, layout, master) ?? {},
+    showMasterShapes,
+    layoutShowMasterShapes,
+    elements: [
+      ...includeMaster && master !== void 0 ? computeTemplateElements(context, master.shapes, "master", master.partPath) : [],
+      ...layout !== void 0 ? computeTemplateElements(context, layout.shapes, "layout", layout.partPath) : [],
+      ...computeSlideElements(context, slide.shapes, slide.partPath)
+    ]
+  };
+}
+function computeBackground(context, slide, layout, master) {
+  const picked = slide.background !== void 0 ? { sourceLayer: "slide", partPath: slide.partPath, background: slide.background } : layout?.background !== void 0 ? {
+    sourceLayer: "layout",
+    partPath: layout.partPath,
+    background: layout.background
+  } : master?.background !== void 0 ? {
+    sourceLayer: "master",
+    partPath: master.partPath,
+    background: master.background
+  } : void 0;
+  if (picked === void 0) return void 0;
+  const { background, sourceLayer } = picked;
+  switch (background.kind) {
+    case "fill":
+      return {
+        background: {
+          kind: "fill",
+          source: background,
+          fill: computeFill(context, background.fill, picked.partPath),
+          sourceLayer
+        }
+      };
+    case "styleReference": {
+      const color = resolveColor(context, background.color);
+      return {
+        background: {
+          kind: "styleReference",
+          source: background,
+          index: background.index,
+          ...color !== void 0 ? { color } : {},
+          sourceLayer
+        }
+      };
+    }
+    case "raw":
+      return { background: { kind: "raw", source: background, sourceLayer } };
+  }
+}
+function computeTemplateElements(context, elements, layer, partPath) {
+  return elements.filter((element) => !(element.kind === "shape" && element.placeholder !== void 0)).map((element) => computeElement(context, element, layer, partPath));
+}
+function computeSlideElements(context, elements, partPath) {
+  return elements.filter((element) => !(element.kind === "shape" && isEmptyPlaceholder(element))).map((element) => computeElement(context, element, "slide", partPath));
+}
+function computeElement(context, element, layer, partPath) {
+  switch (element.kind) {
+    case "shape":
+      return computeShapeElement(context, element, layer, partPath);
+    case "connector":
+      return computeConnectorElement(context, element, layer, partPath);
+    case "group":
+      return computeGroupElement(context, element, layer, partPath);
+    case "image":
+      return computeImageElement(context, element, layer, partPath);
+    case "table":
+      return computeTableElement(context, element, layer, partPath);
+    case "chart":
+      return computeChartElement(context, element, layer, partPath);
+    case "smartArt":
+      return computeSmartArtElement(context, element, layer, partPath);
+    case "raw":
+      return { kind: "raw", sourceLayer: layer, sourcePartPath: partPath, sourceNode: element };
+  }
+}
+function computeConnectorElement(context, connector, layer, partPath) {
+  const effects = connector.effects !== void 0 ? computeEffectList(context, connector.effects) : connector.style?.effectRef !== void 0 ? resolveEffectReference(context, connector.style.effectRef) : void 0;
+  return {
+    kind: "connector",
+    sourceLayer: layer,
+    sourcePartPath: partPath,
+    sourceNode: connector,
+    ...connector.transform !== void 0 ? { transform: connector.transform } : {},
+    ...connector.geometry !== void 0 ? { geometry: connector.geometry } : {},
+    ...connector.outline !== void 0 ? { outline: computeOutline(context, connector.outline, partPath) } : connector.style?.lineRef !== void 0 ? { outline: resolveLineReference(context, connector.style.lineRef, partPath) } : {},
+    ...effects !== void 0 ? { effects } : {}
+  };
+}
+function computeGroupElement(context, group, layer, partPath) {
+  const fill = group.fill !== void 0 ? computeFill(context, group.fill, partPath) : void 0;
+  const effects = group.effects !== void 0 ? computeEffectList(context, group.effects) : void 0;
+  const childContext = fill !== void 0 ? { ...context, groupFill: fill } : context;
+  return {
+    kind: "group",
+    sourceLayer: layer,
+    sourcePartPath: partPath,
+    sourceNode: group,
+    ...group.transform !== void 0 ? { transform: group.transform } : {},
+    ...group.childTransform !== void 0 ? { childTransform: group.childTransform } : {},
+    ...fill !== void 0 ? { fill } : {},
+    ...effects !== void 0 ? { effects } : {},
+    children: group.children.map((child) => computeElement(childContext, child, layer, partPath))
+  };
+}
+function computeShapeElement(context, shape, layer, partPath) {
+  const match = layer === "slide" ? findPlaceholderMatch(
+    {
+      layoutShapes: context.layout?.shapes ?? [],
+      masterShapes: context.master?.shapes ?? []
+    },
+    shape
+  ) : void 0;
+  const placeholderType = shape.placeholder !== void 0 ? shape.placeholder.type ?? "body" : void 0;
+  const transform = firstDefined(
+    shape.transform,
+    match?.layout?.transform,
+    match?.master?.transform
+  );
+  const geometry = firstDefined(shape.geometry, match?.layout?.geometry, match?.master?.geometry);
+  const effects = shape.effects !== void 0 ? computeEffectList(context, shape.effects) : shape.style?.effectRef !== void 0 ? resolveEffectReference(context, shape.style.effectRef) : void 0;
+  return {
+    kind: "shape",
+    sourceLayer: layer,
+    sourcePartPath: partPath,
+    sourceNode: shape,
+    ...transform !== void 0 ? { transform } : {},
+    ...geometry !== void 0 ? { geometry } : {},
+    ...shape.fill !== void 0 ? { fill: computeFill(context, shape.fill, partPath) } : shape.style?.fillRef !== void 0 ? { fill: resolveFillReference(context, shape.style.fillRef, partPath) } : {},
+    ...shape.outline !== void 0 ? { outline: computeOutline(context, shape.outline, partPath) } : shape.style?.lineRef !== void 0 ? { outline: resolveLineReference(context, shape.style.lineRef, partPath) } : {},
+    ...effects !== void 0 ? { effects } : {},
+    ...shape.textBody !== void 0 ? {
+      textBody: computeTextBody(
+        context,
+        shape.textBody,
+        [match?.layout?.textBody, match?.master?.textBody],
+        placeholderType
+      )
+    } : {},
+    ...match !== void 0 ? { placeholderMatch: match } : {}
+  };
+}
+function computeImageElement(context, image, layer, partPath) {
+  const relationship = resolveComputedRelationships(context.source, partPath).find(
+    (rel) => rel.id === image.blipRelationshipId && rel.type === IMAGE_REL_TYPE
+  );
+  const effects = image.effects !== void 0 ? computeEffectList(context, image.effects) : void 0;
+  const blipEffects = image.blipEffects !== void 0 ? computeBlipEffects(context, image.blipEffects) : void 0;
+  return {
+    kind: "image",
+    sourceLayer: layer,
+    sourcePartPath: partPath,
+    sourceNode: image,
+    ...image.transform !== void 0 ? { transform: image.transform } : {},
+    ...relationship !== void 0 ? { relationship } : {},
+    ...relationship?.media !== void 0 ? { media: relationship.media } : {},
+    ...effects !== void 0 ? { effects } : {},
+    ...blipEffects !== void 0 ? { blipEffects } : {}
+  };
+}
+function computeTableElement(context, table, layer, partPath) {
+  return {
+    kind: "table",
+    sourceLayer: layer,
+    sourcePartPath: partPath,
+    sourceNode: table,
+    ...table.transform !== void 0 ? { transform: table.transform } : {},
+    table: {
+      columns: table.table.columns.map((column) => ({ ...column })),
+      rows: table.table.rows.map((row) => computeTableRow(context, table, row, partPath))
+    }
+  };
+}
+function computeChartElement(context, chart, layer, partPath) {
+  const relationship = context.relationships.find(
+    (rel) => rel.id === chart.chartRelationshipId && CHART_REL_TYPES.has(rel.type)
+  );
+  const chartXml = relationship?.targetPartPath !== void 0 ? readRawPackageText(context.source, relationship.targetPartPath) : void 0;
+  const chartData = chartXml !== void 0 ? parseComputedChartData(chartXml, context) : void 0;
+  return {
+    kind: "chart",
+    sourceLayer: layer,
+    sourcePartPath: partPath,
+    sourceNode: chart,
+    ...chart.transform !== void 0 ? { transform: chart.transform } : {},
+    ...relationship !== void 0 ? { relationship } : {},
+    ...chartXml !== void 0 ? { chartXml } : {},
+    ...chartData !== void 0 ? { chartData } : {}
+  };
+}
+function computeSmartArtElement(context, smartArt, layer, partPath) {
+  const dataRelationship = context.relationships.find(
+    (rel) => rel.id === smartArt.dataRelationshipId && DIAGRAM_DATA_REL_TYPES.has(rel.type)
+  );
+  const dataRelationships = dataRelationship?.targetPartPath !== void 0 ? resolveComputedRelationships(context.source, dataRelationship.targetPartPath) : [];
+  const drawingRelationship = dataRelationships.find(
+    (rel) => DIAGRAM_DRAWING_REL_TYPES.has(rel.type)
+  );
+  const drawingPartPath = drawingRelationship?.targetPartPath;
+  const drawingXml = drawingPartPath !== void 0 ? readRawPackageText(context.source, drawingPartPath) : void 0;
+  const drawingRelationships = drawingPartPath !== void 0 ? resolveComputedRelationships(context.source, drawingPartPath) : [];
+  const diagramDrawing = drawingPartPath !== void 0 && drawingXml !== void 0 ? computeDiagramDrawing(context, drawingPartPath, drawingXml, drawingRelationships, layer) : void 0;
+  return {
+    kind: "smartArt",
+    sourceLayer: layer,
+    sourcePartPath: partPath,
+    sourceNode: smartArt,
+    ...smartArt.transform !== void 0 ? { transform: smartArt.transform } : {},
+    ...dataRelationship !== void 0 ? { dataRelationship } : {},
+    ...drawingRelationship !== void 0 ? { drawingRelationship } : {},
+    ...drawingPartPath !== void 0 ? { drawingPartPath } : {},
+    ...drawingXml !== void 0 ? { drawingXml } : {},
+    drawingRelationships,
+    media: context.source.packageGraph.media,
+    ...diagramDrawing !== void 0 ? { diagramDrawing } : {}
+  };
+}
+function computeDiagramDrawing(context, drawingPartPath, drawingXml, drawingRelationships, layer) {
+  const rawPart = context.source.packageGraph.rawParts?.find(
+    (part) => part.partPath === drawingPartPath
+  );
+  const parsed = parseXml(drawingXml);
+  const drawing = getChild(parsed, "drawing");
+  const spTree = getChild(drawing, "spTree");
+  const diagnostics = [];
+  if (spTree === void 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "diagram-drawing-shape-tree-missing",
+      message: `diagram drawing part '${drawingPartPath}' has no shape tree`,
+      sourcePartPath: drawingPartPath
+    });
+  }
+  const orderedSpTree = spTree !== void 0 ? navigateOrdered(parseXmlOrdered(drawingXml), ["drawing", "spTree"]) : void 0;
+  const sourceChildren = spTree !== void 0 ? parseShapeTree(
+    spTree,
+    drawingPartPath,
+    createSidecarIdFactory(drawingPartPath),
+    orderedSpTree
+  ) : [];
+  const diagramContext = {
+    ...context,
+    relationships: drawingRelationships
+  };
+  return {
+    sourcePartPath: drawingPartPath,
+    rawXml: drawingXml,
+    ...rawPart !== void 0 ? { rawPart } : {},
+    rawHandle: { partPath: drawingPartPath },
+    relationships: drawingRelationships,
+    media: context.source.packageGraph.media,
+    ...spTree !== void 0 ? { childTransform: parseDiagramChildTransform(spTree) } : {},
+    children: sourceChildren.map(
+      (child) => computeElement(diagramContext, child, layer, drawingPartPath)
+    ),
+    diagnostics
+  };
+}
+function parseDiagramChildTransform(spTree) {
+  const groupProperties = getChild(spTree, "grpSpPr");
+  const fallback = parseTransform(groupProperties);
+  const xfrm = getChild(groupProperties, "xfrm");
+  const childOff = getChild(xfrm, "chOff");
+  const childExt = getChild(xfrm, "chExt");
+  const offsetX = numericAttr3(childOff, "x") ?? 0;
+  const offsetY = numericAttr3(childOff, "y") ?? 0;
+  const width = numericAttr3(childExt, "cx") ?? fallback?.width;
+  const height = numericAttr3(childExt, "cy") ?? fallback?.height;
+  if (width === void 0 || height === void 0) return void 0;
+  return {
+    offsetX: asEmu(offsetX),
+    offsetY: asEmu(offsetY),
+    width: asEmu(width),
+    height: asEmu(height)
+  };
+}
+function computeTableRow(context, table, row, partPath) {
+  return {
+    source: row,
+    height: row.height,
+    cells: row.cells.map((cell) => computeTableCell(context, table, cell, partPath))
+  };
+}
+function computeTableCell(context, table, cell, partPath) {
+  const borders = cell.borders !== void 0 ? computeCellBorders(context, cell.borders, partPath) : table.table.tableStyleId !== void 0 ? computeCellBorders(context, DEFAULT_TABLE_STYLE_BORDERS, partPath) : void 0;
+  return {
+    source: cell,
+    ...cell.textBody !== void 0 ? { textBody: computeTextBody(context, cell.textBody, [], void 0, false) } : {},
+    ...cell.fill !== void 0 ? { fill: computeFill(context, cell.fill, partPath) } : {},
+    ...borders !== void 0 ? { borders } : {},
+    gridSpan: cell.gridSpan,
+    rowSpan: cell.rowSpan,
+    hMerge: cell.hMerge,
+    vMerge: cell.vMerge
+  };
+}
+function computeCellBorders(context, borders, partPath) {
+  const computed = {
+    ...borders.top !== void 0 ? { top: computeOutline(context, borders.top, partPath) } : {},
+    ...borders.bottom !== void 0 ? { bottom: computeOutline(context, borders.bottom, partPath) } : {},
+    ...borders.left !== void 0 ? { left: computeOutline(context, borders.left, partPath) } : {},
+    ...borders.right !== void 0 ? { right: computeOutline(context, borders.right, partPath) } : {}
+  };
+  return Object.keys(computed).length > 0 ? computed : void 0;
+}
+function computeFill(context, fill, partPath) {
+  switch (fill.kind) {
+    case "none":
+      return { kind: "none", source: fill };
+    case "raw":
+      if (localName(fill.raw.node.name) === "grpFill" && context.groupFill !== void 0) {
+        return context.groupFill;
+      }
+      return { kind: "raw", source: fill };
+    case "gradient":
+      return {
+        kind: "gradient",
+        source: fill,
+        stops: fill.stops.map((stop) => ({
+          position: stop.position,
+          color: resolveColor(context, stop.color) ?? { hex: "#000000", alpha: 1 }
+        })),
+        gradientType: fill.gradientType,
+        ...fill.gradientType === "linear" ? { angle: Number(fill.angle) / 6e4 } : {},
+        ...fill.gradientType === "radial" ? { centerX: fill.centerX, centerY: fill.centerY } : {}
+      };
+    case "pattern":
+      return {
+        kind: "pattern",
+        source: fill,
+        preset: fill.preset,
+        foregroundColor: resolveColor(context, fill.foregroundColor) ?? {
+          hex: "#000000",
+          alpha: 1
+        },
+        backgroundColor: resolveColor(context, fill.backgroundColor) ?? {
+          hex: "#ffffff",
+          alpha: 1
+        }
+      };
+    case "image": {
+      const relationship = resolveComputedRelationships(context.source, partPath).find(
+        (rel) => rel.id === fill.blipRelationshipId && rel.type === IMAGE_REL_TYPE
+      );
+      return {
+        kind: "image",
+        source: fill,
+        ...relationship !== void 0 ? { relationship } : {},
+        ...relationship?.media !== void 0 ? { media: relationship.media } : {},
+        ...fill.tile !== void 0 ? { tile: fill.tile } : {}
+      };
+    }
+    case "solid":
+      return {
+        kind: "solid",
+        source: fill,
+        color: resolveColor(context, fill.color) ?? { hex: "#000000", alpha: 1 }
+      };
+  }
+}
+function computeOutline(context, outline, partPath) {
+  return {
+    source: outline,
+    ...outline.width !== void 0 ? { width: outline.width } : {},
+    ...outline.fill !== void 0 ? { fill: computeFill(context, outline.fill, partPath) } : {}
+  };
+}
+function resolveFillReference(context, ref, partPath) {
+  if (ref.index === 0) return void 0;
+  const list = ref.index >= 1e3 ? context.theme?.formatScheme?.backgroundFillStyles : context.theme?.formatScheme?.fillStyles;
+  const arrayIndex = ref.index >= 1e3 ? ref.index - 1001 : ref.index - 1;
+  const template = list?.[arrayIndex];
+  if (template === void 0) return void 0;
+  const computed = computeFill(context, template, context.theme?.partPath ?? partPath);
+  const overrideColor = ref.color !== void 0 ? resolveColor(context, ref.color) : void 0;
+  if (overrideColor === void 0) return computed;
+  if (computed.kind === "solid") {
+    return { ...computed, color: overrideColor };
+  }
+  if (computed.kind === "gradient") {
+    return {
+      ...computed,
+      stops: computed.stops.map((stop) => ({ ...stop, color: overrideColor }))
+    };
+  }
+  return computed;
+}
+function resolveLineReference(context, ref, partPath) {
+  if (ref.index === 0) return void 0;
+  const template = context.theme?.formatScheme?.lineStyles[ref.index - 1];
+  if (template === void 0) return void 0;
+  const computed = computeOutline(context, template, context.theme?.partPath ?? partPath);
+  const overrideSourceColor = ref.color;
+  if (overrideSourceColor === void 0) return computed;
+  const overrideColor = resolveColor(context, overrideSourceColor);
+  if (overrideColor === void 0) return computed;
+  return {
+    ...computed,
+    fill: {
+      kind: "solid",
+      source: { kind: "solid", color: overrideSourceColor },
+      color: overrideColor
+    }
+  };
+}
+function resolveEffectReference(context, ref) {
+  const template = context.theme?.formatScheme?.effectStyles[ref.index];
+  return template !== void 0 ? computeEffectList(context, template) : void 0;
+}
+function computeEffectList(context, source) {
+  const outerShadowColor = source.outerShadow !== void 0 ? resolveColor(context, source.outerShadow.color) : void 0;
+  const innerShadowColor = source.innerShadow !== void 0 ? resolveColor(context, source.innerShadow.color) : void 0;
+  const glowColor = source.glow !== void 0 ? resolveColor(context, source.glow.color) : void 0;
+  const computed = {
+    source,
+    ...source.outerShadow !== void 0 && outerShadowColor !== void 0 ? {
+      outerShadow: {
+        blurRadius: source.outerShadow.blurRadius,
+        distance: source.outerShadow.distance,
+        direction: Number(source.outerShadow.direction) / 6e4,
+        color: outerShadowColor,
+        alignment: source.outerShadow.alignment,
+        rotateWithShape: source.outerShadow.rotateWithShape
+      }
+    } : {},
+    ...source.innerShadow !== void 0 && innerShadowColor !== void 0 ? {
+      innerShadow: {
+        blurRadius: source.innerShadow.blurRadius,
+        distance: source.innerShadow.distance,
+        direction: Number(source.innerShadow.direction) / 6e4,
+        color: innerShadowColor
+      }
+    } : {},
+    ...source.glow !== void 0 && glowColor !== void 0 ? {
+      glow: {
+        radius: source.glow.radius,
+        color: glowColor
+      }
+    } : {},
+    ...source.softEdge !== void 0 ? { softEdge: source.softEdge } : {}
+  };
+  return computed.outerShadow !== void 0 || computed.innerShadow !== void 0 || computed.glow !== void 0 || computed.softEdge !== void 0 ? computed : void 0;
+}
+function computeBlipEffects(context, source) {
+  const duotoneColor1 = source.duotone !== void 0 ? resolveColor(context, source.duotone.color1) : void 0;
+  const duotoneColor2 = source.duotone !== void 0 ? resolveColor(context, source.duotone.color2) : void 0;
+  const clrChangeFrom = source.clrChange !== void 0 ? resolveColor(context, source.clrChange.from) : void 0;
+  const clrChangeTo = source.clrChange !== void 0 ? resolveColor(context, source.clrChange.to) : void 0;
+  const computed = {
+    source,
+    grayscale: source.grayscale,
+    ...source.biLevel !== void 0 ? { biLevel: source.biLevel } : {},
+    ...source.blur !== void 0 ? { blur: source.blur } : {},
+    ...source.lum !== void 0 ? { lum: source.lum } : {},
+    ...duotoneColor1 !== void 0 && duotoneColor2 !== void 0 ? { duotone: { color1: duotoneColor1, color2: duotoneColor2 } } : {},
+    ...clrChangeFrom !== void 0 && clrChangeTo !== void 0 ? { clrChange: { from: clrChangeFrom, to: clrChangeTo } } : {}
+  };
+  return computed.grayscale || computed.biLevel !== void 0 || computed.blur !== void 0 || computed.lum !== void 0 || computed.duotone !== void 0 || computed.clrChange !== void 0 ? computed : void 0;
+}
+function computeTextBody(context, textBody, inheritedBodies = [], placeholderType, includeInheritedStyleChain = true) {
+  const styleChain = buildTextStyleChain(
+    context,
+    textBody,
+    inheritedBodies,
+    placeholderType,
+    includeInheritedStyleChain
+  );
+  const properties = mergeTextBodyProperties(void 0, textBody.properties);
+  return {
+    ...properties !== void 0 ? { properties } : {},
+    paragraphs: textBody.paragraphs.map(
+      (paragraph) => computeParagraph(context, paragraph, styleChain)
+    )
+  };
+}
+function mergeTextBodyProperties(inherited, local) {
+  const merged = { ...inherited, ...local };
+  if (Object.keys(merged).length === 0) return void 0;
+  if (merged.autoFit === "normAutofit") {
+    return {
+      ...merged,
+      fontScale: merged.fontScale ?? 1,
+      lnSpcReduction: merged.lnSpcReduction ?? 0
+    };
+  }
+  if (merged.autoFit === "spAutofit" || merged.autoFit === "noAutofit") {
+    return {
+      ...merged,
+      fontScale: 1,
+      lnSpcReduction: 0
+    };
+  }
+  return merged;
+}
+function computeParagraph(context, paragraph, styleChain) {
+  const level = paragraph.properties?.level ?? 0;
+  const styleLevelProperties = styleChain.map((entry) => ({
+    properties: textStyleLevelProperties(entry.style, level),
+    includeRunDecorations: entry.includeRunDecorations
+  }));
+  const properties = computeParagraphProperties(
+    context,
+    paragraph.properties,
+    styleLevelProperties.map((entry) => entry.properties)
+  );
+  return {
+    ...properties !== void 0 ? { properties } : {},
+    runs: paragraph.runs.map((run) => {
+      const runProperties = mergeRunProperties(context, run.properties, [
+        {
+          properties: paragraph.properties?.defaultRunProperties,
+          includeDecorations: true
+        },
+        ...styleLevelProperties.map((entry) => ({
+          properties: entry.properties?.defaultRunProperties,
+          includeDecorations: entry.includeRunDecorations
+        }))
+      ]);
+      return {
+        text: run.text,
+        ...runProperties !== void 0 ? { properties: runProperties } : {}
+      };
+    })
+  };
+}
+function buildTextStyleChain(context, textBody, inheritedBodies, placeholderType, includeInheritedStyleChain) {
+  return [
+    ...textBody.listStyle !== void 0 ? [{ style: textBody.listStyle, includeRunDecorations: true }] : [],
+    ...includeInheritedStyleChain ? [
+      ...inheritedBodies.flatMap(
+        (body) => body?.listStyle !== void 0 ? [{ style: body.listStyle, includeRunDecorations: false }] : []
+      ),
+      ...styleEntry(getTxStyleForPlaceholder(context.master?.txStyles, placeholderType)),
+      ...styleEntry(context.source.presentation.defaultTextStyle)
+    ] : []
+  ];
+}
+function getTxStyleForPlaceholder(txStyles, placeholderType) {
+  if (txStyles === void 0) return void 0;
+  if (placeholderType === void 0) return txStyles.otherStyle;
+  if (placeholderType === "title" || placeholderType === "ctrTitle") return txStyles.titleStyle;
+  if (placeholderType === "body" || placeholderType === "subTitle" || placeholderType === "obj") {
+    return txStyles.bodyStyle;
+  }
+  return txStyles.otherStyle;
+}
+function textStyleLevelProperties(style, level) {
+  return style.levels[level] ?? style.defaultParagraph;
+}
+function computeParagraphProperties(context, local, inherited) {
+  const resolvedBulletColor = firstDefined(
+    local?.bulletColor !== void 0 ? resolveColor(context, local.bulletColor) : void 0,
+    ...inherited.map(
+      (properties) => properties?.bulletColor !== void 0 ? resolveColor(context, properties.bulletColor) : void 0
+    )
+  );
+  const merged = {
+    ...local?.align !== void 0 ? { align: local.align } : { align: pickInheritedValue(inherited, "align") ?? "left" },
+    ...local?.level !== void 0 ? { level: local.level } : { level: 0 },
+    ...local?.lineSpacing !== void 0 ? { lineSpacing: local.lineSpacing } : {},
+    ...local?.spaceBefore !== void 0 ? { spaceBefore: local.spaceBefore } : {},
+    ...local?.spaceAfter !== void 0 ? { spaceAfter: local.spaceAfter } : {},
+    ...local?.marginLeft !== void 0 ? { marginLeft: local.marginLeft } : pickInherited(inherited, "marginLeft"),
+    ...local?.indent !== void 0 ? { indent: local.indent } : pickInherited(inherited, "indent"),
+    ...local?.bullet !== void 0 ? { bullet: local.bullet } : pickInherited(inherited, "bullet"),
+    ...local?.bulletFont !== void 0 ? { bulletFont: local.bulletFont } : pickInherited(inherited, "bulletFont"),
+    ...resolvedBulletColor !== void 0 ? { bulletColor: resolvedBulletColor } : {},
+    ...local?.bulletSizePct !== void 0 ? { bulletSizePct: local.bulletSizePct } : pickInherited(inherited, "bulletSizePct"),
+    ...local?.tabStops !== void 0 ? { tabStops: local.tabStops } : {}
+  };
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function mergeRunProperties(context, local, inherited) {
+  const merged = { ...local };
+  for (const defaults of inherited) {
+    if (defaults.properties === void 0) continue;
+    mergeDefaultRunProperties(merged, defaults.properties, defaults.includeDecorations);
+  }
+  if (Object.keys(merged).length === 0) return void 0;
+  const color = merged.color !== void 0 ? resolveColor(context, merged.color) : void 0;
+  const withoutColor = resolveThemeRunFonts(context, omitColor(merged));
+  return {
+    ...withoutColor,
+    ...color !== void 0 ? { color } : {}
+  };
+}
+function styleEntry(style) {
+  return style !== void 0 ? [{ style, includeRunDecorations: false }] : [];
+}
+function mergeDefaultRunProperties(target, defaults, includeDecorations) {
+  if (includeDecorations) {
+    target.bold ??= defaults.bold;
+    target.italic ??= defaults.italic;
+    target.underline ??= defaults.underline;
+    target.strikethrough ??= defaults.strikethrough;
+    target.baseline ??= defaults.baseline;
+  }
+  target.fontSize ??= defaults.fontSize;
+  target.typeface ??= defaults.typeface;
+  target.typefaceEa ??= defaults.typefaceEa;
+  target.typefaceCs ??= defaults.typefaceCs;
+  target.color ??= defaults.color;
+}
+function pickInherited(inherited, key) {
+  const value = pickInheritedValue(inherited, key);
+  const picked = {};
+  if (value !== void 0) {
+    picked[key] = value;
+  }
+  return picked;
+}
+function pickInheritedValue(inherited, key) {
+  const value = inherited.find((properties) => properties?.[key] !== void 0)?.[key];
+  return value;
+}
+function resolveThemeRunFonts(context, properties) {
+  return {
+    ...properties,
+    ...properties.typeface !== void 0 ? { typeface: resolveThemeTypeface(context, properties.typeface) } : {},
+    ...properties.typefaceEa !== void 0 ? { typefaceEa: resolveThemeTypeface(context, properties.typefaceEa) } : {},
+    ...properties.typefaceCs !== void 0 ? { typefaceCs: resolveThemeTypeface(context, properties.typefaceCs) } : {}
+  };
+}
+function resolveThemeTypeface(context, typeface) {
+  const scheme = context.theme?.fontScheme;
+  if (scheme === void 0) return typeface;
+  switch (typeface) {
+    case "+mj-lt":
+      return scheme.majorLatin ?? typeface;
+    case "+mn-lt":
+      return scheme.minorLatin ?? typeface;
+    case "+mj-ea":
+      return scheme.majorEastAsian ?? scheme.majorJapanese ?? typeface;
+    case "+mn-ea":
+      return scheme.minorEastAsian ?? scheme.minorJapanese ?? typeface;
+    case "+mj-cs":
+      return scheme.majorComplexScript ?? typeface;
+    case "+mn-cs":
+      return scheme.minorComplexScript ?? typeface;
+    default:
+      return typeface;
+  }
+}
+function isEmptyPlaceholder(shape) {
+  if (shape.placeholder === void 0) return false;
+  const paragraphs = shape.textBody?.paragraphs;
+  if (paragraphs === void 0 || paragraphs.length === 0) return true;
+  return !paragraphs.some((paragraph) => paragraph.runs.some((run) => run.text.length > 0));
+}
+function readRawPackageText(source, partPath) {
+  const rawPart = source.packageGraph.rawParts?.find((part) => part.partPath === partPath);
+  if (rawPart?.kind === "binary") return textDecoder.decode(rawPart.bytes);
+  return void 0;
+}
+function numericAttr3(node, attrName) {
+  if (node === void 0) return void 0;
+  const value = node[`@_${attrName}`];
+  if (value === void 0 || value === null) return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function omitColor(properties) {
+  const withoutColor = { ...properties };
+  delete withoutColor.color;
+  return withoutColor;
+}
+function firstDefined(...values) {
+  return values.find((value) => value !== void 0);
+}
+
+// src/reader/read-pptx.ts
+var import_fflate = require("fflate");
+
+// src/reader/slide-parts.ts
+var THEME_COLOR_SLOTS = [
+  "dk1",
+  "lt1",
+  "dk2",
+  "lt2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink"
+];
+var FILL_LOCAL_NAMES = /* @__PURE__ */ new Set([
+  "solidFill",
+  "gradFill",
+  "pattFill",
+  "blipFill",
+  "noFill"
+]);
+function parseSlide(root, partPath, layoutPartPath, nextId, orderedSpTree) {
+  const cSld = getChild(root, "cSld");
+  const background = parseBackground(getChild(cSld, "bg"), nextId);
+  const colorMapOverride = parseColorMapOverride(getChild(root, "clrMapOvr"));
+  const showMasterShapes = booleanAttr(root, "showMasterSp");
+  return {
+    partPath,
+    layoutPartPath,
+    ...background !== void 0 ? { background } : {},
+    ...colorMapOverride !== void 0 ? { colorMapOverride } : {},
+    ...showMasterShapes !== void 0 ? { showMasterShapes } : {},
+    shapes: parseShapeTree(getChild(cSld, "spTree"), partPath, nextId, orderedSpTree),
+    handle: { partPath }
+  };
+}
+function parseSlideLayout(root, partPath, masterPartPath, nextId, orderedSpTree) {
+  const cSld = getChild(root, "cSld");
+  const type = getAttr(root, "type");
+  const background = parseBackground(getChild(cSld, "bg"), nextId);
+  const colorMapOverride = parseColorMapOverride(getChild(root, "clrMapOvr"));
+  const showMasterShapes = booleanAttr(root, "showMasterSp");
+  return {
+    partPath,
+    masterPartPath,
+    ...type !== void 0 ? { type } : {},
+    ...background !== void 0 ? { background } : {},
+    ...colorMapOverride !== void 0 ? { colorMapOverride } : {},
+    ...showMasterShapes !== void 0 ? { showMasterShapes } : {},
+    shapes: parseShapeTree(getChild(cSld, "spTree"), partPath, nextId, orderedSpTree),
+    handle: { partPath }
+  };
+}
+function parseSlideMaster(root, partPath, themePartPath, layoutPartPaths, nextId, orderedSpTree) {
+  const cSld = getChild(root, "cSld");
+  const background = parseBackground(getChild(cSld, "bg"), nextId);
+  const colorMap = parseColorMap(getChild(root, "clrMap"));
+  const txStyles = parseMasterTextStyles(getChild(root, "txStyles"));
+  return {
+    partPath,
+    ...themePartPath !== void 0 ? { themePartPath } : {},
+    layoutPartPaths,
+    ...background !== void 0 ? { background } : {},
+    ...colorMap !== void 0 ? { colorMap } : {},
+    ...txStyles !== void 0 ? { txStyles } : {},
+    shapes: parseShapeTree(getChild(cSld, "spTree"), partPath, nextId, orderedSpTree),
+    handle: { partPath }
+  };
+}
+function parseMasterTextStyles(txStyles) {
+  if (txStyles === void 0) return void 0;
+  const titleStyle = parseTextStyle(getChild(txStyles, "titleStyle"));
+  const bodyStyle = parseTextStyle(getChild(txStyles, "bodyStyle"));
+  const otherStyle = parseTextStyle(getChild(txStyles, "otherStyle"));
+  const parsed = {
+    ...titleStyle !== void 0 ? { titleStyle } : {},
+    ...bodyStyle !== void 0 ? { bodyStyle } : {},
+    ...otherStyle !== void 0 ? { otherStyle } : {}
+  };
+  return Object.keys(parsed).length > 0 ? parsed : void 0;
+}
+function parseTheme(root, partPath, nextId, orderedRoot) {
+  const name = getAttr(root, "name");
+  const themeElements = getChild(root, "themeElements");
+  const colorScheme = parseColorScheme(getChild(themeElements, "clrScheme"));
+  const fontScheme = parseFontScheme(getChild(themeElements, "fontScheme"));
+  const formatScheme = parseFormatScheme(getChild(themeElements, "fmtScheme"), nextId, orderedRoot);
+  return {
+    partPath,
+    ...name !== void 0 ? { name } : {},
+    ...colorScheme !== void 0 ? { colorScheme } : {},
+    ...fontScheme !== void 0 ? { fontScheme } : {},
+    ...formatScheme !== void 0 ? { formatScheme } : {},
+    handle: { partPath }
+  };
+}
+function parseBackground(bg, nextId) {
+  if (!bg) return void 0;
+  const bgPr = getChild(bg, "bgPr");
+  if (bgPr) {
+    const fill = parseFill(bgPr, nextId);
+    if (fill !== void 0) return { kind: "fill", fill };
+    return { kind: "raw", raw: makeSidecar("p:bg", bg, nextId) };
+  }
+  const bgRef = getChild(bg, "bgRef");
+  if (bgRef) {
+    const color = parseColorElement(bgRef);
+    const index = numericAttr(bgRef, "idx");
+    if (color !== void 0) {
+      return { kind: "styleReference", index: index ?? 0, color };
+    }
+  }
+  return { kind: "raw", raw: makeSidecar("p:bg", bg, nextId) };
+}
+function parseColorMap(clrMap) {
+  if (!clrMap) return void 0;
+  const mapping = getAttrs(clrMap);
+  return Object.keys(mapping).length > 0 ? { mapping } : void 0;
+}
+function parseColorMapOverride(clrMapOvr) {
+  if (!clrMapOvr) return void 0;
+  const override = getChild(clrMapOvr, "overrideClrMapping");
+  if (!override) return void 0;
+  const mapping = getAttrs(override);
+  return Object.keys(mapping).length > 0 ? { mapping } : void 0;
+}
+function parseColorScheme(clrScheme) {
+  if (!clrScheme) return void 0;
+  const colors = {};
+  for (const slot of THEME_COLOR_SLOTS) {
+    const color = parseColorElement(getChild(clrScheme, slot));
+    if (color !== void 0) colors[slot] = color;
+  }
+  return Object.keys(colors).length > 0 ? { colors } : void 0;
+}
+function parseFontScheme(fontScheme) {
+  if (!fontScheme) return void 0;
+  const majorFont = getChild(fontScheme, "majorFont");
+  const minorFont = getChild(fontScheme, "minorFont");
+  const majorLatin = getAttr(getChild(majorFont, "latin"), "typeface");
+  const minorLatin = getAttr(getChild(minorFont, "latin"), "typeface");
+  const majorEastAsian = resolveEastAsianFont(majorFont);
+  const minorEastAsian = resolveEastAsianFont(minorFont);
+  const majorComplexScript = getAttr(getChild(majorFont, "cs"), "typeface");
+  const minorComplexScript = getAttr(getChild(minorFont, "cs"), "typeface");
+  const majorJapanese = findScriptFont(majorFont, "Jpan");
+  const minorJapanese = findScriptFont(minorFont, "Jpan");
+  const scheme = {
+    ...isNonEmpty(majorLatin) ? { majorLatin } : {},
+    ...isNonEmpty(minorLatin) ? { minorLatin } : {},
+    ...isNonEmpty(majorEastAsian) ? { majorEastAsian } : {},
+    ...isNonEmpty(minorEastAsian) ? { minorEastAsian } : {},
+    // Preserve explicit empty complex script fonts so scheme references can
+    // resolve distinctly from missing values.
+    ...majorComplexScript !== void 0 ? { majorComplexScript } : {},
+    ...minorComplexScript !== void 0 ? { minorComplexScript } : {},
+    ...isNonEmpty(majorJapanese) ? { majorJapanese } : {},
+    ...isNonEmpty(minorJapanese) ? { minorJapanese } : {}
+  };
+  return Object.keys(scheme).length > 0 ? scheme : void 0;
+}
+function resolveEastAsianFont(fontNode) {
+  const typeface = getAttr(getChild(fontNode, "ea"), "typeface");
+  return isNonEmpty(typeface) ? typeface : findScriptFont(fontNode, "Jpan");
+}
+function findScriptFont(fontNode, script) {
+  const font = getChildArray(fontNode, "font").find(
+    (candidate) => getAttr(candidate, "script") === script
+  );
+  return getAttr(font, "typeface");
+}
+function parseFormatScheme(fmtScheme, nextId, orderedRoot) {
+  if (fmtScheme === void 0) return void 0;
+  const orderedFmtScheme = orderedRoot !== void 0 ? navigateOrdered(orderedRoot, ["themeElements", "fmtScheme"]) : [];
+  const fillStyles = parseFillStyleList(
+    getChild(fmtScheme, "fillStyleLst"),
+    orderedFmtScheme,
+    "fillStyleLst",
+    nextId
+  );
+  const backgroundFillStyles = parseFillStyleList(
+    getChild(fmtScheme, "bgFillStyleLst"),
+    orderedFmtScheme,
+    "bgFillStyleLst",
+    nextId
+  );
+  const lineStyles = getChildArray(getChild(fmtScheme, "lnStyleLst"), "ln").flatMap((ln) => {
+    const line = parseLine(ln, nextId);
+    return line !== void 0 ? [line] : [];
+  });
+  const effectStyles = getChildArray(getChild(fmtScheme, "effectStyleLst"), "effectStyle").map(
+    (effectStyle) => parseEffectList2(getChild(effectStyle, "effectLst"))
+  );
+  if (fillStyles.length === 0 && backgroundFillStyles.length === 0 && lineStyles.length === 0 && effectStyles.length === 0) {
+    return void 0;
+  }
+  return { fillStyles, lineStyles, effectStyles, backgroundFillStyles };
+}
+function parseFillStyleList(list, orderedFmtScheme, listName, nextId) {
+  if (list === void 0) return [];
+  const orderedList = orderedFmtScheme?.find((node) => listName in node)?.[listName];
+  if (!Array.isArray(orderedList)) return [];
+  const orderedItems = orderedList;
+  const fills = [];
+  const tagCounters = {};
+  for (const orderedChild of orderedItems) {
+    const qualifiedName = Object.keys(orderedChild).find((key) => FILL_LOCAL_NAMES.has(key));
+    if (qualifiedName === void 0) continue;
+    const name = localName(qualifiedName);
+    const index = tagCounters[name] ?? 0;
+    tagCounters[name] = index + 1;
+    const values = getChildArray(list, name);
+    const value = values[index];
+    if (value === void 0) continue;
+    const fill = parseFill({ [qualifiedName]: value }, nextId);
+    if (fill !== void 0) fills.push(fill);
+  }
+  return fills;
+}
+function parseEffectList2(effectList) {
+  if (effectList === void 0) return void 0;
+  const outerShadow = parseOuterShadow2(getChild(effectList, "outerShdw"));
+  const innerShadow = parseInnerShadow2(getChild(effectList, "innerShdw"));
+  const glow = parseGlow2(getChild(effectList, "glow"));
+  const softEdge = parseSoftEdge2(getChild(effectList, "softEdge"));
+  const parsed = {
+    ...outerShadow !== void 0 ? { outerShadow } : {},
+    ...innerShadow !== void 0 ? { innerShadow } : {},
+    ...glow !== void 0 ? { glow } : {},
+    ...softEdge !== void 0 ? { softEdge } : {}
+  };
+  return Object.keys(parsed).length > 0 ? parsed : void 0;
+}
+function parseOuterShadow2(node) {
+  const color = parseColorElement(node);
+  if (node === void 0 || color === void 0) return void 0;
+  return {
+    blurRadius: asEmu(numericAttr(node, "blurRad") ?? 0),
+    distance: asEmu(numericAttr(node, "dist") ?? 0),
+    direction: asOoxmlAngle(numericAttr(node, "dir") ?? 0),
+    color,
+    alignment: parseRectangleAlignment(getAttr(node, "algn"), "b"),
+    rotateWithShape: getAttr(node, "rotWithShape") !== "0"
+  };
+}
+function parseInnerShadow2(node) {
+  const color = parseColorElement(node);
+  if (node === void 0 || color === void 0) return void 0;
+  return {
+    blurRadius: asEmu(numericAttr(node, "blurRad") ?? 0),
+    distance: asEmu(numericAttr(node, "dist") ?? 0),
+    direction: asOoxmlAngle(numericAttr(node, "dir") ?? 0),
+    color
+  };
+}
+function parseGlow2(node) {
+  const color = parseColorElement(node);
+  if (node === void 0 || color === void 0) return void 0;
+  return {
+    radius: asEmu(numericAttr(node, "rad") ?? 0),
+    color
+  };
+}
+function parseSoftEdge2(node) {
+  if (node === void 0) return void 0;
+  return {
+    radius: asEmu(numericAttr(node, "rad") ?? 0)
+  };
+}
+function booleanAttr(node, name) {
+  const value = getAttr(node, name);
+  if (value === void 0) return void 0;
+  return isTrue(value);
+}
+function isNonEmpty(value) {
+  return value !== void 0 && value !== "";
+}
+
+// src/reader/read-pptx.ts
+var CONTENT_TYPES_PART = "[Content_Types].xml";
+var PACKAGE_ROOT_PART = "";
+var OFFICE_DOCUMENT_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+var SLIDE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide";
+var SLIDE_LAYOUT_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
+var SLIDE_MASTER_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
+var THEME_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
+var PRESENTATION_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml";
+var textDecoder2 = new TextDecoder();
+function readPptx(input) {
+  const entries = unzipPackage(input);
+  const diagnostics = [];
+  const contentTypes = readContentTypes(entries);
+  const relationships = readRelationships(entries);
+  const parts = [];
+  const media = [];
+  const rawParts = [];
+  for (const [path, bytes] of entries) {
+    if (path === CONTENT_TYPES_PART) continue;
+    const contentType = resolveContentType(path, contentTypes.defaults, contentTypes.overrides);
+    parts.push({ partPath: asPartPath(path), contentType });
+    if (isMediaContentType(contentType)) {
+      media.push({ partPath: asPartPath(path), contentType, bytes });
+      continue;
+    }
+    if (isRelationshipPart(path)) continue;
+    rawParts.push({ kind: "binary", partPath: asPartPath(path), contentType, bytes });
+  }
+  const presentation = readPresentation(
+    entries,
+    relationships,
+    contentTypes.overrides,
+    diagnostics
+  );
+  const hierarchy = readSlideHierarchy(entries, relationships, presentation, diagnostics);
+  return {
+    packageGraph: {
+      contentTypes,
+      parts,
+      relationships,
+      media,
+      rawParts
+    },
+    presentation,
+    slides: hierarchy.slides,
+    slideLayouts: hierarchy.slideLayouts,
+    slideMasters: hierarchy.slideMasters,
+    themes: hierarchy.themes,
+    diagnostics
+  };
+}
+function readSlideHierarchy(entries, relationships, presentation, diagnostics) {
+  const slides = [];
+  const layoutPaths = new OrderedPathSet();
+  for (const slidePath of presentation.slidePartPaths) {
+    const part = parsePartRoot(entries, slidePath, "sld", diagnostics, true);
+    if (part === void 0) continue;
+    const layoutPath = resolveSingleRel(relationships, slidePath, SLIDE_LAYOUT_REL_TYPE);
+    if (layoutPath === void 0) {
+      diagnostics.push({
+        severity: "warning",
+        code: "slide-layout-unresolved",
+        message: `slide '${slidePath}' has no resolvable slideLayout relationship`,
+        handle: { partPath: slidePath }
+      });
+    } else {
+      layoutPaths.add(layoutPath);
+    }
+    slides.push(
+      parseSlide(
+        part.root,
+        slidePath,
+        layoutPath ?? asPartPath(""),
+        createSidecarIdFactory(slidePath),
+        navigateOrdered(part.orderedRoot, ["cSld", "spTree"])
+      )
+    );
+  }
+  const slideLayouts = [];
+  const masterPaths = new OrderedPathSet();
+  for (const layoutPath of layoutPaths.values()) {
+    const part = parsePartRoot(entries, layoutPath, "sldLayout", diagnostics, true);
+    if (part === void 0) continue;
+    const masterPath = resolveSingleRel(relationships, layoutPath, SLIDE_MASTER_REL_TYPE);
+    if (masterPath !== void 0) masterPaths.add(masterPath);
+    slideLayouts.push(
+      parseSlideLayout(
+        part.root,
+        layoutPath,
+        masterPath ?? asPartPath(""),
+        createSidecarIdFactory(layoutPath),
+        navigateOrdered(part.orderedRoot, ["cSld", "spTree"])
+      )
+    );
+  }
+  const slideMasters = [];
+  const themePaths = new OrderedPathSet();
+  for (const masterPath of masterPaths.values()) {
+    const part = parsePartRoot(entries, masterPath, "sldMaster", diagnostics, true);
+    if (part === void 0) continue;
+    const themePath = resolveSingleRel(relationships, masterPath, THEME_REL_TYPE);
+    if (themePath !== void 0) themePaths.add(themePath);
+    const masterLayoutPaths = resolveAllRels(relationships, masterPath, SLIDE_LAYOUT_REL_TYPE);
+    slideMasters.push(
+      parseSlideMaster(
+        part.root,
+        masterPath,
+        themePath,
+        masterLayoutPaths,
+        createSidecarIdFactory(masterPath),
+        navigateOrdered(part.orderedRoot, ["cSld", "spTree"])
+      )
+    );
+  }
+  const themes = [];
+  for (const themePath of themePaths.values()) {
+    const part = parsePartRoot(entries, themePath, "theme", diagnostics, true);
+    if (part === void 0) continue;
+    themes.push(
+      parseTheme(part.root, themePath, createSidecarIdFactory(themePath), part.orderedRoot)
+    );
+  }
+  return { slides, slideLayouts, slideMasters, themes };
+}
+function parsePartRoot(entries, partPath, rootLocalName, diagnostics, includeOrderedRoot) {
+  const bytes = entries.get(partPath);
+  if (!bytes) {
+    diagnostics.push({
+      severity: "warning",
+      code: "part-missing",
+      message: `part '${partPath}' referenced by the package graph is missing`,
+      handle: { partPath }
+    });
+    return void 0;
+  }
+  const xml = textDecoder2.decode(bytes);
+  const root = getChild(parseXml(xml), rootLocalName);
+  if (root === void 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "part-root-unexpected",
+      message: `part '${partPath}' does not have the expected <${rootLocalName}> root`,
+      handle: { partPath }
+    });
+    return void 0;
+  }
+  const orderedRoot = includeOrderedRoot ? navigateOrdered(parseXmlOrdered(xml), [rootLocalName]) ?? [] : [];
+  return { root, orderedRoot };
+}
+function resolveSingleRel(relationships, sourcePart, relType) {
+  const rels = relationships.find((rel) => rel.sourcePartPath === sourcePart)?.relationships;
+  const match = rels?.find((rel) => rel.type === relType && rel.targetMode !== "External");
+  if (match === void 0) return void 0;
+  return resolveInternalRelationshipTarget(sourcePart, match);
+}
+function resolveAllRels(relationships, sourcePart, relType) {
+  const rels = relationships.find((rel) => rel.sourcePartPath === sourcePart)?.relationships ?? [];
+  return rels.filter((rel) => rel.type === relType && rel.targetMode !== "External").flatMap((rel) => {
+    const target = resolveInternalRelationshipTarget(sourcePart, rel);
+    return target === void 0 ? [] : [target];
+  });
+}
+var OrderedPathSet = class {
+  seen = /* @__PURE__ */ new Set();
+  order = [];
+  add(path) {
+    if (this.seen.has(path)) return;
+    this.seen.add(path);
+    this.order.push(path);
+  }
+  values() {
+    return this.order;
+  }
+};
+function unzipPackage(input) {
+  const unzipped = (0, import_fflate.unzipSync)(input);
+  const entries = /* @__PURE__ */ new Map();
+  for (const [path, bytes] of Object.entries(unzipped)) {
+    if (path.endsWith("/")) continue;
+    entries.set(path, bytes);
+  }
+  return entries;
+}
+function readContentTypes(entries) {
+  const bytes = entries.get(CONTENT_TYPES_PART);
+  if (!bytes) return { defaults: [], overrides: [] };
+  const root = getChild(parseXml(textDecoder2.decode(bytes)), "Types");
+  const defaults = [];
+  for (const node of getChildArray(root, "Default")) {
+    const extension = getAttr(node, "Extension");
+    const contentType = getAttr(node, "ContentType");
+    if (extension === void 0 || contentType === void 0) continue;
+    defaults.push({ extension, contentType });
+  }
+  const overrides = [];
+  for (const node of getChildArray(root, "Override")) {
+    const partName = getAttr(node, "PartName");
+    const contentType = getAttr(node, "ContentType");
+    if (partName === void 0 || contentType === void 0) continue;
+    overrides.push({ partName: asPartPath(stripLeadingSlash(partName)), contentType });
+  }
+  return { defaults, overrides };
+}
+function readRelationships(entries) {
+  const result = [];
+  for (const [path, bytes] of entries) {
+    if (!isRelationshipPart(path)) continue;
+    const root = getChild(parseXml(textDecoder2.decode(bytes)), "Relationships");
+    const relationships = [];
+    for (const node of getChildArray(root, "Relationship")) {
+      const id = getAttr(node, "Id");
+      const type = getAttr(node, "Type");
+      const target = getAttr(node, "Target");
+      if (id === void 0 || type === void 0 || target === void 0) continue;
+      const targetMode = parseRelationshipTargetMode(getAttr(node, "TargetMode"));
+      relationships.push({
+        id: asRelationshipId(id),
+        type,
+        target,
+        ...targetMode !== void 0 ? { targetMode } : {}
+      });
+    }
+    result.push({ sourcePartPath: relationshipsSourcePartPath(path), relationships });
+  }
+  return result;
+}
+function readPresentation(entries, relationships, overrides, diagnostics) {
+  const presentationPath = locatePresentationPart(relationships, overrides);
+  if (presentationPath === void 0) {
+    throw new Error("readPptx: presentation part not found; input is not a valid PPTX package");
+  }
+  const bytes = entries.get(presentationPath);
+  if (!bytes) {
+    throw new Error(
+      `readPptx: presentation part '${presentationPath}' is missing from the package`
+    );
+  }
+  const presentationPartPath = asPartPath(presentationPath);
+  const root = getChild(parseXml(textDecoder2.decode(bytes)), "presentation");
+  if (root === void 0) {
+    throw new Error(
+      `readPptx: part '${presentationPath}' is not a presentation part (missing p:presentation root)`
+    );
+  }
+  const slideSize = readSlideSize(root);
+  const defaultTextStyle = parseTextStyle(getChild(root, "defaultTextStyle"));
+  const presentationRels = relationships.find(
+    (rel) => rel.sourcePartPath === presentationPath
+  )?.relationships;
+  const slidePartPaths = [];
+  const sldIdLst = getChild(root, "sldIdLst");
+  for (const sldId of getChildArray(sldIdLst, "sldId")) {
+    const relId = getNamespacedAttr(sldId, "id");
+    if (relId === void 0) continue;
+    const handle = { partPath: presentationPartPath, relationshipId: asRelationshipId(relId) };
+    const relationship = presentationRels?.find((rel) => rel.id === relId);
+    if (relationship === void 0) {
+      diagnostics.push({
+        severity: "warning",
+        code: "slide-relationship-unresolved",
+        message: `slide relationship '${relId}' referenced by presentation could not be resolved`,
+        handle
+      });
+      continue;
+    }
+    if (relationship.type !== SLIDE_REL_TYPE || relationship.targetMode === "External") {
+      diagnostics.push({
+        severity: "warning",
+        code: "slide-relationship-invalid",
+        message: `relationship '${relId}' referenced by p:sldId is not an internal slide relationship`,
+        handle
+      });
+      continue;
+    }
+    slidePartPaths.push(
+      asPartPath(resolveRelationshipTarget(presentationPath, relationship.target))
+    );
+  }
+  return {
+    partPath: presentationPartPath,
+    ...slideSize !== void 0 ? { slideSize } : {},
+    ...defaultTextStyle !== void 0 ? { defaultTextStyle } : {},
+    slidePartPaths,
+    handle: { partPath: presentationPartPath }
+  };
+}
+function readSlideSize(presentationRoot) {
+  const sldSz = getChild(presentationRoot, "sldSz");
+  const cx = getAttr(sldSz, "cx");
+  const cy = getAttr(sldSz, "cy");
+  if (cx === void 0 || cy === void 0) return void 0;
+  const width = Number(cx);
+  const height = Number(cy);
+  if (!Number.isFinite(width) || !Number.isFinite(height)) return void 0;
+  return { width: asEmu(width), height: asEmu(height) };
+}
+function locatePresentationPart(relationships, overrides) {
+  const rootRels = relationships.find(
+    (rel) => rel.sourcePartPath === PACKAGE_ROOT_PART
+  )?.relationships;
+  const officeDocumentRel = rootRels?.find(
+    (rel) => rel.type === OFFICE_DOCUMENT_REL_TYPE && rel.targetMode !== "External"
+  );
+  if (officeDocumentRel !== void 0) {
+    return resolveRelationshipTarget(PACKAGE_ROOT_PART, officeDocumentRel.target);
+  }
+  const override = overrides.find((entry) => entry.contentType === PRESENTATION_CONTENT_TYPE);
+  return override?.partName;
+}
+var MEDIA_CONTENT_TYPE_PREFIXES = ["image/", "audio/", "video/"];
+function isMediaContentType(contentType) {
+  return MEDIA_CONTENT_TYPE_PREFIXES.some((prefix) => contentType.startsWith(prefix));
+}
+function resolveContentType(path, defaults, overrides) {
+  const override = overrides.find((entry) => entry.partName === path);
+  if (override !== void 0) return override.contentType;
+  const extension = extensionOf(path);
+  if (extension !== void 0) {
+    const fallback = defaults.find(
+      (entry) => entry.extension.toLowerCase() === extension.toLowerCase()
+    );
+    if (fallback !== void 0) return fallback.contentType;
+  }
+  return "application/octet-stream";
+}
+function extensionOf(path) {
+  const dot = path.lastIndexOf(".");
+  const slash = path.lastIndexOf("/");
+  if (dot === -1 || dot < slash) return void 0;
+  return path.slice(dot + 1);
+}
+function stripLeadingSlash(path) {
+  return path.startsWith("/") ? path.slice(1) : path;
+}
+
+// src/writer/write-pptx.ts
+var import_fast_xml_parser2 = require("fast-xml-parser");
+var import_fflate2 = require("fflate");
+var CONTENT_TYPES_PART2 = "[Content_Types].xml";
+var RELS_CONTENT_TYPE = "application/vnd.openxmlformats-package.relationships+xml";
+var XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+var textEncoder = new TextEncoder();
+var textDecoder3 = new TextDecoder();
+var xmlBuilder = new import_fast_xml_parser2.XMLBuilder({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  format: false,
+  suppressEmptyNode: true
+});
+function writePptx(source) {
+  const textRunEdits = source.edits?.filter(isTextRunEdit) ?? [];
+  const paragraphTextEdits = source.edits?.filter(isParagraphTextEdit) ?? [];
+  const shapeTransformEdits = source.edits?.filter(isShapeTransformEdit) ?? [];
+  validateEdits(textRunEdits, paragraphTextEdits, shapeTransformEdits);
+  const dirtyPartPaths = new Set(
+    [...textRunEdits, ...paragraphTextEdits, ...shapeTransformEdits].map(
+      (edit) => edit.handle.partPath
+    )
+  );
+  const files = {
+    [CONTENT_TYPES_PART2]: encodeXml(serializeContentTypes(source.packageGraph.contentTypes))
+  };
+  const written = /* @__PURE__ */ new Set([CONTENT_TYPES_PART2]);
+  for (const relationships of source.packageGraph.relationships) {
+    const relsPath = relationshipsPartPath(relationships.sourcePartPath);
+    files[relsPath] = encodeXml(serializeRelationships(relationships));
+    written.add(relsPath);
+  }
+  for (const media of source.packageGraph.media) {
+    files[media.partPath] = media.bytes;
+    written.add(media.partPath);
+  }
+  for (const rawPart of source.packageGraph.rawParts ?? []) {
+    if (dirtyPartPaths.has(rawPart.partPath)) continue;
+    files[rawPart.partPath] = serializeRawPackagePart(rawPart);
+    written.add(rawPart.partPath);
+  }
+  for (const partPath of dirtyPartPaths) {
+    files[partPath] = serializeDirtyXmlPart(
+      source,
+      partPath,
+      textRunEdits,
+      paragraphTextEdits,
+      shapeTransformEdits
+    );
+    written.add(partPath);
+  }
+  for (const part of source.packageGraph.parts) {
+    if (written.has(part.partPath)) continue;
+    if (part.contentType === RELS_CONTENT_TYPE || isRelationshipPart(part.partPath)) continue;
+    throw new Error(
+      `writePptx: no preserved package material for part '${part.partPath}'; edited part generation is not implemented in the no-edit writer`
+    );
+  }
+  return (0, import_fflate2.zipSync)(files);
+}
+function isTextRunEdit(edit) {
+  return edit.kind === "replaceTextRunPlainText";
+}
+function isParagraphTextEdit(edit) {
+  return edit.kind === "replaceParagraphPlainText";
+}
+function isShapeTransformEdit(edit) {
+  return edit.kind === "updateShapeTransform";
+}
+function serializeDirtyXmlPart(source, partPath, textRunEdits, paragraphTextEdits, shapeTransformEdits) {
+  const rawPart = source.packageGraph.rawParts?.find((part) => part.partPath === partPath);
+  if (rawPart === void 0) {
+    throw new Error(`writePptx: dirty part '${partPath}' has no preserved raw package material`);
+  }
+  if (rawPart.kind !== "binary") {
+    throw new Error(`writePptx: dirty XML tree part '${partPath}' patching is not implemented`);
+  }
+  const root = parseXml(textDecoder3.decode(rawPart.bytes));
+  for (const edit of paragraphTextEdits.filter((edit2) => edit2.handle.partPath === partPath)) {
+    applyParagraphTextEdit(root, edit);
+  }
+  for (const edit of textRunEdits.filter((edit2) => edit2.handle.partPath === partPath)) {
+    applyTextRunEdit(root, edit);
+  }
+  for (const edit of shapeTransformEdits.filter((edit2) => edit2.handle.partPath === partPath)) {
+    applyShapeTransformEdit(root, edit);
+  }
+  return encodeXml(XML_DECLARATION + xmlBuilder.build(stripXmlProcessingInstruction(root)));
+}
+function stripXmlProcessingInstruction(root) {
+  const stripped = { ...root };
+  delete stripped["?xml"];
+  return stripped;
+}
+function applyTextRunEdit(root, edit) {
+  const locator = parseTextRunLocator(edit.handle.nodeId);
+  const slide = getChild(root, "sld");
+  const cSld = getChild(slide, "cSld");
+  const spTree = getChild(cSld, "spTree");
+  const shape = locateShape(spTree, locator);
+  const paragraphs = getChildArray(getChild(shape, "txBody"), "p");
+  const paragraph = paragraphs[locator.paragraphIndex];
+  const run = getChildArray(paragraph, "r")[locator.runIndex];
+  if (run === void 0) {
+    throw new Error(
+      `writePptx: text run handle '${edit.handle.nodeId}' no longer matches source XML`
+    );
+  }
+  setChildText(run, "t", edit.text);
+}
+function applyParagraphTextEdit(root, edit) {
+  const locator = parseParagraphLocator(edit.handle.nodeId);
+  const slide = getChild(root, "sld");
+  const cSld = getChild(slide, "cSld");
+  const spTree = getChild(cSld, "spTree");
+  const shape = locateShape(spTree, locator);
+  const paragraphs = getChildArray(getChild(shape, "txBody"), "p");
+  const paragraph = locatePhysicalParagraphForTextEdit(paragraphs, locator, edit.handle.nodeId);
+  if (paragraph === void 0) {
+    throw new Error(
+      `writePptx: paragraph handle '${edit.handle.nodeId}' no longer matches source XML`
+    );
+  }
+  replaceParagraphRunsWithSingleTextRun(paragraph, edit.text);
+}
+function applyShapeTransformEdit(root, edit) {
+  const locator = parseShapeLocator(edit.handle);
+  const slide = getChild(root, "sld");
+  const cSld = getChild(slide, "cSld");
+  const spTree = getChild(cSld, "spTree");
+  const shape = locateShapeTreeNode(spTree, locator);
+  const xfrm = getShapeTransformNode(shape);
+  if (xfrm === void 0) {
+    throw new Error(
+      `writePptx: shape transform handle '${String(
+        edit.handle.nodeId ?? edit.handle.orderingSlot ?? ""
+      )}' no longer matches source XML with xfrm`
+    );
+  }
+  const off = getChild(xfrm, "off");
+  const ext = getChild(xfrm, "ext");
+  if (off === void 0 || ext === void 0) {
+    throw new Error("writePptx: shape transform xfrm must contain off and ext");
+  }
+  off["@_x"] = String(edit.offsetX);
+  off["@_y"] = String(edit.offsetY);
+  ext["@_cx"] = String(edit.width);
+  ext["@_cy"] = String(edit.height);
+}
+function parseShapeLocator(handle) {
+  if (handle.nodeId !== void 0) return { nodeId: String(handle.nodeId) };
+  throw new Error("writePptx: shape transform edit requires nodeId in handle");
+}
+function parseTextRunLocator(nodeId) {
+  const value = String(nodeId ?? "");
+  const byShapeId = /^text:shape:(.+):p:(\d+):r:(\d+)$/.exec(value);
+  if (byShapeId !== null) {
+    return {
+      shapeNodeId: byShapeId[1],
+      paragraphIndex: Number(byShapeId[2]),
+      runIndex: Number(byShapeId[3])
+    };
+  }
+  const byShapeSlot = /^text:shapeSlot:(\d+):p:(\d+):r:(\d+)$/.exec(value);
+  if (byShapeSlot !== null) {
+    return {
+      shapeOrderingSlot: Number(byShapeSlot[1]),
+      paragraphIndex: Number(byShapeSlot[2]),
+      runIndex: Number(byShapeSlot[3])
+    };
+  }
+  throw new Error(`writePptx: unsupported text run handle '${value}'`);
+}
+function parseParagraphLocator(nodeId) {
+  const value = String(nodeId ?? "");
+  const byShapeId = /^text:shape:(.+):p:(\d+)$/.exec(value);
+  if (byShapeId !== null) {
+    return {
+      shapeNodeId: byShapeId[1],
+      paragraphIndex: Number(byShapeId[2])
+    };
+  }
+  const byShapeSlot = /^text:shapeSlot:(\d+):p:(\d+)$/.exec(value);
+  if (byShapeSlot !== null) {
+    return {
+      shapeOrderingSlot: Number(byShapeSlot[1]),
+      paragraphIndex: Number(byShapeSlot[2])
+    };
+  }
+  throw new Error(`writePptx: unsupported paragraph handle '${value}'`);
+}
+function locateShape(spTree, locator) {
+  const shapes = getChildArray(spTree, "sp");
+  if (locator.shapeNodeId !== void 0) {
+    return shapes.find(
+      (shape) => getAttr(getChild(getChild(shape, "nvSpPr"), "cNvPr"), "id") === locator.shapeNodeId
+    );
+  }
+  if (locator.shapeOrderingSlot === void 0) return void 0;
+  return getShapeByOrderingSlot(spTree, locator.shapeOrderingSlot);
+}
+function locateShapeTreeNode(spTree, locator) {
+  const shapeKeys = /* @__PURE__ */ new Set(["sp", "pic", "cxnSp", "graphicFrame", "grpSp"]);
+  if (!spTree) return void 0;
+  for (const key of Object.keys(spTree)) {
+    if (key.startsWith("@_") || !shapeKeys.has(localName(key))) continue;
+    const value = spTree[key];
+    const items = Array.isArray(value) ? unsafeOoxmlBoundaryAssertion(value) : [value];
+    const found = items.find(
+      (item) => getShapeTreeNodeId(unsafeOoxmlBoundaryAssertion(item)) === locator.nodeId
+    );
+    if (found !== void 0) return unsafeOoxmlBoundaryAssertion(found);
+  }
+  return void 0;
+}
+function getShapeByOrderingSlot(spTree, orderingSlot) {
+  if (!spTree) return void 0;
+  let currentSlot = 0;
+  for (const key of Object.keys(spTree)) {
+    if (key.startsWith("@_")) continue;
+    const local = localName(key);
+    if (local === "nvGrpSpPr" || local === "grpSpPr") continue;
+    const value = spTree[key];
+    const items = Array.isArray(value) ? value : [value];
+    for (const item of items) {
+      if (currentSlot === orderingSlot) {
+        return local === "sp" ? unsafeOoxmlBoundaryAssertion(item) : void 0;
+      }
+      currentSlot++;
+    }
+  }
+  return void 0;
+}
+function getShapeTreeNodeId(node) {
+  const nonVisualProperties = getChild(node, "nvSpPr") ?? getChild(node, "nvPicPr") ?? getChild(node, "nvCxnSpPr") ?? getChild(node, "nvGrpSpPr") ?? getChild(node, "nvGraphicFramePr");
+  return getAttr(getChild(nonVisualProperties, "cNvPr"), "id");
+}
+function getShapeTransformNode(shape) {
+  if (shape === void 0) return void 0;
+  return getChild(getChild(shape, "spPr"), "xfrm") ?? getChild(getChild(shape, "grpSpPr"), "xfrm") ?? getChild(shape, "xfrm");
+}
+function setChildText(node, name, text) {
+  for (const key of Object.keys(node)) {
+    if (key.startsWith("@_")) continue;
+    if (localName(key) !== name) continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      value[0] = textElementValue(value[0], text);
+      return;
+    }
+    node[key] = textElementValue(value, text);
+    return;
+  }
+  node[`a:${name}`] = textRequiresPreserve(text) ? { "@_xml:space": "preserve", "#text": text } : text;
+}
+function replaceParagraphRunsWithSingleTextRun(paragraph, text) {
+  const firstRunProperties = getChild(getFirstRunLikeNode(paragraph), "rPr");
+  const replacementRun = {
+    ...firstRunProperties !== void 0 ? { "a:rPr": cloneXmlNode(firstRunProperties) } : {},
+    "a:t": textRequiresPreserve(text) ? { "@_xml:space": "preserve", "#text": text } : text
+  };
+  const attrs = [];
+  const paragraphProperties = [];
+  const middleChildren = [];
+  const endProperties = [];
+  for (const [key, value] of Object.entries(paragraph)) {
+    if (key.startsWith("@_")) {
+      attrs.push([key, value]);
+      continue;
+    }
+    const local = localName(key);
+    if (isRunLikeLocalName(local)) continue;
+    if (local === "pPr") paragraphProperties.push([key, value]);
+    else if (local === "endParaRPr") endProperties.push([key, value]);
+    else middleChildren.push([key, value]);
+  }
+  replaceNodeEntries(paragraph, [
+    ...attrs,
+    ...paragraphProperties,
+    ["a:r", replacementRun],
+    ...middleChildren,
+    ...endProperties
+  ]);
+}
+function getFirstRunLikeNode(paragraph) {
+  for (const key of Object.keys(paragraph)) {
+    if (key.startsWith("@_")) continue;
+    if (!isRunLikeLocalName(localName(key))) continue;
+    const value = paragraph[key];
+    return Array.isArray(value) ? unsafeOoxmlBoundaryAssertion(value[0]) : unsafeOoxmlBoundaryAssertion(value);
+  }
+  return void 0;
+}
+function isRunLikeLocalName(name) {
+  return name === "r" || name === "fld" || name === "br";
+}
+function locatePhysicalParagraphForTextEdit(paragraphs, locator, handleNodeId) {
+  let logicalParagraphIndex = 0;
+  for (const paragraph of paragraphs) {
+    const logicalCount = getLogicalParagraphCount(paragraph);
+    if (locator.paragraphIndex >= logicalParagraphIndex && locator.paragraphIndex < logicalParagraphIndex + logicalCount) {
+      if (logicalCount > 1) {
+        throw new Error(
+          `writePptx: paragraph handle '${handleNodeId}' references an interleaved bullet paragraph split by the reader; paragraph replacement is not supported for this source XML`
+        );
+      }
+      return paragraph;
+    }
+    logicalParagraphIndex += logicalCount;
+  }
+  return void 0;
+}
+function getLogicalParagraphCount(paragraph) {
+  const bulletParagraphProperties = getChildArray(paragraph, "pPr").filter(
+    (properties) => getChild(properties, "buChar") !== void 0 || getChild(properties, "buAutoNum") !== void 0
+  );
+  return Math.max(1, bulletParagraphProperties.length);
+}
+function replaceNodeEntries(node, entries) {
+  for (const key of Object.keys(node)) delete node[key];
+  for (const [key, value] of entries) node[key] = value;
+}
+function cloneXmlNode(node) {
+  return Object.fromEntries(
+    Object.entries(node).map(([key, value]) => [key, cloneXmlValue(value)])
+  );
+}
+function cloneXmlValue(value) {
+  if (Array.isArray(value)) return value.map(cloneXmlValue);
+  if (typeof value === "object" && value !== null) {
+    return cloneXmlNode(unsafeOoxmlBoundaryAssertion(value));
+  }
+  return value;
+}
+function textElementValue(existing, text) {
+  if (typeof existing === "object" && existing !== null && !Array.isArray(existing)) {
+    const next = { ...unsafeOoxmlBoundaryAssertion(existing), "#text": text };
+    if (textRequiresPreserve(text)) next["@_xml:space"] = "preserve";
+    else delete next["@_xml:space"];
+    return next;
+  }
+  return textRequiresPreserve(text) ? { "@_xml:space": "preserve", "#text": text } : text;
+}
+function textRequiresPreserve(text) {
+  return text.startsWith(" ") || text.endsWith(" ");
+}
+function validateEdits(textRunEdits, paragraphTextEdits, shapeTransformEdits) {
+  const runKeys = /* @__PURE__ */ new Set();
+  for (const edit of textRunEdits) {
+    const key = editHandleNodeKey(edit);
+    if (runKeys.has(key)) {
+      throw new Error(`writePptx: conflicting text run edits for handle '${edit.handle.nodeId}'`);
+    }
+    runKeys.add(key);
+  }
+  const paragraphKeys = /* @__PURE__ */ new Set();
+  for (const edit of paragraphTextEdits) {
+    const key = editHandleNodeKey(edit);
+    if (paragraphKeys.has(key)) {
+      throw new Error(
+        `writePptx: conflicting paragraph text edits for handle '${edit.handle.nodeId}'`
+      );
+    }
+    paragraphKeys.add(key);
+  }
+  for (const runEdit of textRunEdits) {
+    const paragraphKey = textRunParagraphEditKey(runEdit);
+    if (paragraphKey !== void 0 && paragraphKeys.has(paragraphKey)) {
+      throw new Error(
+        `writePptx: conflicting text run and paragraph edits for handle '${runEdit.handle.nodeId}'`
+      );
+    }
+  }
+  const shapeKeys = /* @__PURE__ */ new Set();
+  for (const edit of shapeTransformEdits) {
+    const key = editHandleNodeKey(edit);
+    if (shapeKeys.has(key)) {
+      throw new Error(
+        `writePptx: conflicting shape transform edits for handle '${String(edit.handle.nodeId)}'`
+      );
+    }
+    shapeKeys.add(key);
+  }
+}
+function editHandleNodeKey(edit) {
+  return [edit.handle.partPath, edit.handle.nodeId ?? "", edit.handle.relationshipId ?? ""].join(
+    "\0"
+  );
+}
+function textRunParagraphEditKey(edit) {
+  const nodeId = String(edit.handle.nodeId ?? "");
+  const byShapeId = /^(text:shape:.+:p:\d+):r:\d+$/.exec(nodeId);
+  const byShapeSlot = /^(text:shapeSlot:\d+:p:\d+):r:\d+$/.exec(nodeId);
+  const paragraphNodeId = byShapeId?.[1] ?? byShapeSlot?.[1];
+  if (paragraphNodeId === void 0) return void 0;
+  return [edit.handle.partPath, paragraphNodeId, edit.handle.relationshipId ?? ""].join("\0");
+}
+function serializeContentTypes(contentTypes) {
+  const defaults = contentTypes.defaults.map(
+    (entry) => `<Default Extension="${escapeAttribute(entry.extension)}" ContentType="${escapeAttribute(entry.contentType)}"/>`
+  ).join("");
+  const overrides = contentTypes.overrides.map(
+    (entry) => `<Override PartName="/${escapeAttribute(entry.partName)}" ContentType="${escapeAttribute(entry.contentType)}"/>`
+  ).join("");
+  return XML_DECLARATION + `<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">` + defaults + overrides + `</Types>`;
+}
+function serializeRelationships(partRelationships) {
+  const relationships = partRelationships.relationships.map((relationship) => {
+    const targetMode = relationship.targetMode === void 0 ? "" : ` TargetMode="${escapeAttribute(relationship.targetMode)}"`;
+    return `<Relationship Id="${escapeAttribute(relationship.id)}" Type="${escapeAttribute(relationship.type)}" Target="${escapeAttribute(relationship.target)}"${targetMode}/>`;
+  }).join("");
+  return XML_DECLARATION + `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">` + relationships + `</Relationships>`;
+}
+function serializeRawPackagePart(rawPart) {
+  if (rawPart.kind === "binary") return rawPart.bytes;
+  return encodeXml(XML_DECLARATION + serializeRawNode(rawPart.xml));
+}
+function serializeRawNode(node) {
+  const attributes = node.attributes === void 0 ? "" : Object.entries(node.attributes).map(([name, value]) => ` ${name}="${escapeAttribute(value)}"`).join("");
+  const text = node.text === void 0 ? "" : escapeText(node.text);
+  const children = node.children?.map((child) => serializeRawNode(child)).join("") ?? "";
+  if (text !== "" && children !== "") {
+    throw new Error(
+      `writePptx: raw XML part '${node.name}' contains mixed text/element content; ordered mixed-content serialization is not implemented in the no-edit writer`
+    );
+  }
+  if (text === "" && children === "") return `<${node.name}${attributes}/>`;
+  return `<${node.name}${attributes}>${text}${children}</${node.name}>`;
+}
+function encodeXml(xml) {
+  return textEncoder.encode(xml);
+}
+function escapeAttribute(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asEmu,
+  asHundredthPt,
+  asOoxmlAngle,
+  asOoxmlPercent,
+  asPartPath,
+  asPt,
+  asRawSidecarId,
+  asRelationshipId,
+  asSourceNodeId,
+  createComputedView,
+  findParagraphBySourceHandle,
+  findShapeNodeBySourceHandle,
+  findTextRunBySourceHandle,
+  readPptx,
+  replaceParagraphPlainText,
+  replaceTextRunPlainText,
+  updateShapeTransform,
+  writePptx
+});