@pie-element/number-line 13.1.0-next.28 → 13.1.1-next.0

package/dist/controller/tickUtils.js

@@ -0,0 +1,254 @@
+import e from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/isObject.js";
+import t from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/isNumber.js";
+import n from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/uniqWith.js";
+import * as r from "mathjs";
+//#region src/controller/tickUtils.ts
+var i = [
+	.001,
+	.01,
+	.02,
+	.04,
+	.05,
+	.1,
+	.125,
+	.2,
+	.25,
+	.5
+], a = [
+	"1/1000",
+	"1/100",
+	"1/64",
+	"1/50",
+	"1/32",
+	"1/25",
+	"1/20",
+	"1/16",
+	"1/15",
+	"1/12",
+	"1/10",
+	"1/9",
+	"1/8",
+	"1/7",
+	"1/6",
+	"1/5",
+	"1/4",
+	"1/3",
+	"1/2"
+], o = {
+	1: [
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		9,
+		10
+	],
+	2: [
+		1,
+		2,
+		4,
+		6,
+		8,
+		10
+	],
+	3: [
+		1,
+		3,
+		6,
+		9
+	],
+	4: [
+		1,
+		2,
+		4,
+		8
+	],
+	5: [
+		1,
+		5,
+		10
+	],
+	6: [
+		1,
+		2,
+		3,
+		6
+	],
+	7: [1, 7],
+	8: [
+		1,
+		2,
+		4,
+		8
+	],
+	9: [
+		1,
+		3,
+		9
+	],
+	10: [
+		1,
+		2,
+		5,
+		10
+	],
+	12: [
+		1,
+		2,
+		3,
+		4,
+		6
+	],
+	15: [
+		1,
+		3,
+		5
+	],
+	16: [
+		1,
+		2,
+		4,
+		8
+	],
+	20: [
+		1,
+		2,
+		4,
+		5,
+		10
+	],
+	25: [1, 5],
+	32: [
+		1,
+		2,
+		4,
+		8
+	],
+	50: [
+		1,
+		2,
+		5,
+		10
+	],
+	64: [
+		1,
+		2,
+		4,
+		8
+	],
+	100: [
+		1,
+		2,
+		4,
+		5,
+		10
+	],
+	1e3: [
+		1,
+		2,
+		4,
+		5,
+		8,
+		10
+	]
+}, s = (e, t, n) => {
+	let i = r.mod(r.abs(e), r.abs(n));
+	if (!r.equal(i, 0)) throw Error("start point must be divisible by interval");
+	if (r.equal(e, t)) return [];
+	let a = r.subtract(t, r.mod(t, r.abs(n))), o = r.larger(n, 0) ? "positive" : "negative";
+	if (o === "negative" && r.largerEq(t, e)) throw Error("start must be > than end when doing a negative decrement");
+	if (o === "positive" && r.smallerEq(t, e)) throw Error("start must be < end when doing increments");
+	let s = o === "positive" ? r.smallerEq : r.equal(a, t) ? r.largerEq : r.larger, c = [], l = e;
+	for (; s(l, a);) c.push(l), l = r.add(l, n);
+	return c;
+}, c = (e, t) => `Can only do a positive or negative range, but got: start: ${e} and end:${t}`, l = (e, t, n) => {
+	e = r.fraction(e), t = r.fraction(t), n = r.fraction(n);
+	let i = r.abs(r.subtract(t, e));
+	if (r.larger(i, r.abs(t))) throw Error(c(e, t));
+	let a = {
+		start: r.abs(e),
+		end: r.abs(t),
+		interval: r.abs(n),
+		multiplier: r.smaller(n, 0) ? -1 : 1
+	}, o = r.mod(a.start, a.interval), l = s(r.larger(o, 0) ? r.add(r.subtract(a.start, o), a.interval) : a.start, a.end, a.interval), u = a.multiplier === -1 ? l.map((e) => r.multiply(e, -1)) : l;
+	return r.smaller(n, 0) && u.reverse(), u;
+}, u = (e, t) => (e = r.fraction(e), t = r.fraction(t), r.smaller(e, t) ? e : t), d = (e, t) => (e = r.fraction(e), t = r.fraction(t), r.larger(e, t) ? e : t), f = (e, t, i) => {
+	e = r.fraction(e), t = r.fraction(t), i = r.fraction(i);
+	let a = r.larger(t, 0) ? l(d(0, e), t, i) : [];
+	return n((r.smaller(e, 0) ? l(u(0, t), e, r.multiply(i, -1)) : []).concat(a), r.equal);
+}, p = (e, t, n) => {
+	n ||= 2;
+	let r = 10 ** -n / 2;
+	return Math.abs(e - t) < r;
+}, m = (e, t, n) => r.smaller(_(e), _(t)) ? t : r.larger(_(e), _(n)) ? n : e, h = (e, t) => {
+	let n = e.max - e.min, i = r.number(r.multiply(10, r.divide(r.fraction(n), t)));
+	return {
+		min: i,
+		max: r.number(r.multiply(20, i))
+	};
+}, g = (e, t) => {
+	let n = r.mod(e, t);
+	return r.equal(n, 0);
+}, _ = (n) => {
+	if (e(n)) return r.fraction(n.n * n.s, n.d);
+	if (t(n)) return r.fraction(n);
+}, v = (e, t, n, i) => {
+	let a = i ? i.limit !== !1 : !0, o = h(e, t), s = a ? m(_(n.minor), o.min, o.max) : _(n.minor), c = a ? m(_(n.major), s, r.multiply(s, 20)) : _(n.major);
+	if (!g(c, s)) {
+		let e = r.divide(c, s), t = e <= 2 ? 2 : Math.round(e);
+		return {
+			minor: s,
+			major: r.multiply(s, t)
+		};
+	}
+	return {
+		major: c,
+		minor: s
+	};
+}, y = (e, t, n, i) => (n = v(e, t, n, i), f(e.min, e.max, n.minor).filter((t) => r.smallerEq(t, r.fraction(e.max))).map((e) => {
+	let t = "minor", i = r.mod(e, n.major);
+	return p(r.number(i), 0) && (t = "major"), {
+		x: e,
+		type: t
+	};
+})), b = (e) => {
+	let t = {
+		fraction: [],
+		decimal: []
+	};
+	return i.forEach((n) => {
+		n >= e.min && n <= e.max && t.decimal.push(n);
+	}), a.forEach((n) => {
+		let i = r.number(r.fraction(n));
+		i >= e.min && i <= e.max && t.fraction.push(n);
+	}), t;
+}, x = (e, t, n) => {
+	let i = {
+		decimal: [],
+		fraction: []
+	}, a = r.fraction(r.number(r.number(e))), s = a.n, c = a.d;
+	if (s >= 1 && c === 1) for (let a = 1; a <= 10; a++) {
+		let o = r.number(r.multiply(s, a));
+		S(t, n, {
+			minor: e,
+			major: o
+		}, { fraction: void 0 }).filter((e) => e.type === "major").length > 1 && (i.fraction.push(o.toString()), i.decimal.push(o));
+	}
+	else for (let a in o[c]) {
+		let l = r.multiply(r.fraction(s, c), o[c][a]);
+		S(t, n, {
+			minor: e,
+			major: r.number(l)
+		}, { fraction: void 0 }).filter((e) => e.type === "major").length > 1 && (l.d === 1 ? i.fraction.push(l.n.toString()) : i.fraction.push(l.n + "/" + l.d), i.decimal.push(r.number(l)));
+	}
+	return i;
+}, S = (e, t, n, i) => y(e, t, n, i).map((e) => i.fraction ? e : {
+	...e,
+	x: r.number(e.x) || 0
+});
+//#endregion
+export { x as generateMajorValuesForMinor, b as generateMinorValues, h as getMinorLimits };

