@pie-lib/graphing-solution-set 4.1.0-beta.9 → 5.0.0-next.20261002100925

package/dist/tools/shared/line/index.js

@@ -0,0 +1,320 @@
+import { equalPoints as e, getMiddleOfTwoPoints as t, sameAxes as n } from "../../../utils.js";
+import { correct as r, disabled as i, incorrect as a, missing as o } from "../styles.js";
+import { MarkLabel as s } from "../../../mark-label.js";
+import { BasePoint as c } from "../point/index.js";
+import l from "react";
+import u from "prop-types";
+import { cloneDeep as d, isEmpty as f, isEqual as p } from "@pie-element/shared-lodash";
+import { gridDraggable as m, trig as h, types as g, utils as _ } from "@pie-lib/plot";
+import { jsx as v, jsxs as y } from "react/jsx-runtime";
+import { color as b } from "@pie-lib/render-ui";
+import x from "react-dom";
+//#region src/tools/shared/line/index.tsx
+var S = (t, n) => () => ({
+	type: t,
+	Component: n,
+	addPoint: (n, r) => r && e(r.root, n) ? r : r ? e(n, r.from) ? { ...r } : {
+		...r,
+		building: !1,
+		to: n
+	} : {
+		type: t,
+		building: !0,
+		from: n
+	}
+}), C = (e) => class extends l.Component {
+	static propTypes = {
+		...g.ToolPropTypeFields,
+		graphProps: g.GraphPropsType.isRequired
+	};
+	constructor(e) {
+		super(e), this.state = {};
+	}
+	startDrag = () => this.setState({ mark: { ...this.props.mark } });
+	stopDrag = () => {
+		let { onChange: e, mark: t } = this.props, r = { ...this.state.mark };
+		this.setState({ mark: void 0 }, () => {
+			let { type: i } = r, a = i && (i === "parabola" || i === "sine" || i === "absolute" || i === "exponential") && n(r.from, r.to);
+			!a && i && i === "exponential" && r.from && r.to && (a = r.from.y === 0 || r.to.y === 0 || r.from.y * r.to.y < 0), !p(t, r) && !a && e(t, r);
+		});
+	};
+	changeMark = ({ from: e, to: t, middle: n }) => {
+		let r = {
+			...this.state.mark,
+			from: e,
+			to: t
+		};
+		n && (r = {
+			...r,
+			middle: n
+		}), this.setState({ mark: r });
+	};
+	changeMarkProps = ({ from: e, to: t, middle: n }) => {
+		let { onChange: r, mark: i } = this.props, a = {
+			...i,
+			...this.state.mark
+		};
+		e && (a = {
+			...a,
+			from: e
+		}), t && (a = {
+			...a,
+			to: t
+		}), n && (a = {
+			...a,
+			middle: n
+		}), p(i, a) || r(i, a);
+	};
+	render() {
+		let { graphProps: t, onClick: n, labelNode: r, labelModeEnabled: i, coordinatesOnHover: a, gssLineData: o } = this.props, s = this.state.mark ? this.state.mark : this.props.mark, c = d(s.from), l = d(s.to), u = d(s.middle);
+		return c && s.isBackground && (c.disabled = !0), l && s.isBackground && (l.disabled = !0), u && s.isBackground && (u.disabled = !0), /* @__PURE__ */ v(e, {
+			disabled: s.disabled,
+			coordinatesOnHover: a,
+			correctness: s.correctness,
+			from: c,
+			to: l,
+			middle: u,
+			graphProps: t,
+			fill: s && s.fill,
+			gssLineData: o,
+			onChange: this.changeMark,
+			changeMarkProps: this.changeMarkProps,
+			onClick: n,
+			onDragStart: this.startDrag,
+			onDragStop: this.stopDrag,
+			labelNode: r,
+			labelModeEnabled: i
+		});
+	}
+}, w = () => ({
+	bounds: (e, { domain: t, range: n }) => {
+		let r = _.lineToArea(e.from, e.to);
+		return _.bounds(r, t, n);
+	},
+	anchorPoint: (e) => {
+		let { from: t } = e;
+		return t;
+	},
+	fromDelta: (e, t) => {
+		let { from: n, to: r } = e;
+		return {
+			from: _.point(n).add(_.point(t)),
+			to: _.point(r).add(_.point(t))
+		};
+	}
+}), T = (n, r) => {
+	let i = m(w())(n), a = r && r.from ? r.from : c, o = r && r.to ? r.to : c;
+	class d extends l.Component {
+		static propTypes = {
+			coordinatesOnHover: u.bool,
+			graphProps: g.GraphPropsType,
+			from: g.PointType,
+			to: g.PointType,
+			middle: g.PointType,
+			onChange: u.func,
+			onDragStart: u.func,
+			onDragStop: u.func,
+			onClick: u.func,
+			correctness: u.string,
+			fill: u.string,
+			gssLineData: u.object,
+			disabled: u.bool,
+			labelNode: u.object,
+			labelModeEnabled: u.bool,
+			changeMarkProps: u.func
+		};
+		onChangePoint = (n) => {
+			let { middle: r, onChange: i } = this.props, { from: a, to: o } = n;
+			e(a, o) || (r && (n.middle = {
+				...r,
+				...t(a, o)
+			}), i(n));
+		};
+		dragComp = ({ from: e, to: n }) => {
+			let { from: r, to: i, onChange: a, middle: o } = this.props;
+			r.label && (e.label = r.label), i.label && (n.label = i.label);
+			let s = {
+				from: e,
+				to: n
+			};
+			o && (s.middle = {
+				...o,
+				...t(e, n)
+			}), a(s);
+		};
+		dragFrom = (t) => {
+			let { from: n, to: r } = this.props;
+			n.label && (t.label = n.label), e(t, r) || this.onChangePoint({
+				from: t,
+				to: r
+			});
+		};
+		dragTo = (t) => {
+			let { from: n, to: r } = this.props;
+			r.label && (t.label = r.label), e(n, t) || this.onChangePoint({
+				from: n,
+				to: t
+			});
+		};
+		labelChange = (e, t) => {
+			let { changeMarkProps: n } = this.props, r = { ...e };
+			(!e.label || f(e.label)) && delete r.label, n({ [t]: r });
+		};
+		clickPoint = (e, n, r) => {
+			let { changeMarkProps: i, disabled: a, from: o, to: s, labelModeEnabled: c, onClick: l } = this.props;
+			if (!c) {
+				l(e || r);
+				return;
+			}
+			a || (n === "middle" && !e && o && s && (e = {
+				...e,
+				...t(o, s)
+			}), i({
+				from: o,
+				to: s,
+				[n]: {
+					label: "",
+					...e
+				}
+			}), this.input[n] && this.input[n].focus());
+		};
+		input = {};
+		render() {
+			let { coordinatesOnHover: e, graphProps: t, fill: n, gssLineData: r, onDragStart: c, onDragStop: l, from: u, to: d, middle: f, disabled: p, correctness: m, onClick: g, labelNode: _, labelModeEnabled: b } = this.props, S = {
+				graphProps: t,
+				fill: n,
+				onDragStart: c,
+				onDragStop: l,
+				disabled: p,
+				correctness: m,
+				onClick: g
+			};
+			r && r.selectedTool === "solutionSet" && (S = {
+				graphProps: t,
+				fill: n,
+				disabled: p,
+				correctness: m,
+				onClick: g
+			});
+			let C = d ? h.toDegrees(h.angle(u, d)) : 0, w = null, T = null, E = null;
+			return _ && (u && Object.prototype.hasOwnProperty.call(u, "label") && (w = x.createPortal(/* @__PURE__ */ v(s, {
+				inputRef: (e) => this.input.from = e,
+				disabled: !b,
+				mark: u,
+				graphProps: t,
+				onChange: (e) => this.labelChange({
+					...u,
+					label: e
+				}, "from")
+			}), _)), d && Object.prototype.hasOwnProperty.call(d, "label") && (T = x.createPortal(/* @__PURE__ */ v(s, {
+				inputRef: (e) => this.input.to = e,
+				disabled: !b,
+				mark: d,
+				graphProps: t,
+				onChange: (e) => this.labelChange({
+					...d,
+					label: e
+				}, "to")
+			}), _)), f && Object.prototype.hasOwnProperty.call(f, "label") && (E = x.createPortal(/* @__PURE__ */ v(s, {
+				inputRef: (e) => this.input.middle = e,
+				disabled: !b,
+				mark: f,
+				graphProps: t,
+				onChange: (e) => this.labelChange({
+					...f,
+					label: e
+				}, "middle")
+			}), _))), r && r.selectedTool === "solutionSet" ? /* @__PURE__ */ y("g", { children: [
+				d && /* @__PURE__ */ v(i, {
+					from: u,
+					to: d,
+					middle: f,
+					...S
+				}),
+				E,
+				/* @__PURE__ */ v(a, {
+					x: u.x,
+					y: u.y,
+					labelNode: _,
+					coordinatesOnHover: e,
+					...S
+				}),
+				w,
+				d && /* @__PURE__ */ v(o, {
+					x: d.x,
+					y: d.y,
+					angle: C,
+					labelNode: _,
+					coordinatesOnHover: e,
+					...S
+				}),
+				T
+			] }) : /* @__PURE__ */ y("g", { children: [
+				d && /* @__PURE__ */ v(i, {
+					from: u,
+					to: d,
+					middle: f,
+					onDrag: this.dragComp,
+					...S,
+					onClick: (e) => this.clickPoint(f, "middle", e)
+				}),
+				E,
+				/* @__PURE__ */ v(a, {
+					x: u.x,
+					y: u.y,
+					labelNode: _,
+					coordinatesOnHover: e,
+					onDrag: this.dragFrom,
+					...S,
+					onClick: (e) => this.clickPoint(u, "from", e)
+				}),
+				w,
+				d && /* @__PURE__ */ v(o, {
+					x: d.x,
+					y: d.y,
+					angle: C,
+					labelNode: _,
+					coordinatesOnHover: e,
+					onDrag: this.dragTo,
+					...S,
+					onClick: (e) => this.clickPoint(d, "to", e)
+				}),
+				T
+			] });
+		}
+	}
+	return d;
+}, E = {
+	line: () => ({
+		fill: "transparent",
+		stroke: b.defaults.BLACK,
+		strokeWidth: 4,
+		transition: "stroke 200ms ease-in, stroke-width 200ms ease-in",
+		"&:hover": {
+			strokeWidth: 6,
+			stroke: b.defaults.BLACK
+		}
+	}),
+	dashedLine: () => ({
+		fill: "transparent",
+		stroke: b.defaults.BLACK,
+		strokeWidth: 4,
+		transition: "stroke 200ms ease-in, stroke-width 200ms ease-in",
+		"&:hover": {
+			strokeWidth: 6,
+			stroke: b.defaults.BLACK
+		},
+		strokeDasharray: "3,3"
+	}),
+	arrow: () => ({ fill: b.defaults.SECONDARY }),
+	disabledArrow: () => ({ ...i() }),
+	disabled: () => ({
+		...i("stroke"),
+		strokeWidth: 2
+	}),
+	correct: (e, t) => ({ ...r(t) }),
+	incorrect: (e, t) => ({ ...a(t) }),
+	missing: (e, t) => ({ ...o(t) })
+};
+//#endregion
+export { T as lineBase, S as lineTool, C as lineToolComponent, E as styles };

