@pie-lib/graphing 4.0.4 → 4.0.5-next.0

package/dist/tools/circle/bg-circle.d.ts

@@ -0,0 +1,116 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/circle/bg-circle.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';
+declare class RawCircle extends React.Component {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        correctness: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        x: PropTypes.Validator<number>;
+        y: PropTypes.Validator<number>;
+        radius: 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>;
+            }>>>;
+        }>>>;
+    };
+    render(): React.JSX.Element;
+}
+export declare const BgCircle: typeof RawCircle;
+declare const _default: {
+    new (props: any): {
+        grid: any;
+        onStart: any;
+        position: any;
+        tiny: any;
+        getScaledBounds: any;
+        getClientPoint: any;
+        skipDragOutsideOfBounds: any;
+        onDrag: any;
+        getDelta: any;
+        applyDelta: any;
+        onStop: any;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<{}>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<{}>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    propTypes: {
+        disabled: PropTypes.Requireable<boolean>;
+        onDragStart: PropTypes.Requireable<(...args: any[]) => any>;
+        onDrag: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragStop: PropTypes.Requireable<(...args: any[]) => any>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onMove: PropTypes.Requireable<(...args: any[]) => any>;
+        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>;
+            }>>>;
+        }>>>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/tools/circle/bg-circle.js

@@ -0,0 +1,72 @@
+import { bounds as e, point as t } from "../../utils.js";
+import { correct as n, disabled as r, disabledSecondary as i, incorrect as a, missing as o } from "../shared/styles.js";
+import s from "react";
+import c from "prop-types";
+import { gridDraggable as l, types as u } from "@pie-lib/plot";
+import d from "classnames";
+import { styled as f } from "@mui/material/styles";
+import { jsx as p } from "react/jsx-runtime";
+import { color as m } from "@pie-lib/render-ui";
+//#region src/tools/circle/bg-circle.tsx
+var h = class extends s.Component {
+	static propTypes = {
+		className: c.string,
+		correctness: c.string,
+		disabled: c.bool,
+		x: c.number.isRequired,
+		y: c.number.isRequired,
+		radius: c.number,
+		graphProps: u.GraphPropsType.isRequired
+	};
+	render() {
+		let { disabled: e, className: t, correctness: n, x: r, y: i, radius: a, graphProps: o, ...s } = this.props, { scale: c } = o, l = Math.abs(c.x(r + a) - c.x(r)), u = Math.abs(c.y(i + a) - c.y(i));
+		return /* @__PURE__ */ p(_, {
+			className: d(t, e && "disabledSecondary", n),
+			cx: c.x(r),
+			cy: c.y(i),
+			rx: l,
+			ry: u,
+			...s
+		});
+	}
+}, g = (e) => ({
+	...e("stroke"),
+	"&:hover": {
+		strokeWidth: 3,
+		...e("stroke")
+	}
+}), _ = f("ellipse")(() => ({
+	fill: "transparent",
+	stroke: m.defaults.BLACK,
+	strokeWidth: 3,
+	transition: "stroke 200ms ease-in, stroke-width 200ms ease-in",
+	"&:hover": {
+		strokeWidth: 6,
+		stroke: m.defaults.PRIMARY_DARK
+	},
+	"&.disabled": g(r),
+	"&.disabledSecondary": g(i),
+	"&.correct": g(n),
+	"&.incorrect": g(a),
+	"&.missing": g(o)
+})), v = h, y = l({
+	bounds: (t, { domain: n, range: r }) => {
+		let { x: i, y: a } = t;
+		return e({
+			left: i,
+			top: a,
+			bottom: a,
+			right: i
+		}, n, r);
+	},
+	anchorPoint: (e) => {
+		let { x: t, y: n } = e;
+		return {
+			x: t,
+			y: n
+		};
+	},
+	fromDelta: (e, n) => t(e).add(t(n))
+})(v);
+//#endregion
+export { y as default };

package/dist/tools/circle/component.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/circle/component.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 RawBaseCircle extends React.Component {
+    static propTypes: {
+        building: PropTypes.Requireable<boolean>;
+        className: PropTypes.Requireable<string>;
+        coordinatesOnHover: PropTypes.Requireable<boolean>;
+        correctness: PropTypes.Requireable<string>;
+        from: PropTypes.Requireable<PropTypes.InferProps<{
+            x: PropTypes.Validator<number>;
+            y: PropTypes.Validator<number>;
+        }>>;
+        disabled: PropTypes.Requireable<boolean>;
+        to: PropTypes.Requireable<PropTypes.InferProps<{
+            x: PropTypes.Validator<number>;
+            y: PropTypes.Validator<number>;
+        }>>;
+        middle: PropTypes.Requireable<PropTypes.InferProps<{
+            x: PropTypes.Validator<number>;
+            y: PropTypes.Validator<number>;
+        }>>;
+        onChange: PropTypes.Validator<(...args: any[]) => any>;
+        onDragStart: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragStop: PropTypes.Requireable<(...args: any[]) => any>;
+        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>;
+        labelNode: PropTypes.Requireable<object>;
+        labelModeEnabled: PropTypes.Requireable<boolean>;
+        changeMarkProps: PropTypes.Requireable<(...args: any[]) => any>;
+        limitLabeling: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        onClick: () => {};
+    };
+    onChangePoint: any;
+    dragFrom: any;
+    dragTo: any;
+    dragCircle: any;
+    labelChange: any;
+    clickPoint: any;
+    input: {};
+    render(): React.JSX.Element;
+}
+export declare const BaseCircle: typeof RawBaseCircle;
+declare const Component: {
+    (props: any): React.JSX.Element;
+    propTypes: {
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        mark: PropTypes.Requireable<object>;
+    };
+};
+export default Component;

package/dist/tools/circle/component.js

@@ -0,0 +1,195 @@
+import { equalPoints as e, getMiddleOfTwoPoints as t, point as n, stripEmptyLabel as r } from "../../utils.js";
+import { BasePoint as i } from "../shared/point/index.js";
+import a from "../../mark-label.js";
+import o from "./bg-circle.js";
+import { rootEdgeComponent as s } from "../shared/line/with-root-edge.js";
+import c from "react";
+import l from "prop-types";
+import { isEmpty as u } from "lodash-es";
+import { types as d } from "@pie-lib/plot";
+import f from "classnames";
+import { keyframes as p, styled as m } from "@mui/material/styles";
+import { jsx as h, jsxs as g } from "react/jsx-runtime";
+import { color as _ } from "@pie-lib/render-ui";
+import v from "react-dom";
+//#region src/tools/circle/component.tsx
+var y = (e) => p({
+	"0%": { opacity: "0.0" },
+	"50%": { opacity: e },
+	"100%": { opacity: "0.0" }
+}), b = (e, t) => n(e).dist(n(t)), x = class extends c.Component {
+	static propTypes = {
+		building: l.bool,
+		className: l.string,
+		coordinatesOnHover: l.bool,
+		correctness: l.string,
+		from: d.PointType,
+		disabled: l.bool,
+		to: d.PointType,
+		middle: d.PointType,
+		onChange: l.func.isRequired,
+		onDragStart: l.func,
+		onDragStop: l.func,
+		graphProps: d.GraphPropsType.isRequired,
+		onClick: l.func,
+		labelNode: l.object,
+		labelModeEnabled: l.bool,
+		changeMarkProps: l.func,
+		limitLabeling: l.bool
+	};
+	static defaultProps = { onClick: () => ({}) };
+	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));
+	};
+	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
+		});
+	};
+	dragCircle = (e) => {
+		let { from: r, to: i, onChange: a, middle: o } = this.props, s = n(r).sub(n(e)), c = n(i).sub(s);
+		r.label && (e.label = r.label), i.label && (c.label = i.label);
+		let l = {
+			from: e,
+			to: c
+		};
+		o && (l.middle = {
+			...o,
+			...t(e, c)
+		}), this.setState({
+			draggedroot: void 0,
+			draggedOuter: void 0,
+			isCircleDrag: !1
+		}, () => a(l));
+	};
+	labelChange = (e, t) => {
+		let { changeMarkProps: n } = this.props, r = { ...e };
+		(!e.label || u(e.label)) && delete r.label, n({ [t]: r });
+	};
+	clickPoint = (e, n, i) => {
+		let { changeMarkProps: a, disabled: o, from: s, to: c, middle: l, labelModeEnabled: u, limitLabeling: d, onClick: f } = this.props;
+		if (!u) {
+			f(e || i);
+			return;
+		}
+		o || d || (n === "middle" && !e && s && c && (e = {
+			...e,
+			...t(s, c)
+		}), a({
+			from: r(s),
+			to: r(c),
+			middle: r(l),
+			[n]: {
+				label: "",
+				...e
+			}
+		}), this.input[n] && this.input[n].focus());
+	};
+	input = {};
+	render() {
+		let { from: e, to: t, middle: n, disabled: r, building: o, coordinatesOnHover: s, onDragStart: c, onDragStop: l, onClick: u, correctness: d, graphProps: p, labelNode: m, labelModeEnabled: _ } = this.props, y = {
+			onDragStart: c,
+			onDragStop: l,
+			graphProps: p,
+			onClick: u
+		};
+		t ||= e;
+		let x = b(e, t), C = null, w = null, T = null;
+		return m && (e?.label !== void 0 && (C = v.createPortal(/* @__PURE__ */ h(a, {
+			inputRef: (e) => this.input.from = e,
+			disabled: !_,
+			mark: e,
+			graphProps: p,
+			onChange: (t) => this.labelChange({
+				...e,
+				label: t
+			}, "from")
+		}), m)), t?.label !== void 0 && (w = v.createPortal(/* @__PURE__ */ h(a, {
+			inputRef: (e) => this.input.to = e,
+			disabled: !_,
+			mark: t,
+			graphProps: p,
+			onChange: (e) => this.labelChange({
+				...t,
+				label: e
+			}, "to")
+		}), m)), n?.label !== void 0 && (T = v.createPortal(/* @__PURE__ */ h(a, {
+			inputRef: (e) => this.input.middle = e,
+			disabled: !_,
+			mark: n,
+			graphProps: p,
+			onChange: (e) => this.labelChange({
+				...n,
+				label: e
+			}, "middle")
+		}), m))), /* @__PURE__ */ g("g", { children: [
+			/* @__PURE__ */ h(S, {
+				disabled: o || r,
+				correctness: d,
+				className: f(o && "bgCircleBuilding"),
+				x: e.x,
+				y: e.y,
+				radius: x,
+				onDrag: this.dragCircle,
+				...y,
+				onClick: (e) => this.clickPoint(n, "middle", e)
+			}),
+			T,
+			/* @__PURE__ */ h(i, {
+				disabled: o || r,
+				coordinatesOnHover: s,
+				correctness: d,
+				labelNode: m,
+				x: t.x,
+				y: t.y,
+				onDrag: this.dragTo,
+				...y,
+				onClick: (e) => this.clickPoint(t, "to", e)
+			}),
+			w,
+			/* @__PURE__ */ h(i, {
+				disabled: o || r,
+				coordinatesOnHover: s,
+				correctness: d,
+				labelNode: m,
+				x: e.x,
+				y: e.y,
+				className: "from",
+				onDrag: this.dragFrom,
+				...y,
+				onClick: (t) => this.clickPoint(e, "from", t)
+			}),
+			C
+		] });
+	}
+}, S = m(o)(() => ({
+	"&.outerLine": {
+		fill: _.transparent(),
+		stroke: _.defaults.BLACK,
+		strokeWidth: 4,
+		"&:hover": {
+			strokeWidth: 6,
+			stroke: _.defaults.PRIMARY_DARK
+		}
+	},
+	"&.bgCircleBuilding": {
+		stroke: _.defaults.BLACK,
+		animation: `${y("0.3")} 2s ease-out infinite`,
+		opacity: 1
+	}
+})), C = s(x);
+//#endregion
+export { C as default };

