@descix/egpt-math-sdk 0.1.0

package/dist/notebooks/stats.html

@@ -0,0 +1,206 @@
+<frqtl-notebook version="1" title="Exact-Arithmetic Statistics with EGPTStat — Mean, Variance, and Deviation Analysis">
+
+<cell type="markdown">
+# Exact-Arithmetic Statistics with EGPTStat
+
+Standard statistical libraries operate on floating-point numbers. Accumulated rounding error is invisible — it hides inside the mantissa and silently distorts results when values are very large, very small, or precisely rational.
+
+`EGPTStat` computes **mean, variance, and deviation in exact rational arithmetic** end-to-end, using the PPF (Prime-Probability Field) representation carried by every `EGPTReal`. No rounding occurs inside any statistical operation. The result you read back from `.toMathString()` is the *exact* rational answer.
+
+This notebook works through a small integer sample — `[3, 6, 9, 12]` — so you can verify the results by hand and see what exact-arithmetic statistics look like at the API boundary. Every cell reaches its compute through the injected `math` builtin; no URL import is used.
+</cell>
+
+<cell type="markdown">
+## 1. The active math backend
+
+`math.activeMathBackend` is a **derived** field — it reads whatever `MathBackendRegistry.active()` reports at runtime. Never hardcoded.
+</cell>
+
+<cell type="js" lane="math" id="backend">
+const { math, display } = caps;
+const backend = math.activeMathBackend;
+display(`Active math backend (derived): ${backend}`);
+</cell>
+
+<cell type="markdown">
+## 2. Constructing the sample
+
+The source example uses a four-element integer sample: `[3, 6, 9, 12]`.
+
+Each value is lifted into exact rational form via `EGPTReal.fromBigInt(n)`. From this point, every operation stays in the PPF basis — no floating-point intermediate values exist.
+</cell>
+
+<cell type="js" lane="math" id="sample" out="sample">
+const { math, display } = caps;
+const { EGPTReal } = math;
+
+const sample = [
+  EGPTReal.fromBigInt(3n),
+  EGPTReal.fromBigInt(6n),
+  EGPTReal.fromBigInt(9n),
+  EGPTReal.fromBigInt(12n)
+];
+
+display(`Sample (${sample.length} values): [${sample.map(v => v.toMathString()).join(', ')}]`);
+return { sample };
+</cell>
+
+<cell type="markdown">
+## 3. Computing the mean
+
+`EGPTStat.mean(sample)` computes the arithmetic mean in **normal space**: it sums all values via `EGPTMath.add`, then divides by the count via `EGPTMath.normalDivide`.
+
+For `[3, 6, 9, 12]`, the exact mean is `30/4 = 15/2 = 7.5`. The `.toMathString()` representation surfaces the exact rational.
+</cell>
+
+<cell type="js" lane="math" id="mean" in="sample" out="mean">
+const { math, display } = caps;
+const { EGPTStat } = math;
+const { sample } = inputs;
+
+const mean = EGPTStat.mean(sample);
+const meanStr = mean.toMathString();
+
+display(`Mean of [3, 6, 9, 12] = ${meanStr}`);
+display(`(Expected exact rational: 15/2)`);
+return { mean };
+</cell>
+
+<cell type="markdown">
+## 4. Computing the variance
+
+`EGPTStat.variance(sample)` computes the population variance `Σ(xᵢ − μ)² / N` in normal space.
+
+Two design choices are worth understanding:
+
+- **Absolute difference:** Because PPF encoding can struggle with negative intermediate values, `EGPTStat.absoluteDifference(x, μ)` is used for each deviation — it returns `|x − μ|` by checking the sign first and subtracting the smaller from the larger.
+- **Normal-space squaring:** Each squared deviation uses `EGPTMath.normalMultiply` (rational multiply), not the Shannon-space product. Variance is a normal-space quantity.
+
+For `[3, 6, 9, 12]` with mean `15/2`:
+- Deviations: `|3 − 7.5| = 4.5`, `|6 − 7.5| = 1.5`, `|9 − 7.5| = 1.5`, `|12 − 7.5| = 4.5`
+- Squared deviations: `81/4`, `9/4`, `9/4`, `81/4`
+- Sum: `180/4 = 45`
+- Variance: `45/4`
+
+The `variance()` call also returns **metadata** describing how many values fell below the mean (negative deviations). This is diagnostic information — it confirms the algorithm correctly identified which values were below the mean even though it computed unsigned absolute differences.
+</cell>
+
+<cell type="js" lane="math" id="variance" in="sample, mean" out="varianceResult">
+const { math, display } = caps;
+const { EGPTStat } = math;
+const { sample, mean } = inputs;
+
+const varianceResult = EGPTStat.variance(sample);
+const varianceStr = varianceResult.variance.toMathString();
+const meta = varianceResult.metadata;
+
+display(`Variance of [3, 6, 9, 12] = ${varianceStr}`);
+display(`(Expected exact rational: 45/4)`);
+display(`Metadata:`);
+display(`  total_vectors: ${meta.total_vectors}`);
+display(`  negative_deviations: ${meta.negative_deviations}  (values that fell below the mean)`);
+display(`  has_negative_deviations: ${meta.has_negative_deviations}`);
+return { varianceResult };
+</cell>
+
+<cell type="markdown">
+## 5. Absolute difference — the PPF-safe subtraction primitive
+
+`EGPTStat.absoluteDifference(a, b)` is the building block that makes variance possible in PPF space. It uses `EGPTMath.compare(a, b)` to determine order, then calls `EGPTMath.subtract(larger, smaller)` — never producing a negative intermediate.
+
+Here we compute it directly for a pair of values from our sample to illustrate the pattern.
+</cell>
+
+<cell type="js" lane="math" id="absdiff" in="sample">
+const { math, display } = caps;
+const { EGPTStat } = math;
+const { sample } = inputs;
+
+// |12 - 3| = 9
+const diff = EGPTStat.absoluteDifference(sample[3], sample[0]);
+display(`|12 − 3| = ${diff.toMathString()}`);
+display(`(Expected: 9/1)`);
+</cell>
+
+<cell type="markdown">
+## 6. Replicating the original demo output
+
+The source `stats.js` example returns exactly:
+
+```json
+{
+  "category": "stats",
+  "mean": "<mean as math string>",
+  "variance": "<variance as math string>",
+  "metadata": { ... }
+}
+```
+
+This cell reproduces that return value verbatim so any downstream consumer sees the same result as the original `run(sdk)`.
+</cell>
+
+<cell type="js" lane="math" id="demo-output" in="sample" out="demoOutput">
+const { math, display } = caps;
+const { EGPTReal, EGPTStat } = math;
+
+// Replicate the original stats.js run(sdk) exactly
+const sample = [
+  EGPTReal.fromBigInt(3n),
+  EGPTReal.fromBigInt(6n),
+  EGPTReal.fromBigInt(9n),
+  EGPTReal.fromBigInt(12n)
+];
+
+const mean = EGPTStat.mean(sample);
+const varianceResult = EGPTStat.variance(sample);
+
+const demoOutput = {
+  category: "stats",
+  mean: mean.toMathString(),
+  variance: varianceResult.variance.toMathString(),
+  metadata: varianceResult.metadata
+};
+
+display(demoOutput);
+return { demoOutput };
+</cell>
+
+<cell type="markdown">
+## 7. Verify correctness
+
+The cell below asserts the two expected exact rational results. A PASS confirms that `EGPTStat.mean` and `EGPTStat.variance` both produce bit-exact rational answers matching hand calculation. A FAIL would indicate a regression in the statistical layer.
+</cell>
+
+<cell type="js" lane="math" id="verify" in="demoOutput">
+const { display } = caps;
+const { demoOutput } = inputs;
+
+const EXPECTED_MEAN     = '15/2';
+const EXPECTED_VARIANCE = '45/4';
+
+const meanOk     = demoOutput.mean     === EXPECTED_MEAN;
+const varianceOk = demoOutput.variance === EXPECTED_VARIANCE;
+const allOk      = meanOk && varianceOk;
+
+const el = document.createElement('div');
+el.style.cssText =
+  'font:600 0.95rem/1.5 system-ui,sans-serif;padding:10px 14px;border-radius:6px;margin:4px 0;' +
+  (allOk
+    ? 'background:#0f2417;border:1px solid #1f5a36;color:#7ee2a8;'
+    : 'background:#2a0c0c;border:1px solid #5a1f1f;color:#ff8a8a;');
+
+if (allOk) {
+  el.textContent =
+    `PASS — mean=${demoOutput.mean} (expected ${EXPECTED_MEAN}); ` +
+    `variance=${demoOutput.variance} (expected ${EXPECTED_VARIANCE}). ` +
+    `Exact-arithmetic statistics verified.`;
+} else {
+  const failures = [];
+  if (!meanOk)     failures.push(`mean: got "${demoOutput.mean}", expected "${EXPECTED_MEAN}"`);
+  if (!varianceOk) failures.push(`variance: got "${demoOutput.variance}", expected "${EXPECTED_VARIANCE}"`);
+  el.textContent = `FAIL — ${failures.join('; ')}`;
+}
+display(el);
+</cell>
+
+</frqtl-notebook>

