@classytic/labs 0.3.0 → 0.4.0

package/dist/kit/expr-analysis.mjs

@@ -1,166 +0,0 @@
-import { differentiate, evaluate } from "@classytic/stage";
-
-//#region src/kit/expr-analysis.ts
-/**
-* expr-analysis, the numeric/symbolic "solving" layer of the interactive-problem
-* engine, built on @classytic/stage's expr engine. Pure functions (no React) so a
-* creator's authored config can derive the quantities A-level questions ask for ,
-* roots, intersections, tangents/normals, areas, without anyone hand-coding a lab.
-*
-* Everything works on a compiled scalar `Fn1 = (x) => number` (params already baked
-* into the closure) plus, for exact tangents, the parsed `Node` AST.
-*/
-function pushUnique(out, x, tol) {
-	if (!out.some((p) => Math.abs(p - x) <= tol)) out.push(x);
-}
-/** Newton's method from x0 using a central-difference derivative (we only hold
-*  the numeric f, not its AST). Returns the polished root, or null on a flat
-*  derivative / divergence. Used to recover tangent (even-multiplicity) roots a
-*  sign-change scan can't see. */
-function newton(f, x0, tol) {
-	let x = x0;
-	for (let k = 0; k < 40; k++) {
-		const fx = f(x);
-		if (!Number.isFinite(fx)) return null;
-		if (Math.abs(fx) <= tol) return x;
-		const h = Math.max(1e-7, Math.abs(x) * 1e-7);
-		const d = (f(x + h) - f(x - h)) / (2 * h);
-		if (!Number.isFinite(d) || Math.abs(d) < 1e-13) return null;
-		const nx = x - fx / d;
-		if (!Number.isFinite(nx)) return null;
-		if (Math.abs(nx - x) <= tol) return nx;
-		x = nx;
-	}
-	return Math.abs(f(x)) <= tol ? x : null;
-}
-/**
-* Real roots of f on [a,b]. Two passes so it doesn't miss the roots students do:
-*   1. sign-change brackets refined by BISECTION (odd-multiplicity / crossings);
-*   2. local minima of |f| polished by NEWTON, accepted only if |f| really drops
-*      to ~0 — this recovers TANGENT / double roots (e.g. x² at 0) that never
-*      change sign. False minima (a parabola that never reaches 0) are rejected
-*      by the accept tolerance, so no phantom roots.
-*/
-function roots(f, a, b, opts = {}) {
-	const steps = opts.steps ?? 1e3;
-	const tol = opts.tol ?? 1e-9;
-	const grid = (b - a) / steps;
-	const out = [];
-	const xs = [], fs = [];
-	for (let i = 0; i <= steps; i++) {
-		const x = a + grid * i;
-		xs.push(x);
-		fs.push(f(x));
-	}
-	let maxAbs = 0;
-	for (const v of fs) if (Number.isFinite(v)) maxAbs = Math.max(maxAbs, Math.abs(v));
-	const acceptTol = 1e-7 * (1 + maxAbs);
-	for (let i = 1; i <= steps; i++) {
-		const fPrev = fs[i - 1], fx = fs[i];
-		if (!Number.isFinite(fPrev) || !Number.isFinite(fx)) continue;
-		if (fPrev === 0) {
-			pushUnique(out, xs[i - 1], grid);
-			continue;
-		}
-		if (fPrev * fx < 0) {
-			let lo = xs[i - 1], hi = xs[i], flo = fPrev;
-			for (let k = 0; k < 80 && hi - lo > tol; k++) {
-				const mid = (lo + hi) / 2;
-				const fm = f(mid);
-				if (!Number.isFinite(fm)) break;
-				if (flo * fm <= 0) hi = mid;
-				else {
-					lo = mid;
-					flo = fm;
-				}
-			}
-			const mid = (lo + hi) / 2;
-			if (Math.abs(f(mid)) <= acceptTol) pushUnique(out, mid, grid);
-		}
-	}
-	for (let i = 1; i < steps; i++) {
-		const p = fs[i - 1], c = fs[i], q = fs[i + 1];
-		if (!Number.isFinite(p) || !Number.isFinite(c) || !Number.isFinite(q)) continue;
-		if (Math.abs(c) <= Math.abs(p) && Math.abs(c) <= Math.abs(q) && Math.abs(c) < .05 * (1 + maxAbs)) {
-			const r = newton(f, xs[i], tol);
-			if (r != null && r >= a - grid && r <= b + grid && Math.abs(f(r)) <= acceptTol) pushUnique(out, r, grid);
-		}
-	}
-	out.sort((u, v) => u - v);
-	return out;
-}
-/** Points where f and g meet on [a,b]. */
-function intersections(f, g, a, b, opts) {
-	return roots((x) => f(x) - g(x), a, b, opts).map((x) => ({
-		x,
-		y: f(x)
-	}));
-}
-/** Exact tangent line to `ast` at x = x0 (params baked in via `scope`). */
-function tangentAt(ast, x0, varName = "x", params = {}) {
-	const d = differentiate(ast, varName);
-	if (!d) return null;
-	const m = evaluate(d, {
-		...params,
-		[varName]: x0
-	});
-	const y0 = evaluate(ast, {
-		...params,
-		[varName]: x0
-	});
-	if (!Number.isFinite(m) || !Number.isFinite(y0)) return null;
-	const c = y0 - m * x0;
-	return {
-		m,
-		c,
-		at: {
-			x: x0,
-			y: y0
-		},
-		f: (x) => m * x + c
-	};
-}
-/** Normal line to `ast` at x = x0 (⟂ the tangent). Null if the tangent is horizontal. */
-function normalAt(ast, x0, varName = "x", params = {}) {
-	const t = tangentAt(ast, x0, varName, params);
-	if (!t || t.m === 0) return null;
-	const m = -1 / t.m;
-	const c = t.at.y - m * t.at.x;
-	return {
-		m,
-		c,
-		at: t.at,
-		f: (x) => m * x + c
-	};
-}
-/** Composite-Simpson definite integral ∫_a^b f dx. */
-function integrate(f, a, b, n = 1e3) {
-	if (a === b) return 0;
-	let N = Math.max(2, Math.round(n));
-	if (N % 2) N++;
-	const h = (b - a) / N;
-	let s = f(a) + f(b);
-	for (let i = 1; i < N; i++) s += (i % 2 ? 4 : 2) * f(a + i * h);
-	return h / 3 * s;
-}
-/**
-* Geometric area between f and g over [a,b]. SPLITS at every crossing so the
-* pieces where g > f don't cancel the pieces where f > g (which a single
-* |∫(f−g)| would). Sums |∫| over each sub-interval — the area an exam actually
-* wants.
-*/
-function areaBetween(f, g, a, b, n = 1e3) {
-	const d = (x) => f(x) - g(x);
-	const cuts = [
-		a,
-		...roots(d, a, b).filter((x) => x > a + 1e-9 && x < b - 1e-9).sort((u, v) => u - v),
-		b
-	];
-	const per = Math.max(20, Math.round(n / Math.max(1, cuts.length - 1)));
-	let area = 0;
-	for (let i = 0; i < cuts.length - 1; i++) area += Math.abs(integrate(d, cuts[i], cuts[i + 1], per));
-	return area;
-}
-
-//#endregion
-export { areaBetween, integrate, intersections, normalAt, roots, tangentAt };

