@pie-element/graphing-solution-set 6.1.1 → 6.1.2-next.0

package/dist/browser/author/index.js

@@ -0,0 +1,1942 @@
+import { V as e, d as t, i as n, t as r } from "../browser-DpedO01u.js";
+import { B as i, D as a, E as o, H as s, I as c, L as l, M as u, N as d, O as f, P as p, R as m, U as h, V as g, W as _, _ as v, a as y, b, c as x, d as S, f as C, g as w, h as T, i as E, j as D, m as O, n as k, o as A, p as j, r as M, s as N, t as P, u as F, v as I, x as L, y as ee, z as R } from "../dist-SjeWPldT.js";
+import * as z from "react";
+import B from "react";
+import { createRoot as te } from "react-dom/client";
+import { Fragment as ne, jsx as V, jsxs as H } from "react/jsx-runtime";
+//#region ../../../node_modules/.bun/@mui+material@7.3.11+eb26afe407ed7030/node_modules/@mui/material/esm/FormGroup/formGroupClasses.js
+function re(e) {
+	return g("MuiFormGroup", e);
+}
+i("MuiFormGroup", [
+	"root",
+	"row",
+	"error"
+]);
+//#endregion
+//#region ../../../node_modules/.bun/@mui+material@7.3.11+eb26afe407ed7030/node_modules/@mui/material/esm/FormGroup/FormGroup.js
+var ie = (e) => {
+	let { classes: t, row: n, error: r } = e;
+	return R({ root: [
+		"root",
+		n && "row",
+		r && "error"
+	] }, re, t);
+}, ae = m("div", {
+	name: "MuiFormGroup",
+	slot: "Root",
+	overridesResolver: (e, t) => {
+		let { ownerState: n } = e;
+		return [t.root, n.row && t.row];
+	}
+})({
+	display: "flex",
+	flexDirection: "column",
+	flexWrap: "wrap",
+	variants: [{
+		props: { row: !0 },
+		style: { flexDirection: "row" }
+	}]
+}), oe = /*#__PURE__*/ z.forwardRef(function(e, t) {
+	let n = p({
+		props: e,
+		name: "MuiFormGroup"
+	}), { className: r, row: i = !1, ...o } = n, c = f({
+		props: n,
+		muiFormControl: a(),
+		states: ["error"]
+	}), l = {
+		...n,
+		row: i,
+		error: c.error
+	};
+	return /*#__PURE__*/ V(ae, {
+		className: s(ie(l).root, r),
+		ownerState: l,
+		ref: t,
+		...o
+	});
+});
+//#endregion
+//#region ../../../node_modules/.bun/@mui+material@7.3.11+eb26afe407ed7030/node_modules/@mui/material/esm/RadioGroup/radioGroupClasses.js
+function se(e) {
+	return g("MuiRadioGroup", e);
+}
+i("MuiRadioGroup", [
+	"root",
+	"row",
+	"error"
+]);
+//#endregion
+//#region ../../../node_modules/.bun/@mui+material@7.3.11+eb26afe407ed7030/node_modules/@mui/material/esm/RadioGroup/RadioGroup.js
+var ce = (e) => {
+	let { classes: t, row: n, error: r } = e;
+	return R({ root: [
+		"root",
+		n && "row",
+		r && "error"
+	] }, se, t);
+}, le = /*#__PURE__*/ z.forwardRef(function(e, t) {
+	let { actions: n, children: r, className: i, defaultValue: a, name: o, onChange: c, value: l, ...f } = e, p = z.useRef(null), m = ce(e), [h, g] = D({
+		controlled: l,
+		default: a,
+		name: "RadioGroup"
+	});
+	z.useImperativeHandle(n, () => ({ focus: () => {
+		let e = p.current.querySelector("input:not(:disabled):checked");
+		e ||= p.current.querySelector("input:not(:disabled)"), e && e.focus();
+	} }), []);
+	let _ = d(t, p), v = u(o), y = z.useMemo(() => ({
+		name: v,
+		onChange(e) {
+			g(e.target.value), c && c(e, e.target.value);
+		},
+		value: h
+	}), [
+		v,
+		c,
+		g,
+		h
+	]);
+	return /*#__PURE__*/ V(S.Provider, {
+		value: y,
+		children: /*#__PURE__*/ V(oe, {
+			role: "radiogroup",
+			ref: _,
+			className: s(m.root, i),
+			...f,
+			children: r
+		})
+	});
+}), U = /* @__PURE__ */ e(h(), 1);
+function W(e) {
+	return typeof e == "function" || typeof e == "object" && !!e && typeof e.$$typeof == "symbol";
+}
+function ue(e, t) {
+	return !e || W(e) ? e : W(e.default) ? e.default : t && W(e[t]) ? e[t] : t && W(e[t]?.default) ? e[t].default : e;
+}
+var de = ue(o, "InputContainer") || ue(pe.InputContainer, "InputContainer"), fe = L, G = fe.default, pe = G && typeof G == "object" ? G : fe, me = m("div")(() => ({ width: "450px" })), he = m("div")(() => ({
+	display: "flex",
+	flexDirection: "column",
+	width: "100%"
+})), K = m("div")(() => ({
+	display: "flex",
+	flexDirection: "column",
+	alignItems: "center"
+})), ge = m("div")(() => ({
+	display: "flex",
+	justifyContent: "space-around",
+	alignItems: "center"
+})), _e = m("div")(({ theme: e }) => ({
+	width: "130px",
+	margin: `${e.spacing(1)} ${e.spacing(.5)}`
+})), q = m("div")(({ theme: e }) => ({
+	width: "160px",
+	margin: `${e.spacing(1)} ${e.spacing(.5)}`,
+	"& .MuiFormControl-root": { width: "100%" }
+})), ve = m("div")(({ theme: e }) => ({
+	width: "230px",
+	margin: `${e.spacing(1)} ${e.spacing(.5)}`,
+	"& .MuiFormControl-root": { width: "100%" }
+})), ye = m(b)(({ theme: e }) => ({
+	fontStyle: "italic",
+	margin: `${e.spacing(1)} 0`
+})), be = m("div")(() => ({
+	display: "flex",
+	justifyContent: "space-between",
+	alignItems: "center"
+})), xe = m(b)(() => ({ color: c.disabled() })), Se = m("div")(({ theme: e }) => ({ paddingTop: e.spacing(2) })), J = (e) => {
+	let { disabled: t, displayedFields: n, labelValue: r, labelValues: i, gridValue: a, gridValues: o, onChange: s } = e, { labelStep: c = {}, step: l = {} } = n;
+	return /* @__PURE__ */ H(K, { children: [l && l.enabled && /* @__PURE__ */ V(q, { children: /* @__PURE__ */ V(y, {
+		label: l.label || "",
+		value: a,
+		customValues: o,
+		variant: "outlined",
+		disabled: t,
+		onChange: (e, t) => s("step", t)
+	}) }), c && c.enabled && /* @__PURE__ */ V(q, { children: /* @__PURE__ */ V(y, {
+		label: c.label || "",
+		value: r,
+		customValues: i,
+		variant: "outlined",
+		disabled: t,
+		onChange: (e, t) => s("labelStep", t)
+	}) })] });
+};
+J.propTypes = {
+	disabled: U.default.bool,
+	displayedFields: U.default.object,
+	labelValue: U.default.number,
+	labelValues: U.default.array,
+	gridValue: U.default.number,
+	gridValues: U.default.array,
+	onChange: U.default.func
+};
+var Y = (e) => {
+	let { disabled: t, displayedFields: n, displayHeader: r, label: i, maxValue: a, minValue: o, onChange: s, type: c } = e, { axisLabel: l = {}, min: u = {}, max: d = {} } = n;
+	return /* @__PURE__ */ H(K, { children: [
+		r && /* @__PURE__ */ H(b, {
+			variant: "subtitle2",
+			children: [/* @__PURE__ */ V("i", { children: c === "domain" ? "x" : "y" }), "-axis"]
+		}),
+		u && u.enabled && /* @__PURE__ */ V(q, { children: /* @__PURE__ */ V(y, {
+			label: u.label || "",
+			value: o,
+			min: -1e4,
+			max: a - .05,
+			variant: "outlined",
+			disabled: t,
+			onChange: (e, t) => s("min", t)
+		}) }),
+		d && d.enabled && /* @__PURE__ */ V(q, { children: /* @__PURE__ */ V(y, {
+			label: d.label || "",
+			value: a,
+			min: o + .05,
+			max: 1e4,
+			variant: "outlined",
+			disabled: t,
+			onChange: (e, t) => s("max", t)
+		}) }),
+		l && l.enabled && /* @__PURE__ */ V(q, { children: /* @__PURE__ */ V(de, {
+			label: l.label || "",
+			children: /* @__PURE__ */ V(Se, { children: /* @__PURE__ */ V(w, {
+				onChange: (e) => s("axisLabel", e),
+				markup: i || "",
+				charactersLimit: 5,
+				onKeyDown: (e) => e.key === "Enter",
+				activePlugins: [
+					"bold",
+					"italic",
+					"underline",
+					"strikethrough"
+				]
+			}) })
+		}) })
+	] });
+};
+Y.propTypes = {
+	disabled: U.default.bool,
+	displayedFields: U.default.object,
+	displayHeader: U.default.bool,
+	label: U.default.string,
+	maxValue: U.default.number,
+	minValue: U.default.number,
+	type: U.default.string,
+	onChange: U.default.func
+};
+var Ce = (e) => {
+	let { domain: t, displayedFields: n = {}, gridValues: r = {}, includeAxes: i, labelValues: a = {}, onChange: o, onChangeView: s, range: c, size: l, sizeConstraints: u, standardGrid: d } = e, f = {
+		min: 2,
+		max: 41
+	}, { axisLabel: p = {}, dimensionsEnabled: m, includeAxesEnabled: h, labelStep: g = {}, min: _ = {}, max: v = {}, standardGridEnabled: S, step: C = {} } = n || {}, w = _.enabled || v.enabled || p.enabled || C.enabled || g.enabled, E = {
+		step: C,
+		labelStep: g
+	}, D = {
+		min: _,
+		max: v,
+		axisLabel: p
+	}, k = (e) => {
+		let n = (e) => {
+			let n = e === "domain" ? t : c;
+			return {
+				min: 1,
+				max: n.max < f.min || n.max > f.max ? 16 : n.max,
+				step: 1,
+				labelStep: 0
+			};
+		};
+		o({
+			includeAxes: e,
+			range: {
+				...c,
+				...e ? { labelStep: 1 } : n("range")
+			},
+			domain: {
+				...t,
+				...e ? { labelStep: 1 } : n("domain")
+			}
+		});
+	}, A = (e) => {
+		o({
+			standardGrid: e,
+			range: {
+				...t,
+				axisLabel: c.axisLabel
+			},
+			graph: {
+				...l,
+				height: l.width
+			}
+		});
+	}, N = (e, t) => {
+		let n = {
+			...l,
+			[e]: t
+		};
+		d && (n.height = t), o({ graph: n });
+	}, P = (e, n) => {
+		t[e] = n, d && e !== "axisLabel" && (c[e] = n), o({
+			domain: t,
+			range: c
+		});
+	}, F = (e, t) => {
+		c[e] = t, o({ range: c });
+	}, I = /* @__PURE__ */ H(ne, { children: [
+		/* @__PURE__ */ H(ge, { children: [/* @__PURE__ */ V(Y, {
+			displayedFields: D,
+			displayHeader: w,
+			type: "domain",
+			minValue: t.min,
+			maxValue: t.max,
+			label: t.axisLabel,
+			includeAxes: i,
+			onChange: P
+		}), /* @__PURE__ */ V(Y, {
+			displayedFields: D,
+			displayHeader: w,
+			type: "range",
+			minValue: c.min,
+			maxValue: c.max,
+			label: c.axisLabel,
+			disabled: d,
+			includeAxes: i,
+			onChange: F
+		})] }),
+		(_.enabled || v.enabled) && /* @__PURE__ */ V(ye, { children: "If you want the axis to be visible, use a zero or negative Min Value, and a positive Max Value" }),
+		(C.enabled || g.enabled) && /* @__PURE__ */ H(ge, { children: [/* @__PURE__ */ V(J, {
+			displayedFields: E,
+			gridValue: t.step,
+			labelValue: t.labelStep,
+			gridValues: r.domain || [],
+			labelValues: a.domain || [],
+			onChange: P
+		}), /* @__PURE__ */ V(J, {
+			disabled: d,
+			displayedFields: E,
+			gridValue: c.step,
+			labelValue: c.labelStep,
+			gridValues: r.range || [],
+			labelValues: a.range || [],
+			onChange: F
+		})] }),
+		g.enabled && /* @__PURE__ */ V(ye, { children: "For unnumbered gridlines, enter a label interval of 0" })
+	] }), L = v.enabled ? /* @__PURE__ */ H(K, { children: [/* @__PURE__ */ V(ve, { children: /* @__PURE__ */ V(y, {
+		label: "Number of Vertical Gridlines",
+		value: t.max,
+		min: !i && f.min,
+		max: !i && f.max,
+		variant: "outlined",
+		onChange: (e, t) => P("max", t)
+	}) }), /* @__PURE__ */ V(ve, { children: /* @__PURE__ */ V(y, {
+		label: "Number of Horizontal Gridlines",
+		value: c.max,
+		min: !i && f.min,
+		max: !i && f.max,
+		variant: "outlined",
+		disabled: d,
+		onChange: (e, t) => F("max", t)
+	}) })] }) : null;
+	return /* @__PURE__ */ V(me, { children: /* @__PURE__ */ H(T, {
+		onChange: s,
+		TransitionProps: { timeout: {
+			enter: 225,
+			exit: 195
+		} },
+		children: [/* @__PURE__ */ V(j, {
+			expandIcon: /* @__PURE__ */ V(x, {}),
+			children: /* @__PURE__ */ V(b, {
+				variant: "subtitle1",
+				children: "Customize Grid Setup"
+			})
+		}), /* @__PURE__ */ V(O, { children: /* @__PURE__ */ H(he, { children: [
+			h && /* @__PURE__ */ V(M, {
+				label: "Include axes and labels?",
+				toggle: k,
+				checked: i
+			}),
+			S && /* @__PURE__ */ V(M, {
+				label: "Constrain to standard coordinate grid?",
+				toggle: A,
+				checked: d
+			}),
+			i ? I : L,
+			m && /* @__PURE__ */ H(be, { children: [
+				/* @__PURE__ */ H("div", { children: [/* @__PURE__ */ V(b, { children: "Dimensions(px)" }), /* @__PURE__ */ H(xe, { children: [
+					"Min ",
+					u.min,
+					", Max ",
+					u.max
+				] })] }),
+				/* @__PURE__ */ V(_e, { children: /* @__PURE__ */ V(y, {
+					label: "Width",
+					value: l.width,
+					min: u.min,
+					max: u.max,
+					step: u.step,
+					variant: "outlined",
+					onChange: (e, t) => N("width", t)
+				}) }),
+				/* @__PURE__ */ V(_e, { children: /* @__PURE__ */ V(y, {
+					label: "Height",
+					value: l.height,
+					min: u.min,
+					max: u.max,
+					step: u.step,
+					variant: "outlined",
+					disabled: d,
+					onChange: (e, t) => N("height", t)
+				}) })
+			] })
+		] }) })]
+	}) });
+};
+Ce.propTypes = {
+	domain: U.default.object,
+	displayedFields: U.default.object,
+	gridValues: U.default.object,
+	includeAxes: U.default.bool,
+	labelValues: U.default.object,
+	onChange: U.default.func,
+	onChangeView: U.default.func,
+	range: U.default.object,
+	size: U.default.object,
+	sizeConstraints: U.default.object,
+	standardGrid: U.default.bool
+};
+//#endregion
+//#region src/author/utils.ts
+var we = /* @__PURE__ */ e(r(), 1), Te = [
+	.01,
+	.02,
+	.04,
+	.05,
+	.0625,
+	.1,
+	.125,
+	.2,
+	.25,
+	.5,
+	1,
+	2,
+	3,
+	4,
+	5,
+	8,
+	10,
+	12,
+	15,
+	20,
+	40,
+	50,
+	64,
+	100,
+	500,
+	1e3
+], Ee = [
+	.01,
+	.02,
+	.05,
+	.1,
+	.2,
+	.25,
+	.5,
+	1,
+	2,
+	5,
+	10,
+	20,
+	50,
+	100,
+	500,
+	1e3
+], De = {
+	.01: [
+		0,
+		.01,
+		.02,
+		.04,
+		.05,
+		.1
+	],
+	.02: [
+		0,
+		.02,
+		.04,
+		.1
+	],
+	.04: [
+		0,
+		.04,
+		.08,
+		.16,
+		.2
+	],
+	.05: [
+		0,
+		.05,
+		.1,
+		.2,
+		.25
+	],
+	.0625: [
+		0,
+		.0625,
+		.125,
+		.25,
+		.5
+	],
+	.1: [
+		0,
+		.1,
+		.2,
+		.4,
+		.5,
+		1
+	],
+	.125: [
+		0,
+		.125,
+		.25,
+		.5,
+		1
+	],
+	.2: [
+		0,
+		.2,
+		.5,
+		.1
+	],
+	.25: [
+		0,
+		.25,
+		.5,
+		1,
+		2
+	],
+	.5: [
+		0,
+		.5,
+		1,
+		2
+	],
+	1: [
+		0,
+		1,
+		2,
+		4,
+		5,
+		10
+	],
+	2: [
+		0,
+		2,
+		4,
+		8,
+		10
+	],
+	3: [
+		0,
+		3,
+		6,
+		12,
+		15
+	],
+	4: [
+		0,
+		4,
+		8,
+		16,
+		20
+	],
+	5: [
+		0,
+		5,
+		10,
+		20,
+		25
+	],
+	8: [
+		0,
+		8,
+		16,
+		32,
+		40,
+		64
+	],
+	10: [
+		0,
+		10,
+		20,
+		40,
+		50,
+		100
+	],
+	12: [
+		0,
+		12,
+		24
+	],
+	15: [
+		0,
+		15,
+		30,
+		60
+	],
+	20: [
+		0,
+		20,
+		40,
+		80,
+		100
+	],
+	40: [
+		0,
+		40,
+		80,
+		160,
+		200
+	],
+	50: [
+		0,
+		50,
+		100,
+		200,
+		250
+	],
+	64: [
+		0,
+		64,
+		128
+	],
+	100: [
+		0,
+		100,
+		200,
+		400,
+		500
+	],
+	500: [
+		0,
+		500,
+		1e3,
+		2500
+	],
+	1e3: [
+		0,
+		1e3,
+		2e3,
+		4e3,
+		5e3
+	]
+}, X = (e, t, n = !1) => {
+	let r = 10 * (e.max - e.min) / t, i = r * 10;
+	return (n ? Ee : Te).filter((e) => e >= r && e <= i);
+}, Z = (e) => De[e] || [], Oe = (e, t, r, i) => {
+	let a = X(e, t), o = Z(e.step);
+	if (!n(r, a) && !a.includes(e.step)) {
+		let n = X(e, t, !0)[0] || 1;
+		return e.step = n, o = Z(n), o.includes(e.labelStep) || (e.labelStep = n), {
+			gridValues: a,
+			labelValues: o
+		};
+	}
+	return !n(i, o) && !o.includes(e.labelStep) && (e.labelStep = e.step), {
+		gridValues: a,
+		labelValues: o
+	};
+}, ke = (e) => {
+	let t = [], n = 0;
+	for (; n >= e.min && t.indexOf(n) < 0;) t.push(n), n = Math.round((n - e.step) * 1e4) / 1e4;
+	for (n = Math.round(e.step * 1e4) / 1e4; n <= e.max && t.indexOf(n) < 0;) t.push(n), n = Math.round((n + e.step) * 1e4) / 1e4;
+	return t ? t.filter((t) => t >= e.min && t <= e.max) : [];
+}, Ae = (e, t, n) => {
+	let r = ke(e), i = ke(t), a = (e, t) => r.includes(e) && i.includes(t);
+	return Object.entries(n || {}).reduce((e, [t, n]) => (e[t] = {
+		...n,
+		marks: (n.marks || []).filter((e) => {
+			if (e.type === "point") return a(e.x, e.y);
+			if (e.type === "polygon") return !e.points.find((e) => !a(e.x, e.y));
+			let t = e.from || e.root, n = e.to || e.edge;
+			return e.building ? a(t.x, t.y) : a(t.x, t.y) && a(n.x, n.y);
+		})
+	}, e), {});
+}, je = (e, t) => Number(Math.sqrt((e.x - t.x) ** 2 + (e.y - t.y) ** 2).toFixed(3)), Q = (e, t) => {
+	let n = e, r = !1, i = [...t];
+	i.push(t[0]);
+	for (let e = 0; e < i.length - 1; e++) {
+		let t = i[e], a = i[e + 1];
+		if (je(t, n) + je(n, a) === je(t, a)) {
+			r = !0;
+			break;
+		}
+	}
+	return r;
+}, Me = (e, t, n, r, i, a, o, s) => {
+	let c, l = (s - a) * (n - e) - (o - i) * (r - t);
+	return l === 0 ? null : (c = ((o - i) * (t - a) - (s - a) * (e - i)) / l, {
+		x: Number((e + c * (n - e)).toFixed(3)),
+		y: Number((t + c * (r - t)).toFixed(3))
+	});
+}, Ne = (e, t, n) => e.x > t.min && e.x < t.max && e.y > n.min && e.y < n.max, Pe = (e, t, n) => e.x >= t.min && e.x <= t.max && e.y >= n.min && e.y <= n.max, Fe = (e, t, n) => {
+	let r = [], i = [
+		[
+			t.max,
+			n.max,
+			t.max,
+			n.min
+		],
+		[
+			t.min,
+			n.max,
+			t.min,
+			n.min
+		],
+		[
+			t.min,
+			n.max,
+			t.max,
+			n.max
+		],
+		[
+			t.min,
+			n.min,
+			t.max,
+			n.min
+		]
+	];
+	for (let a = 0; a < i.length; a++) {
+		let o = Me(e.from.x, e.from.y, e.to.x, e.to.y, i[a][0], i[a][1], i[a][2], i[a][3]);
+		o && Pe(o, t, n) && r.push(o);
+	}
+	return r;
+}, Ie = (e) => {
+	e.sort((e, t) => e.y - t.y);
+	let t = (e[0].y + e[e.length - 1].y) / 2;
+	e.sort((e, t) => t.x - e.x);
+	let n = {
+		x: (e[0].x + e[e.length - 1].x) / 2,
+		y: t
+	}, r;
+	e.forEach((e) => {
+		let t = Math.atan2(e.y - n.y, e.x - n.x);
+		r ? t < r && (t += Math.PI * 2) : r = t, e.angle = t;
+	}), e.sort((e, t) => e.angle - t.angle);
+	let i = e.reverse();
+	return i.unshift(i.pop()), i.map(({ angle: e, ...t }) => t);
+}, Le = (e, t) => e.x * t.x + e.y * t.y, Re = (e) => Math.sqrt(e.x * e.x + e.y * e.y), ze = (e, t) => {
+	let n = Le(e, t), r = Re(e), i = Re(t);
+	return Math.acos(n / (r * i));
+}, Be = (e, t, n, r) => {
+	let i = {
+		x: t.x - e.x,
+		y: t.y - e.y
+	}, a = {
+		x: n.x - e.x,
+		y: n.y - e.y
+	}, o = {
+		x: r.x - e.x,
+		y: r.y - e.y
+	}, s = ze(i, o) + ze(a, o);
+	return Math.abs(s - ze(i, a)) < 1e-4;
+}, Ve = (e) => e.filter((t, n) => n === e.findIndex((e) => t.x === e.x && t.y === e.y)), He = (e) => {
+	for (let t = 0; t < e.length; t++) e[t] = e[t].filter((n, r) => r === e[t].findIndex((e) => n.x === e.x && n.y === e.y));
+	e = e.filter((e) => e.length > 2);
+	for (let t = 0; t < e.length; t++) e[t] = Ie(e[t]);
+	return e;
+}, Ue = (e, t, n) => {
+	let r = [];
+	return r.push([].concat(e)), r.push([].concat(e)), e[0].x === t.max && e[1].y === n.max || e[1].x === t.max && e[0].y === n.max ? (r[0].push({
+		x: t.max,
+		y: n.max
+	}), r[1].push({
+		x: t.min,
+		y: n.max
+	}, {
+		x: t.min,
+		y: n.min
+	}, {
+		x: t.max,
+		y: n.min
+	})) : e[0].x === t.min && e[1].y === n.max || e[1].x === t.min && e[0].y === n.max ? (r[0].push({
+		x: t.min,
+		y: n.max
+	}), r[1].push({
+		x: t.max,
+		y: n.max
+	}, {
+		x: t.max,
+		y: n.min
+	}, {
+		x: t.min,
+		y: n.min
+	})) : e[0].x === t.min && e[1].y === n.min || e[1].x === t.min && e[0].y === n.min ? (r[0].push({
+		x: t.min,
+		y: n.min
+	}), r[1].push({
+		x: t.max,
+		y: n.min
+	}, {
+		x: t.max,
+		y: n.max
+	}, {
+		x: t.min,
+		y: n.max
+	})) : e[0].x === t.max && e[1].y === n.min || e[1].x === t.max && e[0].y === n.min ? (r[0].push({
+		x: t.max,
+		y: n.min
+	}), r[1].push({
+		x: t.min,
+		y: n.min
+	}, {
+		x: t.min,
+		y: n.max
+	}, {
+		x: t.max,
+		y: n.max
+	})) : e[0].x === t.min && e[1].x === t.max || e[0].x === t.max && e[1].x === t.min ? (r[0].push({
+		x: t.min,
+		y: n.max
+	}, {
+		x: t.max,
+		y: n.max
+	}), r[1].push({
+		x: t.min,
+		y: n.min
+	}, {
+		x: t.max,
+		y: n.min
+	})) : (e[0].y === n.min && e[1].y === n.max || e[0].y === n.max && e[1].y === n.min) && (r[0].push({
+		x: t.min,
+		y: n.min
+	}, {
+		x: t.min,
+		y: n.max
+	}), r[1].push({
+		x: t.max,
+		y: n.min
+	}, {
+		x: t.max,
+		y: n.max
+	})), He(r);
+}, We = (e, t, n, r) => {
+	let i = t[0], a = t[1], o = [
+		{
+			x: n.min,
+			y: r.min
+		},
+		{
+			x: n.min,
+			y: r.max
+		},
+		{
+			x: n.max,
+			y: r.min
+		},
+		{
+			x: n.max,
+			y: r.max
+		}
+	], s = Me(i.from.x, i.from.y, i.to.x, i.to.y, a.from.x, a.from.y, a.to.x, a.to.y), c = [], l = Fe(i, n, r);
+	l = Ve(l);
+	let u = Fe(a, n, r);
+	if (u = Ve(u), s && Ne(s, n, r)) for (let e = 0; e < l.length; e++) for (let t = 0; t < u.length; t++) {
+		let n = [], r = [];
+		n.push(s), n.push(l[e]), n.push(u[t]);
+		for (let i = 0; i < o.length; i++) Be(s, l[e], u[t], o[i]) ? n.push(o[i]) : r.push(o[i]);
+		o = r, c.push(n);
+	}
+	else {
+		let e = Ue(l, n, r), t = Ue(u, n, r);
+		for (let t = 0; t < e.length; t++) Q(u[0], e[t]) && Q(u[1], e[t]) || c.push(e[t]);
+		for (let e = 0; e < t.length; e++) Q(l[0], t[e]) && Q(l[1], t[e]) || c.push(t[e]);
+		for (let e = 0; e < c.length; e++) o = o.filter(function(t) {
+			return !c[e].some(function(e) {
+				return t.x === e.x && t.y === e.y;
+			});
+		});
+		let i = o.concat(l, u);
+		c.push(i);
+	}
+	return He(c);
+}, Ge = (e, t, n, r) => (e.numberOfLines === 1 ? e.sections = Ue(Fe(t[0], n, r), n, r) : e.sections = We(e, t, n, r), e), Ke = (e, t) => {
+	let n = t.length, r = e.x, i = e.y, a = !1, o = t[0], s;
+	for (let e = 1; e <= n; e++) {
+		if (s = t[e % n], i > Math.min(o.y, s.y) && i <= Math.max(o.y, s.y) && r <= Math.max(o.x, s.x)) {
+			let e = (i - o.y) * (s.x - o.x) / (s.y - o.y) + o.x;
+			(o.x === s.x || r <= e) && (a = !a);
+		}
+		o = s;
+	}
+	return a;
+}, qe = (e, t) => {
+	if (t.length === 0) return !1;
+	if (e.numberOfLines === 1) {
+		if (t.length === 1) return !t[0].building;
+	} else if (t.length !== 2) return !1;
+	else return !t[1].building;
+}, Je = m("div")(({ theme: e }) => ({
+	display: "flex",
+	flexWrap: "wrap",
+	marginBottom: e.spacing(2.5)
+})), Ye = m("div")(({ theme: e }) => ({
+	display: "flex",
+	flexDirection: "column",
+	marginRight: e.spacing(3),
+	marginBottom: e.spacing(2.5)
+})), Xe = m("div")({
+	display: "flex",
+	flexDirection: "column"
+}), Ze = m(b)(({ theme: e }) => ({
+	marginTop: e.spacing(1.5),
+	marginBottom: e.spacing(1)
+})), Qe = m("div")(({ theme: e }) => ({
+	display: "flex",
+	flexWrap: "wrap",
+	alignItems: "center",
+	width: "100%",
+	marginBottom: e.spacing(2.5)
+})), $e = m(b)(({ theme: e }) => ({ padding: `0 ${e.spacing(1)}` })), et = m(I)({ flex: "1" }), tt = class extends z.Component {
+	static propTypes = {
+		availableTools: U.default.array,
+		authoring: U.default.object,
+		dimensionsEnabled: U.default.bool,
+		graphDimensions: U.default.object,
+		gridConfigurations: U.default.array,
+		labelsPlaceholders: U.default.object,
+		model: U.default.object.isRequired,
+		onChange: U.default.func.isRequired,
+		showLabels: U.default.bool,
+		showTitle: U.default.bool,
+		titlePlaceholder: U.default.string
+	};
+	constructor(e) {
+		super(e);
+		let { domain: t, range: n, graph: r } = e.model || {}, i = {
+			domain: X(t, r.width, !0),
+			range: X(n, r.height, !0)
+		}, a = {
+			domain: Z(t.step),
+			range: Z(n.step)
+		};
+		this.state = {
+			gridValues: i,
+			labelValues: a,
+			showPixelGuides: !1,
+			dialog: { isOpened: !1 },
+			domain: { ...t },
+			range: { ...n }
+		};
+	}
+	changeLabels = (e) => {
+		let { model: t, onChange: n } = this.props;
+		n({
+			...t,
+			labels: e
+		});
+	};
+	changeTitle = (e) => {
+		let { model: t, onChange: n } = this.props;
+		n({
+			...t,
+			title: e
+		});
+	};
+	onConfigChange = (e, r) => {
+		let { model: i, onChange: a } = this.props, { defaultGridConfiguration: o = 0 } = i, { gridValues: s, labelValues: c, domain: l, range: u } = this.state, d = {
+			...i,
+			...e
+		}, { answers: f, domain: p, includeAxes: m = !0, graph: h, range: g, standardGrid: _ } = d, v = {
+			domain: [],
+			range: []
+		}, y = {
+			domain: [],
+			range: []
+		}, b = r >= 0 ? r : o;
+		if (m) {
+			let e = Oe(p, h.width, s.domain, c.domain);
+			v.domain = e.gridValues || [], y.domain = e.labelValues || [];
+		}
+		if (_) v.range = v.domain, y.range = y.domain, g.step = p.step, g.labelStep = p.labelStep;
+		else if (m) {
+			let e = Oe(g, h.height, s.range, c.range);
+			v.range = e.gridValues || [], y.range = e.labelValues || [];
+		}
+		let x = t(f);
+		x.correctAnswer.marks = f.correctAnswer.marks.filter((e) => e.type !== "polygon");
+		let S = Ae(p, g, x);
+		if (!n(x, S)) {
+			this.setState({ dialog: {
+				isOpened: !0,
+				onClose: () => this.setState({ dialog: { isOpened: !1 } }, a({
+					...i,
+					domain: l,
+					range: u
+				})),
+				onConfirm: () => {
+					d.gssLineData.sections = [], d.gssLineData.selectedTool = "lineA", this.setState({
+						gridValues: v,
+						labelValues: y,
+						dialog: { isOpened: !1 },
+						domain: { ...p },
+						range: { ...g }
+					}, a({
+						...d,
+						answers: S,
+						defaultGridConfiguration: b
+					}));
+				}
+			} });
+			return;
+		}
+		this.setState({
+			gridValues: v,
+			labelValues: y,
+			domain: { ...p },
+			range: { ...g }
+		}), a({
+			...d,
+			defaultGridConfiguration: b
+		});
+	};
+	onChangeView = (e, t) => {
+		let { graphDimensions: { enabled: n } = {} } = this.props;
+		n && this.setState({ showPixelGuides: t });
+	};
+	changeGridConfiguration = (e) => {
+		let { gridConfigurations: t } = this.props, { value: n } = e.target;
+		this.onConfigChange(t?.[n] || {}, n);
+	};
+	render() {
+		let { authoring: e = {}, gridConfigurations: t = [], graphDimensions: n = {}, labelsPlaceholders: r, model: i, showLabels: a, dimensionsEnabled: o, showTitle: s, titlePlaceholder: c, mathMlOptions: l = {} } = this.props, { arrows: u, coordinatesOnHover: d, defaultGridConfiguration: f, domain: p, labels: m, range: h, standardGrid: g, title: _ } = i || {}, y = (i || {}).graph || {}, { min: x, max: S, step: C } = n || {}, { dialog: w = {}, gridValues: T, labelValues: E, showPixelGuides: D } = this.state, O = {
+			min: Math.max(150, x),
+			max: Math.min(800, S),
+			step: C >= 1 ? Math.min(200, C) : 20
+		}, k = {
+			axisLabel: e.axisLabel,
+			dimensionsEnabled: o,
+			includeAxesEnabled: !1,
+			labelStep: e.labelStep,
+			min: e.min,
+			max: e.max,
+			standardGridEnabled: e.standardGridEnabled,
+			step: e.step
+		}, j = e.enabled && Object.values(k).some((e) => typeof e == "object" ? e.enabled : e);
+		return /* @__PURE__ */ H(Je, { children: [
+			/* @__PURE__ */ H(Ye, { children: [t && t.length ? /* @__PURE__ */ H(Qe, { children: [/* @__PURE__ */ V($e, {
+				component: "div",
+				variant: "h6",
+				children: "Grid Configuration"
+			}), /* @__PURE__ */ V(et, {
+				input: /* @__PURE__ */ V(ee, { labelWidth: 10 }),
+				displayEmpty: !0,
+				onChange: this.changeGridConfiguration,
+				value: f,
+				MenuProps: { transitionDuration: {
+					enter: 225,
+					exit: 195
+				} },
+				children: (t || []).map((e, t) => /* @__PURE__ */ V(v, {
+					value: t,
+					children: e.label
+				}, t))
+			})] }) : null, j && /* @__PURE__ */ V(Ce, {
+				displayedFields: k,
+				domain: p,
+				gridValues: T,
+				includeAxes: !0,
+				labelValues: E,
+				range: h,
+				size: y,
+				sizeConstraints: O,
+				standardGrid: g,
+				onChange: this.onConfigChange,
+				onChangeView: this.onChangeView
+			})] }),
+			/* @__PURE__ */ H(Xe, { children: [
+				/* @__PURE__ */ V(b, {
+					component: "div",
+					variant: "h6",
+					children: "Define Graph Attributes"
+				}),
+				/* @__PURE__ */ V(Ze, {
+					component: "div",
+					variant: "body1",
+					children: "Use this interface to add/edit a title and/or labels"
+				}),
+				/* @__PURE__ */ V(N, {
+					axesSettings: { includeArrows: u },
+					backgroundMarks: [],
+					coordinatesOnHover: d,
+					collapsibleToolbar: !0,
+					collapsibleToolbarTitle: "Add Background Shapes to Graph",
+					domain: p,
+					labels: m,
+					labelsPlaceholders: r,
+					marks: [],
+					onChangeLabels: this.changeLabels,
+					onChangeTitle: this.changeTitle,
+					range: h,
+					showLabels: a,
+					showPixelGuides: D,
+					showTitle: s,
+					size: {
+						width: y.width,
+						height: y.height
+					},
+					title: _,
+					titlePlaceholder: c,
+					disableToolbar: !0,
+					mathMlOptions: l
+				}, "graphing-config")
+			] }, "graph"),
+			/* @__PURE__ */ V(A, {
+				open: w.isOpened,
+				title: "Warning",
+				text: "This change would make it impossible for students to plot one or more graph objects in the current correct answers. If you proceed, all such graph objects will be removed from the correct answers.",
+				onClose: w.onClose,
+				onConfirm: w.onConfirm
+			})
+		] });
+	}
+}, nt = m(b)(({ theme: e }) => ({
+	marginTop: e.spacing(1.5),
+	marginBottom: e.spacing(1)
+})), rt = m(C)({
+	height: "20px",
+	width: "fit-content",
+	padding: ".5rem 0"
+}), it = m(F)({ color: "#000000 !important" }), at = m("div")(({ theme: e }) => ({
+	fontSize: e.typography.fontSize - 2,
+	color: e.palette.error.main,
+	paddingTop: e.spacing(1)
+})), ot = class extends z.Component {
+	static propTypes = {
+		errors: U.default.object,
+		model: U.default.object.isRequired,
+		onChange: U.default.func.isRequired
+	};
+	state = { dialog: { open: !1 } };
+	handleAlertDialog = (e, t) => this.setState({ dialog: { open: e } }, t);
+	changeMarks = (e) => {
+		let { model: t, onChange: n } = this.props, { gssLineData: r } = t;
+		r.selectedTool === "lineA" && e.length > 0 && (e[0].fill = r.lineA.lineType), r.selectedTool === "lineB" && e.length > 1 && (e[1].fill = r.lineB.lineType), e.length === 0 && (r.selectedTool = "lineA", l(t, "gssLineData", r)), l(t, "answers.correctAnswer.marks", e), n(t);
+	};
+	onResetClick = () => {
+		let { model: e, onChange: t } = this.props, { gssLineData: n, answers: r } = e;
+		this.setState({ dialog: {
+			open: !0,
+			title: "Warning",
+			text: "This will remove all the elements added on the graph and reset graph to original state. Are you sure you want to continue?",
+			onConfirm: () => {
+				r.correctAnswer.marks = [], n.selectedTool = "lineA", n.lineA.lineType = "Solid", n.lineB && (n.lineB.lineType = "Solid"), l(e, "answers", r), l(e, "gssLineData", n), t(e), this.handleAlertDialog(!1);
+			},
+			onClose: () => this.handleAlertDialog(!1)
+		} });
+	};
+	changeNumberOfLines = (e, t) => {
+		let { model: n } = this.props;
+		n.gssLineData.selectedTool === "solutionSet" ? this.setState({ dialog: {
+			open: !0,
+			title: "Warning",
+			text: "Changing number of lines after adding solution set will remove added solution set. Are you sure you want to continue?",
+			onConfirm: () => {
+				this.changeLine(e, t), this.handleAlertDialog(!1);
+			},
+			onClose: () => this.handleAlertDialog(!1)
+		} }) : this.changeLine(e, t);
+	};
+	changeLine = (e, t) => {
+		let { model: n, onChange: r } = this.props, { answers: i } = n, a = n.gssLineData;
+		i.correctAnswer.marks = i.correctAnswer.marks.filter((e) => e.type !== "polygon"), Number.parseInt(t) === 1 ? (delete a.lineB, i.correctAnswer.marks.length > 1 && i.correctAnswer.marks.pop(), a.numberOfLines = 1, a.selectedTool = "lineA") : (a.numberOfLines = 2, i.correctAnswer.marks.length > 0 && (a.selectedTool = "lineB"), a.lineB = { lineType: "Solid" }), l(n, "answers", i), l(n, "gssLineData", a), r(n);
+	};
+	onSolutionSetSelected = (e) => {
+		let { model: t, onChange: n } = this.props, { answers: r, gssLineData: i } = t;
+		for (let t of i.sections) if (Ke(e, t)) {
+			let e = {
+				points: t,
+				building: !1,
+				type: "polygon",
+				closed: !0,
+				isSolution: !0
+			};
+			r.correctAnswer.marks = r.correctAnswer.marks.filter((e) => e.type !== "polygon"), r.correctAnswer.marks.push(e);
+			break;
+		}
+		l(t, "answers", r), n(t);
+	};
+	onChangeGssLineData = (e, t) => {
+		let { model: n } = this.props, { answers: r, domain: i, range: a } = n;
+		if (e.selectedTool === "solutionSet") {
+			let n = r.correctAnswer.marks.filter((e) => e.type !== "polygon");
+			if (!qe(e, n)) e.selectedTool = t, this.setState({ dialog: {
+				open: !0,
+				title: "Warning",
+				text: "Please define the line(s) and then select a solution set for the item.",
+				onConfirm: () => this.handleAlertDialog(!1)
+			} });
+			else {
+				let t = r.correctAnswer.marks.filter((e) => e.type !== "polygon");
+				e = Ge(e, t, i, a);
+			}
+			this.handleGssLineDataChange(e, r);
+		} else {
+			let n = r.correctAnswer.marks.filter((e) => e.type === "polygon");
+			t === "solutionSet" && n.length > 0 ? this.setState({ dialog: {
+				open: !0,
+				title: "Warning",
+				text: "Changing a line after adding a solution set will clear your selected solution set. Click 'Clear Solution Set' to change the line. Otherwise, click 'Cancel'.",
+				onConfirm: () => {
+					r.correctAnswer.marks = r.correctAnswer.marks.filter((e) => e.type !== "polygon"), this.handleGssLineDataChange(e, r), this.handleAlertDialog(!1);
+				},
+				onConfirmText: "CLEAR SOLUTION SET",
+				onClose: () => {
+					e.selectedTool = t, this.handleGssLineDataChange(e, r), this.handleAlertDialog(!1);
+				}
+			} }) : this.handleGssLineDataChange(e, r);
+		}
+	};
+	handleGssLineDataChange = (e, t) => {
+		let { model: n, onChange: r } = this.props;
+		t.correctAnswer.marks.length > 0 && t.correctAnswer.marks[0] && e.lineA && (t.correctAnswer.marks[0].fill = e.lineA.lineType), t.correctAnswer.marks.length > 1 && t.correctAnswer.marks[1] && e.lineB && (t.correctAnswer.marks[1].fill = e.lineB.lineType), (e.selectedTool === "lineB" && t.correctAnswer.marks.length === 0 || e.selectedTool === "lineB" && t.correctAnswer.marks[0].building) && (this.setState({ dialog: {
+			open: !0,
+			title: "Warning",
+			text: "Please add Line A to the graph before adding Line B",
+			onConfirm: () => this.handleAlertDialog(!1)
+		} }), e.selectedTool = "lineA"), e.selectedTool === "lineA" && t.correctAnswer.marks.length > 1 && t.correctAnswer.marks[1].building && (this.setState({ dialog: {
+			open: !0,
+			title: "Warning",
+			text: "Please add Line B to the graph before switching to Line A",
+			onConfirm: () => this.handleAlertDialog(!1)
+		} }), e.selectedTool = "lineB"), l(n, "gssLineData", e), l(n, "answers", t), r(n);
+	};
+	updateModel = (e) => {
+		let { model: t, onChange: n } = this.props;
+		n({
+			...t,
+			...e
+		});
+	};
+	render() {
+		let { errors: e, model: t, mathMlOptions: n = {} } = this.props, { dialog: r } = this.state, { gssLineData: i = {
+			numberOfLines: 1,
+			selectedTool: "lineA",
+			lineA: { lineType: "Solid" }
+		}, arrows: a, coordinatesOnHover: o, domain: s, graph: c = {}, labels: l, labelsEnabled: u, range: d, title: f, titleEnabled: p, answers: m } = t || {}, { correctAnswerErrors: h = "" } = e || {};
+		return /* @__PURE__ */ H("div", { children: [
+			/* @__PURE__ */ V(b, {
+				component: "div",
+				variant: "h6",
+				children: "Define Line Type(s) and Correct Response"
+			}),
+			/* @__PURE__ */ V(nt, {
+				component: "div",
+				variant: "body1",
+				children: "Use this interface to choose how many lines students will be able to draw, and to define the correct answer."
+			}),
+			/* @__PURE__ */ V(nt, {
+				component: "div",
+				variant: "body1",
+				children: "Choose Number of Lines"
+			}),
+			/* @__PURE__ */ H(le, {
+				name: "numberOfLines",
+				value: i.numberOfLines,
+				onChange: this.changeNumberOfLines,
+				children: [/* @__PURE__ */ V(rt, {
+					value: "1",
+					control: /* @__PURE__ */ V(it, { checked: i.numberOfLines === 1 }),
+					label: "One"
+				}), /* @__PURE__ */ V(rt, {
+					value: "2",
+					control: /* @__PURE__ */ V(it, { checked: i.numberOfLines === 2 }),
+					label: "Two"
+				})]
+			}),
+			/* @__PURE__ */ H(z.Fragment, { children: [/* @__PURE__ */ V(N, {
+				style: h.correctAnswer && { border: "2px solid red" },
+				axesSettings: { includeArrows: a },
+				backgroundMarks: [],
+				coordinatesOnHover: o,
+				disabledLabels: !0,
+				disabledTitle: !0,
+				domain: s,
+				draggableTools: !0,
+				labels: l,
+				marks: m && m.correctAnswer && m.correctAnswer.marks ? m.correctAnswer.marks : [],
+				onChangeMarks: (e) => this.changeMarks(e),
+				onCustomReset: this.onResetClick,
+				range: d,
+				showLabels: u,
+				showTitle: p,
+				size: {
+					width: c.width,
+					height: c.height
+				},
+				title: f,
+				gssLineData: i,
+				onChangeGssLineData: this.onChangeGssLineData,
+				onSolutionSetSelected: this.onSolutionSetSelected,
+				toolbarTools: ["line", "polygon"],
+				mathMlOptions: n
+			}), h.correctAnswer && /* @__PURE__ */ V(at, { children: h.correctAnswer })] }),
+			/* @__PURE__ */ V(A, {
+				open: r.open,
+				title: r.title,
+				text: r.text,
+				onClose: r.onClose,
+				onConfirm: r.onConfirm,
+				onConfirmText: r.onConfirmText ? r.onConfirmText : "OK"
+			})
+		] });
+	}
+}, { Panel: st, toggle: $, radio: ct, checkboxes: lt, textField: ut, dropdown: dt } = k;
+(0, we.default)("@pie-element:graphing-solution-set:configure");
+var ft = m(P)(({ theme: e }) => ({
+	width: "100%",
+	paddingTop: e.spacing(2),
+	marginBottom: e.spacing(2),
+	marginTop: e.spacing(2)
+})), pt = m(b)(({ theme: e }) => ({ marginBottom: e.spacing(2.5) })), mt = class extends B.Component {
+	static propTypes = {
+		onModelChanged: U.default.func,
+		onConfigurationChanged: U.default.func,
+		imageSupport: U.default.object,
+		uploadSoundSupport: U.default.object,
+		model: U.default.object.isRequired,
+		configuration: U.default.object.isRequired
+	};
+	componentDidMount() {
+		let { configuration: e, onModelChanged: t, model: n } = this.props, { title: r, graphDimensions: i } = e || {}, { arrows: a, titleEnabled: o, dimensionsEnabled: s } = n || {};
+		typeof a == "boolean" && (a = a ? {
+			left: !0,
+			right: !0,
+			up: !0,
+			down: !0
+		} : {
+			left: !1,
+			right: !1,
+			up: !1,
+			down: !1
+		});
+		let c = o ?? r.enabled, l = s ?? i.enabled;
+		t && t({
+			...n,
+			arrows: a,
+			titleEnabled: c,
+			dimensionsEnabled: l
+		});
+	}
+	onRationaleChange = (e) => {
+		let { onModelChanged: t, model: n } = this.props;
+		t({
+			...n,
+			rationale: e
+		});
+	};
+	onPromptChange = (e) => {
+		let { onModelChanged: t, model: n } = this.props;
+		t({
+			...n,
+			prompt: e
+		});
+	};
+	onTeacherInstructionsChange = (e) => {
+		let { onModelChanged: t, model: n } = this.props;
+		t({
+			...n,
+			teacherInstructions: e
+		});
+	};
+	render() {
+		let { model: e, configuration: t, onConfigurationChanged: n, onModelChanged: r, imageSupport: i, uploadSoundSupport: a } = this.props, { arrows: o = {}, authoring: s = {}, coordinatesOnHover: c = {}, contentDimensions: l = {}, gridConfigurations: u = [], graphDimensions: d = {}, instruction: f = {}, labels: p = {}, padding: m = {}, prompt: h = {}, rationale: g = {}, scoringType: _ = {}, settingsPanelDisabled: v, spellCheck: y = {}, studentInstructions: b = {}, teacherInstructions: x = {}, title: S = {}, maxImageWidth: C = {}, maxImageHeight: T = {}, withRubric: D = {}, language: O = {}, languageChoices: k = {}, mathMlOptions: A = {} } = t || {}, { errors: j = {}, extraCSSRules: M, labelsEnabled: N, dimensionsEnabled: P, promptEnabled: F, rationaleEnabled: I, spellCheckEnabled: L, teacherInstructionsEnabled: ee, titleEnabled: R } = e || {}, z = C && C.prompt, B = T && T.prompt, te = {
+			top: p.top,
+			right: p.right,
+			bottom: p.bottom,
+			left: p.left
+		}, ne = {
+			arrows: o.settings && lt(o.label, {
+				left: o.left,
+				right: o.right,
+				up: o.up,
+				down: o.down
+			}),
+			titleEnabled: S.settings && $(S.label),
+			padding: m.settings && $(m.label),
+			labelsEnabled: p.settings && $(p.label),
+			"language.enabled": O.settings && $(O.label, !0),
+			language: O.settings && O.enabled && dt(k.label, k.options),
+			dimensionsEnabled: d.settings && $(d.label),
+			coordinatesOnHover: c.settings && $(c.label)
+		}, re = {
+			"authoring.enabled": s.settings && $(s.label, !0),
+			teacherInstructionsEnabled: x.settings && $(x.label),
+			studentInstructionsEnabled: b.settings && $(b.label),
+			promptEnabled: h.settings && $(h.label),
+			rationaleEnabled: g.settings && $(g.label),
+			spellCheckEnabled: y.settings && $(y.label),
+			scoringType: _.settings && ct(_.label, ["dichotomous", "partial scoring"]),
+			rubricEnabled: D?.settings && $(D?.label),
+			instruction: f.settings && ut(f.label)
+		};
+		return /* @__PURE__ */ H(E.ConfigLayout, {
+			extraCSSRules: M,
+			dimensions: l,
+			hideSettings: v,
+			settings: /* @__PURE__ */ V(st, {
+				model: e,
+				configuration: t,
+				onChangeModel: r,
+				onChangeConfiguration: n,
+				groups: {
+					Settings: ne,
+					Properties: re
+				}
+			}),
+			children: [
+				/* @__PURE__ */ V(pt, {
+					component: "div",
+					variant: "body1",
+					children: f?.label || ""
+				}),
+				ee && /* @__PURE__ */ V(ft, {
+					label: x.label,
+					children: /* @__PURE__ */ V(w, {
+						markup: e.teacherInstructions || "",
+						onChange: this.onTeacherInstructionsChange,
+						imageSupport: i,
+						nonEmpty: !1,
+						spellCheck: L,
+						maxImageWidth: C && C.teacherInstructions || z,
+						maxImageHeight: T && T.teacherInstructions || B,
+						uploadSoundSupport: a,
+						languageCharactersProps: [{ language: "spanish" }, { language: "special" }],
+						mathMlOptions: A
+					})
+				}),
+				F && /* @__PURE__ */ V(ft, {
+					label: h.label,
+					children: /* @__PURE__ */ V(w, {
+						markup: e.prompt,
+						onChange: this.onPromptChange,
+						imageSupport: i,
+						nonEmpty: !1,
+						spellCheck: L,
+						disableUnderline: !0,
+						maxImageWidth: z,
+						maxImageHeight: B,
+						uploadSoundSupport: a,
+						languageCharactersProps: [{ language: "spanish" }, { language: "special" }],
+						mathMlOptions: A
+					})
+				}),
+				/* @__PURE__ */ V(tt, {
+					authoring: s,
+					gridConfigurations: u,
+					graphDimensions: d,
+					labelsPlaceholders: te,
+					model: e,
+					showLabels: N,
+					dimensionsEnabled: P,
+					showTitle: R,
+					titlePlaceholder: S.placeholder,
+					onChange: this.props.onModelChanged,
+					mathMlOptions: A
+				}),
+				/* @__PURE__ */ V(ot, {
+					errors: j,
+					model: e,
+					onChange: this.props.onModelChanged,
+					mathMlOptions: A
+				}),
+				I && /* @__PURE__ */ V(ft, {
+					label: g.label || "Rationale",
+					children: /* @__PURE__ */ V(w, {
+						markup: e.rationale || "",
+						onChange: this.onRationaleChange,
+						imageSupport: i,
+						spellCheck: L,
+						maxImageWidth: C && C.rationale || z,
+						maxImageHeight: T && T.rationale || B,
+						uploadSoundSupport: a,
+						languageCharactersProps: [{ language: "spanish" }, { language: "special" }],
+						mathMlOptions: A
+					})
+				})
+			]
+		});
+	}
+}, ht = class e extends CustomEvent {
+	static {
+		this.TYPE = "model.updated";
+	}
+	constructor(t, n = !1) {
+		super(e.TYPE, {
+			bubbles: !0,
+			detail: {
+				update: t,
+				reset: n
+			}
+		}), this.update = t, this.reset = n;
+	}
+}, gt = class e extends CustomEvent {
+	static {
+		this.TYPE = "delete.image";
+	}
+	constructor(t, n) {
+		super(e.TYPE, {
+			bubbles: !0,
+			detail: {
+				src: t,
+				done: n
+			}
+		}), this.src = t, this.done = n;
+	}
+}, _t = class e extends CustomEvent {
+	static {
+		this.TYPE = "insert.image";
+	}
+	constructor(t) {
+		super(e.TYPE, {
+			bubbles: !0,
+			detail: t
+		}), this.handler = t;
+	}
+}, vt = class e extends CustomEvent {
+	static {
+		this.TYPE = "delete.sound";
+	}
+	constructor(t, n) {
+		super(e.TYPE, {
+			bubbles: !0,
+			detail: {
+				src: t,
+				done: n
+			}
+		}), this.src = t, this.done = n;
+	}
+}, yt = class e extends CustomEvent {
+	static {
+		this.TYPE = "insert.sound";
+	}
+	constructor(t) {
+		super(e.TYPE, {
+			bubbles: !0,
+			detail: t
+		}), this.handler = t;
+	}
+}, bt = {
+	model: {
+		answers: { correctAnswer: {
+			name: "Correct Answer",
+			marks: []
+		} },
+		arrows: {
+			left: !0,
+			right: !0,
+			up: !0,
+			down: !0
+		},
+		marks: [],
+		defaultGridConfiguration: 0,
+		domain: {
+			min: -5,
+			max: 5,
+			step: 1,
+			labelStep: 1,
+			axisLabel: "x"
+		},
+		graph: {
+			width: 500,
+			height: 500
+		},
+		gssLineData: {
+			numberOfLines: 1,
+			selectedTool: "lineA",
+			sections: [],
+			lineA: { lineType: "Solid" }
+		},
+		includeAxes: !0,
+		labels: {},
+		labelsEnabled: !0,
+		padding: !0,
+		prompt: "",
+		range: {
+			min: -5,
+			max: 5,
+			step: 1,
+			labelStep: 1,
+			axisLabel: "y"
+		},
+		rationale: "",
+		standardGrid: !1,
+		title: "",
+		coordinatesOnHover: !1,
+		promptEnabled: !0,
+		rationaleEnabled: !0,
+		teacherInstructionsEnabled: !0,
+		studentInstructionsEnabled: !0
+	},
+	configuration: {
+		authoring: {
+			settings: !1,
+			label: "Customize Grid Setup",
+			enabled: !0,
+			includeAxesEnabled: !1,
+			standardGridEnabled: !0,
+			min: {
+				label: "Min Value",
+				enabled: !0
+			},
+			max: {
+				label: "Max Value",
+				enabled: !0
+			},
+			axisLabel: {
+				label: "Label",
+				enabled: !0
+			},
+			step: {
+				label: "Grid Interval",
+				enabled: !0
+			},
+			labelStep: {
+				label: "Label Interval",
+				enabled: !0
+			}
+		},
+		arrows: {
+			settings: !0,
+			label: "Include Arrows",
+			left: { label: "left" },
+			right: { label: "right" },
+			up: { label: "up" },
+			down: { label: "down" }
+		},
+		gridConfigurations: [
+			{
+				label: "4-quadrant coordinate grid, -10 to 10",
+				arrows: {
+					left: !0,
+					right: !0,
+					up: !0,
+					down: !0
+				},
+				domain: {
+					min: -10,
+					max: 10,
+					step: 1,
+					padding: 0,
+					labelStep: 1,
+					axisLabel: "<i>x</i>"
+				},
+				graph: {
+					width: 480,
+					height: 480
+				},
+				includeAxes: !0,
+				labels: {
+					top: "",
+					right: "",
+					bottom: "",
+					left: ""
+				},
+				padding: !0,
+				range: {
+					min: -10,
+					max: 10,
+					step: 1,
+					padding: 0,
+					labelStep: 1,
+					axisLabel: "<i>y</i>"
+				},
+				standardGrid: !0,
+				title: ""
+			},
+			{
+				label: "0 to 10 on both axes",
+				arrows: {
+					left: !1,
+					right: !0,
+					up: !0,
+					down: !1
+				},
+				domain: {
+					min: 0,
+					max: 10,
+					step: 1,
+					padding: 0,
+					labelStep: 1,
+					axisLabel: "<i>x</i>"
+				},
+				graph: {
+					width: 480,
+					height: 480
+				},
+				includeAxes: !0,
+				labels: {
+					top: "",
+					right: "",
+					bottom: "",
+					left: ""
+				},
+				padding: !0,
+				range: {
+					min: 0,
+					max: 10,
+					step: 1,
+					padding: 0,
+					labelStep: 1,
+					axisLabel: "<i>y</i>"
+				},
+				standardGrid: !0,
+				title: ""
+			},
+			{
+				label: "0 to 20 on both axes",
+				arrows: {
+					left: !1,
+					right: !0,
+					up: !0,
+					down: !1
+				},
+				domain: {
+					min: 0,
+					max: 20,
+					step: 1,
+					padding: 0,
+					labelStep: 1,
+					axisLabel: "<i>x</i>"
+				},
+				graph: {
+					width: 480,
+					height: 480
+				},
+				includeAxes: !0,
+				labels: {
+					top: "",
+					right: "",
+					bottom: "",
+					left: ""
+				},
+				padding: !0,
+				range: {
+					min: 0,
+					max: 20,
+					step: 1,
+					padding: 0,
+					labelStep: 1,
+					axisLabel: "<i>y</i>"
+				},
+				standardGrid: !0,
+				title: ""
+			},
+			{
+				label: "Sample Data Graph",
+				arrows: {
+					left: !1,
+					right: !0,
+					up: !0,
+					down: !1
+				},
+				domain: {
+					min: 0,
+					max: 30,
+					step: 1,
+					padding: 0,
+					labelStep: 2,
+					axisLabel: "<i>t</i>"
+				},
+				graph: {
+					width: 480,
+					height: 480
+				},
+				includeAxes: !0,
+				labels: {
+					top: "",
+					right: "",
+					bottom: "Time (seconds)",
+					left: "Distance (meters)"
+				},
+				padding: !0,
+				range: {
+					min: 0,
+					max: 80,
+					step: 5,
+					padding: 0,
+					labelStep: 10,
+					axisLabel: "<i>d</i>"
+				},
+				standardGrid: !1,
+				title: "Distance as a function of time"
+			}
+		],
+		graphDimensions: {
+			settings: !1,
+			label: "Graph Dimensions",
+			enabled: !0,
+			min: 150,
+			max: 800,
+			step: 20
+		},
+		padding: {
+			settings: !1,
+			label: "Padding"
+		},
+		labels: {
+			settings: !0,
+			label: "Graph Labels",
+			enabled: !0,
+			top: "Click here to add a top label",
+			right: "Click here to add a right label",
+			bottom: "Click here to add a bottom label",
+			left: "Click here to add a left label"
+		},
+		prompt: {
+			settings: !0,
+			label: "Item Stem"
+		},
+		rationale: {
+			settings: !0,
+			label: "Rationale"
+		},
+		scoringType: {
+			settings: !1,
+			label: "Scoring Type"
+		},
+		studentInstructions: {
+			settings: !1,
+			label: "Student Instructions"
+		},
+		teacherInstructions: {
+			settings: !0,
+			label: "Teacher Instructions"
+		},
+		title: {
+			settings: !0,
+			label: "Graph Title",
+			enabled: !0,
+			placeholder: "Click here to add a title for this graph"
+		},
+		instruction: {
+			settings: !1,
+			label: "Graphing Solution Set items involve plotting one or two lines on a graph and then selecting the correct area that represents the solution set. To create one, first configure the grid, then select if one or two lines will be offered and if the lines should be solid or dashed. After defining the line(s), define the correct answer by clicking the area that represents the solution set."
+		},
+		settingsPanelDisabled: !1,
+		spellCheck: {
+			label: "Spellcheck",
+			settings: !1,
+			enabled: !0
+		},
+		coordinatesOnHover: {
+			settings: !0,
+			label: "Coordinates on Hover"
+		},
+		maxImageWidth: {
+			teacherInstructions: 300,
+			prompt: 300,
+			rationale: 300
+		},
+		maxImageHeight: {
+			teacherInstructions: 300,
+			prompt: 300,
+			rationale: 300
+		},
+		withRubric: {
+			settings: !1,
+			label: "Add Rubric"
+		},
+		language: {
+			settings: !1,
+			label: "Specify Language",
+			enabled: !1
+		},
+		languageChoices: {
+			label: "Language Choices",
+			options: []
+		},
+		mathMlOptions: {
+			mmlOutput: !1,
+			mmlEditing: !1
+		}
+	}
+}, xt = (0, we.default)("pie-elements:graphing-solution-set:configure"), St = (e) => Object.keys(e || {}).sort().reduce((t, n) => (n !== "correctAnswer" && (t[n] = e[n]), t), {}), Ct = class e extends HTMLElement {
+	static createDefaultModel = (e = {}) => {
+		let t = {
+			...bt.model,
+			...e
+		}, { answers: n = {}, domain: r = {}, graph: i = {}, range: a = {}, standardGrid: o } = t;
+		return {
+			...t,
+			answers: n && n.correctAnswer && {
+				correctAnswer: n.correctAnswer,
+				...St(n)
+			} || n,
+			range: o && {
+				...a,
+				min: r.min,
+				max: r.max,
+				step: r.step,
+				labelStep: r.labelStep
+			} || a,
+			graph: o && {
+				...i,
+				height: i.width
+			} || i
+		};
+	};
+	constructor() {
+		super(), this._root = null, this._model = e.createDefaultModel(), this._configuration = bt.configuration;
+	}
+	set model(t) {
+		this._model = e.createDefaultModel(t), this._render();
+	}
+	set configuration(e) {
+		this._configuration = e, e.language?.enabled ? e.languageChoices?.options?.length && (this._model.language = e.languageChoices.options[0].value) : e.language.settings ? this._model.language && (this._configuration.language.enabled = !0) : delete this._model.language, this._render();
+	}
+	onModelChanged = (e) => {
+		this._model = e, this._render(), xt("[onModelChanged]: ", this._model), this.dispatchEvent(new ht(this._model));
+	};
+	onConfigurationChanged = (e) => {
+		this._configuration = e, this._render();
+	};
+	insertImage = (e) => {
+		this.dispatchEvent(new _t(e));
+	};
+	onDeleteImage = (e, t) => {
+		this.dispatchEvent(new gt(e, t));
+	};
+	insertSound(e) {
+		this.dispatchEvent(new yt(e));
+	}
+	onDeleteSound(e, t) {
+		this.dispatchEvent(new vt(e, t));
+	}
+	_render() {
+		if (this._model) {
+			let e = B.createElement(mt, {
+				onModelChanged: this.onModelChanged,
+				onConfigurationChanged: this.onConfigurationChanged,
+				model: this._model,
+				configuration: this._configuration,
+				imageSupport: {
+					add: this.insertImage,
+					delete: this.onDeleteImage
+				},
+				uploadSoundSupport: {
+					add: this.insertSound.bind(this),
+					delete: this.onDeleteSound.bind(this)
+				}
+			});
+			this._root ||= te(this), this._root.render(e), queueMicrotask(() => {
+				_(this);
+			});
+		}
+	}
+	disconnectedCallback() {
+		this._root && this._root.unmount();
+	}
+};
+//#endregion
+export { Ct as default };
+
+//# sourceMappingURL=index.js.map