package/dist/controller/utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @synced-from pie-elements/packages/number-line/controller/src/utils.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+export declare const reloadTicksData: (graph: any) => any;

package/dist/controller/utils.js

@@ -0,0 +1,68 @@
+import { generateMajorValuesForMinor as e, generateMinorValues as t, getMinorLimits as n } from "./tickUtils.js";
+import * as r from "mathjs";
+//#region src/controller/utils.ts
+var i = (t) => {
+	let { domain: n, ticks: r, width: i } = t, a = e(r.minor, n, i);
+	if (a.decimal.indexOf(r.major) === -1) {
+		let e = 0;
+		e = r.tickIntervalType === "Integer" && a.decimal.length > 4 ? 4 : a.decimal.length - 1, r.major = a.decimal[e];
+	}
+	return t.fraction = r.tickIntervalType === "Fraction" && r.major < 1, {
+		...t,
+		ticks: r
+	};
+}, a = (e) => {
+	let { domain: a, ticks: o = {}, width: s } = e;
+	o.tickIntervalType || (o.minor > .5 ? o.tickIntervalType = "Integer" : o.tickIntervalType = "Decimal");
+	let c = n(a, s);
+	if (c.min >= 1) o.tickIntervalType = "Integer", o.minor = o.minor < 1 ? r.number(r.ceil(c.min)) : o.minor >= r.number(r.ceil(c.min)) && o.minor <= r.number(r.floor(c.max)) ? o.minor : r.number(r.ceil(c.min)), o.integerTick = o.minor, o.fractionTick = "0", o.decimalTick = 0;
+	else if (c.min >= 0 && c.max < 1) {
+		o.tickIntervalType === "Integer" && (o.tickIntervalType = "Fraction");
+		let e = t(c), n = r.number(r.fraction(e.fraction[0])), i = r.number(r.fraction(e.fraction[e.fraction.length - 1]));
+		if (o.minor < n || o.minor > i) switch (o.tickIntervalType) {
+			case "Fraction":
+				o.minor = r.number(r.fraction(e.fraction[e.fraction.length - 1])), o.fractionTick = e.fraction[e.fraction.length - 1], o.decimalTick = e.decimal[0];
+				break;
+			case "Decimal":
+			case "Integer": o.minor = e.decimal[e.decimal.length - 1], o.decimalTick = e.decimal[e.decimal.length - 1], o.fractionTick = e.fraction[0];
+		}
+		else switch (o.tickIntervalType) {
+			case "Fraction":
+				let t = r.fraction(r.number(o.minor));
+				o.fractionTick = t.n + "/" + t.d, o.decimalTick = o.decimalTick ? o.decimalTick : e.decimal[0];
+				break;
+			case "Decimal":
+			case "Integer": o.decimalTick = o.minor, o.fractionTick = o.fractionTick ? o.fractionTick : e.fraction[0];
+		}
+		o.integerTick = 1;
+	} else if (c.min < 1 && c.max >= 1) {
+		let e = t(c);
+		if (o.minor >= c.min && o.minor <= c.max) switch (o.tickIntervalType) {
+			case "Integer":
+				o.integerTick = o.minor, o.decimalTick = c.min > .5 ? 0 : e.decimal[0], o.fractionTick = c.min > .5 ? "0" : e.fraction[0];
+				break;
+			case "Decimal":
+				o.integerTick = 1, o.decimalTick = o.minor, o.fractionTick = e.fraction[0];
+				break;
+			case "Fraction":
+				o.integerTick = 1, o.decimalTick = e.decimal[0];
+				let t = r.fraction(r.number(o.minor));
+				o.fractionTick = t.n + "/" + t.d;
+		}
+		else switch (c.min > .5 && (o.tickIntervalType = "Integer"), o.tickIntervalType) {
+			case "Integer":
+				o.minor = r.number(r.ceil(c.min)), o.integerTick = o.minor, o.decimalTick = c.min > .5 ? 0 : e.decimal[0], o.fractionTick = c.min > .5 ? "0" : e.fraction[0];
+				break;
+			case "Decimal":
+				o.minor = e.decimal[0], o.integerTick = 1, o.decimalTick = o.minor, o.fractionTick = e.fraction[0];
+				break;
+			case "Fraction": o.minor = r.number(r.fraction(e.fraction[0])), o.integerTick = 1, o.decimalTick = e.decimal[0], o.fractionTick = e.fraction[0];
+		}
+	}
+	return i({
+		...e,
+		ticks: o
+	});
+};
+//#endregion
+export { a as reloadTicksData };