package/dist/notebooks/transcendentals.html

@@ -0,0 +1,195 @@
+<frqtl-notebook version="1" title="Transcendental Functions in EGPT — exp₂, log₂, and the Riemann Zeta Function">
+
+<cell type="markdown">
+# Transcendental Functions in EGPT
+
+Classical mathematics has a tension at its core: transcendental numbers like π, e, and √2 are *irrational* — they cannot be expressed as a ratio of integers — yet every practical computation must eventually approximate them.
+
+EGPT resolves this tension by working in **Shannon information space**. An `EGPTReal` is not a decimal approximation; it is a canonical rational PPF (Prime-Probability Form) representation. Transcendental operations — `exp2`, `log2`, complex exponentiation — are carried out as **exact rational operations on this canonical form**. The approximate decimal you see at the end is a projection out of information space at the output boundary, deliberately late and deliberately labelled.
+
+This notebook demonstrates three transcendental capabilities:
+
+1. **`EGPTranscendental.exp2(x)`** — computes 2^x in exact rational arithmetic (2^3 = 8 exactly).
+2. **`EGPTranscendental.log2(x)`** — computes log₂(x) by recursive halving (log₂(32) = 5 exactly).
+3. **`EGPTComplex.riemannZeta(s, terms)`** — evaluates the Riemann Zeta function ζ(s) as a partial sum of n^(-s) over complex argument s, verifying ζ(2) = π²/6.
+
+Every cell reaches compute through the injected `math` builtin only — no URL imports.
+</cell>
+
+<cell type="js" lane="math" id="backend">
+// Report the live math backend — DERIVED from the SDK, never hardcoded.
+const { math, display } = caps;
+const backend = math.activeMathBackend;
+display(`Live math backend (derived from the SDK): ${backend}`);
+</cell>
+
+<cell type="markdown">
+## 1. Base-2 Exponentiation — exp₂(x) = 2^x
+
+`EGPTranscendental.exp2` computes 2^x where x is an `EGPTReal`. Internally it extracts the rational parts of x via `_getPPFRationalParts()` and delegates to `EGPTMath.pow(2, numerator, denominator)` — a single closed-form operation on the canonical rational representation, not an iterative floating-point approximation.
+
+For integer inputs like x = 3, the result is exact: 2^3 = **8**.
+
+`toMathString()` renders the canonical form; for a pure integer the output is the integer itself.
+</cell>
+
+<cell type="js" lane="math" id="exp2" out="exp2Three">
+const { math, display } = caps;
+const { EGPTReal, EGPTranscendental } = math;
+
+// Construct x = 3 as an EGPTReal from a BigInt literal.
+const three = EGPTReal.fromBigInt(3n);
+
+// Compute 2^3 in EGPT information space — exact rational result.
+const exp2Three = EGPTranscendental.exp2(three);
+
+display(`exp₂(3) = 2^3 = ${exp2Three.toMathString()}`);
+return { exp2Three };
+</cell>
+
+<cell type="markdown">
+## 2. Base-2 Logarithm — log₂(x)
+
+`EGPTranscendental.log2` computes log₂(x) by **recursive halving**: log₂(x) = log₂(x/2) + 1, bottoming out at log₂(1) = 0. Each recursive division is exact rational arithmetic inside EGPT, so for any power of 2 the answer is a perfect integer.
+
+For x = 32 = 2^5, the result is **5** — no floating-point rounding, no approximation.
+
+Notice that `log2` and `exp2` are mutual inverses: log₂(exp₂(3)) = 3 and exp₂(log₂(32)) = 32. Both are confirmed in the cells below.
+</cell>
+
+<cell type="js" lane="math" id="log2" out="log2ThirtyTwo">
+const { math, display } = caps;
+const { EGPTReal, EGPTranscendental } = math;
+
+// Construct x = 32 = 2^5 as an EGPTReal.
+const thirtyTwo = EGPTReal.fromBigInt(32n);
+
+// Compute log₂(32) — expect exact integer 5.
+const log2ThirtyTwo = EGPTranscendental.log2(thirtyTwo);
+
+display(`log₂(32) = ${log2ThirtyTwo.toMathString()}`);
+return { log2ThirtyTwo };
+</cell>
+
+<cell type="markdown">
+## 3. Inverse Consistency — exp₂ ∘ log₂ and log₂ ∘ exp₂
+
+Because both operations are exact in rational EGPT space, their compositions are exact too. This cell verifies the round-trip on integer inputs.
+</cell>
+
+<cell type="js" lane="math" id="inverse-check" in="exp2Three, log2ThirtyTwo">
+const { math, display } = caps;
+const { EGPTReal, EGPTranscendental } = math;
+const { exp2Three, log2ThirtyTwo } = inputs;
+
+// log₂(exp₂(3)) should be exactly 3.
+const roundTrip1 = EGPTranscendental.log2(exp2Three);
+
+// exp₂(log₂(32)) should be exactly 32.
+const roundTrip2 = EGPTranscendental.exp2(log2ThirtyTwo);
+
+display(`log₂(exp₂(3))  = ${roundTrip1.toMathString()}  (expected 3)`);
+display(`exp₂(log₂(32)) = ${roundTrip2.toMathString()}  (expected 32)`);
+</cell>
+
+<cell type="markdown">
+## 4. Complex Numbers and the Riemann Zeta Function
+
+`ComplexEGPTReal` represents a complex number a + bi where both a and b are `EGPTReal` values — meaning the complex number lives entirely in rational EGPT space.
+
+`EGPTComplex.riemannZeta(s, maxTerms)` evaluates:
+
+```
+ζ(s) = Σ_{n=1}^{maxTerms} n^{-s}
+```
+
+using `EGPTComplex.complexPower(n, -s)` for each term. Each `n^(-s)` is computed via the canonical complex-power routine — rational magnitude from `EGPTMath.pow`, phase from the topology-native wave vector, no `Math.sin`/`Math.cos` in the compressed domain.
+
+**The landmark identity:** ζ(2) = π²/6 ≈ 1.6449. With 100 terms the partial sum approximates this to about 1% accuracy (the series converges slowly; full convergence requires the analytic continuation). The test below uses a tolerance of 0.01.
+</cell>
+
+<cell type="js" lane="math" id="riemann-zeta" out="riemannZetaResult">
+const { math, display } = caps;
+const { EGPTReal, ComplexEGPTReal, EGPTComplex } = math;
+
+// s = 2 + 0i (a purely real complex argument at s=2).
+// EGPTComplex.riemannZeta expects a ComplexEGPTReal; this is NOT ComplexEGPTReal —
+// EGPTComplex is the static utility class hosting riemannZeta and complexPower.
+const s = new ComplexEGPTReal(
+  EGPTReal.fromBigInt(2n),
+  EGPTReal.fromBigInt(0n)
+);
+
+// Evaluate ζ(2) with 100 terms of the Dirichlet series.
+const rzf = EGPTComplex.riemannZeta(s, 100);
+
+// Project the real part out of EGPT information space at the output boundary.
+// breakSymbolicToApproximateJSNumber() is intentionally labelled "break" —
+// it exits the rational canonical form into a JS floating-point number (lossy).
+const rzf_val = rzf.real.breakSymbolicToApproximateJSNumber();
+
+// The known closed-form value π²/6 — computed here using the JS approximation
+// of π only at the BOUNDARY for the human-facing comparison.
+const pi_squared_over_6 = (Math.PI ** 2) / 6;
+
+const riemannZetaResult = {
+  rzf_val,
+  pi_squared_over_6,
+  difference: Math.abs(rzf_val - pi_squared_over_6)
+};
+
+display(`ζ(2) ≈ ${rzf_val.toFixed(6)}  (partial sum, 100 terms)`);
+display(`π²/6 ≈ ${pi_squared_over_6.toFixed(6)}  (reference value)`);
+display(`|difference| = ${riemannZetaResult.difference.toFixed(6)}`);
+
+return { riemannZetaResult };
+</cell>
+
+<cell type="markdown">
+## 5. Precision Assertion
+
+The original demo asserts that the 100-term partial sum agrees with π²/6 to within **0.01**. This cell reproduces that assertion as an explicit pass/fail check, using the same tolerance.
+
+Note that `.toFixed(4)` on the projected JS number matches the original demo's output format.
+</cell>
+
+<cell type="js" lane="math" id="precision-check" in="riemannZetaResult">
+const { math, display } = caps;
+const { riemannZetaResult } = inputs;
+const { rzf_val, pi_squared_over_6, difference } = riemannZetaResult;
+
+const TOLERANCE = 0.01;
+const pass = difference < TOLERANCE;
+
+if (!pass) {
+  throw new Error(
+    `Riemann Zeta precision error: ${rzf_val} vs ${pi_squared_over_6} ` +
+    `(difference ${difference} exceeds tolerance ${TOLERANCE})`
+  );
+}
+
+const el = document.createElement('div');
+el.style.cssText =
+  'font:600 0.95rem/1.5 system-ui,sans-serif;padding:10px 14px;border-radius:6px;margin:4px 0;' +
+  'background:#0f2417;border:1px solid #1f5a36;color:#7ee2a8;';
+el.textContent =
+  `PASS  ζ(2) = ${rzf_val.toFixed(4)} ≈ π²/6 = ${pi_squared_over_6.toFixed(4)}` +
+  `  |diff| = ${difference.toFixed(6)} < ${TOLERANCE}`;
+display(el);
+</cell>
+
+<cell type="markdown">
+## Summary
+
+| Operation | Input | Result |
+|---|---|---|
+| `EGPTranscendental.exp2` | 3 (EGPTReal) | 2^3 = **8** (exact) |
+| `EGPTranscendental.log2` | 32 (EGPTReal) | log₂(32) = **5** (exact) |
+| `EGPTComplex.riemannZeta` | s=2, 100 terms | ≈ **1.6350** (within 0.01 of π²/6) |
+
+All three results agree with `sdk/egpt-math-sdk/src/examples/transcendentals.js` — same classes, same logic, the same projected output at the boundary. The notebook simply makes each step visible and independently runnable for a developer encountering EGPT transcendentals for the first time.
+
+**Key architectural point:** `EGPTranscendental` and `EGPTComplex` are *static utility classes* — they cannot be instantiated. `ComplexEGPTReal` is the *value class* that holds a + bi. These are distinct: `EGPTComplex.riemannZeta(s)` works; `s.riemannZeta()` does not.
+</cell>
+
+</frqtl-notebook>

