@classytic/labs 0.1.0 → 0.2.0

package/dist/math/percent-bar/preset.mjs

@@ -0,0 +1,275 @@
+'use client';
+
+import { round } from "../../core/util.mjs";
+import { StatusPill } from "../../kit/controls.mjs";
+import { ControlBar, LabFrame } from "../../kit/frame.mjs";
+import { useCheckpoint } from "../../kit/pedagogy.mjs";
+import { getScene } from "../../kit/scenes.mjs";
+import { useEffect, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { Dot, Label, MovableDot, Segment, Stage } from "@classytic/stage";
+
+//#region src/math/percent-bar/preset.tsx
+/**
+* PercentBarLab, the authorable PERCENTAGE manipulative: a bar is the whole
+* (100%), the learner drags a fill to a target percent, and the same drag reads
+* out both the percent AND the concrete amount (percent × whole). One engine,
+* many analogies, the story is data: set `whole` + `unit` (students, mL, $, %
+* battery) and an optional `segments` breakdown for the reference bar, and the
+* SAME component teaches "make 25%", "25% of 80", a budget split, a charged
+* battery, a poll. Built on the juiced <MovableDot> (snap + live readout +
+* ghost stops) so a percentage feels tactile, not typed.
+*
+* Fully authorable: whole, unit, target, snap granularity, the reference-bar
+* segments + their labels/colours, and the prompt, no code per analogy.
+*/
+const PALETTE = [
+	"var(--stage-accent)",
+	"var(--stage-good)",
+	"#f3a23b",
+	"#e85aa6",
+	"#7c83ff",
+	"#34c6c6"
+];
+const fmtVal = (n) => String(round(n));
+function PercentBarLab(props = {}) {
+	const { whole = 100, unit = "", start = 0, target, snapPct = 5, showValue = true, segments, referenceLabel, scene, height = 230, title = "Percentages", prompt = target != null ? `Drag the bar to ${target}%.` : "Drag the bar and watch the percentage.", activity = "percent-bar" } = props;
+	const snap = (p) => Math.round(p / snapPct) * snapPct;
+	const clampPct = (p) => Math.max(0, Math.min(100, snap(p)));
+	const [pct, setPct] = useState(clampPct(start));
+	useEffect(() => {
+		setPct(clampPct(start));
+	}, [start, snapPct]);
+	const solved = target != null && pct === target;
+	const value = round(whole * pct / 100);
+	useCheckpoint({
+		solved,
+		activity,
+		response: `${pct}%${showValue ? ` = ${fmtVal(value)} ${unit}` : ""}`
+	});
+	const fillColor = solved ? "var(--stage-good)" : "var(--stage-accent)";
+	const Y_REF = 1.35;
+	const Y_BAR = -.25;
+	const BARW = 30;
+	const segTotal = (segments ?? []).reduce((s, x) => s + Math.max(0, x.frac), 0) || 1;
+	let acc = 0;
+	const segSpans = (segments ?? []).map((s, i) => {
+		const x0 = acc / segTotal * 100;
+		acc += Math.max(0, s.frac);
+		const x1 = acc / segTotal * 100;
+		return {
+			...s,
+			x0,
+			x1,
+			mid: (x0 + x1) / 2,
+			color: s.color ?? PALETTE[i % PALETTE.length]
+		};
+	});
+	const ticks = [];
+	for (let p = 0; p <= 100; p += snapPct) ticks.push(p);
+	const figure = /* @__PURE__ */ jsxs(Stage, {
+		view: {
+			xMin: -7,
+			xMax: 114,
+			yMin: -2.4,
+			yMax: segments?.length || referenceLabel ? 2.6 : 1.2
+		},
+		height,
+		preserveAspect: false,
+		pad: 14,
+		ariaLabel: `Percentage bar at ${pct} percent of ${whole}${unit ? " " + unit : ""}`,
+		children: [
+			(segSpans.length > 0 || referenceLabel) && /* @__PURE__ */ jsxs(Fragment$1, { children: [referenceLabel && /* @__PURE__ */ jsx(Label, {
+				x: 0,
+				y: Y_REF,
+				text: referenceLabel,
+				color: "var(--stage-muted)",
+				size: 12,
+				anchor: "start",
+				dy: -22
+			}), segSpans.length > 0 ? segSpans.map((s, i) => /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: s.x0,
+					y: Y_REF
+				},
+				to: {
+					x: s.x1,
+					y: Y_REF
+				},
+				color: s.color,
+				weight: BARW - 4,
+				opacity: .85
+			}), s.label && s.x1 - s.x0 > 9 && /* @__PURE__ */ jsx(Label, {
+				x: s.mid,
+				y: Y_REF,
+				text: s.label,
+				color: "var(--stage-fg)",
+				size: 11,
+				weight: 700
+			})] }, i)) : /* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: 0,
+					y: Y_REF
+				},
+				to: {
+					x: 100,
+					y: Y_REF
+				},
+				color: "var(--stage-grid)",
+				weight: BARW - 4,
+				opacity: .7
+			})] }),
+			/* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: 0,
+					y: Y_BAR
+				},
+				to: {
+					x: 100,
+					y: Y_BAR
+				},
+				color: "var(--stage-grid)",
+				weight: BARW,
+				opacity: .6
+			}),
+			/* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: 0,
+					y: Y_BAR
+				},
+				to: {
+					x: Math.max(1e-4, pct),
+					y: Y_BAR
+				},
+				color: fillColor,
+				weight: BARW
+			}),
+			ticks.map((p) => /* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: p,
+					y: Y_BAR - .62
+				},
+				to: {
+					x: p,
+					y: Y_BAR - (p % 25 === 0 ? .92 : .78)
+				},
+				color: "var(--stage-fg)",
+				opacity: p % 25 === 0 ? .5 : .2,
+				weight: p % 25 === 0 ? 1.5 : 1
+			}, p)),
+			/* @__PURE__ */ jsx(Label, {
+				x: 0,
+				y: Y_BAR,
+				text: "0%",
+				color: "var(--stage-muted)",
+				size: 12,
+				dy: 34
+			}),
+			/* @__PURE__ */ jsx(Label, {
+				x: 100,
+				y: Y_BAR,
+				text: "100%",
+				color: "var(--stage-muted)",
+				size: 12,
+				dy: 34
+			}),
+			/* @__PURE__ */ jsx(Label, {
+				x: 100,
+				y: Y_BAR,
+				text: `${fmtVal(whole)}${unit ? " " + unit : ""}`,
+				color: "var(--stage-muted)",
+				size: 12,
+				anchor: "start",
+				dx: 10
+			}),
+			target != null && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: target,
+					y: Y_BAR - .95
+				},
+				to: {
+					x: target,
+					y: .7
+				},
+				color: "var(--stage-good)",
+				weight: 1.75,
+				opacity: solved ? .9 : .55,
+				dashed: true
+			}), !solved && /* @__PURE__ */ jsx(Dot, {
+				x: target,
+				y: Y_BAR,
+				r: 5,
+				color: "var(--stage-good)",
+				opacity: .4
+			})] }),
+			/* @__PURE__ */ jsx(MovableDot, {
+				value: {
+					x: pct,
+					y: Y_BAR
+				},
+				onMove: (p) => setPct(clampPct(p.x)),
+				constrain: "horizontal",
+				range: {
+					min: 0,
+					max: 100
+				},
+				snap: snapPct,
+				step: snapPct,
+				readout: () => `${pct}%`,
+				color: fillColor,
+				r: 9,
+				ariaLabel: "percentage fill handle"
+			})
+		]
+	});
+	const controls = /* @__PURE__ */ jsxs(ControlBar, { children: [
+		/* @__PURE__ */ jsxs("span", {
+			style: {
+				fontWeight: 700,
+				fontSize: 16,
+				fontVariantNumeric: "tabular-nums"
+			},
+			children: [pct, "%"]
+		}),
+		showValue && /* @__PURE__ */ jsxs("span", {
+			style: {
+				fontVariantNumeric: "tabular-nums",
+				opacity: .85
+			},
+			children: [
+				"= ",
+				fmtVal(value),
+				unit ? ` ${unit}` : "",
+				whole !== 100 ? ` of ${fmtVal(whole)}` : ""
+			]
+		}),
+		target != null && /* @__PURE__ */ jsx(StatusPill, {
+			ok: solved,
+			children: solved ? `✓ ${target}%` : `target ${target}%`
+		})
+	] });
+	const twin = scene && scene !== "none" ? getScene(scene)?.render({
+		frac: pct / 100,
+		guessTone: solved ? "ok" : "idle",
+		color: fillColor,
+		label: `${pct}%`,
+		width: 132,
+		height: 170
+	}) : null;
+	return /* @__PURE__ */ jsx(LabFrame, {
+		title,
+		prompt,
+		controls,
+		aside: twin ? /* @__PURE__ */ jsx("div", {
+			style: {
+				display: "grid",
+				placeItems: "center"
+			},
+			children: twin
+		}) : void 0,
+		children: figure
+	});
+}
+
+//#endregion
+export { PercentBarLab };

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