package/dist/delivery/data-converter.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @synced-from pie-elements/packages/number-line/src/data-converter.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+export declare const lineIsSwitched: (line: any) => boolean;
+export declare const switchGraphLine: (line: any) => any;
+export declare const switchPosition: (p: any) => {
+    left: any;
+    right: any;
+};
+export declare const toSessionFormat: (gf: any) => {
+    type: string;
+    pointType: any;
+    domainPosition: any;
+    size?: undefined;
+    leftPoint?: undefined;
+    rightPoint?: undefined;
+    direction?: undefined;
+} | {
+    type: string;
+    size: number;
+    domainPosition: any;
+    leftPoint: any;
+    rightPoint: any;
+    pointType?: undefined;
+    direction?: undefined;
+} | {
+    type: string;
+    domainPosition: any;
+    pointType: any;
+    direction: any;
+    size?: undefined;
+    leftPoint?: undefined;
+    rightPoint?: undefined;
+} | undefined;
+export declare const toGraphFormat: (sf: any) => {
+    type: string;
+    pointType: any;
+    position: any;
+    leftPoint?: undefined;
+    rightPoint?: undefined;
+    direction?: undefined;
+} | {
+    type: string;
+    position: {
+        left: any;
+        right: any;
+    };
+    leftPoint: any;
+    rightPoint: any;
+    pointType?: undefined;
+    direction?: undefined;
+} | {
+    type: string;
+    position: any;
+    pointType: any;
+    direction: any;
+    leftPoint?: undefined;
+    rightPoint?: undefined;
+} | undefined;

