@blenx-dev/components 0.0.0

package/dist/components/Splitter/splitter.js

@@ -0,0 +1,313 @@
+"use client";
+import clsx from "../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import { handle, handleHorizontal, handleVertical, panel, root, rootHorizontal, rootVertical } from "./splitter.css.js";
+import { jsx } from "react/jsx-runtime";
+import React, { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+//#region src/components/Splitter/splitter.tsx
+var InternalCtx = createContext(null);
+function useInternalCtx() {
+	const ctx = useContext(InternalCtx);
+	if (!ctx) throw new Error("Splitter compound components must be used within <Splitter>");
+	return ctx;
+}
+function isPanel(child) {
+	return React.isValidElement(child) && child.type === SplitterPanel;
+}
+function isHandle(child) {
+	return React.isValidElement(child) && child.type === SplitterHandle;
+}
+function calculateSizes(panelProps, storageKey) {
+	const count = panelProps.length;
+	if (count === 0) return [];
+	if (storageKey) try {
+		const stored = localStorage.getItem(storageKey);
+		if (stored) {
+			const parsed = JSON.parse(stored);
+			if (Array.isArray(parsed) && parsed.length === count) return parsed;
+		}
+	} catch {}
+	const result = Array.from({ length: count }, () => 0);
+	let usedSize = 0;
+	let unsetCount = count;
+	for (let i = 0; i < count; i++) {
+		const p = panelProps[i];
+		const sz = p?.size ?? p?.defaultSize;
+		if (sz != null) {
+			result[i] = sz;
+			usedSize += sz;
+			unsetCount--;
+		}
+	}
+	const equalShare = unsetCount > 0 ? (100 - usedSize) / unsetCount : 0;
+	for (let i = 0; i < count; i++) if (result[i] == null) result[i] = equalShare;
+	const total = result.reduce((a, b) => a + b, 0);
+	if (Math.abs(total - 100) > .01 && total > 0) for (let i = 0; i < count; i++) result[i] = result[i] / total * 100;
+	return result;
+}
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function Splitter({ orientation = "horizontal", disabled: isDisabled = false, storageKey, children, onResizeStart, onResize, onResizeEnd, className }) {
+	const rootRef = useRef(null);
+	const panelConstraintsRef = useRef([]);
+	const panelRefs = useRef([]);
+	const sizesRef = useRef([]);
+	const isFirstRender = useRef(true);
+	const onResizeStartRef = useRef(onResizeStart);
+	const onResizeRef = useRef(onResize);
+	const onResizeEndRef = useRef(onResizeEnd);
+	onResizeStartRef.current = onResizeStart;
+	onResizeRef.current = onResize;
+	onResizeEndRef.current = onResizeEnd;
+	const panelPropsList = useMemo(() => {
+		const list = [];
+		React.Children.forEach(children, (child) => {
+			if (isPanel(child)) list.push(child.props);
+		});
+		return list;
+	}, [children]);
+	const panelCount = panelPropsList.length;
+	const [sizes, setSizes] = useState(() => calculateSizes(panelPropsList, storageKey));
+	sizesRef.current = sizes;
+	const prevPanelCount = useRef(panelCount);
+	useEffect(() => {
+		if (prevPanelCount.current !== panelCount) {
+			prevPanelCount.current = panelCount;
+			setSizes(calculateSizes(panelPropsList, storageKey));
+		}
+	}, [
+		panelCount,
+		panelPropsList,
+		storageKey
+	]);
+	useEffect(() => {
+		if (isFirstRender.current) {
+			isFirstRender.current = false;
+			return;
+		}
+		if (storageKey) try {
+			localStorage.setItem(storageKey, JSON.stringify(sizes));
+		} catch {}
+	}, [storageKey, sizes]);
+	const handlePointerDown = useCallback((handleIndex, e) => {
+		if (isDisabled) return;
+		e.preventDefault();
+		const root = rootRef.current;
+		if (!root) return;
+		const rect = root.getBoundingClientRect();
+		const totalPx = orientation === "horizontal" ? rect.width : rect.height;
+		const startPos = orientation === "horizontal" ? e.clientX : e.clientY;
+		const availablePx = totalPx - (panelCount - 1) * 8;
+		if (availablePx <= 0) return;
+		const startSizes = [...sizesRef.current];
+		onResizeStartRef.current?.();
+		const onMove = (ev) => {
+			const deltaPct = ((orientation === "horizontal" ? ev.clientX : ev.clientY) - startPos) / availablePx * 100;
+			const newSizes = [...startSizes];
+			let left = (startSizes[handleIndex] ?? 0) + deltaPct;
+			let right = (startSizes[handleIndex + 1] ?? 0) - deltaPct;
+			const cLeft = panelConstraintsRef.current[handleIndex];
+			const cRight = panelConstraintsRef.current[handleIndex + 1];
+			const minL = cLeft?.minSize ?? 0;
+			const maxL = cLeft?.maxSize ?? 100;
+			const minR = cRight?.minSize ?? 0;
+			const maxR = cRight?.maxSize ?? 100;
+			if (left < minL) {
+				right += left - minL;
+				left = minL;
+			}
+			if (left > maxL) {
+				right -= left - maxL;
+				left = maxL;
+			}
+			if (right < minR) {
+				left -= minR - right;
+				right = minR;
+			}
+			if (right > maxR) {
+				left += right - maxR;
+				right = maxR;
+			}
+			left = clamp(left, minL, maxL);
+			right = clamp(right, minR, maxR);
+			newSizes[handleIndex] = left;
+			newSizes[handleIndex + 1] = right;
+			setSizes(newSizes);
+			onResizeRef.current?.(newSizes);
+		};
+		const onUp = () => {
+			document.removeEventListener("pointermove", onMove);
+			document.removeEventListener("pointerup", onUp);
+			document.body.style.userSelect = "";
+			document.body.style.pointerEvents = "";
+			onResizeEndRef.current?.([...sizesRef.current]);
+		};
+		document.addEventListener("pointermove", onMove);
+		document.addEventListener("pointerup", onUp);
+		document.body.style.userSelect = "none";
+		document.body.style.pointerEvents = "none";
+	}, [
+		isDisabled,
+		orientation,
+		panelCount
+	]);
+	const handleKeyDown = useCallback((handleIndex, e) => {
+		if (isDisabled) return;
+		let delta = 0;
+		const step = e.shiftKey ? 10 : 1;
+		if (orientation === "horizontal") {
+			if (e.key === "ArrowLeft") delta = -step;
+			else if (e.key === "ArrowRight") delta = step;
+		} else if (e.key === "ArrowUp") delta = -step;
+		else if (e.key === "ArrowDown") delta = step;
+		if (delta === 0) return;
+		e.preventDefault();
+		const currentSizes = sizesRef.current;
+		const newSizes = [...currentSizes];
+		let left = (currentSizes[handleIndex] ?? 0) + delta;
+		let right = (currentSizes[handleIndex + 1] ?? 0) - delta;
+		const cLeft = panelConstraintsRef.current[handleIndex];
+		const cRight = panelConstraintsRef.current[handleIndex + 1];
+		const minL = cLeft?.minSize ?? 0;
+		const maxL = cLeft?.maxSize ?? 100;
+		const minR = cRight?.minSize ?? 0;
+		const maxR = cRight?.maxSize ?? 100;
+		if (left < minL) {
+			right += left - minL;
+			left = minL;
+		}
+		if (left > maxL) {
+			right -= left - maxL;
+			left = maxL;
+		}
+		if (right < minR) {
+			left -= minR - right;
+			right = minR;
+		}
+		if (right > maxR) {
+			left += right - maxR;
+			right = maxR;
+		}
+		left = clamp(left, minL, maxL);
+		right = clamp(right, minR, maxR);
+		newSizes[handleIndex] = left;
+		newSizes[handleIndex + 1] = right;
+		setSizes(newSizes);
+		onResizeRef.current?.(newSizes);
+	}, [isDisabled, orientation]);
+	const ctxValue = useMemo(() => ({
+		orientation,
+		disabled: isDisabled,
+		sizes,
+		panelConstraintsRef,
+		panelRefs,
+		setSizes,
+		handlePointerDown,
+		handleKeyDown
+	}), [
+		orientation,
+		isDisabled,
+		sizes,
+		handlePointerDown,
+		handleKeyDown
+	]);
+	let panelIdx = 0;
+	let handleIdx = 0;
+	const mapped = React.Children.map(children, (child) => {
+		if (isPanel(child)) {
+			const idx = panelIdx++;
+			return /* @__PURE__ */ createElement(SplitterPanel, {
+				...child.props,
+				__panelIndex: idx,
+				key: child.key ?? `splitter-panel-${idx}`
+			});
+		}
+		if (isHandle(child)) {
+			const idx = handleIdx++;
+			return /* @__PURE__ */ createElement(SplitterHandle, {
+				...child.props,
+				__handleIndex: idx,
+				key: child.key ?? `splitter-handle-${idx}`
+			});
+		}
+		return child;
+	});
+	return /* @__PURE__ */ jsx(InternalCtx.Provider, {
+		value: ctxValue,
+		children: /* @__PURE__ */ jsx("div", {
+			ref: rootRef,
+			className: clsx(root, orientation === "horizontal" ? rootHorizontal : rootVertical, isDisabled && "w4j08r3", className),
+			"data-orientation": orientation,
+			children: mapped
+		})
+	});
+}
+function SplitterPanel({ defaultSize: _defaultSize, size: _size, minSize = 0, maxSize = 100, collapsible: _collapsible = false, collapsedSize: _collapsedSize = 0, children, className, __panelIndex }) {
+	const ctx = useInternalCtx();
+	const index = __panelIndex;
+	useEffect(() => {
+		const ref = ctx.panelConstraintsRef.current;
+		ref[index] = {
+			minSize,
+			maxSize
+		};
+		return () => {
+			ref[index] = void 0;
+		};
+	}, [
+		index,
+		minSize,
+		maxSize,
+		ctx.panelConstraintsRef
+	]);
+	const panelSize = ctx.sizes[index] ?? 0;
+	return /* @__PURE__ */ jsx("div", {
+		ref: (el) => {
+			ctx.panelRefs.current[index] = el;
+		},
+		className: clsx(panel, className),
+		style: { flex: `${panelSize} 0 0` },
+		"data-slot": "splitter-panel",
+		children
+	});
+}
+function SplitterHandle({ disabled: handleDisabled, className, __handleIndex }) {
+	const ctx = useInternalCtx();
+	const index = __handleIndex;
+	const [active, setActive] = useState(false);
+	const onPointerDown = useCallback((e) => {
+		if (handleDisabled || ctx.disabled) return;
+		setActive(true);
+		ctx.handlePointerDown(index, e);
+	}, [
+		handleDisabled,
+		ctx,
+		index
+	]);
+	const onKeyDown = useCallback((e) => {
+		ctx.handleKeyDown(index, e);
+	}, [ctx, index]);
+	useEffect(() => {
+		if (!active) return;
+		const onUp = () => setActive(false);
+		document.addEventListener("pointerup", onUp);
+		return () => document.removeEventListener("pointerup", onUp);
+	}, [active]);
+	const panelSize = ctx.sizes[index] ?? 0;
+	return /* @__PURE__ */ jsx("hr", {
+		tabIndex: handleDisabled || ctx.disabled ? -1 : 0,
+		"aria-orientation": ctx.orientation,
+		"aria-valuenow": Math.round(panelSize),
+		"aria-valuemin": 0,
+		"aria-valuemax": 100,
+		"aria-disabled": handleDisabled || ctx.disabled || void 0,
+		onPointerDown,
+		onKeyDown,
+		className: clsx(handle, ctx.orientation === "horizontal" ? handleHorizontal : handleVertical, active && "w4j08r6", (handleDisabled || ctx.disabled) && handleDisabled, className),
+		"data-slot": "splitter-handle"
+	});
+}
+Splitter.Panel = SplitterPanel;
+Splitter.Handle = SplitterHandle;
+//#endregion
+export { Splitter, SplitterHandle, SplitterPanel };

package/dist/components/Stack/stack.css.js

@@ -0,0 +1,44 @@
+/* empty css                                               */
+/* empty css                                             */
+import { createRuntimeFn } from "../../node_modules/.bun/@vanilla-extract_recipes@0.5.7_19e937df7e0b57ed/node_modules/@vanilla-extract/recipes/dist/createRuntimeFn-62c9670f.esm.js";
+/* empty css                     */
+//#region src/components/Stack/stack.css.ts
+var stackRecipe = createRuntimeFn({
+	defaultClassName: "_82zwcu0",
+	variantClassNames: {
+		gap: {
+			none: "_82zwcu1",
+			xxsmall: "_82zwcu2",
+			xsmall: "_82zwcu3",
+			small: "_82zwcu4",
+			medium: "_82zwcu5",
+			large: "_82zwcu6",
+			xlarge: "_82zwcu7",
+			xxlarge: "_82zwcu8",
+			xxxlarge: "_82zwcu9",
+			huge: "_82zwcua",
+			massive: "_82zwcub"
+		},
+		align: {
+			start: "_82zwcuc",
+			center: "_82zwcud",
+			end: "_82zwcue",
+			stretch: "_82zwcuf",
+			baseline: "_82zwcug"
+		},
+		justify: {
+			start: "_82zwcuh",
+			center: "_82zwcui",
+			end: "_82zwcuj",
+			between: "_82zwcuk",
+			around: "_82zwcul",
+			evenly: "_82zwcum",
+			stretch: "_82zwcun"
+		},
+		wrap: { true: "_82zwcuo" }
+	},
+	defaultVariants: { gap: "medium" },
+	compoundVariants: []
+});
+//#endregion
+export { stackRecipe };

package/dist/components/Stack/stack.js

@@ -0,0 +1,32 @@
+import clsx from "../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import { Box } from "../Box/box.js";
+import { stackRecipe } from "./stack.css.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/Stack/stack.tsx
+function Stack({ gap, align, justify, wrap, className, style, ...props }) {
+	return /* @__PURE__ */ jsx(Box, {
+		display: "flex",
+		className: clsx(stackRecipe({
+			gap,
+			align,
+			justify,
+			wrap
+		}), className),
+		style,
+		...props
+	});
+}
+function VStack(props) {
+	return /* @__PURE__ */ jsx(Stack, {
+		direction: "column",
+		...props
+	});
+}
+function HStack(props) {
+	return /* @__PURE__ */ jsx(Stack, {
+		direction: "row",
+		...props
+	});
+}
+//#endregion
+export { HStack, Stack, VStack };

package/dist/components/Surface/surface.css.js

@@ -0,0 +1,20 @@
+/* empty css                                               */
+import { createRuntimeFn } from "../../node_modules/.bun/@vanilla-extract_recipes@0.5.7_19e937df7e0b57ed/node_modules/@vanilla-extract/recipes/dist/createRuntimeFn-62c9670f.esm.js";
+/* empty css                       */
+//#region src/components/Surface/surface.css.ts
+var variantRecipe = createRuntimeFn({
+	defaultClassName: "_1vnk5c40",
+	variantClassNames: {
+		variant: {
+			"default": "_1vnk5c41",
+			outline: "_1vnk5c42",
+			raised: "_1vnk5c43",
+			sunken: "_1vnk5c44"
+		},
+		interactive: { true: "_1vnk5c45" }
+	},
+	defaultVariants: {},
+	compoundVariants: []
+});
+//#endregion
+export { variantRecipe };

package/dist/components/Surface/surface.js

@@ -0,0 +1,17 @@
+import clsx from "../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import { Box } from "../Box/box.js";
+import { variantRecipe } from "./surface.css.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/Surface/surface.tsx
+function Surface({ variant, interactive, className, style, ...props }) {
+	return /* @__PURE__ */ jsx(Box, {
+		className: clsx(variantRecipe({
+			variant,
+			interactive
+		}), className),
+		style,
+		...props
+	});
+}
+//#endregion
+export { Surface };

package/dist/components/Switch/switch.css.js

@@ -0,0 +1,11 @@
+/* empty css                                               */
+/* empty css                                             */
+/* empty css                      */
+//#region src/components/Switch/switch.css.ts
+var root = "dv64p10";
+var rootChecked = "dv64p11";
+var rootDisabled = "dv64p12";
+var thumb = "dv64p13";
+var thumbChecked = "dv64p14";
+//#endregion
+export { root, rootChecked, rootDisabled, thumb, thumbChecked };

package/dist/components/Switch/switch.js

@@ -0,0 +1,18 @@
+import clsx from "../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import { root, thumb } from "./switch.css.js";
+import { jsx } from "react/jsx-runtime";
+import { Switch } from "@base-ui/react/switch";
+//#region src/components/Switch/switch.tsx
+function Switch$1({ className, style, ...props }) {
+	return /* @__PURE__ */ jsx(Switch.Root, {
+		...props,
+		render: (renderProps, { checked, disabled }) => /* @__PURE__ */ jsx("span", {
+			...renderProps,
+			className: clsx(root, checked && "dv64p11", disabled && "dv64p12", className),
+			style,
+			children: /* @__PURE__ */ jsx(Switch.Thumb, { className: clsx(thumb, checked && "dv64p14") })
+		})
+	});
+}
+//#endregion
+export { Switch$1 as Switch };

package/dist/components/Table/table.css.js

@@ -0,0 +1,16 @@
+/* empty css                                               */
+/* empty css                                             */
+/* empty css                     */
+//#region src/components/Table/table.css.ts
+var root = "ksfrvb0";
+var head = "ksfrvb1";
+var header = "ksfrvb2";
+var row = "ksfrvb3";
+var cell = "ksfrvb4";
+var wrapper = "ksfrvb5";
+var alignLeft = "ksfrvb6";
+var alignCenter = "ksfrvb7";
+var alignRight = "ksfrvb8";
+var colorSecondary = "ksfrvb9";
+//#endregion
+export { alignCenter, alignLeft, alignRight, cell, colorSecondary, head, header, root, row, wrapper };

package/dist/components/Table/table.js

@@ -0,0 +1,44 @@
+import clsx from "../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import { alignCenter, alignLeft, alignRight, cell, head, header, root, row, wrapper } from "./table.css.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/Table/table.tsx
+var cellAlignMap = {
+	left: alignLeft,
+	center: alignCenter,
+	right: alignRight
+};
+function getCellValue(col, row) {
+	if (col?.cell) return col.cell(row);
+	return row[col.key];
+}
+function Table({ columnData, rowData, rowKey, getRowProps, style, className, color }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: clsx(wrapper, color && "ksfrvb9", className),
+		style,
+		children: /* @__PURE__ */ jsxs("table", {
+			className: clsx(root, color && "ksfrvb9"),
+			children: [/* @__PURE__ */ jsx("thead", {
+				className: head,
+				children: /* @__PURE__ */ jsx("tr", { children: columnData.map((col) => /* @__PURE__ */ jsx("th", {
+					style: col.width ? { width: col.width } : void 0,
+					className: clsx(header, col.align && cellAlignMap[col.align]),
+					children: col.header
+				}, col.key.toString())) })
+			}), /* @__PURE__ */ jsx("tbody", { children: rowData.map((dataRow, index) => {
+				const key = rowKey ? dataRow[rowKey] : index.toString();
+				const rowProps = getRowProps?.(dataRow, index);
+				return /* @__PURE__ */ jsx("tr", {
+					...rowProps,
+					className: clsx(row, rowProps?.className),
+					children: columnData.map((col) => /* @__PURE__ */ jsx("td", {
+						...col.cellProps,
+						className: clsx(cell, col.align && cellAlignMap[col.align], col.cellProps?.className || void 0),
+						children: getCellValue(col, dataRow)
+					}, col.key.toString()))
+				}, key);
+			}) })]
+		})
+	});
+}
+//#endregion
+export { Table };

