prographs 0.12.0 → 0.13.0

package/dist/{chunk-WJ3VH2Q4.cjs → chunk-GEAIGM3J.cjs}

@@ -1,15 +1,17 @@
-"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 _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10;
+"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 _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9;
 
 var _chunk4VWNDCUScjs = require('./chunk-4VWNDCUS.cjs');
 
 
-var _chunkXX2YTCORcjs = require('./chunk-XX2YTCOR.cjs');
 
 
-var _chunkPY4R3IFFcjs = require('./chunk-PY4R3IFF.cjs');
 
 
-var _chunkUMEKIIHJcjs = require('./chunk-UMEKIIHJ.cjs');
+
+var _chunkFDD4UP73cjs = require('./chunk-FDD4UP73.cjs');
+
+
+var _chunkPY4R3IFFcjs = require('./chunk-PY4R3IFF.cjs');
 
 // src/charts/machinecharts/AshbyChart.ts
 var _d3 = require('d3');
@@ -52,333 +54,6 @@ var AshbyMath = class {
   }
 };
 
-// src/charts/machinecharts/MachineChart.ts
-
-var CHAR = 6.2;
-var SIZE = 11;
-var MachineChart = class extends _chunkXX2YTCORcjs.CartesianChart {
-  /** A cell as a finite number, or null for blanks, text and dates. */
-  static number(cell) {
-    if (typeof cell === "string" && !cell.trim()) return null;
-    const value = typeof cell === "number" || typeof cell === "string" ? Number(cell) : NaN;
-    return Number.isFinite(value) ? value : null;
-  }
-  /** Short number for labels and tooltips. */
-  static short(value, digits = 3) {
-    return String(+value.toPrecision(digits));
-  }
-  /** Axis titles that depend on the options. A title the caller set wins. */
-  axisTitles() {
-    return {};
-  }
-  paint() {
-    const { xLabel, yLabel } = this.options, titles = this.axisTitles();
-    this.options.xLabel = _nullishCoalesce(xLabel, () => ( titles.x));
-    this.options.yLabel = _nullishCoalesce(yLabel, () => ( titles.y));
-    try {
-      super.paint();
-    } finally {
-      Object.assign(this.options, { xLabel, yLabel });
-    }
-  }
-  get rows() {
-    const { data } = this.options;
-    return Array.isArray(data) ? data.filter((row) => row !== null && typeof row === "object") : [];
-  }
-  /** Padded extent that survives no values and one value. `zero` keeps 0 in view. */
-  span(values, pad = 0.05, zero = false) {
-    let low = _nullishCoalesce(_d3.min.call(void 0, values), () => ( 0)), high = _nullishCoalesce(_d3.max.call(void 0, values), () => ( 1));
-    if (zero) {
-      low = Math.min(0, low);
-      high = Math.max(0, high);
-    }
-    if (low === high) {
-      const half = Math.abs(low) * 0.5 || 1;
-      return [zero && low >= 0 ? 0 : low - half, high + half];
-    }
-    const room = (high - low) * pad;
-    return [zero && low === 0 ? 0 : low - room, zero && high === 0 ? 0 : high + room];
-  }
-  /** A data point in plot pixels. */
-  place({ x, y }, [px, py]) {
-    return [_nullishCoalesce(x(px), () => ( NaN)), _nullishCoalesce(y(py), () => ( NaN))];
-  }
-  curves(ctx, axes, name, list) {
-    const path = _d3.line.call(void 0, ).defined((point) => Number.isFinite(point[0]) && Number.isFinite(point[1]));
-    const shape = (d) => _nullishCoalesce(path.curve(_nullishCoalesce(d.curve, () => ( _chunkPY4R3IFFcjs.Scales.curve())))(d.points.map((point) => this.place(axes, point))), () => ( ""));
-    const marks = ctx.marks(name, "path", list, (d) => d.key).attr("fill", "none").attr("stroke", (d) => d.color).attr("stroke-width", (d) => _nullishCoalesce(d.width, () => ( 2))).attr("stroke-linejoin", "round").attr("stroke-linecap", "round").attr("stroke-dasharray", (d) => _nullishCoalesce(d.dash, () => ( null)));
-    return ctx.set(marks, { d: shape });
-  }
-  /** Ringed dots with a tooltip each. */
-  dots(ctx, axes, name, items, at, fill, tip, radius = 4) {
-    const spot = (d) => this.place(axes, at(d));
-    const shown = items.filter((item) => spot(item).every(Number.isFinite));
-    const marks = ctx.marks(name, "circle", shown).attr("fill", fill).attr("stroke", ctx.theme.surface).attr("stroke-width", radius < 3 ? 1 : 2);
-    ctx.set(marks, { cx: (d) => spot(d)[0], cy: (d) => spot(d)[1], r: radius }, { r: 0 });
-    return ctx.hover(marks, tip);
-  }
-  /** Halo-backed labels kept inside the plot. A label that would overlap an earlier one, or cannot fit, is dropped. */
-  notes(ctx, name, notes) {
-    const { width, height } = ctx.plot;
-    const taken = [];
-    const kept = notes.flatMap((note) => {
-      const wide = note.text.length * CHAR;
-      if (!Number.isFinite(note.x) || !Number.isFinite(note.y) || wide > width || note.y < -SIZE || note.y > height + SIZE || note.x < -wide || note.x > width + wide) return [];
-      const anchor = _nullishCoalesce(note.anchor, () => ( "start")), offset = anchor === "start" ? 0 : anchor === "middle" ? wide / 2 : wide;
-      const x = Math.max(offset, Math.min(width - wide + offset, note.x)), y = Math.max(SIZE, Math.min(height - 3, note.y));
-      const box = [x - offset - 3, y - SIZE, x - offset + wide + 3, y + 3];
-      if (taken.some((other) => box[0] < other[2] && box[2] > other[0] && box[1] < other[3] && box[3] > other[1])) return [];
-      taken.push(box);
-      return [{ ...note, x, y, anchor }];
-    });
-    const tones = { ink: ctx.theme.ink, secondary: ctx.theme.inkSecondary, muted: ctx.theme.inkMuted };
-    ctx.marks(name, "text", kept, (d) => d.key).attr("x", (d) => d.x).attr("y", (d) => d.y).attr("text-anchor", (d) => d.anchor).attr("font-size", SIZE).attr("font-family", ctx.theme.fontFamily).attr("fill", (d) => d.over ? ctx.palette.inkOn(d.over) : tones[_nullishCoalesce(d.tone, () => ( "secondary"))]).attr("stroke", (d) => _nullishCoalesce(d.over, () => ( ctx.theme.surface))).attr("stroke-width", 3).attr("paint-order", "stroke").text((d) => d.text);
-  }
-};
-
-// src/charts/machinecharts/GasCycleMath.ts
-
-var CLOSE = 1e-3;
-var positive = (values) => values.every((value) => Number.isFinite(value) && value > 0);
-var GasCycleMath = class _GasCycleMath {
-  /** Isentropic compression by volume `ratio`, heat added at constant volume up to `peak` K, isentropic expansion, heat rejected at constant volume. */
-  static otto(gas, ratio, peak) {
-    const { gamma, inletPressure: p1, inletTemperature: t1 } = gas;
-    const t2 = t1 * ratio ** (gamma - 1), p2 = p1 * ratio ** gamma, p3 = p2 * peak / t2;
-    return _GasCycleMath.ideal(gas, [[p1, t1], [p2, t2], [p3, peak], [p3 / ratio ** gamma, peak / ratio ** (gamma - 1)]]);
-  }
-  /** Isentropic compression by volume `ratio`, heat added at constant pressure while the volume grows by `cutoff`, isentropic expansion, heat rejected at constant volume. */
-  static diesel(gas, ratio, cutoff) {
-    const { gamma, inletPressure: p1, inletTemperature: t1 } = gas;
-    const t2 = t1 * ratio ** (gamma - 1), p2 = p1 * ratio ** gamma, t3 = t2 * cutoff, expansion = ratio / cutoff;
-    return _GasCycleMath.ideal(gas, [[p1, t1], [p2, t2], [p2, t3], [p2 / expansion ** gamma, t3 / expansion ** (gamma - 1)]]);
-  }
-  /** Isentropic compression by pressure `ratio`, heat added at constant pressure up to `peak` K, isentropic expansion, heat rejected at constant pressure. */
-  static brayton(gas, ratio, peak) {
-    const { gamma, inletPressure: p1, inletTemperature: t1 } = gas, rise = ratio ** ((gamma - 1) / gamma);
-    return _GasCycleMath.ideal(gas, [[p1, t1], [p1 * ratio, t1 * rise], [p1 * ratio, peak], [p1, peak / rise]]);
-  }
-  /** States at `[pressure, temperature]` corners, numbered in order. None when a number is not above zero or `gamma` is not above 1. */
-  static ideal(gas, corners) {
-    if (!(gas.gamma > 1) || !positive([gas.gasConstant, ...corners.flat()])) return [];
-    return _GasCycleMath.entropies(corners.map(([pressure, temperature], i) => ({ label: `${i + 1}`, pressure, temperature, volume: gas.gasConstant * temperature / pressure })), gas);
-  }
-  /**
-   * States read from rows, in row order. Each needs a pressure and a temperature above zero; a volume the row
-   * leaves out comes from `Pv = RT`. A label that repeats, as when the first state closes the list, counts once.
-   */
-  static states(rows, columns, gas) {
-    const found = /* @__PURE__ */ new Map();
-    rows.forEach((row, i) => {
-      const [pressure, temperature, given] = [columns.pressure, columns.temperature, columns.volume].map((column) => _nullishCoalesce(MachineChart.number(row[column]), () => ( NaN)));
-      const label = String(_nullishCoalesce(row[columns.label], () => ( i + 1))), volume = given > 0 ? given : gas.gasConstant * temperature / pressure;
-      if (positive([pressure, temperature, volume]) && !found.has(label)) found.set(label, { label, pressure, temperature, volume });
-    });
-    return _GasCycleMath.entropies([...found.values()], gas);
-  }
-  /** `s = cv ln(T / T₁) + R ln(v / v₁)`, so the first state sits at zero. A gas whose `gamma` is not above 1 has no states. */
-  static entropies(states, { gamma, gasConstant }) {
-    const cv = gasConstant / (gamma - 1), [first] = states;
-    return states.map((state) => ({ ...state, entropy: cv * Math.log(state.temperature / first.temperature) + gasConstant * Math.log(state.volume / first.volume) })).filter((state) => Number.isFinite(state.entropy));
-  }
-  /**
-   * The legs of the closed cycle, the last one returning to the first state. Along a polytrope `ln P` is linear in `ln v`
-   * and `s` in `ln T`, which gives the work `∫P dv` and the heat `∫T ds` in closed form.
-   */
-  static processes(states) {
-    if (states.length < 2) return [];
-    return states.map((from, i) => {
-      const to = states[(i + 1) % states.length];
-      const dv = Math.log(to.volume / from.volume), dp = Math.log(to.pressure / from.pressure), dt = Math.log(to.temperature / from.temperature);
-      const heat = (to.entropy - from.entropy) * (Math.abs(dt) < 1e-9 ? from.temperature : (to.temperature - from.temperature) / dt);
-      const work = Math.abs(dv + dp) < 1e-9 ? from.pressure * from.volume * dv : dv * (to.pressure * to.volume - from.pressure * from.volume) / (dv + dp);
-      const name = Math.abs(dv) < CLOSE ? "Constant volume" : Math.abs(dp) < CLOSE ? "Constant pressure" : Math.abs(dt) < CLOSE ? "Isothermal" : Math.abs(heat) < CLOSE * Math.abs(work) ? "Isentropic" : `Polytropic, n = ${(-dp / dv).toFixed(2)}`;
-      return { from, to, name, heat, work };
-    });
-  }
-  /** Heat in is the heat of every leg that takes some in, heat out of every leg that gives some up, and the efficiency is `1 - out / in`. */
-  static totals(processes) {
-    const heatIn = _d3.sum.call(void 0, processes, (leg) => Math.max(0, leg.heat)), heatOut = _d3.sum.call(void 0, processes, (leg) => Math.max(0, -leg.heat));
-    return { heatIn, heatOut, work: _d3.sum.call(void 0, processes, (leg) => leg.work), efficiency: heatIn > heatOut ? 1 - heatOut / heatIn : null };
-  }
-  /** Points along a leg between two plotted corners. `y` always changes geometrically; `x` does too on P-V (`geometric`), and linearly on T-s. */
-  static leg(from, to, geometric, steps = 24) {
-    return Array.from({ length: steps + 1 }, (_, i) => {
-      const t = i / steps;
-      return [geometric ? from[0] * (to[0] / from[0]) ** t : from[0] + (to[0] - from[0]) * t, from[1] * (to[1] / from[1]) ** t];
-    });
-  }
-};
-
-// src/charts/machinecharts/MachineSamples.ts
-var round = (value, digits = 2) => +value.toFixed(digits);
-var MATERIALS = [
-  ["Foams", "Polymer foam, low density", 0.035, 2e-3],
-  ["Foams", "Polymer foam, rigid", 0.12, 0.08],
-  ["Foams", "Metal foam", 0.35, 0.6],
-  ["Foams", "Ceramic foam", 0.5, 1.6],
-  ["Elastomers", "Natural rubber", 0.93, 2e-3],
-  ["Elastomers", "Butyl rubber", 0.92, 15e-4],
-  ["Elastomers", "Silicone elastomer", 1.25, 0.012],
-  ["Elastomers", "Polyurethane elastomer", 1.15, 0.03],
-  ["Natural materials", "Cork", 0.18, 0.03],
-  ["Natural materials", "Balsa", 0.16, 3.2],
-  ["Natural materials", "Pine", 0.5, 9.5],
-  ["Natural materials", "Oak", 0.75, 12],
-  ["Natural materials", "Bamboo", 0.7, 17],
-  ["Polymers", "Polyethylene", 0.95, 0.75],
-  ["Polymers", "Polypropylene", 0.9, 1.4],
-  ["Polymers", "Polyamide", 1.14, 2.8],
-  ["Polymers", "Polycarbonate", 1.2, 2.3],
-  ["Polymers", "Epoxy", 1.25, 3.2],
-  ["Composites", "Glass fibre laminate", 1.9, 22],
-  ["Composites", "Carbon fibre laminate", 1.55, 110],
-  ["Composites", "Aramid laminate", 1.38, 60],
-  ["Composites", "Metal matrix composite", 2.8, 95],
-  ["Metals", "Magnesium alloys", 1.8, 44],
-  ["Metals", "Aluminium alloys", 2.7, 71],
-  ["Metals", "Titanium alloys", 4.5, 112],
-  ["Metals", "Steels", 7.85, 205],
-  ["Metals", "Nickel alloys", 8.6, 200],
-  ["Metals", "Copper alloys", 8.7, 125],
-  ["Metals", "Lead alloys", 11.2, 15],
-  ["Metals", "Tungsten alloys", 18.5, 360],
-  ["Ceramics", "Concrete", 2.4, 28],
-  ["Ceramics", "Soda-lime glass", 2.5, 70],
-  ["Ceramics", "Alumina", 3.9, 370],
-  ["Ceramics", "Silicon carbide", 3.15, 420],
-  ["Ceramics", "Tungsten carbide", 15.6, 640]
-];
-var POLARS = [
-  ["Clean", 0.22, 0.021, 0.043, 1.6],
-  ["Take-off flaps", 0.62, 0.044, 0.049, 2.05],
-  ["Landing flaps", 1.02, 0.086, 0.056, 2.5]
-];
-var HILLS = [[18, 190, 5], [36, 640, 7.5], [58, 260, 4], [74, 1020, 9], [97, 520, 5.5], [110, 150, 3]];
-var MachineSamples = class {
-  /** `{ speed, mode, frequency }`: rotor natural frequencies in Hz by speed in rpm, with whirl pairs that split and a mode that stiffens. */
-  static campbell(seed) {
-    const { u } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const first = 48 + u() * 14, second = 128 + u() * 20, torsion = 196 + u() * 24;
-    const modes = [
-      ["1st bending, backward", (rev) => first - 0.085 * rev],
-      ["1st bending, forward", (rev) => first + 0.1 * rev],
-      ["2nd bending, backward", (rev) => second - 0.16 * rev],
-      ["2nd bending, forward", (rev) => second + 0.19 * rev],
-      ["1st torsion", (rev) => Math.hypot(torsion, 0.42 * rev)]
-    ];
-    return modes.flatMap(([mode, at]) => Array.from({ length: 13 }, (_, i) => ({ speed: i * 1e3, mode, frequency: round(at(i * 1e3 / 60), 1) })));
-  }
-  /** `{ speed, flow, pressureRatio, efficiency }`: points along each corrected speed line, named as a share of design speed, surge end first. Flow in kg/s, efficiency as a share. */
-  static compressor(seed) {
-    const { u, n } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const design = 3.6 + u() * 0.8, flow = 9 + u() * 3;
-    return [60, 70, 80, 90, 100, 105].flatMap((speed) => {
-      const share = speed / 100, choke = flow * share ** 1.45 * 1.06, surge = choke * (0.66 + 0.16 * share);
-      const top = 1 + (design - 1) * share ** 2.3 * 1.07, peak = 0.86 - (share < 0.92 ? 0.9 : 6) * (share - 0.92) ** 2;
-      return Array.from({ length: 9 }, (_, i) => {
-        const t = i / 8;
-        return {
-          speed: `${speed}%`,
-          flow: round(surge + (choke - surge) * (1 - (1 - t) ** 2.2), 3),
-          pressureRatio: round(top - (top - 1) * (0.06 * t + 0.4 * t ** 3.5), 3),
-          efficiency: round(peak - 0.3 * (t - 0.36) ** 2 * (t > 0.36 ? 1.7 : 1) + n() * 2e-3, 4)
-        };
-      });
-    });
-  }
-  /** `{ speed, torque, bsfc }`: load sweeps at each engine speed up to full load. Speed in rpm, torque in N·m, BSFC in g/kWh. */
-  static bsfcMap(seed) {
-    const { u, n } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const peak = 255 + u() * 50, best = 2200 + u() * 600, floor = 228 + u() * 14;
-    return Array.from({ length: 11 }, (_, i) => 1e3 + i * 500).flatMap((speed) => {
-      const rev = speed / 1e3;
-      const full = peak * Math.min(1, 0.62 + 0.3 * rev - 0.02 * rev ** 2, 1.62 - 0.14 * rev);
-      return Array.from({ length: 10 }, (_, j) => {
-        const load = (j + 1) / 10;
-        const bsfc = floor + 9 * ((speed - best) / 1e3) ** 2 + 95 * (load - 0.78) ** 2 + 26 * (0.2 / load) ** 1.6 * (1 + rev / 6) + n() * 0.8;
-        return { speed, torque: round(full * load, 1), bsfc: round(bsfc, 1) };
-      });
-    });
-  }
-  /** `{ time, lateral, longitudinal }`: one lap of accelerations in g, braking negative, sampled through each corner. */
-  static lap(seed) {
-    const { u, n } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const grip = 1.25 + u() * 0.25, rows = [];
-    let time = 0, [x, y] = [0, 0.35];
-    const glide = (toX, toY, steps) => {
-      const [fromX, fromY] = [x, y];
-      for (let i = 1; i <= steps; i++) {
-        const t = i / steps, ease = t * t * (3 - 2 * t);
-        x = fromX + (toX - fromX) * ease + n() * 0.03;
-        y = fromY + (toY - fromY) * ease + n() * 0.03;
-        rows.push({ time: round(time += 0.1, 1), lateral: round(x, 3), longitudinal: round(y, 3) });
-      }
-    };
-    for (let corner = 0; corner < 14; corner++) {
-      const side = u() < 0.5 ? -1 : 1, hard = 0.55 + u() * 0.45;
-      glide(0, 0.5 - u() * 0.25, 10);
-      glide(side * 0.08, -grip * 0.9 * hard, 5);
-      glide(side * grip * 0.72 * hard, -grip * 0.55 * hard, 6);
-      glide(side * grip * hard, n() * 0.05, 9);
-      glide(side * grip * 0.6 * hard, 0.42, 7);
-    }
-    return rows;
-  }
-  /** `{ configuration, alpha, cl, cd }`: lift and drag coefficients by angle of attack in degrees, for three flap settings. */
-  static dragPolar(seed) {
-    const { u, n } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const tilt = 0.96 + u() * 0.08;
-    return POLARS.flatMap(([configuration, cl0, cd0, k, clMax]) => Array.from({ length: 9 }, (_, i) => {
-      const alpha = -4 + i * 2, straight = cl0 + 0.098 * alpha * tilt;
-      const cl = clMax - Math.log(1 + Math.exp((clMax - straight) * 14)) / 14;
-      return { configuration, alpha, cl: round(cl, 3), cd: round(cd0 + k * (straight - 0.12) ** 2 + 0.25 * (straight - cl) + Math.abs(n()) * 6e-4, 4) };
-    }));
-  }
-  /** `{ family, material, density, modulus }`: density in Mg/m³ and Young's modulus in GPa, close to handbook orders of magnitude. */
-  static materials(seed) {
-    const { n } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    return MATERIALS.map(([family, material, density, modulus]) => ({ family, material, density: +(density * Math.exp(n() * 0.07)).toPrecision(3), modulus: +(modulus * Math.exp(n() * 0.12)).toPrecision(3) }));
-  }
-  /** `{ wingLoading, thrustRatio, weight, cruiseSpeed }`: a sizing study over wing loading (kg/m²) and thrust-to-weight, with take-off weight in t and cruise speed in km/h. */
-  static sizing(seed) {
-    const { u } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const base = 58 + u() * 14, bend = 0.8 + u() * 0.5;
-    return [350, 425, 500, 575, 650].flatMap((wingLoading) => [0.24, 0.28, 0.32, 0.36].map((thrustRatio) => {
-      const wing = (650 - wingLoading) / 300, engine = (thrustRatio - 0.24) / 0.12;
-      return {
-        wingLoading,
-        thrustRatio,
-        weight: round(base + 7.5 * wing ** 1.6 * bend + 5.2 * engine ** 1.3 + 2.4 * wing * engine, 2),
-        cruiseSpeed: Math.round(705 + 0.26 * (wingLoading - 350) + 520 * (thrustRatio - 0.24) + 14 * wing * engine)
-      };
-    }));
-  }
-  /** `{ distance, elevation }`: a mountain stage sampled every 250 m, distance in km and elevation in m. */
-  static route(seed) {
-    const { u, n } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const hills = HILLS.map(([centre, rise, width]) => [centre + (u() - 0.5) * 5, rise * (0.8 + u() * 0.4), width * (0.85 + u() * 0.3)]);
-    let drift = 0;
-    return Array.from({ length: 481 }, (_, i) => {
-      const distance = i * 0.25;
-      drift = drift * 0.96 + n() * 1.6;
-      const ground = 310 + 0.9 * distance + hills.reduce((sum2, [centre, rise, width]) => sum2 + rise * Math.exp(-(((distance - centre) / width) ** 2)), 0);
-      return { distance, elevation: Math.round(ground + drift) };
-    });
-  }
-  /** `{ cycle, state, pressure, volume, temperature }`: the four states of an air-standard Otto, Diesel and Brayton cycle, in kPa, m³/kg and K. */
-  static gasCycles(seed) {
-    const { u } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const gas = { gamma: 1.4, gasConstant: 0.287, inletPressure: 95 + u() * 10, inletTemperature: 288 + u() * 22 };
-    const cycles = [
-      ["Otto", GasCycleMath.otto(gas, 8 + u() * 3, 1900 + u() * 500)],
-      ["Diesel", GasCycleMath.diesel(gas, 16 + u() * 5, 1.8 + u() * 0.8)],
-      ["Brayton", GasCycleMath.brayton(gas, 8 + u() * 8, 1250 + u() * 350)]
-    ];
-    return cycles.flatMap(([cycle, states]) => states.map((state) => ({ cycle, state: state.label, pressure: +state.pressure.toPrecision(5), volume: +state.volume.toPrecision(5), temperature: +state.temperature.toPrecision(5) })));
-  }
-};
-
 // src/charts/machinecharts/AshbyChart.ts
 var AshbyEnvelope = /* @__PURE__ */ ((AshbyEnvelope2) => {
   AshbyEnvelope2["Ellipse"] = "ellipses";
@@ -396,7 +71,7 @@ var AshbyGuide = /* @__PURE__ */ ((AshbyGuide2) => {
 var SLOPE = { ["tie-guides" /* Tie */]: 1, ["beam-guides" /* Beam */]: 2, ["plate-guides" /* Plate */]: 3, ["no-guides" /* None */]: 0 };
 var ROOT = ["", "", "^\xBD", "^\u2153"];
 var plain = (value) => value.toLocaleString("en", { maximumSignificantDigits: 3 });
-var AshbyChart = (_class = class extends MachineChart {
+var AshbyChart = (_class = class extends _chunkFDD4UP73cjs.MachineChart {
   static __initStatic() {this.meta = {
     id: "ashby-chart",
     name: "Ashby chart",
@@ -405,7 +80,7 @@ var AshbyChart = (_class = class extends MachineChart {
     shape: "table" /* Table */,
     description: "Maps material families as labelled envelopes on log-log axes of two properties, with guide lines of constant performance index.",
     tags: ["materials selection", "material property chart", "modulus", "density", "performance index", "bubble chart"],
-    sample: (seed) => MachineSamples.materials(seed),
+    sample: (seed) => _chunkFDD4UP73cjs.MachineSamples.materials(seed),
     variants: { envelope: Object.values(AshbyEnvelope), guide: Object.values(AshbyGuide), markers: [true, false] },
     valid: (values) => values.markers === true || values.envelope !== "no-envelopes" /* None */
   }}
@@ -433,13 +108,13 @@ var AshbyChart = (_class = class extends MachineChart {
   }
   /** Log axes label their decades only. */
   tickFormat(scale) {
-    const log = scale === _optionalChain([this, 'access', _3 => _3.#axes, 'optionalAccess', _4 => _4.x]) ? this.options.xScaleType === "log" /* Log */ : this.options.yScaleType === "log" /* Log */;
+    const log = scale === _optionalChain([this, 'access', _2 => _2.#axes, 'optionalAccess', _3 => _3.x]) ? this.options.xScaleType === "log" /* Log */ : this.options.yScaleType === "log" /* Log */;
     return log ? (value) => Math.abs(Math.log10(+value) % 1) < 1e-9 ? plain(+value) : "" : (value) => plain(+value);
   }
   get materials() {
     const { x, y, series, label, xScaleType, yScaleType } = this.options;
     return this.rows.flatMap((row) => {
-      const px = MachineChart.number(row[x]), py = MachineChart.number(row[y]);
+      const px = _chunkFDD4UP73cjs.MachineChart.number(row[x]), py = _chunkFDD4UP73cjs.MachineChart.number(row[y]);
       if (px === null || py === null || xScaleType === "log" /* Log */ && px <= 0 || yScaleType === "log" /* Log */ && py <= 0) return [];
       return [{ family: String(_nullishCoalesce(row[series], () => ( "Materials"))), name: String(_nullishCoalesce(row[label], () => ( ""))), point: [px, py], row }];
     });
@@ -459,9 +134,9 @@ var AshbyChart = (_class = class extends MachineChart {
     const { theme, palette } = ctx, { materials } = this;
     const slope = SLOPE[guide];
     const window = [axes.x.domain(), axes.y.domain()];
-    const positive2 = window.flat().every((value) => value > 0);
+    const positive = window.flat().every((value) => value > 0);
     const index = ([px, py]) => py ** (1 / slope) / px;
-    const corners = positive2 && slope ? [index([window[0][1], window[1][0]]), index([window[0][0], window[1][1]])].map(Math.log10) : [];
+    const corners = positive && slope ? [index([window[0][1], window[1][0]]), index([window[0][0], window[1][1]])].map(Math.log10) : [];
     const guides = (corners.length ? _d3.ticks.call(void 0, corners[0], corners[1], 5) : []).map((power) => ({ m: 10 ** power, points: AshbyMath.guide(10 ** power, slope, ...window) })).filter((d) => d.points.length);
     this.curves(ctx, axes, "axis-guides", guides.map(({ m, points }) => ({ key: `${m}`, points, color: theme.axis, width: 1, dash: "5 4" })));
     const families = [..._d3.group.call(void 0, materials, (d) => d.family)].map(([family, own]) => {
@@ -491,7 +166,7 @@ var AshbyChart = (_class = class extends MachineChart {
     const names = families.flatMap((d) => {
       if (!d.spots.length) return [];
       const top = envelope === "ellipses" /* Ellipse */ && d.ellipse ? d.ellipse.cy - Math.max(d.ellipse.ry, 14) * 0.6 : Math.min(...d.spots.map((spot) => spot[1])) - 10;
-      return [{ key: d.family, text: d.family, x: d.spots.reduce((sum2, spot) => sum2 + spot[0], 0) / d.spots.length, y: top, anchor: "middle", tone: "ink" }];
+      return [{ key: d.family, text: d.family, x: d.spots.reduce((sum, spot) => sum + spot[0], 0) / d.spots.length, y: top, anchor: "middle", tone: "ink" }];
     });
     const marks = guides.map(({ m, points }, i) => {
       const [px, py] = this.place(axes, points[points.length - 1]);
@@ -504,109 +179,6 @@ var AshbyChart = (_class = class extends MachineChart {
 
 // src/charts/machinecharts/BsfcMap.ts
 
-
-// src/charts/machinecharts/BsfcMath.ts
-
-var BsfcMath = (_class2 = class _BsfcMath {
-  /** rpm × N·m per kW. */
-  static __initStatic2() {this.PER_KW = 6e4 / (2 * Math.PI)}
-  static power(speed, torque) {
-    return speed * torque / _BsfcMath.PER_KW;
-  }
-  static torque(speed, power) {
-    return power * _BsfcMath.PER_KW / speed;
-  }
-  /** Brake mean effective pressure of a four-stroke engine of `litres` swept volume. */
-  static bmep(torque, litres) {
-    return 4 * Math.PI * torque / (litres * 100);
-  }
-  /** Load sweeps, one per engine speed in rising order, each from its lowest torque to full load. Repeated points are averaged. */
-  static sweeps(rows, speed, torque, bsfc) {
-    const nodes = rows.flatMap((row) => {
-      const x = MachineChart.number(row[speed]), y = MachineChart.number(row[torque]), z = MachineChart.number(row[bsfc]);
-      return x === null || y === null || z === null ? [] : [{ x, y, z }];
-    });
-    return [..._d3.group.call(void 0, nodes, (node) => node.x)].sort(([a], [b]) => a - b).map(([x, own]) => [..._d3.group.call(void 0, own, (node) => node.y)].map(([y, same]) => ({ x, y, z: _d3.mean.call(void 0, same, (node) => node.z) })).sort((a, b) => a.y - b.y));
-  }
-  /**
-   * The `[speed, torque]` of least BSFC at each power: where a constant-power line touches its lowest contour. The minimum
-   * is shallow, so noise in the map moves it; each speed is averaged with its neighbours in power, weighted 1-2-1.
-   */
-  static economy(mesh, powers) {
-    const found = powers.flatMap((power) => {
-      let best = null;
-      for (const sweep of mesh.nodes) {
-        const speed = sweep[0].x, torque = _BsfcMath.torque(speed, power);
-        const i = sweep.findIndex((node, at) => at > 0 && node.y >= torque && sweep[at - 1].y <= torque);
-        if (i < 1) continue;
-        const below = sweep[i - 1], above = sweep[i], t = (torque - below.y) / (above.y - below.y || 1);
-        const bsfc = below.z + (above.z - below.z) * t;
-        if (!best || bsfc < best.bsfc) best = { power, speed, bsfc };
-      }
-      return best ? [best] : [];
-    });
-    return found.map(({ power, speed }, i) => {
-      const smooth = ((_nullishCoalesce(_optionalChain([found, 'access', _5 => _5[i - 1], 'optionalAccess', _6 => _6.speed]), () => ( speed))) + 2 * speed + (_nullishCoalesce(_optionalChain([found, 'access', _7 => _7[i + 1], 'optionalAccess', _8 => _8.speed]), () => ( speed)))) / 4;
-      return [smooth, _BsfcMath.torque(smooth, power)];
-    });
-  }
-}, _class2.__initStatic2(), _class2);
-
-// src/charts/machinecharts/MachineMesh.ts
-
-var lerp = (a, b, t) => ({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t, z: a.z + (b.z - a.z) * t });
-var spline = (a, b, c, d, t) => 0.5 * (2 * b + (c - a) * t + (2 * a - 5 * b + 4 * c - d) * t * t + (3 * b - a - 3 * c + d) * t ** 3);
-var MachineMesh = class {
-  /** `nodes[row][column]`: rows run across the lines, columns along them. */
-  
-  /** `lines` in map order, each from one edge of the map to the other. Lines with fewer than two points are left out. */
-  constructor(lines, along = 24, between = 5) {
-    const usable = lines.filter((line4) => line4.length > 1), all = usable.flat();
-    const [x0 = 0, x1 = 1] = _d3.extent.call(void 0, all, (node) => node.x), [y0 = 0, y1 = 1] = _d3.extent.call(void 0, all, (node) => node.y);
-    const sx = x1 - x0 || 1, sy = y1 - y0 || 1;
-    const even = usable.map((line4) => {
-      const reach = [0];
-      for (let i = 1; i < line4.length; i++) reach.push(reach[i - 1] + Math.hypot((line4[i].x - line4[i - 1].x) / sx, (line4[i].y - line4[i - 1].y) / sy));
-      const total = reach[reach.length - 1] || 1;
-      let at = 0;
-      return Array.from({ length: along }, (_, step) => {
-        const want = step / (along - 1) * total;
-        while (at < line4.length - 2 && reach[at + 1] < want) at++;
-        return lerp(line4[at], line4[at + 1], Math.max(0, Math.min(1, (want - reach[at]) / (reach[at + 1] - reach[at] || 1))));
-      });
-    });
-    const last = even.length - 1;
-    this.nodes = last < 1 ? [] : Array.from({ length: last * between + 1 }, (_, row) => {
-      const line4 = Math.min(last - 1, Math.floor(row / between)), t = row / between - line4;
-      const [a, b, c, d] = [-1, 0, 1, 2].map((shift) => even[Math.max(0, Math.min(last, line4 + shift))]);
-      return b.map((_2, i) => ({ x: spline(a[i].x, b[i].x, c[i].x, d[i].x, t), y: spline(a[i].y, b[i].y, c[i].y, d[i].y, t), z: spline(a[i].z, b[i].z, c[i].z, d[i].z, t) }));
-    });
-  }
-  get rows() {
-    return this.nodes.length;
-  }
-  get columns() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _9 => _9.nodes, 'access', _10 => _10[0], 'optionalAccess', _11 => _11.length]), () => ( 0));
-  }
-  /** The contoured quantity, row by row, as d3's contour generator takes it. */
-  get values() {
-    return this.nodes.flatMap((row) => row.map((node) => node.z));
-  }
-  /** Where fractional mesh coordinates sit on the map. */
-  at(column, row) {
-    const i = Math.max(0, Math.min(this.columns - 2, Math.floor(column))), j = Math.max(0, Math.min(this.rows - 2, Math.floor(row)));
-    const top = lerp(this.nodes[j][i], this.nodes[j][i + 1], column - i), bottom = lerp(this.nodes[j + 1][i], this.nodes[j + 1][i + 1], column - i);
-    const { x, y } = lerp(top, bottom, row - j);
-    return [x, y];
-  }
-  /** Round contour levels strictly inside the range of the mesh. */
-  levels(count = 6) {
-    const [low, high] = _d3.extent.call(void 0, this.values);
-    return low === void 0 || high === void 0 ? [] : _d3.ticks.call(void 0, low, high, count).filter((level) => level > low && level < high);
-  }
-};
-
-// src/charts/machinecharts/BsfcMap.ts
 var BsfcLoad = /* @__PURE__ */ ((BsfcLoad2) => {
   BsfcLoad2["Torque"] = "torque";
   BsfcLoad2["Bmep"] = "bmep";
@@ -625,8 +197,8 @@ var BsfcOptimum = /* @__PURE__ */ ((BsfcOptimum2) => {
 })(BsfcOptimum || {});
 var BSFC = "BSFC";
 var ECONOMY = "Best economy line";
-var BsfcMap = (_class3 = class extends MachineChart {
-  static __initStatic3() {this.meta = {
+var BsfcMap = (_class2 = class extends _chunkFDD4UP73cjs.MachineChart {
+  static __initStatic2() {this.meta = {
     id: "bsfc-map",
     name: "Engine BSFC map",
     family: "scientific" /* Scientific */,
@@ -634,7 +206,7 @@ var BsfcMap = (_class3 = class extends MachineChart {
     shape: "table" /* Table */,
     description: "Draws brake specific fuel consumption as contours over engine speed and torque or BMEP, with the full-load curve and constant-power lines.",
     tags: ["engine map", "fuel consumption", "fuel island", "bmep", "torque curve", "automotive", "powertrain"],
-    sample: (seed) => MachineSamples.bsfcMap(seed),
+    sample: (seed) => _chunkFDD4UP73cjs.MachineSamples.bsfcMap(seed),
     variants: { contours: Object.values(BsfcContours), load: Object.values(BsfcLoad), power: [true, false], optimum: Object.values(BsfcOptimum) }
   }}
   defaults() {
@@ -644,11 +216,11 @@ var BsfcMap = (_class3 = class extends MachineChart {
     return { y: this.options.load === "bmep" /* Bmep */ ? "BMEP (bar)" : "Torque (N\xB7m)" };
   }
   get sweeps() {
-    return BsfcMath.sweeps(this.rows, this.options.x, this.options.y, this.options.bsfc);
+    return _chunkFDD4UP73cjs.BsfcMath.sweeps(this.rows, this.options.x, this.options.y, this.options.bsfc);
   }
   /** Torque as the load axis plots it. */
   load(torque) {
-    return this.options.load === "bmep" /* Bmep */ ? BsfcMath.bmep(torque, this.options.displacement || 1) : torque;
+    return this.options.load === "bmep" /* Bmep */ ? _chunkFDD4UP73cjs.BsfcMath.bmep(torque, this.options.displacement || 1) : torque;
   }
   scales(ctx) {
     const nodes = this.sweeps.flat(), [low, high] = this.span(nodes.map((node) => node.x), 0);
@@ -661,7 +233,7 @@ var BsfcMap = (_class3 = class extends MachineChart {
     const { contours, power, optimum } = this.options;
     const { sweeps } = this, { theme, palette } = ctx;
     const spot = (node) => [node.x, this.load(node.y)];
-    const mesh = new MachineMesh(sweeps, 24, 4), filled = contours === "contour-fills" /* Filled */;
+    const mesh = new (0, _chunkFDD4UP73cjs.MachineMesh)(sweeps, 24, 4), filled = contours === "contour-fills" /* Filled */;
     const tone = palette.color(BSFC);
     const field = new (0, _chunk4VWNDCUScjs.FieldContours)(mesh.values.map((value) => -value), mesh.columns, mesh.rows, (i, j) => {
       const [x, y] = mesh.at(i, j);
@@ -669,12 +241,12 @@ var BsfcMap = (_class3 = class extends MachineChart {
     });
     const levels = mesh.levels(10).reverse();
     const regions = levels.map((level, i) => {
-      const { area: area3, line: line4, polylines } = field.at(-level);
+      const { area: area3, line: line3, polylines } = field.at(-level);
       const longest = polylines.reduce((best2, run) => run.length > best2.length ? run : best2, []);
       const share = levels.length > 1 ? i / (levels.length - 1) : 1;
-      return { level, share, fill: palette.sequential(0.08 + 0.8 * share), area: area3, line: line4, mid: _nullishCoalesce(longest[Math.floor(longest.length / 2)], () => ( null)) };
+      return { level, share, fill: palette.sequential(0.08 + 0.8 * share), area: area3, line: line3, mid: _nullishCoalesce(longest[Math.floor(longest.length / 2)], () => ( null)) };
     });
-    const told = (d) => ({ title: `${MachineChart.short(d.level)} g/kWh`, color: tone, rows: [[BSFC, filled ? "at or below" : "contour"]] });
+    const told = (d) => ({ title: `${_chunkFDD4UP73cjs.MachineChart.short(d.level)} g/kWh`, color: tone, rows: [[BSFC, filled ? "at or below" : "contour"]] });
     const fills = ctx.marks("regions", "path", filled ? regions : [], (d) => d.level).attr("fill", (d) => d.fill).attr("stroke", "none");
     ctx.set(fills, { d: (d) => d.area });
     ctx.hover(fills, told);
@@ -688,40 +260,40 @@ var BsfcMap = (_class3 = class extends MachineChart {
       const a = full[i - 1], b = full[i];
       return a.y + (b.y - a.y) * (speed - a.x) / (b.x - a.x || 1);
     };
-    const peak = _nullishCoalesce(_d3.max.call(void 0, full, (node) => BsfcMath.power(node.x, node.y)), () => ( 0));
-    const [first, last] = [_nullishCoalesce(_optionalChain([full, 'access', _12 => _12[0], 'optionalAccess', _13 => _13.x]), () => ( 0)), _nullishCoalesce(_optionalChain([full, 'access', _14 => _14[full.length - 1], 'optionalAccess', _15 => _15.x]), () => ( 0))];
+    const peak = _nullishCoalesce(_d3.max.call(void 0, full, (node) => _chunkFDD4UP73cjs.BsfcMath.power(node.x, node.y)), () => ( 0));
+    const [first, last] = [_nullishCoalesce(_optionalChain([full, 'access', _4 => _4[0], 'optionalAccess', _5 => _5.x]), () => ( 0)), _nullishCoalesce(_optionalChain([full, 'access', _6 => _6[full.length - 1], 'optionalAccess', _7 => _7.x]), () => ( 0))];
     const steps = _d3.range.call(void 0, 0, 81).map((i) => first + (last - first) * i / 80);
     const hyperbolas = (power && peak > 0 ? _d3.ticks.call(void 0, 0, peak, 6).filter((kw) => kw > 0) : []).map((kw) => ({
       kw,
       points: steps.map((speed) => {
-        const torque = BsfcMath.torque(speed, kw);
+        const torque = _chunkFDD4UP73cjs.BsfcMath.torque(speed, kw);
         return torque <= limit(speed) ? spot({ x: speed, y: torque }) : [NaN, NaN];
       })
-    })).filter((line4) => line4.points.filter((point) => Number.isFinite(point[1])).length > 1);
+    })).filter((line3) => line3.points.filter((point) => Number.isFinite(point[1])).length > 1);
     this.curves(ctx, axes, "axis-power", hyperbolas.map(({ kw, points }) => ({ key: `${kw}`, points, color: theme.axis, width: 1, dash: "5 4" })));
     this.curves(ctx, axes, "full-load", full.length > 1 ? [{ key: "full", points: full.map(spot), color: theme.ink, width: 2.5 }] : []);
-    const economy = optimum === "economy-line" /* Line */ && mesh.rows ? BsfcMath.economy(mesh, _d3.range.call(void 0, 1, 25).map((i) => peak * i / 25)) : [];
+    const economy = optimum === "economy-line" /* Line */ && mesh.rows ? _chunkFDD4UP73cjs.BsfcMath.economy(mesh, _d3.range.call(void 0, 1, 25).map((i) => peak * i / 25)) : [];
     this.curves(ctx, axes, "economy", economy.length > 1 ? [{ key: "economy", points: economy.map(([x, y]) => spot({ x, y })), color: palette.color(ECONOMY), curve: _d3.curveBasis }] : []);
     const best = optimum === "best-point" /* Point */ ? sweeps.flat().reduce((low, node) => !low || node.z < low.z ? node : low, null) : null;
     this.dots(ctx, axes, "best", best ? [best] : [], spot, () => theme.ink, (d) => ({
       title: "Lowest BSFC",
-      rows: [["BSFC", `${MachineChart.short(d.z, 4)} g/kWh`], ["Speed", `${Math.round(d.x).toLocaleString("en")} rpm`], ["Torque", `${MachineChart.short(d.y)} N\xB7m`], ["Power", `${MachineChart.short(BsfcMath.power(d.x, d.y))} kW`]]
+      rows: [["BSFC", `${_chunkFDD4UP73cjs.MachineChart.short(d.z, 4)} g/kWh`], ["Speed", `${Math.round(d.x).toLocaleString("en")} rpm`], ["Torque", `${_chunkFDD4UP73cjs.MachineChart.short(d.y)} N\xB7m`], ["Power", `${_chunkFDD4UP73cjs.MachineChart.short(_chunkFDD4UP73cjs.BsfcMath.power(d.x, d.y))} kW`]]
     }), 5);
     const at = (point) => point ? this.place(axes, point) : [NaN, NaN];
     const top = full.reduce((high, node) => !high || node.y > high.y ? node : high, void 0);
     const [tx, ty] = at(top && spot(top)), [bx, by] = at(best ? spot(best) : void 0);
     const notes = [
-      { key: "best", text: best ? `${MachineChart.short(best.z, 4)} g/kWh` : "", x: bx + 9, y: by + 4, tone: "ink", over: filled ? _optionalChain([regions, 'access', _16 => _16[regions.length - 1], 'optionalAccess', _17 => _17.fill]) : void 0 },
+      { key: "best", text: best ? `${_chunkFDD4UP73cjs.MachineChart.short(best.z, 4)} g/kWh` : "", x: bx + 9, y: by + 4, tone: "ink", over: filled ? _optionalChain([regions, 'access', _8 => _8[regions.length - 1], 'optionalAccess', _9 => _9.fill]) : void 0 },
       { key: "full", text: "Full load", x: tx, y: ty - 8, anchor: "middle", tone: "ink" },
       ...hyperbolas.map(({ kw, points }) => {
         const [x, y] = at(points.findLast((point) => Number.isFinite(point[1])));
         return { key: `kw${kw}`, text: `${kw} kW`, x: x + 5, y: y + 4, tone: "muted" };
       }),
-      ...regions.flatMap((region) => region.mid ? [{ key: `level${region.level}`, text: MachineChart.short(region.level), x: region.mid[0], y: region.mid[1] + 4, anchor: "middle", over: filled ? region.fill : void 0 }] : [])
+      ...regions.flatMap((region) => region.mid ? [{ key: `level${region.level}`, text: _chunkFDD4UP73cjs.MachineChart.short(region.level), x: region.mid[0], y: region.mid[1] + 4, anchor: "middle", over: filled ? region.fill : void 0 }] : [])
     ];
     this.notes(ctx, "labels", notes.filter((note) => note.text));
   }
-}, _class3.__initStatic3(), _class3);
+}, _class2.__initStatic2(), _class2);
 
 // src/charts/machinecharts/CampbellDiagram.ts
 
@@ -732,7 +304,7 @@ var CampbellMath = class {
   /** One line per mode, ordered by speed, with repeated speeds averaged. */
   static modes(rows, speed, frequency, series) {
     const usable = rows.flatMap((row) => {
-      const x = MachineChart.number(row[speed]), y = MachineChart.number(row[frequency]);
+      const x = _chunkFDD4UP73cjs.MachineChart.number(row[speed]), y = _chunkFDD4UP73cjs.MachineChart.number(row[frequency]);
       return x === null || y === null ? [] : [{ mode: String(_nullishCoalesce(row[series], () => ( "Mode"))), x, y }];
     });
     return [..._d3.group.call(void 0, usable, (d) => d.mode)].map(([mode, own]) => ({
@@ -761,8 +333,8 @@ var CampbellMath = class {
 
 // src/charts/machinecharts/CampbellDiagram.ts
 var rpm = (speed) => `${Math.round(speed).toLocaleString("en")} rpm`;
-var CampbellDiagram = (_class4 = class extends MachineChart {
-  static __initStatic4() {this.meta = {
+var CampbellDiagram = (_class3 = class extends _chunkFDD4UP73cjs.MachineChart {
+  static __initStatic3() {this.meta = {
     id: "campbell-diagram",
     name: "Campbell diagram",
     family: "scientific" /* Scientific */,
@@ -770,7 +342,7 @@ var CampbellDiagram = (_class4 = class extends MachineChart {
     shape: "table" /* Table */,
     description: "Plots natural frequencies against rotor speed with engine-order lines from the origin, and marks the critical speeds where they cross.",
     tags: ["rotordynamics", "critical speed", "engine order", "whirl", "vibration", "turbomachinery"],
-    sample: (seed) => MachineSamples.campbell(seed),
+    sample: (seed) => _chunkFDD4UP73cjs.MachineSamples.campbell(seed),
     variants: { maxOrder: [4, 2, 6, 1], crossings: [true, false], bands: [false, true], markers: [false, true] },
     valid: (values) => !(values.bands && !values.crossings)
   }}
@@ -816,7 +388,7 @@ var CampbellDiagram = (_class4 = class extends MachineChart {
       markers ? modes.flatMap(({ mode, points }) => points.map((point) => ({ mode, point }))) : [],
       (d) => d.point,
       (d) => ctx.palette.color(d.mode),
-      (d) => ({ title: d.mode, color: ctx.palette.color(d.mode), rows: [["Speed", rpm(d.point[0])], ["Frequency", `${MachineChart.short(d.point[1])} Hz`]] }),
+      (d) => ({ title: d.mode, color: ctx.palette.color(d.mode), rows: [["Speed", rpm(d.point[0])], ["Frequency", `${_chunkFDD4UP73cjs.MachineChart.short(d.point[1])} Hz`]] }),
       3
     );
     this.dots(
@@ -826,7 +398,7 @@ var CampbellDiagram = (_class4 = class extends MachineChart {
       found,
       (d) => [d.speed, d.frequency],
       () => ctx.theme.ink,
-      (d) => ({ title: `${d.mode} at ${d.order}\xD7`, rows: [["Critical speed", rpm(d.speed)], ["Frequency", `${MachineChart.short(d.frequency)} Hz`]] }),
+      (d) => ({ title: `${d.mode} at ${d.order}\xD7`, rows: [["Critical speed", rpm(d.speed)], ["Frequency", `${_chunkFDD4UP73cjs.MachineChart.short(d.frequency)} Hz`]] }),
       4.5
     );
     const ends = rays.map(({ order, points }) => {
@@ -839,7 +411,7 @@ var CampbellDiagram = (_class4 = class extends MachineChart {
     });
     this.notes(ctx, "labels", [...speeds, ...ends]);
   }
-}, _class4.__initStatic4(), _class4);
+}, _class3.__initStatic3(), _class3);
 
 // src/charts/machinecharts/CarpetPlot.ts
 
@@ -855,8 +427,8 @@ var CarpetGrid = class {
   
   constructor(rows, columns, shift = 1) {
     const read = rows.flatMap((row) => {
-      const a = MachineChart.number(row[columns.a]), b = MachineChart.number(row[columns.b]), value = MachineChart.number(row[columns.value]);
-      return a === null || b === null || value === null ? [] : [{ a, b, value, other: MachineChart.number(row[columns.other]) }];
+      const a = _chunkFDD4UP73cjs.MachineChart.number(row[columns.a]), b = _chunkFDD4UP73cjs.MachineChart.number(row[columns.b]), value = _chunkFDD4UP73cjs.MachineChart.number(row[columns.value]);
+      return a === null || b === null || value === null ? [] : [{ a, b, value, other: _chunkFDD4UP73cjs.MachineChart.number(row[columns.other]) }];
     });
     const levels = (pick) => [...new Set(read.map(pick))].sort((p, q) => p - q);
     const as = levels((node) => node.a), bs = levels((node) => node.b);
@@ -882,8 +454,8 @@ var words = (column) => {
   return text.charAt(0).toUpperCase() + text.slice(1);
 };
 var KEY_ROW = 15;
-var CarpetPlot = (_class5 = class extends MachineChart {constructor(...args) { super(...args); _class5.prototype.__init.call(this); }
-  static __initStatic5() {this.meta = {
+var CarpetPlot = (_class4 = class extends _chunkFDD4UP73cjs.MachineChart {constructor(...args) { super(...args); _class4.prototype.__init.call(this); }
+  static __initStatic4() {this.meta = {
     id: "carpet-plot",
     name: "Carpet plot",
     family: "scientific" /* Scientific */,
@@ -891,7 +463,7 @@ var CarpetPlot = (_class5 = class extends MachineChart {constructor(...args) { s
     shape: "table" /* Table */,
     description: "Draws a response over two independent variables as two crossing families of curves, spread along a cheater axis or a second response.",
     tags: ["cheater plot", "design study", "sizing", "trade study", "aerospace", "two variables"],
-    sample: (seed) => MachineSamples.sizing(seed),
+    sample: (seed) => _chunkFDD4UP73cjs.MachineSamples.sizing(seed),
     variants: { abscissa: Object.values(CarpetAbscissa), shift: [1, 0.5, 2], curve: ["natural" /* Natural */, "linear" /* Linear */], nodes: [true, false] },
     valid: (values) => values.abscissa === "cheater-axis" /* Cheater */ || values.shift === 1
   }}
@@ -927,21 +499,21 @@ var CarpetPlot = (_class5 = class extends MachineChart {constructor(...args) { s
     const { a, b, y, x, curve, nodes } = this.options;
     const { grid, cheater } = this, { theme, palette } = ctx, { height } = ctx.plot;
     const names = [words(a), words(b)], shape = _chunkPY4R3IFFcjs.Scales.curve(curve);
-    const lines = grid.families.flatMap((family, side) => family.map((line4) => ({ side, level: line4.level, points: line4.nodes.map(this.spot).filter((point) => Number.isFinite(point[0])) }))).filter((line4) => line4.points.length > 1);
-    const drawn = this.curves(ctx, axes, "carpet", lines.map((line4) => ({ key: `${line4.side}/${line4.level}`, points: line4.points, color: palette.color(names[line4.side]), curve: shape })));
+    const lines = grid.families.flatMap((family, side) => family.map((line3) => ({ side, level: line3.level, points: line3.nodes.map(this.spot).filter((point) => Number.isFinite(point[0])) }))).filter((line3) => line3.points.length > 1);
+    const drawn = this.curves(ctx, axes, "carpet", lines.map((line3) => ({ key: `${line3.side}/${line3.level}`, points: line3.points, color: palette.color(names[line3.side]), curve: shape })));
     ctx.hover(drawn, (d) => {
       const [side, level] = d.key.split("/");
       return { title: `${names[+side]} = ${level}`, color: d.color };
     });
-    const number = (value) => MachineChart.short(value, 4);
+    const number = (value) => _chunkFDD4UP73cjs.MachineChart.short(value, 4);
     this.dots(ctx, axes, "nodes", nodes ? grid.nodes : [], this.spot, () => theme.ink, (d) => ({
       title: `${names[0]} ${number(d.a)}, ${names[1]} ${number(d.b)}`,
       rows: [[words(y), number(d.value)], ...d.other === null ? [] : [[words(x), number(d.other)]]]
     }), 3.5);
-    const ends = lines.map((line4) => {
-      const first = this.place(axes, line4.points[0]), last = this.place(axes, line4.points[line4.points.length - 1]);
-      const end = line4.side === 0 ? first[1] > last[1] ? first : last : first[0] > last[0] ? first : last;
-      return line4.side === 0 ? { key: `0/${line4.level}`, text: number(line4.level), x: end[0], y: end[1] + 15, anchor: "middle" } : { key: `1/${line4.level}`, text: number(line4.level), x: end[0] + 7, y: end[1] + 4 };
+    const ends = lines.map((line3) => {
+      const first = this.place(axes, line3.points[0]), last = this.place(axes, line3.points[line3.points.length - 1]);
+      const end = line3.side === 0 ? first[1] > last[1] ? first : last : first[0] > last[0] ? first : last;
+      return line3.side === 0 ? { key: `0/${line3.level}`, text: number(line3.level), x: end[0], y: end[1] + 15, anchor: "middle" } : { key: `1/${line3.level}`, text: number(line3.level), x: end[0] + 7, y: end[1] + 4 };
     });
     this.notes(ctx, "labels", ends);
     const origin = _nullishCoalesce(axes.x(0), () => ( 0)), reach = (step) => (_nullishCoalesce(axes.x(step), () => ( 0))) - origin;
@@ -958,7 +530,7 @@ var CarpetPlot = (_class5 = class extends MachineChart {constructor(...args) { s
     ctx.set(rules, { d: (d) => `M${d.from},${d.y - 4}V${d.y + 4}M${d.from},${d.y}H${d.to.toFixed(1)}M${d.to.toFixed(1)},${d.y - 4}V${d.y + 4}` });
     ctx.text(ctx.marks("captions", "text", bars, (d) => d.key, key)).attr("x", (d) => d.to + 8).attr("y", (d) => d.y + 4).text((d) => d.text);
   }
-}, _class5.__initStatic5(), _class5);
+}, _class4.__initStatic4(), _class4);
 
 // src/charts/machinecharts/CompressorMap.ts
 
@@ -977,8 +549,8 @@ var CompressorLimits = /* @__PURE__ */ ((CompressorLimits2) => {
 var EFFICIENCY = "Efficiency";
 var SPEED = "Speed lines";
 var PEAK = "Peak efficiency";
-var CompressorMap = (_class6 = class extends MachineChart {
-  static __initStatic6() {this.meta = {
+var CompressorMap = (_class5 = class extends _chunkFDD4UP73cjs.MachineChart {
+  static __initStatic5() {this.meta = {
     id: "compressor-map",
     name: "Compressor map",
     family: "scientific" /* Scientific */,
@@ -986,7 +558,7 @@ var CompressorMap = (_class6 = class extends MachineChart {
     shape: "table" /* Table */,
     description: "Plots pressure ratio against corrected mass flow along speed lines, with efficiency islands as contours and the surge and choke lines.",
     tags: ["turbomachinery", "turbocharger", "surge line", "choke", "efficiency island", "speed line", "gas turbine"],
-    sample: (seed) => MachineSamples.compressor(seed),
+    sample: (seed) => _chunkFDD4UP73cjs.MachineSamples.compressor(seed),
     variants: { islands: Object.values(CompressorIslands), limits: Object.values(CompressorLimits), ridge: [false, true], markers: [true, false] }
   }}
   defaults() {
@@ -1007,8 +579,8 @@ var CompressorMap = (_class6 = class extends MachineChart {
   get lines() {
     const { x, y, series, efficiency } = this.options;
     const points = this.rows.flatMap((row) => {
-      const flow = MachineChart.number(row[x]), ratio = MachineChart.number(row[y]);
-      return flow === null || ratio === null ? [] : [{ speed: String(_nullishCoalesce(row[series], () => ( "Speed"))), x: flow, y: ratio, z: _nullishCoalesce(MachineChart.number(row[efficiency]), () => ( NaN)) }];
+      const flow = _chunkFDD4UP73cjs.MachineChart.number(row[x]), ratio = _chunkFDD4UP73cjs.MachineChart.number(row[y]);
+      return flow === null || ratio === null ? [] : [{ speed: String(_nullishCoalesce(row[series], () => ( "Speed"))), x: flow, y: ratio, z: _nullishCoalesce(_chunkFDD4UP73cjs.MachineChart.number(row[efficiency]), () => ( NaN)) }];
     });
     return [..._d3.group.call(void 0, points, (d) => d.speed)].map(([speed, own]) => ({ speed, points: own.sort((a, b) => a.x - b.x) })).sort((a, b) => _d3.mean.call(void 0, a.points, (d) => d.x) - _d3.mean.call(void 0, b.points, (d) => d.x));
   }
@@ -1018,7 +590,7 @@ var CompressorMap = (_class6 = class extends MachineChart {
     return ridge && items.length ? [...items, { key: PEAK, color: this.theme.ink }] : items;
   }
   scales(ctx) {
-    const points = this.lines.flatMap((line4) => line4.points);
+    const points = this.lines.flatMap((line3) => line3.points);
     return {
       x: _d3.scaleLinear.call(void 0, this.span(points.map((d) => d.x), 0.07), [0, ctx.plot.width]),
       y: _d3.scaleLinear.call(void 0, this.span(points.map((d) => d.y), 0.07), [ctx.plot.height, 0])
@@ -1028,42 +600,42 @@ var CompressorMap = (_class6 = class extends MachineChart {
     const { islands, limits, ridge, markers } = this.options;
     const { lines } = this, { theme, palette } = ctx;
     const tone = palette.color(EFFICIENCY), ink = palette.color(SPEED);
-    const measured = lines.filter((line4) => line4.points.length > 1 && line4.points.every((d) => Number.isFinite(d.z)));
-    const percent = (_nullishCoalesce(_d3.max.call(void 0, measured.flatMap((line4) => line4.points), (d) => d.z), () => ( 0))) <= 1.5;
-    const efficiency = (value) => percent ? `${MachineChart.short(value * 100)}%` : MachineChart.short(value);
-    const mesh = new MachineMesh(measured.map((line4) => line4.points));
+    const measured = lines.filter((line3) => line3.points.length > 1 && line3.points.every((d) => Number.isFinite(d.z)));
+    const percent = (_nullishCoalesce(_d3.max.call(void 0, measured.flatMap((line3) => line3.points), (d) => d.z), () => ( 0))) <= 1.5;
+    const efficiency = (value) => percent ? `${_chunkFDD4UP73cjs.MachineChart.short(value * 100)}%` : _chunkFDD4UP73cjs.MachineChart.short(value);
+    const mesh = new (0, _chunkFDD4UP73cjs.MachineMesh)(measured.map((line3) => line3.points));
     const field = new (0, _chunk4VWNDCUScjs.FieldContours)(mesh.values, mesh.columns, mesh.rows, (i, j) => this.place(axes, mesh.at(i, j)));
     const levels = islands === "no-islands" /* None */ || !mesh.rows ? [] : mesh.levels();
     const shapes = levels.map((level, i) => {
-      const { area: area3, line: line4, polylines } = field.at(level);
+      const { area: area3, line: line3, polylines } = field.at(level);
       const share = levels.length > 1 ? i / (levels.length - 1) : 1;
       const longest = polylines.reduce((best, run) => run.length > best.length ? run : best, []);
-      return { level, share, fill: palette.sequential(0.1 + 0.75 * share), area: area3, line: line4, at: _nullishCoalesce(longest[Math.floor((longest.length - 1) * (0.2 + 0.6 * share))], () => ( null)) };
+      return { level, share, fill: palette.sequential(0.1 + 0.75 * share), area: area3, line: line3, at: _nullishCoalesce(longest[Math.floor((longest.length - 1) * (0.2 + 0.6 * share))], () => ( null)) };
     });
     const fills = ctx.marks("islands", "path", islands === "island-fills" /* Filled */ ? shapes : [], (d) => d.level).attr("fill", (d) => d.fill).attr("stroke", "none");
     ctx.set(fills, { d: (d) => d.area });
     ctx.hover(fills, (d) => ({ title: `Efficiency at or above ${efficiency(d.level)}`, color: tone }));
     const rings = ctx.marks("island-lines", "path", islands === "island-lines" /* Lines */ ? shapes : [], (d) => d.level).attr("fill", "none").attr("stroke", (d) => palette.sequential(0.4 + 0.6 * d.share)).attr("stroke-width", 1.5);
     ctx.set(rings, { d: (d) => d.line });
-    const ends = (pick) => lines.filter((line4) => line4.points.length).map((line4) => {
-      const node = pick(line4);
+    const ends = (pick) => lines.filter((line3) => line3.points.length).map((line3) => {
+      const node = pick(line3);
       return [node.x, node.y];
     });
-    const surge = limits === "no-limits" /* None */ ? [] : ends((line4) => line4.points[0]);
-    const choke = limits === "surge-and-choke" /* Both */ ? ends((line4) => line4.points[line4.points.length - 1]) : [];
+    const surge = limits === "no-limits" /* None */ ? [] : ends((line3) => line3.points[0]);
+    const choke = limits === "surge-and-choke" /* Both */ ? ends((line3) => line3.points[line3.points.length - 1]) : [];
     this.curves(ctx, axes, "limits", [
       ...choke.length > 1 ? [{ key: "choke", points: choke, color: theme.inkMuted, dash: "6 4" }] : [],
       ...surge.length > 1 ? [{ key: "surge", points: surge, color: theme.ink, width: 2.5 }] : []
     ]);
-    const speeds = this.curves(ctx, axes, "speed-lines", lines.map((line4) => ({ key: line4.speed, points: line4.points.map((d) => [d.x, d.y]), color: ink })));
-    ctx.hover(speeds, (d) => ({ title: `Speed ${d.key}`, color: ink, rows: [["Flow at surge", MachineChart.short(d.points[0][0])], ["Flow at choke", MachineChart.short(d.points[d.points.length - 1][0])]] }));
+    const speeds = this.curves(ctx, axes, "speed-lines", lines.map((line3) => ({ key: line3.speed, points: line3.points.map((d) => [d.x, d.y]), color: ink })));
+    ctx.hover(speeds, (d) => ({ title: `Speed ${d.key}`, color: ink, rows: [["Flow at surge", _chunkFDD4UP73cjs.MachineChart.short(d.points[0][0])], ["Flow at choke", _chunkFDD4UP73cjs.MachineChart.short(d.points[d.points.length - 1][0])]] }));
     const tip = (d) => ({
       title: `Speed ${d.speed}`,
       color: ink,
-      rows: [["Flow", MachineChart.short(d.x, 4)], ["Pressure ratio", MachineChart.short(d.y, 4)], ...Number.isFinite(d.z) ? [["Efficiency", efficiency(d.z)]] : []]
+      rows: [["Flow", _chunkFDD4UP73cjs.MachineChart.short(d.x, 4)], ["Pressure ratio", _chunkFDD4UP73cjs.MachineChart.short(d.y, 4)], ...Number.isFinite(d.z) ? [["Efficiency", efficiency(d.z)]] : []]
     });
-    this.dots(ctx, axes, "markers", markers ? lines.flatMap((line4) => line4.points) : [], (d) => [d.x, d.y], () => ink, tip, 2.5);
-    const peaks = ridge ? measured.map((line4) => line4.points.reduce((best, d) => d.z > best.z ? d : best)) : [];
+    this.dots(ctx, axes, "markers", markers ? lines.flatMap((line3) => line3.points) : [], (d) => [d.x, d.y], () => ink, tip, 2.5);
+    const peaks = ridge ? measured.map((line3) => line3.points.reduce((best, d) => d.z > best.z ? d : best)) : [];
     this.curves(ctx, axes, "ridge", peaks.length > 1 ? [{ key: "ridge", points: peaks.map((d) => [d.x, d.y]), color: theme.ink, width: 1.5, dash: "2 4" }] : []);
     this.dots(ctx, axes, "peaks", peaks, (d) => [d.x, d.y], () => theme.ink, tip, 4.5);
     const at = (point) => point ? this.place(axes, point) : [NaN, NaN];
@@ -1071,15 +643,15 @@ var CompressorMap = (_class6 = class extends MachineChart {
     const notes = [
       { key: "surge", text: "Surge line", x: sx - 8, y: sy + 2, anchor: "end", tone: "ink" },
       { key: "choke", text: "Choke", x: cx + 6, y: cy + 16, tone: "muted" },
-      ...lines.filter((line4) => line4.points.length).map((line4) => {
-        const [x, y] = at(ends(() => line4.points[line4.points.length - 1])[0]);
-        return { key: `speed${line4.speed}`, text: line4.speed, x: x + 7, y: y + 4 };
+      ...lines.filter((line3) => line3.points.length).map((line3) => {
+        const [x, y] = at(ends(() => line3.points[line3.points.length - 1])[0]);
+        return { key: `speed${line3.speed}`, text: line3.speed, x: x + 7, y: y + 4 };
       }),
       ...shapes.flatMap((shape) => shape.at ? [{ key: `level${shape.level}`, text: `\u03B7 ${efficiency(shape.level)}`, x: shape.at[0], y: shape.at[1] + 4, anchor: "middle", tone: "muted", over: islands === "island-fills" /* Filled */ ? shape.fill : void 0 }] : [])
     ];
     this.notes(ctx, "labels", notes);
   }
-}, _class6.__initStatic6(), _class6);
+}, _class5.__initStatic5(), _class5);
 
 // src/charts/machinecharts/DragPolar.ts
 
@@ -1089,8 +661,8 @@ var det = (m) => m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) - m[0][1] * (
 var DragPolarMath = class _DragPolarMath {
   /** Least-squares quadratic through the points, or null with fewer than three lift coefficients to fit. */
   static fit(points) {
-    const s = [0, 1, 2, 3, 4].map((power) => points.reduce((sum2, [, cl]) => sum2 + cl ** power, 0));
-    const t = [0, 1, 2].map((power) => points.reduce((sum2, [cd, cl]) => sum2 + cd * cl ** power, 0));
+    const s = [0, 1, 2, 3, 4].map((power) => points.reduce((sum, [, cl]) => sum + cl ** power, 0));
+    const t = [0, 1, 2].map((power) => points.reduce((sum, [cd, cl]) => sum + cd * cl ** power, 0));
     const normal = [[s[0], s[1], s[2]], [s[1], s[2], s[3]], [s[2], s[3], s[4]]], scale = det(normal);
     if (points.length < 3 || Math.abs(scale) < 1e-12) return null;
     const [c0, c1, c2] = [0, 1, 2].map((column) => det(normal.map((row, i) => row.map((value, j) => j === column ? t[i] : value))) / scale);
@@ -1122,8 +694,8 @@ var DragPolarFit = /* @__PURE__ */ ((DragPolarFit2) => {
   DragPolarFit2["Parabolic"] = "parabolic-fit";
   return DragPolarFit2;
 })(DragPolarFit || {});
-var DragPolar = (_class7 = class extends MachineChart {constructor(...args2) { super(...args2); _class7.prototype.__init2.call(this); }
-  static __initStatic7() {this.meta = {
+var DragPolar = (_class6 = class extends _chunkFDD4UP73cjs.MachineChart {constructor(...args2) { super(...args2); _class6.prototype.__init2.call(this); }
+  static __initStatic6() {this.meta = {
     id: "drag-polar",
     name: "Drag polar",
     family: "scientific" /* Scientific */,
@@ -1131,7 +703,7 @@ var DragPolar = (_class7 = class extends MachineChart {constructor(...args2) { s
     shape: "table" /* Table */,
     description: "Plots lift coefficient against drag coefficient for each configuration, with the tangent from the origin that marks the best lift-to-drag ratio.",
     tags: ["aerodynamics", "aircraft", "lift-to-drag", "glide ratio", "aerofoil", "flaps"],
-    sample: (seed) => MachineSamples.dragPolar(seed),
+    sample: (seed) => _chunkFDD4UP73cjs.MachineSamples.dragPolar(seed),
     variants: { view: Object.values(DragPolarView), fit: Object.values(DragPolarFit), tangent: [true, false], markers: [true, false] }
   }}
   defaults() {
@@ -1148,7 +720,7 @@ var DragPolar = (_class7 = class extends MachineChart {constructor(...args2) { s
   get polars() {
     const { x, y, series, fit } = this.options;
     const usable = this.rows.flatMap((row) => {
-      const cd = MachineChart.number(row[x]), cl = MachineChart.number(row[y]);
+      const cd = _chunkFDD4UP73cjs.MachineChart.number(row[x]), cl = _chunkFDD4UP73cjs.MachineChart.number(row[y]);
       return cd === null || cl === null ? [] : [{ name: String(_nullishCoalesce(row[series], () => ( "Polar"))), point: [cd, cl], row }];
     });
     return [..._d3.group.call(void 0, usable, (d) => d.name)].map(([name, measured]) => {
@@ -1180,7 +752,7 @@ var DragPolar = (_class7 = class extends MachineChart {constructor(...args2) { s
     });
     this.curves(ctx, axes, "axis-tangents", rays);
     this.curves(ctx, axes, "polars", polars.map((polar) => ({ key: polar.name, points: polar.curve.map(this.seen), color: palette.color(polar.name) })));
-    const number = (value) => MachineChart.short(value, 3);
+    const number = (value) => _chunkFDD4UP73cjs.MachineChart.short(value, 3);
     this.dots(
       ctx,
       axes,
@@ -1206,87 +778,10 @@ var DragPolar = (_class7 = class extends MachineChart {constructor(...args2) { s
       return ratio ? { key, text, x, y: y - 10, anchor: "middle", tone: "ink" } : { key, text, x: x + 6, y: y + 14, tone: "ink" };
     }));
   }
-}, _class7.__initStatic7(), _class7);
+}, _class6.__initStatic6(), _class6);
 
 // src/charts/machinecharts/ElevationProfile.ts
 
-
-// src/charts/machinecharts/ElevationMath.ts
-
-var CLASSES = [3, 6, 9];
-var SCORES = [8e3, 16e3, 32e3, 64e3, 8e4];
-var ElevationMath = class _ElevationMath {
-  /** The profile ordered by distance, with repeated distances averaged. */
-  static profile(rows, distance, elevation) {
-    const read = rows.flatMap((row) => {
-      const x = MachineChart.number(row[distance]), y = MachineChart.number(row[elevation]);
-      return x === null || y === null ? [] : [[x, y]];
-    });
-    return [..._d3.group.call(void 0, read, (point) => point[0])].map(([x, same]) => [x, _d3.mean.call(void 0, same, (point) => point[1])]).sort((a, b) => a[0] - b[0]);
-  }
-  /** Elevation at a distance, by linear interpolation, held level past either end. */
-  static at(points, distance) {
-    const i = points.findIndex((point) => point[0] >= distance);
-    if (i < 0) return _nullishCoalesce(_optionalChain([points, 'access', _18 => _18[points.length - 1], 'optionalAccess', _19 => _19[1]]), () => ( NaN));
-    if (i === 0) return points[0][1];
-    const [x0, y0] = points[i - 1], [x1, y1] = points[i];
-    return y0 + (y1 - y0) * (distance - x0) / (x1 - x0);
-  }
-  /** Total climbed. A rise or fall smaller than `deadband` is treated as noise in the survey and not counted. */
-  static ascent(points, deadband = 0) {
-    let held = _nullishCoalesce(_optionalChain([points, 'access', _20 => _20[0], 'optionalAccess', _21 => _21[1]]), () => ( 0)), gain = 0;
-    for (const [, elevation] of points) {
-      if (elevation > held + deadband) gain += elevation - held;
-      if (Math.abs(elevation - held) > deadband) held = elevation;
-    }
-    return gain;
-  }
-  static steepness(grade) {
-    return grade <= -CLASSES[0] ? -1 : CLASSES.filter((bound) => grade >= bound).length;
-  }
-  /** The route cut into stretches of `length`, each with its mean gradient. */
-  static segments(points, length, rise = 1e3) {
-    if (points.length < 2 || !(length > 0)) return [];
-    const first = points[0][0], last = points[points.length - 1][0];
-    return Array.from({ length: Math.min(2e3, Math.ceil((last - first) / length - 1e-9)) }, (_, i) => {
-      const from = first + i * length, to = Math.min(last, from + length), start = _ElevationMath.at(points, from), end = _ElevationMath.at(points, to);
-      const grade = (end - start) / ((to - from) * rise) * 100;
-      return { from, to, start, end, grade, steep: _ElevationMath.steepness(grade) };
-    });
-  }
-  /**
-   * Sustained ascents: from a low point to the highest point reached before the road drops by more than `dip`. A climb
-   * counts when it gains at least `least` and averages 3% or more from the last point within 8% of its gain above the foot,
-   * which trims a flat approach.
-   */
-  static climbs(points, { rise = 1e3, dip = 30, least = 80 } = {}) {
-    const found = [];
-    const close = (low2, top2) => {
-      const foot = points[low2][1] + 0.08 * (points[top2][1] - points[low2][1]);
-      for (let i = top2 - 1; i > low2; i--) if (points[i][1] <= foot) {
-        low2 = i;
-        break;
-      }
-      const [from, start] = points[low2], [to, end] = points[top2], gain = end - start, length = to - from, grade = gain / (length * rise) * 100;
-      if (gain < least || grade < CLASSES[0]) return;
-      const rank = SCORES.filter((score) => length * rise * grade >= score).length;
-      found.push({ from, to, start, end, gain, length, grade, category: rank ? Math.max(0, 5 - rank) : null });
-    };
-    let low = 0, top = 0;
-    points.forEach(([, elevation], i) => {
-      if (elevation > points[top][1]) top = i;
-      else if (top === low && elevation < points[low][1]) low = top = i;
-      else if (points[top][1] - elevation > dip) {
-        close(low, top);
-        low = top = i;
-      }
-    });
-    if (top > low) close(low, top);
-    return found;
-  }
-};
-
-// src/charts/machinecharts/ElevationProfile.ts
 var ElevationShading = /* @__PURE__ */ ((ElevationShading2) => {
   ElevationShading2["Gradient"] = "gradient-classes";
   ElevationShading2["Plain"] = "plain-fill";
@@ -1299,8 +794,8 @@ var ElevationBaseline = /* @__PURE__ */ ((ElevationBaseline2) => {
 })(ElevationBaseline || {});
 var STEEP = [{ steep: -1, key: "Descent", tone: -0.55 }, { steep: 0, key: "Under 3%", tone: 0 }, { steep: 1, key: "3 to 6%", tone: 0.4 }, { steep: 2, key: "6 to 9%", tone: 0.72 }, { steep: 3, key: "Over 9%", tone: 1 }];
 var tenth = (value) => (+value.toFixed(1)).toLocaleString("en");
-var ElevationProfile = (_class8 = class extends MachineChart {
-  static __initStatic8() {this.meta = {
+var ElevationProfile = (_class7 = class extends _chunkFDD4UP73cjs.MachineChart {
+  static __initStatic7() {this.meta = {
     id: "elevation-profile",
     name: "Elevation profile",
     family: "scientific" /* Scientific */,
@@ -1308,7 +803,7 @@ var ElevationProfile = (_class8 = class extends MachineChart {
     shape: "table" /* Table */,
     description: "Fills elevation against distance along a route, shades each stretch by steepness class, brackets the climbs and totals the ascent.",
     tags: ["route profile", "gradient", "climb", "cycling", "hiking", "road grade", "total ascent"],
-    sample: (seed) => MachineSamples.route(seed),
+    sample: (seed) => _chunkFDD4UP73cjs.MachineSamples.route(seed),
     variants: { shading: Object.values(ElevationShading), segment: [1, 0.5, 2], climbs: [true, false], baseline: Object.values(ElevationBaseline) },
     valid: (values) => values.shading === "gradient-classes" /* Gradient */ || values.segment === 1
   }}
@@ -1330,7 +825,7 @@ var ElevationProfile = (_class8 = class extends MachineChart {
     return { x: `Distance (${this.options.distanceUnit})`, y: `Elevation (${this.options.elevationUnit})` };
   }
   get profile() {
-    return ElevationMath.profile(this.rows, this.options.x, this.options.y);
+    return _chunkFDD4UP73cjs.ElevationMath.profile(this.rows, this.options.x, this.options.y);
   }
   get shaded() {
     return this.options.shading === "gradient-classes" /* Gradient */;
@@ -1340,7 +835,7 @@ var ElevationProfile = (_class8 = class extends MachineChart {
   }
   legendItems() {
     if (!this.shaded) return super.legendItems();
-    const used = new Set(ElevationMath.segments(this.profile, this.options.segment, this.options.rise).map((part) => part.steep));
+    const used = new Set(_chunkFDD4UP73cjs.ElevationMath.segments(this.profile, this.options.segment, this.options.rise).map((part) => part.steep));
     return STEEP.filter((entry) => used.has(entry.steep)).map((entry) => ({ key: entry.key, color: this.tone(entry.steep) }));
   }
   /** Headroom above the summit holds the climb labels and the total. */
@@ -1353,7 +848,7 @@ var ElevationProfile = (_class8 = class extends MachineChart {
   /** Neighbouring stretches of one class become one shape, so the fill has no seams inside a class. */
   stretches(profile) {
     const { segment, rise } = this.options, runs = [];
-    for (const part of ElevationMath.segments(profile, segment, rise)) {
+    for (const part of _chunkFDD4UP73cjs.ElevationMath.segments(profile, segment, rise)) {
       const run = runs[runs.length - 1];
       if (run && run[0].steep === part.steep) run.push(part);
       else runs.push([part]);
@@ -1368,7 +863,7 @@ var ElevationProfile = (_class8 = class extends MachineChart {
     const whole = (value) => `${Math.round(value).toLocaleString("en")} ${elevationUnit}`, far = (value) => `${tenth(value)} ${distanceUnit}`;
     const { profile, shaded } = this, { theme, palette } = ctx, { height } = ctx.plot;
     const fill = _d3.area.call(void 0, ).curve(_chunkPY4R3IFFcjs.Scales.curve()).x((d) => this.place(axes, d)[0]).y1((d) => this.place(axes, d)[1]).y0(height);
-    const ascent = ElevationMath.ascent(profile, deadband), length = profile.length ? profile[profile.length - 1][0] - profile[0][0] : 0;
+    const ascent = _chunkFDD4UP73cjs.ElevationMath.ascent(profile, deadband), length = profile.length ? profile[profile.length - 1][0] - profile[0][0] : 0;
     const ink = shaded ? theme.ink : palette.color("Elevation");
     const stretches = shaded ? this.stretches(profile) : [];
     const bands = ctx.marks("stretches", "path", stretches, (d) => d.key).attr("fill", (d) => this.tone(d.steep)).attr("stroke", "none");
@@ -1381,7 +876,7 @@ var ElevationProfile = (_class8 = class extends MachineChart {
     ctx.set(plain2, { d: (d) => _nullishCoalesce(fill(d), () => ( "")) });
     ctx.hover(plain2, () => ({ title: "Elevation", color: ink, rows: [["Distance", far(length)], ["Total ascent", whole(ascent)], ["Highest", whole(Math.max(...profile.map((point) => point[1])))]] }));
     this.curves(ctx, axes, "profile", profile.length > 1 ? [{ key: "profile", points: profile, color: ink, width: shaded ? 1.5 : 2 }] : []);
-    const found = (climbs ? ElevationMath.climbs(profile, { rise }) : []).map((climb) => {
+    const found = (climbs ? _chunkFDD4UP73cjs.ElevationMath.climbs(profile, { rise }) : []).map((climb) => {
       const [x1, top] = this.place(axes, [climb.to, climb.end]), [x0] = this.place(axes, [climb.from, climb.start]);
       return { climb, x0, x1, y: top - 10 };
     });
@@ -1395,7 +890,7 @@ var ElevationProfile = (_class8 = class extends MachineChart {
       { key: `climb${climb.from}`, text: `${name(climb)} \xB7 ${far(climb.length)} at ${tenth(climb.grade)}%`, x: (x0 + x1) / 2, y: y - 6, anchor: "middle", tone: "ink" }
     ])]);
   }
-}, _class8.__initStatic8(), _class8);
+}, _class7.__initStatic7(), _class7);
 
 // src/charts/machinecharts/GasCycleDiagram.ts
 
@@ -1416,8 +911,8 @@ var HEAT_OUT = "Heat out";
 var energy = (value) => `${Math.round(value).toLocaleString("en")} kJ/kg`;
 var TURNS = [0, 1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6].map((step) => step * Math.PI / 6);
 var kelvin = (state) => `${Math.round(state.temperature).toLocaleString("en")} K`;
-var GasCycleDiagram = (_class9 = class extends MachineChart {constructor(...args3) { super(...args3); _class9.prototype.__init3.call(this); }
-  static __initStatic9() {this.meta = {
+var GasCycleDiagram = (_class8 = class extends _chunkFDD4UP73cjs.MachineChart {constructor(...args3) { super(...args3); _class8.prototype.__init3.call(this); }
+  static __initStatic8() {this.meta = {
     id: "gas-cycle-diagram",
     name: "Gas power cycle diagram",
     family: "scientific" /* Scientific */,
@@ -1425,7 +920,7 @@ var GasCycleDiagram = (_class9 = class extends MachineChart {constructor(...args
     shape: "table" /* Table */,
     description: "Draws an ideal-gas Otto, Diesel or Brayton cycle on pressure-volume or temperature-entropy axes, with numbered states, the net-work and heat areas and the thermal efficiency.",
     tags: ["thermodynamics", "otto cycle", "diesel cycle", "brayton cycle", "p-v diagram", "t-s diagram", "air-standard cycle", "thermal efficiency", "heat engine"],
-    sample: (seed) => MachineSamples.gasCycles(seed),
+    sample: (seed) => _chunkFDD4UP73cjs.MachineSamples.gasCycles(seed),
     variants: { cycle: Object.values(GasCycleKind), plane: Object.values(GasCyclePlane), areas: [true, false], isotherms: [false, true] }
   }}
   defaults() {
@@ -1471,10 +966,10 @@ var GasCycleDiagram = (_class9 = class extends MachineChart {constructor(...args
       const name = String(_nullishCoalesce(row[series], () => ( ""))).toLowerCase();
       return !name || name.includes(cycle);
     });
-    const read = GasCycleMath.states(own, { pressure, temperature, volume, label }, gas);
+    const read = _chunkFDD4UP73cjs.GasCycleMath.states(own, { pressure, temperature, volume, label }, gas);
     if (read.length) return read;
-    if (cycle === "brayton" /* Brayton */) return GasCycleMath.brayton(gas, pressureRatio, _nullishCoalesce(peakTemperature, () => ( 1400)));
-    return cycle === "diesel" /* Diesel */ ? GasCycleMath.diesel(gas, _nullishCoalesce(compressionRatio, () => ( 18)), cutoffRatio) : GasCycleMath.otto(gas, _nullishCoalesce(compressionRatio, () => ( 9)), _nullishCoalesce(peakTemperature, () => ( 2e3)));
+    if (cycle === "brayton" /* Brayton */) return _chunkFDD4UP73cjs.GasCycleMath.brayton(gas, pressureRatio, _nullishCoalesce(peakTemperature, () => ( 1400)));
+    return cycle === "diesel" /* Diesel */ ? _chunkFDD4UP73cjs.GasCycleMath.diesel(gas, _nullishCoalesce(compressionRatio, () => ( 18)), cutoffRatio) : _chunkFDD4UP73cjs.GasCycleMath.otto(gas, _nullishCoalesce(compressionRatio, () => ( 9)), _nullishCoalesce(peakTemperature, () => ( 2e3)));
   }
   /** P-V starts both axes at zero. T-s starts temperature at absolute zero, so the area under a leg is its heat, and leaves room above for the efficiency. */
   scales(ctx) {
@@ -1488,9 +983,9 @@ var GasCycleDiagram = (_class9 = class extends MachineChart {constructor(...args
   plotMarks(ctx, axes) {
     const { areas, isotherms } = this.options;
     const { states, pv } = this, { theme, palette } = ctx, { width, height } = ctx.plot;
-    const legs = GasCycleMath.processes(states), totals = GasCycleMath.totals(legs);
+    const legs = _chunkFDD4UP73cjs.GasCycleMath.processes(states), totals = _chunkFDD4UP73cjs.GasCycleMath.totals(legs);
     const at = (point) => this.place(axes, point);
-    const run = (leg) => GasCycleMath.leg(this.spot(leg.from), this.spot(leg.to), pv);
+    const run = (leg) => _chunkFDD4UP73cjs.GasCycleMath.leg(this.spot(leg.from), this.spot(leg.to), pv);
     const edge = _d3.line.call(void 0, ).x((d) => at(d)[0]).y((d) => at(d)[1]);
     const under = _d3.area.call(void 0, ).x((d) => at(d)[0]).y1((d) => at(d)[1]).y0(at([0, 0])[1]);
     const tint = palette.color(WORK);
@@ -1504,17 +999,17 @@ var GasCycleDiagram = (_class9 = class extends MachineChart {constructor(...args
     const ranked = [...states].sort((a, b) => b.temperature - a.temperature);
     const levels = (isotherms && states.length > 1 ? [ranked[0], ranked[ranked.length - 1]] : []).map((state) => {
       const product = state.pressure * state.volume, start = Math.max(left, product / top);
-      return { state, points: pv ? GasCycleMath.leg([start, product / start], [right, product / right], true) : [[left, state.temperature], [right, state.temperature]] };
+      return { state, points: pv ? _chunkFDD4UP73cjs.GasCycleMath.leg([start, product / start], [right, product / right], true) : [[left, state.temperature], [right, state.temperature]] };
     });
     this.curves(ctx, axes, "axis-isotherms", levels.map(({ state, points }) => ({ key: state.label, points, color: theme.axis, width: 1, dash: "5 4" })));
     const lines = this.curves(ctx, axes, "processes", legs.map((leg) => ({ key: leg.from.label, points: run(leg), color: theme.ink })));
     ctx.hover(lines, (_, i) => ({ title: `${legs[i].from.label} to ${legs[i].to.label}: ${legs[i].name}`, rows: [["Heat", energy(legs[i].heat)], ["Work", energy(legs[i].work)]] }));
     this.dots(ctx, axes, "states", states, this.spot, () => theme.ink, (d) => ({
       title: `State ${d.label}`,
-      rows: [["Pressure", `${MachineChart.short(d.pressure, 4)} kPa`], ["Specific volume", `${MachineChart.short(d.volume, 4)} m\xB3/kg`], ["Temperature", kelvin(d)], ["Entropy", `${MachineChart.short(d.entropy)} kJ/kg\xB7K`]]
+      rows: [["Pressure", `${_chunkFDD4UP73cjs.MachineChart.short(d.pressure, 4)} kPa`], ["Specific volume", `${_chunkFDD4UP73cjs.MachineChart.short(d.volume, 4)} m\xB3/kg`], ["Temperature", kelvin(d)], ["Entropy", `${_chunkFDD4UP73cjs.MachineChart.short(d.entropy)} kJ/kg\xB7K`]]
     }), 4.5);
     const pixels = states.map((state) => at(this.spot(state))), count = pixels.length, placed = [];
-    const track = legs.flatMap((leg) => GasCycleMath.leg(this.spot(leg.from), this.spot(leg.to), pv, 60)).map(at);
+    const track = legs.flatMap((leg) => _chunkFDD4UP73cjs.GasCycleMath.leg(this.spot(leg.from), this.spot(leg.to), pv, 60)).map(at);
     const clear = (points, [cx, cy], wide, tall) => points.every(([ox, oy, other = 0]) => Math.abs(cx - ox) >= wide + other || Math.abs(cy - oy) >= tall);
     const corners = states.map((state, i) => {
       const [x2, y] = pixels[i], half = state.label.length * 3.1;
@@ -1542,7 +1037,7 @@ var GasCycleDiagram = (_class9 = class extends MachineChart {constructor(...args
     });
     this.notes(ctx, "labels", [...head, ...corners, ...limits]);
   }
-}, _class9.__initStatic9(), _class9);
+}, _class8.__initStatic8(), _class8);
 
 // src/charts/machinecharts/GgDiagram.ts
 
@@ -1596,8 +1091,8 @@ var GgEnvelope = /* @__PURE__ */ ((GgEnvelope2) => {
 })(GgEnvelope || {});
 var NAME = "Acceleration";
 var g = (value) => `${value.toFixed(2)} g`;
-var GgDiagram = (_class10 = class extends MachineChart {
-  static __initStatic10() {this.meta = {
+var GgDiagram = (_class9 = class extends _chunkFDD4UP73cjs.MachineChart {
+  static __initStatic9() {this.meta = {
     id: "gg-diagram",
     name: "g-g diagram",
     family: "scientific" /* Scientific */,
@@ -1605,7 +1100,7 @@ var GgDiagram = (_class10 = class extends MachineChart {
     shape: "table" /* Table */,
     description: "Plots lateral against longitudinal acceleration as points, a density or a trace, with the grip envelope the samples reach.",
     tags: ["friction circle", "traction circle", "vehicle dynamics", "motorsport", "grip", "telemetry"],
-    sample: (seed) => MachineSamples.lap(seed),
+    sample: (seed) => _chunkFDD4UP73cjs.MachineSamples.lap(seed),
     variants: { form: Object.values(GgForm), envelope: Object.values(GgEnvelope), rings: [true, false] }
   }}
   defaults() {
@@ -1614,7 +1109,7 @@ var GgDiagram = (_class10 = class extends MachineChart {
   get samples() {
     const { x, y } = this.options;
     return this.rows.flatMap((row) => {
-      const lateral = MachineChart.number(row[x]), longitudinal = MachineChart.number(row[y]);
+      const lateral = _chunkFDD4UP73cjs.MachineChart.number(row[x]), longitudinal = _chunkFDD4UP73cjs.MachineChart.number(row[y]);
       return lateral === null || longitudinal === null ? [] : [{ point: [lateral, longitudinal], row }];
     });
   }
@@ -1663,7 +1158,7 @@ var GgDiagram = (_class10 = class extends MachineChart {
     ] : [];
     this.notes(ctx, "labels", [...notes, ...radii.map((d) => ({ key: `ring${d}`, text: `${d} g`, x: ox - 5, y: oy - d * unit2 - 4, anchor: "end", tone: "muted" }))]);
   }
-}, _class10.__initStatic10(), _class10);
+}, _class9.__initStatic9(), _class9);
 
 // src/charts/machinecharts/index.ts
 var machinechartsCatalog = [CampbellDiagram, CompressorMap, BsfcMap, GgDiagram, DragPolar, AshbyChart, CarpetPlot, ElevationProfile, GasCycleDiagram];