@pie-lib/plot 4.0.3 → 4.0.4-next.0

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var e = Object.create, t = Object.defineProperty, n = Object.getOwnPropertyDescriptor, r = Object.getOwnPropertyNames, i = Object.getPrototypeOf, a = Object.prototype.hasOwnProperty, o = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports), s = (e, n) => {
+	let r = {};
+	for (var i in e) t(r, i, {
+		get: e[i],
+		enumerable: !0
+	});
+	return n || t(r, Symbol.toStringTag, { value: "Module" }), r;
+}, c = (e, i, o, s) => {
+	if (i && typeof i == "object" || typeof i == "function") for (var c = r(i), l = 0, u = c.length, d; l < u; l++) d = c[l], !a.call(e, d) && d !== o && t(e, d, {
+		get: ((e) => i[e]).bind(null, d),
+		enumerable: !(s = n(i, d)) || s.enumerable
+	});
+	return e;
+}, l = (n, r, a) => (a = n == null ? {} : e(i(n)), c(r || !n || !n.__esModule ? t(a, "default", {
+	value: n,
+	enumerable: !0
+}) : a, n)), u = /* @__PURE__ */ ((e) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(e, { get: (e, t) => (typeof require < "u" ? require : e)[t] }) : e)(function(e) {
+	if (typeof require < "u") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + e + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+export { o as __commonJSMin, s as __exportAll, u as __require, l as __toESM };

package/dist/draggable.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @synced-from pie-lib/packages/plot/src/draggable.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 Draggable, { DraggableCore } from 'react-draggable';
+export default class LocalDraggable extends Draggable {
+    componentWillReceiveProps(next: any): void;
+}
+export { DraggableCore };

package/dist/draggable.js

@@ -0,0 +1,13 @@
+import { __toESM as e } from "./_virtual/_rolldown/runtime.js";
+import { require_react_draggable as t } from "./node_modules/.bun/react-draggable@3.3.2/node_modules/react-draggable/dist/react-draggable.js";
+//#region src/draggable.tsx
+var n = /* @__PURE__ */ e(t(), 1), r = class extends n.default {
+	componentWillReceiveProps(e) {
+		super.componentWillReceiveProps(e), this.setState({
+			x: 0,
+			y: 0
+		});
+	}
+};
+//#endregion
+export { r as default, n as import_react_draggable };

package/dist/graph-props.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @synced-from pie-lib/packages/plot/src/graph-props.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 create: (domain: any, range: any, size: any, getRootNode: any) => {
+    scale: {
+        x: any;
+        y: any;
+    };
+    snap: {
+        x: (value: any) => any;
+        y: (value: any) => any;
+    };
+    domain: any;
+    range: any;
+    size: any;
+    getRootNode: any;
+};

package/dist/graph-props.js

@@ -0,0 +1,29 @@
+import { __toESM as e } from "./_virtual/_rolldown/runtime.js";
+import { require_browser as t } from "./node_modules/.bun/invariant@2.2.4/node_modules/invariant/browser.js";
+import { snapTo as n } from "./utils.js";
+import { scaleLinear as r } from "d3-scale";
+//#region src/graph-props.ts
+var i = /* @__PURE__ */ e(t(), 1), a = ({ min: e, max: t, step: n }) => ({
+	step: n,
+	min: parseInt(e / n) * n,
+	max: parseInt(t / n) * n
+}), o = (e, t, o, s) => {
+	(0, i.default)(e.min < e.max, "domain: min must be less than max"), (0, i.default)(t.min < t.max, "range: min must be less than max");
+	let c = a(e), l = a(t);
+	return {
+		scale: {
+			x: r().domain([e.min, e.max]).range([0, o.width]),
+			y: r().domain([t.max, t.min]).range([0, o.height])
+		},
+		snap: {
+			x: n.bind(null, c.min, c.max, c.step),
+			y: n.bind(null, l.min, l.max, l.step)
+		},
+		domain: e,
+		range: t,
+		size: o,
+		getRootNode: s
+	};
+};
+//#endregion
+export { o as create };

package/dist/grid-draggable.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @synced-from pie-lib/packages/plot/src/grid-draggable.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 const deltaFn: (scale: any, snap: any, val: any) => (delta: any) => number;
+/**
+ * Creates a Component that is draggable, within a bounded grid.
+ * @param {*} opts
+ */
+export declare const gridDraggable: (opts: any) => (Comp: any) => {
+    new (props: any): {
+        grid: any;
+        onStart: any;
+        position: any;
+        tiny: any;
+        getScaledBounds: any;
+        /**
+         * Retrieves the coordinates of a mouse or touch event relative to an SVG element.
+         * This method has been overwritten from the d3-selection library's clientPoint to handle touch events and improve clarity.
+         * @param {Element} node - The SVG element.
+         * @param {Event} event - The mouse or touch event.
+         * @returns {Array} - An array containing the coordinates [x, y] relative to the SVG element.
+         */
+        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;
+};

package/dist/grid-draggable.js

@@ -0,0 +1,168 @@
+import { __toESM as e } from "./_virtual/_rolldown/runtime.js";
+import { GraphPropsType as t } from "./types.js";
+import { require_browser as n } from "./node_modules/.bun/invariant@2.2.4/node_modules/invariant/browser.js";
+import { getDelta as r } from "./utils.js";
+import { import_react_draggable as i } from "./draggable.js";
+import a from "react";
+import o from "prop-types";
+import { pointer as s } from "d3-selection";
+import { jsx as c } from "react/jsx-runtime";
+import { isFunction as l } from "lodash-es";
+import u from "debug";
+//#region src/grid-draggable.tsx
+var d = /* @__PURE__ */ e(n(), 1), f = u("pie-lib:plot:grid-draggable"), p = (e, t, n) => (r) => {
+	let i = r + e(0);
+	return t(n + e.invert(i)).toFixed(4) * 1e3 / 1e3;
+}, m = (e) => (n) => ((0, d.default)(!!e && l(e.fromDelta) && l(e.bounds) && l(e.anchorPoint), "You must supply an object with: { anchorPoint: Function, fromDelta: Function, bounds: Function }"), class extends a.Component {
+	static propTypes = {
+		disabled: o.bool,
+		onDragStart: o.func,
+		onDrag: o.func,
+		onDragStop: o.func,
+		onClick: o.func,
+		onMove: o.func,
+		graphProps: t.isRequired
+	};
+	constructor(e) {
+		super(e), this.state = {
+			startX: null,
+			startY: null
+		};
+	}
+	grid = () => {
+		let { graphProps: e } = this.props, { scale: t, domain: n, range: r } = e;
+		return {
+			x: t.x(n.step) - t.x(0),
+			y: t.y(r.step) - t.y(0)
+		};
+	};
+	onStart = (e) => {
+		let { onDragStart: t } = this.props;
+		document.activeElement && document.activeElement.blur(), this._didDrag = !1, this.setState({
+			startX: e.clientX,
+			startY: e.clientY
+		});
+		let n = e.target, r = (e) => {
+			n.removeEventListener("click", r, !0), this._didDrag && (e.stopPropagation(), e.preventDefault());
+		};
+		n.addEventListener("click", r, !0), t && t();
+	};
+	position = () => {
+		let { x: t, y: n } = e.anchorPoint(this.props), { graphProps: r } = this.props, { scale: i, snap: a } = r;
+		return {
+			anchorPoint: {
+				x: t,
+				y: n
+			},
+			x: p(i.x, a.x, t),
+			y: p(i.y, a.y, n)
+		};
+	};
+	tiny = (e, t) => {
+		let n = e.toUpperCase(), r = Math.abs(t[`client${n}`] - this.state[`start${n}`]), i = r < Math.abs(this.grid()[e]) / 10;
+		return f("[tiny] key: ", e, "delta: ", r, "out: ", i), i;
+	};
+	getScaledBounds = () => {
+		let t = e.bounds(this.props, this.props.graphProps);
+		f("bounds: ", t);
+		let n = this.grid(), r = {
+			left: t.left * n.x,
+			right: t.right * n.x,
+			top: t.top * n.y,
+			bottom: t.bottom * n.y
+		}, i = Math.abs(n.y);
+		return r = {
+			...r,
+			top: Math.min(0, r.top) - i,
+			bottom: Math.abs(r.bottom) + i
+		}, f("[getScaledBounds]: ", r), r;
+	};
+	getClientPoint = (e, t) => {
+		if (!e || !t) return null;
+		let n = e.ownerSVGElement || e;
+		if (n && n.createSVGPoint) {
+			let r = n.createSVGPoint();
+			if (t.touches && t.touches.length > 0) {
+				let e = t.touches[0];
+				r.x = e.clientX, r.y = e.clientY;
+			} else r.x = t.clientX, r.y = t.clientY;
+			return e.getScreenCTM ? (r = r.matrixTransform(e.getScreenCTM().inverse()), [r.x, r.y]) : null;
+		}
+		let r = e.getBoundingClientRect();
+		return r ? [t.clientX - r.left - e.clientLeft, t.clientY - r.top - e.clientTop] : null;
+	};
+	skipDragOutsideOfBounds = (e, t, n) => {
+		let r = n.getRootNode(), i = this.getClientPoint(r, t);
+		if (i === null) return !0;
+		let [a, o] = i, { scale: s, domain: c, range: l } = n, u = s.x.invert(a), d = s.y.invert(o), f = e.deltaX > 0 && u < c.min || e.deltaX < 0 && u > c.max, p = e.deltaY > 0 && d > l.max || e.deltaY < 0 && d < l.min;
+		return f || p;
+	};
+	onDrag = (e, t) => {
+		let { onDrag: n, graphProps: r, disabled: i } = this.props;
+		if ((Math.abs(t.deltaX) > 1 || Math.abs(t.deltaY) > 1) && (this._didDrag = !0), !n || i) return;
+		let a = this.getScaledBounds();
+		if (t.deltaX < 0 && t.deltaX < a.left || t.deltaX > 0 && t.deltaX > a.right || t.deltaY < 0 && t.deltaY < a.top || t.deltaY > 0 && t.deltaY > a.bottom || this.skipDragOutsideOfBounds(t, e, r)) return;
+		let o = this.applyDelta({
+			x: t.deltaX,
+			y: t.deltaY
+		});
+		(o !== void 0 || o !== null) && n(o);
+	};
+	getDelta = (e) => {
+		let t = this.position(), n = {
+			x: t.x(e.x),
+			y: t.y(e.y)
+		};
+		return r(t.anchorPoint, n);
+	};
+	applyDelta = (t) => {
+		let n = this.getDelta(t);
+		return f("[applyDelta] delta:", n), e.fromDelta(this.props, n);
+	};
+	onStop = (e, t) => {
+		f("[onStop] dd:", t);
+		let { onDragStop: n, onClick: r, disabled: i } = this.props;
+		if (n && !i && n(), f("[onStop] lastX/Y: ", t.lastX, t.lastY), !this._didDrag) {
+			if (!i && typeof e?.stopPropagation == "function" && e.stopPropagation(), r) {
+				f("call onClick"), this.setState({
+					startX: null,
+					startY: null
+				});
+				let { graphProps: t } = this.props, { scale: n, snap: i } = t;
+				try {
+					let [t, a] = s(e, e.target), o = n.x.invert(t), c = n.y.invert(a);
+					o = i.x(o), c = i.y(c), r({
+						x: o,
+						y: c
+					});
+				} catch {
+					r({});
+				}
+			}
+			return !1;
+		}
+		return this.setState({
+			startX: null,
+			startY: null
+		}), !1;
+	};
+	render() {
+		let { disabled: t, onClick: r, ...a } = this.props, o = this.grid(), s = (e) => e.nativeEvent.preventDefault(), l = this.state ? !!this.state.startX : !1;
+		return /* @__PURE__ */ c(i.DraggableCore, {
+			onMouseDown: s,
+			onStart: this.onStart,
+			onDrag: this.onDrag,
+			onStop: this.onStop,
+			axis: e.axis || "both",
+			grid: [o.x, o.y],
+			children: /* @__PURE__ */ c(n, {
+				...a,
+				disabled: t,
+				isDragging: l,
+				onClick: l ? void 0 : r
+			})
+		});
+	}
+});
+//#endregion
+export { m as gridDraggable };

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @synced-from pie-lib/packages/plot/src/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 Root from './root.js';
+import Draggable from './draggable.js';
+import { gridDraggable } from './grid-draggable.js';
+import * as utils from './utils.js';
+import * as trig from './trig.js';
+import * as types from './types.js';
+import { create as createGraphProps } from './graph-props.js';
+export { Root, Draggable, gridDraggable, utils, trig, types, createGraphProps };

package/dist/index.js

@@ -0,0 +1,8 @@
+import { types_exports as e } from "./types.js";
+import { utils_exports as t } from "./utils.js";
+import n from "./root.js";
+import r from "./draggable.js";
+import { gridDraggable as i } from "./grid-draggable.js";
+import { trig_exports as a } from "./trig.js";
+import { create as o } from "./graph-props.js";
+export { r as Draggable, n as Root, o as createGraphProps, i as gridDraggable, a as trig, e as types, t as utils };

package/dist/label.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @synced-from pie-lib/packages/plot/src/label.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 const LabelComponent: {
+    (props: any): React.JSX.Element;
+    propTypes: {
+        disabledLabel: PropTypes.Requireable<boolean>;
+        graphHeight: PropTypes.Requireable<number>;
+        graphWidth: PropTypes.Requireable<number>;
+        isChartBottomLabel: PropTypes.Requireable<boolean>;
+        isDefineChartBottomLabel: PropTypes.Requireable<boolean>;
+        isChartLeftLabel: PropTypes.Requireable<boolean>;
+        isDefineChartLeftLabel: PropTypes.Requireable<boolean>;
+        placeholder: PropTypes.Requireable<string>;
+        text: PropTypes.Requireable<string>;
+        side: PropTypes.Requireable<string>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        mathMlOptions: PropTypes.Requireable<object>;
+        charactersLimit: PropTypes.Requireable<number>;
+        titleHeight: PropTypes.Requireable<number>;
+    };
+};
+export default LabelComponent;

package/dist/label.js

@@ -0,0 +1,132 @@
+import { extractTextFromHTML as e, isEmptyString as t } from "./utils.js";
+import { useState as n } from "react";
+import { styled as r } from "@mui/material/styles";
+import i from "prop-types";
+import * as a from "@pie-lib/render-ui";
+import { Readable as o } from "@pie-lib/render-ui";
+import { jsx as s } from "react/jsx-runtime";
+import c from "@pie-lib/editable-html-tip-tap";
+//#region src/label.tsx
+function l(e) {
+	return typeof e == "function" || typeof e == "object" && !!e && typeof e.$$typeof == "symbol";
+}
+function u(e, t) {
+	return !e || l(e) ? e : l(e.default) ? e.default : t && l(e[t]) ? e[t] : t && l(e[t]?.default) ? e[t].default : e;
+}
+var d = u(o, "Readable") || u(m.Readable, "Readable"), f = a, p = f.default, m = p && typeof p == "object" ? p : f, h = {
+	axisLabel: {
+		fontSize: 12,
+		textAlign: "center",
+		margin: 4,
+		padding: "4px 0"
+	},
+	chartLabel: {
+		fontSize: 16,
+		textAlign: "center",
+		margin: 4,
+		padding: "4px 0"
+	},
+	disabledLabel: {
+		pointerEvents: "none",
+		width: "100%"
+	},
+	editLabel: {
+		position: "absolute",
+		backgroundColor: "white",
+		borderRadius: 4,
+		boxShadow: "0px 5px 8px rgba(0,0,0,0.15)",
+		zIndex: 10
+	},
+	rotateLeftLabel: {
+		transform: "rotate(-90deg)",
+		transformOrigin: "0 0",
+		position: "absolute"
+	},
+	rotateRightLabel: {
+		transform: "rotate(90deg)",
+		transformOrigin: "0 0",
+		position: "absolute"
+	},
+	customBottom: { position: "absolute" },
+	displayNone: { display: "none" },
+	centerPlaceholder: { "& .ProseMirror p.is-editor-empty::before, & .ProseMirror div.is-editor-empty::before": {
+		left: 0,
+		right: 0,
+		width: "100%",
+		textAlign: "center"
+	} }
+}, g = r("div")({ ...h.centerPlaceholder }), _ = r("div")({
+	...h.disabledLabel,
+	"& p": { margin: 0 }
+}), v = (r) => {
+	let { disabledLabel: i, graphHeight: a, graphWidth: o, isChartBottomLabel: l, isDefineChartBottomLabel: u, isChartLeftLabel: f, isDefineChartLeftLabel: p, placeholder: m, text: v, side: y, onChange: b, mathMlOptions: x = {}, charactersLimit: S, titleHeight: C, preventNewLines: w } = r, [T, E] = n(!1), D = [
+		"bold",
+		"italic",
+		"underline",
+		"strikethrough",
+		"math"
+	], O = l || f || u || p, k = y === "left" && p && a - 220, A = {
+		width: k || (y === "left" || y === "right" ? a - 8 : o - 8),
+		top: k || f && `${a - 70}px` || y === "left" && `${a - 8}px` || l && `${a - 60 + C}px` || y === "bottom" && `${a - 120 + C}px` || 0,
+		left: y === "right" && `${o - 8}px` || (p || u) && "40px" || l && "-10px" || 0
+	}, j = {
+		width: o - 8,
+		top: y === "right" ? `${a - 22}px` : 0,
+		left: 0
+	}, M = () => {
+		!i && (y === "left" || y === "right") && E(!0);
+	}, N = () => {
+		E(!1), requestAnimationFrame(() => {
+			document.activeElement?.blur?.();
+		});
+	}, P = (e) => !!(w && e.key === "Enter");
+	return /* @__PURE__ */ s(d, {
+		false: !0,
+		children: /* @__PURE__ */ s(g, {
+			onClick: M,
+			style: {
+				...T ? j : A,
+				...O ? h.chartLabel : h.axisLabel,
+				...y === "left" && !T ? h.rotateLeftLabel : {},
+				...y === "right" && !T ? h.rotateRightLabel : {},
+				...T ? h.editLabel : {},
+				...l || u ? h.customBottom : {},
+				...i && !O && t(e(v)) && h.displayNone
+			},
+			children: i ? /* @__PURE__ */ s(_, { dangerouslySetInnerHTML: { __html: v || "" } }) : /* @__PURE__ */ s(c, {
+				markup: v || "",
+				onChange: b,
+				placeholder: !i && m,
+				toolbarOpts: {
+					position: y === "bottom" ? "top" : "bottom",
+					noPadding: !0,
+					noBorder: !0
+				},
+				disableScrollbar: !0,
+				activePlugins: D,
+				onDone: N,
+				onKeyDown: P,
+				mathMlOptions: x,
+				charactersLimit: S
+			})
+		})
+	});
+};
+v.propTypes = {
+	disabledLabel: i.bool,
+	graphHeight: i.number,
+	graphWidth: i.number,
+	isChartBottomLabel: i.bool,
+	isDefineChartBottomLabel: i.bool,
+	isChartLeftLabel: i.bool,
+	isDefineChartLeftLabel: i.bool,
+	placeholder: i.string,
+	text: i.string,
+	side: i.string,
+	onChange: i.func,
+	mathMlOptions: i.object,
+	charactersLimit: i.number,
+	titleHeight: i.number
+};
+//#endregion
+export { v as default };

package/dist/node_modules/.bun/invariant@2.2.4/node_modules/invariant/browser.js

@@ -0,0 +1,28 @@
+import { __commonJSMin as e } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../../node_modules/.bun/invariant@2.2.4/node_modules/invariant/browser.js
+var t = /* @__PURE__ */ e(((e, t) => {
+	t.exports = function(e, t, n, r, i, a, o, s) {
+		if (process.env.NODE_ENV !== "production" && t === void 0) throw Error("invariant requires an error message argument");
+		if (!e) {
+			var c;
+			if (t === void 0) c = /* @__PURE__ */ Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");
+			else {
+				var l = [
+					n,
+					r,
+					i,
+					a,
+					o,
+					s
+				], u = 0;
+				c = Error(t.replace(/%s/g, function() {
+					return l[u++];
+				})), c.name = "Invariant Violation";
+			}
+			throw c.framesToPop = 1, c;
+		}
+	};
+}));
+//#endregion
+export default t();
+export { t as require_browser };