ooxml-core 1.0.0 → 1.2.0

package/dist/docx/layout/index.cjs

@@ -5,7 +5,9 @@ var xmldom = require('@xmldom/xmldom');
 // 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))
@@ -103,6 +105,10 @@ var eighthPoints = (value) => integer("eighthPoints", value);
 var roundSignedTwips = (value) => integer("twips", roundAway("twips", value));
 var twipsToPixels = (value) => value / 15;
 
+// units/constants.ts
+var EMU_PER_PIXEL = 9525;
+var EMU_PER_POINT = 12700;
+
 // docx/simple-types.ts
 function parseOnOff(value) {
   switch (value) {
@@ -144,8 +150,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) {
@@ -154,26 +160,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) {
@@ -332,16 +338,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;
@@ -369,13 +375,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 parseShadingFill(shd) {
@@ -689,6 +695,651 @@ function resolveRunFormatting(run, context = {}) {
   return result;
 }
 
+// color/color-primitives.ts
+function clampUnitInterval(value) {
+  return Math.min(1, Math.max(0, value));
+}
+function hexToRgbChannels(color) {
+  const normalized = color.replace("#", "");
+  if (!/^[0-9a-fA-F]{6}$/.test(normalized)) {
+    return null;
+  }
+  return {
+    r: Number.parseInt(normalized.slice(0, 2), 16),
+    g: Number.parseInt(normalized.slice(2, 4), 16),
+    b: Number.parseInt(normalized.slice(4, 6), 16)
+  };
+}
+function percentDivisorFor(text2) {
+  return text2.endsWith("%") ? 100 : 1e5;
+}
+function parseOoxmlPercent(value) {
+  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;
+  }
+  return magnitude / divisor;
+}
+function parseDrawingPercent(value) {
+  const parsed = parseOoxmlPercent(value);
+  return parsed === void 0 ? void 0 : clampUnitInterval(parsed);
+}
+function scrgbLinearToSrgb8(linear) {
+  const l = Math.min(1, Math.max(0, linear));
+  const companded = l <= 31308e-7 ? 12.92 * l : 1.055 * l ** (1 / 2.4) - 0.055;
+  return Math.min(255, Math.max(0, Math.round(companded * 255)));
+}
+function toHex(value) {
+  return Math.min(255, Math.max(0, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
+}
+function rgbToHsl(r, g, b) {
+  const rN = r / 255;
+  const gN = g / 255;
+  const bN = b / 255;
+  const cMax = Math.max(rN, gN, bN);
+  const cMin = Math.min(rN, gN, bN);
+  const delta = cMax - cMin;
+  const l = (cMax + cMin) / 2;
+  let s = 0;
+  if (delta !== 0) {
+    s = delta / (1 - Math.abs(2 * l - 1));
+  }
+  let h = 0;
+  if (delta !== 0) {
+    if (cMax === rN) {
+      h = 60 * ((gN - bN) / delta % 6);
+    } else if (cMax === gN) {
+      h = 60 * ((bN - rN) / delta + 2);
+    } else {
+      h = 60 * ((rN - gN) / delta + 4);
+    }
+  }
+  if (h < 0) {
+    h += 360;
+  }
+  return { h, s: clampUnitInterval(s), l: clampUnitInterval(l) };
+}
+function hslToRgb(h, s, l, roundChannel = Math.round, options) {
+  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;
+  const x = c * (1 - Math.abs(hN / 60 % 2 - 1));
+  const m = lC - c / 2;
+  let rP = 0;
+  let gP = 0;
+  let bP = 0;
+  if (hN < 60) {
+    rP = c;
+    gP = x;
+    bP = 0;
+  } else if (hN < 120) {
+    rP = x;
+    gP = c;
+    bP = 0;
+  } else if (hN < 180) {
+    rP = 0;
+    gP = c;
+    bP = x;
+  } else if (hN < 240) {
+    rP = 0;
+    gP = x;
+    bP = c;
+  } else if (hN < 300) {
+    rP = x;
+    gP = 0;
+    bP = c;
+  } else {
+    rP = c;
+    gP = 0;
+    bP = x;
+  }
+  return {
+    r: roundChannel((rP + m) * 255),
+    g: roundChannel((gP + m) * 255),
+    b: roundChannel((bP + m) * 255)
+  };
+}
+function parseDrawingFraction(value) {
+  return parseOoxmlPercent(value);
+}
+function parseDrawingHueDegrees(value) {
+  const parsed = Number.parseFloat(String(value ?? "").trim());
+  if (!Number.isFinite(parsed)) {
+    return void 0;
+  }
+  return parsed / 6e4;
+}
+
+// color/color-linear.ts
+function srgb255ToLinear(channel) {
+  const c = clampUnitInterval(channel / 255);
+  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function linearToSrgb255(linear) {
+  const c = clampUnitInterval(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",
+  red: "#FF0000",
+  green: "#008000",
+  blue: "#0000FF",
+  yellow: "#FFFF00",
+  gray: "#808080",
+  grey: "#808080"
+};
+function baseHex(color, theme) {
+  switch (color.kind) {
+    case "srgb":
+      return /^[0-9a-f]{6}$/i.test(color.value) ? `#${color.value.toUpperCase()}` : void 0;
+    case "scheme":
+      return theme?.scheme(color.value);
+    case "system":
+      return color.fallback && /^[0-9a-f]{6}$/i.test(color.fallback) ? `#${color.fallback.toUpperCase()}` : void 0;
+    case "preset":
+      return PRESET_COLORS[color.value];
+    case "scrgb": {
+      const [r, g, b] = color.value.split(",").map((part) => parseDrawingFraction(part));
+      if (r === void 0 || g === void 0 || b === void 0) return void 0;
+      return `#${toHex(scrgbLinearToSrgb8(r))}${toHex(scrgbLinearToSrgb8(g))}${toHex(scrgbLinearToSrgb8(b))}`;
+    }
+    case "hsl": {
+      const [h, s, l] = color.value.split(",");
+      const hue = parseDrawingHueDegrees(h);
+      const sat = parseDrawingFraction(s);
+      const lum = parseDrawingFraction(l);
+      if (hue === void 0 || sat === void 0 || lum === void 0) return void 0;
+      const { r, g, b } = hslToRgb(hue, sat, lum);
+      return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+    }
+  }
+}
+var APPLIED = /* @__PURE__ */ new Set([
+  "alpha",
+  "alphaMod",
+  "alphaOff",
+  "comp",
+  "inv",
+  "gray",
+  "shade",
+  "tint",
+  "hue",
+  "hueMod",
+  "hueOff",
+  "sat",
+  "satMod",
+  "satOff",
+  "lum",
+  "lumMod",
+  "lumOff"
+]);
+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);
+  if (has("comp")) {
+    const hsl = rgbToHsl(r, g, b);
+    ({ r, g, b } = hslToRgb((hsl.h + 180) % 360, hsl.s, hsl.l));
+  }
+  if (has("inv")) [r, g, b] = [255 - r, 255 - g, 255 - b];
+  if (has("gray")) r = g = b = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+  const shade = parseDrawingPercent(find("shade"));
+  if (shade !== void 0) {
+    r = linearToSrgb255(srgb255ToLinear(r) * shade);
+    g = linearToSrgb255(srgb255ToLinear(g) * shade);
+    b = linearToSrgb255(srgb255ToLinear(b) * shade);
+  }
+  const tint = parseDrawingPercent(find("tint"));
+  if (tint !== void 0) {
+    r = linearToSrgb255(1 - (1 - srgb255ToLinear(r)) * tint);
+    g = linearToSrgb255(1 - (1 - srgb255ToLinear(g)) * tint);
+    b = linearToSrgb255(1 - (1 - srgb255ToLinear(b)) * tint);
+  }
+  if (["hue", "hueMod", "hueOff", "sat", "satMod", "satOff", "lum", "lumMod", "lumOff"].some(has)) {
+    const hsl = rgbToHsl(r, g, b);
+    const wrap = (degrees) => (degrees % 360 + 360) % 360;
+    const hueAbs = parseDrawingHueDegrees(find("hue"));
+    if (hueAbs !== void 0) hsl.h = wrap(hueAbs);
+    const hueMod = parseDrawingFraction(find("hueMod"));
+    if (hueMod !== void 0) hsl.h = wrap(hsl.h * hueMod);
+    const hueOff = parseDrawingHueDegrees(find("hueOff"));
+    if (hueOff !== void 0) hsl.h = wrap(hsl.h + hueOff);
+    const satAbs = parseDrawingFraction(find("sat"));
+    if (satAbs !== void 0) hsl.s = clampUnitInterval(satAbs);
+    const satMod = parseDrawingFraction(find("satMod"));
+    if (satMod !== void 0) hsl.s = clampUnitInterval(hsl.s * satMod);
+    const satOff = parseDrawingFraction(find("satOff"));
+    if (satOff !== void 0) hsl.s = clampUnitInterval(hsl.s + satOff);
+    const lumAbs = parseDrawingFraction(find("lum"));
+    if (lumAbs !== void 0) hsl.l = clampUnitInterval(lumAbs);
+    const lumMod = parseDrawingFraction(find("lumMod"));
+    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 = 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;
+  const alphaMod = parseDrawingFraction(find("alphaMod"));
+  if (alphaMod !== void 0) alpha = clampUnitInterval(alpha * alphaMod);
+  const alphaOff = parseDrawingFraction(find("alphaOff"));
+  if (alphaOff !== void 0) alpha = clampUnitInterval(alpha + alphaOff);
+  return {
+    hex: `#${toHex(r)}${toHex(g)}${toHex(b)}`,
+    alpha,
+    unapplied: [...new Set(color.transforms.map((entry) => entry.name))].filter(
+      (name) => !APPLIED.has(name)
+    )
+  };
+}
+
+// drawingml/theme-model.ts
+var DEFAULT_THEME_COLOR_MAP = {
+  bg1: "lt1",
+  tx1: "dk1",
+  bg2: "lt2",
+  tx2: "dk2"
+};
+
+// drawingml/theme-color.ts
+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) {
   return isStThemeColor(value);
@@ -707,12 +1358,6 @@ var TOKEN_TO_SLOT = {
   hyperlink: "hlink",
   followedHyperlink: "folHlink"
 };
-var DEFAULT_MAPPING = {
-  bg1: "lt1",
-  tx1: "dk1",
-  bg2: "lt2",
-  tx2: "dk2"
-};
 function resolveThemeColorToken(token, theme) {
   const logical = {
     background1: "bg1",
@@ -722,7 +1367,7 @@ function resolveThemeColorToken(token, theme) {
   };
   const logicalKey = logical[token];
   if (logicalKey) {
-    const slot2 = theme.colorMapping[logicalKey] ?? DEFAULT_MAPPING[logicalKey];
+    const slot2 = theme.colorMapping[logicalKey] ?? DEFAULT_THEME_COLOR_MAP[logicalKey];
     return theme.colors[slot2];
   }
   const slot = TOKEN_TO_SLOT[token];
@@ -737,27 +1382,16 @@ function hexToRgb(hex) {
     b: Number.parseInt(normalized.slice(4, 6), 16)
   };
 }
-function toHex(value) {
-  return Math.min(255, Math.max(0, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
-}
-function srgbToLinear(channel) {
-  const c = Math.min(1, Math.max(0, channel / 255));
-  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
-}
-function linearToSrgb(linear) {
-  const c = Math.min(1, Math.max(0, linear));
-  return 255 * (c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055);
-}
 function applyThemeShade(hex, fraction) {
   const rgb = hexToRgb(hex);
   if (!rgb) return hex;
-  const mix = (channel) => linearToSrgb(srgbToLinear(channel) * fraction);
+  const mix = (channel) => linearToSrgb255(srgb255ToLinear(channel) * fraction);
   return `#${toHex(mix(rgb.r))}${toHex(mix(rgb.g))}${toHex(mix(rgb.b))}`;
 }
 function applyThemeTint(hex, fraction) {
   const rgb = hexToRgb(hex);
   if (!rgb) return hex;
-  const mix = (channel) => linearToSrgb(1 - (1 - srgbToLinear(channel)) * fraction);
+  const mix = (channel) => linearToSrgb255(1 - (1 - srgb255ToLinear(channel)) * fraction);
   return `#${toHex(mix(rgb.r))}${toHex(mix(rgb.g))}${toHex(mix(rgb.b))}`;
 }
 function resolveThemeColorReference(ref, theme) {
@@ -769,6 +1403,11 @@ function resolveThemeColorReference(ref, theme) {
   return hex;
 }
 
+// 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/expect-defined.ts
 function expectDefined(value, context) {
   if (value === void 0 || value === null) {
@@ -926,10 +1565,10 @@ function hasUnexpectedAttributes(element, allowed, allowDateUtc = false) {
   }
   return false;
 }
-function runPropertiesHaveUnknownContent(properties) {
-  if (!properties) return false;
-  if (hasUnexpectedAttributes(properties, [])) return true;
-  for (const node of Array.from(properties.childNodes)) {
+function runPropertiesHaveUnknownContent(properties2) {
+  if (!properties2) return false;
+  if (hasUnexpectedAttributes(properties2, [])) return true;
+  for (const node of Array.from(properties2.childNodes)) {
     if (node.nodeType !== 1) {
       if (node.nodeType === 3 && node.textContent?.trim()) return true;
       continue;
@@ -994,6 +1633,1928 @@ function definedProps(source) {
   return Object.fromEntries(Object.entries(source).filter(([, value]) => value !== void 0));
 }
 
+// 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 hexToRgb2(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 = hexToRgb2(a.color);
+  const cb = hexToRgb2(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
+function clusteredBarGeometry(barGroupWidth, seriesCount, chartData) {
+  const overlap = chartData.barOverlap ?? 0;
+  const overlapSpan = 1 + (seriesCount - 1) * (1 - overlap / 100);
+  const singleBarWidth = chartData.barGapWidth !== void 0 ? barGroupWidth / (overlapSpan + Math.max(chartData.barGapWidth, 0) / 100) : barGroupWidth * 0.7 / seriesCount;
+  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 properties2 = point.spPr ?? point.marker?.spPr;
+    if (point.index === void 0) continue;
+    const pointColor = solidColor(properties2?.fill);
+    if (pointColor) points[point.index] = pointColor;
+    if (properties2?.fill && properties2.fill.kind !== "solid")
+      pointFills[point.index] = properties2.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 ?? 150,
+    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, ...properties2 } = line2;
+    return wrapped.map((runs, index) => ({
+      ...properties2,
+      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/restore-run-format.ts
 function parseRunPropertiesSnapshot(xml) {
   return parsePropertiesSnapshot(xml, "rPr");
@@ -1016,6 +3577,11 @@ function restoreRunFormatting(run) {
   else delete run.revision;
 }
 
+// docx/field-lock.ts
+function isFieldLocked(run) {
+  return run?.fieldFlags?.locked === true;
+}
+
 // docx/paragraph-properties.ts
 var signedTwipValue = parseSignedTwips;
 var twipValue = parseTwips;
@@ -1052,18 +3618,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 = twipValue(getW(spacing, "before"));
-  const after = twipValue(getW(spacing, "after"));
-  const line = signedTwipValue(getW(spacing, "line"));
+  const spacing2 = first2(props, "spacing");
+  const before = twipValue(getW(spacing2, "before"));
+  const after = twipValue(getW(spacing2, "after"));
+  const line2 = signedTwipValue(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 = signedTwipValue(getW(indent, "left"));
   const indentRight = signedTwipValue(getW(indent, "right"));
@@ -1087,6 +3653,31 @@ function parseDirectParagraphProperties(props) {
   return paragraph;
 }
 
+// docx/numbering-parse.ts
+function resolveNumberingLevel(catalog, numId, level) {
+  const num = catalog.nums[numId];
+  if (!num) return void 0;
+  const override = num.levelOverrides?.[level];
+  const sourceAbstract = catalog.abstractNums[num.abstractNumId]?.levels[level];
+  const abstract = sourceAbstract?.startWasOmitted && sourceAbstract.start === 1 ? { ...sourceAbstract, start: 0 } : sourceAbstract;
+  let base = override?.lvl ?? abstract;
+  if (!base) return void 0;
+  if (override?.lvl) {
+    const { lvlRestart: _ignored, ...properties2 } = base;
+    base = {
+      ...properties2,
+      ...abstract?.lvlRestart !== void 0 ? { lvlRestart: abstract.lvlRestart } : {}
+    };
+  }
+  let start = override?.startOverride ?? base.start;
+  if (override?.lvl) {
+    if (abstract?.lvlRestart === 0 && override.startOverride === void 0) start = abstract.start;
+    else if (!override.lvl.startWasOmitted || override.lvl.start !== 1) start = override.lvl.start;
+    else start = override.startOverride ?? 0;
+  }
+  return start !== base.start ? { ...base, start } : base;
+}
+
 // docx/document-paragraphs.ts
 function mapBlockParagraphs(blocks, map) {
   return blocks.map(
@@ -1210,33 +3801,39 @@ function numberNotesInOrder(blocks, kind) {
   return order;
 }
 
-// docx/numbering-parse.ts
-function resolveNumberingLevel(catalog, numId, level) {
-  const num = catalog.nums[numId];
-  if (!num) return void 0;
-  const override = num.levelOverrides?.[level];
-  const sourceAbstract = catalog.abstractNums[num.abstractNumId]?.levels[level];
-  const abstract = sourceAbstract?.startWasOmitted && sourceAbstract.start === 1 ? { ...sourceAbstract, start: 0 } : sourceAbstract;
-  let base = override?.lvl ?? abstract;
-  if (!base) return void 0;
-  if (override?.lvl) {
-    const { lvlRestart: _ignored, ...properties } = base;
-    base = {
-      ...properties,
-      ...abstract?.lvlRestart !== void 0 ? { lvlRestart: abstract.lvlRestart } : {}
+// 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" };
   }
-  let start = override?.startOverride ?? base.start;
-  if (override?.lvl) {
-    if (abstract?.lvlRestart === 0 && override.startOverride === void 0) start = abstract.start;
-    else if (!override.lvl.startWasOmitted || override.lvl.start !== 1) start = override.lvl.start;
-    else start = override.startOverride ?? 0;
-  }
-  return start !== base.start ? { ...base, start } : base;
 }
 
 // docx/numbering-text.ts
-function romanNumeral(n) {
+function romanNumeral(n2) {
   const values = [1e3, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
   const numerals = [
     "M",
@@ -1253,7 +3850,7 @@ function romanNumeral(n) {
     "IV",
     "I"
   ];
-  let remaining = Math.max(1, Math.min(Math.trunc(n), 3999));
+  let remaining = Math.max(1, Math.min(Math.trunc(n2), 3999));
   let result = "";
   for (const [i, value] of values.entries()) {
     while (remaining >= value) {
@@ -1264,13 +3861,13 @@ function romanNumeral(n) {
   return result;
 }
 var LATIN_LOWER = Array.from("abcdefghijklmnopqrstuvwxyz");
-function letterLabel(n) {
-  const index = Math.max(0, Math.trunc(n) - 1);
+function letterLabel(n2) {
+  const index = Math.max(0, Math.trunc(n2) - 1);
   const letter = LATIN_LOWER[index % LATIN_LOWER.length] ?? "a";
   return letter.repeat(Math.floor(index / LATIN_LOWER.length) + 1);
 }
-var ORDINAL_SUFFIX = (n) => {
-  const abs = Math.abs(Math.trunc(n));
+var ORDINAL_SUFFIX = (n2) => {
+  const abs = Math.abs(Math.trunc(n2));
   if (abs % 100 >= 11 && abs % 100 <= 13) return "th";
   switch (abs % 10) {
     case 1:
@@ -1283,8 +3880,8 @@ var ORDINAL_SUFFIX = (n) => {
       return "th";
   }
 };
-function ordinalNumeral(n) {
-  return `${Math.trunc(n)}${ORDINAL_SUFFIX(n)}`;
+function ordinalNumeral(n2) {
+  return `${Math.trunc(n2)}${ORDINAL_SUFFIX(n2)}`;
 }
 var ONES = [
   "",
@@ -1309,8 +3906,8 @@ var ONES = [
   "nineteen"
 ];
 var TENS = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"];
-function cardinalWords(n) {
-  const value = Math.trunc(n);
+function cardinalWords(n2) {
+  const value = Math.trunc(n2);
   if (value < 0 || value > 999999) return String(value);
   if (value === 0) return "zero";
   const chunk = (v) => {
@@ -1342,8 +3939,8 @@ var ORDINAL_WORDS = {
   nine: "ninth",
   twelve: "twelfth"
 };
-function ordinalWords(n) {
-  const value = Math.trunc(n);
+function ordinalWords(n2) {
+  const value = Math.trunc(n2);
   if (value < 0 || value > 999999) return ordinalNumeral(value);
   const words = cardinalWords(value);
   const splitAt = Math.max(words.lastIndexOf(" "), words.lastIndexOf("-"));
@@ -1483,11 +4080,11 @@ function computeListLabels(model) {
     if (!def) continue;
     if (def.numFmt === "none") continue;
     counters.advance(numId, level, def, catalog);
-    const text = def.numFmt === "bullet" ? def.lvlText : substituteLvlText(def.lvlText, numId, level, catalog, counters, Boolean(def.isLgl));
+    const text2 = def.numFmt === "bullet" ? def.lvlText : substituteLvlText(def.lvlText, numId, level, catalog, counters, Boolean(def.isLgl));
     labels.set(paragraph.id, {
       numId,
       level,
-      text,
+      text: text2,
       suffix: def.suffix ?? "tab",
       ...definedProps({
         alignment: def.lvlJc,
@@ -1512,8 +4109,8 @@ var SYMBOL_BULLETS = {
   "\uF0E0": "\u27A9",
   "\uF0B2": "\u25CB"
 };
-function displayListLabel(text) {
-  return text.replace(/[-]/g, (char) => SYMBOL_BULLETS[char] ?? "\u2022");
+function displayListLabel(text2) {
+  return text2.replace(/[-]/g, (char) => SYMBOL_BULLETS[char] ?? "\u2022");
 }
 
 // docx/restore-paragraph-format.ts
@@ -1551,20 +4148,20 @@ function restoreParagraphFormatting(paragraph) {
     throw new Error(
       "Cannot reject a paragraph formatting revision without its prior properties snapshot."
     );
-  const properties = parsePropertiesSnapshot(xml, "pPr");
+  const properties2 = 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(properties, name))
-        properties.appendChild(properties.ownerDocument.importNode(element, true));
+      if (element && !first2(properties2, name))
+        properties2.appendChild(properties2.ownerDocument.importNode(element, true));
     }
-    orderParagraphProperties(properties);
+    orderParagraphProperties(properties2);
   }
-  const previous = parseDirectParagraphProperties(properties);
+  const previous = parseDirectParagraphProperties(properties2);
   for (const key of PARAGRAPH_FORMAT_KEYS) delete paragraph[key];
   Object.assign(paragraph, previous);
-  paragraph.restoredParagraphPropertiesXml = buildXml(properties);
+  paragraph.restoredParagraphPropertiesXml = buildXml(properties2);
   if (paragraph.sourceParagraphPropertiesXml)
     paragraph.sourceParagraphPropertiesXml = paragraph.restoredParagraphPropertiesXml;
   delete paragraph.formatRevision;
@@ -1730,9 +4327,9 @@ function createFakeMeasurer(options = {}) {
   const charWidthFactor = options.charWidthFactor ?? 0.6;
   const lineHeightFactor = options.lineHeightFactor ?? 1.15;
   return {
-    widthOf(text, font) {
+    widthOf(text2, font) {
       let width = 0;
-      for (const ch of text) {
+      for (const ch of text2) {
         if (ch === "	" || ch === "\n") continue;
         width += font.sizePx * charWidthFactor * (font.bold ? 1.08 : 1) * (ch === " " ? 0.6 : 1);
       }
@@ -1755,7 +4352,7 @@ function isEastAsianChar(ch) {
   const cp = ch.codePointAt(0) ?? 0;
   return cp >= 4352 && cp <= 4607 || cp >= 11904 && cp <= 40959 || cp >= 43360 && cp <= 43391 || cp >= 44032 && cp <= 55295 || cp >= 63744 && cp <= 64255 || cp >= 65072 && cp <= 65103 || cp >= 65280 && cp <= 65519 || cp >= 131072 && cp <= 262143;
 }
-function tokenizeRun(text, runIndex) {
+function tokenizeRun(text2, runIndex) {
   const tokens = [];
   let word = "";
   let wordStart = 0;
@@ -1763,7 +4360,7 @@ function tokenizeRun(text, runIndex) {
     if (word) tokens.push({ kind: "word", text: word, runIndex, sourceStart: wordStart });
     word = "";
   };
-  const chars = [...new Intl.Segmenter(void 0, { granularity: "grapheme" }).segment(text)].map(
+  const chars = [...new Intl.Segmenter(void 0, { granularity: "grapheme" }).segment(text2)].map(
     (part) => part.segment
   );
   let offset = 0;
@@ -1796,7 +4393,7 @@ function appendBreakMarker(tokens, runIndex, sourceStart, kind) {
 
 // docx/layout/page-fields.ts
 function fieldDisplayText(run, values) {
-  if (!run.field) return run.text;
+  if (!run.field || isFieldLocked(run)) return run.text;
   const name = fieldName(run.field.instr);
   if (name === "PAGE") return values.page;
   if (name === "NUMPAGES") return values.numPages;
@@ -1886,11 +4483,11 @@ function fontOf(run) {
     }
   };
 }
-var graphemes = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-function runTextWidth(text, run, measurer) {
+var graphemes2 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function runTextWidth(text2, run, measurer) {
   return Math.max(
     0,
-    measurer.widthOf(text, fontOf(run)) * (run.textScalePercent ?? 100) / 100 + [...graphemes.segment(text)].length * (run.characterSpacingPx ?? 0)
+    measurer.widthOf(text2, fontOf(run)) * (run.textScalePercent ?? 100) / 100 + [...graphemes2.segment(text2)].length * (run.characterSpacingPx ?? 0)
   );
 }
 function resolveIndents(paragraph) {
@@ -1968,9 +4565,9 @@ function buildFragments(tokensOnLine, paragraph) {
   let x = 0;
   for (const { token, widthPx, leader, xOffsetPx, advancePx } of tokensOnLine) {
     const run = paragraph.runs[token.runIndex];
-    const text = token.kind === "word" || token.kind === "space" ? token.text : "";
+    const text2 = token.kind === "word" || token.kind === "space" ? token.text : "";
     fragments.push({
-      text,
+      text: text2,
       xPx: x + (xOffsetPx ?? 0),
       widthPx,
       runIndex: token.runIndex,
@@ -2182,11 +4779,11 @@ function layoutParagraph(paragraph, contentWidthPx, measurer, note, lineBox, sta
   }
   flushLine(lines.length === 0, void 0);
   const lastIndex = lines.length - 1;
-  for (const [index, line] of lines.entries()) {
+  for (const [index, line2] of lines.entries()) {
     lines[index] = {
-      ...line,
+      ...line2,
       fragments: alignFragments(
-        line.fragments,
+        line2.fragments,
         availableWidth(index),
         index === lastIndex,
         effectiveAlign
@@ -2198,10 +4795,10 @@ function layoutParagraph(paragraph, contentWidthPx, measurer, note, lineBox, sta
   const insetTopPx = extent("top");
   const insetBottomPx = extent("bottom");
   let y = insetTopPx;
-  for (const line of lines) {
-    y += line.gapBeforePx ?? 0;
-    line.yPx = y;
-    y += line.heightPx;
+  for (const line2 of lines) {
+    y += line2.gapBeforePx ?? 0;
+    line2.yPx = y;
+    y += line2.heightPx;
   }
   const frame = borders || paragraph.shading ? {
     leftPx: leftPx - extent("left"),
@@ -2254,7 +4851,7 @@ function stackParagraphs(paragraphs, widthPx, measurer, note, topPx = 0, startTo
     );
     y += layout.spacingBeforePx;
     const top = y;
-    const lines = layout.lines.map((line) => ({ ...line, yPx: line.yPx + top }));
+    const lines = layout.lines.map((line2) => ({ ...line2, yPx: line2.yPx + top }));
     boxes.push({
       kind: "paragraph",
       blockId: paragraph.id,
@@ -2322,7 +4919,7 @@ function splitCellAtHeight(boxes, cutHeightPx) {
       continue;
     }
     const beforeLines = box.lines.filter(
-      (line) => box.yPx + line.yPx + line.heightPx <= cutHeightPx
+      (line2) => box.yPx + line2.yPx + line2.heightPx <= cutHeightPx
     );
     const afterLines = box.lines.slice(beforeLines.length);
     if (beforeLines.length) {
@@ -2337,7 +4934,7 @@ function splitCellAtHeight(boxes, cutHeightPx) {
         ...box,
         yPx: 0,
         heightPx: afterLines.at(-1).yPx + afterLines.at(-1).heightPx - shift,
-        lines: afterLines.map((line) => ({ ...line, yPx: line.yPx - shift }))
+        lines: afterLines.map((line2) => ({ ...line2, yPx: line2.yPx - shift }))
       });
     } else {
       afterOrigin = box.yPx + box.heightPx;
@@ -2586,9 +5183,9 @@ function placeParagraph(cursor, placement, note) {
     let end = lineCursor;
     let forced;
     for (let i = lineCursor; i < layout.lines.length; i++) {
-      const line = expectDefined(layout.lines[i], "paragraph line index");
-      const gap = i === lineCursor && !firstSegment ? 0 : line.gapBeforePx ?? 0;
-      const height = line.heightPx + gap;
+      const line2 = expectDefined(layout.lines[i], "paragraph line index");
+      const gap = i === lineCursor && !firstSegment ? 0 : line2.gapBeforePx ?? 0;
+      const height = line2.heightPx + gap;
       if (cumulative + height > budget && (end > lineCursor || !cursor.atColumnTop)) break;
       cumulative += height;
       end = i + 1;
@@ -2616,7 +5213,7 @@ function placeParagraph(cursor, placement, note) {
     }
     const first3 = expectDefined(layout.lines[lineCursor], "first line of paragraph segment");
     const origin = first3.yPx - (firstSegment ? (first3.gapBeforePx ?? 0) + layout.insetTopPx : 0);
-    const segmentLines = layout.lines.slice(lineCursor, lineCursor + placedCount).map((line) => ({ ...line, yPx: line.yPx - origin }));
+    const segmentLines = layout.lines.slice(lineCursor, lineCursor + placedCount).map((line2) => ({ ...line2, yPx: line2.yPx - origin }));
     const isFinal = lineCursor + placedCount >= layout.lines.length;
     const lastLine = segmentLines.at(-1);
     const isLastSegment = lineCursor + placedCount >= layout.lines.length;
@@ -3209,9 +5806,9 @@ function paragraphBox(formatting, theme) {
   let betweenBorder;
   for (const side of ["top", "bottom", "left", "right", "between"]) {
     const source = formatting.borders?.[side];
-    const line = border(source, theme);
-    if (!line) continue;
-    const resolved = { ...line, spacePx: pointsToPx(source?.spacePoints ?? 0) };
+    const line2 = border(source, theme);
+    if (!line2) continue;
+    const resolved = { ...line2, spacePx: pointsToPx(source?.spacePoints ?? 0) };
     if (side === "between") betweenBorder = resolved;
     else borders[side] = resolved;
   }
@@ -3234,8 +5831,8 @@ function groupParagraphBorders(blocks, between) {
     const borders = { ...block.borders };
     if (sameAsNext) delete borders.bottom;
     if (sameAsPrevious) {
-      const line = between.get(block);
-      if (line) borders.top = line;
+      const line2 = between.get(block);
+      if (line2) borders.top = line2;
       else delete borders.top;
     }
     block.borders = borders;
@@ -3350,7 +5947,7 @@ function adaptDocumentModel(model, note = () => {
     if (run.equation) reportOnce(EQUATION_NOTE);
     const name = run.field ? fieldName(run.field.instr) : "";
     const noteText = run.noteReference ? noteLabel(run.noteReference.kind, run.noteReference.id) : run.noteMark ? markLabel ?? "" : void 0;
-    const text = noteText ?? (run.field && (name === "DATE" || name === "TIME") ? dateFieldResult(name, run.field.instr, now) : run.equation ? "[Equation]" : run.text);
+    const text2 = noteText ?? (run.field && !isFieldLocked(run) && (name === "DATE" || name === "TIME") ? dateFieldResult(name, run.field.instr, now) : run.equation ? "[Equation]" : run.text);
     const script = formatting.verticalAlign === "superscript" || noteText !== void 0 && formatting.verticalAlign === void 0 ? "super" : formatting.verticalAlign === "subscript" ? "sub" : void 0;
     const image = run.image;
     if (image?.unsupported === "Text box") reportOnce(TEXT_BOX_NOTE);
@@ -3358,11 +5955,12 @@ function adaptDocumentModel(model, note = () => {
       partName: image.partName,
       contentType: image.contentType,
       widthPx: image.widthPx,
-      heightPx: image.heightPx
+      heightPx: image.heightPx,
+      ...image.chart ? { chart: docxChartPaint(image.chart, image.widthPx, image.heightPx, theme) } : {}
     } : void 0;
     return {
       // Hidden text (`w:vanish`) takes no space when printed, as in Word by default.
-      text: image || formatting.vanish ? "" : formatting.caps ? text.toUpperCase() : text,
+      text: image || formatting.vanish ? "" : formatting.caps ? text2.toUpperCase() : text2,
       ...object ? { object } : {},
       ...definedProps({
         bold: formatting.bold,