package/dist/notebooks/view-vendored-d3.html

@@ -0,0 +1,78 @@
+<frqtl-notebook version="1" title="View Cell — Vendored d3-array Import">
+
+<cell type="markdown">
+# The `view` cell — arbitrary user render code in the realm
+
+A **`view` cell** runs your own render code **in the realm** (the browser context), imports
+**vendored libraries** through the import-map, gets a handle, and draws into a DOM `mount`.
+
+This notebook is the worked example for WS-NOTEBOOK-VENDOR-VIEW: a view cell whose module
+`import`s the vendored **`d3-array`** library (placed under `/vendor` and listed in the
+committed manifest), computes with it, and renders a tiny SVG bar chart into its mount —
+proving the import resolves and the view runs end-to-end.
+
+The pieces:
+
+1. a `type="module"` cell exporting `render(ctx)` — it `import { max, sum } from 'd3-array'`,
+2. a `type="view"` cell that names that module (`module="…#render"`) and selects the realm.
+
+The bare specifier `'d3-array'` resolves via the 2a import-map (it maps `d3-array` →
+`/vendor/d3-array/src/index.js`). An UNLISTED specifier would throw in the realm loader and
+the cell badge would show **ERROR** (FAIL-LOUD) — there is no arbitrary CDN/network import.
+</cell>
+
+<cell type="module" name="./views/d3-bars.js">
+// A view render module. Its export is invoked IN THE REALM with the view `ctx`:
+//   ctx.mount      — a DOM element to render into
+//   ctx.handle     — the frozen ViewHandle for this realm (on/call/start/stop/step/dispose)
+//   ctx.getBinding — read an `in` binding value (data IN)
+//   ctx.commit     — commit a `produces` value (data OUT, serializable-asserted)
+//   ctx.imports    — pre-resolved blessed helpers (makeChartEnv / makeLiveChartController)
+//
+// The bare import below is resolved by the realm's vendor import-map (Phase 2a). d3-array
+// is genuinely-ESM; the import-map maps the bare specifier to the placed /vendor artifact.
+import { max, sum } from 'd3-array';
+
+export function render(ctx) {
+  // A small dataset; compute with d3-array (the WHOLE point — a vendored lib runs in-realm).
+  const data = [4, 9, 2, 7, 5, 8, 3];
+  const peak = max(data);          // 9
+  const total = sum(data);         // 38
+
+  // Render a tiny inline-SVG bar chart into the mount. No physics — pure user render code.
+  const W = 320, H = 120, pad = 8, n = data.length;
+  const bw = (W - pad * 2) / n - 4;
+  const bars = data.map((d, i) => {
+    const h = Math.round((d / peak) * (H - pad * 2));
+    const x = pad + i * ((W - pad * 2) / n);
+    const y = H - pad - h;
+    return `<rect x="${x.toFixed(1)}" y="${y}" width="${bw.toFixed(1)}" height="${h}" fill="#5ad1ff" rx="2"></rect>`;
+  }).join('');
+
+  ctx.mount.innerHTML =
+    `<div style="font:0.75rem/1.4 ui-monospace,monospace;color:#9fe6ff;margin-bottom:6px;" data-role="d3-summary">` +
+      `d3-array in-realm — max=${peak}, sum=${total}` +
+    `</div>` +
+    `<svg width="${W}" height="${H}" viewBox="0 0 ${W} ${H}" role="img" aria-label="d3 bar chart">${bars}</svg>`;
+}
+</cell>
+
+<cell type="view" id="c-d3-view" realm="frqtl" module="./views/d3-bars.js#render"></cell>
+
+<cell type="markdown">
+## What just happened
+
+- The view module ran **in the realm** (same-cell — its render is local; nothing crossed the
+  renderer↔realm seam).
+- `import { max, sum } from 'd3-array'` resolved through the **import-map** to the placed
+  `/vendor/d3-array/src/index.js` artifact (and its transitive `internmap` bare dep — the
+  import-map allowlist covers the whole bare-specifier graph).
+- The mount shows a d3-computed SVG bar chart with the summary `max=9, sum=38`.
+
+`liveChart=` on a canvas is a **blessed preset** over this same `view` substrate: it is a
+same-cell view that imports the blessed chart module (`makeChartEnv`) and drives
+`makeLiveChartController` — both available to any view via `ctx.imports`. The Step-1
+`liveChart=` path is unchanged; the `view` cell is the general form beneath it.
+</cell>
+
+</frqtl-notebook>