package/dist/delivery/data-converter.js

@@ -0,0 +1,70 @@
+import { __exportAll as e } from "../_virtual/_rolldown/runtime.js";
+//#region src/delivery/data-converter.ts
+var t = /* @__PURE__ */ e({
+	lineIsSwitched: () => n,
+	switchGraphLine: () => r,
+	switchPosition: () => i,
+	toGraphFormat: () => o,
+	toSessionFormat: () => a
+}), n = (e) => {
+	let { position: t } = e;
+	return t.left > t.right;
+}, r = (e) => {
+	let { position: t } = e;
+	if (t.left < t.right) return e;
+	let { leftPoint: n, rightPoint: r } = e;
+	return {
+		leftPoint: r,
+		rightPoint: n,
+		position: i(t),
+		type: "line"
+	};
+}, i = (e) => {
+	let { left: t, right: n } = e;
+	return {
+		left: n,
+		right: t
+	};
+}, a = (e) => {
+	if (e.type === "point") return {
+		type: "point",
+		pointType: e.pointType,
+		domainPosition: e.position
+	};
+	if (e.type === "line") return {
+		type: "line",
+		size: e.position.right - e.position.left,
+		domainPosition: e.position.left,
+		leftPoint: e.leftPoint,
+		rightPoint: e.rightPoint
+	};
+	if (e.type === "ray") return {
+		type: "ray",
+		domainPosition: e.position,
+		pointType: e.pointType,
+		direction: e.direction
+	};
+}, o = (e) => {
+	if (e.type === "point") return {
+		type: "point",
+		pointType: e.pointType,
+		position: e.domainPosition
+	};
+	if (e.type === "line") return {
+		type: "line",
+		position: {
+			left: e.domainPosition,
+			right: e.domainPosition + e.size
+		},
+		leftPoint: e.leftPoint,
+		rightPoint: e.rightPoint
+	};
+	if (e.type === "ray") return {
+		type: "ray",
+		position: e.domainPosition,
+		pointType: e.pointType,
+		direction: e.direction
+	};
+};
+//#endregion
+export { t as data_converter_exports, n as lineIsSwitched, r as switchGraphLine, o as toGraphFormat, a as toSessionFormat };