package/dist/tools/shared/point/arrow-point.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @synced-from pie-lib/packages/graphing-solution-set/src/tools/shared/point/arrow-point.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+import React from 'react';
+import PropTypes from 'prop-types';
+export declare class RawArrow extends React.Component {
+    static propTypes: {
+        classes: PropTypes.Requireable<object>;
+        className: PropTypes.Requireable<string>;
+        correctness: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        x: PropTypes.Requireable<number>;
+        y: PropTypes.Requireable<number>;
+        from: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            x: PropTypes.Requireable<number>;
+            y: PropTypes.Requireable<number>;
+        }>>>;
+        to: PropTypes.Requireable<PropTypes.InferProps<{
+            x: PropTypes.Requireable<number>;
+            y: PropTypes.Requireable<number>;
+        }>>;
+        graphProps: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            scale: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                x: PropTypes.Validator<(...args: any[]) => any>;
+                y: PropTypes.Validator<(...args: any[]) => any>;
+            }>>>;
+            snap: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                x: PropTypes.Validator<(...args: any[]) => any>;
+                y: PropTypes.Validator<(...args: any[]) => any>;
+            }>>>;
+            domain: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                min: PropTypes.Validator<number>;
+                max: PropTypes.Validator<number>;
+                step: PropTypes.Requireable<number>;
+            }>>>;
+            range: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                min: PropTypes.Validator<number>;
+                max: PropTypes.Validator<number>;
+                step: PropTypes.Requireable<number>;
+            }>>>;
+            size: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                width: PropTypes.Validator<number>;
+                height: PropTypes.Validator<number>;
+            }>>>;
+        }>>>;
+    };
+    static defaultProps: {
+        from: {};
+        to: {};
+    };
+    render(): React.JSX.Element;
+}