@@ -0,0 +1,50 @@
+import { Complex } from "../complex/core.mjs";
+import { Node } from "@classytic/stage";
+
+//#region src/math/poly/core.d.ts
+declare namespace core_d_exports {
+  export { Poly, PolyRoots, add, allRoots, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, mul, polyTex, solve, solveEquation, trim };
+}
+type Poly = number[];
+declare const trim: (p: Poly) => Poly;
+declare const degree: (p: Poly) => number;
+/** Horner evaluation (real). */
+declare function evalPoly(p: Poly, x: number): number;
+/** Horner evaluation (complex). */
+declare function evalC(p: Poly, z: Complex): Complex;
+/** Derivative polynomial. */
+declare const deriv: (p: Poly) => Poly;
+declare function add(a: Poly, b: Poly): Poly;
+declare function mul(a: Poly, b: Poly): Poly;
+/** Synthetic division of p by (x − r); returns the quotient (assumes r is a root,
+ *  i.e. drops the remainder). The "divide out a found factor" step. */
+declare function deflate(p: Poly, r: number): Poly;
+/** LaTeX of a polynomial in descending order, e.g. [−6,11,−6,1] → "x^{3} - 6x^{2} + 11x - 6". */
+declare function polyTex(p0: Poly, x?: string): string;
+/** Coefficients of `node` as a polynomial in `x` (other vars from `params`), or
+ *  null if it isn't a polynomial in x (sin(x), 1/x, fractional power, …). */
+declare function fromAst(node: Node, x?: string, params?: Record<string, number>): Poly | null;
+/**
+ * All complex roots of `p` via Durand–Kerner simultaneous iteration (then snapped).
+ * For a degree-n polynomial returns n roots; real roots come back with im = 0.
+ */
+declare function allRoots(p0: Poly): Complex[];
+interface PolyRoots {
+  poly: Poly;
+  degree: number;
+  roots: Complex[];
+  realRoots: number[];
+}
+/** Solve p = 0 for ALL roots (any degree up to MAX_DEG). null if degenerate. */
+declare function solve(p0: Poly): PolyRoots | null;
+/** Solve an expression-AST equation `expr = 0` for x, any degree. null if not a
+ *  polynomial in x. (Linear/quadratic also flow through here, exactly.) */
+declare function solveEquation(node: Node, x?: string, params?: Record<string, number>): PolyRoots | null;
+/**
+ * Factored form of the polynomial over the reals: leading coefficient × linear
+ * factors (real roots, with multiplicity) × irreducible quadratics (complex
+ * conjugate pairs). e.g. x³−6x²+11x−6 → "(x − 1)(x − 2)(x − 3)".
+ */
+declare function factorTex(p0: Poly, x?: string): string;
+//#endregion
+export { Poly, PolyRoots, add, allRoots, core_d_exports, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, mul, polyTex, solve, solveEquation, trim };

