pptx-react-viewer 1.18.0 → 1.19.1

package/dist/{chunk-HBXPK572.js → chunk-G5GATDE4.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkEXDUEXTO_js = require('./chunk-EXDUEXTO.js');
+var chunkAD3EAEY6_js = require('./chunk-AD3EAEY6.js');
 var DOMPurify = require('dompurify');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -202,6 +202,18 @@ function collectImagePaths(slides) {
           });
         }
       }
+      if (el.type === "model3d") {
+        const model = el;
+        if (model.modelPath && !model.modelData && !isExternalUrl(model.modelPath)) {
+          paths.add(model.modelPath);
+          refs.push({ element: el, field: "modelData", path: model.modelPath });
+        }
+        const posterNeedsResolution = model.posterImage ? !isExternalUrl(model.posterImage) : !model.imageData;
+        if (model.imagePath && posterNeedsResolution && !isExternalUrl(model.imagePath)) {
+          paths.add(model.imagePath);
+          refs.push({ element: el, field: "posterImage", path: model.imagePath });
+        }
+      }
       if (el.type === "group" && el.children?.length) {
         walkElements(el.children);
       }
@@ -222,7 +234,7 @@ function buildInitialGuides(presentationGuides, firstSlideGuides) {
       guides.push({
         id: g.id,
         axis: g.orientation === "horz" ? "h" : "v",
-        position: chunkEXDUEXTO_js.guideEmuToPx(g.positionEmu)
+        position: chunkAD3EAEY6_js.guideEmuToPx(g.positionEmu)
       });
     }
   }
@@ -231,7 +243,7 @@ function buildInitialGuides(presentationGuides, firstSlideGuides) {
       guides.push({
         id: g.id,
         axis: g.orientation === "horz" ? "h" : "v",
-        position: chunkEXDUEXTO_js.guideEmuToPx(g.positionEmu)
+        position: chunkAD3EAEY6_js.guideEmuToPx(g.positionEmu)
       });
     }
   }
@@ -244,23 +256,23 @@ function getResolvedShapeClipPathFor(shapeType, width, height, adjustments) {
     return void 0;
   }
   if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
-    return chunkEXDUEXTO_js.getShapeClipPath(shapeType);
+    return chunkAD3EAEY6_js.getShapeClipPath(shapeType);
   }
   if (adjustments && Object.keys(adjustments).length > 0) {
-    const adjusted = chunkEXDUEXTO_js.getAdjustmentAwareShapeClipPath(shapeType, width, height, adjustments);
+    const adjusted = chunkAD3EAEY6_js.getAdjustmentAwareShapeClipPath(shapeType, width, height, adjustments);
     if (adjusted !== void 0) {
       return adjusted;
     }
   }
-  const fromPreset = chunkEXDUEXTO_js.getShapeClipPathFromPreset(shapeType, width, height, adjustments);
+  const fromPreset = chunkAD3EAEY6_js.getShapeClipPathFromPreset(shapeType, width, height, adjustments);
   if (fromPreset !== void 0) {
     return fromPreset;
   }
-  const cloud = chunkEXDUEXTO_js.getCloudPathForRendering(shapeType, width, height);
+  const cloud = chunkAD3EAEY6_js.getCloudPathForRendering(shapeType, width, height);
   if (cloud !== void 0) {
     return cloud;
   }
