@mathscan/geometry-engine 0.1.0 → 0.1.1

package/dist/geometryState.schema-CKFPlX8j.js

@@ -0,0 +1,1177 @@
+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 d(e, t, r = a) {
+	return n(e, t) <= r;
+}
+function re(e, t) {
+	return n(e, t) <= c;
+}
+function ie(e) {
+	return e >= -1e-12 && e <= 1.000000000001;
+}
+function ae(e, t, n) {
+	return Math.abs(e - t) <= n + l;
+}
+function oe(e, t) {
+	return e <= t + l;
+}
+function se(e, t) {
+	return e / t;
+}
+//#endregion
+//#region src/geometry/distance.ts
+function f(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 p(e, t, n) {
+	return {
+		x: e.x + (t.x - e.x) * n,
+		y: e.y + (t.y - e.y) * n
+	};
+}
+function ce(e, t, n) {
+	let r = f(e, t, n);
+	return r === null ? t : p(t, n, r);
+}
+function le(e, t, n) {
+	let r = f(e, t, n);
+	return r === null ? t : p(t, n, Math.min(1, Math.max(0, r)));
+}
+function ue(e, t, r) {
+	return n(e, ce(e, t, r));
+}
+function m(e, t, r) {
+	return n(e, le(e, t, r));
+}
+function h(e, t, r) {
+	return Math.abs(n(e, t) - r);
+}
+function g(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/measure/angleType.ts
+function de(e) {
+	let t = l;
+	return e <= t || e >= 360 - t ? null : Math.abs(e - 90) <= t ? "right" : Math.abs(e - 180) <= t ? "straight" : e < 90 ? "acute" : e < 180 ? "obtuse" : "reflex";
+}
+//#endregion
+//#region src/measure/kernel.ts
+var fe = Object.freeze({
+	origin: Object.freeze({ scrCoords: Object.freeze([
+		1,
+		0,
+		0
+	]) }),
+	unitX: 1,
+	unitY: 1
+}), pe = e.default ?? e, _ = pe.Math.Geometry, v = pe.Math;
+function y(e) {
+	return [
+		1,
+		e.x,
+		e.y
+	];
+}
+function me(e, t) {
+	let [n, r, i] = v.crossProduct(y(e), y(t));
+	return v.normalize([
+		n ?? 0,
+		r ?? 0,
+		i ?? 0,
+		0,
+		1,
+		0,
+		0,
+		0
+	]);
+}
+function b(e) {
+	return v.normalize([
+		0,
+		-e.center.x,
+		-e.center.y,
+		.5,
+		e.radius,
+		0,
+		0,
+		0
+	]);
+}
+function x(e) {
+	let [t, n, r] = e.usrCoords;
+	return {
+		w: t ?? NaN,
+		x: n ?? NaN,
+		y: r ?? NaN
+	};
+}
+function he(e, t, n, r) {
+	let [i, a, o] = _.meetSegmentSegment(y(e), y(t), y(n), y(r));
+	return {
+		point: x({ usrCoords: i }),
+		t: a,
+		u: o
+	};
+}
+function S(e, t, n) {
+	return x(_.meetLineCircle(me(e.from, e.to), b(t), n, fe));
+}
+function C(e, t, n) {
+	return x(_.meetCircleCircle(b(e), b(t), n, fe));
+}
+//#endregion
+//#region src/measure/geometryAdapter.ts
+function w(e, t) {
+	return d(e, t);
+}
+function T(e, t) {
+	return n(e, t) === 0 ? NaN : Math.atan2(t.y - e.y, t.x - e.x);
+}
+function E(e, t) {
+	return d(e, t) ? null : _e(Math.atan2(t.y - e.y, t.x - e.x) / (2 * Math.PI));
+}
+function ge(e, t) {
+	return _e(t - e);
+}
+function _e(e) {
+	let t = e % 1, n = t < 0 ? t + 1 : t;
+	return n >= 1 || n === 0 ? 0 : n;
+}
+function ve(e, t, n, r) {
+	let i = ((T(e, t) - T(n, r)) * 180 / Math.PI % 180 + 180) % 180;
+	return Math.min(i, 180 - i);
+}
+function ye(e, t) {
+	let n = ((e - t) % 360 + 360) % 360;
+	return Math.min(n, 360 - n);
+}
+function D(e, t) {
+	return e.type === "line" || ie(t);
+}
+function be(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: xe(n / t),
+		y: xe(r / t)
+	};
+}
+function xe(e) {
+	return e === 0 ? 0 : e;
+}
+function Se(e) {
+	let t = [];
+	for (let n of e) n && (t.some((e) => w(e, n)) || t.push(n));
+	return t.sort((e, t) => e.x - t.x || e.y - t.y);
+}
+function Ce(e, t) {
+	let n = {
+		from: e.from,
+		to: e.to
+	}, r = {
+		center: t.center,
+		radius: t.radius
+	}, i = Se([O(S(n, r, 0)), O(S(n, r, 1))]);
+	return e.type === "line" ? i : i.filter((t) => {
+		let n = f(t, e.from, e.to);
+		return n !== null && D(e, n);
+	});
+}
+function we(e, t) {
+	return w(e.center, t.center) ? [] : Se([O(C(e, t, 0)), O(C(e, t, 1))]);
+}
+function Te(e, t) {
+	let { point: n, t: r, u: i } = he(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 Ee(e, t) {
+	return e.type === "circle" ? t.type === "circle" ? we(e, t) : Ce(t, e) : t.type === "circle" ? Ce(e, t) : Te(e, t);
+}
+//#endregion
+//#region src/geometry/entities/angle.ts
+var De = .4, Oe = {
+	kind: "angle",
+	parents: (e) => e.parents,
+	resolve: (e, [t, r, i]) => {
+		if (t?.kind !== "point" || r?.kind !== "point" || i?.kind !== "point") return null;
+		let a = E(r.at, t.at), o = E(r.at, i.at);
+		if (a === null || o === null) return null;
+		let s = Math.min(n(r.at, t.at), n(r.at, i.at)) * De;
+		return {
+			kind: "angle",
+			vertex: r.at,
+			startTurn: a,
+			sweepTurn: ge(a, o),
+			markRadius: s
+		};
+	},
+	toShape: (e) => ({
+		shape: "angle",
+		vertex: e.vertex,
+		startTurn: e.startTurn,
+		sweepTurn: e.sweepTurn,
+		radius: e.markRadius
+	}),
+	toMeasured: () => null,
+	distanceTo: (e, t) => {
+		let n = ke(e);
+		if (!n) return Ae(e, t);
+		let [r, i, a] = n;
+		return Math.min(m(t, r, i), m(t, i, a));
+	},
+	describe: (e, t) => {
+		let [n, r, i] = e.parents;
+		return `angle at ${t(r)} from ${t(n)} to ${t(i)}`;
+	},
+	hitPriority: 1,
+	identityKey: (e) => `angle:${JSON.stringify(e.parents)}`
+};
+function ke(e) {
+	let { vertex: t, startTurn: n, sweepTurn: r, markRadius: i } = e;
+	if (de(r * 360) !== "right") return null;
+	let a = i * Math.SQRT1_2, o = k(t, n, a), s = k(t, n + r, a);
+	return [
+		o,
+		{
+			x: o.x + s.x - t.x,
+			y: o.y + s.y - t.y
+		},
+		s
+	];
+}
+function Ae(e, t) {
+	let { vertex: r, startTurn: i, sweepTurn: a, markRadius: o } = e, s = E(r, t);
+	return s === null ? o : ((s - i) % 1 + 1) % 1 <= a ? Math.abs(n(r, t) - o) : Math.min(n(t, k(r, i, o)), n(t, k(r, i + a, o)));
+}
+function k(e, t, n) {
+	return {
+		x: e.x + n * Math.cos(2 * Math.PI * t),
+		y: e.y + n * Math.sin(2 * Math.PI * t)
+	};
+}
+//#endregion
+//#region src/geometry/entities/circle.ts
+var je = {
+	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) => h(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:${JSON.stringify(e.parents)}`
+}, A = (e) => ({
+	type: "segment",
+	from: e.from,
+	to: e.to
+}), j = (e) => ({
+	type: "line",
+	from: e.through[0],
+	to: e.through[1]
+}), M = (e) => ({
+	type: "circle",
+	center: e.center,
+	radius: e.radius
+});
+function N(e, t, n) {
+	return Ee(e, t)[n] ?? null;
+}
+var P = () => null, Me = {
+	"point:point": P,
+	"point:segment": P,
+	"point:line": P,
+	"segment:point": P,
+	"line:point": P,
+	"point:circle": P,
+	"circle:point": P,
+	"point:angle": P,
+	"angle:point": P,
+	"segment:angle": P,
+	"angle:segment": P,
+	"line:angle": P,
+	"angle:line": P,
+	"circle:angle": P,
+	"angle:circle": P,
+	"angle:angle": P,
+	"segment:segment": ([e, t], n) => N(A(e), A(t), n),
+	"segment:line": ([e, t], n) => N(A(e), j(t), n),
+	"line:segment": ([e, t], n) => N(j(e), A(t), n),
+	"line:line": ([e, t], n) => N(j(e), j(t), n),
+	"segment:circle": ([e, t], n) => N(A(e), M(t), n),
+	"circle:segment": ([e, t], n) => N(M(e), A(t), n),
+	"line:circle": ([e, t], n) => N(j(e), M(t), n),
+	"circle:line": ([e, t], n) => N(M(e), j(t), n),
+	"circle:circle": ([e, t], n) => N(M(e), M(t), n)
+};
+function Ne(e, t, n = 0) {
+	let r = Me[`${e.kind}:${t.kind}`];
+	return r([e, t], n);
+}
+var F = () => null, I = {
+	point: F,
+	angle: F,
+	segment: (e, t) => p(e.from, e.to, t),
+	line: (e, t) => p(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 Pe(e) {
+	return I[e] !== F;
+}
+function L(e, t) {
+	let n = I[e.kind];
+	return n(e, t);
+}
+var Fe = {
+	point: () => null,
+	angle: () => null,
+	segment: (e, t) => {
+		let n = f(t, e.from, e.to);
+		return n === null ? null : Math.min(1, Math.max(0, n));
+	},
+	line: (e, t) => f(t, e.through[0], e.through[1]),
+	circle: (e, t) => {
+		let n = g(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 Ie(e, t) {
+	let n = Fe[e.kind];
+	return n(e, t);
+}
+//#endregion
+//#region src/geometry/entities/line.ts
+var Le = {
+	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) => ue(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:${JSON.stringify([...e.parents].sort())}`
+}, Re = Object.freeze([]);
+function R(e) {
+	return String(Number(e.toFixed(2)));
+}
+//#endregion
+//#region src/geometry/entities/index.ts
+var z = Object.freeze({
+	point: {
+		kind: "point",
+		parents: (e) => "at" in e ? Re : "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 = L(n, e.t);
+				return r ? {
+					kind: "point",
+					at: r
+				} : null;
+			}
+			let [n, r] = t;
+			if (!n || !r) return null;
+			let i = Ne(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 (${R(e.at.x)}, ${R(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:${JSON.stringify(e.intersectionOf)}:${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) => m(t, e.from, e.to),
+		describe: (e, t) => `segment from ${t(e.parents[0])} to ${t(e.parents[1])}`,
+		hitPriority: 1,
+		identityKey: (e) => `segment:${JSON.stringify([...e.parents].sort())}`
+	},
+	line: Le,
+	circle: je,
+	angle: Oe
+}), ze = Object.freeze(Object.keys(z)), Be = Object.freeze(ze.filter((e) => e !== "point" && Pe(e)));
+function B(e) {
+	return z[e];
+}
+function V(e) {
+	return B(e.kind).parents(e);
+}
+function Ve(e, t) {
+	return B(e.kind).resolve(e, t);
+}
+function He(e, t) {
+	let n = [];
+	for (let r of V(e)) {
+		let e = t.get(r);
+		if (!e) return null;
+		n.push({
+			kind: "point",
+			at: e
+		});
+	}
+	return Ve(e, n);
+}
+function Ue(e) {
+	return B(e.kind).toShape(e);
+}
+function We(e) {
+	return B(e.kind).toMeasured(e);
+}
+function Ge(e, t) {
+	return B(e.kind).distanceTo(e, t);
+}
+function Ke(e) {
+	return B(e).hitPriority;
+}
+function qe(e) {
+	return B(e.kind).identityKey(e);
+}
+function Je(e, t) {
+	return B(e.kind).describe(e, t);
+}
+//#endregion
+//#region src/geometry/entityRecord.ts
+var H = "__proto__";
+function Ye(e) {
+	return e === H;
+}
+function Xe(e) {
+	return `${e} cannot be used as an entity id`;
+}
+function U(e, t) {
+	return Object.prototype.hasOwnProperty.call(e, t) ? e[t] : void 0;
+}
+function W() {
+	return Object.create(null);
+}
+//#endregion
+//#region src/schemas/identifier.schema.ts
+var G = 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 K(e) {
+	return t.preprocess((e, n) => typeof e == "object" && e && Object.prototype.hasOwnProperty.call(e, "__proto__") ? (n.addIssue({
+		code: "custom",
+		path: [H],
+		message: Xe(H)
+	}), t.NEVER) : e, t.record(G, e));
+}
+function q(e) {
+	return e === "angle" ? `an ${e}` : `a ${e}`;
+}
+function Ze(e, t, n, r) {
+	return t.kind === "point" ? r.kind !== "point" && r.kind !== "angle" ? null : "on" in t ? `${e} is on ${n}, which is ${q(r.kind)}` : `${e} intersects ${n}, which is ${q(r.kind)}` : r.kind === "point" ? null : `${e} references ${n}, which is ${q(r.kind)} and not a point`;
+}
+function Qe(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 = V(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 distinct entities`
+		});
+		for (let a of r) {
+			let r = U(e.entities, a);
+			if (!r) {
+				t.parentsMustBeDeclared && n.push({
+					path: s,
+					message: `${i} references missing entity ${a}`
+				});
+				continue;
+			}
+			let c = Ze(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 = qe(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, r] of Object.entries(e.presentation)) {
+		if (!i(t)) {
+			n.push({
+				path: ["presentation", t],
+				message: `presentation entry for unknown entity ${t}`
+			});
+			continue;
+		}
+		r.measureLabel !== void 0 && U(e.entities, t)?.kind !== "angle" && n.push({
+			path: ["presentation", t],
+			message: `presentation entry for ${t} sets measureLabel, which only an angle has`
+		});
+	}
+	return n;
+}
+function $e(e, t) {
+	let n = [];
+	for (let [r, i] of Object.entries(e.entities)) {
+		let a = ["entities", r], o = U(t, r) !== void 0;
+		for (let s of V(i)) {
+			if (Object.prototype.hasOwnProperty.call(e.entities, s)) {
+				o && !U(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 = U(t, s);
+			if (!c) {
+				n.push({
+					path: a,
+					message: `${r} references missing entity ${s}`
+				});
+				continue;
+			}
+			let l = Ze(r, i, s, c);
+			l && n.push({
+				path: a,
+				message: l
+			}), !o && "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 et(e, t) {
+	let n = U(e.entities, t);
+	return n?.kind !== "point" || "intersectionOf" in n ? !1 : e.draggableEntityIds.includes(t);
+}
+function tt(e, t, n, r) {
+	return n.kind !== "point" || r.kind !== "point" ? "collision" : et(e, t) ? "at" in n ? "at" in r ? "override" : "collision" : !("on" in n) || !("on" in r) || r.on !== n.on || U(e.entities, n.on)?.kind === "segment" && !(r.t >= 0 && r.t <= 1) ? "collision" : "override" : "ignored";
+}
+function nt(e, t) {
+	let n = [];
+	for (let [r, i] of Object.entries(e.entities)) {
+		let e = U(t.entities, r);
+		e && tt(t, r, e, i) === "collision" && n.push({
+			path: ["entities", r],
+			message: e.kind === "point" && i.kind === "point" ? `${r} is a point the exercise declares, and an attempt may change only its position` : `${r} is already declared by the exercise as a ${e.kind}`
+		});
+	}
+	return n;
+}
+function rt(e, t, n, r = {}) {
+	let i = [], a = /* @__PURE__ */ new Set();
+	return e.forEach((e, o) => {
+		let s = [t, o], c = U(n.entities, e);
+		c ? r.pointsOnly && c.kind !== "point" && i.push({
+			path: s,
+			message: `${t} names ${e}, which is ${q(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",
+	"angle"
+]), it = t.object({
+	id: G,
+	type: t.literal("angleBisector"),
+	objectType: J,
+	referenceAngleId: G,
+	toleranceDegrees: t.number().positive().max(90)
+}).strict(), at = t.enum([
+	"acute",
+	"right",
+	"obtuse",
+	"straight",
+	"reflex"
+]), ot = t.discriminatedUnion("kind", [t.object({
+	kind: t.literal("degrees"),
+	targetDegrees: t.number().min(0).lt(360),
+	toleranceDegrees: t.number().positive().max(180)
+}).strict(), t.object({
+	kind: t.literal("type"),
+	angleType: at
+}).strict()]), st = t.object({
+	id: G,
+	type: t.literal("angleMeasure"),
+	objectType: t.literal("angle"),
+	vertexPointId: G,
+	interpretation: t.enum(["directed", "undirected"]),
+	criterion: ot
+}).strict(), ct = t.object({
+	id: G,
+	type: t.literal("create"),
+	objectType: J
+}).strict(), lt = t.object({
+	id: G,
+	type: t.literal("givenAngle"),
+	angleId: G,
+	interpretation: t.enum(["directed", "undirected"]),
+	criterion: ot
+}).strict(), ut = t.object({
+	id: G,
+	type: t.literal("midpoint"),
+	objectType: t.literal("point"),
+	referenceObjectId: G,
+	toleranceUnits: t.number().positive().finite()
+}).strict(), dt = t.object({
+	id: G,
+	type: t.literal("parallel"),
+	objectType: J,
+	referenceObjectId: G,
+	throughPointId: G,
+	toleranceDegrees: t.number().positive().max(90)
+}).strict(), ft = t.object({
+	id: G,
+	type: t.literal("perpendicular"),
+	objectType: J,
+	referenceObjectId: G,
+	throughPointId: G,
+	toleranceDegrees: t.number().positive().max(90)
+}).strict(), pt = t.object({
+	id: G,
+	type: t.literal("segmentLength"),
+	objectType: t.literal("segment"),
+	targetLength: t.number().positive().finite(),
+	toleranceUnits: t.number().positive().finite()
+}).strict(), mt = t.object({
+	id: G,
+	type: t.literal("throughPoints"),
+	objectType: J,
+	pointIds: t.array(G).min(1)
+}).strict();
+//#endregion
+//#region src/schemas/goals/goalKindDeclaration.ts
+function Y(e) {
+	return e === "segment" || e === "line";
+}
+var ht = () => [], gt = () => [];
+function _t(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;
+}
+function vt({ interpretation: e, criterion: t }) {
+	return e === "undirected" ? t.kind === "degrees" && t.targetDegrees > 180 ? [{
+		path: ["criterion", "targetDegrees"],
+		message: "an undirected angle cannot measure more than 180 degrees"
+	}] : t.kind === "type" && t.angleType === "reflex" ? [{
+		path: ["criterion", "angleType"],
+		message: "an undirected angle cannot be reflex"
+	}] : [] : [];
+}
+function yt(e, t) {
+	let n = /* @__PURE__ */ new Set([e]), r = [e];
+	for (; r.length > 0;) {
+		let i = r.pop();
+		if (i === void 0) continue;
+		if (i !== e && t.isStudentDraggable(i)) return !0;
+		let a = t.definitionOf(i);
+		if (a) for (let e of V(a)) n.has(e) || (n.add(e), r.push(e));
+	}
+	return !1;
+}
+var bt = Object.freeze({
+	create: {
+		kind: "create",
+		schema: ct,
+		referencedGivenIds: ht,
+		crossReferenceIssues(e) {
+			return e.objectType === "angle" ? [{
+				path: ["objectType"],
+				message: "create does not support angle; use angleMeasure"
+			}] : [];
+		}
+	},
+	throughPoints: {
+		kind: "throughPoints",
+		schema: mt,
+		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: ft,
+		referencedGivenIds: (e) => [e.throughPointId, e.referenceObjectId],
+		crossReferenceIssues: (e, t) => _t(e, t, () => !1)
+	},
+	parallel: {
+		kind: "parallel",
+		schema: dt,
+		referencedGivenIds: (e) => [e.throughPointId, e.referenceObjectId],
+		crossReferenceIssues: (e, t) => _t(e, t, (t) => t !== void 0 && Y(t.kind) && V(t).includes(e.throughPointId))
+	},
+	segmentLength: {
+		kind: "segmentLength",
+		schema: pt,
+		referencedGivenIds: ht,
+		crossReferenceIssues: gt
+	},
+	midpoint: {
+		kind: "midpoint",
+		schema: ut,
+		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}`
+			}] : [];
+		}
+	},
+	angleMeasure: {
+		kind: "angleMeasure",
+		schema: st,
+		referencedGivenIds: (e) => [e.vertexPointId],
+		crossReferenceIssues(e, t) {
+			let n = [];
+			return t.definitionOf(e.vertexPointId)?.kind !== "point" && n.push({
+				path: ["vertexPointId"],
+				message: `unknown point ${e.vertexPointId}`
+			}), n.push(...vt(e)), n;
+		}
+	},
+	angleBisector: {
+		kind: "angleBisector",
+		schema: it,
+		referencedGivenIds: (e) => [e.referenceAngleId],
+		crossReferenceIssues(e, t) {
+			let n = [];
+			return Y(e.objectType) || n.push({
+				path: ["objectType"],
+				message: "angleBisector requires segment or line"
+			}), t.definitionOf(e.referenceAngleId)?.kind !== "angle" && n.push({
+				path: ["referenceAngleId"],
+				message: `angleBisector requires a given angle, got ${e.referenceAngleId}`
+			}), n;
+		}
+	},
+	givenAngle: {
+		kind: "givenAngle",
+		schema: lt,
+		referencedGivenIds: (e) => [e.angleId],
+		crossReferenceIssues(e, t) {
+			let n = [];
+			return t.definitionOf(e.angleId)?.kind === "angle" ? yt(e.angleId, t) || n.push({
+				path: ["angleId"],
+				message: `goal ${e.id} grades ${e.angleId}, and nothing it is built on can be dragged`
+			}) : n.push({
+				path: ["angleId"],
+				message: `givenAngle requires a given angle, got ${e.angleId}`
+			}), n.push(...vt(e)), n;
+		}
+	}
+});
+function xt(e) {
+	return bt[e.type];
+}
+//#endregion
+//#region src/schemas/exerciseProjection.ts
+function St(e) {
+	if (!("solution" in e)) return e;
+	let t = { ...e };
+	return delete t.solution, t;
+}
+//#endregion
+//#region src/schemas/point.schema.ts
+var Ct = t.object({
+	x: t.number().finite(),
+	y: t.number().finite()
+}).strict();
+t.object({
+	id: G,
+	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 wt = t.object({
+	kind: t.literal("point"),
+	at: Ct
+}).strict(), Tt = t.object({
+	kind: t.literal("point"),
+	on: G,
+	t: t.number().finite()
+}).strict(), Et = t.object({
+	kind: t.literal("point"),
+	intersectionOf: t.tuple([G, G]).readonly(),
+	which: t.union([t.literal(0), t.literal(1)]).optional()
+}).strict(), Dt = t.union([
+	wt,
+	Tt,
+	Et
+]), X = t.tuple([G, G]).readonly(), Ot = t.tuple([
+	G,
+	G,
+	G
+]).readonly(), kt = t.object({
+	kind: t.literal("segment"),
+	parents: X
+}).strict(), At = t.object({
+	kind: t.literal("line"),
+	parents: X
+}).strict(), jt = t.object({
+	kind: t.literal("circle"),
+	parents: X
+}).strict(), Mt = t.object({
+	kind: t.literal("angle"),
+	parents: Ot
+}).strict(), Nt = t.union([
+	Dt,
+	kt,
+	At,
+	jt,
+	Mt
+]), Pt = t.enum(["implicit", "explicit"]), Z = t.object({
+	role: Pt,
+	label: t.string().min(1).optional(),
+	measureLabel: t.enum(["degrees"]).optional()
+}).strict();
+//#endregion
+//#region src/schemas/migrate.ts
+function Ft(e) {
+	let t = e.schemaVersion;
+	return typeof t == "number" && Number.isInteger(t) ? t : null;
+}
+function It(e, t, n) {
+	if (typeof e != "object" || !e || Array.isArray(e)) return {
+		success: !1,
+		message: "expected an object"
+	};
+	let r = { ...e }, i = Ft(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 Lt(e) {
+	return "x" in e;
+}
+function Rt(e) {
+	return "onObject" in e;
+}
+//#endregion
+//#region src/geometry/v1Bridge.ts
+var zt = {
+	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 Bt(e) {
+	let t = zt[e.type];
+	return t(e);
+}
+function Vt(e) {
+	return Lt(e) ? {
+		kind: "point",
+		at: e
+	} : Rt(e) ? {
+		kind: "point",
+		on: e.onObject,
+		t: e.t
+	} : {
+		kind: "point",
+		intersectionOf: e.intersectionOf
+	};
+}
+function Ht(e) {
+	return e.type === "point" ? {
+		kind: "point",
+		at: {
+			x: e.x,
+			y: e.y
+		}
+	} : Bt(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 Ut(e, t) {
+	let n = e.id;
+	if (typeof n != "string") throw Error(`${t}.id is not a string`);
+	return Wt(n, `${t}.id`), n;
+}
+function Wt(e, t) {
+	if (Ye(e)) throw Error(`${t}: ${Xe(e)}`);
+}
+function Gt(e, t, n, r) {
+	if (e.has(t)) throw Error(`${n}.id duplicates ${r}`);
+	e.add(t);
+}
+var Kt = [
+	"segment",
+	"line",
+	"circle"
+];
+function qt(e, t) {
+	let n = e.type;
+	if (typeof n != "string" || !Kt.includes(n)) throw Error(`${t} has unknown type ${JSON.stringify(n)}`);
+	return Bt(e);
+}
+function Jt(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 Yt = {
+	from: 1,
+	to: 2,
+	migrate: (e) => {
+		let t = Q(e.points, "points"), n = $(e, "constructions"), r = W(), i = W(), a = [...$(e, "constructedPointIds")], o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Set();
+		for (let [e, n] of Object.entries(t)) Wt(e, `points.${e}`), r[e] = Jt(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 = Ut(c, n);
+			Gt(s, l, n, o.get(l) ?? n), o.set(l, n), r[l] = qt(c, n), i[l] = { role: "explicit" }, a.push(l);
+		}), {
+			schemaVersion: 2,
+			entities: r,
+			presentation: i,
+			answerEntityIds: a
+		};
+	}
+}, Xt = {
+	from: 1,
+	to: 2,
+	migrate: (e) => {
+		let t = $(e, "givens"), n = W(), r = W(), i = [], a = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Map();
+		t.forEach((e, t) => {
+			let s = `givens[${t}]`, c = Q(e, s), l = Ut(c, s);
+			if (Gt(a, l, s, o.get(l) ?? s), o.set(l, s), n[l] = c.type === "point" ? Ht(c) : qt(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
+		};
+	}
+}, Zt = 2, Qt = [Yt], $t = t.object({
+	schemaVersion: t.literal(2),
+	entities: K(Nt),
+	presentation: K(Z),
+	answerEntityIds: t.array(G)
+}).strict().superRefine((e, t) => {
+	for (let n of Qe(e, { parentsMustBeDeclared: !1 })) t.addIssue({
+		code: "custom",
+		path: n.path,
+		message: n.message
+	});
+	for (let n of rt(e.answerEntityIds, "answerEntityIds", e)) t.addIssue({
+		code: "custom",
+		path: n.path,
+		message: n.message
+	});
+});
+function en(e) {
+	return It(e, Qt, 2);
+}
+//#endregion
+export { de as $, et as A, He as B, J as C, ae as Ct, Qe as D, $e as E, Ke as F, ke as G, Ue as H, qe as I, Ee as J, ye as K, We as L, U as M, Je as N, rt as O, Ge as P, be as Q, Be as R, it as S, oe as St, nt as T, r as Tt, Ie as U, Ve as V, L as W, w as X, ve as Y, ge as Z, dt as _, d as _t, Xt as a, m as at, ct as b, ie as bt, Nt as c, i as ct, xt as d, l as dt, g as et, bt as f, o as ft, ft as g, ne as gt, pt as h, s as ht, en as i, ue as it, G as j, K as k, Ct as l, te as lt, mt as m, c as mt, $t as n, le as nt, It as o, p as ot, Y as p, ee as pt, E as q, Zt as r, h as rt, Z as s, f as st, Qt as t, ce as tt, St as u, a as ut, ut as v, u as vt, tt as w, n as wt, st as x, se as xt, lt as y, re as yt, V as z };
+
+//# sourceMappingURL=geometryState.schema-CKFPlX8j.js.map