package/dist/delivery/draggable/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @synced-from pie-elements/packages/number-line/src/draggable/index.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+/**
+ * Shared dnd-kit wrapper for Line + Point.
+ *
+ * Props:
+ *  - id: string (unique)
+ *  - disabled: boolean
+ *  - grid: [stepX] (like grid={[is]})
+ *  - bounds: { left: number, right: number } in px (like scaledLineBounds)
+ *  - onMouseDown: (event) => void
+ *  - onDragStart?: () => void
+ *  - onDragMove?: (deltaX: number) => void      // snapped + clamped
+ *  - onDragEnd?: (deltaX: number) => void       // snapped + clamped
+ *  - children: ({ setNodeRef, attributes, listeners, translateX, isDragging, onMouseDown }) => ReactNode
+ */
+export declare function Draggable({ id, disabled, grid, bounds, onMouseDown, onDragStart, onDragMove, onDragEnd, children, }: {
+    id: any;
+    disabled: any;
+    grid: any;
+    bounds: any;
+    onMouseDown: any;
+    onDragStart: any;
+    onDragMove: any;
+    onDragEnd: any;
+    children: any;
+}): any;

package/dist/delivery/draggable/index.js

@@ -0,0 +1,39 @@
+import { useDndMonitor as e, useDraggable as t } from "@dnd-kit/core";
+//#region src/delivery/draggable/index.ts
+function n({ id: n, disabled: r, grid: i, bounds: a, onMouseDown: o, onDragStart: s, onDragMove: c, onDragEnd: l, children: u }) {
+	let { attributes: d, listeners: f, setNodeRef: p, transform: m } = t({
+		id: n,
+		disabled: r
+	}), h = i && i[0] ? i[0] : null, g = m?.x ?? 0;
+	h && (g = Math.round(g / h) * h), a && (typeof a.left == "number" && (g = Math.max(a.left, g)), typeof a.right == "number" && (g = Math.min(a.right, g)));
+	let _ = g, v = !!m, y = (e) => {
+		let t = e;
+		return h && (t = Math.round(t / h) * h), a && (typeof a.left == "number" && (t = Math.max(a.left, t)), typeof a.right == "number" && (t = Math.min(a.right, t))), t;
+	};
+	return e({
+		onDragStart(e) {
+			e.active.id !== n || r || s?.();
+		},
+		onDragMove(e) {
+			if (e.active.id !== n || r) return;
+			let t = e.delta.x || 0;
+			c?.(y(t));
+		},
+		onDragEnd(e) {
+			if (e.active.id !== n || r) return;
+			let t = e.delta.x || 0;
+			l?.(y(t));
+		}
+	}), u({
+		setNodeRef: p,
+		attributes: d,
+		listeners: f,
+		translateX: _,
+		isDragging: v,
+		onMouseDown: (e) => {
+			e.nativeEvent.preventDefault(), o?.(e);
+		}
+	});
+}
+//#endregion
+export { n as Draggable };

package/dist/delivery/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @synced-from pie-elements/packages/number-line/src/index.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+import * as dataConverter from './data-converter.js';
+import * as pointChooser from './number-line/point-chooser/index.js';
+import * as tickUtils from './number-line/graph/tick-utils.js';
+import Graph from './number-line/graph/index.js';
+import NumberLineComponent from './number-line/index.js';
+export { Graph, NumberLineComponent, tickUtils, dataConverter, pointChooser };
+export default class NumberLine extends HTMLElement {
+    constructor();
+    _scheduleMathRender: any;
+    _initMathObserver(): void;
+    _disconnectMathObserver(): void;
+    set model(m: any);
+    set session(s: any);
+    get session(): any;
+    connectedCallback(): void;
+    isComplete(): boolean;
+    dispatch(type: any): void;
+    dispatchSessionChanged(): void;
+    addElement(data: any): void;
+    moveElement(index: any, el: any, position: any): void;
+    deleteElements(indices: any): void;
+    undoElement(): void;
+    clearElements(): void;
+    _applyInitialElements(): void;
+    _render(): void;
+    disconnectedCallback(): void;
+}

package/dist/delivery/index.js

