@compstats/core 0.2.0

package/dist/index.js

@@ -0,0 +1,4195 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/core/precision.ts
+function machinePrecision() {
+  return Number.EPSILON;
+}
+// src/core/arith.ts
+function sum(values) {
+  return values.reduce((total, value) => total + value, 0);
+}
+function mean(values) {
+  return sum(values) / values.length;
+}
+function extent(values) {
+  return values.reduce(([low, high], value) => [
+    value < low ? value : low,
+    value > high ? value : high
+  ], [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]);
+}
+function withoutNegativeZero(value) {
+  return value === 0 ? 0 : value;
+}
+function requireCount(value, name) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new RangeError(`${name} must be a non-negative integer, got ${value}`);
+  }
+}
+function zipWith(as, bs, combine) {
+  const length = Math.min(as.length, bs.length);
+  return as.slice(0, length).map((a, index) => combine(a, bs[index]));
+}
+function sd(values) {
+  if (values.length < 2) {
+    return Number.NaN;
+  }
+  const center = mean(values);
+  const squares = values.map((value) => (value - center) * (value - center));
+  return Math.sqrt(sum(squares) / (values.length - 1));
+}
+function meanAbsoluteDeviation(values) {
+  const center = mean(values);
+  return mean(values.map((value) => Math.abs(value - center)));
+}
+function fusedMultiplyAdd(a, b, c) {
+  const [product, productError] = twoProduct(a, b);
+  const [sum2, sumError] = twoSum(c, product);
+  const rounded = sum2 + (sumError + productError);
+  return Number.isFinite(rounded) ? rounded : a * b + c;
+}
+function split(value) {
+  const scaled = 134217729 * value;
+  const high = scaled - (scaled - value);
+  return [high, value - high];
+}
+function twoProduct(a, b) {
+  const product = a * b;
+  const [aHigh, aLow] = split(a);
+  const [bHigh, bLow] = split(b);
+  const error = aLow * bLow - (product - aHigh * bHigh - aLow * bHigh - aHigh * bLow);
+  return [product, error];
+}
+function twoSum(a, b) {
+  const sum2 = a + b;
+  const carried = sum2 - a;
+  return [sum2, a - (sum2 - carried) + (b - carried)];
+}
+function quantile(values, p) {
+  return quantiles(values, [p])[0];
+}
+function quantiles(values, probs) {
+  if (probs.some((p) => !(p >= 0 && p <= 1))) {
+    throw new RangeError(`every probability must be in [0, 1], got ${probs}`);
+  }
+  if (values.length === 0) {
+    return probs.map(() => Number.NaN);
+  }
+  const sorted = Float64Array.from(values).sort();
+  return probs.map((p) => type7(sorted, p));
+}
+function median(values) {
+  return quantile(values, 0.5);
+}
+function type7(sorted, p) {
+  const position = 1 + (sorted.length - 1) * p;
+  const below = Math.floor(position);
+  const above = Math.ceil(position);
+  const low = sorted[below - 1];
+  const high = sorted[above - 1];
+  if (position > below && high !== low) {
+    const h = position - below;
+    return (1 - h) * low + h * high;
+  }
+  return low;
+}
+// src/core/kde.ts
+var GRID_SIZE = 512;
+var FFT_SIZE = 2 * GRID_SIZE;
+var CUT = 3;
+var EXT = 4;
+var INV_SQRT_2PI = 0.3989422804014327;
+function bwNrd0(values) {
+  if (values.length < 2) {
+    throw new RangeError(`need at least 2 data points, got ${values.length}`);
+  }
+  const spread = sd(values);
+  const [lowerQuartile, upperQuartile] = quantiles(values, [0.25, 0.75]);
+  const iqrSpread = (upperQuartile - lowerQuartile) / 1.34;
+  const scale = fallbackScale(spread, iqrSpread, values[0]);
+  return 0.9 * scale * Math.pow(values.length, -0.2);
+}
+function fallbackScale(spread, iqrSpread, first) {
+  const smaller = Math.min(spread, iqrSpread);
+  if (smaller !== 0) {
+    return smaller;
+  }
+  if (spread !== 0) {
+    return spread;
+  }
+  return Math.abs(first) !== 0 ? Math.abs(first) : 1;
+}
+function kernelDensity(values, options = {}) {
+  const finite = finiteValuesOf(values);
+  const bw = options.bw ?? bwNrd0(finite);
+  if (!Number.isFinite(bw) || bw <= 0) {
+    throw new RangeError(`bw must be positive and finite, got ${bw}`);
+  }
+  if (finite.length === 0) {
+    throw new RangeError("need at least 1 finite value, got none");
+  }
+  if (options.from !== undefined && !Number.isFinite(options.from)) {
+    throw new RangeError(`non-finite 'from': ${options.from}`);
+  }
+  if (options.to !== undefined && !Number.isFinite(options.to)) {
+    throw new RangeError(`non-finite 'to': ${options.to}`);
+  }
+  const [lowest, highest] = extent(finite);
+  const from = options.from ?? lowest - CUT * bw;
+  const to = options.to ?? highest + CUT * bw;
+  const lo = from - EXT * bw;
+  const up = to + EXT * bw;
+  const binned = binDist(finite, lo, up, finite.length / values.length);
+  const kernel = gaussianKernel(lo, up, bw);
+  const density = convolve(binned, kernel);
+  const working = gridOf(lo, up);
+  const x = gridOf(from, to);
+  const y = x.map((point) => interpolate(working, density, point));
+  return { x, y, bw, n: values.length };
+}
+function finiteValuesOf(values) {
+  if (values.every((value) => Number.isFinite(value))) {
+    return values;
+  }
+  if (values.some((value) => Number.isNaN(value))) {
+    throw new RangeError("values contain a missing value");
+  }
+  return values.filter((value) => Number.isFinite(value));
+}
+function binDist(values, lo, up, keptShare) {
+  const bins = new Float64Array(FFT_SIZE);
+  const step = (up - lo) / (GRID_SIZE - 1);
+  const weight = keptShare / values.length;
+  const lastPair = GRID_SIZE - 2;
+  for (let i = 0;i < values.length; i += 1) {
+    const position = (values[i] - lo) / step;
+    const behind = Math.floor(position);
+    const ahead = position - behind;
+    if (behind >= 0 && behind <= lastPair) {
+      bins[behind] += (1 - ahead) * weight;
+      bins[behind + 1] += ahead * weight;
+    } else if (behind === -1) {
+      bins[0] += ahead * weight;
+    } else if (behind === lastPair + 1) {
+      bins[behind] += (1 - ahead) * weight;
+    }
+  }
+  return bins;
+}
+function gaussianKernel(lo, up, bw) {
+  const span = (FFT_SIZE - 1) / (GRID_SIZE - 1) * (up - lo);
+  const step = span / (FFT_SIZE - 1);
+  const lags = Array.from({ length: FFT_SIZE }, (_, index) => index * step);
+  const folded = lags.map((lag, index) => index > GRID_SIZE ? -lags[FFT_SIZE - index] : lag);
+  return Float64Array.from(folded, (lag) => dnorm(lag, bw));
+}
+function dnorm(at, sd2) {
+  const z = Math.abs(at) / sd2;
+  if (z < 5) {
+    return INV_SQRT_2PI * Math.exp(-0.5 * z * z) / sd2;
+  }
+  if (z > Math.sqrt(-2 * Math.LN2 * (-1021 + 1 - 53))) {
+    return 0;
+  }
+  const head = Math.round(z * 65536) / 65536;
+  const tail = z - head;
+  return INV_SQRT_2PI / sd2 * (Math.exp(-0.5 * head * head) * Math.exp((-0.5 * tail - head) * tail));
+}
+function convolve(binned, kernel) {
+  const massReal = Float64Array.from(binned);
+  const massImaginary = new Float64Array(FFT_SIZE);
+  const kernelReal = Float64Array.from(kernel);
+  const kernelImaginary = new Float64Array(FFT_SIZE);
+  fftInPlace(massReal, massImaginary, false);
+  fftInPlace(kernelReal, kernelImaginary, false);
+  for (let i = 0;i < FFT_SIZE; i += 1) {
+    const real = massReal[i] * kernelReal[i] + massImaginary[i] * kernelImaginary[i];
+    const imaginary = massImaginary[i] * kernelReal[i] - massReal[i] * kernelImaginary[i];
+    massReal[i] = real;
+    massImaginary[i] = imaginary;
+  }
+  fftInPlace(massReal, massImaginary, true);
+  return Float64Array.from(massReal.subarray(0, GRID_SIZE), (value) => Math.max(0, value / FFT_SIZE));
+}
+function fftInPlace(real, imaginary, inverse) {
+  const size = real.length;
+  const half = size >> 1;
+  for (let i = 1, j = 0;i < size; i += 1) {
+    let bit = half;
+    for (;(j & bit) !== 0; bit >>= 1) {
+      j ^= bit;
+    }
+    j ^= bit;
+    if (i < j) {
+      const swappedReal = real[i];
+      const swappedImaginary = imaginary[i];
+      real[i] = real[j];
+      imaginary[i] = imaginary[j];
+      real[j] = swappedReal;
+      imaginary[j] = swappedImaginary;
+    }
+  }
+  const direction = inverse ? 1 : -1;
+  const cosines = new Float64Array(half);
+  const sines = new Float64Array(half);
+  for (let k = 0;k < half; k += 1) {
+    const angle = direction * 2 * Math.PI * k / size;
+    cosines[k] = Math.cos(angle);
+    sines[k] = Math.sin(angle);
+  }
+  for (let span = 1;span < size; span <<= 1) {
+    const stride = half / span;
+    for (let start = 0;start < size; start += span << 1) {
+      for (let k = 0;k < span; k += 1) {
+        const even = start + k;
+        const odd = even + span;
+        const cosine = cosines[k * stride];
+        const sine = sines[k * stride];
+        const oddReal = real[odd] * cosine - imaginary[odd] * sine;
+        const oddImaginary = real[odd] * sine + imaginary[odd] * cosine;
+        real[odd] = real[even] - oddReal;
+        imaginary[odd] = imaginary[even] - oddImaginary;
+        real[even] = real[even] + oddReal;
+        imaginary[even] = imaginary[even] + oddImaginary;
+      }
+    }
+  }
+}
+function gridOf(from, to) {
+  const step = (to - from) / (GRID_SIZE - 1);
+  const points = Array.from({ length: GRID_SIZE }, (_, index) => from + index * step);
+  points[GRID_SIZE - 1] = to;
+  return points;
+}
+function interpolate(grid, values, at) {
+  let low = 0;
+  let high = grid.length - 1;
+  if (at < grid[low]) {
+    return values[low];
+  }
+  if (at > grid[high]) {
+    return values[high];
+  }
+  while (low < high - 1) {
+    const middle = low + high >> 1;
+    if (at < grid[middle]) {
+      high = middle;
+    } else {
+      low = middle;
+    }
+  }
+  if (at === grid[high]) {
+    return values[high];
+  }
+  if (at === grid[low]) {
+    return values[low];
+  }
+  const lowValue = values[low];
+  const highValue = values[high];
+  const lowPoint = grid[low];
+  const highPoint = grid[high];
+  return lowValue + (highValue - lowValue) * ((at - lowPoint) / (highPoint - lowPoint));
+}
+// src/core/pretty.ts
+var ROUNDING_EPS = 0.0000000001;
+var SHRINK_SMALL = 0.75;
+var HIGH_U_BIAS = 1.5;
+var U5_BIAS = 0.5 + 1.5 * HIGH_U_BIAS;
+function rPretty(lo, up, options = {}) {
+  const { n = 5, minN = Math.floor(n / 3) } = options;
+  if (!Number.isFinite(lo) || !Number.isFinite(up)) {
+    throw new RangeError(`lo and up must be finite, got ${lo} and ${up}`);
+  }
+  if (up < lo) {
+    throw new RangeError(`up must not be below lo, got ${lo} and ${up}`);
+  }
+  requireCount(n, "n");
+  requireCount(minN, "minN");
+  if (minN > n) {
+    throw new RangeError(`minN must not be above n, got ${minN} and ${n}`);
+  }
+  const { low, high, cells } = prettyBounds(lo, up, n, minN);
+  if (cells === 0) {
+    return [low];
+  }
+  const step = (high - low) / cells;
+  const edges = Array.from({ length: cells + 1 }, (_, index) => fusedMultiplyAdd(index, step, low));
+  edges[cells] = high;
+  return edges.map((edge) => Math.abs(edge) < 0.00000000000001 * step ? 0 : edge);
+}
+function prettyBounds(lo, up, n, minN) {
+  const unit = cellUnit(lo, up, n, minN);
+  let steps = Math.floor(lo / unit + ROUNDING_EPS);
+  let stepsUp = Math.ceil(up / unit - ROUNDING_EPS);
+  while (steps * unit > lo + ROUNDING_EPS * unit) {
+    steps -= 1;
+  }
+  while (stepsUp * unit < up - ROUNDING_EPS * unit) {
+    stepsUp += 1;
+  }
+  let cells = Math.floor(0.5 + stepsUp - steps);
+  if (cells < minN) {
+    const missing = minN - cells;
+    if (lo === 0 && up > 0) {
+      stepsUp += missing;
+    } else if (up === 0 && lo < 0) {
+      steps -= missing;
+    } else if (steps >= 0) {
+      stepsUp += Math.floor(missing / 2);
+      steps -= Math.floor(missing / 2) + missing % 2;
+    } else {
+      steps -= Math.floor(missing / 2);
+      stepsUp += Math.floor(missing / 2) + missing % 2;
+    }
+    cells = minN;
+  }
+  return {
+    low: steps * unit < lo ? steps * unit : lo,
+    high: stepsUp * unit > up ? stepsUp * unit : up,
+    cells
+  };
+}
+function cellUnit(lo, up, n, minN) {
+  const width = up - lo;
+  let cell;
+  let noWidth;
+  if (width === 0 && up === 0) {
+    cell = 1;
+    noWidth = true;
+  } else {
+    cell = Math.max(Math.abs(lo), Math.abs(up));
+    const bound = 1 + (U5_BIAS >= 1.5 * HIGH_U_BIAS + 0.5 ? 1 / (1 + HIGH_U_BIAS) : 1.5 / (1 + U5_BIAS));
+    noWidth = width < cell * bound * Math.max(1, n) * Number.EPSILON * 3;
+  }
+  if (noWidth) {
+    if (cell > 10) {
+      cell = 9 + cell / 10;
+    }
+    cell *= SHRINK_SMALL;
+    if (minN > 1) {
+      cell /= minN;
+    }
+  } else {
+    cell = width;
+    if (n > 1) {
+      cell /= n;
+    }
+  }
+  const base = powerOfTen(Math.floor(Math.log10(cell)));
+  let unit = base;
+  if (2 * base - cell < HIGH_U_BIAS * (cell - unit)) {
+    unit = 2 * base;
+    if (5 * base - cell < U5_BIAS * (cell - unit)) {
+      unit = 5 * base;
+      if (10 * base - cell < HIGH_U_BIAS * (cell - unit)) {
+        unit = 10 * base;
+      }
+    }
+  }
+  return unit;
+}
+function powerOfTen(exponent) {
+  const parsed = Number(`1e${exponent}`);
+  return Number.isFinite(parsed) && parsed !== 0 ? parsed : Math.pow(10, exponent);
+}
+
+// src/core/histogram.ts
+var FUZZ = 0.0000001;
+function nclassSturges(values) {
+  return Math.ceil(Math.log2(values.length) + 1);
+}
+function histogram(values, options = {}) {
+  const finite = values.filter((value) => Number.isFinite(value));
+  if (finite.length === 0) {
+    throw new RangeError("need at least 1 finite value, got none");
+  }
+  const breaks = resolveBreaks(finite, options.breaks);
+  const widths = zipWith(breaks.slice(1), breaks.slice(0, -1), (up, low) => up - low);
+  const counts = binCount(finite, fuzzyBreaks(breaks, widths, finite));
+  if (sum(counts) < finite.length) {
+    throw new RangeError("some values were not counted; the breaks may not span their range");
+  }
+  return {
+    breaks,
+    counts,
+    mids: zipWith(breaks.slice(1), breaks.slice(0, -1), (up, low) => 0.5 * (up + low))
+  };
+}
+function resolveBreaks(finite, requested) {
+  if (requested !== undefined && typeof requested !== "number") {
+    if (requested.length < 2) {
+      throw new RangeError(`breaks given as edges need at least 2 of them, got ${requested.length}`);
+    }
+    return [...requested].sort((a, b) => a - b);
+  }
+  const cells = requested ?? nclassSturges(finite);
+  if (!Number.isInteger(cells) || cells < 1) {
+    throw new RangeError(`invalid number of breaks: ${cells}`);
+  }
+  return rPretty(...extent(finite), { n: cells, minN: 1 });
+}
+function fuzzyBreaks(breaks, widths, finite) {
+  const positive = widths.filter((width) => width > 0);
+  const [lowest, highest] = extent(finite);
+  const scale = breaks.length > 5 ? quantile(widths, 0.5) : breaks.length <= 3 ? highest - lowest : Math.min(...positive);
+  const nudge = FUZZ * scale;
+  return breaks.map((edge, index) => index === 0 ? edge - nudge : edge + nudge);
+}
+function binCount(values, breaks) {
+  const counts = new Array(breaks.length - 1).fill(0);
+  const last = breaks.length - 1;
+  for (let i = 0;i < values.length; i += 1) {
+    const value = values[i];
+    if (value < breaks[0] || value > breaks[last]) {
+      continue;
+    }
+    let low = 0;
+    let high = last;
+    while (high - low >= 2) {
+      const middle = high + low >> 1;
+      if (value > breaks[middle]) {
+        low = middle;
+      } else {
+        high = middle;
+      }
+    }
+    counts[low] += 1;
+  }
+  return counts;
+}
+// src/core/rng.ts
+function seededRng(seed) {
+  if (!Number.isFinite(seed)) {
+    throw new RangeError(`seed must be finite, got ${seed}`);
+  }
+  let state = Math.trunc(seed) | 0;
+  return () => {
+    state = state + 1831565813 | 0;
+    let mixed = Math.imul(state ^ state >>> 15, 1 | state);
+    mixed = mixed + Math.imul(mixed ^ mixed >>> 7, 61 | mixed) ^ mixed;
+    return ((mixed ^ mixed >>> 14) >>> 0) / 4294967296;
+  };
+}
+function runif(rng, n, options = {}) {
+  requireCount(n, "n");
+  const { min = 0, max = 1 } = options;
+  if (!Number.isFinite(min) || !Number.isFinite(max) || max < min) {
+    return new Array(n).fill(Number.NaN);
+  }
+  return Array.from({ length: n }, () => min + (max - min) * rng());
+}
+function rnorm(rng, n, options = {}) {
+  requireCount(n, "n");
+  const { mean: mean2 = 0, sd: sd2 = 1 } = options;
+  if (!Number.isFinite(mean2) || !Number.isFinite(sd2) || sd2 < 0) {
+    return new Array(n).fill(Number.NaN);
+  }
+  const pairs = Array.from({ length: Math.ceil(n / 2) }, () => standardNormalPair(rng));
+  return pairs.flat().slice(0, n).map((z) => mean2 + sd2 * z);
+}
+function rt(rng, n, df) {
+  requireCount(n, "n");
+  if (!Number.isInteger(df) || df <= 0) {
+    return new Array(n).fill(Number.NaN);
+  }
+  const z = rnorm(rng, n);
+  const components = Array.from({ length: df }, () => rnorm(rng, n));
+  return z.map((numerator, index) => {
+    const chiSquare = sum(components.map((draws) => draws[index] ** 2));
+    return numerator / Math.sqrt(chiSquare / df);
+  });
+}
+function rlnorm(rng, n, options = {}) {
+  const { meanlog = 0, sdlog = 1 } = options;
+  return rnorm(rng, n, { mean: meanlog, sd: sdlog }).map(Math.exp);
+}
+function rcauchy(rng, n, options = {}) {
+  requireCount(n, "n");
+  const { location = 0, scale = 1 } = options;
+  if (!Number.isFinite(location) || !Number.isFinite(scale) || scale < 0) {
+    return new Array(n).fill(Number.NaN);
+  }
+  return runif(rng, n).map((u) => location + scale * Math.tan(Math.PI * (u - 0.5)));
+}
+function standardNormalPair(rng) {
+  const radius = Math.sqrt(-2 * Math.log(1 - rng()));
+  const angle = 2 * Math.PI * rng();
+  return [radius * Math.cos(angle), radius * Math.sin(angle)];
+}
+function sampleWithoutReplacement(rng, values, k) {
+  requireCount(k, "k");
+  if (k > values.length) {
+    throw new RangeError(`cannot take a sample of ${k} from a population of ${values.length}`);
+  }
+  const pool = values.slice();
+  for (let i = 0;i < k; i += 1) {
+    const chosen = i + Math.floor(rng() * (pool.length - i));
+    const held = pool[chosen];
+    pool[chosen] = pool[i];
+    pool[i] = held;
+  }
+  return pool.slice(0, k);
+}
+
+// src/core/sampling.ts
+var CI95_MULTIPLIER = 1.96;
+var CI99_MULTIPLIER = 2.58;
+var DEFAULT_POP_SIZE = 1e4;
+var DEFAULT_NUM_SAMPLES = 100;
+var DEFAULT_SAMPLE_SIZE = 100;
+function drawSamples(rng, population, options) {
+  const { sampleSize, reps = 1, theta = mean } = options;
+  requireCount(reps, "reps");
+  const samples = Array.from({ length: reps }, () => sampleWithoutReplacement(rng, population, sampleSize));
+  return { samples, thetas: samples.map((sample) => theta(sample)) };
+}
+function sampleConfidenceIntervals(samples, populationMean) {
+  return samples.map((sample) => {
+    const center = mean(sample);
+    const spread = sd(sample);
+    const standardError = spread / Math.sqrt(sample.length);
+    const ci95 = spreadAround(center, standardError, CI95_MULTIPLIER);
+    const ci99 = spreadAround(center, standardError, CI99_MULTIPLIER);
+    return {
+      mean: center,
+      sd: spread,
+      standardError,
+      ci95,
+      ci99,
+      excludesPopulationMean: ci95.low > populationMean || ci95.high < populationMean || ci99.low > populationMean || ci99.high < populationMean
+    };
+  });
+}
+function spreadAround(center, standardError, multiplier) {
+  return {
+    low: center - standardError * multiplier,
+    high: center + standardError * multiplier
+  };
+}
+function simulateSampleCi(rng, options = {}) {
+  const {
+    numSamples = DEFAULT_NUM_SAMPLES,
+    sampleSize = DEFAULT_SAMPLE_SIZE,
+    popSize = DEFAULT_POP_SIZE,
+    distribution = standardNormal
+  } = options;
+  requireCount(numSamples, "numSamples");
+  requireCount(popSize, "popSize");
+  const population = distribution(rng, popSize);
+  const populationMean = mean(population);
+  const { samples } = drawSamples(rng, population, {
+    sampleSize,
+    reps: numSamples
+  });
+  return {
+    populationMean,
+    populationSd: sd(population),
+    intervals: sampleConfidenceIntervals(samples, populationMean)
+  };
+}
+function standardNormal(rng, n) {
+  return rnorm(rng, n);
+}
+// src/core/frame.ts
+function isNumericColumn(column) {
+  return column.length > 0 && column.every((value) => typeof value === "number");
+}
+function numericColumns(data) {
+  return Object.keys(data).filter((name) => isNumericColumn(data[name]));
+}
+function requireThreeNumericColumns(numeric, caller) {
+  if (numeric.length < 3) {
+    throw new RangeError(`${caller}() needs at least 3 numeric columns; got ${numeric.length}. ` + "Supply x/y/z explicitly or add numeric columns.");
+  }
+}
+function frameRows(data) {
+  const names = Object.keys(data);
+  const first = names[0];
+  if (first === undefined) {
+    return 0;
+  }
+  const rows = data[first].length;
+  const ragged = names.find((name) => data[name].length !== rows);
+  if (ragged !== undefined) {
+    throw new RangeError(`every column needs the same number of rows: "${first}" has ${rows} ` + `but "${ragged}" has ${data[ragged].length}`);
+  }
+  return rows;
+}
+function requireNumericColumn(data, name, role) {
+  const column = data[name];
+  if (column === undefined) {
+    throw new RangeError(`Column "${name}" (passed as \`${role}\`) is not in the data.`);
+  }
+  if (!isNumericColumn(column)) {
+    throw new RangeError(`Column "${name}" (passed as \`${role}\`) is not numeric; ` + "only numeric columns can carry the statistics.");
+  }
+  return column;
+}
+// src/core/ols.ts
+var DEFAULT_LEAST_SQUARES_TOLERANCE = 0.0000001;
+function leastSquares(design, y, options = {}) {
+  const { weights, tolerance = DEFAULT_LEAST_SQUARES_TOLERANCE } = options;
+  const rows = design.length;
+  if (rows === 0) {
+    throw new RangeError("least squares needs at least one row");
+  }
+  const width = design[0].length;
+  if (design.some((row) => row.length !== width)) {
+    throw new RangeError("every design row needs the same number of columns");
+  }
+  if (y.length !== rows) {
+    throw new RangeError(`the response has ${y.length} values but the design has ${rows} rows`);
+  }
+  if (weights !== undefined) {
+    if (weights.length !== rows) {
+      throw new RangeError(`there are ${weights.length} weights but ${rows} rows`);
+    }
+    if (weights.some((weight) => !(weight >= 0))) {
+      throw new RangeError("weights cannot be negative or missing");
+    }
+  }
+  const scale = weights?.map((weight) => Math.sqrt(weight));
+  const scaled = (value, row) => scale === undefined ? value : value * scale[row];
+  const columns = Array.from({ length: width }, (_, column) => design.map((row, index) => scaled(row[column], index)));
+  const projected = y.map(scaled);
+  const { householders, pivot, rank } = decompose(columns, tolerance, rows);
+  applyHouseholders(columns, householders, projected, Math.min(rank, rows - 1));
+  const solved = backSubstitute(columns, projected, rank);
+  const coefficients = new Array(width).fill(null);
+  pivot.slice(0, rank).forEach((column, position) => {
+    coefficients[column] = solved[position];
+  });
+  const fitted = design.map((row) => sum(zipWith(row, coefficients, (value, coefficient) => coefficient === null ? 0 : value * coefficient)));
+  const residuals = zipWith(y, fitted, (value, fit) => value - fit);
+  return { coefficients, fitted, residuals, rank };
+}
+function decompose(columns, tolerance, rows) {
+  const width = columns.length;
+  const pivot = columns.map((_, column) => column);
+  const originalNorms = columns.map((column) => norm(column, 0) || 1);
+  const householders = new Array(width).fill(0);
+  let live = width;
+  for (let step = 0;step < Math.min(rows, width); step++) {
+    while (step < live && norm(columns[step], step) < originalNorms[step] * tolerance) {
+      cycleToEnd(columns, pivot, originalNorms, step);
+      live -= 1;
+    }
+    if (step === rows - 1) {
+      continue;
+    }
+    householders[step] = reflect(columns, step, rows);
+  }
+  return { householders, pivot, rank: Math.min(live, rows) };
+}
+function reflect(columns, step, rows) {
+  const column = columns[step];
+  const length = norm(column, step);
+  if (length === 0) {
+    return 0;
+  }
+  const pivotNorm = column[step] < 0 ? -length : length;
+  for (let row = step;row < rows; row++) {
+    column[row] = column[row] / pivotNorm;
+  }
+  const leading = 1 + column[step];
+  column[step] = leading;
+  for (let index = step + 1;index < columns.length; index++) {
+    const other = columns[index];
+    let inner = 0;
+    for (let row = step;row < rows; row++) {
+      inner += column[row] * other[row];
+    }
+    const factor = -inner / leading;
+    for (let row = step;row < rows; row++) {
+      other[row] = other[row] + factor * column[row];
+    }
+  }
+  column[step] = -pivotNorm;
+  return leading;
+}
+function applyHouseholders(columns, householders, response, count) {
+  const rows = response.length;
+  for (let step = 0;step < count; step++) {
+    const leading = householders[step];
+    if (leading === 0) {
+      continue;
+    }
+    const column = columns[step];
+    let inner = leading * response[step];
+    for (let row = step + 1;row < rows; row++) {
+      inner += column[row] * response[row];
+    }
+    const factor = -inner / leading;
+    response[step] = response[step] + factor * leading;
+    for (let row = step + 1;row < rows; row++) {
+      response[row] = response[row] + factor * column[row];
+    }
+  }
+}
+function backSubstitute(columns, response, rank) {
+  const solved = new Array(rank).fill(0);
+  for (let row = rank - 1;row >= 0; row--) {
+    let value = response[row];
+    for (let column = row + 1;column < rank; column++) {
+      value -= columns[column][row] * solved[column];
+    }
+    solved[row] = value / columns[row][row];
+  }
+  return solved;
+}
+function cycleToEnd(columns, pivot, originalNorms, step) {
+  moveToEnd(columns, step);
+  moveToEnd(pivot, step);
+  moveToEnd(originalNorms, step);
+}
+function moveToEnd(track, from) {
+  const [moved] = track.splice(from, 1);
+  track.push(moved);
+}
+function norm(column, from) {
+  return Math.hypot(...column.slice(from));
+}
+
+// src/core/moderation.ts
+var GRID_STEPS = 15;
+function moderationSurface(data, options) {
+  const { outcome, iv, mod, interaction = true, controls = [] } = options;
+  if (iv === mod) {
+    throw new RangeError(`\`iv\` and \`mod\` must name different columns, both name "${iv}"`);
+  }
+  const named = new Set([outcome, iv, mod]);
+  controls.forEach((control) => {
+    if (named.has(control)) {
+      throw new RangeError(`control "${control}" already names the outcome, the iv, the mod, ` + "or another control");
+    }
+    named.add(control);
+  });
+  const rows = frameRows(data);
+  const y = requireNumericColumn(data, outcome, "outcome");
+  const ivColumn = requireNumericColumn(data, iv, "iv");
+  const modColumn = requireNumericColumn(data, mod, "mod");
+  const controlColumns = controls.map((control) => requireNumericColumn(data, control, "controls"));
+  const modelColumns = [y, ivColumn, modColumn, ...controlColumns];
+  const completeRows = y.map((_, row) => row).filter((row) => modelColumns.every((column) => Number.isFinite(column[row])));
+  if (completeRows.length === 0) {
+    throw new RangeError("the model has no complete rows: every row is missing a value in " + "the outcome, the IV, the moderator, or a control");
+  }
+  const designColumns = [
+    { name: "(Intercept)", values: new Array(rows).fill(1) },
+    { name: iv, values: ivColumn },
+    { name: mod, values: modColumn },
+    ...controls.map((control, index) => ({
+      name: control,
+      values: controlColumns[index]
+    })),
+    ...interaction ? [
+      {
+        name: `${iv}:${mod}`,
+        values: zipWith(ivColumn, modColumn, (a, b) => a * b)
+      }
+    ] : []
+  ];
+  const design = completeRows.map((row) => designColumns.map((column) => column.values[row]));
+  const fit = leastSquares(design, completeRows.map((row) => y[row]));
+  const coefficients = designColumns.map((column, index) => ({
+    name: column.name,
+    value: fit.coefficients[index] ?? null
+  }));
+  const fitted = new Array(rows).fill(Number.NaN);
+  const residuals = new Array(rows).fill(Number.NaN);
+  completeRows.forEach((row, survivor) => {
+    fitted[row] = fit.fitted[survivor];
+    residuals[row] = fit.residuals[survivor];
+  });
+  const ivValues = rSeq(...extent(ivColumn), GRID_STEPS);
+  const modValues = rSeq(...extent(modColumn), GRID_STEPS);
+  const holds = Object.fromEntries(controls.map((control, index) => [
+    control,
+    mean(controlColumns[index].filter(Number.isFinite))
+  ]));
+  const weights = coefficients.map((term) => term.value ?? 0);
+  const predictions = modValues.flatMap((modValue) => ivValues.map((ivValue) => {
+    const gridRow = [
+      1,
+      ivValue,
+      modValue,
+      ...controls.map((control) => holds[control]),
+      ...interaction ? [ivValue * modValue] : []
+    ];
+    return sum(zipWith(gridRow, weights, (value, weight) => value * weight));
+  }));
+  const [dataLow, dataHigh] = extent(y);
+  const [surfaceLow, surfaceHigh] = extent(predictions);
+  return {
+    coefficients,
+    fitted,
+    residuals,
+    ivValues,
+    modValues,
+    predictions,
+    zlim: [Math.min(dataLow, surfaceLow), Math.max(dataHigh, surfaceHigh)],
+    holds
+  };
+}
+function rSeq(from, to, length) {
+  if (from === to) {
+    return new Array(length).fill(from);
+  }
+  const by = (to - from) / (length - 1);
+  return Array.from({ length }, (_, index) => index === 0 ? from : index === length - 1 ? to : from + index * by);
+}
+// src/core/regression.ts
+function completePointRows(points) {
+  return points.flatMap((point, row) => Number.isFinite(point.x) && Number.isFinite(point.y) ? [row] : []);
+}
+function linearRegression(points) {
+  const rows = completePointRows(points);
+  if (rows.length === 0) {
+    return null;
+  }
+  const xs = rows.map((row) => points[row].x);
+  const ys = rows.map((row) => points[row].y);
+  const meanX = mean(xs);
+  const meanY = mean(ys);
+  const devX = xs.map((x) => x - meanX);
+  const devY = ys.map((y) => y - meanY);
+  const sumSquaresX = sum(devX.map((d) => d * d));
+  const sumSquaresY = sum(devY.map((d) => d * d));
+  const sumProducts = sum(zipWith(devX, devY, (dx, dy) => dx * dy));
+  const slope = sumSquaresX === 0 ? null : sumProducts / sumSquaresX;
+  const intercept = slope === null ? meanY : meanY - slope * meanX;
+  const correlation = sumSquaresX === 0 || sumSquaresY === 0 ? null : sumProducts / Math.sqrt(sumSquaresX * sumSquaresY);
+  const fittedComplete = xs.map((x) => slope === null ? intercept : intercept + slope * x);
+  const ssr = sum(fittedComplete.map((f) => (f - meanY) * (f - meanY)));
+  const sse = sum(zipWith(ys, fittedComplete, (y, f) => (y - f) * (y - f)));
+  const sst = sumSquaresY;
+  const rSquared = sst === 0 ? null : ssr / sst;
+  const fitted = new Array(points.length).fill(Number.NaN);
+  rows.forEach((row, survivor) => {
+    fitted[row] = fittedComplete[survivor];
+  });
+  return {
+    intercept,
+    slope,
+    correlation,
+    ssr,
+    sse,
+    sst,
+    rSquared,
+    fitted
+  };
+}
+// src/core/matrix.ts
+var SMALLEST_NORMAL = 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014;
+function determinant(matrix) {
+  return determinantOf(factorize(matrix));
+}
+function invertMatrix(matrix) {
+  const factorization = factorize(matrix);
+  const determinant2 = determinantOf(factorization);
+  const zeroPivot = zeroPivotOf(factorization);
+  if (zeroPivot !== null) {
+    return {
+      determinant: determinant2,
+      inverse: null,
+      singularity: "exact",
+      rcond: 0,
+      zeroPivot
+    };
+  }
+  const inverse = solveForIdentity(factorization);
+  const rcond = 1 / (oneNorm(matrix) * oneNorm(inverse));
+  if (rcond < Number.EPSILON) {
+    return {
+      determinant: determinant2,
+      inverse: null,
+      singularity: "computational",
+      rcond,
+      zeroPivot: null
+    };
+  }
+  return {
+    determinant: determinant2,
+    inverse,
+    singularity: null,
+    rcond,
+    zeroPivot: null
+  };
+}
+function factorize(matrix) {
+  const interchanged = Math.abs(matrix.y1) > Math.abs(matrix.x1);
+  const leading = interchanged ? matrix.y1 : matrix.x1;
+  const upperRight = interchanged ? matrix.y2 : matrix.x2;
+  const below = interchanged ? matrix.x1 : matrix.y1;
+  const belowRight = interchanged ? matrix.x2 : matrix.y2;
+  const multiplier = Math.abs(leading) >= SMALLEST_NORMAL ? below * (1 / leading) : below / leading;
+  const trailing = fusedMultiplyAdd(-multiplier, upperRight, belowRight);
+  return {
+    interchanged,
+    multiplier,
+    pivots: [leading, trailing],
+    upperRight
+  };
+}
+function determinantOf(factorization) {
+  const { interchanged, pivots } = factorization;
+  if (zeroPivotOf(factorization) !== null) {
+    return 0;
+  }
+  const modulus = sum(pivots.map((pivot) => Math.log(Math.abs(pivot))));
+  const sign = pivots.reduce((carried, pivot) => pivot < 0 ? -carried : carried, interchanged ? -1 : 1);
+  return sign * Math.exp(modulus);
+}
+function zeroPivotOf(factorization) {
+  const [leading, trailing] = factorization.pivots;
+  if (leading === 0) {
+    return 1;
+  }
+  return trailing === 0 ? 2 : null;
+}
+function solveForIdentity(factorization) {
+  const { interchanged } = factorization;
+  const [firstTop, firstBottom] = interchanged ? [0, 1] : [1, 0];
+  const [secondTop, secondBottom] = interchanged ? [1, 0] : [0, 1];
+  const [x1, y1] = solveColumn(factorization, firstTop, firstBottom);
+  const [x2, y2] = solveColumn(factorization, secondTop, secondBottom);
+  return {
+    x1: withoutNegativeZero(x1),
+    y1: withoutNegativeZero(y1),
+    x2: withoutNegativeZero(x2),
+    y2: withoutNegativeZero(y2)
+  };
+}
+function solveColumn(factorization, top, bottom) {
+  const { multiplier, pivots, upperRight } = factorization;
+  const lower = fusedMultiplyAdd(-multiplier, top, bottom) / pivots[1];
+  const upper = fusedMultiplyAdd(-upperRight, lower, top) / pivots[0];
+  return [upper, lower];
+}
+function oneNorm(matrix) {
+  return Math.max(Math.abs(matrix.x1) + Math.abs(matrix.y1), Math.abs(matrix.x2) + Math.abs(matrix.y2));
+}
+// src/core/pca.ts
+function principalComponents(points) {
+  const rows = completePointRows(points);
+  if (rows.length === 0) {
+    return null;
+  }
+  const complete = rows.map((row) => points[row]);
+  const centerX = mean(complete.map((point) => point.x));
+  const centerY = mean(complete.map((point) => point.y));
+  const devX = complete.map((point) => point.x - centerX);
+  const devY = complete.map((point) => point.y - centerY);
+  const divisor = Math.max(1, complete.length - 1);
+  const varX = sum(devX.map((d) => d * d)) / divisor;
+  const varY = sum(devY.map((d) => d * d)) / divisor;
+  const covariance = sum(zipWith(devX, devY, (dx, dy) => dx * dy)) / divisor;
+  const [first, second] = componentsOf(varX, varY, covariance);
+  const scores = points.map(() => ({ x: Number.NaN, y: Number.NaN }));
+  rows.forEach((row, survivor) => {
+    const dx = devX[survivor];
+    const dy = devY[survivor];
+    scores[row] = {
+      x: dx * first.loadings[0] + dy * first.loadings[1],
+      y: dx * second.loadings[0] + dy * second.loadings[1]
+    };
+  });
+  return {
+    sdev: [sdevOf(first.variance), sdevOf(second.variance)],
+    rotation: [first.loadings, second.loadings],
+    center: { x: centerX, y: centerY },
+    scores
+  };
+}
+function componentsOf(varX, varY, covariance) {
+  if (covariance === 0) {
+    const alongX = { variance: varX, loadings: [1, 0] };
+    const alongY = { variance: varY, loadings: [0, 1] };
+    return varX >= varY ? [alongX, alongY] : [alongY, alongX];
+  }
+  const middle = (varX + varY) / 2;
+  const spread = Math.hypot((varX - varY) / 2, covariance);
+  const larger = middle + spread;
+  const smaller = middle - spread;
+  const fromRowX = larger - varX;
+  const fromRowY = larger - varY;
+  const direction = fromRowX >= fromRowY ? [covariance, fromRowX] : [fromRowY, covariance];
+  const leading = signed(unit(direction));
+  const trailing = signed([negated(leading[1]), leading[0]]);
+  return [
+    { variance: larger, loadings: leading },
+    { variance: smaller, loadings: trailing }
+  ];
+}
+function unit(vector) {
+  const length = Math.hypot(vector[0], vector[1]);
+  return [vector[0] / length, vector[1] / length];
+}
+function signed(vector) {
+  const dominant = Math.abs(vector[0]) >= Math.abs(vector[1]) ? vector[0] : vector[1];
+  return dominant >= 0 ? vector : [negated(vector[0]), negated(vector[1])];
+}
+function negated(value) {
+  return withoutNegativeZero(-value);
+}
+function sdevOf(variance) {
+  return Math.sqrt(Math.max(0, variance));
+}
+// src/core/logit.ts
+var DEFAULT_LOGIT_EPSILON = 0.00000001;
+var DEFAULT_LOGIT_MAX_ITERATIONS = 25;
+var LINK_THRESHOLD = 30;
+var BOUND = 10 * Number.EPSILON;
+function logisticRegression(points, options = {}) {
+  const {
+    epsilon = DEFAULT_LOGIT_EPSILON,
+    maxIterations = DEFAULT_LOGIT_MAX_ITERATIONS
+  } = options;
+  const rows = completePointRows(points);
+  if (rows.length === 0) {
+    return null;
+  }
+  const complete = rows.map((row) => points[row]);
+  if (complete.some((point) => point.y !== 0 && point.y !== 1)) {
+    throw new RangeError("every outcome must be 0 or 1");
+  }
+  const outcomes = complete.map((point) => point.y);
+  const design = complete.map((point) => [1, point.x]);
+  let fitted = outcomes.map((outcome) => (outcome + 0.5) / 2);
+  let predictors = fitted.map(logit);
+  let previousDeviance = totalDeviance(outcomes, fitted);
+  let deviance = previousDeviance;
+  let coefficients = [Number.NaN, null];
+  let rank = 0;
+  let iterations = 0;
+  let converged = false;
+  for (let iteration = 1;iteration <= maxIterations; iteration++) {
+    iterations = iteration;
+    const working = predictors.map((predictor, row) => {
+      const probability = fitted[row];
+      const slope = linkSlope(predictor);
+      return {
+        weight: slope * slope / (probability * (1 - probability)),
+        response: predictor + (outcomes[row] - probability) / slope
+      };
+    });
+    const step = leastSquares(design, working.map((row) => row.response), {
+      weights: working.map((row) => row.weight),
+      tolerance: Math.min(0.0000001, epsilon / 1000)
+    });
+    if (step.coefficients.some((coefficient) => coefficient !== null && !Number.isFinite(coefficient))) {
+      break;
+    }
+    coefficients = step.coefficients;
+    rank = step.rank;
+    predictors = design.map((row) => sum(zipWith(row, coefficients, (value, coefficient) => coefficient === null ? 0 : value * coefficient)));
+    fitted = predictors.map(linkInverse);
+    deviance = totalDeviance(outcomes, fitted);
+    if (Math.abs(deviance - previousDeviance) / (0.1 + Math.abs(deviance)) < epsilon) {
+      converged = true;
+      break;
+    }
+    previousDeviance = deviance;
+  }
+  const wholeMean = mean(outcomes);
+  const nullDeviance = totalDeviance(outcomes, outcomes.map(() => wholeMean));
+  const paddedFitted = new Array(points.length).fill(Number.NaN);
+  const paddedPredictors = new Array(points.length).fill(Number.NaN);
+  rows.forEach((row, survivor) => {
+    paddedFitted[row] = fitted[survivor];
+    paddedPredictors[row] = predictors[survivor];
+  });
+  return {
+    intercept: coefficients[0] ?? Number.NaN,
+    slope: coefficients[1] ?? null,
+    fitted: paddedFitted,
+    linearPredictors: paddedPredictors,
+    deviance,
+    nullDeviance,
+    aic: deviance + 2 * rank,
+    rank,
+    iterations,
+    converged,
+    saturated: fitted.some((probability) => probability > 1 - BOUND || probability < BOUND)
+  };
+}
+function predictLogit(fit, x) {
+  return linkInverse(fit.intercept + (fit.slope ?? 0) * x);
+}
+function logit(probability) {
+  return Math.log(probability / (1 - probability));
+}
+function linkInverse(predictor) {
+  const odds = predictor < -LINK_THRESHOLD ? Number.EPSILON : predictor > LINK_THRESHOLD ? 1 / Number.EPSILON : Math.exp(predictor);
+  return odds / (1 + odds);
+}
+function linkSlope(predictor) {
+  if (predictor > LINK_THRESHOLD || predictor < -LINK_THRESHOLD) {
+    return Number.EPSILON;
+  }
+  const odds = Math.exp(predictor);
+  return odds / ((1 + odds) * (1 + odds));
+}
+function totalDeviance(outcomes, probabilities) {
+  return sum(zipWith(outcomes, probabilities, (outcome, probability) => 2 * (surprise(outcome, probability) + surprise(1 - outcome, 1 - probability))));
+}
+function surprise(outcome, probability) {
+  return outcome !== 0 ? outcome * Math.log(outcome / probability) : 0;
+}
+// src/core/special.ts
+var LANCZOS_G = 607 / 128;
+var LANCZOS_LEAD = 0.9999999999999971;
+var LANCZOS_TAIL = [
+  57.15623566586292,
+  -59.59796035547549,
+  14.136097974741746,
+  -0.4919138160976202,
+  0.00003399464998481189,
+  0.00004652362892704858,
+  -0.00009837447530487956,
+  0.0001580887032249125,
+  -0.00021026444172410488,
+  0.00021743961811521265,
+  -0.0001643181065367639,
+  0.00008441822398385275,
+  -0.000026190838401581408,
+  0.0000036899182659531625
+];
+var LOG_SQRT_TWO_PI = 0.5 * Math.log(2 * Math.PI);
+function lanczosSeries(x) {
+  return LANCZOS_LEAD + sum(LANCZOS_TAIL.map((coefficient, index) => coefficient / (x + index)));
+}
+function logGamma(x) {
+  if (!(x > 0)) {
+    return Number.NaN;
+  }
+  const shifted = x + LANCZOS_G - 0.5;
+  return LOG_SQRT_TWO_PI + (x - 0.5) * Math.log(shifted) - shifted + Math.log(lanczosSeries(x));
+}
+function logBeta(a, b) {
+  if (!(a > 0) || !(b > 0)) {
+    return Number.NaN;
+  }
+  const shiftedSum = a + b + LANCZOS_G - 0.5;
+  return LOG_SQRT_TWO_PI - (LANCZOS_G - 0.5) + Math.log(lanczosSeries(a)) + Math.log(lanczosSeries(b)) - Math.log(lanczosSeries(a + b)) + (a - 0.5) * Math.log1p(-b / shiftedSum) + (b - 0.5) * Math.log1p(-a / shiftedSum) - 0.5 * Math.log(shiftedSum);
+}
+var FRACTION_MAX_STEPS = 400;
+var FRACTION_EPSILON = 0.0000000000000003;
+var FRACTION_FLOOR = 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001;
+function betaContinuedFraction(x, a, b) {
+  const total = a + b;
+  const aPlus = a + 1;
+  const aMinus = a - 1;
+  let c = 1;
+  let d = 1 - total * x / aPlus;
+  if (Math.abs(d) < FRACTION_FLOOR) {
+    d = FRACTION_FLOOR;
+  }
+  d = 1 / d;
+  let value = d;
+  for (let step = 1;step <= FRACTION_MAX_STEPS; step += 1) {
+    const twice = 2 * step;
+    const even = step * (b - step) * x / ((aMinus + twice) * (a + twice));
+    d = 1 + even * d;
+    if (Math.abs(d) < FRACTION_FLOOR) {
+      d = FRACTION_FLOOR;
+    }
+    c = 1 + even / c;
+    if (Math.abs(c) < FRACTION_FLOOR) {
+      c = FRACTION_FLOOR;
+    }
+    d = 1 / d;
+    value *= d * c;
+    const odd = -(a + step) * (total + step) * x / ((a + twice) * (aPlus + twice));
+    d = 1 + odd * d;
+    if (Math.abs(d) < FRACTION_FLOOR) {
+      d = FRACTION_FLOOR;
+    }
+    c = 1 + odd / c;
+    if (Math.abs(c) < FRACTION_FLOOR) {
+      c = FRACTION_FLOOR;
+    }
+    d = 1 / d;
+    const delta = d * c;
+    value *= delta;
+    if (Math.abs(delta - 1) < FRACTION_EPSILON) {
+      break;
+    }
+  }
+  return value;
+}
+function incompleteBeta(x, a, b) {
+  if (Number.isNaN(x)) {
+    return Number.NaN;
+  }
+  if (x <= 0) {
+    return 0;
+  }
+  if (x >= 1) {
+    return 1;
+  }
+  return incompleteBetaSplit(x, 1 - x, a, b);
+}
+function incompleteBetaSplit(x, complement, a, b) {
+  if (Number.isNaN(x) || Number.isNaN(complement) || !(a > 0) || !(b > 0)) {
+    return Number.NaN;
+  }
+  if (x <= 0) {
+    return 0;
+  }
+  if (complement <= 0) {
+    return 1;
+  }
+  const logX = complement < 0.5 ? Math.log1p(-complement) : Math.log(x);
+  const logComplement = x < 0.5 ? Math.log1p(-x) : Math.log(complement);
+  const front = Math.exp(a * logX + b * logComplement - logBeta(a, b));
+  if (x < (a + 1) / (a + b + 2)) {
+    return front * betaContinuedFraction(x, a, b) / a;
+  }
+  return 1 - front * betaContinuedFraction(complement, b, a) / b;
+}
+var GAMMA_MAX_STEPS = 1000;
+var GAMMA_EPSILON = 0.0000000000000003;
+function lowerGammaSeries(a, x) {
+  let term = 1 / a;
+  let total = term;
+  for (let step = 1;step <= GAMMA_MAX_STEPS; step += 1) {
+    term *= x / (a + step);
+    total += term;
+    if (Math.abs(term) < Math.abs(total) * GAMMA_EPSILON) {
+      break;
+    }
+  }
+  return total * Math.exp(-x + a * Math.log(x) - logGamma(a));
+}
+function upperGammaFraction(a, x) {
+  let b = x + 1 - a;
+  let c = 1 / FRACTION_FLOOR;
+  let d = 1 / b;
+  let value = d;
+  for (let step = 1;step <= GAMMA_MAX_STEPS; step += 1) {
+    const numerator = -step * (step - a);
+    b += 2;
+    d = numerator * d + b;
+    if (Math.abs(d) < FRACTION_FLOOR) {
+      d = FRACTION_FLOOR;
+    }
+    c = b + numerator / c;
+    if (Math.abs(c) < FRACTION_FLOOR) {
+      c = FRACTION_FLOOR;
+    }
+    d = 1 / d;
+    const delta = d * c;
+    value *= delta;
+    if (Math.abs(delta - 1) < GAMMA_EPSILON) {
+      break;
+    }
+  }
+  return value * Math.exp(-x + a * Math.log(x) - logGamma(a));
+}
+function upperGamma(a, x) {
+  if (x <= 0) {
+    return 1;
+  }
+  if (!Number.isFinite(x)) {
+    return 0;
+  }
+  return x < a + 1 ? 1 - lowerGammaSeries(a, x) : upperGammaFraction(a, x);
+}
+function normalCdf(z) {
+  if (Number.isNaN(z)) {
+    return Number.NaN;
+  }
+  const lower = 0.5 * upperGamma(0.5, 0.5 * z * z);
+  return z > 0 ? 1 - lower : lower;
+}
+var BELOW_ONE = 1 - Number.EPSILON / 2;
+var INVERSE_MAX_STEPS = 200;
+function inverseGuess(p, a, b) {
+  if (a >= 1 && b >= 1) {
+    const tail = p < 0.5 ? p : 1 - p;
+    const t = Math.sqrt(-2 * Math.log(tail));
+    const normal = (p < 0.5 ? -1 : 1) * ((2.30753 + t * 0.27061) / (1 + t * (0.99229 + t * 0.04481)) - t);
+    const scale = (normal * normal - 3) / 6;
+    const harmonic = 2 / (1 / (2 * a - 1) + 1 / (2 * b - 1));
+    const w = normal * Math.sqrt(scale + harmonic) / harmonic - (1 / (2 * b - 1) - 1 / (2 * a - 1)) * (scale + 5 / 6 - 2 / (3 * harmonic));
+    return a / (a + b * Math.exp(2 * w));
+  }
+  const lower = Math.exp(a * Math.log(a / (a + b))) / a;
+  const upper = Math.exp(b * Math.log(b / (a + b))) / b;
+  const total = lower + upper;
+  if (p < lower / total) {
+    return Math.pow(a * total * p, 1 / a);
+  }
+  return 1 - Math.pow(b * total * (1 - p), 1 / b);
+}
+function inverseIncompleteBeta(p, a, b) {
+  if (Number.isNaN(p) || !(a > 0) || !(b > 0)) {
+    return Number.NaN;
+  }
+  if (p <= 0) {
+    return 0;
+  }
+  if (p >= 1) {
+    return 1;
+  }
+  const logBetaValue = logBeta(a, b);
+  let lower = 0;
+  let upper = 1;
+  let x = inverseGuess(p, a, b);
+  if (!(x > 0) || !(x < 1)) {
+    x = 0.5;
+  }
+  for (let step = 0;step < INVERSE_MAX_STEPS; step += 1) {
+    const residual = incompleteBeta(x, a, b) - p;
+    if (residual < 0) {
+      lower = x;
+    } else {
+      upper = x;
+    }
+    const density = Math.exp((a - 1) * Math.log(x) + (b - 1) * Math.log1p(-x) - logBetaValue);
+    let next = density > 0 && Number.isFinite(density) ? x - residual / density : Number.NaN;
+    if (!(next > lower) || !(next < upper)) {
+      next = 0.5 * (lower + upper);
+    }
+    if (next === x) {
+      break;
+    }
+    const moved = Math.abs(next - x);
+    x = next;
+    if (moved <= Number.EPSILON * x) {
+      break;
+    }
+  }
+  return Math.min(x, BELOW_ONE);
+}
+
+// src/core/tdist.ts
+function isNonCentral(ncp) {
+  return ncp !== undefined && ncp !== 0;
+}
+function isBadArgument(value, df, ncp) {
+  return Number.isNaN(value) || !(df > 0) || ncp !== undefined && Number.isNaN(ncp);
+}
+function dt(x, df, ncp) {
+  if (isBadArgument(x, df, ncp)) {
+    return Number.NaN;
+  }
+  return isNonCentral(ncp) ? nonCentralDensity(x, df, ncp) : centralDensity(x, df);
+}
+function pt(x, df, ncp) {
+  if (isBadArgument(x, df, ncp)) {
+    return Number.NaN;
+  }
+  return isNonCentral(ncp) ? nonCentralProbability(x, df, ncp) : centralProbability(x, df);
+}
+function qt(p, df, ncp) {
+  if (isBadArgument(p, df, ncp) || p < 0 || p > 1) {
+    return Number.NaN;
+  }
+  return isNonCentral(ncp) ? nonCentralQuantile(p, df, ncp) : centralQuantile(p, df);
+}
+function centralDensity(x, df) {
+  if (!Number.isFinite(x)) {
+    return 0;
+  }
+  const logDensity = -0.5 * Math.log(df) - logBeta(0.5, df / 2) - (df + 1) / 2 * Math.log1p(x * x / df);
+  return Math.exp(logDensity);
+}
+function centralProbability(x, df) {
+  if (x === 0) {
+    return 0.5;
+  }
+  if (x === Number.POSITIVE_INFINITY) {
+    return 1;
+  }
+  if (x === Number.NEGATIVE_INFINITY) {
+    return 0;
+  }
+  const tail = upperTail(Math.abs(x), df);
+  return x < 0 ? tail : 1 - tail;
+}
+function upperTail(t, df) {
+  const squared = t * t;
+  if (!Number.isFinite(squared)) {
+    return 0;
+  }
+  const total = df + squared;
+  return 0.5 * incompleteBetaSplit(df / total, squared / total, df / 2, 0.5);
+}
+var POLISH_MAX_STEPS = 4;
+function centralQuantile(p, df) {
+  if (p === 0.5) {
+    return 0;
+  }
+  if (p <= 0) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  if (p >= 1) {
+    return Number.POSITIVE_INFINITY;
+  }
+  const tail = p < 0.5 ? p : 1 - p;
+  const sign = p < 0.5 ? -1 : 1;
+  const twoSided = 2 * tail;
+  let squared;
+  if (twoSided > 0.5) {
+    const near = inverseIncompleteBeta(1 - twoSided, 0.5, df / 2);
+    squared = df * near / (1 - near);
+  } else {
+    const far = inverseIncompleteBeta(twoSided, df / 2, 0.5);
+    squared = df * (1 - far) / far;
+  }
+  return sign * polish(Math.sqrt(squared), tail, df);
+}
+function polish(start, tail, df) {
+  let t = start;
+  for (let step = 0;step < POLISH_MAX_STEPS; step += 1) {
+    const density = centralDensity(t, df);
+    if (!(density > 0) || !Number.isFinite(t)) {
+      break;
+    }
+    const move = (upperTail(t, df) - tail) / density;
+    const next = t + move;
+    if (!(next > 0) || !Number.isFinite(next) || Math.abs(move) > 0.25 * t) {
+      break;
+    }
+    if (next === t) {
+      break;
+    }
+    t = next;
+    if (Math.abs(move) <= Number.EPSILON * t) {
+      break;
+    }
+  }
+  return t;
+}
+var SERIES_MAX_STEPS = 1000;
+var SERIES_ERROR_MAX = 0.000000000001;
+var SERIES_NCP_LIMIT_SQUARED = 2 * Math.LN2 * 1022;
+var SERIES_DF_LIMIT = 400000;
+var SQRT_TWO_OVER_PI = Math.sqrt(2 / Math.PI);
+function nonCentralProbability(x, df, ncp) {
+  if (x === Number.POSITIVE_INFINITY) {
+    return 1;
+  }
+  if (x === Number.NEGATIVE_INFINITY) {
+    return 0;
+  }
+  const reflected = x < 0;
+  const t = reflected ? -x : x;
+  const delta = reflected ? -ncp : ncp;
+  const lower = df > SERIES_DF_LIMIT || delta * delta > SERIES_NCP_LIMIT_SQUARED ? normalApproximation(t, df, delta) : lenthSeries(t, df, delta);
+  return reflected ? 1 - lower : lower;
+}
+function normalApproximation(t, df, delta) {
+  const shrink = 1 / (4 * df);
+  const spread = Math.sqrt(1 + t * t * 2 * shrink);
+  return normalCdf((t * (1 - shrink) - delta) / spread);
+}
+function lenthSeries(t, df, delta) {
+  const squared = t * t;
+  const total = df + squared;
+  const x = squared / total;
+  const complement = df / total;
+  let sum2 = 0;
+  if (x > 0) {
+    const lambda = delta * delta;
+    let oddWeight = 0.5 * Math.exp(-0.5 * lambda);
+    let evenWeight = SQRT_TWO_OVER_PI * oddWeight * delta;
+    let remaining = 0.5 - oddWeight;
+    if (remaining < 0.0000001) {
+      remaining = -0.5 * Math.expm1(-0.5 * lambda);
+    }
+    let a = 0.5;
+    const b = 0.5 * df;
+    const powered = Math.pow(complement, b);
+    const logBetaValue = logBeta(0.5, b);
+    let oddTerm = incompleteBetaSplit(x, complement, a, b);
+    let oddStep = 2 * powered * Math.exp(a * Math.log(x) - logBetaValue);
+    let evenTerm = 1 - powered;
+    let evenStep = b * x * powered;
+    sum2 = oddWeight * oddTerm + evenWeight * evenTerm;
+    for (let step = 1;step <= SERIES_MAX_STEPS; step += 1) {
+      a += 1;
+      oddTerm -= oddStep;
+      evenTerm -= evenStep;
+      oddStep *= x * (a + b - 1) / a;
+      evenStep *= x * (a + b - 0.5) / (a + 0.5);
+      oddWeight *= lambda / (2 * step);
+      evenWeight *= lambda / (2 * step + 1);
+      remaining -= oddWeight;
+      if (remaining <= 0) {
+        break;
+      }
+      sum2 += oddWeight * oddTerm + evenWeight * evenTerm;
+      if (Math.abs(2 * remaining * (oddTerm - oddStep)) < SERIES_ERROR_MAX) {
+        break;
+      }
+    }
+  }
+  return Math.min(Math.max(sum2 + normalCdf(-delta), 0), 1);
+}
+function nonCentralDensity(x, df, ncp) {
+  if (!Number.isFinite(x)) {
+    return 0;
+  }
+  if (Math.abs(x) > Math.sqrt(df * Number.EPSILON)) {
+    const stepped = x * Math.sqrt((df + 2) / df);
+    const difference = nonCentralProbability(stepped, df + 2, ncp) - nonCentralProbability(x, df, ncp);
+    return df / Math.abs(x) * Math.abs(difference);
+  }
+  return Math.exp(-0.5 * Math.log(df) - logBeta(0.5, df / 2) - 0.5 * ncp * ncp);
+}
+var QUANTILE_MAX_STEPS = 200;
+function nonCentralQuantile(p, df, ncp) {
+  if (p <= 0) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  if (p >= 1) {
+    return Number.POSITIVE_INFINITY;
+  }
+  let upper = Math.max(1, ncp);
+  while (Number.isFinite(upper) && nonCentralProbability(upper, df, ncp) < p) {
+    upper *= 2;
+  }
+  let lower = Math.min(-1, -ncp);
+  while (Number.isFinite(lower) && nonCentralProbability(lower, df, ncp) > p) {
+    lower *= 2;
+  }
+  let t = 0.5 * (lower + upper);
+  for (let step = 0;step < QUANTILE_MAX_STEPS; step += 1) {
+    const residual = nonCentralProbability(t, df, ncp) - p;
+    if (residual < 0) {
+      lower = t;
+    } else {
+      upper = t;
+    }
+    const density = nonCentralDensity(t, df, ncp);
+    let next = density > 0 && Number.isFinite(density) ? t - residual / density : Number.NaN;
+    if (!(next > lower) || !(next < upper)) {
+      next = 0.5 * (lower + upper);
+    }
+    if (next === t) {
+      break;
+    }
+    const moved = Math.abs(next - t);
+    t = next;
+    if (moved <= Number.EPSILON * Math.abs(t)) {
+      break;
+    }
+  }
+  return t;
+}
+// src/core/ttest.ts
+var DEFAULT_T_TEST_OPTIONS = {
+  diff: 0.5,
+  sd: 4,
+  n: 100,
+  alpha: 0.05
+};
+var FILL_UPPER_QUANTILE = 0.999;
+function tTestStats(options = {}) {
+  const { diff, sd: sd2, n, alpha } = { ...DEFAULT_T_TEST_OPTIONS, ...options };
+  const df = n - 1;
+  const t = diff / (sd2 / Math.sqrt(n));
+  const criticalValue = qt(1 - alpha, df);
+  const beta = pt(criticalValue, df, t);
+  const power = 1 - beta;
+  const altMedian = qt(0.5, df, t);
+  const altFillFrom = qt(beta, df, t);
+  return {
+    diff,
+    sd: sd2,
+    n,
+    alpha,
+    df,
+    t,
+    criticalValue,
+    beta,
+    power,
+    altMedian,
+    altMedianDensity: dt(altMedian, df, t),
+    altFill: {
+      from: altFillFrom,
+      to: qt(FILL_UPPER_QUANTILE, df, t)
+    },
+    nullFill: {
+      from: criticalValue,
+      to: qt(FILL_UPPER_QUANTILE, df)
+    },
+    errorMatrix: {
+      typeOne: alpha,
+      correctReject: power,
+      correctFailToReject: 1 - alpha,
+      typeTwo: beta,
+      highlightTopRow: altFillFrom < altMedian
+    }
+  };
+}
+// src/data/moderationData.ts
+var moderationData = {
+  y: [
+    -7.272897200071196,
+    -1.8368504105536234,
+    2.4825030269210964,
+    6.0885502472158235,
+    -2.7813932586215913,
+    -1.404547743484975,
+    -2.328370225641195,
+    0.24770227680217238,
+    -1.0630104614416778,
+    -2.0458910688111343,
+    -5.134105295915988,
+    18.10246414109479,
+    -3.4663420296290077,
+    -1.0047522093312424,
+    -0.8247466640897548,
+    0.011971257899126564,
+    -2.4321918294924254,
+    -14.110628278307653,
+    -1.5077118301445713,
+    -3.3519580636316557,
+    0.3422839785409655,
+    -1.4420566151665186,
+    -0.09954101599791107,
+    -4.171757229061835,
+    5.638370200339164,
+    -0.24209932633994577,
+    -0.9294220298667977,
+    -0.1430677581344491,
+    -0.7519187319967391,
+    -2.6149345603765624,
+    1.9162030995224288,
+    2.882308922335612,
+    -4.1366719661768885,
+    -1.5262757249783787,
+    -0.13241561132928859,
+    1.0868995782488633,
+    -5.43223982082246,
+    -1.0526454319438507,
+    -5.336080703693647,
+    0.8037058943922428,
+    0.6456670109243666,
+    -0.580865310517441,
+    5.995820813731591,
+    -3.748881331929856,
+    4.799106863920568,
+    3.917014743258661,
+    -2.52057971625805,
+    1.0052100508228277,
+    -1.2592451123609627,
+    -1.4191054380364576,
+    -2.7688068774363885,
+    -1.1283556266006958,
+    -5.015571911735988,
+    0.7443650892965741,
+    1.3457889732609731,
+    -1.5775936354323048,
+    0.24940175331052905,
+    0.8453453656305834,
+    9.108639550485199,
+    -1.089576439866974,
+    -0.0548347508354996,
+    3.4396743692990768,
+    1.82777129315956,
+    -9.08768179039613,
+    -1.6403441299936004,
+    6.344112012159234,
+    3.0068415808329494,
+    1.0402916701960967,
+    -10.792485667257104,
+    0.19774249672127087,
+    -2.6230964327485333,
+    -1.5340564759379902,
+    1.72657398132359,
+    -4.472744132233102,
+    0.051358701883551766,
+    3.4112581498484817,
+    1.7155585583877218,
+    -2.4096746494084527,
+    -3.658089954388166,
+    -4.219629941316109,
+    5.770611553647898,
+    -4.03685548370302,
+    -1.8534915424952012,
+    -1.4551065653571458,
+    -0.5733313061368043,
+    1.2587331393918402,
+    -0.1807495531690153,
+    -1.7541060455623132,
+    -7.181673967259479,
+    2.268171576280935,
+    -2.2618552849857134,
+    -1.0033432551835315,
+    -1.5998101004488254,
+    13.776336779706227,
+    -1.360193467035638,
+    0.8437705359604352,
+    0.26923062515768637,
+    -6.158720480354257,
+    0.2845594239106771,
+    -3.7313390977173673,
+    2.209575611277963,
+    4.957315515246748,
+    -1.1074416328100625,
+    6.773590899689121,
+    -1.1622855609602678,
+    -0.1468882418607233,
+    -1.8138297100034615,
+    -0.8822977247856844,
+    -2.531058796320521,
+    0.9225068493015128,
+    1.0529999297345707,
+    -1.0226841183124429,
+    -0.6282619133683303,
+    0.047095104558446066,
+    -2.1862971987559754,
+    1.9185432668727294,
+    -1.4157898788687031,
+    3.8559400012867275,
+    4.8196910254616006,
+    1.1859049624611124,
+    2.1292032810255828,
+    -2.580469493916582,
+    0.7806460650847441,
+    -0.7717747448671646,
+    4.302323128742706,
+    1.1280497997890846,
+    -3.3823450205179935,
+    -2.8141768087650334,
+    1.9176969652481777,
+    -1.8022438527307034,
+    0.5676992260859575,
+    -1.1988798479187797,
+    -0.8112714289530125,
+    3.0023694027723717,
+    6.313814189291469,
+    -0.7209131724573175,
+    -0.4934212971184535,
+    -5.311645069538028,
+    1.5864321371634191,
+    -1.3767448543412033,
+    -0.32149297043332475,
+    -2.7378068772633672,
+    0.44512957644982276,
+    1.014415590908376,
+    -0.3398299559551271,
+    3.6424411700938926,
+    -0.804849649687885,
+    0.26491344714041165,
+    1.0255159271802998,
+    -3.4431481857611512,
+    -1.261772843081508,
+    2.4072718264535986,
+    4.18584814419661,
+    0.8444989650012846,
+    0.6890664424805704,
+    -4.930173029208773,
+    1.3181686730513686,
+    -3.950474574106549,
+    0.6996653997568072,
+    -7.733171334446728,
+    0.37966613312994063,
+    2.098048515776042,
+    0.5869676229216956,
+    -0.09533520375390134,
+    -1.3602473690753563,
+    -1.8363341184552933,
+    -5.327197109758741,
+    -2.4667878836756927,
+    -0.8477118043370667,
+    1.794347325600735,
+    -1.1215052328640052,
+    0.9693808927847424,
+    -8.852509568972764,
+    -10.171192748327044,
+    5.515479360644947,
+    0.8133474344349123,
+    1.5442257490953633,
+    -2.3028072866769134,
+    0.6898369821689965,
+    1.9915198521027817,
+    2.832247846170376,
+    0.34764862749885805,
+    -0.5034271262990748,
+    1.1733004427545144,
+    0.18449984894824215,
+    -1.9938893833160367,
+    0.8829064829548916,
+    0.6266797217305222,
+    -3.9311936779928676,
+    -4.693057322327316,
+    0.5942425542793619,
+    -0.04091322810348444,
+    1.5529759191506414,
+    0.5255897517761228,
+    -0.5181252414019946,
+    5.713823828860155,
+    0.8064569522257248,
+    2.7208395005315182,
+    -1.9931388422548042,
+    2.0982441518090775
+  ],
+  x: [
+    2.741916894293337,
+    -1.1293963427921776,
+    0.7262568226746783,
+    1.265725209922081,
+    0.8085366462819982,
+    -0.21224903218296798,
+    3.023043994877878,
+    -0.18931807682619511,
+    4.036847427754083,
+    -0.125428198104842,
+    2.6097393084469704,
+    4.573290785402214,
+    -2.7777214022246786,
+    -0.5575775336347428,
+    -0.266642672787316,
+    1.271900796140149,
+    -0.5685058428321448,
+    -5.312910841809552,
+    -4.880933857151038,
+    2.640226691460384,
+    -0.6132771881569492,
+    -3.562616867960001,
+    -0.3438347115192427,
+    2.429349398345198,
+    3.7903869225299305,
+    -0.8609382632123992,
+    -0.5145387655378593,
+    -3.5263261703895603,
+    0.9201947096625428,
+    -1.2799897519202386,
+    0.9109002464824387,
+    1.4096746744576383,
+    2.0702070439398446,
+    -1.2178527508144228,
+    1.0099102465959404,
+    -3.434017358146686,
+    -1.5689180167589927,
+    -1.7018151883530368,
+    -4.828415299893265,
+    0.07224521378451125,
+    0.41199720040050775,
+    -0.7221145970973324,
+    1.516326471399034,
+    -1.4534096541531503,
+    -2.736562088838589,
+    0.8656360517774341,
+    -1.6227863523733432,
+    2.8882025234425055,
+    -0.8628924052266909,
+    1.3112957668044132,
+    0.6438505304078931,
+    -1.5676778817607508,
+    3.1514550395839547,
+    1.285798611434633,
+    0.17952129319921128,
+    0.5531014945829259,
+    1.3585776321105416,
+    0.17966577315816343,
+    -5.98618016630587,
+    0.5697659070613188,
+    -0.7344692854819507,
+    0.3704611297312187,
+    1.1636474547310138,
+    2.799473654585356,
+    -1.45458411894893,
+    2.605085264088287,
+    0.6716962395041488,
+    2.0770121973952422,
+    1.8414571365812926,
+    1.4417563257337251,
+    -2.08623787713571,
+    -0.18037277322141337,
+    1.2470363239990871,
+    -1.907046715544688,
+    -1.0856576291477136,
+    1.1619929953633648,
+    1.536357475669182,
+    0.9275351770803344,
+    -1.771552594819359,
+    -2.199561797295711,
+    3.025414019609856,
+    0.5158428750640617,
+    0.17688045831917268,
+    -0.24179307507817885,
+    -2.3886577903210564,
+    1.2239937960807739,
+    -0.4342796914930417,
+    -0.3655134126638434,
+    1.8666926571423201,
+    1.643546221016498,
+    2.784232751868542,
+    -0.9523478461093488,
+    1.3006971214526097,
+    2.7822209127800015,
+    -2.2215777588957977,
+    -1.7215851737556847,
+    -2.26347736170754,
+    -2.9184279990047917,
+    0.15996510648232234,
+    1.30640867929838,
+    2.4019307511969883,
+    2.0895021743354505,
+    -2.006417293679696,
+    3.696963803345493,
+    -1.3335468175156342,
+    0.21102762491213886,
+    -0.8445117637377121,
+    -0.24470034390994258,
+    0.37638606900299576,
+    0.23832191599401276,
+    -0.050185101734805754,
+    0.2161454558840652,
+    -0.9708704716933354,
+    -1.0084342613758068,
+    -3.322198159829624,
+    -0.7646674537476362,
+    -1.025300515755601,
+    5.403782000689595,
+    -2.7242324623794376,
+    0.2745124371172138,
+    -2.987250134632581,
+    -2.940871482873593,
+    0.2494047723940136,
+    -1.9932782697680742,
+    -0.0036452286094163897,
+    -0.8565177628516306,
+    -1.2273432128989903,
+    -4.049355690838215,
+    -2.449495900719972,
+    0.3590328822358758,
+    1.1352411888470701,
+    -0.9857547071069496,
+    0.00012576813070224816,
+    2.245779286759933,
+    2.87971148595238,
+    -2.1942275368116433,
+    -0.23463912050035363,
+    2.4029968018394023,
+    -0.9394591611326017,
+    -0.10493896987799263,
+    -0.17221459647417905,
+    -1.775358035812863,
+    -0.8893680097694762,
+    -0.05888975817647629,
+    -0.8277376981158471,
+    2.2267720467364067,
+    -0.9619856833079639,
+    -0.8663380652014581,
+    1.3937251531042052,
+    -2.1127368263418163,
+    -0.08139695030242985,
+    -3.1030896446951792,
+    2.334339098471364,
+    -0.5472914027481613,
+    -0.9356906493445072,
+    -2.4765046559724295,
+    -0.015524067554653256,
+    -1.600564355903319,
+    -1.066984659900873,
+    2.5753504911691776,
+    -0.35105174048425475,
+    -2.143564768301352,
+    0.3264137649347646,
+    -0.7254768312558996,
+    1.1800270959746773,
+    2.864843855461979,
+    -1.9853850222189862,
+    0.9093005951605652,
+    0.16979611735697459,
+    1.7911311645290895,
+    -0.45955627789253306,
+    1.6732381369212268,
+    -3.4901117226733867,
+    3.378917842626747,
+    1.729555957037156,
+    -0.3015519777714956,
+    -2.898014260278335,
+    1.2860174000839635,
+    0.9663877276295352,
+    -0.012711252842777425,
+    0.30291178572484884,
+    -1.1682179406996087,
+    0.7376134652604842,
+    0.5893086794390312,
+    -0.5585187466851501,
+    -2.672473309786308,
+    1.4014976368800685,
+    1.108393244548067,
+    -1.67261318560283,
+    -3.189176324012486,
+    0.40991716117526766,
+    -0.6901759559457797,
+    0.5052234067289093,
+    -2.5880049309691064,
+    -1.918340888760726,
+    2.1715497073598016,
+    0.8075498094314278,
+    1.1729750734385955,
+    3.630456892307906,
+    0.2576428572047662
+  ],
+  z: [
+    -4.001858475463022,
+    0.6675543948671404,
+    2.342650254717589,
+    4.119078484598608,
+    -2.7537231964810425,
+    -2.301711131254211,
+    -1.4116427895202421,
+    -2.108111564154383,
+    -1.2914874462849828,
+    -0.3707559353530068,
+    -2.4024441014799702,
+    4.0739443339663,
+    0.2155494897710934,
+    -0.16821620101116128,
+    0.9912392832091879,
+    0.07483037223593068,
+    -0.2641760739118198,
+    2.9535748471041936,
+    -0.43406042018420693,
+    -2.5672044081844505,
+    0.7713357808868047,
+    -0.7030257470581849,
+    -1.0435921867125384,
+    -2.1362624013743408,
+    0.856731806533385,
+    -0.3480364688539898,
+    1.0313354572960587,
+    -0.468730554611843,
+    -1.3170068516435418,
+    2.500473208157433,
+    -0.5435274302227936,
+    1.8959039917503921,
+    -2.4031648602178755,
+    -0.9322321927510044,
+    -0.5387027903063599,
+    -0.7819308162617215,
+    2.697414023983427,
+    -0.04552940259682519,
+    0.4884517022069007,
+    -1.8847434157278455,
+    -1.4584345530191491,
+    1.9961378171096964,
+    2.5169633291911206,
+    2.497727377620192,
+    -2.7612740990506603,
+    4.099921387272788,
+    2.0337456595990835,
+    -0.053434928276515886,
+    1.407215557596521,
+    -1.9427704583037273,
+    -2.1923124831177145,
+    0.09810090187519412,
+    -2.39699171311556,
+    0.380037997119496,
+    2.5954117992093324,
+    -2.067747445929502,
+    -1.4768815084261278,
+    0.0931278789017267,
+    -2.0351922396522117,
+    -0.7665679197725563,
+    1.745510823342797,
+    1.939090027940234,
+    0.7676933300541888,
+    -3.703111326134929,
+    -0.10799347365233136,
+    2.1295464286765675,
+    1.62639007482321,
+    -0.38163294820856347,
+    -5.399859617127405,
+    0.1219332776022331,
+    1.1475033949671558,
+    0.09160715945019773,
+    0.3148250803517509,
+    0.8631307457375416,
+    -0.7930994721004244,
+    2.6199564515030986,
+    0.940786799747886,
+    -2.4853405411492027,
+    2.763150912771066,
+    2.4089178740196484,
+    1.648147927363762,
+    -3.3252588043711886,
+    -1.1386126872109616,
+    1.2710276345790525,
+    0.08744401515571584,
+    0.6960246073226142,
+    4.91918709774083,
+    -1.636760648799339,
+    -4.226400229858274,
+    0.5473905448608293,
+    -1.3751936824868236,
+    0.8920821059237314,
+    -1.6247694475811947,
+    4.424110960670272,
+    -0.24741194315485965,
+    -0.9546710120601046,
+    -0.3325229829732164,
+    1.7251267672528618,
+    0.19468097040563787,
+    -3.2512334784225763,
+    -0.00924153565291559,
+    1.5204843353241098,
+    0.07798182574512524,
+    1.4701442832288814,
+    -0.2929452539977395,
+    -0.11577467076256517,
+    0.9647389322090653,
+    1.9858872735514685,
+    -2.4927909960640844,
+    -0.06697504969121937,
+    -0.1419243624999926,
+    -1.517841307461901,
+    -2.0687187218783056,
+    -1.2614639079416392,
+    1.1736154400259904,
+    -0.8326453123673038,
+    -1.5697756190106404,
+    0.32683263897219417,
+    -2.4734284702186993,
+    2.091747552473343,
+    -0.9691908324374187,
+    0.37825762336133084,
+    0.1020126631499464,
+    -0.0004813377728839536,
+    3.618764084885732,
+    -1.6506559142198896,
+    2.2909409044559705,
+    0.06314637510648614,
+    -1.6704116106134392,
+    -0.13752729803302502,
+    1.4935433740249338,
+    -0.8510374687892082,
+    -1.5441644703869135,
+    0.30552821349578935,
+    1.977193690357598,
+    -0.14691666934434808,
+    -2.774053107119484,
+    -2.6133518087507257,
+    -1.5367906501558772,
+    -1.0542162507489161,
+    -0.04285413008324925,
+    1.3409961419925638,
+    -0.869234077144813,
+    -2.2277595666256937,
+    1.2142119897569996,
+    0.5509139374791826,
+    2.3146941388294735,
+    -3.3649617189565113,
+    0.17463817778974872,
+    2.706723787885337,
+    1.4483476013667382,
+    -1.665105651528423,
+    1.4650569735368288,
+    -1.7438537399944254,
+    -0.9067950224595854,
+    2.3750685572581554,
+    -0.5802906235801585,
+    1.6570922899308729,
+    -0.5824554175583375,
+    -3.1527248094958122,
+    -1.6976313938978438,
+    -2.1770397239143895,
+    -0.968581142234347,
+    -0.6726224180191456,
+    -0.3067157813232876,
+    -0.4864944571496919,
+    3.784404083200223,
+    -2.7719966745708398,
+    -0.8296486014155607,
+    0.6981630562136623,
+    3.256884531630813,
+    0.17704379142723264,
+    2.478301416801126,
+    -3.2891110715074134,
+    2.892713050756959,
+    -1.3811203433303656,
+    -0.5528621709077041,
+    -2.2188375197988743,
+    0.26773863285890354,
+    3.570678103463104,
+    4.8443267105031795,
+    -2.1536578042368233,
+    0.971882220806198,
+    2.7770434774885837,
+    -0.3913136345690878,
+    -0.43634959541242196,
+    -0.6095559090928905,
+    1.195665448222886,
+    2.7948588216315193,
+    1.3752395224799268,
+    0.6403760285939373,
+    -0.6037398515545216,
+    0.9966973711158991,
+    -1.0990738358335126,
+    -0.5585130072744854,
+    2.1930268862234645,
+    0.8840261763576225,
+    0.48203258805222476,
+    -0.5112153107110367,
+    1.8620658029697648
+  ],
+  w: [
+    -0.49696586637986573,
+    0.8446407716647866,
+    1.9753065872793472,
+    1.6711363440700464,
+    -1.321043718091411,
+    3.1281389865836706,
+    -3.245951870583094,
+    1.727792746957976,
+    -1.0232055468724002,
+    -3.8347300508908027,
+    -3.731627697239897,
+    0.4903581268793773,
+    4.447068603816132,
+    0.5467521282889305,
+    2.261569589056565,
+    1.6773387481201982,
+    -1.3092305557564106,
+    1.907921956958791,
+    0.7059029309786451,
+    0.4131985852992269,
+    2.002226468620497,
+    1.4949039832805529,
+    -1.2531496734462773,
+    0.7904473718734281,
+    -1.7843359080911552,
+    1.2616368201835455,
+    -0.865410366569135,
+    0.9042772884370336,
+    0.7359980903926909,
+    -0.5407749793238182,
+    0.9310252354259575,
+    1.1487124512539382,
+    -0.4613999803148218,
+    2.3444850166049025,
+    2.7854054134662434,
+    -1.3239825114191694,
+    -1.5547384134500284,
+    1.0270771578175601,
+    -1.8266244760825443,
+    -0.8988476105006012,
+    1.6058653982072366,
+    -1.1469537019622078,
+    -3.8562503356966524,
+    1.3287816676442965,
+    -3.205080447588506,
+    -2.709200514907699,
+    -6.0358653588357924,
+    1.6624756444601259,
+    0.502194177694688,
+    0.9245869318826591,
+    1.6895844464464735,
+    -0.0839430486431242,
+    -2.2111518114000552,
+    1.1275513046617478,
+    2.606729511639341,
+    -3.0004418755893147,
+    -1.2139784702380723,
+    -0.5844901313131545,
+    -2.579366686647206,
+    1.3882116975493977,
+    -1.198363805794238,
+    2.5138132879432744,
+    0.10701602725472605,
+    1.456185035343705,
+    3.1221961364212145,
+    0.5312495071943797,
+    2.1534525184145346,
+    0.4213958633584909,
+    -3.0233470516447363,
+    0.044804519827250026,
+    1.4362724120842063,
+    0.9789140356845396,
+    -0.34777669175653925,
+    -2.435398977336801,
+    1.292796737418924,
+    -1.8329120566957797,
+    -2.5036468848511326,
+    1.1898554368110026,
+    -2.465621330379653,
+    0.48872882981227517,
+    0.005544370687190118,
+    -2.65641937205113,
+    2.35939282366555,
+    -1.1856099982978574,
+    2.399956632673344,
+    -0.9500673592242697,
+    -1.1501141923016327,
+    -0.06245204921699806,
+    -0.7161139919569112,
+    -0.7132021552954626,
+    -1.7553287668674522,
+    -2.4257942503559256,
+    1.2265732373740676,
+    -1.6124066829249548,
+    -2.7529138598177902,
+    -1.0156957983270942,
+    -1.6018709734746754,
+    -4.385571371340135,
+    -0.5818742985353497,
+    0.3343482423210354,
+    0.5893847129713754,
+    0.7854825308414517,
+    -2.0016874260016304,
+    -0.6514542396468678,
+    -2.016697610857685,
+    -1.2708629640675322,
+    -2.419681375974685,
+    -2.2329276013053807,
+    1.2597623251518704,
+    -0.5450431403572512,
+    -0.5176823367573421,
+    3.459116359782987,
+    -0.11678433081474329,
+    -1.0741275692178371,
+    1.4945733923314797,
+    -0.9745156707794659,
+    2.7458155629590104,
+    -0.7553447212924415,
+    -1.2323052282367883,
+    -2.3362501021493713,
+    0.6572807171821716,
+    2.93302125488033,
+    -0.7120190901778252,
+    0.5229352837548622,
+    0.6666577103514623,
+    2.8443864806190855,
+    1.3277532013323454,
+    -2.147310311390621,
+    -1.3938035493334802,
+    -1.4922609138691223,
+    0.2831457442644387,
+    -0.007894441461306145,
+    0.7358750021835311,
+    -1.314685829394494,
+    -0.7526933403221041,
+    1.4827201208501692,
+    -0.19921351289694036,
+    -1.3085797572141897,
+    1.942328748122542,
+    0.02699262313677293,
+    -1.83306933404309,
+    3.4193771225232736,
+    -2.3362019798933114,
+    -3.562072520305047,
+    -4.506264897136434,
+    1.3022519390933986,
+    -1.0656652512055347,
+    -0.5511187139445664,
+    0.5792539452580913,
+    -0.9329681235815281,
+    -3.216120349889375,
+    -3.899567592083976,
+    -0.6813998364619616,
+    0.3494510546626397,
+    -4.555555121554458,
+    0.5810489618941678,
+    0.8446127149472286,
+    2.5894747264134295,
+    0.32942803714790875,
+    0.4099076816004704,
+    1.2092072534516118,
+    -0.03828153833786284,
+    -0.15942869475761728,
+    0.2319689288056091,
+    1.4883467280967757,
+    -0.8625812070553853,
+    -0.9990579038224688,
+    -1.7303241535114227,
+    -1.915514566543747,
+    0.6535999426772754,
+    3.09474445137035,
+    -1.9377191377288612,
+    -0.37688085251892567,
+    -2.060002322911837,
+    1.816172883720992,
+    -0.634763729416257,
+    0.35800793308084394,
+    0.6960563754583543,
+    -2.1085580425488804,
+    -0.2094885762214029,
+    -0.45668523418905876,
+    1.3507111248550778,
+    -2.4664893870126186,
+    -2.3999230888455583,
+    1.5317331532322156,
+    -1.1761957225659538,
+    -1.3205916599511518,
+    0.22602704439468746,
+    -0.6407975993720775,
+    3.7327629938775755,
+    0.5190629115355975,
+    0.32312014183613985,
+    1.8621498186707084,
+    -0.11989349851924225,
+    0.09747940015490032,
+    -2.1457508014679263,
+    -4.585942860961345,
+    -2.414413700128684,
+    0.22821885959438232,
+    -2.066594158210754
+  ]
+};
+// src/data/pcaDegenerate.ts
+var pcaDegenerate = [
+  { x: 0.0548817670573706, y: 34.740158547327 },
+  { x: 0.0548817670573706, y: 24.6785012534724 },
+  { x: 0.0548817670573706, y: 10.0433633715021 },
+  { x: -0.493935903516516, y: -0.567111592926364 },
+  { x: -0.128057456467252, y: -10.0799512162071 },
+  { x: 1.88427400230367, y: -16.6657632630937 },
+  { x: -40.7405650789349, y: -17.7633986042415 },
+  { x: -22.8125211735212, y: -17.2145809336676 },
+  { x: -7.4456263974524, y: -16.8487024866183 },
+  { x: 7.73832915509179, y: -16.4828240395691 },
+  { x: 22.3734670370621, y: -15.9340063689952 },
+  { x: 38.4721187072295, y: -15.7510671454706 },
+  { x: 14.8729588725523, y: -16.2998848160445 },
+  { x: 0.237820990582013, y: 18.6415068771597 },
+  { x: -1.0427535740904, y: -18.3122162748154 },
+  { x: -12.0191069855681, y: -16.8487024866183 }
+];
+// src/plot/target.ts
+function resolveTarget(target) {
+  if ("ctx" in target) {
+    return target;
+  }
+  const ctx = target.getContext("2d");
+  if (ctx === null) {
+    throw new Error("plot target: the canvas gave no 2D context. In tests, pass " + "{ ctx, width, height } instead of a canvas element.");
+  }
+  return { ctx, width: target.width, height: target.height };
+}
+// src/plot/axes.ts
+var DEFAULT_MARGINS = {
+  top: 20,
+  right: 20,
+  bottom: 44,
+  left: 52
+};
+var DEFAULT_TICK_COUNT = 5;
+var TICK_LENGTH = 5;
+var LABEL_GAP = 4;
+var TITLE_GAP = 26;
+var AXIS_COLOR = "#000000";
+var AXIS_FONT = "12px sans-serif";
+function extentOf(limits) {
+  return { min: Math.min(...limits), max: Math.max(...limits) };
+}
+function createScale(options) {
+  const margins = options.margins ?? DEFAULT_MARGINS;
+  const left = margins.left;
+  const top = margins.top;
+  const right = options.width - margins.right;
+  const bottom = options.height - margins.bottom;
+  const area = {
+    left,
+    right,
+    top,
+    bottom,
+    width: right - left,
+    height: bottom - top
+  };
+  const world = { x: options.x, y: options.y };
+  const spanX = options.x.max - options.x.min;
+  const spanY = options.y.max - options.y.min;
+  return {
+    area,
+    world,
+    toPixelX(x) {
+      if (spanX === 0) {
+        return left + area.width / 2;
+      }
+      return left + (x - options.x.min) / spanX * area.width;
+    },
+    toPixelY(y) {
+      if (spanY === 0) {
+        return top + area.height / 2;
+      }
+      return bottom - (y - options.y.min) / spanY * area.height;
+    },
+    toWorldX(px) {
+      if (area.width === 0) {
+        return options.x.min;
+      }
+      return options.x.min + (px - left) / area.width * spanX;
+    },
+    toWorldY(py) {
+      if (area.height === 0) {
+        return options.y.min;
+      }
+      return options.y.min + (bottom - py) / area.height * spanY;
+    }
+  };
+}
+function pixelInArea(area, pixel) {
+  return pixel.x >= area.left && pixel.x <= area.right && pixel.y >= area.top && pixel.y <= area.bottom;
+}
+function prettyTicks(extent2, count = DEFAULT_TICK_COUNT) {
+  const min = Math.min(extent2.min, extent2.max);
+  const max = Math.max(extent2.min, extent2.max);
+  if (min === max) {
+    return [min];
+  }
+  const step = niceStep((max - min) / Math.max(1, count));
+  const decimals = decimalsFor(step);
+  const guard = step * 0.000000001;
+  const first = Math.ceil((min - guard) / step);
+  const last = Math.floor((max + guard) / step);
+  return Array.from({ length: last - first + 1 }, (_unused, index) => roundTo((first + index) * step, decimals));
+}
+function drawAxes(ctx, scale, options = {}) {
+  const { area } = scale;
+  const showYAxis = options.yAxis ?? true;
+  const xTicks = prettyTicks(scale.world.x, options.tickCount);
+  const yTicks = showYAxis ? prettyTicks(scale.world.y, options.tickCount) : [];
+  ctx.save();
+  ctx.setLineDash([]);
+  ctx.strokeStyle = AXIS_COLOR;
+  ctx.fillStyle = AXIS_COLOR;
+  ctx.lineWidth = 1;
+  ctx.font = AXIS_FONT;
+  ctx.beginPath();
+  if (options.frame ?? true) {
+    ctx.rect(area.left, area.top, area.width, area.height);
+  } else if (showYAxis) {
+    ctx.moveTo(area.left, area.top);
+    ctx.lineTo(area.left, area.bottom);
+    ctx.lineTo(area.right, area.bottom);
+  } else {
+    ctx.moveTo(area.left, area.bottom);
+    ctx.lineTo(area.right, area.bottom);
+  }
+  for (const tick of xTicks) {
+    const px = scale.toPixelX(tick);
+    ctx.moveTo(px, area.bottom);
+    ctx.lineTo(px, area.bottom + TICK_LENGTH);
+  }
+  for (const tick of yTicks) {
+    const py = scale.toPixelY(tick);
+    ctx.moveTo(area.left, py);
+    ctx.lineTo(area.left - TICK_LENGTH, py);
+  }
+  ctx.stroke();
+  ctx.textAlign = "center";
+  ctx.textBaseline = "top";
+  for (const tick of xTicks) {
+    ctx.fillText(String(tick), scale.toPixelX(tick), area.bottom + TICK_LENGTH + LABEL_GAP);
+  }
+  ctx.textAlign = "right";
+  ctx.textBaseline = "middle";
+  for (const tick of yTicks) {
+    ctx.fillText(String(tick), area.left - TICK_LENGTH - LABEL_GAP, scale.toPixelY(tick));
+  }
+  if (options.xLabel !== undefined) {
+    ctx.textAlign = "center";
+    ctx.textBaseline = "bottom";
+    ctx.fillText(options.xLabel, (area.left + area.right) / 2, area.bottom + TICK_LENGTH + LABEL_GAP + TITLE_GAP);
+  }
+  if (options.yLabel !== undefined) {
+    ctx.save();
+    ctx.translate(area.left - TICK_LENGTH - LABEL_GAP - TITLE_GAP, (area.top + area.bottom) / 2);
+    ctx.rotate(-Math.PI / 2);
+    ctx.textAlign = "center";
+    ctx.textBaseline = "middle";
+    ctx.fillText(options.yLabel, 0, 0);
+    ctx.restore();
+  }
+  ctx.restore();
+}
+function niceStep(rawStep) {
+  const magnitude = 10 ** Math.floor(Math.log10(rawStep));
+  const normalized = rawStep / magnitude;
+  if (normalized < 1.5) {
+    return magnitude;
+  }
+  if (normalized < 3) {
+    return 2 * magnitude;
+  }
+  if (normalized < 7) {
+    return 5 * magnitude;
+  }
+  return 10 * magnitude;
+}
+function decimalsFor(step) {
+  return Math.min(20, Math.max(0, -Math.floor(Math.log10(step))));
+}
+function roundTo(value, decimals) {
+  return Number(value.toFixed(decimals));
+}
+// src/plot/draw.ts
+var DOTTED = [1, 3];
+var POINT_COLOR = "#bebebe";
+var POINT_RADIUS = 6;
+var ARROW_COLOR = "#000000";
+var ARROW_WIDTH = 1;
+var HEAD_ANGLE = Math.PI / 6;
+var MIN_ARROW_PIXELS = 96 / 1000;
+function clearSurface(ctx, width, height) {
+  ctx.setLineDash([]);
+  ctx.fillStyle = "#ffffff";
+  ctx.fillRect(0, 0, width, height);
+}
+function clipToArea(ctx, area) {
+  ctx.beginPath();
+  ctx.rect(area.left, area.top, area.width, area.height);
+  ctx.clip();
+}
+function drawDots(ctx, scale, points) {
+  ctx.save();
+  ctx.setLineDash([]);
+  ctx.fillStyle = POINT_COLOR;
+  for (const point of points) {
+    ctx.beginPath();
+    ctx.arc(scale.toPixelX(point.x), scale.toPixelY(point.y), POINT_RADIUS, 0, 2 * Math.PI);
+    ctx.fill();
+  }
+  ctx.restore();
+}
+function drawArrow(ctx, tail, tip, options) {
+  const {
+    headLength,
+    dash = [],
+    color = ARROW_COLOR,
+    lineWidth = ARROW_WIDTH
+  } = options;
+  const length = Math.hypot(tip[0] - tail[0], tip[1] - tail[1]);
+  if (!Number.isFinite(length) || length < MIN_ARROW_PIXELS) {
+    return;
+  }
+  const back = Math.atan2(tail[1] - tip[1], tail[0] - tip[0]);
+  const edge = (turn) => [
+    tip[0] + headLength * Math.cos(back + turn),
+    tip[1] + headLength * Math.sin(back + turn)
+  ];
+  ctx.save();
+  ctx.strokeStyle = color;
+  ctx.lineWidth = lineWidth;
+  ctx.setLineDash([...dash]);
+  ctx.beginPath();
+  ctx.moveTo(tail[0], tail[1]);
+  ctx.lineTo(tip[0], tip[1]);
+  const [firstX, firstY] = edge(HEAD_ANGLE);
+  const [secondX, secondY] = edge(-HEAD_ANGLE);
+  ctx.moveTo(firstX, firstY);
+  ctx.lineTo(tip[0], tip[1]);
+  ctx.lineTo(secondX, secondY);
+  ctx.stroke();
+  ctx.restore();
+}
+
+// src/plot/matrixInverse.ts
+var WORLD = { min: -3, max: 3 };
+var MATRIX_FILL = "#FF00001A";
+var INVERSE_FILL = "#0000FF1A";
+var BORDER_COLOR = "#0000004D";
+var ARROW_COLOR2 = "#000000";
+var LINE_WIDTH = 1;
+var HEAD_LENGTH = 24;
+function matrixInverseScale(width, height) {
+  return createScale({ width, height, x: WORLD, y: WORLD });
+}
+function plotMatrixInverse(target, matrix) {
+  const inversion = invertMatrix(matrix);
+  const { ctx, width, height } = resolveTarget(target);
+  if (inversion.inverse === null) {
+    return inversion;
+  }
+  const scale = matrixInverseScale(width, height);
+  clearSurface(ctx, width, height);
+  drawAxes(ctx, scale, { frame: false, xLabel: "x", yLabel: "y" });
+  const { area } = scale;
+  ctx.save();
+  clipToArea(ctx, area);
+  drawMatrix(ctx, scale, matrix, MATRIX_FILL);
+  drawMatrix(ctx, scale, inversion.inverse, INVERSE_FILL);
+  ctx.restore();
+  return inversion;
+}
+function drawMatrix(ctx, scale, matrix, fill) {
+  drawParallelogram(ctx, scale, matrix, fill);
+  drawColumnArrow(ctx, scale, matrix.x1, matrix.y1);
+  drawColumnArrow(ctx, scale, matrix.x2, matrix.y2);
+}
+function drawParallelogram(ctx, scale, matrix, fill) {
+  const corners = [
+    [0, 0],
+    [matrix.x1, matrix.y1],
+    [matrix.x1 + matrix.x2, matrix.y1 + matrix.y2],
+    [matrix.x2, matrix.y2],
+    [0, 0]
+  ];
+  ctx.save();
+  ctx.setLineDash([]);
+  ctx.fillStyle = fill;
+  ctx.strokeStyle = BORDER_COLOR;
+  ctx.lineWidth = LINE_WIDTH;
+  ctx.beginPath();
+  corners.forEach(([x, y], index) => {
+    const px = scale.toPixelX(x);
+    const py = scale.toPixelY(y);
+    if (index === 0) {
+      ctx.moveTo(px, py);
+    } else {
+      ctx.lineTo(px, py);
+    }
+  });
+  ctx.fill();
+  ctx.stroke();
+  ctx.restore();
+}
+function drawColumnArrow(ctx, scale, x, y) {
+  const tail = [scale.toPixelX(0), scale.toPixelY(0)];
+  const tip = [scale.toPixelX(x), scale.toPixelY(y)];
+  drawArrow(ctx, tail, tip, {
+    headLength: HEAD_LENGTH,
+    color: ARROW_COLOR2,
+    lineWidth: LINE_WIDTH
+  });
+}
+// src/plot/format.ts
+function formatStat(value) {
+  if (value === null || !Number.isFinite(value)) {
+    return "NA";
+  }
+  return String(Math.round(value * 100) / 100);
+}
+var R_SIGNIFICANT_DIGITS = 15;
+function formatNumber(value) {
+  if (!Number.isFinite(value)) {
+    return "NA";
+  }
+  return String(Number(value.toPrecision(R_SIGNIFICANT_DIGITS)));
+}
+
+// src/plot/logit.ts
+var WORLD_Y = { min: 0, max: 1 };
+var DEFAULT_MIN_X = 0;
+var DEFAULT_MAX_X = 1;
+var HALF_LINE_COLOR = "lightgray";
+var CURVE_COLOR = "cornflowerblue";
+var TEXT_COLOR = "#000000";
+var CURVE_WIDTH = 2;
+var CURVE_SAMPLES = 500;
+var HALF = 0.5;
+var STATS_FONT = "12px monospace";
+var STATS_LINE_HEIGHT = 15;
+var STATS_PADDING = 8;
+var STATS_LABEL_WIDTH = 11;
+function logitScale(width, height, points, options = {}) {
+  const finite = points.filter((point) => Number.isFinite(point.x));
+  const min = finite.reduce((low, point) => Math.min(low, point.x), options.minX ?? DEFAULT_MIN_X);
+  const max = finite.reduce((high, point) => Math.max(high, point.x), options.maxX ?? DEFAULT_MAX_X);
+  return createScale({ width, height, x: { min, max }, y: WORLD_Y });
+}
+function plotLogit(target, points, options = {}) {
+  const { ctx, width, height } = resolveTarget(target);
+  const showRegression = options.regression ?? true;
+  const showStats = options.stats ?? true;
+  const legendLocation = options.legendLoc ?? "topleft";
+  const scale = logitScale(width, height, points, options);
+  clearSurface(ctx, width, height);
+  drawAxes(ctx, scale, { xLabel: "x", yLabel: "y" });
+  drawDots(ctx, scale, points);
+  drawHalfLine(ctx, scale);
+  if (points.length < 2 || !showRegression) {
+    return null;
+  }
+  const fit = logisticRegression(points);
+  if (fit === null) {
+    return null;
+  }
+  drawCurve(ctx, scale, fit);
+  if (showStats) {
+    drawStats(ctx, scale, fit, legendLocation);
+  }
+  return fit;
+}
+function drawHalfLine(ctx, scale) {
+  const { area } = scale;
+  ctx.save();
+  ctx.strokeStyle = HALF_LINE_COLOR;
+  ctx.lineWidth = 1;
+  ctx.setLineDash(DOTTED);
+  ctx.beginPath();
+  ctx.moveTo(area.left, scale.toPixelY(HALF));
+  ctx.lineTo(area.right, scale.toPixelY(HALF));
+  ctx.stroke();
+  ctx.restore();
+}
+function drawCurve(ctx, scale, fit) {
+  const { area, world } = scale;
+  const span = world.x.max - world.x.min;
+  const samples = Array.from({ length: CURVE_SAMPLES }, (_unused, index) => {
+    const x = world.x.min + span * index / (CURVE_SAMPLES - 1);
+    return {
+      px: scale.toPixelX(x),
+      py: scale.toPixelY(predictLogit(fit, x))
+    };
+  });
+  ctx.save();
+  clipToArea(ctx, area);
+  ctx.strokeStyle = CURVE_COLOR;
+  ctx.lineWidth = CURVE_WIDTH;
+  ctx.setLineDash([]);
+  ctx.beginPath();
+  for (const [index, { px, py }] of samples.entries()) {
+    if (index === 0) {
+      ctx.moveTo(px, py);
+    } else {
+      ctx.lineTo(px, py);
+    }
+  }
+  ctx.stroke();
+  ctx.restore();
+}
+function drawStats(ctx, scale, fit, location) {
+  const rows = [
+    ["Intercept", fit.intercept],
+    ["Coefficient", fit.slope],
+    ["AIC", fit.aic]
+  ];
+  const { area } = scale;
+  const onRight = location === "topright" || location === "bottomright";
+  const atBottom = location === "bottomleft" || location === "bottomright";
+  const x = onRight ? area.right - STATS_PADDING : area.left + STATS_PADDING;
+  const top = atBottom ? Math.max(area.top + STATS_PADDING, area.bottom - STATS_PADDING - rows.length * STATS_LINE_HEIGHT) : area.top + STATS_PADDING;
+  ctx.save();
+  ctx.setLineDash([]);
+  ctx.fillStyle = TEXT_COLOR;
+  ctx.font = STATS_FONT;
+  ctx.textAlign = onRight ? "right" : "left";
+  ctx.textBaseline = "top";
+  for (const [index, [label, value]] of rows.entries()) {
+    ctx.fillText(`${label.padEnd(STATS_LABEL_WIDTH)}: ${formatStat(value)}`, x, top + index * STATS_LINE_HEIGHT);
+  }
+  ctx.restore();
+}
+// src/plot/sampleCi.ts
+var GOOD_COLORS = {
+  span99: "#87cefa",
+  span95: "#6ca6cd",
+  point: "#4a708b"
+};
+var BAD_COLORS = {
+  span99: "#f08080",
+  span95: "#cd5b45",
+  point: "#8b3e2f"
+};
+var MEAN_LINE_COLOR = "#000000";
+var SPAN_WIDTH = 3;
+var POINT_RADIUS2 = 2.5;
+function sampleCiScale(width, height, simulation) {
+  const center = Number.isFinite(simulation.populationMean) ? simulation.populationMean : 0;
+  const half = Number.isFinite(simulation.populationSd) ? simulation.populationSd / 2 : 0.5;
+  return createScale({
+    width,
+    height,
+    x: { min: center - half, max: center + half },
+    y: { min: 1, max: Math.max(1, simulation.intervals.length) }
+  });
+}
+function plotSampleCi(target, options = {}) {
+  const { ctx, width, height } = resolveTarget(target);
+  const {
+    rng = seededRng(Math.floor(Math.random() * 4294967296)),
+    ...simulationOptions
+  } = options;
+  const simulation = simulateSampleCi(rng, simulationOptions);
+  const scale = sampleCiScale(width, height, simulation);
+  clearSurface(ctx, width, height);
+  drawAxes(ctx, scale, {
+    xLabel: "Confidence Intervals",
+    yLabel: "Samples"
+  });
+  const { area } = scale;
+  ctx.save();
+  clipToArea(ctx, area);
+  const rows = simulation.intervals.map((interval, index) => ({ interval, row: index + 1 })).filter(({ interval }) => isDrawable(interval));
+  drawRows(ctx, scale, rows, GOOD_COLORS);
+  drawRows(ctx, scale, rows.filter(({ interval }) => interval.excludesPopulationMean), BAD_COLORS);
+  drawPopulationMean(ctx, scale, simulation.populationMean);
+  ctx.restore();
+  return simulation;
+}
+function isDrawable(interval) {
+  return Number.isFinite(interval.mean) && Number.isFinite(interval.ci95.low) && Number.isFinite(interval.ci95.high) && Number.isFinite(interval.ci99.low) && Number.isFinite(interval.ci99.high);
+}
+function drawRows(ctx, scale, rows, colors) {
+  ctx.save();
+  ctx.setLineDash([]);
+  ctx.lineWidth = SPAN_WIDTH;
+  ctx.strokeStyle = colors.span99;
+  for (const { interval, row } of rows) {
+    drawSpan(ctx, scale, interval.ci99.low, interval.ci99.high, row);
+  }
+  ctx.strokeStyle = colors.span95;
+  for (const { interval, row } of rows) {
+    drawSpan(ctx, scale, interval.ci95.low, interval.ci95.high, row);
+  }
+  ctx.fillStyle = colors.point;
+  for (const { interval, row } of rows) {
+    drawDiamond(ctx, scale, interval.mean, row);
+  }
+  ctx.restore();
+}
+function drawSpan(ctx, scale, low, high, row) {
+  const y = scale.toPixelY(row);
+  ctx.beginPath();
+  ctx.moveTo(scale.toPixelX(low), y);
+  ctx.lineTo(scale.toPixelX(high), y);
+  ctx.stroke();
+}
+function drawDiamond(ctx, scale, at, row) {
+  const x = scale.toPixelX(at);
+  const y = scale.toPixelY(row);
+  ctx.beginPath();
+  ctx.moveTo(x, y - POINT_RADIUS2);
+  ctx.lineTo(x + POINT_RADIUS2, y);
+  ctx.lineTo(x, y + POINT_RADIUS2);
+  ctx.lineTo(x - POINT_RADIUS2, y);
+  ctx.fill();
+}
+function drawPopulationMean(ctx, scale, at) {
+  if (!Number.isFinite(at)) {
+    return;
+  }
+  const { area } = scale;
+  const x = scale.toPixelX(at);
+  ctx.save();
+  ctx.setLineDash([]);
+  ctx.strokeStyle = MEAN_LINE_COLOR;
+  ctx.lineWidth = 1;
+  ctx.beginPath();
+  ctx.moveTo(x, area.top);
+  ctx.lineTo(x, area.bottom);
+  ctx.stroke();
+  ctx.restore();
+}
+// src/plot/sampling.ts
+var DEFAULT_SAMPLE_SIZE2 = 10;
+var DEFAULT_REPS = 1;
+var PANELS = ["population", "samples", "statistic"];
+var PANEL_MARGINS = { top: 8, right: 24, bottom: 28, left: 24 };
+var CURVE_COLOR2 = "#000000";
+var TEXT_COLOR2 = "#000000";
+var SAMPLE_CURVE_COLOR = "rgba(179, 179, 179, 0.5)";
+var BAR_COLOR = "lightgray";
+var CURVE_WIDTH2 = 2;
+var SAMPLE_CURVE_WIDTH = 1;
+var LABEL_FONT = "bold 11px sans-serif";
+var COUNT_FONT = "11px sans-serif";
+var LABEL_LINE_HEIGHT = 13;
+function samplingScale(width, height, panel, window, yMax) {
+  const band = height / PANELS.length;
+  const index = PANELS.indexOf(panel);
+  const top = index * band;
+  return createScale({
+    width,
+    height,
+    x: window,
+    y: { min: 0, max: yMax },
+    margins: {
+      top: top + PANEL_MARGINS.top,
+      bottom: height - (top + band) + PANEL_MARGINS.bottom,
+      left: PANEL_MARGINS.left,
+      right: PANEL_MARGINS.right
+    }
+  });
+}
+function plotSampling(target, population, options = {}) {
+  const { ctx, width, height } = resolveTarget(target);
+  const {
+    sampleSize = DEFAULT_SAMPLE_SIZE2,
+    reps = DEFAULT_REPS,
+    theta = mean,
+    rng = seededRng(Math.floor(Math.random() * 4294967296)),
+    state = null,
+    densityWindow = "data"
+  } = options;
+  const window = frozenWindow(population, state);
+  const grid = densityWindow === "frozen" ? { from: window.min, to: window.max } : {};
+  const drawable = population.length >= 2;
+  const draw = drawable ? drawSamples(rng, population, { sampleSize, reps, theta }) : { samples: [], thetas: [] };
+  const sampleTheta = [...state?.sampleTheta ?? [], ...draw.thetas];
+  clearSurface(ctx, width, height);
+  drawDensityPanel(ctx, width, height, "population", window, drawable ? kernelDensity(population, grid) : null, [], "Population Distribution");
+  const pooled = draw.samples.flat();
+  drawDensityPanel(ctx, width, height, "samples", window, pooled.length >= 2 ? kernelDensity(pooled, grid) : null, draw.samples.filter((sample) => sample.length >= 2).map((sample) => kernelDensity(sample, grid)), "Sample Distribution");
+  const countable = sampleTheta.filter((theta2) => theta2 >= window.min && theta2 <= window.max);
+  const counted = countable.length > 0 ? histogram(countable) : null;
+  drawStatisticPanel(ctx, width, height, window, counted, sampleTheta.length);
+  return {
+    state: { xMin: window.min, xMax: window.max, sampleTheta },
+    samples: draw.samples,
+    thetas: draw.thetas,
+    histogram: counted
+  };
+}
+function frozenWindow(population, state) {
+  if (state !== null) {
+    return { min: state.xMin, max: state.xMax };
+  }
+  if (population.length === 0) {
+    return { min: 0, max: 1 };
+  }
+  const [min, max] = extent(population);
+  return { min, max };
+}
+function drawDensityPanel(ctx, width, height, panel, window, main, perSample, label) {
+  const peak = main === null ? 1 : highestOf(main.y);
+  const scale = samplingScale(width, height, panel, window, peak);
+  drawAxes(ctx, scale, { frame: false, yAxis: false });
+  drawLabel(ctx, scale, [label], peak / 2, LABEL_FONT);
+  if (main === null) {
+    return;
+  }
+  drawCurve2(ctx, scale, main, CURVE_COLOR2, CURVE_WIDTH2, panel === "population");
+  for (const estimate of perSample) {
+    drawCurve2(ctx, scale, estimate, SAMPLE_CURVE_COLOR, SAMPLE_CURVE_WIDTH, false);
+  }
+  if (panel === "samples") {
+    drawCurve2(ctx, scale, main, CURVE_COLOR2, CURVE_WIDTH2, false);
+  }
+}
+function drawStatisticPanel(ctx, width, height, window, counted, drawnSoFar) {
+  const tallest = counted === null ? 1 : highestOf(counted.counts);
+  const scale = samplingScale(width, height, "statistic", window, tallest);
+  drawAxes(ctx, scale, { frame: false, yAxis: false });
+  if (counted !== null) {
+    drawBars(ctx, scale, counted);
+  }
+  drawLabel(ctx, scale, ["Sampling Statistic ", `( ${drawnSoFar} )`], tallest / 2, COUNT_FONT);
+}
+function drawCurve2(ctx, scale, estimate, color, lineWidth, dotted) {
+  const { area } = scale;
+  ctx.save();
+  clipToArea(ctx, area);
+  ctx.strokeStyle = color;
+  ctx.lineWidth = lineWidth;
+  ctx.setLineDash(dotted ? DOTTED : []);
+  ctx.beginPath();
+  estimate.x.forEach((x, index) => {
+    const px = scale.toPixelX(x);
+    const py = scale.toPixelY(estimate.y[index]);
+    if (index === 0) {
+      ctx.moveTo(px, py);
+    } else {
+      ctx.lineTo(px, py);
+    }
+  });
+  ctx.stroke();
+  ctx.restore();
+}
+function drawBars(ctx, scale, counted) {
+  const { area } = scale;
+  const foot = scale.toPixelY(0);
+  ctx.save();
+  clipToArea(ctx, area);
+  ctx.setLineDash([]);
+  ctx.fillStyle = BAR_COLOR;
+  counted.counts.forEach((count, index) => {
+    const left = scale.toPixelX(counted.breaks[index]);
+    const right = scale.toPixelX(counted.breaks[index + 1]);
+    const top = scale.toPixelY(count);
+    ctx.fillRect(left, top, right - left, foot - top);
+  });
+  ctx.restore();
+}
+function drawLabel(ctx, scale, lines, at, font) {
+  ctx.save();
+  ctx.setLineDash([]);
+  ctx.fillStyle = TEXT_COLOR2;
+  ctx.font = font;
+  ctx.textAlign = "left";
+  ctx.textBaseline = "middle";
+  lines.forEach((line, index) => {
+    ctx.fillText(line, scale.area.left, scale.toPixelY(at) + index * LABEL_LINE_HEIGHT);
+  });
+  ctx.restore();
+}
+function highestOf(values) {
+  const highest = values.reduce((high, value) => value > high ? value : high, 0);
+  return highest > 0 ? highest : 1;
+}
+// src/plot/pca.ts
+var DEFAULT_LIMITS = [-50, 50];
+var HEAD_LENGTH2 = 10;
+function pcaScale(width, height, options = {}) {
+  const x = extentOf(options.xlim ?? DEFAULT_LIMITS);
+  const y = extentOf(options.ylim ?? DEFAULT_LIMITS);
+  const areaWidth = width - DEFAULT_MARGINS.left - DEFAULT_MARGINS.right;
+  const areaHeight = height - DEFAULT_MARGINS.top - DEFAULT_MARGINS.bottom;
+  const perPixel = Math.max((x.max - x.min) / areaWidth, (y.max - y.min) / areaHeight);
+  if (!(areaWidth > 0 && areaHeight > 0 && perPixel > 0)) {
+    return createScale({ width, height, x, y });
+  }
+  return createScale({
+    width,
+    height,
+    x: widenedTo(x, perPixel * areaWidth),
+    y: widenedTo(y, perPixel * areaHeight)
+  });
+}
+function plotPca(target, points, options = {}) {
+  const { ctx, width, height } = resolveTarget(target);
+  const scale = pcaScale(width, height, options);
+  clearSurface(ctx, width, height);
+  drawAxes(ctx, scale, { xLabel: "x", yLabel: "y" });
+  if (points.length === 0) {
+    return null;
+  }
+  const { area } = scale;
+  ctx.save();
+  clipToArea(ctx, area);
+  drawDots(ctx, scale, points);
+  const result = points.length >= 3 ? principalComponents(points) : null;
+  if (result !== null) {
+    const anchor = options.meancenter ?? true ? result.center : ORIGIN;
+    drawComponent(ctx, scale, result, anchor, 0, []);
+    drawComponent(ctx, scale, result, anchor, 1, DOTTED);
+  }
+  ctx.restore();
+  return result;
+}
+var ORIGIN = { x: 0, y: 0 };
+function widenedTo(extent2, span) {
+  const middle = (extent2.min + extent2.max) / 2;
+  return { min: middle - span / 2, max: middle + span / 2 };
+}
+function drawComponent(ctx, scale, result, anchor, component, dash) {
+  const loadings = result.rotation[component];
+  const sdev = result.sdev[component];
+  const tail = [
+    scale.toPixelX(anchor.x - loadings[0] * sdev),
+    scale.toPixelY(anchor.y - loadings[1] * sdev)
+  ];
+  const tip = [
+    scale.toPixelX(anchor.x + loadings[0] * sdev),
+    scale.toPixelY(anchor.y + loadings[1] * sdev)
+  ];
+  drawArrow(ctx, tail, tip, { headLength: HEAD_LENGTH2, dash });
+}
+// src/plot/regression.ts
+var WORLD2 = { min: -5, max: 50 };
+var CROSSHAIR_COLOR = "lightgray";
+var LINE_COLOR = "cornflowerblue";
+var TEXT_COLOR3 = "#000000";
+var STATS_FONT2 = "12px monospace";
+var STATS_LINE_HEIGHT2 = 15;
+var STATS_PADDING2 = 8;
+var STATS_LABEL_WIDTH2 = 13;
+function regressionScale(width, height, options = {}) {
+  return createScale({
+    width,
+    height,
+    x: options.xlim ? extentOf(options.xlim) : WORLD2,
+    y: options.ylim ? extentOf(options.ylim) : WORLD2
+  });
+}
+function plotRegression(target, points, options = {}) {
+  const { ctx, width, height } = resolveTarget(target);
+  const showRegression = options.regression ?? true;
+  const showStats = options.stats ?? true;
+  const scale = regressionScale(width, height, options);
+  clearSurface(ctx, width, height);
+  drawAxes(ctx, scale, { xLabel: "x", yLabel: "y" });
+  const fit = linearRegression(points);
+  if (fit === null) {
+    return null;
+  }
+  drawDots(ctx, scale, points);
+  if (points.length < 2 || !showRegression) {
+    return fit;
+  }
+  drawMeanCrosshair(ctx, scale, points);
+  if (fit.slope !== null) {
+    drawFittedLine(ctx, scale, fit.intercept, fit.slope);
+  }
+  if (showStats) {
+    drawStats2(ctx, scale, fit);
+  }
+  return fit;
+}
+function drawMeanCrosshair(ctx, scale, points) {
+  const meanX = mean(points.map((point) => point.x));
+  const meanY = mean(points.map((point) => point.y));
+  const { x, y } = scale.world;
+  const originX = Math.min(Math.max(0, x.min), x.max);
+  const originY = Math.min(Math.max(0, y.min), y.max);
+  ctx.save();
+  ctx.strokeStyle = CROSSHAIR_COLOR;
+  ctx.lineWidth = 1;
+  ctx.setLineDash(DOTTED);
+  ctx.beginPath();
+  ctx.moveTo(scale.toPixelX(originX), scale.toPixelY(meanY));
+  ctx.lineTo(scale.toPixelX(x.max), scale.toPixelY(meanY));
+  ctx.moveTo(scale.toPixelX(meanX), scale.toPixelY(originY));
+  ctx.lineTo(scale.toPixelX(meanX), scale.toPixelY(meanY));
+  ctx.stroke();
+  ctx.restore();
+}
+function drawFittedLine(ctx, scale, intercept, slope) {
+  const { area, world } = scale;
+  ctx.save();
+  clipToArea(ctx, area);
+  ctx.strokeStyle = LINE_COLOR;
+  ctx.lineWidth = 2;
+  ctx.setLineDash([]);
+  ctx.beginPath();
+  ctx.moveTo(scale.toPixelX(world.x.min), scale.toPixelY(intercept + slope * world.x.min));
+  ctx.lineTo(scale.toPixelX(world.x.max), scale.toPixelY(intercept + slope * world.x.max));
+  ctx.stroke();
+  ctx.restore();
+}
+function drawStats2(ctx, scale, fit) {
+  const rows = [
+    ["Raw intercept", fit.intercept],
+    ["Raw slope", fit.slope],
+    ["Correlation", fit.correlation],
+    ["SSR", fit.ssr],
+    ["SSE", fit.sse],
+    ["SST", fit.sst],
+    ["R-squared", fit.rSquared]
+  ];
+  ctx.save();
+  ctx.setLineDash([]);
+  ctx.fillStyle = TEXT_COLOR3;
+  ctx.font = STATS_FONT2;
+  ctx.textAlign = "left";
+  ctx.textBaseline = "top";
+  for (const [index, [label, value]] of rows.entries()) {
+    ctx.fillText(`${label.padEnd(STATS_LABEL_WIDTH2)}: ${formatStat(value)}`, scale.area.left + STATS_PADDING2, scale.area.top + STATS_PADDING2 + index * STATS_LINE_HEIGHT2);
+  }
+  ctx.restore();
+}
+// src/plot/tTest.ts
+var WORLD_X = { min: -6, max: 6 };
+var NULL_COLOR = "#bf1a1a";
+var NULL_FILL = "#ff8080";
+var ALT_COLOR = "#1a1abf";
+var ALT_FILL = "rgba(102, 102, 255, 0.3)";
+var CORRECT_FILL = "rgba(77, 128, 191, 0.5)";
+var TEXT_COLOR4 = "#000000";
+var LINE_WIDTH2 = 2;
+var DASHED = [4, 4];
+var HIGHLIGHT_WIDTH = 4;
+var CURVE_SAMPLES2 = 1000;
+var CURVE_HALF_WIDTH = 6;
+var MAX_FILL_SAMPLES = 2000;
+var MATRIX = {
+  left: -5.5,
+  middle: -4,
+  right: -2.5,
+  bottom: 0.125,
+  center: 0.25,
+  top: 0.375
+};
+var MATRIX_HEADROOM = 0.045;
+var CAPTION_FONT_SIZE = 9;
+var TITLE_FONT_SIZE = 10;
+var VALUE_FONT_SIZE = 13;
+var CAPTION_LINE_HEIGHT = 12;
+var MIN_CAPTION_FONT_SIZE = 6;
+function tTestScale(width, height, options = {}) {
+  const { errorMatrix = false, ...statOptions } = options;
+  return buildScale(width, height, tTestStats(statOptions), errorMatrix);
+}
+function buildScale(width, height, stats, showErrorMatrix) {
+  const peak = Math.max(dt(0, stats.df), stats.altMedianDensity);
+  const tallest = Number.isFinite(peak) && peak > 0 ? peak : 1;
+  const top = showErrorMatrix ? Math.max(1.04 * tallest, MATRIX.top + MATRIX_HEADROOM) : 1.04 * tallest;
+  return createScale({
+    width,
+    height,
+    x: WORLD_X,
+    y: { min: -0.04 * tallest, max: top }
+  });
+}
+function plotTTest(target, options = {}) {
+  const { ctx, width, height } = resolveTarget(target);
+  const { errorMatrix: showErrorMatrix = false, ...statOptions } = options;
+  const stats = tTestStats(statOptions);
+  const scale = buildScale(width, height, stats, showErrorMatrix);
+  clearSurface(ctx, width, height);
+  drawAxes(ctx, scale, { frame: false });
+  drawFill(ctx, scale, stats.nullFill, stats.df, 0, NULL_FILL);
+  drawCurve3(ctx, scale, stats.df, 0, NULL_COLOR, []);
+  drawFill(ctx, scale, stats.altFill, stats.df, stats.t, ALT_FILL);
+  drawMedianSegment(ctx, scale, stats);
+  drawCurve3(ctx, scale, stats.df, stats.t, ALT_COLOR, DASHED);
+  if (showErrorMatrix) {
+    drawErrorMatrix(ctx, scale, stats);
+  }
+  return stats;
+}
+function drawCurve3(ctx, scale, df, ncp, color, dash) {
+  ctx.save();
+  clipToArea(ctx, scale.area);
+  ctx.strokeStyle = color;
+  ctx.lineWidth = LINE_WIDTH2;
+  ctx.setLineDash([...dash]);
+  ctx.beginPath();
+  const from = ncp - CURVE_HALF_WIDTH;
+  const step = 2 * CURVE_HALF_WIDTH / (CURVE_SAMPLES2 - 1);
+  for (let index = 0;index < CURVE_SAMPLES2; index += 1) {
+    const x = from + index * step;
+    const px = scale.toPixelX(x);
+    const py = scale.toPixelY(dt(x, df, ncp));
+    if (index === 0) {
+      ctx.moveTo(px, py);
+    } else {
+      ctx.lineTo(px, py);
+    }
+  }
+  ctx.stroke();
+  ctx.restore();
+}
+function drawFill(ctx, scale, range, df, ncp, color) {
+  const from = Math.max(range.from, WORLD_X.min);
+  const to = Math.min(range.to, WORLD_X.max);
+  if (!(to > from)) {
+    return;
+  }
+  const fromPixel = scale.toPixelX(from);
+  const toPixel = scale.toPixelX(to);
+  const samples = Math.max(2, Math.min(MAX_FILL_SAMPLES, Math.ceil(toPixel - fromPixel)));
+  const step = (to - from) / (samples - 1);
+  const baseline = scale.toPixelY(0);
+  ctx.save();
+  clipToArea(ctx, scale.area);
+  ctx.fillStyle = color;
+  ctx.setLineDash([]);
+  ctx.beginPath();
+  ctx.moveTo(fromPixel, baseline);
+  for (let index = 0;index < samples; index += 1) {
+    const x = from + index * step;
+    ctx.lineTo(scale.toPixelX(x), scale.toPixelY(dt(x, df, ncp)));
+  }
+  ctx.lineTo(toPixel, baseline);
+  ctx.fill();
+  ctx.restore();
+}
+function drawMedianSegment(ctx, scale, stats) {
+  if (!Number.isFinite(stats.altMedian)) {
+    return;
+  }
+  ctx.save();
+  clipToArea(ctx, scale.area);
+  ctx.strokeStyle = ALT_FILL;
+  ctx.lineWidth = LINE_WIDTH2;
+  ctx.setLineDash([]);
+  ctx.beginPath();
+  ctx.moveTo(scale.toPixelX(stats.altMedian), scale.toPixelY(0));
+  ctx.lineTo(scale.toPixelX(stats.altMedian), scale.toPixelY(stats.altMedianDensity));
+  ctx.stroke();
+  ctx.restore();
+}
+function drawErrorMatrix(ctx, scale, stats) {
+  const { errorMatrix: cells, alpha } = stats;
+  ctx.save();
+  ctx.setLineDash([]);
+  drawCell(ctx, scale, {
+    left: MATRIX.left,
+    bottom: MATRIX.center,
+    right: MATRIX.middle,
+    top: MATRIX.top,
+    fill: NULL_FILL,
+    title: "Type I error",
+    value: formatNumber(alpha),
+    rowCaption: ["If evidence says", "REJECT", "null hypothesis"],
+    columnCaption: ["If null is", "really TRUE"]
+  });
+  drawCell(ctx, scale, {
+    left: MATRIX.middle,
+    bottom: MATRIX.center,
+    right: MATRIX.right,
+    top: MATRIX.top,
+    fill: CORRECT_FILL,
+    title: "Correct!",
+    value: formatStat(cells.correctReject),
+    columnCaption: ["If null is", "really FALSE"]
+  });
+  drawCell(ctx, scale, {
+    left: MATRIX.left,
+    bottom: MATRIX.bottom,
+    right: MATRIX.middle,
+    top: MATRIX.center,
+    fill: CORRECT_FILL,
+    title: "Correct!",
+    value: formatNumber(cells.correctFailToReject),
+    rowCaption: ["If evidence says", "CANNOT REJECT", "null hypothesis"]
+  });
+  drawCell(ctx, scale, {
+    left: MATRIX.middle,
+    bottom: MATRIX.bottom,
+    right: MATRIX.right,
+    top: MATRIX.center,
+    fill: NULL_FILL,
+    title: "Type II error",
+    value: formatStat(cells.typeTwo)
+  });
+  const ringBottom = cells.highlightTopRow ? MATRIX.center : MATRIX.bottom;
+  const ringTop = cells.highlightTopRow ? MATRIX.top : MATRIX.center;
+  ctx.strokeStyle = ALT_COLOR;
+  ctx.lineWidth = HIGHLIGHT_WIDTH;
+  ctx.beginPath();
+  ctx.rect(...worldRect(scale, MATRIX.left, ringBottom, MATRIX.right, ringTop));
+  ctx.stroke();
+  ctx.restore();
+}
+function drawCell(ctx, scale, cell) {
+  const centerX = (cell.left + cell.right) / 2;
+  const centerY = (cell.bottom + cell.top) / 2;
+  ctx.fillStyle = cell.fill;
+  ctx.beginPath();
+  ctx.rect(...worldRect(scale, cell.left, cell.bottom, cell.right, cell.top));
+  ctx.fill();
+  ctx.fillStyle = TEXT_COLOR4;
+  ctx.textAlign = "center";
+  ctx.font = `${TITLE_FONT_SIZE}px sans-serif`;
+  ctx.textBaseline = "top";
+  ctx.fillText(cell.title, scale.toPixelX(centerX), scale.toPixelY(cell.top - 0.015));
+  ctx.font = `${VALUE_FONT_SIZE}px sans-serif`;
+  ctx.textBaseline = "middle";
+  ctx.fillText(cell.value, scale.toPixelX(centerX), scale.toPixelY(centerY));
+  ctx.font = `${CAPTION_FONT_SIZE}px sans-serif`;
+  if (cell.columnCaption !== undefined) {
+    ctx.textBaseline = "bottom";
+    const blockHeight = (cell.columnCaption.length - 1) * CAPTION_LINE_HEIGHT;
+    const anchor = Math.max(scale.toPixelY(cell.top + 0.02), scale.area.top + blockHeight + CAPTION_FONT_SIZE);
+    drawLines(ctx, cell.columnCaption, scale.toPixelX(centerX), anchor - blockHeight, CAPTION_LINE_HEIGHT);
+  }
+  if (cell.rowCaption !== undefined) {
+    const gapLeft = scale.toPixelX(WORLD_X.min);
+    const layout = fitCaption(scale.toPixelX(cell.left) - gapLeft, cell.rowCaption.length);
+    ctx.save();
+    ctx.font = `${layout.fontSize}px sans-serif`;
+    ctx.translate(gapLeft + layout.start, scale.toPixelY(centerY));
+    ctx.rotate(-Math.PI / 2);
+    ctx.textAlign = "center";
+    ctx.textBaseline = "middle";
+    drawLines(ctx, cell.rowCaption, 0, 0, layout.advance);
+    ctx.restore();
+  }
+}
+function fitCaption(gap, lineCount) {
+  const advance = Math.min(CAPTION_LINE_HEIGHT, gap / lineCount);
+  const fontSize = Math.max(MIN_CAPTION_FONT_SIZE, Math.min(CAPTION_FONT_SIZE, advance - 1));
+  return { advance, fontSize, start: (gap - (lineCount - 1) * advance) / 2 };
+}
+function drawLines(ctx, lines, x, y, advance) {
+  for (const [index, line] of lines.entries()) {
+    ctx.fillText(line, x, y + index * advance);
+  }
+}
+function worldRect(scale, left, bottom, right, top) {
+  const x = scale.toPixelX(left);
+  const y = scale.toPixelY(top);
+  return [x, y, scale.toPixelX(right) - x, scale.toPixelY(bottom) - y];
+}
+// src/interactive/target.ts
+function resolveInteractiveTarget(target) {
+  if ("surface" in target) {
+    return target;
+  }
+  return { surface: resolveTarget(target), element: target };
+}
+function eventPixel(element, surface, event) {
+  const rect = element.getBoundingClientRect();
+  const scaleX = rect.width === 0 ? 1 : surface.width / rect.width;
+  const scaleY = rect.height === 0 ? 1 : surface.height / rect.height;
+  return {
+    x: (event.clientX - rect.left) * scaleX,
+    y: (event.clientY - rect.top) * scaleY
+  };
+}
+var CONTROL_COLUMN_WIDTH = 140;
+var FALLBACK_WIDTH = 640;
+var FALLBACK_HEIGHT = 400;
+function resolveControlTarget(target) {
+  if ("surface" in target) {
+    return {
+      surface: target.surface,
+      controls: target.controls,
+      release: () => {
+        return;
+      }
+    };
+  }
+  if (target.tagName === "CANVAS") {
+    throw new Error("interactive target: pass a container element to build the panel in, " + "not a canvas. A canvas has no room for the controls.");
+  }
+  const owner = target.ownerDocument;
+  const controls = owner.createElement("div");
+  controls.style.width = `${CONTROL_COLUMN_WIDTH}px`;
+  controls.style.flexShrink = "0";
+  controls.style.padding = "4px 6px";
+  controls.style.overflowY = "auto";
+  const width = target.clientWidth > CONTROL_COLUMN_WIDTH ? target.clientWidth - CONTROL_COLUMN_WIDTH : FALLBACK_WIDTH;
+  const height = target.clientHeight > 0 ? target.clientHeight : FALLBACK_HEIGHT;
+  const ratio = pixelRatio();
+  const canvas = owner.createElement("canvas");
+  canvas.width = Math.round(width * ratio);
+  canvas.height = Math.round(height * ratio);
+  canvas.style.width = `${width}px`;
+  canvas.style.height = `${height}px`;
+  canvas.style.minWidth = "0";
+  target.style.display = "flex";
+  target.appendChild(controls);
+  target.appendChild(canvas);
+  const remove = () => {
+    controls.remove();
+    canvas.remove();
+  };
+  const context = canvas.getContext("2d");
+  if (context === null) {
+    remove();
+    throw new Error("interactive target: the canvas gave no 2D context. In tests, pass " + "{ surface: { ctx, width, height }, controls } instead of a container.");
+  }
+  if (ratio !== 1) {
+    context.scale(ratio, ratio);
+  }
+  return { surface: { ctx: context, width, height }, controls, release: remove };
+}
+var FALLBACK_PLOT_HEIGHT = 480;
+function resolvePlot3dTarget(target) {
+  if ("plot" in target) {
+    return {
+      plot: target.plot,
+      controls: target.controls,
+      release: () => {
+        return;
+      }
+    };
+  }
+  if (target.tagName === "CANVAS") {
+    throw new Error("interactive target: pass a container element to build the panel in, " + "not a canvas. Plotly draws into an element of its own.");
+  }
+  const owner = target.ownerDocument;
+  const controls = owner.createElement("div");
+  controls.style.display = "flex";
+  controls.style.flexWrap = "wrap";
+  controls.style.gap = "12px";
+  controls.style.padding = "8px";
+  controls.style.flexShrink = "0";
+  const plot = owner.createElement("div");
+  plot.style.flex = "1 1 auto";
+  plot.style.minHeight = target.clientHeight > 0 ? "0" : `${FALLBACK_PLOT_HEIGHT}px`;
+  target.style.display = "flex";
+  target.style.flexDirection = "column";
+  target.appendChild(controls);
+  target.appendChild(plot);
+  return {
+    plot,
+    controls,
+    release: () => {
+      controls.remove();
+      plot.remove();
+    }
+  };
+}
+function pixelRatio() {
+  const ratio = globalThis.devicePixelRatio;
+  return typeof ratio === "number" && ratio > 0 ? ratio : 1;
+}
+// src/interactive/controls.ts
+function startingSliderValue(given, fallback, range) {
+  if (given === undefined) {
+    return fallback;
+  }
+  if (!Number.isFinite(given)) {
+    return range.min;
+  }
+  const clamped = Math.min(range.max, Math.max(range.min, given));
+  const decimals = decimalsOf(range.step);
+  const factor = 10 ** decimals;
+  const steps = Math.round((clamped - range.min) * factor / (range.step * factor));
+  const snapped = Number((range.min + steps * range.step).toFixed(decimals));
+  return Math.min(range.max, snapped);
+}
+function decimalsOf(step) {
+  return String(step).split(".")[1]?.length ?? 0;
+}
+function buildSlider(owner, name, label, range, value) {
+  const wrapper = owner.createElement("label");
+  wrapper.style.display = "block";
+  const caption = owner.createElement("span");
+  caption.textContent = `${label} `;
+  const readout = owner.createElement("output");
+  readout.textContent = String(value);
+  const input = owner.createElement("input");
+  input.type = "range";
+  input.name = name;
+  input.min = String(range.min);
+  input.max = String(range.max);
+  input.step = String(range.step);
+  input.value = String(value);
+  input.style.width = "100%";
+  wrapper.appendChild(caption);
+  wrapper.appendChild(readout);
+  wrapper.appendChild(input);
+  return { wrapper, input, readout };
+}
+function buildSelect(owner, name, label, choices, selected) {
+  const wrapper = owner.createElement("label");
+  wrapper.style.display = "block";
+  const caption = owner.createElement("span");
+  caption.textContent = `${label} `;
+  const input = owner.createElement("select");
+  input.name = name;
+  input.style.width = "100%";
+  for (const choice of choices) {
+    const option = owner.createElement("option");
+    option.value = String(choice);
+    option.textContent = String(choice);
+    input.appendChild(option);
+  }
+  input.value = String(selected);
+  wrapper.appendChild(caption);
+  wrapper.appendChild(input);
+  return { wrapper, input };
+}
+function buildNote(owner) {
+  const element = owner.createElement("p");
+  element.style.margin = "4px 0 0";
+  element.style.fontSize = "12px";
+  element.textContent = "";
+  element.hidden = true;
+  return {
+    element,
+    show(text) {
+      element.textContent = text ?? "";
+      element.hidden = text === null;
+    }
+  };
+}
+
+// src/interactive/matrixInverse.ts
+var DEFAULT_MATRIX_INVERSE_VALUES = {
+  x1: 1,
+  y1: 2,
+  x2: 2,
+  y2: 1
+};
+var ENTRIES = ["x1", "y1", "x2", "y2"];
+var SLIDER_MIN = -2;
+var SLIDER_MAX = 2;
+var SLIDER_STEP = 0.1;
+var SLIDER_RANGE = {
+  min: SLIDER_MIN,
+  max: SLIDER_MAX,
+  step: SLIDER_STEP
+};
+var NOTICE_BACKGROUND = "#ffffff";
+var NOTICE_COLOR = "#b22222";
+var NOTICE_FONT = "12px monospace";
+var NOTICE_MARGIN = 12;
+var SIGNIFICANT_DIGITS = 6;
+function interactiveMatrixInverse(target, options = {}) {
+  const { onDone } = options;
+  const panel = resolveControlTarget(target);
+  const startingValue = (name) => startingSliderValue(options[name], DEFAULT_MATRIX_INVERSE_VALUES[name], SLIDER_RANGE);
+  let values = {
+    x1: startingValue("x1"),
+    y1: startingValue("y1"),
+    x2: startingValue("x2"),
+    y2: startingValue("y2")
+  };
+  const owner = panel.controls.ownerDocument;
+  const built = [];
+  const inputs = [];
+  const readouts = new Map;
+  let destroyed = false;
+  function draw() {
+    const drawn = plotMatrixInverse(panel.surface, values);
+    if (drawn.singularity !== null) {
+      showNotice(panel.surface, drawn);
+    }
+    return drawn;
+  }
+  function handleInput(event) {
+    const input = event.target;
+    const name = input.name;
+    if (!(name in values)) {
+      return;
+    }
+    values = { ...values, [name]: Number(input.value) };
+    const readout = readouts.get(name);
+    if (readout !== undefined) {
+      readout.textContent = input.value;
+    }
+    result = draw();
+  }
+  for (const name of ENTRIES) {
+    const { wrapper, input, readout } = buildSlider(owner, name, name, SLIDER_RANGE, values[name]);
+    readouts.set(name, readout);
+    panel.controls.appendChild(wrapper);
+    built.push(wrapper);
+    inputs.push(input);
+    input.addEventListener("input", handleInput);
+  }
+  let result = draw();
+  return {
+    getValues: () => ({ ...values }),
+    getResult: () => result,
+    done() {
+      onDone?.({ ...values });
+    },
+    destroy() {
+      if (destroyed) {
+        return;
+      }
+      destroyed = true;
+      for (const input of inputs) {
+        input.removeEventListener("input", handleInput);
+      }
+      for (const node of built) {
+        node.remove();
+      }
+      panel.release();
+    }
+  };
+}
+function showNotice(surface, report) {
+  const { ctx, width, height } = surface;
+  ctx.save();
+  ctx.setLineDash([]);
+  ctx.fillStyle = NOTICE_BACKGROUND;
+  ctx.fillRect(0, 0, width, height);
+  ctx.fillStyle = NOTICE_COLOR;
+  ctx.font = NOTICE_FONT;
+  ctx.textAlign = "left";
+  ctx.textBaseline = "top";
+  ctx.fillText(messageFor(report), NOTICE_MARGIN, NOTICE_MARGIN);
+  ctx.restore();
+}
+function messageFor(report) {
+  if (report.singularity === "exact") {
+    const pivot = report.zeroPivot ?? 1;
+    return `Lapack routine dgesv: system is exactly singular: U[${pivot},${pivot}] = 0`;
+  }
+  return "system is computationally singular: reciprocal condition number = " + formatConditionNumber(report.rcond);
+}
+function formatConditionNumber(value) {
+  const [mantissa, exponentText] = value.toExponential(SIGNIFICANT_DIGITS - 1).split("e");
+  const exponent = Number(exponentText);
+  const sign = exponent < 0 ? "-" : "+";
+  const digits = String(Math.abs(exponent)).padStart(2, "0");
+  return `${withoutTrailingZeros(String(mantissa))}e${sign}${digits}`;
+}
+function withoutTrailingZeros(text) {
+  if (!text.includes(".")) {
+    return text;
+  }
+  return text.replace(/0+$/, "").replace(/\.$/, "");
+}
+// src/interactive/sampling.ts
+var SAMPLE_SIZES = [10, 100, 500, 1000, 5000, 1e4];
+var REPETITIONS = [1, 5, 10, 50, 100];
+var SAMPLE_SIZE_NAME = "sampleSize";
+var SAMPLE_SIZE_LABEL = "Sample size";
+var REPS_NAME = "reps";
+var REPS_LABEL = "Repetitions";
+var BUTTON_LABEL = "Sample";
+function interactiveSampling(target, population, options = {}) {
+  const {
+    onDone,
+    sampleSize,
+    reps,
+    rng: given,
+    state: initial,
+    ...forwarded
+  } = options;
+  const panel = resolveControlTarget(target);
+  let values = {
+    sampleSize: chooseFrom(sampleSize, SAMPLE_SIZES),
+    reps: chooseFrom(reps, REPETITIONS)
+  };
+  const rng = given ?? seededRng(Math.floor(Math.random() * 4294967296));
+  let state = initial ?? null;
+  let last;
+  const owner = panel.controls.ownerDocument;
+  const built = [];
+  let destroyed = false;
+  function draw(repetitions) {
+    last = plotSampling(panel.surface, population, {
+      ...forwarded,
+      sampleSize: values.sampleSize,
+      reps: repetitions,
+      rng,
+      state
+    });
+    state = last.state;
+  }
+  function handleChange(event) {
+    const input = event.target;
+    const numeric = Number(input.value);
+    values = input.name === SAMPLE_SIZE_NAME ? { ...values, sampleSize: numeric } : { ...values, reps: numeric };
+  }
+  function handlePress() {
+    draw(values.reps);
+  }
+  const sizeSelect = buildSelect(owner, SAMPLE_SIZE_NAME, SAMPLE_SIZE_LABEL, SAMPLE_SIZES, values.sampleSize);
+  const repsSelect = buildSelect(owner, REPS_NAME, REPS_LABEL, REPETITIONS, values.reps);
+  const button = owner.createElement("button");
+  button.type = "button";
+  button.textContent = BUTTON_LABEL;
+  for (const wrapper of [sizeSelect.wrapper, repsSelect.wrapper]) {
+    panel.controls.appendChild(wrapper);
+    built.push(wrapper);
+  }
+  panel.controls.appendChild(button);
+  built.push(button);
+  sizeSelect.input.addEventListener("change", handleChange);
+  repsSelect.input.addEventListener("change", handleChange);
+  button.addEventListener("click", handlePress);
+  draw(values.reps);
+  return {
+    getValues: () => ({ ...values }),
+    getState: () => last.state,
+    reset() {
+      state = null;
+      draw(0);
+    },
+    done() {
+      onDone?.(last.state);
+    },
+    destroy() {
+      if (destroyed) {
+        return;
+      }
+      destroyed = true;
+      sizeSelect.input.removeEventListener("change", handleChange);
+      repsSelect.input.removeEventListener("change", handleChange);
+      button.removeEventListener("click", handlePress);
+      for (const node of built) {
+        node.remove();
+      }
+      panel.release();
+    }
+  };
+}
+function chooseFrom(asked, choices) {
+  const first = choices[0];
+  return asked !== undefined && choices.includes(asked) ? asked : first;
+}
+// src/interactive/tTest.ts
+var SLIDERS = [
+  { name: "diff", label: "Difference", min: 0, max: 4, step: 0.1 },
+  { name: "sd", label: "Std Dev", min: 1, max: 5, step: 0.1 },
+  { name: "n", label: "Sample Size", min: 2, max: 500, step: 1 },
+  { name: "alpha", label: "Alpha", min: 0.01, max: 0.1, step: 0.01 }
+];
+var ERROR_MATRIX_NAME = "errorMatrix";
+var ERROR_MATRIX_LABEL = "Error Matrix";
+function interactiveTTest(target, options = {}) {
+  const { onDone, diff, sd: sd2, n, alpha, errorMatrix, ...forwarded } = options;
+  const panel = resolveControlTarget(target);
+  let values = {
+    diff: diff ?? DEFAULT_T_TEST_OPTIONS.diff,
+    sd: sd2 ?? DEFAULT_T_TEST_OPTIONS.sd,
+    n: n ?? DEFAULT_T_TEST_OPTIONS.n,
+    alpha: alpha ?? DEFAULT_T_TEST_OPTIONS.alpha,
+    errorMatrix: errorMatrix ?? false
+  };
+  const owner = panel.controls.ownerDocument;
+  const built = [];
+  const inputs = [];
+  const readouts = new Map;
+  let destroyed = false;
+  function draw() {
+    return plotTTest(panel.surface, { ...forwarded, ...values });
+  }
+  function withControl(input) {
+    const numeric = Number(input.value);
+    switch (input.name) {
+      case "diff":
+        return { ...values, diff: numeric };
+      case "sd":
+        return { ...values, sd: numeric };
+      case "n":
+        return { ...values, n: numeric };
+      case "alpha":
+        return { ...values, alpha: numeric };
+      case ERROR_MATRIX_NAME:
+        return { ...values, errorMatrix: input.checked };
+      default:
+        return values;
+    }
+  }
+  function handleInput(event) {
+    const input = event.target;
+    values = withControl(input);
+    const readout = readouts.get(input.name);
+    if (readout !== undefined) {
+      readout.textContent = input.value;
+    }
+    stats = draw();
+  }
+  function mount(wrapper, input) {
+    panel.controls.appendChild(wrapper);
+    built.push(wrapper);
+    inputs.push(input);
+    input.addEventListener("input", handleInput);
+  }
+  for (const spec of SLIDERS) {
+    const { wrapper, input, readout } = buildSlider(owner, spec.name, spec.label, spec, values[spec.name]);
+    readouts.set(spec.name, readout);
+    mount(wrapper, input);
+  }
+  const checkboxWrapper = owner.createElement("label");
+  checkboxWrapper.style.display = "block";
+  const checkbox = owner.createElement("input");
+  checkbox.type = "checkbox";
+  checkbox.name = ERROR_MATRIX_NAME;
+  checkbox.checked = values.errorMatrix;
+  checkboxWrapper.appendChild(checkbox);
+  checkboxWrapper.appendChild(owner.createTextNode(` ${ERROR_MATRIX_LABEL}`));
+  mount(checkboxWrapper, checkbox);
+  let stats = draw();
+  return {
+    getValues: () => ({ ...values }),
+    getStats: () => stats,
+    done() {
+      onDone?.({ ...values });
+    },
+    destroy() {
+      if (destroyed) {
+        return;
+      }
+      destroyed = true;
+      for (const input of inputs) {
+        input.removeEventListener("input", handleInput);
+      }
+      for (const node of built) {
+        node.remove();
+      }
+      panel.release();
+    }
+  };
+}
+// src/interactive/logit.ts
+var DEFAULT_MIN_X2 = 0;
+var DEFAULT_MAX_X2 = 50;
+function interactiveLogit(target, options = {}) {
+  const {
+    initialPoints,
+    onDone,
+    minX = DEFAULT_MIN_X2,
+    maxX = DEFAULT_MAX_X2,
+    ...plotOptions
+  } = options;
+  const { surface, element } = resolveInteractiveTarget(target);
+  let points = initialPoints ?? [];
+  const rightEdge = points.reduce((edge, point) => Math.max(edge, point.x), maxX);
+  function draw() {
+    plotLogit(surface, points, { ...plotOptions, minX, maxX: rightEdge });
+  }
+  function handleClick(event) {
+    const scale = logitScale(surface.width, surface.height, points, {
+      minX,
+      maxX: rightEdge
+    });
+    const pixel = eventPixel(element, surface, event);
+    if (!pixelInArea(scale.area, pixel)) {
+      return;
+    }
+    points = [
+      ...points,
+      {
+        x: clamp(scale.toWorldX(pixel.x), 0, rightEdge),
+        y: Math.round(clamp(scale.toWorldY(pixel.y), 0, 1))
+      }
+    ];
+    draw();
+  }
+  draw();
+  element.addEventListener("click", handleClick);
+  return {
+    getPoints: () => [...points],
+    reset() {
+      points = [];
+      draw();
+    },
+    done() {
+      onDone?.([...points]);
+    },
+    destroy() {
+      element.removeEventListener("click", handleClick);
+    }
+  };
+}
+function clamp(value, low, high) {
+  return Math.min(high, Math.max(low, value));
+}
+// src/interactive/pca.ts
+function interactivePca(target, options = {}) {
+  const { initialPoints, onDone, ...plotOptions } = options;
+  const { surface, element } = resolveInteractiveTarget(target);
+  let points = initialPoints ?? [];
+  let fit = null;
+  function draw() {
+    fit = plotPca(surface, points, plotOptions);
+  }
+  function handleClick(event) {
+    const scale = pcaScale(surface.width, surface.height, plotOptions);
+    const pixel = eventPixel(element, surface, event);
+    points = [
+      ...points,
+      { x: scale.toWorldX(pixel.x), y: scale.toWorldY(pixel.y) }
+    ];
+    draw();
+  }
+  draw();
+  element.addEventListener("click", handleClick);
+  return {
+    getPoints: () => [...points],
+    getFit: () => fit,
+    reset() {
+      points = [];
+      draw();
+    },
+    done() {
+      onDone?.({ points: [...points], fit });
+    },
+    destroy() {
+      element.removeEventListener("click", handleClick);
+    }
+  };
+}
+// src/interactive/regression.ts
+function interactiveRegression(target, options = {}) {
+  const { initialPoints, onDone, ...plotOptions } = options;
+  const { surface, element } = resolveInteractiveTarget(target);
+  const scale = regressionScale(surface.width, surface.height);
+  let points = initialPoints ?? [];
+  function draw() {
+    plotRegression(surface, points, plotOptions);
+  }
+  function handleClick(event) {
+    const pixel = eventPixel(element, surface, event);
+    if (!pixelInArea(scale.area, pixel)) {
+      return;
+    }
+    points = [
+      ...points,
+      { x: scale.toWorldX(pixel.x), y: scale.toWorldY(pixel.y) }
+    ];
+    draw();
+  }
+  draw();
+  element.addEventListener("click", handleClick);
+  return {
+    getPoints: () => [...points],
+    reset() {
+      points = [];
+      draw();
+    },
+    done() {
+      onDone?.([...points]);
+    },
+    destroy() {
+      element.removeEventListener("click", handleClick);
+    }
+  };
+}
+export {
+  tTestStats,
+  tTestScale,
+  simulateSampleCi,
+  seededRng,
+  sd,
+  samplingScale,
+  sampleWithoutReplacement,
+  sampleConfidenceIntervals,
+  sampleCiScale,
+  runif,
+  rt,
+  rnorm,
+  rlnorm,
+  resolveTarget,
+  resolveInteractiveTarget,
+  resolveControlTarget,
+  requireNumericColumn,
+  regressionScale,
+  rcauchy,
+  rPretty,
+  quantiles,
+  quantile,
+  qt,
+  pt,
+  principalComponents,
+  prettyTicks,
+  predictLogit,
+  plotTTest,
+  plotSampling,
+  plotSampleCi,
+  plotRegression,
+  plotPca,
+  plotMatrixInverse,
+  plotLogit,
+  pixelInArea,
+  pcaScale,
+  pcaDegenerate,
+  numericColumns,
+  normalCdf,
+  nclassSturges,
+  moderationSurface,
+  moderationData,
+  median,
+  meanAbsoluteDeviation,
+  mean,
+  matrixInverseScale,
+  machinePrecision,
+  logitScale,
+  logisticRegression,
+  logGamma,
+  logBeta,
+  linearRegression,
+  leastSquares,
+  kernelDensity,
+  isNumericColumn,
+  invertMatrix,
+  inverseIncompleteBeta,
+  interactiveTTest,
+  interactiveSampling,
+  interactiveRegression,
+  interactivePca,
+  interactiveMatrixInverse,
+  interactiveLogit,
+  incompleteBetaSplit,
+  incompleteBeta,
+  histogram,
+  frameRows,
+  formatStat,
+  formatNumber,
+  eventPixel,
+  dt,
+  drawSamples,
+  drawAxes,
+  determinant,
+  createScale,
+  bwNrd0,
+  DEFAULT_T_TEST_OPTIONS,
+  DEFAULT_MATRIX_INVERSE_VALUES,
+  DEFAULT_MARGINS,
+  DEFAULT_LOGIT_MAX_ITERATIONS,
+  DEFAULT_LOGIT_EPSILON,
+  DEFAULT_LEAST_SQUARES_TOLERANCE
+};
+
+//# debugId=2FC10F4594685E1B64756E2164756E21
+//# sourceMappingURL=index.js.map