-  return chunkEXDUEXTO_js.getShapeClipPath(shapeType);
+  return chunkAD3EAEY6_js.getShapeClipPath(shapeType);
 }
 function getResolvedShapeClipPath(element, width, height) {
   const shapeType = element.shapeType;
@@ -453,7 +465,7 @@ function getPatternSvg(preset, fg, bg) {
   const svg = (w, h, inner) => `<svg xmlns="${xmlns}" width="${w}" height="${h}">${inner}</svg>`;
   const rect = (x, y, w, h, fill) => `<rect x="${x}" y="${y}" width="${w}" height="${h}" fill="${fill}"/>`;
   const bgRect = (w, h) => rect(0, 0, w, h, bg);
-  const line = (x1, y1, x2, y2, stroke, sw, extra = "") => `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${stroke}" stroke-width="${sw}"${extra}/>`;
+  const line2 = (x1, y1, x2, y2, stroke, sw, extra = "") => `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${stroke}" stroke-width="${sw}"${extra}/>`;
   const circle = (cx, cy, r, fill) => `<circle cx="${cx}" cy="${cy}" r="${r}" fill="${fill}"/>`;
   switch (preset) {
     // ── Percentage fills ──────────────────────────────────────────────
@@ -532,61 +544,61 @@ function getPatternSvg(preset, fg, bg) {
       return svg(
         s,
         s,
-        bgRect(s, s) + line(0, 0, s, s, fg, 2) + line(-s, 0, 0, s, fg, 2) + line(s, 0, s * 2, s, fg, 2)
+        bgRect(s, s) + line2(0, 0, s, s, fg, 2) + line2(-s, 0, 0, s, fg, 2) + line2(s, 0, s * 2, s, fg, 2)
       );
     case "ltDnDiag":
       return svg(
         s,
         s,
-        bgRect(s, s) + line(0, 0, s, s, fg, 1) + line(-s, 0, 0, s, fg, 1) + line(s, 0, s * 2, s, fg, 1)
+        bgRect(s, s) + line2(0, 0, s, s, fg, 1) + line2(-s, 0, 0, s, fg, 1) + line2(s, 0, s * 2, s, fg, 1)
       );
     case "dkDnDiag":
       return svg(
         s,
         s,
-        bgRect(s, s) + line(0, 0, s, s, fg, 3) + line(-s, 0, 0, s, fg, 3) + line(s, 0, s * 2, s, fg, 3)
+        bgRect(s, s) + line2(0, 0, s, s, fg, 3) + line2(-s, 0, 0, s, fg, 3) + line2(s, 0, s * 2, s, fg, 3)
       );
     case "wdDnDiag":
       return svg(
         12,
         12,
-        bgRect(12, 12) + line(0, 0, 12, 12, fg, 4) + line(-12, 0, 0, 12, fg, 4) + line(12, 0, 24, 12, fg, 4)
+        bgRect(12, 12) + line2(0, 0, 12, 12, fg, 4) + line2(-12, 0, 0, 12, fg, 4) + line2(12, 0, 24, 12, fg, 4)
       );
     case "dashDnDiag":
-      return svg(s, s, bgRect(s, s) + line(0, 0, s, s, fg, 1, ' stroke-dasharray="4,4"'));
+      return svg(s, s, bgRect(s, s) + line2(0, 0, s, s, fg, 1, ' stroke-dasharray="4,4"'));
     // ── Diagonal lines (up) ──────────────────────────────────────────
     case "upDiag":
       return svg(
         s,
         s,
-        bgRect(s, s) + line(0, s, s, 0, fg, 2) + line(-s, s, 0, 0, fg, 2) + line(s, s, s * 2, 0, fg, 2)
+        bgRect(s, s) + line2(0, s, s, 0, fg, 2) + line2(-s, s, 0, 0, fg, 2) + line2(s, s, s * 2, 0, fg, 2)
       );
     case "ltUpDiag":
       return svg(
         s,
         s,
-        bgRect(s, s) + line(0, s, s, 0, fg, 1) + line(-s, s, 0, 0, fg, 1) + line(s, s, s * 2, 0, fg, 1)
+        bgRect(s, s) + line2(0, s, s, 0, fg, 1) + line2(-s, s, 0, 0, fg, 1) + line2(s, s, s * 2, 0, fg, 1)
       );
     case "dkUpDiag":
       return svg(
         s,
         s,
-        bgRect(s, s) + line(0, s, s, 0, fg, 3) + line(-s, s, 0, 0, fg, 3) + line(s, s, s * 2, 0, fg, 3)
+        bgRect(s, s) + line2(0, s, s, 0, fg, 3) + line2(-s, s, 0, 0, fg, 3) + line2(s, s, s * 2, 0, fg, 3)
       );
     case "wdUpDiag":
       return svg(
         12,
         12,
-        bgRect(12, 12) + line(0, 12, 12, 0, fg, 4) + line(-12, 12, 0, 0, fg, 4) + line(12, 12, 24, 0, fg, 4)
+        bgRect(12, 12) + line2(0, 12, 12, 0, fg, 4) + line2(-12, 12, 0, 0, fg, 4) + line2(12, 12, 24, 0, fg, 4)
       );
     case "dashUpDiag":
-      return svg(s, s, bgRect(s, s) + line(0, s, s, 0, fg, 1, ' stroke-dasharray="4,4"'));
+      return svg(s, s, bgRect(s, s) + line2(0, s, s, 0, fg, 1, ' stroke-dasharray="4,4"'));
     // ── Diagonal cross ───────────────────────────────────────────────
     case "diagCross":
       return svg(
         s,
         s,
-        bgRect(s, s) + line(0, 0, s, s, fg, 1) + line(-s, 0, 0, s, fg, 1) + line(s, 0, s * 2, s, fg, 1) + line(0, s, s, 0, fg, 1) + line(-s, s, 0, 0, fg, 1) + line(s, s, s * 2, 0, fg, 1)
+        bgRect(s, s) + line2(0, 0, s, s, fg, 1) + line2(-s, 0, 0, s, fg, 1) + line2(s, 0, s * 2, s, fg, 1) + line2(0, s, s, 0, fg, 1) + line2(-s, s, 0, 0, fg, 1) + line2(s, s, s * 2, 0, fg, 1)
       );
     // ── Checkerboard ─────────────────────────────────────────────────
     case "smCheck":
@@ -628,7 +640,7 @@ function getPatternSvg(preset, fg, bg) {
       return svg(
         s,
         s,
-        bgRect(s, s) + line(0, 4, 4, 0, fg, 1) + line(4, s, s, 4, fg, 1) + line(0, s, s, 0, fg, 1)
+        bgRect(s, s) + line2(0, 4, 4, 0, fg, 1) + line2(4, s, s, 4, fg, 1) + line2(0, s, s, 0, fg, 1)
       );
     // ── Diamond ──────────────────────────────────────────────────────
     case "solidDmnd":
@@ -637,7 +649,7 @@ function getPatternSvg(preset, fg, bg) {
       return svg(
         s,
         s,
-        bgRect(s, s) + line(4, 0, s, 4, fg, 1) + line(s, 4, 4, s, fg, 1) + line(4, s, 0, 4, fg, 1) + line(0, 4, 4, 0, fg, 1)
+        bgRect(s, s) + line2(4, 0, s, 4, fg, 1) + line2(s, 4, 4, s, fg, 1) + line2(4, s, 0, 4, fg, 1) + line2(0, 4, 4, 0, fg, 1)
       );
     case "dotDmnd":
       return svg(
@@ -662,21 +674,21 @@ function getPatternSvg(preset, fg, bg) {
       return svg(
         s,
         s,
-        bgRect(s, s) + line(0, 0, 4, 4, fg, 1.5) + line(4, 4, 0, s, fg, 1.5) + line(s, 0, 4, 4, fg, 1.5) + line(4, 4, s, s, fg, 1.5) + line(4, 0, s, 4, fg, 1.5) + line(0, 4, 4, s, fg, 1.5)
+        bgRect(s, s) + line2(0, 0, 4, 4, fg, 1.5) + line2(4, 4, 0, s, fg, 1.5) + line2(s, 0, 4, 4, fg, 1.5) + line2(4, 4, s, s, fg, 1.5) + line2(4, 0, s, 4, fg, 1.5) + line2(0, 4, 4, s, fg, 1.5)
       );
     // ── Divot ────────────────────────────────────────────────────────
     case "divot":
       return svg(
         s,
         s,
-        bgRect(s, s) + line(2, 1, 2, 3, fg, 1) + line(1, 2, 3, 2, fg, 1) + line(6, 5, 6, 7, fg, 1) + line(5, 6, 7, 6, fg, 1)
+        bgRect(s, s) + line2(2, 1, 2, 3, fg, 1) + line2(1, 2, 3, 2, fg, 1) + line2(6, 5, 6, 7, fg, 1) + line2(5, 6, 7, 6, fg, 1)
       );
     // ── Shingle ──────────────────────────────────────────────────────
     case "shingle":
       return svg(
         s,
         s,
-        bgRect(s, s) + line(0, 0, s, s, fg, 1) + line(0, s, 4, 4, fg, 1) + rect(0, 7, s, 1, fg)
+        bgRect(s, s) + line2(0, 0, s, s, fg, 1) + line2(0, s, 4, 4, fg, 1) + rect(0, 7, s, 1, fg)
       );
     // ── Wave ─────────────────────────────────────────────────────────
     case "wave":
@@ -975,7 +987,7 @@ var DEFAULT_SCHEME_COLOR_MAP = {
   phclr: "#4472C4"
 };
 function applyDrawingColorTransforms2(baseColor, colorNode) {
-  return chunkEXDUEXTO_js.applyDrawingColorTransforms(baseColor, colorNode);
+  return chunkAD3EAEY6_js.applyDrawingColorTransforms(baseColor, colorNode);
 }
 function parseDrawingColorChoice(colorNode, schemeColorOverrides) {
   if (!colorNode) {
@@ -1027,7 +1039,7 @@ function parseDrawingColorChoice(colorNode, schemeColorOverrides) {
       const h = hueRaw / 6e4;
       const s = clampUnitInterval(satRaw / 1e5);
       const l = clampUnitInterval(lumRaw / 1e5);
-      const rgb = chunkEXDUEXTO_js.hslToRgb(h, s, l);
+      const rgb = chunkAD3EAEY6_js.hslToRgb(h, s, l);
       const toHex = (value) => Math.min(255, Math.max(0, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
       const base = `#${toHex(rgb.r)}${toHex(rgb.g)}${toHex(rgb.b)}`;
       return applyDrawingColorTransforms2(base, hslNode);
@@ -1037,7 +1049,7 @@ function parseDrawingColorChoice(colorNode, schemeColorOverrides) {
     const preset = String(
       colorNode["a:prstClr"]?.["@_val"] || ""
     ).toLowerCase();
-    const mapped = chunkEXDUEXTO_js.PRESET_COLOR_MAP[preset];
+    const mapped = chunkAD3EAEY6_js.PRESET_COLOR_MAP[preset];
     if (!mapped) {
       return void 0;
     }
@@ -1363,14 +1375,36 @@ function buildReflectionCssValue(distance, startOpacity, endOpacity, fadeLength,
 function getDuotoneFilterId(elementId) {
   return `dag-duotone-${elementId}`;
 }
-function clamp(v, lo, hi) {
+function clamp(value, minimum, maximum) {
+  return Math.min(maximum, Math.max(minimum, value));
+}
+function buildImageBiLevelTable(threshold) {
+  const cutoff = clamp(threshold, 0, 100);
+  return Array.from({ length: 101 }, (_, index) => index >= cutoff ? "1" : "0").join(" ");
+}
+function buildImageLuminanceTransfer(amount) {
+  const normalized = clamp(amount / 100, -1, 1);
+  return normalized >= 0 ? { slope: 1 - normalized, intercept: normalized } : { slope: 1 + normalized, intercept: 0 };
+}
+function clamp2(v, lo, hi) {
   return v < lo ? lo : v > hi ? hi : v;
 }
 function normalizeRadius01(radius) {
-  return clamp(radius / 100, 0, 1);
+  return clamp2(radius / 100, 0, 1);
+}
+function hexToRgbUnit2(hex) {
+  const clean = hex.replace(/^#/u, "");
+  const r = parseInt(clean.substring(0, 2), 16) / 255;
+  const g = parseInt(clean.substring(2, 4), 16) / 255;
+  const b = parseInt(clean.substring(4, 6), 16) / 255;
+  return {
+    r: Number.isFinite(r) ? r : 0,
+    g: Number.isFinite(g) ? g : 0,
+    b: Number.isFinite(b) ? b : 0
+  };
 }
 function getEffects(element) {
-  if (!chunkEXDUEXTO_js.isImageLikeElement(element)) {
+  if (!chunkAD3EAEY6_js.isImageLikeElement(element)) {
     return void 0;
   }
   return element.imageEffects;
@@ -1458,10 +1492,6 @@ function getImageFilterCss(element, options) {
       filters.push(buildSimpleArtisticCss(effects.artisticEffect, radius));
     }
   }
-  if (typeof effects.biLevel === "number") {
-    const thresh = clamp(effects.biLevel, 0, 100);
-    filters.push(`grayscale(100%) contrast(1000%) brightness(${thresh}%)`);
-  }
   return filters.length > 0 ? filters.join(" ") : void 0;
 }
 var getImageEffectsFilter = getImageFilterCss;
@@ -1532,10 +1562,257 @@ function getImageEffectsOpacity(element) {
     return void 0;
   }
   if (typeof effects.alphaModFix === "number") {
-    return clamp(effects.alphaModFix / 100, 0, 1);
+    return clamp2(effects.alphaModFix / 100, 0, 1);
   }
   return void 0;
 }
+var GRAYSCALE_LUMINANCE_MATRIX = [
+  0.2126,
+  0.7152,
+  0.0722,
+  0,
+  0,
+  0.2126,
+  0.7152,
+  0.0722,
+  0,
+  0,
+  0.2126,
+  0.7152,
+  0.0722,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0
+].join(" ");
+function buildDuotoneFilterMarkup(color1, color2) {
+  const c1 = hexToRgbUnit2(color1);
+  const c2 = hexToRgbUnit2(color2);
+  return `<feColorMatrix type="matrix" values="${GRAYSCALE_LUMINANCE_MATRIX}"/><feComponentTransfer><feFuncR type="linear" slope="${c2.r - c1.r}" intercept="${c1.r}"/><feFuncG type="linear" slope="${c2.g - c1.g}" intercept="${c1.g}"/><feFuncB type="linear" slope="${c2.b - c1.b}" intercept="${c1.b}"/></feComponentTransfer>`;
+}
+function getDuotoneImageFilter(element, elementId = chunkAD3EAEY6_js.isImageLikeElement(element) ? element.id : "") {
+  const effects = getEffects(element);
+  if (!effects?.duotone) {
+    return void 0;
+  }
+  const id = getImageDuotoneFilterId(elementId);
+  return {
+    id,
+    cssReference: `url(#${id})`,
+    filterMarkup: buildDuotoneFilterMarkup(effects.duotone.color1, effects.duotone.color2)
+  };
+}
+function buildImageAlphaFilterMarkup(effects) {
+  const parts = [];
+  let resultIdx = 0;
+  let inputRef = "SourceGraphic";
+  const next = (build) => {
+    const output = `r${resultIdx++}`;
+    parts.push(build(inputRef, output));
+    inputRef = output;
+  };
+  if (typeof effects.alphaModFix === "number") {
+    const mul = clamp2(effects.alphaModFix / 100, 0, 1);
+    next(
+      (inp, out) => `<feColorMatrix in="${inp}" result="${out}" type="matrix" values="1 0 0 0 0  0 1 0 0 0  0 0 1 0 0  0 0 0 ${mul} 0"/>`
+    );
+  }
+  if (effects.alphaInv) {
+    next(
+      (inp, out) => `<feComponentTransfer in="${inp}" result="${out}"><feFuncA type="linear" slope="-1" intercept="1"/></feComponentTransfer>`
+    );
+  }
+  if (effects.alphaCeiling) {
+    next(
+      (inp, out) => `<feComponentTransfer in="${inp}" result="${out}"><feFuncA type="discrete" tableValues="0 1 1 1 1 1 1 1 1 1"/></feComponentTransfer>`
+    );
+  }
+  if (effects.alphaFloor) {
+    next(
+      (inp, out) => `<feComponentTransfer in="${inp}" result="${out}"><feFuncA type="discrete" tableValues="0 0 0 0 0 0 0 0 0 1"/></feComponentTransfer>`
+    );
+  }
+  if (typeof effects.alphaRepl === "number") {
+    const a = clamp2(effects.alphaRepl / 100, 0, 1);
+    next(
+      (inp, out) => `<feComponentTransfer in="${inp}" result="${out}"><feFuncA type="linear" slope="0" intercept="${a}"/></feComponentTransfer>`
+    );
+  }
+  if (typeof effects.alphaBiLevel === "number") {
+    const t = clamp2(effects.alphaBiLevel / 100, 0, 1);
+    const table = Array.from({ length: 10 }, (_, i) => i / 10 >= t ? "1" : "0").join(" ");
+    next(
+      (inp, out) => `<feComponentTransfer in="${inp}" result="${out}"><feFuncA type="discrete" tableValues="${table}"/></feComponentTransfer>`
+    );
+  }
+  if (typeof effects.biLevel === "number") {
+    next((inp, out) => `<feColorMatrix in="${inp}" result="${out}" type="saturate" values="0"/>`);
+    const tbl = buildImageBiLevelTable(effects.biLevel);
+    next(
+      (inp, out) => `<feComponentTransfer in="${inp}" result="${out}"><feFuncR type="discrete" tableValues="${tbl}"/><feFuncG type="discrete" tableValues="${tbl}"/><feFuncB type="discrete" tableValues="${tbl}"/></feComponentTransfer>`
+    );
+  }
+  if (effects.lum && (typeof effects.lum.bright === "number" || typeof effects.lum.contrast === "number")) {
+    const b = (effects.lum.bright ?? 0) / 100;
+    const c = 1 + (effects.lum.contrast ?? 0) / 100;
+    const slope = c;
+    const intercept = b + (1 - c) / 2;
+    next(
+      (inp, out) => `<feComponentTransfer in="${inp}" result="${out}"><feFuncR type="linear" slope="${slope}" intercept="${intercept}"/><feFuncG type="linear" slope="${slope}" intercept="${intercept}"/><feFuncB type="linear" slope="${slope}" intercept="${intercept}"/></feComponentTransfer>`
+    );
+  }
+  if (effects.hsl && typeof effects.hsl.sat === "number") {
+    const v = clamp2(1 + effects.hsl.sat / 100, 0, 2);
+    next(
+      (inp, out) => `<feColorMatrix in="${inp}" result="${out}" type="saturate" values="${v}"/>`
+    );
+  }
+  if (effects.hsl && typeof effects.hsl.lum === "number") {
+    const { slope, intercept } = buildImageLuminanceTransfer(effects.hsl.lum);
+    next(
+      (inp, out) => `<feComponentTransfer in="${inp}" result="${out}"><feFuncR type="linear" slope="${slope}" intercept="${intercept}"/><feFuncG type="linear" slope="${slope}" intercept="${intercept}"/><feFuncB type="linear" slope="${slope}" intercept="${intercept}"/></feComponentTransfer>`
+    );
+  }
+  if (effects.tint && typeof effects.tint.hue === "number") {
+    next(
+      (inp, out) => `<feColorMatrix in="${inp}" result="${out}" type="hueRotate" values="${effects.tint.hue}"/>`
+    );
+  }
+  if (effects.tint && typeof effects.tint.amt === "number") {
+    const { slope, intercept } = buildImageLuminanceTransfer(effects.tint.amt);
+    next(
+      (inp, out) => `<feComponentTransfer in="${inp}" result="${out}"><feFuncR type="linear" slope="${slope}" intercept="${intercept}"/><feFuncG type="linear" slope="${slope}" intercept="${intercept}"/><feFuncB type="linear" slope="${slope}" intercept="${intercept}"/></feComponentTransfer>`
+    );
+  }
+  if (effects.clrRepl) {
+    const c = hexToRgbUnit2(effects.clrRepl.color);
+    next(
+      (inp, out) => `<feColorMatrix in="${inp}" result="${out}" type="matrix" values="0 0 0 0 ${c.r}  0 0 0 0 ${c.g}  0 0 0 0 ${c.b}  0 0 0 1 0"/>`
+    );
+  }
+  return parts.length > 0 ? parts.join("") : void 0;
+}
+function getImageAlphaFilter(element, elementId = chunkAD3EAEY6_js.isImageLikeElement(element) ? element.id : "") {
+  const effects = getEffects(element);
+  if (!effects || !hasAdvancedImageAlphaEffects(element)) {
+    return void 0;
+  }
+  const markup = buildImageAlphaFilterMarkup(effects);
+  if (!markup) {
+    return void 0;
+  }
+  const id = getImageAlphaFilterId(elementId);
+  return { id, cssReference: `url(#${id})`, filterMarkup: markup };
+}
+function buildDiscreteTable(steps) {
+  const values = [];
+  for (let i = 0; i < steps; i++) {
+    const v = Math.round(i / (steps - 1) * 100) / 100;
+    const count = Math.ceil(256 / steps);
+    for (let j = 0; j < count; j++) {
+      values.push(v);
+    }
+  }
+  return values.slice(0, 256).join(" ");
+}
+function buildArtisticFilterMarkup(effectName, radius) {
+  const normalizedRadius = clamp2(radius, 0, 100) / 100;
+  switch (effectName) {
+    case "artisticFilmGrain":
+    case "filmGrain": {
+      const freq = 0.5 + normalizedRadius * 0.5;
+      const opacity = 0.15 + normalizedRadius * 0.25;
+      return `<feTurbulence type="fractalNoise" baseFrequency="${freq}" numOctaves="4" seed="1" stitchTiles="stitch" result="grain"/><feColorMatrix in="grain" type="saturate" values="0" result="grainGray"/><feBlend in="SourceGraphic" in2="grainGray" mode="overlay"/><feComponentTransfer><feFuncR type="linear" slope="${1 + opacity * 0.3}" intercept="${opacity * 0.02}"/><feFuncG type="linear" slope="${1 + opacity * 0.3}" intercept="${opacity * 0.02}"/><feFuncB type="linear" slope="${1 + opacity * 0.3}" intercept="${opacity * 0.02}"/></feComponentTransfer>`;
+    }
+    case "artisticCutout":
+    case "cutout": {
+      const steps = Math.max(2, Math.round(4 + normalizedRadius * 4));
+      const tableValues = buildDiscreteTable(steps);
+      return `<feComponentTransfer><feFuncR type="discrete" tableValues="${tableValues}"/><feFuncG type="discrete" tableValues="${tableValues}"/><feFuncB type="discrete" tableValues="${tableValues}"/></feComponentTransfer>`;
+    }
+    case "artisticCement":
+    case "cement": {
+      const freq = 1.5 + normalizedRadius * 2.5;
+      const desat = Math.max(0, 0.4 - normalizedRadius * 0.3);
+      return `<feColorMatrix type="saturate" values="${desat}" result="desat"/><feTurbulence type="fractalNoise" baseFrequency="${freq}" numOctaves="5" seed="2" stitchTiles="stitch" result="cementNoise"/><feColorMatrix in="cementNoise" type="saturate" values="0" result="cementGray"/><feBlend in="desat" in2="cementGray" mode="multiply"/><feComponentTransfer><feFuncR type="linear" slope="1.2" intercept="0"/><feFuncG type="linear" slope="1.2" intercept="0"/><feFuncB type="linear" slope="1.2" intercept="0"/></feComponentTransfer>`;
+    }
+    case "artisticTexturizer":
+    case "texturizer": {
+      const freq = 2 + normalizedRadius * 3;
+      return `<feTurbulence type="fractalNoise" baseFrequency="${freq}" numOctaves="3" seed="3" stitchTiles="stitch" result="texNoise"/><feColorMatrix in="texNoise" type="saturate" values="0" result="texGray"/><feBlend in="SourceGraphic" in2="texGray" mode="overlay"/><feComponentTransfer><feFuncR type="linear" slope="1.1" intercept="0.02"/><feFuncG type="linear" slope="1.1" intercept="0.02"/><feFuncB type="linear" slope="1.1" intercept="0.02"/></feComponentTransfer>`;
+    }
+    case "artisticCrisscrossEtching":
+    case "crisscrossEtching": {
+      const freq = 0.08 + normalizedRadius * 0.12;
+      return `<feColorMatrix type="saturate" values="0" result="gray"/><feTurbulence type="turbulence" baseFrequency="${freq} ${freq * 3}" numOctaves="1" seed="7" result="lines"/><feColorMatrix in="lines" type="saturate" values="0" result="linesGray"/><feBlend in="gray" in2="linesGray" mode="multiply"/><feComponentTransfer><feFuncR type="linear" slope="1.3" intercept="-0.05"/><feFuncG type="linear" slope="1.3" intercept="-0.05"/><feFuncB type="linear" slope="1.3" intercept="-0.05"/></feComponentTransfer>`;
+    }
+    case "artisticMosaic":
+    case "artisticMosaicBubbles":
+    case "mosaicBubbles":
+    case "mosaic": {
+      const blurAmount = Math.max(2, Math.round(radius * 0.8));
+      const freq = 0.02 + normalizedRadius * 0.03;
+      return `<feGaussianBlur in="SourceGraphic" stdDeviation="${blurAmount}" result="blurred"/><feTurbulence type="turbulence" baseFrequency="${freq}" numOctaves="1" seed="4" result="cells"/><feDisplacementMap in="blurred" in2="cells" scale="${blurAmount * 0.5}" xChannelSelector="R" yChannelSelector="G" result="mosaic"/><feComponentTransfer in="mosaic"><feFuncR type="linear" slope="1.05" intercept="0"/><feFuncG type="linear" slope="1.05" intercept="0"/><feFuncB type="linear" slope="1.05" intercept="0"/></feComponentTransfer>`;
+    }
+    case "artisticGlowEdges":
+    case "glowEdges":
+    case "glow_edges": {
+      const edgeBlur = Math.max(1, Math.round(normalizedRadius * 3));
+      return `<feColorMatrix type="matrix" values="-1 0 0 0 1  0 -1 0 0 1  0 0 -1 0 1  0 0 0 1 0" result="inverted"/><feGaussianBlur in="inverted" stdDeviation="${edgeBlur}" result="blurredInv"/><feBlend in="SourceGraphic" in2="blurredInv" mode="screen"/><feComponentTransfer><feFuncR type="linear" slope="2" intercept="-0.3"/><feFuncG type="linear" slope="2" intercept="-0.3"/><feFuncB type="linear" slope="2" intercept="-0.3"/></feComponentTransfer>`;
+    }
+    case "artisticChalkSketch":
+    case "chalkSketch":
+    case "chalk": {
+      const freq = 1 + normalizedRadius * 2;
+      const desat = Math.max(0, 0.2 - normalizedRadius * 0.2);
+      return `<feColorMatrix type="saturate" values="${desat}" result="gray"/><feTurbulence type="fractalNoise" baseFrequency="${freq}" numOctaves="4" seed="5" stitchTiles="stitch" result="chalkTex"/><feColorMatrix in="chalkTex" type="saturate" values="0" result="chalkGray"/><feBlend in="gray" in2="chalkGray" mode="overlay"/><feComponentTransfer><feFuncR type="linear" slope="1.5" intercept="0.05"/><feFuncG type="linear" slope="1.5" intercept="0.05"/><feFuncB type="linear" slope="1.5" intercept="0.05"/></feComponentTransfer>`;
+    }
+    case "artisticPencilSketch":
+    case "pencilSketch": {
+      const blurAmt = Math.max(3, Math.round(4 + normalizedRadius * 8));
+      return `<feColorMatrix type="saturate" values="0" result="gray"/><feColorMatrix in="gray" type="matrix" values="-1 0 0 0 1  0 -1 0 0 1  0 0 -1 0 1  0 0 0 1 0" result="invGray"/><feGaussianBlur in="invGray" stdDeviation="${blurAmt}" result="blurInv"/><feBlend in="blurInv" in2="gray" mode="screen" result="sketch"/><feComponentTransfer in="sketch"><feFuncR type="linear" slope="1.6" intercept="-0.15"/><feFuncG type="linear" slope="1.6" intercept="-0.15"/><feFuncB type="linear" slope="1.6" intercept="-0.15"/></feComponentTransfer>`;
+    }
+    case "artisticPencilGrayscale":
+    case "pencilGrayscale":
+    case "grayPencil": {
+      const sharpenBlur = Math.max(0.5, 1 + normalizedRadius * 2);
+      return `<feColorMatrix type="saturate" values="0" result="gray"/><feGaussianBlur in="gray" stdDeviation="${sharpenBlur}" result="grayBlur"/><feComposite in="gray" in2="grayBlur" operator="arithmetic" k1="0" k2="1.5" k3="-0.5" k4="0"/>`;
+    }
+    default:
+      return void 0;
+  }
+}
+function getArtisticImageFilter(element, elementId = chunkAD3EAEY6_js.isImageLikeElement(element) ? element.id : "") {
+  const effects = getEffects(element);
+  if (!effects?.artisticEffect || !needsSvgArtisticFilter(effects.artisticEffect)) {
+    return void 0;
+  }
+  const markup = buildArtisticFilterMarkup(effects.artisticEffect, effects.artisticRadius ?? 5);
+  if (!markup) {
+    return void 0;
+  }
+  const id = getArtisticFilterId(elementId);
+  return { id, cssReference: `url(#${id})`, filterMarkup: markup };
+}
+function getImageSvgFilters(element) {
+  const defs = [];
+  const duotone = getDuotoneImageFilter(element);
+  if (duotone) {
+    defs.push({ id: duotone.id, markup: duotone.filterMarkup });
+  }
+  const alpha = getImageAlphaFilter(element);
+  if (alpha) {
+    defs.push({ id: alpha.id, markup: alpha.filterMarkup });
+  }
+  const artistic = getArtisticImageFilter(element);
+  if (artistic) {
+    defs.push({ id: artistic.id, markup: artistic.filterMarkup });
+  }
+  return defs;
+}
 var NONE_PRESETS = /* @__PURE__ */ new Set(["textNoShape", "textPlain"]);
 var PATH_PRESETS = /* @__PURE__ */ new Set([
   "textArchUp",
@@ -3290,8 +3567,8 @@ function hexToRgb(hex) {
   ];
 }
 function rgbToHex(r, g, b) {
-  const clamp3 = (v) => Math.max(0, Math.min(255, Math.round(v)));
-  return `#${clamp3(r).toString(16).padStart(2, "0")}${clamp3(g).toString(16).padStart(2, "0")}${clamp3(b).toString(16).padStart(2, "0")}`;
+  const clamp7 = (v) => Math.max(0, Math.min(255, Math.round(v)));
+  return `#${clamp7(r).toString(16).padStart(2, "0")}${clamp7(g).toString(16).padStart(2, "0")}${clamp7(b).toString(16).padStart(2, "0")}`;
 }
 function tint(hex, amount) {
   const [r, g, b] = hexToRgb(hex);
@@ -3403,14 +3680,17 @@ function computeValueRange(series) {
 }
 function valueToY(val2, range, topY, bottomY) {
   const usable = bottomY - topY;
+  let ratio;
   if (range.logScale && range.logBase) {
     const base = range.logBase;
     const clampedVal = Math.max(val2, range.min);
     const logVal = Math.log(clampedVal) / Math.log(base);
     const logMin = Math.log(range.min) / Math.log(base);
-    return bottomY - (logVal - logMin) / range.span * usable;
+    ratio = (logVal - logMin) / range.span;
+  } else {
+    ratio = (val2 - range.min) / range.span;
   }
-  return bottomY - (val2 - range.min) / range.span * usable;
+  return range.reverseOrder ? topY + ratio * usable : bottomY - ratio * usable;
 }
 function formatAxisValue(val2) {
   if (Math.abs(val2) >= 1e6) {
@@ -3468,8 +3748,9 @@ function computeLayout(elementWidth, elementHeight, style, hasAxes, legendPos, o
     svgHeight
   };
 }
+var LOG_EXPONENT_TOLERANCE = 1e-12;
 function computeLogValueRange(series, logBase) {
-  const allValues = series.flatMap((s) => s.values).filter((v) => v > 0);
+  const allValues = series.flatMap((item) => item.values).filter((value) => value > 0);
   if (allValues.length === 0) {
     return { min: 1, max: logBase, span: 1, logScale: true, logBase };
   }
@@ -3479,15 +3760,34 @@ function computeLogValueRange(series, logBase) {
   const logMax = Math.ceil(Math.log(dataMax) / Math.log(logBase));
   const min = logBase ** logMin;
   const max = logBase ** Math.max(logMax, logMin + 1);
-  const logSpan = Math.log(max) / Math.log(logBase) - Math.log(min) / Math.log(logBase);
   return {
     min,
     max,
-    span: Math.max(logSpan, 1),
+    span: Math.max(Math.log(max) / Math.log(logBase) - Math.log(min) / Math.log(logBase), 1),
     logScale: true,
     logBase
   };
 }
+function computeValueRangeForAxis(series, axis) {
+  const requestedLogBase = axis?.logBase ?? 10;
+  const logBase = axis?.logScale && Number.isFinite(requestedLogBase) && requestedLogBase > 1 ? requestedLogBase : axis?.logScale ? 10 : void 0;
+  const automatic = logBase ? computeLogValueRange(series, logBase) : computeValueRange(series);
+  const validMin = typeof axis?.min === "number" && Number.isFinite(axis.min) && (!logBase || axis.min > 0) ? axis.min : void 0;
+  const validMax = typeof axis?.max === "number" && Number.isFinite(axis.max) && (!logBase || axis.max > 0) ? axis.max : void 0;
+  const min = validMin ?? automatic.min;
+  let max = validMax ?? automatic.max;
+  if (max <= min) {
+    max = logBase ? min * logBase : min + 1;
+  }
+  const span = logBase ? Math.log(max) / Math.log(logBase) - Math.log(min) / Math.log(logBase) : max - min;
+  return {
+    min,
+    max,
+    span: Math.max(span, Number.EPSILON),
+    ...logBase ? { logScale: true, logBase } : {},
+    ...axis?.orientation === "maxMin" ? { reverseOrder: true } : {}
+  };
+}
 function generateLogTicks(range) {
   if (!range.logScale || !range.logBase) {
     return [];
@@ -3495,21 +3795,56 @@ function generateLogTicks(range) {
   const base = range.logBase;
   const logMin = Math.log(range.min) / Math.log(base);
   const logMax = Math.log(range.max) / Math.log(base);
-  const ticks = [];
-  for (let exp = Math.round(logMin); exp <= Math.round(logMax); exp++) {
-    ticks.push(base ** exp);
+  const firstExponent = Math.ceil(logMin - LOG_EXPONENT_TOLERANCE);
+  const lastExponent = Math.floor(logMax + LOG_EXPONENT_TOLERANCE);
+  if (lastExponent < firstExponent) {
+    return range.min === range.max ? [range.min] : [range.min, range.max];
   }
-  return ticks;
+  return Array.from(
+    { length: lastExponent - firstExponent + 1 },
+    (_unused, index) => base ** (firstExponent + index)
+  );
 }
-function findLogAxis(axes) {
-  return axes?.find((a) => a.axisType === "valAx" && a.logScale);
+function generateIntervalTicks(range, unit) {
+  if (!Number.isFinite(unit) || unit <= 0 || range.logScale) {
+    return [];
+  }
+  const tolerance = Math.max(1, Math.abs(range.min), Math.abs(range.max)) * 1e-12;
+  const first = Math.ceil((range.min - tolerance) / unit);
+  const last = Math.floor((range.max + tolerance) / unit);
+  const count = Math.min(Math.max(last - first + 1, 0), 2e3);
+  return Array.from({ length: count }, (_, index) => (first + index) * unit);
 }
-function computeValueRangeForChart(series, axes) {
-  const logAxis = findLogAxis(axes);
-  if (logAxis?.logBase) {
-    return computeLogValueRange(series, logAxis.logBase);
+function generateAxisTicks(range, axis, defaultIntervals) {
+  if (range.logScale && range.logBase) {
+    return generateLogTicks(range);
+  }
+  const explicit = generateIntervalTicks(range, axis?.majorUnit ?? 0);
+  if (explicit.length > 0) {
+    return explicit;
+  }
+  return Array.from(
+    { length: defaultIntervals + 1 },
+    (_, index) => range.min + range.span / defaultIntervals * index
+  );
+}
+function generateMinorAxisTicks(range, axis) {
+  const minor = generateIntervalTicks(range, axis?.minorUnit ?? 0);
+  if (minor.length === 0) {
+    return [];
   }
-  return computeValueRange(series);
+  const majorUnit = axis?.majorUnit;
+  if (!majorUnit || !Number.isFinite(majorUnit) || majorUnit <= 0) {
+    return minor;
+  }
+  const tolerance = Math.max(1, Math.abs(range.min), Math.abs(range.max)) * 1e-10;
+  return minor.filter(
+    (value) => Math.abs(value / majorUnit - Math.round(value / majorUnit)) > tolerance
+  );
+}
+function computeValueRangeForChart(series, axes) {
+  const primaryAxis = axes?.find((axis) => axis.axisType === "valAx" && axis.axPos === "l") ?? axes?.find((axis) => axis.axisType === "valAx" && axis.axPos !== "r");
+  return computeValueRangeForAxis(series, primaryAxis);
 }
 var DISPLAY_UNIT_DIVISORS = {
   hundreds: 100,
@@ -3595,6 +3930,13 @@ function getSecondaryValueAxisId(axes) {
   const ax = getSecondaryValueAxis(axes);
   return ax?.axisId;
 }
+function getPrimaryValueAxisId(axes) {
+  if (!axes) {
+    return void 0;
+  }
+  const primary = axes.find((a) => a.axisType === "valAx" && a.axPos === "l");
+  return primary?.axisId ?? axes.find((a) => a.axisType === "valAx")?.axisId;
+}
 function isSeriesOnSecondaryAxis(series, axes) {
   if (!axes) {
     return false;
@@ -3620,41 +3962,199 @@ function splitSeriesByAxis(series, axes) {
   }
   return { primary, secondary };
 }
+function clamp3(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function horizontalAxisY(valueAxis, range, layout, fallback) {
+  if (valueAxis?.crosses === "max") {
+    return layout.plotTop;
+  }
+  if (valueAxis?.crosses === "min") {
+    return layout.plotBottom;
+  }
+  const crossingValue = valueAxis?.crossesAt ?? 0;
+  if (valueAxis?.crossesAt !== void 0 || valueAxis?.crosses === "autoZero") {
+    return valueToY2(
+      clamp3(crossingValue, range.min, range.max),
+      range,
+      layout.plotTop,
+      layout.plotBottom
+    );
+  }
+  return fallback === "top" ? layout.plotTop : layout.plotBottom;
+}
+function verticalAxisX(categoryAxis, categoryCount, layout, fallback, dateValues) {
+  if (categoryAxis?.crosses === "max") {
+    return layout.plotRight;
+  }
+  if (categoryAxis?.crosses === "min") {
+    return layout.plotLeft;
+  }
+  if (categoryAxis?.crossesAt !== void 0) {
+    if (categoryAxis.axisType === "dateAx" && dateValues?.length) {
+      const min = categoryAxis.min ?? Math.min(...dateValues);
+      const max = categoryAxis.max ?? Math.max(...dateValues);
+      const ratio2 = max === min ? 0.5 : (clamp3(categoryAxis.crossesAt, min, max) - min) / (max - min);
+      return layout.plotLeft + ratio2 * layout.plotWidth;
+    }
+    const index = clamp3(categoryAxis.crossesAt - 1, 0, Math.max(categoryCount - 1, 0));
+    const ratio = categoryCount <= 1 ? 0.5 : index / (categoryCount - 1);
+    return layout.plotLeft + ratio * layout.plotWidth;
+  }
+  return fallback === "right" ? layout.plotRight : layout.plotLeft;
+}
+var DEFAULT_COLOR2 = "#64748b";
+function dashArray(style, width) {
+  if (!style || style === "solid") {
+    return void 0;
+  }
+  const unit = Math.max(width, 1);
+  if (style === "dot" || style === "sysDot") {
+    return `${unit} ${unit * 2}`;
+  }
+  if (style === "lgDash") {
+    return `${unit * 6} ${unit * 3}`;
+  }
+  return `${unit * 3} ${unit * 2}`;
+}
+function chartAxisTextStyle(axis, defaultFontSize = 8) {
+  return {
+    fontSize: axis?.fontSize ?? defaultFontSize,
+    fill: axis?.fontColor ?? DEFAULT_COLOR2,
+    ...axis?.fontBold !== void 0 ? { fontWeight: axis.fontBold ? "bold" : "normal" } : {},
+    ...axis?.fontFamily ? { fontFamily: axis.fontFamily } : {}
+  };
+}
+function chartLineStyle(shape, fallbackColor = DEFAULT_COLOR2, fallbackWidth = 1) {
+  const strokeWidth = shape?.strokeWidth ?? fallbackWidth;
+  return {
+    stroke: shape?.strokeColor ?? fallbackColor,
+    strokeWidth,
+    ...dashArray(shape?.strokeDashStyle, strokeWidth) ? { dashArray: dashArray(shape?.strokeDashStyle, strokeWidth) } : {}
+  };
+}
+function buildVerticalTickMark(axisX, y, placement, side, length, shape) {
+  if (!placement || placement === "none") {
+    return void 0;
+  }
+  const inward = side === "left" ? 1 : -1;
+  const startOffset = placement === "cross" ? -inward * length : 0;
+  const endOffset = placement === "out" ? -inward * length : inward * length;
+  return {
+    kind: "line",
+    x1: axisX + startOffset,
+    y1: y,
+    x2: axisX + endOffset,
+    y2: y,
+    ...chartLineStyle(shape)
+  };
+}
+function buildVerticalAxisLine(axis, axisX, layout) {
+  return axis?.spPr ? {
+    kind: "line",
+    x1: axisX,
+    y1: layout.plotTop,
+    x2: axisX,
+    y2: layout.plotBottom,
+    ...chartLineStyle(axis.spPr)
+  } : void 0;
+}
+function buildStyledGridline(y, layout, shape, fallbackColor, fallbackWidth, fallbackDash, opacity) {
+  const style = chartLineStyle(shape, fallbackColor, fallbackWidth);
+  return {
+    kind: "line",
+    x1: layout.plotLeft,
+    y1: y,
+    x2: layout.plotRight,
+    y2: y,
+    ...style,
+    ...(shape ? style.dashArray : fallbackDash) ? { dashArray: shape ? style.dashArray : fallbackDash } : {},
+    ...opacity !== void 0 ? { opacity } : {}
+  };
+}
 var GRIDLINE_COLOR = "#e2e8f0";
-var AXIS_LABEL_COLOR = "#64748b";
 var SECONDARY_GRID_COLOR = "#e2e8f0";
 var TICK_COUNT = 5;
+var MAJOR_TICK_LENGTH = 4;
+var MINOR_TICK_LENGTH = 2.5;
+function valueAxisLabelPlacement(layout, position, defaultSide, axisX) {
+  if (!position || position === "nextTo") {
+    return defaultSide === "left" ? { x: axisX - 4, textAnchor: "end" } : { x: axisX + 4, textAnchor: "start" };
+  }
+  const side = position === "high" ? "right" : position === "low" ? "left" : defaultSide;
+  return side === "left" ? { x: layout.plotLeft - 4, textAnchor: "end" } : { x: layout.plotRight + 4, textAnchor: "start" };
+}
 function formatTick(val2, axis) {
   if (axis?.displayUnits) {
     return formatAxisValueWithUnits(val2, axis);
   }
   return formatAxisValue2(val2);
 }
-function buildPrimaryAxis(range, layout, axis) {
+function buildPrimaryAxis(range, layout, axis, axisX = layout.plotLeft) {
   const gridlines = [];
   const axisLabels = [];
-  const tickVals = range.logScale && range.logBase ? generateLogTicks(range) : Array.from({ length: TICK_COUNT + 1 }, (_, i) => range.min + range.span / TICK_COUNT * i);
+  const tickVals = generateAxisTicks(range, axis, TICK_COUNT);
+  const minorTickVals = generateMinorAxisTicks(range, axis);
+  const axisLine = buildVerticalAxisLine(axis, axisX, layout);
+  if (axisLine) {
+    gridlines.push(axisLine);
+  }
+  if (axis?.minorGridlines) {
+    for (const val2 of minorTickVals) {
+      const y = valueToY2(val2, range, layout.plotTop, layout.plotBottom);
+      gridlines.push(
+        buildStyledGridline(y, layout, axis.minorGridlinesSpPr, GRIDLINE_COLOR, 0.5, "1 2", 0.5)
+      );
+    }
+  }
+  for (const val2 of minorTickVals) {
+    const y = valueToY2(val2, range, layout.plotTop, layout.plotBottom);
+    const tick = buildVerticalTickMark(
+      axisX,
+      y,
+      axis?.minorTickMark,
+      "left",
+      MINOR_TICK_LENGTH,
+      axis?.spPr
+    );
+    if (tick) {
+      gridlines.push(tick);
+    }
+  }
   for (const val2 of tickVals) {
     const y = valueToY2(val2, range, layout.plotTop, layout.plotBottom);
-    gridlines.push({
-      kind: "line",
-      x1: layout.plotLeft,
-      y1: y,
-      x2: layout.plotRight,
-      y2: y,
-      stroke: GRIDLINE_COLOR,
-      strokeWidth: 1
-    });
-    axisLabels.push({
-      kind: "text",
-      x: layout.plotLeft - 4,
+    gridlines.push(
+      buildStyledGridline(
+        y,
+        layout,
+        axis?.majorGridlinesSpPr,
+        GRIDLINE_COLOR,
+        1,
+        void 0,
+        void 0
+      )
+    );
+    const tick = buildVerticalTickMark(
+      axisX,
       y,
-      text: formatTick(val2, axis),
-      fontSize: 8,
-      fill: AXIS_LABEL_COLOR,
-      textAnchor: "end",
-      dominantBaseline: "central"
-    });
+      axis?.majorTickMark,
+      "left",
+      MAJOR_TICK_LENGTH,
+      axis?.spPr
+    );
+    if (tick) {
+      gridlines.push(tick);
+    }
+    if (axis?.tickLblPos !== "none") {
+      axisLabels.push({
+        kind: "text",
+        ...valueAxisLabelPlacement(layout, axis?.tickLblPos, "left", axisX),
+        y,
+        text: formatTick(val2, axis),
+        ...chartAxisTextStyle(axis),
+        dominantBaseline: "central"
+      });
+    }
   }
   if (axis?.displayUnits) {
     const unitLabel = getDisplayUnitLabel(axis.displayUnits, axis.displayUnitsLabel);
@@ -3666,8 +4166,7 @@ function buildPrimaryAxis(range, layout, axis) {
         x: labelX,
         y: midY,
         text: unitLabel,
-        fontSize: 9,
-        fill: AXIS_LABEL_COLOR,
+        ...chartAxisTextStyle(axis, 9),
         textAnchor: "middle",
         transform: `rotate(-90, ${labelX}, ${midY})`
       });
@@ -3675,37 +4174,81 @@ function buildPrimaryAxis(range, layout, axis) {
   }
   return { gridlines, axisLabels };
 }
-function buildSecondaryAxis(range, layout, axis) {
+function buildSecondaryAxis(range, layout, axis, axisX = layout.plotRight) {
   const gridlines = [];
   const axisLabels = [];
-  const fontSize = axis?.fontSize ?? 8;
-  const fontColor = axis?.fontColor ?? AXIS_LABEL_COLOR;
-  const fontWeight = axis?.fontBold ? "bold" : "normal";
-  for (let i = 0; i <= TICK_COUNT - 1; i++) {
-    const val2 = range.min + range.span / (TICK_COUNT - 1) * i;
+  const textStyle = chartAxisTextStyle(axis);
+  const captionStyle = chartAxisTextStyle(axis, 9);
+  const axisLine = buildVerticalAxisLine(axis, axisX, layout);
+  if (axisLine) {
+    gridlines.push(axisLine);
+  }
+  const tickValues = generateAxisTicks(range, axis, TICK_COUNT - 1);
+  const minorTickValues = generateMinorAxisTicks(range, axis);
+  if (axis?.minorGridlines) {
+    for (const val2 of minorTickValues) {
+      const y = valueToY2(val2, range, layout.plotTop, layout.plotBottom);
+      gridlines.push(
+        buildStyledGridline(
+          y,
+          layout,
+          axis.minorGridlinesSpPr,
+          SECONDARY_GRID_COLOR,
+          0.5,
+          "1 2",
+          0.35
+        )
+      );
+    }
+  }
+  for (const val2 of minorTickValues) {
     const y = valueToY2(val2, range, layout.plotTop, layout.plotBottom);
-    gridlines.push({
-      kind: "line",
-      x1: layout.plotLeft,
-      y1: y,
-      x2: layout.plotRight,
-      y2: y,
-      stroke: SECONDARY_GRID_COLOR,
-      strokeWidth: 0.5,
-      dashArray: "2 3",
-      opacity: 0.5
-    });
-    axisLabels.push({
-      kind: "text",
-      x: layout.plotRight + 4,
+    const tick = buildVerticalTickMark(
+      axisX,
       y,
-      text: formatTick(val2, axis),
-      fontSize,
-      fill: fontColor,
-      textAnchor: "start",
-      fontWeight,
-      dominantBaseline: "central"
-    });
+      axis?.minorTickMark,
+      "right",
+      MINOR_TICK_LENGTH,
+      axis?.spPr
+    );
+    if (tick) {
+      gridlines.push(tick);
+    }
+  }
+  for (const val2 of tickValues) {
+    const y = valueToY2(val2, range, layout.plotTop, layout.plotBottom);
+    gridlines.push(
+      buildStyledGridline(
+        y,
+        layout,
+        axis?.majorGridlinesSpPr,
+        SECONDARY_GRID_COLOR,
+        0.5,
+        "2 3",
+        0.5
+      )
+    );
+    const tick = buildVerticalTickMark(
+      axisX,
+      y,
+      axis?.majorTickMark,
+      "right",
+      MAJOR_TICK_LENGTH,
+      axis?.spPr
+    );
+    if (tick) {
+      gridlines.push(tick);
+    }
+    if (axis?.tickLblPos !== "none") {
+      axisLabels.push({
+        kind: "text",
+        ...valueAxisLabelPlacement(layout, axis?.tickLblPos, "right", axisX),
+        y,
+        text: formatTick(val2, axis),
+        ...textStyle,
+        dominantBaseline: "central"
+      });
+    }
   }
   if (axis?.titleText) {
     const titleX = layout.plotRight + 36;
@@ -3715,8 +4258,7 @@ function buildSecondaryAxis(range, layout, axis) {
       x: titleX,
       y: midY,
       text: axis.titleText,
-      fontSize: 9,
-      fill: fontColor,
+      ...captionStyle,
       textAnchor: "middle",
       transform: `rotate(-90, ${titleX}, ${midY})`
     });
@@ -3731,8 +4273,7 @@ function buildSecondaryAxis(range, layout, axis) {
         x: labelX,
         y: midY,
         text: unitLabel,
-        fontSize: 9,
-        fill: fontColor,
+        ...captionStyle,
         textAnchor: "middle",
         transform: `rotate(-90, ${labelX}, ${midY})`
       });
@@ -3740,13 +4281,60 @@ function buildSecondaryAxis(range, layout, axis) {
   }
   return { gridlines, axisLabels };
 }
+function hasRicherAxisFeatures(chartData) {
+  return Boolean(
+    chartData.dataTable || chartData.axes?.some(
+      (axis) => axis.crosses !== void 0 || axis.crossesAt !== void 0 || axis.crossBetween !== void 0 || axis.axisType === "valAx" && Boolean(
+        axis.logScale || axis.displayUnits || axis.axPos === "r" || axis.orientation === "maxMin" || axis.majorUnit !== void 0 || axis.minorUnit !== void 0 || axis.minorGridlines || axis.majorTickMark !== void 0 || axis.minorTickMark !== void 0 || axis.tickLblPos !== void 0
+      )
+    )
+  );
+}
+function buildCartesianAxes(chartData, layout, primaryRange, secondaryRange, categoryCount) {
+  if (!hasRicherAxisFeatures(chartData)) {
+    const { gridlines, axisLabels } = buildGridlinesAndLabels(primaryRange, layout);
+    return { gridlines, axisLabels, secondaryGridlines: void 0, secondaryAxisLabels: void 0 };
+  }
+  const primaryAxis = chartData.axes?.find((axis) => axis.axisType === "valAx" && axis.axPos !== "r") ?? chartData.axes?.find((axis) => axis.axisType === "valAx");
+  const categoryAxisFor = (axisId) => chartData.axes?.find(
+    (axis) => (axis.axisType === "catAx" || axis.axisType === "dateAx") && axis.axisId === axisId
+  );
+  const axisX = (axisId, fallback) => verticalAxisX(
+    categoryAxisFor(axisId),
+    categoryCount,
+    layout,
+    fallback,
+    chartData.dateCategories?.values
+  );
+  const primary = buildPrimaryAxis(
+    primaryRange,
+    layout,
+    primaryAxis,
+    axisX(primaryAxis?.crossAxisId, "left")
+  );
+  if (!secondaryRange) {
+    return { ...primary, secondaryGridlines: void 0, secondaryAxisLabels: void 0 };
+  }
+  const secondaryAxis = getSecondaryValueAxis(chartData.axes);
+  const secondary = buildSecondaryAxis(
+    secondaryRange,
+    layout,
+    secondaryAxis,
+    axisX(secondaryAxis?.crossAxisId, "right")
+  );
+  return {
+    ...primary,
+    secondaryGridlines: secondary.gridlines,
+    secondaryAxisLabels: secondary.axisLabels
+  };
+}
 function categoryTotals(series, catCount) {
   return Array.from(
     { length: catCount },
     (_, ci) => series.reduce((sum, s) => sum + Math.abs(s.values[ci] ?? 0), 0)
   );
 }
-function buildBars(chartData, catCount, layout, primaryRange, secondaryRange, secondaryIdx, grouping) {
+function buildBars(chartData, catCount, layout, primaryRange, secondaryRange, secondaryIdx, grouping, sourceIndices2) {
   const primitives = [];
   const dataLabels = [];
   const series = chartData.series;
@@ -3757,10 +4345,11 @@ function buildBars(chartData, catCount, layout, primaryRange, secondaryRange, se
     const barGroupWidth2 = layout.plotWidth / Math.max(catCount, 1);
     const singleBarWidth = barGroupWidth2 * 0.7 / seriesCount;
     const groupOffset = (barGroupWidth2 - singleBarWidth * seriesCount) / 2;
-    for (let ci = 0; ci < catCount; ci++) {
+    for (let displayIndex = 0; displayIndex < catCount; displayIndex++) {
+      const sourceIndex = sourceIndices2[displayIndex] ?? displayIndex;
       for (let si = 0; si < series.length; si++) {
-        const val2 = series[si].values[ci] ?? 0;
-        const x = layout.plotLeft + barGroupWidth2 * ci + groupOffset + singleBarWidth * si;
+        const val2 = series[si].values[sourceIndex] ?? 0;
+        const x = layout.plotLeft + barGroupWidth2 * displayIndex + groupOffset + singleBarWidth * si;
         const activeRange = secondaryIdx.has(si) && secondaryRange ? secondaryRange : primaryRange;
         const zeroY = valueToY2(0, activeRange, layout.plotTop, layout.plotBottom);
         const valY = valueToY2(val2, activeRange, layout.plotTop, layout.plotBottom);
@@ -3774,7 +4363,7 @@ function buildBars(chartData, catCount, layout, primaryRange, secondaryRange, se
           h,
           fill: seriesColor2(series[si], si, palette),
           rx: 1,
-          part: { role: "dataPoint", seriesIndex: si, pointIndex: ci }
+          part: { role: "dataPoint", seriesIndex: si, pointIndex: sourceIndex }
         });
         if (showLabels) {
           dataLabels.push({
@@ -3792,7 +4381,11 @@ function buildBars(chartData, catCount, layout, primaryRange, secondaryRange, se
     return { primitives, dataLabels };
   }
   if (grouping === "stacked") {
-    const rects = computeStackedBarRects(series, catCount, layout, primaryRange, palette);
+    const displaySeries2 = series.map((entry) => ({
+      ...entry,
+      values: sourceIndices2.map((sourceIndex) => entry.values[sourceIndex] ?? 0)
+    }));
+    const rects = computeStackedBarRects(displaySeries2, catCount, layout, primaryRange, palette);
     for (const r of rects) {
       primitives.push({
         kind: "rect",
@@ -3802,24 +4395,33 @@ function buildBars(chartData, catCount, layout, primaryRange, secondaryRange, se
         h: r.h,
         fill: r.fill,
         rx: 1,
-        part: r.seriesIndex !== void 0 && r.pointIndex !== void 0 ? { role: "dataPoint", seriesIndex: r.seriesIndex, pointIndex: r.pointIndex } : void 0
+        part: r.seriesIndex !== void 0 && r.pointIndex !== void 0 ? {
+          role: "dataPoint",
+          seriesIndex: r.seriesIndex,
+          pointIndex: sourceIndices2[r.pointIndex] ?? r.pointIndex
+        } : void 0
       });
     }
     if (showLabels) {
-      pushClusteredStackedLabels(series, catCount, layout, primaryRange, dataLabels);
+      pushClusteredStackedLabels(series, sourceIndices2, catCount, layout, primaryRange, dataLabels);
     }
     return { primitives, dataLabels };
   }
   const barGroupWidth = layout.plotWidth / Math.max(catCount, 1);
   const barW = barGroupWidth * 0.6;
   const barOffset = (barGroupWidth - barW) / 2;
-  const totals = categoryTotals(series, catCount);
+  const displaySeries = series.map((entry) => ({
+    ...entry,
+    values: sourceIndices2.map((sourceIndex) => entry.values[sourceIndex] ?? 0)
+  }));
+  const totals = categoryTotals(displaySeries, catCount);
   for (let ci = 0; ci < catCount; ci++) {
     let posRunning = 0;
     let negRunning = 0;
     const catTotal = totals[ci] || 1;
     for (let si = 0; si < series.length; si++) {
-      const rawVal = series[si].values[ci] ?? 0;
+      const sourceIndex = sourceIndices2[ci] ?? ci;
+      const rawVal = series[si].values[sourceIndex] ?? 0;
       const val2 = catTotal > 0 ? rawVal / catTotal * 100 : 0;
       const isNeg = val2 < 0;
       const base = isNeg ? negRunning : posRunning;
@@ -3836,7 +4438,7 @@ function buildBars(chartData, catCount, layout, primaryRange, secondaryRange, se
         w: barW,
         h,
         fill: seriesColor2(series[si], si, palette),
-        part: { role: "dataPoint", seriesIndex: si, pointIndex: ci }
+        part: { role: "dataPoint", seriesIndex: si, pointIndex: sourceIndex }
       });
       if (showLabels && Math.abs(val2) > 0) {
         dataLabels.push({
@@ -3859,14 +4461,15 @@ function buildBars(chartData, catCount, layout, primaryRange, secondaryRange, se
   }
   return { primitives, dataLabels };
 }
-function pushClusteredStackedLabels(series, catCount, layout, range, dataLabels) {
+function pushClusteredStackedLabels(series, sourceIndices2, catCount, layout, range, dataLabels) {
   const barGroupWidth = layout.plotWidth / catCount;
   const seriesCount = Math.max(series.length, 1);
   const singleBarWidth = barGroupWidth * 0.7 / seriesCount;
   const groupOffset = (barGroupWidth - singleBarWidth * seriesCount) / 2;
   for (let ci = 0; ci < catCount; ci++) {
+    const sourceIndex = sourceIndices2[ci] ?? ci;
     for (let si = 0; si < series.length; si++) {
-      const val2 = series[si].values[ci] ?? 0;
+      const val2 = series[si].values[sourceIndex] ?? 0;
       const x = layout.plotLeft + barGroupWidth * ci + groupOffset + singleBarWidth * si + singleBarWidth / 2;
       const zeroY = valueToY2(0, range, layout.plotTop, layout.plotBottom);
       const valY = valueToY2(val2, range, layout.plotTop, layout.plotBottom);
@@ -3883,7 +4486,7 @@ function pushClusteredStackedLabels(series, catCount, layout, range, dataLabels)
     }
   }
 }
-function buildLines(chartData, catCount, layout, primaryRange, secondaryRange, secondaryIdx) {
+function buildLines(chartData, catCount, layout, primaryRange, secondaryRange, secondaryIdx, sourceIndices2, xPositions) {
   const primitives = [];
   const dataLabels = [];
   const showLabels = chartData.style?.hasDataLabels;
@@ -3893,7 +4496,13 @@ function buildLines(chartData, catCount, layout, primaryRange, secondaryRange, s
       continue;
     }
     const activeRange = secondaryIdx.has(si) && secondaryRange ? secondaryRange : primaryRange;
-    const pts = computeLinePoints(series.values, catCount, layout, activeRange);
+    const displayValues = sourceIndices2.map((sourceIndex) => series.values[sourceIndex] ?? 0);
+    const pts = computeLinePoints(displayValues, catCount, layout, activeRange).map(
+      (point, index) => ({
+        ...point,
+        x: xPositions?.[index] ?? point.x
+      })
+    );
     const c = seriesColor2(series, si, chartData.colorPalette);
     primitives.push({
       kind: "polyline",
@@ -3903,19 +4512,20 @@ function buildLines(chartData, catCount, layout, primaryRange, secondaryRange, s
       fill: "none",
       part: { role: "series", seriesIndex: si }
     });
-    pts.forEach((pt, vi) => {
+    pts.forEach((pt, displayIndex) => {
+      const sourceIndex = sourceIndices2[displayIndex] ?? displayIndex;
       primitives.push({
         kind: "circle",
         cx: pt.x,
         cy: pt.y,
         r: 2.5,
         fill: c,
-        part: { role: "dataPoint", seriesIndex: si, pointIndex: vi }
+        part: { role: "dataPoint", seriesIndex: si, pointIndex: sourceIndex }
       });
     });
     if (showLabels) {
-      series.values.forEach((val2, vi) => {
-        const pt = pts[vi];
+      displayValues.forEach((val2, displayIndex) => {
+        const pt = pts[displayIndex];
         if (!pt) {
           return;
         }
@@ -3933,7 +4543,7 @@ function buildLines(chartData, catCount, layout, primaryRange, secondaryRange, s
   }
   return { primitives, dataLabels };
 }
-function buildAreas(chartData, catCount, layout, range) {
+function buildAreas(chartData, catCount, layout, range, sourceIndices2, xPositions) {
   const primitives = [];
   const dataLabels = [];
   const showLabels = chartData.style?.hasDataLabels;
@@ -3943,7 +4553,11 @@ function buildAreas(chartData, catCount, layout, range) {
     if (series.values.length === 0) {
       continue;
     }
-    const pts = computeLinePoints(series.values, catCount, layout, range);
+    const displayValues = sourceIndices2.map((sourceIndex) => series.values[sourceIndex] ?? 0);
+    const pts = computeLinePoints(displayValues, catCount, layout, range).map((point, index) => ({
+      ...point,
+      x: xPositions?.[index] ?? point.x
+    }));
     const c = seriesColor2(series, si, chartData.colorPalette);
     const lineStr = linePointsToSvgString(pts);
     const firstPt = pts[0];
@@ -3951,7 +4565,7 @@ function buildAreas(chartData, catCount, layout, range) {
     if (firstPt && lastPt) {
       primitives.push({
         kind: "polyline",
-        points: `${layout.plotLeft.toFixed(2)},${baselineY.toFixed(2)} ${lineStr} ${lastPt.x.toFixed(2)},${baselineY.toFixed(2)}`,
+        points: `${firstPt.x.toFixed(2)},${baselineY.toFixed(2)} ${lineStr} ${lastPt.x.toFixed(2)},${baselineY.toFixed(2)}`,
         stroke: "none",
         strokeWidth: 0,
         fill: c,
@@ -3967,9 +4581,23 @@ function buildAreas(chartData, catCount, layout, range) {
       fill: "none",
       part: { role: "series", seriesIndex: si }
     });
+    pts.forEach((pt, displayIndex) => {
+      primitives.push({
+        kind: "circle",
+        cx: pt.x,
+        cy: pt.y,
+        r: 2,
+        fill: c,
+        part: {
+          role: "dataPoint",
+          seriesIndex: si,
+          pointIndex: sourceIndices2[displayIndex] ?? displayIndex
+        }
+      });
+    });
     if (showLabels) {
-      series.values.forEach((val2, vi) => {
-        const pt = pts[vi];
+      displayValues.forEach((val2, displayIndex) => {
+        const pt = pts[displayIndex];
         if (!pt) {
           return;
         }
@@ -3993,10 +4621,11 @@ function buildScatter(chartData, layout, range) {
   const showLabels = chartData.style?.hasDataLabels;
   const allIndices = chartData.series.flatMap((s) => s.values.map((_, i) => i));
   const maxXIndex = Math.max(1, ...allIndices);
+  const xValues = chartData.categories.map(Number);
   for (let si = 0; si < chartData.series.length; si++) {
     const series = chartData.series[si];
     const c = seriesColor2(series, si, chartData.colorPalette);
-    const dots = computeScatterDots(series.values, maxXIndex, layout, range);
+    const dots = computeScatterDots(series.values, maxXIndex, layout, range, xValues);
     dots.forEach((dot, vi) => {
       primitives.push({
         kind: "circle",
@@ -4034,6 +4663,7 @@ function buildBubbles(chartData, layout, range) {
   const showLabels = chartData.style?.hasDataLabels;
   const allIndices = chartData.series.flatMap((s) => s.values.map((_, i) => i));
   const maxXIndex = Math.max(1, ...allIndices);
+  const xValues = chartData.categories.map(Number);
   const sizeSeries = chartData.series.length >= 3 ? chartData.series[2] : void 0;
   const maxBubble = sizeSeries ? Math.max(1, ...sizeSeries.values.map((v) => Math.abs(v))) : 1;
   const medianRadius = Math.min(layout.plotWidth, layout.plotHeight) * 0.04;
@@ -4041,7 +4671,7 @@ function buildBubbles(chartData, layout, range) {
   for (let si = 0; si < pointSeries.length; si++) {
     const series = pointSeries[si];
     const c = seriesColor2(series, si, chartData.colorPalette);
-    const dots = computeScatterDots(series.values, maxXIndex, layout, range);
+    const dots = computeScatterDots(series.values, maxXIndex, layout, range, xValues);
     dots.forEach((dot, vi) => {
       const r = computeBubbleRadius(sizeSeries?.values[vi], maxBubble, medianRadius);
       primitives.push({
@@ -4074,12 +4704,527 @@ function buildBubbles(chartData, layout, range) {
   }
   return { primitives, dataLabels };
 }
-function xToPixel2(xVal, catCount, layout, mode) {
-  if (mode === "bar") {
-    const slotWidth = layout.plotWidth / Math.max(catCount, 1);
-    return layout.plotLeft + slotWidth * xVal + slotWidth / 2;
+function categoryX(displayIndex, count, layout, spacing) {
+  if (spacing === "bar") {
+    return layout.plotLeft + layout.plotWidth / Math.max(count, 1) * (displayIndex + 0.5);
   }
-  const maxIdx = Math.max(catCount - 1, 1);
+  return count > 1 ? layout.plotLeft + layout.plotWidth / (count - 1) * displayIndex : layout.plotLeft + layout.plotWidth / 2;
+}
+function groupedLabels(values) {
+  const groups = [];
+  values.forEach((text, index) => {
+    const previous = groups[groups.length - 1];
+    if (previous?.text === text) {
+      previous.end = index;
+    } else {
+      groups.push({ text, start: index, end: index });
+    }
+  });
+  return groups;
+}
+function buildMultiLevelCategoryLabels(categoryLabels, categoryLevels, sourceIndices2, layout, spacing, axis, labelY, labelsAbove, offset) {
+  const sourceLevels = categoryLevels?.length ? categoryLevels : [categoryLabels];
+  const levels = axis?.noMultiLevelLabels ? sourceLevels.slice(0, 1) : sourceLevels;
+  const skip = Math.max(1, axis?.tickLabelSkip ?? 1);
+  const textAnchor = axis?.labelAlignment === "l" ? "start" : axis?.labelAlignment === "r" ? "end" : "middle";
+  const direction = labelsAbove ? -1 : 1;
+  const bandHeight = Math.max(axis?.fontSize ?? 8, 8) + 4;
+  return levels.flatMap((level, levelIndex) => {
+    const values = sourceIndices2.map((sourceIndex) => level[sourceIndex] ?? "");
+    return groupedLabels(values).flatMap((group) => {
+      if (!group.text || group.start % skip !== 0) {
+        return [];
+      }
+      const startX = categoryX(group.start, sourceIndices2.length, layout, spacing);
+      const endX = categoryX(group.end, sourceIndices2.length, layout, spacing);
+      return [
+        {
+          kind: "text",
+          x: (startX + endX) / 2,
+          y: labelY + direction * (offset + levelIndex * bandHeight),
+          text: group.text,
+          textAnchor,
+          ...chartAxisTextStyle(axis)
+        }
+      ];
+    });
+  });
+}
+function primaryCategoryAxis(axes) {
+  const categoryAxes = axes?.filter(
+    (axis) => axis.axisType === "catAx" || axis.axisType === "dateAx"
+  );
+  return categoryAxes?.find((axis) => axis.axPos !== "t") ?? categoryAxes?.[0];
+}
+function tickLine(x, y, placement, topAxis, length, axis) {
+  if (!placement || placement === "none") {
+    return void 0;
+  }
+  const inward = topAxis ? length : -length;
+  const outward = -inward;
+  const [start, end] = placement === "cross" ? [-length, length] : placement === "in" ? [0, inward] : [0, outward];
+  return {
+    kind: "line",
+    x1: x,
+    y1: y + start,
+    x2: x,
+    y2: y + end,
+    ...chartLineStyle(axis.spPr)
+  };
+}
+function buildTickMarks(axis, sourceCount, layout, spacing, axisY) {
+  if (!axis || axis.deleted) {
+    return [];
+  }
+  const result = [];
+  const topAxis = axis.axPos === "t";
+  const y = axisY ?? (topAxis ? layout.plotTop : layout.plotBottom);
+  if (axis.spPr) {
+    result.push({
+      kind: "line",
+      x1: layout.plotLeft,
+      y1: y,
+      x2: layout.plotRight,
+      y2: y,
+      ...chartLineStyle(axis.spPr)
+    });
+  }
+  const majorSkip = Math.max(1, axis.tickMarkSkip ?? 1);
+  for (let displayIndex = 0; displayIndex < sourceCount; displayIndex += majorSkip) {
+    const x = categoryX(displayIndex, sourceCount, layout, spacing);
+    const major = tickLine(x, y, axis.majorTickMark, topAxis, 4, axis);
+    if (major) {
+      result.push(major);
+    }
+    if (axis.minorTickMark !== void 0 && displayIndex + majorSkip < sourceCount) {
+      const nextX = categoryX(displayIndex + majorSkip, sourceCount, layout, spacing);
+      const minor = tickLine((x + nextX) / 2, y, axis.minorTickMark, topAxis, 2.5, axis);
+      if (minor) {
+        result.push(minor);
+      }
+    }
+  }
+  return result;
+}
+function buildCategoryAxisPlan(categoryLabels, layout, spacing, axes, selectedAxis, axisY, categoryLevels) {
+  const axis = selectedAxis ?? primaryCategoryAxis(axes);
+  const sourceIndices2 = categoryLabels.map((_label, index) => index);
+  if (axis?.orientation === "maxMin") {
+    sourceIndices2.reverse();
+  }
+  if (axis?.deleted || axis?.tickLblPos === "none") {
+    return {
+      axis,
+      sourceIndices: sourceIndices2,
+      labels: [],
+      tickMarks: buildTickMarks(axis, sourceIndices2.length, layout, spacing, axisY)
+    };
+  }
+  const topAxis = axis?.axPos === "t";
+  const high = axis?.tickLblPos === "high";
+  const low = axis?.tickLblPos === "low";
+  const labelsAbove = high || !low && topAxis;
+  const offset = 4 + 8 * ((axis?.labelOffset ?? 100) / 100);
+  const labelY = high ? layout.plotTop : low ? layout.plotBottom : axisY ?? (topAxis ? layout.plotTop : layout.plotBottom);
+  const labels = buildMultiLevelCategoryLabels(
+    categoryLabels,
+    categoryLevels,
+    sourceIndices2,
+    layout,
+    spacing,
+    axis,
+    labelY,
+    labelsAbove,
+    offset
+  );
+  return {
+    axis,
+    sourceIndices: sourceIndices2,
+    labels,
+    tickMarks: buildTickMarks(axis, sourceIndices2.length, layout, spacing, axisY)
+  };
+}
+function chartDataInCategoryOrder(chartData, sourceIndices2) {
+  if (sourceIndices2.every((sourceIndex, displayIndex) => sourceIndex === displayIndex)) {
+    return chartData;
+  }
+  return {
+    ...chartData,
+    categories: sourceIndices2.map((sourceIndex) => chartData.categories[sourceIndex] ?? ""),
+    categoryLevels: chartData.categoryLevels?.map(
+      (level) => sourceIndices2.map((sourceIndex) => level[sourceIndex] ?? "")
+    ),
+    series: chartData.series.map((series) => ({
+      ...series,
+      values: sourceIndices2.map((sourceIndex) => series.values[sourceIndex] ?? 0),
+      errBars: series.errBars?.map((errorBars) => ({
+        ...errorBars,
+        customPlus: errorBars.customPlus ? sourceIndices2.map((sourceIndex) => errorBars.customPlus?.[sourceIndex] ?? 0) : void 0,
+        customMinus: errorBars.customMinus ? sourceIndices2.map((sourceIndex) => errorBars.customMinus?.[sourceIndex] ?? 0) : void 0
+      }))
+    }))
+  };
+}
+var DAY_MS = 864e5;
+function excelSerialToDate(serial, date1904 = false) {
+  const epoch = date1904 ? Date.UTC(1904, 0, 1) : Date.UTC(1899, 11, serial < 60 ? 31 : 30);
+  return new Date(epoch + serial * DAY_MS);
+}
+function primaryDateAxis(chartData) {
+  return chartData.axes?.find((axis) => axis.axisType === "dateAx" && axis.axPos !== "t") ?? chartData.axes?.find((axis) => axis.axisType === "dateAx");
+}
+function serialToX(serial, min, max, layout) {
+  const ratio = max === min ? 0.5 : (serial - min) / (max - min);
+  return layout.plotLeft + ratio * layout.plotWidth;
+}
+function addUnit(date, amount, unit) {
+  const next = new Date(date);
+  if (unit === "days") {
+    next.setUTCDate(next.getUTCDate() + amount);
+  } else if (unit === "months") {
+    next.setUTCMonth(next.getUTCMonth() + amount);
+  } else {
+    next.setUTCFullYear(next.getUTCFullYear() + amount);
+  }
+  return next;
+}
+function formatDate(date, unit, format) {
+  const month = date.toLocaleString("en-US", { month: "short", timeZone: "UTC" });
+  const year = String(date.getUTCFullYear());
+  const day = String(date.getUTCDate());
+  if (format?.toLowerCase().includes("yyyy")) {
+    return format.toLowerCase().includes("d") ? `${day} ${month} ${year}` : `${month} ${year}`;
+  }
+  if (unit === "years") {
+    return year;
+  }
+  if (unit === "months") {
+    return `${month} ${year}`;
+  }
+  return `${day} ${month}`;
+}
+function tickLine2(x, y, axis, minor) {
+  const placement = minor ? axis.minorTickMark : axis.majorTickMark;
+  if (!placement || placement === "none") {
+    return void 0;
+  }
+  const length = minor ? 2.5 : 4;
+  const direction = axis.axPos === "t" ? 1 : -1;
+  const inward = direction * length;
+  const outward = -inward;
+  const [start, end] = placement === "cross" ? [-length, length] : placement === "in" ? [0, inward] : [0, outward];
+  return {
+    kind: "line",
+    x1: x,
+    y1: y + start,
+    x2: x,
+    y2: y + end,
+    ...chartLineStyle(axis.spPr)
+  };
+}
+function calendarTicks(min, max, date1904, unit, step) {
+  const result = [];
+  let date = excelSerialToDate(min, date1904);
+  for (let guard = 0; guard < 1e3 && date.getTime() <= excelSerialToDate(max, date1904).getTime(); guard++) {
+    result.push(min + (date.getTime() - excelSerialToDate(min, date1904).getTime()) / DAY_MS);
+    date = addUnit(date, step, unit);
+  }
+  return result;
+}
+function buildDateAxisPlan(chartData, layout, selectedAxis, axisY) {
+  const dates = chartData.dateCategories;
+  const axis = selectedAxis ?? primaryDateAxis(chartData);
+  if (!dates || !axis || dates.values.length === 0) {
+    return void 0;
+  }
+  const indexed = dates.values.map((value, index) => ({ value, index })).sort((a, b) => a.value - b.value);
+  const dataMin = indexed[0]?.value ?? 0;
+  const dataMax = indexed[indexed.length - 1]?.value ?? dataMin;
+  const min = axis.min ?? dataMin;
+  const max = axis.max ?? dataMax;
+  const visible = indexed.filter(({ value }) => value >= min && value <= max);
+  if (axis.orientation === "maxMin") {
+    visible.reverse();
+  }
+  const sourceIndices2 = visible.map(({ index }) => index);
+  const xPositions = visible.map(({ value }) => {
+    const x = serialToX(value, min, max, layout);
+    return axis.orientation === "maxMin" ? layout.plotLeft + layout.plotWidth - (x - layout.plotLeft) : x;
+  });
+  const unit = axis.majorTimeUnit ?? axis.baseTimeUnit ?? "days";
+  const ticks = calendarTicks(
+    min,
+    max,
+    dates.date1904 ?? false,
+    unit,
+    Math.max(1, axis.majorUnit ?? 1)
+  );
+  const y = axisY ?? (axis.axPos === "t" ? layout.plotTop : layout.plotBottom);
+  const offset = 4 + 8 * ((axis.labelOffset ?? 100) / 100);
+  const labelsAbove = axis.tickLblPos === "high" || axis.tickLblPos !== "low" && axis.axPos === "t";
+  const labelY = axis.tickLblPos === "high" ? layout.plotTop : axis.tickLblPos === "low" ? layout.plotBottom : y;
+  const labelSkip = Math.max(1, axis.tickLabelSkip ?? 1);
+  const labels = axis.deleted || axis.tickLblPos === "none" ? [] : ticks.flatMap((serial, index) => {
+    if (index % labelSkip !== 0) {
+      return [];
+    }
+    let x = serialToX(serial, min, max, layout);
+    if (axis.orientation === "maxMin") {
+      x = layout.plotLeft + layout.plotWidth - (x - layout.plotLeft);
+    }
+    return [
+      {
+        kind: "text",
+        x,
+        y: labelsAbove ? labelY - offset : labelY + offset,
+        text: formatDate(
+          excelSerialToDate(serial, dates.date1904),
+          unit,
+          axis.numFmt?.formatCode ?? dates.formatCode
+        ),
+        ...chartAxisTextStyle(axis),
+        textAnchor: "middle"
+      }
+    ];
+  });
+  const tickMarks = axis.deleted ? [] : ticks.flatMap((serial, index) => {
+    if (index % Math.max(1, axis.tickMarkSkip ?? 1) !== 0) {
+      return [];
+    }
+    let x = serialToX(serial, min, max, layout);
+    if (axis.orientation === "maxMin") {
+      x = layout.plotLeft + layout.plotWidth - (x - layout.plotLeft);
+    }
+    const line2 = tickLine2(x, y, axis, false);
+    return line2 ? [line2] : [];
+  });
+  if (!axis.deleted && axis.spPr) {
+    tickMarks.unshift({
+      kind: "line",
+      x1: layout.plotLeft,
+      y1: y,
+      x2: layout.plotRight,
+      y2: y,
+      ...chartLineStyle(axis.spPr)
+    });
+  }
+  if (!axis.deleted && axis.minorTickMark && axis.minorTickMark !== "none") {
+    const minorUnit = axis.minorTimeUnit ?? axis.baseTimeUnit ?? unit;
+    for (const serial of calendarTicks(
+      min,
+      max,
+      dates.date1904 ?? false,
+      minorUnit,
+      Math.max(1, axis.minorUnit ?? 1)
+    )) {
+      let x = serialToX(serial, min, max, layout);
+      if (axis.orientation === "maxMin") {
+        x = layout.plotLeft + layout.plotWidth - (x - layout.plotLeft);
+      }
+      const line2 = tickLine2(x, y, axis, true);
+      if (line2) {
+        tickMarks.push(line2);
+      }
+    }
+  }
+  return { sourceIndices: sourceIndices2, xPositions, labels, tickMarks };
+}
+function buildCartesianHorizontalAxis(chartData, categoryLabels, layout, kind, primaryRange, secondaryRange) {
+  let catAxisStyle = kind === "line" || kind === "area" || kind === "scatter" || kind === "bubble" ? "line" : "bar";
+  const horizontalAxes = chartData.axes?.filter(
+    (axis) => axis.axisType === "catAx" || axis.axisType === "dateAx"
+  );
+  const primaryAxis = horizontalAxes?.find((axis) => axis.axPos !== "t") ?? horizontalAxes?.[0];
+  const secondaryAxis = horizontalAxes?.find((axis) => axis.axPos === "t" && axis !== primaryAxis);
+  const linkedValueAxis = (axis) => chartData.axes?.find(
+    (candidate) => candidate.axisType === "valAx" && candidate.axisId === axis?.crossAxisId
+  );
+  const primaryValueAxis = linkedValueAxis(primaryAxis);
+  if (primaryValueAxis?.crossBetween === "between") {
+    catAxisStyle = "bar";
+  } else if (primaryValueAxis?.crossBetween === "midCat") {
+    catAxisStyle = "line";
+  }
+  const rangeAndY = (axis) => {
+    const valueAxis = linkedValueAxis(axis);
+    const range = valueAxis?.axPos === "r" && secondaryRange ? secondaryRange : primaryRange;
+    return horizontalAxisY(valueAxis, range, layout, axis?.axPos === "t" ? "top" : "bottom");
+  };
+  const supportsDateScale = kind === "line" || kind === "area" || kind === "combo" || kind === "stock";
+  const datePlan = supportsDateScale && primaryAxis?.axisType === "dateAx" ? buildDateAxisPlan(chartData, layout, primaryAxis, rangeAndY(primaryAxis)) : void 0;
+  const categoryPlan = kind === "scatter" || kind === "bubble" || datePlan ? void 0 : buildCategoryAxisPlan(
+    categoryLabels,
+    layout,
+    catAxisStyle,
+    chartData.axes,
+    primaryAxis,
+    rangeAndY(primaryAxis),
+    chartData.categoryLevels
+  );
+  const secondaryPlan = secondaryAxis ? secondaryAxis.axisType === "dateAx" ? buildDateAxisPlan(chartData, layout, secondaryAxis, rangeAndY(secondaryAxis)) : buildCategoryAxisPlan(
+    categoryLabels,
+    layout,
+    linkedValueAxis(secondaryAxis)?.crossBetween === "between" ? "bar" : "line",
+    chartData.axes,
+    secondaryAxis,
+    rangeAndY(secondaryAxis),
+    chartData.categoryLevels
+  ) : void 0;
+  const sourceIndices2 = datePlan?.sourceIndices ?? categoryPlan?.sourceIndices ?? categoryLabels.map((_label, index) => index);
+  return {
+    catAxisStyle,
+    sourceIndices: sourceIndices2,
+    xPositions: datePlan?.xPositions ?? categoryPlan?.sourceIndices.map(
+      (_sourceIndex, displayIndex) => categoryX(displayIndex, categoryPlan.sourceIndices.length, layout, catAxisStyle)
+    ),
+    labels: [
+      ...datePlan?.labels ?? categoryPlan?.labels ?? buildCategoryLabels(categoryLabels, layout, catAxisStyle),
+      ...secondaryPlan?.labels ?? []
+    ],
+    tickMarks: [
+      ...datePlan?.tickMarks ?? categoryPlan?.tickMarks ?? [],
+      ...secondaryPlan?.tickMarks ?? []
+    ],
+    displayChartData: datePlan || categoryPlan ? chartDataInCategoryOrder(chartData, sourceIndices2) : chartData
+  };
+}
+var DEFAULT_COLOR3 = "#334155";
+var CAP_HALF_WIDTH = 4;
+function categoryX2(value, count, layout, mode) {
+  if (mode === "bar") {
+    const slot = layout.plotWidth / Math.max(count, 1);
+    return layout.plotLeft + slot * value + slot / 2;
+  }
+  return layout.plotLeft + value / Math.max(count - 1, 1) * layout.plotWidth;
+}
+function positionedCategoryX(value, positions, fallback) {
+  if (!positions || positions.length === 0) {
+    return fallback(value);
+  }
+  const lower = Math.floor(value);
+  const upper = Math.ceil(value);
+  const at = (index) => {
+    if (positions[index] !== void 0) {
+      return positions[index];
+    }
+    const lastIndex = positions.length - 1;
+    const last = positions[lastIndex] ?? 0;
+    const beforeLast = lastIndex > 0 ? positions[lastIndex - 1] ?? positions[0] ?? 0 : positions[0] ?? 0;
+    const gap = last - beforeLast;
+    return last + gap * (index - positions.length + 1);
+  };
+  return at(lower) + (at(upper) - at(lower)) * (value - lower);
+}
+function numericX(value, range, layout) {
+  return layout.plotLeft + (value - range.min) / Math.max(range.span, 1e-9) * layout.plotWidth;
+}
+function xValuesForSeries(chartData, series, indexes) {
+  const seriesType = series.seriesChartType ?? chartData.chartType;
+  const numeric = seriesType === "scatter" || seriesType === "bubble";
+  if (!numeric) {
+    return { values: indexes.map((_index, displayIndex) => displayIndex), numeric: false };
+  }
+  return {
+    values: indexes.map((index) => {
+      const parsed = Number(chartData.categories[index]);
+      return Number.isFinite(parsed) ? parsed : index;
+    }),
+    numeric: true
+  };
+}
+function numericXRange(values) {
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  return { min, max, span: Math.max(max - min, 1) };
+}
+function errorValue(errBars, values, displayIndex, sourceIndex, direction) {
+  switch (errBars.valType) {
+    case "fixedVal":
+      return errBars.val ?? 0;
+    case "percentage":
+      return Math.abs(values[displayIndex] ?? 0) * ((errBars.val ?? 0) / 100);
+    case "stdDev": {
+      const mean = values.reduce((sum, value) => sum + value, 0) / Math.max(values.length, 1);
+      const variance = values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / Math.max(values.length, 1);
+      return Math.sqrt(variance) * (errBars.val ?? 1);
+    }
+    case "stdErr": {
+      const count = Math.max(values.length, 1);
+      const mean = values.reduce((sum, value) => sum + value, 0) / count;
+      const variance = values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / count;
+      return Math.sqrt(variance / count);
+    }
+    case "cust":
+      return direction === "plus" ? errBars.customPlus?.[sourceIndex] ?? 0 : errBars.customMinus?.[sourceIndex] ?? 0;
+  }
+}
+function line(x1, y1, x2, y2, color) {
+  return { kind: "line", x1, y1, x2, y2, stroke: color, strokeWidth: 1 };
+}
+function appendYBar(out, errBars, x, baseValue, error, direction, range, layout) {
+  const color = errBars.color ?? DEFAULT_COLOR3;
+  const baseY = valueToY2(baseValue, range, layout.plotTop, layout.plotBottom);
+  const endValue = direction === "plus" ? baseValue + error : baseValue - error;
+  const endY = valueToY2(endValue, range, layout.plotTop, layout.plotBottom);
+  out.push(line(x, baseY, x, endY, color));
+  if (!errBars.noEndCap) {
+    out.push(line(x - CAP_HALF_WIDTH, endY, x + CAP_HALF_WIDTH, endY, color));
+  }
+}
+function appendXBar(out, errBars, baseXValue, error, direction, y, toPixel) {
+  const color = errBars.color ?? DEFAULT_COLOR3;
+  const baseX = toPixel(baseXValue);
+  const endValue = direction === "plus" ? baseXValue + error : baseXValue - error;
+  const endX = toPixel(endValue);
+  out.push(line(baseX, y, endX, y, color));
+  if (!errBars.noEndCap) {
+    out.push(line(endX, y - CAP_HALF_WIDTH, endX, y + CAP_HALF_WIDTH, color));
+  }
+}
+function computeErrorBarPrimitives(chartData, catCount, layout, range, mode = "line", options = {}) {
+  const out = [];
+  chartData.series.forEach((series, seriesIndex) => {
+    const indexes = options.sourceIndices ?? series.values.map((_value, index) => index);
+    const yValues = indexes.map((index) => series.values[index] ?? 0);
+    const xValues = xValuesForSeries(chartData, series, indexes);
+    const xRange = xValues.numeric ? numericXRange(xValues.values) : void 0;
+    const seriesMode = options.seriesModes?.[seriesIndex] ?? mode;
+    const yRange = options.seriesRanges?.[seriesIndex] ?? range;
+    series.errBars?.forEach((errBars) => {
+      indexes.forEach((sourceIndex, displayIndex) => {
+        const yValue = yValues[displayIndex] ?? 0;
+        const baseXValue = xValues.values[displayIndex] ?? displayIndex;
+        const categoryMapper = (value) => positionedCategoryX(
+          value,
+          options.xPositions,
+          (index) => categoryX2(index, indexes.length || catCount, layout, seriesMode)
+        );
+        const toPixel = xValues.numeric ? (value) => numericX(value, xRange, layout) : categoryMapper;
+        const x = toPixel(baseXValue);
+        const y = valueToY2(yValue, yRange, layout.plotTop, layout.plotBottom);
+        for (const direction of ["plus", "minus"]) {
+          if (errBars.barType !== direction && errBars.barType !== "both") {
+            continue;
+          }
+          const values = errBars.direction === "x" ? xValues.values : yValues;
+          const error = errorValue(errBars, values, displayIndex, sourceIndex, direction);
+          if (errBars.direction === "x") {
+            appendXBar(out, errBars, baseXValue, error, direction, y, toPixel);
+          } else {
+            appendYBar(out, errBars, x, yValue, error, direction, yRange, layout);
+          }
+        }
+      });
+    });
+  });
+  return out;
+}
+function xToPixel2(xVal, catCount, layout, mode) {
+  if (mode === "bar") {
+    const slotWidth = layout.plotWidth / Math.max(catCount, 1);
+    return layout.plotLeft + slotWidth * xVal + slotWidth / 2;
+  }
+  const maxIdx = Math.max(catCount - 1, 1);
   return layout.plotLeft + xVal / maxIdx * layout.plotWidth;
 }
 function computeLinearRegression2(xVals, yVals) {
@@ -4328,102 +5473,6 @@ function computeTrendlinePrimitives(chartData, catCount, layout, range, mode = "
   });
   return out;
 }
-function computeErrorValue(errBars, values, pointIndex, direction) {
-  switch (errBars.valType) {
-    case "fixedVal":
-      return errBars.val ?? 0;
-    case "percentage":
-      return Math.abs(values[pointIndex]) * ((errBars.val ?? 0) / 100);
-    case "stdDev": {
-      const n = values.length;
-      if (n === 0) {
-        return 0;
-      }
-      const mean = values.reduce((s, v) => s + v, 0) / n;
-      const variance = values.reduce((s, v) => s + (v - mean) ** 2, 0) / n;
-      return Math.sqrt(variance) * (errBars.val ?? 1);
-    }
-    case "stdErr": {
-      const n2 = values.length;
-      if (n2 === 0) {
-        return 0;
-      }
-      const mean2 = values.reduce((s, v) => s + v, 0) / n2;
-      const variance2 = values.reduce((s, v) => s + (v - mean2) ** 2, 0) / n2;
-      return Math.sqrt(variance2 / n2);
-    }
-    case "cust":
-      return direction === "plus" ? errBars.customPlus?.[pointIndex] ?? 0 : errBars.customMinus?.[pointIndex] ?? 0;
-    default:
-      return 0;
-  }
-}
-var ERROR_BAR_COLOR = "#334155";
-function computeErrorBarPrimitives(chartData, catCount, layout, range, mode = "line") {
-  const out = [];
-  const capW = 4;
-  chartData.series.forEach((series) => {
-    if (!series.errBars || series.errBars.length === 0) {
-      return;
-    }
-    series.errBars.forEach((eb) => {
-      if (eb.direction !== "y") {
-        return;
-      }
-      series.values.forEach((val2, vi) => {
-        const cx = xToPixel2(vi, catCount, layout, mode);
-        const baseY = valueToY2(val2, range, layout.plotTop, layout.plotBottom);
-        if (eb.barType === "plus" || eb.barType === "both") {
-          const plusErr = computeErrorValue(eb, series.values, vi, "plus");
-          const topY = valueToY2(val2 + plusErr, range, layout.plotTop, layout.plotBottom);
-          const stem = {
-            kind: "line",
-            x1: cx,
-            y1: baseY,
-            x2: cx,
-            y2: topY,
-            stroke: ERROR_BAR_COLOR,
-            strokeWidth: 1
-          };
-          const cap = {
-            kind: "line",
-            x1: cx - capW,
-            y1: topY,
-            x2: cx + capW,
-            y2: topY,
-            stroke: ERROR_BAR_COLOR,
-            strokeWidth: 1
-          };
-          out.push(stem, cap);
-        }
-        if (eb.barType === "minus" || eb.barType === "both") {
-          const minusErr = computeErrorValue(eb, series.values, vi, "minus");
-          const botY = valueToY2(val2 - minusErr, range, layout.plotTop, layout.plotBottom);
-          const stem = {
-            kind: "line",
-            x1: cx,
-            y1: baseY,
-            x2: cx,
-            y2: botY,
-            stroke: ERROR_BAR_COLOR,
-            strokeWidth: 1
-          };
-          const cap = {
-            kind: "line",
-            x1: cx - capW,
-            y1: botY,
-            x2: cx + capW,
-            y2: botY,
-            stroke: ERROR_BAR_COLOR,
-            strokeWidth: 1
-          };
-          out.push(stem, cap);
-        }
-      });
-    });
-  });
-  return out;
-}
 var AXIS_TITLE_COLOR = "#475569";
 function computeAxisTitlePrimitives(chartData, layout) {
   const out = [];
@@ -4633,42 +5682,6 @@ function computeDataTablePrimitives(chartData, layout, colorPalette) {
   });
   return out;
 }
-function hasRicherAxisFeatures(chartData) {
-  const axes = chartData.axes;
-  if (axes && axes.length > 0) {
-    for (const a of axes) {
-      if (a.axisType === "valAx" && (a.logScale || a.displayUnits || a.axPos === "r")) {
-        return true;
-      }
-    }
-  }
-  return Boolean(chartData.dataTable);
-}
-function findPrimaryValueAxis(chartData) {
-  const axes = chartData.axes;
-  if (!axes) {
-    return void 0;
-  }
-  return axes.find((a) => a.axisType === "valAx" && a.axPos !== "r") ?? axes.find((a) => a.axisType === "valAx");
-}
-function buildAxes(chartData, layout, primaryRange, secondaryRange) {
-  const richer = hasRicherAxisFeatures(chartData);
-  if (!richer) {
-    const { gridlines: gridlines2, axisLabels: axisLabels2 } = buildGridlinesAndLabels(primaryRange, layout);
-    return { gridlines: gridlines2, axisLabels: axisLabels2, secondaryGridlines: void 0, secondaryAxisLabels: void 0 };
-  }
-  const primaryAxis = findPrimaryValueAxis(chartData);
-  const { gridlines, axisLabels } = buildPrimaryAxis(primaryRange, layout, primaryAxis);
-  let secondaryGridlines;
-  let secondaryAxisLabels;
-  if (secondaryRange) {
-    const secAxis = getSecondaryValueAxis(chartData.axes);
-    const sec = buildSecondaryAxis(secondaryRange, layout, secAxis);
-    secondaryGridlines = sec.gridlines;
-    secondaryAxisLabels = sec.axisLabels;
-  }
-  return { gridlines, axisLabels, secondaryGridlines, secondaryAxisLabels };
-}
 function stackedRange(chartData, catCount, isPercent) {
   if (isPercent) {
     return { min: 0, max: 100, span: 100 };
@@ -4687,15 +5700,31 @@ function buildCartesianViewModel(element, chartData, categoryLabels, kind) {
   const useSecondary = !isStacked && secondaryIdx.size > 0;
   const primaryPlotSeries = useSecondary ? chartData.series.filter((_s, i) => !secondaryIdx.has(i)) : chartData.series;
   const secondaryPlotSeries = useSecondary ? chartData.series.filter((_s, i) => secondaryIdx.has(i)) : [];
-  const primaryRange = isStacked ? stackedRange(chartData, catCount, isPercent) : computeValueRangeForChart(
+  const primaryAxis = chartData.axes?.find(
+    (axis) => axis.axisType === "valAx" && axis.axPos !== "r"
+  );
+  const primaryRange = isStacked ? {
+    ...stackedRange(chartData, catCount, isPercent),
+    ...primaryAxis?.orientation === "maxMin" ? { reverseOrder: true } : {}
+  } : computeValueRangeForChart(
     primaryPlotSeries.length > 0 ? primaryPlotSeries : chartData.series,
     chartData.axes
   );
-  const secondaryRange = useSecondary && secondaryPlotSeries.length > 0 ? computeValueRange2(secondaryPlotSeries) : void 0;
-  const axisRes = buildAxes(chartData, layout, primaryRange, secondaryRange);
+  const secondaryRange = useSecondary && secondaryPlotSeries.length > 0 ? computeValueRangeForAxis(
+    secondaryPlotSeries,
+    chartData.axes?.find((axis) => axis.axisType === "valAx" && axis.axPos === "r")
+  ) : void 0;
+  const axisRes = buildCartesianAxes(chartData, layout, primaryRange, secondaryRange, catCount);
   const zeroLine = primaryRange.logScale ? void 0 : buildZeroLine(primaryRange, layout);
-  const catAxisStyle = kind === "line" || kind === "area" || kind === "scatter" || kind === "bubble" ? "line" : "bar";
-  const catLabels = buildCategoryLabels(categoryLabels, layout, catAxisStyle);
+  const horizontalAxis = buildCartesianHorizontalAxis(
+    chartData,
+    categoryLabels,
+    layout,
+    kind,
+    primaryRange,
+    secondaryRange
+  );
+  const { catAxisStyle, sourceIndices: sourceIndices2, displayChartData } = horizontalAxis;
   const legendPos = chartData.style?.legendPosition ?? "b";
   const { legend, legendX, legendY, legendAnchor } = buildLegend(
     chartData.series,
@@ -4714,31 +5743,52 @@ function buildCartesianViewModel(element, chartData, categoryLabels, kind) {
       primaryRange,
       secondaryRange,
       secondaryIdx,
-      isStacked ? isPercent ? "percentStacked" : "stacked" : "clustered"
+      isStacked ? isPercent ? "percentStacked" : "stacked" : "clustered",
+      sourceIndices2
     );
   } else if (kind === "line") {
-    plot = buildLines(chartData, catCount, layout, primaryRange, secondaryRange, secondaryIdx);
+    plot = buildLines(
+      chartData,
+      catCount,
+      layout,
+      primaryRange,
+      secondaryRange,
+      secondaryIdx,
+      sourceIndices2,
+      horizontalAxis.xPositions
+    );
   } else if (kind === "area") {
-    plot = buildAreas(chartData, catCount, layout, primaryRange);
+    plot = buildAreas(
+      chartData,
+      catCount,
+      layout,
+      primaryRange,
+      sourceIndices2,
+      horizontalAxis.xPositions
+    );
   } else if (kind === "scatter") {
     plot = buildScatter(chartData, layout, primaryRange);
   } else {
     plot = buildBubbles(chartData, layout, primaryRange);
   }
-  const primitives = [...plot.primitives];
+  const primitives = [...plot.primitives, ...horizontalAxis.tickMarks];
   const overlays = [
     ...computeTrendlinePrimitives(
-      chartData,
+      displayChartData,
       catCount,
       layout,
       primaryRange,
       catAxisStyle,
       chartData.colorPalette
     ),
-    ...computeErrorBarPrimitives(chartData, catCount, layout, primaryRange, catAxisStyle),
+    ...computeErrorBarPrimitives(displayChartData, catCount, layout, primaryRange, catAxisStyle),
     ...computeAxisTitlePrimitives(chartData, layout)
   ];
-  const dataTablePrims = computeDataTablePrimitives(chartData, layout, chartData.colorPalette);
+  const dataTablePrims = computeDataTablePrimitives(
+    displayChartData,
+    layout,
+    chartData.colorPalette
+  );
   primitives.push(...overlays, ...dataTablePrims);
   const title = chartData.style?.hasTitle && chartData.title ? chartData.title : void 0;
   const valueDrag = isStacked ? void 0 : {
@@ -4757,7 +5807,7 @@ function buildCartesianViewModel(element, chartData, categoryLabels, kind) {
     gridlines: axisRes.gridlines,
     axisLabels: axisRes.axisLabels,
     zeroLine,
-    categoryLabels: catLabels,
+    categoryLabels: horizontalAxis.labels,
     primitives,
     dataLabels: plot.dataLabels,
     legend: chartData.style?.hasLegend ? legend : [],
@@ -4771,135 +5821,255 @@ function buildCartesianViewModel(element, chartData, categoryLabels, kind) {
     valueDrag
   };
 }
-var CANDLE_UP_FILL = "#22c55e";
-var CANDLE_DOWN_FILL = "#ef4444";
-var CANDLE_WICK_COLOR = "#334155";
+function rangeForSeries(index, primaryRange, secondaryRange, secondaryIndexes) {
+  return secondaryRange && secondaryIndexes.has(index) ? secondaryRange : primaryRange;
+}
 function buildComboViewModel(element, chartData, categoryLabels) {
-  const layout = computePlotLayout(element.width, element.height, chartData, true);
-  const catCount = Math.max(categoryLabels.length, 1);
-  const range = computeValueRange2(chartData.series);
-  const { gridlines, axisLabels } = buildGridlinesAndLabels(range, layout);
-  const zeroLine = buildZeroLine(range, layout);
-  const catLabels = buildCategoryLabels(categoryLabels, layout, "bar");
-  const legendPos = chartData.style?.legendPosition ?? "b";
-  const { legend, legendX, legendY, legendAnchor } = buildLegend(
-    chartData.series,
-    chartData.colorPalette,
-    layout.svgWidth,
-    legendPos,
-    layout.svgHeight,
-    layout.plotTop
+  const layoutOptions = computeLayoutOptions(
+    chartData.axes,
+    chartData.dataTable,
+    chartData.series.length
   );
-  const primitives = [];
-  const dataLabels = [];
-  const barSeries = chartData.series.slice(0, 1);
-  if (barSeries.length > 0) {
-    const barRects = computeBarRects(barSeries, catCount, layout, range, chartData.colorPalette);
-    for (const r of barRects) {
-      primitives.push({
-        kind: "rect",
-        x: r.x,
-        y: r.y,
-        w: r.w,
-        h: r.h,
-        fill: r.fill,
-        rx: 1
-      });
-    }
-    if (chartData.style?.hasDataLabels && barSeries[0]) {
-      const barGroupWidth2 = layout.plotWidth / catCount;
-      const singleBarWidth = barGroupWidth2 * 0.7;
-      const groupOffset = (barGroupWidth2 - singleBarWidth) / 2;
-      barSeries[0].values.forEach((val2, vi) => {
-        const x = layout.plotLeft + barGroupWidth2 * vi + groupOffset + singleBarWidth / 2;
-        const zeroY = valueToY2(0, range, layout.plotTop, layout.plotBottom);
-        const valY = valueToY2(val2, range, layout.plotTop, layout.plotBottom);
-        const labelY = val2 >= 0 ? Math.min(zeroY, valY) - 4 : Math.max(zeroY, valY) + 10;
-        dataLabels.push({
-          kind: "text",
-          x,
-          y: labelY,
-          text: formatAxisValue2(val2),
-          fontSize: 7,
-          fill: "#334155",
-          textAnchor: "middle"
-        });
-      });
-    }
+  const layout = computePlotLayout(
+    element.width,
+    element.height,
+    chartData,
+    true,
+    layoutOptions
+  );
+  const catCount = Math.max(categoryLabels.length, 1);
+  const { primary, secondary } = splitSeriesByAxis(chartData.series, chartData.axes);
+  const secondaryIndexes = new Set(secondary.map((entry) => entry.index));
+  const primarySeries = primary.length > 0 ? primary.map((entry) => entry.series) : chartData.series;
+  const primaryAxisId = getPrimaryValueAxisId(chartData.axes);
+  const primaryAxis = chartData.axes?.find((axis) => axis.axisId === primaryAxisId);
+  const secondaryAxisFormatting = getSecondaryValueAxis(chartData.axes);
+  const primaryRange = computeValueRangeForAxis(primarySeries, primaryAxis);
+  const secondaryRange = secondary.length > 0 ? computeValueRangeForAxis(
+    secondary.map((entry) => entry.series),
+    secondaryAxisFormatting
+  ) : void 0;
+  const primaryCategoryAxis2 = chartData.axes?.find(
+    (axis) => (axis.axisType === "catAx" || axis.axisType === "dateAx") && axis.axisId === primaryAxis?.crossAxisId
+  );
+  const primaryAxisX = verticalAxisX(
+    primaryCategoryAxis2,
+    catCount,
+    layout,
+    "left",
+    chartData.dateCategories?.values
+  );
+  const primaryRendered = primaryCategoryAxis2?.crosses !== void 0 || primaryCategoryAxis2?.crossesAt !== void 0 ? buildPrimaryAxis(primaryRange, layout, primaryAxis, primaryAxisX) : buildGridlinesAndLabels(primaryRange, layout);
+  const { gridlines, axisLabels } = primaryRendered;
+  const secondaryCategoryAxis = chartData.axes?.find(
+    (axis) => (axis.axisType === "catAx" || axis.axisType === "dateAx") && axis.axisId === secondaryAxisFormatting?.crossAxisId
+  );
+  const secondaryAxis = secondaryRange ? buildSecondaryAxis(
+    secondaryRange,
+    layout,
+    secondaryAxisFormatting,
+    verticalAxisX(
+      secondaryCategoryAxis,
+      catCount,
+      layout,
+      "right",
+      chartData.dateCategories?.values
+    )
+  ) : void 0;
+  const zeroLine = primaryRange.logScale ? void 0 : buildZeroLine(primaryRange, layout);
+  const horizontalAxis = buildCartesianHorizontalAxis(
+    chartData,
+    categoryLabels,
+    layout,
+    "combo",
+    primaryRange,
+    secondaryRange
+  );
+  const sourceIndices2 = horizontalAxis.sourceIndices;
+  const legendPos = chartData.style?.legendPosition ?? "b";
+  const { legend, legendX, legendY, legendAnchor } = buildLegend(
+    chartData.series,
+    chartData.colorPalette,
+    layout.svgWidth,
+    legendPos,
+    layout.svgHeight,
+    layout.plotTop
+  );
+  const primitives = [];
+  const dataLabels = [];
+  const barSeries = chartData.series.slice(0, 1);
+  if (barSeries[0]) {
+    const barRange = rangeForSeries(0, primaryRange, secondaryRange, secondaryIndexes);
+    const displayBarSeries = [
+      { ...barSeries[0], values: sourceIndices2.map((index) => barSeries[0].values[index] ?? 0) }
+    ];
+    primitives.push(
+      ...computeBarRects(displayBarSeries, catCount, layout, barRange, chartData.colorPalette).map(
+        (rect, displayIndex) => ({
+          kind: "rect",
+          x: horizontalAxis.xPositions ? (horizontalAxis.xPositions[displayIndex] ?? rect.x) - rect.w / 2 : rect.x,
+          y: rect.y,
+          w: rect.w,
+          h: rect.h,
+          fill: rect.fill,
+          rx: 1,
+          part: {
+            role: "dataPoint",
+            seriesIndex: 0,
+            pointIndex: sourceIndices2[displayIndex] ?? displayIndex
+          }
+        })
+      )
+    );
+    appendBarLabels(
+      barSeries[0],
+      chartData,
+      layout,
+      catCount,
+      barRange,
+      sourceIndices2,
+      dataLabels,
+      horizontalAxis.xPositions
+    );
   }
   const barGroupWidth = layout.plotWidth / catCount;
-  const lineSeries = chartData.series.slice(1);
-  lineSeries.forEach((series, si) => {
+  chartData.series.slice(1).forEach((series, offset) => {
+    const seriesIndex = offset + 1;
     if (series.values.length === 0) {
       return;
     }
-    const seriesIdx = si + 1;
-    const c = seriesColor2(series, seriesIdx, chartData.colorPalette);
-    const pts = series.values.map((val2, vi) => ({
-      x: layout.plotLeft + barGroupWidth * vi + barGroupWidth / 2,
-      y: valueToY2(val2, range, layout.plotTop, layout.plotBottom)
-    }));
-    const pointsStr = pts.map((p) => `${p.x.toFixed(2)},${p.y.toFixed(2)}`).join(" ");
+    const range = rangeForSeries(seriesIndex, primaryRange, secondaryRange, secondaryIndexes);
+    const fill = seriesColor2(series, seriesIndex, chartData.colorPalette);
+    const points = sourceIndices2.map((sourceIndex, displayIndex) => {
+      const value = series.values[sourceIndex] ?? 0;
+      return {
+        x: horizontalAxis.xPositions?.[displayIndex] ?? layout.plotLeft + barGroupWidth * displayIndex + barGroupWidth / 2,
+        y: valueToY2(value, range, layout.plotTop, layout.plotBottom),
+        sourceIndex,
+        value
+      };
+    });
     primitives.push({
       kind: "polyline",
-      points: pointsStr,
-      stroke: c,
+      points: points.map((point) => `${point.x.toFixed(2)},${point.y.toFixed(2)}`).join(" "),
+      stroke: fill,
       strokeWidth: 2.4,
       fill: "none"
     });
-    for (const pt of pts) {
-      primitives.push({
-        kind: "circle",
-        cx: pt.x,
-        cy: pt.y,
-        r: 2.5,
-        fill: c
-      });
-    }
+    primitives.push(
+      ...points.map(
+        (point) => ({
+          kind: "circle",
+          cx: point.x,
+          cy: point.y,
+          r: 2.5,
+          fill,
+          part: { role: "dataPoint", seriesIndex, pointIndex: point.sourceIndex }
+        })
+      )
+    );
     if (chartData.style?.hasDataLabels) {
-      series.values.forEach((val2, vi) => {
-        const pt = pts[vi];
-        if (!pt) {
-          return;
+      points.forEach((point) => {
+        if (point) {
+          dataLabels.push({
+            kind: "text",
+            x: point.x,
+            y: point.y - 7,
+            text: formatAxisValue2(point.value),
+            fontSize: 7,
+            fill: "#334155",
+            textAnchor: "middle"
+          });
         }
-        dataLabels.push({
-          kind: "text",
-          x: pt.x,
-          y: pt.y - 7,
-          text: formatAxisValue2(val2),
-          fontSize: 7,
-          fill: "#334155",
-          textAnchor: "middle"
-        });
       });
     }
   });
-  const title = chartData.style?.hasTitle && chartData.title ? chartData.title : void 0;
+  primitives.push(...horizontalAxis.tickMarks);
+  const displayChartData = horizontalAxis.displayChartData;
+  primitives.push(
+    ...computeErrorBarPrimitives(displayChartData, catCount, layout, primaryRange, "line", {
+      xPositions: horizontalAxis.xPositions,
+      seriesRanges: chartData.series.map(
+        (_series, index) => rangeForSeries(index, primaryRange, secondaryRange, secondaryIndexes)
+      ),
+      seriesModes: chartData.series.map((_series, index) => index === 0 ? "bar" : "line")
+    })
+  );
   return {
     svgWidth: layout.svgWidth,
     svgHeight: layout.svgHeight,
-    title,
+    title: chartData.style?.hasTitle && chartData.title ? chartData.title : void 0,
     titleX: layout.svgWidth / 2,
     titleY: 12,
     gridlines,
     axisLabels,
     zeroLine,
-    categoryLabels: catLabels,
+    categoryLabels: horizontalAxis.labels,
     primitives,
     dataLabels,
     legend: chartData.style?.hasLegend ? legend : [],
     legendX,
     legendY,
-    legendAnchor
+    legendAnchor,
+    secondaryGridlines: secondaryAxis?.gridlines,
+    secondaryAxisLabels: secondaryAxis?.axisLabels
   };
 }
+function appendBarLabels(series, chartData, layout, catCount, range, sourceIndices2, labels, xPositions) {
+  if (!chartData.style?.hasDataLabels) {
+    return;
+  }
+  const groupWidth = layout.plotWidth / catCount;
+  const barWidth = groupWidth * 0.7;
+  const offset = (groupWidth - barWidth) / 2;
+  sourceIndices2.forEach((sourceIndex, displayIndex) => {
+    const value = series.values[sourceIndex] ?? 0;
+    const zeroY = valueToY2(0, range, layout.plotTop, layout.plotBottom);
+    const valueY = valueToY2(value, range, layout.plotTop, layout.plotBottom);
+    labels.push({
+      kind: "text",
+      x: xPositions?.[displayIndex] ?? layout.plotLeft + groupWidth * displayIndex + offset + barWidth / 2,
+      y: value >= 0 ? Math.min(zeroY, valueY) - 4 : Math.max(zeroY, valueY) + 10,
+      text: formatAxisValue2(value),
+      fontSize: 7,
+      fill: "#334155",
+      textAnchor: "middle"
+    });
+  });
+}
+var CANDLE_UP_FILL = "#22c55e";
+var CANDLE_DOWN_FILL = "#ef4444";
+var CANDLE_WICK_COLOR = "#334155";
 function buildStockViewModel(element, chartData, categoryLabels) {
-  const layout = computePlotLayout(element.width, element.height, chartData, true);
+  const layout = computePlotLayout(
+    element.width,
+    element.height,
+    chartData,
+    true,
+    computeLayoutOptions(chartData.axes, chartData.dataTable, chartData.series.length)
+  );
   const catCount = Math.max(categoryLabels.length, 1);
   const range = computeValueRange2(chartData.series);
-  const { gridlines, axisLabels } = buildGridlinesAndLabels(range, layout);
+  const valueAxis = chartData.axes?.find((axis) => axis.axisType === "valAx" && axis.axPos !== "r");
+  const categoryAxis = chartData.axes?.find(
+    (axis) => (axis.axisType === "catAx" || axis.axisType === "dateAx") && axis.axisId === valueAxis?.crossAxisId
+  );
+  const renderedAxis = categoryAxis?.crosses !== void 0 || categoryAxis?.crossesAt !== void 0 ? buildPrimaryAxis(
+    range,
+    layout,
+    valueAxis,
+    verticalAxisX(categoryAxis, catCount, layout, "left", chartData.dateCategories?.values)
+  ) : buildGridlinesAndLabels(range, layout);
+  const { gridlines, axisLabels } = renderedAxis;
   const zeroLine = buildZeroLine(range, layout);
-  const catLabels = buildCategoryLabels(categoryLabels, layout, "bar");
+  const horizontalAxis = buildCartesianHorizontalAxis(
+    chartData,
+    categoryLabels,
+    layout,
+    "stock",
+    range
+  );
+  const sourceIndices2 = horizontalAxis.sourceIndices;
   const legendPos = chartData.style?.legendPosition ?? "b";
   const { legend, legendX, legendY, legendAnchor } = buildLegend(
     chartData.series,
@@ -4919,13 +6089,14 @@ function buildStockViewModel(element, chartData, categoryLabels) {
   if (highSeries && lowSeries && closeSeries) {
     const barGroupWidth = layout.plotWidth / catCount;
     const candleWidth = barGroupWidth * 0.5;
-    for (let ci = 0; ci < catCount; ci++) {
-      const high = highSeries.values[ci] ?? 0;
-      const low = lowSeries.values[ci] ?? 0;
-      const open = openSeries ? openSeries.values[ci] ?? low : low;
-      const close = closeSeries.values[ci] ?? high;
+    for (let displayIndex = 0; displayIndex < catCount; displayIndex++) {
+      const sourceIndex = sourceIndices2[displayIndex] ?? displayIndex;
+      const high = highSeries.values[sourceIndex] ?? 0;
+      const low = lowSeries.values[sourceIndex] ?? 0;
+      const open = openSeries ? openSeries.values[sourceIndex] ?? low : low;
+      const close = closeSeries.values[sourceIndex] ?? high;
       const isUp = close >= open;
-      const cx = layout.plotLeft + barGroupWidth * ci + barGroupWidth / 2;
+      const cx = horizontalAxis.xPositions?.[displayIndex] ?? layout.plotLeft + barGroupWidth * displayIndex + barGroupWidth / 2;
       const highY = valueToY2(high, range, layout.plotTop, layout.plotBottom);
       const lowY = valueToY2(low, range, layout.plotTop, layout.plotBottom);
       const openY = valueToY2(open, range, layout.plotTop, layout.plotBottom);
@@ -4948,7 +6119,12 @@ function buildStockViewModel(element, chartData, categoryLabels) {
         w: candleWidth,
         h: bodyHeight,
         fill: isUp ? CANDLE_UP_FILL : CANDLE_DOWN_FILL,
-        rx: 1
+        rx: 1,
+        part: {
+          role: "dataPoint",
+          seriesIndex: hasFour ? 3 : 2,
+          pointIndex: sourceIndex
+        }
       });
       if (chartData.style?.hasDataLabels) {
         dataLabels.push({
@@ -4963,6 +6139,7 @@ function buildStockViewModel(element, chartData, categoryLabels) {
       }
     }
   }
+  primitives.push(...horizontalAxis.tickMarks);
   const title = chartData.style?.hasTitle && chartData.title ? chartData.title : void 0;
   return {
     svgWidth: layout.svgWidth,
@@ -4973,7 +6150,7 @@ function buildStockViewModel(element, chartData, categoryLabels) {
     gridlines,
     axisLabels,
     zeroLine,
-    categoryLabels: catLabels,
+    categoryLabels: horizontalAxis.labels,
     primitives,
     dataLabels,
     legend: chartData.style?.hasLegend ? legend : [],
@@ -4982,255 +6159,544 @@ function buildStockViewModel(element, chartData, categoryLabels) {
     legendAnchor
   };
 }
-var WHISKER_COLOR = "#64748b";
-var MEDIAN_COLOR = "#1e293b";
-var DATA_LABEL_COLOR = "#334155";
+function percentile(sorted, p, method) {
+  const rank = method === "inclusive" ? (sorted.length - 1) * p : (sorted.length + 1) * p - 1;
+  const clamped = Math.max(0, Math.min(rank, sorted.length - 1));
+  const lower = Math.floor(clamped);
+  const upper = Math.ceil(clamped);
+  const fraction = clamped - lower;
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * fraction;
+}
+function computeBoxStats(values, method) {
+  if (values.length < 2) {
+    return void 0;
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  if (!method) {
+    return {
+      min: sorted[0],
+      q1: sorted[Math.floor(sorted.length * 0.25)],
+      median: sorted[Math.floor(sorted.length * 0.5)],
+      q3: sorted[Math.floor(sorted.length * 0.75)],
+      max: sorted[sorted.length - 1]
+    };
+  }
+  return {
+    min: sorted[0],
+    q1: percentile(sorted, 0.25, method),
+    median: percentile(sorted, 0.5, method),
+    q3: percentile(sorted, 0.75, method),
+    max: sorted[sorted.length - 1]
+  };
+}
 function distributionRange(series) {
-  const all = series.flatMap((s) => s.values);
+  const all = series.flatMap((item) => item.values);
   const min = Math.min(...all, 0);
   const max = Math.max(...all, 1);
   return { min, max, span: Math.max(max - min, 1) };
 }
+var WHISKER_COLOR = "#64748b";
+var MEDIAN_COLOR = "#1e293b";
+function computeBoxWhiskerGeometry(chartData, catCount, layout, range, colorPalette) {
+  const groupWidth = layout.plotWidth / catCount;
+  const boxW = groupWidth * 0.5;
+  const options = chartData.series.find((series) => series.boxWhiskerOptions)?.boxWhiskerOptions;
+  const method = options ? options.quartileMethod ?? "exclusive" : void 0;
+  const output = [];
+  for (let categoryIndex = 0; categoryIndex < catCount; categoryIndex++) {
+    const observations = chartData.series.map((series, seriesIndex) => ({ value: series.values[categoryIndex], seriesIndex })).filter((item) => item.value !== void 0);
+    const stats = computeBoxStats(
+      observations.map((item) => item.value),
+      method
+    );
+    if (!stats) {
+      continue;
+    }
+    const iqr = stats.q3 - stats.q1;
+    const lowerFence = stats.q1 - 1.5 * iqr;
+    const upperFence = stats.q3 + 1.5 * iqr;
+    const inliers = observations.filter(
+      (item) => !options || item.value >= lowerFence && item.value <= upperFence
+    );
+    const whiskerMin = Math.min(...inliers.map((item) => item.value));
+    const whiskerMax = Math.max(...inliers.map((item) => item.value));
+    const boxX = layout.plotLeft + groupWidth * categoryIndex + (groupWidth - boxW) / 2;
+    const mean = observations.reduce((sum, item) => sum + item.value, 0) / observations.length;
+    output.push({
+      stats,
+      boxX,
+      boxW,
+      xMid: boxX + boxW / 2,
+      yMin: valueToY2(whiskerMin, range, layout.plotTop, layout.plotBottom),
+      yMax: valueToY2(whiskerMax, range, layout.plotTop, layout.plotBottom),
+      yQ1: valueToY2(stats.q1, range, layout.plotTop, layout.plotBottom),
+      yQ3: valueToY2(stats.q3, range, layout.plotTop, layout.plotBottom),
+      yMed: valueToY2(stats.median, range, layout.plotTop, layout.plotBottom),
+      yMean: valueToY2(mean, range, layout.plotTop, layout.plotBottom),
+      fill: paletteColor2(categoryIndex, colorPalette),
+      points: observations.map((item, index) => ({
+        x: boxX + boxW * (0.2 + 0.6 * (index + 1) / (observations.length + 1)),
+        y: valueToY2(item.value, range, layout.plotTop, layout.plotBottom),
+        seriesIndex: item.seriesIndex,
+        outlier: item.value < whiskerMin || item.value > whiskerMax
+      }))
+    });
+  }
+  return output;
+}
+function whiskerPrimitives(geometry) {
+  const g = geometry;
+  return [
+    {
+      kind: "line",
+      x1: g.xMid,
+      y1: g.yMax,
+      x2: g.xMid,
+      y2: g.yQ3,
+      stroke: WHISKER_COLOR,
+      strokeWidth: 1
+    },
+    {
+      kind: "line",
+      x1: g.xMid,
+      y1: g.yQ1,
+      x2: g.xMid,
+      y2: g.yMin,
+      stroke: WHISKER_COLOR,
+      strokeWidth: 1
+    },
+    {
+      kind: "line",
+      x1: g.boxX + g.boxW * 0.25,
+      y1: g.yMax,
+      x2: g.boxX + g.boxW * 0.75,
+      y2: g.yMax,
+      stroke: WHISKER_COLOR,
+      strokeWidth: 1
+    },
+    {
+      kind: "line",
+      x1: g.boxX + g.boxW * 0.25,
+      y1: g.yMin,
+      x2: g.boxX + g.boxW * 0.75,
+      y2: g.yMin,
+      stroke: WHISKER_COLOR,
+      strokeWidth: 1
+    },
+    {
+      kind: "rect",
+      x: g.boxX,
+      y: Math.min(g.yQ1, g.yQ3),
+      w: g.boxW,
+      h: Math.abs(g.yQ1 - g.yQ3),
+      fill: g.fill,
+      rx: 1,
+      opacity: 0.8
+    },
+    {
+      kind: "line",
+      x1: g.boxX,
+      y1: g.yMed,
+      x2: g.boxX + g.boxW,
+      y2: g.yMed,
+      stroke: MEDIAN_COLOR,
+      strokeWidth: 2
+    }
+  ];
+}
+function optionPrimitives(geometry, options, categoryIndex) {
+  if (!options) {
+    return [];
+  }
+  const output = [];
+  if (options.showMeanLine) {
+    output.push({
+      kind: "line",
+      x1: geometry.boxX,
+      y1: geometry.yMean,
+      x2: geometry.boxX + geometry.boxW,
+      y2: geometry.yMean,
+      stroke: "#0f766e",
+      strokeWidth: 1.5
+    });
+  }
+  if (options.showMeanMarker) {
+    output.push({
+      kind: "circle",
+      cx: geometry.xMid,
+      cy: geometry.yMean,
+      r: 3,
+      fill: "#0f766e"
+    });
+  }
+  for (const point of geometry.points) {
+    if (point.outlier && !options.showOutlierPoints || !point.outlier && !options.showInnerPoints) {
+      continue;
+    }
+    output.push({
+      kind: "circle",
+      cx: point.x,
+      cy: point.y,
+      r: 2.25,
+      fill: point.outlier ? "#dc2626" : MEDIAN_COLOR,
+      part: { role: "dataPoint", seriesIndex: point.seriesIndex, pointIndex: categoryIndex }
+    });
+  }
+  return output;
+}
+function buildBoxWhiskerViewModel(element, chartData, categoryLabels) {
+  const layout = computePlotLayout(element.width, element.height, chartData, true);
+  const range = distributionRange(chartData.series);
+  const options = chartData.series.find((series) => series.boxWhiskerOptions)?.boxWhiskerOptions;
+  const geometries = computeBoxWhiskerGeometry(
+    chartData,
+    Math.max(categoryLabels.length, 1),
+    layout,
+    range,
+    chartData.colorPalette
+  );
+  const primitives = geometries.flatMap((geometry, index) => [
+    ...whiskerPrimitives(geometry),
+    ...optionPrimitives(geometry, options, index)
+  ]);
+  const { gridlines, axisLabels } = buildGridlinesAndLabels(range, layout);
+  const { legend, legendX, legendY, legendAnchor } = buildLegend(
+    chartData.series,
+    chartData.colorPalette,
+    layout.svgWidth,
+    chartData.style?.legendPosition ?? "b",
+    layout.svgHeight,
+    layout.plotTop
+  );
+  const categoryLegend = categoryLabels.map((label, index) => ({
+    color: paletteColor2(index, chartData.colorPalette),
+    label
+  }));
+  return {
+    svgWidth: layout.svgWidth,
+    svgHeight: layout.svgHeight,
+    title: chartData.style?.hasTitle ? chartData.title : void 0,
+    titleX: layout.svgWidth / 2,
+    titleY: 12,
+    gridlines,
+    axisLabels,
+    zeroLine: buildZeroLine(range, layout),
+    categoryLabels: buildCategoryLabels(categoryLabels, layout, "bar"),
+    primitives,
+    dataLabels: [],
+    legend: chartData.style?.hasLegend ? categoryLegend.length ? categoryLegend : legend : [],
+    legendX,
+    legendY,
+    legendAnchor
+  };
+}
+function orderParetoEntries(entries) {
+  return [...entries].sort(
+    (left, right) => Math.max(right.value, 0) - Math.max(left.value, 0) || left.sourcePointIndex - right.sourcePointIndex
+  );
+}
+function buildParetoPrimitives(entries, layout, series, seriesIndex) {
+  const total = entries.reduce((sum, entry) => sum + Math.max(entry.value, 0), 0);
+  if (total <= 0) {
+    return [];
+  }
+  let cumulative = 0;
+  const points = entries.map((entry, displayIndex) => {
+    cumulative += Math.max(entry.value, 0);
+    const percentage = displayIndex === entries.length - 1 ? 100 : cumulative / total * 100;
+    return {
+      x: layout.plotLeft + layout.plotWidth * (displayIndex + 0.5) / entries.length,
+      y: layout.plotBottom - layout.plotHeight * percentage / 100,
+      pointIndex: entry.sourcePointIndex
+    };
+  });
+  const color = series.color ?? "#ED7D31";
+  return [
+    {
+      kind: "polyline",
+      points: points.map((point) => `${point.x},${point.y}`).join(" "),
+      stroke: color,
+      strokeWidth: 2,
+      fill: "none",
+      part: { role: "series", seriesIndex }
+    },
+    ...points.map(
+      (point) => ({
+        kind: "circle",
+        cx: point.x,
+        cy: point.y,
+        r: 2.5,
+        fill: color,
+        part: { role: "dataPoint", seriesIndex, pointIndex: point.pointIndex }
+      })
+    )
+  ];
+}
+function buildParetoAxis(layout) {
+  const axis = buildSecondaryAxis({ min: 0, max: 100, span: 100 }, layout, {
+    majorUnit: 20,
+    majorTickMark: "out"
+  });
+  return {
+    secondaryGridlines: axis.gridlines,
+    secondaryAxisLabels: axis.axisLabels.map((label) => ({
+      ...label,
+      text: `${label.text}%`
+    }))
+  };
+}
+var DATA_LABEL_COLOR = "#334155";
+function binLabel(lower, upper, closed) {
+  return closed === "r" ? `(${formatAxisValue2(lower)}, ${formatAxisValue2(upper)}]` : `[${formatAxisValue2(lower)}, ${formatAxisValue2(upper)})`;
+}
+function computeHistogramBins(values, options) {
+  const closed = options.intervalClosed ?? "l";
+  const finite = values.map((value, sourceIndex) => ({ value, sourceIndex })).filter((item) => Number.isFinite(item.value));
+  if (finite.length === 0) {
+    return [];
+  }
+  const underflow = typeof options.underflow === "number" ? options.underflow : void 0;
+  const overflow = typeof options.overflow === "number" ? options.overflow : void 0;
+  const under = underflow === void 0 ? [] : finite.filter(
+    (item) => closed === "r" ? item.value <= underflow : item.value < underflow
+  );
+  const over = overflow === void 0 ? [] : finite.filter((item) => closed === "l" ? item.value >= overflow : item.value > overflow);
+  const regular = finite.filter((item) => !under.includes(item) && !over.includes(item));
+  const result = [];
+  if (underflow !== void 0) {
+    result.push({
+      value: under.length,
+      label: `${closed === "r" ? "\u2264" : "<"} ${formatAxisValue2(underflow)}`,
+      sourceIndices: under.map((item) => item.sourceIndex)
+    });
+  }
+  if (regular.length > 0) {
+    const min = Math.min(...regular.map((item) => item.value));
+    const max = Math.max(...regular.map((item) => item.value));
+    const requestedSize = options.binSize && options.binSize > 0 ? options.binSize : void 0;
+    const requestedCount = options.binCount && options.binCount > 0 ? options.binCount : void 0;
+    const start = requestedSize ? Math.floor(min / requestedSize) * requestedSize : min;
+    const count = requestedSize ? Math.max(
+      closed === "l" ? Math.floor((max - start) / requestedSize) + 1 : Math.ceil((max - start) / requestedSize),
+      1
+    ) : Math.max(requestedCount ?? Math.ceil(Math.sqrt(regular.length)), 1);
+    const width = requestedSize ?? Math.max((max - start) / count, 1);
+    const bins = Array.from({ length: count }, (_, index) => ({
+      value: 0,
+      label: binLabel(start + index * width, start + (index + 1) * width, closed),
+      sourceIndices: []
+    }));
+    for (const item of regular) {
+      const rawIndex = closed === "r" ? Math.ceil((item.value - start) / width) - 1 : Math.floor((item.value - start) / width);
+      const index = Math.max(0, Math.min(rawIndex, bins.length - 1));
+      bins[index].value += 1;
+      bins[index].sourceIndices.push(item.sourceIndex);
+    }
+    result.push(...bins);
+  }
+  if (overflow !== void 0) {
+    result.push({
+      value: over.length,
+      label: `${closed === "l" ? "\u2265" : ">"} ${formatAxisValue2(overflow)}`,
+      sourceIndices: over.map((item) => item.sourceIndex)
+    });
+  }
+  return result;
+}
 function computeHistogramBars(values, catCount, layout, range, seriesColorOverride, colorPalette) {
   const count = Math.max(catCount, values.length, 1);
   const barWidth = layout.plotWidth / count;
-  return values.map((val2, i) => {
-    const x = layout.plotLeft + barWidth * i;
+  return values.map((val2, pointIndex) => {
     const zeroY = valueToY2(0, range, layout.plotTop, layout.plotBottom);
     const valY = valueToY2(val2, range, layout.plotTop, layout.plotBottom);
-    const y = Math.min(zeroY, valY);
-    const h = Math.max(Math.abs(zeroY - valY), 1);
     return {
-      x,
-      y,
+      x: layout.plotLeft + barWidth * pointIndex,
+      y: Math.min(zeroY, valY),
       w: Math.max(barWidth - 0.5, 1),
-      h,
-      fill: seriesColorOverride ?? paletteColor2(i, colorPalette)
+      h: Math.max(Math.abs(zeroY - valY), 1),
+      fill: seriesColorOverride ?? paletteColor2(pointIndex, colorPalette),
+      pointIndex
     };
   });
 }
 function buildHistogramViewModel(element, chartData, categoryLabels) {
-  const layout = computePlotLayout(element.width, element.height, chartData, true);
-  const range = distributionRange(chartData.series);
-  const values = chartData.series[0]?.values ?? [];
-  const catCount = Math.max(categoryLabels.length, values.length, 1);
-  const barWidth = layout.plotWidth / catCount;
+  const paretoIndex = chartData.series.findIndex(
+    (item) => item.histogramOptions?.layout === "pareto"
+  );
+  const layout = computePlotLayout(element.width, element.height, chartData, true, {
+    hasSecondaryValueAxis: paretoIndex >= 0
+  });
+  const histogramIndex = Math.max(
+    chartData.series.findIndex((series2) => series2.histogramOptions?.layout !== "pareto"),
+    0
+  );
+  const series = chartData.series[histogramIndex];
+  const options = series?.histogramOptions;
+  const bins = options?.layout === "histogram" ? computeHistogramBins(series?.values ?? [], options) : void 0;
+  const baseEntries = (bins?.map((bin) => ({ value: bin.value, label: bin.label })) ?? (series?.values ?? []).map((value, index) => ({
+    value,
+    label: categoryLabels[index] ?? ""
+  }))).map((entry, sourcePointIndex) => ({ ...entry, sourcePointIndex }));
+  const entries = paretoIndex >= 0 ? orderParetoEntries(baseEntries) : baseEntries;
+  const values = entries.map((entry) => entry.value);
+  const labels = entries.map((entry) => entry.label);
+  const range = distributionRange([{ name: series?.name ?? "", values }]);
   const bars = computeHistogramBars(
     values,
-    categoryLabels.length,
+    labels.length,
     layout,
     range,
-    chartData.series[0]?.color,
+    series?.color,
     chartData.colorPalette
   );
   const primitives = bars.map(
-    (b) => ({
+    (bar, displayIndex) => ({
       kind: "rect",
-      x: b.x,
-      y: b.y,
-      w: b.w,
-      h: b.h,
-      fill: b.fill,
-      opacity: 0.85
+      x: bar.x,
+      y: bar.y,
+      w: bar.w,
+      h: bar.h,
+      fill: bar.fill,
+      opacity: 0.85,
+      ...bins ? {} : {
+        part: {
+          role: "dataPoint",
+          seriesIndex: histogramIndex,
+          pointIndex: entries[displayIndex]?.sourcePointIndex ?? displayIndex
+        }
+      }
     })
   );
-  const dataLabels = [];
-  if (chartData.style?.hasDataLabels) {
-    bars.forEach((b, i) => {
-      const val2 = values[i];
-      if (val2 === void 0) {
-        return;
-      }
-      dataLabels.push({
-        kind: "text",
-        x: b.x + barWidth / 2,
-        y: b.y - 4,
-        text: formatAxisValue2(val2),
-        fontSize: 7,
-        fill: DATA_LABEL_COLOR,
-        textAnchor: "middle"
-      });
-    });
+  if (paretoIndex >= 0) {
+    primitives.push(
+      ...buildParetoPrimitives(entries, layout, chartData.series[paretoIndex], paretoIndex)
+    );
   }
+  const dataLabels = chartData.style?.hasDataLabels ? bars.map((bar, index) => ({
+    kind: "text",
+    x: bar.x + bar.w / 2,
+    y: bar.y - 4,
+    text: formatAxisValue2(values[index]),
+    fontSize: 7,
+    fill: DATA_LABEL_COLOR,
+    textAnchor: "middle"
+  })) : [];
   const { gridlines, axisLabels } = buildGridlinesAndLabels(range, layout);
-  const zeroLine = buildZeroLine(range, layout);
-  const catLabels = buildCategoryLabels(categoryLabels, layout, "bar");
-  const legendPos = chartData.style?.legendPosition ?? "b";
+  const paretoAxis = paretoIndex >= 0 ? buildParetoAxis(layout) : void 0;
   const { legend, legendX, legendY, legendAnchor } = buildLegend(
     chartData.series,
     chartData.colorPalette,
     layout.svgWidth,
-    legendPos,
+    chartData.style?.legendPosition ?? "b",
     layout.svgHeight,
     layout.plotTop
   );
-  const title = chartData.style?.hasTitle && chartData.title ? chartData.title : void 0;
   return {
     svgWidth: layout.svgWidth,
     svgHeight: layout.svgHeight,
-    title,
+    title: chartData.style?.hasTitle ? chartData.title : void 0,
     titleX: layout.svgWidth / 2,
     titleY: 12,
     gridlines,
     axisLabels,
-    zeroLine,
-    categoryLabels: catLabels,
+    zeroLine: buildZeroLine(range, layout),
+    categoryLabels: buildCategoryLabels(labels, layout, "bar"),
     primitives,
     dataLabels,
     legend: chartData.style?.hasLegend ? legend : [],
     legendX,
     legendY,
-    legendAnchor
+    legendAnchor,
+    secondaryGridlines: paretoAxis?.secondaryGridlines,
+    secondaryAxisLabels: paretoAxis?.secondaryAxisLabels
   };
 }
-function computeBoxStats(values) {
-  if (values.length < 2) {
-    return void 0;
-  }
-  const sorted = [...values].sort((a, b) => a - b);
-  const n = sorted.length;
-  return {
-    min: sorted[0],
-    q1: sorted[Math.floor(n * 0.25)],
-    median: sorted[Math.floor(n * 0.5)],
-    q3: sorted[Math.floor(n * 0.75)],
-    max: sorted[n - 1]
-  };
+function arcPath(cx, cy, innerRadius, outerRadius, startAngle, endAngle) {
+  const sweep = endAngle - startAngle;
+  const largeArc = sweep > Math.PI ? 1 : 0;
+  const x1 = cx + outerRadius * Math.cos(startAngle);
+  const y1 = cy + outerRadius * Math.sin(startAngle);
+  const x2 = cx + outerRadius * Math.cos(endAngle);
+  const y2 = cy + outerRadius * Math.sin(endAngle);
+  const x3 = cx + innerRadius * Math.cos(endAngle);
+  const y3 = cy + innerRadius * Math.sin(endAngle);
+  const x4 = cx + innerRadius * Math.cos(startAngle);
+  const y4 = cy + innerRadius * Math.sin(startAngle);
+  return `M ${x1} ${y1} A ${outerRadius} ${outerRadius} 0 ${largeArc} 1 ${x2} ${y2} L ${x3} ${y3} A ${innerRadius} ${innerRadius} 0 ${largeArc} 0 ${x4} ${y4} Z`;
 }
-function computeBoxWhiskerGeometry(chartData, catCount, layout, range, colorPalette) {
-  const boxGroupW = layout.plotWidth / catCount;
-  const boxW = boxGroupW * 0.5;
-  const boxOffset = (boxGroupW - boxW) / 2;
+function computeSunburstArcs(series, cx, cy, maxR, colorPalette) {
+  const seriesCount = Math.max(series.length, 1);
+  const ringWidth = maxR / (seriesCount + 0.5);
   const out = [];
-  for (let ci = 0; ci < catCount; ci++) {
-    const catVals = chartData.series.map((s) => s.values[ci] ?? 0);
-    const stats = computeBoxStats(catVals);
-    if (!stats) {
-      continue;
+  for (let si = 0; si < series.length; si++) {
+    const values = series[si].values;
+    const innerRadius = ringWidth * (si + 0.5);
+    const outerRadius = ringWidth * (si + 1.5);
+    const total = values.reduce((acc, value) => acc + Math.abs(value), 0) || 1;
+    let startAngle = -Math.PI / 2;
+    for (let pointIndex = 0; pointIndex < values.length; pointIndex++) {
+      const endAngle = startAngle + Math.abs(values[pointIndex]) / total * Math.PI * 2;
+      out.push({
+        d: arcPath(cx, cy, innerRadius, outerRadius, startAngle, endAngle),
+        fill: paletteColor2(pointIndex, colorPalette),
+        opacity: Math.max(0.1, 0.9 - si * 0.1),
+        pointIndex,
+        level: si
+      });
+      startAngle = endAngle;
     }
-    const boxX = layout.plotLeft + boxGroupW * ci + boxOffset;
-    out.push({
-      stats,
-      boxX,
-      boxW,
-      xMid: boxX + boxW / 2,
-      yMin: valueToY2(stats.min, range, layout.plotTop, layout.plotBottom),
-      yMax: valueToY2(stats.max, range, layout.plotTop, layout.plotBottom),
-      yQ1: valueToY2(stats.q1, range, layout.plotTop, layout.plotBottom),
-      yQ3: valueToY2(stats.q3, range, layout.plotTop, layout.plotBottom),
-      yMed: valueToY2(stats.median, range, layout.plotTop, layout.plotBottom),
-      fill: paletteColor2(ci, colorPalette)
-    });
   }
   return out;
 }
-function buildBoxWhiskerViewModel(element, chartData, categoryLabels) {
-  const layout = computePlotLayout(element.width, element.height, chartData, true);
-  const range = distributionRange(chartData.series);
-  const catCount = Math.max(categoryLabels.length, 1);
-  const geometries = computeBoxWhiskerGeometry(
-    chartData,
-    catCount,
-    layout,
-    range,
-    chartData.colorPalette
-  );
-  const primitives = [];
-  for (const g of geometries) {
-    primitives.push(
-      {
-        kind: "line",
-        x1: g.xMid,
-        y1: g.yMax,
-        x2: g.xMid,
-        y2: g.yQ3,
-        stroke: WHISKER_COLOR,
-        strokeWidth: 1
-      },
-      {
-        kind: "line",
-        x1: g.xMid,
-        y1: g.yQ1,
-        x2: g.xMid,
-        y2: g.yMin,
-        stroke: WHISKER_COLOR,
-        strokeWidth: 1
+function hierarchyKey(levels, level, index) {
+  return levels.slice(level).map((labels) => labels[index] ?? "").join("\0");
+}
+function computeHierarchicalSunburstArcs(categoryLevels, values, cx, cy, maxR, colorPalette) {
+  const levels = categoryLevels.filter((level) => level.length > 0);
+  const leafCount = Math.max(values.length, ...levels.map((level) => level.length), 0);
+  if (levels.length === 0 || leafCount === 0) {
+    return [];
+  }
+  const rawWeights = Array.from({ length: leafCount }, (_, index) => Math.abs(values[index] ?? 0));
+  const weights = rawWeights.some((value) => value !== 0) ? rawWeights : rawWeights.map(() => 1);
+  const total = weights.reduce((sum, value) => sum + value, 0);
+  const prefix = [0];
+  for (const weight of weights) {
+    prefix.push((prefix[prefix.length - 1] ?? 0) + weight);
+  }
+  const ringWidth = maxR / (levels.length + 0.5);
+  const rootLabels = levels[levels.length - 1] ?? [];
+  const rootColors = /* @__PURE__ */ new Map();
+  const out = [];
+  for (let level = levels.length - 1; level >= 0; level--) {
+    const ringIndex = levels.length - 1 - level;
+    const innerRadius = ringWidth * (ringIndex + 0.5);
+    const outerRadius = ringWidth * (ringIndex + 1.5);
+    let start = 0;
+    while (start < leafCount) {
+      const key = hierarchyKey(levels, level, start);
+      let end = start + 1;
+      while (end < leafCount && hierarchyKey(levels, level, end) === key) {
+        end++;
       }
-    );
-    primitives.push(
-      {
-        kind: "line",
-        x1: g.boxX + g.boxW * 0.25,
-        y1: g.yMax,
-        x2: g.boxX + g.boxW * 0.75,
-        y2: g.yMax,
-        stroke: WHISKER_COLOR,
-        strokeWidth: 1
-      },
-      {
-        kind: "line",
-        x1: g.boxX + g.boxW * 0.25,
-        y1: g.yMin,
-        x2: g.boxX + g.boxW * 0.75,
-        y2: g.yMin,
-        stroke: WHISKER_COLOR,
-        strokeWidth: 1
+      const startAngle = -Math.PI / 2 + prefix[start] / total * Math.PI * 2;
+      const endAngle = -Math.PI / 2 + prefix[end] / total * Math.PI * 2;
+      const rootLabel = rootLabels[start] ?? "";
+      if (!rootColors.has(rootLabel)) {
+        rootColors.set(rootLabel, rootColors.size);
       }
-    );
-    primitives.push({
-      kind: "rect",
-      x: g.boxX,
-      y: Math.min(g.yQ1, g.yQ3),
-      w: g.boxW,
-      h: Math.abs(g.yQ1 - g.yQ3),
-      fill: g.fill,
-      rx: 1,
-      opacity: 0.8
-    });
-    primitives.push({
-      kind: "line",
-      x1: g.boxX,
-      y1: g.yMed,
-      x2: g.boxX + g.boxW,
-      y2: g.yMed,
-      stroke: MEDIAN_COLOR,
-      strokeWidth: 2
-    });
+      out.push({
+        d: arcPath(cx, cy, innerRadius, outerRadius, startAngle, endAngle),
+        fill: paletteColor2(rootColors.get(rootLabel) ?? start, colorPalette),
+        opacity: Math.max(0.1, 0.9 - ringIndex * 0.1),
+        level: ringIndex,
+        label: levels[level][start] ?? "",
+        ...level === 0 && end === start + 1 ? { pointIndex: start } : {}
+      });
+      start = end;
+    }
   }
-  const { gridlines, axisLabels } = buildGridlinesAndLabels(range, layout);
-  const zeroLine = buildZeroLine(range, layout);
-  const catLabels = buildCategoryLabels(categoryLabels, layout, "bar");
-  const legendPos = chartData.style?.legendPosition ?? "b";
-  const { legend, legendX, legendY, legendAnchor } = buildLegend(
-    chartData.series,
-    chartData.colorPalette,
-    layout.svgWidth,
-    legendPos,
-    layout.svgHeight,
-    layout.plotTop
-  );
-  const catLegend = categoryLabels.map((label, i) => ({
-    color: paletteColor2(i, chartData.colorPalette),
-    label
-  }));
-  const title = chartData.style?.hasTitle && chartData.title ? chartData.title : void 0;
-  return {
-    svgWidth: layout.svgWidth,
-    svgHeight: layout.svgHeight,
-    title,
-    titleX: layout.svgWidth / 2,
-    titleY: 12,
-    gridlines,
-    axisLabels,
-    zeroLine,
-    categoryLabels: catLabels,
-    primitives,
-    dataLabels: [],
-    legend: chartData.style?.hasLegend ? catLegend.length > 0 ? catLegend : legend : [],
-    legendX,
-    legendY,
-    legendAnchor
-  };
+  return out;
 }
 function emptyChrome() {
   return {
@@ -5327,45 +6793,20 @@ function buildFunnelViewModel(element, chartData, categoryLabels) {
     legendAnchor: "middle"
   };
 }
-function computeSunburstArcs(series, cx, cy, maxR, colorPalette) {
-  const seriesCount = Math.max(series.length, 1);
-  const ringWidth = maxR / (seriesCount + 0.5);
-  const out = [];
-  for (let si = 0; si < series.length; si++) {
-    const s = series[si];
-    const iR = ringWidth * (si + 0.5);
-    const oR = ringWidth * (si + 1.5);
-    const total = s.values.reduce((acc, v) => acc + Math.abs(v), 0) || 1;
-    let startAngle = -Math.PI / 2;
-    for (let vi = 0; vi < s.values.length; vi++) {
-      const val2 = s.values[vi];
-      const sweep = Math.abs(val2) / total * Math.PI * 2;
-      const endAngle = startAngle + sweep;
-      const largeArc = sweep > Math.PI ? 1 : 0;
-      const x1 = cx + oR * Math.cos(startAngle);
-      const y1 = cy + oR * Math.sin(startAngle);
-      const x2 = cx + oR * Math.cos(endAngle);
-      const y2 = cy + oR * Math.sin(endAngle);
-      const x3 = cx + iR * Math.cos(endAngle);
-      const y3 = cy + iR * Math.sin(endAngle);
-      const x4 = cx + iR * Math.cos(startAngle);
-      const y4 = cy + iR * Math.sin(startAngle);
-      out.push({
-        d: `M ${x1} ${y1} A ${oR} ${oR} 0 ${largeArc} 1 ${x2} ${y2} L ${x3} ${y3} A ${iR} ${iR} 0 ${largeArc} 0 ${x4} ${y4} Z`,
-        fill: paletteColor2(vi, colorPalette),
-        opacity: Math.max(0.1, 0.9 - si * 0.1)
-      });
-      startAngle = endAngle;
-    }
-  }
-  return out;
-}
 function buildSunburstViewModel(element, chartData, categoryLabels) {
   const layout = computePlotLayout(element.width, element.height, chartData, false);
   const cx = layout.plotLeft + layout.plotWidth / 2;
   const cy = layout.plotTop + layout.plotHeight / 2;
   const maxR = Math.min(layout.plotWidth, layout.plotHeight) / 2 - 4;
-  const arcs = computeSunburstArcs(chartData.series, cx, cy, maxR, chartData.colorPalette);
+  const categoryLevels = chartData.categoryLevels;
+  const arcs = categoryLevels?.length ? computeHierarchicalSunburstArcs(
+    categoryLevels,
+    chartData.series[0]?.values ?? [],
+    cx,
+    cy,
+    maxR,
+    chartData.colorPalette
+  ) : computeSunburstArcs(chartData.series, cx, cy, maxR, chartData.colorPalette);
   const primitives = arcs.map(
     (arc) => ({
       kind: "path",
@@ -5373,10 +6814,12 @@ function buildSunburstViewModel(element, chartData, categoryLabels) {
       fill: arc.fill,
       stroke: "#ffffff",
       strokeWidth: 1,
-      opacity: arc.opacity
+      opacity: arc.opacity,
+      part: arc.pointIndex === void 0 ? void 0 : { role: "dataPoint", seriesIndex: 0, pointIndex: arc.pointIndex }
     })
   );
-  const legend = chartData.style?.hasLegend ? categoryLabels.map((label, i) => ({ color: paletteColor2(i, chartData.colorPalette), label })) : [];
+  const legendLabels = categoryLevels?.length ? [...new Set(categoryLevels[categoryLevels.length - 1]?.filter(Boolean) ?? categoryLabels)] : categoryLabels;
+  const legend = chartData.style?.hasLegend ? legendLabels.map((label, i) => ({ color: paletteColor2(i, chartData.colorPalette), label })) : [];
   const title = chartData.style?.hasTitle && chartData.title ? chartData.title : void 0;
   return {
     svgWidth: layout.svgWidth,
@@ -5393,6 +6836,176 @@ function buildSunburstViewModel(element, chartData, categoryLabels) {
     legendAnchor: "middle"
   };
 }
+function normalizedLevels(levels, pointCount) {
+  return levels.map((level) => {
+    let previous = "";
+    return Array.from({ length: pointCount }, (_, index) => {
+      const label = level[index]?.trim() ?? "";
+      if (label) {
+        previous = label;
+      }
+      return label || previous;
+    });
+  });
+}
+function findOrAddParent(children, label, colorIndex, parentLabelLayout) {
+  const existing = children.find((child2) => child2.children && child2.label === label);
+  if (existing) {
+    return existing;
+  }
+  const parent = {
+    label,
+    weight: 0,
+    children: [],
+    colorIndex,
+    parentLabelLayout
+  };
+  children.push(parent);
+  return parent;
+}
+function buildSeriesHierarchy(series, seriesIndex, categoryLabels, categoryLevels, colorStride) {
+  const pointCount = series.values.length;
+  const levels = normalizedLevels(categoryLevels ?? [], pointCount);
+  const layout = series.treemapOptions?.parentLabelLayout ?? "banner";
+  const roots = [];
+  for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+    let children = roots;
+    for (let levelIndex = levels.length - 1; levelIndex >= 1; levelIndex--) {
+      const label = levels[levelIndex][pointIndex] || `Group ${levelIndex}`;
+      children = findOrAddParent(children, label, pointIndex, layout).children;
+    }
+    children.push({
+      label: levels[0]?.[pointIndex] || categoryLabels[pointIndex] || String(pointIndex + 1),
+      weight: Math.abs(series.values[pointIndex] ?? 0),
+      seriesIndex,
+      pointIndex,
+      colorIndex: seriesIndex * colorStride + pointIndex,
+      parentLabelLayout: layout
+    });
+  }
+  return roots;
+}
+function aggregate(node) {
+  if (node.children) {
+    node.weight = node.children.reduce((sum, child2) => sum + aggregate(child2), 0);
+  }
+  return node.weight;
+}
+function splitNodes(nodes, box) {
+  const sorted = [...nodes].sort((a, b) => b.weight - a.weight);
+  const total = sorted.reduce((sum, node) => sum + node.weight, 0);
+  const fallback = total === 0 ? sorted.length : total;
+  let remaining = fallback;
+  let current = { ...box };
+  return sorted.map((node) => {
+    const weight = total === 0 ? 1 : node.weight;
+    const fraction = remaining > 0 ? weight / remaining : 0;
+    const splitWidth = current.w >= current.h;
+    const allocated = splitWidth ? { ...current, w: current.w * fraction } : { ...current, h: current.h * fraction };
+    if (splitWidth) {
+      current = { ...current, x: current.x + allocated.w, w: current.w - allocated.w };
+    } else {
+      current = { ...current, y: current.y + allocated.h, h: current.h - allocated.h };
+    }
+    remaining -= weight;
+    return [node, allocated];
+  });
+}
+function renderNodes(nodes, box, colorPalette, primitives) {
+  for (const [node, allocation] of splitNodes(nodes, box)) {
+    const cell = {
+      x: allocation.x + 1,
+      y: allocation.y + 1,
+      w: Math.max(allocation.w - 2, 1),
+      h: Math.max(allocation.h - 2, 1)
+    };
+    if (node.children) {
+      const showParent = node.parentLabelLayout !== "none" && cell.w > 28 && cell.h > 16;
+      if (showParent) {
+        primitives.push({
+          kind: "text",
+          x: cell.x + 4,
+          y: cell.y + 11,
+          text: node.label,
+          fontSize: 10,
+          fill: "#303030",
+          textAnchor: "start",
+          fontWeight: "bold"
+        });
+      }
+      const bannerHeight = showParent && node.parentLabelLayout === "banner" ? 16 : 0;
+      renderNodes(
+        node.children,
+        { ...cell, y: cell.y + bannerHeight, h: Math.max(cell.h - bannerHeight, 1) },
+        colorPalette,
+        primitives
+      );
+      continue;
+    }
+    primitives.push({
+      kind: "rect",
+      ...cell,
+      fill: paletteColor2(node.colorIndex, colorPalette),
+      rx: 2,
+      opacity: 0.85,
+      part: {
+        role: "dataPoint",
+        seriesIndex: node.seriesIndex,
+        pointIndex: node.pointIndex
+      }
+    });
+    if (cell.w > 30 && cell.h > 14) {
+      primitives.push({
+        kind: "text",
+        x: cell.x + cell.w / 2,
+        y: cell.y + cell.h / 2,
+        text: node.label,
+        fontSize: Math.min(10, cell.h * 0.3),
+        fill: "#ffffff",
+        textAnchor: "middle",
+        fontWeight: "bold",
+        dominantBaseline: "central"
+      });
+    }
+  }
+}
+function buildHierarchicalTreemapPrimitives(chartData, categoryLabels, box) {
+  const colorStride = Math.max(
+    categoryLabels.length,
+    ...chartData.series.map((s) => s.values.length),
+    1
+  );
+  let roots = chartData.series.flatMap(
+    (series, seriesIndex) => buildSeriesHierarchy(
+      series,
+      seriesIndex,
+      categoryLabels,
+      chartData.categoryLevels,
+      colorStride
+    )
+  );
+  if (chartData.series.length > 1) {
+    roots = chartData.series.map((series, seriesIndex) => ({
+      label: series.name,
+      weight: 0,
+      children: buildSeriesHierarchy(
+        series,
+        seriesIndex,
+        categoryLabels,
+        chartData.categoryLevels,
+        colorStride
+      ),
+      colorIndex: seriesIndex * colorStride,
+      parentLabelLayout: series.treemapOptions?.parentLabelLayout ?? "banner"
+    }));
+  }
+  for (const root of roots) {
+    aggregate(root);
+  }
+  const primitives = [];
+  renderNodes(roots, box, chartData.colorPalette, primitives);
+  return primitives;
+}
 var ISO_COS30 = Math.cos(Math.PI / 6);
 var ISO_SIN30 = Math.sin(Math.PI / 6);
 function isoProject(x, y, z) {
@@ -5562,67 +7175,24 @@ function buildFlatSurfaceViewModel(element, chartData, categoryLabels) {
     legendX,
     legendY,
     legendAnchor
-  };
-}
-function buildSurfaceViewModel(element, chartData, categoryLabels) {
-  const catCount = Math.max(categoryLabels.length, 1);
-  const seriesCount = chartData.series.length;
-  if (seriesCount >= 2 && catCount >= 2) {
-    return buildIsometricSurfaceViewModel(element, chartData, categoryLabels);
-  }
-  return buildFlatSurfaceViewModel(element, chartData, categoryLabels);
-}
-function buildTreemapViewModel(element, chartData, categoryLabels) {
-  const layout = computePlotLayout(element.width, element.height, chartData, false);
-  const allValues = chartData.series.flatMap((s) => s.values);
-  const totalAbs = allValues.reduce((sum, v) => sum + Math.abs(v), 0) || 1;
-  const primitives = [];
-  let curX = layout.plotLeft;
-  let curY = layout.plotTop;
-  let remainW = layout.plotWidth;
-  let remainH = layout.plotHeight;
-  let remainTotal = totalAbs;
-  const items = allValues.map((v, i) => ({ value: Math.abs(v), index: i })).sort((a, b) => b.value - a.value);
-  for (const item of items) {
-    const fraction = remainTotal > 0 ? item.value / remainTotal : 0;
-    const useWidth = remainW >= remainH;
-    const w = useWidth ? remainW * fraction : remainW;
-    const h = useWidth ? remainH : remainH * fraction;
-    const rw = Math.max(w - 1, 1);
-    const rh = Math.max(h - 1, 1);
-    primitives.push({
-      kind: "rect",
-      x: curX,
-      y: curY,
-      w: rw,
-      h: rh,
-      fill: paletteColor2(item.index, chartData.colorPalette),
-      rx: 2,
-      opacity: 0.85
-    });
-    const label = categoryLabels[item.index] ?? String(item.index + 1);
-    if (rw > 30 && rh > 14) {
-      primitives.push({
-        kind: "text",
-        x: curX + rw / 2,
-        y: curY + rh / 2,
-        text: label,
-        fontSize: Math.min(10, rh * 0.3),
-        fill: "#ffffff",
-        textAnchor: "middle",
-        fontWeight: "bold",
-        dominantBaseline: "central"
-      });
-    }
-    if (useWidth) {
-      curX += w;
-      remainW -= w;
-    } else {
-      curY += h;
-      remainH -= h;
-    }
-    remainTotal -= item.value;
+  };
+}
+function buildSurfaceViewModel(element, chartData, categoryLabels) {
+  const catCount = Math.max(categoryLabels.length, 1);
+  const seriesCount = chartData.series.length;
+  if (seriesCount >= 2 && catCount >= 2) {
+    return buildIsometricSurfaceViewModel(element, chartData, categoryLabels);
   }
+  return buildFlatSurfaceViewModel(element, chartData, categoryLabels);
+}
+function buildTreemapViewModel(element, chartData, categoryLabels) {
+  const layout = computePlotLayout(element.width, element.height, chartData, false);
+  const primitives = buildHierarchicalTreemapPrimitives(chartData, categoryLabels, {
+    x: layout.plotLeft,
+    y: layout.plotTop,
+    w: layout.plotWidth,
+    h: layout.plotHeight
+  });
   const legendPos = chartData.style?.legendPosition ?? "b";
   const { legend, legendX, legendY, legendAnchor } = buildLegend(
     chartData.series,
@@ -5652,31 +7222,144 @@ function buildTreemapViewModel(element, chartData, categoryLabels) {
     legendAnchor
   };
 }
+function sourceIndices(indices, length) {
+  return Array.from({ length }, (_, position) => indices?.[position] ?? position);
+}
+function valueAtSource(values, indices, sourceIndex) {
+  const position = indices.indexOf(sourceIndex);
+  return position >= 0 ? values[position] : void 0;
+}
+function cachedEntityName(cache, entityId) {
+  if (!cache || typeof cache !== "object") {
+    return void 0;
+  }
+  const record = cache;
+  if (String(record["@_entityId"] ?? "") === entityId && record["@_entityName"] !== void 0) {
+    return String(record["@_entityName"]);
+  }
+  for (const value of Object.values(record)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        const name = cachedEntityName(item, entityId);
+        if (name) {
+          return name;
+        }
+      }
+    } else {
+      const name = cachedEntityName(value, entityId);
+      if (name) {
+        return name;
+      }
+    }
+  }
+  return void 0;
+}
+function resolveRegionEntityCode(entityId, options, resolveCode) {
+  if (!entityId) {
+    return void 0;
+  }
+  const direct = resolveCode(entityId);
+  if (direct) {
+    return direct;
+  }
+  const tokens = entityId.split(/[:/|._-]+/u).filter(Boolean);
+  for (let index = tokens.length - 1; index >= 0; index--) {
+    const resolved = resolveCode(tokens[index] ?? "");
+    if (resolved) {
+      return resolved;
+    }
+  }
+  const cachedName = cachedEntityName(options?.geographyCache, entityId);
+  return cachedName ? resolveCode(cachedName) : void 0;
+}
+function buildRegionMapEntries(categories, values, options, resolveCode) {
+  const entityIds = options?.entityIds ?? [];
+  const categoryIndices = sourceIndices(options?.categorySourceIndices, categories.length);
+  const valueIndices = sourceIndices(options?.valueSourceIndices, values.length);
+  const entityIndices = sourceIndices(options?.entityIdSourceIndices, entityIds.length);
+  const indices = [.../* @__PURE__ */ new Set([...categoryIndices, ...valueIndices, ...entityIndices])].sort(
+    (a, b) => a - b
+  );
+  return indices.map((sourceIndex) => {
+    const category = valueAtSource(categories, categoryIndices, sourceIndex) ?? "";
+    const value = valueAtSource(values, valueIndices, sourceIndex) ?? 0;
+    const entityId = valueAtSource(entityIds, entityIndices, sourceIndex);
+    return {
+      sourceIndex,
+      label: category || entityId || `Region ${sourceIndex + 1}`,
+      value,
+      ...entityId ? { entityId } : {},
+      code: resolveRegionEntityCode(entityId, options, resolveCode) ?? resolveCode(category)
+    };
+  });
+}
+function shouldRenderRegionLabel(layout, projectedWidth, projectedHeight) {
+  if (layout === "none") {
+    return false;
+  }
+  if (layout === "bestFitOnly") {
+    return projectedWidth >= 18 && projectedHeight >= 10;
+  }
+  return true;
+}
+function formatRegionMapValue(value, cultureLanguage) {
+  if (!cultureLanguage) {
+    return String(value);
+  }
+  try {
+    return new Intl.NumberFormat(cultureLanguage, { maximumFractionDigits: 2 }).format(value);
+  } catch {
+    return String(value);
+  }
+}
+function buildWaterfallSteps(values, options) {
+  const subtotalIndices = new Set(
+    options?.subtotalIndices ?? (values.length > 0 ? [values.length - 1] : [])
+  );
+  const steps = [];
+  let runningTotal = 0;
+  for (let sourceIndex = 0; sourceIndex < values.length; sourceIndex++) {
+    const value = values[sourceIndex] ?? 0;
+    const isSubtotal = subtotalIndices.has(sourceIndex);
+    const startValue = isSubtotal ? 0 : runningTotal;
+    const endValue = isSubtotal ? value : runningTotal + value;
+    steps.push({ sourceIndex, value, startValue, endValue, isSubtotal });
+    runningTotal = endValue;
+  }
+  return steps;
+}
+function computeWaterfallRange(steps) {
+  return computeValueRange2([
+    {
+      name: "Waterfall range",
+      values: steps.flatMap((step) => [step.startValue, step.endValue])
+    }
+  ]);
+}
 var WF_COLOR_POSITIVE = "#22c55e";
 var WF_COLOR_NEGATIVE = "#ef4444";
 var WF_COLOR_TOTAL = "#6366f1";
 var WF_CONNECTOR_COLOR = "#94a3b8";
 function buildWaterfallViewModel(element, chartData, categoryLabels) {
   const layout = computePlotLayout(element.width, element.height, chartData, true);
-  const values = chartData.series[0]?.values ?? [];
-  const range = computeValueRange2(chartData.series);
+  const series = chartData.series[0];
+  const values = series?.values ?? [];
+  const steps = buildWaterfallSteps(values, series?.waterfallOptions);
+  const range = computeWaterfallRange(steps);
   const catCount = Math.max(categoryLabels.length, values.length, 1);
   const barWidth = layout.plotWidth / catCount * 0.6;
   const gap = layout.plotWidth / catCount * 0.2;
   const primitives = [];
   const dataLabels = [];
-  let runningTotal = 0;
-  for (let i = 0; i < values.length; i++) {
-    const val2 = values[i] ?? 0;
-    const isLast = i === values.length - 1;
-    const startVal = isLast ? 0 : runningTotal;
-    const endVal = runningTotal + val2;
-    const barStartY = valueToY2(startVal, range, layout.plotTop, layout.plotBottom);
-    const barEndY = valueToY2(endVal, range, layout.plotTop, layout.plotBottom);
+  for (const step of steps) {
+    const { sourceIndex, value, startValue, endValue, isSubtotal } = step;
+    const barStartY = valueToY2(startValue, range, layout.plotTop, layout.plotBottom);
+    const barEndY = valueToY2(endValue, range, layout.plotTop, layout.plotBottom);
+    const i = sourceIndex;
     const x = layout.plotLeft + layout.plotWidth / catCount * i + gap;
     const y = Math.min(barStartY, barEndY);
     const h = Math.max(Math.abs(barEndY - barStartY), 1);
-    const barColor = isLast ? WF_COLOR_TOTAL : val2 >= 0 ? WF_COLOR_POSITIVE : WF_COLOR_NEGATIVE;
+    const barColor = isSubtotal ? WF_COLOR_TOTAL : value >= 0 ? WF_COLOR_POSITIVE : WF_COLOR_NEGATIVE;
     primitives.push({
       kind: "rect",
       x,
@@ -5684,20 +7367,21 @@ function buildWaterfallViewModel(element, chartData, categoryLabels) {
       w: barWidth,
       h,
       fill: barColor,
-      rx: 1
+      rx: 1,
+      part: { role: "dataPoint", seriesIndex: 0, pointIndex: sourceIndex }
     });
     if (chartData.style?.hasDataLabels) {
       dataLabels.push({
         kind: "text",
         x: x + barWidth / 2,
         y: y - 4,
-        text: formatAxisValue2(isLast ? endVal : val2),
+        text: formatAxisValue2(value),
         fontSize: 7,
         fill: "#334155",
         textAnchor: "middle"
       });
     }
-    if (!isLast && i < values.length - 1) {
+    if (series?.waterfallOptions?.connectorLines !== false && i < values.length - 1) {
       const nextX = layout.plotLeft + layout.plotWidth / catCount * (i + 1) + gap;
       primitives.push({
         kind: "line",
@@ -5710,9 +7394,6 @@ function buildWaterfallViewModel(element, chartData, categoryLabels) {
         dashArray: "3 2"
       });
     }
-    if (!isLast) {
-      runningTotal += val2;
-    }
   }
   const { gridlines, axisLabels } = buildGridlinesAndLabels(range, layout);
   const zeroLine = buildZeroLine(range, layout);
@@ -5821,7 +7502,7 @@ function resolveRegionCode(label) {
   return REGION_ALIAS_MAP[normalized];
 }
 function lerpColor(a, b, t) {
-  const clamp3 = (v) => Math.max(0, Math.min(255, Math.round(v)));
+  const clamp7 = (v) => Math.max(0, Math.min(255, Math.round(v)));
   const ha = a.replace("#", "");
   const hb = b.replace("#", "");
   const r1 = parseInt(ha.substring(0, 2), 16);
@@ -5830,9 +7511,9 @@ function lerpColor(a, b, t) {
   const r2 = parseInt(hb.substring(0, 2), 16);
   const g2 = parseInt(hb.substring(2, 4), 16);
   const b2 = parseInt(hb.substring(4, 6), 16);
-  const r = clamp3(r1 + (r2 - r1) * t);
-  const g = clamp3(g1 + (g2 - g1) * t);
-  const bl = clamp3(b1 + (b2 - b1) * t);
+  const r = clamp7(r1 + (r2 - r1) * t);
+  const g = clamp7(g1 + (g2 - g1) * t);
+  const bl = clamp7(b1 + (b2 - b1) * t);
   const toHex = (n) => n.toString(16).padStart(2, "0");
   return `#${toHex(r)}${toHex(g)}${toHex(bl)}`;
 }
@@ -5983,24 +7664,61 @@ var WORLD_REGIONS = [
     labelXY: [838, 378]
   }
 ];
+function regionBounds(region) {
+  const coordinates = region.path.match(/-?\d+(?:\.\d+)?/gu)?.map(Number) ?? [];
+  const xs = [];
+  const ys = [];
+  for (let index = 0; index < coordinates.length; index += 2) {
+    xs.push(coordinates[index] ?? 0);
+    ys.push(coordinates[index + 1] ?? 0);
+  }
+  return {
+    minX: Math.min(...xs),
+    minY: Math.min(...ys),
+    maxX: Math.max(...xs),
+    maxY: Math.max(...ys)
+  };
+}
+function regionViewBounds(viewedRegionType, regionValues) {
+  if (!viewedRegionType || viewedRegionType === "world" || regionValues.size === 0) {
+    return { minX: 0, minY: 0, maxX: 1e3, maxY: 500 };
+  }
+  const matched = WORLD_REGIONS.filter((region) => regionValues.has(region.code));
+  const targets = viewedRegionType === "countryRegion" ? matched.slice(0, 1) : matched;
+  if (targets.length === 0) {
+    return { minX: 0, minY: 0, maxX: 1e3, maxY: 500 };
+  }
+  const bounds = targets.map(regionBounds);
+  const padding = 10;
+  return {
+    minX: Math.max(0, Math.min(...bounds.map((item) => item.minX)) - padding),
+    minY: Math.max(0, Math.min(...bounds.map((item) => item.minY)) - padding),
+    maxX: Math.min(1e3, Math.max(...bounds.map((item) => item.maxX)) + padding),
+    maxY: Math.min(500, Math.max(...bounds.map((item) => item.maxY)) + padding)
+  };
+}
 function buildRegionMapViewModel(element, chartData, categoryLabels) {
   const svgWidth = Math.max(element.width, 320);
   const svgHeight = Math.max(element.height, 200);
   const categories = categoryLabels.length > 0 ? categoryLabels : chartData.categories;
-  const values = chartData.series.length > 0 ? chartData.series[0]?.values ?? [] : [];
+  const series = chartData.series[0];
+  const options = series?.regionMapOptions;
+  const entries = buildRegionMapEntries(categories, series?.values ?? [], options, resolveRegionCode);
+  const values = entries.map((entry) => entry.value);
   const finiteVals = values.filter((v) => Number.isFinite(v));
   const minVal = finiteVals.length > 0 ? Math.min(...finiteVals) : 0;
   const maxVal = finiteVals.length > 0 ? Math.max(...finiteVals) : 1;
   const regionValueMap = /* @__PURE__ */ new Map();
   const unmatchedRows = [];
-  for (let i = 0; i < categories.length; i++) {
-    const cat = categories[i] ?? "";
-    const value = values[i] ?? 0;
-    const code = resolveRegionCode(cat);
-    if (code !== void 0) {
-      regionValueMap.set(code, { value, label: cat });
+  for (const entry of entries) {
+    if (entry.code !== void 0) {
+      regionValueMap.set(entry.code, {
+        value: entry.value,
+        label: entry.label,
+        sourceIndex: entry.sourceIndex
+      });
     } else {
-      unmatchedRows.push({ label: cat, value });
+      unmatchedRows.push({ label: entry.label, value: entry.value });
     }
   }
   const legendHeight = 30;
@@ -6009,9 +7727,12 @@ function buildRegionMapViewModel(element, chartData, categoryLabels) {
   const fallbackTableH = unmatchedRows.length > 0 ? (maxFallbackRows + 1) * fallbackRowH + 8 : 0;
   const titleH = chartData.title ? 22 : 0;
   const mapAreaH = Math.max(svgHeight - titleH - legendHeight - fallbackTableH - 8, 80);
-  const mapScale = Math.min((svgWidth - 20) / 1e3, mapAreaH / 500);
-  const mapOffsetX = (svgWidth - 1e3 * mapScale) / 2;
-  const mapOffsetY = titleH + 4;
+  const viewBounds = regionViewBounds(options?.viewedRegionType, regionValueMap);
+  const viewWidth = Math.max(viewBounds.maxX - viewBounds.minX, 1);
+  const viewHeight = Math.max(viewBounds.maxY - viewBounds.minY, 1);
+  const mapScale = Math.min((svgWidth - 20) / viewWidth, mapAreaH / viewHeight);
+  const mapOffsetX = (svgWidth - viewWidth * mapScale) / 2 - viewBounds.minX * mapScale;
+  const mapOffsetY = titleH + 4 - viewBounds.minY * mapScale;
   const primitives = [];
   primitives.push({
     kind: "rect",
@@ -6046,16 +7767,28 @@ function buildRegionMapViewModel(element, chartData, categoryLabels) {
       d: scaledPath,
       fill,
       stroke: "#94a3b8",
-      strokeWidth: Math.max(0.5 / mapScale, 0.3)
+      strokeWidth: Math.max(0.5 / mapScale, 0.3),
+      ...entry ? {
+        part: {
+          role: "dataPoint",
+          seriesIndex: 0,
+          pointIndex: entry.sourceIndex
+        }
+      } : {}
     });
-    if (entry !== void 0) {
+    const bounds = regionBounds(region);
+    if (entry !== void 0 && shouldRenderRegionLabel(
+      options?.regionLabelLayout,
+      (bounds.maxX - bounds.minX) * mapScale,
+      (bounds.maxY - bounds.minY) * mapScale
+    )) {
       const lx = region.labelXY[0] * mapScale + mapOffsetX;
       const ly = region.labelXY[1] * mapScale + mapOffsetY + 4;
       primitives.push({
         kind: "text",
         x: lx,
         y: ly,
-        text: formatAxisValue2(entry.value),
+        text: formatRegionMapValue(entry.value, options?.cultureLanguage),
         fontSize: Math.max(6, 7 * mapScale),
         fill: "#1e293b",
         textAnchor: "middle",
@@ -6110,6 +7843,17 @@ function buildRegionMapViewModel(element, chartData, categoryLabels) {
       textAnchor: "middle"
     }
   );
+  if (options?.attribution) {
+    primitives.push({
+      kind: "text",
+      x: svgWidth - 4,
+      y: svgHeight - 4,
+      text: options.attribution,
+      fontSize: 5,
+      fill: "#64748b",
+      textAnchor: "end"
+    });
+  }
   if (unmatchedRows.length > 0) {
     const tableY = legendY + 26;
     const fontSize = Math.min(8, fallbackRowH * 0.7);
@@ -6287,14 +8031,17 @@ function computeStackedValueRange(series, catCount) {
 }
 function valueToY2(val2, range, topY, bottomY) {
   const usable = bottomY - topY;
+  let ratio;
   if (range.logScale && range.logBase) {
     const base = range.logBase;
     const clampedVal = Math.max(val2, range.min);
     const logVal = Math.log(clampedVal) / Math.log(base);
     const logMin = Math.log(range.min) / Math.log(base);
-    return bottomY - (logVal - logMin) / range.span * usable;
+    ratio = (logVal - logMin) / range.span;
+  } else {
+    ratio = (val2 - range.min) / range.span;
   }
-  return bottomY - (val2 - range.min) / range.span * usable;
+  return range.reverseOrder ? topY + ratio * usable : bottomY - ratio * usable;
 }
 function formatAxisValue2(val2) {
   if (Math.abs(val2) >= 1e6) {
@@ -6355,7 +8102,7 @@ function computePlotLayout(elementWidth, elementHeight, chartData, hasAxes, opti
   };
 }
 var GRIDLINE_COLOR2 = "#e2e8f0";
-var AXIS_LABEL_COLOR2 = "#64748b";
+var AXIS_LABEL_COLOR = "#64748b";
 var ZERO_LINE_COLOR = "#94a3b8";
 var TICK_COUNT2 = 5;
 function buildGridlinesAndLabels(range, layout) {
@@ -6379,7 +8126,7 @@ function buildGridlinesAndLabels(range, layout) {
       y,
       text: formatAxisValue2(val2),
       fontSize: 8,
-      fill: AXIS_LABEL_COLOR2,
+      fill: AXIS_LABEL_COLOR,
       textAnchor: "end",
       dominantBaseline: "central"
     });
@@ -6411,7 +8158,7 @@ function buildCategoryLabels(categoryLabels, layout, catSpacing) {
       y: layout.plotBottom + 12,
       text: label,
       fontSize: 8,
-      fill: AXIS_LABEL_COLOR2,
+      fill: AXIS_LABEL_COLOR,
       textAnchor: "middle"
     };
   });
@@ -6565,9 +8312,12 @@ function computePieSlices(values, cx, cy, outerR, innerR) {
     return computePieSlicePath(cx, cy, outerR, innerR, startAngle, cumAngle);
   });
 }
-function computeScatterDots(values, maxXIndex, layout, range) {
+function computeScatterDots(values, maxXIndex, layout, range, xValues) {
+  const finiteX = xValues?.slice(0, values.length).filter(Number.isFinite);
+  const minX = finiteX?.length ? Math.min(...finiteX) : 0;
+  const spanX = finiteX?.length ? Math.max(Math.max(...finiteX) - minX, 1) : maxXIndex;
   return values.map((val2, i) => ({
-    cx: layout.plotLeft + (maxXIndex > 0 ? i / maxXIndex : 0) * layout.plotWidth,
+    cx: layout.plotLeft + (spanX > 0 ? (Number.isFinite(xValues?.[i]) ? xValues[i] - minX : i) / spanX : 0) * layout.plotWidth,
     cy: valueToY2(val2, range, layout.plotTop, layout.plotBottom)
   }));
 }
@@ -6983,13 +8733,14 @@ function valueFromY(y, range, topY, bottomY) {
   if (usable === 0) {
     return range.min;
   }
+  const ratio = range.reverseOrder ? (y - topY) / usable : (bottomY - y) / usable;
   if (range.logScale && range.logBase) {
     const base = range.logBase;
     const logMin = Math.log(range.min) / Math.log(base);
-    const logVal = logMin + (bottomY - y) / usable * range.span;
+    const logVal = logMin + ratio * range.span;
     return base ** logVal;
   }
-  return range.min + (bottomY - y) / usable * range.span;
+  return range.min + ratio * range.span;
 }
 function roundDragValue(value, range) {
   if (!Number.isFinite(value) || range.span <= 0) {
@@ -6999,16 +8750,16 @@ function roundDragValue(value, range) {
   const rounded = Math.round(value / step) * step;
   return Number.parseFloat(rounded.toPrecision(12));
 }
-function rangeForSeries(drag, seriesIndex) {
+function rangeForSeries2(drag, seriesIndex) {
   const useSecondary = drag.secondaryRange !== void 0 && (drag.secondarySeriesIndexes?.includes(seriesIndex) ?? false);
   return useSecondary && drag.secondaryRange ? drag.secondaryRange : drag.range;
 }
 function dragValueForPart(viewY, drag, seriesIndex) {
-  const range = rangeForSeries(drag, seriesIndex);
+  const range = rangeForSeries2(drag, seriesIndex);
   return roundDragValue(valueFromY(viewY, range, drag.plotTop, drag.plotBottom), range);
 }
 function dragAnchorViewY(value, drag, seriesIndex) {
-  return valueToY2(value, rangeForSeries(drag, seriesIndex), drag.plotTop, drag.plotBottom);
+  return valueToY2(value, rangeForSeries2(drag, seriesIndex), drag.plotTop, drag.plotBottom);
 }
 function withChartPointValue(chartData, seriesIndex, pointIndex, value) {
   const series = chartData.series[seriesIndex];
@@ -7311,8 +9062,8 @@ function hexToRgb3(hex) {
   };
 }
 function rgbToHex3(r, g, b) {
-  const clamp3 = (v) => Math.max(0, Math.min(255, Math.round(v)));
-  return `#${clamp3(r).toString(16).padStart(2, "0")}${clamp3(g).toString(16).padStart(2, "0")}${clamp3(b).toString(16).padStart(2, "0")}`;
+  const clamp7 = (v) => Math.max(0, Math.min(255, Math.round(v)));
+  return `#${clamp7(r).toString(16).padStart(2, "0")}${clamp7(g).toString(16).padStart(2, "0")}${clamp7(b).toString(16).padStart(2, "0")}`;
 }
 function rgbToHsl(r, g, b) {
   const rn = r / 255;
@@ -10206,7 +11957,7 @@ function rotateDelta(dx, dy, rotationDeg) {
 }
 function applyResize(box, handle, dxScreen, dyScreen, zoom, opts = {}) {
   const scale = zoom || 1;
-  const minSize = opts.minSize ?? chunkEXDUEXTO_js.MIN_ELEMENT_SIZE;
+  const minSize = opts.minSize ?? chunkAD3EAEY6_js.MIN_ELEMENT_SIZE;
   const rotation = rotationOf(box);
   const local = rotateDelta(dxScreen / scale, dyScreen / scale, rotation);
   const dx = local.x;
@@ -10233,7 +11984,7 @@ function applyResize(box, handle, dxScreen, dyScreen, zoom, opts = {}) {
   }
   return { x: newX, y: newY, width: newW, height: newH, rotation };
 }
-function snapBoxToGrid(box, handle, gridSpacingPx, minSize = chunkEXDUEXTO_js.MIN_ELEMENT_SIZE) {
+function snapBoxToGrid(box, handle, gridSpacingPx, minSize = chunkAD3EAEY6_js.MIN_ELEMENT_SIZE) {
   if (handle === null || gridSpacingPx <= 0) {
     return box;
   }
@@ -10263,7 +12014,7 @@ function snapBoxToGrid(box, handle, gridSpacingPx, minSize = chunkEXDUEXTO_js.MI
   }
   return { x, y, width, height };
 }
-function computeMarqueeHitIds(marquee, elements, minSize = chunkEXDUEXTO_js.MIN_ELEMENT_SIZE) {
+function computeMarqueeHitIds(marquee, elements, minSize = chunkAD3EAEY6_js.MIN_ELEMENT_SIZE) {
   const minX = Math.min(marquee.startX, marquee.currentX);
   const minY = Math.min(marquee.startY, marquee.currentY);
   const maxX = Math.max(marquee.startX, marquee.currentX);
@@ -10366,6 +12117,16 @@ function getSlideBackgroundStyle(slide) {
     style["background-repeat"] = "no-repeat";
   } else if (slide?.backgroundGradient) {
     style["background-image"] = slide.backgroundGradient;
+  } else if (pattern) {
+    const svg = getPatternSvg(
+      pattern.preset,
+      pattern.fgColor ?? solid ?? "#000000",
+      pattern.bgColor ?? DEFAULT_SLIDE_BACKGROUND
+    );
+    if (svg) {
+      style["background-image"] = `url("data:image/svg+xml,${encodeURIComponent(svg)}")`;
+      style["background-repeat"] = "repeat";
+    }
   }
   return style;
 }
@@ -10571,6 +12332,37 @@ function resolveSlideId(slide, index) {
   const cSld = rawXml?.["p:sld"];
   return String(cSld?.["@_id"] || slide?.slideNumber || index + 1);
 }
+function groupSlidesBySection(sections, slides) {
+  if (slides.length === 0) {
+    return [];
+  }
+  if (sections.length === 0) {
+    return [
+      { section: void 0, slides: [...slides], slideIndexes: slides.map((_slide, i) => i) }
+    ];
+  }
+  const sectionById = new Map(sections.map((section) => [section.id, section]));
+  const grouped = /* @__PURE__ */ new Map();
+  const ungrouped = {
+    section: void 0,
+    slides: [],
+    slideIndexes: []
+  };
+  for (const section of sections) {
+    grouped.set(section.id, { section, slides: [], slideIndexes: [] });
+  }
+  slides.forEach((slide, index) => {
+    const group = slide.sectionId ? grouped.get(slide.sectionId) : void 0;
+    const target = group && sectionById.has(slide.sectionId ?? "") ? group : ungrouped;
+    target.slides.push(slide);
+    target.slideIndexes.push(index);
+  });
+  const result = sections.map((section) => grouped.get(section.id)).filter((group) => group.slides.length > 0);
+  if (ungrouped.slides.length > 0) {
+    result.push(ungrouped);
+  }
+  return result;
+}
 function addSection(sections, slides, name, afterSlideIndex, idGenerator = generateSectionId) {
   const newId = idGenerator();
   const slideAtIndex = slides[afterSlideIndex];
@@ -10899,6 +12691,19 @@ function generateTicks(slideLengthPx, scale, unit) {
   }
   return ticks;
 }
+function resolvePictureBullet(info, baseFontSize) {
+  if (!info.imageDataUrl && !info.imageRelId && !info.imageBlipFillXml) {
+    return void 0;
+  }
+  const sizePx = typeof info.sizePts === "number" ? info.sizePts : typeof info.sizePercent === "number" ? baseFontSize * (info.sizePercent / 100) : baseFontSize;
+  return {
+    ...info.imageDataUrl ? { src: info.imageDataUrl } : {},
+    sizePx,
+    fallbackMarker: "\u2022",
+    accessibleLabel: "Bullet",
+    ...info.imageRelId ? { imageRelId: info.imageRelId } : {}
+  };
+}
 var BLOCKED_PROTOCOLS = /* @__PURE__ */ new Set([
   `${"javascript"}:`,
   "data:",
@@ -11705,16 +13510,12 @@ function purifyFn() {
   const purify = DOMPurify__default.default;
   return typeof purify.sanitize === "function" ? purify.sanitize : void 0;
 }
-function sanitizeMarkupOrRaw(markup, config) {
-  const sanitize = purifyFn();
-  return sanitize ? sanitize(markup, config) : markup;
-}
 function sanitizeMarkupOrEmpty(markup, config) {
   const sanitize = purifyFn();
   return sanitize ? sanitize(markup, config) : "";
 }
 function sanitizeMathMl(markup) {
-  const sanitized = sanitizeMarkupOrRaw(markup, { USE_PROFILES: { mathMl: true, svg: true } });
+  const sanitized = sanitizeMarkupOrEmpty(markup, { USE_PROFILES: { mathMl: true, svg: true } });
   if (/<math(?:\s|>)/iu.test(markup) && !/<math(?:\s|>)/iu.test(sanitized) && sanitized) {
     return `<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline">${sanitized}</math>`;
   }
@@ -11729,8 +13530,8 @@ function hexToRgb6(hex) {
   };
 }
 function rgbToHex5(r, g, b) {
-  const clamp3 = (v) => Math.max(0, Math.min(255, Math.round(v)));
-  return `#${clamp3(r).toString(16).padStart(2, "0").toUpperCase()}${clamp3(g).toString(16).padStart(2, "0").toUpperCase()}${clamp3(b).toString(16).padStart(2, "0").toUpperCase()}`;
+  const clamp7 = (v) => Math.max(0, Math.min(255, Math.round(v)));
+  return `#${clamp7(r).toString(16).padStart(2, "0").toUpperCase()}${clamp7(g).toString(16).padStart(2, "0").toUpperCase()}${clamp7(b).toString(16).padStart(2, "0").toUpperCase()}`;
 }
 function tintColor2(hex, tintFactor) {
   const { r, g, b } = hexToRgb6(hex);
@@ -11768,7 +13569,7 @@ var THEME_COLOR_LABELS = {
 };
 function buildThemeColorGrid(colorScheme) {
   return THEME_COLOR_TINT_ROWS.map(
-    (row) => chunkEXDUEXTO_js.THEME_COLOR_SCHEME_KEYS.map((key) => ({
+    (row) => chunkAD3EAEY6_js.THEME_COLOR_SCHEME_KEYS.map((key) => ({
       hex: row.transform(colorScheme[key]),
       schemeKey: key,
       rowLabel: row.label,
@@ -12244,7 +14045,7 @@ function svgLineCap(lineCap) {
 }
 function copyFormatFromElement(element) {
   const result = {};
-  if (chunkEXDUEXTO_js.hasShapeProperties(element) && element.shapeStyle) {
+  if (chunkAD3EAEY6_js.hasShapeProperties(element) && element.shapeStyle) {
     const s = element.shapeStyle;
     result.shapeStyle = {
       fillColor: s.fillColor,
@@ -12273,7 +14074,7 @@ function copyFormatFromElement(element) {
       softEdgeRadius: s.softEdgeRadius
     };
   }
-  if (chunkEXDUEXTO_js.hasTextProperties(element) && element.textStyle) {
+  if (chunkAD3EAEY6_js.hasTextProperties(element) && element.textStyle) {
     const t = element.textStyle;
     result.textStyle = {
       fontFamily: t.fontFamily,
@@ -12304,7 +14105,7 @@ function definedEntries(obj) {
 }
 function applyFormatToElement(element, format) {
   let updated = { ...element };
-  if (format.shapeStyle && chunkEXDUEXTO_js.hasShapeProperties(updated)) {
+  if (format.shapeStyle && chunkAD3EAEY6_js.hasShapeProperties(updated)) {
     updated = {
       ...updated,
       shapeStyle: {
@@ -12313,7 +14114,7 @@ function applyFormatToElement(element, format) {
       }
     };
   }
-  if (format.textStyle && chunkEXDUEXTO_js.hasTextProperties(updated)) {
+  if (format.textStyle && chunkAD3EAEY6_js.hasTextProperties(updated)) {
     updated = {
       ...updated,
       textStyle: {
@@ -12328,7 +14129,7 @@ function hasCopyableFormat(element) {
   if (!element) {
     return false;
   }
-  return chunkEXDUEXTO_js.hasShapeProperties(element) || chunkEXDUEXTO_js.hasTextProperties(element);
+  return chunkAD3EAEY6_js.hasShapeProperties(element) || chunkAD3EAEY6_js.hasTextProperties(element);
 }
 function copySegmentMetadata(from, to) {
   if (from.equationXml !== void 0) {
@@ -12465,7 +14266,7 @@ function getRoundRectRadiusPx(element) {
   return Math.min(Math.max(element.width, 1), Math.max(element.height, 1)) * 0.5 * normalizedAdjustment;
 }
 function getShapeAdjustmentHandleDescriptor(element) {
-  if (!chunkEXDUEXTO_js.hasShapeProperties(element)) {
+  if (!chunkAD3EAEY6_js.hasShapeProperties(element)) {
     return null;
   }
   const normalizedShapeType = String(element.shapeType || "").toLowerCase();
@@ -12918,6 +14719,7 @@ var SCALAR_ELEMENT_KEYS = /* @__PURE__ */ new Set([
   "mediaMimeType",
   "mediaReferenceKind",
   "mediaReferenceName",
+  "mediaReferenceContentType",
   "trimStartMs",
   "trimEndMs",
   "posterFramePath",
@@ -12952,9 +14754,11 @@ var SCALAR_ELEMENT_KEYS = /* @__PURE__ */ new Set([
   "inkWidths",
   "inkOpacities",
   "inkTool",
+  "inkPartPath",
   "zoomType",
   "targetSlideIndex",
   "targetSectionId",
+  "summaryLayout",
   "modelPath",
   "modelMimeType",
   "posterImage",
@@ -12988,6 +14792,8 @@ var COMPLEX_ELEMENT_FIELDS = {
   groupFill: "_gf",
   inkPointPressures: "_ipp",
   inkStrokes: "_cis",
+  inkPartRawXml: "_cirx",
+  summaryTargets: "_zst",
   extensionXml: "_ext",
   customGeometryPaths: "_cgp",
   customGeometryRawData: "_cgr",
@@ -13451,7 +15257,7 @@ function createSyncGate(onOpen, graceMs = INITIAL_SYNC_GRACE_MS) {
 var POSITION_THRESHOLD = 2;
 var SIZE_THRESHOLD = 2;
 function getElementText(element) {
-  if (!chunkEXDUEXTO_js.hasTextProperties(element)) {
+  if (!chunkAD3EAEY6_js.hasTextProperties(element)) {
     return "";
   }
   if (element.textSegments && element.textSegments.length > 0) {
@@ -13629,6 +15435,38 @@ function compareSlides(base, compare) {
 function comparePresentation(base, compare) {
   return compareSlides(base.slides, compare.slides);
 }
+function applyAcceptSlide(slides, diff) {
+  const next = [...slides];
+  if (diff.status === "added" && diff.compareSlide) {
+    next.splice(Math.min(diff.compareIndex, next.length), 0, { ...diff.compareSlide });
+  } else if (diff.status === "changed" && diff.compareSlide && diff.baseIndex >= 0) {
+    next[diff.baseIndex] = { ...diff.compareSlide };
+  } else if (diff.status === "removed" && diff.baseIndex >= 0) {
+    next.splice(diff.baseIndex, 1);
+  }
+  return next;
+}
+function applyAcceptAllSlides(slides, compareResult) {
+  const next = [...slides];
+  const diffs = [...compareResult.diffs];
+  for (const diff of diffs) {
+    if (diff.status === "changed" && diff.compareSlide && diff.baseIndex >= 0 && diff.baseIndex < next.length) {
+      next[diff.baseIndex] = { ...diff.compareSlide };
+    }
+  }
+  for (let index = diffs.length - 1; index >= 0; index--) {
+    const diff = diffs[index];
+    if (diff.status === "removed" && diff.baseIndex >= 0 && diff.baseIndex < next.length) {
+      next.splice(diff.baseIndex, 1);
+    }
+  }
+  for (const diff of diffs) {
+    if (diff.status === "added" && diff.compareSlide) {
+      next.splice(Math.min(diff.compareIndex, next.length), 0, { ...diff.compareSlide });
+    }
+  }
+  return next;
+}
 function resolveDirection(direction, defaultDir) {
   switch (direction) {
     case "l":
@@ -16850,6 +18688,15 @@ function setCachedResult(key, dataUrl) {
   }
   colorChangeCache.set(key, dataUrl);
 }
+function getImageColorWashStyle(wash) {
+  if (!wash?.color) {
+    return void 0;
+  }
+  return {
+    backgroundColor: wash.color,
+    opacity: Math.max(0, Math.min(100, wash.opacity)) / 100
+  };
+}
 function mapDuotonePixels(data, shadow, highlight) {
   const len = data.length;
   for (let i = 0; i < len; i += 4) {
@@ -16984,7 +18831,7 @@ function getAriaRole(element) {
     case "model3d":
       return "img";
     case "shape": {
-      if (chunkEXDUEXTO_js.hasTextProperties(element) && element.text) {
+      if (chunkAD3EAEY6_js.hasTextProperties(element) && element.text) {
         return "group";
       }
       return "img";
@@ -16997,7 +18844,7 @@ function getAriaLabel(element) {
   if ((element.type === "image" || element.type === "picture") && "altText" in element && typeof element.altText === "string" && element.altText.trim()) {
     return element.altText.trim();
   }
-  if (chunkEXDUEXTO_js.hasTextProperties(element) && element.text) {
+  if (chunkAD3EAEY6_js.hasTextProperties(element) && element.text) {
     const text = element.text.trim();
     if (text) {
       return text.length > 120 ? `${text.slice(0, 117)}...` : text;
@@ -17404,7 +19251,7 @@ var DEFAULT_CHART_POSITION = { x: 120, y: 120, width: 480, height: 320 };
 var DEFAULT_CATEGORIES = ["Category 1", "Category 2", "Category 3"];
 var DEFAULT_SERIES_VALUES = [4, 3, 5];
 function createDefaultChartElement(chartType = DEFAULT_INSERT_CHART_TYPE, position) {
-  return chunkEXDUEXTO_js.createChartElement(
+  return chunkAD3EAEY6_js.createChartElement(
     chartType,
     {
       categories: [...DEFAULT_CATEGORIES],
@@ -17536,6 +19383,55 @@ function rebuildDrawingShapesIfCleared(smartArtData, layout, palette, style, ele
     drawingShapes: reflowToDrawingShapes(layoutResult, smartArtData.nodes)
   };
 }
+function buildSummaryZoomView(element, lookup) {
+  if (element.zoomType !== "summary" || !element.summaryTargets?.length) {
+    return void 0;
+  }
+  const layout = element.summaryLayout ?? "grid";
+  const columns = Math.max(1, Math.ceil(Math.sqrt(element.summaryTargets.length)));
+  const tiles = element.summaryTargets.map((target, index) => {
+    const targetInfo = lookup?.(target.targetSlideIndex);
+    const label = target.title || targetInfo?.sectionName || target.sectionId;
+    const slideNumber = targetInfo?.slideNumber ?? target.targetSlideIndex + 1;
+    return {
+      key: `${target.sectionId}:${index}`,
+      sectionId: target.sectionId,
+      targetSlideIndex: target.targetSlideIndex,
+      label,
+      slideLabel: `Slide ${slideNumber}`,
+      imageSrc: target.imageData,
+      backgroundColor: targetInfo?.backgroundColor ?? "#f0f0f0",
+      style: layout === "fixed" ? fixedTileStyle(element, target.x, target.y, target.width, target.height) : { position: "relative", minWidth: "0", minHeight: "0" },
+      ariaLabel: `Zoom to section ${label}, slide ${slideNumber}`
+    };
+  });
+  return {
+    layout,
+    containerStyle: layout === "fixed" ? { position: "relative", width: "100%", height: "100%" } : {
+      display: "grid",
+      gridTemplateColumns: `repeat(${columns}, minmax(0, 1fr))`,
+      gap: "4px",
+      width: "100%",
+      height: "100%"
+    },
+    tiles,
+    ariaLabel: `Summary Zoom with ${tiles.length} sections`
+  };
+}
+function fixedTileStyle(element, x, y, width, height) {
+  const safeWidth = Math.max(element.width, 1);
+  const safeHeight = Math.max(element.height, 1);
+  return {
+    position: "absolute",
+    left: percent((x - element.x) / safeWidth),
+    top: percent((y - element.y) / safeHeight),
+    width: percent(width / safeWidth),
+    height: percent(height / safeHeight)
+  };
+}
+function percent(value) {
+  return `${Math.round(value * 1e5) / 1e3}%`;
+}
 var ARTISTIC_EFFECTS = [
   ["none", "pptx.image.effectNone", ""],
   ["blur", "pptx.image.effectBlur", "blur(4px)"],
@@ -18132,6 +20028,55 @@ function putAutosaveRecord(filePath, data) {
     })
   );
 }
+async function getAutosaveSnapshot(filePath) {
+  const db = await openAutosaveDb();
+  return new Promise((resolve) => {
+    const tx = db.transaction(AUTOSAVE_STORE_NAME, "readonly");
+    const store = tx.objectStore(AUTOSAVE_STORE_NAME);
+    const req = store.get(filePath);
+    req.onsuccess = () => {
+      db.close();
+      resolve(req.result);
+    };
+    req.onerror = () => {
+      db.close();
+      resolve(void 0);
+    };
+  });
+}
+async function listAutosaveSnapshots() {
+  const db = await openAutosaveDb();
+  return new Promise((resolve) => {
+    const results = [];
+    try {
+      const tx = db.transaction(AUTOSAVE_STORE_NAME, "readonly");
+      const store = tx.objectStore(AUTOSAVE_STORE_NAME);
+      const cursorReq = store.openCursor();
+      cursorReq.onsuccess = () => {
+        const cursor = cursorReq.result;
+        if (cursor) {
+          const val2 = cursor.value;
+          results.push({ key: val2.key, timestamp: val2.timestamp, size: val2.size });
+          cursor.continue();
+        }
+      };
+      tx.oncomplete = () => {
+        db.close();
+        resolve(results);
+      };
+      tx.onerror = () => {
+        db.close();
+        resolve([]);
+      };
+    } catch {
+      try {
+        db.close();
+      } catch {
+      }
+      resolve([]);
+    }
+  });
+}
 async function saveAutosaveSnapshot(filePath, data) {
   try {
     return await putAutosaveRecord(filePath, data);
@@ -18147,6 +20092,233 @@ async function saveAutosaveSnapshot(filePath, data) {
     return putAutosaveRecord(filePath, data);
   }
 }
+var BACKSTAGE_NAV = [
+  { id: "home", label: "Home" },
+  { id: "new", label: "New" },
+  { id: "open", label: "Open" },
+  { id: "info", label: "Info" },
+  { id: "save", label: "Save" },
+  { id: "saveAs", label: "Save As" },
+  { id: "print", label: "Print" },
+  { id: "share", label: "Share" },
+  { id: "export", label: "Export" },
+  { id: "close", label: "Close" },
+  { id: "account", label: "Account", group: "footer" },
+  { id: "options", label: "Options", group: "footer" }
+];
+var BACKSTAGE_TEMPLATES = [
+  {
+    id: "blank",
+    name: "Blank Presentation",
+    description: "Start with a clean canvas",
+    preview: "linear-gradient(145deg, #fff 0 88%, #d34a1f 88%)"
+  },
+  {
+    id: "warm",
+    name: "Warm Welcome",
+    description: "Bold editorial title slides",
+    preview: "linear-gradient(135deg, #d94b20 0 62%, #f4b183 62%)"
+  },
+  {
+    id: "geometry",
+    name: "Geometric",
+    description: "Modern shapes and strong contrast",
+    preview: "conic-gradient(from 220deg, #173b8f, #dce6ff, #efb7bd, #173b8f)"
+  },
+  {
+    id: "mono",
+    name: "Urban Monochrome",
+    description: "Architectural black and white",
+    preview: "linear-gradient(125deg, #171717, #eee 49%, #777 50%, #fafafa)"
+  },
+  {
+    id: "earth",
+    name: "Earthy Inspiration",
+    description: "Natural, calm presentation system",
+    preview: "radial-gradient(circle at 70% 30%, #be9473, #34271f 38%, #111 70%)"
+  },
+  {
+    id: "future",
+    name: "Future Forward",
+    description: "Clean technology storytelling",
+    preview: "repeating-radial-gradient(ellipse at bottom, #111 0 3px, #fff 4px 13px)"
+  }
+];
+var TEMPLATE_BACKGROUNDS = {
+  blank: { backgroundColor: "#ffffff" },
+  warm: {
+    backgroundColor: "#d94b20",
+    backgroundGradient: "linear-gradient(135deg, #d94b20 0 62%, #f4b183 62%)"
+  },
+  geometry: {
+    backgroundColor: "#dce6ff",
+    backgroundGradient: "linear-gradient(135deg, #173b8f, #dce6ff 54%, #efb7bd)"
+  },
+  mono: {
+    backgroundColor: "#f4f4f4",
+    backgroundGradient: "linear-gradient(125deg, #171717, #eeeeee 49%, #777777 50%, #fafafa)"
+  },
+  earth: {
+    backgroundColor: "#34271f",
+    backgroundGradient: "radial-gradient(circle at 70% 30%, #be9473, #34271f 38%, #111111 70%)"
+  },
+  future: {
+    backgroundColor: "#ffffff",
+    backgroundGradient: "repeating-radial-gradient(ellipse at bottom, #111111 0 3px, #ffffff 4px 13px)"
+  }
+};
+function createBackstagePresentation(templateId) {
+  const slide = createBlankSlide(1);
+  return [{ ...slide, ...TEMPLATE_BACKGROUNDS[templateId] ?? TEMPLATE_BACKGROUNDS.blank }];
+}
+function splitFilePath(path) {
+  const normalized = path.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  return {
+    name: parts[parts.length - 1] || "Untitled Presentation.pptx",
+    location: parts.slice(0, -1).join("/") || "Browser storage"
+  };
+}
+async function listBackstageRecentFiles() {
+  if (typeof indexedDB === "undefined") {
+    return [];
+  }
+  try {
+    const snapshots = await listAutosaveSnapshots();
+    return snapshots.map((snapshot) => ({ ...snapshot, ...splitFilePath(snapshot.key) })).sort((a, b) => b.timestamp - a.timestamp);
+  } catch {
+    return [];
+  }
+}
+async function readBackstageRecentFile(key) {
+  if (typeof indexedDB === "undefined") {
+    return void 0;
+  }
+  return (await getAutosaveSnapshot(key))?.data;
+}
+function formatBackstageDate(timestamp, now = Date.now()) {
+  const elapsed = Math.max(0, now - timestamp);
+  if (elapsed < 6e4) {
+    return "Just now";
+  }
+  if (elapsed < 36e5) {
+    return `${Math.floor(elapsed / 6e4)} min ago`;
+  }
+  if (elapsed < 864e5) {
+    return `${Math.floor(elapsed / 36e5)} hr ago`;
+  }
+  return new Intl.DateTimeFormat(void 0, { month: "short", day: "numeric" }).format(timestamp);
+}
+function formatBackstageSize(bytes) {
+  if (bytes < 1024 * 1024) {
+    return `${Math.max(1, Math.round(bytes / 1024))} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+var DEFAULT_VIRTUAL_OVERSCAN = 5;
+var SLIDE_VIRTUALIZATION_THRESHOLD = 50;
+function computeVirtualRange(totalItems, itemHeight, scrollTop, viewportHeight, overscan = DEFAULT_VIRTUAL_OVERSCAN) {
+  const safeCount = Math.max(0, totalItems);
+  const safeItemHeight = Math.max(itemHeight, 1);
+  const totalHeight = safeCount * safeItemHeight;
+  if (safeCount === 0) {
+    return {
+      startIndex: 0,
+      endIndex: -1,
+      totalHeight: 0,
+      offsetY: 0,
+      visibleRange: { start: 0, end: -1 }
+    };
+  }
+  const visibleStart = Math.min(safeCount - 1, Math.max(0, Math.floor(scrollTop / safeItemHeight)));
+  const visibleEnd = Math.min(
+    safeCount - 1,
+    Math.max(visibleStart, Math.floor((scrollTop + Math.max(0, viewportHeight)) / safeItemHeight))
+  );
+  const safeOverscan = Math.max(0, overscan);
+  const startIndex = Math.max(0, visibleStart - safeOverscan);
+  const endIndex = Math.min(safeCount - 1, visibleEnd + safeOverscan);
+  return {
+    startIndex,
+    endIndex,
+    totalHeight,
+    offsetY: startIndex * safeItemHeight,
+    visibleRange: { start: visibleStart, end: visibleEnd }
+  };
+}
+function collectFontsFromElement(element, fonts) {
+  if (chunkAD3EAEY6_js.hasTextProperties(element)) {
+    if (element.textStyle?.fontFamily) {
+      fonts.add(element.textStyle.fontFamily);
+    }
+    for (const segment of element.textSegments ?? []) {
+      if (segment.style?.fontFamily) {
+        fonts.add(segment.style.fontFamily);
+      }
+    }
+  }
+  if (element.type === "group") {
+    for (const child2 of element.children ?? []) {
+      collectFontsFromElement(child2, fonts);
+    }
+  }
+}
+function collectUsedFonts(slides) {
+  const fonts = /* @__PURE__ */ new Set();
+  for (const slide of slides) {
+    for (const element of slide.elements ?? []) {
+      collectFontsFromElement(element, fonts);
+    }
+  }
+  return [...fonts].sort();
+}
+function browserFontSource() {
+  return typeof document === "undefined" ? void 0 : document.fonts;
+}
+function isFontFamilyAvailable(family, source = browserFontSource()) {
+  if (!source) {
+    return false;
+  }
+  try {
+    const escaped = family.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    return source.check(`12px "${escaped}"`);
+  } catch {
+    return false;
+  }
+}
+async function scanAvailableFontFamilies(families, source = browserFontSource()) {
+  if (!source) {
+    return /* @__PURE__ */ new Set();
+  }
+  try {
+    await source.ready;
+    return new Set(families.filter((family) => isFontFamilyAvailable(family, source)));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function shouldLoopContinuously(input) {
+  return Boolean(input.loopContinuously) || input.showType === "kiosk";
+}
+function applyRehearsalTimings(slides, timings) {
+  return slides.map((slide, index) => {
+    const advanceAfterMs = timings[index];
+    if (typeof advanceAfterMs !== "number") {
+      return slide;
+    }
+    return {
+      ...slide,
+      transition: {
+        ...slide.transition,
+        type: slide.transition?.type ?? "none",
+        advanceAfterMs
+      }
+    };
+  });
+}
+function computeEntranceAnimationDelay(delayMs, animationIndex) {
+  return Math.max(0, delayMs || 0) + animationIndex * 60;
+}
 var FALLBACK_DOWNLOAD_NAME = "presentation.pptx";
 var REVOKE_DELAY_MS = 200;
 var OPEN_REVOKE_DELAY_MS = 6e4;
@@ -18239,6 +20411,22 @@ function canvasToJpegData(canvas, quality = 0.92) {
   }
   return { bytes, w: canvas.width, h: canvas.height };
 }
+function generatePackageReadme(presentationFilename) {
+  return [
+    "Presentation Package",
+    "====================",
+    "",
+    `This folder contains the presentation "${presentationFilename}" along with`,
+    "all linked media files (images, audio, video) in the /media subfolder.",
+    "",
+    "To view this presentation:",
+    "1. Open the presentation file with any compatible presentation software",
+    "2. Ensure the /media folder remains alongside the presentation file",
+    "",
+    `Packaged on ${(/* @__PURE__ */ new Date()).toLocaleDateString()}`,
+    ""
+  ].join("\n");
+}
 function encodeGif(frames, delay = {}) {
   if (frames.length === 0) {
     throw new Error("[gif-encoder] encodeGif: frames array must not be empty");
@@ -18699,11 +20887,11 @@ function buildNotesTextStream(lines, startY) {
   let content = `BT /F1 ${NOTES_FONT_SIZE} Tf 0 0 0 rg `;
   content += `${NOTES_MARGIN} ${startY.toFixed(2)} Td `;
   for (let li = 0; li < lines.length; li++) {
-    const line = lines[li];
+    const line2 = lines[li];
     if (li === 0) {
-      content += `(${escapePdfText(line)}) Tj `;
+      content += `(${escapePdfText(line2)}) Tj `;
     } else {
-      content += `0 ${(-15.399999999999999).toFixed(2)} Td (${escapePdfText(line)}) Tj `;
+      content += `0 ${(-15.399999999999999).toFixed(2)} Td (${escapePdfText(line2)}) Tj `;
     }
   }
   content += "ET\n";
@@ -18748,12 +20936,24 @@ function isSafeSvgMarkup(svg) {
   }
   return !EVENT_HANDLER_ATTR_RE.test(trimmed);
 }
+function sanitizeSlideSvg(svg, width, height) {
+  if (!isSafeSvgMarkup(svg)) {
+    return "";
+  }
+  const sanitized = sanitizeMarkupOrEmpty(svg, { USE_PROFILES: { svg: true } }).trim();
+  if (!sanitized || sanitized.toLowerCase().startsWith("<svg")) {
+    return sanitized;
+  }
+  const safeWidth = Number.isFinite(width) && width > 0 ? width : 1;
+  const safeHeight = Number.isFinite(height) && height > 0 ? height : 1;
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${safeWidth} ${safeHeight}" width="${safeWidth}" height="${safeHeight}">${sanitized}</svg>`;
+}
 function buildPrintDocument(svgs, width, height, options = {}) {
   const { title = "Print", orientation = "landscape", colorFilter = "" } = options;
   const safeOrientation = sanitizeOrientation(orientation);
   const safeColorFilter = sanitizeCssDeclaration(colorFilter);
   const slidePages = svgs.map((svg, i) => {
-    const safeSvg = isSafeSvgMarkup(svg) ? sanitizeMarkupOrEmpty(svg, { USE_PROFILES: { svg: true } }) : "";
+    const safeSvg = sanitizeSlideSvg(svg, width, height);
     return `<section class="print-slide-page" aria-label="Slide ${i + 1}">
   ${safeSvg}
 </section>`;
@@ -19749,6 +21949,8 @@ function segmentFrameCount(durationMs, fps) {
 
 exports.ACTION_BUTTON_PRESETS = ACTION_BUTTON_PRESETS;
 exports.ARTISTIC_EFFECTS = ARTISTIC_EFFECTS;
+exports.BACKSTAGE_NAV = BACKSTAGE_NAV;
+exports.BACKSTAGE_TEMPLATES = BACKSTAGE_TEMPLATES;
 exports.BROADCAST_THROTTLE_MS = BROADCAST_THROTTLE_MS;
 exports.CATEGORIES = CATEGORIES;
 exports.CONNECTION_TIMEOUT_MS = CONNECTION_TIMEOUT_MS;
@@ -19756,6 +21958,7 @@ exports.DEFAULT_BROADCAST_SERVER_URL = DEFAULT_BROADCAST_SERVER_URL;
 exports.DEFAULT_COLOR_CHANGE_TOLERANCE = DEFAULT_COLOR_CHANGE_TOLERANCE;
 exports.DEFAULT_INSERT_CHART_TYPE = DEFAULT_INSERT_CHART_TYPE;
 exports.DEFAULT_ROW_HEIGHT = DEFAULT_ROW_HEIGHT;
+exports.DEFAULT_VIRTUAL_OVERSCAN = DEFAULT_VIRTUAL_OVERSCAN;
 exports.DIRECTIONAL_PRESETS = DIRECTIONAL_PRESETS;
 exports.DUOTONE_PRESETS = DUOTONE_PRESETS;
 exports.EXPORT_ASSEMBLING_PERCENT = EXPORT_ASSEMBLING_PERCENT;
@@ -19785,6 +21988,7 @@ exports.SECTION_HEADING = SECTION_HEADING;
 exports.SEL = SEL;
 exports.SHAPE_PRESET_DEFS = SHAPE_PRESET_DEFS;
 exports.SLIDE_TRANSITION_KEYFRAMES = SLIDE_TRANSITION_KEYFRAMES;
+exports.SLIDE_VIRTUALIZATION_THRESHOLD = SLIDE_VIRTUALIZATION_THRESHOLD;
 exports.TABLET_BREAKPOINT = TABLET_BREAKPOINT;
 exports.TABLE_STYLE_PRESETS = TABLE_STYLE_PRESETS;
 exports.TAB_ROW_ACTION_CLASSES = TAB_ROW_ACTION_CLASSES;
@@ -19799,10 +22003,13 @@ exports.addSection = addSection;
 exports.alignElements = alignElements;
 exports.appendPresentationInkPoint = appendPresentationInkPoint;
 exports.apply3dEffects = apply3dEffects;
+exports.applyAcceptAllSlides = applyAcceptAllSlides;
+exports.applyAcceptSlide = applyAcceptSlide;
 exports.applyCaseTransformToSegments = applyCaseTransformToSegments;
 exports.applyColorChange = applyColorChange;
 exports.applyDuotone = applyDuotone;
 exports.applyFormatToElement = applyFormatToElement;
+exports.applyRehearsalTimings = applyRehearsalTimings;
 exports.applyReroutedConnectors = applyReroutedConnectors;
 exports.applyResize = applyResize;
 exports.applyStyleToSelectedSegments = applyStyleToSelectedSegments;
@@ -19838,6 +22045,7 @@ exports.buildSlidesPdfBytes = buildSlidesPdfBytes;
 exports.buildSmartArt3DModel = buildSmartArt3DModel;
 exports.buildSmartArtA11y = buildSmartArtA11y;
 exports.buildSmartArtPresetData = buildSmartArtPresetData;
+exports.buildSummaryZoomView = buildSummaryZoomView;
 exports.buildTextBody3DSceneStyle = buildTextBody3DSceneStyle;
 exports.buildTextFillCss = buildTextFillCss;
 exports.buildTextReflectionCss = buildTextReflectionCss;
@@ -19858,11 +22066,13 @@ exports.cloneSlide = cloneSlide;
 exports.cloneTemplateElementsBySlideId = cloneTemplateElementsBySlideId;
 exports.collectImagePaths = collectImagePaths;
 exports.collectMediaElements = collectMediaElements;
+exports.collectUsedFonts = collectUsedFonts;
 exports.colorWithOpacity = colorWithOpacity;
 exports.comparePresentation = comparePresentation;
 exports.computeAllNotesPages = computeAllNotesPages;
 exports.computeAutoFitTextStyle = computeAutoFitTextStyle;
 exports.computeColumnBoundaries = computeColumnBoundaries;
+exports.computeEntranceAnimationDelay = computeEntranceAnimationDelay;
 exports.computeHandoutLayout = computeHandoutLayout;
 exports.computeInlineEditorRect = computeInlineEditorRect;
 exports.computeKeyboardInset = computeKeyboardInset;
@@ -19880,11 +22090,13 @@ exports.computeSnapToShape = computeSnapToShape;
 exports.computeSplitCell = computeSplitCell;
 exports.computeValueRange = computeValueRange;
 exports.computeValueRangeForChart = computeValueRangeForChart;
+exports.computeVirtualRange = computeVirtualRange;
 exports.convertLatexToOmml = convertLatexToOmml;
 exports.convertOmmlToLatex = convertOmmlToLatex;
 exports.convertOmmlToMathMl = convertOmmlToMathMl;
 exports.copyFormatFromElement = copyFormatFromElement;
 exports.countTextSegments = countTextSegments;
+exports.createBackstagePresentation = createBackstagePresentation;
 exports.createBlankSlide = createBlankSlide;
 exports.createDefaultChartElement = createDefaultChartElement;
 exports.createInitialPresentationSnapshot = createInitialPresentationSnapshot;
@@ -19915,6 +22127,8 @@ exports.findChartPartTarget = findChartPartTarget;
 exports.findSmartArtNodeText = findSmartArtNodeText;
 exports.formatAxisValue = formatAxisValue;
 exports.formatAxisValueWithUnits = formatAxisValueWithUnits;
+exports.formatBackstageDate = formatBackstageDate;
+exports.formatBackstageSize = formatBackstageSize;
 exports.formatBytes = formatBytes;
 exports.formatCommentTimestamp = formatCommentTimestamp;
 exports.formatElapsed = formatElapsed;
@@ -19928,6 +22142,7 @@ exports.generateBroadcastRoomId = generateBroadcastRoomId;
 exports.generateElementId = generateElementId;
 exports.generateLogTicks = generateLogTicks;
 exports.generateNoteLineCount = generateNoteLineCount;
+exports.generatePackageReadme = generatePackageReadme;
 exports.generatePressureCircles = generatePressureCircles;
 exports.generateTicks = generateTicks;
 exports.getAnimationInitialStyle = getAnimationInitialStyle;
@@ -19950,8 +22165,10 @@ exports.getEffectDagFilter = getEffectDagFilter;
 exports.getElementLabel = getElementLabel;
 exports.getElementTransform = getElementTransform;
 exports.getElementTransformWithoutRotation = getElementTransformWithoutRotation;
+exports.getImageColorWashStyle = getImageColorWashStyle;
 exports.getImageEffectsFilter = getImageEffectsFilter;
 exports.getImageEffectsOpacity = getImageEffectsOpacity;
+exports.getImageSvgFilters = getImageSvgFilters;
 exports.getInkReplayStyles = getInkReplayStyles;
 exports.getInlineEditorSelection = getInlineEditorSelection;
 exports.getKinsokuLineBreakStyles = getKinsokuLineBreakStyles;
@@ -19974,6 +22191,7 @@ exports.getTextCompensationTransform = getTextCompensationTransform;
 exports.getWarpPath = getWarpPath;
 exports.groupElements = groupElements;
 exports.groupIntoParagraphs = groupIntoParagraphs;
+exports.groupSlidesBySection = groupSlidesBySection;
 exports.hasCopyableFormat = hasCopyableFormat;
 exports.hasDistinctScriptFonts = hasDistinctScriptFonts;
 exports.hasPressureVariation = hasPressureVariation;
@@ -19993,6 +22211,7 @@ exports.isPresentationSessionMessage = isPresentationSessionMessage;
 exports.isTemplateElement = isTemplateElement;
 exports.isTemplateElementId = isTemplateElementId;
 exports.isUrlSafe = isUrlSafe;
+exports.listBackstageRecentFiles = listBackstageRecentFiles;
 exports.loadPresentationDeck = loadPresentationDeck;
 exports.makeCloneId = makeCloneId;
 exports.makeSlideId = makeSlideId;
@@ -20027,6 +22246,7 @@ exports.preprocessCssForCapture = preprocessCssForCapture;
 exports.presentationInkPath = presentationInkPath;
 exports.presenterElapsed = presenterElapsed;
 exports.pressuresToWidths = pressuresToWidths;
+exports.readBackstageRecentFile = readBackstageRecentFile;
 exports.readSlidesFromYDoc = readSlidesFromYDoc;
 exports.readViewportMetrics = readViewportMetrics;
 exports.rebuildDrawingShapesIfCleared = rebuildDrawingShapesIfCleared;
@@ -20048,6 +22268,7 @@ exports.resolveLineHeight = resolveLineHeight;
 exports.resolveOleType = resolveOleType;
 exports.resolveParagraphAlign = resolveParagraphAlign;
 exports.resolveParagraphRtl = resolveParagraphRtl;
+exports.resolvePictureBullet = resolvePictureBullet;
 exports.resolveRegionCode = resolveRegionCode;
 exports.resolveTitleBarStatusKey = resolveTitleBarStatusKey;
 exports.resolveTransitionDurationMs = resolveTransitionDurationMs;
@@ -20059,6 +22280,7 @@ exports.sanitizeColor = sanitizeColor;
 exports.sanitizeDownloadFilename = sanitizeDownloadFilename;
 exports.sanitizeMathMl = sanitizeMathMl;
 exports.saveAutosaveSnapshot = saveAutosaveSnapshot;
+exports.scanAvailableFontFamilies = scanAvailableFontFamilies;
 exports.segmentByScript = segmentByScript;
 exports.segmentFrameCount = segmentFrameCount;
 exports.sendBackward = sendBackward;
@@ -20070,6 +22292,7 @@ exports.setDuotoneCachedResult = setDuotoneCachedResult;
 exports.setPendingSelectionRestore = setPendingSelectionRestore;
 exports.shadeColor2 = shadeColor2;
 exports.shouldCommitSmartArtNodeText = shouldCommitSmartArtNodeText;
+exports.shouldLoopContinuously = shouldLoopContinuously;
 exports.shouldUseSvgWarp = shouldUseSvgWarp;
 exports.slideProgressPercent = slideProgressPercent;
 exports.slideStatusLabel = slideStatusLabel;