package/dist/tools/circle/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/circle/index.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+export declare const tool: () => {
+    type: string;
+    Component: {
+        (props: any): import("react").JSX.Element;
+        propTypes: {
+            onChange: import("prop-types").Requireable<(...args: any[]) => any>;
+            mark: import("prop-types").Requireable<object>;
+        };
+    };
+    hover: (point: any, mark: any) => any;
+    addPoint: (point: any, mark: any) => any;
+};

package/dist/tools/circle/index.js

@@ -0,0 +1,22 @@
+import { equalPoints as e } from "../../utils.js";
+import t from "./component.js";
+//#region src/tools/circle/index.ts
+var n = () => ({
+	type: "circle",
+	Component: t,
+	hover: (e, t) => ({
+		...t,
+		edge: e
+	}),
+	addPoint: (t, n) => n && e(n.root, t) ? n : n ? {
+		...n,
+		edge: t,
+		building: !1
+	} : {
+		type: "circle",
+		root: t,
+		building: !0
+	}
+});
+//#endregion
+export { n as tool };

package/dist/tools/exponential/component.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/exponential/component.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.
+ */
+declare const Component: {
+    (props: any): import("react").JSX.Element;
+    propTypes: {
+        onChange: import("prop-types").Requireable<(...args: any[]) => any>;
+        mark: import("prop-types").Requireable<object>;
+    };
+};
+export default Component;

