prographs 0.12.0 → 0.13.0

package/dist/{chunk-NJ4X6XGV.cjs → chunk-EZTYX2GH.cjs}

@@ -22,7 +22,7 @@ var _chunkPY4R3IFFcjs = require('./chunk-PY4R3IFF.cjs');
 var _chunk35CT4Q2Ecjs = require('./chunk-35CT4Q2E.cjs');
 
 
-var _chunkUMEKIIHJcjs = require('./chunk-UMEKIIHJ.cjs');
+var _chunkLNWTC72Ycjs = require('./chunk-LNWTC72Y.cjs');
 
 // src/charts/surveycharts/IrtMath.ts
 var IrtModel = /* @__PURE__ */ ((IrtModel2) => {
@@ -137,7 +137,7 @@ var STATEMENTS = [
 var SurveySamples = class {
   /** `{ item, difficulty, discrimination, guessing }`, one row per calibrated item of a maths test. */
   static testItems(seed) {
-    const { n } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
+    const { n } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
     return ITEMS.map(([item, a, b, c]) => ({
       item,
       difficulty: +(b + n() * 0.08).toFixed(2),
@@ -147,7 +147,7 @@ var SurveySamples = class {
   }
   /** `{ role, label, measure, group }`, a Rasch calibration: person rows have a null group, and item rows name a strand. */
   static calibration(seed) {
-    const { n, u } = _chunkUMEKIIHJcjs.SampleData.rng(seed), { mean: mean3, sd, low, high } = ABILITY;
+    const { n, u } = _chunkLNWTC72Ycjs.SampleData.rng(seed), { mean: mean3, sd, low, high } = ABILITY;
     const persons = Array.from({ length: PERSONS }, (_, i) => ({
       role: "person",
       label: `P${i + 1}`,
@@ -164,7 +164,7 @@ var SurveySamples = class {
   }
   /** `{ concept, left, right, value }`, one row per rating on a 1 to 7 scale. */
   static ratings(seed) {
-    const { n } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
+    const { n } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
     return CONCEPTS.flatMap(([concept, means]) => POLES.flatMap(([left, right], pair) => Array.from({ length: RESPONDENTS }, () => ({
       concept,
       left,
@@ -174,7 +174,7 @@ var SurveySamples = class {
   }
   /** `{ item, agree, neutral, disagree }`, response counts per statement of a staff survey. */
   static agreement(seed) {
-    const { n } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
+    const { n } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
     return STATEMENTS.map(([item, agreeing, disagreeing, base]) => {
       const agree = Math.round(base * (agreeing + n() * 0.015)), disagree = Math.round(base * (disagreeing + n() * 0.015));
       return { item, agree, neutral: Math.max(0, base - agree - disagree), disagree };

package/dist/chunk-FDD4UP73.cjs

@@ -0,0 +1,521 @@
+"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 _chunkXX2YTCORcjs = require('./chunk-XX2YTCOR.cjs');
+
+
+var _chunkPY4R3IFFcjs = require('./chunk-PY4R3IFF.cjs');
+
+
+var _chunkLNWTC72Ycjs = require('./chunk-LNWTC72Y.cjs');
+
+// src/charts/machinecharts/MachineMesh.ts
+var _d3 = require('d3');
+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((line2) => line2.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((line2) => {
+      const reach = [0];
+      for (let i = 1; i < line2.length; i++) reach.push(reach[i - 1] + Math.hypot((line2[i].x - line2[i - 1].x) / sx, (line2[i].y - line2[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 < line2.length - 2 && reach[at + 1] < want) at++;
+        return lerp(line2[at], line2[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 line2 = Math.min(last - 1, Math.floor(row / between)), t = row / between - line2;
+      const [a, b, c, d] = [-1, 0, 1, 2].map((shift) => even[Math.max(0, Math.min(last, line2 + 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', _3 => _3.nodes, 'access', _4 => _4[0], 'optionalAccess', _5 => _5.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/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 } = _chunkLNWTC72Ycjs.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 } = _chunkLNWTC72Ycjs.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 } = _chunkLNWTC72Ycjs.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 } = _chunkLNWTC72Ycjs.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 } = _chunkLNWTC72Ycjs.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 } = _chunkLNWTC72Ycjs.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 } = _chunkLNWTC72Ycjs.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 } = _chunkLNWTC72Ycjs.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 } = _chunkLNWTC72Ycjs.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/BsfcMath.ts
+
+var BsfcMath = (_class = class _BsfcMath {
+  /** rpm × N·m per kW. */
+  static __initStatic() {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', _6 => _6[i - 1], 'optionalAccess', _7 => _7.speed]), () => ( speed))) + 2 * speed + (_nullishCoalesce(_optionalChain([found, 'access', _8 => _8[i + 1], 'optionalAccess', _9 => _9.speed]), () => ( speed)))) / 4;
+      return [smooth, _BsfcMath.torque(smooth, power)];
+    });
+  }
+}, _class.__initStatic(), _class);
+
+// 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', _10 => _10[points.length - 1], 'optionalAccess', _11 => _11[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', _12 => _12[0], 'optionalAccess', _13 => _13[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;
+  }
+};
+
+
+
+
+
+
+
+
+exports.MachineChart = MachineChart; exports.GasCycleMath = GasCycleMath; exports.MachineSamples = MachineSamples; exports.BsfcMath = BsfcMath; exports.MachineMesh = MachineMesh; exports.ElevationMath = ElevationMath;