prographs 0.12.0 → 0.13.0

package/dist/chunk-SYABFMD7.cjs

@@ -0,0 +1,633 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _class; var _class2;
+
+var _chunkCM7X3KFUcjs = require('./chunk-CM7X3KFU.cjs');
+
+
+var _chunk6KYVL5HYcjs = require('./chunk-6KYVL5HY.cjs');
+
+
+var _chunkPY4R3IFFcjs = require('./chunk-PY4R3IFF.cjs');
+
+// src/charts/threesurfaces/SurfaceBase.ts
+var _d3 = require('d3');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _three = require('./vendor/three.js');
+
+// src/charts/threesurfaces/ColorRamp.ts
+
+var ColorRamp = class {
+  constructor(fn, lo = 0, hi = 1, size = 128) {
+    this.lo = lo;
+    this.hi = hi;
+    this.table = Array.from({ length: size }, (_, k) => new (0, _three.Color)(fn(lo + (hi - lo) * k / (size - 1))));
+  }
+  
+  
+  
+  at(t) {
+    const position = Number.isFinite(t) ? (t - this.lo) / (this.hi - this.lo) : 0;
+    return this.table[Math.round(Math.max(0, Math.min(1, position)) * (this.table.length - 1))];
+  }
+};
+
+// src/charts/threesurfaces/SurfaceGeometry.ts
+
+var _BufferGeometryUtilsjs = require('three/addons/utils/BufferGeometryUtils.js');
+var SurfaceGeometry = class _SurfaceGeometry {
+  /** `nx × ny` vertex lattice. A vertex with a non-finite coordinate is a hole and its triangles are skipped. */
+  static grid(nx, ny, place, paint, wrap = {}) {
+    const positions = new Float32Array(nx * ny * 3), colors = new Float32Array(nx * ny * 3), solid = new Uint8Array(nx * ny);
+    for (let j = 0; j < ny; j++) for (let i = 0; i < nx; i++) {
+      const point = place(i, j), k = i + j * nx;
+      if (!point.every(Number.isFinite)) continue;
+      solid[k] = 1;
+      positions.set(point, k * 3);
+      const color = paint(i, j);
+      colors.set([color.r, color.g, color.b], k * 3);
+    }
+    const indices = [];
+    const cellsX = wrap.x ? nx : nx - 1, cellsY = wrap.y ? ny : ny - 1;
+    for (let j = 0; j < cellsY; j++) for (let i = 0; i < cellsX; i++) {
+      const a = i + j * nx, b = (i + 1) % nx + j * nx, c = i + (j + 1) % ny * nx, d = (i + 1) % nx + (j + 1) % ny * nx;
+      if (solid[a] && solid[b] && solid[d]) indices.push(a, d, b);
+      if (solid[a] && solid[d] && solid[c]) indices.push(a, c, d);
+    }
+    const geometry = new (0, _three.BufferGeometry)();
+    geometry.setAttribute("position", new (0, _three.Float32BufferAttribute)(positions, 3));
+    geometry.setAttribute("color", new (0, _three.Float32BufferAttribute)(colors, 3));
+    geometry.setIndex(indices);
+    geometry.computeVertexNormals();
+    return geometry;
+  }
+  /** Split shared vertices so each triangle shades flat. `userData.source` keeps the way back to the grid for picking. */
+  static faceted(geometry) {
+    const source = Uint32Array.from(_nullishCoalesce(_optionalChain([geometry, 'access', _3 => _3.getIndex, 'call', _4 => _4(), 'optionalAccess', _5 => _5.array]), () => ( [])));
+    const flat = geometry.toNonIndexed();
+    flat.computeVertexNormals();
+    flat.userData.source = source;
+    return flat;
+  }
+  /** Vertical wall hanging from a polyline to `base`, with colours for its top and bottom edges. */
+  static curtain(top, base, upper, lower) {
+    const floor = typeof base === "number" ? () => base : base;
+    const finite = top.map((point) => point.every(Number.isFinite));
+    return _SurfaceGeometry.grid(
+      top.length,
+      2,
+      (k, row) => finite[k] ? row ? top[k] : [top[k][0], floor(k), top[k][2]] : [NaN, NaN, NaN],
+      (k, row) => row ? upper(k) : lower(k)
+    );
+  }
+  /** A curtain with thickness along `(dx, dz)`: front, back and lid. */
+  static slab(top, [dx, dz], base, upper, lower) {
+    const shift = (sign) => top.map(([x, y, z]) => [x + dx * sign / 2, y, z + dz * sign / 2]);
+    const front = shift(1), back = shift(-1);
+    const lid = _SurfaceGeometry.grid(top.length, 2, (k, row) => (row ? back : front)[k], upper);
+    const ends = [0, top.length - 1].map((k) => {
+      const floor = typeof base === "number" ? base : base(k);
+      const wall = (point) => [[point[0], floor, point[2]], point];
+      return _SurfaceGeometry.grid(2, 2, (i, row) => wall((i ? back : front)[k])[row], (_, row) => row ? upper(k) : lower(k));
+    });
+    return _SurfaceGeometry.merge([_SurfaceGeometry.curtain(front, base, upper, lower), _SurfaceGeometry.curtain(back, base, upper, lower), lid, ...ends]);
+  }
+  /** Drop vertices no triangle uses. `userData.source` maps the survivors back to their original index. */
+  static compact(geometry) {
+    const index = geometry.getIndex();
+    const source = [...new Set(index.array)], renumber = new Map(source.map((vertex, k) => [vertex, k]));
+    const out = new (0, _three.BufferGeometry)();
+    for (const name of Object.keys(geometry.attributes)) {
+      const attribute = geometry.getAttribute(name), size = attribute.itemSize;
+      const values = new Float32Array(source.length * size);
+      source.forEach((vertex, k) => {
+        for (let c = 0; c < size; c++) values[k * size + c] = attribute.array[vertex * size + c];
+      });
+      out.setAttribute(name, new (0, _three.Float32BufferAttribute)(values, size));
+    }
+    out.setIndex(Array.from(index.array, (vertex) => renumber.get(vertex)));
+    out.userData.source = Uint32Array.from(source);
+    return out;
+  }
+  /** Give a three.js primitive the uniform vertex colour that lets it merge with painted geometry. */
+  static tinted(geometry, color) {
+    const count = geometry.getAttribute("position").count;
+    const colors = new Float32Array(count * 3);
+    for (let k = 0; k < count; k++) colors.set([color.r, color.g, color.b], k * 3);
+    geometry.setAttribute("color", new (0, _three.Float32BufferAttribute)(colors, 3));
+    geometry.deleteAttribute("uv");
+    return geometry;
+  }
+  static merge(parts) {
+    const unified = parts.filter((part) => part.getAttribute("position").count).map((part) => part.index ? part : indexed(part));
+    return _nullishCoalesce((unified.length ? _BufferGeometryUtilsjs.mergeGeometries.call(void 0, unified) : null), () => ( new (0, _three.BufferGeometry)()));
+  }
+};
+function indexed(geometry) {
+  geometry.setIndex(Array.from({ length: geometry.getAttribute("position").count }, (_, k) => k));
+  return geometry;
+}
+
+// src/charts/threesurfaces/SurfaceSpace.ts
+
+var FLOOR = -0.7;
+var CEIL = 0.75;
+var SurfaceSpace = class _SurfaceSpace {
+  constructor(field, kind = "linear" /* Linear */, range = [FLOOR, CEIL], domain = field.zDomain) {
+    this.field = field;
+    this.range = range;
+    this.level = _SurfaceSpace.height(kind, domain, range);
+  }
+  
+  
+  
+  /** Height scale. Log becomes symlog so zero and negative heights stay on the chart. */
+  static height(kind, [lo, hi], range) {
+    const scale = kind === "log" /* Log */ || kind === "symlog" /* Symlog */ ? _d3.scaleSymlog.call(void 0, ).constant(Math.max(hi - lo, 1e-9) / 8) : _chunkPY4R3IFFcjs.Scales.continuous(kind);
+    return scale.domain([lo, hi]).range(range);
+  }
+  /** Position of a fractional index along a possibly uneven axis, 0..1. */
+  fraction(axis, index) {
+    const i = Math.max(0, Math.min(axis.length - 2, Math.floor(index)));
+    const span = axis.at(-1) - axis[0] || 1;
+    return (axis[i] + (axis[i + 1] - axis[i]) * (index - i) - axis[0]) / span;
+  }
+  /** World x and z of a fractional grid index. */
+  ground(fi, fj) {
+    return [this.fraction(this.field.x, fi) * 2 - 1, 1 - this.fraction(this.field.y, fj) * 2];
+  }
+  at(fi, fj, lift = 0) {
+    const [x, z] = this.ground(fi, fj);
+    return [x, this.level(this.field.sample(fi, fj)) + lift, z];
+  }
+  floor(fi, fj, lift = 0) {
+    const [x, z] = this.ground(fi, fj);
+    return [x, this.range[0] + lift, z];
+  }
+};
+var PolarSurfaceSpace = class extends SurfaceSpace {
+  constructor(field, kind, sweep, inner, swap = false) {
+    super(field, kind);
+    this.sweep = sweep;
+    this.inner = inner;
+    this.swap = swap;
+  }
+  
+  
+  
+  polar(angle, radius) {
+    const a = ((angle - 0.5) * this.sweep - 90) * (Math.PI / 180);
+    return [Math.cos(a) * radius, Math.sin(a) * radius];
+  }
+  ground(fi, fj) {
+    const { x, y } = this.field;
+    const angular = this.swap ? y : x, radial = this.swap ? x : y;
+    const turn = this.fraction(angular, this.swap ? fj : fi) * (this.sweep === 360 ? (angular.length - 1) / angular.length : 1);
+    return this.polar(turn, this.inner + (1 - this.inner) * this.fraction(radial, this.swap ? fi : fj));
+  }
+};
+
+// src/charts/threesurfaces/TubeBatch.ts
+
+var WHITE = new (0, _three.Color)(1, 1, 1);
+var WEIGHT = 1.6;
+var TubeBatch = (_class = class {
+  constructor(radius = 65e-4, sides = 5) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
+    this.radius = radius;
+    this.sides = sides;
+  }
+  
+  
+  __init() {this.positions = []}
+  __init2() {this.normals = []}
+  __init3() {this.colors = []}
+  __init4() {this.indices = []}
+  /** Add a polyline. A non-finite point breaks it into separate runs. */
+  add(path, paint = WHITE, radius = this.radius) {
+    radius *= WEIGHT;
+    let run = [], first = 0;
+    const flush = (start) => {
+      if (run.length > 1) this.tube(run, start, paint, radius);
+      run = [];
+    };
+    path.forEach((point, k) => {
+      if (!point.every(Number.isFinite)) return flush(first);
+      const next = new (0, _three.Vector3)(...point);
+      if (run.length && run.at(-1).distanceToSquared(next) < 1e-10) return;
+      if (!run.length) first = k;
+      run.push(next);
+    });
+    flush(first);
+    return this;
+  }
+  tube(run, start, paint, radius) {
+    const { sides } = this;
+    const base = this.positions.length / 3;
+    const tangent = new (0, _three.Vector3)(), side = new (0, _three.Vector3)(), up = new (0, _three.Vector3)(), ring = new (0, _three.Vector3)();
+    tangent.subVectors(run[1], run[0]).normalize();
+    side.set(Math.abs(tangent.y) > 0.9 ? 1 : 0, Math.abs(tangent.y) > 0.9 ? 0 : 1, 0);
+    run.forEach((point, k) => {
+      tangent.subVectors(run[Math.min(k + 1, run.length - 1)], run[Math.max(k - 1, 0)]).normalize();
+      side.addScaledVector(tangent, -side.dot(tangent)).normalize();
+      up.crossVectors(tangent, side);
+      const color = typeof paint === "function" ? paint(start + k) : paint;
+      for (let s = 0; s < sides; s++) {
+        const angle = s / sides * Math.PI * 2;
+        ring.copy(side).multiplyScalar(Math.cos(angle)).addScaledVector(up, Math.sin(angle));
+        this.positions.push(point.x + ring.x * radius, point.y + ring.y * radius, point.z + ring.z * radius);
+        this.normals.push(ring.x, ring.y, ring.z);
+        this.colors.push(color.r, color.g, color.b);
+      }
+    });
+    for (let k = 0; k < run.length - 1; k++) for (let s = 0; s < sides; s++) {
+      const a = base + k * sides + s, b = base + k * sides + (s + 1) % sides, c = a + sides, d = b + sides;
+      this.indices.push(a, b, c, b, d, c);
+    }
+  }
+  get empty() {
+    return !this.indices.length;
+  }
+  geometry() {
+    const geometry = new (0, _three.BufferGeometry)();
+    geometry.setAttribute("position", new (0, _three.Float32BufferAttribute)(this.positions, 3));
+    geometry.setAttribute("normal", new (0, _three.Float32BufferAttribute)(this.normals, 3));
+    geometry.setAttribute("color", new (0, _three.Float32BufferAttribute)(this.colors, 3));
+    geometry.setIndex(this.indices);
+    return geometry;
+  }
+}, _class);
+
+// src/charts/threesurfaces/SurfaceBase.ts
+var SurfaceOverlay = /* @__PURE__ */ ((SurfaceOverlay2) => {
+  SurfaceOverlay2["None"] = "bare";
+  SurfaceOverlay2["Mesh"] = "mesh-lines";
+  SurfaceOverlay2["Contours"] = "contour-lines";
+  return SurfaceOverlay2;
+})(SurfaceOverlay || {});
+var SurfaceProjection = /* @__PURE__ */ ((SurfaceProjection2) => {
+  SurfaceProjection2["None"] = "unprojected";
+  SurfaceProjection2["FloorContours"] = "floor-contours";
+  SurfaceProjection2["FloorHeatmap"] = "floor-heatmap";
+  SurfaceProjection2["Walls"] = "wall-profiles";
+  return SurfaceProjection2;
+})(SurfaceProjection || {});
+var LINE = 65e-4;
+var SurfaceBase = class extends _chunk6KYVL5HYcjs.Chart3D {
+  defaults() {
+    return { azimuth: 38, elevation: 26, distance: 5.2 };
+  }
+  ticks(domain, map, count = 4) {
+    const reach = Math.abs(domain[1] - domain[0]);
+    return _d3.scaleLinear.call(void 0, domain, [0, 1]).ticks(count).map((value) => [map(value), _chunkPY4R3IFFcjs.Scales.format(value, reach)]);
+  }
+  /** Back walls and floor with gridlines at the ticks. The walls swap sides as the camera orbits, so they never block the data. */
+  box(ctx, { x, y, z }, { walls = true, bottom = FLOOR, outline = true } = {}) {
+    const stage = new (0, _three.Group)();
+    const grid = new (0, _three.LineBasicMaterial)({ color: ctx.theme.grid }), edge = new (0, _three.LineBasicMaterial)({ color: ctx.theme.axis });
+    const lines = (points, material) => {
+      const geometry = new (0, _three.BufferGeometry)();
+      geometry.setAttribute("position", new (0, _three.Float32BufferAttribute)(points, 3));
+      return new (0, _three.LineSegments)(geometry, material);
+    };
+    const top = walls ? Math.max(CEIL, bottom) : bottom;
+    stage.add(lines([...x.flatMap(([at]) => [at, bottom, -1, at, bottom, 1]), ...y.flatMap(([at]) => [-1, bottom, at, 1, bottom, at])], grid));
+    if (outline) stage.add(lines([-1, bottom, -1, 1, bottom, -1, 1, bottom, -1, 1, bottom, 1, 1, bottom, 1, -1, bottom, 1, -1, bottom, 1, -1, bottom, -1], edge));
+    const catcher = new (0, _three.Mesh)(new (0, _three.PlaneGeometry)(2, 2), new (0, _three.ShadowMaterial)({ opacity: 0.16 }));
+    catcher.rotation.x = -Math.PI / 2;
+    catcher.position.y = bottom - 2e-3;
+    catcher.receiveShadow = true;
+    stage.add(catcher);
+    if (walls) {
+      const across = lines([...x.flatMap(([at]) => [at, bottom, -1, at, top, -1]), ...z.flatMap(([at]) => [-1, at, -1, 1, at, -1])], grid);
+      const along = lines([...y.flatMap(([at]) => [-1, bottom, at, -1, top, at]), ...z.flatMap(([at]) => [-1, at, -1, -1, at, 1])], grid);
+      stage.add(across, along);
+      catcher.onBeforeRender = (_renderer, _scene, camera) => {
+        across.position.z = camera.position.z >= 0 ? 0 : 2;
+        along.position.x = camera.position.x >= 0 ? 0 : 2;
+        across.updateMatrixWorld();
+        along.updateMatrixWorld();
+      };
+    }
+    ctx.root.add(stage);
+    const { xLabel, yLabel, zLabel } = this.options;
+    for (const [at, text] of x) ctx.label(text, [at, bottom - 0.03, 1.12], "muted", 10);
+    for (const [at, text] of y) ctx.label(text, [1.13, bottom - 0.03, at], "muted", 10);
+    if (walls) for (const [at, text] of z) ctx.label(text, [-1.1, at, 1.02], "muted", 10);
+    const longest = Math.max(0, ...y.map(([, text]) => text.length));
+    if (xLabel && x.some(([, text]) => text)) ctx.label(xLabel, [0, bottom - 0.03, 1.5], "secondary", 11);
+    if (yLabel && y.some(([, text]) => text)) ctx.label(yLabel, [1.4 + longest * 0.04, bottom - 0.03, 0], "secondary", 11);
+    if (zLabel && walls) ctx.label(zLabel, [-1.1, CEIL + 0.12, 1.02], "secondary", 11);
+  }
+  /** Group that grows out of the floor on entry. */
+  rise(ctx, floor = FLOOR) {
+    const group = new (0, _three.Group)();
+    ctx.reveal((progress) => {
+      group.scale.y = Math.max(1e-3, progress);
+      group.position.y = floor * (1 - group.scale.y);
+    }, 1.1);
+    ctx.root.add(group);
+    return group;
+  }
+  /** Group that scales and turns into place, for free-standing shapes. */
+  bloom(ctx) {
+    const group = new (0, _three.Group)();
+    ctx.reveal((progress) => {
+      group.scale.setScalar(Math.max(1e-3, progress));
+      group.rotation.y = (progress - 1) * 1.2;
+    }, 1.3);
+    ctx.root.add(group);
+    return group;
+  }
+  /** Height colour: polarity when the data crosses zero, magnitude otherwise. */
+  painter(ctx, [lo, hi]) {
+    const scale = _nullishCoalesce(this.options.color, () => ( (lo < 0 && hi > 0 ? "diverging" /* Diverging */ : "sequential" /* Sequential */)));
+    if (scale === "diverging" /* Diverging */) {
+      const ramp2 = new ColorRamp(ctx.palette.diverging, -1, 1), reach = Math.max(Math.abs(lo), Math.abs(hi)) || 1;
+      return (value) => ramp2.at(value / reach);
+    }
+    const ramp = new ColorRamp(ctx.palette.sequential);
+    return (value) => ramp.at(0.05 + 0.95 * (value - lo) / (hi - lo || 1));
+  }
+  material(overrides = {}) {
+    return new (0, _three.MeshStandardMaterial)({ vertexColors: true, side: _three.DoubleSide, roughness: 0.62, metalness: 0, ...overrides });
+  }
+  /** Painted, shadow-casting surface. `pick` receives the nearest vertex. */
+  solid(ctx, geometry, parent, pick, overrides) {
+    const mesh = new (0, _chunkCM7X3KFUcjs.SurfaceMesh)(geometry, this.material(overrides));
+    mesh.castShadow = true;
+    parent.add(mesh);
+    if (pick) ctx.pick(mesh, pick);
+    return mesh;
+  }
+  /** Draw a tube batch. Pass `color` for a single tone; otherwise the batch's own colours are used. */
+  tubes(batch, parent, color, opacity = 1) {
+    if (batch.empty) return null;
+    const mesh = new (0, _three.Mesh)(batch.geometry(), this.material({ vertexColors: !color, side: 0, roughness: 0.5, ...color ? { color } : {}, transparent: opacity < 1, opacity }));
+    parent.add(mesh);
+    return mesh;
+  }
+  /** Round markers on one instanced mesh; sizes in world units. */
+  dots(ctx, points, radius, paint, parent, pick) {
+    if (!points.length) return null;
+    const mesh = new (0, _three.InstancedMesh)(new (0, _three.SphereGeometry)(1, 12, 10), new (0, _three.MeshStandardMaterial)({ roughness: 0.45 }), points.length);
+    const dummy = new (0, _three.Object3D)();
+    points.forEach((point, k) => {
+      dummy.position.set(...point);
+      dummy.scale.setScalar(typeof radius === "number" ? radius : radius(k));
+      dummy.updateMatrix();
+      mesh.setMatrixAt(k, dummy.matrix);
+      mesh.setColorAt(k, paint(k));
+    });
+    mesh.castShadow = true;
+    parent.add(mesh);
+    if (pick) ctx.pick(mesh, pick);
+    return mesh;
+  }
+  /** Thin surface-coloured lattice that reveals the shape of the mesh without adding a new hue. */
+  meshLines(ctx, space, parent, cells = 12) {
+    const { nx, ny } = space.field;
+    const batch = new TubeBatch(LINE * 0.7), stepX = Math.max(1, Math.round((nx - 1) / cells)), stepY = Math.max(1, Math.round((ny - 1) / cells));
+    const columns = Array.from({ length: Math.ceil(nx / stepX) }, (_, k) => k * stepX), rows = Array.from({ length: Math.ceil(ny / stepY) }, (_, k) => k * stepY);
+    for (const i of columns) batch.add(Array.from({ length: ny }, (_, j) => space.at(i, j, 3e-3)));
+    for (const j of rows) batch.add(Array.from({ length: nx }, (_, i) => space.at(i, j, 3e-3)));
+    this.tubes(batch, parent, ctx.theme.surface, 0.8);
+  }
+  thresholds({ zMin, zMax, zDomain }, levels) {
+    if (zMax === zMin) return [zDomain[0]];
+    return Array.from({ length: levels }, (_, k) => zMin + (k + 1) * (zMax - zMin) / (levels + 1));
+  }
+  contourLines(ctx, space, parent, levels = 8) {
+    const batch = new TubeBatch(LINE * 0.6);
+    for (const { paths } of space.field.lines(this.thresholds(space.field, levels))) {
+      for (const path of paths) batch.add(path.map(([i, j]) => space.at(i, j, 4e-3)));
+    }
+    this.tubes(batch, parent, ctx.theme.ink, 0.55);
+  }
+  floorContours(ctx, space, paint, levels = 8) {
+    const batch = new TubeBatch(LINE * 0.7);
+    for (const { value, paths } of space.field.lines(this.thresholds(space.field, levels))) {
+      const color = paint(value);
+      for (const path of paths) batch.add(path.map(([i, j]) => space.floor(i, j, 6e-3)), color);
+    }
+    this.tubes(batch, ctx.root);
+  }
+  floorHeatmap(ctx, space, paint) {
+    const { field } = space;
+    this.solid(ctx, SurfaceGeometry.grid(field.nx, field.ny, (i, j) => Number.isNaN(field.at(i, j)) ? [NaN, NaN, NaN] : space.floor(i, j, 4e-3), (i, j) => paint(field.at(i, j))), ctx.root).castShadow = false;
+  }
+  /** The surface's upper envelope along each axis, drawn as a silhouette on the back walls. */
+  wallProfiles(ctx, space, paint) {
+    const { field } = space;
+    const envelope = (count, across, read) => Array.from({ length: count }, (_, k) => {
+      let top = -Infinity;
+      for (let c = 0; c < across; c++) {
+        const value = read(k, c);
+        if (value > top) top = value;
+      }
+      return top;
+    });
+    const low = paint(field.zDomain[0]);
+    const wall = (peaks, place) => {
+      const top = peaks.map((peak, k) => place(k, Number.isFinite(peak) ? space.level(peak) : NaN));
+      const batch = new TubeBatch(LINE).add(top, (k) => paint(peaks[k]));
+      this.solid(ctx, SurfaceGeometry.curtain(top, FLOOR, (k) => paint(peaks[k]), () => low), ctx.root, void 0, { transparent: true, opacity: 0.4, depthWrite: false }).castShadow = false;
+      this.tubes(batch, ctx.root);
+    };
+    wall(envelope(field.nx, field.ny, (i, j) => field.at(i, j)), (i, h) => [space.ground(i, 0)[0], h, -0.995]);
+    wall(envelope(field.ny, field.nx, (j, i) => field.at(i, j)), (j, h) => [-0.995, h, space.ground(0, j)[1]]);
+  }
+  /** Vertical wall from the surface's boundary to the floor, turning the sheet into a solid. */
+  skirt(ctx, space, paint, parent, sides = [0, 1, 2, 3], closed = false) {
+    const { nx, ny } = space.field;
+    const edges = [
+      Array.from({ length: nx }, (_, i) => [i, 0]),
+      Array.from({ length: ny }, (_, j) => [nx - 1, j]),
+      Array.from({ length: nx }, (_, i) => [i, ny - 1]),
+      Array.from({ length: ny }, (_, j) => [0, j])
+    ];
+    const low = paint(space.field.zDomain[0]);
+    const parts = sides.map((side) => closed ? [...edges[side], edges[side][0]] : edges[side]).map((edge) => SurfaceGeometry.curtain(edge.map(([i, j]) => space.at(i, j)), FLOOR, (k) => paint(space.field.at(...edge[k])), () => low));
+    this.solid(ctx, SurfaceGeometry.merge(parts), parent);
+  }
+};
+
+// src/charts/threesurfaces/SurfaceField.ts
+
+var numeric = (cell) => {
+  if (cell === null || cell === void 0 || cell === "") return NaN;
+  const value = +cell;
+  return Number.isFinite(value) ? value : NaN;
+};
+var catmullRom = (a, b, c, d, t) => b + 0.5 * t * (c - a + t * (2 * a - 5 * b + 4 * c - d + t * (3 * (b - c) + d - a)));
+var SurfaceField = (_class2 = class _SurfaceField {
+  constructor(x, y, z) {;_class2.prototype.__init5.call(this);
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.nx = x.length;
+    this.ny = y.length;
+    const [lo, hi] = _d3.extent.call(void 0, z);
+    this.zMin = _nullishCoalesce(lo, () => ( 0));
+    this.zMax = _nullishCoalesce(hi, () => ( 1));
+  }
+  
+  
+  
+  
+  
+  
+  
+  static empty() {
+    return new _SurfaceField([0, 1], [0, 1], new Float64Array(4).fill(NaN));
+  }
+  static from(data, columns = {}) {
+    if (Array.isArray(data)) return _SurfaceField.pivot(data, columns);
+    if (!_optionalChain([data, 'optionalAccess', _6 => _6.x, 'optionalAccess', _7 => _7.length]) || !_optionalChain([data, 'access', _8 => _8.y, 'optionalAccess', _9 => _9.length]) || !_optionalChain([data, 'access', _10 => _10.z, 'optionalAccess', _11 => _11.length])) return _SurfaceField.empty();
+    const z = new Float64Array(data.x.length * data.y.length);
+    data.y.forEach((_, j) => data.x.forEach((_2, i) => {
+      z[i + j * data.x.length] = numeric(_optionalChain([data, 'access', _12 => _12.z, 'access', _13 => _13[j], 'optionalAccess', _14 => _14[i]]));
+    }));
+    return _SurfaceField.widened(data.x.map(Number), data.y.map(Number), z);
+  }
+  /** Long rows to grid: duplicate cells average, missing cells become holes, text axes index by first appearance. */
+  static pivot(rows, { x = "x", y = "y", z = "z" }) {
+    if (!rows.length) return _SurfaceField.empty();
+    const axis = (column) => {
+      const seen = [...new Set(rows.map((row) => row[column]))].filter((cell) => cell !== null && cell !== void 0);
+      if (seen.every((cell) => Number.isFinite(numeric(cell)))) return new Map([...new Set(seen.map(numeric))].sort((a, b) => a - b).map((value, i) => [value, i]));
+      return new Map(seen.map((cell, i) => [cell, i]));
+    };
+    const lookup = (map, cell) => _nullishCoalesce(map.get(cell), () => ( map.get(numeric(cell))));
+    const xs = axis(x), ys = axis(y);
+    if (!xs.size || !ys.size) return _SurfaceField.empty();
+    const totals = new Float64Array(xs.size * ys.size), counts = new Uint32Array(xs.size * ys.size);
+    for (const row of rows) {
+      const i = lookup(xs, row[x]), j = lookup(ys, row[y]), value = numeric(row[z]);
+      if (i === void 0 || j === void 0 || Number.isNaN(value)) continue;
+      totals[i + j * xs.size] += value;
+      counts[i + j * xs.size]++;
+    }
+    const values = totals.map((total, k) => counts[k] ? total / counts[k] : NaN);
+    const labels = (map) => [...map.keys()].map((key, i) => typeof key === "number" ? key : i);
+    return _SurfaceField.widened(labels(xs), labels(ys), values);
+  }
+  /** A single row or column still needs width to make a surface. */
+  static widened(x, y, z) {
+    if (x.length > 1 && y.length > 1) return new _SurfaceField(x, y, z);
+    const gx = x.length > 1 ? x : [x[0], x[0] + 1], gy = y.length > 1 ? y : [y[0], y[0] + 1];
+    const out = new Float64Array(gx.length * gy.length);
+    gy.forEach((_, j) => gx.forEach((_2, i) => {
+      out[i + j * gx.length] = z[Math.min(i, x.length - 1) + Math.min(j, y.length - 1) * x.length];
+    }));
+    return new _SurfaceField(gx, gy, out);
+  }
+  static compute(x, y, fn) {
+    const z = new Float64Array(x.length * y.length);
+    y.forEach((v, j) => x.forEach((u, i) => {
+      const value = fn(u, v);
+      z[i + j * x.length] = Number.isFinite(value) ? value : NaN;
+    }));
+    return new _SurfaceField(x, y, z);
+  }
+  get xDomain() {
+    return [this.x[0], this.x[this.nx - 1]];
+  }
+  get yDomain() {
+    return [this.y[0], this.y[this.ny - 1]];
+  }
+  get zDomain() {
+    return this.zMax > this.zMin ? [this.zMin, this.zMax] : [this.zMin - 1, this.zMin + 1];
+  }
+  get hasData() {
+    return this.z.some((value) => !Number.isNaN(value));
+  }
+  at(i, j) {
+    return this.z[Math.max(0, Math.min(this.nx - 1, i)) + Math.max(0, Math.min(this.ny - 1, j)) * this.nx];
+  }
+  /** Bilinear read at fractional indices. A hole with any weight makes the read a hole. */
+  sample(fi, fj) {
+    const i = Math.max(0, Math.min(this.nx - 2, Math.floor(fi))), j = Math.max(0, Math.min(this.ny - 2, Math.floor(fj)));
+    const a = fi - i, b = fj - j;
+    const part = (weight, value) => weight > 0 ? weight * value : 0;
+    return part((1 - a) * (1 - b), this.at(i, j)) + part(a * (1 - b), this.at(i + 1, j)) + part((1 - a) * b, this.at(i, j + 1)) + part(a * b, this.at(i + 1, j + 1));
+  }
+  /** Catmull-Rom read at fractional indices. */
+  cubic(fi, fj) {
+    const i = Math.floor(fi), j = Math.floor(fj);
+    const row = (r) => catmullRom(this.at(i - 1, r), this.at(i, r), this.at(i + 1, r), this.at(i + 2, r), fi - i);
+    return catmullRom(row(j - 1), row(j), row(j + 1), row(j + 2), fj - j);
+  }
+  resample(nx, ny, smooth = false) {
+    const lerp = (axis, t) => {
+      const i = Math.min(axis.length - 2, Math.floor(t));
+      return axis[i] + (axis[i + 1] - axis[i]) * (t - i);
+    };
+    const xs = Array.from({ length: nx }, (_, i) => i * (this.nx - 1) / (nx - 1)), ys = Array.from({ length: ny }, (_, j) => j * (this.ny - 1) / (ny - 1));
+    const z = new Float64Array(nx * ny);
+    ys.forEach((fj, j) => xs.forEach((fi, i) => {
+      z[i + j * nx] = smooth ? this.cubic(fi, fj) : this.sample(fi, fj);
+    }));
+    return new _SurfaceField(xs.map((t) => lerp(this.x, t)), ys.map((t) => lerp(this.y, t)), z);
+  }
+  /** Keep vertex counts sane when a user hands in a huge grid. */
+  capped(limit) {
+    return this.nx <= limit && this.ny <= limit ? this : this.resample(Math.min(this.nx, limit), Math.min(this.ny, limit));
+  }
+  map(fn) {
+    const z = this.z.map((value, k) => {
+      const out = fn(value, k % this.nx, Math.floor(k / this.nx));
+      return Number.isFinite(out) ? out : NaN;
+    });
+    return new _SurfaceField(this.x, this.y, z);
+  }
+  raw(thresholds) {
+    const clean = this.z.map((value) => Number.isNaN(value) ? -Infinity : value);
+    return _d3.contours.call(void 0, ).size([this.nx, this.ny]).thresholds(thresholds)(Array.from(clean));
+  }
+  __init5() {this.toGrid = ([x, y]) => [Math.max(0, Math.min(this.nx - 1, x - 0.5)), Math.max(0, Math.min(this.ny - 1, y - 0.5))]}
+  /** Filled iso-bands: each polygon is an outer ring followed by its holes. */
+  bands(thresholds) {
+    return this.raw(thresholds).map(({ value, coordinates }) => ({ value, polygons: coordinates.map((polygon) => polygon.map((ring) => ring.map(this.toGrid))) }));
+  }
+  /** Iso-lines with the grid border removed, so a contour ends at the edge rather than running along it. */
+  lines(thresholds) {
+    const edge = ([x, y]) => x <= 0 || y <= 0 || x >= this.nx || y >= this.ny;
+    return this.raw(thresholds).map(({ value, coordinates }) => ({
+      value,
+      paths: coordinates.flat().flatMap((ring) => {
+        const paths = [[]];
+        for (const point of ring) {
+          if (edge(point)) {
+            if (paths.at(-1).length) paths.push([]);
+          } else paths.at(-1).push(this.toGrid(point));
+        }
+        return paths.filter((path) => path.length > 1);
+      })
+    }));
+  }
+}, _class2);
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ColorRamp = ColorRamp; exports.SurfaceGeometry = SurfaceGeometry; exports.FLOOR = FLOOR; exports.CEIL = CEIL; exports.SurfaceSpace = SurfaceSpace; exports.PolarSurfaceSpace = PolarSurfaceSpace; exports.TubeBatch = TubeBatch; exports.SurfaceOverlay = SurfaceOverlay; exports.SurfaceProjection = SurfaceProjection; exports.SurfaceBase = SurfaceBase; exports.SurfaceField = SurfaceField;