package/dist/tools/shared/point/arrow-point.js

@@ -0,0 +1,47 @@
+import { arrowDimensions as e, getAngleDeg as t } from "../../../utils.js";
+import { clsx as n } from "../../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import r from "react";
+import i from "prop-types";
+import { isEqual as a } from "@pie-element/shared-lodash";
+import { types as o } from "@pie-lib/plot";
+import { jsx as s } from "react/jsx-runtime";
+//#region src/tools/shared/point/arrow-point.tsx
+var c = class extends r.Component {
+	static propTypes = {
+		classes: i.object,
+		className: i.string,
+		correctness: i.string,
+		disabled: i.bool,
+		x: i.number,
+		y: i.number,
+		from: i.shape({
+			x: i.number,
+			y: i.number
+		}).isRequired,
+		to: i.shape({
+			x: i.number,
+			y: i.number
+		}),
+		graphProps: o.GraphPropsType.isRequired
+	};
+	static defaultProps = {
+		from: {},
+		to: {}
+	};
+	render() {
+		let { classes: r, className: i, x: o, y: c, disabled: l, correctness: u, graphProps: d, from: f, to: p, ...m } = this.props, { scale: h } = d, g = t(f.x, f.y, p.x, p.y), _ = "";
+		return _ = a(f, p) ? "0,0 0,0 0,0" : `0,0 ${e.vector},${e.vector * 2} 
+      -${e.vector},${e.vector * 2}`, /* @__PURE__ */ s("g", {
+			className: n(r.point, l && r.disabled, r[u], i),
+			...m,
+			children: /* @__PURE__ */ s("polygon", {
+				points: _,
+				transform: `
+          translate(${h.x(o)}, ${h.y(c)})
+          rotate(${g} 0 0)`
+			})
+		});
+	}
+};
+//#endregion
+export { c as RawArrow };