package/dist/math/poly/core.mjs

@@ -0,0 +1,268 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.mjs";
+import { ONE, ZERO, abs, add as add$1, cx, div, fromPolar, isFiniteC, mul as mul$1, sub } from "../complex/core.mjs";
+import { evaluate } from "@classytic/stage";
+
+//#region src/math/poly/core.ts
+/**
+* Polynomial core, the canonical single-variable polynomial engine. The clean,
+* focused alternative to bolting on a heavy general CAS (Algebrite / nerdamer):
+* for the polynomial algebra school actually needs — expand, evaluate,
+* differentiate, FACTOR, and SOLVE any degree — a normalised coefficient form
+* makes everything fall out.
+*
+*   • a Poly is just `number[]` ascending: [a0, a1, …, an] = a0 + a1 x + … + an xⁿ.
+*   • roots of ANY degree via DURAND–KERNER (Weierstrass) simultaneous iteration,
+*     reusing the complex kernel — all n complex roots at once, then snapped to
+*     exact rationals where they're clearly nice (so 2, ½, −3 print exact, not
+*     1.9999999).
+*   • factored form is read straight off the cleaned roots (real → (x−r);
+*     complex pair → an irreducible real quadratic).
+*
+* Numerically safe: Durand–Kerner is capped at MAX_ITER and falls back gracefully;
+* coefficient arrays are trimmed; no overflow paths (the complex kernel guards div).
+*/
+var core_exports = /* @__PURE__ */ __exportAll({
+	add: () => add,
+	allRoots: () => allRoots,
+	deflate: () => deflate,
+	degree: () => degree,
+	deriv: () => deriv,
+	evalC: () => evalC,
+	evalPoly: () => evalPoly,
+	factorTex: () => factorTex,
+	fromAst: () => fromAst,
+	mul: () => mul,
+	polyTex: () => polyTex,
+	solve: () => solve,
+	solveEquation: () => solveEquation,
+	trim: () => trim
+});
+const EPS = 1e-9;
+const MAX_ITER = 300;
+const MAX_DEG = 8;
+const trim = (p) => {
+	let n = p.length;
+	while (n > 1 && Math.abs(p[n - 1]) < 1e-12) n--;
+	return p.slice(0, n);
+};
+const degree = (p) => trim(p).length - 1;
+/** Horner evaluation (real). */
+function evalPoly(p, x) {
+	let s = 0;
+	for (let i = p.length - 1; i >= 0; i--) s = s * x + (p[i] ?? 0);
+	return s;
+}
+/** Horner evaluation (complex). */
+function evalC(p, z) {
+	let s = ZERO;
+	for (let i = p.length - 1; i >= 0; i--) s = add$1(mul$1(s, z), cx(p[i] ?? 0));
+	return s;
+}
+/** Derivative polynomial. */
+const deriv = (p) => trim(p.slice(1).map((c, i) => c * (i + 1)));
+function add(a, b) {
+	const n = Math.max(a.length, b.length), o = [];
+	for (let i = 0; i < n; i++) o.push((a[i] ?? 0) + (b[i] ?? 0));
+	return trim(o);
+}
+function mul(a, b) {
+	const o = new Array(a.length + b.length - 1).fill(0);
+	for (let i = 0; i < a.length; i++) for (let j = 0; j < b.length; j++) o[i + j] += a[i] * b[j];
+	return trim(o);
+}
+/** Synthetic division of p by (x − r); returns the quotient (assumes r is a root,
+*  i.e. drops the remainder). The "divide out a found factor" step. */
+function deflate(p, r) {
+	const n = p.length - 1;
+	if (n < 1) return [0];
+	const q = new Array(n).fill(0);
+	q[n - 1] = p[n];
+	for (let k = n - 2; k >= 0; k--) q[k] = p[k + 1] + r * q[k + 1];
+	return trim(q);
+}
+const tnum = (n) => {
+	const r = Math.round(n * 1e6) / 1e6;
+	return (Object.is(r, -0) ? 0 : r).toString();
+};
+/** LaTeX of a polynomial in descending order, e.g. [−6,11,−6,1] → "x^{3} - 6x^{2} + 11x - 6". */
+function polyTex(p0, x = "x") {
+	const p = trim(p0);
+	let out = "";
+	for (let d = p.length - 1; d >= 0; d--) {
+		const c = p[d];
+		if (c === 0) continue;
+		const mag = Math.abs(c);
+		const t = `${d === 0 ? tnum(mag) : mag === 1 ? "" : tnum(mag)}${d === 0 ? "" : d === 1 ? x : `${x}^{${d}}`}`;
+		out += out === "" ? c < 0 ? `-${t}` : t : c < 0 ? ` - ${t}` : ` + ${t}`;
+	}
+	return out || "0";
+}
+function hasVar(node, x) {
+	switch (node.type) {
+		case "var": return node.name === x;
+		case "neg": return hasVar(node.arg, x);
+		case "binary": return hasVar(node.left, x) || hasVar(node.right, x);
+		case "call": return node.args.some((a) => hasVar(a, x));
+		default: return false;
+	}
+}
+/** Coefficients of `node` as a polynomial in `x` (other vars from `params`), or
+*  null if it isn't a polynomial in x (sin(x), 1/x, fractional power, …). */
+function fromAst(node, x = "x", params = {}) {
+	if (!hasVar(node, x)) {
+		const v = evaluate(node, params);
+		return Number.isFinite(v) ? [v] : null;
+	}
+	switch (node.type) {
+		case "var": return [0, 1];
+		case "neg": {
+			const c = fromAst(node.arg, x, params);
+			return c && c.map((k) => -k);
+		}
+		case "binary": {
+			const { op, left, right } = node;
+			const L = fromAst(left, x, params);
+			if (!L) return null;
+			if (op === "+") {
+				const R = fromAst(right, x, params);
+				return R && add(L, R);
+			}
+			if (op === "-") {
+				const R = fromAst(right, x, params);
+				return R && add(L, R.map((k) => -k));
+			}
+			if (op === "*") {
+				const R = fromAst(right, x, params);
+				return R && mul(L, R);
+			}
+			if (op === "/") {
+				if (hasVar(right, x)) return null;
+				const d = evaluate(right, params);
+				return Number.isFinite(d) && d !== 0 ? L.map((k) => k / d) : null;
+			}
+			if (op === "^") {
+				if (hasVar(right, x)) return null;
+				const n = evaluate(right, params);
+				if (!Number.isInteger(n) || n < 0 || n > MAX_DEG) return null;
+				let acc = [1];
+				for (let i = 0; i < n; i++) acc = mul(acc, L);
+				return acc;
+			}
+			return null;
+		}
+		default: return null;
+	}
+}
+/** Snap a near-rational real to its exact value (denominators 1..12), else itself. */
+function snapReal(r) {
+	for (const d of [
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		8,
+		10,
+		12
+	]) {
+		const n = Math.round(r * d);
+		if (Math.abs(r * d - n) < 1e-7) {
+			const v = n / d;
+			return Object.is(v, -0) ? 0 : v;
+		}
+	}
+	return Math.round(r * 1e9) / 1e9;
+}
+const snap = (z) => Math.abs(z.im) < 1e-7 ? {
+	re: snapReal(z.re),
+	im: 0
+} : {
+	re: snapReal(z.re),
+	im: snapReal(z.im)
+};
+/**
+* All complex roots of `p` via Durand–Kerner simultaneous iteration (then snapped).
+* For a degree-n polynomial returns n roots; real roots come back with im = 0.
+*/
+function allRoots(p0) {
+	const p = trim(p0);
+	const n = p.length - 1;
+	if (n <= 0) return [];
+	const lead = p[n];
+	const m = p.map((c) => c / lead);
+	let z = Array.from({ length: n }, (_, k) => fromPolar(1 + .1 * k / n, 2 * Math.PI * k / n + .6));
+	for (let it = 0; it < MAX_ITER; it++) {
+		let maxDelta = 0;
+		z = z.map((zi, i) => {
+			let denom = ONE;
+			for (let j = 0; j < n; j++) if (j !== i) denom = mul$1(denom, sub(zi, z[j]));
+			const corr = div(evalC(m, zi), denom);
+			if (!isFiniteC(corr)) return zi;
+			maxDelta = Math.max(maxDelta, abs(corr));
+			return sub(zi, corr);
+		});
+		if (maxDelta < EPS) break;
+	}
+	const roots = z.map(snap);
+	roots.sort((a, b) => a.im === 0 && b.im === 0 ? a.re - b.re : a.im === 0 ? -1 : b.im === 0 ? 1 : a.re - b.re || a.im - b.im);
+	return roots;
+}
+/** Solve p = 0 for ALL roots (any degree up to MAX_DEG). null if degenerate. */
+function solve(p0) {
+	const p = trim(p0);
+	const d = p.length - 1;
+	if (d < 1) return null;
+	const roots = allRoots(p);
+	return {
+		poly: p,
+		degree: d,
+		roots,
+		realRoots: roots.filter((r) => r.im === 0).map((r) => r.re)
+	};
+}
+/** Solve an expression-AST equation `expr = 0` for x, any degree. null if not a
+*  polynomial in x. (Linear/quadratic also flow through here, exactly.) */
+function solveEquation(node, x = "x", params = {}) {
+	const p = fromAst(node, x, params);
+	return p ? solve(p) : null;
+}
+const fnum = (n) => {
+	const r = Math.round(n * 1e6) / 1e6;
+	return (Object.is(r, -0) ? 0 : r).toString().replace(/^-/, "−");
+};
+/** "(x − r)" with the sign tucked in, and "(x − 0)" → "x". */
+const linTex = (r, x) => r === 0 ? x : `(${x} ${r < 0 ? "+" : "−"} ${fnum(Math.abs(r))})`;
+/**
+* Factored form of the polynomial over the reals: leading coefficient × linear
+* factors (real roots, with multiplicity) × irreducible quadratics (complex
+* conjugate pairs). e.g. x³−6x²+11x−6 → "(x − 1)(x − 2)(x − 3)".
+*/
+function factorTex(p0, x = "x") {
+	const p = trim(p0);
+	const lead = p[p.length - 1] ?? 1;
+	const sol = solve(p);
+	if (!sol) return fnum(p[0] ?? 0);
+	const used = new Array(sol.roots.length).fill(false);
+	const parts = [];
+	for (let i = 0; i < sol.roots.length; i++) {
+		if (used[i]) continue;
+		const z = sol.roots[i];
+		if (z.im === 0) {
+			used[i] = true;
+			parts.push(linTex(z.re, x));
+			continue;
+		}
+		used[i] = true;
+		const j = sol.roots.findIndex((w, k) => !used[k] && Math.abs(w.re - z.re) < 1e-6 && Math.abs(w.im + z.im) < 1e-6);
+		if (j >= 0) used[j] = true;
+		const b2 = z.re * z.re + z.im * z.im, two = 2 * z.re;
+		const mid = Math.abs(two) < 1e-9 ? "" : ` ${two < 0 ? "+" : "−"} ${fnum(Math.abs(two))}${x}`;
+		parts.push(`(${x}^2${mid} ${b2 < 0 ? "−" : "+"} ${fnum(Math.abs(b2))})`);
+	}
+	const lc = Math.abs(lead - 1) < 1e-9 ? "" : `${fnum(lead)}\\,`;
+	return parts.length ? `${lc}${parts.join("")}` : fnum(lead);
+}
+
+//#endregion
+export { core_exports, deflate, degree, evalPoly, factorTex, fromAst, polyTex, solve, solveEquation, trim };

