santosp-rslib-project 1.0.1

package/dist/index.js

@@ -0,0 +1,1387 @@
+/*! For license information please see index.js.LICENSE.txt */
+import * as __rspack_external_react from "react";
+import { __webpack_require__ } from "./rslib-runtime.js";
+import clsx from "clsx";
+__webpack_require__.add({
+    "./node_modules/react/cjs/react-jsx-runtime.development.js" (__unused_rspack_module, exports, __webpack_require__) {
+        /**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ "production" !== process.env.NODE_ENV && function() {
+            function getComponentNameFromType(type) {
+                if (null == type) return null;
+                if ("function" == typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+                if ("string" == typeof type) return type;
+                switch(type){
+                    case REACT_FRAGMENT_TYPE:
+                        return "Fragment";
+                    case REACT_PROFILER_TYPE:
+                        return "Profiler";
+                    case REACT_STRICT_MODE_TYPE:
+                        return "StrictMode";
+                    case REACT_SUSPENSE_TYPE:
+                        return "Suspense";
+                    case REACT_SUSPENSE_LIST_TYPE:
+                        return "SuspenseList";
+                    case REACT_ACTIVITY_TYPE:
+                        return "Activity";
+                }
+                if ("object" == typeof type) switch("number" == typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof){
+                    case REACT_PORTAL_TYPE:
+                        return "Portal";
+                    case REACT_CONTEXT_TYPE:
+                        return type.displayName || "Context";
+                    case REACT_CONSUMER_TYPE:
+                        return (type._context.displayName || "Context") + ".Consumer";
+                    case REACT_FORWARD_REF_TYPE:
+                        var innerType = type.render;
+                        type = type.displayName;
+                        type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+                        return type;
+                    case REACT_MEMO_TYPE:
+                        return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+                    case REACT_LAZY_TYPE:
+                        innerType = type._payload;
+                        type = type._init;
+                        try {
+                            return getComponentNameFromType(type(innerType));
+                        } catch (x) {}
+                }
+                return null;
+            }
+            function testStringCoercion(value) {
+                return "" + value;
+            }
+            function checkKeyStringCoercion(value) {
+                try {
+                    testStringCoercion(value);
+                    var JSCompiler_inline_result = !1;
+                } catch (e) {
+                    JSCompiler_inline_result = !0;
+                }
+                if (JSCompiler_inline_result) {
+                    JSCompiler_inline_result = console;
+                    var JSCompiler_temp_const = JSCompiler_inline_result.error;
+                    var JSCompiler_inline_result$jscomp$0 = "function" == typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+                    JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+                    return testStringCoercion(value);
+                }
+            }
+            function getTaskName(type) {
+                if (type === REACT_FRAGMENT_TYPE) return "<>";
+                if ("object" == typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE) return "<...>";
+                try {
+                    var name = getComponentNameFromType(type);
+                    return name ? "<" + name + ">" : "<...>";
+                } catch (x) {
+                    return "<...>";
+                }
+            }
+            function getOwner() {
+                var dispatcher = ReactSharedInternals.A;
+                return null === dispatcher ? null : dispatcher.getOwner();
+            }
+            function UnknownOwner() {
+                return Error("react-stack-top-frame");
+            }
+            function hasValidKey(config) {
+                if (hasOwnProperty.call(config, "key")) {
+                    var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+                    if (getter && getter.isReactWarning) return !1;
+                }
+                return void 0 !== config.key;
+            }
+            function defineKeyPropWarningGetter(props, displayName) {
+                function warnAboutAccessingKey() {
+                    specialPropKeyWarningShown || (specialPropKeyWarningShown = !0, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+                }
+                warnAboutAccessingKey.isReactWarning = !0;
+                Object.defineProperty(props, "key", {
+                    get: warnAboutAccessingKey,
+                    configurable: !0
+                });
+            }
+            function elementRefGetterWithDeprecationWarning() {
+                var componentName = getComponentNameFromType(this.type);
+                didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = !0, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+                componentName = this.props.ref;
+                return void 0 !== componentName ? componentName : null;
+            }
+            function ReactElement(type, key, props, owner, debugStack, debugTask) {
+                var refProp = props.ref;
+                type = {
+                    $$typeof: REACT_ELEMENT_TYPE,
+                    type: type,
+                    key: key,
+                    props: props,
+                    _owner: owner
+                };
+                null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+                    enumerable: !1,
+                    get: elementRefGetterWithDeprecationWarning
+                }) : Object.defineProperty(type, "ref", {
+                    enumerable: !1,
+                    value: null
+                });
+                type._store = {};
+                Object.defineProperty(type._store, "validated", {
+                    configurable: !1,
+                    enumerable: !1,
+                    writable: !0,
+                    value: 0
+                });
+                Object.defineProperty(type, "_debugInfo", {
+                    configurable: !1,
+                    enumerable: !1,
+                    writable: !0,
+                    value: null
+                });
+                Object.defineProperty(type, "_debugStack", {
+                    configurable: !1,
+                    enumerable: !1,
+                    writable: !0,
+                    value: debugStack
+                });
+                Object.defineProperty(type, "_debugTask", {
+                    configurable: !1,
+                    enumerable: !1,
+                    writable: !0,
+                    value: debugTask
+                });
+                Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+                return type;
+            }
+            function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+                var children = config.children;
+                if (void 0 !== children) if (isStaticChildren) if (isArrayImpl(children)) {
+                    for(isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)validateChildKeys(children[isStaticChildren]);
+                    Object.freeze && Object.freeze(children);
+                } else console.error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+                else validateChildKeys(children);
+                if (hasOwnProperty.call(config, "key")) {
+                    children = getComponentNameFromType(type);
+                    var keys = Object.keys(config).filter(function(k) {
+                        return "key" !== k;
+                    });
+                    isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+                    didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error('A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />', isStaticChildren, children, keys, children), didWarnAboutKeySpread[children + isStaticChildren] = !0);
+                }
+                children = null;
+                void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+                hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+                if ("key" in config) {
+                    maybeKey = {};
+                    for(var propName in config)"key" !== propName && (maybeKey[propName] = config[propName]);
+                } else maybeKey = config;
+                children && defineKeyPropWarningGetter(maybeKey, "function" == typeof type ? type.displayName || type.name || "Unknown" : type);
+                return ReactElement(type, children, maybeKey, getOwner(), debugStack, debugTask);
+            }
+            function validateChildKeys(node) {
+                isValidElement(node) ? node._store && (node._store.validated = 1) : "object" == typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+            }
+            function isValidElement(object) {
+                return "object" == typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+            }
+            var React = __webpack_require__("react"), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+                return null;
+            };
+            React = {
+                react_stack_bottom_frame: function(callStackForError) {
+                    return callStackForError();
+                }
+            };
+            var specialPropKeyWarningShown;
+            var didWarnAboutElementRef = {};
+            var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(React, UnknownOwner)();
+            var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+            var didWarnAboutKeySpread = {};
+            exports.Fragment = REACT_FRAGMENT_TYPE;
+            exports.jsx = function(type, config, maybeKey) {
+                var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+                return jsxDEVImpl(type, config, maybeKey, !1, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+            };
+            exports.jsxs = function(type, config, maybeKey) {
+                var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+                return jsxDEVImpl(type, config, maybeKey, !0, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+            };
+        }();
+    },
+    "./node_modules/react/cjs/react-jsx-runtime.production.js" (__unused_rspack_module, exports) {
+        /**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+        function jsxProd(type, config, maybeKey) {
+            var key = null;
+            void 0 !== maybeKey && (key = "" + maybeKey);
+            void 0 !== config.key && (key = "" + config.key);
+            if ("key" in config) {
+                maybeKey = {};
+                for(var propName in config)"key" !== propName && (maybeKey[propName] = config[propName]);
+            } else maybeKey = config;
+            config = maybeKey.ref;
+            return {
+                $$typeof: REACT_ELEMENT_TYPE,
+                type: type,
+                key: key,
+                ref: void 0 !== config ? config : null,
+                props: maybeKey
+            };
+        }
+        exports.Fragment = REACT_FRAGMENT_TYPE;
+        exports.jsx = jsxProd;
+        exports.jsxs = jsxProd;
+    },
+    "./node_modules/react/jsx-runtime.js" (module, __unused_rspack_exports, __webpack_require__) {
+        if ('production' === process.env.NODE_ENV) module.exports = __webpack_require__("./node_modules/react/cjs/react-jsx-runtime.production.js");
+        else module.exports = __webpack_require__("./node_modules/react/cjs/react-jsx-runtime.development.js");
+    },
+    react (module) {
+        module.exports = __rspack_external_react;
+    }
+});
+function isObject(value) {
+    return "object" == typeof value && null != value && !Array.isArray(value);
+}
+var isObjectOrArray = (obj)=>"object" == typeof obj && null !== obj;
+function helpers_compact(value) {
+    return Object.fromEntries(Object.entries(value ?? {}).filter(([_, value2])=>void 0 !== value2));
+}
+var isBaseCondition = (v)=>"base" === v;
+function filterBaseConditions(c) {
+    return c.slice().filter((v)=>!isBaseCondition(v));
+}
+function toChar(code) {
+    return String.fromCharCode(code + (code > 25 ? 39 : 97));
+}
+function toName(code) {
+    let name = "";
+    let x;
+    for(x = Math.abs(code); x > 52; x = x / 52 | 0)name = toChar(x % 52) + name;
+    return toChar(x % 52) + name;
+}
+function toPhash(h, x) {
+    let i = x.length;
+    while(i)h = 33 * h ^ x.charCodeAt(--i);
+    return h;
+}
+function toHash(value) {
+    return toName(toPhash(5381, value) >>> 0);
+}
+var importantRegex = /\s*!(important)?/i;
+function isImportant(value) {
+    return "string" == typeof value ? importantRegex.test(value) : false;
+}
+function withoutImportant(value) {
+    return "string" == typeof value ? value.replace(importantRegex, "").trim() : value;
+}
+function withoutSpace(str) {
+    return "string" == typeof str ? str.replaceAll(" ", "_") : str;
+}
+var helpers_memo = (fn)=>{
+    const cache = /* @__PURE__ */ new Map();
+    const get = (...args)=>{
+        const key = JSON.stringify(args);
+        if (cache.has(key)) return cache.get(key);
+        const result = fn(...args);
+        cache.set(key, result);
+        return result;
+    };
+    return get;
+};
+var MERGE_OMIT = /* @__PURE__ */ new Set([
+    "__proto__",
+    "constructor",
+    "prototype"
+]);
+function helpers_mergeProps(...sources) {
+    return sources.reduce((prev, obj)=>{
+        if (!obj) return prev;
+        Object.keys(obj).forEach((key)=>{
+            if (MERGE_OMIT.has(key)) return;
+            const prevValue = prev[key];
+            const value = obj[key];
+            if (isObject(prevValue) && isObject(value)) prev[key] = helpers_mergeProps(prevValue, value);
+            else prev[key] = value;
+        });
+        return prev;
+    }, {});
+}
+var isNotNullish = (element)=>null != element;
+function walkObject(target, predicate, options = {}) {
+    const { stop, getKey } = options;
+    function inner(value, path = []) {
+        if (isObjectOrArray(value)) {
+            const result = {};
+            for (const [prop, child] of Object.entries(value)){
+                const key = getKey?.(prop, child) ?? prop;
+                const childPath = [
+                    ...path,
+                    key
+                ];
+                if (stop?.(value, childPath)) return predicate(value, path);
+                const next = inner(child, childPath);
+                if (isNotNullish(next)) result[key] = next;
+            }
+            return result;
+        }
+        return predicate(value, path);
+    }
+    return inner(target);
+}
+function mapObject(obj, fn) {
+    if (Array.isArray(obj)) return obj.map((value)=>fn(value));
+    if (!isObject(obj)) return fn(obj);
+    return walkObject(obj, (value)=>fn(value));
+}
+function toResponsiveObject(values, breakpoints) {
+    return values.reduce((acc, current, index)=>{
+        const key = breakpoints[index];
+        if (null != current) acc[key] = current;
+        return acc;
+    }, {});
+}
+function normalizeStyleObject(styles, context, shorthand = true) {
+    const { utility, conditions } = context;
+    const { hasShorthand, resolveShorthand } = utility;
+    return walkObject(styles, (value)=>Array.isArray(value) ? toResponsiveObject(value, conditions.breakpoints.keys) : value, {
+        stop: (value)=>Array.isArray(value),
+        getKey: shorthand ? (prop)=>hasShorthand ? resolveShorthand(prop) : prop : void 0
+    });
+}
+var fallbackCondition = {
+    shift: (v)=>v,
+    finalize: (v)=>v,
+    breakpoints: {
+        keys: []
+    }
+};
+var sanitize = (value)=>"string" == typeof value ? value.replaceAll(/[\n\s]+/g, " ") : value;
+function createCss(context) {
+    const { utility, hash, conditions: conds = fallbackCondition } = context;
+    const formatClassName = (str)=>[
+            utility.prefix,
+            str
+        ].filter(Boolean).join("-");
+    const hashFn = (conditions, className)=>{
+        let result;
+        if (hash) {
+            const baseArray = [
+                ...conds.finalize(conditions),
+                className
+            ];
+            result = formatClassName(utility.toHash(baseArray, toHash));
+        } else {
+            const baseArray = [
+                ...conds.finalize(conditions),
+                formatClassName(className)
+            ];
+            result = baseArray.join(":");
+        }
+        return result;
+    };
+    return helpers_memo(({ base, ...styles } = {})=>{
+        const styleObject = Object.assign(styles, base);
+        const normalizedObject = normalizeStyleObject(styleObject, context);
+        const classNames = /* @__PURE__ */ new Set();
+        walkObject(normalizedObject, (value, paths)=>{
+            if (null == value) return;
+            const important = isImportant(value);
+            const [prop, ...allConditions] = conds.shift(paths);
+            const conditions = filterBaseConditions(allConditions);
+            const transformed = utility.transform(prop, withoutImportant(sanitize(value)));
+            let className = hashFn(conditions, transformed.className);
+            if (important) className = `${className}!`;
+            classNames.add(className);
+        });
+        return Array.from(classNames).join(" ");
+    });
+}
+function compactStyles(...styles) {
+    return styles.flat().filter((style)=>isObject(style) && Object.keys(helpers_compact(style)).length > 0);
+}
+function createMergeCss(context) {
+    function resolve(styles) {
+        const allStyles = compactStyles(...styles);
+        if (1 === allStyles.length) return allStyles;
+        return allStyles.map((style)=>normalizeStyleObject(style, context));
+    }
+    function mergeCss(...styles) {
+        return helpers_mergeProps(...resolve(styles));
+    }
+    function assignCss(...styles) {
+        return Object.assign({}, ...resolve(styles));
+    }
+    return {
+        mergeCss: helpers_memo(mergeCss),
+        assignCss
+    };
+}
+var wordRegex = /([A-Z])/g;
+var msRegex = /^ms-/;
+var hypenateProperty = helpers_memo((property)=>{
+    if (property.startsWith("--")) return property;
+    return property.replace(wordRegex, "-$1").replace(msRegex, "-ms-").toLowerCase();
+});
+var fns = [
+    "min",
+    "max",
+    "clamp",
+    "calc"
+];
+var fnRegExp = new RegExp(`^(${fns.join("|")})\\(.*\\)`);
+var isCssFunction = (v)=>"string" == typeof v && fnRegExp.test(v);
+var lengthUnits = "cm,mm,Q,in,pc,pt,px,em,ex,ch,rem,lh,rlh,vw,vh,vmin,vmax,vb,vi,svw,svh,lvw,lvh,dvw,dvh,cqw,cqh,cqi,cqb,cqmin,cqmax,%";
+var lengthUnitsPattern = `(?:${lengthUnits.split(",").join("|")})`;
+var lengthRegExp = new RegExp(`^[+-]?[0-9]*.?[0-9]+(?:[eE][+-]?[0-9]+)?${lengthUnitsPattern}$`);
+var helpers_isCssUnit = (v)=>"string" == typeof v && lengthRegExp.test(v);
+var helpers_isCssVar = (v)=>"string" == typeof v && /^var\(--.+\)$/.test(v);
+var patternFns = {
+    map: mapObject,
+    isCssFunction: isCssFunction,
+    isCssVar: helpers_isCssVar,
+    isCssUnit: helpers_isCssUnit
+};
+var getPatternStyles = (pattern, styles)=>{
+    if (!pattern?.defaultValues) return styles;
+    const defaults = "function" == typeof pattern.defaultValues ? pattern.defaultValues(styles) : pattern.defaultValues;
+    return Object.assign({}, defaults, helpers_compact(styles));
+};
+function helpers_splitProps(props, ...keys) {
+    const descriptors = Object.getOwnPropertyDescriptors(props);
+    const dKeys = Object.keys(descriptors);
+    const split = (k)=>{
+        const clone = {};
+        for(let i = 0; i < k.length; i++){
+            const key = k[i];
+            if (descriptors[key]) {
+                Object.defineProperty(clone, key, descriptors[key]);
+                delete descriptors[key];
+            }
+        }
+        return clone;
+    };
+    const fn = (key)=>split(Array.isArray(key) ? key : dKeys.filter(key));
+    return keys.map(fn).concat(split(dKeys));
+}
+var helpers_uniq = (...items)=>{
+    const set = items.reduce((acc, currItems)=>{
+        if (currItems) currItems.forEach((item)=>acc.add(item));
+        return acc;
+    }, /* @__PURE__ */ new Set([]));
+    return Array.from(set);
+};
+var htmlProps = [
+    "htmlSize",
+    "htmlTranslate",
+    "htmlWidth",
+    "htmlHeight"
+];
+function convert(key) {
+    return htmlProps.includes(key) ? key.replace("html", "").toLowerCase() : key;
+}
+function normalizeHTMLProps(props) {
+    return Object.fromEntries(Object.entries(props).map(([key, value])=>[
+            convert(key),
+            value
+        ]));
+}
+normalizeHTMLProps.keys = htmlProps;
+const conditionsStr = "_hover,_focus,_focusWithin,_focusVisible,_disabled,_active,_visited,_target,_readOnly,_readWrite,_empty,_checked,_enabled,_expanded,_highlighted,_complete,_incomplete,_dragging,_before,_after,_firstLetter,_firstLine,_marker,_selection,_file,_backdrop,_first,_last,_only,_even,_odd,_firstOfType,_lastOfType,_onlyOfType,_peerFocus,_peerHover,_peerActive,_peerFocusWithin,_peerFocusVisible,_peerDisabled,_peerChecked,_peerInvalid,_peerExpanded,_peerPlaceholderShown,_groupFocus,_groupHover,_groupActive,_groupFocusWithin,_groupFocusVisible,_groupDisabled,_groupChecked,_groupExpanded,_groupInvalid,_indeterminate,_required,_valid,_invalid,_autofill,_inRange,_outOfRange,_placeholder,_placeholderShown,_pressed,_selected,_grabbed,_underValue,_overValue,_atValue,_default,_optional,_open,_closed,_fullscreen,_loading,_hidden,_current,_currentPage,_currentStep,_today,_unavailable,_rangeStart,_rangeEnd,_now,_topmost,_motionReduce,_motionSafe,_print,_landscape,_portrait,_dark,_light,_osDark,_osLight,_highContrast,_lessContrast,_moreContrast,_ltr,_rtl,_scrollbar,_scrollbarThumb,_scrollbarTrack,_horizontal,_vertical,_icon,_starting,_noscript,_invertedColors,sm,smOnly,smDown,md,mdOnly,mdDown,lg,lgOnly,lgDown,xl,xlOnly,xlDown,2xl,2xlOnly,2xlDown,smToMd,smToLg,smToXl,smTo2xl,mdToLg,mdToXl,mdTo2xl,lgToXl,lgTo2xl,xlTo2xl,@/xs,@/sm,@/md,@/lg,@/xl,@/2xl,@/3xl,@/4xl,@/5xl,@/6xl,@/7xl,@/8xl,base";
+const conditions_conditions = new Set(conditionsStr.split(','));
+const conditionRegex = /^@|&|&$/;
+function isCondition(value) {
+    return conditions_conditions.has(value) || conditionRegex.test(value);
+}
+const underscoreRegex = /^_/;
+const conditionsSelectorRegex = /&|@/;
+function finalizeConditions(paths) {
+    return paths.map((path)=>{
+        if (conditions_conditions.has(path)) return path.replace(underscoreRegex, '');
+        if (conditionsSelectorRegex.test(path)) return `[${withoutSpace(path.trim())}]`;
+        return path;
+    });
+}
+function sortConditions(paths) {
+    return paths.sort((a, b)=>{
+        const aa = isCondition(a);
+        const bb = isCondition(b);
+        if (aa && !bb) return 1;
+        if (!aa && bb) return -1;
+        return 0;
+    });
+}
+const utilities = "aspectRatio:asp,boxDecorationBreak:bx-db,zIndex:z,boxSizing:bx-s,objectPosition:obj-p,objectFit:obj-f,overscrollBehavior:ovs-b,overscrollBehaviorX:ovs-bx,overscrollBehaviorY:ovs-by,position:pos/1,top:top,left:left,inset:inset,insetInline:inset-x/insetX,insetBlock:inset-y/insetY,insetBlockEnd:inset-be,insetBlockStart:inset-bs,insetInlineEnd:inset-e/insetEnd/end,insetInlineStart:inset-s/insetStart/start,right:right,bottom:bottom,float:float,visibility:vis,display:d,hideFrom:hide,hideBelow:show,flexBasis:flex-b,flex:flex,flexDirection:flex-d/flexDir,flexGrow:flex-g,flexShrink:flex-sh,gridTemplateColumns:grid-tc,gridTemplateRows:grid-tr,gridColumn:grid-c,gridRow:grid-r,gridColumnStart:grid-cs,gridColumnEnd:grid-ce,gridAutoFlow:grid-af,gridAutoColumns:grid-ac,gridAutoRows:grid-ar,gap:gap,gridGap:grid-g,gridRowGap:grid-rg,gridColumnGap:grid-cg,rowGap:rg,columnGap:cg,justifyContent:jc,alignContent:ac,alignItems:ai,alignSelf:as,padding:p/1,paddingLeft:pl/1,paddingRight:pr/1,paddingTop:pt/1,paddingBottom:pb/1,paddingBlock:py/1/paddingY,paddingBlockEnd:pbe,paddingBlockStart:pbs,paddingInline:px/paddingX/1,paddingInlineEnd:pe/1/paddingEnd,paddingInlineStart:ps/1/paddingStart,marginLeft:ml/1,marginRight:mr/1,marginTop:mt/1,marginBottom:mb/1,margin:m/1,marginBlock:my/1/marginY,marginBlockEnd:mbe,marginBlockStart:mbs,marginInline:mx/1/marginX,marginInlineEnd:me/1/marginEnd,marginInlineStart:ms/1/marginStart,spaceX:sx,spaceY:sy,outlineWidth:ring-w/ringWidth,outlineColor:ring-c/ringColor,outline:ring/1,outlineOffset:ring-o/ringOffset,focusRing:focus-ring,focusVisibleRing:focus-v-ring,focusRingColor:focus-ring-c,focusRingOffset:focus-ring-o,focusRingWidth:focus-ring-w,focusRingStyle:focus-ring-s,divideX:dvd-x,divideY:dvd-y,divideColor:dvd-c,divideStyle:dvd-s,width:w/1,inlineSize:w-is,minWidth:min-w/minW,minInlineSize:min-w-is,maxWidth:max-w/maxW,maxInlineSize:max-w-is,height:h/1,blockSize:h-bs,minHeight:min-h/minH,minBlockSize:min-h-bs,maxHeight:max-h/maxH,maxBlockSize:max-b,boxSize:size,color:c,fontFamily:ff,fontSize:fs,fontSizeAdjust:fs-a,fontPalette:fp,fontKerning:fk,fontFeatureSettings:ff-s,fontWeight:fw,fontSmoothing:fsmt,fontVariant:fv,fontVariantAlternates:fv-alt,fontVariantCaps:fv-caps,fontVariationSettings:fv-s,fontVariantNumeric:fv-num,letterSpacing:ls,lineHeight:lh,textAlign:ta,textDecoration:td,textDecorationColor:td-c,textEmphasisColor:te-c,textDecorationStyle:td-s,textDecorationThickness:td-t,textUnderlineOffset:tu-o,textTransform:tt,textIndent:ti,textShadow:tsh,textShadowColor:tsh-c/textShadowColor,WebkitTextFillColor:wktf-c,textOverflow:tov,verticalAlign:va,wordBreak:wb,textWrap:tw,truncate:trunc,lineClamp:lc,listStyleType:li-t,listStylePosition:li-pos,listStyleImage:li-img,listStyle:li-s,backgroundPosition:bg-p/bgPosition,backgroundPositionX:bg-p-x/bgPositionX,backgroundPositionY:bg-p-y/bgPositionY,backgroundAttachment:bg-a/bgAttachment,backgroundClip:bg-cp/bgClip,background:bg/1,backgroundColor:bg-c/bgColor,backgroundOrigin:bg-o/bgOrigin,backgroundImage:bg-i/bgImage,backgroundRepeat:bg-r/bgRepeat,backgroundBlendMode:bg-bm/bgBlendMode,backgroundSize:bg-s/bgSize,backgroundGradient:bg-grad/bgGradient,backgroundLinear:bg-linear/bgLinear,backgroundRadial:bg-radial/bgRadial,backgroundConic:bg-conic/bgConic,textGradient:txt-grad,gradientFromPosition:grad-from-pos,gradientToPosition:grad-to-pos,gradientFrom:grad-from,gradientTo:grad-to,gradientVia:grad-via,gradientViaPosition:grad-via-pos,borderRadius:bdr/rounded,borderTopLeftRadius:bdr-tl/roundedTopLeft,borderTopRightRadius:bdr-tr/roundedTopRight,borderBottomRightRadius:bdr-br/roundedBottomRight,borderBottomLeftRadius:bdr-bl/roundedBottomLeft,borderTopRadius:bdr-t/roundedTop,borderRightRadius:bdr-r/roundedRight,borderBottomRadius:bdr-b/roundedBottom,borderLeftRadius:bdr-l/roundedLeft,borderStartStartRadius:bdr-ss/roundedStartStart,borderStartEndRadius:bdr-se/roundedStartEnd,borderStartRadius:bdr-s/roundedStart,borderEndStartRadius:bdr-es/roundedEndStart,borderEndEndRadius:bdr-ee/roundedEndEnd,borderEndRadius:bdr-e/roundedEnd,border:bd,borderWidth:bd-w,borderTopWidth:bd-t-w,borderLeftWidth:bd-l-w,borderRightWidth:bd-r-w,borderBottomWidth:bd-b-w,borderBlockStartWidth:bd-bs-w,borderBlockEndWidth:bd-be-w,borderColor:bd-c,borderInline:bd-x/borderX,borderInlineWidth:bd-x-w/borderXWidth,borderInlineColor:bd-x-c/borderXColor,borderBlock:bd-y/borderY,borderBlockWidth:bd-y-w/borderYWidth,borderBlockColor:bd-y-c/borderYColor,borderLeft:bd-l,borderLeftColor:bd-l-c,borderInlineStart:bd-s/borderStart,borderInlineStartWidth:bd-s-w/borderStartWidth,borderInlineStartColor:bd-s-c/borderStartColor,borderRight:bd-r,borderRightColor:bd-r-c,borderInlineEnd:bd-e/borderEnd,borderInlineEndWidth:bd-e-w/borderEndWidth,borderInlineEndColor:bd-e-c/borderEndColor,borderTop:bd-t,borderTopColor:bd-t-c,borderBottom:bd-b,borderBottomColor:bd-b-c,borderBlockEnd:bd-be,borderBlockEndColor:bd-be-c,borderBlockStart:bd-bs,borderBlockStartColor:bd-bs-c,opacity:op,boxShadow:bx-sh/shadow,boxShadowColor:bx-sh-c/shadowColor,mixBlendMode:mix-bm,filter:filter,brightness:brightness,contrast:contrast,grayscale:grayscale,hueRotate:hue-rotate,invert:invert,saturate:saturate,sepia:sepia,dropShadow:drop-shadow,blur:blur,backdropFilter:bkdp,backdropBlur:bkdp-blur,backdropBrightness:bkdp-brightness,backdropContrast:bkdp-contrast,backdropGrayscale:bkdp-grayscale,backdropHueRotate:bkdp-hue-rotate,backdropInvert:bkdp-invert,backdropOpacity:bkdp-opacity,backdropSaturate:bkdp-saturate,backdropSepia:bkdp-sepia,borderCollapse:bd-cl,borderSpacing:bd-sp,borderSpacingX:bd-sx,borderSpacingY:bd-sy,tableLayout:tbl,transitionTimingFunction:trs-tmf,transitionDelay:trs-dly,transitionDuration:trs-dur,transitionProperty:trs-prop,transition:trs,animation:anim,animationName:anim-n,animationTimingFunction:anim-tmf,animationDuration:anim-dur,animationDelay:anim-dly,animationPlayState:anim-ps,animationComposition:anim-comp,animationFillMode:anim-fm,animationDirection:anim-dir,animationIterationCount:anim-ic,animationRange:anim-r,animationState:anim-s,animationRangeStart:anim-rs,animationRangeEnd:anim-re,animationTimeline:anim-tl,transformOrigin:trf-o,transformBox:trf-b,transformStyle:trf-s,transform:trf,rotate:rotate,rotateX:rotate-x,rotateY:rotate-y,rotateZ:rotate-z,scale:scale,scaleX:scale-x,scaleY:scale-y,translate:translate,translateX:translate-x/x,translateY:translate-y/y,translateZ:translate-z/z,accentColor:ac-c,caretColor:ca-c,scrollBehavior:scr-bhv,scrollbar:scr-bar,scrollbarColor:scr-bar-c,scrollbarGutter:scr-bar-g,scrollbarWidth:scr-bar-w,scrollMargin:scr-m,scrollMarginLeft:scr-ml,scrollMarginRight:scr-mr,scrollMarginTop:scr-mt,scrollMarginBottom:scr-mb,scrollMarginBlock:scr-my/scrollMarginY,scrollMarginBlockEnd:scr-mbe,scrollMarginBlockStart:scr-mbt,scrollMarginInline:scr-mx/scrollMarginX,scrollMarginInlineEnd:scr-me,scrollMarginInlineStart:scr-ms,scrollPadding:scr-p,scrollPaddingBlock:scr-py/scrollPaddingY,scrollPaddingBlockStart:scr-pbs,scrollPaddingBlockEnd:scr-pbe,scrollPaddingInline:scr-px/scrollPaddingX,scrollPaddingInlineEnd:scr-pe,scrollPaddingInlineStart:scr-ps,scrollPaddingLeft:scr-pl,scrollPaddingRight:scr-pr,scrollPaddingTop:scr-pt,scrollPaddingBottom:scr-pb,scrollSnapAlign:scr-sa,scrollSnapStop:scrs-s,scrollSnapType:scrs-t,scrollSnapStrictness:scrs-strt,scrollSnapMargin:scrs-m,scrollSnapMarginTop:scrs-mt,scrollSnapMarginBottom:scrs-mb,scrollSnapMarginLeft:scrs-ml,scrollSnapMarginRight:scrs-mr,scrollSnapCoordinate:scrs-c,scrollSnapDestination:scrs-d,scrollSnapPointsX:scrs-px,scrollSnapPointsY:scrs-py,scrollSnapTypeX:scrs-tx,scrollSnapTypeY:scrs-ty,scrollTimeline:scrtl,scrollTimelineAxis:scrtl-a,scrollTimelineName:scrtl-n,touchAction:tch-a,userSelect:us,overflow:ov,overflowWrap:ov-wrap,overflowX:ov-x,overflowY:ov-y,overflowAnchor:ov-a,overflowBlock:ov-b,overflowInline:ov-i,overflowClipBox:ovcp-bx,overflowClipMargin:ovcp-m,overscrollBehaviorBlock:ovs-bb,overscrollBehaviorInline:ovs-bi,fill:fill,stroke:stk,strokeWidth:stk-w,strokeDasharray:stk-dsh,strokeDashoffset:stk-do,strokeLinecap:stk-lc,strokeLinejoin:stk-lj,strokeMiterlimit:stk-ml,strokeOpacity:stk-op,srOnly:sr,debug:debug,appearance:ap,backfaceVisibility:bfv,clipPath:cp-path,hyphens:hy,mask:msk,maskImage:msk-i,maskSize:msk-s,textSizeAdjust:txt-adj,container:cq,containerName:cq-n,containerType:cq-t,cursor:cursor,textStyle:textStyle";
+const classNameByProp = new Map();
+const shorthands = new Map();
+utilities.split(',').forEach((utility)=>{
+    const [prop, meta] = utility.split(':');
+    const [className, ...shorthandList] = meta.split('/');
+    classNameByProp.set(prop, className);
+    if (shorthandList.length) shorthandList.forEach((shorthand)=>{
+        shorthands.set('1' === shorthand ? className : shorthand, prop);
+    });
+});
+const css_resolveShorthand = (prop)=>shorthands.get(prop) || prop;
+const css_context = {
+    conditions: {
+        shift: sortConditions,
+        finalize: finalizeConditions,
+        breakpoints: {
+            keys: [
+                "base",
+                "sm",
+                "md",
+                "lg",
+                "xl",
+                "2xl"
+            ]
+        }
+    },
+    utility: {
+        prefix: "leve",
+        transform: (prop, value)=>{
+            const key = css_resolveShorthand(prop);
+            const propKey = classNameByProp.get(key) || hypenateProperty(key);
+            return {
+                className: `${propKey}_${withoutSpace(value)}`
+            };
+        },
+        hasShorthand: true,
+        toHash: (path, hashFn)=>hashFn(path.join(":")),
+        resolveShorthand: css_resolveShorthand
+    }
+};
+const cssFn = createCss(css_context);
+const css_css = (...styles)=>cssFn(css_mergeCss(...styles));
+css_css.raw = (...styles)=>css_mergeCss(...styles);
+const { mergeCss: css_mergeCss, assignCss: css_assignCss } = createMergeCss(css_context);
+function getCompoundVariantCss(compoundVariants, variantMap) {
+    let result = {};
+    compoundVariants.forEach((compoundVariant)=>{
+        const isMatching = Object.entries(compoundVariant).every(([key, value])=>{
+            if ('css' === key) return true;
+            const values = Array.isArray(value) ? value : [
+                value
+            ];
+            return values.some((value)=>variantMap[key] === value);
+        });
+        if (isMatching) result = css_mergeCss(result, compoundVariant.css);
+    });
+    return result;
+}
+function assertCompoundVariant(name, compoundVariants, variants, prop) {
+    if (compoundVariants.length > 0 && 'object' == typeof variants?.[prop]) throw new Error(`[recipe:${name}:${prop}] Conditions are not supported when using compound variants.`);
+}
+function cx_cx() {
+    let str = '', i = 0, arg;
+    for(; i < arguments.length;)if ((arg = arguments[i++]) && 'string' == typeof arg) {
+        str && (str += ' ');
+        str += arg;
+    }
+    return str;
+}
+const createRecipe = (name, defaultVariants, compoundVariants)=>{
+    const getVariantProps = (variants)=>({
+            [name]: '__ignore__',
+            ...defaultVariants,
+            ...helpers_compact(variants)
+        });
+    const recipeFn = (variants, withCompoundVariants = true)=>{
+        const transform = (prop, value)=>{
+            assertCompoundVariant(name, compoundVariants, variants, prop);
+            if ('__ignore__' === value) return {
+                className: name
+            };
+            value = withoutSpace(value);
+            return {
+                className: `${name}--${prop}_${value}`
+            };
+        };
+        const recipeCss = createCss({
+            conditions: {
+                shift: sortConditions,
+                finalize: finalizeConditions,
+                breakpoints: {
+                    keys: [
+                        "base",
+                        "sm",
+                        "md",
+                        "lg",
+                        "xl",
+                        "2xl"
+                    ]
+                }
+            },
+            utility: {
+                prefix: "leve",
+                toHash: (path, hashFn)=>hashFn(path.join(":")),
+                transform
+            }
+        });
+        const recipeStyles = getVariantProps(variants);
+        if (withCompoundVariants) {
+            const compoundVariantStyles = getCompoundVariantCss(compoundVariants, recipeStyles);
+            return cx_cx(recipeCss(recipeStyles), css_css(compoundVariantStyles));
+        }
+        return recipeCss(recipeStyles);
+    };
+    return {
+        recipeFn,
+        getVariantProps,
+        __getCompoundVariantCss__: (variants)=>getCompoundVariantCss(compoundVariants, getVariantProps(variants))
+    };
+};
+const mergeRecipes = (recipeA, recipeB)=>{
+    if (recipeA && !recipeB) return recipeA;
+    if (!recipeA && recipeB) return recipeB;
+    const recipeFn = (...args)=>cx_cx(recipeA(...args), recipeB(...args));
+    const variantKeys = helpers_uniq(recipeA.variantKeys, recipeB.variantKeys);
+    const variantMap = variantKeys.reduce((acc, key)=>{
+        acc[key] = helpers_uniq(recipeA.variantMap[key], recipeB.variantMap[key]);
+        return acc;
+    }, {});
+    return Object.assign(recipeFn, {
+        __recipe__: true,
+        __name__: `${recipeA.__name__} ${recipeB.__name__}`,
+        raw: (props)=>props,
+        variantKeys,
+        variantMap,
+        splitVariantProps (props) {
+            return helpers_splitProps(props, variantKeys);
+        }
+    });
+};
+const textRecipeFn = /* @__PURE__ */ createRecipe('leve-text', {
+    color: "dark",
+    size: "h6",
+    bold: false
+}, []);
+const textRecipeVariantMap = {
+    color: [
+        "primary",
+        "secondary",
+        "dark",
+        "light",
+        "purple",
+        "orange",
+        "red",
+        "yellow",
+        "sand",
+        "petrol",
+        "olive",
+        "lead",
+        "pink",
+        "neutral",
+        "green"
+    ],
+    size: [
+        "xxs",
+        "xs",
+        "sm",
+        "md",
+        "lg",
+        "h6",
+        "h5",
+        "h4",
+        "h3",
+        "h2",
+        "h1"
+    ],
+    bold: [
+        "true",
+        "false"
+    ],
+    truncate: [
+        "true",
+        "false"
+    ]
+};
+const textRecipeVariantKeys = Object.keys(textRecipeVariantMap);
+const textRecipe = /* @__PURE__ */ Object.assign(helpers_memo(textRecipeFn.recipeFn), {
+    __recipe__: true,
+    __name__: 'textRecipe',
+    __getCompoundVariantCss__: textRecipeFn.__getCompoundVariantCss__,
+    raw: (props)=>props,
+    variantKeys: textRecipeVariantKeys,
+    variantMap: textRecipeVariantMap,
+    merge (recipe) {
+        return mergeRecipes(this, recipe);
+    },
+    splitVariantProps (props) {
+        return helpers_splitProps(props, textRecipeVariantKeys);
+    },
+    getVariantProps: textRecipeFn.getVariantProps
+});
+const linkRecipeFn = /* @__PURE__ */ createRecipe('leve-link', {
+    color: "primary"
+}, []);
+const linkRecipeVariantMap = {
+    color: [
+        "primary",
+        "secondary",
+        "dark",
+        "light",
+        "purple",
+        "orange",
+        "red",
+        "yellow",
+        "sand",
+        "petrol",
+        "olive",
+        "lead",
+        "pink",
+        "neutral",
+        "green"
+    ],
+    disabled: [
+        "true"
+    ]
+};
+const linkRecipeVariantKeys = Object.keys(linkRecipeVariantMap);
+const linkRecipe = /* @__PURE__ */ Object.assign(helpers_memo(linkRecipeFn.recipeFn), {
+    __recipe__: true,
+    __name__: 'linkRecipe',
+    __getCompoundVariantCss__: linkRecipeFn.__getCompoundVariantCss__,
+    raw: (props)=>props,
+    variantKeys: linkRecipeVariantKeys,
+    variantMap: linkRecipeVariantMap,
+    merge (recipe) {
+        return mergeRecipes(this, recipe);
+    },
+    splitVariantProps (props) {
+        return helpers_splitProps(props, linkRecipeVariantKeys);
+    },
+    getVariantProps: linkRecipeFn.getVariantProps
+});
+const buttonRecipeFn = /* @__PURE__ */ createRecipe('leve-button', {
+    variant: "solid",
+    color: "primary",
+    size: "md"
+}, [
+    {
+        size: "sm",
+        icon: true,
+        css: {
+            width: "40px"
+        }
+    },
+    {
+        size: "md",
+        icon: true,
+        css: {
+            width: "48px",
+            _icon: {
+                width: "30px",
+                height: "30px"
+            }
+        }
+    }
+]);
+const buttonRecipeVariantMap = {
+    variant: [
+        "solid",
+        "outline",
+        "ghost"
+    ],
+    size: [
+        "sm",
+        "md"
+    ],
+    color: [
+        "primary",
+        "secondary",
+        "dark",
+        "light",
+        "purple",
+        "orange",
+        "red",
+        "yellow",
+        "sand",
+        "petrol",
+        "olive",
+        "lead",
+        "pink",
+        "neutral",
+        "green"
+    ],
+    icon: [
+        "true"
+    ]
+};
+const buttonRecipeVariantKeys = Object.keys(buttonRecipeVariantMap);
+const buttonRecipe = /* @__PURE__ */ Object.assign(helpers_memo(buttonRecipeFn.recipeFn), {
+    __recipe__: true,
+    __name__: 'buttonRecipe',
+    __getCompoundVariantCss__: buttonRecipeFn.__getCompoundVariantCss__,
+    raw: (props)=>props,
+    variantKeys: buttonRecipeVariantKeys,
+    variantMap: buttonRecipeVariantMap,
+    merge (recipe) {
+        return mergeRecipes(this, recipe);
+    },
+    splitVariantProps (props) {
+        return helpers_splitProps(props, buttonRecipeVariantKeys);
+    },
+    getVariantProps: buttonRecipeFn.getVariantProps
+});
+const jsx_runtime = __webpack_require__("./node_modules/react/jsx-runtime.js");
+const Button = (props)=>{
+    const { children, type = 'button', className, rightIcon, leftIcon, color, icon, size, variant, ...rest } = props;
+    return /*#__PURE__*/ (0, jsx_runtime.jsxs)("button", {
+        ...rest,
+        type: type,
+        className: clsx(buttonRecipe({
+            color,
+            icon,
+            size,
+            variant
+        }), className),
+        children: [
+            !icon && leftIcon,
+            children,
+            !icon && rightIcon
+        ]
+    });
+};
+const Text = (props)=>{
+    const { children, className, tag = 'h1', bold, color, size, truncate, ...rest } = props;
+    const Tag = tag;
+    return /*#__PURE__*/ (0, jsx_runtime.jsx)(Tag, {
+        ...rest,
+        className: clsx(textRecipe({
+            bold,
+            color,
+            size,
+            truncate
+        }), className),
+        children: children
+    });
+};
+const boxConfig = {
+    transform (props) {
+        return props;
+    }
+};
+const getBoxStyle = (styles = {})=>{
+    const _styles = getPatternStyles(boxConfig, styles);
+    return boxConfig.transform(_styles, patternFns);
+};
+const box = (styles)=>css_css(getBoxStyle(styles));
+box.raw = getBoxStyle;
+const flexConfig = {
+    transform (props) {
+        const { direction, align, justify, wrap: wrap2, basis, grow, shrink, ...rest } = props;
+        return {
+            display: "flex",
+            flexDirection: direction,
+            alignItems: align,
+            justifyContent: justify,
+            flexWrap: wrap2,
+            flexBasis: basis,
+            flexGrow: grow,
+            flexShrink: shrink,
+            ...rest
+        };
+    }
+};
+const getFlexStyle = (styles = {})=>{
+    const _styles = getPatternStyles(flexConfig, styles);
+    return flexConfig.transform(_styles, patternFns);
+};
+const flex = (styles)=>css_css(getFlexStyle(styles));
+flex.raw = getFlexStyle;
+const stackConfig = {
+    transform (props) {
+        const { align, justify, direction, gap, ...rest } = props;
+        return {
+            display: "flex",
+            flexDirection: direction,
+            alignItems: align,
+            justifyContent: justify,
+            gap,
+            ...rest
+        };
+    },
+    defaultValues: {
+        direction: 'column',
+        gap: '8px'
+    }
+};
+const getStackStyle = (styles = {})=>{
+    const _styles = getPatternStyles(stackConfig, styles);
+    return stackConfig.transform(_styles, patternFns);
+};
+const stack = (styles)=>css_css(getStackStyle(styles));
+stack.raw = getStackStyle;
+const vstackConfig = {
+    transform (props) {
+        const { justify, gap, ...rest } = props;
+        return {
+            display: "flex",
+            alignItems: "center",
+            justifyContent: justify,
+            gap,
+            flexDirection: "column",
+            ...rest
+        };
+    },
+    defaultValues: {
+        gap: '8px'
+    }
+};
+const getVstackStyle = (styles = {})=>{
+    const _styles = getPatternStyles(vstackConfig, styles);
+    return vstackConfig.transform(_styles, patternFns);
+};
+const vstack = (styles)=>css_css(getVstackStyle(styles));
+vstack.raw = getVstackStyle;
+const hstackConfig = {
+    transform (props) {
+        const { justify, gap, ...rest } = props;
+        return {
+            display: "flex",
+            alignItems: "center",
+            justifyContent: justify,
+            gap,
+            flexDirection: "row",
+            ...rest
+        };
+    },
+    defaultValues: {
+        gap: '8px'
+    }
+};
+const getHstackStyle = (styles = {})=>{
+    const _styles = getPatternStyles(hstackConfig, styles);
+    return hstackConfig.transform(_styles, patternFns);
+};
+const hstack = (styles)=>css_css(getHstackStyle(styles));
+hstack.raw = getHstackStyle;
+const spacerConfig = {
+    transform (props, { map }) {
+        const { size, ...rest } = props;
+        return {
+            alignSelf: "stretch",
+            justifySelf: "stretch",
+            flex: map(size, (v)=>null == v ? "1" : `0 0 ${v}`),
+            ...rest
+        };
+    }
+};
+const getSpacerStyle = (styles = {})=>{
+    const _styles = getPatternStyles(spacerConfig, styles);
+    return spacerConfig.transform(_styles, patternFns);
+};
+const spacer = (styles)=>css_css(getSpacerStyle(styles));
+spacer.raw = getSpacerStyle;
+const squareConfig = {
+    transform (props) {
+        const { size, ...rest } = props;
+        return {
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            flex: "0 0 auto",
+            width: size,
+            height: size,
+            ...rest
+        };
+    }
+};
+const getSquareStyle = (styles = {})=>{
+    const _styles = getPatternStyles(squareConfig, styles);
+    return squareConfig.transform(_styles, patternFns);
+};
+const square = (styles)=>css_css(getSquareStyle(styles));
+square.raw = getSquareStyle;
+const circleConfig = {
+    transform (props) {
+        const { size, ...rest } = props;
+        return {
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            flex: "0 0 auto",
+            width: size,
+            height: size,
+            borderRadius: "9999px",
+            ...rest
+        };
+    }
+};
+const getCircleStyle = (styles = {})=>{
+    const _styles = getPatternStyles(circleConfig, styles);
+    return circleConfig.transform(_styles, patternFns);
+};
+const circle = (styles)=>css_css(getCircleStyle(styles));
+circle.raw = getCircleStyle;
+const centerConfig = {
+    transform (props) {
+        const { inline, ...rest } = props;
+        return {
+            display: inline ? "inline-flex" : "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            ...rest
+        };
+    }
+};
+const getCenterStyle = (styles = {})=>{
+    const _styles = getPatternStyles(centerConfig, styles);
+    return centerConfig.transform(_styles, patternFns);
+};
+const center = (styles)=>css_css(getCenterStyle(styles));
+center.raw = getCenterStyle;
+const linkOverlayConfig = {
+    transform (props) {
+        return {
+            _before: {
+                content: '""',
+                position: "absolute",
+                inset: "0",
+                zIndex: "0",
+                ...props["_before"]
+            },
+            ...props
+        };
+    }
+};
+const getLinkOverlayStyle = (styles = {})=>{
+    const _styles = getPatternStyles(linkOverlayConfig, styles);
+    return linkOverlayConfig.transform(_styles, patternFns);
+};
+const linkOverlay = (styles)=>css_css(getLinkOverlayStyle(styles));
+linkOverlay.raw = getLinkOverlayStyle;
+const aspectRatioConfig = {
+    transform (props, { map }) {
+        const { ratio = 4 / 3, ...rest } = props;
+        return {
+            position: "relative",
+            _before: {
+                content: '""',
+                display: "block",
+                height: "0",
+                paddingBottom: map(ratio, (r)=>`${1 / r * 100}%`)
+            },
+            "&>*": {
+                display: "flex",
+                justifyContent: "center",
+                alignItems: "center",
+                overflow: "hidden",
+                position: "absolute",
+                inset: "0",
+                width: "100%",
+                height: "100%"
+            },
+            "&>img, &>video": {
+                objectFit: "cover"
+            },
+            ...rest
+        };
+    }
+};
+const getAspectRatioStyle = (styles = {})=>{
+    const _styles = getPatternStyles(aspectRatioConfig, styles);
+    return aspectRatioConfig.transform(_styles, patternFns);
+};
+const aspectRatio = (styles)=>css_css(getAspectRatioStyle(styles));
+aspectRatio.raw = getAspectRatioStyle;
+const gridConfig = {
+    transform (props, { map, isCssUnit }) {
+        const { columnGap, rowGap, gap, columns, minChildWidth, ...rest } = props;
+        const getValue = (v)=>isCssUnit(v) ? v : `token(sizes.${v}, ${v})`;
+        return {
+            display: "grid",
+            gridTemplateColumns: null != columns ? map(columns, (v)=>`repeat(${v}, minmax(0, 1fr))`) : null != minChildWidth ? map(minChildWidth, (v)=>`repeat(auto-fit, minmax(${getValue(v)}, 1fr))`) : void 0,
+            gap,
+            columnGap,
+            rowGap,
+            ...rest
+        };
+    },
+    defaultValues (props) {
+        return {
+            gap: props.columnGap || props.rowGap ? void 0 : "8px"
+        };
+    }
+};
+const getGridStyle = (styles = {})=>{
+    const _styles = getPatternStyles(gridConfig, styles);
+    return gridConfig.transform(_styles, patternFns);
+};
+const grid = (styles)=>css_css(getGridStyle(styles));
+grid.raw = getGridStyle;
+const gridItemConfig = {
+    transform (props, { map }) {
+        const { colSpan, rowSpan, colStart, rowStart, colEnd, rowEnd, ...rest } = props;
+        const spanFn = (v)=>"auto" === v ? v : `span ${v}`;
+        return {
+            gridColumn: null != colSpan ? map(colSpan, spanFn) : void 0,
+            gridRow: null != rowSpan ? map(rowSpan, spanFn) : void 0,
+            gridColumnStart: colStart,
+            gridColumnEnd: colEnd,
+            gridRowStart: rowStart,
+            gridRowEnd: rowEnd,
+            ...rest
+        };
+    }
+};
+const getGridItemStyle = (styles = {})=>{
+    const _styles = getPatternStyles(gridItemConfig, styles);
+    return gridItemConfig.transform(_styles, patternFns);
+};
+const gridItem = (styles)=>css_css(getGridItemStyle(styles));
+gridItem.raw = getGridItemStyle;
+const wrapConfig = {
+    transform (props) {
+        const { columnGap, rowGap, gap = columnGap || rowGap ? void 0 : "8px", align, justify, ...rest } = props;
+        return {
+            display: "flex",
+            flexWrap: "wrap",
+            alignItems: align,
+            justifyContent: justify,
+            gap,
+            columnGap,
+            rowGap,
+            ...rest
+        };
+    }
+};
+const getWrapStyle = (styles = {})=>{
+    const _styles = getPatternStyles(wrapConfig, styles);
+    return wrapConfig.transform(_styles, patternFns);
+};
+const wrap = (styles)=>css_css(getWrapStyle(styles));
+wrap.raw = getWrapStyle;
+const containerConfig = {
+    transform (props) {
+        return {
+            position: "relative",
+            maxWidth: "8xl",
+            mx: "auto",
+            px: {
+                base: "4",
+                md: "6",
+                lg: "8"
+            },
+            ...props
+        };
+    }
+};
+const getContainerStyle = (styles = {})=>{
+    const _styles = getPatternStyles(containerConfig, styles);
+    return containerConfig.transform(_styles, patternFns);
+};
+const container = (styles)=>css_css(getContainerStyle(styles));
+container.raw = getContainerStyle;
+const dividerConfig = {
+    transform (props, { map }) {
+        const { orientation, thickness, color, ...rest } = props;
+        return {
+            "--thickness": thickness,
+            width: map(orientation, (v)=>"vertical" === v ? void 0 : "100%"),
+            height: map(orientation, (v)=>"horizontal" === v ? void 0 : "100%"),
+            borderBlockEndWidth: map(orientation, (v)=>"horizontal" === v ? "var(--thickness)" : void 0),
+            borderInlineEndWidth: map(orientation, (v)=>"vertical" === v ? "var(--thickness)" : void 0),
+            borderColor: color,
+            ...rest
+        };
+    },
+    defaultValues: {
+        orientation: 'horizontal',
+        thickness: '1px'
+    }
+};
+const getDividerStyle = (styles = {})=>{
+    const _styles = getPatternStyles(dividerConfig, styles);
+    return dividerConfig.transform(_styles, patternFns);
+};
+const divider = (styles)=>css_css(getDividerStyle(styles));
+divider.raw = getDividerStyle;
+const floatConfig = {
+    transform (props, { map }) {
+        const { offset, offsetX, offsetY, placement, ...rest } = props;
+        return {
+            display: "inline-flex",
+            justifyContent: "center",
+            alignItems: "center",
+            position: "absolute",
+            insetBlockStart: map(placement, (v)=>{
+                const [side] = v.split("-");
+                const map2 = {
+                    top: offsetY,
+                    middle: "50%",
+                    bottom: "auto"
+                };
+                return map2[side];
+            }),
+            insetBlockEnd: map(placement, (v)=>{
+                const [side] = v.split("-");
+                const map2 = {
+                    top: "auto",
+                    middle: "50%",
+                    bottom: offsetY
+                };
+                return map2[side];
+            }),
+            insetInlineStart: map(placement, (v)=>{
+                const [, align] = v.split("-");
+                const map2 = {
+                    start: offsetX,
+                    center: "50%",
+                    end: "auto"
+                };
+                return map2[align];
+            }),
+            insetInlineEnd: map(placement, (v)=>{
+                const [, align] = v.split("-");
+                const map2 = {
+                    start: "auto",
+                    center: "50%",
+                    end: offsetX
+                };
+                return map2[align];
+            }),
+            translate: map(placement, (v)=>{
+                const [side, align] = v.split("-");
+                const mapX = {
+                    start: "-50%",
+                    center: "-50%",
+                    end: "50%"
+                };
+                const mapY = {
+                    top: "-50%",
+                    middle: "-50%",
+                    bottom: "50%"
+                };
+                return `${mapX[align]} ${mapY[side]}`;
+            }),
+            ...rest
+        };
+    },
+    defaultValues (props) {
+        const offset = props.offset || "0";
+        return {
+            offset,
+            offsetX: offset,
+            offsetY: offset,
+            placement: "top-end"
+        };
+    }
+};
+const getFloatStyle = (styles = {})=>{
+    const _styles = getPatternStyles(floatConfig, styles);
+    return floatConfig.transform(_styles, patternFns);
+};
+const float_float = (styles)=>css_css(getFloatStyle(styles));
+float_float.raw = getFloatStyle;
+const bleedConfig = {
+    transform (props, { map, isCssUnit, isCssVar }) {
+        const { inline, block, ...rest } = props;
+        const valueFn = (v)=>isCssUnit(v) || isCssVar(v) ? v : `token(spacing.${v}, ${v})`;
+        return {
+            "--bleed-x": map(inline, valueFn),
+            "--bleed-y": map(block, valueFn),
+            marginInline: "calc(var(--bleed-x, 0) * -1)",
+            marginBlock: "calc(var(--bleed-y, 0) * -1)",
+            ...rest
+        };
+    },
+    defaultValues: {
+        inline: '0',
+        block: '0'
+    }
+};
+const getBleedStyle = (styles = {})=>{
+    const _styles = getPatternStyles(bleedConfig, styles);
+    return bleedConfig.transform(_styles, patternFns);
+};
+const bleed = (styles)=>css_css(getBleedStyle(styles));
+bleed.raw = getBleedStyle;
+const visuallyHiddenConfig = {
+    transform (props) {
+        return {
+            srOnly: true,
+            ...props
+        };
+    }
+};
+const getVisuallyHiddenStyle = (styles = {})=>{
+    const _styles = getPatternStyles(visuallyHiddenConfig, styles);
+    return visuallyHiddenConfig.transform(_styles, patternFns);
+};
+const visuallyHidden = (styles)=>css_css(getVisuallyHiddenStyle(styles));
+visuallyHidden.raw = getVisuallyHiddenStyle;
+const cqConfig = {
+    transform (props) {
+        const { name, type, ...rest } = props;
+        return {
+            containerType: type,
+            containerName: name,
+            ...rest
+        };
+    },
+    defaultValues: {
+        type: 'inline-size'
+    }
+};
+const getCqStyle = (styles = {})=>{
+    const _styles = getPatternStyles(cqConfig, styles);
+    return cqConfig.transform(_styles, patternFns);
+};
+const cq = (styles)=>css_css(getCqStyle(styles));
+cq.raw = getCqStyle;
+const Flex = (props)=>{
+    const { children, className, ...variants } = props;
+    return /*#__PURE__*/ (0, jsx_runtime.jsx)("div", {
+        className: clsx(flex(variants), className),
+        children: children
+    });
+};
+const Link = (props)=>{
+    const { children, href, className, leftIcon, rightIcon, color, disabled, ...rest } = props;
+    function handleClick(e) {
+        if (disabled) {
+            e.preventDefault();
+            e.stopPropagation();
+        }
+    }
+    function handleKeyDown(e) {
+        if (disabled) {
+            e.preventDefault();
+            e.stopPropagation();
+        }
+    }
+    return /*#__PURE__*/ (0, jsx_runtime.jsx)(jsx_runtime.Fragment, {
+        children: /*#__PURE__*/ (0, jsx_runtime.jsxs)("a", {
+            href: href,
+            onClick: handleClick,
+            onKeyDown: handleKeyDown,
+            tabIndex: disabled ? -1 : 1,
+            ...rest,
+            className: clsx(linkRecipe({
+                color,
+                disabled
+            }), className),
+            children: [
+                leftIcon,
+                /*#__PURE__*/ (0, jsx_runtime.jsx)("span", {
+                    children: children
+                }),
+                rightIcon
+            ]
+        })
+    });
+};
+export { Button, Flex, Link, Text };