package/dist/kit/solve.d.mts

@@ -1,21 +0,0 @@
-import { Complex } from "../math/complex/core.mjs";
-import { fromAst } from "../math/poly/core.mjs";
-import { Node } from "@classytic/stage";
-
-//#region src/kit/solve.d.ts
-/** Coefficients [a0, a1, …] of `node` as a polynomial in `x` (the canonical poly
- *  engine does the extraction). null if it isn't polynomial in x. */
-declare const polyCoeffs: typeof fromAst;
-interface PolySolution {
-  coeffs: number[];
-  degree: number;
-  roots: Complex[];
-  realRoots: number[];
-  discriminant?: number;
-}
-/** Solve `node` = 0 for x exactly (degree 1 or 2). null if not a usable polynomial. */
-declare function solvePoly(node: Node, x?: string, params?: Record<string, number>): PolySolution | null;
-/** "x = 2 or x = −2" (complex when needed), or "no real solutions" framing. */
-declare function solutionTex(sol: PolySolution, x?: string): string;
-//#endregion
-export { PolySolution, polyCoeffs, solutionTex, solvePoly };

package/dist/kit/solve.mjs

@@ -1,75 +0,0 @@
-import { toStr } from "../math/complex/core.mjs";
-import { fromAst, trim } from "../math/poly/core.mjs";
-
-//#region src/kit/solve.ts
-const cleanNum = (n) => {
-	const r = Math.round(n * 1e9) / 1e9;
-	return Object.is(r, -0) ? 0 : r;
-};
-/** Coefficients [a0, a1, …] of `node` as a polynomial in `x` (the canonical poly
-*  engine does the extraction). null if it isn't polynomial in x. */
-const polyCoeffs = fromAst;
-/** Solve `node` = 0 for x exactly (degree 1 or 2). null if not a usable polynomial. */
-function solvePoly(node, x = "x", params = {}) {
-	const raw = polyCoeffs(node, x, params);
-	if (!raw) return null;
-	const coeffs = trim(raw);
-	const degree = coeffs.length - 1;
-	if (degree === 1) {
-		const a0 = coeffs[0], a1 = coeffs[1];
-		const r = cleanNum(-a0 / a1);
-		return {
-			coeffs,
-			degree,
-			roots: [{
-				re: r,
-				im: 0
-			}],
-			realRoots: [r]
-		};
-	}
-	if (degree === 2) {
-		const c0 = coeffs[0], c1 = coeffs[1], c2 = coeffs[2];
-		const disc = c1 * c1 - 4 * c2 * c0;
-		const twoA = 2 * c2;
-		if (disc >= 0) {
-			const s = Math.sqrt(disc);
-			const real = [cleanNum((-c1 - s) / twoA), cleanNum((-c1 + s) / twoA)].sort((u, v) => u - v);
-			return {
-				coeffs,
-				degree,
-				discriminant: disc,
-				roots: real.map((r) => ({
-					re: r,
-					im: 0
-				})),
-				realRoots: real
-			};
-		}
-		const s = Math.sqrt(-disc), re = cleanNum(-c1 / twoA), im = cleanNum(s / twoA);
-		return {
-			coeffs,
-			degree,
-			discriminant: disc,
-			roots: [{
-				re,
-				im: -im
-			}, {
-				re,
-				im
-			}],
-			realRoots: []
-		};
-	}
-	return null;
-}
-/** "x = 2 or x = −2" (complex when needed), or "no real solutions" framing. */
-function solutionTex(sol, x = "x") {
-	if (sol.roots.length === 1) return `${x} = ${toStr(sol.roots[0])}`;
-	const [r1, r2] = sol.roots;
-	if (r1 && r2 && r1.re === r2.re && r1.im === r2.im) return `${x} = ${toStr(r1)} \\text{ (repeated)}`;
-	return `${x} = ${toStr(r1)} \\text{ or } ${x} = ${toStr(r2)}`;
-}
-
-//#endregion
-export { polyCoeffs, solutionTex, solvePoly };

