@pie-lib/mask-markup 3.1.3 → 4.0.0-next.37

package/dist/drag-in-the-blank.js

@@ -0,0 +1,220 @@
+import { withMask as e } from "./with-mask.js";
+import t from "./choices/choice.js";
+import n from "./choices/index.js";
+import r from "./components/blank.js";
+import { closestDroppableKeyboardCoordinates as i } from "./keyboard-coordinates.js";
+import a from "react";
+import o from "prop-types";
+import { jsx as s, jsxs as c } from "react/jsx-runtime";
+import { DragProvider as l } from "@pie-lib/drag";
+import { DragOverlay as u, rectIntersection as d } from "@dnd-kit/core";
+//#region src/drag-in-the-blank.tsx
+var f = 250, p = e("blank", (e) => (t, n, i) => {
+	let a = t.data?.dataset || {};
+	if (a.component === "blank") {
+		let { disabled: o, duplicates: c, correctResponse: l, feedback: u, showCorrectAnswer: d, emptyResponseAreaWidth: f, emptyResponseAreaHeight: p, instanceId: m, isDragging: h, selectedItem: g, onSelectClick: _, onPlacementClick: v } = e, y = d ? l[a.id] : n[a.id], b = y && e.choices.find((e) => e.id === y);
+		return /* @__PURE__ */ s(r, {
+			correct: d || u && u[a.id],
+			disabled: o,
+			duplicates: c,
+			choice: b,
+			id: a.id,
+			emptyResponseAreaWidth: f,
+			emptyResponseAreaHeight: p,
+			onChange: (e, t) => {
+				let r = { ...n };
+				t === void 0 ? delete r[e] : r[e] = t, i(r);
+			},
+			instanceId: m,
+			isDragging: h,
+			selectedItem: g,
+			onSelectClick: _,
+			onPlacementClick: v
+		}, `${t.type}-${a.id}`);
+	}
+}), m = class extends a.Component {
+	constructor(e) {
+		super(e), this.state = {
+			activeDragItem: null,
+			dropAnimation: void 0,
+			selectedItem: null
+		}, this.lastDragEndAt = 0;
+	}
+	static propTypes = {
+		markup: o.string,
+		layout: o.object,
+		choicesPosition: o.string,
+		choices: o.array,
+		value: o.object,
+		onChange: o.func,
+		duplicates: o.bool,
+		disabled: o.bool,
+		feedback: o.object,
+		correctResponse: o.object,
+		showCorrectAnswer: o.bool,
+		emptyResponseAreaWidth: o.oneOfType([o.string, o.number]),
+		emptyResponseAreaHeight: o.oneOfType([o.string, o.number]),
+		instanceId: o.string
+	};
+	static defaultProps = { instanceId: "drag-in-the-blank" };
+	handleDragStart = (e) => {
+		let { active: t } = e;
+		t?.data?.current && this.setState({
+			activeDragItem: t.data.current,
+			dropAnimation: void 0,
+			selectedItem: t.data.current
+		});
+	};
+	renderDragOverlay = () => {
+		let { activeDragItem: e } = this.state;
+		return e && e.type === "MaskBlank" ? /* @__PURE__ */ s(t, {
+			disabled: e.disabled,
+			choice: e.choice,
+			instanceId: e.instanceId
+		}) : null;
+	};
+	commitPlacement = (e, t) => {
+		let { onChange: n, value: r } = this.props;
+		if (n) {
+			if (t === void 0) {
+				if (!e.fromChoice && e.id) {
+					let t = { ...r };
+					delete t[e.id], n(t);
+				}
+				return;
+			}
+			if (e.fromChoice === !0) {
+				let i = { ...r };
+				i[t] = e.choice.id, n(i);
+			} else if (e.id && e.id !== t) {
+				let i = { ...r };
+				i[t] = e.choice.id, delete i[e.id], n(i);
+			}
+		}
+	};
+	handleDragEnd = (e) => {
+		let { active: t, over: n } = e, r = t?.data?.current, i = n?.data?.current, a = !!t && !!n && r?.type === "MaskBlank" && i?.accepts?.includes("MaskBlank");
+		if (this.setState({
+			activeDragItem: null,
+			dropAnimation: a ? null : void 0
+		}), this.cancelSelection(), this.lastDragEndAt = Date.now(), !a) return;
+		let o = i.toChoiceBoard === !0 ? void 0 : i.id;
+		this.commitPlacement(r, o);
+	};
+	onDragCancel = () => {
+		this.setState({
+			activeDragItem: null,
+			dropAnimation: void 0
+		}), this.cancelSelection(), this.lastDragEndAt = Date.now();
+	};
+	isSameItem = (e, t) => !e || !t || e.fromChoice !== t.fromChoice ? !1 : e.fromChoice ? e.choice.id === t.choice.id : e.id === t.id;
+	toggleItemSelection = (e) => {
+		this.setState((t) => ({ selectedItem: this.isSameItem(t.selectedItem, e) ? null : e }));
+	};
+	cancelSelection = () => {
+		this.setState({ selectedItem: null });
+	};
+	endAnyLiveKeyboardDrag = () => {
+		this.state.activeDragItem && document.dispatchEvent(new KeyboardEvent("keydown", {
+			code: "Escape",
+			bubbles: !0,
+			cancelable: !0
+		}));
+	};
+	placeSelectedItem = (e) => {
+		let { selectedItem: t } = this.state;
+		t && (this.commitPlacement(t, e), this.cancelSelection(), this.endAnyLiveKeyboardDrag());
+	};
+	isClickSoonAfterDragEnd = () => Date.now() - this.lastDragEndAt < f;
+	onItemClick = (e) => {
+		this.isClickSoonAfterDragEnd() || (this.endAnyLiveKeyboardDrag(), this.toggleItemSelection(e));
+	};
+	onPlacementClick = (e) => {
+		this.isClickSoonAfterDragEnd() || this.placeSelectedItem(e);
+	};
+	getPositionDirection = (e) => {
+		let t, n, r;
+		switch (e) {
+			case "left":
+				t = "row", r = "center";
+				break;
+			case "right":
+				t = "row-reverse", n = "flex-end", r = "center";
+				break;
+			case "below":
+				t = "column-reverse";
+				break;
+			default:
+				t = "column";
+				break;
+		}
+		return {
+			flexDirection: t,
+			justifyContent: n,
+			alignItems: r
+		};
+	};
+	render() {
+		let { markup: e, duplicates: t, value: r, onChange: a, choicesPosition: o, choices: f, correctResponse: m, disabled: h, feedback: g, showCorrectAnswer: _, emptyResponseAreaWidth: v, emptyResponseAreaHeight: y, layout: b, instanceId: x } = this.props, S = o || "below", C = {
+			display: "flex",
+			minWidth: "100px",
+			...this.getPositionDirection(S)
+		};
+		return /* @__PURE__ */ s(l, {
+			onDragStart: this.handleDragStart,
+			onDragEnd: this.handleDragEnd,
+			onDragCancel: this.onDragCancel,
+			collisionDetection: d,
+			keyboardCoordinateGetter: i,
+			keyboardCodes: {
+				start: ["Space", "Enter"],
+				cancel: ["Escape"],
+				end: ["Space", "Enter"]
+			},
+			children: /* @__PURE__ */ c("div", {
+				ref: (e) => this.rootRef = e,
+				style: C,
+				children: [
+					/* @__PURE__ */ s(n, {
+						choicePosition: S,
+						choices: f,
+						value: r,
+						duplicates: t,
+						disabled: h,
+						instanceId: x,
+						selectedItem: this.state.selectedItem,
+						onSelectClick: this.onItemClick,
+						onPlacementClick: this.onPlacementClick
+					}),
+					/* @__PURE__ */ s(p, {
+						elementType: "drag-in-the-blank",
+						markup: e,
+						layout: b,
+						value: r,
+						choices: f,
+						onChange: a,
+						disabled: h,
+						duplicates: t,
+						feedback: g,
+						correctResponse: m,
+						showCorrectAnswer: _,
+						emptyResponseAreaWidth: v,
+						emptyResponseAreaHeight: y,
+						instanceId: x,
+						isDragging: !!this.state.activeDragItem,
+						selectedItem: this.state.selectedItem,
+						onSelectClick: this.onItemClick,
+						onPlacementClick: this.onPlacementClick
+					}),
+					/* @__PURE__ */ s(u, {
+						style: { pointerEvents: "none" },
+						dropAnimation: this.state.dropAnimation,
+						children: this.renderDragOverlay()
+					})
+				]
+			})
+		});
+	}
+};
+//#endregion
+export { m as default };

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @synced-from pie-lib/packages/mask-markup/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 { buildLayoutFromMarkup, withMask } from './with-mask.js';
+import DragInTheBlank from './drag-in-the-blank.js';
+import ConstructedResponse from './constructed-response.js';
+import Customizable from './customizable.js';
+import InlineDropdown from './inline-dropdown.js';
+import componentize from './componentize.js';
+export { withMask, buildLayoutFromMarkup, DragInTheBlank, ConstructedResponse, InlineDropdown, componentize, Customizable, };

