ooxml-core 1.14.0 → 1.16.0

package/dist/index.cjs

@@ -128,9 +128,9 @@ function rgbToHsl(r, g2, b) {
   const cMin = Math.min(rN, gN, bN);
   const delta = cMax - cMin;
   const l = (cMax + cMin) / 2;
-  let s = 0;
+  let s2 = 0;
   if (delta !== 0) {
-    s = delta / (1 - Math.abs(2 * l - 1));
+    s2 = delta / (1 - Math.abs(2 * l - 1));
   }
   let h2 = 0;
   if (delta !== 0) {
@@ -145,10 +145,10 @@ function rgbToHsl(r, g2, b) {
   if (h2 < 0) {
     h2 += 360;
   }
-  return { h: h2, s: clampUnitInterval(s), l: clampUnitInterval(l) };
+  return { h: h2, s: clampUnitInterval(s2), l: clampUnitInterval(l) };
 }
-function hslToRgb(h2, s, l, roundChannel = Math.round, options) {
-  const sC = options?.clampSaturation === false ? s : clampUnitInterval(s);
+function hslToRgb(h2, s2, l, roundChannel = Math.round, options) {
+  const sC = options?.clampSaturation === false ? s2 : clampUnitInterval(s2);
   const lC = clampUnitInterval(l);
   const hN = (h2 % 360 + 360) % 360;
   const c2 = (1 - Math.abs(2 * lC - 1)) * sC;
@@ -588,9 +588,9 @@ function normalizePaletteHex(value) {
 function applyThemePaletteVariant(hex, variant) {
   const rgb = hexToRgbChannels(hex);
   if (!rgb) return hex;
-  const { h: h2, s, l } = rgbToHsl(rgb.r, rgb.g, rgb.b);
+  const { h: h2, s: s2, l } = rgbToHsl(rgb.r, rgb.g, rgb.b);
   const { lumMod, lumOff } = themePaletteVariantLuminance(variant);
-  const next = hslToRgb(h2, s, l * lumMod + (lumOff ?? 0), (value) => Math.floor(value + 1e-6));
+  const next = hslToRgb(h2, s2, l * lumMod + (lumOff ?? 0), (value) => Math.floor(value + 1e-6));
   return `#${toHex(next.r)}${toHex(next.g)}${toHex(next.b)}`.toLowerCase();
 }
 function describeThemePaletteSwatch(name, variant) {
@@ -773,9 +773,9 @@ function computeLinearRegression(xVals, yVals) {
   }
   const slope = (n2 * sumXY - sumX * sumY) / denom;
   const intercept = (sumY - slope * sumX) / n2;
-  const ssRes = yVals.reduce((s, y, i2) => s + (y - (slope * xVals[i2] + intercept)) ** 2, 0);
+  const ssRes = yVals.reduce((s2, y, i2) => s2 + (y - (slope * xVals[i2] + intercept)) ** 2, 0);
   const meanY = sumY / n2;
-  const ssTot = yVals.reduce((s, y) => s + (y - meanY) ** 2, 0);
+  const ssTot = yVals.reduce((s2, y) => s2 + (y - meanY) ** 2, 0);
   const rSquared = ssTot > 0 ? 1 - ssRes / ssTot : 0;
   return { slope, intercept, rSquared };
 }
@@ -829,7 +829,7 @@ function computeRSquared(xVals, yVals, evalFn) {
   if (n2 === 0) {
     return 0;
   }
-  const meanY = yVals.reduce((s, y) => s + y, 0) / n2;
+  const meanY = yVals.reduce((s2, y) => s2 + y, 0) / n2;
   let ssRes = 0;
   let ssTot = 0;
   for (let i2 = 0; i2 < n2; i2++) {
@@ -1471,24 +1471,24 @@ function propagateColor(node, colorIndex) {
   for (const child3 of node.children ?? []) propagateColor(child3, colorIndex);
 }
 function buildHierarchyRoots(series, categoryLabels, categoryLevels2) {
-  const colorStride = Math.max(categoryLabels.length, ...series.map((s) => s.values.length), 1);
+  const colorStride = Math.max(categoryLabels.length, ...series.map((s2) => s2.values.length), 1);
   let roots2 = series.flatMap(
-    (s, index) => buildSeriesHierarchy(s, index, categoryLabels, categoryLevels2, colorStride)
+    (s2, index) => buildSeriesHierarchy(s2, index, categoryLabels, categoryLevels2, colorStride)
   );
   if (series.length > 1)
-    roots2 = series.map((s, index) => ({
-      label: s.name,
+    roots2 = series.map((s2, index) => ({
+      label: s2.name,
       weight: 0,
-      children: buildSeriesHierarchy(s, index, categoryLabels, categoryLevels2, colorStride),
+      children: buildSeriesHierarchy(s2, index, categoryLabels, categoryLevels2, colorStride),
       colorIndex: index * colorStride,
-      parentLabelLayout: s.parentLabelLayout ?? "banner"
+      parentLabelLayout: s2.parentLabelLayout ?? "banner"
     }));
   for (const root of roots2) aggregate(root);
   roots2.forEach((root, index) => propagateColor(root, index));
   return roots2;
 }
 function hierarchyBranchLabels(series, categoryLabels, categoryLevels2) {
-  if (series.length > 1) return series.map((s) => s.name);
+  if (series.length > 1) return series.map((s2) => s2.name);
   if (categoryLevels2 && categoryLevels2.length > 1) {
     const pointCount = series[0]?.values.length ?? categoryLabels.length;
     const topLevel = normalizeLevels(categoryLevels2, pointCount).at(-1) ?? [];
@@ -1564,8 +1564,8 @@ function computeSunburstArcs(series, cx2, cy, maxR) {
   const seriesCount = Math.max(series.length, 1);
   const ringWidth = maxR / (seriesCount + 0.5);
   const out = [];
-  series.forEach((s, si) => {
-    const values = s.values;
+  series.forEach((s2, si) => {
+    const values = s2.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;
@@ -1880,7 +1880,7 @@ function fitModel(options, xVals, yVals) {
     case "linear": {
       const reg = computeLinearRegression(xs, ys);
       const fixed = options.intercept;
-      const slope = fixed !== void 0 ? ys.reduce((s, y, i2) => s + (y - fixed) * xs[i2], 0) / xs.reduce((s, x) => s + x * x, 0) : reg.slope;
+      const slope = fixed !== void 0 ? ys.reduce((s2, y, i2) => s2 + (y - fixed) * xs[i2], 0) / xs.reduce((s2, x) => s2 + x * x, 0) : reg.slope;
       const b = fixed ?? reg.intercept;
       return {
         evaluate: (x) => slope * x + b,
@@ -1931,7 +1931,7 @@ function fitModel(options, xVals, yVals) {
     case "polynomial": {
       const order = Math.min(options.order ?? 2, 6);
       const coeffs = fitPolynomial(xs, ys, order);
-      const evaluate = (x) => coeffs.reduce((s, c2, i2) => s + c2 * x ** i2, 0);
+      const evaluate = (x) => coeffs.reduce((s2, c2, i2) => s2 + c2 * x ** i2, 0);
       return {
         evaluate,
         equation: formatPolynomialEquation(coeffs),
@@ -2605,9 +2605,9 @@ function baseHex(color, theme) {
       return `#${toHex(scrgbLinearToSrgb8(r))}${toHex(scrgbLinearToSrgb8(g2))}${toHex(scrgbLinearToSrgb8(b))}`;
     }
     case "hsl": {
-      const [h2, s, l] = color.value.split(",");
+      const [h2, s2, l] = color.value.split(",");
       const hue = parseDrawingHueDegrees(h2);
-      const sat = parseDrawingFraction(s);
+      const sat = parseDrawingFraction(s2);
       const lum = parseDrawingFraction(l);
       if (hue === void 0 || sat === void 0 || lum === void 0) return void 0;
       const { r, g: g2, b } = hslToRgb(hue, sat, lum);
@@ -5614,7 +5614,7 @@ function chartExSummary(source) {
   const chart = cx(root, "chart");
   const region = cx(cx(chart, "plotArea"), "plotAreaRegion");
   const all = region ? children(region, "series", NS.cx) : [];
-  const primary = all.find((s) => s.getAttribute("layoutId") !== "paretoLine") ?? all[0];
+  const primary = all.find((s2) => s2.getAttribute("layoutId") !== "paretoLine") ?? all[0];
   const layoutId = primary?.getAttribute("layoutId") ?? "";
   const chartType = layoutId === "waterfall" ? "waterfall" : layoutId === "clusteredColumn" ? "histogram" : layoutId === "treemap" || layoutId === "sunburst" ? layoutId : void 0;
   if (!primary || !chartType) return { layoutId };
@@ -5878,7 +5878,7 @@ function bars(model, frame2, out, values) {
   const base = frame2.value(0);
   const pos = new Array(model.categories.length).fill(0);
   const neg = new Array(model.categories.length).fill(0);
-  model.series.forEach((s, si) => {
+  model.series.forEach((s2, si) => {
     values[si]?.forEach((v, i2) => {
       if (v === null || i2 >= model.categories.length) return;
       let from = 0;
@@ -5895,8 +5895,8 @@ function bars(model, frame2, out, values) {
       const center = frame2.band(i2);
       const width = model.horizontal ? Math.abs(b - a2) : barSize;
       const height = model.horizontal ? barSize : Math.abs(b - a2);
-      let color = s.pointColors?.[i2] ?? s.color;
-      const gradient = s.pointGradients?.[i2] ?? (s.pointColors?.[i2] === void 0 ? s.gradient : void 0);
+      let color = s2.pointColors?.[i2] ?? s2.color;
+      const gradient = s2.pointGradients?.[i2] ?? (s2.pointColors?.[i2] === void 0 ? s2.gradient : void 0);
       if (gradient && (gradient.path === "circle" || gradient.path === "shape")) {
         const baseId = color.match(/^url\(#(.+)\)$/)?.[1];
         if (baseId) {
@@ -5913,11 +5913,11 @@ function bars(model, frame2, out, values) {
       out.push(`<g data-chart-series="${si}" data-chart-point="${i2}">`);
       if (model.horizontal)
         out.push(
-          rect(Math.min(a2, b), center + offset, Math.abs(b - a2), barSize, color, s.shadowFilter)
+          rect(Math.min(a2, b), center + offset, Math.abs(b - a2), barSize, color, s2.shadowFilter)
         );
       else
         out.push(
-          rect(center + offset, Math.min(a2, b), barSize, Math.abs(b - a2), color, s.shadowFilter)
+          rect(center + offset, Math.min(a2, b), barSize, Math.abs(b - a2), color, s2.shadowFilter)
         );
       out.push("</g>");
     });
@@ -6118,9 +6118,9 @@ function resolveDrawingShadow(effects, theme) {
 function resolveDrawingShadowXml(xml, theme) {
   return xml ? resolveDrawingShadow(parseXml(xml).documentElement, theme) : void 0;
 }
-function svgDropShadowElement(s, format) {
+function svgDropShadowElement(s2, format) {
   const num2 = format.number;
-  return `<feDropShadow dx="${num2(s.dx)}" dy="${num2(s.dy)}" stdDeviation="${num2(s.blur / 2)}" flood-color="${format.color(s.color, "#000000")}" flood-opacity="${num2(s.opacity)}" result="shadow"/>`;
+  return `<feDropShadow dx="${num2(s2.dx)}" dy="${num2(s2.dy)}" stdDeviation="${num2(s2.blur / 2)}" flood-color="${format.color(s2.color, "#000000")}" flood-opacity="${num2(s2.opacity)}" result="shadow"/>`;
 }
 
 // chart/render/theme-palette.ts
@@ -6337,25 +6337,25 @@ function seriesContext(chart, theme, options) {
     ) : void 0
   };
 }
-function seriesView(ctx, s, index, total, categoriesOf) {
+function seriesView(ctx, s2, index, total, categoriesOf) {
   const { theme, scheme, palette, evaluateRef } = ctx;
-  const values = resolveRef(s.valuesRef, evaluateRef)?.map(toNumber) ?? s.values.map(toNumber);
-  categoriesOf(resolveRef(s.categoriesRef, evaluateRef) ?? s.categories);
+  const values = resolveRef(s2.valuesRef, evaluateRef)?.map(toNumber) ?? s2.values.map(toNumber);
+  categoriesOf(resolveRef(s2.categoriesRef, evaluateRef) ?? s2.categories);
   const paletteColor = palette && chartPaletteSeriesColor(palette, index, total, scheme);
-  const color = s.fill?.kind === "none" ? "none" : ctx.drawingColor(s.fill?.kind === "solid" ? s.fill.color : s.drawingColor) ?? ctx.seriesColor?.(s, index) ?? paletteColor ?? autoSeriesColor(theme, index);
-  const view = { name: seriesName(s, index, evaluateRef), values, color };
-  const shadow = resolveDrawingShadowXml(s.effectsXml, { scheme: (name) => scheme[name] });
+  const color = s2.fill?.kind === "none" ? "none" : ctx.drawingColor(s2.fill?.kind === "solid" ? s2.fill.color : s2.drawingColor) ?? ctx.seriesColor?.(s2, index) ?? paletteColor ?? autoSeriesColor(theme, index);
+  const view = { name: seriesName(s2, index, evaluateRef), values, color };
+  const shadow = resolveDrawingShadowXml(s2.effectsXml, { scheme: (name) => scheme[name] });
   if (shadow) view.shadow = shadow;
-  const resolvedGradient = ctx.gradient(s.fill);
+  const resolvedGradient = ctx.gradient(s2.fill);
   if (resolvedGradient) view.gradient = resolvedGradient;
   const points = Object.fromEntries(
-    Object.entries(s.pointFills ?? {}).flatMap(([key, fill]) => {
+    Object.entries(s2.pointFills ?? {}).flatMap(([key, fill]) => {
       const value = ctx.gradient(fill);
       return value ? [[key, value]] : [];
     })
   );
   if (Object.keys(points).length) view.pointGradients = points;
-  Object.assign(view, analysisView(s, color, ctx.drawingColor));
+  Object.assign(view, analysisView(s2, color, ctx.drawingColor));
   return view;
 }
 
@@ -6403,7 +6403,7 @@ function hierarchyView(chart, model, evaluateRef) {
     parentLabelLayout: chart.hierarchy?.parentLabelLayout ?? "banner",
     labels: chart.hierarchy?.dataLabels !== false,
     branches: hierarchyBranchLabels(
-      model.series.map((s) => ({ name: s.name, values: s.values.map((v) => v ?? 0) })),
+      model.series.map((s2) => ({ name: s2.name, values: s2.values.map((v) => v ?? 0) })),
       model.categories,
       levels.length > 1 ? levels : void 0
     )
@@ -6449,8 +6449,8 @@ function valueExtent(type, grouping, series, categories) {
     for (let i2 = 0; i2 < categories; i2++) {
       let pos = 0;
       let neg = 0;
-      for (const s of series) {
-        const v = s.values[i2] ?? 0;
+      for (const s2 of series) {
+        const v = s2.values[i2] ?? 0;
         if (v >= 0) pos += v;
         else neg += v;
       }
@@ -6458,8 +6458,8 @@ function valueExtent(type, grouping, series, categories) {
       max = Math.max(max, pos);
     }
   } else {
-    for (const s of series)
-      for (const v of s.values)
+    for (const s2 of series)
+      for (const v of s2.values)
         if (v !== null) {
           min = Math.min(min, v);
           max = Math.max(max, v);
@@ -6480,7 +6480,7 @@ function valueAxis(model) {
 }
 function categoryTotals(model) {
   return model.categories.map(
-    (_, i2) => model.series.reduce((sum, s) => sum + Math.abs(s.values[i2] ?? 0), 0)
+    (_, i2) => model.series.reduce((sum, s2) => sum + Math.abs(s2.values[i2] ?? 0), 0)
   );
 }
 
@@ -6543,7 +6543,7 @@ function chartExtraView(chart, model, ctx, total, categoriesOf) {
   let index = chart.series.length;
   const groups = [];
   for (const group2 of chart.extraGroups ?? []) {
-    const series = group2.series.map((s) => seriesView(ctx, s, index++, total, categoriesOf));
+    const series = group2.series.map((s2) => seriesView(ctx, s2, index++, total, categoriesOf));
     const view = {
       type: group2.chartType,
       grouping: group2.grouping ?? (group2.chartType === "column" ? "clustered" : "standard"),
@@ -6636,11 +6636,11 @@ function chartSummaryView(chart, theme, options = {}) {
   const collect = (cats) => void rawCategories.push(cats);
   const extra = chart.extraGroups ?? [];
   const total = chart.series.length + extra.reduce((n2, g2) => n2 + g2.series.length, 0);
-  const series = chart.series.map((s, i2) => seriesView(ctx, s, i2, total, collect));
+  const series = chart.series.map((s2, i2) => seriesView(ctx, s2, i2, total, collect));
   const longest = Math.max(
     0,
-    ...series.map((s) => s.values.length),
-    ...extra.flatMap((g2) => g2.series.map((s) => s.values.length))
+    ...series.map((s2) => s2.values.length),
+    ...extra.flatMap((g2) => g2.series.map((s2) => s2.values.length))
   );
   const firstCats = rawCategories.find((c2) => c2.length > 0) ?? [];
   const categories = Array.from(
@@ -6648,28 +6648,28 @@ function chartSummaryView(chart, theme, options = {}) {
     (_, i2) => firstCats[i2] !== void 0 ? toText(firstCats[i2] ?? null) : String(i2 + 1)
   );
   if (byPoint) {
-    series.forEach((s, seriesIndex) => {
-      s.pointColors = s.values.map((_, i2) => {
+    series.forEach((s2, seriesIndex) => {
+      s2.pointColors = s2.values.map((_, i2) => {
         const explicit = drawingColor(chart.series[seriesIndex]?.pointColors?.[i2]);
-        return explicit ?? (palette ? chartPaletteSeriesColor(palette, i2, s.values.length, scheme) : autoSeriesColor(theme, i2));
+        return explicit ?? (palette ? chartPaletteSeriesColor(palette, i2, s2.values.length, scheme) : autoSeriesColor(theme, i2));
       });
     });
   } else
-    series.forEach((s, seriesIndex) => {
+    series.forEach((s2, seriesIndex) => {
       const points = chart.series[seriesIndex]?.pointColors;
-      if (points) s.pointColors = s.values.map((_, i2) => drawingColor(points[i2]) ?? s.color);
+      if (points) s2.pointColors = s2.values.map((_, i2) => drawingColor(points[i2]) ?? s2.color);
     });
-  series.forEach((s, index) => {
+  series.forEach((s2, index) => {
     const source = chart.series[index];
-    if (s.gradient && !radial && s.pointColors) {
-      for (let i2 = 0; i2 < s.pointColors.length; i2++)
-        if (!source.pointColors?.[i2]) delete s.pointColors[i2];
+    if (s2.gradient && !radial && s2.pointColors) {
+      for (let i2 = 0; i2 < s2.pointColors.length; i2++)
+        if (!source.pointColors?.[i2]) delete s2.pointColors[i2];
     }
     for (const [key, fill] of Object.entries(source.pointFills ?? {})) {
-      if (fill.kind === "none") (s.pointColors ??= [])[Number(key)] = "none";
+      if (fill.kind === "none") (s2.pointColors ??= [])[Number(key)] = "none";
       else if (fill.kind === "solid") {
         const paint2 = drawingColor(fill.color);
-        if (paint2) (s.pointColors ??= [])[Number(key)] = paint2;
+        if (paint2) (s2.pointColors ??= [])[Number(key)] = paint2;
       }
     }
   });
@@ -6697,12 +6697,12 @@ function chartSummaryView(chart, theme, options = {}) {
   const appearance = chartAppearance(chart, theme);
   if (appearance) model.appearance = appearance;
   if (type === "scatter" || type === "bubble") {
-    series.forEach((s, i2) => {
+    series.forEach((s2, i2) => {
       const cats = rawCategories[i2] ?? [];
       const numeric = cats.length > 0 && cats.every((c2) => typeof c2 === "number");
-      s.xValues = s.values.map((_, k) => numeric ? toNumber(cats[k] ?? null) : k + 1);
+      s2.xValues = s2.values.map((_, k) => numeric ? toNumber(cats[k] ?? null) : k + 1);
     });
-    const xs = series.flatMap((s) => s.xValues ?? []).filter((x) => x !== null);
+    const xs = series.flatMap((s2) => s2.xValues ?? []).filter((x) => x !== null);
     model.xAxis = xs.length ? niceScale(Math.min(...xs), Math.max(...xs)) : niceScale(0, 1);
   }
   if (type === "stock") model.stock = stockView(chart.stock, ctx);
@@ -6929,10 +6929,10 @@ function cartesianAxes(model, area, out) {
   return frame2;
 }
 function plotted(model) {
-  if (model.grouping !== "percentStacked") return model.series.map((s) => s.values);
+  if (model.grouping !== "percentStacked") return model.series.map((s2) => s2.values);
   const totals = categoryTotals(model);
   return model.series.map(
-    (s) => s.values.map((v, i2) => v === null ? null : v / (totals[i2] || 1))
+    (s2) => s2.values.map((v, i2) => v === null ? null : v / (totals[i2] || 1))
   );
 }
 function linesAndAreas(model, frame2, out) {
@@ -6941,7 +6941,7 @@ function linesAndAreas(model, frame2, out) {
   const acc = new Array(model.categories.length).fill(0);
   const area = model.type === "area";
   const layers2 = [];
-  model.series.forEach((s, si) => {
+  model.series.forEach((s2, si) => {
     const points = [];
     const lower = [];
     model.categories.forEach((_, i2) => {
@@ -6959,8 +6959,8 @@ function linesAndAreas(model, frame2, out) {
     layers2.push({
       points,
       lower,
-      color: s.color,
-      filter: s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""
+      color: s2.color,
+      filter: s2.shadowFilter ? ` filter="${s2.shadowFilter}"` : ""
     });
   });
   for (const { points, lower, color, filter } of area ? [...layers2].reverse() : layers2) {
@@ -7012,19 +7012,19 @@ function scatter(model, area, out) {
   };
   const bubble = model.type === "bubble" ? model.bubble : void 0;
   const biggest = maxBubbleSize(
-    model.series.flatMap((s) => (s.sizes ?? []).filter((v) => v !== null))
+    model.series.flatMap((s2) => (s2.sizes ?? []).filter((v) => v !== null))
   );
   const median2 = medianBubbleRadius(plot.w, plot.h);
   const radiusOf = (size) => bubble && !(size !== void 0 && size < 0 && !bubble.showNegativeBubbles) ? computeBubbleRadius(size, biggest, median2, bubble) : void 0;
   let reach = 0;
   if (bubble)
-    for (const s of model.series)
-      s.values.forEach((_, i2) => {
-        reach = Math.max(reach, radiusOf(s.sizes?.[i2] ?? void 0) ?? 0);
+    for (const s2 of model.series)
+      s2.values.forEach((_, i2) => {
+        reach = Math.max(reach, radiusOf(s2.sizes?.[i2] ?? void 0) ?? 0);
       });
-  const widen = (s, length) => {
-    const pad2 = reach * (s.max - s.min || 1) / Math.max(1, length - 2 * reach);
-    return { ...s, min: s.min - pad2, max: s.max + pad2 };
+  const widen = (s2, length) => {
+    const pad2 = reach * (s2.max - s2.min || 1) / Math.max(1, length - 2 * reach);
+    return { ...s2, min: s2.min - pad2, max: s2.max + pad2 };
   };
   const xView = widen(xs, plot.w);
   const yView = widen(ys, plot.h);
@@ -7055,17 +7055,17 @@ function scatter(model, area, out) {
     line(plot.x, plot.y + plot.h, plot.x + plot.w, plot.y + plot.h, xAxis.color, xAxis.width)
   );
   out.push(line(plot.x, plot.y, plot.x, plot.y + plot.h, yAxis.color, yAxis.width));
-  for (const [si, s] of model.series.entries())
-    s.values.forEach((v, i2) => {
-      const x = s.xValues?.[i2] ?? null;
+  for (const [si, s2] of model.series.entries())
+    s2.values.forEach((v, i2) => {
+      const x = s2.xValues?.[i2] ?? null;
       if (v === null || x === null) return;
-      const filter = s.shadowFilter ? ` filter="${s.shadowFilter}"` : "";
-      const fill = s.pointColors?.[i2] ?? s.color;
+      const filter = s2.shadowFilter ? ` filter="${s2.shadowFilter}"` : "";
+      const fill = s2.pointColors?.[i2] ?? s2.color;
       if (!bubble) {
         out.push(`<circle cx="${n(px3(x))}" cy="${n(py(v))}" r="3" fill="${fill}"${filter}/>`);
         return;
       }
-      const r = radiusOf(s.sizes?.[i2] ?? void 0);
+      const r = radiusOf(s2.sizes?.[i2] ?? void 0);
       if (r === void 0) return;
       out.push(
         `<circle cx="${n(px3(x))}" cy="${n(py(v))}" r="${n(r)}" fill="${fill}" fill-opacity="0.6" data-chart-series="${si}" data-chart-point="${i2}"${filter}/>`
@@ -7239,18 +7239,18 @@ function pieSvg(model, area) {
   const rings = model.type === "doughnut" ? model.series : model.series.slice(0, 1);
   const hole = model.type === "doughnut" ? radius * 0.5 : 0;
   const ringSize = (radius - hole) / Math.max(1, rings.length);
-  rings.forEach((s, ri) => {
+  rings.forEach((s2, ri) => {
     const outer = radius - ri * ringSize;
     const inner = model.type === "doughnut" ? outer - ringSize : 0;
-    const total = s.values.reduce((sum, v) => sum + (v !== null && v > 0 ? v : 0), 0);
+    const total = s2.values.reduce((sum, v) => sum + (v !== null && v > 0 ? v : 0), 0);
     if (total <= 0) return;
     let angle = 0;
-    s.values.forEach((v, i2) => {
+    s2.values.forEach((v, i2) => {
       if (v === null || v <= 0) return;
       const sweep = v / total * Math.PI * 2;
-      const color = s.pointColors?.[i2] ?? s.color;
+      const color = s2.pointColors?.[i2] ?? s2.color;
       out.push(
-        `<path d="${slicePath(cx2, cy, outer, inner, angle, angle + sweep)}" fill="${color}" stroke="#FFFFFF" stroke-width="1"${s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""}/>`
+        `<path d="${slicePath(cx2, cy, outer, inner, angle, angle + sweep)}" fill="${color}" stroke="#FFFFFF" stroke-width="1"${s2.shadowFilter ? ` filter="${s2.shadowFilter}"` : ""}/>`
       );
       angle += sweep;
     });
@@ -7300,10 +7300,10 @@ function radarSvg(model, area) {
         })
       );
   });
-  for (const s of model.series) {
-    const points = s.values.slice(0, count).map((v, i2) => polar(cx2, cy, r(v ?? scale.min), angle(i2))).map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
+  for (const s2 of model.series) {
+    const points = s2.values.slice(0, count).map((v, i2) => polar(cx2, cy, r(v ?? scale.min), angle(i2))).map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
     out.push(
-      `<polygon points="${points}" fill="none" stroke="${s.color}" stroke-width="2"${s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""}/>`
+      `<polygon points="${points}" fill="none" stroke="${s2.color}" stroke-width="2"${s2.shadowFilter ? ` filter="${s2.shadowFilter}"` : ""}/>`
     );
   }
   return out.join("");
@@ -7319,9 +7319,9 @@ var leafValues = (model) => (model.series[0]?.values ?? []).map((v) => v ?? 0);
 function treemapSvg(model, area) {
   const out = [chartAreaRect(model, "plotArea", area)];
   const hierarchy = model.hierarchy;
-  const series = model.series.map((s) => ({
-    name: s.name,
-    values: s.values.map((v) => v ?? 0),
+  const series = model.series.map((s2) => ({
+    name: s2.name,
+    values: s2.values.map((v) => v ?? 0),
     // Without data labels Office draws no parent banners either, so no space is reserved.
     parentLabelLayout: hierarchy?.labels === false ? "none" : hierarchy?.parentLabelLayout
   }));
@@ -7371,7 +7371,7 @@ function sunburstSvg(model, area) {
   if (maxR <= 0) return out.join("");
   const levels = model.hierarchy?.levels ?? [];
   const arcs = levels.length > 1 ? computeHierarchicalSunburstArcs(levels, leafValues(model), cx2, cy, maxR) : computeSunburstArcs(
-    model.series.map((s) => ({ values: s.values.map((v) => v ?? 0) })),
+    model.series.map((s2) => ({ values: s2.values.map((v) => v ?? 0) })),
     cx2,
     cy,
     maxR
@@ -7494,9 +7494,9 @@ function legendEntries(model) {
       { label: "Decrease", color: model.waterfall.colors.decrease },
       { label: "Total", color: model.waterfall.colors.total }
     ];
-  return [...model.series, ...(model.extraGroups ?? []).flatMap((g2) => g2.series)].map((s) => ({
-    label: s.name,
-    color: s.color
+  return [...model.series, ...(model.extraGroups ?? []).flatMap((g2) => g2.series)].map((s2) => ({
+    label: s2.name,
+    color: s2.color
   }));
 }
 function automaticLegend(model, area, out, options, bounds2) {
@@ -22025,7 +22025,7 @@ function partsOf(root) {
 function pack(shapes, vertical, gap, end) {
   const rects = [];
   const heads = [];
-  const across = (s) => vertical ? boundsOf(s.rects).w : boundsOf(s.rects).h;
+  const across = (s2) => vertical ? boundsOf(s2.rects).w : boundsOf(s2.rects).h;
   const thickness = Math.max(0, ...shapes.map(across));
   for (const shape of shapes) {
     const bounds2 = boundsOf(shape.rects);
@@ -22603,8 +22603,8 @@ function cellSize(cell, box) {
 }
 function metricsOf(node, box, cells, spacers, row2) {
   const sizes = cells.map((c2) => cellSize(c2, box));
-  const cellW = Math.max(...sizes.map((s) => s.w));
-  const cellH = Math.max(...sizes.map((s) => s.h));
+  const cellW = Math.max(...sizes.map((s2) => s2.w));
+  const cellH = Math.max(...sizes.map((s2) => s2.h));
   const spacer = spacers[0];
   const along = spacer ? spacer.values.get(row2 ? "w" : "h") ?? 0 : node.values.get("sibSp") ?? 0;
   return {
@@ -23098,11 +23098,11 @@ var NO_MERGE = {
   carrierByTarget: /* @__PURE__ */ new Map()
 };
 function namesakeTarget(carrier, siblings, carrierIds) {
-  return siblings.find((s) => {
-    if (s === carrier || s.alg.type !== "tx") {
+  return siblings.find((s2) => {
+    if (s2 === carrier || s2.alg.type !== "tx") {
       return false;
     }
-    const ids = sourceIdsOf(s);
+    const ids = sourceIdsOf(s2);
     return ids.length === carrierIds.length && ids.every((id) => carrierIds.includes(id));
   });
 }
@@ -23110,7 +23110,7 @@ function computeMoveWithMerge(siblings) {
   if (siblings.length < 2) {
     return NO_MERGE;
   }
-  const byName = new Map(siblings.map((s) => [s.name, s]));
+  const byName = new Map(siblings.map((s2) => [s2.name, s2]));
   const extraIdsByTarget = /* @__PURE__ */ new Map();
   const suppressed = /* @__PURE__ */ new Set();
   const carrierByTarget = /* @__PURE__ */ new Map();
@@ -27188,8 +27188,8 @@ function resolveContentSizedExtents(texts, crossExtentPx, fontSizePx, table, lin
 // diagram/layout/smartart-layout-interpreter-axis-range.ts
 function positionRange(start, count, step, total) {
   const out = [];
-  const s = step > 0 ? step : 1;
-  for (let i2 = Math.max(0, start - 1); i2 < total; i2 += s) {
+  const s2 = step > 0 ? step : 1;
+  for (let i2 = Math.max(0, start - 1); i2 < total; i2 += s2) {
     out.push(i2 + 1);
     if (count !== void 0 && count > 0 && out.length >= count) {
       break;
@@ -28287,8 +28287,8 @@ function absOf(dim) {
 function axisAbsMax(slots, pos, ctr, size) {
   let max = 0;
   for (const { dims } of slots) {
-    const s = absOf(dims[size]);
-    const edge = Math.max(absOf(dims[pos]) + s, absOf(dims[ctr]) + s / 2, s);
+    const s2 = absOf(dims[size]);
+    const edge = Math.max(absOf(dims[pos]) + s2, absOf(dims[ctr]) + s2 / 2, s2);
     if (edge > max) {
       max = edge;
     }
@@ -34130,12 +34130,12 @@ function padMd4Style(message) {
 }
 function applyRotatingRound(r, ops, f6, x, feedback = false) {
   let target = 0;
-  for (const [k, s, addConst] of ops) {
+  for (const [k, s2, addConst] of ops) {
     const i1 = target + 1 & 3;
     const next = r[i1];
     const rotated = rotl32(
       add32(r[target], f6(next, r[target + 2 & 3], r[target + 3 & 3]), x[k], addConst),
-      s
+      s2
     );
     r[target] = feedback ? add32(next, rotated) : rotated;
     target = target + 3 & 3;
@@ -34617,13 +34617,13 @@ var LEFT_FNS2 = [f12, f22, f32, f4, f5];
 var RIGHT_FNS2 = [f5, f4, f32, f22, f12];
 function applyLane(r, ops, f6, x, startTarget) {
   let target = startTarget;
-  for (const [k, s, addConst] of ops) {
+  for (const [k, s2, addConst] of ops) {
     const i1 = (target + 1) % 5;
     const i2 = (target + 2) % 5;
     const i3 = (target + 3) % 5;
     const i4 = (target + 4) % 5;
     const sum = r[target] + f6(r[i1], r[i2], r[i3]) + x[k] + addConst >>> 0;
-    const newTarget = (sum << s | sum >>> 32 - s) + r[i4] >>> 0;
+    const newTarget = (sum << s2 | sum >>> 32 - s2) + r[i4] >>> 0;
     const c2 = r[i2];
     r[i2] = (c2 << 10 | c2 >>> 22) >>> 0;
     r[target] = newTarget;
@@ -35642,6 +35642,8 @@ __export(geometry_exports, {
   ROTATE_STEM_PX: () => ROTATE_STEM_PX,
   ROUTING_PADDING_DEFAULT: () => ROUTING_PADDING_DEFAULT,
   SCROLLS_ACCENT_CALLOUTS_PRESET_DEFINITIONS: () => SCROLLS_ACCENT_CALLOUTS_PRESET_DEFINITIONS,
+  SHAPE_GALLERY_CATEGORIES: () => SHAPE_GALLERY_CATEGORIES,
+  SHAPE_GALLERY_ENTRIES: () => SHAPE_GALLERY_ENTRIES,
   SNAP_THRESHOLD: () => SNAP_THRESHOLD,
   STAR_CONNECTION_SITES: () => STAR_CONNECTION_SITES,
   STAR_TEXT_RECTS: () => STAR_TEXT_RECTS,
@@ -35737,6 +35739,9 @@ __export(geometry_exports, {
   routeOrthogonalConnector: () => routeOrthogonalConnector,
   segmentIntersection: () => segmentIntersection,
   segmentIntersectsRect: () => segmentIntersectsRect,
+  shapeGalleryCategoryKey: () => shapeGalleryCategoryKey,
+  shapeGalleryName: () => shapeGalleryName,
+  shapeGalleryNameKey: () => shapeGalleryNameKey,
   signedArea: () => signedArea,
   simplifyPath: () => simplifyPath,
   snapAngle: () => snapAngle,
@@ -41740,6 +41745,260 @@ function subtractSvgPaths(path1, path2) {
   return subtractShapes(path1, path2);
 }
 
+// geometry/shape-gallery-catalog.ts
+var s = (preset, name) => ({ preset, name });
+var SHAPE_GALLERY_CATEGORIES = [
+  {
+    id: "lines",
+    name: "Lines",
+    shapes: [
+      s("line", "Line"),
+      s("straightConnector1", "Connector: Straight"),
+      s("bentConnector3", "Connector: Elbow"),
+      s("curvedConnector3", "Connector: Curved"),
+      s("lineInv", "Line: Inverse"),
+      s("bentConnector2", "Connector: Elbow (L)"),
+      s("bentConnector4", "Connector: Elbow (3 segments)"),
+      s("bentConnector5", "Connector: Elbow (4 segments)"),
+      s("curvedConnector2", "Connector: Curved (L)"),
+      s("curvedConnector4", "Connector: Curved (3 segments)"),
+      s("curvedConnector5", "Connector: Curved (4 segments)")
+    ]
+  },
+  {
+    id: "rectangles",
+    name: "Rectangles",
+    shapes: [
+      s("rect", "Rectangle"),
+      s("roundRect", "Rectangle: Rounded Corners"),
+      s("snip1Rect", "Rectangle: Single Corner Snipped"),
+      s("snip2SameRect", "Rectangle: Top Corners Snipped"),
+      s("snip2DiagRect", "Rectangle: Diagonal Corners Snipped"),
+      s("snipRoundRect", "Rectangle: Top Corners, One Rounded and One Snipped"),
+      s("round1Rect", "Rectangle: Single Corner Rounded"),
+      s("round2SameRect", "Rectangle: Top Corners Rounded"),
+      s("round2DiagRect", "Rectangle: Diagonal Corners Rounded")
+    ]
+  },
+  {
+    id: "basic",
+    name: "Basic Shapes",
+    shapes: [
+      s("ellipse", "Oval"),
+      s("triangle", "Isosceles Triangle"),
+      s("rtTriangle", "Right Triangle"),
+      s("parallelogram", "Parallelogram"),
+      s("trapezoid", "Trapezoid"),
+      s("nonIsoscelesTrapezoid", "Trapezoid: Non-Isosceles"),
+      s("diamond", "Diamond"),
+      s("pentagon", "Regular Pentagon"),
+      s("hexagon", "Hexagon"),
+      s("heptagon", "Heptagon"),
+      s("octagon", "Octagon"),
+      s("decagon", "Decagon"),
+      s("dodecagon", "Dodecagon"),
+      s("pie", "Partial Circle"),
+      s("pieWedge", "Pie Wedge"),
+      s("chord", "Chord"),
+      s("teardrop", "Teardrop"),
+      s("frame", "Frame"),
+      s("halfFrame", "Half Frame"),
+      s("corner", "L-Shape"),
+      s("diagStripe", "Diagonal Stripe"),
+      s("plus", "Cross"),
+      s("plaque", "Plaque"),
+      s("can", "Cylinder"),
+      s("cube", "Cube"),
+      s("bevel", "Bevel"),
+      s("donut", "Donut"),
+      s("noSmoking", '"No" Symbol'),
+      s("blockArc", "Block Arc"),
+      s("foldedCorner", "Folded Corner"),
+      s("smileyFace", "Smiley Face"),
+      s("heart", "Heart"),
+      s("lightningBolt", "Lightning Bolt"),
+      s("sun", "Sun"),
+      s("moon", "Moon"),
+      s("cloud", "Cloud"),
+      s("arc", "Arc"),
+      s("bracketPair", "Double Bracket"),
+      s("bracePair", "Double Brace"),
+      s("leftBracket", "Left Bracket"),
+      s("rightBracket", "Right Bracket"),
+      s("leftBrace", "Left Brace"),
+      s("rightBrace", "Right Brace"),
+      s("funnel", "Funnel"),
+      s("gear6", "Gear: 6 Teeth"),
+      s("gear9", "Gear: 9 Teeth"),
+      s("cornerTabs", "Corner Tabs"),
+      s("squareTabs", "Square Tabs"),
+      s("plaqueTabs", "Plaque Tabs"),
+      s("chartX", "Chart: X"),
+      s("chartStar", "Chart: Star"),
+      s("chartPlus", "Chart: Plus")
+    ]
+  },
+  {
+    id: "blockArrows",
+    name: "Block Arrows",
+    shapes: [
+      s("rightArrow", "Arrow: Right"),
+      s("leftArrow", "Arrow: Left"),
+      s("upArrow", "Arrow: Up"),
+      s("downArrow", "Arrow: Down"),
+      s("leftRightArrow", "Arrow: Left-Right"),
+      s("upDownArrow", "Arrow: Up-Down"),
+      s("quadArrow", "Arrow: Quad"),
+      s("leftRightUpArrow", "Arrow: Left-Right-Up"),
+      s("bentArrow", "Arrow: Bent"),
+      s("uturnArrow", "Arrow: U-Turn"),
+      s("leftUpArrow", "Arrow: Left-Up"),
+      s("bentUpArrow", "Arrow: Bent-Up"),
+      s("curvedRightArrow", "Arrow: Curved Right"),
+      s("curvedLeftArrow", "Arrow: Curved Left"),
+      s("curvedUpArrow", "Arrow: Curved Up"),
+      s("curvedDownArrow", "Arrow: Curved Down"),
+      s("stripedRightArrow", "Arrow: Striped Right"),
+      s("notchedRightArrow", "Arrow: Notched Right"),
+      s("homePlate", "Arrow: Pentagon"),
+      s("chevron", "Arrow: Chevron"),
+      s("rightArrowCallout", "Callout: Right Arrow"),
+      s("downArrowCallout", "Callout: Down Arrow"),
+      s("leftArrowCallout", "Callout: Left Arrow"),
+      s("upArrowCallout", "Callout: Up Arrow"),
+      s("leftRightArrowCallout", "Callout: Left-Right Arrow"),
+      s("upDownArrowCallout", "Callout: Up-Down Arrow"),
+      s("quadArrowCallout", "Callout: Quad Arrow"),
+      s("circularArrow", "Arrow: Circular"),
+      s("leftCircularArrow", "Arrow: Circular Left"),
+      s("leftRightCircularArrow", "Arrow: Circular Left-Right"),
+      s("swooshArrow", "Arrow: Swoosh")
+    ]
+  },
+  {
+    id: "equation",
+    name: "Equation Shapes",
+    shapes: [
+      s("mathPlus", "Plus Sign"),
+      s("mathMinus", "Minus Sign"),
+      s("mathMultiply", "Multiplication Sign"),
+      s("mathDivide", "Division Sign"),
+      s("mathEqual", "Equal Sign"),
+      s("mathNotEqual", "Not Equal Sign")
+    ]
+  },
+  {
+    id: "flowchart",
+    name: "Flowchart",
+    shapes: [
+      s("flowChartProcess", "Flowchart: Process"),
+      s("flowChartAlternateProcess", "Flowchart: Alternate Process"),
+      s("flowChartDecision", "Flowchart: Decision"),
+      s("flowChartInputOutput", "Flowchart: Data"),
+      s("flowChartPredefinedProcess", "Flowchart: Predefined Process"),
+      s("flowChartInternalStorage", "Flowchart: Internal Storage"),
+      s("flowChartDocument", "Flowchart: Document"),
+      s("flowChartMultidocument", "Flowchart: Multidocument"),
+      s("flowChartTerminator", "Flowchart: Terminator"),
+      s("flowChartPreparation", "Flowchart: Preparation"),
+      s("flowChartManualInput", "Flowchart: Manual Input"),
+      s("flowChartManualOperation", "Flowchart: Manual Operation"),
+      s("flowChartConnector", "Flowchart: Connector"),
+      s("flowChartOffpageConnector", "Flowchart: Off-page Connector"),
+      s("flowChartPunchedCard", "Flowchart: Card"),
+      s("flowChartPunchedTape", "Flowchart: Punched Tape"),
+      s("flowChartSummingJunction", "Flowchart: Summing Junction"),
+      s("flowChartOr", "Flowchart: Or"),
+      s("flowChartCollate", "Flowchart: Collate"),
+      s("flowChartSort", "Flowchart: Sort"),
+      s("flowChartExtract", "Flowchart: Extract"),
+      s("flowChartMerge", "Flowchart: Merge"),
+      s("flowChartOnlineStorage", "Flowchart: Stored Data"),
+      s("flowChartDelay", "Flowchart: Delay"),
+      s("flowChartMagneticTape", "Flowchart: Sequential Access Storage"),
+      s("flowChartMagneticDisk", "Flowchart: Magnetic Disk"),
+      s("flowChartMagneticDrum", "Flowchart: Direct Access Storage"),
+      s("flowChartDisplay", "Flowchart: Display"),
+      s("flowChartOfflineStorage", "Flowchart: Offline Storage")
+    ]
+  },
+  {
+    id: "starsBanners",
+    name: "Stars and Banners",
+    shapes: [
+      s("irregularSeal1", "Explosion: 8 Points"),
+      s("irregularSeal2", "Explosion: 14 Points"),
+      s("star4", "Star: 4 Points"),
+      s("star5", "Star: 5 Points"),
+      s("star6", "Star: 6 Points"),
+      s("star7", "Star: 7 Points"),
+      s("star8", "Star: 8 Points"),
+      s("star10", "Star: 10 Points"),
+      s("star12", "Star: 12 Points"),
+      s("star16", "Star: 16 Points"),
+      s("star24", "Star: 24 Points"),
+      s("star32", "Star: 32 Points"),
+      s("ribbon2", "Ribbon: Tilted Up"),
+      s("ribbon", "Ribbon: Tilted Down"),
+      s("ellipseRibbon2", "Ribbon: Curved and Tilted Up"),
+      s("ellipseRibbon", "Ribbon: Curved and Tilted Down"),
+      s("leftRightRibbon", "Ribbon: Left-Right"),
+      s("verticalScroll", "Scroll: Vertical"),
+      s("horizontalScroll", "Scroll: Horizontal"),
+      s("wave", "Wave"),
+      s("doubleWave", "Double Wave")
+    ]
+  },
+  {
+    id: "callouts",
+    name: "Callouts",
+    shapes: [
+      s("wedgeRectCallout", "Speech Bubble: Rectangle"),
+      s("wedgeRoundRectCallout", "Speech Bubble: Rectangle with Corners Rounded"),
+      s("wedgeEllipseCallout", "Speech Bubble: Oval"),
+      s("cloudCallout", "Thought Bubble: Cloud"),
+      s("borderCallout1", "Callout: Line"),
+      s("borderCallout2", "Callout: Bent Line"),
+      s("borderCallout3", "Callout: Double Bent Line"),
+      s("accentCallout1", "Callout: Line with Accent Bar"),
+      s("accentCallout2", "Callout: Bent Line with Accent Bar"),
+      s("accentCallout3", "Callout: Double Bent Line with Accent Bar"),
+      s("callout1", "Callout: Line with No Border"),
+      s("callout2", "Callout: Bent Line with No Border"),
+      s("callout3", "Callout: Double Bent Line with No Border"),
+      s("accentBorderCallout1", "Callout: Line with Border and Accent Bar"),
+      s("accentBorderCallout2", "Callout: Bent Line with Border and Accent Bar"),
+      s("accentBorderCallout3", "Callout: Double Bent Line with Border and Accent Bar")
+    ]
+  },
+  {
+    id: "actionButtons",
+    name: "Action Buttons",
+    shapes: [
+      s("actionButtonBackPrevious", "Action Button: Go Back or Previous"),
+      s("actionButtonForwardNext", "Action Button: Go Forward or Next"),
+      s("actionButtonBeginning", "Action Button: Go to Beginning"),
+      s("actionButtonEnd", "Action Button: Go to End"),
+      s("actionButtonHome", "Action Button: Go Home"),
+      s("actionButtonInformation", "Action Button: Information"),
+      s("actionButtonReturn", "Action Button: Return"),
+      s("actionButtonMovie", "Action Button: Movie"),
+      s("actionButtonDocument", "Action Button: Document"),
+      s("actionButtonSound", "Action Button: Sound"),
+      s("actionButtonHelp", "Action Button: Help"),
+      s("actionButtonBlank", "Action Button: Custom")
+    ]
+  }
+];
+var shapeGalleryCategoryKey = (id) => `pptx.shapes.category.${id}`;
+var shapeGalleryNameKey = (preset) => `pptx.shapes.name.${preset}`;
+var SHAPE_GALLERY_ENTRIES = SHAPE_GALLERY_CATEGORIES.flatMap(
+  (category) => category.shapes.map((shape) => ({ ...shape, category: category.id }))
+);
+function shapeGalleryName(preset) {
+  return SHAPE_GALLERY_ENTRIES.find((entry3) => entry3.preset === preset)?.name;
+}
+
 // geometry/svg-path-curves.ts
 function sampleCubic(p0, p1, p2, p3, segments, out) {
   for (let i2 = 1; i2 <= segments; i2++) {