ooxml-core 1.1.0 → 1.2.1

package/dist/docx/ui/index.mjs

@@ -2,7 +2,7 @@ import { Step, Transform, DocAttrStep, StepMap, ReplaceStep, Mapping, AddMarkSte
 import { collab, sendableSteps, receiveTransaction, getVersion } from 'prosemirror-collab';
 import { closeHistory, isHistoryTransaction } from 'prosemirror-history';
 import { PluginKey, Plugin, TextSelection, NodeSelection } from 'prosemirror-state';
-import { XMLSerializer, DOMParser } from '@xmldom/xmldom';
+import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
 import { Slice, Fragment } from 'prosemirror-model';
 import * as Y2 from 'yjs';
 import { ySyncPluginKey, prosemirrorToYXmlFragment, initProseMirrorDoc, defaultDeleteFilter, ySyncPlugin, getRelativeSelection, yCursorPlugin, yCursorPluginKey, relativePositionToAbsolutePosition, absolutePositionToRelativePosition } from 'y-prosemirror';
@@ -149,25 +149,25 @@ var inlineRunFormattingAttrs = Object.fromEntries(
   [...RUN_PROPERTY_ATTRIBUTES].map((name) => [name, { default: null }])
 );
 function inlineRunProperties(node) {
-  const properties3 = typeof node.attrs.format === "string" ? JSON.parse(node.attrs.format) : {};
+  const properties4 = typeof node.attrs.format === "string" ? JSON.parse(node.attrs.format) : {};
   for (const key of DIRECT_RUN_PROPERTY_KEYS) {
     const override = node.attrs[attributeName(key)];
     if (typeof override !== "string") continue;
     const value = JSON.parse(override);
-    if (value === null) delete properties3[key];
-    else properties3[key] = value;
+    if (value === null) delete properties4[key];
+    else properties4[key] = value;
   }
   const projection = node.marks.find((mark) => mark.type.name === "inlineCommentAnchors");
   if (projection) {
     const ids = projection.attrs.ids;
-    if (ids.length) properties3.commentIds = [...ids];
-    else delete properties3.commentIds;
+    if (ids.length) properties4.commentIds = [...ids];
+    else delete properties4.commentIds;
   }
-  return properties3;
+  return properties4;
 }
 function inlineRunPropertiesDomAttrs(node) {
-  const properties3 = inlineRunProperties(node);
-  return Object.keys(properties3).length ? { "data-run-properties": JSON.stringify(properties3) } : {};
+  const properties4 = inlineRunProperties(node);
+  return Object.keys(properties4).length ? { "data-run-properties": JSON.stringify(properties4) } : {};
 }
 function updatedInlineRunAttributes(node, format) {
   if (!node.type.spec.attrs?.[attributeName("bold")]) return { ...node.attrs, format };
@@ -751,7 +751,9 @@ function commentIdsFromNode(node) {
 // xml/namespaces.ts
 var NS = {
   /** WordprocessingML main. */
-  w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main"};
+  w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+  /** DrawingML main. */
+  a: "http://schemas.openxmlformats.org/drawingml/2006/main"};
 function parseXml(xml, options = {}) {
   const label = options.label ?? "OOXML";
   if (/<!DOCTYPE|<!ENTITY/i.test(xml))
@@ -855,6 +857,7 @@ var signedTwipsFromPixels = (pixels) => roundSignedTwips(pixels * 15);
 
 // units/constants.ts
 var EMU_PER_PIXEL = 9525;
+var EMU_PER_POINT = 12700;
 
 // docx/simple-types.ts
 function parseOnOff(value) {
@@ -897,8 +900,8 @@ function universalMeasureToTwips(value) {
 }
 function parseSignedTwips(value) {
   if (value === null || value === void 0) return void 0;
-  const text = value.trim();
-  const parsed = SAFE_INTEGER.test(text) ? parseInteger(text) : universalMeasureToTwips(text);
+  const text2 = value.trim();
+  const parsed = SAFE_INTEGER.test(text2) ? parseInteger(text2) : universalMeasureToTwips(text2);
   return parsed === void 0 ? void 0 : signedTwips(parsed);
 }
 function parseTwips(value) {
@@ -907,26 +910,26 @@ function parseTwips(value) {
 }
 function parseHalfPoints(value) {
   if (value === null || value === void 0) return void 0;
-  const text = value.trim();
-  if (/^\d+$/.test(text)) {
-    const parsed = parseInteger(text);
+  const text2 = value.trim();
+  if (/^\d+$/.test(text2)) {
+    const parsed = parseInteger(text2);
     return parsed === void 0 ? void 0 : halfPoints(parsed);
   }
-  const asTwips = UNIVERSAL_MEASURE.test(text) ? universalMeasureToTwips(text) : void 0;
+  const asTwips = UNIVERSAL_MEASURE.test(text2) ? universalMeasureToTwips(text2) : void 0;
   return asTwips !== void 0 && asTwips >= 0 ? halfPoints(Math.round(asTwips / 10)) : void 0;
 }
 function parseSignedHalfPoints(value) {
   if (value === null || value === void 0) return void 0;
-  const text = value.trim();
-  const integer2 = parseInteger(text);
+  const text2 = value.trim();
+  const integer2 = parseInteger(text2);
   if (integer2 !== void 0) return halfPoints(integer2);
-  const twips2 = universalMeasureToTwips(text);
+  const twips2 = universalMeasureToTwips(text2);
   return twips2 === void 0 ? void 0 : halfPoints(Math.sign(twips2) * Math.round(Math.abs(twips2) / 10));
 }
 function parseTextScale(value) {
-  const text = value?.trim();
-  if (text?.endsWith("%") && !/^\d+%$/.test(text)) return void 0;
-  const parsed = parseUnsignedInteger(text?.endsWith("%") ? text.slice(0, -1) : text);
+  const text2 = value?.trim();
+  if (text2?.endsWith("%") && !/^\d+%$/.test(text2)) return void 0;
+  const parsed = parseUnsignedInteger(text2?.endsWith("%") ? text2.slice(0, -1) : text2);
   return parsed !== void 0 && parsed <= 600 ? parsed : void 0;
 }
 function parseEighthPoints(value) {
@@ -1112,16 +1115,16 @@ function parseRunProperties(props) {
   const color = first2(props, "color");
   const hex = parseRgbColor(getW(color, "val"));
   if (hex) result.color = hex;
-  const themeColor = enumValue(isStThemeColor, getW(color, "themeColor"));
-  if (themeColor) {
-    result.colorTheme = { token: themeColor };
+  const themeColor2 = enumValue(isStThemeColor, getW(color, "themeColor"));
+  if (themeColor2) {
+    result.colorTheme = { token: themeColor2 };
     const tint = parseTintShade(getW(color, "themeTint"));
     const shade = parseTintShade(getW(color, "themeShade"));
     if (tint !== void 0) result.colorTheme.tint = tint;
     if (shade !== void 0) result.colorTheme.shade = shade;
   }
-  const spacing = parseSignedTwips(getW(first2(props, "spacing"), "val"));
-  if (spacing !== void 0) result.characterSpacingTwips = spacing;
+  const spacing2 = parseSignedTwips(getW(first2(props, "spacing"), "val"));
+  if (spacing2 !== void 0) result.characterSpacingTwips = spacing2;
   const scaleElement = first2(props, "w");
   const scale = scaleElement ? parseTextScale(getW(scaleElement, "val") ?? "100") : void 0;
   if (scale !== void 0) result.textScalePercent = scale;
@@ -1207,13 +1210,13 @@ function borderSide(element) {
   const style = enumValue(isStBorder, getW(element, "val"));
   const size = parseEighthPoints(getW(element, "sz"));
   const color = parseRgbColor(getW(element, "color"));
-  const themeColor = enumValue(isStThemeColor, getW(element, "themeColor"));
-  if (!style && size === void 0 && !color && !themeColor) return void 0;
+  const themeColor2 = enumValue(isStThemeColor, getW(element, "themeColor"));
+  if (!style && size === void 0 && !color && !themeColor2) return void 0;
   const side = {};
   if (style) side.style = style;
   if (size !== void 0) side.sizeEighthPoints = size;
   if (color) side.color = color;
-  if (themeColor) side.themeColor = themeColor;
+  if (themeColor2) side.themeColor = themeColor2;
   return side;
 }
 function parseTableBorders(bordersElement) {
@@ -1328,16 +1331,16 @@ function parseFormatting(pPr) {
   if (borders) result.borders = borders;
   const shading = parseShadingFill(first2(pPr, "shd"));
   if (shading) result.shadingFill = shading;
-  const spacing = first2(pPr, "spacing");
-  const before = twipValue(getW(spacing, "before"));
-  const after = twipValue(getW(spacing, "after"));
-  const line = signedTwipValue(getW(spacing, "line"));
+  const spacing2 = first2(pPr, "spacing");
+  const before = twipValue(getW(spacing2, "before"));
+  const after = twipValue(getW(spacing2, "after"));
+  const line2 = signedTwipValue(getW(spacing2, "line"));
   if (before !== void 0) result.spacingBeforeTwips = before;
   if (after !== void 0) result.spacingAfterTwips = after;
-  if (line !== void 0) result.lineSpacingTwips = line;
-  const rule = getW(spacing, "lineRule");
+  if (line2 !== void 0) result.lineSpacingTwips = line2;
+  const rule = getW(spacing2, "lineRule");
   if (rule === "auto" || rule === "exact" || rule === "atLeast") result.lineSpacingRule = rule;
-  else if (line !== void 0) result.lineSpacingRule = "auto";
+  else if (line2 !== void 0) result.lineSpacingRule = "auto";
   const ind = first2(pPr, "ind");
   for (const [xml, key] of [
     ["left", "indentLeftTwips"],
@@ -1621,13 +1624,13 @@ function hexToRgbChannels(color) {
     b: Number.parseInt(normalized.slice(4, 6), 16)
   };
 }
-function percentDivisorFor(text) {
-  return text.endsWith("%") ? 100 : 1e5;
+function percentDivisorFor(text2) {
+  return text2.endsWith("%") ? 100 : 1e5;
 }
 function parseOoxmlPercent(value) {
-  const text = String(value ?? "").trim();
-  const divisor = percentDivisorFor(text);
-  const magnitude = Number.parseFloat(divisor === 100 ? text.slice(0, -1) : text);
+  const text2 = String(value ?? "").trim();
+  const divisor = percentDivisorFor(text2);
+  const magnitude = Number.parseFloat(divisor === 100 ? text2.slice(0, -1) : text2);
   if (!Number.isFinite(magnitude)) {
     return void 0;
   }
@@ -1673,7 +1676,7 @@ function rgbToHsl(r, g, b) {
   return { h, s: clampUnitInterval(s), l: clampUnitInterval(l) };
 }
 function hslToRgb(h, s, l, roundChannel = Math.round, options) {
-  const sC = clampUnitInterval(s);
+  const sC = options?.clampSaturation === false ? s : clampUnitInterval(s);
   const lC = clampUnitInterval(l);
   const hN = (h % 360 + 360) % 360;
   const c = (1 - Math.abs(2 * lC - 1)) * sC;
@@ -1734,7 +1737,379 @@ function linearToSrgb255(linear) {
   return 255 * (c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055);
 }
 
+// color/native-gradient-curve.ts
+var OFFICE_SIGMA_FACTORS = [
+  0,
+  59,
+  120,
+  182,
+  247,
+  314,
+  383,
+  454,
+  527,
+  602,
+  680,
+  759,
+  841,
+  926,
+  1013,
+  1102,
+  1194,
+  1288,
+  1385,
+  1485,
+  1587,
+  1692,
+  1800,
+  1911,
+  2024,
+  2141,
+  2260,
+  2383,
+  2508,
+  2637,
+  2769,
+  2904,
+  3042,
+  3183,
+  3328,
+  3477,
+  3628,
+  3783,
+  3942,
+  4104,
+  4270,
+  4439,
+  4612,
+  4789,
+  4969,
+  5153,
+  5341,
+  5533,
+  5728,
+  5928,
+  6131,
+  6338,
+  6549,
+  6764,
+  6983,
+  7206,
+  7434,
+  7665,
+  7900,
+  8139,
+  8382,
+  8630,
+  8881,
+  9136,
+  9396,
+  9660,
+  9927,
+  10199,
+  10475,
+  10755,
+  11039,
+  11327,
+  11619,
+  11916,
+  12216,
+  12520,
+  12828,
+  13140,
+  13456,
+  13776,
+  14099,
+  14427,
+  14758,
+  15093,
+  15431,
+  15774,
+  16119,
+  16469,
+  16822,
+  17178,
+  17538,
+  17901,
+  18267,
+  18637,
+  19009,
+  19385,
+  19764,
+  20146,
+  20530,
+  20918,
+  21308,
+  21701,
+  22096,
+  22494,
+  22894,
+  23297,
+  23702,
+  24109,
+  24518,
+  24929,
+  25342,
+  25756,
+  26173,
+  26591,
+  27010,
+  27431,
+  27853,
+  28276,
+  28701,
+  29126,
+  29552,
+  29979,
+  30407,
+  30836,
+  31264,
+  31694,
+  32123,
+  32553,
+  32983,
+  33413,
+  33842,
+  34272,
+  34700,
+  35129,
+  35557,
+  35984,
+  36410,
+  36835,
+  37260,
+  37683,
+  38105,
+  38526,
+  38945,
+  39363,
+  39780,
+  40194,
+  40607,
+  41018,
+  41427,
+  41834,
+  42239,
+  42642,
+  43042,
+  43440,
+  43835,
+  44228,
+  44618,
+  45006,
+  45390,
+  45772,
+  46151,
+  46527,
+  46899,
+  47269,
+  47635,
+  47998,
+  48358,
+  48714,
+  49067,
+  49417,
+  49762,
+  50105,
+  50443,
+  50778,
+  51109,
+  51437,
+  51760,
+  52080,
+  52396,
+  52708,
+  53016,
+  53320,
+  53620,
+  53917,
+  54209,
+  54497,
+  54781,
+  55061,
+  55337,
+  55609,
+  55876,
+  56140,
+  56400,
+  56655,
+  56906,
+  57154,
+  57397,
+  57636,
+  57871,
+  58102,
+  58330,
+  58553,
+  58772,
+  58987,
+  59198,
+  59405,
+  59608,
+  59808,
+  60003,
+  60195,
+  60383,
+  60567,
+  60747,
+  60924,
+  61097,
+  61266,
+  61432,
+  61594,
+  61753,
+  61908,
+  62059,
+  62208,
+  62353,
+  62494,
+  62632,
+  62767,
+  62899,
+  63028,
+  63153,
+  63276,
+  63395,
+  63512,
+  63625,
+  63736,
+  63844,
+  63949,
+  64051,
+  64151,
+  64248,
+  64342,
+  64434,
+  64523,
+  64610,
+  64695,
+  64777,
+  64856,
+  64934,
+  65009,
+  65082,
+  65153,
+  65222,
+  65289,
+  65354,
+  65416,
+  65477,
+  65536
+];
+
+// color/sigma-gradient-stops.ts
+function sigmaGradientStops(stops) {
+  if (stops.length !== 2 || stops[0]?.offset !== 0 || stops[1]?.offset !== 1) return void 0;
+  if (stops.some((stop) => (stop.opacity ?? 1) !== 1)) return void 0;
+  const front = hexToRgbChannels(stops[0].color);
+  const back = hexToRgbChannels(stops[1].color);
+  if (!front || !back) return void 0;
+  return OFFICE_SIGMA_FACTORS.map((value, index) => {
+    const factor = value / 65536;
+    const mix = (a, b) => toHex(255 * ((a / 255) ** 2.2 * (1 - factor) + (b / 255) ** 2.2 * factor) ** (1 / 2.2));
+    return {
+      offset: Math.fround(index / 255),
+      color: `#${mix(front.r, back.r)}${mix(front.g, back.g)}${mix(front.b, back.b)}`,
+      opacity: 1
+    };
+  });
+}
+
+// color/hex-rgb.ts
+function parseArgbHex(hex) {
+  const clean2 = hex.replace(/^#/, "");
+  const rgb = clean2.length === 8 ? clean2.slice(2) : clean2;
+  if (!/^[0-9a-fA-F]{6}$/.test(rgb)) return void 0;
+  return [0, 2, 4].map((i) => parseInt(rgb.slice(i, i + 2), 16));
+}
+
+// drawingml/ordered-color-transforms.ts
+function orderedColorTransforms(channels, transforms) {
+  let { r, g, b } = channels;
+  let alpha = 1;
+  const wrap = (value) => (value % 360 + 360) % 360;
+  for (const transform of transforms) {
+    const { name, value } = transform;
+    const fraction = parseDrawingFraction(value);
+    if (name === "alpha" && fraction !== void 0) alpha = clampUnitInterval(fraction);
+    else if (name === "alphaMod" && fraction !== void 0)
+      alpha = clampUnitInterval(alpha * fraction);
+    else if (name === "alphaOff" && fraction !== void 0)
+      alpha = clampUnitInterval(alpha + fraction);
+    else if (name === "inv") [r, g, b] = [255 - r, 255 - g, 255 - b];
+    else if (name === "gray") r = g = b = 0.299 * r + 0.587 * g + 0.114 * b;
+    else if ((name === "shade" || name === "tint") && fraction !== void 0) {
+      const mix = (channel) => linearToSrgb255(
+        name === "shade" ? srgb255ToLinear(channel) * fraction : 1 - (1 - srgb255ToLinear(channel)) * fraction
+      );
+      [r, g, b] = [mix(r), mix(g), mix(b)];
+    } else {
+      const hsl = rgbToHsl(r, g, b);
+      if (name === "comp") hsl.h = wrap(hsl.h + 180);
+      else if (name === "hue") {
+        const hue = parseDrawingHueDegrees(value);
+        if (hue !== void 0) hsl.h = wrap(hue);
+      } else if (name === "hueOff") {
+        const hue = parseDrawingHueDegrees(value);
+        if (hue !== void 0) hsl.h = wrap(hsl.h + hue);
+      } else if (name === "hueMod" && fraction !== void 0) hsl.h = wrap(hsl.h * fraction);
+      else if (name === "sat" && fraction !== void 0) hsl.s = clampUnitInterval(fraction);
+      else if (name === "satMod" && fraction !== void 0) hsl.s *= fraction;
+      else if (name === "satOff" && fraction !== void 0)
+        hsl.s = clampUnitInterval(hsl.s + fraction);
+      else if (name === "lum" && fraction !== void 0) hsl.l = clampUnitInterval(fraction);
+      else if (name === "lumMod" && fraction !== void 0)
+        hsl.l = clampUnitInterval(hsl.l * fraction);
+      else if (name === "lumOff" && fraction !== void 0)
+        hsl.l = clampUnitInterval(hsl.l + fraction);
+      else continue;
+      ({ r, g, b } = hslToRgb(hsl.h, hsl.s, hsl.l, (channel) => channel, {
+        clampSaturation: false
+      }));
+    }
+  }
+  return { r, g, b, alpha };
+}
+
 // drawingml/drawing-color.ts
+var COLOR_ELEMENTS = {
+  srgbClr: "srgb",
+  schemeClr: "scheme",
+  sysClr: "system",
+  prstClr: "preset",
+  scrgbClr: "scrgb",
+  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");
+}
+function parseDrawingColorIn(container) {
+  if (!container) return void 0;
+  for (const element of elements(container)) {
+    const kind = COLOR_ELEMENTS[element.localName];
+    if (!kind || element.namespaceURI && element.namespaceURI !== NS.a) continue;
+    return parseDrawingColor(element);
+  }
+  return void 0;
+}
+function parseDrawingColor(element) {
+  const kind = COLOR_ELEMENTS[element.localName];
+  if (!kind) return void 0;
+  const color = {
+    kind,
+    value: colorValue(kind, element),
+    transforms: elements(element).map((child) => ({
+      name: child.localName,
+      value: child.getAttribute("val") ?? ""
+    }))
+  };
+  const fallback = kind === "system" ? element.getAttribute("lastClr") : null;
+  if (fallback) color.fallback = fallback;
+  return color;
+}
 var PRESET_COLORS = {
   black: "#000000",
   white: "#FFFFFF",
@@ -1794,6 +2169,17 @@ function resolveDrawingColor(color, theme, options) {
   const base = baseHex(color, theme);
   const rgb = base ? hexToRgbChannels(base) : null;
   if (!rgb) return void 0;
+  if (options?.transformOrder === "document") {
+    const value = orderedColorTransforms(rgb, color.transforms);
+    const round = options.hslRounding === "halfDown" ? (channel) => Math.ceil(channel - 0.5) : Math.round;
+    return {
+      hex: `#${toHex(round(value.r))}${toHex(round(value.g))}${toHex(round(value.b))}`,
+      alpha: value.alpha,
+      unapplied: [...new Set(color.transforms.map((transform) => transform.name))].filter(
+        (name) => !APPLIED.has(name)
+      )
+    };
+  }
   let { r, g, b } = rgb;
   const find = (name) => color.transforms.find((entry) => entry.name === name)?.value;
   const has = (name) => color.transforms.some((entry) => entry.name === name);
@@ -1836,7 +2222,7 @@ function resolveDrawingColor(color, theme, options) {
     if (lumMod !== void 0) hsl.l = clampUnitInterval(hsl.l * lumMod);
     const lumOff = parseDrawingFraction(find("lumOff"));
     if (lumOff !== void 0) hsl.l = clampUnitInterval(hsl.l + lumOff);
-    const round = Math.round;
+    const round = options?.hslRounding === "halfDown" ? (value) => Math.ceil(value - 0.5) : Math.round;
     ({ r, g, b } = hslToRgb(hsl.h, hsl.s, hsl.l, round));
   }
   let alpha = parseDrawingPercent(find("alpha")) ?? 1;
@@ -1891,6 +2277,11 @@ function themeColorSlotFor(name, colorMap = {}) {
   if (name === "dk1" || name === "lt1" || name === "dk2" || name === "lt2") return name;
   return colorMap[name] ?? name;
 }
+function themeSlotHex(color) {
+  if (!color) return void 0;
+  const value = color.kind === "srgb" ? color.value : color.kind === "system" ? color.fallback : void 0;
+  return value ? value.toUpperCase() : void 0;
+}
 
 // docx/theme-color.ts
 function isThemeColorToken(value) {
@@ -1900,6 +2291,11 @@ function fractionToThemeByte(fraction) {
   return toHex(Math.round(Math.min(1, Math.max(0, fraction)) * 255));
 }
 
+// opc/signature/xml-utils.ts
+function escapeXmlAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
 // docx/comment-spans.ts
 function rangeKeys(run) {
   const keys = (run.commentIds ?? []).map((id) => `comment:${id}`);
@@ -2190,24 +2586,24 @@ function updateDirection(doc, props, paragraph, base) {
   }
 }
 function updateSpacing(doc, props, paragraph, base) {
-  let spacing = first2(props, "spacing");
-  if (!spacing) {
-    spacing = makeW(doc, "spacing");
-    props.appendChild(spacing);
+  let spacing2 = first2(props, "spacing");
+  if (!spacing2) {
+    spacing2 = makeW(doc, "spacing");
+    props.appendChild(spacing2);
   }
   if (!base || paragraph.spacingBeforeTwips !== base.spacingBeforeTwips)
-    setWordValue(spacing, "before", paragraph.spacingBeforeTwips);
+    setWordValue(spacing2, "before", paragraph.spacingBeforeTwips);
   if (!base || paragraph.spacingAfterTwips !== base.spacingAfterTwips)
-    setWordValue(spacing, "after", paragraph.spacingAfterTwips);
+    setWordValue(spacing2, "after", paragraph.spacingAfterTwips);
   if (!base || paragraph.lineSpacingTwips !== base.lineSpacingTwips || paragraph.lineSpacingRule !== base.lineSpacingRule) {
-    setWordValue(spacing, "line", paragraph.lineSpacingTwips);
+    setWordValue(spacing2, "line", paragraph.lineSpacingTwips);
     setWordValue(
-      spacing,
+      spacing2,
       "lineRule",
       paragraph.lineSpacingRule ?? (paragraph.lineSpacingTwips === void 0 ? void 0 : "auto")
     );
   }
-  if (!spacing.attributes.length && !spacing.childNodes.length) props.removeChild(spacing);
+  if (!spacing2.attributes.length && !spacing2.childNodes.length) props.removeChild(spacing2);
 }
 function updateIndent(doc, props, paragraph, base) {
   let indent = first2(props, "ind");
@@ -2530,10 +2926,10 @@ function hasUnexpectedAttributes(element, allowed, allowDateUtc = false) {
   }
   return false;
 }
-function runPropertiesHaveUnknownContent(properties3) {
-  if (!properties3) return false;
-  if (hasUnexpectedAttributes(properties3, [])) return true;
-  for (const node of Array.from(properties3.childNodes)) {
+function runPropertiesHaveUnknownContent(properties4) {
+  if (!properties4) return false;
+  if (hasUnexpectedAttributes(properties4, [])) return true;
+  for (const node of Array.from(properties4.childNodes)) {
     if (node.nodeType !== 1) {
       if (node.nodeType === 3 && node.textContent?.trim()) return true;
       continue;
@@ -2637,9 +3033,9 @@ function setExtendedRunProperties(doc, props, run, base) {
   if (changed("characterSpacingTwips")) {
     removeChildren2(props, "spacing");
     if (run.characterSpacingTwips !== void 0) {
-      const spacing = makeW(doc, "spacing");
-      setAttribute5(spacing, "val", String(Math.round(run.characterSpacingTwips)));
-      props.appendChild(spacing);
+      const spacing2 = makeW(doc, "spacing");
+      setAttribute5(spacing2, "val", String(Math.round(run.characterSpacingTwips)));
+      props.appendChild(spacing2);
     }
   }
   if (changed("shadingFill") || changed("shadingThemeFill")) {
@@ -2737,13 +3133,13 @@ function buildWatermarkRun(doc, spec, uniqueId) {
   shape.setAttribute("stroked", "f");
   const fill = v("fill");
   fill.setAttribute("opacity", spec.semitransparent ? ".5" : "1");
-  const text = v("textpath");
-  text.setAttribute("style", `font-family:"${spec.fontFamily ?? "Calibri"}";font-size:1pt`);
-  text.setAttribute("string", spec.text);
+  const text2 = v("textpath");
+  text2.setAttribute("style", `font-family:"${spec.fontFamily ?? "Calibri"}";font-size:1pt`);
+  text2.setAttribute("string", spec.text);
   const wrap = makeNS(doc, WORD10_NS, "w10:wrap");
   wrap.setAttribute("anchorx", "margin");
   wrap.setAttribute("anchory", "margin");
-  for (const child of [fill, text, wrap]) shape.appendChild(child);
+  for (const child of [fill, text2, wrap]) shape.appendChild(child);
   pict.appendChild(type);
   pict.appendChild(shape);
   run.appendChild(pict);
@@ -2763,15 +3159,15 @@ var add = (parent, ...items) => {
 var emu = (px) => String(Math.max(1, Math.round(px * EMU_PER_PIXEL)));
 var descendants = (root, ns, local) => Array.from(root.getElementsByTagNameNS(ns, local));
 function paragraphsFor(doc, lines) {
-  return (lines.length ? lines : [""]).map((line) => {
+  return (lines.length ? lines : [""]).map((line2) => {
     const paragraph = makeW(doc, "p");
-    if (line) {
+    if (line2) {
       const run = makeW(doc, "r");
-      const text = makeW(doc, "t");
-      if (/^\s|\s$/.test(line))
-        text.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
-      text.textContent = line;
-      add(run, text);
+      const text2 = makeW(doc, "t");
+      if (/^\s|\s$/.test(line2))
+        text2.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
+      text2.textContent = line2;
+      add(run, text2);
       add(paragraph, run);
     }
     return paragraph;
@@ -2815,6 +3211,1962 @@ function patchTextBox(doc, drawing, image, base) {
   }
 }
 
+// drawingml/drawing-color-css.ts
+function drawingColorCss(value) {
+  if (!value || value.alpha === 1) return value?.hex;
+  const channels = [1, 3, 5].map(
+    (offset) => Number.parseInt(value.hex.slice(offset, offset + 2), 16)
+  );
+  return `rgba(${channels.join(",")},${value.alpha})`;
+}
+
+// drawingml/drawing-shadow.ts
+function resolveDrawingShadow(effects, theme) {
+  const node = first(effects, "outerShdw", NS.a);
+  if (!node) return void 0;
+  const value = (key, fallback) => Number(node.getAttribute(key) ?? fallback);
+  if (value("sx", 1e5) !== 1e5 || value("sy", 1e5) !== 1e5 || value("kx", 0) !== 0 || value("ky", 0) !== 0)
+    return void 0;
+  const color = parseDrawingColorIn(node);
+  const resolved = color && resolveDrawingColor(color, theme, { transformOrder: "document" });
+  const blur = value("blurRad", 0) / EMU_PER_PIXEL;
+  const distance = value("dist", 0) / EMU_PER_PIXEL;
+  const angle = value("dir", 0) / 6e4 * Math.PI / 180;
+  if (!resolved || ![blur, distance, angle].every(Number.isFinite) || blur < 0 || distance < 0)
+    return void 0;
+  return {
+    color: resolved.hex,
+    opacity: resolved.alpha,
+    blur,
+    dx: Math.cos(angle) * distance,
+    dy: Math.sin(angle) * distance
+  };
+}
+function resolveDrawingShadowXml(xml, theme) {
+  return xml ? resolveDrawingShadow(parseXml(xml).documentElement, theme) : void 0;
+}
+function svgDropShadowElement(s, format) {
+  const num = format.number;
+  return `<feDropShadow dx="${num(s.dx)}" dy="${num(s.dy)}" stdDeviation="${num(s.blur / 2)}" flood-color="${format.color(s.color, "#000000")}" flood-opacity="${num(s.opacity)}" result="shadow"/>`;
+}
+function hexToRgb(color) {
+  const parsed = hexToRgbChannels(color);
+  if (parsed) return parsed;
+  const hex = color.replace("#", "");
+  return {
+    r: Number.parseInt(hex.slice(0, 2), 16) || 0,
+    g: Number.parseInt(hex.slice(2, 4), 16) || 0,
+    b: Number.parseInt(hex.slice(4, 6), 16) || 0
+  };
+}
+function toHexChannel(value) {
+  return toHex(value).toLowerCase();
+}
+function lerpStops(a, b, t) {
+  const ca = hexToRgb(a.color);
+  const cb = hexToRgb(b.color);
+  const oa = a.opacity ?? 1;
+  const ob = b.opacity ?? 1;
+  return {
+    color: `#${toHexChannel(ca.r + (cb.r - ca.r) * t)}${toHexChannel(ca.g + (cb.g - ca.g) * t)}${toHexChannel(ca.b + (cb.b - ca.b) * t)}`,
+    opacity: oa + (ob - oa) * t
+  };
+}
+function colorAt(stops, position) {
+  const first3 = stops[0];
+  const last = stops[stops.length - 1];
+  if (position <= first3.position) {
+    return { color: first3.color, opacity: first3.opacity ?? 1 };
+  }
+  if (position >= last.position) {
+    return { color: last.color, opacity: last.opacity ?? 1 };
+  }
+  for (let i = 0; i < stops.length - 1; i += 1) {
+    const from = stops[i];
+    const to = stops[i + 1];
+    if (position >= from.position && position <= to.position) {
+      const span = to.position - from.position;
+      const t = span > 0 ? (position - from.position) / span : 0;
+      return lerpStops(from, to, t);
+    }
+  }
+  return { color: last.color, opacity: last.opacity ?? 1 };
+}
+function resolveInnerRect(fillToRect, focalPoint) {
+  let centerX = 50;
+  let centerY = 50;
+  let width = 0;
+  let height = 0;
+  if (fillToRect) {
+    const { l, t, r, b } = fillToRect;
+    centerX = (l + (1 - r)) / 2 * 100;
+    centerY = (t + (1 - b)) / 2 * 100;
+    width = Math.max(0, Math.min(1, 1 - l - r)) * 100;
+    height = Math.max(0, Math.min(1, 1 - t - b)) * 100;
+  }
+  return {
+    left: centerX - width / 2,
+    top: centerY - height / 2,
+    right: centerX + width / 2,
+    bottom: centerY + height / 2
+  };
+}
+function lerpEdge(inner, outer, t) {
+  return inner + (outer - inner) * t;
+}
+function buildRectPathGradientSvg(stops, focalPoint, fillToRect, options) {
+  if (stops.length === 0) {
+    return '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"/>';
+  }
+  const sorted = [...stops].sort((a, b) => a.position - b.position);
+  const inner = resolveInnerRect(fillToRect);
+  const rects = [];
+  const alphaRects = [];
+  const masked = sorted.some((stop) => (stop.opacity ?? 1) < 1);
+  const bands = options?.bands;
+  if (!Number.isInteger(bands) || bands < 1) throw new RangeError("Invalid gradient band count");
+  for (let i = bands; i >= 0; i -= 1) {
+    const t = i / bands;
+    const { color, opacity } = colorAt(sorted, t * 100);
+    const left = lerpEdge(inner.left, 0, t);
+    const top = lerpEdge(inner.top, 0, t);
+    const right = lerpEdge(inner.right, 100, t);
+    const bottom = lerpEdge(inner.bottom, 100, t);
+    const opacityAttr = !masked && opacity < 1 ? ` fill-opacity="${Math.max(0, opacity).toFixed(3)}"` : "";
+    rects.push(
+      `<rect x="${left.toFixed(2)}" y="${top.toFixed(2)}" width="${(right - left).toFixed(2)}" height="${(bottom - top).toFixed(2)}" fill="${color}"${opacityAttr}/>`
+    );
+    if (masked) {
+      const channel = toHexChannel(opacity * 255);
+      alphaRects.push(
+        `<rect x="${left.toFixed(2)}" y="${top.toFixed(2)}" width="${(right - left).toFixed(2)}" height="${(bottom - top).toFixed(2)}" fill="#${channel}${channel}${channel}"/>`
+      );
+    }
+  }
+  const paint = masked ? `<defs><mask id="alpha" maskUnits="userSpaceOnUse" x="0" y="0" width="100" height="100" mask-type="luminance" color-interpolation="sRGB">${alphaRects.join("")}</mask></defs><g mask="url(#alpha)">${rects.join("")}</g>` : rects.join("");
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" preserveAspectRatio="none">${paint}</svg>`;
+}
+
+// chart/color-palettes.ts
+var COLORFUL_VARIATIONS = [
+  {},
+  { lumMod: 6e4 },
+  { lumMod: 8e4, lumOff: 2e4 },
+  { lumMod: 8e4 },
+  { lumMod: 6e4, lumOff: 4e4 },
+  { lumMod: 5e4 },
+  { lumMod: 7e4, lumOff: 3e4 },
+  { lumMod: 7e4 },
+  { lumMod: 5e4, lumOff: 5e4 }
+];
+var GRAY_VARIATIONS = [
+  { tint: 88500 },
+  { tint: 55e3 },
+  { tint: 75e3 },
+  { tint: 98500 },
+  { tint: 3e4 },
+  { tint: 6e4 },
+  { tint: 8e4 }
+];
+var ACCENTS = ["accent1", "accent2", "accent3", "accent4", "accent5", "accent6"];
+function colorful(id, index, base) {
+  return { id, group: "colorful", index, meth: "cycle", base, variations: COLORFUL_VARIATIONS };
+}
+function mono(id, index, accent, meth) {
+  return { id, group: "monochromatic", index, meth, base: [accent], variations: [] };
+}
+var CHART_COLOR_PALETTES = [
+  colorful(10, 1, ACCENTS),
+  colorful(11, 2, ["accent1", "accent3", "accent5"]),
+  colorful(12, 3, ["accent2", "accent4", "accent6"]),
+  colorful(13, 4, ["accent6", "accent5", "accent4"]),
+  ...ACCENTS.map((accent, i) => mono(14 + i, 1 + i, accent, "withinLinear")),
+  {
+    id: 20,
+    group: "monochromatic",
+    index: 7,
+    meth: "cycle",
+    base: ["dk1"],
+    variations: GRAY_VARIATIONS
+  },
+  ...ACCENTS.map((accent, i) => mono(21 + i, 8 + i, accent, "withinLinearReversed"))
+];
+function findChartColorPalette(id) {
+  return CHART_COLOR_PALETTES.find((palette) => palette.id === id);
+}
+function withinLinearTransform(i, n2) {
+  if (n2 <= 1) {
+    return {};
+  }
+  const step = 140 / (n2 + 1);
+  const centre = (n2 - 1) / 2;
+  const value = 100 - step * Math.abs(i - centre);
+  if (i < centre) {
+    return { shade: Math.floor(value + 1e-9) * 1e3 };
+  }
+  if (i > centre) {
+    return { tint: Math.ceil(value - 1e-9) * 1e3 };
+  }
+  return {};
+}
+function chartPaletteSeriesColorChoice(palette, i, n2) {
+  let base;
+  let transform;
+  if (palette.meth === "cycle") {
+    base = palette.base[i % palette.base.length];
+    const round = Math.floor(i / palette.base.length);
+    transform = (palette.variations.length ? palette.variations[round % palette.variations.length] : {}) ?? {};
+  } else {
+    const index = palette.meth === "withinLinearReversed" ? n2 - 1 - i : i;
+    base = palette.base[0];
+    transform = withinLinearTransform(index, n2);
+  }
+  if (!base) throw new RangeError("A chart palette must have a base color");
+  return {
+    kind: "scheme",
+    value: base,
+    transforms: Object.entries(transform).map(([name, value]) => ({ name, value: String(value) }))
+  };
+}
+function chartPaletteSeriesColor(palette, i, n2, scheme) {
+  const choice = chartPaletteSeriesColorChoice(palette, i, n2);
+  return (resolveDrawingColor(choice, { scheme: (name) => scheme[name] })?.hex ?? scheme[choice.value]).toUpperCase();
+}
+
+// chart/style-definition.ts
+var CHART_STYLE_PARTS = [
+  "title",
+  "axisTitle",
+  "categoryAxis",
+  "valueAxis",
+  "legend",
+  "dataLabel",
+  "dataPoint",
+  "dataPointLine",
+  "gridlineMajor",
+  "gridlineMinor",
+  "chartArea",
+  "plotArea"
+];
+function resolveChartStyleDefinition(style, resolve) {
+  const out = {};
+  const fillColor = (fill) => fill?.kind === "none" ? "none" : fill?.kind === "solid" ? resolve(fill.color) : void 0;
+  for (const name of CHART_STYLE_PARTS) {
+    const source = style.entries[name];
+    if (!source) continue;
+    const entry = {};
+    for (const key of ["fontSize", "bold", "italic", "underline"]) {
+      const value = source[key];
+      if (value !== void 0) Object.assign(entry, { [key]: value });
+    }
+    const line2 = fillColor(source.line?.fill) ?? (source.lineRef?.color && resolve(source.lineRef.color));
+    const fill = fillColor(source.fill) ?? (source.fillRef?.color && resolve(source.fillRef.color));
+    const color = (source.textColor && resolve(source.textColor)) ?? (source.fontRef?.color && resolve(source.fontRef.color));
+    if (color !== void 0) entry.color = color;
+    if (line2 !== void 0) entry.lineColor = line2;
+    if (fill !== void 0) entry.fillColor = fill;
+    if (source.line?.widthEmu !== void 0 && source.line.widthEmu > 0)
+      entry.lineWidth = source.line.widthEmu / 12700;
+    if (Object.keys(entry).length) out[name] = entry;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function effectiveBuiltInChartStyle(formatting) {
+  return formatting?.builtInStyle ?? (formatting?.sourceXml ? void 0 : 102);
+}
+function builtInChartTextStyle(id) {
+  if (id === void 0 || !Number.isInteger(id) || !(id >= 1 && id <= 48 || id >= 101 && id <= 148))
+    return {};
+  const legacy = id > 100 ? id - 100 : id;
+  const common = {
+    sourceXml: "",
+    fontSize: 10,
+    bold: false,
+    italic: false,
+    fontRef: {
+      index: "minor",
+      color: { kind: "scheme", value: legacy >= 41 ? "lt1" : "tx1", transforms: [] }
+    }
+  };
+  return {
+    title: { ...common, fontSize: id > 100 ? 18 : 10, bold: true },
+    categoryAxis: { ...common },
+    valueAxis: { ...common },
+    legend: { ...common }
+  };
+}
+
+// chart/manual-layout.ts
+function hasManualLayoutFields(layout) {
+  return layout != null && (layout.x !== void 0 || layout.y !== void 0 || layout.width !== void 0 || layout.height !== void 0);
+}
+function resolveManualLayoutRect(layout, frame, auto) {
+  if (!hasManualLayoutFields(layout)) return void 0;
+  const x = layout.x === void 0 ? auto.x : layout.xMode === "edge" ? layout.x * frame.width : auto.x + layout.x * frame.width;
+  const y = layout.y === void 0 ? auto.y : layout.yMode === "edge" ? layout.y * frame.height : auto.y + layout.y * frame.height;
+  const width = layout.width === void 0 ? auto.width : layout.widthMode === "edge" ? layout.width * frame.width - x : layout.width * frame.width;
+  const height = layout.height === void 0 ? auto.height : layout.heightMode === "edge" ? layout.height * frame.height - y : layout.height * frame.height;
+  return { x, y, width: Math.max(width, 1), height: Math.max(height, 1) };
+}
+
+// chart/gradient-stop-edit.ts
+function sortGradientStops(stops) {
+  return stops.slice().sort((a, b) => a.position - b.position);
+}
+
+// chart/gradient-coincident-stops.ts
+var NATIVE_COINCIDENT_STOP_RAMP = 1 / 256;
+function spreadCoincidentStops(stops) {
+  const out = [];
+  for (const [index, stop] of stops.entries()) {
+    const source = stops[index - 1];
+    const previous = out.at(-1);
+    const next = stops[index + 1];
+    if (!source || !previous || stop.offset !== source.offset || stop.color === source.color && (stop.opacity ?? 1) === (source.opacity ?? 1)) {
+      out.push(stop);
+      continue;
+    }
+    const limit = Math.min(1, next ? next.offset : 1);
+    out.push({
+      ...stop,
+      offset: Math.max(stop.offset, Math.min(previous.offset + NATIVE_COINCIDENT_STOP_RAMP, limit))
+    });
+  }
+  return out;
+}
+
+// chart/gradient-definition.ts
+function resolveChartGradient(fill, resolve) {
+  const focus = fill.fillToRect;
+  const stops = fill.stops.flatMap((stop) => {
+    const color = resolve(stop.color);
+    return color ? [{ position: stop.position, color: color.hex, opacity: color.alpha }] : [];
+  });
+  return {
+    type: fill.path ? "radial" : "linear",
+    stops,
+    ...fill.angle === void 0 ? {} : { angle: fill.angle },
+    ...fill.scaled === void 0 ? {} : { scaled: fill.scaled },
+    ...fill.path === void 0 ? {} : { path: fill.path },
+    ...focus === void 0 ? {} : { fillToRect: { ...focus } },
+    // Native opaque endpoint-pair linear, rect, circle and rectangular-shape profiles.
+    ...(!fill.path && fill.scaled === true || ["rect", "circle", "shape"].includes(fill.path ?? "")) && fill.stops.length === 2 && stops.length === 2 && stops.every((stop) => stop.opacity === 1) && stops.some((stop) => stop.position === 0) && stops.some((stop) => stop.position === 100) ? { interpolation: "sigma-gamma22" } : {},
+    ...focus ? { focalPoint: { x: (1 + focus.l - focus.r) / 2, y: (1 + focus.t - focus.b) / 2 } } : {}
+  };
+}
+function buildChartGradientDef(id, fill, bounds) {
+  const sourceStops = sortGradientStops(fill.stops).map((stop) => ({
+    offset: Math.min(Math.max(stop.position / 100, 0), 1),
+    color: stop.color,
+    ...stop.opacity !== void 0 ? { opacity: stop.opacity } : {}
+  }));
+  const stops = fill.interpolation === "sigma-gamma22" ? sigmaGradientStops(sourceStops) ?? sourceStops : sourceStops;
+  if (fill.type === "radial" && (fill.path === "rect" || fill.path === "shape" && bounds?.shape === "rect")) {
+    const markup = buildRectPathGradientSvg(
+      stops.map((stop) => ({
+        position: stop.offset * 100,
+        color: stop.color,
+        ...stop.opacity === void 0 ? {} : { opacity: stop.opacity }
+      })),
+      void 0,
+      fill.fillToRect,
+      { bands: 1024}
+    );
+    return {
+      kind: "rectPath",
+      id,
+      href: `data:image/svg+xml,${encodeURIComponent(markup)}`,
+      stops
+    };
+  }
+  if (fill.type === "radial") {
+    const cx = fill.focalPoint?.x ?? 0.5;
+    const cy = fill.focalPoint?.y ?? 0.5;
+    const aspect = fill.path === "circle" && bounds && Number.isFinite(bounds.width) && Number.isFinite(bounds.height) && bounds.width > 0 && bounds.height > 0 ? bounds.height / bounds.width : 1;
+    return {
+      kind: "radialGradient",
+      id,
+      cx,
+      cy,
+      r: Math.max(
+        ...[0, 1].flatMap((x) => [0, 1].map((y) => Math.hypot(x - cx, (y - cy) * aspect)))
+      ),
+      ...aspect === 1 ? {} : { gradientTransform: `matrix(1 0 0 ${1 / aspect} 0 ${cy * (1 - 1 / aspect)})` },
+      stops
+    };
+  }
+  const rad = (fill.angle ?? 0) * Math.PI / 180;
+  const span = fill.scaled ? Math.abs(Math.cos(rad)) + Math.abs(Math.sin(rad)) : 1;
+  const dx = Math.cos(rad) * span / 2;
+  const dy = Math.sin(rad) * span / 2;
+  const round = (value) => Math.round(value * 1e4) / 1e4;
+  return {
+    kind: "linearGradient",
+    id,
+    x1: round(0.5 - dx),
+    y1: round(0.5 - dy),
+    x2: round(0.5 + dx),
+    y2: round(0.5 + dy),
+    stops: spreadCoincidentStops(stops)
+  };
+}
+
+// chart/gradient-markup.ts
+function chartGradientMarkup(def) {
+  if (def.kind === "rectPath")
+    return `<pattern id="${escapeXmlAttr(def.id)}" patternUnits="objectBoundingBox" patternContentUnits="objectBoundingBox" width="1" height="1"><image href="${escapeXmlAttr(def.href)}" width="1" height="1" preserveAspectRatio="none"/></pattern>`;
+  const geometry = def.kind === "linearGradient" ? `x1="${def.x1}" y1="${def.y1}" x2="${def.x2}" y2="${def.y2}"` : `cx="${def.cx}" cy="${def.cy}" r="${def.r}"`;
+  const stops = def.stops.map(
+    (stop) => `<stop offset="${stop.offset}" stop-color="${escapeXmlAttr(stop.color)}" stop-opacity="${stop.opacity ?? 1}"/>`
+  ).join("");
+  const transform = def.kind === "radialGradient" && def.gradientTransform ? ` gradientTransform="${escapeXmlAttr(def.gradientTransform)}"` : "";
+  return `<${def.kind} id="${escapeXmlAttr(def.id)}" ${geometry}${transform}>${stops}</${def.kind}>`;
+}
+
+// chart/bar-cluster-geometry.ts
+var DEFAULT_BAR_GAP_WIDTH = 150;
+function clusteredBarGeometry(barGroupWidth, seriesCount, chartData) {
+  const overlap = chartData.barOverlap ?? 0;
+  const overlapSpan = 1 + (seriesCount - 1) * (1 - overlap / 100);
+  const gapWidth = chartData.barGapWidth ?? DEFAULT_BAR_GAP_WIDTH;
+  const singleBarWidth = barGroupWidth / (overlapSpan + Math.max(gapWidth, 0) / 100);
+  const step = singleBarWidth * (1 - overlap / 100);
+  return { singleBarWidth, step, clusterWidth: singleBarWidth + step * (seriesCount - 1) };
+}
+
+// chart/data-cache.ts
+function chartCacheValues(cache) {
+  if (!cache) return [];
+  const numeric = cache.type === "number";
+  const out = [];
+  for (const point of cache.points) {
+    const text2 = point.value;
+    out[point.index ?? out.length] = numeric && text2.trim() !== "" && Number.isFinite(Number(text2)) ? Number(text2) : text2;
+  }
+  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;
+}
+var chartSourceValues = (source) => chartCacheValues(source?.cache ?? source?.levels?.[0]);
+
+// chart/render/summary-from-space.ts
+var solidColor = (fill) => fill?.kind === "solid" ? fill.color : void 0;
+var isSolidFill = (fill) => fill?.kind === "solid" || fill?.kind === "unsupported" && fill.element === "solidFill";
+var GROUP_TYPES = {
+  bar: "bar",
+  line: "line",
+  area: "area",
+  pie: "pie",
+  ofPie: "pie",
+  doughnut: "doughnut",
+  scatter: "scatter",
+  radar: "radar",
+  bubble: "bubble",
+  stock: "stock",
+  surface: "surface"
+};
+var GROUPINGS = /* @__PURE__ */ new Set(["clustered", "stacked", "percentStacked", "standard"]);
+function chartSummarySeries(source, chartType) {
+  const categories = source.categories ?? source.xValues;
+  const values = source.values ?? source.yValues;
+  const out = {
+    categories: chartSourceValues(categories),
+    values: chartSourceValues(values).map(
+      (v) => typeof v === "number" ? v : v === "" ? null : Number.isFinite(Number(v)) ? Number(v) : null
+    )
+  };
+  if (source.tx?.text !== void 0) out.name = source.tx.text;
+  const nameRef = source.tx?.reference?.formula;
+  if (nameRef) out.nameRef = nameRef;
+  if (categories?.formula) out.categoriesRef = categories.formula;
+  if (values?.formula) out.valuesRef = values.formula;
+  if (source.spPr?.effectsXml) out.effectsXml = source.spPr.effectsXml;
+  const primary = ["line", "scatter", "radar"].includes(chartType) ? source.spPr?.line?.fill : source.spPr?.fill;
+  const fill = chartType === "scatter" && !isSolidFill(primary) ? source.marker?.spPr?.fill : primary;
+  const drawingColor = solidColor(fill);
+  if (drawingColor) out.drawingColor = drawingColor;
+  if (fill && fill.kind !== "solid" && !(chartType === "scatter" && fill.kind === "none"))
+    out.fill = fill;
+  const points = {};
+  const pointFills = {};
+  for (const point of source.dataPoints) {
+    const properties4 = point.spPr ?? point.marker?.spPr;
+    if (point.index === void 0) continue;
+    const pointColor = solidColor(properties4?.fill);
+    if (pointColor) points[point.index] = pointColor;
+    if (properties4?.fill && properties4.fill.kind !== "solid")
+      pointFills[point.index] = properties4.fill;
+  }
+  if (Object.keys(points).length) out.pointColors = points;
+  if (Object.keys(pointFills).length) out.pointFills = pointFills;
+  return out;
+}
+function chartSummaryFromSpace(chartSpace, extras = {}) {
+  const group = chartSpace.plotArea.groups[0];
+  let chartType = group ? GROUP_TYPES[group.kind] : "column";
+  if (chartType === "bar" && group?.barDirection !== "bar") chartType = "column";
+  const series = (group?.series ?? []).map((source) => chartSummarySeries(source, chartType));
+  const summary = {
+    chartType,
+    series,
+    showLegend: chartSpace.legend !== void 0
+  };
+  const grouping = group?.grouping;
+  if (grouping && GROUPINGS.has(grouping))
+    summary.grouping = grouping;
+  if (chartType === "bar" || chartType === "column") {
+    for (const [value, field, fallback, min, max] of [
+      [group?.gapWidth, "barGapWidth", 150, 0, 500],
+      [group?.overlap, "barOverlap", 0, -100, 100]
+    ]) {
+      const resolved = value ?? fallback;
+      if (Number.isInteger(resolved) && resolved >= min && resolved <= max)
+        summary[field] = resolved;
+    }
+  }
+  if (chartSpace.title && chartSpace.autoTitleDeleted !== true) {
+    const title = chartSpace.title.text;
+    if (title !== void 0) summary.title = title;
+    else if (series.length === 1 && series[0]?.name) summary.title = series[0].name;
+  }
+  const legendPos = chartSpace.legend?.position;
+  if (legendPos && ["r", "l", "t", "b", "tr"].includes(legendPos))
+    summary.legendPosition = legendPos;
+  if (extras.formatting) summary.formatting = extras.formatting;
+  if (extras.colorPalette !== void 0) summary.colorPalette = extras.colorPalette;
+  if (extras.styleDefinition) summary.styleDefinition = extras.styleDefinition;
+  return summary;
+}
+
+// chart/render/chart-scale.ts
+var clean = (n2) => Number(n2.toPrecision(12));
+function* units(raw) {
+  let exp = Math.floor(Math.log10(raw)) - 1;
+  for (; ; ) {
+    const base = 10 ** exp;
+    for (const m of [1, 2, 5]) yield clean(m * base);
+    exp++;
+  }
+}
+function niceScale(dataMin, dataMax, options = {}) {
+  const maxIntervals = Math.max(1, options.maxIntervals ?? 10);
+  let lo = Number.isFinite(dataMin) ? dataMin : 0;
+  let hi = Number.isFinite(dataMax) ? dataMax : 0;
+  if (lo > hi) [lo, hi] = [hi, lo];
+  if (lo === hi) {
+    if (lo === 0) hi = 1;
+    else if (options.noZero) {
+      const pad = Math.abs(lo) * 0.1 || 1;
+      lo -= pad;
+      hi += pad;
+    } else if (lo > 0) lo = 0;
+    else hi = 0;
+  }
+  let fixedLo = false;
+  let fixedHi = false;
+  if (!options.noZero) {
+    if (lo >= 0 && hi - lo >= hi / 6) {
+      lo = 0;
+      fixedLo = true;
+    } else if (hi <= 0 && hi - lo >= -lo / 6) {
+      hi = 0;
+      fixedHi = true;
+    }
+  }
+  const range = hi - lo;
+  const top = fixedHi ? hi : hi + range * 0.05;
+  const bottom = fixedLo ? lo : lo - range * 0.05;
+  for (const unit of units(range / maxIntervals)) {
+    const min = fixedLo ? lo : Math.floor(clean(bottom / unit)) * unit;
+    const max = fixedHi ? hi : Math.ceil(clean(top / unit)) * unit;
+    const intervals = Math.round((max - min) / unit);
+    if (intervals <= maxIntervals && intervals > 0) {
+      const ticks = [];
+      for (let i = 0; i <= intervals; i++) ticks.push(clean(min + i * unit));
+      return { min: clean(min), max: clean(max), majorUnit: unit, ticks };
+    }
+  }
+  return { min: lo, max: hi, majorUnit: range, ticks: [lo, hi] };
+}
+var PERCENT_SCALE = {
+  min: 0,
+  max: 1,
+  majorUnit: 0.1,
+  ticks: [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
+};
+function formatAxisValue(value, percent = false) {
+  if (percent) return `${clean(value * 100)}%`;
+  const v = clean(value);
+  if (Math.abs(v) >= 1e15 || v !== 0 && Math.abs(v) < 1e-6)
+    return v.toExponential(2).replace("e+", "E+").replace("e-", "E-");
+  const [int = "0", frac] = String(Math.abs(v)).split(".");
+  const grouped = int.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return `${v < 0 ? "-" : ""}${grouped}${frac ? `.${frac}` : ""}`;
+}
+
+// chart/render/chart-svg-util.ts
+var TEXT_COLOR = "#595959";
+var GRID_COLOR = "#D9D9D9";
+var AXIS_COLOR = "#BFBFBF";
+var FONT_SIZE = 10;
+function esc(text2) {
+  return text2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var n = (value) => String(Math.round(value * 100) / 100);
+var textWidth = (text2, size = FONT_SIZE) => text2.length * size * 0.55;
+function text(x, y, content, attrs = {}) {
+  const parts = [`x="${n(x)}"`, `y="${n(y)}"`];
+  parts.push(`font-size="${attrs.size ?? FONT_SIZE}"`);
+  parts.push(`fill="${esc(attrs.fill ?? TEXT_COLOR)}"`);
+  if (attrs.anchor && attrs.anchor !== "start") parts.push(`text-anchor="${attrs.anchor}"`);
+  if (attrs.weight) parts.push(`font-weight="${attrs.weight}"`);
+  if (attrs.baseline) parts.push(`dominant-baseline="${attrs.baseline}"`);
+  if (attrs.family) parts.push(`font-family="${esc(attrs.family)}"`);
+  if (attrs.filter) parts.push(`filter="${esc(attrs.filter)}"`);
+  if (attrs.italic !== void 0) parts.push(`font-style="${attrs.italic ? "italic" : "normal"}"`);
+  if (attrs.underline !== void 0)
+    parts.push(`text-decoration="${attrs.underline ? "underline" : "none"}"`);
+  return `<text ${parts.join(" ")}>${esc(content)}</text>`;
+}
+var line = (x1, y1, x2, y2, stroke, width = 1) => `<line x1="${n(x1)}" y1="${n(y1)}" x2="${n(x2)}" y2="${n(y2)}" stroke="${stroke}" stroke-width="${width}"/>`;
+var rect = (x, y, w, h, fill, filter) => `<rect x="${n(x)}" y="${n(y)}" width="${n(Math.max(0, w))}" height="${n(Math.max(0, h))}" fill="${fill}"${filter ? ` filter="${esc(filter)}"` : ""}/>`;
+function fit(content, maxWidth, size = FONT_SIZE) {
+  if (textWidth(content, size) <= maxWidth) return content;
+  const chars = Math.max(1, Math.floor(maxWidth / (size * 0.55)) - 1);
+  return `${content.slice(0, chars)}\u2026`;
+}
+
+// chart/render/theme-palette.ts
+var THEME_SLOTS = [
+  "lt1",
+  "dk1",
+  "lt2",
+  "dk2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink"
+];
+var DEFAULT_THEME_COLORS = [
+  "FFFFFF",
+  "000000",
+  "E7E6E6",
+  "44546A",
+  "4472C4",
+  "ED7D31",
+  "A5A5A5",
+  "FFC000",
+  "5B9BD5",
+  "70AD47",
+  "0563C1",
+  "954F72"
+];
+function themeColor(theme, index) {
+  const hex = theme.colors[index] ?? DEFAULT_THEME_COLORS[index];
+  return hex && parseArgbHex(hex) ? hex.replace(/^#/, "") : void 0;
+}
+
+// chart/render/chart-colors.ts
+function chartColorScheme(theme) {
+  const slots = Object.fromEntries(
+    THEME_SLOTS.map((slot, index) => [slot, `#${themeColor(theme, index) ?? "000000"}`])
+  );
+  return {
+    ...slots,
+    bg1: slots.lt1,
+    tx1: slots.dk1,
+    bg2: slots.lt2,
+    tx2: slots.dk2
+  };
+}
+function autoSeriesColor(theme, index) {
+  const i = Math.max(0, Math.floor(index));
+  return chartPaletteSeriesColor(findChartColorPalette(10), i, i + 1, chartColorScheme(theme));
+}
+
+// chart/render/chart-value-axis.ts
+function valueAxis(model) {
+  const stackable = model.type === "bar" || model.type === "column" || model.type === "line" || model.type === "area";
+  if (stackable && model.grouping === "percentStacked")
+    return { ...PERCENT_SCALE, ticks: [...PERCENT_SCALE.ticks], percent: true };
+  let min = Infinity;
+  let max = -Infinity;
+  if (stackable && model.grouping === "stacked") {
+    for (let i = 0; i < model.categories.length; i++) {
+      let pos = 0;
+      let neg = 0;
+      for (const s of model.series) {
+        const v = s.values[i] ?? 0;
+        if (v >= 0) pos += v;
+        else neg += v;
+      }
+      min = Math.min(min, neg);
+      max = Math.max(max, pos);
+    }
+  } else {
+    for (const s of model.series)
+      for (const v of s.values)
+        if (v !== null) {
+          min = Math.min(min, v);
+          max = Math.max(max, v);
+        }
+  }
+  if (min === Infinity) {
+    min = 0;
+    max = 1;
+  }
+  return { ...niceScale(min, max), percent: false };
+}
+function categoryTotals(model) {
+  return model.categories.map(
+    (_, i) => model.series.reduce((sum, s) => sum + Math.abs(s.values[i] ?? 0), 0)
+  );
+}
+
+// chart/text-inheritance.ts
+var TEXT_KEYS = [
+  "fontSize",
+  "bold",
+  "italic",
+  "underline",
+  "typeface",
+  "textColor",
+  "fontRef"
+];
+var TEXT_PARTS = [
+  "title",
+  "axisTitle",
+  "categoryAxis",
+  "valueAxis",
+  "legend",
+  "dataLabel"
+];
+function inheritChartText(part, entry, builtIn, root) {
+  if (!root || !TEXT_PARTS.includes(part)) return entry;
+  const out = { ...entry };
+  for (const key of TEXT_KEYS) {
+    delete out[key];
+    const value = root[key] ?? builtIn?.[key];
+    if (value !== void 0) Object.assign(out, { [key]: value });
+  }
+  if (part === "title" && root.fontSize !== void 0) out.fontSize = root.fontSize * 1.2;
+  if (root.textEffectsXml !== void 0) out.textEffectsXml = root.textEffectsXml;
+  return out;
+}
+
+// chart/render/chart-appearance.ts
+var chartPointsToPixels = (points) => points * EMU_PER_POINT / EMU_PER_PIXEL;
+function typeface(entry, theme) {
+  const name = entry.typeface;
+  if (name?.startsWith("+mj-")) return theme.majorFont;
+  if (name?.startsWith("+mn-")) return theme.minorFont;
+  return name ?? (entry.fontRef?.index === "major" ? theme.majorFont : entry.fontRef?.index === "minor" ? theme.minorFont : void 0);
+}
+function chartAppearance(chart, theme) {
+  const defaults = builtInChartTextStyle(effectiveBuiltInChartStyle(chart.formatting));
+  const entries = {};
+  for (const part of CHART_STYLE_PARTS) {
+    const base = chart.styleDefinition?.entries[part];
+    const direct = chart.formatting?.entries[part];
+    if (!defaults[part] && !base && !direct) continue;
+    const entry = {
+      ...inheritChartText(
+        part,
+        { ...defaults[part], ...base, sourceXml: base?.sourceXml ?? "" },
+        defaults[part],
+        chart.formatting?.textDefaults
+      ),
+      ...direct,
+      sourceXml: direct?.sourceXml ?? base?.sourceXml ?? ""
+    };
+    if (base?.line || direct?.line) entry.line = { ...base?.line, ...direct?.line };
+    entries[part] = entry;
+  }
+  const scheme = chartColorScheme(theme);
+  const resolve = (color) => resolveDrawingColor(
+    color,
+    { scheme: (name) => scheme[name] },
+    { hslRounding: "halfDown", transformOrder: "document" }
+  );
+  const out = resolveChartStyleDefinition(
+    { entries},
+    (color) => drawingColorCss(resolve(color))
+  ) ?? {};
+  for (const part of CHART_STYLE_PARTS) {
+    const entry = entries[part];
+    if (!entry) continue;
+    const family = typeface(entry, theme);
+    const shadow = resolveDrawingShadowXml(entry.textEffectsXml, {
+      scheme: (name) => scheme[name]
+    });
+    if (shadow) (out[part] ??= {}).textShadow = shadow;
+    if (family) (out[part] ??= {}).typeface = family;
+    if (entry.axisVisible !== void 0) (out[part] ??= {}).axisVisible = entry.axisVisible;
+    if (entry.labelsVisible !== void 0) (out[part] ??= {}).labelsVisible = entry.labelsVisible;
+    if (entry.line?.widthEmu === 0) (out[part] ??= {}).lineWidth = 0;
+    if (entry.fill?.kind === "gradient") {
+      (out[part] ??= {}).gradient = resolveChartGradient(entry.fill, resolve);
+    }
+  }
+  return out;
+}
+
+// chart/render/chart-title-text.ts
+function properties(run) {
+  return {
+    ...run.sizePt === void 0 ? {} : { fontSize: run.sizePt },
+    ...run.bold === void 0 ? {} : { bold: run.bold },
+    ...run.italic === void 0 ? {} : { italic: run.italic },
+    ...run.underline === void 0 ? {} : { underline: run.underline },
+    ...run.typeface === void 0 ? {} : { typeface: run.typeface },
+    ...run.color === void 0 ? {} : { textColor: run.color }
+  };
+}
+function chartTitleText(chart, theme) {
+  const formatting = chart.formatting;
+  const entry = formatting?.entries.title;
+  const body = entry?.textBody;
+  if (!formatting || !body || body.text !== chart.title) return void 0;
+  if (body.paragraphs.length === 1 && body.paragraphs[0].runs.length <= 1 && !body.text.includes("\n") && !body.paragraphs[0].lineSpacing && !body.paragraphs[0].spaceBefore && !body.paragraphs[0].spaceAfter)
+    return void 0;
+  return {
+    paragraphs: body.paragraphs.map((paragraph) => ({
+      ...paragraph.align ? { align: paragraph.align } : {},
+      ...paragraph.lineSpacing ? { lineSpacing: paragraph.lineSpacing } : {},
+      ...paragraph.spaceBefore ? { spaceBefore: paragraph.spaceBefore } : {},
+      ...paragraph.spaceAfter ? { spaceAfter: paragraph.spaceAfter } : {},
+      runs: paragraph.runs.map((run) => {
+        const direct = {
+          sourceXml: "",
+          ...entry.textBodyStyle,
+          ...properties(paragraph.defaultProperties ?? {}),
+          ...properties(run)
+        };
+        const appearance = chartAppearance(
+          {
+            ...chart,
+            formatting: { ...formatting, entries: { ...formatting.entries, title: direct } }
+          },
+          theme
+        )?.title ?? {};
+        return { text: run.text, appearance };
+      })
+    }))
+  };
+}
+
+// chart/render/chart-view.ts
+var isRefError = (value) => typeof value === "object" && value !== null && "error" in value;
+var SUPPORTED = /* @__PURE__ */ new Set([
+  "bar",
+  "column",
+  "line",
+  "area",
+  "pie",
+  "doughnut",
+  "scatter",
+  "radar"
+]);
+function toText(value) {
+  if (value === null) return "";
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  if (isRefError(value)) return value.error;
+  return String(value);
+}
+var toNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+function resolveRef(ref, evaluateRef) {
+  if (!ref) return void 0;
+  try {
+    const values = evaluateRef(ref);
+    return values.length ? values : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function seriesName(series, index, evaluateRef) {
+  const fromRef = resolveRef(series.nameRef, evaluateRef)?.map(toText).filter((t) => t !== "").join(" ");
+  return fromRef || series.name || `Series${index + 1}`;
+}
+function chartSummaryView(chart, theme, options = {}) {
+  const evaluateRef = options.evaluateRef ?? (() => []);
+  const type = chart.chartType;
+  const radial = type === "pie" || type === "doughnut";
+  const palette = chart.colorPalette === void 0 ? void 0 : findChartColorPalette(chart.colorPalette);
+  const scheme = chartColorScheme(theme);
+  const drawingColor = (color) => color && drawingColorCss(
+    resolveDrawingColor(
+      color,
+      {
+        scheme: (name) => scheme[name]
+      },
+      { transformOrder: "document" }
+    )
+  );
+  const gradient = (fill) => fill?.kind === "gradient" ? resolveChartGradient(
+    fill,
+    (color) => resolveDrawingColor(
+      color,
+      {
+        scheme: (name) => scheme[name]
+      },
+      { transformOrder: "document" }
+    )
+  ) : void 0;
+  const grouping = chart.grouping ?? (type === "bar" || type === "column" ? "clustered" : "standard");
+  let categories = [];
+  const rawCategories = [];
+  const series = chart.series.map((s, i) => {
+    const values = resolveRef(s.valuesRef, evaluateRef)?.map(toNumber) ?? s.values.map(toNumber);
+    const cats = resolveRef(s.categoriesRef, evaluateRef) ?? s.categories;
+    rawCategories.push(cats);
+    const paletteColor = palette && chartPaletteSeriesColor(palette, i, chart.series.length, scheme);
+    const color = s.fill?.kind === "none" ? "none" : drawingColor(s.fill?.kind === "solid" ? s.fill.color : s.drawingColor) ?? options.seriesColor?.(s, i) ?? paletteColor ?? autoSeriesColor(theme, i);
+    const view = { name: seriesName(s, i, evaluateRef), values, color };
+    const shadow = resolveDrawingShadowXml(s.effectsXml, {
+      scheme: (name) => scheme[name]
+    });
+    if (shadow) view.shadow = shadow;
+    const resolvedGradient = gradient(s.fill);
+    if (resolvedGradient) view.gradient = resolvedGradient;
+    const points = Object.fromEntries(
+      Object.entries(s.pointFills ?? {}).flatMap(([key, fill]) => {
+        const value = gradient(fill);
+        return value ? [[key, value]] : [];
+      })
+    );
+    if (Object.keys(points).length) view.pointGradients = points;
+    return view;
+  });
+  const longest = Math.max(0, ...series.map((s) => s.values.length));
+  const firstCats = rawCategories.find((c) => c.length > 0) ?? [];
+  categories = Array.from(
+    { length: Math.max(longest, firstCats.length) },
+    (_, i) => firstCats[i] !== void 0 ? toText(firstCats[i] ?? null) : String(i + 1)
+  );
+  if (radial) {
+    series.forEach((s, seriesIndex) => {
+      s.pointColors = s.values.map((_, i) => {
+        const explicit = drawingColor(chart.series[seriesIndex]?.pointColors?.[i]);
+        return explicit ?? (palette ? chartPaletteSeriesColor(palette, i, s.values.length, scheme) : autoSeriesColor(theme, i));
+      });
+    });
+  } else
+    series.forEach((s, seriesIndex) => {
+      const points = chart.series[seriesIndex]?.pointColors;
+      if (points) s.pointColors = s.values.map((_, i) => drawingColor(points[i]) ?? s.color);
+    });
+  series.forEach((s, index) => {
+    const source = chart.series[index];
+    if (s.gradient && !radial && s.pointColors) {
+      for (let i = 0; i < s.pointColors.length; i++)
+        if (!source.pointColors?.[i]) delete s.pointColors[i];
+    }
+    for (const [key, fill] of Object.entries(source.pointFills ?? {})) {
+      if (fill.kind === "none") (s.pointColors ??= [])[Number(key)] = "none";
+      else if (fill.kind === "solid") {
+        const paint = drawingColor(fill.color);
+        if (paint) (s.pointColors ??= [])[Number(key)] = paint;
+      }
+    }
+  });
+  const model = {
+    ...chart.barGapWidth === void 0 ? {} : { barGapWidth: chart.barGapWidth },
+    ...chart.barOverlap === void 0 ? {} : { barOverlap: chart.barOverlap },
+    type,
+    grouping,
+    showLegend: chart.showLegend,
+    legendPosition: chart.legendPosition ?? "r",
+    categories,
+    series,
+    horizontal: type === "bar",
+    supported: SUPPORTED.has(type)
+  };
+  if (chart.title) model.title = chart.title;
+  const titleFormatting = chart.formatting?.entries.title;
+  if (titleFormatting?.layout) model.titleLayout = titleFormatting.layout;
+  if (titleFormatting?.overlay !== void 0) model.titleOverlay = titleFormatting.overlay;
+  const legendFormatting = chart.formatting?.entries.legend;
+  if (legendFormatting?.layout) model.legendLayout = legendFormatting.layout;
+  if (legendFormatting?.overlay !== void 0) model.legendOverlay = legendFormatting.overlay;
+  const titleText = chartTitleText(chart, theme);
+  if (titleText) model.titleText = titleText;
+  const appearance = chartAppearance(chart, theme);
+  if (appearance) model.appearance = appearance;
+  if (type === "scatter") {
+    series.forEach((s, i) => {
+      const cats = rawCategories[i] ?? [];
+      const numeric = cats.length > 0 && cats.every((c) => typeof c === "number");
+      s.xValues = s.values.map((_, k) => numeric ? toNumber(cats[k] ?? null) : k + 1);
+    });
+    const xs = series.flatMap((s) => s.xValues ?? []).filter((x) => x !== null);
+    model.xAxis = xs.length ? niceScale(Math.min(...xs), Math.max(...xs)) : niceScale(0, 1);
+  }
+  if (!radial) model.valueAxis = valueAxis(model);
+  return model;
+}
+
+// text/css-font-family.ts
+var FALLBACKS = {
+  calibri: '"Calibri", "Carlito", "Segoe UI", Arial, sans-serif',
+  "calibri light": '"Calibri Light", "Calibri", "Carlito", "Segoe UI", Arial, sans-serif',
+  cambria: '"Cambria", "Caladea", Georgia, serif',
+  arial: 'Arial, "Liberation Sans", Helvetica, sans-serif',
+  "times new roman": '"Times New Roman", "Liberation Serif", Times, serif',
+  "courier new": '"Courier New", "Liberation Mono", monospace',
+  aptos: '"Aptos", "Calibri", "Carlito", "Segoe UI", sans-serif'
+};
+function cssFontFamily(name) {
+  const known = FALLBACKS[name.toLowerCase()];
+  if (known) return known;
+  const quoted = `"${name.replace(/["\\]/g, "")}"`;
+  return `${quoted}, "Calibri", "Carlito", "Segoe UI", sans-serif`;
+}
+
+// chart/render/chart-svg-appearance.ts
+var nextPaintId = 0;
+function chartGradientPaint(model, width = 1024, height = 768) {
+  const prefix = `xlsx-chart-${++nextPaintId}`;
+  const appearance = { ...model.appearance };
+  const defs = [];
+  const shadowPaint = (shadow, suffix) => {
+    const id = `${prefix}-${suffix}`;
+    const pad = Math.max(4, shadow.blur * 3 + Math.abs(shadow.dx) + Math.abs(shadow.dy));
+    defs.push(
+      `<filter id="${id}" filterUnits="userSpaceOnUse" x="${n(-pad)}" y="${n(-pad)}" width="${n(width + pad * 2)}" height="${n(height + pad * 2)}" color-interpolation-filters="sRGB">${svgDropShadowElement(shadow, { number: n, color: (value) => esc(value) })}</filter>`
+    );
+    return `url(#${id})`;
+  };
+  for (const [part, entry] of Object.entries(appearance)) {
+    if (entry?.textShadow)
+      appearance[part] = {
+        ...entry,
+        textShadowFilter: shadowPaint(entry.textShadow, `${part}-text-shadow`)
+      };
+  }
+  const paint = (gradient, suffix, bounds) => {
+    const def = buildChartGradientDef(`${prefix}-${suffix}`, gradient, bounds);
+    defs.push(chartGradientMarkup(def));
+    return `url(#${def.id})`;
+  };
+  for (const part of ["chartArea", "plotArea"]) {
+    const entry = appearance[part];
+    if (!entry?.gradient) continue;
+    if (part === "plotArea" && ["circle", "shape"].includes(entry.gradient.path ?? "")) continue;
+    appearance[part] = {
+      ...entry,
+      fillColor: paint(entry.gradient, part, { width, height, shape: "rect" })
+    };
+  }
+  const series = model.series.map((source, index) => {
+    const view = { ...source };
+    if (source.shadow) view.shadowFilter = shadowPaint(source.shadow, `s${index}-shadow`);
+    const bounds = model.type === "bar" || model.type === "column" ? { width: 1, height: 1, shape: "rect" } : void 0;
+    if (source.gradient) view.color = paint(source.gradient, `s${index}`, bounds);
+    if (source.pointGradients) {
+      view.pointColors = [...source.pointColors ?? []];
+      for (const [key, gradient] of Object.entries(source.pointGradients))
+        view.pointColors[Number(key)] = paint(gradient, `s${index}-p${key}`, bounds);
+    }
+    return view;
+  });
+  return defs.length ? { model: { ...model, appearance, series }, defs: `<defs>${defs.join("")}</defs>` } : { model, defs: "" };
+}
+function chartTextAttributes(model, part, fallbackSize = FONT_SIZE) {
+  const entry = model.appearance?.[part];
+  return {
+    size: entry?.fontSize === void 0 ? fallbackSize : chartPointsToPixels(entry.fontSize),
+    ...entry?.color === void 0 ? {} : { fill: entry.color },
+    ...entry?.bold === void 0 ? {} : { weight: entry.bold ? "bold" : "normal" },
+    ...entry?.italic === void 0 ? {} : { italic: entry.italic },
+    ...entry?.underline === void 0 ? {} : { underline: entry.underline },
+    ...entry?.typeface === void 0 ? {} : { family: cssFontFamily(entry.typeface) },
+    ...entry?.textShadowFilter === void 0 ? {} : { filter: entry.textShadowFilter }
+  };
+}
+function chartStroke(model, part) {
+  const entry = model.appearance?.[part];
+  return {
+    color: entry?.axisVisible === false ? "none" : entry?.lineColor ?? (part === "gridlineMajor" ? GRID_COLOR : AXIS_COLOR),
+    width: entry?.lineWidth === void 0 ? 1 : chartPointsToPixels(entry.lineWidth)
+  };
+}
+function chartAreaRect(model, part, area) {
+  if (area.w <= 0 || area.h <= 0) return "";
+  const entry = model.appearance?.[part];
+  let fill = entry?.fillColor ?? (part === "chartArea" ? "#FFFFFF" : "none");
+  let defs = "";
+  if (part !== "chartArea" && entry?.gradient && (part !== "plotArea" || ["circle", "shape"].includes(entry.gradient.path ?? ""))) {
+    const def = buildChartGradientDef(`xlsx-chart-${++nextPaintId}-${part}`, entry.gradient, {
+      width: area.w,
+      height: area.h,
+      shape: "rect"
+    });
+    defs = `<defs>${chartGradientMarkup(def)}</defs>`;
+    fill = `url(#${def.id})`;
+  }
+  const stroke = entry?.lineColor ?? "none";
+  if (fill === "none" && stroke === "none") return "";
+  const width = entry?.lineWidth === void 0 ? 1 : chartPointsToPixels(entry.lineWidth);
+  return `${defs}<rect x="${n(area.x)}" y="${n(area.y)}" width="${n(area.w)}" height="${n(area.h)}" fill="${esc(fill)}" stroke="${esc(stroke)}" stroke-width="${n(width)}" data-chart-part="${part}"/>`;
+}
+
+// chart/render/chart-spacing.ts
+function chartBarSpacing(chart) {
+  const stacked = chart.grouping === "stacked" || chart.grouping === "percentStacked";
+  return {
+    barGapWidth: chart.barGapWidth ?? DEFAULT_BAR_GAP_WIDTH,
+    barOverlap: chart.barOverlap ?? (stacked ? 100 : 0)
+  };
+}
+
+// chart/render/chart-svg-bars.ts
+function bars(model, frame, out, values) {
+  const stacked = model.grouping === "stacked" || model.grouping === "percentStacked";
+  const count = Math.max(1, model.series.length);
+  const geometry = clusteredBarGeometry(frame.bandSize, count, chartBarSpacing(model));
+  const barSize = geometry.singleBarWidth;
+  const base = frame.value(0);
+  const pos = new Array(model.categories.length).fill(0);
+  const neg = new Array(model.categories.length).fill(0);
+  model.series.forEach((s, si) => {
+    values[si]?.forEach((v, i) => {
+      if (v === null || i >= model.categories.length) return;
+      let from = 0;
+      let to = v;
+      if (stacked) {
+        const acc = v >= 0 ? pos : neg;
+        from = acc[i] ?? 0;
+        to = from + v;
+        acc[i] = to;
+      }
+      const a = stacked ? frame.value(from) : base;
+      const b = frame.value(to);
+      const offset = model.horizontal ? geometry.clusterWidth / 2 - barSize - si * geometry.step : -geometry.clusterWidth / 2 + si * geometry.step;
+      const center = frame.band(i);
+      const width = model.horizontal ? Math.abs(b - a) : barSize;
+      const height = model.horizontal ? barSize : Math.abs(b - a);
+      let color = s.pointColors?.[i] ?? s.color;
+      const gradient = s.pointGradients?.[i] ?? (s.pointColors?.[i] === void 0 ? s.gradient : void 0);
+      if (gradient && (gradient.path === "circle" || gradient.path === "shape")) {
+        const baseId = color.match(/^url\(#(.+)\)$/)?.[1];
+        if (baseId) {
+          const id = baseId.replace(/(-s\d+(?:-p\d+)?)$/, `-mark${i}$1`);
+          const def = buildChartGradientDef(id, gradient, {
+            width: Number(n(width)),
+            height: Number(n(height)),
+            shape: "rect"
+          });
+          out.push(`<defs>${chartGradientMarkup(def)}</defs>`);
+          color = `url(#${id})`;
+        }
+      }
+      out.push(`<g data-chart-series="${si}" data-chart-point="${i}">`);
+      if (model.horizontal)
+        out.push(
+          rect(Math.min(a, b), center + offset, Math.abs(b - a), barSize, color, s.shadowFilter)
+        );
+      else
+        out.push(
+          rect(center + offset, Math.min(a, b), barSize, Math.abs(b - a), color, s.shadowFilter)
+        );
+      out.push("</g>");
+    });
+  });
+}
+
+// chart/render/chart-svg-cartesian.ts
+function axes(model, area, out) {
+  const scale = model.valueAxis;
+  if (!scale) return void 0;
+  const labels = scale.ticks.map((t) => formatAxisValue(t, scale.percent));
+  const valueAttrs = chartTextAttributes(model, "valueAxis");
+  const categoryAttrs = chartTextAttributes(model, "categoryAxis");
+  const valueSize = valueAttrs.size ?? 10;
+  const categorySize = categoryAttrs.size ?? 10;
+  const grid = chartStroke(model, "gridlineMajor");
+  const axis = chartStroke(model, "categoryAxis");
+  const valueLabels = model.appearance?.valueAxis?.labelsVisible !== false;
+  const categoryLabels = model.appearance?.categoryAxis?.labelsVisible !== false;
+  const labelW = valueLabels ? Math.max(...labels.map((l) => textWidth(l, valueSize)), 8) + 6 : 4;
+  const horizontal = model.horizontal;
+  const cats = Math.max(1, model.categories.length);
+  const catW = Math.min(
+    area.w * 0.3,
+    Math.max(...model.categories.map((c) => textWidth(c, categorySize)), 8) + 6
+  );
+  const plot = horizontal ? {
+    x: area.x + catW,
+    y: area.y,
+    w: Math.max(1, area.w - catW - 4),
+    h: Math.max(1, area.h - Math.max(16, valueSize * 1.5))
+  } : {
+    x: area.x + labelW,
+    y: area.y + 4,
+    w: Math.max(1, area.w - labelW - 4),
+    h: Math.max(1, area.h - Math.max(20, categorySize * 1.5))
+  };
+  const span = scale.max - scale.min || 1;
+  const value = horizontal ? (v) => plot.x + (v - scale.min) / span * plot.w : (v) => plot.y + plot.h - (v - scale.min) / span * plot.h;
+  const bandSize = (horizontal ? plot.h : plot.w) / cats;
+  const band = horizontal ? (i) => plot.y + plot.h - bandSize * (i + 0.5) : (i) => plot.x + bandSize * (i + 0.5);
+  out.push(chartAreaRect(model, "plotArea", plot));
+  scale.ticks.forEach((t, i) => {
+    const p = value(t);
+    const label = labels[i] ?? "";
+    if (horizontal) {
+      out.push(line(p, plot.y, p, plot.y + plot.h, grid.color, grid.width));
+      if (valueLabels)
+        out.push(
+          text(p, plot.y + plot.h + valueSize + 2, label, { anchor: "middle", ...valueAttrs })
+        );
+    } else {
+      out.push(line(plot.x, p, plot.x + plot.w, p, grid.color, grid.width));
+      if (valueLabels)
+        out.push(text(plot.x - 4, p + valueSize * 0.3, label, { anchor: "end", ...valueAttrs }));
+    }
+  });
+  const zero = value(Math.min(Math.max(0, scale.min), scale.max));
+  if (horizontal) out.push(line(zero, plot.y, zero, plot.y + plot.h, axis.color, axis.width));
+  else out.push(line(plot.x, zero, plot.x + plot.w, zero, axis.color, axis.width));
+  const step = Math.max(
+    1,
+    Math.ceil(cats / Math.max(1, Math.floor((horizontal ? plot.h : plot.w) / 14)))
+  );
+  model.categories.forEach((c, i) => {
+    if (!categoryLabels || i % step !== 0) return;
+    const p = band(i);
+    if (horizontal)
+      out.push(
+        text(plot.x - 4, p + categorySize * 0.3, fit(c, catW - 6, categorySize), {
+          anchor: "end",
+          ...categoryAttrs
+        })
+      );
+    else
+      out.push(
+        text(p, plot.y + plot.h + categorySize + 3, fit(c, bandSize * step, categorySize), {
+          anchor: "middle",
+          ...categoryAttrs
+        })
+      );
+  });
+  return { plot, value, band, bandSize };
+}
+function plotted(model) {
+  if (model.grouping !== "percentStacked") return model.series.map((s) => s.values);
+  const totals = categoryTotals(model);
+  return model.series.map(
+    (s) => s.values.map((v, i) => v === null ? null : v / (totals[i] || 1))
+  );
+}
+function linesAndAreas(model, frame, out) {
+  const values = plotted(model);
+  const stacked = model.grouping === "stacked" || model.grouping === "percentStacked";
+  const acc = new Array(model.categories.length).fill(0);
+  const area = model.type === "area";
+  const layers = [];
+  model.series.forEach((s, si) => {
+    const points = [];
+    const lower = [];
+    model.categories.forEach((_, i) => {
+      const v = values[si]?.[i] ?? null;
+      if (v === null && !area) {
+        points.push([NaN, NaN]);
+        return;
+      }
+      const below = stacked ? acc[i] ?? 0 : 0;
+      const top = below + (v ?? 0);
+      if (stacked) acc[i] = top;
+      points.push([frame.band(i), frame.value(top)]);
+      lower.push([frame.band(i), frame.value(below)]);
+    });
+    layers.push({
+      points,
+      lower,
+      color: s.color,
+      filter: s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""
+    });
+  });
+  for (const { points, lower, color, filter } of area ? [...layers].reverse() : layers) {
+    if (area) {
+      const poly = [...points, ...[...lower].reverse()].map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
+      out.push(`<polygon points="${poly}" fill="${color}" fill-opacity="0.85"${filter}/>`);
+      continue;
+    }
+    let segment = [];
+    const flush = () => {
+      if (segment.length > 1)
+        out.push(
+          `<polyline points="${segment.join(" ")}" fill="none" stroke="${color}" stroke-width="2.25" stroke-linejoin="round"${filter}/>`
+        );
+      segment = [];
+    };
+    for (const [x, y] of points) {
+      if (Number.isNaN(x)) flush();
+      else segment.push(`${n(x)},${n(y)}`);
+    }
+    flush();
+    for (const [x, y] of points)
+      if (!Number.isNaN(x))
+        out.push(`<circle cx="${n(x)}" cy="${n(y)}" r="2.5" fill="${color}"${filter}/>`);
+  }
+}
+function scatter(model, area, out) {
+  const ys = model.valueAxis;
+  const xs = model.xAxis;
+  if (!ys || !xs) return;
+  const yLabels = ys.ticks.map((t) => formatAxisValue(t));
+  const valueAttrs = chartTextAttributes(model, "valueAxis");
+  const categoryAttrs = chartTextAttributes(model, "categoryAxis");
+  const valueSize = valueAttrs.size ?? 10;
+  const categorySize = categoryAttrs.size ?? 10;
+  const grid = chartStroke(model, "gridlineMajor");
+  const xAxis = chartStroke(model, "categoryAxis");
+  const yAxis = chartStroke(model, "valueAxis");
+  const valueLabels = model.appearance?.valueAxis?.labelsVisible !== false;
+  const categoryLabels = model.appearance?.categoryAxis?.labelsVisible !== false;
+  const labelW = valueLabels ? Math.max(...yLabels.map((l) => textWidth(l, valueSize)), 8) + 6 : 4;
+  const plot = {
+    x: area.x + labelW,
+    y: area.y + 4,
+    w: Math.max(1, area.w - labelW - 8),
+    h: Math.max(1, area.h - Math.max(20, categorySize * 1.5))
+  };
+  const px = (v, s) => plot.x + (v - s.min) / (s.max - s.min || 1) * plot.w;
+  const py = (v, s) => plot.y + plot.h - (v - s.min) / (s.max - s.min || 1) * plot.h;
+  out.push(chartAreaRect(model, "plotArea", plot));
+  ys.ticks.forEach((t, i) => {
+    out.push(line(plot.x, py(t, ys), plot.x + plot.w, py(t, ys), grid.color, grid.width));
+    if (valueLabels)
+      out.push(
+        text(plot.x - 4, py(t, ys) + valueSize * 0.3, yLabels[i] ?? "", {
+          anchor: "end",
+          ...valueAttrs
+        })
+      );
+  });
+  for (const t of xs.ticks) {
+    out.push(
+      line(px(t, xs), plot.y + plot.h, px(t, xs), plot.y + plot.h + 3, xAxis.color, xAxis.width)
+    );
+    if (categoryLabels)
+      out.push(
+        text(px(t, xs), plot.y + plot.h + categorySize + 3, formatAxisValue(t), {
+          anchor: "middle",
+          ...categoryAttrs
+        })
+      );
+  }
+  out.push(
+    line(plot.x, plot.y + plot.h, plot.x + plot.w, plot.y + plot.h, xAxis.color, xAxis.width)
+  );
+  out.push(line(plot.x, plot.y, plot.x, plot.y + plot.h, yAxis.color, yAxis.width));
+  for (const s of model.series)
+    s.values.forEach((v, i) => {
+      const x = s.xValues?.[i] ?? null;
+      if (v === null || x === null) return;
+      out.push(
+        `<circle cx="${n(px(x, xs))}" cy="${n(py(v, ys))}" r="3" fill="${s.pointColors?.[i] ?? s.color}"${s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""}/>`
+      );
+    });
+}
+function cartesianSvg(model, area) {
+  const out = [];
+  if (model.type === "scatter") {
+    scatter(model, area, out);
+    return out.join("");
+  }
+  const frame = axes(model, area, out);
+  if (!frame) return "";
+  if (model.type === "bar" || model.type === "column") bars(model, frame, out, plotted(model));
+  else linesAndAreas(model, frame, out);
+  return out.join("");
+}
+
+// chart/render/chart-svg-radial.ts
+var polar = (cx, cy, r, angle) => [
+  cx + r * Math.sin(angle),
+  cy - r * Math.cos(angle)
+];
+function slicePath(cx, cy, r, inner, a0, a1) {
+  const sweep = a1 - a0;
+  if (sweep >= Math.PI * 2 - 1e-9) {
+    const mid = a0 + Math.PI;
+    return slicePath(cx, cy, r, inner, a0, mid) + slicePath(cx, cy, r, inner, mid, a1);
+  }
+  const large = sweep > Math.PI ? 1 : 0;
+  const [x0, y0] = polar(cx, cy, r, a0);
+  const [x1, y1] = polar(cx, cy, r, a1);
+  if (inner <= 0)
+    return `M${n(cx)},${n(cy)} L${n(x0)},${n(y0)} A${n(r)},${n(r)} 0 ${large} 1 ${n(x1)},${n(y1)} Z`;
+  const [ix1, iy1] = polar(cx, cy, inner, a1);
+  const [ix0, iy0] = polar(cx, cy, inner, a0);
+  return `M${n(x0)},${n(y0)} A${n(r)},${n(r)} 0 ${large} 1 ${n(x1)},${n(y1)} L${n(ix1)},${n(iy1)} A${n(inner)},${n(inner)} 0 ${large} 0 ${n(ix0)},${n(iy0)} Z`;
+}
+function pieSvg(model, area) {
+  const out = [chartAreaRect(model, "plotArea", area)];
+  const cx = area.x + area.w / 2;
+  const cy = area.y + area.h / 2;
+  const radius = Math.max(1, Math.min(area.w, area.h) / 2 - 4);
+  const rings = model.type === "doughnut" ? model.series : model.series.slice(0, 1);
+  const hole = model.type === "doughnut" ? radius * 0.5 : 0;
+  const ringSize = (radius - hole) / Math.max(1, rings.length);
+  rings.forEach((s, ri) => {
+    const outer = radius - ri * ringSize;
+    const inner = model.type === "doughnut" ? outer - ringSize : 0;
+    const total = s.values.reduce((sum, v) => sum + (v !== null && v > 0 ? v : 0), 0);
+    if (total <= 0) return;
+    let angle = 0;
+    s.values.forEach((v, i) => {
+      if (v === null || v <= 0) return;
+      const sweep = v / total * Math.PI * 2;
+      const color = s.pointColors?.[i] ?? s.color;
+      out.push(
+        `<path d="${slicePath(cx, cy, outer, inner, angle, angle + sweep)}" fill="${color}" stroke="#FFFFFF" stroke-width="1"${s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""}/>`
+      );
+      angle += sweep;
+    });
+  });
+  return out.join("");
+}
+function radarSvg(model, area) {
+  const out = [chartAreaRect(model, "plotArea", area)];
+  const scale = model.valueAxis;
+  const count = model.categories.length;
+  if (!scale || count < 1) return "";
+  const valueAttrs = chartTextAttributes(model, "valueAxis", 9);
+  const categoryAttrs = chartTextAttributes(model, "categoryAxis");
+  const valueSize = valueAttrs.size ?? 9;
+  const categorySize = categoryAttrs.size ?? 10;
+  const grid = chartStroke(model, "gridlineMajor");
+  const axis = chartStroke(model, "categoryAxis");
+  const cx = area.x + area.w / 2;
+  const cy = area.y + area.h / 2 + 4;
+  const radius = Math.max(1, Math.min(area.w, area.h) / 2 - Math.max(18, categorySize * 1.8));
+  const angle = (i) => i / count * Math.PI * 2;
+  const r = (v) => (v - scale.min) / (scale.max - scale.min || 1) * radius;
+  const labelEvery = Math.max(
+    1,
+    Math.ceil(12 / Math.max(1, radius / Math.max(1, scale.ticks.length - 1)))
+  );
+  for (const [k, t] of scale.ticks.entries()) {
+    const ring = Array.from({ length: count }, (_, i) => polar(cx, cy, r(t), angle(i))).map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
+    out.push(
+      `<polygon points="${ring}" fill="none" stroke="${grid.color}" stroke-width="${n(grid.width)}"/>`
+    );
+    if (model.appearance?.valueAxis?.labelsVisible !== false && k % labelEvery === 0)
+      out.push(
+        text(cx + 3, cy - r(t) + valueSize * 0.3, formatAxisValue(t, scale.percent), valueAttrs)
+      );
+  }
+  model.categories.forEach((c, i) => {
+    const [x, y] = polar(cx, cy, radius, angle(i));
+    out.push(line(cx, cy, x, y, axis.color, axis.width));
+    const [lx, ly] = polar(cx, cy, radius + 10, angle(i));
+    const anchor = Math.abs(lx - cx) < 2 ? "middle" : lx > cx ? "start" : "end";
+    if (model.appearance?.categoryAxis?.labelsVisible !== false)
+      out.push(
+        text(lx, ly + categorySize * 0.3, fit(c, area.w / 4, categorySize), {
+          anchor,
+          ...categoryAttrs
+        })
+      );
+  });
+  for (const s of model.series) {
+    const points = s.values.slice(0, count).map((v, i) => polar(cx, cy, r(v ?? scale.min), angle(i))).map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
+    out.push(
+      `<polygon points="${points}" fill="none" stroke="${s.color}" stroke-width="2"${s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""}/>`
+    );
+  }
+  return out.join("");
+}
+
+// chart/render/chart-svg-text-metrics.ts
+var CHART_FONT_FAMILY = "Calibri, Carlito, Arial, sans-serif";
+function cssFont(attrs) {
+  return `${attrs.italic ? "italic" : "normal"} ${attrs.weight ?? "normal"} ${attrs.size ?? 10}px ${attrs.family ?? CHART_FONT_FAMILY}`;
+}
+function chartFontMetrics(attrs, options) {
+  const metrics = options.measureFont?.(cssFont(attrs));
+  return metrics && Number.isFinite(metrics.ascent) && Number.isFinite(metrics.descent) && metrics.ascent >= 0 && metrics.descent >= 0 && metrics.ascent + metrics.descent > 0 ? metrics : void 0;
+}
+function chartTextWidth(content, attrs, options) {
+  const width = options.measureText?.(content, cssFont(attrs));
+  return width !== void 0 && Number.isFinite(width) && width >= 0 ? width : textWidth(content, attrs.size);
+}
+function fitChartText(content, maxWidth, attrs, options) {
+  if (!options.measureText) return fit(content, maxWidth, attrs.size);
+  if (chartTextWidth(content, attrs, options) <= maxWidth) return content;
+  const points = [...content];
+  let low = 0;
+  let high = points.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (chartTextWidth(`${points.slice(0, mid).join("")}\u2026`, attrs, options) <= maxWidth) low = mid;
+    else high = mid - 1;
+  }
+  return `${points.slice(0, low).join("")}\u2026`;
+}
+
+// chart/render/chart-svg-legend.ts
+function chartLegendSvg(model, area, frame, options) {
+  const automatic = [];
+  const bounds = {};
+  const reserved = automaticLegend(model, area, automatic, options, bounds);
+  const plot = model.legendOverlay ? area : reserved;
+  const box = bounds.box;
+  if (!box) return { plot, markup: "", foreground: false };
+  const manual = resolveManualLayoutRect(model.legendLayout, frame, {
+    x: box.x,
+    y: box.y,
+    width: box.w,
+    height: box.h
+  });
+  if (!manual) return { plot, markup: automatic.join(""), foreground: !!model.legendOverlay };
+  const entries = legendEntries(model);
+  const attrs = chartTextAttributes(model, "legend");
+  const size = attrs.size ?? 10;
+  const font = chartFontMetrics(attrs, options);
+  const keySize = size / 2;
+  const keyGap = size / 4;
+  const widths = entries.map(
+    (entry) => chartTextWidth(entry.label, attrs, options) + keySize + keyGap
+  );
+  const horizontal = manual.width > manual.height && widths.reduce((sum, width) => sum + width, 0) + size <= manual.width;
+  const rowWidth = horizontal ? manual.width / entries.length : manual.width;
+  const rowHeight = horizontal ? manual.height : manual.height / entries.length;
+  const horizontalGap = Math.max(
+    0,
+    (manual.width - widths.reduce((sum, width) => sum + width, 0)) / (entries.length + 1)
+  );
+  let horizontalX = manual.x + horizontalGap;
+  const markup = [
+    chartAreaRect(model, "legend", { x: manual.x, y: manual.y, w: manual.width, h: manual.height })
+  ];
+  const baselineOffset = font ? (font.ascent - font.descent) / 2 : size * 0.35;
+  entries.forEach((entry, i) => {
+    const available = horizontal ? chartTextWidth(entry.label, attrs, options) : Math.max(0, rowWidth - size / 2 - keySize - keyGap);
+    const label = fitChartText(entry.label, available, attrs, options);
+    const contentWidth = Math.min(
+      horizontal ? widths[i] ?? 0 : Math.max(...widths),
+      rowWidth - size / 2
+    );
+    const x = horizontal ? horizontalX : manual.x + Math.max(size / 4, (rowWidth - contentWidth) / 2);
+    const centerY = manual.y + (horizontal ? 0 : i * rowHeight) + rowHeight / 2;
+    markup.push(rect(x, centerY - keySize / 2, keySize, keySize, entry.color));
+    markup.push(text(x + keySize + keyGap, centerY + baselineOffset, label, attrs));
+    if (horizontal) horizontalX += (widths[i] ?? 0) + horizontalGap;
+  });
+  return {
+    plot,
+    markup: `<g data-chart-legend-layout="true">${markup.join("")}</g>`,
+    foreground: true
+  };
+}
+function legendEntries(model) {
+  if (model.type === "pie" || model.type === "doughnut") {
+    const first3 = model.series[0];
+    return model.categories.map((label, i) => ({
+      label,
+      color: first3?.pointColors?.[i] ?? first3?.color ?? "#4472C4"
+    }));
+  }
+  return model.series.map((s) => ({ label: s.name, color: s.color }));
+}
+function automaticLegend(model, area, out, options, bounds) {
+  const entries = legendEntries(model);
+  if (!model.showLegend || entries.length === 0) return area;
+  const pos = model.legendPosition;
+  const attrs = chartTextAttributes(model, "legend");
+  const size = attrs.size ?? 10;
+  const rowH = Math.max(16, size * 1.4);
+  if (pos === "t" || pos === "b") {
+    const widths = entries.map(
+      (e) => Math.min(chartTextWidth(e.label, attrs, options) + 20, area.w / 2)
+    );
+    const total = widths.reduce((a, b) => a + b, 0);
+    let x2 = area.x + Math.max(0, (area.w - total) / 2);
+    const y = pos === "t" ? area.y + 4 : area.y + area.h - rowH + 4;
+    bounds.box = { x: x2 - 4, y: y - 4, w: Math.min(total, area.w) + 8, h: rowH + 4 };
+    out.push(
+      chartAreaRect(model, "legend", {
+        x: x2 - 4,
+        y: y - 4,
+        w: Math.min(total, area.w) + 8,
+        h: rowH + 4
+      })
+    );
+    entries.forEach((e, i) => {
+      const w = widths[i] ?? 0;
+      out.push(rect(x2, y, 8, 8, e.color));
+      out.push(text(x2 + 12, y + 8, fitChartText(e.label, w - 16, attrs, options), attrs));
+      x2 += w;
+    });
+    return pos === "t" ? { x: area.x, y: area.y + rowH + 4, w: area.w, h: area.h - rowH - 4 } : { x: area.x, y: area.y, w: area.w, h: area.h - rowH - 4 };
+  }
+  const width = Math.min(
+    area.w * 0.35,
+    Math.max(...entries.map((e) => chartTextWidth(e.label, attrs, options))) + 22
+  );
+  const height = entries.length * rowH;
+  const x = pos === "l" ? area.x + 4 : area.x + area.w - width;
+  const y0 = pos === "tr" ? area.y + 4 : area.y + Math.max(0, (area.h - height) / 2);
+  bounds.box = { x: x - 4, y: y0, w: width + 4, h: Math.min(height, area.y + area.h - y0) };
+  out.push(
+    chartAreaRect(model, "legend", {
+      x: x - 4,
+      y: y0,
+      w: width + 4,
+      h: Math.min(height, area.y + area.h - y0)
+    })
+  );
+  entries.forEach((e, i) => {
+    const y = y0 + i * rowH;
+    if (y + rowH > area.y + area.h + 2) return;
+    out.push(rect(x, y + 3, 8, 8, e.color));
+    out.push(text(x + 12, y + 11, fitChartText(e.label, width - 16, attrs, options), attrs));
+  });
+  return pos === "l" ? { x: area.x + width + 8, y: area.y, w: area.w - width - 8, h: area.h } : { x: area.x, y: area.y, w: area.w - width - 8, h: area.h };
+}
+
+// text/wrap-styled-runs.ts
+var graphemes = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function wrapStyledRuns(runs, maxWidth, measure, options = {}) {
+  const groups = [];
+  for (const [source, run] of runs.entries()) {
+    for (const token of run.text.split(/(\r\n|[\r\n]|[ \t]+)/u).filter(Boolean)) {
+      const kind = /^[\r\n]+$/u.test(token) ? "break" : /^[ \t]+$/u.test(token) ? "space" : "word";
+      let group = groups.at(-1);
+      if (!group || group.kind !== kind || kind === "break") {
+        group = { kind, pieces: [] };
+        groups.push(group);
+      }
+      if (kind !== "break") group.pieces.push({ run, source, text: token });
+    }
+  }
+  const merged = (left, right) => {
+    const result2 = left.map((piece) => ({ ...piece }));
+    for (const piece of right) {
+      const last = result2.at(-1);
+      if (last?.source === piece.source) last.text += piece.text;
+      else result2.push({ ...piece });
+    }
+    return result2;
+  };
+  const width = (pieces) => pieces.reduce((sum, piece) => {
+    const advance = measure(piece.text, piece.run);
+    return sum + (Number.isFinite(advance) && advance >= 0 ? advance : 0);
+  }, 0);
+  const result = [];
+  let line2 = [];
+  let spaces = [];
+  const flush = () => {
+    result.push(line2.map((piece) => ({ ...piece.run, text: piece.text })));
+    line2 = [];
+    spaces = [];
+  };
+  for (const group of groups) {
+    if (group.kind === "break") {
+      flush();
+      continue;
+    }
+    if (group.kind === "space") {
+      spaces = group.pieces;
+      continue;
+    }
+    const separator = line2.length ? spaces : [];
+    const wordWidth = width(group.pieces);
+    if (line2.length && width(merged(line2, [...separator, ...group.pieces])) > maxWidth) flush();
+    else line2 = merged(line2, separator);
+    spaces = [];
+    if (options.breakWords && wordWidth > maxWidth) {
+      for (const piece of group.pieces) {
+        for (const { segment } of graphemes.segment(piece.text)) {
+          const next = { ...piece, text: segment };
+          if (line2.length && width(merged(line2, [next])) > maxWidth) flush();
+          line2 = merged(line2, [next]);
+        }
+      }
+    } else line2 = merged(line2, group.pieces);
+  }
+  flush();
+  return result;
+}
+
+// chart/render/chart-svg-title-text.ts
+function spacing(value, naturalHeight, fallback) {
+  return value ? value.unit === "points" ? chartPointsToPixels(value.value) : naturalHeight * value.value : fallback;
+}
+function chartRichTitleSvg(model, width, options = {}, frameHeight = 400) {
+  if (!model.title) return void 0;
+  const base = chartTextAttributes(model, "title", 14);
+  const capacity = Math.max(1, width * 0.8 - 8);
+  if (!model.titleText && !hasManualLayoutFields(model.titleLayout) && !model.titleOverlay && !model.title.includes("\n") && chartTextWidth(model.title, base, options) <= capacity)
+    return void 0;
+  const paragraphs = model.titleText?.paragraphs ?? [
+    {
+      runs: [{ text: model.title, appearance: model.appearance?.title ?? {} }]
+    }
+  ];
+  const hardLines = [];
+  for (const paragraph of paragraphs) {
+    let line2 = {
+      ...paragraph,
+      runs: []
+    };
+    hardLines.push(line2);
+    for (const run of paragraph.runs) {
+      const pieces = run.text.split("\n");
+      for (const [index, piece] of pieces.entries()) {
+        if (index) {
+          line2 = { ...paragraph, runs: [] };
+          hardLines.push(line2);
+        }
+        if (piece) line2.runs.push({ ...run, text: piece });
+      }
+    }
+  }
+  const lines = hardLines.flatMap((line2) => {
+    const wrapped = wrapStyledRuns(
+      line2.runs,
+      capacity,
+      (content, run) => chartTextWidth(
+        content,
+        chartTextAttributes(
+          { ...model, appearance: { title: run.appearance } },
+          "title",
+          base.size
+        ),
+        options
+      ),
+      { breakWords: true }
+    );
+    const { spaceBefore, spaceAfter, ...properties4 } = line2;
+    return wrapped.map((runs, index) => ({
+      ...properties4,
+      runs,
+      ...index === 0 && spaceBefore ? { spaceBefore } : {},
+      ...index === wrapped.length - 1 && spaceAfter ? { spaceAfter } : {}
+    }));
+  });
+  const metrics = lines.map((line2) => {
+    const runs = line2.runs.map((run) => ({
+      ...run,
+      attrs: chartTextAttributes(
+        { ...model, appearance: { title: run.appearance } },
+        "title",
+        base.size
+      )
+    }));
+    return {
+      ...line2,
+      runs,
+      width: runs.reduce((sum, run) => sum + chartTextWidth(run.text, run.attrs, options), 0),
+      size: runs.length ? Math.max(...runs.map((run) => run.attrs.size ?? 14)) : base.size ?? 14,
+      fontMetrics: (runs.length ? runs.map((run) => run.attrs) : [base]).map(
+        (attrs) => chartFontMetrics(attrs, options)
+      )
+    };
+  });
+  const measured = metrics.every((line2) => line2.fontMetrics.every((font) => font !== void 0));
+  const vertical = metrics.map((line2) => {
+    const ascent = measured ? Math.max(...line2.fontMetrics.map((font) => font.ascent)) : line2.size;
+    const descent = measured ? Math.max(...line2.fontMetrics.map((font) => font.descent)) : line2.size * 0.4 + 4;
+    const natural = ascent + descent;
+    const height2 = spacing(line2.lineSpacing, natural, natural);
+    const leading = (height2 - natural) / 2;
+    return {
+      ascent: ascent + leading,
+      descent: descent + leading,
+      height: height2,
+      before: spacing(line2.spaceBefore, natural, 0),
+      after: spacing(line2.spaceAfter, natural, 0),
+      leading
+    };
+  });
+  const boxWidth = Math.min(width - 16, Math.max(0, ...metrics.map((line2) => line2.width)) + 8);
+  const height = vertical.reduce(
+    (sum, line2) => sum + line2.height + line2.before + line2.after,
+    measured ? 4 : 0
+  );
+  let baseline = 8 + (metrics[0]?.size ?? base.size ?? 14) + (vertical[0]?.before ?? 0) + (vertical[0]?.leading ?? 0);
+  const spans = [];
+  for (const [index, line2] of metrics.entries()) {
+    if (index)
+      baseline += vertical[index - 1].descent + vertical[index - 1].after + vertical[index].before + vertical[index].ascent;
+    let x = line2.align === "l" ? (width - boxWidth) / 2 + 4 : line2.align === "r" ? (width + boxWidth) / 2 - 4 - line2.width : (width - line2.width) / 2;
+    for (const run of line2.runs) {
+      spans.push(
+        text(x, baseline, run.text, {
+          ...run.attrs,
+          anchor: "start"
+        }).replace("<text ", '<tspan data-chart-title-run="true" ').replace("</text>", "</tspan>")
+      );
+      x += chartTextWidth(run.text, run.attrs, options);
+    }
+  }
+  const parent = text(0, 0, "", { ...base, underline: false }).replace(
+    "</text>",
+    `${spans.join("")}</text>`
+  );
+  const markup = chartAreaRect(model, "title", {
+    x: (width - boxWidth) / 2,
+    y: 4,
+    w: Math.max(0, boxWidth),
+    h: height
+  }) + parent;
+  const automatic = { x: (width - boxWidth) / 2, y: 4, width: boxWidth, height };
+  const manual = resolveManualLayoutRect(
+    model.titleLayout,
+    { width, height: frameHeight },
+    automatic
+  );
+  return {
+    markup: manual ? `<g data-chart-title-layout="true" transform="translate(${n(manual.x - automatic.x)} ${n(manual.y - automatic.y)})">${markup}</g>` : markup,
+    height: Math.max(24, height)
+  };
+}
+
+// chart/render/chart-svg.ts
+function renderChartSvg(model, width, height, options = {}) {
+  const paint = chartGradientPaint(model, Math.max(1, width), Math.max(1, height));
+  model = paint.model;
+  const w = Math.max(1, width);
+  const h = Math.max(1, height);
+  const out = [];
+  let foregroundTitle = "";
+  out.push(
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${n(w)}" height="${n(h)}" viewBox="0 0 ${n(w)} ${n(h)}" font-family="${esc(CHART_FONT_FAMILY)}" role="img">`
+  );
+  if (model.title) out.push(`<title>${esc(model.title)}</title>`);
+  if (paint.defs) out.push(paint.defs);
+  out.push(chartAreaRect(model, "chartArea", { x: 0, y: 0, w, h }));
+  let area = { x: 8, y: 8, w: w - 16, h: h - 16 };
+  const richTitle = chartRichTitleSvg(model, w, options, h);
+  if (richTitle) {
+    if (model.titleLayout || model.titleOverlay) foregroundTitle = richTitle.markup;
+    else out.push(richTitle.markup);
+    if (!model.titleOverlay)
+      area = { ...area, y: area.y + richTitle.height, h: area.h - richTitle.height };
+  } else if (model.title) {
+    const attrs = chartTextAttributes(model, "title", 14);
+    const size = attrs.size ?? 14;
+    const label = fitChartText(model.title, w - 16, attrs, options);
+    const titleWidth = Math.min(w - 16, chartTextWidth(label, attrs, options) + 8);
+    const font = chartFontMetrics(attrs, options);
+    const titleHeight = Math.max(24, font ? font.ascent + font.descent + 4 : size * 1.4 + 4);
+    out.push(
+      chartAreaRect(model, "title", {
+        x: (w - titleWidth) / 2,
+        y: 4,
+        w: Math.max(0, titleWidth),
+        h: font ? font.ascent + font.descent + 4 : size * 1.4 + 4
+      })
+    );
+    out.push(
+      text(w / 2, 8 + size, label, {
+        anchor: "middle",
+        fill: "#404040",
+        ...attrs
+      })
+    );
+    if (!model.titleOverlay)
+      area = { x: area.x, y: area.y + titleHeight, w: area.w, h: area.h - titleHeight };
+  }
+  if (!model.supported) {
+    out.push(
+      text(w / 2, area.y + area.h / 2, `${model.type} charts are not drawn`, { anchor: "middle" })
+    );
+    if (foregroundTitle) out.push(foregroundTitle);
+    out.push("</svg>");
+    return out.join("");
+  }
+  const legend = chartLegendSvg(model, area, { width: w, height: h }, options);
+  area = legend.plot;
+  if (!legend.foreground) out.push(legend.markup);
+  if (area.w > 4 && area.h > 4) {
+    if (model.type === "pie" || model.type === "doughnut") out.push(pieSvg(model, area));
+    else if (model.type === "radar") out.push(radarSvg(model, area));
+    else out.push(cartesianSvg(model, area));
+  }
+  if (legend.foreground) out.push(legend.markup);
+  if (foregroundTitle) out.push(foregroundTitle);
+  out.push("</svg>");
+  return out.join("");
+}
+
+// chart/render/render-space.ts
+var DRAWN_CHART_TYPES = /* @__PURE__ */ new Set([
+  "bar",
+  "column",
+  "line",
+  "area",
+  "pie",
+  "doughnut",
+  "scatter",
+  "radar"
+]);
+function chartThemePalette(theme, fonts = {}) {
+  return {
+    colors: THEME_SLOTS.map(
+      (slot, index) => themeSlotHex(theme?.colors[slot]) ?? DEFAULT_THEME_COLORS[index] ?? "000000"
+    ),
+    majorFont: fonts.major ?? "Calibri Light",
+    minorFont: fonts.minor ?? "Calibri"
+  };
+}
+function chartSpaceKind(space) {
+  if (!space.plotArea.groups.length) return { drawn: false };
+  const type = chartSummaryFromSpace(space).chartType;
+  return { type, drawn: DRAWN_CHART_TYPES.has(type) };
+}
+function renderChartSpaceSvg(space, options) {
+  const { width, height, theme, fonts, formatting, colorPalette, styleDefinition, ...svg } = options;
+  const summary = chartSummaryFromSpace(space, {
+    ...formatting ? { formatting } : {},
+    ...colorPalette !== void 0 ? { colorPalette } : {},
+    ...styleDefinition ? { styleDefinition } : {}
+  });
+  const view = chartSummaryView(summary, chartThemePalette(theme, fonts));
+  return renderChartSvg(view, width, height, svg);
+}
+
+// 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/write-drawing.ts
 var A_NS2 = "http://schemas.openxmlformats.org/drawingml/2006/main";
 var WP_NS2 = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
@@ -3150,11 +5502,11 @@ function createRun(doc, run, base, old, allocator) {
     if (piece === "\n") node.appendChild(makeW(doc, "br"));
     else if (piece === "	") node.appendChild(makeW(doc, "tab"));
     else if (piece) {
-      const text = makeW(doc, "t");
+      const text2 = makeW(doc, "t");
       if (/^\s|\s$/.test(piece))
-        text.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
-      text.appendChild(doc.createTextNode(piece));
-      node.appendChild(text);
+        text2.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
+      text2.appendChild(doc.createTextNode(piece));
+      node.appendChild(text2);
     }
   }
   if (!run.text) node.appendChild(makeW(doc, "t"));
@@ -3221,38 +5573,6 @@ function preserveEquation(run, base, old) {
       "Equation editing or insertion is unsupported; imported OMML must remain unchanged."
     );
 }
-
-// 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;
-}
 function isCommentReferenceRun(run) {
   const content = Array.from(run.childNodes).filter(
     (child) => isElement(child) && !named2(child, "rPr")
@@ -3464,18 +5784,18 @@ function parseDirectParagraphProperties(props) {
   if (shading) paragraph.shadingFill = shading;
   const tabStops = parseTabStops(first2(props, "tabs"));
   if (tabStops.length) paragraph.tabStops = tabStops;
-  const spacing = first2(props, "spacing");
-  const before = twipValue2(getW(spacing, "before"));
-  const after = twipValue2(getW(spacing, "after"));
-  const line = signedTwipValue2(getW(spacing, "line"));
+  const spacing2 = first2(props, "spacing");
+  const before = twipValue2(getW(spacing2, "before"));
+  const after = twipValue2(getW(spacing2, "after"));
+  const line2 = signedTwipValue2(getW(spacing2, "line"));
   if (before !== void 0) paragraph.spacingBeforeTwips = before;
   if (after !== void 0) paragraph.spacingAfterTwips = after;
-  if (line !== void 0) {
-    paragraph.lineSpacingTwips = line;
+  if (line2 !== void 0) {
+    paragraph.lineSpacingTwips = line2;
   }
-  const rule = getW(spacing, "lineRule");
+  const rule = getW(spacing2, "lineRule");
   if (rule === "auto" || rule === "exact" || rule === "atLeast") paragraph.lineSpacingRule = rule;
-  else if (line !== void 0) paragraph.lineSpacingRule = "auto";
+  else if (line2 !== void 0) paragraph.lineSpacingRule = "auto";
   const indent = first2(props, "ind");
   const indentLeft = signedTwipValue2(getW(indent, "left"));
   const indentRight = signedTwipValue2(getW(indent, "right"));
@@ -3607,9 +5927,9 @@ function resolveNumberingLevel(catalog, numId, level) {
   let base = override?.lvl ?? abstract;
   if (!base) return void 0;
   if (override?.lvl) {
-    const { lvlRestart: _ignored, ...properties3 } = base;
+    const { lvlRestart: _ignored, ...properties4 } = base;
     base = {
-      ...properties3,
+      ...properties4,
       ...abstract?.lvlRestart !== void 0 ? { lvlRestart: abstract.lvlRestart } : {}
     };
   }
@@ -3635,6 +5955,37 @@ function documentBlockLists(model) {
   ];
 }
 
+// docx/chart-paint.ts
+function themeCatalogColorScheme(theme) {
+  const colors = {};
+  for (const [slot, value] of Object.entries(theme?.colors ?? {}))
+    if (value) colors[slot] = { kind: "srgb", value: value.replace(/^#/, ""), transforms: [] };
+  return { colors };
+}
+function docxChartPaint(chart, widthPx, heightPx, theme) {
+  const space = chart?.chartSpace;
+  if (!space) return { label: "Chart" };
+  const kind = chartSpaceKind(space);
+  if (!kind.drawn) return { label: kind.type ? `Chart (${kind.type})` : "Chart" };
+  try {
+    const fonts = {
+      ...theme?.fonts.major.latin ? { major: theme.fonts.major.latin } : {},
+      ...theme?.fonts.minor.latin ? { minor: theme.fonts.minor.latin } : {}
+    };
+    const svg = renderChartSpaceSvg(space, {
+      width: Math.max(1, Math.round(widthPx)),
+      height: Math.max(1, Math.round(heightPx)),
+      theme: themeCatalogColorScheme(theme),
+      fonts,
+      ...chart.formatting ? { formatting: chart.formatting } : {},
+      ...chart.colorPalette !== void 0 ? { colorPalette: chart.colorPalette } : {}
+    });
+    return { svg, label: chart.title ? `Chart: ${chart.title}` : "Chart" };
+  } catch {
+    return { label: kind.type ? `Chart (${kind.type})` : "Chart" };
+  }
+}
+
 // docx/diagram-theme.ts
 function diagramColorTheme(theme) {
   return {
@@ -3702,20 +6053,20 @@ function restoreParagraphFormatting(paragraph) {
     throw new Error(
       "Cannot reject a paragraph formatting revision without its prior properties snapshot."
     );
-  const properties3 = parsePropertiesSnapshot(xml, "pPr");
+  const properties4 = parsePropertiesSnapshot(xml, "pPr");
   if (paragraph.sourceParagraphPropertiesXml) {
     const current = parsePropertiesSnapshot(paragraph.sourceParagraphPropertiesXml, "pPr");
     for (const name of ["rPr", "sectPr"]) {
       const element = first2(current, name);
-      if (element && !first2(properties3, name))
-        properties3.appendChild(properties3.ownerDocument.importNode(element, true));
+      if (element && !first2(properties4, name))
+        properties4.appendChild(properties4.ownerDocument.importNode(element, true));
     }
-    orderParagraphProperties(properties3);
+    orderParagraphProperties(properties4);
   }
-  const previous = parseDirectParagraphProperties(properties3);
+  const previous = parseDirectParagraphProperties(properties4);
   for (const key of PARAGRAPH_FORMAT_KEYS) delete paragraph[key];
   Object.assign(paragraph, previous);
-  paragraph.restoredParagraphPropertiesXml = buildXml(properties3);
+  paragraph.restoredParagraphPropertiesXml = buildXml(properties4);
   if (paragraph.sourceParagraphPropertiesXml)
     paragraph.sourceParagraphPropertiesXml = paragraph.restoredParagraphPropertiesXml;
   delete paragraph.formatRevision;
@@ -4339,7 +6690,8 @@ function runToInlineNodes(run, schema, noteNumber) {
           textBoxText: run.image.textBoxText ? JSON.stringify(run.image.textBoxText) : null,
           textBoxEditable: run.image.textBoxEditable ?? null,
           textBoxBorder: run.image.textBoxBorder ?? null,
-          diagram: run.image.diagram ? JSON.stringify(run.image.diagram) : null
+          diagram: run.image.diagram ? JSON.stringify(run.image.diagram) : null,
+          chart: run.image.chart ? JSON.stringify(run.image.chart) : null
         },
         void 0,
         marks2
@@ -4361,8 +6713,8 @@ function applyInlineFormat(run, child) {
   Object.assign(run, inlineRunProperties(child));
   const marks = { text: "", ...run.revision ? { revision: run.revision } : {} };
   applyMarkFormatting(marks, child);
-  const { text: _text, ...properties3 } = marks;
-  Object.assign(run, properties3);
+  const { text: _text, ...properties4 } = marks;
+  Object.assign(run, properties4);
   const ids = commentIdsFromNode(child);
   if (ids.length) run.commentIds = ids;
   else delete run.commentIds;
@@ -4423,6 +6775,7 @@ function appendInlineNode(runs, child) {
         // Same key order as the parser's run: the writer compares an unchanged placeholder run by JSON.
         ...child.attrs.unsupported ? { unsupported: child.attrs.unsupported } : {},
         ...typeof child.attrs.diagram === "string" ? { diagram: JSON.parse(child.attrs.diagram) } : {},
+        ...typeof child.attrs.chart === "string" ? { chart: JSON.parse(child.attrs.chart) } : {},
         ...typeof child.attrs.placement === "string" ? { placement: JSON.parse(child.attrs.placement) } : {},
         ...typeof child.attrs.textBoxText === "string" ? { textBoxText: JSON.parse(child.attrs.textBoxText) } : {},
         ...child.attrs.textBoxEditable ? { textBoxEditable: true } : {},
@@ -4524,9 +6877,9 @@ function fieldClipboardSlice(slice) {
       });
       return node.copy(Fragment.fromArray(children4));
     }
-    const properties3 = !node.isText && node.type.spec.attrs?.format ? inlineRunProperties(node) : void 0;
+    const properties4 = !node.isText && node.type.spec.attrs?.format ? inlineRunProperties(node) : void 0;
     const field = node.marks.find((mark) => mark.type.name === "field");
-    const cached2 = properties3?.field;
+    const cached2 = properties4?.field;
     if (!field && !cached2) return node;
     if (!(field?.attrs.simple ?? cached2?.simple) && complete.has(pos)) return node;
     const marks = node.marks.flatMap((mark) => {
@@ -4535,8 +6888,8 @@ function fieldClipboardSlice(slice) {
       const { fieldInstanceId: _identity, fieldFlags: _flags2, ...props } = mark.attrs.props ?? {};
       return Object.keys(props).length ? [mark.type.create({ ...mark.attrs, props })] : [];
     });
-    if (!properties3 || !cached2) return node.mark(marks);
-    const { field: _field, fieldInstanceId: _id, fieldFlags: _flags, ...literal } = properties3;
+    if (!properties4 || !cached2) return node.mark(marks);
+    const { field: _field, fieldInstanceId: _id, fieldFlags: _flags, ...literal } = properties4;
     return node.type.create(
       updatedInlineRunAttributes(
         node,
@@ -4587,7 +6940,7 @@ function fieldResultRanges(doc) {
 }
 
 // docx/ui/simple-field-input.ts
-var graphemes = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+var graphemes2 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 function targetField(state, from, to) {
   return fieldResultRanges(state.doc).find(
     (range) => range.mark.attrs.simple && from >= range.from && to <= range.to && (from !== to || from > range.from && from < range.to)
@@ -4601,14 +6954,14 @@ function resultMarks(node, field) {
     ...typeof id === "string" && { fieldInstanceId: id },
     ...source?.fieldFlags && { fieldFlags: source.fieldFlags }
   };
-  const properties3 = node.type.schema.marks.runProperties;
-  if (properties3) {
-    const old = properties3.isInSet(marks);
+  const properties4 = node.type.schema.marks.runProperties;
+  if (properties4) {
+    const old = properties4.isInSet(marks);
     const { fieldInstanceId: _identity, fieldFlags: _flags, ...other } = old?.attrs.props ?? {};
     const props = { ...other, ...state };
-    marks = properties3.removeFromSet(marks);
+    marks = properties4.removeFromSet(marks);
     if (Object.keys(props).length)
-      marks = properties3.create({ ...old?.attrs ?? {}, props }).addToSet(marks);
+      marks = properties4.create({ ...old?.attrs ?? {}, props }).addToSet(marks);
   }
   return marks;
 }
@@ -4634,19 +6987,19 @@ function simpleFieldPasteSlice(slice, state) {
   slice.content.forEach((node) => children3.push(project(node)));
   return new Slice(Fragment.fromArray(children3), slice.openStart, slice.openEnd);
 }
-function replaceSimpleFieldResult(state, from, to, text) {
+function replaceSimpleFieldResult(state, from, to, text2) {
   const field = targetField(state, from, to);
   if (!field) return null;
-  if (!text) {
+  if (!text2) {
     const tr2 = state.tr;
     if (!emptySimpleFieldResult(tr2, from, to)) return null;
     return tr2.setSelection(TextSelection.create(tr2.doc, from + 3));
   }
   const $from = state.doc.resolve(from);
   const marks = state.storedMarks ?? (from === to ? $from.marks() : $from.marksAcross(state.doc.resolve(to)));
-  const node = state.schema.text(text, marks);
+  const node = state.schema.text(text2, marks);
   const tr = state.tr.replaceRangeWith(from, to, node.mark(resultMarks(node, field)));
-  if (!tr.selection.empty && tr.selection.to === from + text.length)
+  if (!tr.selection.empty && tr.selection.to === from + text2.length)
     tr.setSelection(TextSelection.near(tr.selection.$to));
   return tr;
 }
@@ -4680,7 +7033,7 @@ function deleteSimpleFieldResult(state, backward) {
     (range) => range.mark.attrs.simple && (backward ? range.to === from : range.from === from)
   );
   if (!field) return null;
-  const segments = graphemes.segment(field.text)[Symbol.iterator]();
+  const segments = graphemes2.segment(field.text)[Symbol.iterator]();
   if (segments.next().done || !segments.next().done) return null;
   return replaceSimpleFieldResult(state, field.from, field.to, "");
 }
@@ -4718,10 +7071,10 @@ function fieldGuardPlugin() {
           if (!view.editable || !event.clipboardData) return false;
           const tr = deleteFieldSelection(view.state);
           if (!tr) return false;
-          const { dom, text } = view.serializeForClipboard(view.state.selection.content());
+          const { dom, text: text2 } = view.serializeForClipboard(view.state.selection.content());
           event.clipboardData.clearData();
           event.clipboardData.setData("text/html", dom.innerHTML);
-          event.clipboardData.setData("text/plain", text);
+          event.clipboardData.setData("text/plain", text2);
           event.preventDefault();
           view.dispatch(tr.scrollIntoView().setMeta("uiEvent", "cut"));
           return true;
@@ -4729,8 +7082,8 @@ function fieldGuardPlugin() {
       },
       transformCopied: fieldClipboardSlice,
       transformPasted: (slice, view) => simpleFieldPasteSlice(fieldClipboardSlice(slice), view?.state),
-      handleTextInput: (view, from, to, text) => {
-        const transaction = replaceAroundMarkers(view.state, from, to, text) ?? replaceSimpleFieldResult(view.state, from, to, text);
+      handleTextInput: (view, from, to, text2) => {
+        const transaction = replaceAroundMarkers(view.state, from, to, text2) ?? replaceSimpleFieldResult(view.state, from, to, text2);
         if (transaction) view.dispatch(transaction);
         return Boolean(transaction);
       },
@@ -4822,7 +7175,7 @@ function markersIn(doc, from, to) {
   });
   return markers;
 }
-function replaceAroundMarkers(state, from, to, text) {
+function replaceAroundMarkers(state, from, to, text2) {
   if (from === to) return null;
   const markers = markersIn(state.doc, from, to);
   if (!markers.length) return null;
@@ -4837,8 +7190,8 @@ function replaceAroundMarkers(state, from, to, text) {
     end = marker.pos;
   }
   if (from < end) transaction.delete(from, end);
-  if (text) transaction.insert(from, state.schema.text(text, marks));
-  return transaction.setSelection(TextSelection.create(transaction.doc, from + text.length));
+  if (text2) transaction.insert(from, state.schema.text(text2, marks));
+  return transaction.setSelection(TextSelection.create(transaction.doc, from + text2.length));
 }
 function deleteAroundMarkers(state, backward) {
   const { selection, doc } = state;
@@ -4910,7 +7263,7 @@ var commentSerial = 0;
 function nextCommentId(idGenerator) {
   return idGenerator ? idGenerator("comment") : `dve-comment-${Date.now().toString(36)}-${++commentSerial}`;
 }
-function addComment(view, author, text, idGenerator, inlineElements = true) {
+function addComment(view, author, text2, idGenerator, inlineElements = true) {
   if (!view.editable || !view.state.schema.marks.comment) return null;
   const { from, to } = commentSelectionRange(
     view.state.doc,
@@ -4939,7 +7292,7 @@ function addComment(view, author, text, idGenerator, inlineElements = true) {
     tr = tr.addMark(start, end, view.state.schema.marks.comment.create({ ids: [id] }));
   });
   if (!tr.docChanged) return null;
-  const comment = { id, author, text, resolved: false };
+  const comment = { id, author, text: text2, resolved: false };
   const threads = commentThreadsFromDoc(view.state.doc);
   if (inlineElements && threads) setCommentThreads(tr, [...threads, comment]);
   view.dispatch(closeHistory(tr));
@@ -4988,9 +7341,9 @@ function deleteComment(comments, id) {
 function resolveComment(comments, id, resolved) {
   return comments.map((comment) => comment.id === id ? { ...comment, resolved } : comment);
 }
-function replyToComment(comments, parentId, author, text, idGenerator) {
+function replyToComment(comments, parentId, author, text2, idGenerator) {
   const id = nextCommentId(idGenerator);
-  return [...comments, { id, author, text, parentId }];
+  return [...comments, { id, author, text: text2, parentId }];
 }
 function commentIdsAtSelection(view) {
   const { from, to, empty } = view.state.selection;
@@ -5284,7 +7637,7 @@ var WordYjsComments = class {
     }
     return true;
   }
-  add(view, author, text, idGenerator) {
+  add(view, author, text2, idGenerator) {
     if (!view.editable || view.state.selection.empty || ySyncPluginKey.getState(view.state)?.type !== this.fragment)
       return null;
     const id = idGenerator("comment");
@@ -5292,18 +7645,18 @@ var WordYjsComments = class {
     let added = null;
     this.change(() => {
       const elements2 = this.inlineEnabled() && this.inlineAnchors.add(view.state, id);
-      added = addComment(view, author, text, () => id, false);
-      if (!added && elements2) added = { id, author, text, resolved: false };
+      added = addComment(view, author, text2, () => id, false);
+      if (!added && elements2) added = { id, author, text: text2, resolved: false };
       if (added) this.records.set(id, added);
     });
     return added;
   }
-  reply(parentId, author, text, idGenerator) {
+  reply(parentId, author, text2, idGenerator) {
     const root = this.records.get(parentId);
     if (!root || root.parentId || this.deleted.get(parentId)) return false;
     const id = idGenerator("comment");
     if (!id || this.records.has(id)) return false;
-    return this.change(() => this.records.set(id, { id, parentId, author, text }));
+    return this.change(() => this.records.set(id, { id, parentId, author, text: text2 }));
   }
   resolve(id, resolved) {
     const root = this.records.get(id);
@@ -5345,12 +7698,12 @@ function independentCommentAnchors(node) {
     if (!node.isText && node.type.spec.attrs?.format && node.marks.some(
       (mark) => mark.type.name === "comment" || mark.type.name === "inlineCommentAnchors"
     )) {
-      const properties3 = inlineRunProperties(node);
+      const properties4 = inlineRunProperties(node);
       const ids = commentIdsFromNode(node);
-      if (ids.length) properties3.commentIds = ids;
-      else delete properties3.commentIds;
+      if (ids.length) properties4.commentIds = ids;
+      else delete properties4.commentIds;
       return node.type.create(
-        updatedInlineRunAttributes(node, JSON.stringify(properties3)),
+        updatedInlineRunAttributes(node, JSON.stringify(properties4)),
         void 0,
         marks.filter(
           (mark) => mark.type.name !== "inlineCommentAnchors" && mark.type.name !== "comment"
@@ -5697,6 +8050,64 @@ var insertWordHardBreak = (state, dispatch, view) => {
   return true;
 };
 
+// docx/ui/chart-spec.ts
+var SVG_NS2 = "http://www.w3.org/2000/svg";
+function elementSpec(element, root) {
+  const attrs = {};
+  for (const attr2 of Array.from(element.attributes)) {
+    if (attr2.name === "xmlns" || attr2.name.startsWith("xmlns:") || /^on/i.test(attr2.name)) continue;
+    attrs[attr2.name] = attr2.value;
+  }
+  const children3 = [];
+  for (const child of Array.from(element.childNodes)) {
+    if (isElement(child)) children3.push(elementSpec(child, false));
+    else if (child.nodeType === 3 && child.nodeValue) children3.push(child.nodeValue);
+  }
+  const tag = root ? `${SVG_NS2} ${element.localName}` : element.localName;
+  return [tag, attrs, ...children3];
+}
+function svgMarkupSpec(svg) {
+  return elementSpec(parseXml(svg, { label: "Chart SVG" }).documentElement, true);
+}
+function nodeChart(node) {
+  const value = node.attrs.chart;
+  if (typeof value !== "string") return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function chartNodeSpec(node, theme) {
+  const width = Number(node.attrs.widthPx) || 96;
+  const height = Number(node.attrs.heightPx) || 96;
+  const paint = docxChartPaint(nodeChart(node), width, height, theme);
+  const style = `width:${width}px;height:${height}px`;
+  if (!paint.svg)
+    return [
+      "span",
+      {
+        "data-docx-image-placeholder": "1",
+        "data-docx-chart": "frame",
+        ...inlineRunPropertiesDomAttrs(node),
+        class: "dve-image-placeholder",
+        style
+      },
+      paint.label
+    ];
+  return [
+    "span",
+    {
+      "data-docx-chart": "1",
+      ...inlineRunPropertiesDomAttrs(node),
+      class: "dve-chart",
+      style,
+      title: paint.label
+    },
+    svgMarkupSpec(paint.svg)
+  ];
+}
+
 // docx/ui/inline-content-schema.ts
 var safeAttrValue = (value) => String(value ?? "").replace(/[;{}"]/g, "");
 function placementClass(value) {
@@ -5717,7 +8128,7 @@ function textBoxLines(value) {
   if (typeof value !== "string") return [];
   try {
     const lines = JSON.parse(value);
-    return Array.isArray(lines) ? lines.map((line) => ["span", { class: "dve-textbox-line" }, String(line)]) : [];
+    return Array.isArray(lines) ? lines.map((line2) => ["span", { class: "dve-textbox-line" }, String(line2)]) : [];
   } catch {
     return [];
   }
@@ -5749,7 +8160,9 @@ var imageNodeSpec = {
     textBoxEditable: { default: null },
     textBoxBorder: { default: null },
     /** A SmartArt graphic (`DocxDiagram`) as JSON; shown read-only by the SmartArt node view. */
-    diagram: { default: null }
+    diagram: { default: null },
+    /** A chart (`DocxChart`) as JSON; painted read-only from its cached values (`chart-spec.ts`). */
+    chart: { default: null }
   },
   parseDOM: [
     {
@@ -5768,7 +8181,7 @@ var imageNodeSpec = {
       })
     }
   ],
-  toDOM: (node) => node.attrs.unsupported ? [
+  toDOM: (node) => node.attrs.chart ? chartNodeSpec(node) : node.attrs.unsupported ? [
     "span",
     {
       "data-docx-image-placeholder": "1",
@@ -5925,10 +8338,10 @@ var removeWordLink = (state, dispatch, view) => {
 function patchedRun(node, patch) {
   const run = inlineNodeRun(node);
   if (!run) return void 0;
-  const properties3 = run;
+  const properties4 = run;
   for (const [key, value] of Object.entries(patch)) {
-    if (value === void 0) delete properties3[key];
-    else properties3[key] = value;
+    if (value === void 0) delete properties4[key];
+    else properties4[key] = value;
   }
   return run;
 }
@@ -6340,14 +8753,14 @@ function resolveFormattingRange(tr, from, to, mode) {
       setInlineRunFormatting(tr, piece.from, run2);
       continue;
     }
-    const properties3 = piece.node.marks.find((mark) => mark.type.name === "runProperties");
+    const properties4 = piece.node.marks.find((mark) => mark.type.name === "runProperties");
     if (mode === "accept") {
-      const props = { ...properties3.attrs.props };
+      const props = { ...properties4.attrs.props };
       if (props.formatRevision) delete props.formatRevision;
       else delete props.revision;
-      tr.removeMark(piece.from, piece.to, properties3);
+      tr.removeMark(piece.from, piece.to, properties4);
       if (Object.keys(props).length)
-        tr.addMark(piece.from, piece.to, properties3.type.create({ props }));
+        tr.addMark(piece.from, piece.to, properties4.type.create({ props }));
       continue;
     }
     const run = { text: "", revision: piece.revision };
@@ -6359,7 +8772,7 @@ function resolveFormattingRange(tr, from, to, mode) {
 }
 
 // docx/ui/track-run-formatting.ts
-function properties(node) {
+function properties2(node) {
   const run = inlineNodeRun(node) ?? { text: "" };
   run.text = "";
   delete run.image;
@@ -6395,8 +8808,8 @@ function trackRunFormatting(steps, oldState, newState, author, date, nextId) {
         if (!previous.isInline || previous.type.name === "equation") return;
         const start = Math.max(from, previousPos);
         const end = Math.min(to, previousPos + previous.nodeSize);
-        const before = properties(previous);
-        const after = properties(node);
+        const before = properties2(previous);
+        const after = properties2(node);
         if (propertiesSignature(before) === propertiesSignature(after)) {
           if (hasInlineRunAttributes(node) && node.marks.some((mark2) => RUN_FORMAT_MARKS.has(mark2.type.name)))
             setInlineRunFormatting(tr, start, inlineNodeRun(node));
@@ -6483,7 +8896,7 @@ function paragraphProperties(element) {
     for (const child of children2(element, name)) element.removeChild(child);
   return element;
 }
-function properties2(node) {
+function properties3(node) {
   const paragraph = paragraphFromAttrs(node.attrs, String(node.attrs.id), []);
   delete paragraph.formatRevision;
   delete paragraph.markRevision;
@@ -6501,8 +8914,8 @@ function trackParagraphFormatting(steps, oldState, newState, author, date, nextI
     if (node.type.name !== "paragraph" || !node.type.spec.attrs?.formatRevision) return;
     const previous = oldState.doc.nodeAt(pos);
     if (previous === node) return;
-    const before = properties2(previous);
-    const after = properties2(node);
+    const before = properties3(previous);
+    const after = properties3(node);
     if (propertiesSignature(before) === propertiesSignature(after)) return;
     const pending = paragraphFormattingRevision(previous);
     const priorXml = pending?.previousParagraphPropertiesXml ?? buildXml(before);
@@ -6566,14 +8979,14 @@ function trackSimpleFieldDeletion(transform, from, to, slice, author, date, next
 function sourceProperties(value) {
   if (typeof value !== "string" || !value) return value;
   try {
-    const properties3 = parsePropertiesSnapshot(value, "pPr");
-    const run = first2(properties3, "rPr");
+    const properties4 = parsePropertiesSnapshot(value, "pPr");
+    const run = first2(properties4, "rPr");
     if (run) {
       for (const name of ["ins", "del"])
         for (const revision of children2(run, name)) run.removeChild(revision);
-      if (!run.childNodes.length && !run.attributes.length) properties3.removeChild(run);
+      if (!run.childNodes.length && !run.attributes.length) properties4.removeChild(run);
     }
-    return propertiesSignature(properties3);
+    return propertiesSignature(properties4);
   } catch {
     return value;
   }
@@ -7916,10 +10329,10 @@ function paragraphBoxCss(borders, shadingFill) {
   const parsed = typeof borders === "string" ? parseBordersJson(borders) : borders;
   const css = [];
   for (const side of ["top", "bottom", "left", "right"]) {
-    const line = cssBorderSide(parsed?.[side]);
-    if (!line) continue;
+    const line2 = cssBorderSide(parsed?.[side]);
+    if (!line2) continue;
     css.push(
-      `border-${side}:${line}`,
+      `border-${side}:${line2}`,
       `padding-${side}:${(parsed[side].spacePoints ?? 0) * 4 / 3}px`
     );
   }
@@ -8023,7 +10436,7 @@ function applyThemeColors(host, previous, colors) {
 }
 
 // docx/ui/word-count.ts
-function countWords(text, locale) {
+function countWords(text2, locale) {
   if (typeof Intl.Segmenter === "function") {
     let segmenter;
     try {
@@ -8031,9 +10444,9 @@ function countWords(text, locale) {
     } catch {
       segmenter = new Intl.Segmenter(void 0, { granularity: "word" });
     }
-    return [...segmenter.segment(text)].filter((part) => part.isWordLike).length;
+    return [...segmenter.segment(text2)].filter((part) => part.isWordLike).length;
   }
-  return text.match(/[\p{L}\p{N}][\p{L}\p{M}\p{N}'’]*/gu)?.length ?? 0;
+  return text2.match(/[\p{L}\p{N}][\p{L}\p{M}\p{N}'’]*/gu)?.length ?? 0;
 }
 
 // docx/ui/zoom-fit.ts
@@ -8045,4 +10458,4 @@ function fitZoomPercent(mode, viewport, page) {
   return Math.max(10, Math.min(500, Math.floor(ratio * 100)));
 }
 
-export { CollaborationAuthority, CollaborationClient, DirtyState, EDITOR_THEME_MODES, FIELD_RESULT_REPAIR_META, HEADER_FOOTER_INPUT, NotePartsStep, PAGE_GAP, PARAGRAPH_KEEP_KEYS, REMOTE_TRANSACTION_META, RIBBON_ACTION_IDS, RIBBON_ACTION_LABELS, SectionPartsStep, THEME_KEYS, WordYjsCollaboration, WordYjsComments, WordYjsMedia, acceptAllChanges, acceptChangeAtCursor, acceptRevisionRange, addComment, appendInlineNode, applyMarkFormatting, applyRunFormattingPatch, applyThemeColors, applyWordLink, authorColor, backstageFocus, clearDirectRunFormatting, collectRevisionRanges, commentAnchors, commentHistoryAttributes, commentIdsAtSelection, commentIdsFromMarks, commentIdsFromNode, commentThreadsFromDoc, countWords, createCollaborationIdGenerator, createToggleFormat, cssBorderSide, darkTheme, deleteAroundMarkers, deleteComment, deleteFieldSelection, dispatchIsolatedCommand, expectDefined, explicitOffFields, extraRunFields, extraRunProperties, fieldGuardPlugin, fieldMarkerNodeSpec, fieldResultRanges, fieldsBalanced, fitZoomPercent, formattingRevision, freezeBatch, goToComment, goToNextChange, goToPreviousChange, hardBreakNodeSpec, hasAnyChange, hasChangeAtCursor, hasNoteRevisions, imageNodeSpec, inlineNodeRun, insertWordHardBreak, isNavigableHref, isRibbonActionId, isWordYjsRemoteTransaction, ligatureCss, ligatureStyle, lightTheme, linkFromMarks, linkMarkSpec, markSpecs, marksForRun, moveName, nodeNumbering, normalizeRibbonActions, normalizeThemeMode, notePartsJson, noteReferenceNodeSpec, pageBreakNodeSpec, paragraphAttrs, paragraphBoxCss, paragraphFormattingRevision, paragraphFromAttrs, parseBatch, parseBordersJson, placementClass, refreshWordYjsPresence, rejectAllChanges, rejectChangeAtCursor, rejectRevisionRange, removeCommentAnchor, removeCommentThread, removeWordLink, repairCollaborativeDocumentIds, repairCollaborativeParagraphIds, replaceAroundMarkers, replyToComment, resolveCellVisuals, resolveComment, resolveNoteRevisions, restoreNoteParts, restoreSectionParts, reviewMarks, ribbonActionIdForLabel, runPropertiesMark, runToInlineNodes, sameJson2 as sameJson, sameRuns, sectionPartsJson, setCommentThreads, setReviewRecordingPreferences, swatchColor, tableCellStyle, tableStyle, themeDrawing, themeToCssVars, toggleTrackChanges, toggleTrackFormatting, toggleTrackMoves, trackChangesPlugin, trackChangesPluginKey, updateCommentThreads, wordHighlightColors, wordLinkRangeAt, wordYjsPluginKey, wordYjsPresencePlugin, wordYjsRedo, wordYjsUndo };
+export { CollaborationAuthority, CollaborationClient, DirtyState, EDITOR_THEME_MODES, FIELD_RESULT_REPAIR_META, HEADER_FOOTER_INPUT, NotePartsStep, PAGE_GAP, PARAGRAPH_KEEP_KEYS, REMOTE_TRANSACTION_META, RIBBON_ACTION_IDS, RIBBON_ACTION_LABELS, SectionPartsStep, THEME_KEYS, WordYjsCollaboration, WordYjsComments, WordYjsMedia, acceptAllChanges, acceptChangeAtCursor, acceptRevisionRange, addComment, appendInlineNode, applyMarkFormatting, applyRunFormattingPatch, applyThemeColors, applyWordLink, authorColor, backstageFocus, chartNodeSpec, clearDirectRunFormatting, collectRevisionRanges, commentAnchors, commentHistoryAttributes, commentIdsAtSelection, commentIdsFromMarks, commentIdsFromNode, commentThreadsFromDoc, countWords, createCollaborationIdGenerator, createToggleFormat, cssBorderSide, darkTheme, deleteAroundMarkers, deleteComment, deleteFieldSelection, dispatchIsolatedCommand, expectDefined, explicitOffFields, extraRunFields, extraRunProperties, fieldGuardPlugin, fieldMarkerNodeSpec, fieldResultRanges, fieldsBalanced, fitZoomPercent, formattingRevision, freezeBatch, goToComment, goToNextChange, goToPreviousChange, hardBreakNodeSpec, hasAnyChange, hasChangeAtCursor, hasNoteRevisions, imageNodeSpec, inlineNodeRun, insertWordHardBreak, isNavigableHref, isRibbonActionId, isWordYjsRemoteTransaction, ligatureCss, ligatureStyle, lightTheme, linkFromMarks, linkMarkSpec, markSpecs, marksForRun, moveName, nodeChart, nodeNumbering, normalizeRibbonActions, normalizeThemeMode, notePartsJson, noteReferenceNodeSpec, pageBreakNodeSpec, paragraphAttrs, paragraphBoxCss, paragraphFormattingRevision, paragraphFromAttrs, parseBatch, parseBordersJson, placementClass, refreshWordYjsPresence, rejectAllChanges, rejectChangeAtCursor, rejectRevisionRange, removeCommentAnchor, removeCommentThread, removeWordLink, repairCollaborativeDocumentIds, repairCollaborativeParagraphIds, replaceAroundMarkers, replyToComment, resolveCellVisuals, resolveComment, resolveNoteRevisions, restoreNoteParts, restoreSectionParts, reviewMarks, ribbonActionIdForLabel, runPropertiesMark, runToInlineNodes, sameJson2 as sameJson, sameRuns, sectionPartsJson, setCommentThreads, setReviewRecordingPreferences, svgMarkupSpec, swatchColor, tableCellStyle, tableStyle, themeDrawing, themeToCssVars, toggleTrackChanges, toggleTrackFormatting, toggleTrackMoves, trackChangesPlugin, trackChangesPluginKey, updateCommentThreads, wordHighlightColors, wordLinkRangeAt, wordYjsPluginKey, wordYjsPresencePlugin, wordYjsRedo, wordYjsUndo };