package/dist/index.js

@@ -0,0 +1,7 @@
+import e from "./componentize.js";
+import { buildLayoutFromMarkup as t, withMask as n } from "./with-mask.js";
+import r from "./drag-in-the-blank.js";
+import i from "./constructed-response.js";
+import a from "./customizable.js";
+import o from "./inline-dropdown.js";
+export { i as ConstructedResponse, a as Customizable, r as DragInTheBlank, o as InlineDropdown, t as buildLayoutFromMarkup, e as componentize, n as withMask };

package/dist/inline-dropdown.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @synced-from pie-lib/packages/mask-markup/src/inline-dropdown.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';
+declare const _default: {
+    new (props: any): {
+        componentDidUpdate(prevProps: any): void;
+        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;
+        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: {
+        markup: import("prop-types").Requireable<string>;
+        layout: import("prop-types").Requireable<object>;
+        value: import("prop-types").Requireable<object>;
+        onChange: import("prop-types").Requireable<(...args: any[]) => any>;
+        customMarkMarkupComponent: import("prop-types").Requireable<(...args: any[]) => any>;
+        elementType: import("prop-types").Requireable<string>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/inline-dropdown.js

@@ -0,0 +1,24 @@
+import { withMask as e } from "./with-mask.js";
+import t from "./components/dropdown.js";
+import "react";
+import { jsx as n } from "react/jsx-runtime";
+//#region src/inline-dropdown.tsx
+var r = e("dropdown", (e) => (r, i, a) => {
+	let o = r.data && r.data.dataset || {};
+	if (o.component === "dropdown") {
+		let { choices: s, disabled: c, feedback: l, showCorrectAnswer: u } = e, d = s && s[o.id] && s[o.id].find((e) => e.correct), f = u ? d && d.value : i[o.id];
+		return /* @__PURE__ */ n(t, {
+			correct: l && l[o.id] && l[o.id] === "correct",
+			disabled: c || u,
+			value: f,
+			correctValue: u ? d && d.label : void 0,
+			id: o.id,
+			onChange: a,
+			choices: s[o.id],
+			showCorrectAnswer: u,
+			singleQuery: Object.keys(s).length == 1
+		}, `${r.type}-dropdown-${o.id}`);
+	}
+});
+//#endregion
+export { r as default };

package/dist/keyboard-coordinates.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @synced-from pie-lib/packages/mask-markup/src/keyboard-coordinates.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.
+ */
+/**
+ * Custom keyboard coordinate getter for drag-in-the-blank's Tab-based placement.
+ *
+ * Tab/Shift+Tab cycle the dragged item directly onto the next/previous enabled
+ * droppable — a blank (`mask-blank-drop-{id}`), sorted by on-screen position
+ * (top-to-bottom, then left-to-right, since blanks sit inline in flowing text rather
+ * than a simple list) — followed by the choice board as a fixed last stop (see below
+ * for why the board isn't sorted alongside the blanks).
+ *
+ * Arrow keys are delegated to dnd-kit's own `defaultKeyboardCoordinateGetter`, leaving
+ * the existing free-form arrow-key dragging behavior completely unchanged.
+ */
+export declare const closestDroppableKeyboardCoordinates: (event: any, { active, context, currentCoordinates }: {
+    active: any;
+    context: any;
+    currentCoordinates: any;
+}) => any;

package/dist/keyboard-coordinates.js

@@ -0,0 +1,49 @@
+import { KeyboardCode as e, defaultKeyboardCoordinateGetter as t } from "@dnd-kit/core";
+//#region src/keyboard-coordinates.ts
+var n = "drag-in-the-blank-droppable", r = (r, { active: a, context: o, currentCoordinates: s }) => {
+	let { code: c } = r, l = c === e.Tab, u = c === e.Down || c === e.Up || c === e.Left || c === e.Right;
+	if (!l && !u) return;
+	if (u) return t(r, {
+		context: o,
+		currentCoordinates: s
+	});
+	r.preventDefault();
+	let { droppableRects: d, droppableContainers: f, collisionRect: p } = o;
+	if (!d || d.size === 0) return s;
+	let m = a?.data?.current, h = m && m.fromChoice === !1 && m.id != null ? `mask-blank-drop-${m.id}` : void 0, g = [], _;
+	for (let [e, t] of f) {
+		if (t?.disabled || e === h) continue;
+		let r = t?.node?.current?.getBoundingClientRect() ?? d.get(e);
+		if (!r) continue;
+		let i = {
+			x: r.left + r.width / 2,
+			y: r.top + r.height / 2
+		}, a = p?.height ?? 0, o = {
+			id: e,
+			rect: r,
+			dropPosition: {
+				x: r.left,
+				y: r.top + r.height / 2 - a / 2
+			},
+			center: i
+		};
+		e === n ? _ = o : g.push(o);
+	}
+	if (g.length === 0 && !_) return s;
+	let v = r.shiftKey;
+	g.sort((e, t) => Math.abs(e.center.y - t.center.y) > 10 ? e.center.y - t.center.y : e.center.x - t.center.x), _ && g.push(_);
+	let y = p ? {
+		x: p.left + p.width / 2,
+		y: p.top + p.height / 2
+	} : s, b = g.findIndex((e) => y.x >= e.rect.left && y.x <= e.rect.right && y.y >= e.rect.top && y.y <= e.rect.bottom);
+	if (b === -1) {
+		let e = Infinity;
+		for (let t = 0; t < g.length; t++) {
+			let n = i(s, g[t].dropPosition);
+			n < e && (e = n, b = t);
+		}
+	}
+	return g[v ? (b - 1 + g.length) % g.length : (b + 1) % g.length].dropPosition;
+}, i = (e, t) => Math.sqrt((e.x - t.x) ** 2 + (e.y - t.y) ** 2);
+//#endregion
+export { r as closestDroppableKeyboardCoordinates };

package/dist/mask.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @synced-from pie-lib/packages/mask-markup/src/mask.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 renderChildren: (layout: any, value: any, onChange: any, rootRenderChildren: any, parentNode: any, elementType: any) => any[] | null;
+/**
+ * Renders a layout that uses the slate.js Value model structure.
+ */
+export default class Mask extends React.Component {
+    constructor(props: any);
+    static propTypes: {
+        renderChildren: PropTypes.Requireable<(...args: any[]) => any>;
+        layout: PropTypes.Requireable<object>;
+        value: PropTypes.Requireable<object>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        elementType: PropTypes.Requireable<string>;
+        containerRef: PropTypes.Requireable<NonNullable<((...args: any[]) => any) | PropTypes.InferProps<{
+            current: PropTypes.Requireable<Element>;
+        }> | null | undefined>>;
+    };
+    componentDidMount(): void;
+    handleChange: any;
+    render(): React.JSX.Element;
+}

package/dist/mask.js

@@ -0,0 +1,95 @@
+import { MARK_TAGS as e } from "./serialization.js";
+import t from "react";
+import n from "prop-types";
+import { get as r } from "@pie-element/shared-lodash";
+import { styled as i } from "@mui/material/styles";
+import { renderMath as a } from "@pie-element/shared-math-rendering-mathjax";
+import { jsx as o } from "react/jsx-runtime";
+//#region src/mask.tsx
+var s = i("div")(({ theme: e }) => ({
+	paddingTop: e.spacing(.5),
+	paddingBottom: e.spacing(.5)
+})), c = i("span")(() => ({
+	display: "inline-block",
+	width: ".75em"
+})), l = ["tbody", "tr"], u = (e, t) => {
+	let n = t.trim() === "", r = e && e.type;
+	if (!(n && l.includes(r))) return t;
+}, d = (e) => {
+	let t = e.leaves.find((e) => r(e, "marks", []).length);
+	return t ? t.marks : null;
+}, f = (t, n, r, i, a, l) => {
+	if (!n) return null;
+	let p = [];
+	return (t.nodes || []).forEach((t, m) => {
+		let h = t.type ? `${t.type}-${m}` : `${m}`;
+		if (t.isMath) return p.push(/* @__PURE__ */ o("span", { dangerouslySetInnerHTML: { __html: `<math displaystyle="true">${t.nodes[0].innerHTML}</math>` } })), p;
+		if (i) {
+			let e = i(t, n, r);
+			if (e) {
+				let n = t.data?.dataset?.component === "blank";
+				n && p.push(/* @__PURE__ */ o(c, {}, `spacer-${m}-before`)), p.push(e), n && p.push(/* @__PURE__ */ o(c, {}, `spacer-${m}-after`));
+				return;
+			}
+		}
+		if (t.object === "text") {
+			let n = t.leaves.reduce((e, t) => {
+				let n = t.text, r = u(a, n);
+				return r ? e + r : e;
+			}, ""), r = d(t);
+			if (r?.length > 0) {
+				let t = r.map((t) => Object.keys(e).find((n) => e[n] === t.type)).filter(Boolean);
+				t.length > 0 ? p.push(t.reduceRight((e, t, n) => /* @__PURE__ */ o(t, { children: e }, `${h}-${t}-${n}`), n)) : p.push(n);
+			} else n.length > 0 && p.push(n);
+		} else {
+			let e = f(t, n, r, i, t, l);
+			if (t.type === "p" || t.type === "paragraph") p.push(/* @__PURE__ */ o(s, { children: e }, h));
+			else {
+				let n = t.type;
+				t.nodes && t.nodes.length > 0 ? p.push(/* @__PURE__ */ o(n, {
+					...t.data.attributes,
+					children: e
+				}, h)) : p.push(/* @__PURE__ */ o(n, { ...t.data.attributes }, h));
+			}
+		}
+	}), p;
+}, p = i("div")(() => ({
+	display: "initial",
+	"&:not(.MathJax) table": { borderCollapse: "collapse" },
+	"&:not(.MathJax) table td, &:not(.MathJax) table th": {
+		padding: "8px 12px",
+		textAlign: "left"
+	}
+})), m = class extends t.Component {
+	constructor(e) {
+		super(e), this.internalContainerRef = t.createRef();
+	}
+	static propTypes = {
+		renderChildren: n.func,
+		layout: n.object,
+		value: n.object,
+		onChange: n.func,
+		elementType: n.string,
+		containerRef: n.oneOfType([n.func, n.shape({ current: n.instanceOf(Element) })])
+	};
+	componentDidMount() {
+		let e = this.props.containerRef || this.internalContainerRef;
+		e.current && typeof a == "function" && a(e.current);
+	}
+	handleChange = (e, t) => {
+		let n = {
+			...this.props.value,
+			[e]: t
+		};
+		this.props.onChange(n);
+	};
+	render() {
+		let { value: e, layout: t, elementType: n, containerRef: r } = this.props, i = f(t, e, this.handleChange, this.props.renderChildren, null, n);
+		return /* @__PURE__ */ o(p, {
+			ref: r || this.internalContainerRef,
+			children: i
+		});
+	}
+};
+//#endregion
+export { m as default, f as renderChildren };

package/dist/node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.js

@@ -0,0 +1,16 @@
+//#region ../../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+function e(t) {
+	var n, r, i = "";
+	if (typeof t == "string" || typeof t == "number") i += t;
+	else if (typeof t == "object") if (Array.isArray(t)) {
+		var a = t.length;
+		for (n = 0; n < a; n++) t[n] && (r = e(t[n])) && (i && (i += " "), i += r);
+	} else for (r in t) t[r] && (i && (i += " "), i += r);
+	return i;
+}
+function t() {
+	for (var t, n, r = 0, i = "", a = arguments.length; r < a; r++) (t = arguments[r]) && (n = e(t)) && (i && (i += " "), i += n);
+	return i;
+}
+//#endregion
+export { t as clsx, t as default };

package/dist/node_modules/.bun/to-style@1.3.3/node_modules/to-style/index.js

@@ -0,0 +1,17 @@
+import { __commonJSMin as e } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_prefixProperties as t } from "./src/prefixProperties.js";
+import { require_cssUnitless as n } from "./src/cssUnitless.js";
+import { require_toStyleObject as r } from "./src/toStyleObject.js";
+import { require_toStyleString as i } from "./src/toStyleString.js";
+//#region ../../../node_modules/.bun/to-style@1.3.3/node_modules/to-style/index.js
+var a = /* @__PURE__ */ e(((e, a) => {
+	a.exports = {
+		prefixProperties: t(),
+		cssUnitless: n(),
+		object: r(),
+		string: i()
+	};
+}));
+//#endregion
+export default a();
+export { a as require_to_style };

package/dist/node_modules/.bun/to-style@1.3.3/node_modules/to-style/src/cssPrefix.js

@@ -0,0 +1,9 @@
+import { __commonJSMin as e } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_prefixer as t } from "./prefixer.js";
+//#region ../../../node_modules/.bun/to-style@1.3.3/node_modules/to-style/src/cssPrefix.js
+var n = /* @__PURE__ */ e(((e, n) => {
+	n.exports = t()();
+}));
+//#endregion
+export default n();
+export { n as require_cssPrefix };