package/dist/kit/space.mjs

@@ -1,326 +0,0 @@
-'use client';
-
-import { useId } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
-import { fmt, useCoords } from "@classytic/stage";
-
-//#region src/kit/space.tsx
-/**
-* Space glyph kit, Earth, Sun and a satellite, drawn in the stage's pixel frame
-* (project the world centre, then size everything off the px radius so the glyph
-* is crisp at any zoom). Kurzgesagt-style: radial body gradient + a rim shadow
-* for spherical depth + a top-left specular highlight, the technique borrowed from
-* my-video's EarthIcon. Gradient ids are made unique per instance so multiple
-* glyphs on one Stage don't collide.
-*
-* These are decorative (pointer-events:none), drop a draggable MovableDot on top
-* if the body needs to be grabbed.
-*/
-/** Earth, blue oceans, a few green landmasses, ice caps, rim + shine + atmosphere. */
-function EarthGlyph({ center, r, atmosphere = true }) {
-	const c = useCoords();
-	const [cx, cy] = c.toPx(center.x, center.y);
-	const R = c.sx(r);
-	const uid = useId().replace(/:/g, "");
-	const land = `url(#${uid}-land)`;
-	return /* @__PURE__ */ jsxs("g", {
-		style: { pointerEvents: "none" },
-		children: [
-			/* @__PURE__ */ jsxs("defs", { children: [
-				/* @__PURE__ */ jsxs("radialGradient", {
-					id: `${uid}-ocean`,
-					cx: "40%",
-					cy: "35%",
-					r: "65%",
-					children: [
-						/* @__PURE__ */ jsx("stop", {
-							offset: "0%",
-							stopColor: "#60A5FA"
-						}),
-						/* @__PURE__ */ jsx("stop", {
-							offset: "40%",
-							stopColor: "#3B82F6"
-						}),
-						/* @__PURE__ */ jsx("stop", {
-							offset: "100%",
-							stopColor: "#1E3A5F"
-						})
-					]
-				}),
-				/* @__PURE__ */ jsxs("linearGradient", {
-					id: `${uid}-land`,
-					x1: "0",
-					y1: "0",
-					x2: "0",
-					y2: "1",
-					children: [/* @__PURE__ */ jsx("stop", {
-						offset: "0%",
-						stopColor: "#4ADE80"
-					}), /* @__PURE__ */ jsx("stop", {
-						offset: "100%",
-						stopColor: "#15803D"
-					})]
-				}),
-				/* @__PURE__ */ jsxs("radialGradient", {
-					id: `${uid}-rim`,
-					cx: "50%",
-					cy: "50%",
-					r: "50%",
-					children: [/* @__PURE__ */ jsx("stop", {
-						offset: "68%",
-						stopColor: "rgba(0,0,0,0)"
-					}), /* @__PURE__ */ jsx("stop", {
-						offset: "100%",
-						stopColor: "rgba(0,0,0,0.4)"
-					})]
-				}),
-				/* @__PURE__ */ jsxs("radialGradient", {
-					id: `${uid}-shine`,
-					cx: "32%",
-					cy: "28%",
-					r: "42%",
-					children: [/* @__PURE__ */ jsx("stop", {
-						offset: "0%",
-						stopColor: "rgba(255,255,255,0.4)"
-					}), /* @__PURE__ */ jsx("stop", {
-						offset: "100%",
-						stopColor: "rgba(255,255,255,0)"
-					})]
-				}),
-				/* @__PURE__ */ jsx("clipPath", {
-					id: `${uid}-clip`,
-					children: /* @__PURE__ */ jsx("circle", {
-						cx: fmt(cx),
-						cy: fmt(cy),
-						r: fmt(R)
-					})
-				})
-			] }),
-			atmosphere && /* @__PURE__ */ jsx("circle", {
-				cx: fmt(cx),
-				cy: fmt(cy),
-				r: fmt(R + R * .1),
-				fill: "none",
-				stroke: "#93C5FD",
-				strokeWidth: fmt(R * .06),
-				opacity: .25
-			}),
-			/* @__PURE__ */ jsx("circle", {
-				cx: fmt(cx),
-				cy: fmt(cy),
-				r: fmt(R),
-				fill: `url(#${uid}-ocean)`
-			}),
-			/* @__PURE__ */ jsxs("g", {
-				clipPath: `url(#${uid}-clip)`,
-				children: [
-					/* @__PURE__ */ jsx("path", {
-						d: `M ${fmt(cx - R * .5)} ${fmt(cy - R * .45)} q ${fmt(R * .3)} ${fmt(-R * .15)} ${fmt(R * .5)} ${fmt(R * .1)} q ${fmt(R * .1)} ${fmt(R * .3)} ${fmt(-R * .15)} ${fmt(R * .4)} q ${fmt(-R * .35)} ${fmt(R * .1)} ${fmt(-R * .45)} ${fmt(-R * .2)} Z`,
-						fill: land,
-						opacity: .88
-					}),
-					/* @__PURE__ */ jsx("path", {
-						d: `M ${fmt(cx + R * .05)} ${fmt(cy - R * .1)} q ${fmt(R * .3)} ${fmt(-R * .05)} ${fmt(R * .4)} ${fmt(R * .25)} q ${fmt(-R * .05)} ${fmt(R * .45)} ${fmt(-R * .3)} ${fmt(R * .5)} q ${fmt(-R * .25)} ${fmt(-R * .1)} ${fmt(-R * .1)} ${fmt(-R * .7)} Z`,
-						fill: land,
-						opacity: .82
-					}),
-					/* @__PURE__ */ jsx("ellipse", {
-						cx: fmt(cx),
-						cy: fmt(cy - R * .92),
-						rx: fmt(R * .6),
-						ry: fmt(R * .16),
-						fill: "#E2E8F0",
-						opacity: .35
-					}),
-					/* @__PURE__ */ jsx("ellipse", {
-						cx: fmt(cx),
-						cy: fmt(cy + R * .92),
-						rx: fmt(R * .66),
-						ry: fmt(R * .18),
-						fill: "#F1F5F9",
-						opacity: .4
-					})
-				]
-			}),
-			/* @__PURE__ */ jsx("circle", {
-				cx: fmt(cx),
-				cy: fmt(cy),
-				r: fmt(R),
-				fill: `url(#${uid}-rim)`
-			}),
-			/* @__PURE__ */ jsx("circle", {
-				cx: fmt(cx),
-				cy: fmt(cy),
-				r: fmt(R),
-				fill: `url(#${uid}-shine)`
-			})
-		]
-	});
-}
-/** Sun, glowing core with a corona of rays. */
-function SunGlyph({ center, r }) {
-	const c = useCoords();
-	const [cx, cy] = c.toPx(center.x, center.y);
-	const R = c.sx(r);
-	const uid = useId().replace(/:/g, "");
-	const rays = Array.from({ length: 12 }, (_, i) => {
-		const a = i * Math.PI / 6;
-		return {
-			x1: fmt(cx + Math.cos(a) * R * 1.15),
-			y1: fmt(cy + Math.sin(a) * R * 1.15),
-			x2: fmt(cx + Math.cos(a) * R * 1.5),
-			y2: fmt(cy + Math.sin(a) * R * 1.5)
-		};
-	});
-	return /* @__PURE__ */ jsxs("g", {
-		style: { pointerEvents: "none" },
-		children: [
-			/* @__PURE__ */ jsxs("defs", { children: [/* @__PURE__ */ jsxs("radialGradient", {
-				id: `${uid}-core`,
-				cx: "42%",
-				cy: "38%",
-				r: "60%",
-				children: [
-					/* @__PURE__ */ jsx("stop", {
-						offset: "0%",
-						stopColor: "#FEF9C3"
-					}),
-					/* @__PURE__ */ jsx("stop", {
-						offset: "45%",
-						stopColor: "#FDB813"
-					}),
-					/* @__PURE__ */ jsx("stop", {
-						offset: "100%",
-						stopColor: "#F97316"
-					})
-				]
-			}), /* @__PURE__ */ jsxs("radialGradient", {
-				id: `${uid}-glow`,
-				cx: "50%",
-				cy: "50%",
-				r: "50%",
-				children: [
-					/* @__PURE__ */ jsx("stop", {
-						offset: "55%",
-						stopColor: "rgba(253,184,19,0)"
-					}),
-					/* @__PURE__ */ jsx("stop", {
-						offset: "80%",
-						stopColor: "rgba(253,184,19,0.25)"
-					}),
-					/* @__PURE__ */ jsx("stop", {
-						offset: "100%",
-						stopColor: "rgba(253,184,19,0)"
-					})
-				]
-			})] }),
-			/* @__PURE__ */ jsx("circle", {
-				cx: fmt(cx),
-				cy: fmt(cy),
-				r: fmt(R * 1.8),
-				fill: `url(#${uid}-glow)`
-			}),
-			rays.map((p, i) => /* @__PURE__ */ jsx("line", {
-				x1: p.x1,
-				y1: p.y1,
-				x2: p.x2,
-				y2: p.y2,
-				stroke: "#FDB813",
-				strokeWidth: fmt(R * .14),
-				strokeLinecap: "round",
-				opacity: .75
-			}, i)),
-			/* @__PURE__ */ jsx("circle", {
-				cx: fmt(cx),
-				cy: fmt(cy),
-				r: fmt(R),
-				fill: `url(#${uid}-core)`
-			}),
-			/* @__PURE__ */ jsx("circle", {
-				cx: fmt(cx - R * .3),
-				cy: fmt(cy - R * .32),
-				r: fmt(R * .32),
-				fill: "rgba(255,255,255,0.45)"
-			})
-		]
-	});
-}
-/** Satellite, a body with two solar-panel wings and a dish. */
-function SatelliteGlyph({ center, size, tilt = -.4 }) {
-	const c = useCoords();
-	const [cx, cy] = c.toPx(center.x, center.y);
-	const s = c.sx(size);
-	const deg = tilt * 180 / Math.PI;
-	return /* @__PURE__ */ jsxs("g", {
-		style: { pointerEvents: "none" },
-		transform: `translate(${fmt(cx)},${fmt(cy)}) rotate(${fmt(deg)})`,
-		children: [
-			/* @__PURE__ */ jsx("rect", {
-				x: fmt(-s * 2.1),
-				y: fmt(-s * .55),
-				width: fmt(s * 1.3),
-				height: fmt(s * 1.1),
-				rx: fmt(s * .1),
-				fill: "#2563EB",
-				stroke: "#1E3A8A",
-				strokeWidth: fmt(s * .08)
-			}),
-			/* @__PURE__ */ jsx("rect", {
-				x: fmt(s * .8),
-				y: fmt(-s * .55),
-				width: fmt(s * 1.3),
-				height: fmt(s * 1.1),
-				rx: fmt(s * .1),
-				fill: "#2563EB",
-				stroke: "#1E3A8A",
-				strokeWidth: fmt(s * .08)
-			}),
-			/* @__PURE__ */ jsx("line", {
-				x1: fmt(-s * .8),
-				y1: 0,
-				x2: fmt(-s * .45),
-				y2: 0,
-				stroke: "#94A3B8",
-				strokeWidth: fmt(s * .1)
-			}),
-			/* @__PURE__ */ jsx("line", {
-				x1: fmt(s * .45),
-				y1: 0,
-				x2: fmt(s * .8),
-				y2: 0,
-				stroke: "#94A3B8",
-				strokeWidth: fmt(s * .1)
-			}),
-			/* @__PURE__ */ jsx("rect", {
-				x: fmt(-s * .5),
-				y: fmt(-s * .6),
-				width: fmt(s),
-				height: fmt(s * 1.2),
-				rx: fmt(s * .14),
-				fill: "#E5E7EB",
-				stroke: "#9CA3AF",
-				strokeWidth: fmt(s * .08)
-			}),
-			/* @__PURE__ */ jsx("ellipse", {
-				cx: 0,
-				cy: fmt(-s * .8),
-				rx: fmt(s * .42),
-				ry: fmt(s * .18),
-				fill: "#F8FAFC",
-				stroke: "#9CA3AF",
-				strokeWidth: fmt(s * .06)
-			}),
-			/* @__PURE__ */ jsx("line", {
-				x1: 0,
-				y1: fmt(-s * .6),
-				x2: 0,
-				y2: fmt(-s * .82),
-				stroke: "#9CA3AF",
-				strokeWidth: fmt(s * .06)
-			})
-		]
-	});
-}
-
-//#endregion
-export { EarthGlyph, SatelliteGlyph, SunGlyph };

