prographs 0.12.0 → 0.13.0

package/dist/{chunk-5BFCIX2V.cjs → chunk-CPPMO4IQ.cjs}

@@ -1,4 +1,4 @@
-"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; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19;
+"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; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20;
 
 var _chunk6KYVL5HYcjs = require('./chunk-6KYVL5HY.cjs');
 
@@ -6,10 +6,14 @@ var _chunk6KYVL5HYcjs = require('./chunk-6KYVL5HY.cjs');
 var _chunkXX2YTCORcjs = require('./chunk-XX2YTCOR.cjs');
 
 
+
+var _chunkEEF5WRRZcjs = require('./chunk-EEF5WRRZ.cjs');
+
+
 var _chunkPY4R3IFFcjs = require('./chunk-PY4R3IFF.cjs');
 
 
-var _chunkUMEKIIHJcjs = require('./chunk-UMEKIIHJ.cjs');
+var _chunkLNWTC72Ycjs = require('./chunk-LNWTC72Y.cjs');
 
 
 var _chunkANNBM27Zcjs = require('./chunk-ANNBM27Z.cjs');
@@ -46,7 +50,7 @@ var SignalWavelet = /* @__PURE__ */ ((SignalWavelet2) => {
   return SignalWavelet2;
 })(SignalWavelet || {});
 
-// src/charts/signals/AudiogramChart.ts
+// src/charts/signals/AntennaPatternChart.ts
 var _d3 = require('d3');
 
 // src/charts/signals/SignalChart.ts
@@ -532,7 +536,356 @@ var SignalChart = (_class = class extends _chunkXX2YTCORcjs.CartesianChart {cons
   }
 }, _class);
 