package/dist/node_modules/.bun/to-style@1.3.3/node_modules/to-style/src/cssUnitless.js

@@ -0,0 +1,26 @@
+"use exports";
+import { __commonJSMin as e } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../../node_modules/.bun/to-style@1.3.3/node_modules/to-style/src/cssUnitless.js
+var t = /* @__PURE__ */ e(((e, t) => {
+	t.exports = {
+		animation: 1,
+		"column-count": 1,
+		columns: 1,
+		"font-weight": 1,
+		opacity: 1,
+		"order  ": 1,
+		"z-index": 1,
+		zoom: 1,
+		flex: 1,
+		"box-flex": 1,
+		transform: 1,
+		perspective: 1,
+		"box-pack": 1,
+		"box-align": 1,
+		colspan: 1,
+		rowspan: 1
+	};
+}));
+//#endregion
+export default t();
+export { t as require_cssUnitless };

package/dist/node_modules/.bun/to-style@1.3.3/node_modules/to-style/src/hasOwn.js

@@ -0,0 +1,11 @@
+import { __commonJSMin as e } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../../node_modules/.bun/to-style@1.3.3/node_modules/to-style/src/hasOwn.js
+var t = /* @__PURE__ */ e(((e, t) => {
+	var n = Object.prototype.hasOwnProperty;
+	t.exports = function(e, t) {
+		return n.call(e, t);
+	};
+}));
+//#endregion
+export default t();
+export { t as require_hasOwn };