package/dist/vendor/d3-array/src/array.js

@@ -0,0 +1,4 @@
+var array = Array.prototype;
+
+export var slice = array.slice;
+export var map = array.map;

package/dist/vendor/d3-array/src/ascending.js

@@ -0,0 +1,3 @@
+export default function ascending(a, b) {
+  return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+}

package/dist/vendor/d3-array/src/bin.js

@@ -0,0 +1,125 @@
+import {slice} from "./array.js";
+import bisect from "./bisect.js";
+import constant from "./constant.js";
+import extent from "./extent.js";
+import identity from "./identity.js";
+import nice from "./nice.js";
+import ticks, {tickIncrement} from "./ticks.js";
+import sturges from "./threshold/sturges.js";
+
+export default function bin() {
+  var value = identity,
+      domain = extent,
+      threshold = sturges;
+
+  function histogram(data) {
+    if (!Array.isArray(data)) data = Array.from(data);
+
+    var i,
+        n = data.length,
+        x,
+        step,
+        values = new Array(n);
+
+    for (i = 0; i < n; ++i) {
+      values[i] = value(data[i], i, data);
+    }
+
+    var xz = domain(values),
+        x0 = xz[0],
+        x1 = xz[1],
+        tz = threshold(values, x0, x1);
+
+    // Convert number of thresholds into uniform thresholds, and nice the
+    // default domain accordingly.
+    if (!Array.isArray(tz)) {
+      const max = x1, tn = +tz;
+      if (domain === extent) [x0, x1] = nice(x0, x1, tn);
+      tz = ticks(x0, x1, tn);
+
+      // If the domain is aligned with the first tick (which it will by
+      // default), then we can use quantization rather than bisection to bin
+      // values, which is substantially faster.
+      if (tz[0] <= x0) step = tickIncrement(x0, x1, tn);
+
+      // If the last threshold is coincident with the domain’s upper bound, the
+      // last bin will be zero-width. If the default domain is used, and this
+      // last threshold is coincident with the maximum input value, we can
+      // extend the niced upper bound by one tick to ensure uniform bin widths;
+      // otherwise, we simply remove the last threshold. Note that we don’t
+      // coerce values or the domain to numbers, and thus must be careful to
+      // compare order (>=) rather than strict equality (===)!
+      if (tz[tz.length - 1] >= x1) {
+        if (max >= x1 && domain === extent) {
+          const step = tickIncrement(x0, x1, tn);
+          if (isFinite(step)) {
+            if (step > 0) {
+              x1 = (Math.floor(x1 / step) + 1) * step;
+            } else if (step < 0) {
+              x1 = (Math.ceil(x1 * -step) + 1) / -step;
+            }
+          }
+        } else {
+          tz.pop();
+        }
+      }
+    }
+
+    // Remove any thresholds outside the domain.
+    // Be careful not to mutate an array owned by the user!
+    var m = tz.length, a = 0, b = m;
+    while (tz[a] <= x0) ++a;
+    while (tz[b - 1] > x1) --b;
+    if (a || b < m) tz = tz.slice(a, b), m = b - a;
+
+    var bins = new Array(m + 1),
+        bin;
+
+    // Initialize bins.
+    for (i = 0; i <= m; ++i) {
+      bin = bins[i] = [];
+      bin.x0 = i > 0 ? tz[i - 1] : x0;
+      bin.x1 = i < m ? tz[i] : x1;
+    }
+
+    // Assign data to bins by value, ignoring any outside the domain.
+    if (isFinite(step)) {
+      if (step > 0) {
+        for (i = 0; i < n; ++i) {
+          if ((x = values[i]) != null && x0 <= x && x <= x1) {
+            bins[Math.min(m, Math.floor((x - x0) / step))].push(data[i]);
+          }
+        }
+      } else if (step < 0) {
+        for (i = 0; i < n; ++i) {
+          if ((x = values[i]) != null && x0 <= x && x <= x1) {
+            const j = Math.floor((x0 - x) * step);
+            bins[Math.min(m, j + (tz[j] <= x))].push(data[i]); // handle off-by-one due to rounding
+          }
+        }
+      }
+    } else {
+      for (i = 0; i < n; ++i) {
+        if ((x = values[i]) != null && x0 <= x && x <= x1) {
+          bins[bisect(tz, x, 0, m)].push(data[i]);
+        }
+      }
+    }
+
+    return bins;
+  }
+
+  histogram.value = function(_) {
+    return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value;
+  };
+
+  histogram.domain = function(_) {
+    return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain;
+  };
+
+  histogram.thresholds = function(_) {
+    return arguments.length ? (threshold = typeof _ === "function" ? _ : constant(Array.isArray(_) ? slice.call(_) : _), histogram) : threshold;
+  };
+
+  return histogram;
+}

