ooxml-core 1.1.0 → 1.2.1

package/dist/docx/embedded.mjs

@@ -7,12 +7,18 @@ var NS = {
   w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
   /** DrawingML main. */
   a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+  /** DrawingML chart. */
+  c: "http://schemas.openxmlformats.org/drawingml/2006/chart",
+  /** Office 2010 chart extensions, including built-in modern chart styles. */
+  c14: "http://schemas.microsoft.com/office/drawing/2007/8/2/chart",
   /** DrawingML diagram (SmartArt) main. */
   dgm: "http://schemas.openxmlformats.org/drawingml/2006/diagram",
   /** Office 2007+ diagram drawing (`dsp`). */
   dsp: "http://schemas.microsoft.com/office/drawing/2008/diagram",
   /** Relationships (`r:id`, `r:embed`). */
   r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  /** Markup compatibility (`mc:AlternateContent`). */
+  mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
   /** OPC relationships part. */
   rels: "http://schemas.openxmlformats.org/package/2006/relationships",
   /** OPC content types part. */
@@ -360,12 +366,12 @@ function runPropertyChanged(run, base, key) {
 function parseDirectRunProperties(props) {
   const result = parseRunProperties(props);
   const language = first2(props, "lang");
-  for (const [attribute, key] of [
+  for (const [attribute2, key] of [
     ["val", "language"],
     ["eastAsia", "eastAsiaLanguage"],
     ["bidi", "bidiLanguage"]
   ]) {
-    const value = getW(language, attribute);
+    const value = getW(language, attribute2);
     if (value !== void 0) result[key] = value;
   }
   const rtl = onOffElement(first2(props, "rtl"));
@@ -923,10 +929,10 @@ var COLOR_ELEMENTS = {
   hslClr: "hsl"
 };
 function colorValue(kind, element) {
-  const attribute = (name) => element.getAttribute(name) ?? "";
-  if (kind === "scrgb") return `${attribute("r")},${attribute("g")},${attribute("b")}`;
-  if (kind === "hsl") return `${attribute("hue")},${attribute("sat")},${attribute("lum")}`;
-  return attribute("val");
+  const attribute2 = (name) => element.getAttribute(name) ?? "";
+  if (kind === "scrgb") return `${attribute2("r")},${attribute2("g")},${attribute2("b")}`;
+  if (kind === "hsl") return `${attribute2("hue")},${attribute2("sat")},${attribute2("lum")}`;
+  return attribute2("val");
 }
 function parseDrawingColorIn(container) {
   if (!container) return void 0;
@@ -1148,6 +1154,10 @@ function resolvePartPath(basePart, target) {
   }
   return resolved.join("/");
 }
+function relationshipsPartFor(partName) {
+  const slash = partName.lastIndexOf("/");
+  return `${partName.slice(0, slash + 1)}_rels/${partName.slice(slash + 1)}.rels`;
+}
 function nextRelationshipId(used) {
   let index = 1;
   while (used.has(`rId${index}`)) index++;
@@ -1278,7 +1288,7 @@ function parseCoreProperties(xml) {
   }
   return Object.keys(result).length ? result : void 0;
 }
-var same = (a, b) => PROPERTY_FIELDS.every((field) => (a?.[field] ?? "") === (b?.[field] ?? ""));
+var same = (a2, b) => PROPERTY_FIELDS.every((field) => (a2?.[field] ?? "") === (b?.[field] ?? ""));
 async function applyCoreProperties(zip, next, prior) {
   if (same(next, prior)) return;
   const existing = zip.file(CORE_PATH);
@@ -1437,13 +1447,13 @@ function buildCommentsExtendedDocument(comments) {
   );
   const root = doc.documentElement;
   comments.forEach((comment, index) => {
-    const entry = doc.createElementNS(W15_NS, "w15:commentEx");
-    entry.setAttributeNS(W15_NS, "w15:paraId", paraIdFor(comment.id, index));
-    if (comment.resolved) entry.setAttributeNS(W15_NS, "w15:done", "1");
-    const parentIndex = comments.findIndex((c) => c.id === comment.parentId);
+    const entry2 = doc.createElementNS(W15_NS, "w15:commentEx");
+    entry2.setAttributeNS(W15_NS, "w15:paraId", paraIdFor(comment.id, index));
+    if (comment.resolved) entry2.setAttributeNS(W15_NS, "w15:done", "1");
+    const parentIndex = comments.findIndex((c2) => c2.id === comment.parentId);
     if (parentIndex >= 0)
-      entry.setAttributeNS(W15_NS, "w15:paraIdParent", paraIdFor(comment.parentId, parentIndex));
-    root.appendChild(entry);
+      entry2.setAttributeNS(W15_NS, "w15:paraIdParent", paraIdFor(comment.parentId, parentIndex));
+    root.appendChild(entry2);
   });
   return doc;
 }
@@ -1573,7 +1583,7 @@ function rangeEdges(runs, ranges) {
   const opens = /* @__PURE__ */ new Map();
   const closes = /* @__PURE__ */ new Map();
   const order = (key) => key.startsWith("comment:") ? 0 : 1;
-  for (const key of [...first3.keys()].sort((a, b) => order(a) - order(b))) {
+  for (const key of [...first3.keys()].sort((a2, b) => order(a2) - order(b))) {
     if (!ranges?.before.has(key)) {
       const index = first3.get(key);
       (opens.get(index) ?? opens.set(index, []).get(index)).push(edgeFor(key, index));
@@ -1796,8 +1806,8 @@ function orderChildren(parent, order) {
     if (rank >= 0) previousRank = rank;
     return { element, index, rank: rank >= 0 ? rank : previousRank + 0.5 };
   });
-  const sorted = [...ranked].sort((a, b) => a.rank - b.rank || a.index - b.index);
-  if (sorted.every((entry, index) => entry.element === elements2[index])) return;
+  const sorted = [...ranked].sort((a2, b) => a2.rank - b.rank || a2.index - b.index);
+  if (sorted.every((entry2, index) => entry2.element === elements2[index])) return;
   for (const { element } of sorted) parent.appendChild(element);
 }
 var SECTPR_ORDER = [
@@ -2584,7 +2594,7 @@ function borderElement(doc, name, side) {
   }
   return element;
 }
-var sameJson = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+var sameJson = (a2, b) => JSON.stringify(a2 ?? null) === JSON.stringify(b ?? null);
 function updateShading(doc, props, paragraph, base) {
   if (base && paragraph.shadingFill === base.shadingFill) return;
   for (const element of children2(props, "shd")) props.removeChild(element);
@@ -2776,8 +2786,8 @@ function reconcileBookmarks(doc, starts, ends, names, baseNames, nextId) {
 function setAttribute3(element, local, value) {
   element.setAttributeNS(WORD_NS, `w:${local}`, value);
 }
-function sameNumbering(a, b) {
-  return a?.numId === b?.numId && a?.level === b?.level;
+function sameNumbering(a2, b) {
+  return a2?.numId === b?.numId && a2?.level === b?.level;
 }
 function writeNumberingProperties(doc, props, paragraph, base) {
   if (base && sameNumbering(paragraph.numbering, base.numbering)) return;
@@ -2960,11 +2970,11 @@ var allowedRunPropertyAttributes = {
   shd: ["val", "fill", "color", "themeFill", "themeFillTint", "themeFillShade"]
 };
 function hasUnexpectedAttributes(element, allowed, allowDateUtc = false) {
-  for (const attribute of Array.from(element.attributes)) {
-    if (attribute.namespaceURI === "http://www.w3.org/2000/xmlns/") continue;
-    if (allowDateUtc && attribute.namespaceURI === WORD_DATE_UTC_NS && attribute.localName === "dateUtc")
+  for (const attribute2 of Array.from(element.attributes)) {
+    if (attribute2.namespaceURI === "http://www.w3.org/2000/xmlns/") continue;
+    if (allowDateUtc && attribute2.namespaceURI === WORD_DATE_UTC_NS && attribute2.localName === "dateUtc")
       continue;
-    if (attribute.namespaceURI !== WORD_NS || !allowed.includes(attribute.localName)) return true;
+    if (attribute2.namespaceURI !== WORD_NS || !allowed.includes(attribute2.localName)) return true;
   }
   return false;
 }
@@ -2991,7 +3001,7 @@ function runPropertiesHaveUnknownContent(properties) {
       if (!isLigatures(property.getAttributeNS(WORD_2010_NS, "val")) || elements(property).length)
         return true;
       if (Array.from(property.attributes).some(
-        (attribute) => attribute.namespaceURI !== "http://www.w3.org/2000/xmlns/" && (attribute.namespaceURI !== WORD_2010_NS || attribute.localName !== "val")
+        (attribute2) => attribute2.namespaceURI !== "http://www.w3.org/2000/xmlns/" && (attribute2.namespaceURI !== WORD_2010_NS || attribute2.localName !== "val")
       ))
         return true;
       continue;
@@ -3138,19 +3148,19 @@ function colorOf(value) {
 }
 function parseWatermarkShape(shape) {
   if (!shape || !(shape.getAttribute("id") ?? "").startsWith(WATERMARK_PREFIX)) return void 0;
-  const path = Array.from(shape.getElementsByTagNameNS(VML_NS, "textpath"))[0];
-  if (!path) return void 0;
+  const path2 = Array.from(shape.getElementsByTagNameNS(VML_NS, "textpath"))[0];
+  if (!path2) return void 0;
   const style = shape.getAttribute("style") ?? "";
   const fill = Array.from(shape.getElementsByTagNameNS(VML_NS, "fill"))[0];
   const opacity = fill?.getAttribute("opacity");
   const family = /font-family:\s*(?:"|"|')?([^;"'&]+)/i.exec(
-    path.getAttribute("style") ?? ""
+    path2.getAttribute("style") ?? ""
   )?.[1];
   const width = /width:\s*([\d.]+)pt/i.exec(style);
   const height = /height:\s*([\d.]+)pt/i.exec(style);
   const rotation = /rotation:\s*(-?[\d.]+)/i.exec(style);
   const spec = {
-    text: path.getAttribute("string") ?? "",
+    text: path2.getAttribute("string") ?? "",
     color: colorOf(shape.getAttribute("fillcolor")),
     semitransparent: opacity !== null && opacity !== "" && opacity !== "1",
     layout: rotation && Math.abs(Number(rotation[1]) % 360) > 1 ? "diagonal" : "horizontal",
@@ -3206,11 +3216,11 @@ function buildWatermarkRun(doc, spec, uniqueId) {
     f.setAttribute("eqn", eqn);
     formulas.appendChild(f);
   }
-  const path = v("path");
-  path.setAttribute("textpathok", "t");
-  path.setAttributeNS(OFFICE_NS, "o:connecttype", "custom");
-  path.setAttributeNS(OFFICE_NS, "o:connectlocs", "@9,0;@10,10800;@11,21600;@12,10800");
-  path.setAttributeNS(OFFICE_NS, "o:connectangles", "270,180,90,0");
+  const path2 = v("path");
+  path2.setAttribute("textpathok", "t");
+  path2.setAttributeNS(OFFICE_NS, "o:connecttype", "custom");
+  path2.setAttributeNS(OFFICE_NS, "o:connectlocs", "@9,0;@10,10800;@11,21600;@12,10800");
+  path2.setAttributeNS(OFFICE_NS, "o:connectangles", "270,180,90,0");
   const typePath = v("textpath");
   typePath.setAttribute("on", "t");
   typePath.setAttribute("fitshape", "t");
@@ -3223,7 +3233,7 @@ function buildWatermarkRun(doc, spec, uniqueId) {
   lock.setAttributeNS(VML_NS, "v:ext", "edit");
   lock.setAttribute("text", "t");
   lock.setAttribute("shapetype", "t");
-  for (const child3 of [formulas, path, typePath, handles, lock]) type.appendChild(child3);
+  for (const child3 of [formulas, path2, typePath, handles, lock]) type.appendChild(child3);
   const size = watermarkSizePt(spec);
   const shape = v("shape");
   shape.setAttribute("id", `${WATERMARK_PREFIX}${uniqueId}`);
@@ -3456,8 +3466,8 @@ var CUSTOM_LAYOUT_ATTRIBUTES = [
 ];
 function parseCustomLayoutAttributes(get) {
   const custom = {};
-  for (const [key, attribute, kind] of CUSTOM_LAYOUT_ATTRIBUTES) {
-    const raw = get(attribute);
+  for (const [key, attribute2, kind] of CUSTOM_LAYOUT_ATTRIBUTES) {
+    const raw = get(attribute2);
     const value = kind === "flag" ? optionalBoolean(raw) : optionalScaled(raw, kind === "angle" ? 6e4 : 1e5);
     if (value !== void 0) custom[key] = value;
   }
@@ -3471,8 +3481,8 @@ var RELATIONSHIP_ATTRIBUTES = [
 ];
 function parseRelationshipIdAttributes(get) {
   const result = {};
-  for (const [property, attribute] of RELATIONSHIP_ATTRIBUTES) {
-    const value = optionalString(get(attribute));
+  for (const [property, attribute2] of RELATIONSHIP_ATTRIBUTES) {
+    const value = optionalString(get(attribute2));
     if (value) result[property] = value;
   }
   return result;
@@ -3534,7 +3544,7 @@ async function resolveDiagramDrawingPart(hostPart, dataRelId, drawingExtensionRe
   const entries = await host.readRelationshipEntries(diagramRelationshipsPart(dataPath));
   if (!entries) return void 0;
   const drawing = entries.find(
-    (entry) => (!drawingExtensionRelId || entry.id.trim() === drawingExtensionRelId) && entry.type.endsWith("/diagramDrawing")
+    (entry2) => (!drawingExtensionRelId || entry2.id.trim() === drawingExtensionRelId) && entry2.type.endsWith("/diagramDrawing")
   );
   const id = drawing?.id.trim() ?? "";
   const target = drawing?.target.trim() ?? "";
@@ -3638,14 +3648,14 @@ function parseDiagramDataModel(source, part) {
     if (connection.modelId && connectionIds.has(connection.modelId))
       report("CONNECTION_ID_DUPLICATE", `Duplicate dgm:cxn modelId: ${connection.modelId}.`);
     if (connection.modelId) connectionIds.add(connection.modelId);
-    for (const [attribute, id] of [
+    for (const [attribute2, id] of [
       ["srcId", connection.sourceId],
       ["destId", connection.destId]
     ])
       if (!ids.has(id))
         report(
           "CONNECTION_ENDPOINT_MISSING",
-          `dgm:cxn ${attribute} references missing point: ${id}.`
+          `dgm:cxn ${attribute2} references missing point: ${id}.`
         );
     const label = connectionLabel(connection, transitionText);
     connections.push(label ? { ...connection, label } : connection);
@@ -3788,7 +3798,7 @@ function parseDrawingFill(properties) {
       });
       const angle = Number.parseInt(first(fill, "lin", NS.a)?.getAttribute("ang") ?? "", 10);
       const scaled = first(fill, "lin", NS.a)?.getAttribute("scaled");
-      const path = first(fill, "path", NS.a)?.getAttribute("path");
+      const path2 = first(fill, "path", NS.a)?.getAttribute("path");
       const focus = first(first(fill, "path", NS.a), "fillToRect", NS.a);
       const tile = first(fill, "tileRect", NS.a);
       const tileRect = tile ? {
@@ -3810,7 +3820,7 @@ function parseDrawingFill(properties) {
         ...Number.isFinite(angle) ? { angle: angle / 6e4 } : {},
         ...scaled === "1" || scaled === "true" ? { scaled: true } : {},
         ...scaled === "0" || scaled === "false" ? { scaled: false } : {},
-        ...path ? { path } : {},
+        ...path2 ? { path: path2 } : {},
         ...fillToRect && Object.values(fillToRect).every(Number.isFinite) ? { fillToRect } : {},
         ...tileRect && Object.values(tileRect).every(Number.isFinite) ? { tileRect } : {}
       };
@@ -3914,13 +3924,13 @@ function parseDrawingTextBody(body) {
   const anchor = properties?.getAttribute("anchor");
   if (anchor) result.anchor = anchor;
   const insets = {};
-  for (const [key, attribute] of [
+  for (const [key, attribute2] of [
     ["left", "lIns"],
     ["top", "tIns"],
     ["right", "rIns"],
     ["bottom", "bIns"]
   ]) {
-    const value = Number.parseInt(properties?.getAttribute(attribute) ?? "", 10);
+    const value = Number.parseInt(properties?.getAttribute(attribute2) ?? "", 10);
     if (Number.isFinite(value)) insets[key] = value;
   }
   if (Object.keys(insets).length > 0) result.insetsEmu = insets;
@@ -3951,18 +3961,18 @@ function parseTransform(xfrm) {
     ...booleanAttribute(xfrm, "flipV") ? { flipVertical: true } : {}
   };
 }
-function parsePathCommands(path) {
+function parsePathCommands(path2) {
   const commands = [];
   const point = (element) => {
     const x = int(element, "x");
     const y = int(element, "y");
     return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : void 0;
   };
-  for (const element of Array.from(path.childNodes)) {
+  for (const element of Array.from(path2.childNodes)) {
     if (element.nodeType !== 1) continue;
     const node = element;
     const points = children(node, "pt", NS.a).map(point);
-    if (points.some((entry) => entry === void 0)) return void 0;
+    if (points.some((entry2) => entry2 === void 0)) return void 0;
     const [p0, p1, p2] = points;
     switch (node.localName) {
       case "moveTo":
@@ -4005,17 +4015,17 @@ function parseDrawingGeometry(spPr) {
   const custom = first(spPr, "custGeom", NS.a);
   if (custom) {
     const paths = [];
-    for (const path of children(first(custom, "pathLst", NS.a) ?? custom, "path", NS.a)) {
-      const commands = parsePathCommands(path);
+    for (const path2 of children(first(custom, "pathLst", NS.a) ?? custom, "path", NS.a)) {
+      const commands = parsePathCommands(path2);
       if (!commands) return { geometry: "custom", issue: "CUSTOM_GEOMETRY_GUIDES_UNSUPPORTED" };
-      const width = int(path, "w");
-      const height = int(path, "h");
+      const width = int(path2, "w");
+      const height = int(path2, "h");
       paths.push({
         commands,
         ...Number.isFinite(width) ? { width } : {},
         ...Number.isFinite(height) ? { height } : {},
-        ...path.getAttribute("fill") ? { fill: path.getAttribute("fill") } : {},
-        ...path.getAttribute("stroke") === "0" || path.getAttribute("stroke") === "false" ? { stroke: false } : {}
+        ...path2.getAttribute("fill") ? { fill: path2.getAttribute("fill") } : {},
+        ...path2.getAttribute("stroke") === "0" || path2.getAttribute("stroke") === "false" ? { stroke: false } : {}
       });
     }
     return { geometry: "custom", paths };
@@ -4357,6 +4367,1179 @@ async function resolveDiagramParts(diagram, readText) {
   diagram.notice = diagramNotice(diagram.rendering);
 }
 
+// chart/color-style.ts
+var CHART_COLOR_STYLE_NS = "http://schemas.microsoft.com/office/drawing/2012/chartStyle";
+function chartColorStyleId(xml) {
+  const root = parseXml(xml).documentElement;
+  if (root.localName !== "colorStyle" || root.namespaceURI !== CHART_COLOR_STYLE_NS)
+    return void 0;
+  const value = root.getAttribute("id");
+  if (!value || !/^\d+$/.test(value)) return void 0;
+  const id = Number(value);
+  return Number.isInteger(id) && id >= 0 ? id : void 0;
+}
+
+// chart/built-in-text-style.ts
+var C14 = NS.c14;
+function readBuiltInChartStyle(root) {
+  for (const content of children(root, "AlternateContent", NS.mc)) {
+    for (const choice of children(content, "Choice", NS.mc)) {
+      const requires = choice.getAttribute("Requires")?.trim().split(/\s+/);
+      if (!requires?.length || !requires.every((prefix) => choice.lookupNamespaceURI(prefix) === C14))
+        continue;
+      const modern = first(choice, "style", C14)?.getAttribute("val");
+      if (modern && /^\d+$/.test(modern) && Number(modern) >= 101 && Number(modern) <= 148)
+        return Number(modern);
+    }
+  }
+  const legacy = first(root, "style", NS.c) ?? first(first(first(root, "AlternateContent", NS.mc), "Fallback", NS.mc), "style", NS.c);
+  const value = legacy?.getAttribute("val");
+  if (!legacy) return 2;
+  return value && /^\d+$/.test(value) && Number.isSafeInteger(Number(value)) ? Number(value) : void 0;
+}
+
+// chart/read-appearance.ts
+function readChartAppearance(text, properties) {
+  const out = {};
+  const size = Number(text?.getAttribute("sz") ?? NaN);
+  if (Number.isFinite(size) && size > 0) out.fontSize = size / 100;
+  for (const [attribute2, key] of [
+    ["b", "bold"],
+    ["i", "italic"]
+  ]) {
+    const value = text?.getAttribute(attribute2);
+    if (value !== null && value !== void 0) out[key] = value === "1" || value === "true";
+  }
+  const typeface = first(text, "latin", NS.a)?.getAttribute("typeface");
+  const underline = text?.getAttribute("u");
+  if (underline) out.underline = underline !== "none";
+  if (typeface) out.typeface = typeface;
+  const color = parseDrawingColorIn(first(text, "solidFill", NS.a));
+  if (color) out.textColor = color;
+  const fill = parseDrawingFill(properties);
+  const line = parseDrawingLine(first(properties, "ln", NS.a));
+  if (fill) out.fill = fill;
+  if (line) out.line = line;
+  const effects = first(text, "effectLst", NS.a);
+  if (effects) out.textEffectsXml = buildXml(effects);
+  return out;
+}
+
+// chart/formatting-nodes.ts
+function chartFormattingNodes(root) {
+  const chart = first(root, "chart", NS.c);
+  const plot = first(chart, "plotArea", NS.c);
+  const category = first(plot, "catAx", NS.c) ?? first(plot, "dateAx", NS.c);
+  const values = plot ? children(plot, "valAx", NS.c) : [];
+  return {
+    chartArea: root,
+    plotArea: plot,
+    title: first(chart, "title", NS.c),
+    legend: first(chart, "legend", NS.c),
+    categoryAxis: category ?? values[0],
+    valueAxis: category ? values[0] : values[1],
+    gridlineMajor: first(values[0], "majorGridlines", NS.c),
+    gridlineMinor: first(values[0], "minorGridlines", NS.c)
+  };
+}
+
+// chart/manual-layout.ts
+function readChartManualLayoutValues(value) {
+  const result = {};
+  const enumeration = (name, values) => {
+    const raw = value(name);
+    return values.includes(raw) ? raw : void 0;
+  };
+  const target = enumeration("layoutTarget", ["inner", "outer"]);
+  if (target) result.layoutTarget = target;
+  for (const [xml, key] of [
+    ["xMode", "xMode"],
+    ["yMode", "yMode"],
+    ["wMode", "widthMode"],
+    ["hMode", "heightMode"]
+  ]) {
+    const mode = enumeration(xml, ["edge", "factor"]);
+    if (mode) result[key] = mode;
+  }
+  for (const [xml, key] of [
+    ["x", "x"],
+    ["y", "y"],
+    ["w", "width"],
+    ["h", "height"]
+  ]) {
+    const raw = value(xml);
+    if (typeof raw !== "string" && typeof raw !== "number" || typeof raw === "string" && !raw.trim())
+      continue;
+    const number = Number(raw);
+    if (Number.isFinite(number)) result[key] = number;
+  }
+  return Object.keys(result).length ? result : void 0;
+}
+
+// chart/read-formatting.ts
+var c = (parent, name) => first(parent, name, NS.c);
+var a = (parent, name) => first(parent, name, NS.a);
+function entry(node) {
+  const body = c(node, "txPr");
+  const paragraph = a(body, "p");
+  const defaults = a(a(paragraph, "pPr"), "defRPr");
+  const rich = c(c(node, "tx"), "rich");
+  const richParagraph = a(rich, "p");
+  const textBody = parseDrawingTextBody(rich);
+  const manual = c(c(node, "layout"), "manualLayout");
+  const layout2 = manual ? readChartManualLayoutValues((name) => c(manual, name)?.getAttribute("val")) : void 0;
+  const overlay = c(node, "overlay")?.getAttribute("val");
+  const out = {
+    sourceXml: buildXml(node),
+    ...layout2 ? { layout: layout2 } : {},
+    ...overlay === "0" || overlay === "false" ? { overlay: false } : overlay === "1" || overlay === "true" ? { overlay: true } : {},
+    ...readChartAppearance(defaults, c(node, "spPr")),
+    ...readChartAppearance(a(a(richParagraph, "pPr"), "defRPr"), void 0),
+    ...readChartAppearance(a(a(richParagraph, "r"), "rPr"), void 0),
+    ...textBody ? { textBody, textBodyStyle: readChartAppearance(defaults, void 0) } : {}
+  };
+  if (["catAx", "dateAx", "valAx"].includes(node.localName)) {
+    const deleted = c(node, "delete")?.getAttribute("val");
+    if (deleted !== void 0) out.axisVisible = deleted !== "1" && deleted !== "true";
+    out.labelsVisible = out.axisVisible !== false && c(node, "tickLblPos")?.getAttribute("val") !== "none";
+  }
+  return out;
+}
+function readChartFormatting(root) {
+  const nodes = chartFormattingNodes(root);
+  const entries = Object.fromEntries(
+    Object.entries(nodes).flatMap(([name, node]) => node ? [[name, entry(node)]] : [])
+  );
+  const builtInStyle = readBuiltInChartStyle(root);
+  const textBody = c(root, "txPr");
+  const textDefaults = textBody ? {
+    sourceXml: buildXml(textBody),
+    ...readChartAppearance(a(a(a(textBody, "p"), "pPr"), "defRPr"), void 0)
+  } : void 0;
+  return Object.keys(entries).length ? {
+    entries,
+    sourceXml: buildXml(root),
+    ...builtInStyle === void 0 ? {} : { builtInStyle },
+    ...textDefaults ? { textDefaults } : {}
+  } : void 0;
+}
+
+// chart/data-cache.ts
+function chartCacheValues(cache) {
+  if (!cache) return [];
+  const numeric = cache.type === "number";
+  const out = [];
+  for (const point of cache.points) {
+    const text = point.value;
+    out[point.index ?? out.length] = numeric && text.trim() !== "" && Number.isFinite(Number(text)) ? Number(text) : text;
+  }
+  const size = Math.max(cache.pointCount ?? 0, out.length);
+  for (let index = 0; index < size; index++) if (out[index] === void 0) out[index] = "";
+  return out;
+}
+
+// chart/xml-fragment.ts
+var CHART_ROOT_BINDINGS = /* @__PURE__ */ new Map([
+  ["c", NS.c],
+  ["a", NS.a],
+  ["r", NS.r]
+]);
+var DECLARATION = / xmlns:([A-Za-z_][\w.-]*)="([^"]*)"/g;
+function stripDeclarations(xml, bindings) {
+  const conflicting = /* @__PURE__ */ new Set();
+  for (const [, prefix, uri] of xml.matchAll(DECLARATION))
+    if (prefix !== void 0 && bindings.has(prefix) && bindings.get(prefix) !== uri)
+      conflicting.add(prefix);
+  return xml.replace(
+    DECLARATION,
+    (match, prefix, uri) => bindings.get(prefix) === uri && !conflicting.has(prefix) ? "" : match
+  );
+}
+var innerXml = (element) => stripDeclarations(elements(element).map(buildXml).join(""), CHART_ROOT_BINDINGS);
+
+// chart/parse-util.ts
+var cChild = (parent, local) => first(parent, local, NS.c);
+var attribute = (element, name) => element?.hasAttribute(name) ? element.getAttribute(name) ?? void 0 : void 0;
+var cVal = (parent, local) => attribute(cChild(parent, local), "val");
+var path = (element) => `c:${element.parentNode?.localName ?? ""}/c:${element.localName}`;
+function malformed(context, element, value) {
+  context.issues.push({
+    code: "CHART_VALUE_INVALID",
+    message: `${path(element)} has an unreadable value "${value}".`
+  });
+}
+function cBool(context, parent, local) {
+  const element = cChild(parent, local);
+  if (!element) return void 0;
+  const raw = attribute(element, "val");
+  if (raw === void 0) return true;
+  const value = raw.trim().toLowerCase();
+  if (value === "1" || value === "true") return true;
+  if (value === "0" || value === "false") return false;
+  malformed(context, element, raw);
+  return void 0;
+}
+function cNumber(context, parent, local) {
+  const element = cChild(parent, local);
+  const raw = attribute(element, "val");
+  if (!element || raw === void 0) return void 0;
+  const value = raw.trim() ? Number(raw) : Number.NaN;
+  if (Number.isFinite(value)) return value;
+  malformed(context, element, raw);
+  return void 0;
+}
+function reportUnmodelled(context, element, handled) {
+  for (const child3 of elements(element)) {
+    if (handled.has(child3.localName)) continue;
+    context.issues.push({
+      code: "CHART_ELEMENT_NOT_MODELLED",
+      message: `${path(child3)} is not modelled; it is kept only in the source part.`
+    });
+  }
+}
+function extensionList(parent) {
+  const extLst = cChild(parent, "extLst");
+  return extLst ? buildXml(extLst) : void 0;
+}
+function readShapeFields(spPr) {
+  const out = {};
+  const fill = parseDrawingFill(spPr);
+  if (fill) out.fill = fill;
+  const line = parseDrawingLine(first(spPr, "ln", NS.a));
+  if (line) out.line = line;
+  const effects = first(spPr, "effectLst", NS.a);
+  if (effects) out.effectsXml = buildXml(effects);
+  return out;
+}
+function shapeProperties(parent) {
+  const spPr = cChild(parent, "spPr");
+  if (!spPr) return void 0;
+  const out = readShapeFields(spPr);
+  const source = innerXml(spPr);
+  if (source) out.sourceXml = source;
+  return out;
+}
+function chartTextBody(element) {
+  const body = parseDrawingTextBody(element);
+  if (!body || !element) return body;
+  const source = innerXml(element);
+  if (source) body.sourceXml = source;
+  return body;
+}
+var textProperties = (parent) => chartTextBody(cChild(parent, "txPr"));
+function chartLines(parent, local) {
+  const element = cChild(parent, local);
+  if (!element) return void 0;
+  const spPr = shapeProperties(element);
+  return spPr ? { spPr } : {};
+}
+function numberFormat(parent) {
+  const element = cChild(parent, "numFmt");
+  const formatCode = attribute(element, "formatCode");
+  if (formatCode === void 0) return void 0;
+  const linked = attribute(element, "sourceLinked");
+  return {
+    formatCode,
+    ...linked === "1" || linked === "true" ? { sourceLinked: true } : {},
+    ...linked === "0" || linked === "false" ? { sourceLinked: false } : {}
+  };
+}
+function readLayoutFields(layout2) {
+  const manual = cChild(layout2, "manualLayout");
+  return (manual && readChartManualLayoutValues((name) => cVal(manual, name))) ?? {};
+}
+function manualLayout(parent) {
+  const layout2 = cChild(parent, "layout");
+  if (!layout2) return void 0;
+  const out = readLayoutFields(layout2);
+  const source = innerXml(layout2);
+  if (source) out.sourceXml = source;
+  return out;
+}
+function assignDefined(target, values) {
+  for (const [key, value] of Object.entries(values))
+    if (value !== void 0) target[key] = value;
+  return target;
+}
+
+// chart/parse-text.ts
+function parseCache(node) {
+  const cache = {
+    type: node.localName === "numCache" || node.localName === "numLit" ? "number" : "string",
+    points: children(node, "pt", NS.c).map((pt) => {
+      const point = { value: cChild(pt, "v")?.textContent ?? "" };
+      const index = Number(attribute(pt, "idx") ?? Number.NaN);
+      if (Number.isInteger(index) && index >= 0) point.index = index;
+      const formatCode2 = attribute(pt, "formatCode");
+      if (formatCode2 !== void 0) point.formatCode = formatCode2;
+      return point;
+    })
+  };
+  const count = Number(cVal(node, "ptCount") ?? Number.NaN);
+  if (Number.isInteger(count) && count >= 0) cache.pointCount = count;
+  const formatCode = cChild(node, "formatCode")?.textContent;
+  if (formatCode) cache.formatCode = formatCode;
+  return cache;
+}
+function parseDataSource(element) {
+  if (!element) return void 0;
+  const source = {};
+  const ref = cChild(element, "numRef") ?? cChild(element, "strRef") ?? cChild(element, "multiLvlStrRef");
+  if (ref) {
+    source.kind = ref.localName;
+    const formula = cChild(ref, "f")?.textContent;
+    if (formula) source.formula = formula;
+    const cache = cChild(ref, "numCache") ?? cChild(ref, "strCache");
+    if (cache) source.cache = parseCache(cache);
+    const levels = cChild(ref, "multiLvlStrCache");
+    if (levels) {
+      source.levels = children(levels, "lvl", NS.c).map(parseCache);
+      const count = Number(cVal(levels, "ptCount") ?? Number.NaN);
+      if (Number.isInteger(count) && count >= 0) source.levelPointCount = count;
+    }
+    return source;
+  }
+  const literal = cChild(element, "numLit") ?? cChild(element, "strLit");
+  if (literal) {
+    source.kind = literal.localName;
+    source.cache = parseCache(literal);
+  }
+  return source;
+}
+function parseChartText(context, tx, allowValue) {
+  if (!tx) return void 0;
+  const text = {};
+  const rich = chartTextBody(cChild(tx, "rich"));
+  if (rich) text.rich = rich;
+  if (cChild(tx, "strRef")) {
+    const reference = parseDataSource(tx);
+    if (reference) text.reference = reference;
+  }
+  const value = allowValue ? cChild(tx, "v")?.textContent : void 0;
+  if (value !== void 0 && value !== null) text.value = value;
+  const cached2 = chartCacheValues(text.reference?.cache)[0];
+  const flat = text.value ?? (rich ? rich.text : cached2 === void 0 ? void 0 : String(cached2));
+  if (flat !== void 0) text.text = flat;
+  reportUnmodelled(context, tx, new Set(allowValue ? ["strRef", "v"] : ["rich", "strRef"]));
+  return text;
+}
+var TITLE = /* @__PURE__ */ new Set(["tx", "layout", "overlay", "spPr", "txPr", "extLst"]);
+function parseTitle(context, element) {
+  const tx = parseChartText(context, cChild(element, "tx"), false);
+  reportUnmodelled(context, element, TITLE);
+  return assignDefined(
+    {},
+    {
+      tx,
+      text: tx?.text,
+      overlay: cBool(context, element, "overlay"),
+      layout: manualLayout(element),
+      spPr: shapeProperties(element),
+      txPr: textProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var LABEL_OPTIONS = [
+  "delete",
+  "showLegendKey",
+  "showVal",
+  "showCatName",
+  "showSerName",
+  "showPercent",
+  "showBubbleSize",
+  "separator",
+  "dLblPos",
+  "numFmt",
+  "spPr",
+  "txPr",
+  "extLst"
+];
+function labelOptions(context, element) {
+  const flag2 = (local) => cBool(context, element, local);
+  return assignDefined(
+    {},
+    {
+      deleted: flag2("delete"),
+      showLegendKey: flag2("showLegendKey"),
+      showValue: flag2("showVal"),
+      showCategoryName: flag2("showCatName"),
+      showSeriesName: flag2("showSerName"),
+      showPercent: flag2("showPercent"),
+      showBubbleSize: flag2("showBubbleSize"),
+      separator: cChild(element, "separator")?.textContent ?? void 0,
+      position: cVal(element, "dLblPos"),
+      numberFormat: numberFormat(element),
+      spPr: shapeProperties(element),
+      txPr: textProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var LABEL = /* @__PURE__ */ new Set([...LABEL_OPTIONS, "idx", "layout", "tx"]);
+var LABELS = /* @__PURE__ */ new Set([...LABEL_OPTIONS, "dLbl", "showLeaderLines", "leaderLines"]);
+function parseDataLabels(context, element) {
+  if (!element) return void 0;
+  const labels = children(element, "dLbl", NS.c).map((node) => {
+    reportUnmodelled(context, node, LABEL);
+    return assignDefined(labelOptions(context, node), {
+      index: cNumber(context, node, "idx"),
+      tx: parseChartText(context, cChild(node, "tx"), false),
+      layout: manualLayout(node)
+    });
+  });
+  reportUnmodelled(context, element, LABELS);
+  return assignDefined(
+    { ...labelOptions(context, element), labels },
+    {
+      showLeaderLines: cBool(context, element, "showLeaderLines"),
+      leaderLines: chartLines(element, "leaderLines")
+    }
+  );
+}
+
+// chart/parse-chrome.ts
+var SURFACE = /* @__PURE__ */ new Set(["thickness", "spPr", "pictureOptions", "extLst"]);
+function parseSurface(context, element) {
+  if (!element) return void 0;
+  reportUnmodelled(context, element, SURFACE);
+  const pictureOptions = cChild(element, "pictureOptions");
+  return assignDefined(
+    {},
+    {
+      thickness: cNumber(context, element, "thickness"),
+      spPr: shapeProperties(element),
+      pictureOptionsXml: pictureOptions ? buildXml(pictureOptions) : void 0,
+      extLst: extensionList(element)
+    }
+  );
+}
+var DATA_TABLE = /* @__PURE__ */ new Set([
+  "showHorzBorder",
+  "showVertBorder",
+  "showOutline",
+  "showKeys",
+  "spPr",
+  "txPr",
+  "extLst"
+]);
+function parseDataTable(context, element) {
+  if (!element) return void 0;
+  reportUnmodelled(context, element, DATA_TABLE);
+  return assignDefined(
+    {},
+    {
+      showHorizontalBorder: cBool(context, element, "showHorzBorder"),
+      showVerticalBorder: cBool(context, element, "showVertBorder"),
+      showOutline: cBool(context, element, "showOutline"),
+      showKeys: cBool(context, element, "showKeys"),
+      spPr: shapeProperties(element),
+      txPr: textProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var DISPLAY_UNITS = /* @__PURE__ */ new Set(["custUnit", "builtInUnit", "dispUnitsLbl", "extLst"]);
+var DISPLAY_UNITS_LABEL = /* @__PURE__ */ new Set(["layout", "tx", "spPr", "txPr"]);
+function parseDisplayUnits(context, element) {
+  if (!element) return void 0;
+  reportUnmodelled(context, element, DISPLAY_UNITS);
+  const labelElement = cChild(element, "dispUnitsLbl");
+  let label;
+  if (labelElement) {
+    reportUnmodelled(context, labelElement, DISPLAY_UNITS_LABEL);
+    label = assignDefined(
+      {},
+      {
+        layout: manualLayout(labelElement),
+        tx: parseChartText(context, cChild(labelElement, "tx"), false),
+        spPr: shapeProperties(labelElement),
+        txPr: textProperties(labelElement)
+      }
+    );
+  }
+  return assignDefined(
+    {},
+    {
+      builtInUnit: cVal(element, "builtInUnit"),
+      customUnit: cNumber(context, element, "custUnit"),
+      label,
+      extLst: extensionList(element)
+    }
+  );
+}
+
+// chart/parse-series.ts
+var MARKER = /* @__PURE__ */ new Set(["symbol", "size", "spPr", "extLst"]);
+function parseMarker(context, element) {
+  if (!element) return void 0;
+  reportUnmodelled(context, element, MARKER);
+  return assignDefined(
+    {},
+    {
+      symbol: cVal(element, "symbol"),
+      size: cNumber(context, element, "size"),
+      spPr: shapeProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var POINT = /* @__PURE__ */ new Set([
+  "idx",
+  "invertIfNegative",
+  "marker",
+  "bubble3D",
+  "explosion",
+  "spPr",
+  "extLst"
+]);
+function parseDataPoint(context, element) {
+  reportUnmodelled(context, element, POINT);
+  const index = cNumber(context, element, "idx");
+  return assignDefined(
+    {},
+    {
+      index: index !== void 0 && Number.isInteger(index) && index >= 0 ? index : void 0,
+      invertIfNegative: cBool(context, element, "invertIfNegative"),
+      bubble3D: cBool(context, element, "bubble3D"),
+      explosion: cNumber(context, element, "explosion"),
+      marker: parseMarker(context, cChild(element, "marker")),
+      spPr: shapeProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var SERIES = /* @__PURE__ */ new Set([
+  "idx",
+  "order",
+  "tx",
+  "spPr",
+  "invertIfNegative",
+  "dPt",
+  "dLbls",
+  "cat",
+  "val",
+  "xVal",
+  "yVal",
+  "smooth",
+  "marker",
+  "explosion",
+  "bubbleSize",
+  "bubble3D",
+  "shape",
+  "extLst"
+]);
+function parseSeries(context, element) {
+  reportUnmodelled(context, element, SERIES);
+  return assignDefined(
+    { dataPoints: children(element, "dPt", NS.c).map((point) => parseDataPoint(context, point)) },
+    {
+      index: cNumber(context, element, "idx"),
+      order: cNumber(context, element, "order"),
+      tx: parseChartText(context, cChild(element, "tx"), true),
+      spPr: shapeProperties(element),
+      marker: parseMarker(context, cChild(element, "marker")),
+      dataLabels: parseDataLabels(context, cChild(element, "dLbls")),
+      categories: parseDataSource(cChild(element, "cat")),
+      values: parseDataSource(cChild(element, "val")),
+      xValues: parseDataSource(cChild(element, "xVal")),
+      yValues: parseDataSource(cChild(element, "yVal")),
+      bubbleSizes: parseDataSource(cChild(element, "bubbleSize")),
+      smooth: cBool(context, element, "smooth"),
+      invertIfNegative: cBool(context, element, "invertIfNegative"),
+      explosion: cNumber(context, element, "explosion"),
+      bubble3D: cBool(context, element, "bubble3D"),
+      shape: cVal(element, "shape"),
+      extLst: extensionList(element)
+    }
+  );
+}
+
+// chart/parse-plot.ts
+var CHART_GROUP_ELEMENTS = {
+  barChart: { kind: "bar", is3D: false },
+  bar3DChart: { kind: "bar", is3D: true },
+  lineChart: { kind: "line", is3D: false },
+  line3DChart: { kind: "line", is3D: true },
+  areaChart: { kind: "area", is3D: false },
+  area3DChart: { kind: "area", is3D: true },
+  pieChart: { kind: "pie", is3D: false },
+  pie3DChart: { kind: "pie", is3D: true },
+  ofPieChart: { kind: "ofPie", is3D: false },
+  doughnutChart: { kind: "doughnut", is3D: false },
+  scatterChart: { kind: "scatter", is3D: false },
+  radarChart: { kind: "radar", is3D: false },
+  bubbleChart: { kind: "bubble", is3D: false },
+  stockChart: { kind: "stock", is3D: false },
+  surfaceChart: { kind: "surface", is3D: false },
+  surface3DChart: { kind: "surface", is3D: true }
+};
+var AXIS_ELEMENTS = {
+  catAx: "cat",
+  valAx: "val",
+  dateAx: "date",
+  serAx: "ser"
+};
+var GROUP = /* @__PURE__ */ new Set([
+  "ser",
+  "axId",
+  "varyColors",
+  "dLbls",
+  "barDir",
+  "grouping",
+  "gapWidth",
+  "overlap",
+  "gapDepth",
+  "shape",
+  "marker",
+  "smooth",
+  "dropLines",
+  "hiLowLines",
+  "upDownBars",
+  "serLines",
+  "firstSliceAng",
+  "holeSize",
+  "ofPieType",
+  "scatterStyle",
+  "radarStyle",
+  "bubble3D",
+  "bubbleScale",
+  "showNegBubbles",
+  "sizeRepresents",
+  "wireframe",
+  "extLst"
+]);
+function parseGroup(context, element) {
+  const { kind, is3D } = CHART_GROUP_ELEMENTS[element.localName] ?? { kind: "bar", is3D: false };
+  reportUnmodelled(context, element, GROUP);
+  const number = (local) => cNumber(context, element, local);
+  const flag2 = (local) => cBool(context, element, local);
+  const barDir = cVal(element, "barDir");
+  const present = (local) => cChild(element, local) ? true : void 0;
+  const linesShape = (local) => chartLines(element, local)?.spPr;
+  const bars = cChild(element, "upDownBars");
+  return assignDefined(
+    {
+      kind,
+      element: element.localName,
+      is3D,
+      series: children(element, "ser", NS.c).map((ser) => parseSeries(context, ser)),
+      axisIds: children(element, "axId", NS.c).flatMap((axis) => {
+        const raw = attribute(axis, "val")?.trim();
+        const id = raw ? Number(raw) : Number.NaN;
+        return Number.isFinite(id) ? [id] : [];
+      })
+    },
+    {
+      varyColors: flag2("varyColors"),
+      dataLabels: parseDataLabels(context, cChild(element, "dLbls")),
+      barDirection: barDir === "bar" || barDir === "col" ? barDir : void 0,
+      grouping: cVal(element, "grouping"),
+      gapWidth: number("gapWidth"),
+      overlap: number("overlap"),
+      gapDepth: number("gapDepth"),
+      shape: cVal(element, "shape"),
+      marker: flag2("marker"),
+      smooth: flag2("smooth"),
+      dropLines: present("dropLines"),
+      hiLowLines: present("hiLowLines"),
+      upDownBars: present("upDownBars"),
+      seriesLines: present("serLines"),
+      dropLinesSpPr: linesShape("dropLines"),
+      hiLowLinesSpPr: linesShape("hiLowLines"),
+      seriesLinesSpPr: linesShape("serLines"),
+      upDownBarsGapWidth: cNumber(context, bars, "gapWidth"),
+      upBars: chartLines(bars, "upBars"),
+      downBars: chartLines(bars, "downBars"),
+      firstSliceAngle: number("firstSliceAng"),
+      holeSize: number("holeSize"),
+      ofPieType: cVal(element, "ofPieType"),
+      scatterStyle: cVal(element, "scatterStyle"),
+      radarStyle: cVal(element, "radarStyle"),
+      bubble3D: flag2("bubble3D"),
+      bubbleScale: number("bubbleScale"),
+      showNegativeBubbles: flag2("showNegBubbles"),
+      sizeRepresents: cVal(element, "sizeRepresents"),
+      wireframe: flag2("wireframe"),
+      extLst: extensionList(element)
+    }
+  );
+}
+var SCALING = /* @__PURE__ */ new Set(["orientation", "logBase", "min", "max", "extLst"]);
+var AXIS = /* @__PURE__ */ new Set([
+  "axId",
+  "scaling",
+  "delete",
+  "axPos",
+  "majorGridlines",
+  "minorGridlines",
+  "title",
+  "numFmt",
+  "majorTickMark",
+  "minorTickMark",
+  "tickLblPos",
+  "spPr",
+  "txPr",
+  "crossAx",
+  "crosses",
+  "crossesAt",
+  "crossBetween",
+  "majorUnit",
+  "minorUnit",
+  "auto",
+  "lblAlgn",
+  "lblOffset",
+  "tickLblSkip",
+  "tickMarkSkip",
+  "noMultiLvlLbl",
+  "baseTimeUnit",
+  "dispUnits",
+  "extLst"
+]);
+function parseAxis(context, element, kind) {
+  reportUnmodelled(context, element, AXIS);
+  const number = (local) => cNumber(context, element, local);
+  const scalingElement = cChild(element, "scaling");
+  if (scalingElement) reportUnmodelled(context, scalingElement, SCALING);
+  const scaling = assignDefined(
+    {},
+    {
+      orientation: cVal(scalingElement, "orientation"),
+      min: cNumber(context, scalingElement, "min"),
+      max: cNumber(context, scalingElement, "max"),
+      logBase: cNumber(context, scalingElement, "logBase")
+    }
+  );
+  const title = cChild(element, "title");
+  return assignDefined(
+    {
+      kind,
+      scaling,
+      majorGridlines: cChild(element, "majorGridlines") !== void 0,
+      minorGridlines: cChild(element, "minorGridlines") !== void 0
+    },
+    {
+      majorGridlinesSpPr: chartLines(element, "majorGridlines")?.spPr,
+      minorGridlinesSpPr: chartLines(element, "minorGridlines")?.spPr,
+      id: number("axId"),
+      crossAxisId: number("crossAx"),
+      position: cVal(element, "axPos"),
+      deleted: cBool(context, element, "delete"),
+      title: title ? parseTitle(context, title) : void 0,
+      numberFormat: numberFormat(element),
+      majorTickMark: cVal(element, "majorTickMark"),
+      minorTickMark: cVal(element, "minorTickMark"),
+      tickLabelPosition: cVal(element, "tickLblPos"),
+      crosses: cVal(element, "crosses"),
+      crossesAt: number("crossesAt"),
+      crossBetween: cVal(element, "crossBetween"),
+      majorUnit: number("majorUnit"),
+      minorUnit: number("minorUnit"),
+      auto: cBool(context, element, "auto"),
+      labelAlign: cVal(element, "lblAlgn"),
+      labelOffset: number("lblOffset"),
+      tickLabelSkip: number("tickLblSkip"),
+      tickMarkSkip: number("tickMarkSkip"),
+      noMultiLevelLabels: cBool(context, element, "noMultiLvlLbl"),
+      baseTimeUnit: cVal(element, "baseTimeUnit"),
+      displayUnits: parseDisplayUnits(context, cChild(element, "dispUnits")),
+      spPr: shapeProperties(element),
+      txPr: textProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var PLOT_AREA = /* @__PURE__ */ new Set(["layout", "dTable", "spPr", "extLst"]);
+function parsePlotArea(context, element) {
+  const plotArea = { groups: [], axes: [] };
+  if (!element) {
+    context.issues.push({
+      code: "CHART_PLOT_AREA_MISSING",
+      message: "The chart has no c:plotArea."
+    });
+    return plotArea;
+  }
+  const handled = new Set(PLOT_AREA);
+  for (const child3 of elements(element)) {
+    if (CHART_GROUP_ELEMENTS[child3.localName]) {
+      plotArea.groups.push(parseGroup(context, child3));
+      handled.add(child3.localName);
+    }
+    const axis = AXIS_ELEMENTS[child3.localName];
+    if (axis) {
+      plotArea.axes.push(parseAxis(context, child3, axis));
+      handled.add(child3.localName);
+    }
+  }
+  reportUnmodelled(context, element, handled);
+  return assignDefined(plotArea, {
+    layout: manualLayout(element),
+    dataTable: parseDataTable(context, cChild(element, "dTable")),
+    spPr: shapeProperties(element),
+    extLst: extensionList(element)
+  });
+}
+
+// chart/parse-space.ts
+var LEGEND = /* @__PURE__ */ new Set(["legendPos", "legendEntry", "layout", "overlay", "spPr", "txPr", "extLst"]);
+function parseLegend(context, element) {
+  reportUnmodelled(context, element, LEGEND);
+  const entries = children(element, "legendEntry", NS.c).map(
+    (entry2) => assignDefined(
+      {},
+      {
+        index: cNumber(context, entry2, "idx"),
+        deleted: cBool(context, entry2, "delete"),
+        txPr: textProperties(entry2)
+      }
+    )
+  );
+  return assignDefined(
+    { entries },
+    {
+      position: cVal(element, "legendPos"),
+      overlay: cBool(context, element, "overlay"),
+      layout: manualLayout(element),
+      spPr: shapeProperties(element),
+      txPr: textProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var VIEW_3D = /* @__PURE__ */ new Set(["rotX", "rotY", "depthPercent", "hPercent", "rAngAx", "perspective"]);
+function parseView3D(context, element) {
+  reportUnmodelled(context, element, VIEW_3D);
+  return assignDefined(
+    {},
+    {
+      rotX: cNumber(context, element, "rotX"),
+      rotY: cNumber(context, element, "rotY"),
+      depthPercent: cNumber(context, element, "depthPercent"),
+      heightPercent: cNumber(context, element, "hPercent"),
+      rightAngleAxes: cBool(context, element, "rAngAx"),
+      perspective: cNumber(context, element, "perspective")
+    }
+  );
+}
+function chartStyle(context, space) {
+  const direct = cNumber(context, space, "style");
+  if (direct !== void 0) return direct;
+  for (const alternate of children(space, "AlternateContent", NS.mc)) {
+    const style = cNumber(context, first(alternate, "Fallback", NS.mc), "style");
+    if (style !== void 0) return style;
+  }
+  return void 0;
+}
+function c14Style(space) {
+  for (const alternate of children(space, "AlternateContent", NS.mc)) {
+    const raw = attribute(first(first(alternate, "Choice", NS.mc), "style", NS.c14, false), "val");
+    const value = raw?.trim() ? Number(raw) : Number.NaN;
+    if (Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+function namespaceDeclarations(root) {
+  const out = [];
+  for (const item of Array.from(root.attributes)) {
+    if (item.prefix !== "xmlns" || CHART_ROOT_BINDINGS.get(item.localName) === item.value) continue;
+    out.push({ prefix: item.localName, uri: item.value });
+  }
+  return out.length ? out : void 0;
+}
+var CHART = /* @__PURE__ */ new Set([
+  "title",
+  "autoTitleDeleted",
+  "view3D",
+  "floor",
+  "sideWall",
+  "backWall",
+  "plotArea",
+  "legend",
+  "plotVisOnly",
+  "dispBlanksAs",
+  "showDLblsOverMax",
+  "extLst"
+]);
+var SPACE = /* @__PURE__ */ new Set([
+  "date1904",
+  "lang",
+  "roundedCorners",
+  "AlternateContent",
+  "style",
+  "chart",
+  "spPr",
+  "txPr",
+  "externalData",
+  "printSettings",
+  "userShapes",
+  "extLst"
+]);
+function parseChartSpace(source) {
+  const context = { issues: [] };
+  const root = typeof source === "string" ? parseXml(source, { label: "Chart part" }).documentElement : source;
+  if (root.localName !== "chartSpace" || root.namespaceURI && root.namespaceURI !== NS.c) {
+    context.issues.push({
+      code: "CHART_ROOT_UNEXPECTED",
+      message: `The part root is {${root.namespaceURI ?? ""}}${root.localName}, not c:chartSpace (chartex parts are not modelled).`
+    });
+    return { chartSpace: { plotArea: { groups: [], axes: [] } }, issues: context.issues };
+  }
+  reportUnmodelled(context, root, SPACE);
+  const chart = cChild(root, "chart");
+  if (!chart)
+    context.issues.push({ code: "CHART_CHART_MISSING", message: "The part has no c:chart." });
+  else reportUnmodelled(context, chart, CHART);
+  const title = cChild(chart, "title");
+  const legend = cChild(chart, "legend");
+  const view3D = cChild(chart, "view3D");
+  const printSettings = cChild(root, "printSettings");
+  const chartSpace = assignDefined(
+    { plotArea: parsePlotArea(context, cChild(chart, "plotArea")) },
+    {
+      date1904: cBool(context, root, "date1904"),
+      language: cVal(root, "lang"),
+      roundedCorners: cBool(context, root, "roundedCorners"),
+      style: chartStyle(context, root),
+      c14Style: c14Style(root),
+      title: title ? parseTitle(context, title) : void 0,
+      autoTitleDeleted: cBool(context, chart, "autoTitleDeleted"),
+      view3D: view3D ? parseView3D(context, view3D) : void 0,
+      floor: parseSurface(context, cChild(chart, "floor")),
+      sideWall: parseSurface(context, cChild(chart, "sideWall")),
+      backWall: parseSurface(context, cChild(chart, "backWall")),
+      legend: legend ? parseLegend(context, legend) : void 0,
+      plotVisibleOnly: cBool(context, chart, "plotVisOnly"),
+      displayBlanksAs: cVal(chart, "dispBlanksAs"),
+      showDataLabelsOverMax: cBool(context, chart, "showDLblsOverMax"),
+      spPr: shapeProperties(root),
+      txPr: textProperties(root),
+      externalDataRelId: relAttr(cChild(root, "externalData"), "id") || void 0,
+      externalDataAutoUpdate: cBool(context, cChild(root, "externalData"), "autoUpdate"),
+      printSettings: printSettings ? buildXml(printSettings) : void 0,
+      userShapesRelId: relAttr(cChild(root, "userShapes"), "id") || void 0,
+      chartExtLst: extensionList(chart),
+      extLst: extensionList(root),
+      namespaceDeclarations: namespaceDeclarations(root)
+    }
+  );
+  return { chartSpace, issues: context.issues };
+}
+
+// docx/breaks.ts
+function isCachedPageBreak(element) {
+  return named2(element, "lastRenderedPageBreak") && !element.childNodes.length && Array.from(element.attributes).every(
+    (attribute2) => attribute2.namespaceURI === "http://www.w3.org/2000/xmlns/"
+  );
+}
+function hasSpecialBreak(element) {
+  for (const attribute2 of Array.from(element.attributes)) {
+    if (attribute2.namespaceURI === "http://www.w3.org/2000/xmlns/") continue;
+    if (attribute2.namespaceURI !== WORD_NS) return true;
+    if (attribute2.localName === "type") {
+      if (attribute2.value !== "textWrapping") return true;
+    } else if (attribute2.localName === "clear") {
+      if (attribute2.value !== "none") return true;
+    } else return true;
+  }
+  return false;
+}
+function classifyBreak(element) {
+  const type = getW(element, "type");
+  return type === "page" || type === "column" ? type : "textWrapping";
+}
+function isModeledBreak(element) {
+  const kind = classifyBreak(element);
+  if (kind === "textWrapping") return false;
+  for (const attribute2 of Array.from(element.attributes)) {
+    if (attribute2.namespaceURI === "http://www.w3.org/2000/xmlns/") continue;
+    if (attribute2.namespaceURI !== WORD_NS || attribute2.localName !== "type") return false;
+  }
+  return true;
+}
+
+// docx/parse-warnings.ts
+function hasAny(document, names) {
+  return names.some((name) => document.getElementsByTagNameNS(WORD_NS, name).length > 0);
+}
+function warningsFor(document) {
+  const warnings = [];
+  const features = [
+    [["object"], "Embedded OLE objects (w:object) are preserved but rendered as a placeholder."],
+    [["altChunk"], "Embedded alternate-format content is not represented in the document model."],
+    [
+      ["fldSimple", "instrText", "fldChar"],
+      "Fields show the result Word last saved while editing; Print Layout recalculates PAGE, NUMPAGES, SECTIONPAGES, DATE and TIME, and tables of contents update from the References tab."
+    ],
+    [
+      ["moveFrom", "moveTo"],
+      "Moved text is linked by its move name: accepting or rejecting either side resolves both. Moves are shown and saved with their range markers."
+    ],
+    [
+      ["rPrChange"],
+      "Formatting-change revisions retain their prior run-properties snapshots and support acceptance and rejection; recording new formatting changes and showing prior formatting in Original display are not supported yet."
+    ],
+    [
+      ["pPrChange"],
+      "Paragraph-formatting-change revisions retain their prior properties snapshots and support acceptance and rejection; recording new paragraph formatting changes and showing prior formatting in Original display are not supported yet."
+    ],
+    [
+      ["tblPrChange", "trPrChange", "tcPrChange"],
+      "Table-structure tracked changes are preserved in the source XML but are not represented in the document model."
+    ]
+  ];
+  for (const [names, message] of features) if (hasAny(document, names)) warnings.push(message);
+  if (Array.from(document.getElementsByTagNameNS(WORD_NS, "instrText")).some(
+    (el3) => /HYPERLINK/i.test(textContent(el3))
+  ))
+    warnings.push(
+      "Complex HYPERLINK field codes (w:fldChar/w:instrText) are preserved but not parsed as links; their result text edits as plain text."
+    );
+  const specialBreak = Array.from(document.getElementsByTagNameNS(WORD_NS, "br")).some(
+    (br) => hasSpecialBreak(br) && !isModeledBreak(br)
+  ) || Array.from(document.getElementsByTagNameNS(WORD_NS, "cr")).some(
+    (cr) => cr.attributes.length > 0
+  );
+  if (specialBreak)
+    warnings.push(
+      "Some non-line breaks other than page and column breaks are not distinguished from line breaks in the document model; edits to paragraphs containing them are rejected to preserve the original XML."
+    );
+  return warnings;
+}
+function forEachParagraph2(blocks, visit) {
+  for (const block of blocks) {
+    if (block.type === "paragraph") visit(block);
+    else for (const row of block.rows) for (const cell of row) cell.paragraphs.forEach(visit);
+  }
+}
+function imageAndBookmarkWarnings(blocks) {
+  const warnings = [];
+  let hasPicture = false;
+  let hasAnchored = false;
+  const unsupportedKinds = /* @__PURE__ */ new Set();
+  let hasBookmarks = false;
+  forEachParagraph2(blocks, (paragraph) => {
+    if (paragraph.bookmarks?.length) hasBookmarks = true;
+    for (const run of paragraph.runs) {
+      if (!run.image) continue;
+      if (run.image.unsupported) {
+        if (run.image.diagram?.rendering !== "cached-drawing")
+          unsupportedKinds.add(run.image.unsupported);
+      } else hasPicture = true;
+      if (run.image.anchored) hasAnchored = true;
+    }
+  });
+  if (hasPicture)
+    warnings.push(
+      "Inline pictures render from their original bytes and can be deleted or newly inserted; crop, artistic effects, and non-inline text wrapping are not reproduced."
+    );
+  if (hasAnchored)
+    warnings.push(
+      "Floating pictures follow their text wrapping approximately (floated left or right, or on their own line); exact positions, vertical offsets and in-front/behind layering are not reproduced."
+    );
+  if (unsupportedKinds.size)
+    warnings.push(
+      `${Array.from(unsupportedKinds).join(", ")} content is rendered as a labeled placeholder and is not editable.`
+    );
+  if (hasBookmarks)
+    warnings.push(
+      "Bookmark names are read-only; editing a paragraph that contains bookmarks preserves them but moves their start/end to the paragraph boundaries."
+    );
+  return warnings;
+}
+
+// docx/chart.ts
+var CHART_GRAPHIC_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+var CHART_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
+var PACKAGE_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/package";
+var CHART_NOTICE = "The chart is drawn from the values cached in its part (bar, column, line, area, pie, doughnut, scatter and radar charts; other kinds show a labelled frame). It is not editable, and the chart part and its workbook are preserved unchanged on save.";
+function parseChartGraphic(graphicData, docPr, rels, isAnchor) {
+  const element = Array.from(graphicData.childNodes).find(
+    (node) => isElement(node) && node.localName === "chart"
+  );
+  const relId = getR(element, "id") || void 0;
+  const issues = [];
+  let partName;
+  const rel = relId ? rels.get(relId) : void 0;
+  if (!relId)
+    issues.push({
+      code: "CHART_RELATIONSHIP_MISSING",
+      message: "The graphic has no c:chart/@r:id."
+    });
+  else if (!rel || rel.mode === "External")
+    issues.push({
+      code: "CHART_RELATIONSHIP_UNRESOLVED",
+      message: `Chart relationship ${relId} does not point at a part in this package.`
+    });
+  else {
+    if (rel.type !== CHART_RELATIONSHIP_TYPE)
+      issues.push({
+        code: "CHART_RELATIONSHIP_TYPE",
+        message: `Chart relationship ${relId} has type ${rel.type}, expected ${CHART_RELATIONSHIP_TYPE}.`
+      });
+    partName = resolvePartPath("word/document.xml", rel.target);
+  }
+  const name = docPr?.getAttribute("name") || void 0;
+  const id = docPr?.getAttribute("id") || void 0;
+  return {
+    placement: isAnchor ? "anchor" : "inline",
+    ...name ? { name } : {},
+    ...id ? { id } : {},
+    ...relId ? { relId } : {},
+    ...partName ? { partName } : {},
+    notice: CHART_NOTICE,
+    issues
+  };
+}
+async function resolveChartPart(chart, readText) {
+  if (!chart.partName) return;
+  try {
+    const xml = await readText(chart.partName);
+    if (xml === void 0) {
+      chart.issues.push({
+        code: "CHART_PART_MISSING",
+        message: `The chart part ${chart.partName} is not in the package.`
+      });
+      return;
+    }
+    const root = parseXml(xml, { label: "Chart part" }).documentElement;
+    const { chartSpace, issues } = parseChartSpace(root);
+    chart.chartSpace = chartSpace;
+    chart.issues.push(...issues);
+    const title = chartSpace.autoTitleDeleted ? void 0 : chartSpace.title?.text;
+    if (title) chart.title = title;
+    if (chartSpace.plotArea.groups.length) {
+      const formatting = readChartFormatting(root);
+      if (formatting) chart.formatting = formatting;
+    }
+    const rels = parseRelationships(await readText(relationshipsPartFor(chart.partName)));
+    const dataRelId = chartSpace.externalDataRelId;
+    const dataRel = dataRelId ? rels.get(dataRelId) : void 0;
+    if (dataRel && dataRel.mode !== "External" && dataRel.type === PACKAGE_RELATIONSHIP_TYPE)
+      chart.workbookPartName = resolvePartPath(chart.partName, dataRel.target);
+    const colorsRel = [...rels.values()].find(
+      (rel) => rel.mode !== "External" && rel.type.endsWith("/chartColorStyle")
+    );
+    const colorsXml = colorsRel && await readText(resolvePartPath(chart.partName, colorsRel.target));
+    const palette = colorsXml ? chartColorStyleId(colorsXml) : void 0;
+    if (palette !== void 0) chart.colorPalette = palette;
+  } catch (error) {
+    chart.issues.push({
+      code: "CHART_PART_UNREADABLE",
+      message: `The chart part ${chart.partName} could not be read: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+}
+function chartsIn(blocks) {
+  const charts = [];
+  forEachParagraph2(blocks, (paragraph) => {
+    for (const run of paragraph.runs) if (run.image?.chart) charts.push(run.image.chart);
+  });
+  return charts;
+}
+async function resolveDocumentCharts(blocks, readText) {
+  for (const chart of chartsIn(blocks)) await resolveChartPart(chart, readText);
+}
+
 // docx/drawing.ts
 var WP_NS2 = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
 var A_NS2 = "http://schemas.openxmlformats.org/drawingml/2006/main";
@@ -4472,6 +5655,7 @@ function parseModernDrawing(node, context) {
       ...svg ? { svgPartName: svg.partName } : {}
     };
   const diagram = uri === DIAGRAM_GRAPHIC_URI && graphicData ? parseDiagramGraphic(graphicData, extent, docPr, context.rels, Boolean(anchored)) : void 0;
+  const chart = uri === CHART_GRAPHIC_URI && graphicData ? parseChartGraphic(graphicData, docPr, context.rels, Boolean(anchored)) : void 0;
   const textBox = uri.includes("wordprocessingShape") ? textBoxParagraphs(graphicData) : void 0;
   return {
     relId: relId ?? "",
@@ -4482,6 +5666,7 @@ function parseModernDrawing(node, context) {
     ...definedProps({ altText, title, anchored }),
     unsupported: textBox ? "Text box" : unsupportedKindLabel(uri),
     ...diagram ? { diagram } : {},
+    ...chart ? { chart } : {},
     ...diagram && placement ? { placement } : {},
     ...textBox ? { textBoxText: textBox } : {},
     ...textBox && isSimpleTextBox(graphicData, Boolean(anchored)) ? { textBoxEditable: true, textBoxBorder: textBoxHasBorder(graphicData) } : {}
@@ -4561,8 +5746,8 @@ function findDrawingChild(run) {
     if (isElement(child3) && (named2(child3, "drawing") || named2(child3, "pict"))) return child3;
   return void 0;
 }
-function sameUnderlyingImage(a, b) {
-  return Boolean(a.partName) && a.relId === b.relId && a.partName === b.partName;
+function sameUnderlyingImage(a2, b) {
+  return Boolean(a2.partName) && a2.relId === b.relId && a2.partName === b.partName;
 }
 function walk(root, visit) {
   const stack = [root];
@@ -4772,17 +5957,17 @@ function setBooleanAttribute(doc, props, local, value) {
   }
   setAttribute6(element, "val", value ? "1" : "0");
 }
-function setLanguageAttribute(doc, props, attribute, value) {
+function setLanguageAttribute(doc, props, attribute2, value) {
   let language = first2(props, "lang");
   if (value === void 0 || value === "") {
     if (!language) return;
-    language.removeAttributeNS(WORD_NS, attribute);
+    language.removeAttributeNS(WORD_NS, attribute2);
   } else {
     if (!language) {
       language = makeW(doc, "lang");
       props.appendChild(language);
     }
-    setAttribute6(language, attribute, value);
+    setAttribute6(language, attribute2, value);
   }
   if (language && !language.attributes.length && !language.childNodes.length)
     props.removeChild(language);
@@ -4882,8 +6067,8 @@ function setRunProperties(doc, runNode, run, base) {
       };
       for (const script of ["ascii", "hAnsi", "eastAsia", "cs"]) {
         const role = run.fontTheme?.[script];
-        const [attribute, suffix] = themeAttribute[script];
-        if (role) setAttribute6(fonts, attribute, `${role}${suffix}`);
+        const [attribute2, suffix] = themeAttribute[script];
+        if (role) setAttribute6(fonts, attribute2, `${role}${suffix}`);
       }
       props.appendChild(fonts);
     }
@@ -4971,8 +6156,8 @@ function createRun(doc, run, base, old, allocator) {
 }
 
 // docx/inline-source.ts
-function samePictureSource(a, b) {
-  return !!a?.partName && a.partName === b?.partName && a.relId === b?.relId;
+function samePictureSource(a2, b) {
+  return !!a2?.partName && a2.partName === b?.partName && a2.relId === b?.relId;
 }
 function inlineSourceLookup(runs, base) {
   const usedPictures = /* @__PURE__ */ new Set();
@@ -5014,8 +6199,8 @@ function takeSimpleFieldCommentEdges(doc, runs, start, end, opens, closes) {
 }
 
 // docx/field-lock.ts
-function sameFieldFlags(a, b) {
-  return a?.locked === b?.locked && a?.dirty === b?.dirty;
+function sameFieldFlags(a2, b) {
+  return a2?.locked === b?.locked && a2?.dirty === b?.dirty;
 }
 var MATH_NAMESPACES = /* @__PURE__ */ new Set([
   "http://schemas.openxmlformats.org/officeDocument/2006/math",
@@ -5042,38 +6227,6 @@ function preserveEquation(run, base, old) {
   return old.cloneNode(true);
 }
 
-// docx/breaks.ts
-function isCachedPageBreak(element) {
-  return named2(element, "lastRenderedPageBreak") && !element.childNodes.length && Array.from(element.attributes).every(
-    (attribute) => attribute.namespaceURI === "http://www.w3.org/2000/xmlns/"
-  );
-}
-function hasSpecialBreak(element) {
-  for (const attribute of Array.from(element.attributes)) {
-    if (attribute.namespaceURI === "http://www.w3.org/2000/xmlns/") continue;
-    if (attribute.namespaceURI !== WORD_NS) return true;
-    if (attribute.localName === "type") {
-      if (attribute.value !== "textWrapping") return true;
-    } else if (attribute.localName === "clear") {
-      if (attribute.value !== "none") return true;
-    } else return true;
-  }
-  return false;
-}
-function classifyBreak(element) {
-  const type = getW(element, "type");
-  return type === "page" || type === "column" ? type : "textWrapping";
-}
-function isModeledBreak(element) {
-  const kind = classifyBreak(element);
-  if (kind === "textWrapping") return false;
-  for (const attribute of Array.from(element.attributes)) {
-    if (attribute.namespaceURI === "http://www.w3.org/2000/xmlns/") continue;
-    if (attribute.namespaceURI !== WORD_NS || attribute.localName !== "type") return false;
-  }
-  return true;
-}
-
 // docx/parse-revisions.ts
 var REVISION_WRAPPERS = {
   ins: "insert",
@@ -5095,7 +6248,7 @@ function trackMoveRange(item, moves) {
   const open = moves[range.kind];
   if (range.start) open.push({ name: getW(item, "name") ?? id, id });
   else {
-    const index = open.findIndex((entry) => entry.id === id);
+    const index = open.findIndex((entry2) => entry2.id === id);
     if (index >= 0) open.splice(index, 1);
   }
   return true;
@@ -5268,10 +6421,10 @@ function replaceableInlineChildren(paragraph) {
     (child3) => isElement(child3) && (isEquationElement(child3) || named2(child3, "r") || named2(child3, "hyperlink") || named2(child3, "fldSimple") || isRevisionWrapperElement(child3) || isCommentAnchorElement(child3))
   );
 }
-function sameLink(a, b) {
-  if (!a && !b) return true;
-  if (!a || !b) return false;
-  return a.href === b.href && a.anchor === b.anchor && a.tooltip === b.tooltip;
+function sameLink(a2, b) {
+  if (!a2 && !b) return true;
+  if (!a2 || !b) return false;
+  return a2.href === b.href && a2.anchor === b.anchor && a2.tooltip === b.tooltip;
 }
 function setW6(element, local, value) {
   element.setAttributeNS(WORD_NS, `w:${local}`, value);
@@ -5360,10 +6513,10 @@ function containerGroup(run) {
     };
   return void 0;
 }
-function sameGroup(a, b) {
-  if (!a || !b) return a === b;
-  if (a.kind === "link" && b.kind === "link") return sameLink(a.link, b.link);
-  return a.kind === "simpleField" && b.kind === "simpleField" && a.instr === b.instr && a.instanceId === b.instanceId && sameFieldFlags(a.fieldFlags, b.fieldFlags);
+function sameGroup(a2, b) {
+  if (!a2 || !b) return a2 === b;
+  if (a2.kind === "link" && b.kind === "link") return sameLink(a2.link, b.link);
+  return a2.kind === "simpleField" && b.kind === "simpleField" && a2.instr === b.instr && a2.instanceId === b.instanceId && sameFieldFlags(a2.fieldFlags, b.fieldFlags);
 }
 
 // docx/paragraph-properties.ts
@@ -5595,8 +6748,8 @@ var IMAGE_RELATIONSHIP_TYPE = RELATIONSHIP_TYPES.image;
 function scanUsedRelationshipIds(doc) {
   const used = /* @__PURE__ */ new Set();
   const visit = (node) => {
-    for (const attribute of Array.from(node.attributes))
-      if (attribute.namespaceURI === REL_NS) used.add(attribute.value);
+    for (const attribute2 of Array.from(node.attributes))
+      if (attribute2.namespaceURI === REL_NS) used.add(attribute2.value);
     for (const child3 of Array.from(node.childNodes)) if (isElement(child3)) visit(child3);
   };
   if (doc.documentElement) visit(doc.documentElement);
@@ -5834,9 +6987,9 @@ function isXsdDateTime(value) {
   return !zone || Number(zone[1]) <= 14 && Number(zone[2]) <= 59;
 }
 var Checker = class _Checker {
-  constructor(issues, path) {
+  constructor(issues, path2) {
     this.issues = issues;
-    this.path = path;
+    this.path = path2;
   }
   issues;
   path;
@@ -5882,78 +7035,78 @@ var Checker = class _Checker {
 
 // docx/validate-paragraph.ts
 var isFraction = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
-function validateThemeReference(c, field, value) {
+function validateThemeReference(c2, field, value) {
   if (value === void 0) return;
-  const at = c.at(`.${field}`);
+  const at = c2.at(`.${field}`);
   at.theme("token", value.token);
   at.check("tint", value.tint, isFraction, "must be a fraction between 0 and 1");
   at.check("shade", value.shade, isFraction, "must be a fraction between 0 and 1");
 }
-function validateRevision(c, field, revision) {
+function validateRevision(c2, field, revision) {
   if (revision === void 0) return;
-  c.at(`.${field}`).dateTime("date", revision.date);
+  c2.at(`.${field}`).dateTime("date", revision.date);
 }
-function validateFontSize(c, value) {
-  c.check(
+function validateFontSize(c2, value) {
+  c2.check(
     "fontSize",
     value,
     (v) => typeof v === "number" && Number.isFinite(v) && Math.round(v * 2) >= 0,
     "must be a finite, non-negative point size that converts to whole half-points (ST_HpsMeasure)"
   );
 }
-function validateRun(c, run) {
-  c.enum("ligatures", run.ligatures, isLigatures, "ST_Ligatures");
-  validateFontSize(c, run.fontSize);
-  c.check(
+function validateRun(c2, run) {
+  c2.enum("ligatures", run.ligatures, isLigatures, "ST_Ligatures");
+  validateFontSize(c2, run.fontSize);
+  c2.check(
     "textScalePercent",
     run.textScalePercent,
     (v) => Number.isSafeInteger(v) && v >= 0 && v <= 600,
     "must be a whole percentage from 0 through 600 (ST_TextScale)"
   );
-  c.check(
+  c2.check(
     "kerningHalfPoints",
     run.kerningHalfPoints,
     (v) => Number.isSafeInteger(v) && v >= 0,
     "must be a nonnegative whole number of half-points (ST_HpsMeasure)"
   );
-  c.check(
+  c2.check(
     "positionHalfPoints",
     run.positionHalfPoints,
     Number.isSafeInteger,
     "must be a signed whole number of half-points (ST_SignedHpsMeasure)"
   );
-  c.hex("color", run.color);
-  c.hex("shadingFill", run.shadingFill);
-  c.hex("underlineColor", run.underlineColor);
-  validateThemeReference(c, "colorTheme", run.colorTheme);
-  validateThemeReference(c, "shadingThemeFill", run.shadingThemeFill);
-  c.enum("underlineStyle", run.underlineStyle, isStUnderline, "ST_Underline");
+  c2.hex("color", run.color);
+  c2.hex("shadingFill", run.shadingFill);
+  c2.hex("underlineColor", run.underlineColor);
+  validateThemeReference(c2, "colorTheme", run.colorTheme);
+  validateThemeReference(c2, "shadingThemeFill", run.shadingThemeFill);
+  c2.enum("underlineStyle", run.underlineStyle, isStUnderline, "ST_Underline");
   if (run.highlight !== void 0 && !isStHighlightColor(run.highlight))
-    c.fail(
+    c2.fail(
       "highlight",
       run.highlight,
       `Unsupported Word highlight token: ${String(run.highlight)}`
     );
-  c.enum("break", run.break, isStBrType, "ST_BrType");
-  c.enum("fieldChar", run.fieldChar, isStFldCharType, "ST_FldCharType");
-  c.check(
+  c2.enum("break", run.break, isStBrType, "ST_BrType");
+  c2.enum("fieldChar", run.fieldChar, isStFldCharType, "ST_FldCharType");
+  c2.check(
     "characterSpacingTwips",
     run.characterSpacingTwips,
     (v) => typeof v === "number" && Number.isFinite(v),
     "must be a finite number of twips (ST_SignedTwipsMeasure)"
   );
-  c.language("language", run.language);
-  c.language("eastAsiaLanguage", run.eastAsiaLanguage);
-  c.language("bidiLanguage", run.bidiLanguage);
-  c.check(
+  c2.language("language", run.language);
+  c2.language("eastAsiaLanguage", run.eastAsiaLanguage);
+  c2.language("bidiLanguage", run.bidiLanguage);
+  c2.check(
     "verticalAlign",
     run.verticalAlign,
     isStVerticalAlignRun,
     'must be "baseline", "superscript" or "subscript"'
   );
-  validateRevision(c, "revision", run.revision);
+  validateRevision(c2, "revision", run.revision);
   if (run.image) {
-    const image = c.at(".image");
+    const image = c2.at(".image");
     for (const key of ["widthPx", "heightPx"])
       image.check(
         key,
@@ -5963,14 +7116,14 @@ function validateRun(c, run) {
       );
   }
 }
-function validateTabStop(c, stop) {
-  c.signed("posTwips", stop.posTwips, "CT_TabStop/@pos");
-  c.enum("align", stop.align, isStTabJc, "ST_TabJc");
-  c.enum("leader", stop.leader, isStTabTlc, "ST_TabTlc");
+function validateTabStop(c2, stop) {
+  c2.signed("posTwips", stop.posTwips, "CT_TabStop/@pos");
+  c2.enum("align", stop.align, isStTabJc, "ST_TabJc");
+  c2.enum("leader", stop.leader, isStTabTlc, "ST_TabTlc");
 }
-function validateParagraph(c, paragraph) {
+function validateParagraph(c2, paragraph) {
   if (paragraph.dropCap) {
-    const at = c.at(".dropCap");
+    const at = c2.at(".dropCap");
     at.check(
       "style",
       paragraph.dropCap.style,
@@ -5990,14 +7143,14 @@ function validateParagraph(c, paragraph) {
       "must be a nonnegative whole number of twips"
     );
   }
-  c.check(
+  c2.check(
     "align",
     paragraph.align,
     (v) => v === "left" || v === "center" || v === "right" || v === "justify",
     'must be "left", "center", "right" or "justify"'
   );
-  c.enum("justification", paragraph.justification, isStJc, "ST_Jc");
-  c.check(
+  c2.enum("justification", paragraph.justification, isStJc, "ST_Jc");
+  c2.check(
     "direction",
     paragraph.direction,
     (v) => v === "ltr" || v === "rtl",
@@ -6009,7 +7162,7 @@ function validateParagraph(c, paragraph) {
     "firstLineTwips",
     "hangingTwips"
   ])
-    c.unsigned(key, paragraph[key], "ST_TwipsMeasure");
+    c2.unsigned(key, paragraph[key], "ST_TwipsMeasure");
   for (const key of [
     "lineSpacingTwips",
     "indentLeftTwips",
@@ -6017,87 +7170,87 @@ function validateParagraph(c, paragraph) {
     "indentStartTwips",
     "indentEndTwips"
   ])
-    c.signed(key, paragraph[key], "ST_SignedTwipsMeasure");
-  c.enum("lineSpacingRule", paragraph.lineSpacingRule, isStLineSpacingRule, "ST_LineSpacingRule");
+    c2.signed(key, paragraph[key], "ST_SignedTwipsMeasure");
+  c2.enum("lineSpacingRule", paragraph.lineSpacingRule, isStLineSpacingRule, "ST_LineSpacingRule");
   if (paragraph.numbering) {
-    const numbering = c.at(".numbering");
+    const numbering = c2.at(".numbering");
     numbering.unsigned("numId", paragraph.numbering.numId, "ST_DecimalNumber");
     numbering.unsigned("level", paragraph.numbering.level, "ST_DecimalNumber");
   }
-  paragraph.tabStops?.forEach((stop, index) => validateTabStop(c.at(`.tabStops[${index}]`), stop));
-  validateRevision(c, "markRevision", paragraph.markRevision);
-  paragraph.runs.forEach((run, index) => validateRun(c.at(`.runs[${index}]`), run));
+  paragraph.tabStops?.forEach((stop, index) => validateTabStop(c2.at(`.tabStops[${index}]`), stop));
+  validateRevision(c2, "markRevision", paragraph.markRevision);
+  paragraph.runs.forEach((run, index) => validateRun(c2.at(`.runs[${index}]`), run));
 }
 
 // docx/validate-structure.ts
-function validateBorderSide(c, side) {
+function validateBorderSide(c2, side) {
   if (!side) return;
-  c.enum("style", side.style, isStBorder, "ST_Border");
-  c.unsigned("sizeEighthPoints", side.sizeEighthPoints, "ST_EighthPointMeasure");
-  c.unsigned("spacePoints", side.spacePoints, "ST_PointMeasure");
-  c.hex("color", side.color);
-  c.theme("themeColor", side.themeColor);
+  c2.enum("style", side.style, isStBorder, "ST_Border");
+  c2.unsigned("sizeEighthPoints", side.sizeEighthPoints, "ST_EighthPointMeasure");
+  c2.unsigned("spacePoints", side.spacePoints, "ST_PointMeasure");
+  c2.hex("color", side.color);
+  c2.theme("themeColor", side.themeColor);
 }
-function validateBorders(c, borders) {
+function validateBorders(c2, borders) {
   if (!borders) return;
   for (const side of ["top", "left", "bottom", "right", "insideH", "insideV"])
-    validateBorderSide(c.at(`.${side}`), borders[side]);
+    validateBorderSide(c2.at(`.${side}`), borders[side]);
 }
-function validateCell(c, cell) {
-  c.check(
+function validateCell(c2, cell) {
+  c2.check(
     "gridSpan",
     cell.gridSpan,
     (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 1,
     "must be a positive integer (CT_DecimalNumber)"
   );
-  c.enum("verticalMerge", cell.verticalMerge, isStMerge, "ST_Merge");
-  c.unsigned("widthTwips", cell.widthTwips, "ST_TwipsMeasure");
-  c.enum("verticalAlign", cell.verticalAlign, isStVerticalJc, "ST_VerticalJc");
-  c.hex("shadingFill", cell.shadingFill);
-  validateThemeReference(c, "shadingThemeFill", cell.shadingThemeFill);
-  validateBorders(c.at(".borders"), cell.borders);
+  c2.enum("verticalMerge", cell.verticalMerge, isStMerge, "ST_Merge");
+  c2.unsigned("widthTwips", cell.widthTwips, "ST_TwipsMeasure");
+  c2.enum("verticalAlign", cell.verticalAlign, isStVerticalJc, "ST_VerticalJc");
+  c2.hex("shadingFill", cell.shadingFill);
+  validateThemeReference(c2, "shadingThemeFill", cell.shadingThemeFill);
+  validateBorders(c2.at(".borders"), cell.borders);
   if (cell.margins)
     for (const side of ["top", "bottom", "left", "right"])
-      c.at(".margins").signed(side, cell.margins[side], "ST_SignedTwipsMeasure");
+      c2.at(".margins").signed(side, cell.margins[side], "ST_SignedTwipsMeasure");
 }
-function validateTable(c, table) {
-  c.unsigned("widthTwips", table.widthTwips, "ST_TwipsMeasure");
-  c.signed("indentTwips", table.indentTwips, "ST_SignedTwipsMeasure");
-  c.check(
+function validateTable(c2, table) {
+  c2.unsigned("widthTwips", table.widthTwips, "ST_TwipsMeasure");
+  c2.signed("indentTwips", table.indentTwips, "ST_SignedTwipsMeasure");
+  c2.check(
     "alignment",
     table.alignment,
     (v) => v === "left" || v === "center" || v === "right",
     'must be "left", "center" or "right"'
   );
-  c.enum("justification", table.justification, isStJcTable, "ST_JcTable");
+  c2.enum("justification", table.justification, isStJcTable, "ST_JcTable");
   table.grid?.forEach(
-    (width, index) => c.at(`.grid[${index}]`).unsigned("width", width, "ST_TwipsMeasure")
+    (width, index) => c2.at(`.grid[${index}]`).unsigned("width", width, "ST_TwipsMeasure")
   );
-  validateBorders(c.at(".borders"), table.borders);
+  validateBorders(c2.at(".borders"), table.borders);
   if (table.cellMargins)
     for (const side of ["top", "bottom", "left", "right"])
-      c.at(".cellMargins").signed(side, table.cellMargins[side], "ST_SignedTwipsMeasure");
+      c2.at(".cellMargins").signed(side, table.cellMargins[side], "ST_SignedTwipsMeasure");
   table.rowProperties?.forEach((row, index) => {
     if (row)
-      c.at(`.rowProperties[${index}]`).unsigned("heightTwips", row.heightTwips, "ST_TwipsMeasure");
+      c2.at(`.rowProperties[${index}]`).unsigned("heightTwips", row.heightTwips, "ST_TwipsMeasure");
   });
   table.rows.forEach(
-    (row, r) => row.forEach((cell, k) => validateCell(c.at(`.rows[${r}][${k}]`), cell))
+    (row, r) => row.forEach((cell, k) => validateCell(c2.at(`.rows[${r}][${k}]`), cell))
   );
 }
-function validateSection(c, section) {
-  c.enum("type", section.type, isStSectionMark, "ST_SectionMark");
-  c.enum("orientation", section.orientation, isStPageOrientation, "ST_PageOrientation");
-  c.enum("verticalAlign", section.verticalAlign, isStVerticalJc, "ST_VerticalJc");
+function validateSection(c2, section) {
+  c2.enum("type", section.type, isStSectionMark, "ST_SectionMark");
+  c2.enum("orientation", section.orientation, isStPageOrientation, "ST_PageOrientation");
+  c2.enum("verticalAlign", section.verticalAlign, isStVerticalJc, "ST_VerticalJc");
   for (const key of ["pageWidthTwips", "pageHeightTwips"])
-    c.check(
+    c2.check(
       key,
       section[key],
       (v) => typeof v === "number" && Number.isSafeInteger(v) && v > 0,
       "must be a positive integer number of twips (CT_PageSz)"
     );
   for (const key of ["marginTopTwips", "marginBottomTwips"])
-    c.signed(key, section[key], "ST_SignedTwipsMeasure");
+    c2.signed(key, section[key], "ST_SignedTwipsMeasure");
   for (const key of [
     "marginLeftTwips",
     "marginRightTwips",
@@ -6105,8 +7258,8 @@ function validateSection(c, section) {
     "footerDistanceTwips",
     "gutterTwips"
   ])
-    c.unsigned(key, section[key], "ST_TwipsMeasure");
-  const columns = c.at(".columns");
+    c2.unsigned(key, section[key], "ST_TwipsMeasure");
+  const columns = c2.at(".columns");
   columns.check(
     "count",
     section.columns?.count,
@@ -6120,7 +7273,7 @@ function validateSection(c, section) {
     at.unsigned("spacingTwips", column.spacingTwips, "ST_TwipsMeasure");
   });
   if (section.lineNumberSettings) {
-    const line = c.at(".lineNumberSettings");
+    const line = c2.at(".lineNumberSettings");
     const settings = section.lineNumberSettings;
     line.check(
       "countBy",
@@ -6143,12 +7296,12 @@ function validateSection(c, section) {
     line.unsigned("distanceTwips", settings.distanceTwips, "ST_TwipsMeasure");
   }
   if (section.pageNumbering) {
-    const numbering = c.at(".pageNumbering");
+    const numbering = c2.at(".pageNumbering");
     numbering.enum("format", section.pageNumbering.format, isStNumberFormat, "ST_NumberFormat");
     numbering.signed("start", section.pageNumbering.start, "ST_DecimalNumber");
   }
 }
-function validateNumberingCatalog(c, catalog) {
+function validateNumberingCatalog(c2, catalog) {
   const levelOf = (at, level) => {
     at.enum("numFmt", level.numFmt, isStNumberFormat, "ST_NumberFormat");
     at.signed("start", level.start, "ST_DecimalNumber");
@@ -6179,19 +7332,19 @@ function validateNumberingCatalog(c, catalog) {
   };
   for (const [id, abstract] of Object.entries(catalog.abstractNums))
     for (const [key, level] of Object.entries(abstract.levels))
-      levelOf(new Checker(c.issues, `${c.path}.abstractNums[${id}].levels[${key}]`), level);
+      levelOf(new Checker(c2.issues, `${c2.path}.abstractNums[${id}].levels[${key}]`), level);
   for (const [id, num] of Object.entries(catalog.nums))
     for (const [key, override] of Object.entries(num.levelOverrides ?? {})) {
-      const at = new Checker(c.issues, `${c.path}.nums[${id}].levelOverrides[${key}]`);
+      const at = new Checker(c2.issues, `${c2.path}.nums[${id}].levelOverrides[${key}]`);
       at.signed("startOverride", override.startOverride, "ST_DecimalNumber");
       if (override.lvl) levelOf(at.at(".lvl"), override.lvl);
     }
 }
 
 // docx/validate-model.ts
-function validateBlocks(c, blocks) {
+function validateBlocks(c2, blocks) {
   blocks?.forEach((block, index) => {
-    const at = c.at(`[${index}]`);
+    const at = c2.at(`[${index}]`);
     if (block.type === "paragraph") return validateParagraph(at, block);
     validateTable(at, block);
     block.rows.forEach(
@@ -6205,8 +7358,8 @@ function validateBlocks(c, blocks) {
 }
 function validateDocumentModel(model) {
   const issues = [];
-  const path = (suffix) => new Checker(issues, suffix);
-  const page = path("page");
+  const path2 = (suffix) => new Checker(issues, suffix);
+  const page = path2("page");
   for (const key of ["width", "height"])
     page.check(
       key,
@@ -6221,9 +7374,9 @@ function validateDocumentModel(model) {
       (v) => typeof v === "number" && Number.isFinite(v) && (key === "marginTop" || key === "marginBottom" || v >= 0),
       "must be a finite pixel size (converted to integer twips; left/right non-negative)"
     );
-  validateBlocks(path("blocks"), model.blocks);
+  validateBlocks(path2("blocks"), model.blocks);
   model.sections?.forEach((section, index) => {
-    const at = path(`sections[${index}]`);
+    const at = path2(`sections[${index}]`);
     validateSection(at, section);
     for (const kind of ["headers", "footers"])
       for (const [slot2, content] of Object.entries(section[kind] ?? {}))
@@ -6231,16 +7384,16 @@ function validateDocumentModel(model) {
   });
   for (const kind of ["footnotes", "endnotes"])
     model[kind]?.forEach(
-      (note, index) => validateBlocks(path(`${kind}[${index}].blocks`), note.blocks)
+      (note, index) => validateBlocks(path2(`${kind}[${index}].blocks`), note.blocks)
     );
   model.comments?.forEach(
-    (comment, index) => path(`comments[${index}]`).dateTime("date", comment.date)
+    (comment, index) => path2(`comments[${index}]`).dateTime("date", comment.date)
   );
-  path("model").hex("pageColor", model.pageColor);
-  path("model").enum("footnoteNumFmt", model.footnoteNumFmt, isStNumberFormat, "ST_NumberFormat");
-  path("model").enum("endnoteNumFmt", model.endnoteNumFmt, isStNumberFormat, "ST_NumberFormat");
+  path2("model").hex("pageColor", model.pageColor);
+  path2("model").enum("footnoteNumFmt", model.footnoteNumFmt, isStNumberFormat, "ST_NumberFormat");
+  path2("model").enum("endnoteNumFmt", model.endnoteNumFmt, isStNumberFormat, "ST_NumberFormat");
   if (model.numberingCatalog)
-    validateNumberingCatalog(path("numberingCatalog"), model.numberingCatalog);
+    validateNumberingCatalog(path2("numberingCatalog"), model.numberingCatalog);
   return issues;
 }
 function assertValidDocumentModel(model) {
@@ -6356,12 +7509,12 @@ function parseNum(element) {
   const levelOverrides = {};
   for (const override of children2(element, "lvlOverride")) {
     const level = integer2(getW(override, "ilvl"), 0);
-    const entry = {};
+    const entry2 = {};
     const startOverride = getW(first2(override, "startOverride"), "val");
-    if (startOverride !== void 0) entry.startOverride = integer2(startOverride, 1);
+    if (startOverride !== void 0) entry2.startOverride = integer2(startOverride, 1);
     const lvl = first2(override, "lvl");
-    if (lvl) entry.lvl = parseNumberingLevel(lvl);
-    if (Object.keys(entry).length) levelOverrides[level] = entry;
+    if (lvl) entry2.lvl = parseNumberingLevel(lvl);
+    if (Object.keys(entry2).length) levelOverrides[level] = entry2;
   }
   return {
     id,
@@ -6567,7 +7720,7 @@ function buildAbstractNumElement(doc, def) {
   const element = makeW(doc, "abstractNum");
   setAttribute8(element, "abstractNumId", def.id);
   element.appendChild(valueElement(doc, "multiLevelType", "hybridMultilevel"));
-  for (const level of Object.values(def.levels).sort((a, b) => a.level - b.level))
+  for (const level of Object.values(def.levels).sort((a2, b) => a2.level - b.level))
     element.appendChild(buildLevelElement(doc, level));
   return element;
 }
@@ -6686,13 +7839,13 @@ async function applyStyleNumbering(zip, model, base) {
 // docx/part-relationships.ts
 var CONTENT_TYPES_PART = "[Content_Types].xml";
 var extensionOf = (partName) => partName.split(".").pop()?.toLowerCase() ?? "";
-function relationshipsPartFor(partName) {
+function relationshipsPartFor2(partName) {
   const slash = partName.lastIndexOf("/");
   return `${partName.slice(0, slash)}/_rels/${partName.slice(slash + 1)}.rels`;
 }
 async function allocatorForPart(zip, partName, doc, docPrIds) {
   const declared = parseRelationships(
-    await zip.file(relationshipsPartFor(partName))?.async("string")
+    await zip.file(relationshipsPartFor2(partName))?.async("string")
   );
   const allocator = new RelationshipAllocator(
     [...scanUsedRelationshipIds(doc), ...declared.keys()],
@@ -6703,7 +7856,7 @@ async function allocatorForPart(zip, partName, doc, docPrIds) {
 }
 async function writeNewRelationships(zip, partName, created, pendingMedia) {
   if (!created.length) return;
-  const relsPath = relationshipsPartFor(partName);
+  const relsPath = relationshipsPartFor2(partName);
   const relationships = parseRelationships(await zip.file(relsPath)?.async("string"));
   let contentTypesXml = await zip.file(CONTENT_TYPES_PART)?.async("string");
   for (const relationship of created) {
@@ -6787,8 +7940,8 @@ async function createHeaderFooterParts(zip, model, base, docPrIds) {
           (_match, start, end) => `${start}${docPrIds.next()}${end}`
         ) : xml
       );
-      const rels = zip.file(relationshipsPartFor(content.sourcePartName));
-      if (rels) zip.file(relationshipsPartFor(partName), await rels.async("uint8array"));
+      const rels = zip.file(relationshipsPartFor2(content.sourcePartName));
+      if (rels) zip.file(relationshipsPartFor2(partName), await rels.async("uint8array"));
     }
     await ensureContentTypeOverride(
       zip,
@@ -7861,15 +9014,15 @@ function parseNotesPart(xml, kind, parseBlocks) {
 }
 
 // docx/document-parts.ts
-async function partContext(zip, path, base) {
+async function partContext(zip, path2, base) {
   if (!base) return void 0;
-  const slash = path.lastIndexOf("/");
-  const relsPath = `${path.slice(0, slash)}/_rels/${path.slice(slash + 1)}.rels`;
+  const slash = path2.lastIndexOf("/");
+  const relsPath = `${path2.slice(0, slash)}/_rels/${path2.slice(slash + 1)}.rels`;
   return { ...base, rels: parseRelationships(await readPart(zip, relsPath)) };
 }
 var FIELD_MARKUP = /<w:(?:fldSimple|instrText|fldChar)\b/;
-async function readPart(zip, path) {
-  return zip.file(path)?.async("string");
+async function readPart(zip, path2) {
+  return zip.file(path2)?.async("string");
 }
 function parseSettings(xml) {
   if (!xml) return { evenAndOddHeaders: false, autoHyphenation: false };
@@ -7897,21 +9050,21 @@ async function resolveSlots(zip, relationships, refs, cache, fieldMarkup, drawin
   for (const ref of refs) {
     const relationship = relationships.get(ref.rId);
     if (!relationship) continue;
-    const path = resolvePartPath("word/document.xml", relationship.target);
-    let blocks = cache.get(path);
+    const path2 = resolvePartPath("word/document.xml", relationship.target);
+    let blocks = cache.get(path2);
     if (!blocks) {
-      const xml = await readPart(zip, path);
+      const xml = await readPart(zip, path2);
       if (xml === void 0) continue;
       if (FIELD_MARKUP.test(xml)) fieldMarkup.seen = true;
-      const context = await partContext(zip, path, drawings);
+      const context = await partContext(zip, path2, drawings);
       const root = parseXml2(xml).documentElement;
       blocks = withParseWarnings(
         sink2,
-        () => parseBlocksFromContainer(root, `${path.replace(/[^a-z0-9]+/gi, "")}-`, context)
+        () => parseBlocksFromContainer(root, `${path2.replace(/[^a-z0-9]+/gi, "")}-`, context)
       );
-      cache.set(path, blocks);
+      cache.set(path2, blocks);
     }
-    slots[ref.slot] = { blocks, partName: path };
+    slots[ref.slot] = { blocks, partName: path2 };
   }
   return Object.keys(slots).length ? slots : void 0;
 }
@@ -7947,8 +9100,8 @@ async function parseDocumentParts(zip, body, blocks, drawings) {
   }
   const footnotesXml = await readPart(zip, "word/footnotes.xml");
   const endnotesXml = await readPart(zip, "word/endnotes.xml");
-  const notesParser = async (path) => {
-    const context = await partContext(zip, path, drawings);
+  const notesParser = async (path2) => {
+    const context = await partContext(zip, path2, drawings);
     return (container, prefix) => withParseWarnings(warnings, () => parseBlocksFromContainer(container, prefix, context));
   };
   const footnotes = footnotesXml ? parseNotesPart(footnotesXml, "footnote", await notesParser("word/footnotes.xml")) : void 0;
@@ -8000,15 +9153,15 @@ function parseComments(commentsXml, extendedXml) {
   });
   if (extendedXml) {
     const extended = parseXml2(extendedXml);
-    for (const entry of Array.from(
+    for (const entry2 of Array.from(
       extended.getElementsByTagNameNS(W15_NS2, "commentEx")
     )) {
-      const paraId = entry.getAttributeNS(W15_NS2, "paraId");
-      const comment = paraId && comments.find((c) => c.id === paraIdToCommentId.get(paraId));
+      const paraId = entry2.getAttributeNS(W15_NS2, "paraId");
+      const comment = paraId && comments.find((c2) => c2.id === paraIdToCommentId.get(paraId));
       if (!comment) continue;
-      const done = entry.getAttributeNS(W15_NS2, "done");
+      const done = entry2.getAttributeNS(W15_NS2, "done");
       comment.resolved = done === "1" || done === "true";
-      const parentParaId = entry.getAttributeNS(W15_NS2, "paraIdParent");
+      const parentParaId = entry2.getAttributeNS(W15_NS2, "paraIdParent");
       const parentId = parentParaId && paraIdToCommentId.get(parentParaId);
       if (parentId) comment.parentId = parentId;
     }
@@ -8016,96 +9169,6 @@ function parseComments(commentsXml, extendedXml) {
   return comments;
 }
 
-// docx/parse-warnings.ts
-function hasAny(document, names) {
-  return names.some((name) => document.getElementsByTagNameNS(WORD_NS, name).length > 0);
-}
-function warningsFor(document) {
-  const warnings = [];
-  const features = [
-    [["object"], "Embedded OLE objects (w:object) are preserved but rendered as a placeholder."],
-    [["altChunk"], "Embedded alternate-format content is not represented in the document model."],
-    [
-      ["fldSimple", "instrText", "fldChar"],
-      "Fields show the result Word last saved while editing; Print Layout recalculates PAGE, NUMPAGES, SECTIONPAGES, DATE and TIME, and tables of contents update from the References tab."
-    ],
-    [
-      ["moveFrom", "moveTo"],
-      "Moved text is linked by its move name: accepting or rejecting either side resolves both. Moves are shown and saved with their range markers."
-    ],
-    [
-      ["rPrChange"],
-      "Formatting-change revisions retain their prior run-properties snapshots and support acceptance and rejection; recording new formatting changes and showing prior formatting in Original display are not supported yet."
-    ],
-    [
-      ["pPrChange"],
-      "Paragraph-formatting-change revisions retain their prior properties snapshots and support acceptance and rejection; recording new paragraph formatting changes and showing prior formatting in Original display are not supported yet."
-    ],
-    [
-      ["tblPrChange", "trPrChange", "tcPrChange"],
-      "Table-structure tracked changes are preserved in the source XML but are not represented in the document model."
-    ]
-  ];
-  for (const [names, message] of features) if (hasAny(document, names)) warnings.push(message);
-  if (Array.from(document.getElementsByTagNameNS(WORD_NS, "instrText")).some(
-    (el3) => /HYPERLINK/i.test(textContent(el3))
-  ))
-    warnings.push(
-      "Complex HYPERLINK field codes (w:fldChar/w:instrText) are preserved but not parsed as links; their result text edits as plain text."
-    );
-  const specialBreak = Array.from(document.getElementsByTagNameNS(WORD_NS, "br")).some(
-    (br) => hasSpecialBreak(br) && !isModeledBreak(br)
-  ) || Array.from(document.getElementsByTagNameNS(WORD_NS, "cr")).some(
-    (cr) => cr.attributes.length > 0
-  );
-  if (specialBreak)
-    warnings.push(
-      "Some non-line breaks other than page and column breaks are not distinguished from line breaks in the document model; edits to paragraphs containing them are rejected to preserve the original XML."
-    );
-  return warnings;
-}
-function forEachParagraph2(blocks, visit) {
-  for (const block of blocks) {
-    if (block.type === "paragraph") visit(block);
-    else for (const row of block.rows) for (const cell of row) cell.paragraphs.forEach(visit);
-  }
-}
-function imageAndBookmarkWarnings(blocks) {
-  const warnings = [];
-  let hasPicture = false;
-  let hasAnchored = false;
-  const unsupportedKinds = /* @__PURE__ */ new Set();
-  let hasBookmarks = false;
-  forEachParagraph2(blocks, (paragraph) => {
-    if (paragraph.bookmarks?.length) hasBookmarks = true;
-    for (const run of paragraph.runs) {
-      if (!run.image) continue;
-      if (run.image.unsupported) {
-        if (run.image.diagram?.rendering !== "cached-drawing")
-          unsupportedKinds.add(run.image.unsupported);
-      } else hasPicture = true;
-      if (run.image.anchored) hasAnchored = true;
-    }
-  });
-  if (hasPicture)
-    warnings.push(
-      "Inline pictures render from their original bytes and can be deleted or newly inserted; crop, artistic effects, and non-inline text wrapping are not reproduced."
-    );
-  if (hasAnchored)
-    warnings.push(
-      "Floating pictures follow their text wrapping approximately (floated left or right, or on their own line); exact positions, vertical offsets and in-front/behind layering are not reproduced."
-    );
-  if (unsupportedKinds.size)
-    warnings.push(
-      `${Array.from(unsupportedKinds).join(", ")} content is rendered as a labeled placeholder and is not editable.`
-    );
-  if (hasBookmarks)
-    warnings.push(
-      "Bookmark names are read-only; editing a paragraph that contains bookmarks preserves them but moves their start/end to the paragraph boundaries."
-    );
-  return warnings;
-}
-
 // docx/diagram-document.ts
 function diagramsIn(blocks) {
   const diagrams = [];
@@ -8143,7 +9206,7 @@ async function readPackage(input) {
   const entries = Object.values(zip.files);
   if (entries.length > 5e3) throw new Error("DOCX package exceeds the 5,000 part limit");
   const totalSize = entries.reduce(
-    (sum, entry) => sum + Number(entry._data?.uncompressedSize ?? 0),
+    (sum, entry2) => sum + Number(entry2._data?.uncompressedSize ?? 0),
     0
   );
   if (totalSize > 200 * 1024 * 1024)
@@ -8294,6 +9357,10 @@ async function readPackage(input) {
     pictureBlocks,
     async (partName) => zip.file(partName)?.async("string")
   );
+  await resolveDocumentCharts(
+    pictureBlocks,
+    async (partName) => zip.file(partName)?.async("string")
+  );
   model.warnings.push(...imageAndBookmarkWarnings(blocks), ...diagramWarnings(pictureBlocks));
   for (const warning of schemaWarnings)
     if (!model.warnings.includes(warning)) model.warnings.push(warning);