@extend-ai/react-xlsx 0.18.1 → 0.20.0

package/dist/surface-regl-AY7JZVYY.cjs

@@ -0,0 +1,727 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+var _chunkO3V2MCOCcjs = require('./chunk-O3V2MCOC.cjs');
+
+
+
+
+
+
+
+
+
+var _chunkCJBI5F6Vcjs = require('./chunk-CJBI5F6V.cjs');
+require('./chunk-T5WZHPIN.cjs');
+
+// src/surface-regl.tsx
+var _regl = require('regl'); var _regl2 = _interopRequireDefault(_regl);
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function safeNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().replace(/,/g, "");
+    if (!normalized) {
+      return null;
+    }
+    const parsed = Number(normalized);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function parseRgbColor(color) {
+  const match = /^#?([0-9a-f]{6})$/i.exec(color);
+  if (!match) {
+    return null;
+  }
+  return {
+    blue: Number.parseInt(match[1].slice(4, 6), 16),
+    green: Number.parseInt(match[1].slice(2, 4), 16),
+    red: Number.parseInt(match[1].slice(0, 2), 16)
+  };
+}
+function resolveSurfaceBaseColor(chart, palette) {
+  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _2 => _2.chartColorPalette, 'optionalAccess', _3 => _3[0]]), () => ( _optionalChain([chart, 'access', _4 => _4.series, 'access', _5 => _5[0], 'optionalAccess', _6 => _6.color]))), () => ( _optionalChain([chart, 'access', _7 => _7.series, 'access', _8 => _8[0], 'optionalAccess', _9 => _9.lineColor]))), () => ( chart.axisLineColor)), () => ( chart.textColor)), () => ( palette.text));
+}
+function normalizeSurfaceRendererHexColor(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const normalized = trimmed.startsWith("#") ? trimmed.slice(1) : trimmed;
+  return /^[0-9a-f]{6}$/i.test(normalized) ? `#${normalized.toLowerCase()}` : null;
+}
+function resolveExplicitSurfaceSeriesColor(chart, kind) {
+  const shape = _optionalChain([chart, 'access', _10 => _10.series, 'access', _11 => _11[0], 'optionalAccess', _12 => _12.shapeProperties]);
+  if (kind === "fill" ? _optionalChain([shape, 'optionalAccess', _13 => _13.xmlFillHidden]) === true : _optionalChain([shape, 'optionalAccess', _14 => _14.xmlLineHidden]) === true) return "transparent";
+  const color = kind === "fill" ? _nullishCoalesce(_optionalChain([shape, 'optionalAccess', _15 => _15.xmlFillColor]), () => ( _optionalChain([shape, 'optionalAccess', _16 => _16.solidFillHex]))) : _nullishCoalesce(_optionalChain([shape, 'optionalAccess', _17 => _17.xmlLineColor]), () => ( _optionalChain([shape, 'optionalAccess', _18 => _18.lineColorHex])));
+  return normalizeSurfaceRendererHexColor(color);
+}
+function getSurfaceColorStops(chart, palette) {
+  const explicitFill = resolveExplicitSurfaceSeriesColor(chart, "fill");
+  if (explicitFill) return [explicitFill];
+  const colors = (_nullishCoalesce(chart.chartColorPalette, () => ( []))).filter((value) => typeof value === "string" && value.length > 0);
+  return colors.length > 0 ? colors : [resolveSurfaceBaseColor(chart, palette)];
+}
+function getSurfaceDomain(chart) {
+  const numericValues = chart.series.flatMap((series) => series.values.map((value) => safeNumber(value)).filter((value) => value != null));
+  if (numericValues.length === 0) {
+    return null;
+  }
+  const explicitMin = typeof _optionalChain([chart, 'access', _19 => _19.valueAxis, 'optionalAccess', _20 => _20.min]) === "number" && Number.isFinite(chart.valueAxis.min) ? chart.valueAxis.min : null;
+  const explicitMax = typeof _optionalChain([chart, 'access', _21 => _21.valueAxis, 'optionalAccess', _22 => _22.max]) === "number" && Number.isFinite(chart.valueAxis.max) ? chart.valueAxis.max : null;
+  const rawMin = Math.min(...numericValues);
+  const rawMax = Math.max(...numericValues);
+  const spanBase = Math.max(1e-6, rawMax - Math.min(0, rawMin));
+  const roughStep = spanBase / 5;
+  const magnitude = Math.pow(10, Math.floor(Math.log10(Math.max(roughStep, 1e-6))));
+  const normalized = roughStep / magnitude;
+  const niceStep = normalized <= 1 ? 1 : normalized <= 2 ? 2 : normalized <= 5 ? 5 : 10;
+  const step = typeof _optionalChain([chart, 'access', _23 => _23.valueAxis, 'optionalAccess', _24 => _24.majorUnit]) === "number" && chart.valueAxis.majorUnit > 0 ? chart.valueAxis.majorUnit : niceStep * magnitude;
+  const minValue = _nullishCoalesce(explicitMin, () => ( (rawMin >= 0 ? 0 : Math.floor(rawMin / step) * step)));
+  const maxValue = _nullishCoalesce(explicitMax, () => ( Math.ceil(rawMax / step) * step));
+  const safeMax = maxValue <= minValue ? minValue + step : maxValue;
+  const ticks = [];
+  for (let current = minValue; current <= safeMax + step * 1e-3; current += step) {
+    ticks.push(Number(current.toFixed(8)));
+  }
+  const boundedTicks = [.../* @__PURE__ */ new Set([...ticks.filter((tick) => tick < safeMax), safeMax])];
+  return {
+    maxValue,
+    minValue,
+    safeMax,
+    ticks: boundedTicks.length >= 2 ? boundedTicks : [minValue, safeMax]
+  };
+}
+function resolveSurfaceBandPaletteColor(chart, palette, domain, value) {
+  const bandIndex = resolveSurfaceBandIndex(domain, value);
+  const explicitColor = resolveSurfaceBandFormatColor(chart, "bandFormatColors", bandIndex);
+  if (explicitColor) return explicitColor;
+  const explicitFill = resolveExplicitSurfaceSeriesColor(chart, "fill");
+  if (explicitFill) return explicitFill;
+  const themeColors = _optionalChain([chart, 'access', _25 => _25.raw, 'optionalAccess', _26 => _26.builtinThemeColors]);
+  const paletteCount = Math.trunc((domain.safeMax - domain.minValue) / (domain.ticks[1] - domain.ticks[0])) + 1;
+  const builtinColor = themeColors ? _chunkCJBI5F6Vcjs.resolveBuiltinChartColor.call(void 0, _chunkCJBI5F6Vcjs.getBuiltinChartColor.call(void 0, chart.chartStyleId, bandIndex % paletteCount, paletteCount), themeColors) : void 0;
+  if (builtinColor) return builtinColor;
+  const stops = getSurfaceColorStops(chart, palette);
+  if (stops.length === 0) {
+    return resolveSurfaceBaseColor(chart, palette);
+  }
+  return _nullishCoalesce(_nullishCoalesce(stops[Math.min(stops.length - 1, Math.max(0, bandIndex))], () => ( stops[stops.length - 1])), () => ( resolveSurfaceBaseColor(chart, palette)));
+}
+function resolveSurfaceBandIndex(domain, value) {
+  const ticks = domain.ticks;
+  for (let index = 0; index < ticks.length - 1; index += 1) {
+    const end = _nullishCoalesce(ticks[index + 1], () => ( domain.safeMax));
+    if (value <= end || index === ticks.length - 2) {
+      return index;
+    }
+  }
+  return Math.max(0, ticks.length - 2);
+}
+function resolveSurfaceBandColor(chart, palette, domain, value) {
+  return resolveSurfaceBandPaletteColor(chart, palette, domain, value);
+}
+function resolveSurfaceBandFormatColor(chart, key, index) {
+  const colors = _optionalChain([chart, 'access', _27 => _27.raw, 'optionalAccess', _28 => _28[key]]);
+  if (!colors || typeof colors !== "object" || !Object.prototype.hasOwnProperty.call(colors, index)) return null;
+  const color = colors[index];
+  return typeof color === "string" && color.length > 0 ? color : null;
+}
+function resolveSurfaceWireframeColor(chart, palette, domain, value) {
+  const bandIndex = resolveSurfaceBandIndex(domain, value);
+  const themeColors = _optionalChain([chart, 'access', _29 => _29.raw, 'optionalAccess', _30 => _30.builtinThemeColors]);
+  const paletteCount = Math.trunc((domain.safeMax - domain.minValue) / (domain.ticks[1] - domain.ticks[0])) + 1;
+  const builtinLine = themeColors ? _chunkCJBI5F6Vcjs.resolveBuiltinChartColor.call(void 0, _chunkCJBI5F6Vcjs.getBuiltinChartSurfaceLine.call(void 0, chart.chartStyleId, bandIndex, paletteCount), themeColors) : void 0;
+  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(resolveSurfaceBandFormatColor(chart, "bandFormatLineColors", bandIndex), () => ( resolveExplicitSurfaceSeriesColor(chart, "line"))), () => ( builtinLine)), () => ( resolveSurfaceBandPaletteColor(chart, palette, domain, value)));
+}
+function colorToRgba(color, alpha = 1) {
+  if (color === "transparent") return [0, 0, 0, 0];
+  const rgb = parseRgbColor(color);
+  if (!rgb) {
+    return [0.1, 0.1, 0.1, alpha];
+  }
+  return [rgb.red / 255, rgb.green / 255, rgb.blue / 255, alpha];
+}
+function normalizeSurfaceX(column, cols) {
+  return cols <= 1 ? 0 : (column / (cols - 1) - 0.5) * 2;
+}
+function normalizeSurfaceY(row, rows) {
+  return rows <= 1 ? 0 : (row / (rows - 1) - 0.5) * 2;
+}
+function normalizeSurfaceZ(value, domain, heightExtent, axis) {
+  return -(_chunkO3V2MCOCcjs.normalizeSurfaceValue.call(void 0, value, domain.minValue, domain.safeMax, axis) - 0.5) * heightExtent;
+}
+function projectCartesian3dPoint(x, y, z, rotXRad, rotYRad, usePerspective, perspectiveStrength, rightAngleAxes) {
+  if (rightAngleAxes) {
+    return { depth: z, x: x + z * Math.sin(rotYRad), y: y - z * Math.sin(rotXRad) };
+  }
+  const cosX = Math.cos(rotXRad);
+  const sinX = Math.sin(rotXRad);
+  const cosY = Math.cos(rotYRad);
+  const sinY = Math.sin(rotYRad);
+  const x1 = x * cosY + z * sinY;
+  const z1 = -x * sinY + z * cosY;
+  const y1 = y * cosX - z1 * sinX;
+  const z2 = y * sinX + z1 * cosX;
+  const perspective = usePerspective ? 1 / Math.max(0.18, 1 + z2 * (0.24 + perspectiveStrength * 0.5)) : 1;
+  return {
+    depth: z2,
+    x: x1 * perspective,
+    y: y1 * perspective
+  };
+}
+function withProjectedDepth(point, depth) {
+  return {
+    ...point,
+    depth
+  };
+}
+function nudgeProjectedDepth(point, delta) {
+  return {
+    ...point,
+    depth: point.depth + delta
+  };
+}
+function isContourSurfaceChart(chart) {
+  const rawChartType = chart.raw && typeof chart.raw === "object" && typeof chart.raw.xmlChartType === "string" ? chart.raw.xmlChartType : "";
+  if (rawChartType === "surfaceChart") {
+    return true;
+  }
+  if (rawChartType === "surface3DChart") {
+    return false;
+  }
+  return chart.chartType === "Surface" && chart.is3d !== true;
+}
+function buildSurfaceMesh(chart, palette, layout) {
+  const rows = chart.series.length;
+  const cols = chart.series.reduce((max, series) => Math.max(max, series.values.length), 0);
+  if (rows < 2 || cols < 2) {
+    return null;
+  }
+  const matrix = chart.series.map((series) => Array.from({ length: cols }, (_, columnIndex) => safeNumber(series.values[columnIndex])));
+  const domain = getSurfaceDomain(chart);
+  if (!domain) {
+    return null;
+  }
+  const isContour = isContourSurfaceChart(chart);
+  const isWireframe = chart.wireframe === true;
+  const fillVertices = [];
+  const wallTriangles = [];
+  const contourLines = [];
+  const meshLines = [];
+  const rotX = (_nullishCoalesce(_optionalChain([chart, 'access', _31 => _31.view3d, 'optionalAccess', _32 => _32.rotX]), () => ( 25))) * (Math.PI / 180);
+  const rotY = (_nullishCoalesce(_optionalChain([chart, 'access', _33 => _33.view3d, 'optionalAccess', _34 => _34.rotY]), () => ( 30))) * (Math.PI / 180);
+  const usePerspective = !isContour && _optionalChain([chart, 'access', _35 => _35.view3d, 'optionalAccess', _36 => _36.rAngAx]) === false;
+  const perspectiveStrength = clamp((_nullishCoalesce(_optionalChain([chart, 'access', _37 => _37.view3d, 'optionalAccess', _38 => _38.perspective]), () => ( (usePerspective ? 30 : 0)))) / 100, 0, 1);
+  const ratios = _chunkO3V2MCOCcjs.surfaceDataRatios.call(void 0, rows, cols, _optionalChain([chart, 'access', _39 => _39.valueAxis, 'optionalAccess', _40 => _40.crossBetween]) !== "midCat", _optionalChain([chart, 'access', _41 => _41.view3d, 'optionalAccess', _42 => _42.heightPercent]), _optionalChain([chart, 'access', _43 => _43.view3d, 'optionalAccess', _44 => _44.depthPercent]), layout);
+  const depthScale = ratios.depth;
+  const heightExtent = 2 * ratios.height;
+  const usesFlatMaterial = chart.surfaceMaterial === "flat";
+  const wallLineColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _45 => _45.valueAxis, 'optionalAccess', _46 => _46.majorGridlineColor]), () => ( _optionalChain([chart, 'access', _47 => _47.backWall, 'optionalAccess', _48 => _48.lineColor]))), () => ( _optionalChain([chart, 'access', _49 => _49.sideWall, 'optionalAccess', _50 => _50.lineColor]))), () => ( _optionalChain([chart, 'access', _51 => _51.floor, 'optionalAccess', _52 => _52.lineColor]))), () => ( chart.axisLineColor)), () => ( "#a6a6a6"));
+  const backWallFill = _nullishCoalesce(_optionalChain([chart, 'access', _53 => _53.backWall, 'optionalAccess', _54 => _54.fillColor]), () => ( "#d9d9df"));
+  const sideWallFill = _nullishCoalesce(_optionalChain([chart, 'access', _55 => _55.sideWall, 'optionalAccess', _56 => _56.fillColor]), () => ( "#d5d7dc"));
+  const floorFill = _nullishCoalesce(_optionalChain([chart, 'access', _57 => _57.floor, 'optionalAccess', _58 => _58.fillColor]), () => ( "#d0d2d8"));
+  const projectPoint = (column, row, value) => {
+    const worldX = normalizeSurfaceX(column, cols);
+    if (isContour) {
+      return {
+        depth: 0,
+        worldX,
+        worldY: normalizeSurfaceY(row, rows),
+        worldZ: 0,
+        x: worldX,
+        y: normalizeSurfaceY(row, rows)
+      };
+    }
+    const worldY = normalizeSurfaceZ(value, domain, heightExtent, chart.valueAxis);
+    const worldZ = normalizeSurfaceY(row, rows) * depthScale;
+    const projected = projectCartesian3dPoint(worldX, worldY, worldZ, rotX, rotY, usePerspective, perspectiveStrength, _optionalChain([chart, 'access', _59 => _59.view3d, 'optionalAccess', _60 => _60.rAngAx]) !== false);
+    return {
+      depth: projected.depth,
+      worldX,
+      worldY,
+      worldZ,
+      x: projected.x,
+      y: projected.y
+    };
+  };
+  const addWallQuad = (a, b, c, d2, color) => {
+    wallTriangles.push(
+      { color, points: [a, b, c] },
+      { color, points: [a, c, d2] }
+    );
+  };
+  const addMeshLine = (from, to, color) => {
+    meshLines.push({ color, from, to });
+  };
+  for (let rowIndex = 0; rowIndex < rows - 1; rowIndex += 1) {
+    for (let columnIndex = 0; columnIndex < cols - 1; columnIndex += 1) {
+      const p00 = _optionalChain([matrix, 'access', _61 => _61[rowIndex], 'optionalAccess', _62 => _62[columnIndex]]);
+      const p10 = _optionalChain([matrix, 'access', _63 => _63[rowIndex], 'optionalAccess', _64 => _64[columnIndex + 1]]);
+      const p01 = _optionalChain([matrix, 'access', _65 => _65[rowIndex + 1], 'optionalAccess', _66 => _66[columnIndex]]);
+      const p11 = _optionalChain([matrix, 'access', _67 => _67[rowIndex + 1], 'optionalAccess', _68 => _68[columnIndex + 1]]);
+      if (p00 == null || p10 == null || p01 == null || p11 == null) {
+        continue;
+      }
+      const triangles = _chunkO3V2MCOCcjs.triangulateSurfaceQuad.call(void 0, [
+        { value: p00, x: columnIndex, y: rowIndex },
+        { value: p10, x: columnIndex + 1, y: rowIndex },
+        { value: p11, x: columnIndex + 1, y: rowIndex + 1 },
+        { value: p01, x: columnIndex, y: rowIndex + 1 }
+      ], chart.valueAxis);
+      for (const triangle of triangles) {
+        for (let band = 0; band < domain.ticks.length - 1; band += 1) {
+          const lower = domain.ticks[band];
+          const upper = domain.ticks[band + 1];
+          const polygon = _chunkO3V2MCOCcjs.clipSurfaceBand.call(void 0, _chunkO3V2MCOCcjs.clipSurfaceBand.call(void 0, triangle, lower, true, chart.valueAxis, band === 0), upper, false, chart.valueAxis);
+          if (polygon.length < 3) continue;
+          const bandColor = resolveSurfaceBandColor(chart, palette, domain, (lower + upper) / 2);
+          if (!isWireframe && bandColor !== "transparent") {
+            for (let index = 1; index < polygon.length - 1; index += 1) {
+              for (const vertex of [polygon[0], polygon[index], polygon[index + 1]]) {
+                const point = projectPoint(vertex.x, vertex.y, vertex.value);
+                fillVertices.push({ bandColor, point: isContour ? withProjectedDepth(point, 0.08) : point, value: vertex.value });
+              }
+            }
+          }
+          for (const group of _chunkO3V2MCOCcjs.groupSurfaceBandEdges.call(void 0, polygon, triangle, band, lower, isWireframe)) {
+            const edgeMidpoint = (domain.ticks[group.band] + domain.ticks[group.band + 1]) / 2;
+            const color = resolveSurfaceWireframeColor(chart, palette, domain, edgeMidpoint);
+            if (color !== "transparent") {
+              for (const [from, to] of group.edges) {
+                contourLines.push({ color, from: projectPoint(from.x, from.y, from.value), to: projectPoint(to.x, to.y, to.value) });
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  const columnSkip = Math.max(1, _nullishCoalesce(_optionalChain([chart, 'access', _69 => _69.categoryAxis, 'optionalAccess', _70 => _70.tickMarkSkip]), () => ( 1)));
+  const rowSkip = Math.max(1, _nullishCoalesce(_optionalChain([chart, 'access', _71 => _71.seriesAxis, 'optionalAccess', _72 => _72.tickMarkSkip]), () => ( 1)));
+  if (isContour) {
+    const topLeft = withProjectedDepth(projectPoint(0, 0, domain.minValue), -0.12);
+    const topRight = withProjectedDepth(projectPoint(cols - 1, 0, domain.minValue), -0.12);
+    const bottomRight = withProjectedDepth(projectPoint(cols - 1, rows - 1, domain.minValue), -0.12);
+    const bottomLeft = withProjectedDepth(projectPoint(0, rows - 1, domain.minValue), -0.12);
+    if (_optionalChain([chart, 'access', _73 => _73.backWall, 'optionalAccess', _74 => _74.hidden]) !== true && backWallFill !== "transparent") {
+      addWallQuad(topLeft, topRight, bottomRight, bottomLeft, backWallFill);
+    }
+    for (let columnIndex = 0; columnIndex < cols; columnIndex += columnSkip) {
+      addMeshLine(
+        withProjectedDepth(projectPoint(columnIndex, 0, domain.minValue), 0.04),
+        withProjectedDepth(projectPoint(columnIndex, rows - 1, domain.minValue), 0.04),
+        wallLineColor
+      );
+    }
+    for (let rowIndex = 0; rowIndex < rows; rowIndex += rowSkip) {
+      addMeshLine(
+        withProjectedDepth(projectPoint(0, rowIndex, domain.minValue), 0.04),
+        withProjectedDepth(projectPoint(cols - 1, rowIndex, domain.minValue), 0.04),
+        wallLineColor
+      );
+    }
+  } else {
+    const minPlaneValue = domain.minValue;
+    const wallDepthOffset = 0;
+    const backRow = _optionalChain([chart, 'access', _75 => _75.view3d, 'optionalAccess', _76 => _76.rAngAx]) !== false || Math.cos(rotX) * Math.cos(rotY) >= 0 ? rows - 1 : 0;
+    const sideColumn = Math.sin(rotY) >= 0 ? 0 : cols - 1;
+    if (_optionalChain([chart, 'access', _77 => _77.floor, 'optionalAccess', _78 => _78.hidden]) !== true && floorFill !== "transparent") {
+      addWallQuad(
+        nudgeProjectedDepth(projectPoint(0, 0, minPlaneValue), wallDepthOffset),
+        nudgeProjectedDepth(projectPoint(cols - 1, 0, minPlaneValue), wallDepthOffset),
+        nudgeProjectedDepth(projectPoint(cols - 1, rows - 1, minPlaneValue), wallDepthOffset),
+        nudgeProjectedDepth(projectPoint(0, rows - 1, minPlaneValue), wallDepthOffset),
+        floorFill
+      );
+    }
+    if (_optionalChain([chart, 'access', _79 => _79.backWall, 'optionalAccess', _80 => _80.hidden]) !== true && backWallFill !== "transparent") {
+      addWallQuad(
+        nudgeProjectedDepth(projectPoint(0, backRow, domain.safeMax), wallDepthOffset),
+        nudgeProjectedDepth(projectPoint(cols - 1, backRow, domain.safeMax), wallDepthOffset),
+        nudgeProjectedDepth(projectPoint(cols - 1, backRow, minPlaneValue), wallDepthOffset),
+        nudgeProjectedDepth(projectPoint(0, backRow, minPlaneValue), wallDepthOffset),
+        backWallFill
+      );
+    }
+    if (_optionalChain([chart, 'access', _81 => _81.sideWall, 'optionalAccess', _82 => _82.hidden]) !== true && sideWallFill !== "transparent") {
+      addWallQuad(
+        nudgeProjectedDepth(projectPoint(sideColumn, 0, domain.safeMax), wallDepthOffset),
+        nudgeProjectedDepth(projectPoint(sideColumn, rows - 1, domain.safeMax), wallDepthOffset),
+        nudgeProjectedDepth(projectPoint(sideColumn, rows - 1, minPlaneValue), wallDepthOffset),
+        nudgeProjectedDepth(projectPoint(sideColumn, 0, minPlaneValue), wallDepthOffset),
+        sideWallFill
+      );
+    }
+    for (const tick of _optionalChain([chart, 'access', _83 => _83.valueAxis, 'optionalAccess', _84 => _84.majorGridlines]) ? domain.ticks : []) {
+      if (_optionalChain([chart, 'access', _85 => _85.backWall, 'optionalAccess', _86 => _86.hidden]) !== true && wallLineColor !== "transparent") {
+        addMeshLine(nudgeProjectedDepth(projectPoint(0, backRow, tick), wallDepthOffset * 0.75), nudgeProjectedDepth(projectPoint(cols - 1, backRow, tick), wallDepthOffset * 0.75), wallLineColor);
+      }
+      if (_optionalChain([chart, 'access', _87 => _87.sideWall, 'optionalAccess', _88 => _88.hidden]) !== true && wallLineColor !== "transparent") {
+        addMeshLine(nudgeProjectedDepth(projectPoint(sideColumn, 0, tick), wallDepthOffset * 0.75), nudgeProjectedDepth(projectPoint(sideColumn, rows - 1, tick), wallDepthOffset * 0.75), wallLineColor);
+      }
+    }
+    for (let columnIndex = 0; _optionalChain([chart, 'access', _89 => _89.categoryAxis, 'optionalAccess', _90 => _90.majorGridlines]) && columnIndex < cols; columnIndex += columnSkip) {
+      if (_optionalChain([chart, 'access', _91 => _91.floor, 'optionalAccess', _92 => _92.hidden]) !== true && wallLineColor !== "transparent") {
+        addMeshLine(nudgeProjectedDepth(projectPoint(columnIndex, 0, minPlaneValue), wallDepthOffset * 0.75), nudgeProjectedDepth(projectPoint(columnIndex, rows - 1, minPlaneValue), wallDepthOffset * 0.75), wallLineColor);
+      }
+      if (_optionalChain([chart, 'access', _93 => _93.backWall, 'optionalAccess', _94 => _94.hidden]) !== true && wallLineColor !== "transparent") {
+        addMeshLine(nudgeProjectedDepth(projectPoint(columnIndex, backRow, minPlaneValue), wallDepthOffset * 0.75), nudgeProjectedDepth(projectPoint(columnIndex, backRow, domain.safeMax), wallDepthOffset * 0.75), wallLineColor);
+      }
+    }
+    for (let rowIndex = 0; _optionalChain([chart, 'access', _95 => _95.seriesAxis, 'optionalAccess', _96 => _96.majorGridlines]) && rowIndex < rows; rowIndex += rowSkip) {
+      if (_optionalChain([chart, 'access', _97 => _97.floor, 'optionalAccess', _98 => _98.hidden]) !== true && wallLineColor !== "transparent") {
+        addMeshLine(nudgeProjectedDepth(projectPoint(0, rowIndex, minPlaneValue), wallDepthOffset * 0.75), nudgeProjectedDepth(projectPoint(cols - 1, rowIndex, minPlaneValue), wallDepthOffset * 0.75), wallLineColor);
+      }
+      if (_optionalChain([chart, 'access', _99 => _99.sideWall, 'optionalAccess', _100 => _100.hidden]) !== true && wallLineColor !== "transparent") {
+        addMeshLine(nudgeProjectedDepth(projectPoint(sideColumn, rowIndex, minPlaneValue), wallDepthOffset * 0.75), nudgeProjectedDepth(projectPoint(sideColumn, rowIndex, domain.safeMax), wallDepthOffset * 0.75), wallLineColor);
+      }
+    }
+  }
+  const allPoints = [
+    ...fillVertices.map((vertex) => vertex.point),
+    ...wallTriangles.flatMap((triangle) => triangle.points),
+    ...meshLines.flatMap((line) => [line.from, line.to]),
+    ...contourLines.flatMap((line) => [line.from, line.to])
+  ];
+  if (allPoints.length === 0) {
+    return null;
+  }
+  const minX = Math.min(...allPoints.map((point) => point.x));
+  const maxX = Math.max(...allPoints.map((point) => point.x));
+  const minY = Math.min(...allPoints.map((point) => point.y));
+  const maxY = Math.max(...allPoints.map((point) => point.y));
+  const minDepth = Math.min(...allPoints.map((point) => point.depth));
+  const maxDepth = Math.max(...allPoints.map((point) => point.depth));
+  const scale = Math.min(
+    layout.plot.width / Math.max(0.25, maxX - minX),
+    layout.plot.height / Math.max(0.25, maxY - minY)
+  );
+  const centerX = layout.plot.left + layout.plot.width / 2;
+  const centerY = layout.plot.top + layout.plot.height / 2;
+  const centerRawX = (minX + maxX) / 2;
+  const centerRawY = (minY + maxY) / 2;
+  const toScreenX = (x) => centerX + (x - centerRawX) * scale;
+  const toScreenY = (y) => centerY + (y - centerRawY) * scale;
+  const toClipPoint = (point) => {
+    const screenX = toScreenX(point.x);
+    const screenY = toScreenY(point.y);
+    return {
+      x: screenX / layout.width * 2 - 1,
+      y: 1 - screenY / layout.height * 2,
+      z: clamp((point.depth - minDepth) / Math.max(1e-6, maxDepth - minDepth) * 2 - 1, -1, 1)
+    };
+  };
+  const fillPositions = [];
+  const fillColors = [];
+  const wallPositions = [];
+  const wallColors = [];
+  for (const triangle of wallTriangles) {
+    const world = triangle.points.map((point) => ({ x: point.worldX, y: point.worldY, z: -point.worldZ }));
+    const normal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, _chunkO3V2MCOCcjs.surfaceNormal.call(void 0, world[0], world[1], world[2]), _nullishCoalesce(_optionalChain([chart, 'access', _101 => _101.view3d, 'optionalAccess', _102 => _102.rotX]), () => ( 25)), _nullishCoalesce(_optionalChain([chart, 'access', _103 => _103.view3d, 'optionalAccess', _104 => _104.rotY]), () => ( 30)), _optionalChain([chart, 'access', _105 => _105.view3d, 'optionalAccess', _106 => _106.rAngAx]) !== false);
+    const rgba = colorToRgba(usesFlatMaterial ? triangle.color : _chunkO3V2MCOCcjs.shadeSurfaceMatteColor.call(void 0, triangle.color, normal), 1);
+    for (const point of triangle.points) {
+      const clip = toClipPoint(point);
+      wallPositions.push(clip.x, clip.y, clip.z);
+      wallColors.push(rgba[0], rgba[1], rgba[2], rgba[3]);
+    }
+  }
+  for (let index = 0; index < fillVertices.length; index += 3) {
+    const left = fillVertices[index];
+    const middle = fillVertices[index + 1];
+    const right = fillVertices[index + 2];
+    if (!left || !middle || !right) {
+      continue;
+    }
+    const world = [left, middle, right].map((vertex) => ({ x: vertex.point.worldX, y: vertex.point.worldY, z: -vertex.point.worldZ }));
+    const normal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, _chunkO3V2MCOCcjs.surfaceNormal.call(void 0, world[0], world[1], world[2]), _nullishCoalesce(_optionalChain([chart, 'access', _107 => _107.view3d, 'optionalAccess', _108 => _108.rotX]), () => ( 25)), _nullishCoalesce(_optionalChain([chart, 'access', _109 => _109.view3d, 'optionalAccess', _110 => _110.rotY]), () => ( 30)), _optionalChain([chart, 'access', _111 => _111.view3d, 'optionalAccess', _112 => _112.rAngAx]) !== false);
+    const shaded = colorToRgba(usesFlatMaterial ? left.bandColor : _chunkO3V2MCOCcjs.shadeSurfaceMatteColor.call(void 0, left.bandColor, normal), 1);
+    [left, middle, right].forEach((vertex) => {
+      const clip = toClipPoint(vertex.point);
+      fillPositions.push(clip.x, clip.y, clip.z);
+      fillColors.push(shaded[0], shaded[1], shaded[2], shaded[3]);
+    });
+  }
+  const linePositions = [];
+  const lineColors = [];
+  meshLines.forEach((line) => {
+    const from = toClipPoint(line.from);
+    const to = toClipPoint(line.to);
+    const rgba = colorToRgba(line.color, 1);
+    linePositions.push(from.x, from.y, from.z - 1e-5, to.x, to.y, to.z - 1e-5);
+    lineColors.push(rgba[0], rgba[1], rgba[2], rgba[3], rgba[0], rgba[1], rgba[2], rgba[3]);
+  });
+  contourLines.forEach((line) => {
+    const from = toClipPoint(line.from);
+    const to = toClipPoint(line.to);
+    const rgba = colorToRgba(line.color, 1);
+    linePositions.push(from.x, from.y, from.z - 1e-5, to.x, to.y, to.z - 1e-5);
+    lineColors.push(rgba[0], rgba[1], rgba[2], rgba[3], rgba[0], rgba[1], rgba[2], rgba[3]);
+  });
+  return {
+    fillColors: new Float32Array(fillColors),
+    fillPositions: new Float32Array(fillPositions),
+    lineColors: new Float32Array(lineColors),
+    linePositions: new Float32Array(linePositions),
+    wallColors: new Float32Array(wallColors),
+    wallPositions: new Float32Array(wallPositions)
+  };
+}
+var MemoSurfaceChartComposite = _chunkCJBI5F6Vcjs.N.call(void 0, function MemoSurfaceChartComposite2({
+  background,
+  borderColor,
+  chart,
+  fontFamily,
+  layout,
+  onDoubleClick,
+  onPointerDown,
+  overlay,
+  palette,
+  fallback
+}) {
+  const canvasRef = _chunkCJBI5F6Vcjs.A.call(void 0, null);
+  const [ready, setReady] = _chunkCJBI5F6Vcjs.d.call(void 0, false);
+  const [failed, setFailed] = _chunkCJBI5F6Vcjs.d.call(void 0, false);
+  const isContour = isContourSurfaceChart(chart);
+  _chunkCJBI5F6Vcjs.h.call(void 0, () => {
+    if (isContour) {
+      setReady(false);
+      setFailed(false);
+      return;
+    }
+    const canvas = canvasRef.current;
+    if (!canvas) {
+      return;
+    }
+    let cancelled = false;
+    let reglInstance = null;
+    const drawSurface = () => {
+      try {
+        const scene = buildSurfaceMesh(chart, palette, layout);
+        if (!scene) {
+          if (!cancelled) {
+            setFailed(true);
+            setReady(false);
+          }
+          return;
+        }
+        const dpr = window.devicePixelRatio || 1;
+        canvas.width = Math.max(1, Math.round(layout.width * dpr));
+        canvas.height = Math.max(1, Math.round(layout.height * dpr));
+        reglInstance = _regl2.default.call(void 0, {
+          attributes: {
+            alpha: true,
+            antialias: true,
+            depth: true,
+            premultipliedAlpha: true
+          },
+          canvas
+        });
+        const fillCommand = scene.fillPositions.length > 0 ? reglInstance({
+          attributes: {
+            color: scene.fillColors,
+            position: scene.fillPositions
+          },
+          blend: {
+            enable: true,
+            func: {
+              dstRGB: "one minus src alpha",
+              dstAlpha: "one minus src alpha",
+              srcRGB: "src alpha",
+              srcAlpha: "src alpha"
+            }
+          },
+          count: scene.fillPositions.length / 3,
+          depth: {
+            enable: true
+          },
+          frag: `
+                precision mediump float;
+                varying vec4 vColor;
+                void main() {
+                  gl_FragColor = vColor;
+                }
+              `,
+          primitive: "triangles",
+          vert: `
+                precision mediump float;
+                attribute vec3 position;
+                attribute vec4 color;
+                varying vec4 vColor;
+                void main() {
+                  gl_Position = vec4(position, 1.0);
+                  vColor = color;
+                }
+              `
+        }) : null;
+        const wallCommand = scene.wallPositions.length > 0 ? reglInstance({
+          attributes: {
+            color: scene.wallColors,
+            position: scene.wallPositions
+          },
+          blend: {
+            enable: true,
+            func: {
+              dstRGB: "one minus src alpha",
+              dstAlpha: "one minus src alpha",
+              srcRGB: "src alpha",
+              srcAlpha: "src alpha"
+            }
+          },
+          count: scene.wallPositions.length / 3,
+          depth: {
+            enable: true,
+            func: "lequal"
+          },
+          frag: `
+                precision mediump float;
+                varying vec4 vColor;
+                void main() {
+                  gl_FragColor = vColor;
+                }
+              `,
+          primitive: "triangles",
+          vert: `
+                precision mediump float;
+                attribute vec3 position;
+                attribute vec4 color;
+                varying vec4 vColor;
+                void main() {
+                  gl_Position = vec4(position, 1.0);
+                  vColor = color;
+                }
+              `
+        }) : null;
+        const lineCommand = scene.linePositions.length > 0 ? reglInstance({
+          attributes: {
+            color: scene.lineColors,
+            position: scene.linePositions
+          },
+          blend: {
+            enable: true,
+            func: {
+              dstRGB: "one minus src alpha",
+              dstAlpha: "one minus src alpha",
+              srcRGB: "src alpha",
+              srcAlpha: "src alpha"
+            }
+          },
+          count: scene.linePositions.length / 3,
+          depth: {
+            enable: true,
+            func: "lequal"
+          },
+          frag: `
+                precision mediump float;
+                varying vec4 vColor;
+                void main() {
+                  gl_FragColor = vColor;
+                }
+              `,
+          lineWidth: 1,
+          primitive: "lines",
+          vert: `
+                precision mediump float;
+                attribute vec3 position;
+                attribute vec4 color;
+                varying vec4 vColor;
+                void main() {
+                  gl_Position = vec4(position, 1.0);
+                  vColor = color;
+                }
+              `
+        }) : null;
+        reglInstance.clear({ color: [0, 0, 0, 0], depth: 1 });
+        _optionalChain([wallCommand, 'optionalCall', _113 => _113()]);
+        _optionalChain([fillCommand, 'optionalCall', _114 => _114()]);
+        _optionalChain([lineCommand, 'optionalCall', _115 => _115()]);
+        if (!cancelled) {
+          setReady(true);
+          setFailed(false);
+        }
+      } catch (e) {
+        if (!cancelled) {
+          setReady(false);
+          setFailed(true);
+        }
+      }
+    };
+    setReady(false);
+    setFailed(false);
+    drawSurface();
+    return () => {
+      cancelled = true;
+      _optionalChain([reglInstance, 'optionalAccess', _116 => _116.destroy, 'call', _117 => _117()]);
+    };
+  }, [
+    chart,
+    isContour,
+    layout,
+    palette
+  ]);
+  const shouldRenderFallback = isContour || failed || !ready;
+  return /* @__PURE__ */ _chunkCJBI5F6Vcjs.u.call(void 0, 
+    "div",
+    {
+      "aria-label": _nullishCoalesce(_nullishCoalesce(chart.title, () => ( chart.name)), () => ( "Chart")),
+      role: "img",
+      style: {
+        background,
+        border: borderColor.trim().toLowerCase() === "transparent" ? "none" : `1px solid ${borderColor}`,
+        boxSizing: "border-box",
+        fontFamily,
+        height: "100%",
+        overflow: "hidden",
+        pointerEvents: "auto",
+        position: "relative",
+        width: "100%"
+      },
+      children: [
+        /* @__PURE__ */ _chunkCJBI5F6Vcjs.u.call(void 0, 
+          "canvas",
+          {
+            ref: canvasRef,
+            style: {
+              display: shouldRenderFallback ? "none" : "block",
+              height: "100%",
+              inset: 0,
+              position: "absolute",
+              width: "100%"
+            }
+          }
+        ),
+        /* @__PURE__ */ _chunkCJBI5F6Vcjs.u.call(void 0, 
+          "svg",
+          {
+            onDoubleClick,
+            onPointerDown,
+            style: { display: "block", height: "100%", inset: 0, position: "absolute", width: "100%" },
+            viewBox: `0 0 ${layout.width} ${layout.height}`,
+            children: [
+              shouldRenderFallback ? fallback : null,
+              overlay
+            ]
+          }
+        )
+      ]
+    }
+  );
+}, (prev, next) => prev.chart === next.chart && prev.palette === next.palette && prev.background === next.background && prev.borderColor === next.borderColor && prev.fontFamily === next.fontFamily && prev.onDoubleClick === next.onDoubleClick && prev.onPointerDown === next.onPointerDown && prev.layout.width === next.layout.width && prev.layout.height === next.layout.height && prev.layout.plot.left === next.layout.plot.left && prev.layout.plot.top === next.layout.plot.top && prev.layout.plot.width === next.layout.plot.width && prev.layout.plot.height === next.layout.plot.height && prev.overlay === next.overlay && prev.fallback === next.fallback);
+
+
+exports.MemoSurfaceChartComposite = MemoSurfaceChartComposite;
+//# sourceMappingURL=surface-regl-AY7JZVYY.cjs.map