package/dist/node_modules/.bun/to-style@1.3.3/node_modules/to-style/src/isFunction.js

@@ -0,0 +1,11 @@
+import { __commonJSMin as e } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../../node_modules/.bun/to-style@1.3.3/node_modules/to-style/src/isFunction.js
+var t = /* @__PURE__ */ e(((e, t) => {
+	var n = Object.prototype.toString;
+	t.exports = function(e) {
+		return n.apply(e) === "[object Function]";
+	};
+}));
+//#endregion
+export default t();
+export { t as require_isFunction };

package/dist/node_modules/.bun/to-style@1.3.3/node_modules/to-style/src/isObject.js

@@ -0,0 +1,11 @@
+import { __commonJSMin as e } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../../node_modules/.bun/to-style@1.3.3/node_modules/to-style/src/isObject.js
+var t = /* @__PURE__ */ e(((e, t) => {
+	var n = Object.prototype.toString;
+	t.exports = function(e) {
+		return !!e && n.call(e) === "[object Object]";
+	};
+}));
+//#endregion
+export default t();
+export { t as require_isObject };

package/dist/node_modules/.bun/to-style@1.3.3/node_modules/to-style/src/prefixInfo.js

@@ -0,0 +1,24 @@
+import { __commonJSMin as e } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_toUpperFirst as t } from "./stringUtils/toUpperFirst.js";
+//#region ../../../node_modules/.bun/to-style@1.3.3/node_modules/to-style/src/prefixInfo.js
+var n = /* @__PURE__ */ e(((e, n) => {
+	var r = t(), i = /^(Moz|Webkit|Khtml|O|ms|Icab)(?=[A-Z])/, a = typeof document > "u" ? {} : document.documentElement.style;
+	n.exports = (function() {
+		var e = (function() {
+			for (var e in a) if (i.test(e)) return e.match(i)[0];
+			return "WebkitOpacity" in a ? "Webkit" : "KhtmlOpacity" in a ? "Khtml" : "";
+		})();
+		return {
+			style: e,
+			css: "-" + e.toLowerCase() + "-",
+			dom: {
+				Webkit: "WebKit",
+				ms: "MS",
+				o: "WebKit"
+			}[e] || r(e)
+		};
+	})();
+}));
+//#endregion
+export default n();
+export { n as require_prefixInfo };