@mathscan/geometry-engine 0.1.0

package/dist/geometryState.schema-D0ixyGYE.js

@@ -0,0 +1,955 @@
+import e from "jsxgraph";
+import { z as t } from "zod";
+//#region src/geometry/point.ts
+function n(e, t) {
+	return Math.hypot(t.x - e.x, t.y - e.y);
+}
+function r(e, t) {
+	return {
+		x: (e.x + t.x) / 2,
+		y: (e.y + t.y) / 2
+	};
+}
+//#endregion
+//#region src/numerics/policy.ts
+var i = 1e-9, a = 1e-9, o = 1e-12, s = 1e-12, c = 1e-6, l = 1e-9, ee = 24, te = 32;
+function ne(e, t, n = i) {
+	return Math.abs(e - t) <= n;
+}
+function u(e, t) {
+	return Math.abs(e) <= Math.abs(t) * s;
+}
+function re(e, t, r = a) {
+	return n(e, t) <= r;
+}
+function ie(e, t) {
+	return n(e, t) <= c;
+}
+function ae(e) {
+	return e >= -1e-12 && e <= 1.000000000001;
+}
+function oe(e, t, n) {
+	return Math.abs(e - t) <= n + l;
+}
+function se(e, t) {
+	return e <= t + l;
+}
+function ce(e, t) {
+	return e / t;
+}
+//#endregion
+//#region src/geometry/distance.ts
+function d(e, t, r) {
+	let i = r.x - t.x, a = r.y - t.y, o = Math.hypot(i, a);
+	if (o === 0 || u(o, n(e, t))) return null;
+	let s = i / o, c = a / o;
+	return ((e.x - t.x) * s + (e.y - t.y) * c) / o;
+}
+function f(e, t, n) {
+	return {
+		x: e.x + (t.x - e.x) * n,
+		y: e.y + (t.y - e.y) * n
+	};
+}
+function p(e, t, n) {
+	let r = d(e, t, n);
+	return r === null ? t : f(t, n, r);
+}
+function m(e, t, n) {
+	let r = d(e, t, n);
+	return r === null ? t : f(t, n, Math.min(1, Math.max(0, r)));
+}
+function h(e, t, r) {
+	return n(e, p(e, t, r));
+}
+function g(e, t, r) {
+	return n(e, m(e, t, r));
+}
+function _(e, t, r) {
+	return Math.abs(n(e, t) - r);
+}
+function v(e, t, n) {
+	let r = e.x - t.x, i = e.y - t.y, a = Math.hypot(r, i);
+	return a === 0 || u(a, n) ? null : {
+		x: t.x + r / a * n,
+		y: t.y + i / a * n
+	};
+}
+//#endregion
+//#region src/geometry/entities/circle.ts
+var le = {
+	kind: "circle",
+	parents: (e) => e.parents,
+	resolve: (e, [t, r]) => {
+		if (t?.kind !== "point" || r?.kind !== "point") return null;
+		let i = n(t.at, r.at);
+		return i === 0 ? null : {
+			kind: "circle",
+			center: t.at,
+			radius: i
+		};
+	},
+	toShape: (e) => ({
+		shape: "circle",
+		center: e.center,
+		radius: e.radius
+	}),
+	toMeasured: (e) => ({
+		type: "circle",
+		center: e.center,
+		radius: e.radius
+	}),
+	distanceTo: (e, t) => _(t, e.center, e.radius),
+	describe: (e, t) => `circle centred on ${t(e.parents[0])} through ${t(e.parents[1])}`,
+	hitPriority: 1,
+	identityKey: (e) => `circle:${e.parents.join(":")}`
+}, ue = {
+	kind: "line",
+	parents: (e) => e.parents,
+	resolve: (e, [t, n]) => t?.kind !== "point" || n?.kind !== "point" ? null : {
+		kind: "line",
+		through: [t.at, n.at]
+	},
+	toShape: (e) => ({
+		shape: "line",
+		through: e.through
+	}),
+	toMeasured: (e) => ({
+		type: "line",
+		from: e.through[0],
+		to: e.through[1]
+	}),
+	distanceTo: (e, t) => h(t, e.through[0], e.through[1]),
+	describe: (e, t) => `line through ${t(e.parents[0])} and ${t(e.parents[1])}`,
+	hitPriority: 2,
+	identityKey: (e) => `line:${[...e.parents].sort().join(":")}`
+}, de = Object.freeze({
+	origin: Object.freeze({ scrCoords: Object.freeze([
+		1,
+		0,
+		0
+	]) }),
+	unitX: 1,
+	unitY: 1
+}), fe = e.default ?? e, y = fe.Math.Geometry, b = fe.Math;
+function x(e) {
+	return [
+		1,
+		e.x,
+		e.y
+	];
+}
+function pe(e, t) {
+	let [n, r, i] = b.crossProduct(x(e), x(t));
+	return b.normalize([
+		n ?? 0,
+		r ?? 0,
+		i ?? 0,
+		0,
+		1,
+		0,
+		0,
+		0
+	]);
+}
+function S(e) {
+	return b.normalize([
+		0,
+		-e.center.x,
+		-e.center.y,
+		.5,
+		e.radius,
+		0,
+		0,
+		0
+	]);
+}
+function C(e) {
+	let [t, n, r] = e.usrCoords;
+	return {
+		w: t ?? NaN,
+		x: n ?? NaN,
+		y: r ?? NaN
+	};
+}
+function me(e, t, n, r) {
+	let [i, a, o] = y.meetSegmentSegment(x(e), x(t), x(n), x(r));
+	return {
+		point: C({ usrCoords: i }),
+		t: a,
+		u: o
+	};
+}
+function he(e, t, n) {
+	return C(y.meetLineCircle(pe(e.from, e.to), S(t), n, de));
+}
+function w(e, t, n) {
+	return C(y.meetCircleCircle(S(e), S(t), n, de));
+}
+//#endregion
+//#region src/measure/geometryAdapter.ts
+function T(e, t) {
+	return re(e, t);
+}
+function E(e, t) {
+	return n(e, t) === 0 ? NaN : Math.atan2(t.y - e.y, t.x - e.x);
+}
+function ge(e, t, n, r) {
+	let i = ((E(e, t) - E(n, r)) * 180 / Math.PI % 180 + 180) % 180;
+	return Math.min(i, 180 - i);
+}
+function D(e, t) {
+	return e.type === "line" || ae(t);
+}
+function _e(e) {
+	return e.type === "segment" ? {
+		type: "line",
+		from: e.from,
+		to: e.to
+	} : e;
+}
+function O(e) {
+	let { w: t, x: n, y: r } = e;
+	return !Number.isFinite(t) || !Number.isFinite(n) || !Number.isFinite(r) || u(t, 1) ? null : {
+		x: k(n / t),
+		y: k(r / t)
+	};
+}
+function k(e) {
+	return e === 0 ? 0 : e;
+}
+function A(e) {
+	let t = [];
+	for (let n of e) n && (t.some((e) => T(e, n)) || t.push(n));
+	return t.sort((e, t) => e.x - t.x || e.y - t.y);
+}
+function j(e, t) {
+	let n = {
+		from: e.from,
+		to: e.to
+	}, r = {
+		center: t.center,
+		radius: t.radius
+	}, i = A([O(he(n, r, 0)), O(he(n, r, 1))]);
+	return e.type === "line" ? i : i.filter((t) => {
+		let n = d(t, e.from, e.to);
+		return n !== null && D(e, n);
+	});
+}
+function ve(e, t) {
+	return T(e.center, t.center) ? [] : A([O(w(e, t, 0)), O(w(e, t, 1))]);
+}
+function ye(e, t) {
+	let { point: n, t: r, u: i } = me(e.from, e.to, t.from, t.to);
+	if (!Number.isFinite(r) || !Number.isFinite(i)) return [];
+	let a = O(n);
+	return !a || !D(e, r) || !D(t, i) ? [] : [a];
+}
+function M(e, t) {
+	return e.type === "circle" ? t.type === "circle" ? ve(e, t) : j(t, e) : t.type === "circle" ? j(e, t) : ye(e, t);
+}
+//#endregion
+//#region src/geometry/entities/relations.ts
+var N = (e) => ({
+	type: "segment",
+	from: e.from,
+	to: e.to
+}), P = (e) => ({
+	type: "line",
+	from: e.through[0],
+	to: e.through[1]
+}), F = (e) => ({
+	type: "circle",
+	center: e.center,
+	radius: e.radius
+});
+function I(e, t, n) {
+	return M(e, t)[n] ?? null;
+}
+var L = () => null, be = {
+	"point:point": L,
+	"point:segment": L,
+	"point:line": L,
+	"segment:point": L,
+	"line:point": L,
+	"point:circle": L,
+	"circle:point": L,
+	"segment:segment": ([e, t], n) => I(N(e), N(t), n),
+	"segment:line": ([e, t], n) => I(N(e), P(t), n),
+	"line:segment": ([e, t], n) => I(P(e), N(t), n),
+	"line:line": ([e, t], n) => I(P(e), P(t), n),
+	"segment:circle": ([e, t], n) => I(N(e), F(t), n),
+	"circle:segment": ([e, t], n) => I(F(e), N(t), n),
+	"line:circle": ([e, t], n) => I(P(e), F(t), n),
+	"circle:line": ([e, t], n) => I(F(e), P(t), n),
+	"circle:circle": ([e, t], n) => I(F(e), F(t), n)
+};
+function xe(e, t, n = 0) {
+	let r = be[`${e.kind}:${t.kind}`];
+	return r([e, t], n);
+}
+var Se = {
+	point: () => null,
+	segment: (e, t) => f(e.from, e.to, t),
+	line: (e, t) => f(e.through[0], e.through[1], t),
+	circle: (e, t) => ({
+		x: e.center.x + e.radius * Math.cos(2 * Math.PI * t),
+		y: e.center.y + e.radius * Math.sin(2 * Math.PI * t)
+	})
+};
+function R(e, t) {
+	let n = Se[e.kind];
+	return n(e, t);
+}
+var Ce = {
+	point: () => null,
+	segment: (e, t) => {
+		let n = d(t, e.from, e.to);
+		return n === null ? null : Math.min(1, Math.max(0, n));
+	},
+	line: (e, t) => d(t, e.through[0], e.through[1]),
+	circle: (e, t) => {
+		let n = v(t, e.center, e.radius);
+		if (!n) return null;
+		let r = Math.atan2(n.y - e.center.y, n.x - e.center.x) / (2 * Math.PI);
+		return r < 0 ? r + 1 : r;
+	}
+};
+function we(e, t) {
+	let n = Ce[e.kind];
+	return n(e, t);
+}
+//#endregion
+//#region src/geometry/entities/point.ts
+var Te = Object.freeze([]);
+function z(e) {
+	return String(Number(e.toFixed(2)));
+}
+//#endregion
+//#region src/geometry/entities/index.ts
+var B = Object.freeze({
+	point: {
+		kind: "point",
+		parents: (e) => "at" in e ? Te : "on" in e ? [e.on] : e.intersectionOf,
+		resolve: (e, t) => {
+			if ("at" in e) return {
+				kind: "point",
+				at: e.at
+			};
+			if ("on" in e) {
+				let n = t[0];
+				if (!n) return null;
+				let r = R(n, e.t);
+				return r ? {
+					kind: "point",
+					at: r
+				} : null;
+			}
+			let [n, r] = t;
+			if (!n || !r) return null;
+			let i = xe(n, r, e.which ?? 0);
+			return i ? {
+				kind: "point",
+				at: i
+			} : null;
+		},
+		toShape: (e) => ({
+			shape: "point",
+			at: e.at
+		}),
+		toMeasured: () => null,
+		distanceTo: (e, t) => n(t, e.at),
+		describe: (e, t) => {
+			if ("at" in e) return `point at (${z(e.at.x)}, ${z(e.at.y)})`;
+			if ("on" in e) return `point on ${t(e.on)}`;
+			let [n, r] = e.intersectionOf;
+			return `point where ${t(n)} and ${t(r)} meet`;
+		},
+		hitPriority: 0,
+		identityKey: (e) => "at" in e ? `point:at:${e.at.x}:${e.at.y}` : "on" in e ? `point:on:${e.on}:${e.t}` : `point:meet:${e.intersectionOf.join(":")}:${e.which ?? 0}`
+	},
+	segment: {
+		kind: "segment",
+		parents: (e) => e.parents,
+		resolve: (e, [t, n]) => t?.kind !== "point" || n?.kind !== "point" ? null : {
+			kind: "segment",
+			from: t.at,
+			to: n.at
+		},
+		toShape: (e) => ({
+			shape: "segment",
+			from: e.from,
+			to: e.to
+		}),
+		toMeasured: (e) => ({
+			type: "segment",
+			from: e.from,
+			to: e.to
+		}),
+		distanceTo: (e, t) => g(t, e.from, e.to),
+		describe: (e, t) => `segment from ${t(e.parents[0])} to ${t(e.parents[1])}`,
+		hitPriority: 1,
+		identityKey: (e) => `segment:${[...e.parents].sort().join(":")}`
+	},
+	line: ue,
+	circle: le
+}), Ee = Object.freeze(Object.keys(B)), De = Object.freeze(Ee.filter((e) => e !== "point"));
+function V(e) {
+	return B[e];
+}
+function H(e) {
+	return V(e.kind).parents(e);
+}
+function Oe(e, t) {
+	return V(e.kind).resolve(e, t);
+}
+function ke(e, t) {
+	let n = [];
+	for (let r of H(e)) {
+		let e = t.get(r);
+		if (!e) return null;
+		n.push({
+			kind: "point",
+			at: e
+		});
+	}
+	return Oe(e, n);
+}
+function Ae(e) {
+	return V(e.kind).toShape(e);
+}
+function je(e) {
+	return V(e.kind).toMeasured(e);
+}
+function Me(e, t) {
+	return V(e.kind).distanceTo(e, t);
+}
+function Ne(e) {
+	return V(e).hitPriority;
+}
+function Pe(e) {
+	return V(e.kind).identityKey(e);
+}
+function Fe(e, t) {
+	return V(e.kind).describe(e, t);
+}
+//#endregion
+//#region src/geometry/entityRecord.ts
+var U = "__proto__";
+function Ie(e) {
+	return e === U;
+}
+function Le(e) {
+	return `${e} cannot be used as an entity id`;
+}
+function W(e, t) {
+	return Object.prototype.hasOwnProperty.call(e, t) ? e[t] : void 0;
+}
+function G() {
+	return Object.create(null);
+}
+//#endregion
+//#region src/schemas/identifier.schema.ts
+var K = t.string().min(1).refine((e) => e === e.trim(), { message: "id must not have leading or trailing spaces" });
+//#endregion
+//#region src/schemas/entityDocument.ts
+function q(e) {
+	return t.preprocess((e, n) => typeof e == "object" && e && Object.prototype.hasOwnProperty.call(e, "__proto__") ? (n.addIssue({
+		code: "custom",
+		path: [U],
+		message: Le(U)
+	}), t.NEVER) : e, t.record(K, e));
+}
+function Re(e, t, n, r) {
+	return t.kind === "point" ? r.kind === "point" ? "on" in t ? `${e} is on ${n}, which is a point` : `${e} intersects ${n}, which is a point` : null : r.kind === "point" ? null : `${e} references ${n}, which is a ${r.kind} and not a point`;
+}
+function ze(e, t) {
+	let n = [], r = Object.entries(e.entities), i = (t) => Object.prototype.hasOwnProperty.call(e.entities, t), a = /* @__PURE__ */ new Map();
+	for (let [i, o] of r) {
+		let r = H(o), s = ["entities", i];
+		r.includes(i) && n.push({
+			path: s,
+			message: `${i} is its own parent`
+		}), new Set(r).size !== r.length && n.push({
+			path: s,
+			message: `${i} must reference two distinct entities`
+		});
+		for (let a of r) {
+			let r = W(e.entities, a);
+			if (!r) {
+				t.parentsMustBeDeclared && n.push({
+					path: s,
+					message: `${i} references missing entity ${a}`
+				});
+				continue;
+			}
+			let c = Re(i, o, a, r);
+			c && n.push({
+				path: s,
+				message: c
+			}), "on" in o && r.kind === "segment" && (o.t < 0 || o.t > 1) && n.push({
+				path: [...s, "t"],
+				message: `${i} must have t within [0, 1] on segment ${a}`
+			});
+		}
+		if (o.kind === "point") continue;
+		let c = Pe(o), l = a.get(c);
+		l === void 0 ? a.set(c, i) : n.push({
+			path: s,
+			message: `${i} duplicates the geometry of ${l}`
+		});
+	}
+	for (let t of Object.keys(e.presentation)) i(t) || n.push({
+		path: ["presentation", t],
+		message: `presentation entry for unknown entity ${t}`
+	});
+	return n;
+}
+function Be(e, t) {
+	let n = [];
+	for (let [r, i] of Object.entries(e.entities)) {
+		let a = ["entities", r], o = W(t, r) !== void 0;
+		for (let s of H(i)) {
+			if (Object.prototype.hasOwnProperty.call(e.entities, s)) {
+				o && !W(t, s) && n.push({
+					path: a,
+					message: `${r} is declared by the exercise and cannot be defined on ${s}, which it does not declare`
+				});
+				continue;
+			}
+			let c = W(t, s);
+			if (!c) {
+				n.push({
+					path: a,
+					message: `${r} references missing entity ${s}`
+				});
+				continue;
+			}
+			let l = Re(r, i, s, c);
+			l && n.push({
+				path: a,
+				message: l
+			}), "on" in i && c.kind === "segment" && (i.t < 0 || i.t > 1) && n.push({
+				path: [...a, "t"],
+				message: `${r} must have t within [0, 1] on segment ${s}`
+			});
+		}
+	}
+	return n;
+}
+function Ve(e, t) {
+	return e.kind !== "point" || t.kind !== "point";
+}
+function He(e, t) {
+	let n = [];
+	for (let [r, i] of Object.entries(e.entities)) {
+		let e = W(t, r);
+		!e || !Ve(e, i) || n.push({
+			path: ["entities", r],
+			message: `${r} is already declared by the exercise as a ${e.kind}`
+		});
+	}
+	return n;
+}
+function Ue(e, t, n, r = {}) {
+	let i = [], a = /* @__PURE__ */ new Set();
+	return e.forEach((e, o) => {
+		let s = [t, o], c = W(n.entities, e);
+		c ? r.pointsOnly && c.kind !== "point" && i.push({
+			path: s,
+			message: `${t} names ${e}, which is a ${c.kind}`
+		}) : i.push({
+			path: s,
+			message: `${t} names unknown entity ${e}`
+		}), a.has(e) && i.push({
+			path: s,
+			message: `duplicate ${t} entry: ${e}`
+		}), a.add(e);
+	}), i;
+}
+//#endregion
+//#region src/schemas/objectTypeName.schema.ts
+var J = t.enum([
+	"point",
+	"segment",
+	"line",
+	"circle"
+]), We = t.object({
+	id: K,
+	type: t.literal("create"),
+	objectType: J
+}).strict(), Ge = t.object({
+	id: K,
+	type: t.literal("midpoint"),
+	objectType: t.literal("point"),
+	referenceObjectId: K,
+	toleranceUnits: t.number().positive().finite()
+}).strict(), Ke = t.object({
+	id: K,
+	type: t.literal("parallel"),
+	objectType: J,
+	referenceObjectId: K,
+	throughPointId: K,
+	toleranceDegrees: t.number().positive().max(90)
+}).strict(), qe = t.object({
+	id: K,
+	type: t.literal("perpendicular"),
+	objectType: J,
+	referenceObjectId: K,
+	throughPointId: K,
+	toleranceDegrees: t.number().positive().max(90)
+}).strict(), Je = t.object({
+	id: K,
+	type: t.literal("segmentLength"),
+	objectType: t.literal("segment"),
+	targetLength: t.number().positive().finite(),
+	toleranceUnits: t.number().positive().finite()
+}).strict(), Ye = t.object({
+	id: K,
+	type: t.literal("throughPoints"),
+	objectType: J,
+	pointIds: t.array(K).min(1)
+}).strict();
+//#endregion
+//#region src/schemas/goals/goalKindDeclaration.ts
+function Y(e) {
+	return e === "segment" || e === "line";
+}
+var Xe = () => [], Ze = () => [];
+function Qe(e, t, n) {
+	let r = [];
+	Y(e.objectType) || r.push({
+		path: ["objectType"],
+		message: `${e.type} requires segment or line`
+	});
+	let i = t.definitionOf(e.referenceObjectId);
+	return i ? Y(i.kind) || r.push({
+		path: ["referenceObjectId"],
+		message: `${e.type} requires a segment or line reference, got ${i.kind} ${e.referenceObjectId}`
+	}) : r.push({
+		path: ["referenceObjectId"],
+		message: `unknown reference object ${e.referenceObjectId}`
+	}), t.definitionOf(e.throughPointId)?.kind !== "point" && r.push({
+		path: ["throughPointId"],
+		message: `unknown point ${e.throughPointId}`
+	}), n(i) && r.push({
+		path: ["throughPointId"],
+		message: `parallel through ${e.throughPointId} is degenerate: it defines ${e.referenceObjectId}`
+	}), r;
+}
+var $e = Object.freeze({
+	create: {
+		kind: "create",
+		schema: We,
+		referencedGivenIds: Xe,
+		crossReferenceIssues: Ze
+	},
+	throughPoints: {
+		kind: "throughPoints",
+		schema: Ye,
+		referencedGivenIds: (e) => e.pointIds,
+		crossReferenceIssues(e, t) {
+			let n = [];
+			Y(e.objectType) || n.push({
+				path: ["objectType"],
+				message: "throughPoints requires segment or line"
+			}), (e.pointIds.length !== 2 || new Set(e.pointIds).size !== 2) && n.push({
+				path: ["pointIds"],
+				message: "throughPoints requires two distinct points"
+			});
+			for (let r of e.pointIds) t.definitionOf(r)?.kind !== "point" && n.push({
+				path: ["pointIds"],
+				message: `unknown point ${r}`
+			});
+			return n;
+		}
+	},
+	perpendicular: {
+		kind: "perpendicular",
+		schema: qe,
+		referencedGivenIds: (e) => [e.throughPointId, e.referenceObjectId],
+		crossReferenceIssues: (e, t) => Qe(e, t, () => !1)
+	},
+	parallel: {
+		kind: "parallel",
+		schema: Ke,
+		referencedGivenIds: (e) => [e.throughPointId, e.referenceObjectId],
+		crossReferenceIssues: (e, t) => Qe(e, t, (t) => t !== void 0 && Y(t.kind) && H(t).includes(e.throughPointId))
+	},
+	segmentLength: {
+		kind: "segmentLength",
+		schema: Je,
+		referencedGivenIds: Xe,
+		crossReferenceIssues: Ze
+	},
+	midpoint: {
+		kind: "midpoint",
+		schema: Ge,
+		referencedGivenIds: (e) => [e.referenceObjectId],
+		crossReferenceIssues(e, t) {
+			let n = t.definitionOf(e.referenceObjectId);
+			return !n || n.kind !== "segment" ? [{
+				path: ["referenceObjectId"],
+				message: `midpoint requires a given segment, got ${e.referenceObjectId}`
+			}] : [];
+		}
+	}
+});
+function et(e) {
+	return $e[e.type];
+}
+//#endregion
+//#region src/schemas/exerciseProjection.ts
+function tt(e) {
+	if (!("solution" in e)) return e;
+	let t = { ...e };
+	return delete t.solution, t;
+}
+//#endregion
+//#region src/schemas/point.schema.ts
+var nt = t.object({
+	x: t.number().finite(),
+	y: t.number().finite()
+}).strict();
+t.object({
+	id: K,
+	type: t.literal("point"),
+	x: t.number().finite(),
+	y: t.number().finite(),
+	label: t.string().min(1).optional(),
+	draggable: t.boolean().optional()
+}).strict();
+//#endregion
+//#region src/schemas/entityDefinition.schema.ts
+var rt = t.object({
+	kind: t.literal("point"),
+	at: nt
+}).strict(), it = t.object({
+	kind: t.literal("point"),
+	on: K,
+	t: t.number().finite()
+}).strict(), at = t.object({
+	kind: t.literal("point"),
+	intersectionOf: t.tuple([K, K]).readonly(),
+	which: t.union([t.literal(0), t.literal(1)]).optional()
+}).strict(), ot = t.union([
+	rt,
+	it,
+	at
+]), X = t.tuple([K, K]).readonly(), st = t.object({
+	kind: t.literal("segment"),
+	parents: X
+}).strict(), ct = t.object({
+	kind: t.literal("line"),
+	parents: X
+}).strict(), lt = t.object({
+	kind: t.literal("circle"),
+	parents: X
+}).strict(), ut = t.union([
+	ot,
+	st,
+	ct,
+	lt
+]), dt = t.enum(["implicit", "explicit"]), ft = t.object({
+	role: dt,
+	label: t.string().min(1).optional()
+}).strict();
+//#endregion
+//#region src/schemas/migrate.ts
+function pt(e) {
+	let t = e.schemaVersion;
+	return typeof t == "number" && Number.isInteger(t) ? t : null;
+}
+function Z(e, t, n) {
+	if (typeof e != "object" || !e || Array.isArray(e)) return {
+		success: !1,
+		message: "expected an object"
+	};
+	let r = { ...e }, i = pt(r);
+	if (i === null) return {
+		success: !1,
+		message: "missing or invalid schemaVersion"
+	};
+	if (i > n) return {
+		success: !1,
+		message: `schemaVersion ${i} is newer than the supported version ${n}`
+	};
+	let a = i;
+	for (; a < n;) {
+		let e = t.find((e) => e.from === a);
+		if (!e) return {
+			success: !1,
+			message: `no migration from schemaVersion ${a} to ${n}`
+		};
+		if (e.to <= a) return {
+			success: !1,
+			message: `migration from ${a} does not advance the version`
+		};
+		try {
+			r = {
+				...e.migrate(r),
+				schemaVersion: e.to
+			};
+		} catch (t) {
+			return {
+				success: !1,
+				message: `migration from ${a} to ${e.to} failed: ${t instanceof Error ? t.message : String(t)}`
+			};
+		}
+		a = e.to;
+	}
+	return {
+		success: !0,
+		data: r
+	};
+}
+//#endregion
+//#region src/geometry/pointOrigin.ts
+function mt(e) {
+	return "x" in e;
+}
+function ht(e) {
+	return "onObject" in e;
+}
+//#endregion
+//#region src/geometry/v1Bridge.ts
+var gt = {
+	segment: (e) => ({
+		kind: "segment",
+		parents: [e.from, e.to]
+	}),
+	line: (e) => ({
+		kind: "line",
+		parents: e.through
+	}),
+	circle: (e) => ({
+		kind: "circle",
+		parents: [e.center, e.through]
+	})
+};
+function _t(e) {
+	let t = gt[e.type];
+	return t(e);
+}
+function vt(e) {
+	return mt(e) ? {
+		kind: "point",
+		at: e
+	} : ht(e) ? {
+		kind: "point",
+		on: e.onObject,
+		t: e.t
+	} : {
+		kind: "point",
+		intersectionOf: e.intersectionOf
+	};
+}
+function yt(e) {
+	return e.type === "point" ? {
+		kind: "point",
+		at: {
+			x: e.x,
+			y: e.y
+		}
+	} : _t(e);
+}
+function Q(e, t) {
+	if (typeof e != "object" || !e || Array.isArray(e)) throw Error(`${t} is not an object`);
+	return e;
+}
+function $(e, t) {
+	let n = e[t];
+	if (!Array.isArray(n)) throw Error(`${t} is not an array`);
+	return n;
+}
+function bt(e, t) {
+	let n = e.id;
+	if (typeof n != "string") throw Error(`${t}.id is not a string`);
+	return xt(n, `${t}.id`), n;
+}
+function xt(e, t) {
+	if (Ie(e)) throw Error(`${t}: ${Le(e)}`);
+}
+function St(e, t, n, r) {
+	if (e.has(t)) throw Error(`${n}.id duplicates ${r}`);
+	e.add(t);
+}
+var Ct = [
+	"segment",
+	"line",
+	"circle"
+];
+function wt(e, t) {
+	let n = e.type;
+	if (typeof n != "string" || !Ct.includes(n)) throw Error(`${t} has unknown type ${JSON.stringify(n)}`);
+	return _t(e);
+}
+function Tt(e, t) {
+	let n = Q(t, `points.${e}`);
+	if (!("x" in n) && !("onObject" in n) && !("intersectionOf" in n)) throw Error(`points.${e} is not a free, on-object or intersection origin`);
+	return vt(n);
+}
+var Et = {
+	from: 1,
+	to: 2,
+	migrate: (e) => {
+		let t = Q(e.points, "points"), n = $(e, "constructions"), r = G(), i = G(), a = [...$(e, "constructedPointIds")], o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Set();
+		for (let [e, n] of Object.entries(t)) xt(e, `points.${e}`), r[e] = Tt(e, n), i[e] = { role: "explicit" }, s.add(e), o.set(e, `points.${e}`);
+		return n.forEach((e, t) => {
+			let n = `constructions[${t}]`, c = Q(e, n), l = bt(c, n);
+			St(s, l, n, o.get(l) ?? n), o.set(l, n), r[l] = wt(c, n), i[l] = { role: "explicit" }, a.push(l);
+		}), {
+			schemaVersion: 2,
+			entities: r,
+			presentation: i,
+			answerEntityIds: a
+		};
+	}
+}, Dt = {
+	from: 1,
+	to: 2,
+	migrate: (e) => {
+		let t = $(e, "givens"), n = G(), r = G(), i = [], a = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Map();
+		t.forEach((e, t) => {
+			let s = `givens[${t}]`, c = Q(e, s), l = bt(c, s);
+			if (St(a, l, s, o.get(l) ?? s), o.set(l, s), n[l] = c.type === "point" ? yt(c) : wt(c, s), c.label !== void 0 && (r[l] = {
+				role: "explicit",
+				label: c.label
+			}), c.draggable !== void 0) {
+				if (typeof c.draggable != "boolean") throw Error(`${s}.draggable is not a boolean`);
+				c.draggable && i.push(l);
+			}
+		});
+		let s = { ...e };
+		return delete s.givens, {
+			...s,
+			schemaVersion: 2,
+			entities: n,
+			presentation: r,
+			draggableEntityIds: i
+		};
+	}
+}, Ot = 2, kt = [Et], At = t.object({
+	schemaVersion: t.literal(2),
+	entities: q(ut),
+	presentation: q(ft),
+	answerEntityIds: t.array(K)
+}).strict().superRefine((e, t) => {
+	for (let n of ze(e, { parentsMustBeDeclared: !1 })) t.addIssue({
+		code: "custom",
+		path: n.path,
+		message: n.message
+	});
+	for (let n of Ue(e.answerEntityIds, "answerEntityIds", e)) t.addIssue({
+		code: "custom",
+		path: n.path,
+		message: n.message
+	});
+});
+function jt(e) {
+	return Z(e, kt, 2);
+}
+//#endregion
+export { i as $, Me as A, R as B, ze as C, K as D, Ve as E, H as F, v as G, ge as H, ke as I, _ as J, p as K, Oe as L, Pe as M, je as N, W as O, De as P, d as Q, Ae as R, Be as S, q as T, T as U, M as V, _e as W, g as X, h as Y, f as Z, Ke as _, Dt as a, c as at, J as b, ut as c, re as ct, et as d, ae as dt, te as et, $e as f, ce as ft, qe as g, r as gt, Je as h, n as ht, jt as i, ee as it, Ne as j, Fe as k, nt as l, u as lt, Ye as m, oe as mt, At as n, l as nt, Z as o, s as ot, Y as p, se as pt, m as q, Ot as r, o as rt, ft as s, ne as st, kt as t, a as tt, tt as u, ie as ut, Ge as v, Ue as w, He as x, We as y, we as z };
+
+//# sourceMappingURL=geometryState.schema-D0ixyGYE.js.map