package/dist/math/complex/core.d.mts

@@ -1,93 +0,0 @@
-declare namespace core_d_exports {
-  export { Complex, DEG2RAD, I, MAX_POW, MAX_ROOTS, ONE, RAD2DEG, TWO_PI, ZERO, abs, add, arg, argDeg, conj, cx, div, eq, fromPolar, iPow, isFiniteC, mul, neg, nthRoots, omega, powInt, rootsOfUnity, scale, sub, toPolar, toStr, toTex };
-}
-/**
- * Complex-number kernel, the pure engine every complex/Argand/polar lab computes
- * against (so a lab — or an agent — never hand-rolls a²+b² or atan2). A complex
- * number is rectangular `{ re, im }`; the polar view (modulus r, argument θ) is
- * derived, exactly the (x, y) ↔ (r, θ) bridge the vector labs already teach.
- *
- * Engineered for CORRECTNESS + SAFETY (no NaN spirals, no overflow, no runaway
- * loops):
- *   • modulus uses Math.hypot (no re²+im² overflow);
- *   • division uses Smith's algorithm (scale by the larger term, avoids overflow
- *     / underflow), with a near-zero-denominator guard;
- *   • integer powers use exponentiation-by-squaring, |n| capped (MAX_POW), with a
- *     finiteness guard so r^n that overflows returns an explicit ∞, not garbage;
- *   • iⁿ is computed EXACTLY from n mod 4 (no float drift in the i, −1, −i, 1 cycle);
- *   • rootsOfUnity / nthRoots cap n (MAX_ROOTS) so an author can't request a
- *     billion-element array.
- */
-interface Complex {
-  re: number;
-  im: number;
-}
-declare const TWO_PI: number;
-declare const RAD2DEG: number;
-declare const DEG2RAD: number;
-/** Hard caps so an authored value can never blow memory or hang a loop. */
-declare const MAX_POW = 1024;
-declare const MAX_ROOTS = 360;
-declare const cx: (re: number, im?: number) => Complex;
-declare const ZERO: Complex;
-declare const ONE: Complex;
-declare const I: Complex;
-declare const isFiniteC: (z: Complex) => boolean;
-declare const add: (a: Complex, b: Complex) => Complex;
-declare const sub: (a: Complex, b: Complex) => Complex;
-declare const neg: (a: Complex) => Complex;
-declare const conj: (a: Complex) => Complex;
-declare const scale: (a: Complex, k: number) => Complex;
-/** (a+bi)(c+di) = (ac − bd) + (ad + bc)i. */
-declare const mul: (a: Complex, b: Complex) => Complex;
-/**
- * Complex division via Smith's algorithm: divide through by the LARGER of the
- * denominator's components so the intermediate ratio stays in [−1, 1] (no
- * overflow when |b| is huge, no underflow when tiny). Returns an ∞/NaN complex
- * for a (near-)zero denominator rather than throwing.
- */
-declare function div(a: Complex, b: Complex): Complex;
-/** Modulus |z| = √(re² + im²), via hypot so large components don't overflow. */
-declare const abs: (z: Complex) => number;
-/** Argument arg(z) in RADIANS, in (−π, π]. arg(0) = 0 by convention. */
-declare const arg: (z: Complex) => number;
-/** Argument in DEGREES, in (−180, 180]. */
-declare const argDeg: (z: Complex) => number;
-/** Polar → rectangular: r·e^{iθ} = r(cosθ + i sinθ), θ in radians. */
-declare const fromPolar: (r: number, theta: number) => Complex;
-/** Rectangular → polar { r, theta(rad) }. */
-declare const toPolar: (z: Complex) => {
-  r: number;
-  theta: number;
-};
-/**
- * iⁿ for any integer n, EXACTLY (no De Moivre float drift): the 4-cycle
- * 1, i, −1, −i. Negative n handled by the (n mod 4 + 4) mod 4 normalisation.
- */
-declare function iPow(n: number): Complex;
-/**
- * zⁿ for an INTEGER n via exponentiation-by-squaring (negative n inverts).
- * |n| is capped at MAX_POW; an overflowing magnitude returns an explicit ∞
- * complex (finite check) instead of looping into garbage.
- */
-declare function powInt(z: Complex, n: number): Complex;
-/**
- * The n nth-roots of UNITY: e^{2πik/n}, k = 0…n−1 (so ω = roots[1] is the
- * primitive root). For n = 2 → {1, −1}; n = 3 → {1, ω, ω²}; n = 4 → {1, i, −1, −i}.
- * n is clamped to [1, MAX_ROOTS]. The k = n/2 (real −1) and k = 0 (real 1) entries
- * are snapped to exact values so labels read cleanly.
- */
-declare function rootsOfUnity(n: number): Complex[];
-/** The n nth-roots of any z: |z|^{1/n} · e^{i(arg z + 2πk)/n}, k = 0…n−1. */
-declare function nthRoots(z: Complex, n: number): Complex[];
-/** The primitive nth root of unity ω (default the CUBE root, n = 3): e^{2πi/n}.
- *  For n = 3: ω = −½ + (√3/2)i, with ω³ = 1 and 1 + ω + ω² = 0. */
-declare const omega: (n?: number) => Complex;
-/** Equal within a tolerance (default 1e-9), on both components. */
-declare const eq: (a: Complex, b: Complex, eps?: number) => boolean;
-/** Plain string, e.g. "3 − 2i", "i", "−1", "0", "2i". */
-declare function toStr(z: Complex, dp?: number): string;
-/** LaTeX form for <Tex> (uses real minus signs, "i"). */
-declare function toTex(z: Complex, dp?: number): string;
-//#endregion
-export { Complex, core_d_exports };