package/dist/components/Tabs/tabs.css.js

@@ -0,0 +1,23 @@
+/* empty css                                               */
+/* empty css                                             */
+/* empty css                    */
+//#region src/components/Tabs/tabs.css.ts
+var root = "wawfqz0";
+var rootVertical = "wawfqz1";
+var list = "wawfqz2";
+var listUnderline = "wawfqz4";
+var tabUnderlineActive = "wawfqz8";
+var listGhost = "wawfqz9";
+var tabGhost = "wawfqza";
+var tabGhostActive = "wawfqzb";
+var listSegmented = "wawfqzc";
+var tabSegmented = "wawfqzd";
+var tabSegmentedActive = "wawfqze";
+var tab = "wawfqzf";
+var tabVertical = "wawfqzh";
+var tabDisabled = "wawfqzj";
+var tabUnderline = "wawfqzl";
+var panel = "wawfqzp";
+var panelVertical = "wawfqzq";
+//#endregion
+export { list, listGhost, listSegmented, listUnderline, panel, panelVertical, root, rootVertical, tab, tabDisabled, tabGhost, tabGhostActive, tabSegmented, tabSegmentedActive, tabUnderline, tabUnderlineActive, tabVertical };

package/dist/components/Tabs/tabs.js

@@ -0,0 +1,47 @@
+import clsx from "../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import { list, panel, root, tab } from "./tabs.css.js";
+import { jsx } from "react/jsx-runtime";
+import * as React$1 from "react";
+import { Tabs } from "@base-ui/react/tabs";
+//#region src/components/Tabs/tabs.tsx
+var DEFAULT_VARIANT = "underline";
+var TabsContext = React$1.createContext(null);
+function useTabsContext() {
+	return React$1.useContext(TabsContext) ?? { variant: DEFAULT_VARIANT };
+}
+function Tabs$1({ children, variant = DEFAULT_VARIANT, ...props }) {
+	const contextValue = React$1.useMemo(() => ({ variant }), [variant]);
+	return /* @__PURE__ */ jsx(TabsContext.Provider, {
+		value: contextValue,
+		children: /* @__PURE__ */ jsx(Tabs.Root, {
+			className: (state) => clsx(root, state.orientation === "vertical" && "wawfqz1"),
+			...props,
+			children
+		})
+	});
+}
+function TabsList({ className, ...props }) {
+	const { variant } = useTabsContext();
+	return /* @__PURE__ */ jsx(Tabs.List, {
+		className: clsx(list, variant === "underline" && "wawfqz4", variant === "ghost" && "wawfqz9", variant === "segmented" && "wawfqzc", className),
+		...props
+	});
+}
+function TabsTab({ className, ...props }) {
+	const { variant } = useTabsContext();
+	return /* @__PURE__ */ jsx(Tabs.Tab, {
+		className: (state) => clsx(tab, variant === "underline" && "wawfqzl", variant === "ghost" && "wawfqza", variant === "segmented" && "wawfqzd", state.orientation === "vertical" && "wawfqzh", state.active && variant === "underline" && "wawfqz8", state.active && variant === "ghost" && "wawfqzb", state.active && variant === "segmented" && "wawfqze", state.disabled && "wawfqzj", className),
+		...props
+	});
+}
+function TabsIndicator() {
+	return null;
+}
+function TabsPanel({ className, ...props }) {
+	return /* @__PURE__ */ jsx(Tabs.Panel, {
+		className: (state) => clsx(panel, state.orientation === "vertical" && "wawfqzq", className),
+		...props
+	});
+}
+//#endregion
+export { Tabs$1 as Tabs, TabsIndicator, TabsList, TabsPanel, TabsTab };