package/dist/math/poly/index.d.mts

@@ -0,0 +1,3 @@
+import { Poly, PolyRoots, add, allRoots, core_d_exports, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, mul, polyTex, solve, solveEquation, trim } from "./core.mjs";
+import { factorSteps, solveSteps } from "./steps.mjs";
+import { PolynomialSolverLab, PolynomialSolverProps, SolverMode } from "./preset.mjs";

package/dist/math/poly/preset.d.mts

@@ -0,0 +1,23 @@
+import { ReactNode } from "react";
+
+//#region src/math/poly/preset.d.ts
+type SolverMode = 'factor' | 'solve';
+interface PolynomialSolverProps {
+  /** The polynomial in x, e.g. "x^2 + 5x + 6" or "x^3 - 6x^2 + 11x - 6". */
+  expr?: string;
+  mode?: SolverMode;
+  /** Let the learner edit the polynomial (the live solver). Default true. */
+  editable?: boolean;
+  height?: number;
+  title?: string;
+  prompt?: string;
+}
+declare function PolynomialSolverLab({
+  expr,
+  mode,
+  editable,
+  title,
+  prompt
+}?: PolynomialSolverProps): ReactNode;
+//#endregion
+export { PolynomialSolverLab, PolynomialSolverProps, SolverMode };