package/dist/vendor/d3-array/src/bisect.js

@@ -0,0 +1,9 @@
+import ascending from "./ascending.js";
+import bisector from "./bisector.js";
+import number from "./number.js";
+
+const ascendingBisect = bisector(ascending);
+export const bisectRight = ascendingBisect.right;
+export const bisectLeft = ascendingBisect.left;
+export const bisectCenter = bisector(number).center;
+export default bisectRight;

package/dist/vendor/d3-array/src/bisector.js

@@ -0,0 +1,56 @@
+import ascending from "./ascending.js";
+import descending from "./descending.js";
+
+export default function bisector(f) {
+  let compare1, compare2, delta;
+
+  // If an accessor is specified, promote it to a comparator. In this case we
+  // can test whether the search value is (self-) comparable. We can’t do this
+  // for a comparator (except for specific, known comparators) because we can’t
+  // tell if the comparator is symmetric, and an asymmetric comparator can’t be
+  // used to test whether a single value is comparable.
+  if (f.length !== 2) {
+    compare1 = ascending;
+    compare2 = (d, x) => ascending(f(d), x);
+    delta = (d, x) => f(d) - x;
+  } else {
+    compare1 = f === ascending || f === descending ? f : zero;
+    compare2 = f;
+    delta = f;
+  }
+
+  function left(a, x, lo = 0, hi = a.length) {
+    if (lo < hi) {
+      if (compare1(x, x) !== 0) return hi;
+      do {
+        const mid = (lo + hi) >>> 1;
+        if (compare2(a[mid], x) < 0) lo = mid + 1;
+        else hi = mid;
+      } while (lo < hi);
+    }
+    return lo;
+  }
+
+  function right(a, x, lo = 0, hi = a.length) {
+    if (lo < hi) {
+      if (compare1(x, x) !== 0) return hi;
+      do {
+        const mid = (lo + hi) >>> 1;
+        if (compare2(a[mid], x) <= 0) lo = mid + 1;
+        else hi = mid;
+      } while (lo < hi);
+    }
+    return lo;
+  }
+
+  function center(a, x, lo = 0, hi = a.length) {
+    const i = left(a, x, lo, hi - 1);
+    return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
+  }
+
+  return {left, center, right};
+}
+
+function zero() {
+  return 0;
+}