package/dist/components/Text/index.js

@@ -0,0 +1 @@
+import "./text.js";

package/dist/components/Text/text.css.js

@@ -0,0 +1,61 @@
+/* empty css                                               */
+/* empty css                                             */
+/* empty css                    */
+import { createRuntimeFn } from "../../node_modules/.bun/@vanilla-extract_recipes@0.5.7_19e937df7e0b57ed/node_modules/@vanilla-extract/recipes/dist/createRuntimeFn-62c9670f.esm.js";
+//#region src/components/Text/text.css.ts
+var textVariants = createRuntimeFn({
+	defaultClassName: "_1wmhbih0",
+	variantClassNames: {
+		variant: {
+			h1: "_1wmhbih1",
+			h2: "_1wmhbih2",
+			h3: "_1wmhbih3",
+			h4: "_1wmhbih4",
+			h5: "_1wmhbih5",
+			h6: "_1wmhbih6",
+			body1: "_1wmhbih7",
+			body2: "_1wmhbih8",
+			body3: "_1wmhbih9",
+			body4: "_1wmhbiha",
+			caption: "_1wmhbihb",
+			creatorNote: "_1wmhbihc",
+			p: "_1wmhbihd",
+			div: "_1wmhbihe",
+			code: "_1wmhbihf"
+		},
+		textAlign: {
+			left: "_1wmhbihg",
+			center: "_1wmhbihh",
+			right: "_1wmhbihi"
+		},
+		weight: {
+			regular: "_1wmhbihj",
+			medium: "_1wmhbihk",
+			semibold: "_1wmhbihl",
+			bold: "_1wmhbihm"
+		},
+		transform: {
+			uppercase: "_1wmhbihn",
+			capitalize: "_1wmhbiho",
+			none: "_1wmhbihp",
+			lowercase: "_1wmhbihq"
+		},
+		size: {
+			xxsmall: "_1wmhbihr",
+			xsmall: "_1wmhbihs",
+			small: "_1wmhbiht",
+			medium: "_1wmhbihu",
+			large: "_1wmhbihv",
+			xlarge: "_1wmhbihw",
+			xxlarge: "_1wmhbihx",
+			xxxlarge: "_1wmhbihy",
+			huge: "_1wmhbihz",
+			massive: "_1wmhbih10",
+			titanic: "_1wmhbih11"
+		}
+	},
+	defaultVariants: {},
+	compoundVariants: []
+});
+//#endregion
+export { textVariants };