@@ -0,0 +1,109 @@
+import { data_converter_exports as e, lineIsSwitched as t, switchGraphLine as n, toGraphFormat as r, toSessionFormat as i } from "./data-converter.js";
+import { point_chooser_exports as a } from "./number-line/point-chooser/index.js";
+import o from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/cloneDeep.js";
+import { tick_utils_exports as s } from "./number-line/graph/tick-utils.js";
+import c from "./number-line/graph/index.js";
+import l from "./number-line/index.js";
+import u from "react";
+import { createRoot as d } from "react-dom/client";
+import { renderMath as f } from "@pie-element/shared-math-rendering-mathjax";
+//#region src/delivery/index.ts
+var p = class extends HTMLElement {
+	constructor() {
+		super(), this._root = null, this._mathObserver = null, this._mathRenderPending = !1;
+	}
+	_scheduleMathRender = () => {
+		this._mathRenderPending || (this._mathRenderPending = !0, requestAnimationFrame(() => {
+			this._mathObserver && this._mathObserver.disconnect(), f(this), this._mathRenderPending = !1, setTimeout(() => {
+				this._mathObserver && this._mathObserver.observe(this, {
+					childList: !0,
+					subtree: !0,
+					characterData: !1
+				});
+			}, 50);
+		}));
+	};
+	_initMathObserver() {
+		this._mathObserver || (this._mathObserver = new MutationObserver(() => {
+			this._scheduleMathRender();
+		}), this._mathObserver.observe(this, {
+			childList: !0,
+			subtree: !0,
+			characterData: !1
+		}));
+	}
+	_disconnectMathObserver() {
+		this._mathObserver &&= (this._mathObserver.disconnect(), null);
+	}
+	set model(e) {
+		this._model = e, this._applyInitialElements(), this._render(), this.dispatch("model-set");
+	}
+	set session(e) {
+		this._session = e, this._applyInitialElements(), this._render();
+	}
+	get session() {
+		return this._session;
+	}
+	connectedCallback() {
+		this._initMathObserver(), this._render();
+	}
+	isComplete() {
+		return this._session ? (this._session.answer || []).length > 0 : !1;
+	}
+	dispatch(e) {
+		this.dispatchEvent(new CustomEvent(e, {
+			bubbles: !0,
+			detail: { complete: this.isComplete() }
+		}));
+	}
+	dispatchSessionChanged() {
+		this.dispatch("session-changed");
+	}
+	addElement(e) {
+		this._session && (this._session.answer = this._session.answer || [], this._session.answer.push(i(e)), this.dispatchSessionChanged(), this._render());
+	}
+	moveElement(e, r, a) {
+		if (!this._session.answer[e]) throw Error("cant find element at index: ", e);
+		if (r.type === "line" && a.left === a.right) {
+			this._render();
+			return;
+		}
+		r.position = a;
+		let o = r.type === "line" && t(r) ? n(r) : r;
+		this._session.answer.splice(e, 1, i(o)), this.dispatchSessionChanged(), this._render();
+	}
+	deleteElements(e) {
+		this._session.answer = this._session.answer.filter((t, n) => !e.some((e) => e === n)), this.dispatchSessionChanged(), this._render();
+	}
+	undoElement() {
+		this._session.answer.pop(), this.dispatchSessionChanged(), this._render();
+	}
+	clearElements() {
+		this._session.answer = [], this.dispatchSessionChanged(), this._render();
+	}
+	_applyInitialElements() {
+		this._model && this._model.graph && this._model.graph.initialElements && this._session && (!this._session.answer || !this._session.answer.length) && (this._session.answer = o(this._model.graph.initialElements));
+	}
+	_render() {
+		if (this._model && this._session) {
+			this._session.answer || this._applyInitialElements();
+			let e = (this._session.answer || []).map(r), t = o(this._model);
+			t.correctResponse = t.correctResponse && t.correctResponse.map(r);
+			let n = {
+				model: t,
+				answer: e,
+				onAddElement: this.addElement.bind(this),
+				onMoveElement: this.moveElement.bind(this),
+				onDeleteElements: this.deleteElements.bind(this),
+				onUndoElement: this.undoElement.bind(this),
+				onClearElements: this.clearElements.bind(this)
+			}, i = u.createElement(l, n);
+			this._root ||= d(this), this._root.render(i), this._scheduleMathRender();
+		}
+	}
+	disconnectedCallback() {
+		this._disconnectMathObserver(), this._root && this._root.unmount();
+	}
+};
+//#endregion
+export { c as Graph, l as NumberLineComponent, e as dataConverter, p as default, a as pointChooser, s as tickUtils };

package/dist/delivery/number-line/colors.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @synced-from pie-elements/packages/number-line/src/number-line/colors.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+export declare const selected: any;
+export declare const correct: any;
+export declare const incorrect: any;