+// src/charts/signals/SignalSamples.ts
+var TAU2 = Math.PI * 2;
+var SignalSamples = class {
+  /** Zero-mean, unit-variance noise per series, from the steps of a random walk. */
+  static noise(seed, samples, channels) {
+    const rows = _chunkLNWTC72Ycjs.SampleData.timeSeries(seed, samples + 1, channels), names = [...new Set(rows.map((row) => String(row.series)))];
+    return names.map((name) => {
+      const walk = rows.filter((row) => row.series === name).map((row) => +row.value);
+      const steps = walk.slice(1).map((value, i) => value - walk[i]), mean2 = steps.reduce((sum, step) => sum + step, 0) / steps.length;
+      const deviation = Math.sqrt(steps.reduce((sum, step) => sum + (step - mean2) ** 2, 0) / steps.length) || 1;
+      return { name, noise: steps.map((step) => (step - mean2) / deviation) };
+    });
+  }
+  static rows(seed, samples, channels, rate, shape) {
+    return this.noise(seed, samples, channels).flatMap(({ name, noise }, channel) => {
+      const phase = Math.abs(noise[0]) % TAU2;
+      return noise.map((step, i) => ({ t: +(i / rate).toFixed(6), series: name, value: +shape(i / rate, channel, step, phase).toFixed(5) }));
+    });
+  }
+  /** Plucked notes with harmonics, in a phrase: the demo for waveforms and spectra. */
+  static notes(seed = 1, samples = 2048, channels = 2, rate = 8e3) {
+    const duration = samples / rate, starts = [0, 0.22, 0.47, 0.68].map((start) => start * duration);
+    return this.rows(seed, samples, channels, rate, (t, channel, noise, phase) => {
+      const note = starts.reduce((held, start, i) => t >= start ? i : held, 0), since = t - starts[note];
+      const pitch = (220 + 45 * channel) * [1, 1.5, 1.25, 2][note];
+      const tone = Math.sin(TAU2 * pitch * t + phase) + 0.5 * Math.sin(TAU2 * 2 * pitch * t) + 0.25 * Math.sin(TAU2 * 3 * pitch * t + phase);
+      return (0.82 - channel * 0.22) * Math.exp(-since * 14 / duration * 0.5) * Math.min(1, since * 400) * tone * 0.58 + 2e-3 * noise;
+    });
+  }
+  /** A rising chirp, a steady tone and a click: shows off time-frequency views. */
+  static chirp(seed = 1, samples = 4096, channels = 1, rate = 8e3) {
+    const duration = samples / rate;
+    return this.rows(seed, samples, channels, rate, (t, channel, noise, phase) => {
+      const x = t / duration, sweep = 150 * t + 1500 * t * t / (2 * duration);
+      const click = Math.exp(-(((x - 0.72) / 4e-3) ** 2)) * Math.sin(TAU2 * 2600 * t);
+      return 0.7 * Math.sin(TAU2 * sweep + phase + channel) * Math.sin(Math.PI * x) ** 0.5 + 0.28 * Math.sin(TAU2 * 900 * t) * (x > 0.15 && x < 0.55 ? 1 : 0) + 0.5 * click + 2e-3 * noise;
+    });
+  }
+  /** A pulse train with formant-like harmonics: a voiced sound with a clear pitch. */
+  static voiced(seed = 1, samples = 2048, channels = 1, rate = 8e3) {
+    const pitch = 142;
+    return this.rows(seed, samples, channels, rate, (t, channel, noise, phase) => {
+      let sum = 0;
+      for (let k = 1; k <= 36; k++) {
+        const f = k * pitch * (1 + channel * 0.2);
+        if (f < rate / 2) sum += (Math.exp(-(((f - 650) / 420) ** 2)) + 0.45 * Math.exp(-(((f - 1700) / 520) ** 2)) + 0.04) * Math.sin(TAU2 * f * t + phase * k);
+      }
+      return sum * 0.5 + 0.01 * noise;
+    });
+  }
+  /** Rössler attractor sampled from a noise-chosen start; `value` per series holds x, y and z. */
+  static attractor(seed = 1, samples = 1600, channels = 2) {
+    const [{ noise }] = this.noise(seed, 8, 1);
+    let [x, y, z] = [1 + noise[0] * 0.3, 1 + noise[1] * 0.3, 0.1];
+    const dt = 0.03, trail = [];
+    const flow = (a, b, c) => [-b - c, a + 0.2 * b, 0.2 + c * (a - 5.7)];
+    for (let i = 0; i < samples + 600; i++) {
+      const k1 = flow(x, y, z), k2 = flow(x + dt / 2 * k1[0], y + dt / 2 * k1[1], z + dt / 2 * k1[2]);
+      const k3 = flow(x + dt / 2 * k2[0], y + dt / 2 * k2[1], z + dt / 2 * k2[2]), k4 = flow(x + dt * k3[0], y + dt * k3[1], z + dt * k3[2]);
+      x += dt / 6 * (k1[0] + 2 * k2[0] + 2 * k3[0] + k4[0]);
+      y += dt / 6 * (k1[1] + 2 * k2[1] + 2 * k3[1] + k4[1]);
+      z += dt / 6 * (k1[2] + 2 * k2[2] + 2 * k3[2] + k4[2]);
+      if (i >= 600) trail.push([x, y, z]);
+    }
+    return ["x", "y", "z"].slice(0, channels).flatMap((series, axis) => trail.map((point, i) => ({ t: +(i * dt).toFixed(3), series, value: +point[axis].toFixed(4) })));
+  }
+  /**
+   * `{ angle, gain, cut }`: gain in dBi every 2 degrees round the E-plane and H-plane of a small array of patch elements, boresight at 0.
+   * Each cut is a uniform array factor at half-wave spacing times an element pattern that leaks a little to the rear, with the walk's noise as ripple.
+   */
+  static antenna(seed = 1) {
+    const elements = [5 + seed % 4, 2 + seed % 2], peak = 10 * Math.log10(elements[0] * elements[1] * 3.2);
+    return this.noise(seed, 180, 2).flatMap(({ noise }, cut) => noise.map((ripple, i) => {
+      const angle = -180 + i * 2, theta = angle * Math.PI / 180, count = elements[cut], phase = Math.PI * Math.sin(theta) / 2;
+      const array = Math.abs(Math.sin(phase)) < 1e-9 ? 1 : (Math.sin(count * phase) / (count * Math.sin(phase))) ** 2;
+      const element = (0.92 * ((1 + Math.cos(theta)) / 2) ** 1.5 + 0.08) ** 2;
+      return { angle, cut: cut ? "H-plane" : "E-plane", gain: +(peak + 10 * Math.log10(array * element + 10 ** -4.5) + 0.12 * ripple).toFixed(2) };
+    }));
+  }
+};
+
+// src/charts/signals/AntennaPatternChart.ts
+var AntennaPatternForm = /* @__PURE__ */ ((AntennaPatternForm2) => {
+  AntennaPatternForm2["Polar"] = "polar";
+  AntennaPatternForm2["Rectangular"] = "rectangular";
+  return AntennaPatternForm2;
+})(AntennaPatternForm || {});
+var RAD = Math.PI / 180;
+var CHAR = 5.7;
+var ROW = 12;
+var DOT = 4;
+var PROMINENCE = 1;
+var HALF_POWER = 3;
+var RING_LABELS_AT = 105;
+var LEAST_PLOT = 190;
+var RIM = 34;
+var wrap = (angle) => ((angle + 180) % 360 + 360) % 360 - 180;
+var degrees = (angle) => `${+wrap(angle).toFixed(1)}\xB0`;
+var AntennaPatternChart = (_class2 = class _AntennaPatternChart extends _chunkEEF5WRRZcjs.Chart2D {
+  static __initStatic() {this.meta = {
+    id: "signal-antenna-pattern",
+    name: "Antenna radiation pattern",
+    family: "scientific" /* Scientific */,
+    dimension: 2 /* Two */,
+    shape: "table" /* Table */,
+    description: "Plots antenna gain in dB against angle for one or more cuts, normalised to the peak, on a polar or a rectangular plot, with the main lobe, half-power beamwidth, first side-lobe level and front-to-back ratio marked.",
+    tags: ["antenna", "rf", "radiation pattern", "beamwidth", "side lobe", "front-to-back", "e-plane", "h-plane", "polar"],
+    sample: (seed) => SignalSamples.antenna(seed),
+    variants: {
+      form: Object.values(AntennaPatternForm),
+      amplitude: Object.values(SignalAmplitude),
+      normalize: [true, false],
+      metrics: [true, false]
+    }
+  }}
+  defaults() {
+    return { x: "angle", y: "gain", series: "cut", form: "polar" /* Polar */, amplitude: "decibel" /* Decibel */, normalize: true, metrics: true, range: 40 };
+  }
+  plotMargin() {
+    return { top: 8, right: 12, bottom: 8, left: 12 };
+  }
+  /** True when sorted angles go all the way round, leaving no gap wider than their usual step. */
+  static closed(angles) {
+    const n = angles.length;
+    return n > 2 && 360 - (angles[n - 1] - angles[0]) <= 1.5 * (angles[n - 1] - angles[0]) / (n - 1);
+  }
+  /** Gain at `angle`, read between the two nearest samples and across the seam of a cut that goes all the way round. `null` outside an open cut. */
+  static gainAt(angles, gains, angle) {
+    const n = Math.min(angles.length, gains.length), after = angles.findIndex((value) => value >= angle), b = after < 0 ? 0 : after, a = (b + n - 1) % n;
+    if (!n) return null;
+    if (angles[b] === angle) return gains[b];
+    if (after <= 0 && !_AntennaPatternChart.closed(angles)) return null;
+    const from = angles[a] - (after === 0 ? 360 : 0), to = angles[b] + (after < 0 ? 360 : 0);
+    return gains[a] + (gains[b] - gains[a]) * (angle - from) / (to - from || 1);
+  }
+  /**
+   * Peak, half-power points, first side lobe and front-to-back ratio of a cut whose `angles` are sorted, in degrees from -180.
+   * Each side is walked out from the peak: to the first sample 3 dB down, then past the first null to the next maximum.
+   */
+  static metrics(angles, gains) {
+    const n = Math.min(angles.length, gains.length), closed = _AntennaPatternChart.closed(angles);
+    if (!n) return null;
+    let top = 0;
+    for (let i = 1; i < n; i++) if (gains[i] > gains[top]) top = i;
+    const peak = gains[top], reach = closed ? Math.floor(n / 2) : n - 1;
+    const has = (k) => closed || top + k >= 0 && top + k < n, gain = (k) => gains[((top + k) % n + n) % n];
+    const angle = (k) => angles[((top + k) % n + n) % n] + 360 * Math.floor((top + k) / n);
+    const edge = (side) => {
+      for (let k = 1; k <= reach && has(side * k); k++) {
+        if (gain(side * k) > peak - HALF_POWER) continue;
+        const before = gain(side * (k - 1)), t = (before - (peak - HALF_POWER)) / (before - gain(side * k));
+        return angle(side * (k - 1)) + (angle(side * k) - angle(side * (k - 1))) * t;
+      }
+      return null;
+    };
+    const lobe = (side) => {
+      let low = peak, best = 0;
+      for (let k = 1; k <= reach && has(side * k); k++) {
+        const here = gain(side * k);
+        if (!best) {
+          if (here < low) low = here;
+          else if (low <= peak - HALF_POWER && here > low + PROMINENCE) best = k;
+        } else if (here > gain(side * best)) best = k;
+        else if (here < gain(side * best) - PROMINENCE) break;
+      }
+      return best ? [{ angle: wrap(angle(side * best)), level: gain(side * best) - peak }] : [];
+    };
+    const left = edge(-1), right = edge(1), behind = wrap(angles[top] + 180), rear = _AntennaPatternChart.gainAt(angles, gains, behind);
+    return {
+      peak,
+      peakAngle: angles[top],
+      halfPower: left === null || right === null ? null : [left, right],
+      sideLobe: _nullishCoalesce([...lobe(-1), ...lobe(1)].sort((a, b) => b.level - a.level)[0], () => ( null)),
+      back: rear === null ? null : { angle: behind, ratio: peak - rear }
+    };
+  }
+  /** One cut per name, in the order the names first appear. */
+  get cuts() {
+    const { data, x, y, series } = this.options;
+    const rows = (Array.isArray(data) ? data : []).flatMap((row) => {
+      const cell = row === null || typeof row !== "object" ? null : row[x], turned = typeof cell === "number" || typeof cell === "string" && cell.trim() ? +cell : NaN;
+      return Number.isFinite(turned) ? [{ angle: wrap(turned), gain: row[y], cut: _nullishCoalesce(row[series], () => ( "Pattern")) }] : [];
+    });
+    return SignalParser.channels(rows, "angle", "gain", "cut").flatMap(({ name, t, v }) => {
+      const metrics = _AntennaPatternChart.metrics(t, v);
+      return metrics ? [{ name, angles: t, gains: v, closed: _AntennaPatternChart.closed(t), metrics }] : [];
+    });
+  }
+  /** Maps gain onto 0 to 1 from the bottom of the scale to its top, with the levels to rule and label. */
+  #levels(cuts) {
+    const { amplitude, normalize, range } = this.options;
+    const peak = cuts.length ? Math.max(...cuts.map((cut) => cut.metrics.peak)) : 0, base = normalize ? peak : 0;
+    const clamp = (value) => Math.max(0, Math.min(1, value));
+    if (amplitude === "linear" /* Linear */) {
+      const scale = _d3.scaleLinear.call(void 0, [0, normalize ? 1 : 10 ** (peak / 10)], [0, 1]);
+      if (!normalize) scale.nice(4);
+      return { unit: (gain) => clamp(scale(10 ** ((gain - base) / 10))), ticks: scale.ticks(4).map((tick) => ({ at: scale(tick), text: SignalScales.number(tick) })) };
+    }
+    const span = Math.max(5, Number.isFinite(range) ? range : 40), top = normalize ? 0 : Math.ceil(peak / 10) * 10, step = span <= 20 ? 5 : span <= 60 ? 10 : 20;
+    const ticks = Array.from({ length: Math.floor(span / step) + 1 }, (_, i) => ({ at: 1 - i * step / span, text: `${top - i * step}${i ? "" : " dB"}` }));
+    return { unit: (gain) => clamp((gain - base - (top - span)) / span), ticks };
+  }
+  draw(ctx) {
+    const cuts = this.cuts, levels = this.#levels(cuts), polar = this.options.form === "polar" /* Polar */, { width, height } = ctx.plot;
+    for (const cut of cuts) ctx.palette.color(cut.name);
+    const blocks = this.options.metrics ? cuts.map((cut) => [cut.name, ..._AntennaPatternChart.#figures(cut).map(([name, value]) => `${name} ${value}`)]) : [];
+    const column = Math.max(0, ...blocks.flat().map((line2) => _chunkEEF5WRRZcjs.TextFit.width(line2, CHAR))) + 16, listed = blocks.length > 0 && width - column >= LEAST_PLOT;
+    const wide = listed ? width - column : width, slack = listed && polar ? Math.max(0, wide - 2 * _AntennaPatternChart.#radius(wide, height) - 2 * RIM) : 0;
+    const room = { x: slack / 2, y: 0, width: wide - slack, height };
+    const frame = polar ? this.#dial(ctx, levels, room) : this.#axes(ctx, levels, cuts, room);
+    if (polar) this.#axes(ctx, levels, cuts, room, true);
+    else this.#dial(ctx, levels, room, true);
+    this.#marks(ctx, cuts, levels, frame);
+    let y = 10;
+    const lines = (listed ? blocks : []).flatMap((block, i) => {
+      if (y + block.length * ROW > height + 4) return [];
+      const placed = block.map((text, row) => ({ key: `${i}/${row}`, text, x: room.x + room.width + 14, y: y + row * ROW, anchor: "start", bold: !row, listed: true }));
+      y += block.length * ROW + 8;
+      return placed;
+    });
+    this.#write(ctx, "axis-figures", lines);
+  }
+  /** The largest dial that leaves room for its angle labels. */
+  static #radius(width, height) {
+    return Math.max(8, Math.min(width / 2 - RIM, height / 2 - 18));
+  }
+  static #figures({ metrics }) {
+    return [
+      ["Peak", `${metrics.peak.toFixed(1)} dB at ${degrees(metrics.peakAngle)}`],
+      ...metrics.halfPower ? [["HPBW", `${(metrics.halfPower[1] - metrics.halfPower[0]).toFixed(1)}\xB0`]] : [],
+      ...metrics.sideLobe ? [["SLL", `${metrics.sideLobe.level.toFixed(1)} dB`]] : [],
+      ...metrics.back ? [["F/B", `${metrics.back.ratio.toFixed(1)} dB`]] : []
+    ];
+  }
+  /** Text on a surface halo, so it stays legible over a cut. */
+  #write(ctx, name, labels) {
+    const { theme } = ctx;
+    const written = ctx.marks(name, "text", labels, (d) => d.key).attr("dy", (d) => d.listed ? null : "0.35em").attr("text-anchor", (d) => d.anchor).attr("font-weight", (d) => d.bold ? 600 : 400).attr("paint-order", "stroke").attr("stroke", theme.surface).attr("stroke-width", 3).attr("stroke-linejoin", "round").style("pointer-events", "none").text((d) => d.text);
+    ctx.text(written, 10).attr("fill", (d) => d.bold ? theme.ink : d.muted ? theme.inkMuted : theme.inkSecondary);
+    ctx.set(written, { x: (d) => d.x, y: (d) => d.y });
+  }
+  /** Rings, spokes and angle labels of the polar form. `clear` draws none, which removes what the other form left. */
+  #dial(ctx, levels, { x: start, width, height }, clear = false) {
+    const { theme } = ctx, cx = start + width / 2, cy = height / 2, radius = _AntennaPatternChart.#radius(width, height);
+    const turn = radius >= 70 ? 30 : radius >= 36 ? 45 : 90;
+    const around = (angle, r) => [cx + r * Math.sin(angle * RAD), cy - r * Math.cos(angle * RAD)];
+    const rings = clear ? [] : levels.ticks.filter((tick) => tick.at > 0), spokes = clear ? [] : Array.from({ length: 360 / turn }, (_, i) => -180 + turn + i * turn);
+    const circles = ctx.marks("axis-rings", "circle", rings, (d) => d.text).attr("fill", "none").attr("stroke", (d) => d.at === 1 ? theme.axis : theme.grid).attr("stroke-width", 1);
+    ctx.set(circles, { cx, cy, r: (d) => radius * d.at });
+    const lines = ctx.marks("axis-spokes", "line", spokes, (d) => d).attr("stroke", theme.grid).attr("stroke-width", 1);
+    ctx.set(lines, { x1: cx, y1: cy, x2: (d) => around(d, radius)[0], y2: (d) => around(d, radius)[1] });
+    const side = (angle) => Math.sin(angle * RAD) > 0.2 ? "start" : Math.sin(angle * RAD) < -0.2 ? "end" : "middle";
+    const named = spokes.map((angle) => ({ angle, text: `${angle}\xB0`, anchor: side(angle), at: around(angle, radius + 9) }));
+    const angles = ctx.text(ctx.marks("axis-angles", "text", named, (d) => d.angle)).attr("dy", "0.35em").attr("text-anchor", (d) => d.anchor).text((d) => d.text);
+    ctx.set(angles, { x: (d) => d.at[0], y: (d) => d.at[1] });
+    const gap = rings.length > 1 ? radius * (rings[0].at - rings[1].at) : radius, every = Math.max(1, Math.ceil((Math.max(0, ...rings.map((ring) => _chunkEEF5WRRZcjs.TextFit.width(ring.text, CHAR))) + 5) / gap));
+    const scale = ctx.text(ctx.marks("axis-levels", "text", rings.filter((ring, i) => i % every === 0 && radius * ring.at - _chunkEEF5WRRZcjs.TextFit.width(ring.text, CHAR) >= 6), (d) => d.text), 10, "muted").attr("dy", "0.35em").attr("text-anchor", "end").attr("paint-order", "stroke").attr("stroke", theme.surface).attr("stroke-width", 3).attr("stroke-linejoin", "round").text((d) => d.text);
+    ctx.set(scale, { x: (d) => around(RING_LABELS_AT, radius * d.at)[0] - 2, y: (d) => around(RING_LABELS_AT, radius * d.at)[1] });
+    return {
+      round: true,
+      point: (angle, level) => around(angle, radius * level),
+      tag: (angle, level) => {
+        const [x, y] = around(angle, Math.max(radius * level, radius * 0.24) + 11), anchor = side(angle);
+        return { x, y: y + (anchor === "middle" ? Math.cos(angle * RAD) > 0 ? -2 : 3 : 0), anchor };
+      },
+      beam: (edge, level, away) => {
+        const reach = Math.max(12, radius * Math.min(level, 0.78)), [x, y] = around(edge + away * 9 / (reach * RAD), reach), from = around(edge, reach)[0];
+        return { x, y, anchor: x > from + 1 ? "start" : x < from - 1 ? "end" : "middle" };
+      }
+    };
+  }
+  /** Level rules and the angle axis of the rectangular form. `clear` draws none, which removes what the other form left. */
+  #axes(ctx, levels, cuts, { x: start, width, height }, clear = false) {
+    const { theme } = ctx;
+    const left = start + Math.max(24, ...levels.ticks.map((tick) => _chunkEEF5WRRZcjs.TextFit.width(tick.text, 6.2) + 10)), right = start + width - 10, top = 6, bottom = Math.max(top + 10, height - 18);
+    const seen = cuts.flatMap((cut) => [cut.angles[0], cut.angles[cut.angles.length - 1]]);
+    let [low, high] = !cuts.length || cuts.some((cut) => cut.closed) ? [-180, 180] : [Math.min(...seen), Math.max(...seen)];
+    if (low === high) [low, high] = [low - 1, high + 1];
+    const x = _d3.scaleLinear.call(void 0, [low, high], [left, Math.max(left + 10, right)]), y = (level) => bottom - level * (bottom - top);
+    const step = _nullishCoalesce([30, 45, 60, 90, 180].find((size) => (x(high) - x(low)) * size / (high - low) >= 36), () => ( 360));
+    const ticks = clear ? [] : Array.from({ length: Math.floor(high / step) - Math.ceil(low / step) + 1 }, (_, i) => (Math.ceil(low / step) + i) * step);
+    const ruled = clear ? [] : levels.ticks;
+    const rules = ctx.marks("axis-rules", "line", ruled, (d) => d.text).attr("stroke", theme.grid).attr("stroke-width", 1);
+    ctx.set(rules, { x1: left, x2: x(high), y1: (d) => y(d.at), y2: (d) => y(d.at) });
+    const base = ctx.marks("axis-base", "line", clear ? [] : [0]).attr("stroke", theme.axis).attr("stroke-width", 1);
+    ctx.set(base, { x1: left, x2: x(high), y1: bottom, y2: bottom });
+    const levelText = ctx.text(ctx.marks("axis-level-ticks", "text", ruled, (d) => d.text)).attr("dy", "0.32em").attr("text-anchor", "end").text((d) => d.text);
+    ctx.set(levelText, { x: left - 6, y: (d) => y(d.at) });
+    const angleText = ctx.text(ctx.marks("axis-angle-ticks", "text", ticks, (d) => d)).attr("text-anchor", "middle").text((d) => `${d}\xB0`);
+    ctx.set(angleText, { x: (d) => x(d), y: bottom + 14 });
+    const across = (angle) => x(Math.max(low, Math.min(high, angle > high || angle < low ? wrap(angle) : angle)));
+    return {
+      round: false,
+      point: (angle, level) => [across(angle), y(level)],
+      tag: (angle, level, wide) => ({ x: Math.max(left + wide / 2 + 2, Math.min(x(high) - wide / 2 - 2, across(angle))), y: Math.max(top + 6, y(level) - 12), anchor: "middle" }),
+      beam: (edge, level, away) => ({ x: across(edge) + away * 9, y: y(level), anchor: away > 0 ? "start" : "end" })
+    };
+  }
+  #marks(ctx, cuts, levels, frame) {
+    const { theme, palette } = ctx;
+    const traced = cuts.map((cut) => {
+      const edge = !frame.round && cut.closed ? _AntennaPatternChart.gainAt(cut.angles, cut.gains, -180) : null;
+      const run = cut.angles.map((angle, i) => [angle, cut.gains[i]]);
+      const whole = edge === null ? run : [...run[0][0] > -180 ? [[-180, edge]] : [], ...run, [180, edge]];
+      return { cut, points: whole.map(([angle, gain]) => frame.point(angle, levels.unit(gain))) };
+    });
+    const outline = (points, shut) => points.length ? `M${points.map(([x, y]) => `${x.toFixed(2)},${y.toFixed(2)}`).join("L")}${shut ? "Z" : ""}` : "";
+    const lead = this.options.metrics ? cuts[0] : void 0, found = _optionalChain([lead, 'optionalAccess', _9 => _9.metrics]), tint = lead ? palette.color(lead.name) : null;
+    const halfPower = levels.unit((_nullishCoalesce(_optionalChain([found, 'optionalAccess', _10 => _10.peak]), () => ( 0))) - HALF_POWER), [from, to] = _nullishCoalesce(_optionalChain([found, 'optionalAccess', _11 => _11.halfPower]), () => ( [0, 0]));
+    const guides = !_optionalChain([found, 'optionalAccess', _12 => _12.halfPower]) ? [] : [
+      ...frame.round || wrap(from) < wrap(to) ? [{ key: "arc", d: outline(Array.from({ length: 25 }, (_, i) => frame.point(from + (to - from) * i / 24, halfPower)), false) }] : [],
+      ...[from, to].map((angle, i) => ({ key: `edge-${i}`, d: outline([frame.point(angle, 0), frame.point(angle, halfPower)], false) }))
+    ];
+    const beams = ctx.marks("axis-beam", "path", guides, (d) => d.key).attr("fill", "none").attr("stroke", theme.inkMuted).attr("stroke-width", 1).attr("stroke-dasharray", (d) => d.key === "arc" ? null : "3 3");
+    ctx.set(beams, { d: (d) => d.d });
+    const paths = ctx.marks("cuts", "path", traced.filter((entry) => entry.points.length > 1), (d) => d.cut.name).attr("fill", "none").attr("stroke", (d) => palette.color(d.cut.name)).attr("stroke-width", 2).attr("stroke-linejoin", "round").attr("stroke-linecap", "round");
+    ctx.set(paths, { d: (d) => outline(d.points, frame.round && d.cut.closed) });
+    ctx.drawOn(paths);
+    ctx.hover(paths, (d) => ({ title: d.cut.name, color: palette.color(d.cut.name), rows: _AntennaPatternChart.#figures(d.cut) }));
+    const lone = ctx.marks("single", "circle", traced.filter((entry) => entry.points.length === 1 && entry.cut !== lead), (d) => d.cut.name).attr("fill", (d) => palette.color(d.cut.name)).attr("stroke", theme.surface).attr("stroke-width", 2);
+    ctx.set(lone, { cx: (d) => d.points[0][0], cy: (d) => d.points[0][1], r: DOT }, { r: 0 });
+    ctx.hover(lone, (d) => ({ title: d.cut.name, color: palette.color(d.cut.name), rows: _AntennaPatternChart.#figures(d.cut) }));
+    const read = (value) => `${value.toFixed(1)} dB`;
+    const spots = !found ? [] : [
+      { key: "peak", angle: found.peakAngle, gain: found.peak, name: "Main lobe", text: "", value: `${read(found.peak)} at ${degrees(found.peakAngle)}` },
+      ...(_nullishCoalesce(found.halfPower, () => ( []))).map((angle, i) => ({ key: `half-${i}`, angle, gain: found.peak - HALF_POWER, name: "Half power", text: "", value: degrees(angle) })),
+      ...found.sideLobe ? [{ key: "side", angle: found.sideLobe.angle, gain: found.peak + found.sideLobe.level, name: "First side lobe", text: "SLL", value: `${read(found.sideLobe.level)} at ${degrees(found.sideLobe.angle)}` }] : [],
+      ...found.back ? [{ key: "back", angle: found.back.angle, gain: found.peak - found.back.ratio, name: "Front to back", text: "F/B", value: read(found.back.ratio) }] : []
+    ].map((spot) => ({ ...spot, at: frame.point(spot.angle, levels.unit(spot.gain)), tag: frame.tag(spot.angle, levels.unit(spot.gain), _chunkEEF5WRRZcjs.TextFit.width(spot.text, CHAR)) }));
+    const dots = ctx.marks("markers", "circle", spots, (d) => d.key).attr("fill", tint).attr("stroke", theme.surface).attr("stroke-width", 2);
+    ctx.set(dots, { cx: (d) => d.at[0], cy: (d) => d.at[1], r: (d) => d.key.startsWith("half") ? DOT - 1 : DOT }, { r: 0 }, 30);
+    ctx.hover(dots, (d) => ({ title: d.name, color: _nullishCoalesce(tint, () => ( void 0)), rows: [[lead.name, d.value]] }));
+    const tagged = spots.filter((spot) => spot.text);
+    const leaders = !frame.round ? [] : tagged.flatMap((spot) => {
+      const far = Math.hypot(spot.tag.x - spot.at[0], spot.tag.y - spot.at[1]), along = (t) => [spot.at[0] + (spot.tag.x - spot.at[0]) * t, spot.at[1] + (spot.tag.y - spot.at[1]) * t];
+      return far > 24 ? [{ key: spot.key, from: along(7 / far), to: along(1 - 10 / far) }] : [];
+    });
+    const tails = ctx.marks("axis-leaders", "line", leaders, (d) => d.key).attr("stroke", theme.axis).attr("stroke-width", 1);
+    ctx.set(tails, { x1: (d) => d.from[0], y1: (d) => d.from[1], x2: (d) => d.to[0], y2: (d) => d.to[1] });
+    const sideLobe = _optionalChain([found, 'optionalAccess', _13 => _13.sideLobe]) ? wrap(found.sideLobe.angle - found.peakAngle) : -1;
+    this.#write(ctx, "axis-tags", [
+      ...tagged.map((spot) => ({ key: spot.key, text: spot.text, ...spot.tag })),
+      ..._optionalChain([found, 'optionalAccess', _14 => _14.halfPower]) ? [{ key: "beam", text: "HPBW", ...sideLobe > 0 ? frame.beam(from, halfPower, -1) : frame.beam(to, halfPower, 1) }] : [],
+      ...cuts.length ? [] : [{ key: "empty", text: "No pattern", x: 4, y: 12, anchor: "start", muted: true }]
+    ]);
+  }
+}, _class2.__initStatic(), _class2);
+
 // src/charts/signals/AudiogramChart.ts
+
 var AudiogramLayout = /* @__PURE__ */ ((AudiogramLayout2) => {
   AudiogramLayout2["Combined"] = "combined";
   AudiogramLayout2["Separate"] = "separate-ears";
@@ -547,8 +900,8 @@ var FREQUENCIES = [250, 500, 1e3, 2e3, 4e3, 8e3];
 var ZONES = [[-10, 25, "Normal"], [25, 40, "Mild"], [40, 70, "Moderate"], [70, 90, "Severe"], [90, 120, "Profound"]];
 var BANANA = [[250, 28, 48], [500, 22, 52], [1e3, 20, 55], [2e3, 22, 58], [4e3, 28, 55], [6e3, 34, 48]];
 var GUTTER = 22;
-var AudiogramChart = (_class2 = class extends SignalChart {
-  static __initStatic() {this.meta = {
+var AudiogramChart = (_class3 = class extends SignalChart {
+  static __initStatic2() {this.meta = {
     id: "signal-audiogram",
     name: "Audiogram",
     family: "scientific" /* Scientific */,
@@ -557,7 +910,7 @@ var AudiogramChart = (_class2 = class extends SignalChart {
     description: "Plots hearing thresholds per ear against test frequency, with hearing level increasing downward.",
     tags: ["hearing", "audiometry", "dB HL", "speech banana"],
     sample: (seed) => {
-      const rows = _chunkUMEKIIHJcjs.SampleData.categories(seed, 6, 4), slope = [8, 10, 16, 28, 48, 62];
+      const rows = _chunkLNWTC72Ycjs.SampleData.categories(seed, 6, 4), slope = [8, 10, 16, 28, 48, 62];
       return rows.map((row, i) => {
         const at = Math.floor(i / 4), kind = i % 4, ear = kind % 2 ? "Left" : "Right", bone = kind > 1;
         const level = slope[at] + (kind % 2 ? 6 : 0) - (bone ? Math.min(slope[at] * 0.4, 18) : 0) + (+row.value - 60) / 80 * 10;
@@ -659,84 +1012,14 @@ var AudiogramChart = (_class2 = class extends SignalChart {
   }
   connect(ctx, inner, key, list, x, y) {
     const ordered = [...list].sort((a, b) => a.freq - b.freq);
-    if (_optionalChain([ordered, 'access', _9 => _9[0], 'optionalAccess', _10 => _10.bone])) return;
+    if (_optionalChain([ordered, 'access', _15 => _15[0], 'optionalAccess', _16 => _16.bone])) return;
     const line2 = this.stroke(inner, `air-${key.replace(/\W/g, "")}`, [ordered], () => key, (items) => this.path(items.map((item) => [item.freq, item.level]), x, y), () => ctx.palette.color(ordered[0].ear), 2);
     line2.attr("opacity", 0.9);
   }
-}, _class2.__initStatic(), _class2);
+}, _class3.__initStatic2(), _class3);
 
 // src/charts/signals/CepstrumChart.ts
 
-
-// src/charts/signals/SignalSamples.ts
-var TAU2 = Math.PI * 2;
-var SignalSamples = class {
-  /** Zero-mean, unit-variance noise per series, from the steps of a random walk. */
-  static noise(seed, samples, channels) {
-    const rows = _chunkUMEKIIHJcjs.SampleData.timeSeries(seed, samples + 1, channels), names = [...new Set(rows.map((row) => String(row.series)))];
-    return names.map((name) => {
-      const walk = rows.filter((row) => row.series === name).map((row) => +row.value);
-      const steps = walk.slice(1).map((value, i) => value - walk[i]), mean2 = steps.reduce((sum, step) => sum + step, 0) / steps.length;
-      const deviation = Math.sqrt(steps.reduce((sum, step) => sum + (step - mean2) ** 2, 0) / steps.length) || 1;
-      return { name, noise: steps.map((step) => (step - mean2) / deviation) };
-    });
-  }
-  static rows(seed, samples, channels, rate, shape) {
-    return this.noise(seed, samples, channels).flatMap(({ name, noise }, channel) => {
-      const phase = Math.abs(noise[0]) % TAU2;
-      return noise.map((step, i) => ({ t: +(i / rate).toFixed(6), series: name, value: +shape(i / rate, channel, step, phase).toFixed(5) }));
-    });
-  }
-  /** Plucked notes with harmonics, in a phrase: the demo for waveforms and spectra. */
-  static notes(seed = 1, samples = 2048, channels = 2, rate = 8e3) {
-    const duration = samples / rate, starts = [0, 0.22, 0.47, 0.68].map((start) => start * duration);
-    return this.rows(seed, samples, channels, rate, (t, channel, noise, phase) => {
-      const note = starts.reduce((held, start, i) => t >= start ? i : held, 0), since = t - starts[note];
-      const pitch = (220 + 45 * channel) * [1, 1.5, 1.25, 2][note];
-      const tone = Math.sin(TAU2 * pitch * t + phase) + 0.5 * Math.sin(TAU2 * 2 * pitch * t) + 0.25 * Math.sin(TAU2 * 3 * pitch * t + phase);
-      return (0.82 - channel * 0.22) * Math.exp(-since * 14 / duration * 0.5) * Math.min(1, since * 400) * tone * 0.58 + 2e-3 * noise;
-    });
-  }
-  /** A rising chirp, a steady tone and a click: shows off time-frequency views. */
-  static chirp(seed = 1, samples = 4096, channels = 1, rate = 8e3) {
-    const duration = samples / rate;
-    return this.rows(seed, samples, channels, rate, (t, channel, noise, phase) => {
-      const x = t / duration, sweep = 150 * t + 1500 * t * t / (2 * duration);
-      const click = Math.exp(-(((x - 0.72) / 4e-3) ** 2)) * Math.sin(TAU2 * 2600 * t);
-      return 0.7 * Math.sin(TAU2 * sweep + phase + channel) * Math.sin(Math.PI * x) ** 0.5 + 0.28 * Math.sin(TAU2 * 900 * t) * (x > 0.15 && x < 0.55 ? 1 : 0) + 0.5 * click + 2e-3 * noise;
-    });
-  }
-  /** A pulse train with formant-like harmonics: a voiced sound with a clear pitch. */
-  static voiced(seed = 1, samples = 2048, channels = 1, rate = 8e3) {
-    const pitch = 142;
-    return this.rows(seed, samples, channels, rate, (t, channel, noise, phase) => {
-      let sum = 0;
-      for (let k = 1; k <= 36; k++) {
-        const f = k * pitch * (1 + channel * 0.2);
-        if (f < rate / 2) sum += (Math.exp(-(((f - 650) / 420) ** 2)) + 0.45 * Math.exp(-(((f - 1700) / 520) ** 2)) + 0.04) * Math.sin(TAU2 * f * t + phase * k);
-      }
-      return sum * 0.5 + 0.01 * noise;
-    });
-  }
-  /** Rössler attractor sampled from a noise-chosen start; `value` per series holds x, y and z. */
-  static attractor(seed = 1, samples = 1600, channels = 2) {
-    const [{ noise }] = this.noise(seed, 8, 1);
-    let [x, y, z] = [1 + noise[0] * 0.3, 1 + noise[1] * 0.3, 0.1];
-    const dt = 0.03, trail = [];
-    const flow = (a, b, c) => [-b - c, a + 0.2 * b, 0.2 + c * (a - 5.7)];
-    for (let i = 0; i < samples + 600; i++) {
-      const k1 = flow(x, y, z), k2 = flow(x + dt / 2 * k1[0], y + dt / 2 * k1[1], z + dt / 2 * k1[2]);
-      const k3 = flow(x + dt / 2 * k2[0], y + dt / 2 * k2[1], z + dt / 2 * k2[2]), k4 = flow(x + dt * k3[0], y + dt * k3[1], z + dt * k3[2]);
-      x += dt / 6 * (k1[0] + 2 * k2[0] + 2 * k3[0] + k4[0]);
-      y += dt / 6 * (k1[1] + 2 * k2[1] + 2 * k3[1] + k4[1]);
-      z += dt / 6 * (k1[2] + 2 * k2[2] + 2 * k3[2] + k4[2]);
-      if (i >= 600) trail.push([x, y, z]);
-    }
-    return ["x", "y", "z"].slice(0, channels).flatMap((series, axis) => trail.map((point, i) => ({ t: +(i * dt).toFixed(3), series, value: +point[axis].toFixed(4) })));
-  }
-};
-
-// src/charts/signals/CepstrumChart.ts
 var CepstrumKind = /* @__PURE__ */ ((CepstrumKind2) => {
   CepstrumKind2["Real"] = "real";
   CepstrumKind2["Power"] = "power";
@@ -753,8 +1036,8 @@ var CepstrumMark = /* @__PURE__ */ ((CepstrumMark2) => {
   CepstrumMark2["Stem"] = "stem";
   return CepstrumMark2;
 })(CepstrumMark || {});
-var CepstrumChart = (_class3 = class extends SignalChart {
-  static __initStatic2() {this.meta = {
+var CepstrumChart = (_class4 = class extends SignalChart {
+  static __initStatic3() {this.meta = {
     id: "signal-cepstrum",
     name: "Cepstrum",
     family: "scientific" /* Scientific */,
@@ -801,7 +1084,7 @@ var CepstrumChart = (_class3 = class extends SignalChart {
       const x = _d3.scaleLog.call(void 0, [low, high], [0, width]);
       return { x: SignalScales.labelled(x, SignalScales.sparse(x, low, high), SignalScales.hertz), y };
     }
-    return { x: _d3.scaleLinear.call(void 0, [_optionalChain([points, 'access', _11 => _11[0], 'optionalAccess', _12 => _12.quefrency]) * 1e3 || 0, (_nullishCoalesce(_optionalChain([points, 'access', _13 => _13[points.length - 1], 'optionalAccess', _14 => _14.quefrency]), () => ( 0.02))) * 1e3], [0, width]), y };
+    return { x: _d3.scaleLinear.call(void 0, [_optionalChain([points, 'access', _17 => _17[0], 'optionalAccess', _18 => _18.quefrency]) * 1e3 || 0, (_nullishCoalesce(_optionalChain([points, 'access', _19 => _19[points.length - 1], 'optionalAccess', _20 => _20.quefrency]), () => ( 0.02))) * 1e3], [0, width]), y };
   }
   plotMarks(ctx, { x, y }) {
     const { mark, lifter, pitchRange } = this.options, { width, height } = ctx.plot, base = y(0);
@@ -813,7 +1096,7 @@ var CepstrumChart = (_class3 = class extends SignalChart {
     }
     this.rule(ctx, "zero", [0], y);
     if (mark === "stem" /* Stem */) {
-      const stride = Math.max(1, Math.ceil((_nullishCoalesce(_optionalChain([traces, 'access', _15 => _15[0], 'optionalAccess', _16 => _16.points, 'access', _17 => _17.length]), () => ( 1))) / (width / 5)));
+      const stride = Math.max(1, Math.ceil((_nullishCoalesce(_optionalChain([traces, 'access', _21 => _21[0], 'optionalAccess', _22 => _22.points, 'access', _23 => _23.length]), () => ( 1))) / (width / 5)));
       const strongest = (points) => points.filter((_, i) => i % stride === 0).map((_, n) => points.slice(n * stride, (n + 1) * stride).reduce((best, point) => Math.abs(point.value) > Math.abs(best.value) ? point : best));
       const rods = traces.flatMap((trace) => strongest(trace.points).map((point) => ({ point, trace })));
       const marks = ctx.marks("rods", "line", rods, (rod) => `${rod.trace.name}${rod.point.key}`).attr("stroke", (rod) => rod.trace.color).attr("stroke-width", 2);
@@ -839,7 +1122,7 @@ var CepstrumChart = (_class3 = class extends SignalChart {
       ctx.text(ctx.marks("pitch-text", "text", [0]).attr("x", px + (flip ? -9 : 9)).attr("y", Math.max(11, py + 4)).attr("text-anchor", flip ? "end" : "start").text(`Pitch ${SignalScales.hertz(1 / top.quefrency)} Hz`), 11, "ink");
     }
   }
-}, _class3.__initStatic2(), _class3);
+}, _class4.__initStatic3(), _class4);
 
 // src/charts/signals/ECGChart.ts
 
@@ -866,8 +1149,8 @@ var LEADS = [["II", 1], ["I", 0.7], ["III", 0.45], ["aVR", -0.8], ["aVL", 0.3],
 var WAVES = [[-0.2, 0.024, 0.14], [-0.04, 9e-3, -0.14], [0, 0.011, 1.15], [0.04, 0.011, -0.24], [0.26, 0.05, 0.3]];
 var MINOR = 0.04;
 var RATE = 200;
-var ECGChart = (_class4 = class extends SignalChart {
-  static __initStatic3() {this.meta = {
+var ECGChart = (_class5 = class extends SignalChart {
+  static __initStatic4() {this.meta = {
     id: "signal-ecg",
     name: "ECG",
     family: "scientific" /* Scientific */,
@@ -1032,7 +1315,7 @@ var ECGChart = (_class4 = class extends SignalChart {
     ctx.set(dots, { cx: (pair) => x(pair.a), cy: (pair) => y(pair.b), r: 4.5 }, { r: 0 }, 20);
     ctx.hover(dots, (pair) => ({ title: "Successive beats", color, rows: [["RR\u2099", `${Math.round(pair.a)} ms`], ["RR\u2099\u208A\u2081", `${Math.round(pair.b)} ms`]] }));
   }
-}, _class4.__initStatic3(), _class4);
+}, _class5.__initStatic4(), _class5);
 
 // src/charts/signals/EnvelopeChart.ts
 
@@ -1049,8 +1332,8 @@ var EnvelopeShape = /* @__PURE__ */ ((EnvelopeShape2) => {
   return EnvelopeShape2;
 })(EnvelopeShape || {});
 var FLOOR = -60;
-var EnvelopeChart = (_class5 = class extends SignalChart {
-  static __initStatic4() {this.meta = {
+var EnvelopeChart = (_class6 = class extends SignalChart {
+  static __initStatic5() {this.meta = {
     id: "signal-envelope",
     name: "Signal envelope",
     family: "scientific" /* Scientific */,
@@ -1137,7 +1420,7 @@ var EnvelopeChart = (_class5 = class extends SignalChart {
     const span = marks[1].at - marks[0].at, flip = marks[1].at > ctx.plot.width - 90;
     if (span > 0) ctx.text(ctx.marks("decay-text", "text", [0]).attr("x", marks[1].at + (flip ? -8 : 8)).attr("y", Math.max(12, marks[1].height - 8)).attr("text-anchor", flip ? "end" : "start").text(`\u221220 dB in ${SignalScales.number(t[after] - t[top])} s`), 11, "ink");
   }
-}, _class5.__initStatic4(), _class5);
+}, _class6.__initStatic5(), _class6);
 
 // src/charts/signals/FilterResponseChart.ts
 
@@ -1205,8 +1488,8 @@ var chebyshev = (order, ripple) => {
   return butterworth(order).map(([re, im]) => [re * Math.sinh(mu), im * Math.cosh(mu)]);
 };
 var BESSEL = [[-0.6573, 0.8302], [-0.6573, -0.8302], [-0.9047, 0.2711], [-0.9047, -0.2711]].map(([re, im]) => [re * 1.2, im * 1.2]);
-var FilterResponseChart = (_class6 = class extends SignalChart {
-  static __initStatic5() {this.meta = {
+var FilterResponseChart = (_class7 = class extends SignalChart {
+  static __initStatic6() {this.meta = {
     id: "signal-filter-response",
     name: "Filter response",
     family: "scientific" /* Scientific */,
@@ -1215,7 +1498,7 @@ var FilterResponseChart = (_class6 = class extends SignalChart {
     description: "Shows the gain, phase and delay of a filter across frequency as a Bode plot, group delay or Nyquist diagram.",
     tags: ["bode", "nyquist", "group delay", "butterworth", "chebyshev"],
     sample: (seed) => {
-      const cutoff = 400 + +_chunkUMEKIIHJcjs.SampleData.categories(seed, 1, 1)[0].value * 6;
+      const cutoff = 400 + +_chunkLNWTC72Ycjs.SampleData.categories(seed, 1, 1)[0].value * 6;
       const designs = [["Butterworth", butterworth(4)], ["Chebyshev", chebyshev(4, 1)], ["Bessel", BESSEL]];
       return designs.flatMap(([series, poles]) => {
         const phase = unwrapped(Array.from({ length: SAMPLE_POINTS }, (_, i) => response(poles, 0.02 * 500 ** (i / (SAMPLE_POINTS - 1)))[1]));
@@ -1354,7 +1637,7 @@ var FilterResponseChart = (_class6 = class extends SignalChart {
   }
   /** One stop per plotted frequency of the first sweep, read across every sweep at its nearest frequency, as the probe reads it. */
   keyBins(sweeps, plotted, spot) {
-    const shown = _nullishCoalesce(_optionalChain([sweeps, 'access', _18 => _18[0], 'optionalAccess', _19 => _19.freq, 'access', _20 => _20.filter, 'call', _21 => _21(plotted)]), () => ( []));
+    const shown = _nullishCoalesce(_optionalChain([sweeps, 'access', _24 => _24[0], 'optionalAccess', _25 => _25.freq, 'access', _26 => _26.filter, 'call', _27 => _27(plotted)]), () => ( []));
     if (!shown.length) return;
     const nearest = (sweep, freq) => sweep.freq.reduce((best, value, i) => Math.abs(value - freq) < Math.abs(sweep.freq[best] - freq) ? i : best, 0);
     const filled = sweeps.filter((sweep) => sweep.freq.length);
@@ -1368,7 +1651,7 @@ var FilterResponseChart = (_class6 = class extends SignalChart {
   }
   cutoff(ctx, sweeps, x, y) {
     const first = sweeps[0];
-    if (!_optionalChain([first, 'optionalAccess', _22 => _22.freq, 'access', _23 => _23.length])) return;
+    if (!_optionalChain([first, 'optionalAccess', _28 => _28.freq, 'access', _29 => _29.length])) return;
     const reference = first.gain[0], hit = first.gain.findIndex((value) => value <= reference - 3);
     if (hit <= 0) return;
     const at = x(first.freq[hit]), bottom = y.range()[0];
@@ -1388,7 +1671,7 @@ var FilterResponseChart = (_class6 = class extends SignalChart {
     this.stroke(ctx, "curve", sweeps, (sweep) => sweep.name, (sweep) => this.path(points(sweep), x, y), (sweep) => ctx.palette.color(sweep.name));
     this.stroke(ctx, "mirror", sweeps, (sweep) => sweep.name, (sweep) => this.path(points(sweep).map(([re, im]) => [re, -im]), x, y), (sweep) => ctx.palette.color(sweep.name), 1).attr("stroke-dasharray", "3 3");
   }
-}, _class6.__initStatic5(), _class6);
+}, _class7.__initStatic6(), _class7);
 
 // src/charts/signals/ImpulseResponseChart.ts
 
@@ -1406,8 +1689,8 @@ var ImpulseMark = /* @__PURE__ */ ((ImpulseMark2) => {
 })(ImpulseMark || {});
 var FLOOR2 = -70;
 var STEMS = 48;
-var ImpulseResponseChart = (_class7 = class extends SignalChart {
-  static __initStatic6() {this.meta = {
+var ImpulseResponseChart = (_class8 = class extends SignalChart {
+  static __initStatic7() {this.meta = {
     id: "signal-impulse-response",
     name: "Impulse response",
     family: "scientific" /* Scientific */,
@@ -1521,7 +1804,7 @@ var ImpulseResponseChart = (_class7 = class extends SignalChart {
     ctx.set(dot, { cx: px, cy: py, r: 4 }, { r: 0 });
     ctx.text(ctx.marks("note-text", "text", [0]).attr("x", px + (flip ? -9 : 9)).attr("y", Math.max(11, Math.min(height - 5, py - 7))).attr("text-anchor", flip ? "end" : "start").text(label), 11, "ink");
   }
-}, _class7.__initStatic6(), _class7);
+}, _class8.__initStatic7(), _class8);
 
 // src/charts/signals/LogicAnalyzerChart.ts
 
@@ -1538,8 +1821,8 @@ var LogicEdge = /* @__PURE__ */ ((LogicEdge2) => {
 })(LogicEdge || {});
 var BUS = "Bus";
 var SAMPLE_BITS = ["CLK", "D0", "D1", "D2", "D3"];
-var LogicAnalyzerChart = (_class8 = class extends SignalChart {
-  static __initStatic7() {this.meta = {
+var LogicAnalyzerChart = (_class9 = class extends SignalChart {
+  static __initStatic8() {this.meta = {
     id: "signal-logic-analyzer",
     name: "Logic analyzer",
     family: "scientific" /* Scientific */,
@@ -1584,7 +1867,7 @@ var LogicAnalyzerChart = (_class8 = class extends SignalChart {
     times.forEach((start, i) => {
       const value = lines.reduce((sum, channel, bit) => {
         const run = this.runs(channel).find((item) => start >= item.start && start < item.end);
-        return sum + (_nullishCoalesce(_optionalChain([run, 'optionalAccess', _24 => _24.level]), () => ( 0))) * 2 ** bit;
+        return sum + (_nullishCoalesce(_optionalChain([run, 'optionalAccess', _30 => _30.level]), () => ( 0))) * 2 ** bit;
       }, 0);
       words.push({ key: `w${i}`, start, end: _nullishCoalesce(times[i + 1], () => ( this.span[1])), value });
     });
@@ -1614,7 +1897,7 @@ var LogicAnalyzerChart = (_class8 = class extends SignalChart {
     if (display !== "bus" /* Bus */) this.placeSample = (channel, i) => [x(channel.t[i]), (_nullishCoalesce(y(channel.name), () => ( 0))) + (channel.v[i] > this.options.threshold ? 0 : thick)];
     this.probe(ctx, (px) => {
       const time = x.invert(px);
-      const rows = this.channels.map((channel) => [channel.name, _nullishCoalesce(_optionalChain([this, 'access', _25 => _25.runs, 'call', _26 => _26(channel), 'access', _27 => _27.find, 'call', _28 => _28((run) => time >= run.start && time < run.end), 'optionalAccess', _29 => _29.level]), () => ( 0))]);
+      const rows = this.channels.map((channel) => [channel.name, _nullishCoalesce(_optionalChain([this, 'access', _31 => _31.runs, 'call', _32 => _32(channel), 'access', _33 => _33.find, 'call', _34 => _34((run) => time >= run.start && time < run.end), 'optionalAccess', _35 => _35.level]), () => ( 0))]);
       return { x: px, tip: { title: `${SignalScales.number(time)}`, rows }, datum: { t: time } };
     });
   }
@@ -1634,7 +1917,7 @@ var LogicAnalyzerChart = (_class8 = class extends SignalChart {
     const named = words.filter((word) => x(word.end) - x(word.start) > 15);
     ctx.marks("bus-text", "text", named, (word) => word.key).attr("x", (word) => (x(word.start) + x(word.end)) / 2).attr("y", middle + 4).attr("text-anchor", "middle").attr("font-size", 11).attr("font-family", ctx.theme.fontFamily).attr("fill", ctx.palette.inkOn(color)).text((word) => word.value.toString(16).toUpperCase());
   }
-}, _class8.__initStatic7(), _class8);
+}, _class9.__initStatic8(), _class9);
 
 // src/charts/signals/OscilloscopeChart.ts
 
@@ -1668,8 +1951,8 @@ var ceilStep = (value) => {
   return (_nullishCoalesce([1, 2, 5, 10].find((step) => step >= unit - 1e-9), () => ( 10))) * power;
 };
 var seconds = (value) => value >= 1 ? `${+value.toFixed(2)} s` : value >= 1e-3 ? `${+(value * 1e3).toFixed(2)} ms` : `${+(value * 1e6).toFixed(1)} \xB5s`;
-var OscilloscopeChart = (_class9 = class extends SignalChart {
-  static __initStatic8() {this.meta = {
+var OscilloscopeChart = (_class10 = class extends SignalChart {
+  static __initStatic9() {this.meta = {
     id: "signal-oscilloscope",
     name: "Oscilloscope",
     family: "scientific" /* Scientific */,
@@ -1797,7 +2080,7 @@ var OscilloscopeChart = (_class9 = class extends SignalChart {
   envelope(ctx, sweeps, x, y) {
     const names = [...new Set(sweeps.map((sweep) => sweep.name))];
     const bands = names.map((name) => {
-      const mine = sweeps.filter((sweep) => sweep.name === name), reference = _nullishCoalesce(_optionalChain([mine, 'access', _30 => _30[0], 'optionalAccess', _31 => _31.points]), () => ( []));
+      const mine = sweeps.filter((sweep) => sweep.name === name), reference = _nullishCoalesce(_optionalChain([mine, 'access', _36 => _36[0], 'optionalAccess', _37 => _37.points]), () => ( []));
       const rows = reference.map(([at]) => {
         const values = mine.map((sweep) => SignalDsp.interpolate(sweep.points.map((point) => point[0]), sweep.points.map((point) => point[1]), at));
         return { at, low: _d3.min.call(void 0, values), high: _d3.max.call(void 0, values) };
@@ -1816,7 +2099,7 @@ var OscilloscopeChart = (_class9 = class extends SignalChart {
     const points = Array.from({ length: span }, (_, i) => [ax[i], ay[i]]);
     this.stroke(ctx, "figure", [points], () => 0, (list) => this.path(list, x, y), () => ctx.palette.color(a.name), this.options.display === "persistence" /* Persistence */ ? 1 : 2);
   }
-}, _class9.__initStatic8(), _class9);
+}, _class10.__initStatic9(), _class10);
 
 // src/charts/signals/PeriodogramChart.ts
 
@@ -1851,8 +2134,8 @@ var PeriodogramAbscissa = /* @__PURE__ */ ((PeriodogramAbscissa2) => {
 })(PeriodogramAbscissa || {});
 var chiSquared = (dof, z) => dof * (1 - 2 / (9 * dof) + z * Math.sqrt(2 / (9 * dof))) ** 3;
 var CAP = 512;
-var PeriodogramChart = (_class10 = class extends SpectralChart {
-  static __initStatic9() {this.meta = {
+var PeriodogramChart = (_class11 = class extends SpectralChart {
+  static __initStatic10() {this.meta = {
     id: "signal-periodogram",
     name: "Periodogram",
     family: "scientific" /* Scientific */,
@@ -1936,7 +2219,7 @@ var PeriodogramChart = (_class10 = class extends SpectralChart {
     this.stroke(ctx, "trace", estimates, (estimate) => estimate.name, (estimate) => this.path(points(estimate).map((point) => [point.value, Math.max(floor, Math.min(top, point.level))]), x, y), (estimate) => estimate.color, 1.5);
     this.probe(ctx, (px) => {
       const at = x.invert(px), first = estimates[0];
-      if (!_optionalChain([first, 'optionalAccess', _32 => _32.x, 'access', _33 => _33.length])) return null;
+      if (!_optionalChain([first, 'optionalAccess', _38 => _38.x, 'access', _39 => _39.length])) return null;
       const nearest = first.x.reduce((best, value, i) => Math.abs(value - at) < Math.abs(first.x[best] - at) ? i : best, 0);
       return { x: x(first.x[nearest]), tip: { title: SignalScales.number(first.x[nearest]), rows: estimates.map((estimate) => [estimate.name, SignalScales.number(this.level(estimate.power[nearest]))]) }, datum: { x: first.x[nearest] } };
     });
@@ -1954,7 +2237,7 @@ var PeriodogramChart = (_class10 = class extends SpectralChart {
       return { title: period ? `${+(value * 1e3).toPrecision(3)} ms` : `${SignalScales.hertz(value)} Hz`, rows: all.map((estimate) => [estimate.name, SignalScales.number(this.level(estimate.power[at]))]) };
     }, (bin) => all.map((estimate) => [x(first.x[order[bin]]), clamp(this.level(estimate.power[order[bin]]))]));
   }
-}, _class10.__initStatic9(), _class10);
+}, _class11.__initStatic10(), _class11);
 
 // src/charts/signals/PhaseSpace3DChart.ts
 
@@ -1990,8 +2273,8 @@ var Phase3DStyle = /* @__PURE__ */ ((Phase3DStyle2) => {
 })(Phase3DStyle || {});
 var MAX_STEPS = 900;
 var FLOOR3 = -0.82;
-var PhaseSpace3DChart = (_class11 = class extends _chunk6KYVL5HYcjs.Chart3D {
-  static __initStatic10() {this.meta = {
+var PhaseSpace3DChart = (_class12 = class extends _chunk6KYVL5HYcjs.Chart3D {
+  static __initStatic11() {this.meta = {
     id: "signal-phase-space-3d",
     name: "3D phase space",
     family: "scientific" /* Scientific */,
@@ -2094,7 +2377,7 @@ var PhaseSpace3DChart = (_class11 = class extends _chunk6KYVL5HYcjs.Chart3D {
       holder.rotation.y = Math.sin(seconds2 * 0.2) * 0.06;
     });
   }
-}, _class11.__initStatic10(), _class11);
+}, _class12.__initStatic11(), _class12);
 
 // src/charts/signals/PhaseSpaceChart.ts
 var _d3hexbin = require('d3-hexbin');
@@ -2113,8 +2396,8 @@ var PhaseMark = /* @__PURE__ */ ((PhaseMark2) => {
 })(PhaseMark || {});
 var SEGMENTS = 24;
 var POINTS = 180;
-var PhaseSpaceChart = (_class12 = class extends SignalChart {
-  static __initStatic11() {this.meta = {
+var PhaseSpaceChart = (_class13 = class extends SignalChart {
+  static __initStatic12() {this.meta = {
     id: "signal-phase-space",
     name: "Phase space plot",
     family: "scientific" /* Scientific */,
@@ -2143,7 +2426,7 @@ var PhaseSpaceChart = (_class12 = class extends SignalChart {
     return false;
   }
   get points() {
-    const { coordinates, delay } = this.options, { v, rate } = this.first, b = _optionalChain([this, 'access', _34 => _34.channels, 'access', _35 => _35[1], 'optionalAccess', _36 => _36.v]);
+    const { coordinates, delay } = this.options, { v, rate } = this.first, b = _optionalChain([this, 'access', _40 => _40.channels, 'access', _41 => _41[1], 'optionalAccess', _42 => _42.v]);
     if (coordinates === "channels" /* Channels */ && b) return v.slice(0, b.length).map((value, i) => [value, b[i]]);
     if (coordinates === "derivative" /* Derivative */) return v.slice(1, -1).map((value, i) => [value, (v[i + 2] - v[i]) * rate / 2]);
     return v.slice(0, Math.max(0, v.length - delay)).map((value, i) => [value, v[i + delay]]);
@@ -2190,7 +2473,7 @@ var PhaseSpaceChart = (_class12 = class extends SignalChart {
     ctx.set(dots, { cx: x(at), cy: (hit) => y(hit.y), r: 4 }, { r: 0 }, 8);
     ctx.hover(dots, (hit) => ({ title: "Section crossing", rows: [["y", SignalScales.number(hit.y)]] }));
   }
-}, _class12.__initStatic11(), _class12);
+}, _class13.__initStatic12(), _class13);
 
 // src/charts/signals/SeismogramChart.ts
 
@@ -2215,8 +2498,8 @@ var P = 7.6;
 var S = 4.3;
 var RATE2 = 20;
 var DURATION = 100;
-var SeismogramChart = (_class13 = class extends SignalChart {
-  static __initStatic12() {this.meta = {
+var SeismogramChart = (_class14 = class extends SignalChart {
+  static __initStatic13() {this.meta = {
     id: "signal-seismogram",
     name: "Seismogram",
     family: "scientific" /* Scientific */,
@@ -2356,7 +2639,7 @@ var SeismogramChart = (_class13 = class extends SignalChart {
       return { x: px, tip: { title: trace.label, rows: [["Time", `${SignalScales.number(time)} s`], ["Amplitude", SignalScales.number(SignalDsp.interpolate(trace.channel.t, trace.channel.v, time))]] }, datum: { station: trace.label, t: time } };
     });
   }
-}, _class13.__initStatic12(), _class13);
+}, _class14.__initStatic13(), _class14);
 
 // src/charts/signals/SpectrumChart.ts
 
@@ -2366,8 +2649,8 @@ var SpectrumMark = /* @__PURE__ */ ((SpectrumMark2) => {
   SpectrumMark2["Bands"] = "third-octave-bands";
   return SpectrumMark2;
 })(SpectrumMark || {});
-var SpectrumChart = (_class14 = class extends SpectralChart {
-  static __initStatic13() {this.meta = {
+var SpectrumChart = (_class15 = class extends SpectralChart {
+  static __initStatic14() {this.meta = {
     id: "signal-spectrum",
     name: "Frequency spectrum",
     family: "scientific" /* Scientific */,
@@ -2400,7 +2683,7 @@ var SpectrumChart = (_class14 = class extends SpectralChart {
   }
   scales(ctx) {
     const traces = this.traces(ctx), { width, height } = ctx.plot;
-    const x = this.frequencyAxis(_nullishCoalesce(_optionalChain([traces, 'access', _37 => _37.find, 'call', _38 => _38((trace) => trace.spectrum.freq.length), 'optionalAccess', _39 => _39.spectrum, 'access', _40 => _40.freq]), () => ( [])), width);
+    const x = this.frequencyAxis(_nullishCoalesce(_optionalChain([traces, 'access', _43 => _43.find, 'call', _44 => _44((trace) => trace.spectrum.freq.length), 'optionalAccess', _45 => _45.spectrum, 'access', _46 => _46.freq]), () => ( [])), width);
     const banded = this.options.mark === "third-octave-bands" /* Bands */ ? _d3.max.call(void 0, this.bands(traces, x.domain()[1]), (band) => band.level) : void 0;
     const top = _nullishCoalesce(_nullishCoalesce(banded, () => ( _d3.max.call(void 0, traces, (trace) => _d3.max.call(void 0, trace.level)))), () => ( 1));
     return { x, y: _d3.scaleLinear.call(void 0, this.decibel ? [this.options.floor, Math.max(top, this.options.floor + 10)] : [0, top || 1], [height, 0]).nice(5) };
@@ -2439,23 +2722,23 @@ var SpectrumChart = (_class14 = class extends SpectralChart {
     const reading = (freq) => ({ title: `${SignalScales.hertz(freq)} Hz`, rows: traces.map((trace) => [trace.name, SignalScales.number(SignalDsp.interpolate(trace.spectrum.freq, trace.level, freq))]) });
     this.probe(ctx, (px) => {
       const freq = x.invert(px), first = traces[0];
-      if (!_optionalChain([first, 'optionalAccess', _41 => _41.spectrum, 'access', _42 => _42.freq, 'access', _43 => _43.length])) return null;
+      if (!_optionalChain([first, 'optionalAccess', _47 => _47.spectrum, 'access', _48 => _48.freq, 'access', _49 => _49.length])) return null;
       return { x: px, tip: reading(freq), datum: { frequency: freq } };
     });
-    const shown = _nullishCoalesce(_optionalChain([traces, 'access', _44 => _44[0], 'optionalAccess', _45 => _45.spectrum, 'access', _46 => _46.freq, 'access', _47 => _47.filter, 'call', _48 => _48((freq) => freq >= x.domain()[0])]), () => ( []));
+    const shown = _nullishCoalesce(_optionalChain([traces, 'access', _50 => _50[0], 'optionalAccess', _51 => _51.spectrum, 'access', _52 => _52.freq, 'access', _53 => _53.filter, 'call', _54 => _54((freq) => freq >= x.domain()[0])]), () => ( []));
     if (shown.length) this.bins = SignalBins.line(shown.length, (bin) => reading(shown[bin]), (bin) => traces.map((trace) => [x(shown[bin]), y(SignalDsp.interpolate(trace.spectrum.freq, trace.level, shown[bin]))]));
   }
   /** Labels the strongest peak of the first channel. */
   mark(ctx, traces, x, y) {
     const trace = traces[0];
-    if (!_optionalChain([trace, 'optionalAccess', _49 => _49.level, 'access', _50 => _50.length])) return;
+    if (!_optionalChain([trace, 'optionalAccess', _55 => _55.level, 'access', _56 => _56.length])) return;
     const index = trace.level.indexOf(Math.max(...trace.level)), freq = trace.spectrum.freq[index], px = x(freq), py = y(trace.level[index]);
     const dots = ctx.marks("peak", "circle", [0]).attr("fill", trace.color).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
     ctx.set(dots, { cx: px, cy: py, r: 4 }, { r: 0 });
     const flip = px > ctx.plot.width - 70;
     ctx.text(ctx.marks("peak-label", "text", [0]).attr("x", px + (flip ? -8 : 8)).attr("y", Math.max(11, py + 3)).attr("text-anchor", flip ? "end" : "start").text(`${SignalScales.hertz(freq)} Hz`), 11, "ink");
   }
-}, _class14.__initStatic13(), _class14);
+}, _class15.__initStatic14(), _class15);
 
 // src/charts/signals/StemSignalChart.ts
 
@@ -2466,8 +2749,8 @@ var StemReconstruction = /* @__PURE__ */ ((StemReconstruction2) => {
   return StemReconstruction2;
 })(StemReconstruction || {});
 var sinc = (x) => Math.abs(x) < 1e-9 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
-var StemSignalChart = (_class15 = class extends SignalChart {
-  static __initStatic14() {this.meta = {
+var StemSignalChart = (_class16 = class extends SignalChart {
+  static __initStatic15() {this.meta = {
     id: "signal-stem",
     name: "Stem plot",
     family: "scientific" /* Scientific */,
@@ -2487,7 +2770,7 @@ var StemSignalChart = (_class15 = class extends SignalChart {
     return { ...super.defaults(), xLabel: "Sample n", yLabel: "x[n]", orientation: "vertical" /* Vertical */, marker: "circle" /* Circle */, layout: "lanes" /* Lanes */, reconstruction: "none" /* None */, limit: 64 };
   }
   constructor(options) {
-    super(options.orientation === "horizontal" /* Horizontal */ ? { xLabel: "x[n]", yLabel: "Sample n", ...options } : options);_class15.prototype.__init3.call(this);;
+    super(options.orientation === "horizontal" /* Horizontal */ ? { xLabel: "x[n]", yLabel: "Sample n", ...options } : options);_class16.prototype.__init3.call(this);;
   }
   __init3() {this.along = 300}
   get vertical() {
@@ -2554,7 +2837,7 @@ var StemSignalChart = (_class15 = class extends SignalChart {
     const d = (curve) => this.vertical ? this.path(curve.points, time, curve.origin) : this.path(curve.points.map(([a, b]) => [b, a]), curve.origin, time);
     this.stroke(ctx, "rebuilt", curves, (curve) => curve.name, d, (curve) => ctx.palette.color(curve.name), 1.5).attr("opacity", 0.55);
   }
-}, _class15.__initStatic14(), _class15);
+}, _class16.__initStatic15(), _class16);
 
 // src/charts/signals/TimeDomainDiffChart.ts
 
@@ -2571,8 +2854,8 @@ var DiffMetric = /* @__PURE__ */ ((DiffMetric2) => {
   return DiffMetric2;
 })(DiffMetric || {});
 var COLUMNS = 360;
-var TimeDomainDiffChart = (_class16 = class extends SignalChart {
-  static __initStatic15() {this.meta = {
+var TimeDomainDiffChart = (_class17 = class extends SignalChart {
+  static __initStatic16() {this.meta = {
     id: "signal-time-domain-diff",
     name: "Time domain diff",
     family: "scientific" /* Scientific */,
@@ -2687,7 +2970,7 @@ var TimeDomainDiffChart = (_class16 = class extends SignalChart {
     const [first, second] = this.channels, lag = this.lag;
     this.placeSample = (channel, i) => [x(channel.t[i] - (second && channel === second && channel !== first ? lag : 0)), y(channel.v[i])];
   }
-}, _class16.__initStatic15(), _class16);
+}, _class17.__initStatic16(), _class17);
 
 // src/charts/signals/WaterfallSpectrum.ts
 
@@ -2708,8 +2991,8 @@ var WaterfallOrder = /* @__PURE__ */ ((WaterfallOrder2) => {
   return WaterfallOrder2;
 })(WaterfallOrder || {});
 var SHEAR = 0.16;
-var WaterfallSpectrum = (_class17 = class extends SpectralChart {
-  static __initStatic16() {this.meta = {
+var WaterfallSpectrum = (_class18 = class extends SpectralChart {
+  static __initStatic17() {this.meta = {
     id: "signal-waterfall-spectrum",
     name: "Waterfall spectrum",
     family: "scientific" /* Scientific */,
@@ -2776,7 +3059,7 @@ var WaterfallSpectrum = (_class17 = class extends SpectralChart {
       const freq = x.invert(px - ridge.shift);
       return { x: px, tip: { title: `${SignalScales.number(ridge.time)} s`, rows: [["Frequency", `${SignalScales.hertz(freq)} Hz`], ["Peak", SignalScales.number(ridge.peak)]] }, datum: { t: ridge.time, frequency: freq } };
     });
-    const across = _nullishCoalesce(_optionalChain([ridges, 'access', _51 => _51[0], 'optionalAccess', _52 => _52.points, 'access', _53 => _53.length]), () => ( 0)), range = this.options.range;
+    const across = _nullishCoalesce(_optionalChain([ridges, 'access', _57 => _57[0], 'optionalAccess', _58 => _58.points, 'access', _59 => _59.length]), () => ( 0)), range = this.options.range;
     if (across && ridges.every((ridge) => ridge.points.length === across)) {
       this.bins = SignalBins.grid(ridges.length, across, ["frame", "Bin"], (row, bin) => {
         const ridge = ridges[row], [freq, level] = ridge.points[bin];
@@ -2787,7 +3070,7 @@ var WaterfallSpectrum = (_class17 = class extends SpectralChart {
       });
     }
   }
-}, _class17.__initStatic16(), _class17);
+}, _class18.__initStatic17(), _class18);
 
 // src/charts/signals/WaveformChart.ts
 
@@ -2801,8 +3084,8 @@ var WaveformStyle = /* @__PURE__ */ ((WaveformStyle2) => {
 })(WaveformStyle || {});
 var FLOOR4 = 60;
 var BAR = 5;
-var WaveformChart = (_class18 = class extends SignalChart {
-  static __initStatic17() {this.meta = {
+var WaveformChart = (_class19 = class extends SignalChart {
+  static __initStatic18() {this.meta = {
     id: "signal-waveform",
     name: "Waveform",
     family: "scientific" /* Scientific */,
@@ -2900,7 +3183,7 @@ var WaveformChart = (_class18 = class extends SignalChart {
     ctx.set(marks, { x: (bar) => bar.at, width: thick, y: (bar) => bar.top, height: (bar) => Math.max(thick, bar.bottom - bar.top) }, { y: (bar) => (bar.top + bar.bottom) / 2, height: 0 }, 1);
     ctx.hover(marks, (bar) => ({ title: `${SignalScales.number(bar.bucket.t)} s`, color: bar.item.color, rows: [["Peak", SignalScales.number(bar.bucket.max)], ["RMS", SignalScales.number(bar.bucket.rms)]] }));
   }
-}, _class18.__initStatic17(), _class18);
+}, _class19.__initStatic18(), _class19);
 
 // src/charts/signals/WaveletScalogram.ts
 
@@ -3000,8 +3283,8 @@ var WaveletAxis = /* @__PURE__ */ ((WaveletAxis2) => {
   return WaveletAxis2;
 })(WaveletAxis || {});
 var SLOT = 12;
-var WaveletScalogram = (_class19 = class extends TimeFrequencyChart {
-  static __initStatic18() {this.meta = {
+var WaveletScalogram = (_class20 = class extends TimeFrequencyChart {
+  static __initStatic19() {this.meta = {
     id: "signal-wavelet-scalogram",
     name: "Wavelet scalogram",
     family: "scientific" /* Scientific */,
@@ -3028,7 +3311,7 @@ var WaveletScalogram = (_class19 = class extends TimeFrequencyChart {
   
   get transform() {
     const channel = this.channel, key = `${this.options.wavelet}|${channel.name}|${channel.v.length}|${channel.v[0]}`;
-    if (_optionalChain([this, 'access', _54 => _54.cache, 'optionalAccess', _55 => _55.key]) !== key) this.cache = { key, field: SignalDsp.wavelet(channel.v, channel.rate, this.options.wavelet) };
+    if (_optionalChain([this, 'access', _60 => _60.cache, 'optionalAccess', _61 => _61.key]) !== key) this.cache = { key, field: SignalDsp.wavelet(channel.v, channel.rate, this.options.wavelet) };
     return this.cache.field;
   }
   get byPeriod() {
@@ -3095,7 +3378,7 @@ var WaveletScalogram = (_class19 = class extends TimeFrequencyChart {
     this.fill(ctx, "cone", [points], () => 0, (list) => _nullishCoalesce(shape(list), () => ( "")), () => ctx.theme.surface, 0.62);
     this.stroke(ctx, "cone-edge", [points], () => 0, (list) => this.path(list.map((point) => [point.t, point.at]), x, (value) => value), () => ctx.theme.ink, 1);
   }
-}, _class19.__initStatic18(), _class19);
+}, _class20.__initStatic19(), _class20);
 
 // src/charts/signals/index.ts
 var signalsCatalog = [
@@ -3116,7 +3399,8 @@ var signalsCatalog = [
   ECGChart,
   LogicAnalyzerChart,
   PhaseSpaceChart,
-  PhaseSpace3DChart
+  PhaseSpace3DChart,
+  AntennaPatternChart
 ];
 
 
@@ -3182,4 +3466,6 @@ var signalsCatalog = [
 
 
 
-exports.SignalWindow = SignalWindow; exports.SignalFrequencyScale = SignalFrequencyScale; exports.SignalAmplitude = SignalAmplitude; exports.SignalLayout = SignalLayout; exports.SignalWavelet = SignalWavelet; exports.AudiogramLayout = AudiogramLayout; exports.AudiogramSpacing = AudiogramSpacing; exports.AudiogramChart = AudiogramChart; exports.CepstrumKind = CepstrumKind; exports.CepstrumAxis = CepstrumAxis; exports.CepstrumMark = CepstrumMark; exports.CepstrumChart = CepstrumChart; exports.EcgView = EcgView; exports.EcgLayout = EcgLayout; exports.EcgAnnotation = EcgAnnotation; exports.ECGChart = ECGChart; exports.EnvelopeMethod = EnvelopeMethod; exports.EnvelopeShape = EnvelopeShape; exports.EnvelopeChart = EnvelopeChart; exports.FilterView = FilterView; exports.FilterResponseChart = FilterResponseChart; exports.ImpulseView = ImpulseView; exports.ImpulseMark = ImpulseMark; exports.ImpulseResponseChart = ImpulseResponseChart; exports.LogicDisplay = LogicDisplay; exports.LogicEdge = LogicEdge; exports.LogicAnalyzerChart = LogicAnalyzerChart; exports.ScopeMode = ScopeMode; exports.ScopeTrigger = ScopeTrigger; exports.ScopeDisplay = ScopeDisplay; exports.ScopeCoupling = ScopeCoupling; exports.OscilloscopeChart = OscilloscopeChart; exports.PeriodogramMethod = PeriodogramMethod; exports.PeriodogramAbscissa = PeriodogramAbscissa; exports.PeriodogramChart = PeriodogramChart; exports.Phase3DCoordinates = Phase3DCoordinates; exports.Phase3DStyle = Phase3DStyle; exports.PhaseSpace3DChart = PhaseSpace3DChart; exports.PhaseCoordinates = PhaseCoordinates; exports.PhaseMark = PhaseMark; exports.PhaseSpaceChart = PhaseSpaceChart; exports.SeismogramLayout = SeismogramLayout; exports.SeismogramFill = SeismogramFill; exports.SeismogramGain = SeismogramGain; exports.SeismogramChart = SeismogramChart; exports.SpectrumMark = SpectrumMark; exports.SpectrumChart = SpectrumChart; exports.StemReconstruction = StemReconstruction; exports.StemSignalChart = StemSignalChart; exports.DiffView = DiffView; exports.DiffMetric = DiffMetric; exports.TimeDomainDiffChart = TimeDomainDiffChart; exports.WaterfallFill = WaterfallFill; exports.WaterfallProjection = WaterfallProjection; exports.WaterfallOrder = WaterfallOrder; exports.WaterfallSpectrum = WaterfallSpectrum; exports.WaveformStyle = WaveformStyle; exports.WaveformChart = WaveformChart; exports.WaveletValue = WaveletValue; exports.WaveletAxis = WaveletAxis; exports.WaveletScalogram = WaveletScalogram; exports.signalsCatalog = signalsCatalog;
+
+
+exports.SignalWindow = SignalWindow; exports.SignalFrequencyScale = SignalFrequencyScale; exports.SignalAmplitude = SignalAmplitude; exports.SignalLayout = SignalLayout; exports.SignalWavelet = SignalWavelet; exports.AntennaPatternForm = AntennaPatternForm; exports.AntennaPatternChart = AntennaPatternChart; exports.AudiogramLayout = AudiogramLayout; exports.AudiogramSpacing = AudiogramSpacing; exports.AudiogramChart = AudiogramChart; exports.CepstrumKind = CepstrumKind; exports.CepstrumAxis = CepstrumAxis; exports.CepstrumMark = CepstrumMark; exports.CepstrumChart = CepstrumChart; exports.EcgView = EcgView; exports.EcgLayout = EcgLayout; exports.EcgAnnotation = EcgAnnotation; exports.ECGChart = ECGChart; exports.EnvelopeMethod = EnvelopeMethod; exports.EnvelopeShape = EnvelopeShape; exports.EnvelopeChart = EnvelopeChart; exports.FilterView = FilterView; exports.FilterResponseChart = FilterResponseChart; exports.ImpulseView = ImpulseView; exports.ImpulseMark = ImpulseMark; exports.ImpulseResponseChart = ImpulseResponseChart; exports.LogicDisplay = LogicDisplay; exports.LogicEdge = LogicEdge; exports.LogicAnalyzerChart = LogicAnalyzerChart; exports.ScopeMode = ScopeMode; exports.ScopeTrigger = ScopeTrigger; exports.ScopeDisplay = ScopeDisplay; exports.ScopeCoupling = ScopeCoupling; exports.OscilloscopeChart = OscilloscopeChart; exports.PeriodogramMethod = PeriodogramMethod; exports.PeriodogramAbscissa = PeriodogramAbscissa; exports.PeriodogramChart = PeriodogramChart; exports.Phase3DCoordinates = Phase3DCoordinates; exports.Phase3DStyle = Phase3DStyle; exports.PhaseSpace3DChart = PhaseSpace3DChart; exports.PhaseCoordinates = PhaseCoordinates; exports.PhaseMark = PhaseMark; exports.PhaseSpaceChart = PhaseSpaceChart; exports.SeismogramLayout = SeismogramLayout; exports.SeismogramFill = SeismogramFill; exports.SeismogramGain = SeismogramGain; exports.SeismogramChart = SeismogramChart; exports.SpectrumMark = SpectrumMark; exports.SpectrumChart = SpectrumChart; exports.StemReconstruction = StemReconstruction; exports.StemSignalChart = StemSignalChart; exports.DiffView = DiffView; exports.DiffMetric = DiffMetric; exports.TimeDomainDiffChart = TimeDomainDiffChart; exports.WaterfallFill = WaterfallFill; exports.WaterfallProjection = WaterfallProjection; exports.WaterfallOrder = WaterfallOrder; exports.WaterfallSpectrum = WaterfallSpectrum; exports.WaveformStyle = WaveformStyle; exports.WaveformChart = WaveformChart; exports.WaveletValue = WaveletValue; exports.WaveletAxis = WaveletAxis; exports.WaveletScalogram = WaveletScalogram; exports.signalsCatalog = signalsCatalog;