package/dist/tools/shared/point/arrow.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @synced-from pie-lib/packages/graphing-solution-set/src/tools/shared/point/arrow.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+import React from 'react';
+import PropTypes from 'prop-types';
+export default class Arrow extends React.Component {
+    static propTypes: {
+        classes: PropTypes.Requireable<object>;
+        className: PropTypes.Requireable<string>;
+        correctness: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        x: PropTypes.Validator<number>;
+        y: PropTypes.Validator<number>;
+        angle: PropTypes.Validator<number>;
+        graphProps: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            scale: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                x: PropTypes.Validator<(...args: any[]) => any>;
+                y: PropTypes.Validator<(...args: any[]) => any>;
+            }>>>;
+            snap: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                x: PropTypes.Validator<(...args: any[]) => any>;
+                y: PropTypes.Validator<(...args: any[]) => any>;
+            }>>>;
+            domain: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                min: PropTypes.Validator<number>;
+                max: PropTypes.Validator<number>;
+                step: PropTypes.Requireable<number>;
+            }>>>;
+            range: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                min: PropTypes.Validator<number>;
+                max: PropTypes.Validator<number>;
+                step: PropTypes.Requireable<number>;
+            }>>>;
+            size: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                width: PropTypes.Validator<number>;
+                height: PropTypes.Validator<number>;
+            }>>>;
+        }>>>;
+    };
+    render(): React.JSX.Element;
+}

package/dist/tools/shared/point/arrow.js

@@ -0,0 +1,36 @@
+import { thinnerShapesNeeded as e } from "../../../utils.js";
+import { clsx as t } from "../../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import { ArrowHead as n } from "../arrow-head.js";
+import r from "react";
+import i from "prop-types";
+import { types as a } from "@pie-lib/plot";
+import { jsx as o } from "react/jsx-runtime";
+//#region src/tools/shared/point/arrow.tsx
+var s = class extends r.Component {
+	static propTypes = {
+		classes: i.object,
+		className: i.string,
+		correctness: i.string,
+		disabled: i.bool,
+		x: i.number.isRequired,
+		y: i.number.isRequired,
+		angle: i.number.isRequired,
+		graphProps: a.GraphPropsType.isRequired
+	};
+	render() {
+		let { classes: r, angle: i, className: a, x: s, y: c, disabled: l, correctness: u, graphProps: d, ...f } = this.props, p = e(d) ? 12 : 14, { scale: m } = d, h = m.x(s), g = m.y(c), _ = `rotate(${-i}, ${h},${g})`, v = `${h},${g}
+        ${h - p},${g - p / 2}
+        ${h - p}, ${g + p / 2}`;
+		return /* @__PURE__ */ o("g", {
+			className: t(r.point, l && r.disabled, r[u], a),
+			...f,
+			children: /* @__PURE__ */ o(n, {
+				size: p,
+				transform: _,
+				points: v
+			})
+		});
+	}
+};
+//#endregion
+export { s as default };