package/dist/tools/exponential/component.js

@@ -0,0 +1,14 @@
+import { rootEdgeComponent as e, withRootEdge as t } from "../shared/line/with-root-edge.js";
+import n from "debug";
+import { buildDataPoints as r, exponentialFromTwoPoints as i } from "@pie-lib/graphing-utils";
+//#region src/tools/exponential/component.tsx
+var a = n("pie-lib:graphing:exponential"), o = e(t((e) => {
+	let { root: t, edge: n, graphProps: o } = e, { domain: s, range: c } = o, l = n && n.x === t.x ? [] : r(s, c, t, n, i(t, n), !0);
+	return a("dataPoints:", l), {
+		root: e.root,
+		edge: e.edge,
+		dataPoints: l
+	};
+}));
+//#endregion
+export { o as default };

package/dist/tools/exponential/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/exponential/index.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+export declare const tool: () => {
+    type: string;
+    Component: {
+        (props: any): import("react").JSX.Element;
+        propTypes: {
+            onChange: import("prop-types").Requireable<(...args: any[]) => any>;
+            mark: import("prop-types").Requireable<object>;
+        };
+    };
+    complete: (data: any, mark: any) => any;
+    addPoint: (point: any, mark: any) => any;
+};

package/dist/tools/exponential/index.js

