@compstats/core 0.2.0

package/dist/3d.js

@@ -0,0 +1,1984 @@
+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/plot/plotly.ts
+function sameCamera(a, b) {
+  if (a === undefined || b === undefined) {
+    return a === b;
+  }
+  return sameVector(a.eye, b.eye) && sameVector(a.center, b.center) && sameVector(a.up, b.up);
+}
+function sameVector(a, b) {
+  if (a === undefined || b === undefined) {
+    return a === b;
+  }
+  return a.x === b.x && a.y === b.y && a.z === b.z;
+}
+var loading;
+function loadPlotly() {
+  loading ??= import("plotly.js-dist-min").then((module) => {
+    const loaded = module.default ?? module;
+    return loaded;
+  });
+  return loading;
+}
+// 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/plot/scatter3d.ts
+var UIREVISION = "scatter3d";
+var NUMERIC_COLORSCALE = "Viridis";
+var CONFIG = { responsive: true };
+var DEFAULT_SCATTER3D_STYLE = {
+  aspect: [1, 1, 1],
+  opacity: 0.8,
+  size: 5
+};
+function scatter3dSpec(data, options = {}) {
+  const {
+    aspect = DEFAULT_SCATTER3D_STYLE.aspect,
+    opacity = DEFAULT_SCATTER3D_STYLE.opacity,
+    size = DEFAULT_SCATTER3D_STYLE.size,
+    camera,
+    titles,
+    color
+  } = options;
+  validateScatter3dStyle(aspect, opacity, size);
+  frameRows(data);
+  const { axes, note } = chooseAxes(data, options);
+  const points = {
+    x: requireAxisColumn(data, axes.x, "x"),
+    y: requireAxisColumn(data, axes.y, "y"),
+    z: requireAxisColumn(data, axes.z, "z")
+  };
+  const colorColumn = color === undefined ? undefined : data[color];
+  if (color !== undefined && colorColumn === undefined) {
+    throw new RangeError(`Column "${color}" (passed as \`color\`) is not in the data.`);
+  }
+  const traces = buildTraces(points, { opacity, size }, colorColumn);
+  const shown = { x: axes.x, y: axes.y, z: axes.z, ...titles };
+  const layout = {
+    uirevision: UIREVISION,
+    scene: {
+      aspectmode: "manual",
+      aspectratio: {
+        x: aspect[0],
+        y: aspect[1],
+        z: aspect[2]
+      },
+      xaxis: { title: { text: shown.x } },
+      yaxis: { title: { text: shown.y } },
+      zaxis: { title: { text: shown.z } },
+      uirevision: UIREVISION,
+      ...camera === undefined ? {} : { camera }
+    }
+  };
+  return { traces, layout, note };
+}
+async function plotScatter3d(target, data, options = {}) {
+  const { plotly, ...specOptions } = options;
+  const spec = scatter3dSpec(data, specOptions);
+  const engine = plotly ?? await loadPlotly();
+  const element = await engine.react(target, spec.traces, spec.layout, CONFIG);
+  return { ...spec, element, plotly: engine };
+}
+function validateScatter3dStyle(aspect, opacity, size) {
+  if (aspect.length !== 3 || !aspect.every((value) => Number.isFinite(value))) {
+    throw new RangeError("`aspect` must be a numeric vector of length 3.");
+  }
+  if (aspect.some((value) => value <= 0)) {
+    throw new RangeError("`aspect` values must all be positive.");
+  }
+  if (!Number.isFinite(opacity) || opacity <= 0 || opacity > 1) {
+    throw new RangeError("`opacity` must be a single numeric in (0, 1].");
+  }
+  if (!Number.isFinite(size) || size <= 0) {
+    throw new RangeError("`size` must be a single positive numeric.");
+  }
+}
+function chooseAxes(data, options) {
+  const { x, y, z } = options;
+  if (x !== undefined && y !== undefined && z !== undefined) {
+    return { axes: { x, y, z }, note: null };
+  }
+  const numeric = numericColumns(data);
+  requireThreeNumericColumns(numeric, "plotScatter3d");
+  const chosen = numeric.slice(0, 3);
+  const skipped = numeric.slice(3);
+  const note = skipped.length === 0 ? null : `plotScatter3d(): using numeric columns ${chosen.join(", ")}; ` + `skipped ${skipped.join(", ")}. Pass x/y/z to choose explicitly.`;
+  return {
+    axes: { x: x ?? chosen[0], y: y ?? chosen[1], z: z ?? chosen[2] },
+    note
+  };
+}
+function requireAxisColumn(data, name, axis) {
+  const column = data[name];
+  if (column === undefined) {
+    throw new RangeError(`Column "${name}" (passed as \`${axis}\`) is not in the data.`);
+  }
+  if (!isNumericColumn(column)) {
+    throw new RangeError(`Column "${name}" (passed as \`${axis}\`) is ${describe(column)}; ` + "plotScatter3d() requires numeric columns on x/y/z. " + "Use `color` for categorical separation.");
+  }
+  return column;
+}
+function describe(column) {
+  const kinds = new Set(column.map((value) => typeof value));
+  if (kinds.size === 0) {
+    return "empty";
+  }
+  if (kinds.size > 1) {
+    return "mixed";
+  }
+  if (kinds.has("string")) {
+    return "text";
+  }
+  return kinds.has("boolean") ? "true or false" : "numbers";
+}
+function buildTraces(points, marker, color) {
+  if (color === undefined) {
+    return [{ type: "scatter3d", mode: "markers", ...points, marker }];
+  }
+  if (isNumericColumn(color)) {
+    return [
+      {
+        type: "scatter3d",
+        mode: "markers",
+        ...points,
+        marker: {
+          ...marker,
+          color,
+          colorscale: NUMERIC_COLORSCALE,
+          showscale: true
+        }
+      }
+    ];
+  }
+  const levels = [...new Set(color.map((value) => String(value)))];
+  return levels.map((level) => {
+    const rows = color.flatMap((value, row) => String(value) === level ? [row] : []);
+    return {
+      type: "scatter3d",
+      mode: "markers",
+      x: rows.map((row) => points.x[row]),
+      y: rows.map((row) => points.y[row]),
+      z: rows.map((row) => points.z[row]),
+      marker,
+      name: level,
+      showlegend: true
+    };
+  });
+}
+// 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/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/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/scatter3d.ts
+var NONE = "(none)";
+var ASPECT_RANGE = { min: 0.1, max: 10, step: 0.1 };
+var OPACITY_RANGE = { min: 0.05, max: 1, step: 0.05 };
+var SIZE_RANGE = { min: 1, max: 20, step: 1 };
+var ASPECT_SLIDERS = [
+  { name: "aspectX", label: "Aspect X" },
+  { name: "aspectY", label: "Aspect Y" },
+  { name: "aspectZ", label: "Aspect Z" }
+];
+function interactiveScatter3d(target, data, options = {}) {
+  const {
+    plotly: givenEngine,
+    onDone,
+    x,
+    y,
+    z,
+    color,
+    aspect,
+    opacity,
+    size,
+    camera,
+    titles,
+    ...forwarded
+  } = options;
+  const style = {
+    aspect: aspect ?? DEFAULT_SCATTER3D_STYLE.aspect,
+    opacity: opacity ?? DEFAULT_SCATTER3D_STYLE.opacity,
+    size: size ?? DEFAULT_SCATTER3D_STYLE.size
+  };
+  validateScatter3dStyle(style.aspect, style.opacity, style.size);
+  const numeric = numericColumns(data);
+  requireThreeNumericColumns(numeric, "interactiveScatter3d");
+  for (const [axis, given] of [
+    ["x", x],
+    ["y", y],
+    ["z", z]
+  ]) {
+    if (given !== undefined && !numeric.includes(given)) {
+      throw new RangeError(`Initial \`${axis}\` ("${given}") is not a numeric column of ` + `\`data\`. Numeric columns: ${numeric.join(", ")}.`);
+    }
+  }
+  if (color !== undefined && data[color] === undefined) {
+    throw new RangeError(`Initial \`color\` ("${color}") is not in \`data\`.`);
+  }
+  const panel = resolvePlot3dTarget(target);
+  const owner = panel.controls.ownerDocument;
+  let values = {
+    x: x ?? numeric[0],
+    y: y ?? numeric[1],
+    z: z ?? numeric[2],
+    color,
+    aspect: style.aspect.map((value, axis) => startingSliderValue(value, DEFAULT_SCATTER3D_STYLE.aspect[axis], ASPECT_RANGE)),
+    opacity: startingSliderValue(style.opacity, DEFAULT_SCATTER3D_STYLE.opacity, OPACITY_RANGE),
+    size: startingSliderValue(style.size, DEFAULT_SCATTER3D_STYLE.size, SIZE_RANGE),
+    camera,
+    titles
+  };
+  let spec = null;
+  let engine = givenEngine;
+  let element = null;
+  let listening = false;
+  let destroyed = false;
+  let inFlight = null;
+  let queued = false;
+  const note = buildNote(owner);
+  async function renderOnce() {
+    const drawn = await plotScatter3d(panel.plot, data, {
+      ...forwarded,
+      ...values,
+      plotly: engine
+    });
+    if (destroyed) {
+      return;
+    }
+    engine = drawn.plotly;
+    element = drawn.element;
+    spec = { traces: drawn.traces, layout: drawn.layout, note: drawn.note };
+    note.show(drawn.note);
+    if (!listening) {
+      listening = true;
+      element.on("plotly_relayout", handleRelayout);
+    }
+  }
+  function requestRender() {
+    if (destroyed) {
+      return;
+    }
+    queued = true;
+    inFlight ??= start();
+  }
+  function start() {
+    const run = pump();
+    run.catch(() => {
+      return;
+    });
+    return run;
+  }
+  async function pump() {
+    try {
+      while (queued && !destroyed) {
+        queued = false;
+        await renderOnce();
+      }
+    } finally {
+      inFlight = null;
+    }
+  }
+  function handleRelayout(event) {
+    const moved = event["scene.camera"];
+    if (moved === undefined || destroyed || sameCamera(moved, values.camera)) {
+      return;
+    }
+    values = { ...values, camera: moved };
+    if (element !== null && engine !== undefined) {
+      engine.relayout(element, { "scene.camera": moved }).catch(() => {
+        return;
+      });
+    }
+  }
+  function handleChange(event) {
+    const input = event.target;
+    if (input.name === "color") {
+      values = {
+        ...values,
+        color: input.value === NONE ? undefined : input.value
+      };
+    } else {
+      values = { ...values, [input.name]: input.value };
+    }
+    requestRender();
+  }
+  function handleInput(event) {
+    const input = event.target;
+    const moved = Number(input.value);
+    const axis = ASPECT_SLIDERS.findIndex((slider) => slider.name === input.name);
+    if (axis >= 0) {
+      values = {
+        ...values,
+        aspect: values.aspect.map((was, index) => index === axis ? moved : was)
+      };
+    } else {
+      values = { ...values, [input.name]: moved };
+    }
+    const readout = readouts.get(input.name);
+    if (readout !== undefined) {
+      readout.textContent = input.value;
+    }
+    requestRender();
+  }
+  const built = [];
+  const selects = [];
+  const sliders = [];
+  const readouts = new Map;
+  for (const [axis, label] of [
+    ["x", "X"],
+    ["y", "Y"],
+    ["z", "Z"]
+  ]) {
+    const picker = buildSelect(owner, axis, label, numeric, values[axis]);
+    panel.controls.appendChild(picker.wrapper);
+    built.push(picker.wrapper);
+    selects.push(picker.input);
+  }
+  const colorPicker = buildSelect(owner, "color", "Color", [NONE, ...Object.keys(data)], values.color ?? NONE);
+  panel.controls.appendChild(colorPicker.wrapper);
+  built.push(colorPicker.wrapper);
+  selects.push(colorPicker.input);
+  for (const [axis, wanted] of ASPECT_SLIDERS.entries()) {
+    const control = buildSlider(owner, wanted.name, wanted.label, ASPECT_RANGE, values.aspect[axis]);
+    panel.controls.appendChild(control.wrapper);
+    built.push(control.wrapper);
+    sliders.push(control.input);
+    readouts.set(wanted.name, control.readout);
+  }
+  for (const [name, label, range, value] of [
+    ["opacity", "Opacity", OPACITY_RANGE, values.opacity],
+    ["size", "Size", SIZE_RANGE, values.size]
+  ]) {
+    const control = buildSlider(owner, name, label, range, value);
+    panel.controls.appendChild(control.wrapper);
+    built.push(control.wrapper);
+    sliders.push(control.input);
+    readouts.set(name, control.readout);
+  }
+  panel.controls.appendChild(note.element);
+  built.push(note.element);
+  for (const select of selects) {
+    select.addEventListener("change", handleChange);
+  }
+  for (const slider of sliders) {
+    slider.addEventListener("input", handleInput);
+  }
+  requestRender();
+  function currentValues() {
+    return { ...values, aspect: [...values.aspect] };
+  }
+  return {
+    getValues: currentValues,
+    getSpec: () => spec,
+    rendered: () => inFlight ?? Promise.resolve(),
+    done() {
+      onDone?.(currentValues());
+    },
+    destroy() {
+      if (destroyed) {
+        return;
+      }
+      destroyed = true;
+      for (const select of selects) {
+        select.removeEventListener("change", handleChange);
+      }
+      for (const slider of sliders) {
+        slider.removeEventListener("input", handleInput);
+      }
+      for (const node of built) {
+        node.remove();
+      }
+      if (element !== null) {
+        element.removeAllListeners("plotly_relayout");
+        engine?.purge(element);
+      }
+      panel.release();
+    }
+  };
+}
+// 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/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/plot/moderation3d.ts
+var DEFAULT_Z_ROT = 40;
+var DEFAULT_X_ROT = -70;
+var EYE_DISTANCE = 1.25 * Math.sqrt(3);
+var UIREVISION2 = "moderation3d";
+var CONFIG2 = { responsive: true };
+function cameraFromRotations(zRot, xRot) {
+  if (!Number.isFinite(zRot) || !Number.isFinite(xRot)) {
+    throw new RangeError("`zRot` and `xRot` must be finite numbers.");
+  }
+  const azimuth = (-90 - zRot) * Math.PI / 180;
+  const elevation = (90 + xRot) * Math.PI / 180;
+  const eye = {
+    x: EYE_DISTANCE * Math.cos(elevation) * Math.cos(azimuth),
+    y: EYE_DISTANCE * Math.cos(elevation) * Math.sin(azimuth),
+    z: EYE_DISTANCE * Math.sin(elevation)
+  };
+  return { eye };
+}
+function moderation3dSpec(surface, model, view = {}) {
+  const { zRot = DEFAULT_Z_ROT, xRot = DEFAULT_X_ROT, zlim } = view;
+  const camera = cameraFromRotations(zRot, xRot);
+  if (zlim !== undefined) {
+    if (zlim.length !== 2 || !zlim.every((value) => Number.isFinite(value))) {
+      throw new RangeError("`zlim` must be two finite numbers.");
+    }
+  }
+  const range = zlim ?? [
+    surface.zlim[0],
+    surface.zlim[1]
+  ];
+  const steps = surface.ivValues.length;
+  const heights = surface.modValues.map((_, j) => surface.ivValues.map((__, i) => surface.predictions[j * steps + i]));
+  if (!surface.predictions.every(Number.isFinite)) {
+    throw new RangeError("the surface must have finite heights everywhere; " + "a prediction is NaN or infinite");
+  }
+  const trace = {
+    type: "surface",
+    x: surface.ivValues,
+    y: surface.modValues,
+    z: heights,
+    showscale: false
+  };
+  const layout = {
+    uirevision: UIREVISION2,
+    scene: {
+      xaxis: { title: { text: model.iv } },
+      yaxis: { title: { text: model.mod } },
+      zaxis: { title: { text: model.outcome }, range },
+      uirevision: UIREVISION2,
+      camera
+    }
+  };
+  return { traces: [trace], layout, note: describeHolds(model) };
+}
+async function plotModeration3d(target, data, options) {
+  const { plotly, zRot, xRot, zlim, ...model } = options;
+  const surface = moderationSurface(data, model);
+  const spec = moderation3dSpec(surface, model, { zRot, xRot, zlim });
+  const engine = plotly ?? await loadPlotly();
+  const element = await engine.react(target, spec.traces, spec.layout, CONFIG2);
+  return { ...spec, element, plotly: engine, surface };
+}
+function describeHolds(model) {
+  if ((model.controls ?? []).length === 0) {
+    return null;
+  }
+  return `Surface shows predicted ${model.outcome} over ${model.iv} and ` + `${model.mod}. Other predictors are held at their typical values.`;
+}
+
+// src/interactive/moderation3d.ts
+var Z_ROT_RANGE = { min: 0, max: 360, step: 1 };
+var X_ROT_RANGE = { min: -90, max: -70, step: 1 };
+var DEFAULT_Z_ROT2 = 40;
+var DEFAULT_X_ROT2 = -70;
+var SLIDERS = [
+  {
+    name: "zRot",
+    label: "Z rotation",
+    range: Z_ROT_RANGE,
+    fallback: DEFAULT_Z_ROT2
+  },
+  {
+    name: "xRot",
+    label: "X rotation",
+    range: X_ROT_RANGE,
+    fallback: DEFAULT_X_ROT2
+  }
+];
+function interactiveModeration3d(target, data, options) {
+  const { plotly: givenEngine, onDone, zRot, xRot, ...model } = options;
+  const panel = resolvePlot3dTarget(target);
+  const owner = panel.controls.ownerDocument;
+  let values = {
+    ...model,
+    zRot: startingSliderValue(zRot, DEFAULT_Z_ROT2, Z_ROT_RANGE),
+    xRot: startingSliderValue(xRot, DEFAULT_X_ROT2, X_ROT_RANGE)
+  };
+  let spec = null;
+  let surface = null;
+  let engine = givenEngine;
+  let element = null;
+  let painted = null;
+  let seenCamera;
+  let listening = false;
+  let destroyed = false;
+  let inFlight = null;
+  let queued = false;
+  const note = buildNote(owner);
+  async function renderOnce() {
+    const wanted = { zRot: values.zRot, xRot: values.xRot };
+    const drawn = await plotModeration3d(panel.plot, data, {
+      ...values,
+      plotly: engine
+    });
+    if (destroyed) {
+      return;
+    }
+    engine = drawn.plotly;
+    element = drawn.element;
+    surface = drawn.surface;
+    spec = { traces: drawn.traces, layout: drawn.layout, note: drawn.note };
+    note.show(drawn.note);
+    if (!listening) {
+      listening = true;
+      element.on("plotly_relayout", handleRelayout);
+    }
+    const moved = painted !== null && (painted.zRot !== wanted.zRot || painted.xRot !== wanted.xRot);
+    painted = wanted;
+    const camera = drawn.layout.scene.camera;
+    if (moved && camera !== undefined) {
+      seenCamera = camera;
+      await drawn.plotly.relayout(element, { "scene.camera": camera });
+    } else if (seenCamera !== undefined && !sameCamera(seenCamera, camera)) {
+      await drawn.plotly.relayout(element, { "scene.camera": seenCamera });
+    }
+  }
+  function handleRelayout(event) {
+    const moved = event["scene.camera"];
+    if (moved === undefined || destroyed || sameCamera(moved, seenCamera)) {
+      return;
+    }
+    seenCamera = moved;
+    if (element !== null && engine !== undefined) {
+      engine.relayout(element, { "scene.camera": moved }).catch(() => {
+        return;
+      });
+    }
+  }
+  function requestRender() {
+    if (destroyed) {
+      return;
+    }
+    queued = true;
+    inFlight ??= start();
+  }
+  function start() {
+    const run = pump();
+    run.catch(() => {
+      return;
+    });
+    return run;
+  }
+  async function pump() {
+    try {
+      while (queued && !destroyed) {
+        queued = false;
+        await renderOnce();
+      }
+    } finally {
+      inFlight = null;
+    }
+  }
+  function handleInput(event) {
+    const input = event.target;
+    values = { ...values, [input.name]: Number(input.value) };
+    const readout = readouts.get(input.name);
+    if (readout !== undefined) {
+      readout.textContent = input.value;
+    }
+    requestRender();
+  }
+  const built = [];
+  const inputs = [];
+  const readouts = new Map;
+  for (const slider of SLIDERS) {
+    const control = buildSlider(owner, slider.name, slider.label, slider.range, values[slider.name]);
+    panel.controls.appendChild(control.wrapper);
+    built.push(control.wrapper);
+    inputs.push(control.input);
+    readouts.set(slider.name, control.readout);
+    control.input.addEventListener("input", handleInput);
+  }
+  panel.controls.appendChild(note.element);
+  built.push(note.element);
+  requestRender();
+  return {
+    getValues: () => ({ ...values }),
+    getSurface: () => surface,
+    getSpec: () => spec,
+    rendered: () => inFlight ?? Promise.resolve(),
+    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();
+      }
+      if (element !== null) {
+        element.removeAllListeners("plotly_relayout");
+        engine?.purge(element);
+      }
+      panel.release();
+    }
+  };
+}
+// 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
+  ]
+};
+export {
+  validateScatter3dStyle,
+  scatter3dSpec,
+  resolvePlot3dTarget,
+  requireThreeNumericColumns,
+  requireNumericColumn,
+  plotScatter3d,
+  plotModeration3d,
+  numericColumns,
+  moderationSurface,
+  moderationData,
+  moderation3dSpec,
+  loadPlotly,
+  isNumericColumn,
+  interactiveScatter3d,
+  interactiveModeration3d,
+  frameRows,
+  cameraFromRotations,
+  DEFAULT_SCATTER3D_STYLE
+};
+
+//# debugId=167ACAEEE5BCC45664756E2164756E21
+//# sourceMappingURL=3d.js.map