@pie-lib/math-input-mathlive 1.1.5-beta.9 → 2.0.1-next.20261109072207

package/dist/keys/sub-sup.js

@@ -0,0 +1,17 @@
+import { __exportAll as e } from "../_virtual/_rolldown/runtime.js";
+import { mkSet as t } from "./utils.js";
+//#region src/keys/sub-sup.ts
+var n = /* @__PURE__ */ e({
+	subscript: () => a,
+	superscript: () => i
+}), r = t("sub-sup"), i = r({
+	name: "Superscript",
+	latex: "x^{}",
+	command: "^"
+}), a = r({
+	name: "Subscript",
+	latex: "x_{}",
+	command: "_"
+});
+//#endregion
+export { n as sub_sup_exports, a as subscript, i as superscript };

package/dist/keys/trigonometry.d.ts

@@ -0,0 +1,6 @@
+export declare const sin: any;
+export declare const cos: any;
+export declare const tan: any;
+export declare const sec: any;
+export declare const csc: any;
+export declare const cot: any;

package/dist/keys/trigonometry.js

@@ -0,0 +1,43 @@
+import { __exportAll as e } from "../_virtual/_rolldown/runtime.js";
+import { mkSet as t } from "./utils.js";
+//#region src/keys/trigonometry.ts
+var n = /* @__PURE__ */ e({
+	cos: () => a,
+	cot: () => l,
+	csc: () => c,
+	sec: () => s,
+	sin: () => i,
+	tan: () => o
+}), r = t("trigonometry"), i = r({
+	name: "sine",
+	label: "sin",
+	command: "\\sin",
+	latex: "\\sin"
+}), a = r({
+	name: "cosine",
+	label: "cos",
+	command: "\\cos",
+	latex: "\\cos"
+}), o = r({
+	name: "tanget",
+	label: "tan",
+	command: "\\tan",
+	latex: "\\tan"
+}), s = r({
+	name: "secant",
+	label: "sec",
+	command: "\\sec",
+	latex: "\\sec"
+}), c = r({
+	name: "cosecant",
+	label: "csc",
+	command: "\\csc",
+	latex: "\\csc"
+}), l = r({
+	name: "cotangent",
+	label: "cot",
+	command: "\\cot",
+	latex: "\\cot"
+});
+//#endregion
+export { a as cos, l as cot, c as csc, s as sec, i as sin, o as tan, n as trigonometry_exports };

package/dist/keys/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const mkSet: (category: any) => (o: any) => any;
+export declare const toArray: (o: any) => any[];
+export declare const toKey: (category: any) => (v: any) => any;
+export declare const transformToKeySetStructure: (data?: never[]) => any[];
+export declare const extendKeySet: (base?: never[], keySetData?: never[]) => any[][];

package/dist/keys/utils.js

@@ -0,0 +1,24 @@
+import { flatten as e, times as t } from "@pie-element/shared-lodash";
+//#region src/keys/utils.ts
+var n = (e) => (t) => ({
+	...t,
+	category: e
+}), r = (e = []) => {
+	let n = [];
+	t(5, () => n.push([]));
+	let r = e.length, i = 0, a = 0;
+	for (; a < r;) n[i++].push(e[a++]), i === 5 && (i = 0);
+	return n;
+}, i = (t) => (n) => {
+	let r = e(t), i = r.some((e) => e.latex === n.latex), a = r.some((e) => e.name === n.name);
+	return !i && !a;
+}, a = (e = [], n = []) => {
+	n = n.filter(i(e));
+	let a = [];
+	t(5 - e.length, () => e.push([])), t(5, () => a.push([]));
+	let o = r(n);
+	for (let t = 0; t < 5; t++) a[t] = [...e[t], ...o[t]];
+	return a;
+};
+//#endregion
+export { a as extendKeySet, n as mkSet, r as transformToKeySetStructure };

package/dist/keys/vars.d.ts

@@ -0,0 +1,3 @@
+export declare const x: any;
+export declare const y: any;
+export declare const theta: any;

package/dist/keys/vars.js