@@ -0,0 +1,32 @@
+import { equalPoints as e, sameAxes as t } from "../../utils.js";
+import n from "./component.js";
+import r from "debug";
+//#region src/tools/exponential/index.ts
+var i = r("pie-lib:graphing:exponential"), a = () => ({
+	type: "exponential",
+	Component: n,
+	complete: (e, t) => ({
+		...t,
+		building: !1,
+		closed: !0
+	}),
+	addPoint: (n, r) => {
+		if (i("add point to exponential model: ", n, "mark: ", r), r && (e(r.root, n) || t(r.root, n)) || r && r.root.y * n.y < 0 || n.y === 0) return r;
+		if (!r) return {
+			type: "exponential",
+			root: n,
+			edge: void 0,
+			closed: !1,
+			building: !0
+		};
+		if (r && !r.root) throw Error("no root - should never happen");
+		return {
+			...r,
+			edge: n,
+			closed: !0,
+			building: !1
+		};
+	}
+});
+//#endregion
+export { a as tool };

package/dist/tools/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/index.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+import { tool as point } from './point/index.js';
+import { tool as circle } from './circle/index.js';
+import { tool as polygon } from './polygon/index.js';
+import { tool as sine } from './sine/index.js';
+import { tool as parabola } from './parabola/index.js';
+import { tool as line } from './line/index.js';
+import { tool as ray } from './ray/index.js';
+import { tool as vector } from './vector/index.js';
+import { tool as absolute } from './absolute/index.js';
+import { tool as exponential } from './exponential/index.js';
+declare const allTools: string[];
+declare const toolsArr: ({
+    type: any;
+    Component: any;
+    addPoint: (point: any, mark: any) => any;
+} | {
+    type: string;
+})[];
+export { allTools, toolsArr, circle, line, point, parabola, polygon, ray, sine, vector, absolute, exponential };

package/dist/tools/index.js

@@ -0,0 +1,55 @@
+import { __exportAll as e } from "../_virtual/_rolldown/runtime.js";
+import { tool as t } from "./point/index.js";
+import { tool as n } from "./circle/index.js";
+import { tool as r } from "./polygon/index.js";
+import { tool as i } from "./sine/index.js";
+import { tool as a } from "./parabola/index.js";
+import { tool as o } from "./line/index.js";
+import { tool as s } from "./segment/index.js";
+import { tool as c } from "./ray/index.js";
+import { tool as l } from "./vector/index.js";
+import { tool as u } from "./absolute/index.js";
+import { tool as d } from "./exponential/index.js";
+//#region src/tools/index.ts
+var f = /* @__PURE__ */ e({
+	absolute: () => u,
+	allTools: () => p,
+	circle: () => n,
+	exponential: () => d,
+	line: () => o,
+	parabola: () => a,
+	point: () => t,
+	polygon: () => r,
+	ray: () => c,
+	sine: () => i,
+	toolsArr: () => m,
+	vector: () => l
+}), p = [
+	"circle",
+	"line",
+	"label",
+	"parabola",
+	"point",
+	"polygon",
+	"ray",
+	"segment",
+	"sine",
+	"vector",
+	"absolute",
+	"exponential"
+], m = [
+	n(),
+	o(),
+	a(),
+	t(),
+	r(),
+	c(),
+	s(),
+	i(),
+	l(),
+	u(),
+	d(),
+	{ type: "label" }
+];
+//#endregion
+export { p as allTools, m as toolsArr, f as tools_exports };