package/dist/tools/shared/point/base-point.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @synced-from pie-lib/packages/graphing-solution-set/src/tools/shared/point/base-point.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+import React from 'react';
+import PropTypes from 'prop-types';
+export declare class RawBp extends React.Component {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        coordinatesOnHover: PropTypes.Requireable<boolean>;
+        correctness: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        labelNode: PropTypes.Requireable<object>;
+        x: PropTypes.Requireable<number>;
+        y: PropTypes.Requireable<number>;
+        graphProps: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            scale: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                x: PropTypes.Validator<(...args: any[]) => any>;
+                y: PropTypes.Validator<(...args: any[]) => any>;
+            }>>>;
+            snap: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                x: PropTypes.Validator<(...args: any[]) => any>;
+                y: PropTypes.Validator<(...args: any[]) => any>;
+            }>>>;
+            domain: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                min: PropTypes.Validator<number>;
+                max: PropTypes.Validator<number>;
+                step: PropTypes.Requireable<number>;
+            }>>>;
+            range: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                min: PropTypes.Validator<number>;
+                max: PropTypes.Validator<number>;
+                step: PropTypes.Requireable<number>;
+            }>>>;
+            size: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                width: PropTypes.Validator<number>;
+                height: PropTypes.Validator<number>;
+            }>>>;
+        }>>>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onTouchStart: PropTypes.Requireable<(...args: any[]) => any>;
+        onTouchEnd: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    constructor(props: any);
+    render(): React.JSX.Element;
+}

package/dist/tools/shared/point/base-point.js

@@ -0,0 +1,88 @@
+import { thinnerShapesNeeded as e } from "../../../utils.js";
+import { correct as t, disabled as n, incorrect as r, missing as i } from "../styles.js";
+import { CoordinatesLabel as a } from "../../../coordinates-label.js";
+import o from "react";
+import s from "prop-types";
+import { types as c } from "@pie-lib/plot";
+import { Fragment as l, jsx as u, jsxs as d } from "react/jsx-runtime";
+import { styled as f } from "@mui/material/styles";
+import { color as p } from "@pie-lib/render-ui";
+import m from "react-dom";
+//#region src/tools/shared/point/base-point.tsx
+var h = f("g")(({ disabled: e, correctness: a }) => ({
+	cursor: "pointer",
+	"& circle": { fill: "currentColor" },
+	...e && {
+		...n("fill"),
+		...n("color")
+	},
+	...a === "correct" && {
+		...t("fill"),
+		...t("color")
+	},
+	...a === "incorrect" && {
+		...r("fill"),
+		...r("color")
+	},
+	...a === "missing" && {
+		...i("fill"),
+		...i("color")
+	}
+})), g = class extends o.Component {
+	static propTypes = {
+		className: s.string,
+		coordinatesOnHover: s.bool,
+		correctness: s.string,
+		disabled: s.bool,
+		labelNode: s.object,
+		x: s.number,
+		y: s.number,
+		graphProps: c.GraphPropsType.isRequired,
+		onClick: s.func,
+		onTouchStart: s.func,
+		onTouchEnd: s.func
+	};
+	constructor(e) {
+		super(e), this.state = { showCoordinates: !1 };
+	}
+	render() {
+		let { className: t, coordinatesOnHover: n, x: r, y: i, disabled: o, correctness: s, graphProps: c, labelNode: f, style: g, onClick: _, onTouchStart: v, onTouchEnd: y, ...b } = this.props, { showCoordinates: x } = this.state, { scale: S } = c, C = e(c) ? 5 : 7;
+		return /* @__PURE__ */ d(l, { children: [/* @__PURE__ */ u("circle", {
+			style: {
+				fill: "transparent",
+				cursor: "pointer",
+				pointerEvents: "all"
+			},
+			r: C * 3,
+			cx: S.x(r),
+			cy: S.y(i),
+			onMouseEnter: () => this.setState({ showCoordinates: !0 }),
+			onMouseLeave: () => this.setState({ showCoordinates: !1 }),
+			onTouchStart: v,
+			onTouchEnd: y,
+			onClick: _
+		}), /* @__PURE__ */ d(h, {
+			disabled: o,
+			correctness: s,
+			className: t,
+			onMouseEnter: () => this.setState({ showCoordinates: !0 }),
+			onMouseLeave: () => this.setState({ showCoordinates: !1 }),
+			children: [/* @__PURE__ */ u("circle", {
+				...b,
+				style: {
+					fill: p.defaults.BLACK,
+					cursor: "pointer"
+				},
+				r: C,
+				cx: S.x(r),
+				cy: S.y(i)
+			}), f && n && x && m.createPortal(/* @__PURE__ */ u(a, {
+				graphProps: c,
+				x: r,
+				y: i
+			}), f)]
+		})] });
+	}
+};
+//#endregion
+export { g as RawBp };