@@ -0,0 +1,22 @@
+import { __exportAll as e } from "../_virtual/_rolldown/runtime.js";
+import { mkSet as t } from "./utils.js";
+//#region src/keys/vars.ts
+var n = /* @__PURE__ */ e({
+	theta: () => o,
+	x: () => i,
+	y: () => a
+}), r = t("vars"), i = r({
+	name: "X",
+	latex: "x",
+	write: "x"
+}), a = r({
+	name: "Y",
+	latex: "y",
+	write: "y"
+}), o = r({
+	name: "Theta",
+	latex: "\\theta",
+	write: "\\theta"
+});
+//#endregion
+export { o as theta, n as vars_exports, i as x, a as y };

package/dist/latex-bridge.d.ts

@@ -0,0 +1,197 @@
+/**
+ * LaTeX translation layer between the MathQuill-era content model and MathLive.
+ *
+ * Two independent concerns live here:
+ *
+ *  1. Newlines. MathQuill had no line break, so pie-lib registered a custom
+ *     `newLine` embed that serialises to `\embed{newLine}[]`. MathLive has no
+ *     embed system but supports real multiline environments, so we translate
+ *     `\embed{newLine}[]` <-> `\\` inside `\displaylines{}`.
+ *
+ *     Authored content keeps its `\embed{newLine}[]` on-disk form (that is what
+ *     @pie-lib/math-rendering already normalises for MathJax), so each renderer
+ *     normalises at its own boundary and stored items stay compatible.
+ *
+ *  2. Keypad key -> MathLive action. MathQuill keys carry `write`/`command`/
+ *     `keystroke` built for `mf.write()` / `mf.cmd()` / `mf.keystroke()`.
+ *     MathLive has `insert()` and `executeCommand()` instead.
+ */
+export declare const NEWLINE_EMBED = "\\embed{newLine}[]";
+/**
+ * Static latex for a filled response area: the answer inside the same box a
+ * `\answerBlock` draws, tagged `data-answer-block` with the response id.
+ *
+ * This replaces MathQuill's pattern of rendering an empty embed and then
+ * running `applyStaticMath` on a span inside it, which has no equivalent in
+ * MathLive's markup.
+ *
+ * @param {string} id response id, e.g. `r1`
+ * @param {string} [answer] stored latex of the answer
+ * @returns {string}
+ */
+export declare const answerBlockLatex: (id: any, answer: any) => string;
+/** Default id used when stored latex has an unnamed field. */
+export declare const DEFAULT_FIELD_ID = "r1";
+/**
+ * Make empty argument slots visible, for static rendering.
+ *
+ * Display-only: never feed the result to a mathfield or to storage - the
+ * original latex is what gets typed and saved.
+ *
+ * @param {string} latex
+ * @returns {string}
+ */
+export declare const withVisibleEmptySlots: (latex: any) => any;
+/**
+ * Pie commands that take an argument, and their native MathLive equivalents.
+ *
+ * These MUST NOT be handled as MathLive macros. A macro is serialised from the
+ * arguments it was created with, so text typed inside its expansion never makes
+ * it back out: `getValue('latex')` keeps returning `\longdiv{\placeholder{}}`
+ * while `getValue('ascii-math')` shows the typed content. Setting
+ * `captureSelection: false` lets the cursor in but does not change
+ * serialisation.
+ *
+ * Expanding to native constructs instead gives real, editable atoms that
+ * round-trip. All three targets are understood by MathJax too, so stored latex
+ * still renders in @pie-lib/math-rendering without a reverse mapping.
+ */
+/**
+ * Rewrite argument-taking pie commands into native MathLive latex.
+ * Applied on the way *into* a mathfield.
+ *
+ * @param {string} latex
+ * @returns {string}
+ */
+export declare const toNativeCommands: (latex: any) => any;
+/**
+ * Ids of the answer blocks in a piece of stored latex, in document order.
+ *
+ * @param {string} latex
+ * @returns {string[]}
+ */
+export declare const fieldIds: (latex: any) => any[];
+/**
+ * The answer in each answer block of stored latex, keyed by id.
+ *
+ * @param {string} latex
+ * @returns {Record<string, string>}
+ */
+export declare const fieldValues: (latex: any) => {};
+/**
+ * Stored latex with every answer block emptied: what stays the same while a
+ * student types.
+ *
+ * @param {string} latex
+ * @returns {string}
+ */
+export declare const fieldTemplate: (latex: any) => any;
+/**
+ * Stored latex with each answer block holding `values[id]`. Everything outside
+ * the blocks is kept exactly as stored, so it round-trips unchanged.
+ *
+ * @param {string} latex
+ * @param {Record<string, string>} values
+ * @returns {string}
+ */
+export declare const fillFields: (latex: any, values: any) => string;
+/**
+ * Latex for a text alternative: the same expression without the display-only
+ * markup that MathLive's MathML and speech conversions drop with its content.
+ *
+ * - `\htmlData{...}{x}` keeps `x`, and `\boxed{x}` keeps `x`;
+ * - an answer block's "R" label goes, as it is decoration;
+ * - an empty response area reads as a blank.
+ *
+ * @param {string} latex MathLive latex, after `toMathLive`
+ * @returns {string}
+ */
+export declare const toAccessibleLatex: (latex: any) => any;
+/**
+ * Convert stored latex (which may contain `\embed{newLine}[]`) into latex that
+ * MathLive can parse and render as multiple lines.
+ *
+ * @param {string} latex
+ * @returns {string}
+ */
+export declare const toMathLive: (latex: any) => any;
+/**
+ * Keypad command names that MathQuill treated as ALIASES of a different command.
+ *
+ * MathQuill registered `\\divide` as another name for `\\div` (and
+ * `\\perpendicular` for `\\perp`), so pressing the key stored the real command.
+ * MathLive only knows these names through `PIE_MACROS`, and serialises a macro
+ * under its own name - so `\\divide` reached storage verbatim, where MathJax
+ * (@pie-lib/math-rendering) has no such command and renders it as red text.
+ *
+ * Every other keypad command already matches what MathQuill stored (`\\degree`,
+ * `\\nsim`, `\\ncong`, `\\nparallel`, `\\square`, `\\napprox`,
+ * `\\parallelogram`), and MathJax understands those.
+ */
+declare const MATHQUILL_ALIASES: {
+    '\\divide': string;
+    '\\perpendicular': string;
+};
+/**
+ * Rewrite what MathLive serialises into the form MathQuill stored: alias
+ * command names, and primes.
+ *
+ * @param {string} latex
+ * @returns {string}
+ */
+export declare const toCanonicalCommands: (latex: any) => any;
+/**
+ * Convert latex out of MathLive back into the stored form, so items authored
+ * with the MathLive editor remain readable by @pie-lib/math-rendering and by
+ * the existing MathQuill implementation.
+ *
+ * @param {string} latex
+ * @returns {string}
+ */
+export declare const fromMathLive: (latex: any) => any;
+/**
+ * MathQuill `cmd()` semantics: commands that take arguments should land the
+ * cursor inside the first argument. MathLive expresses that with `#?`
+ * placeholders in the inserted latex.
+ */
+declare const COMMANDS_WITH_ARGS: {
+    '\\frac': string;
+    '/': string;
+    '\\sqrt': string;
+    '\\nthroot': string;
+    '\\overline': string;
+    '\\overrightarrow': string;
+    '\\overleftrightarrow': string;
+    '\\overarc': string;
+    '\\longdiv': string;
+    '^': string;
+    _: string;
+    '(': string;
+    '[': string;
+    '|': string;
+};
+/**
+ * MathQuill keystroke names -> MathLive command selectors.
+ */
+declare const KEYSTROKES: {
+    Left: string;
+    Right: string;
+    Backspace: string;
+    Delete: string;
+    Up: string;
+    Down: string;
+};
+/**
+ * Translate a keypad key definition into a MathLive action.
+ *
+ * Mirrors the precedence in @pie-lib/math-input's MathInput.keypadPress:
+ * latex (unless a command is present) -> write -> command -> keystroke.
+ *
+ * @param {object} key
+ * @returns {{type: 'insert'|'command', value: string}|undefined}
+ */
+export declare const keyToAction: (key: any) => {
+    type: string;
+    value: any;
+} | undefined;
+export { COMMANDS_WITH_ARGS, KEYSTROKES, MATHQUILL_ALIASES };

package/dist/latex-bridge.js

@@ -0,0 +1,210 @@
+//#region src/latex-bridge.ts
+var e = "\\embed{newLine}[]", t = /^\\displaylines\{([\s\S]*)\}$/, n = "\\MathQuillMathField", r = (e, t) => {
+	let n = 0;
+	for (let r = t; r < e.length; r++) {
+		let t = e[r];
+		if (t === "\\") r += 1;
+		else if (t === "{") n += 1;
+		else if (t === "}" && (--n, n === 0)) return r;
+	}
+	return -1;
+}, i = (e, t, n) => {
+	let i = RegExp(`${t.replace(/\\/g, "\\\\")}\\[([^\\]]*)\\]\\{`, "g"), a = "", o = 0, s;
+	for (; (s = i.exec(e)) !== null;) {
+		let t = s.index + s[0].length - 1, c = r(e, t);
+		if (c === -1) break;
+		a += e.slice(o, s.index) + n(s[1], e.slice(t + 1, c)), o = c + 1, i.lastIndex = o;
+	}
+	return a + e.slice(o);
+}, a = (e, t) => {
+	let n = [], r = 0, i = 0, a = 0;
+	for (; a < e.length;) {
+		if (r === 0 && e.startsWith(t, a)) {
+			n.push(e.slice(i, a)), a += t.length, i = a;
+			continue;
+		}
+		let o = e[a];
+		if (o === "\\") {
+			let t = e.slice(a).match(/^\\(?:[a-zA-Z]+|.)/), n = t ? t[0] : o;
+			n === "\\begin" ? r += 1 : n === "\\end" && --r, a += n.length;
+		} else o === "{" ? r += 1 : o === "}" && --r, a += 1;
+	}
+	return n.push(e.slice(i)), n;
+}, o = (t) => {
+	if (t.indexOf("\\embed{newLine}[]") === -1) return t;
+	let n = "", i = 0;
+	for (; i < t.length;) {
+		let s = t[i];
+		if (s === "\\") n += t.slice(i, i + 2), i += 2;
+		else {
+			if (s === "{") {
+				let s = r(t, i);
+				if (s !== -1) {
+					let r = a(o(t.slice(i + 1, s)), e);
+					n += `{${r.length > 1 ? `\\begin{array}{l}${r.join(" \\\\ ")}\\end{array}` : r[0]}}`, i = s + 1;
+					continue;
+				}
+			}
+			n += s, i += 1;
+		}
+	}
+	return n;
+}, s = (e) => {
+	if (e.indexOf("$") === -1) return e;
+	let t = "";
+	for (let n = 0; n < e.length; n++) e[n] === "\\" ? (t += e.slice(n, n + 2), n += 1) : t += e[n] === "$" ? "\\$" : e[n];
+	return t;
+}, c = /\\placeholder\{([^{}]*)\}/g, l = /\\placeholder(?![[{a-zA-Z])/g, u = /\\embed\{answerBlock\}\[([^\]]*)\]/g, d = /\\answerBlock\{([^{}]*)\}/g, f = (t, n) => {
+	let r = n ? a(n, e) : [];
+	return `\\htmlData{answer-block=${t}}{\\boxed{\\htmlData{answer-block-index=${t}}{\\textsf{R}}\\enspace ${r.length > 1 ? `\\begin{array}{l}${r.join(" \\\\ ")}\\end{array}` : n || "\\phantom{0}"}}}`;
+}, p = "\\htmlData{pie-empty=1}{\\rule{0.55em}{0.55em}}", m = /\{\s*\}/g, h = /_\{\s*\}/g, g = /\^\{\s*\}/g, _ = "\\htmlData{pie-empty=1}{\\rule[-0.4em]{0.55em}{0.95em}}", v = "\\rule[-0.5em]{0em}{0.5em}", y = "\\htmlData{pie-empty=1}{\\rule[-0.1em]{0.55em}{0.95em}}", b = /\\overline\{\s*\}/g, x = "\\rule{0em}{0.87em}", S = "\\rule{0em}{1.3em}", C = /\\left([([|])\s*\\right([)\]|])/g, w = "\\rule{0em}{1em}\\htmlData{pie-empty=1}{\\rule[-0.25em]{0.55em}{1em}}", T = (e) => (e || "").replace(b, `${S}\\overline{${x}${p}}`).replace(h, `_{${_}}${v}`).replace(g, `^{${y}}`).replace(m, `{${p}}`).replace(C, (e, t, n) => `\\left${t}${w}\\right${n}`), E = (e) => {
+	if (typeof e != "string" || !e) return e || "";
+	let t = e;
+	return t = O(t), t = t.replace(/\\longdiv\{/g, "\\enclose{longdiv}{"), t = t.replace(/\\overarc\{/g, "\\overparen{"), t = D(t), t;
+}, D = (e) => {
+	if (e.indexOf("%") === -1) return e;
+	let t = "", n = 0;
+	for (let r = 0; r < e.length; r++) {
+		let i = e[r];
+		t += i === "%" && n % 2 == 0 ? "\\%" : i, n = i === "\\" ? n + 1 : 0;
+	}
+	return t;
+}, O = (e) => {
+	let t = e, n = t.indexOf("\\abs{");
+	for (; n !== -1;) {
+		let e = n + 5 - 1, r = 0, i = -1;
+		for (let n = e; n < t.length; n++) if (t[n] === "{") r++;
+		else if (t[n] === "}" && (r--, r === 0)) {
+			i = n;
+			break;
+		}
+		if (i === -1) break;
+		let a = t.slice(e + 1, i);
+		t = `${t.slice(0, n)}\\left|${a}\\right|${t.slice(i + 1)}`, n = t.indexOf("\\abs{");
+	}
+	return t;
+}, k = (e) => {
+	if (typeof e != "string") return [];
+	let t = [];
+	return i(e, n, (e) => (t.push(e || "r1"), "")), t;
+}, A = (e) => {
+	let t = {};
+	return typeof e == "string" && i(e, n, (e, n) => (t[e || "r1"] = n, "")), t;
+}, j = (e) => typeof e == "string" ? i(e, n, (e) => `${n}[${e || "r1"}]{}`) : e, M = (e, t) => i(e, n, (e, r) => {
+	let i = e || "r1";
+	return `${n}[${i}]{${t[i] === void 0 ? r : t[i]}}`;
+}), N = (e) => {
+	if (typeof e != "string" || !e) return e || "";
+	let t = (e, t, n) => {
+		let i = e, a = i.indexOf(t);
+		for (; a !== -1;) {
+			let e = a + t.length, o = i[e] === "{" ? r(i, e) : -1;
+			if (o === -1) {
+				a = i.indexOf(t, a + t.length);
+				continue;
+			}
+			let s = n(i, e, o);
+			i = i.slice(0, a) + s.text + i.slice(s.end), a = i.indexOf(t, a);
+		}
+		return i;
+	}, n = e.replace(d, "\\square");
+	return n = t(n, "\\htmlData", (e, t, n) => {
+		let i = e.slice(t + 1, n), a = n + 1, o = e[a] === "{" ? r(e, a) : -1;
+		if (o === -1) return {
+			text: "",
+			end: n + 1
+		};
+		if (/^answer-block-index=/.test(i)) {
+			let t = e.slice(o + 1).match(/^\s*\\enspace\s*/);
+			return {
+				text: "",
+				end: o + 1 + (t ? t[0].length : 0)
+			};
+		}
+		return {
+			text: `{${e.slice(a + 1, o)}}`,
+			end: o + 1
+		};
+	}), t(n, "\\boxed", (e, t, n) => ({
+		text: `{${e.slice(t + 1, n)}}`,
+		end: n + 1
+	}));
+}, P = (t) => {
+	if (typeof t != "string" || !t) return t || "";
+	let r = E(t);
+	if (r = i(r, n, (e, t) => `\\placeholder[${e || "r1"}]{${t}}`), r = r.replace(u, (e, t) => `\\answerBlock{${t}}`), r = s(r), r = o(r), r.indexOf("\\embed{newLine}[]") !== -1) {
+		let t = a(r, e);
+		t.length > 1 && (r = `\\displaylines{${t.join(" \\\\ ")}}`);
+	}
+	return r;
+}, F = {
+	"\\divide": "\\div",
+	"\\perpendicular": "\\perp"
+}, I = /\\(divide|perpendicular)(?![a-zA-Z])/g, L = /\^\{((?:\s*\\(?:prime|doubleprime)(?![a-zA-Z]))+)\s*\}/g, R = /\\doubleprime(?![a-zA-Z])/g, z = (e) => "'".repeat((e.match(/\\prime(?![a-zA-Z])/g) || []).length + 2 * (e.match(R) || []).length), B = /^\\(doubleprime|prime)(?![a-zA-Z])/, V = (e) => {
+	if (e.indexOf("prime") === -1) return e;
+	let t = [], n = "", r = 0;
+	for (; r < e.length;) {
+		let i = e[r];
+		if (i === "\\") {
+			let a = e.slice(r).match(B);
+			if (a) {
+				let e = a[1] === "doubleprime";
+				/[\^_]\s*$/.test(n) || t.indexOf(!0) !== -1 ? n += e ? "\\prime\\prime" : "\\prime" : n += e ? "''" : "'", r += a[0].length;
+				continue;
+			}
+			let o = e.slice(r).match(/^\\(?:[a-zA-Z]+|.)/), s = o ? o[0] : i;
+			n += s, r += s.length;
+		} else i === "{" ? t.push(/[\^_]\s*$/.test(n)) : i === "}" && t.pop(), n += i, r += 1;
+	}
+	return n;
+}, H = (e) => typeof e == "string" ? V(e.replace(I, (e) => F[e]).replace(L, (e, t) => z(t))) : e, U = (n) => {
+	if (typeof n != "string" || !n) return n || "";
+	let r = n.trim().match(t), o = n;
+	return r && (o = a(r[1], "\\\\").map((e) => e.trim()).join(e)), o = i(o, "\\placeholder", (e, t) => `\\MathQuillMathField[${e || "r1"}]{${t}}`), o = o.replace(d, (e, t) => `\\embed{answerBlock}[${t}]`), o = o.replace(c, (e, t) => t), o = o.replace(l, ""), H(o);
+}, W = {
+	"\\frac": "\\frac{#?}{#?}",
+	"/": "\\frac{#@}{#?}",
+	"\\sqrt": "\\sqrt{#?}",
+	"\\nthroot": "\\sqrt[#?]{#?}",
+	"\\overline": "\\overline{#?}",
+	"\\overrightarrow": "\\overrightarrow{#?}",
+	"\\overleftrightarrow": "\\overleftrightarrow{#?}",
+	"\\overarc": "\\overparen{#?}",
+	"\\longdiv": "\\enclose{longdiv}{#?}",
+	"^": "^{#?}",
+	_: "_{#?}",
+	"(": "\\left(#?\\right)",
+	"[": "\\left[#?\\right]",
+	"|": "\\left|#?\\right|"
+}, G = {
+	Left: "moveToPreviousChar",
+	Right: "moveToNextChar",
+	Backspace: "deleteBackward",
+	Delete: "deleteForward",
+	Up: "moveUp",
+	Down: "moveDown"
+}, K = (e) => {
+	if (e) {
+		if (e.latex && !e.command) return {
+			type: "insert",
+			value: e.latex
+		};
+		if (e.write) return {
+			type: "insert",
+			value: e.write
+		};
+		if (e.command) return {
+			type: "insert",
+			value: (Array.isArray(e.command) ? e.command : [e.command]).map((e) => W[e] || F[e] || e).join("")
+		};
+		if (e.keystroke) {
+			let t = G[e.keystroke];
+			return t ? {
+				type: "command",
+				value: t
+			} : void 0;
+		}
+	}
+};
+//#endregion
+export { W as COMMANDS_WITH_ARGS, G as KEYSTROKES, F as MATHQUILL_ALIASES, e as NEWLINE_EMBED, f as answerBlockLatex, k as fieldIds, j as fieldTemplate, A as fieldValues, M as fillFields, U as fromMathLive, K as keyToAction, N as toAccessibleLatex, H as toCanonicalCommands, P as toMathLive, E as toNativeCommands, T as withVisibleEmptySlots };

package/dist/longdiv.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Correct every long division under `root`.
+ *
+ * @param {ParentNode} root a mathfield's shadow root, or an element holding
+ *   static MathLive markup
+ * @returns {number} how many were corrected
+ */
+export declare const fixLongDivision: (root: any) => number;
+/**
+ * Correct static markup now, and again once web fonts have loaded: the bar's
+ * end is measured, and glyph widths change when the math fonts arrive.
+ *
+ * @param {Element} element
+ */
+export declare const fixLongDivisionWhenReady: (element: any) => void;
+/**
+ * Keep a live mathfield's long divisions corrected. MathLive rebuilds its shadow
+ * DOM on every render (each keystroke, a resize, the fonts loading), which
+ * discards the corrections, so they are reapplied whenever it does.
+ *
+ * @param {HTMLElement} mathField a MathLive `<math-field>`
+ * @returns {function|undefined} teardown, to call on unmount
+ */
+export declare const trackLongDivision: (mathField: any) => (() => void) | undefined;

package/dist/longdiv.js

@@ -0,0 +1,43 @@
+import e from "debug";
+//#region src/longdiv.ts
+var t = e("pie-lib:math-input-mathlive:longdiv"), n = (e, t) => {
+	let n = RegExp(`(?:^|;)\\s*${t}:\\s*(-?[\\d.]+)em`).exec(e || "");
+	return n ? parseFloat(n[1]) : 0;
+}, r = (e, t) => e && Array.from(e.children || []).find((e) => e.tagName.toLowerCase() === t), i = (e) => {
+	let t = -Infinity;
+	return e.querySelectorAll("*").forEach((e) => {
+		if (e.children.length || e.classList && e.classList.contains("ML__caret")) return;
+		let n = e.getBoundingClientRect();
+		n.width > 0 && (t = Math.max(t, n.right));
+	}), t;
+}, a = (e) => {
+	if (!e || typeof e.querySelectorAll != "function") return 0;
+	let a = 0;
+	return e.querySelectorAll(".ML__notation").forEach((e) => {
+		try {
+			let t = r(e, "svg"), o = r(t, "line");
+			if (!o || !r(t, "path")) return;
+			let s = e.nextElementSibling, c = s && s.getAttribute("style"), l = n(c, "width"), u = n(c, "margin-left"), d = n(c, "top"), f = (t.getAttribute("viewBox") || "").trim().split(/\s+/).map(Number), p = parseFloat(o.getAttribute("x1"));
+			if (!l || f.length !== 4 || Number.isNaN(p)) return;
+			e.style.width = `calc(${f[2]}em + 1px)`, d && e.parentElement && (s.style.top = "0", e.parentElement.style.paddingTop = `${d}em`);
+			let m = p + u + l, h = t.getBoundingClientRect(), g = i(s);
+			h.width > 0 && Number.isFinite(g) && (m = (g - h.left) * (f[2] / h.width)), o.setAttribute("x2", String(m)), a += 1;
+		} catch (e) {
+			t("could not correct a long division: %s", e && e.message);
+		}
+	}), a;
+}, o = (e) => {
+	a(e), typeof document < "u" && document.fonts && document.fonts.ready && document.fonts.ready.then(() => a(e)).catch(() => {});
+}, s = (e) => {
+	let t = e && e.shadowRoot;
+	if (!t) return;
+	let n = () => a(t);
+	if (n(), typeof MutationObserver > "u") return () => {};
+	let r = new MutationObserver(n);
+	return r.observe(t, {
+		childList: !0,
+		subtree: !0
+	}), () => r.disconnect();
+};
+//#endregion
+export { a as fixLongDivision, o as fixLongDivisionWhenReady, s as trackLongDivision };

package/dist/math-input.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+/**
+ * MathLive-backed equivalent of @pie-lib/math-input's `MathInput`.
+ * Same props (`keyset`, `latex`, `onChange`, `displayMode`).
+ */
+export declare class MathInput extends React.Component {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        keyset: PropTypes.Requireable<any[]>;
+        displayMode: PropTypes.Requireable<string>;
+        latex: PropTypes.Requireable<string>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        keyset: never[];
+        displayMode: string;
+    };
+    constructor(props: any);
+    keypadPress: (key: any) => void;
+    inputFocus: () => void;
+    inputBlur: () => void;
+    changeLatex: (l: any) => void;
+    render(): React.JSX.Element;
+}
+export default MathInput;