@sunggang/ui-lib 0.1.47 → 0.1.49

package/index.esm.js

@@ -1,7 +1,6 @@
 import { jsx, jsxs, Fragment as Fragment$1 } from 'react/jsx-runtime';
 import * as React from 'react';
 import React__default, { useMemo, useRef, useReducer, useEffect, useCallback, forwardRef, useImperativeHandle, Fragment, useState } from 'react';
-import { Icon } from '@iconify/react';
 import * as SwitchPrimitives from '@radix-ui/react-switch';
 import { clsx } from 'clsx';
 import { twMerge } from 'tailwind-merge';
@@ -10,14 +9,11 @@ import { Calendar as Calendar$1 } from 'lucide-react';
 import { Slot } from '@radix-ui/react-slot';
 import { cva } from 'class-variance-authority';
 import { DayPicker } from 'react-day-picker';
-import { zhTW } from 'date-fns/locale';
+import zhTW from 'date-fns/locale/zh-TW';
 import * as PopoverPrimitive from '@radix-ui/react-popover';
 import { Calendar as Calendar$2, DateRange } from 'react-date-range';
 import * as locales from 'react-date-range/dist/locale';
 import format$1 from 'date-fns/format';
-import '@tanstack/react-table';
-import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
-import { ChevronRightIcon, CheckIcon, DotFilledIcon } from '@radix-ui/react-icons';
 
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
@@ -64554,14 +64550,14 @@ var has$2 = Function.call.bind(Object.prototype.hasOwnProperty);
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-function _instanceof$3(left, right) {
+function _instanceof$4(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
         return left instanceof right;
     }
 }
-function _type_of$1(obj) {
+function _type_of$2(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
@@ -64605,7 +64601,7 @@ if (process.env.NODE_ENV !== "production") {
                     // This is intentionally an invariant that gets caught. It's the same
                     // behavior as without this statement except with a better message.
                     if (typeof typeSpecs[typeSpecName] !== "function") {
-                        var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; " + "it must be a function, usually from the `prop-types` package, but received `" + _type_of$1(typeSpecs[typeSpecName]) + "`." + "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                        var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; " + "it must be a function, usually from the `prop-types` package, but received `" + _type_of$2(typeSpecs[typeSpecName]) + "`." + "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
                         err.name = "Invariant Violation";
                         throw err;
                     }
@@ -64613,10 +64609,10 @@ if (process.env.NODE_ENV !== "production") {
                 } catch (ex) {
                     error = ex;
                 }
-                if (error && !_instanceof$3(error, Error)) {
-                    printWarning$1((componentName || "React class") + ": type specification of " + location + " `" + typeSpecName + "` is invalid; the type checker " + "function must return `null` or an `Error` but returned a " + (typeof error === "undefined" ? "undefined" : _type_of$1(error)) + ". " + "You may have forgotten to pass an argument to the type checker " + "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " + "shape all require an argument).");
+                if (error && !_instanceof$4(error, Error)) {
+                    printWarning$1((componentName || "React class") + ": type specification of " + location + " `" + typeSpecName + "` is invalid; the type checker " + "function must return `null` or an `Error` but returned a " + (typeof error === "undefined" ? "undefined" : _type_of$2(error)) + ". " + "You may have forgotten to pass an argument to the type checker " + "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " + "shape all require an argument).");
                 }
-                if (_instanceof$3(error, Error) && !(error.message in loggedTypeFailures)) {
+                if (_instanceof$4(error, Error) && !(error.message in loggedTypeFailures)) {
                     // Only monitor this failure once because there tends to be a lot of the
                     // same error.
                     loggedTypeFailures[error.message] = true;
@@ -64644,14 +64640,14 @@ var checkPropTypes_1 = checkPropTypes$1;
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-function _instanceof$2(left, right) {
+function _instanceof$3(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
         return left instanceof right;
     }
 }
-function _type_of(obj) {
+function _type_of$1(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
@@ -64869,7 +64865,7 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
             }
             for(var i = 0; i < propValue.length; i++){
                 var error = typeChecker(propValue, i, componentName, location, propFullName + "[" + i + "]", ReactPropTypesSecret$1);
-                if (_instanceof$2(error, Error)) {
+                if (_instanceof$3(error, Error)) {
                     return error;
                 }
             }
@@ -64901,7 +64897,7 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
     }
     function createInstanceTypeChecker(expectedClass) {
         function validate(props, propName, componentName, location, propFullName) {
-            if (!_instanceof$2(props[propName], expectedClass)) {
+            if (!_instanceof$3(props[propName], expectedClass)) {
                 var expectedClassName = expectedClass.name || ANONYMOUS;
                 var actualClassName = getClassName(props[propName]);
                 return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + actualClassName + "` supplied to `" + componentName + "`, expected ") + ("instance of `" + expectedClassName + "`."));
@@ -64952,7 +64948,7 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
             for(var key in propValue){
                 if (has(propValue, key)) {
                     var error = typeChecker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret$1);
-                    if (_instanceof$2(error, Error)) {
+                    if (_instanceof$3(error, Error)) {
                         return error;
                     }
                 }
@@ -65050,7 +65046,7 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
         return createChainableTypeChecker(validate);
     }
     function isNode(propValue) {
-        switch(typeof propValue === "undefined" ? "undefined" : _type_of(propValue)){
+        switch(typeof propValue === "undefined" ? "undefined" : _type_of$1(propValue)){
             case "number":
             case "string":
             case "undefined":
@@ -65107,18 +65103,18 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
             return true;
         }
         // Fallback for non-spec compliant Symbols which are polyfilled.
-        if (typeof Symbol === "function" && _instanceof$2(propValue, Symbol)) {
+        if (typeof Symbol === "function" && _instanceof$3(propValue, Symbol)) {
             return true;
         }
         return false;
     }
     // Equivalent of `typeof` but with special handling for array and regexp.
     function getPropType(propValue) {
-        var propType = typeof propValue === "undefined" ? "undefined" : _type_of(propValue);
+        var propType = typeof propValue === "undefined" ? "undefined" : _type_of$1(propValue);
         if (Array.isArray(propValue)) {
             return "array";
         }
-        if (_instanceof$2(propValue, RegExp)) {
+        if (_instanceof$3(propValue, RegExp)) {
             // Old webkits (at least until Android 4.0) return 'function' rather than
             // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
             // passes PropTypes.object.
@@ -65137,9 +65133,9 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
         }
         var propType = getPropType(propValue);
         if (propType === "object") {
-            if (_instanceof$2(propValue, Date)) {
+            if (_instanceof$3(propValue, Date)) {
                 return "date";
-            } else if (_instanceof$2(propValue, RegExp)) {
+            } else if (_instanceof$3(propValue, RegExp)) {
                 return "regexp";
             }
         }
@@ -65261,7 +65257,7 @@ INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */ /* global Reflect, Promise, SuppressedError, Symbol */ function _instanceof$1(left, right) {
+***************************************************************************** */ /* global Reflect, Promise, SuppressedError, Symbol */ function _instanceof$2(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -65270,7 +65266,7 @@ PERFORMANCE OF THIS SOFTWARE.
 }
 function __awaiter(thisArg, _arguments, P, generator) {
     function adopt(value) {
-        return _instanceof$1(value, P) ? value : new P(function(resolve) {
+        return _instanceof$2(value, P) ? value : new P(function(resolve) {
             resolve(value);
         });
     }
@@ -66071,7 +66067,7 @@ var _default = function(file, acceptedFiles) {
     return true;
 };
 
-function _instanceof(left, right) {
+function _instanceof$1(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -66384,7 +66380,7 @@ function isIeOrEdge() {
  * @param {any} v
  * @returns {boolean} True if v is an abort exception.
  */ function isAbort(v) {
-    return _instanceof(v, DOMException) && (v.name === "AbortError" || v.code === v.ABORT_ERR);
+    return _instanceof$1(v, DOMException) && (v.name === "AbortError" || v.code === v.ABORT_ERR);
 }
 /**
  * Check if v is a security error.
@@ -66393,7 +66389,7 @@ function isIeOrEdge() {
  * @param {any} v
  * @returns {boolean} True if v is a security error.
  */ function isSecurityError(v) {
-    return _instanceof(v, DOMException) && (v.name === "SecurityError" || v.code === v.SECURITY_ERR);
+    return _instanceof$1(v, DOMException) && (v.name === "SecurityError" || v.code === v.SECURITY_ERR);
 }
 /**
  * Check if v is a MIME type string.
@@ -67451,6 +67447,1960 @@ function v4(options, buf, offset) {
     return stringify(rnds);
 }
 
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$5(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _object_spread$5(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$5(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$3(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$3(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$3(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+var matchIconName = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var stringToIcon = function(value, validate, allowSimpleName) {
+    var provider = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : "";
+    var colonSeparated = value.split(":");
+    if (value.slice(0, 1) === "@") {
+        if (colonSeparated.length < 2 || colonSeparated.length > 3) {
+            return null;
+        }
+        provider = colonSeparated.shift().slice(1);
+    }
+    if (colonSeparated.length > 3 || !colonSeparated.length) {
+        return null;
+    }
+    if (colonSeparated.length > 1) {
+        var name2 = colonSeparated.pop();
+        var prefix = colonSeparated.pop();
+        var result = {
+            // Allow provider without '@': "provider:prefix:name"
+            provider: colonSeparated.length > 0 ? colonSeparated[0] : provider,
+            prefix: prefix,
+            name: name2
+        };
+        return validate && !validateIconName(result) ? null : result;
+    }
+    var name = colonSeparated[0];
+    var dashSeparated = name.split("-");
+    if (dashSeparated.length > 1) {
+        var result1 = {
+            provider: provider,
+            prefix: dashSeparated.shift(),
+            name: dashSeparated.join("-")
+        };
+        return validate && !validateIconName(result1) ? null : result1;
+    }
+    if (allowSimpleName && provider === "") {
+        var result2 = {
+            provider: provider,
+            prefix: "",
+            name: name
+        };
+        return validate && !validateIconName(result2, allowSimpleName) ? null : result2;
+    }
+    return null;
+};
+var validateIconName = function(icon, allowSimpleName) {
+    if (!icon) {
+        return false;
+    }
+    return !!((icon.provider === "" || icon.provider.match(matchIconName)) && (allowSimpleName && icon.prefix === "" || icon.prefix.match(matchIconName)) && icon.name.match(matchIconName));
+};
+var defaultIconDimensions = Object.freeze({
+    left: 0,
+    top: 0,
+    width: 16,
+    height: 16
+});
+var defaultIconTransformations = Object.freeze({
+    rotate: 0,
+    vFlip: false,
+    hFlip: false
+});
+var defaultIconProps = Object.freeze(_object_spread$5({}, defaultIconDimensions, defaultIconTransformations));
+var defaultExtendedIconProps = Object.freeze(_object_spread_props$3(_object_spread$5({}, defaultIconProps), {
+    body: "",
+    hidden: false
+}));
+function mergeIconTransformations(obj1, obj2) {
+    var result = {};
+    if (!obj1.hFlip !== !obj2.hFlip) {
+        result.hFlip = true;
+    }
+    if (!obj1.vFlip !== !obj2.vFlip) {
+        result.vFlip = true;
+    }
+    var rotate = ((obj1.rotate || 0) + (obj2.rotate || 0)) % 4;
+    if (rotate) {
+        result.rotate = rotate;
+    }
+    return result;
+}
+function mergeIconData(parent, child) {
+    var result = mergeIconTransformations(parent, child);
+    for(var key in defaultExtendedIconProps){
+        if (key in defaultIconTransformations) {
+            if (key in parent && !(key in result)) {
+                result[key] = defaultIconTransformations[key];
+            }
+        } else if (key in child) {
+            result[key] = child[key];
+        } else if (key in parent) {
+            result[key] = parent[key];
+        }
+    }
+    return result;
+}
+function getIconsTree(data, names) {
+    var icons = data.icons;
+    var aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+    var resolved = /* @__PURE__ */ Object.create(null);
+    function resolve(name) {
+        if (icons[name]) {
+            return resolved[name] = [];
+        }
+        if (!(name in resolved)) {
+            resolved[name] = null;
+            var parent = aliases[name] && aliases[name].parent;
+            var value = parent && resolve(parent);
+            if (value) {
+                resolved[name] = [
+                    parent
+                ].concat(value);
+            }
+        }
+        return resolved[name];
+    }
+    (names || Object.keys(icons).concat(Object.keys(aliases))).forEach(resolve);
+    return resolved;
+}
+function internalGetIconData(data, name, tree) {
+    var icons = data.icons;
+    var aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+    var currentProps = {};
+    function parse(name2) {
+        currentProps = mergeIconData(icons[name2] || aliases[name2], currentProps);
+    }
+    parse(name);
+    tree.forEach(parse);
+    return mergeIconData(data, currentProps);
+}
+function parseIconSet(data, callback) {
+    var names = [];
+    if (typeof data !== "object" || typeof data.icons !== "object") {
+        return names;
+    }
+    if (_instanceof(data.not_found, Array)) {
+        data.not_found.forEach(function(name) {
+            callback(name, null);
+            names.push(name);
+        });
+    }
+    var tree = getIconsTree(data);
+    for(var name in tree){
+        var item = tree[name];
+        if (item) {
+            callback(name, internalGetIconData(data, name, item));
+            names.push(name);
+        }
+    }
+    return names;
+}
+var optionalPropertyDefaults = _object_spread$5({
+    provider: "",
+    aliases: {},
+    not_found: {}
+}, defaultIconDimensions);
+function checkOptionalProps(item, defaults) {
+    for(var prop in defaults){
+        if (prop in item && _type_of(item[prop]) !== _type_of(defaults[prop])) {
+            return false;
+        }
+    }
+    return true;
+}
+function quicklyValidateIconSet(obj) {
+    if (typeof obj !== "object" || obj === null) {
+        return null;
+    }
+    var data = obj;
+    if (typeof data.prefix !== "string" || !obj.icons || typeof obj.icons !== "object") {
+        return null;
+    }
+    if (!checkOptionalProps(obj, optionalPropertyDefaults)) {
+        return null;
+    }
+    var icons = data.icons;
+    for(var name in icons){
+        var icon = icons[name];
+        if (!name.match(matchIconName) || typeof icon.body !== "string" || !checkOptionalProps(icon, defaultExtendedIconProps)) {
+            return null;
+        }
+    }
+    var aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+    for(var name1 in aliases){
+        var icon1 = aliases[name1];
+        var parent = icon1.parent;
+        if (!name1.match(matchIconName) || typeof parent !== "string" || !icons[parent] && !aliases[parent] || !checkOptionalProps(icon1, defaultExtendedIconProps)) {
+            return null;
+        }
+    }
+    return data;
+}
+var dataStorage = /* @__PURE__ */ Object.create(null);
+function newStorage(provider, prefix) {
+    return {
+        provider: provider,
+        prefix: prefix,
+        icons: /* @__PURE__ */ Object.create(null),
+        missing: /* @__PURE__ */ new Set()
+    };
+}
+function getStorage(provider, prefix) {
+    var providerStorage = dataStorage[provider] || (dataStorage[provider] = /* @__PURE__ */ Object.create(null));
+    return providerStorage[prefix] || (providerStorage[prefix] = newStorage(provider, prefix));
+}
+function addIconSet(storage, data) {
+    if (!quicklyValidateIconSet(data)) {
+        return [];
+    }
+    return parseIconSet(data, function(name, icon) {
+        if (icon) {
+            storage.icons[name] = icon;
+        } else {
+            storage.missing.add(name);
+        }
+    });
+}
+function addIconToStorage(storage, name, icon) {
+    try {
+        if (typeof icon.body === "string") {
+            storage.icons[name] = _object_spread$5({}, icon);
+            return true;
+        }
+    } catch (err) {}
+    return false;
+}
+var simpleNames = false;
+function allowSimpleNames(allow) {
+    if (typeof allow === "boolean") {
+        simpleNames = allow;
+    }
+    return simpleNames;
+}
+function getIconData(name) {
+    var icon = typeof name === "string" ? stringToIcon(name, true, simpleNames) : name;
+    if (icon) {
+        var storage = getStorage(icon.provider, icon.prefix);
+        var iconName = icon.name;
+        return storage.icons[iconName] || (storage.missing.has(iconName) ? null : void 0);
+    }
+}
+function addIcon(name, data) {
+    var icon = stringToIcon(name, true, simpleNames);
+    if (!icon) {
+        return false;
+    }
+    var storage = getStorage(icon.provider, icon.prefix);
+    return addIconToStorage(storage, icon.name, data);
+}
+function addCollection(data, provider) {
+    if (typeof data !== "object") {
+        return false;
+    }
+    if (typeof provider !== "string") {
+        provider = data.provider || "";
+    }
+    if (simpleNames && !provider && !data.prefix) {
+        var added = false;
+        if (quicklyValidateIconSet(data)) {
+            data.prefix = "";
+            parseIconSet(data, function(name, icon) {
+                if (icon && addIcon(name, icon)) {
+                    added = true;
+                }
+            });
+        }
+        return added;
+    }
+    var prefix = data.prefix;
+    if (!validateIconName({
+        provider: provider,
+        prefix: prefix,
+        name: "a"
+    })) {
+        return false;
+    }
+    var storage = getStorage(provider, prefix);
+    return !!addIconSet(storage, data);
+}
+var defaultIconSizeCustomisations = Object.freeze({
+    width: null,
+    height: null
+});
+var defaultIconCustomisations = Object.freeze(_object_spread$5({}, defaultIconSizeCustomisations, defaultIconTransformations));
+var unitsSplit = /(-?[0-9.]*[0-9]+[0-9.]*)/g;
+var unitsTest = /^-?[0-9.]*[0-9]+[0-9.]*$/g;
+function calculateSize(size, ratio, precision) {
+    if (ratio === 1) {
+        return size;
+    }
+    precision = precision || 100;
+    if (typeof size === "number") {
+        return Math.ceil(size * ratio * precision) / precision;
+    }
+    if (typeof size !== "string") {
+        return size;
+    }
+    var oldParts = size.split(unitsSplit);
+    if (oldParts === null || !oldParts.length) {
+        return size;
+    }
+    var newParts = [];
+    var code = oldParts.shift();
+    var isNumber = unitsTest.test(code);
+    while(true){
+        if (isNumber) {
+            var num = parseFloat(code);
+            if (isNaN(num)) {
+                newParts.push(code);
+            } else {
+                newParts.push(Math.ceil(num * ratio * precision) / precision);
+            }
+        } else {
+            newParts.push(code);
+        }
+        code = oldParts.shift();
+        if (code === void 0) {
+            return newParts.join("");
+        }
+        isNumber = !isNumber;
+    }
+}
+var isUnsetKeyword = function(value) {
+    return value === "unset" || value === "undefined" || value === "none";
+};
+function iconToSVG(icon, customisations) {
+    var fullIcon = _object_spread$5({}, defaultIconProps, icon);
+    var fullCustomisations = _object_spread$5({}, defaultIconCustomisations, customisations);
+    var box = {
+        left: fullIcon.left,
+        top: fullIcon.top,
+        width: fullIcon.width,
+        height: fullIcon.height
+    };
+    var body = fullIcon.body;
+    [
+        fullIcon,
+        fullCustomisations
+    ].forEach(function(props) {
+        var transformations = [];
+        var hFlip = props.hFlip;
+        var vFlip = props.vFlip;
+        var rotation = props.rotate;
+        if (hFlip) {
+            if (vFlip) {
+                rotation += 2;
+            } else {
+                transformations.push("translate(" + (box.width + box.left).toString() + " " + (0 - box.top).toString() + ")");
+                transformations.push("scale(-1 1)");
+                box.top = box.left = 0;
+            }
+        } else if (vFlip) {
+            transformations.push("translate(" + (0 - box.left).toString() + " " + (box.height + box.top).toString() + ")");
+            transformations.push("scale(1 -1)");
+            box.top = box.left = 0;
+        }
+        var tempValue;
+        if (rotation < 0) {
+            rotation -= Math.floor(rotation / 4) * 4;
+        }
+        rotation = rotation % 4;
+        switch(rotation){
+            case 1:
+                tempValue = box.height / 2 + box.top;
+                transformations.unshift("rotate(90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+                break;
+            case 2:
+                transformations.unshift("rotate(180 " + (box.width / 2 + box.left).toString() + " " + (box.height / 2 + box.top).toString() + ")");
+                break;
+            case 3:
+                tempValue = box.width / 2 + box.left;
+                transformations.unshift("rotate(-90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+                break;
+        }
+        if (rotation % 2 === 1) {
+            if (box.left !== box.top) {
+                tempValue = box.left;
+                box.left = box.top;
+                box.top = tempValue;
+            }
+            if (box.width !== box.height) {
+                tempValue = box.width;
+                box.width = box.height;
+                box.height = tempValue;
+            }
+        }
+        if (transformations.length) {
+            body = '<g transform="' + transformations.join(" ") + '">' + body + "</g>";
+        }
+    });
+    var customisationsWidth = fullCustomisations.width;
+    var customisationsHeight = fullCustomisations.height;
+    var boxWidth = box.width;
+    var boxHeight = box.height;
+    var width;
+    var height;
+    if (customisationsWidth === null) {
+        height = customisationsHeight === null ? "1em" : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+        width = calculateSize(height, boxWidth / boxHeight);
+    } else {
+        width = customisationsWidth === "auto" ? boxWidth : customisationsWidth;
+        height = customisationsHeight === null ? calculateSize(width, boxHeight / boxWidth) : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+    }
+    var attributes = {};
+    var setAttr = function(prop, value) {
+        if (!isUnsetKeyword(value)) {
+            attributes[prop] = value.toString();
+        }
+    };
+    setAttr("width", width);
+    setAttr("height", height);
+    attributes.viewBox = box.left.toString() + " " + box.top.toString() + " " + boxWidth.toString() + " " + boxHeight.toString();
+    return {
+        attributes: attributes,
+        body: body
+    };
+}
+var regex = /\sid="(\S+)"/g;
+var randomPrefix = "IconifyId" + Date.now().toString(16) + (Math.random() * 16777216 | 0).toString(16);
+var counter = 0;
+function replaceIDs(body) {
+    var prefix = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : randomPrefix;
+    var ids = [];
+    var match;
+    while(match = regex.exec(body)){
+        ids.push(match[1]);
+    }
+    if (!ids.length) {
+        return body;
+    }
+    var suffix = "suffix" + (Math.random() * 16777216 | Date.now()).toString(16);
+    ids.forEach(function(id) {
+        var newID = typeof prefix === "function" ? prefix(id) : prefix + (counter++).toString();
+        var escapedID = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        body = body.replace(// Allowed characters before id: [#;"]
+        // Allowed characters after id: [)"], .[a-z]
+        new RegExp('([#;"])(' + escapedID + ')([")]|\\.[a-z])', "g"), "$1" + newID + suffix + "$3");
+    });
+    body = body.replace(new RegExp(suffix, "g"), "");
+    return body;
+}
+var storage = /* @__PURE__ */ Object.create(null);
+function setAPIModule(provider, item) {
+    storage[provider] = item;
+}
+function getAPIModule(provider) {
+    return storage[provider] || storage[""];
+}
+function createAPIConfig(source) {
+    var resources;
+    if (typeof source.resources === "string") {
+        resources = [
+            source.resources
+        ];
+    } else {
+        resources = source.resources;
+        if (!_instanceof(resources, Array) || !resources.length) {
+            return null;
+        }
+    }
+    var result = {
+        // API hosts
+        resources: resources,
+        // Root path
+        path: source.path || "/",
+        // URL length limit
+        maxURL: source.maxURL || 500,
+        // Timeout before next host is used.
+        rotate: source.rotate || 750,
+        // Timeout before failing query.
+        timeout: source.timeout || 5e3,
+        // Randomise default API end point.
+        random: source.random === true,
+        // Start index
+        index: source.index || 0,
+        // Receive data after time out (used if time out kicks in first, then API module sends data anyway).
+        dataAfterTimeout: source.dataAfterTimeout !== false
+    };
+    return result;
+}
+var configStorage = /* @__PURE__ */ Object.create(null);
+var fallBackAPISources = [
+    "https://api.simplesvg.com",
+    "https://api.unisvg.com"
+];
+var fallBackAPI = [];
+while(fallBackAPISources.length > 0){
+    if (fallBackAPISources.length === 1) {
+        fallBackAPI.push(fallBackAPISources.shift());
+    } else {
+        if (Math.random() > 0.5) {
+            fallBackAPI.push(fallBackAPISources.shift());
+        } else {
+            fallBackAPI.push(fallBackAPISources.pop());
+        }
+    }
+}
+configStorage[""] = createAPIConfig({
+    resources: [
+        "https://api.iconify.design"
+    ].concat(fallBackAPI)
+});
+function addAPIProvider(provider, customConfig) {
+    var config = createAPIConfig(customConfig);
+    if (config === null) {
+        return false;
+    }
+    configStorage[provider] = config;
+    return true;
+}
+function getAPIConfig(provider) {
+    return configStorage[provider];
+}
+var detectFetch = function() {
+    var callback;
+    try {
+        callback = fetch;
+        if (typeof callback === "function") {
+            return callback;
+        }
+    } catch (err) {}
+};
+var fetchModule = detectFetch();
+function calculateMaxLength(provider, prefix) {
+    var config = getAPIConfig(provider);
+    if (!config) {
+        return 0;
+    }
+    var result;
+    if (!config.maxURL) {
+        result = 0;
+    } else {
+        var maxHostLength = 0;
+        config.resources.forEach(function(item) {
+            var host = item;
+            maxHostLength = Math.max(maxHostLength, host.length);
+        });
+        var url = prefix + ".json?icons=";
+        result = config.maxURL - maxHostLength - config.path.length - url.length;
+    }
+    return result;
+}
+function shouldAbort(status) {
+    return status === 404;
+}
+var prepare = function(provider, prefix, icons) {
+    var results = [];
+    var maxLength = calculateMaxLength(provider, prefix);
+    var type = "icons";
+    var item = {
+        type: type,
+        provider: provider,
+        prefix: prefix,
+        icons: []
+    };
+    var length = 0;
+    icons.forEach(function(name, index) {
+        length += name.length + 1;
+        if (length >= maxLength && index > 0) {
+            results.push(item);
+            item = {
+                type: type,
+                provider: provider,
+                prefix: prefix,
+                icons: []
+            };
+            length = name.length;
+        }
+        item.icons.push(name);
+    });
+    results.push(item);
+    return results;
+};
+function getPath(provider) {
+    if (typeof provider === "string") {
+        var config = getAPIConfig(provider);
+        if (config) {
+            return config.path;
+        }
+    }
+    return "/";
+}
+var send = function(host, params, callback) {
+    if (!fetchModule) {
+        callback("abort", 424);
+        return;
+    }
+    var path = getPath(params.provider);
+    switch(params.type){
+        case "icons":
+            {
+                var prefix = params.prefix;
+                var icons = params.icons;
+                var iconsList = icons.join(",");
+                var urlParams = new URLSearchParams({
+                    icons: iconsList
+                });
+                path += prefix + ".json?" + urlParams.toString();
+                break;
+            }
+        case "custom":
+            {
+                var uri = params.uri;
+                path += uri.slice(0, 1) === "/" ? uri.slice(1) : uri;
+                break;
+            }
+        default:
+            callback("abort", 400);
+            return;
+    }
+    var defaultError = 503;
+    fetchModule(host + path).then(function(response) {
+        var status = response.status;
+        if (status !== 200) {
+            setTimeout(function() {
+                callback(shouldAbort(status) ? "abort" : "next", status);
+            });
+            return;
+        }
+        defaultError = 501;
+        return response.json();
+    }).then(function(data) {
+        if (typeof data !== "object" || data === null) {
+            setTimeout(function() {
+                if (data === 404) {
+                    callback("abort", data);
+                } else {
+                    callback("next", defaultError);
+                }
+            });
+            return;
+        }
+        setTimeout(function() {
+            callback("success", data);
+        });
+    }).catch(function() {
+        callback("next", defaultError);
+    });
+};
+var fetchAPIModule = {
+    prepare: prepare,
+    send: send
+};
+function sortIcons(icons) {
+    var result = {
+        loaded: [],
+        missing: [],
+        pending: []
+    };
+    var storage = /* @__PURE__ */ Object.create(null);
+    icons.sort(function(a, b) {
+        if (a.provider !== b.provider) {
+            return a.provider.localeCompare(b.provider);
+        }
+        if (a.prefix !== b.prefix) {
+            return a.prefix.localeCompare(b.prefix);
+        }
+        return a.name.localeCompare(b.name);
+    });
+    var lastIcon = {
+        provider: "",
+        prefix: "",
+        name: ""
+    };
+    icons.forEach(function(icon) {
+        if (lastIcon.name === icon.name && lastIcon.prefix === icon.prefix && lastIcon.provider === icon.provider) {
+            return;
+        }
+        lastIcon = icon;
+        var provider = icon.provider;
+        var prefix = icon.prefix;
+        var name = icon.name;
+        var providerStorage = storage[provider] || (storage[provider] = /* @__PURE__ */ Object.create(null));
+        var localStorage = providerStorage[prefix] || (providerStorage[prefix] = getStorage(provider, prefix));
+        var list;
+        if (name in localStorage.icons) {
+            list = result.loaded;
+        } else if (prefix === "" || localStorage.missing.has(name)) {
+            list = result.missing;
+        } else {
+            list = result.pending;
+        }
+        var item = {
+            provider: provider,
+            prefix: prefix,
+            name: name
+        };
+        list.push(item);
+    });
+    return result;
+}
+function removeCallback(storages, id) {
+    storages.forEach(function(storage) {
+        var items = storage.loaderCallbacks;
+        if (items) {
+            storage.loaderCallbacks = items.filter(function(row) {
+                return row.id !== id;
+            });
+        }
+    });
+}
+function updateCallbacks(storage) {
+    if (!storage.pendingCallbacksFlag) {
+        storage.pendingCallbacksFlag = true;
+        setTimeout(function() {
+            storage.pendingCallbacksFlag = false;
+            var items = storage.loaderCallbacks ? storage.loaderCallbacks.slice(0) : [];
+            if (!items.length) {
+                return;
+            }
+            var hasPending = false;
+            var provider = storage.provider;
+            var prefix = storage.prefix;
+            items.forEach(function(item) {
+                var icons = item.icons;
+                var oldLength = icons.pending.length;
+                icons.pending = icons.pending.filter(function(icon) {
+                    if (icon.prefix !== prefix) {
+                        return true;
+                    }
+                    var name = icon.name;
+                    if (storage.icons[name]) {
+                        icons.loaded.push({
+                            provider: provider,
+                            prefix: prefix,
+                            name: name
+                        });
+                    } else if (storage.missing.has(name)) {
+                        icons.missing.push({
+                            provider: provider,
+                            prefix: prefix,
+                            name: name
+                        });
+                    } else {
+                        hasPending = true;
+                        return true;
+                    }
+                    return false;
+                });
+                if (icons.pending.length !== oldLength) {
+                    if (!hasPending) {
+                        removeCallback([
+                            storage
+                        ], item.id);
+                    }
+                    item.callback(icons.loaded.slice(0), icons.missing.slice(0), icons.pending.slice(0), item.abort);
+                }
+            });
+        });
+    }
+}
+var idCounter = 0;
+function storeCallback(callback, icons, pendingSources) {
+    var id = idCounter++;
+    var abort = removeCallback.bind(null, pendingSources, id);
+    if (!icons.pending.length) {
+        return abort;
+    }
+    var item = {
+        id: id,
+        icons: icons,
+        callback: callback,
+        abort: abort
+    };
+    pendingSources.forEach(function(storage) {
+        (storage.loaderCallbacks || (storage.loaderCallbacks = [])).push(item);
+    });
+    return abort;
+}
+function listToIcons(list) {
+    var validate = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true, simpleNames = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    var result = [];
+    list.forEach(function(item) {
+        var icon = typeof item === "string" ? stringToIcon(item, validate, simpleNames) : item;
+        if (icon) {
+            result.push(icon);
+        }
+    });
+    return result;
+}
+// src/config.ts
+var defaultConfig = {
+    resources: [],
+    index: 0,
+    timeout: 2e3,
+    rotate: 750,
+    random: false,
+    dataAfterTimeout: false
+};
+// src/query.ts
+function sendQuery(config, payload, query, done) {
+    var resourcesCount = config.resources.length;
+    var startIndex = config.random ? Math.floor(Math.random() * resourcesCount) : config.index;
+    var resources;
+    if (config.random) {
+        var list = config.resources.slice(0);
+        resources = [];
+        while(list.length > 1){
+            var nextIndex = Math.floor(Math.random() * list.length);
+            resources.push(list[nextIndex]);
+            list = list.slice(0, nextIndex).concat(list.slice(nextIndex + 1));
+        }
+        resources = resources.concat(list);
+    } else {
+        resources = config.resources.slice(startIndex).concat(config.resources.slice(0, startIndex));
+    }
+    var startTime = Date.now();
+    var status = "pending";
+    var queriesSent = 0;
+    var lastError;
+    var timer = null;
+    var queue = [];
+    var doneCallbacks = [];
+    if (typeof done === "function") {
+        doneCallbacks.push(done);
+    }
+    function resetTimer() {
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+    }
+    function abort() {
+        if (status === "pending") {
+            status = "aborted";
+        }
+        resetTimer();
+        queue.forEach(function(item) {
+            if (item.status === "pending") {
+                item.status = "aborted";
+            }
+        });
+        queue = [];
+    }
+    function subscribe(callback, overwrite) {
+        if (overwrite) {
+            doneCallbacks = [];
+        }
+        if (typeof callback === "function") {
+            doneCallbacks.push(callback);
+        }
+    }
+    function getQueryStatus() {
+        return {
+            startTime: startTime,
+            payload: payload,
+            status: status,
+            queriesSent: queriesSent,
+            queriesPending: queue.length,
+            subscribe: subscribe,
+            abort: abort
+        };
+    }
+    function failQuery() {
+        status = "failed";
+        doneCallbacks.forEach(function(callback) {
+            callback(void 0, lastError);
+        });
+    }
+    function clearQueue() {
+        queue.forEach(function(item) {
+            if (item.status === "pending") {
+                item.status = "aborted";
+            }
+        });
+        queue = [];
+    }
+    function moduleResponse(item, response, data) {
+        var isError = response !== "success";
+        queue = queue.filter(function(queued) {
+            return queued !== item;
+        });
+        switch(status){
+            case "pending":
+                break;
+            case "failed":
+                if (isError || !config.dataAfterTimeout) {
+                    return;
+                }
+                break;
+            default:
+                return;
+        }
+        if (response === "abort") {
+            lastError = data;
+            failQuery();
+            return;
+        }
+        if (isError) {
+            lastError = data;
+            if (!queue.length) {
+                if (!resources.length) {
+                    failQuery();
+                } else {
+                    execNext();
+                }
+            }
+            return;
+        }
+        resetTimer();
+        clearQueue();
+        if (!config.random) {
+            var index = config.resources.indexOf(item.resource);
+            if (index !== -1 && index !== config.index) {
+                config.index = index;
+            }
+        }
+        status = "completed";
+        doneCallbacks.forEach(function(callback) {
+            callback(data);
+        });
+    }
+    function execNext() {
+        if (status !== "pending") {
+            return;
+        }
+        resetTimer();
+        var resource = resources.shift();
+        if (resource === void 0) {
+            if (queue.length) {
+                timer = setTimeout(function() {
+                    resetTimer();
+                    if (status === "pending") {
+                        clearQueue();
+                        failQuery();
+                    }
+                }, config.timeout);
+                return;
+            }
+            failQuery();
+            return;
+        }
+        var item = {
+            status: "pending",
+            resource: resource,
+            callback: function(status2, data) {
+                moduleResponse(item, status2, data);
+            }
+        };
+        queue.push(item);
+        queriesSent++;
+        timer = setTimeout(execNext, config.rotate);
+        query(resource, payload, item.callback);
+    }
+    setTimeout(execNext);
+    return getQueryStatus;
+}
+// src/index.ts
+function initRedundancy(cfg) {
+    var config = _object_spread$5({}, defaultConfig, cfg);
+    var queries = [];
+    function cleanup() {
+        queries = queries.filter(function(item) {
+            return item().status === "pending";
+        });
+    }
+    function query(payload, queryCallback, doneCallback) {
+        var query2 = sendQuery(config, payload, queryCallback, function(data, error) {
+            cleanup();
+            if (doneCallback) {
+                doneCallback(data, error);
+            }
+        });
+        queries.push(query2);
+        return query2;
+    }
+    function find(callback) {
+        return queries.find(function(value) {
+            return callback(value);
+        }) || null;
+    }
+    var instance = {
+        query: query,
+        find: find,
+        setIndex: function(index) {
+            config.index = index;
+        },
+        getIndex: function() {
+            return config.index;
+        },
+        cleanup: cleanup
+    };
+    return instance;
+}
+function emptyCallback$1() {}
+var redundancyCache = /* @__PURE__ */ Object.create(null);
+function getRedundancyCache(provider) {
+    if (!redundancyCache[provider]) {
+        var config = getAPIConfig(provider);
+        if (!config) {
+            return;
+        }
+        var redundancy = initRedundancy(config);
+        var cachedReundancy = {
+            config: config,
+            redundancy: redundancy
+        };
+        redundancyCache[provider] = cachedReundancy;
+    }
+    return redundancyCache[provider];
+}
+function sendAPIQuery(target, query, callback) {
+    var redundancy;
+    var send;
+    if (typeof target === "string") {
+        var api = getAPIModule(target);
+        if (!api) {
+            callback(void 0, 424);
+            return emptyCallback$1;
+        }
+        send = api.send;
+        var cached = getRedundancyCache(target);
+        if (cached) {
+            redundancy = cached.redundancy;
+        }
+    } else {
+        var config = createAPIConfig(target);
+        if (config) {
+            redundancy = initRedundancy(config);
+            var moduleKey = target.resources ? target.resources[0] : "";
+            var api1 = getAPIModule(moduleKey);
+            if (api1) {
+                send = api1.send;
+            }
+        }
+    }
+    if (!redundancy || !send) {
+        callback(void 0, 424);
+        return emptyCallback$1;
+    }
+    return redundancy.query(query, send, callback)().abort;
+}
+var browserCacheVersion = "iconify2";
+var browserCachePrefix = "iconify";
+var browserCacheCountKey = browserCachePrefix + "-count";
+var browserCacheVersionKey = browserCachePrefix + "-version";
+var browserStorageHour = 36e5;
+var browserStorageCacheExpiration = 168;
+function getStoredItem(func, key) {
+    try {
+        return func.getItem(key);
+    } catch (err) {}
+}
+function setStoredItem(func, key, value) {
+    try {
+        func.setItem(key, value);
+        return true;
+    } catch (err) {}
+}
+function removeStoredItem(func, key) {
+    try {
+        func.removeItem(key);
+    } catch (err) {}
+}
+function setBrowserStorageItemsCount(storage, value) {
+    return setStoredItem(storage, browserCacheCountKey, value.toString());
+}
+function getBrowserStorageItemsCount(storage) {
+    return parseInt(getStoredItem(storage, browserCacheCountKey)) || 0;
+}
+var browserStorageConfig = {
+    local: true,
+    session: true
+};
+var browserStorageEmptyItems = {
+    local: /* @__PURE__ */ new Set(),
+    session: /* @__PURE__ */ new Set()
+};
+var browserStorageStatus = false;
+function setBrowserStorageStatus(status) {
+    browserStorageStatus = status;
+}
+var _window = typeof window === "undefined" ? {} : window;
+function getBrowserStorage(key) {
+    var attr = key + "Storage";
+    try {
+        if (_window && _window[attr] && typeof _window[attr].length === "number") {
+            return _window[attr];
+        }
+    } catch (err) {}
+    browserStorageConfig[key] = false;
+}
+function iterateBrowserStorage(key, callback) {
+    var func = getBrowserStorage(key);
+    if (!func) {
+        return;
+    }
+    var version = getStoredItem(func, browserCacheVersionKey);
+    if (version !== browserCacheVersion) {
+        if (version) {
+            var total2 = getBrowserStorageItemsCount(func);
+            for(var i = 0; i < total2; i++){
+                removeStoredItem(func, browserCachePrefix + i.toString());
+            }
+        }
+        setStoredItem(func, browserCacheVersionKey, browserCacheVersion);
+        setBrowserStorageItemsCount(func, 0);
+        return;
+    }
+    var minTime = Math.floor(Date.now() / browserStorageHour) - browserStorageCacheExpiration;
+    var parseItem = function(index) {
+        var name = browserCachePrefix + index.toString();
+        var item = getStoredItem(func, name);
+        if (typeof item !== "string") {
+            return;
+        }
+        try {
+            var data = JSON.parse(item);
+            if (typeof data === "object" && typeof data.cached === "number" && data.cached > minTime && typeof data.provider === "string" && typeof data.data === "object" && typeof data.data.prefix === "string" && // Valid item: run callback
+            callback(data, index)) {
+                return true;
+            }
+        } catch (err) {}
+        removeStoredItem(func, name);
+    };
+    var total = getBrowserStorageItemsCount(func);
+    for(var i1 = total - 1; i1 >= 0; i1--){
+        if (!parseItem(i1)) {
+            if (i1 === total - 1) {
+                total--;
+                setBrowserStorageItemsCount(func, total);
+            } else {
+                browserStorageEmptyItems[key].add(i1);
+            }
+        }
+    }
+}
+function initBrowserStorage() {
+    if (browserStorageStatus) {
+        return;
+    }
+    setBrowserStorageStatus(true);
+    for(var key in browserStorageConfig){
+        iterateBrowserStorage(key, function(item) {
+            var iconSet = item.data;
+            var provider = item.provider;
+            var prefix = iconSet.prefix;
+            var storage = getStorage(provider, prefix);
+            if (!addIconSet(storage, iconSet).length) {
+                return false;
+            }
+            var lastModified = iconSet.lastModified || -1;
+            storage.lastModifiedCached = storage.lastModifiedCached ? Math.min(storage.lastModifiedCached, lastModified) : lastModified;
+            return true;
+        });
+    }
+}
+function updateLastModified(storage, lastModified) {
+    var lastValue = storage.lastModifiedCached;
+    if (// Matches or newer
+    lastValue && lastValue >= lastModified) {
+        return lastValue === lastModified;
+    }
+    storage.lastModifiedCached = lastModified;
+    if (lastValue) {
+        for(var key in browserStorageConfig){
+            iterateBrowserStorage(key, function(item) {
+                var iconSet = item.data;
+                return item.provider !== storage.provider || iconSet.prefix !== storage.prefix || iconSet.lastModified === lastModified;
+            });
+        }
+    }
+    return true;
+}
+function storeInBrowserStorage(storage, data) {
+    if (!browserStorageStatus) {
+        initBrowserStorage();
+    }
+    function store(key) {
+        var func;
+        if (!browserStorageConfig[key] || !(func = getBrowserStorage(key))) {
+            return;
+        }
+        var set = browserStorageEmptyItems[key];
+        var index;
+        if (set.size) {
+            set.delete(index = Array.from(set).shift());
+        } else {
+            index = getBrowserStorageItemsCount(func);
+            if (!setBrowserStorageItemsCount(func, index + 1)) {
+                return;
+            }
+        }
+        var item = {
+            cached: Math.floor(Date.now() / browserStorageHour),
+            provider: storage.provider,
+            data: data
+        };
+        return setStoredItem(func, browserCachePrefix + index.toString(), JSON.stringify(item));
+    }
+    if (data.lastModified && !updateLastModified(storage, data.lastModified)) {
+        return;
+    }
+    if (!Object.keys(data.icons).length) {
+        return;
+    }
+    if (data.not_found) {
+        data = Object.assign({}, data);
+        delete data.not_found;
+    }
+    if (!store("local")) {
+        store("session");
+    }
+}
+function emptyCallback() {}
+function loadedNewIcons(storage) {
+    if (!storage.iconsLoaderFlag) {
+        storage.iconsLoaderFlag = true;
+        setTimeout(function() {
+            storage.iconsLoaderFlag = false;
+            updateCallbacks(storage);
+        });
+    }
+}
+function loadNewIcons(storage, icons) {
+    if (!storage.iconsToLoad) {
+        storage.iconsToLoad = icons;
+    } else {
+        storage.iconsToLoad = storage.iconsToLoad.concat(icons).sort();
+    }
+    if (!storage.iconsQueueFlag) {
+        storage.iconsQueueFlag = true;
+        setTimeout(function() {
+            storage.iconsQueueFlag = false;
+            var provider = storage.provider, prefix = storage.prefix;
+            var icons2 = storage.iconsToLoad;
+            delete storage.iconsToLoad;
+            var api;
+            if (!icons2 || !(api = getAPIModule(provider))) {
+                return;
+            }
+            var params = api.prepare(provider, prefix, icons2);
+            params.forEach(function(item) {
+                sendAPIQuery(provider, item, function(data) {
+                    if (typeof data !== "object") {
+                        item.icons.forEach(function(name) {
+                            storage.missing.add(name);
+                        });
+                    } else {
+                        try {
+                            var parsed = addIconSet(storage, data);
+                            if (!parsed.length) {
+                                return;
+                            }
+                            var pending = storage.pendingIcons;
+                            if (pending) {
+                                parsed.forEach(function(name) {
+                                    pending.delete(name);
+                                });
+                            }
+                            storeInBrowserStorage(storage, data);
+                        } catch (err) {
+                            console.error(err);
+                        }
+                    }
+                    loadedNewIcons(storage);
+                });
+            });
+        });
+    }
+}
+var loadIcons = function(icons, callback) {
+    var cleanedIcons = listToIcons(icons, true, allowSimpleNames());
+    var sortedIcons = sortIcons(cleanedIcons);
+    if (!sortedIcons.pending.length) {
+        var callCallback = true;
+        if (callback) {
+            setTimeout(function() {
+                if (callCallback) {
+                    callback(sortedIcons.loaded, sortedIcons.missing, sortedIcons.pending, emptyCallback);
+                }
+            });
+        }
+        return function() {
+            callCallback = false;
+        };
+    }
+    var newIcons = /* @__PURE__ */ Object.create(null);
+    var sources = [];
+    var lastProvider, lastPrefix;
+    sortedIcons.pending.forEach(function(icon) {
+        var provider = icon.provider, prefix = icon.prefix;
+        if (prefix === lastPrefix && provider === lastProvider) {
+            return;
+        }
+        lastProvider = provider;
+        lastPrefix = prefix;
+        sources.push(getStorage(provider, prefix));
+        var providerNewIcons = newIcons[provider] || (newIcons[provider] = /* @__PURE__ */ Object.create(null));
+        if (!providerNewIcons[prefix]) {
+            providerNewIcons[prefix] = [];
+        }
+    });
+    sortedIcons.pending.forEach(function(icon) {
+        var provider = icon.provider, prefix = icon.prefix, name = icon.name;
+        var storage = getStorage(provider, prefix);
+        var pendingQueue = storage.pendingIcons || (storage.pendingIcons = /* @__PURE__ */ new Set());
+        if (!pendingQueue.has(name)) {
+            pendingQueue.add(name);
+            newIcons[provider][prefix].push(name);
+        }
+    });
+    sources.forEach(function(storage) {
+        var provider = storage.provider, prefix = storage.prefix;
+        if (newIcons[provider][prefix].length) {
+            loadNewIcons(storage, newIcons[provider][prefix]);
+        }
+    });
+    return callback ? storeCallback(callback, sortedIcons, sources) : emptyCallback;
+};
+function mergeCustomisations(defaults, item) {
+    var result = _object_spread$5({}, defaults);
+    for(var key in item){
+        var value = item[key];
+        var valueType = typeof value === "undefined" ? "undefined" : _type_of(value);
+        if (key in defaultIconSizeCustomisations) {
+            if (value === null || value && (valueType === "string" || valueType === "number")) {
+                result[key] = value;
+            }
+        } else if (valueType === _type_of(result[key])) {
+            result[key] = key === "rotate" ? value % 4 : value;
+        }
+    }
+    return result;
+}
+var separator = /[\s,]+/;
+function flipFromString(custom, flip) {
+    flip.split(separator).forEach(function(str) {
+        var value = str.trim();
+        switch(value){
+            case "horizontal":
+                custom.hFlip = true;
+                break;
+            case "vertical":
+                custom.vFlip = true;
+                break;
+        }
+    });
+}
+function rotateFromString(value) {
+    var defaultValue = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+    var units = value.replace(/^-?[0-9.]*/, "");
+    function cleanup(value2) {
+        while(value2 < 0){
+            value2 += 4;
+        }
+        return value2 % 4;
+    }
+    if (units === "") {
+        var num = parseInt(value);
+        return isNaN(num) ? 0 : cleanup(num);
+    } else if (units !== value) {
+        var split = 0;
+        switch(units){
+            case "%":
+                split = 25;
+                break;
+            case "deg":
+                split = 90;
+        }
+        if (split) {
+            var num1 = parseFloat(value.slice(0, value.length - units.length));
+            if (isNaN(num1)) {
+                return 0;
+            }
+            num1 = num1 / split;
+            return num1 % 1 === 0 ? cleanup(num1) : 0;
+        }
+    }
+    return defaultValue;
+}
+function iconToHTML(body, attributes) {
+    var renderAttribsHTML = body.indexOf("xlink:") === -1 ? "" : ' xmlns:xlink="http://www.w3.org/1999/xlink"';
+    for(var attr in attributes){
+        renderAttribsHTML += " " + attr + '="' + attributes[attr] + '"';
+    }
+    return '<svg xmlns="http://www.w3.org/2000/svg"' + renderAttribsHTML + ">" + body + "</svg>";
+}
+function encodeSVGforURL(svg) {
+    return svg.replace(/"/g, "'").replace(/%/g, "%25").replace(/#/g, "%23").replace(/</g, "%3C").replace(/>/g, "%3E").replace(/\s+/g, " ");
+}
+function svgToData(svg) {
+    return "data:image/svg+xml," + encodeSVGforURL(svg);
+}
+function svgToURL(svg) {
+    return 'url("' + svgToData(svg) + '")';
+}
+var policy;
+function createPolicy() {
+    try {
+        policy = window.trustedTypes.createPolicy("iconify", {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            createHTML: function(s) {
+                return s;
+            }
+        });
+    } catch (err) {
+        policy = null;
+    }
+}
+function cleanUpInnerHTML(html) {
+    if (policy === void 0) {
+        createPolicy();
+    }
+    return policy ? policy.createHTML(html) : html;
+}
+var defaultExtendedIconCustomisations = _object_spread_props$3(_object_spread$5({}, defaultIconCustomisations), {
+    inline: false
+});
+/**
+ * Default SVG attributes
+ */ var svgDefaults = {
+    "xmlns": "http://www.w3.org/2000/svg",
+    "xmlnsXlink": "http://www.w3.org/1999/xlink",
+    "aria-hidden": true,
+    "role": "img"
+};
+/**
+ * Style modes
+ */ var commonProps = {
+    display: "inline-block"
+};
+var monotoneProps = {
+    backgroundColor: "currentColor"
+};
+var coloredProps = {
+    backgroundColor: "transparent"
+};
+// Dynamically add common props to variables above
+var propsToAdd = {
+    Image: "var(--svg)",
+    Repeat: "no-repeat",
+    Size: "100% 100%"
+};
+var propsToAddTo = {
+    WebkitMask: monotoneProps,
+    mask: monotoneProps,
+    background: coloredProps
+};
+for(var prefix in propsToAddTo){
+    var list = propsToAddTo[prefix];
+    for(var prop in propsToAdd){
+        list[prefix + prop] = propsToAdd[prop];
+    }
+}
+/**
+ * Default values for customisations for inline icon
+ */ var inlineDefaults = _object_spread_props$3(_object_spread$5({}, defaultExtendedIconCustomisations), {
+    inline: true
+});
+/**
+ * Fix size: add 'px' to numbers
+ */ function fixSize(value) {
+    return value + (value.match(/^[-0-9.]+$/) ? "px" : "");
+}
+/**
+ * Render icon
+ */ var render = function(// Icon must be validated before calling this function
+icon, // Partial properties
+props, // True if icon should have vertical-align added
+inline, // Optional reference for SVG/SPAN, extracted by React.forwardRef()
+ref) {
+    // Get default properties
+    var defaultProps = inline ? inlineDefaults : defaultExtendedIconCustomisations;
+    // Get all customisations
+    var customisations = mergeCustomisations(defaultProps, props);
+    // Check mode
+    var mode = props.mode || "svg";
+    // Create style
+    var style = {};
+    var customStyle = props.style || {};
+    // Create SVG component properties
+    var componentProps = _object_spread_props$3(_object_spread$5({}, mode === "svg" ? svgDefaults : {}), {
+        ref: ref
+    });
+    // Get element properties
+    for(var key in props){
+        var value = props[key];
+        if (value === void 0) {
+            continue;
+        }
+        switch(key){
+            // Properties to ignore
+            case "icon":
+            case "style":
+            case "children":
+            case "onLoad":
+            case "mode":
+            case "_ref":
+            case "_inline":
+                break;
+            // Boolean attributes
+            case "inline":
+            case "hFlip":
+            case "vFlip":
+                customisations[key] = value === true || value === "true" || value === 1;
+                break;
+            // Flip as string: 'horizontal,vertical'
+            case "flip":
+                if (typeof value === "string") {
+                    flipFromString(customisations, value);
+                }
+                break;
+            // Color: copy to style
+            case "color":
+                style.color = value;
+                break;
+            // Rotation as string
+            case "rotate":
+                if (typeof value === "string") {
+                    customisations[key] = rotateFromString(value);
+                } else if (typeof value === "number") {
+                    customisations[key] = value;
+                }
+                break;
+            // Remove aria-hidden
+            case "ariaHidden":
+            case "aria-hidden":
+                if (value !== true && value !== "true") {
+                    delete componentProps["aria-hidden"];
+                }
+                break;
+            // Copy missing property if it does not exist in customisations
+            default:
+                if (defaultProps[key] === void 0) {
+                    componentProps[key] = value;
+                }
+        }
+    }
+    // Generate icon
+    var item = iconToSVG(icon, customisations);
+    var renderAttribs = item.attributes;
+    // Inline display
+    if (customisations.inline) {
+        style.verticalAlign = "-0.125em";
+    }
+    if (mode === "svg") {
+        // Add style
+        componentProps.style = _object_spread$5({}, style, customStyle);
+        // Add icon stuff
+        Object.assign(componentProps, renderAttribs);
+        // Counter for ids based on "id" property to render icons consistently on server and client
+        var localCounter = 0;
+        var id = props.id;
+        if (typeof id === "string") {
+            // Convert '-' to '_' to avoid errors in animations
+            id = id.replace(/-/g, "_");
+        }
+        // Add icon stuff
+        componentProps.dangerouslySetInnerHTML = {
+            __html: cleanUpInnerHTML(replaceIDs(item.body, id ? function() {
+                return id + "ID" + localCounter++;
+            } : "iconifyReact"))
+        };
+        return React__default.createElement("svg", componentProps);
+    }
+    // Render <span> with style
+    var body = icon.body, width = icon.width, height = icon.height;
+    var useMask = mode === "mask" || (mode === "bg" ? false : body.indexOf("currentColor") !== -1);
+    // Generate SVG
+    var html = iconToHTML(body, _object_spread_props$3(_object_spread$5({}, renderAttribs), {
+        width: width + "",
+        height: height + ""
+    }));
+    // Generate style
+    componentProps.style = _object_spread$5(_object_spread_props$3(_object_spread$5({}, style), {
+        "--svg": svgToURL(html),
+        "width": fixSize(renderAttribs.width),
+        "height": fixSize(renderAttribs.height)
+    }), commonProps, useMask ? monotoneProps : coloredProps, customStyle);
+    return React__default.createElement("span", componentProps);
+};
+/**
+ * Initialise stuff
+ */ // Enable short names
+allowSimpleNames(true);
+// Set API module
+setAPIModule("", fetchAPIModule);
+/**
+ * Browser stuff
+ */ if (typeof document !== "undefined" && typeof window !== "undefined") {
+    // Set cache and load existing cache
+    initBrowserStorage();
+    var _window1 = window;
+    // Load icons from global "IconifyPreload"
+    if (_window1.IconifyPreload !== void 0) {
+        var preload = _window1.IconifyPreload;
+        var err = "Invalid IconifyPreload syntax.";
+        if (typeof preload === "object" && preload !== null) {
+            (_instanceof(preload, Array) ? preload : [
+                preload
+            ]).forEach(function(item) {
+                try {
+                    if (// Check if item is an object and not null/array
+                    typeof item !== "object" || item === null || _instanceof(item, Array) || // Check for 'icons' and 'prefix'
+                    typeof item.icons !== "object" || typeof item.prefix !== "string" || // Add icon set
+                    !addCollection(item)) {
+                        console.error(err);
+                    }
+                } catch (e) {
+                    console.error(err);
+                }
+            });
+        }
+    }
+    // Set API from global "IconifyProviders"
+    if (_window1.IconifyProviders !== void 0) {
+        var providers = _window1.IconifyProviders;
+        if (typeof providers === "object" && providers !== null) {
+            for(var key in providers){
+                var err1 = "IconifyProviders[" + key + "] is invalid.";
+                try {
+                    var value = providers[key];
+                    if (typeof value !== "object" || !value || value.resources === void 0) {
+                        continue;
+                    }
+                    if (!addAPIProvider(key, value)) {
+                        console.error(err1);
+                    }
+                } catch (e) {
+                    console.error(err1);
+                }
+            }
+        }
+    }
+}
+var IconComponent = /*#__PURE__*/ function(_React_Component) {
+    _inherits(IconComponent, _React_Component);
+    var _super = _create_super(IconComponent);
+    function IconComponent(props) {
+        _class_call_check(this, IconComponent);
+        var _this;
+        _this = _super.call(this, props);
+        _this.state = {
+            // Render placeholder before component is mounted
+            icon: null
+        };
+        return _this;
+    }
+    _create_class(IconComponent, [
+        {
+            /**
+     * Abort loading icon
+     */ key: "_abortLoading",
+            value: function _abortLoading() {
+                if (this._loading) {
+                    this._loading.abort();
+                    this._loading = null;
+                }
+            }
+        },
+        {
+            /**
+     * Update state
+     */ key: "_setData",
+            value: function _setData(icon) {
+                if (this.state.icon !== icon) {
+                    this.setState({
+                        icon: icon
+                    });
+                }
+            }
+        },
+        {
+            /**
+     * Check if icon should be loaded
+     */ key: "_checkIcon",
+            value: function _checkIcon(changed) {
+                var state = this.state;
+                var icon = this.props.icon;
+                // Icon is an object
+                if (typeof icon === "object" && icon !== null && typeof icon.body === "string") {
+                    // Stop loading
+                    this._icon = "";
+                    this._abortLoading();
+                    if (changed || state.icon === null) {
+                        // Set data if it was changed
+                        this._setData({
+                            data: icon
+                        });
+                    }
+                    return;
+                }
+                // Invalid icon?
+                var iconName;
+                if (typeof icon !== "string" || (iconName = stringToIcon(icon, false, true)) === null) {
+                    this._abortLoading();
+                    this._setData(null);
+                    return;
+                }
+                // Load icon
+                var data = getIconData(iconName);
+                if (!data) {
+                    // Icon data is not available
+                    if (!this._loading || this._loading.name !== icon) {
+                        // New icon to load
+                        this._abortLoading();
+                        this._icon = "";
+                        this._setData(null);
+                        if (data !== null) {
+                            // Icon was not loaded
+                            this._loading = {
+                                name: icon,
+                                abort: loadIcons([
+                                    iconName
+                                ], this._checkIcon.bind(this, false))
+                            };
+                        }
+                    }
+                    return;
+                }
+                // Icon data is available
+                if (this._icon !== icon || state.icon === null) {
+                    // New icon or icon has been loaded
+                    this._abortLoading();
+                    this._icon = icon;
+                    // Add classes
+                    var classes = [
+                        "iconify"
+                    ];
+                    if (iconName.prefix !== "") {
+                        classes.push("iconify--" + iconName.prefix);
+                    }
+                    if (iconName.provider !== "") {
+                        classes.push("iconify--" + iconName.provider);
+                    }
+                    // Set data
+                    this._setData({
+                        data: data,
+                        classes: classes
+                    });
+                    if (this.props.onLoad) {
+                        this.props.onLoad(icon);
+                    }
+                }
+            }
+        },
+        {
+            /**
+     * Component mounted
+     */ key: "componentDidMount",
+            value: function componentDidMount() {
+                this._checkIcon(false);
+            }
+        },
+        {
+            /**
+     * Component updated
+     */ key: "componentDidUpdate",
+            value: function componentDidUpdate(oldProps) {
+                if (oldProps.icon !== this.props.icon) {
+                    this._checkIcon(true);
+                }
+            }
+        },
+        {
+            /**
+     * Abort loading
+     */ key: "componentWillUnmount",
+            value: function componentWillUnmount() {
+                this._abortLoading();
+            }
+        },
+        {
+            /**
+     * Render
+     */ key: "render",
+            value: function render1() {
+                var props = this.props;
+                var icon = this.state.icon;
+                if (icon === null) {
+                    // Render placeholder
+                    return props.children ? props.children : React__default.createElement("span", {});
+                }
+                // Add classes
+                var newProps = props;
+                if (icon.classes) {
+                    newProps = _object_spread_props$3(_object_spread$5({}, props), {
+                        className: (typeof props.className === "string" ? props.className + " " : "") + icon.classes.join(" ")
+                    });
+                }
+                // Render icon
+                return render(_object_spread$5({}, defaultIconProps, icon.data), newProps, props._inline, props._ref);
+            }
+        }
+    ]);
+    return IconComponent;
+}(React__default.Component);
+/**
+ * Block icon
+ *
+ * @param props - Component properties
+ */ var Icon = React__default.forwardRef(function Icon(props, ref) {
+    var newProps = _object_spread_props$3(_object_spread$5({}, props), {
+        _ref: ref,
+        _inline: false
+    });
+    return React__default.createElement(IconComponent, newProps);
+});
+/**
+ * Inline icon (has negative verticalAlign that makes it behave like icon font)
+ *
+ * @param props - Component properties
+ */ React__default.forwardRef(function InlineIcon(props, ref) {
+    var newProps = _object_spread_props$3(_object_spread$5({}, props), {
+        _ref: ref,
+        _inline: true
+    });
+    return React__default.createElement(IconComponent, newProps);
+});
+
 function _array_like_to_array$3(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
@@ -67462,7 +69412,7 @@ function _array_with_holes$3(arr) {
 function _array_without_holes(arr) {
     if (Array.isArray(arr)) return _array_like_to_array$3(arr);
 }
-function _define_property$7(obj, key, value) {
+function _define_property$4(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -67508,7 +69458,7 @@ function _non_iterable_rest$3() {
 function _non_iterable_spread() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _object_spread$7(target) {
+function _object_spread$4(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
         var ownKeys = Object.keys(source);
@@ -67518,12 +69468,12 @@ function _object_spread$7(target) {
             }));
         }
         ownKeys.forEach(function(key) {
-            _define_property$7(target, key, source[key]);
+            _define_property$4(target, key, source[key]);
         });
     }
     return target;
 }
-function ownKeys$3(object, enumerableOnly) {
+function ownKeys$2(object, enumerableOnly) {
     var keys = Object.keys(object);
     if (Object.getOwnPropertySymbols) {
         var symbols = Object.getOwnPropertySymbols(object);
@@ -67536,12 +69486,12 @@ function ownKeys$3(object, enumerableOnly) {
     }
     return keys;
 }
-function _object_spread_props$3(target, source) {
+function _object_spread_props$2(target, source) {
     source = source != null ? source : {};
     if (Object.getOwnPropertyDescriptors) {
         Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
     } else {
-        ownKeys$3(Object(source)).forEach(function(key) {
+        ownKeys$2(Object(source)).forEach(function(key) {
             Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
         });
     }
@@ -67602,11 +69552,11 @@ var DropImage = function(param) {
     return /*#__PURE__*/ jsxs("section", {
         className: "w-full",
         children: [
-            /*#__PURE__*/ jsxs("div", _object_spread_props$3(_object_spread$7({}, getRootProps({
+            /*#__PURE__*/ jsxs("div", _object_spread_props$2(_object_spread$4({}, getRootProps({
                 className: "dropzone"
             })), {
                 children: [
-                    /*#__PURE__*/ jsx("input", _object_spread$7({}, getInputProps())),
+                    /*#__PURE__*/ jsx("input", _object_spread$4({}, getInputProps())),
                     /*#__PURE__*/ jsx("div", {
                         className: "flex justify-between",
                         children: /*#__PURE__*/ jsx("div", {
@@ -68047,7 +69997,7 @@ function cn() {
     return twMerge(clsx(inputs));
 }
 
-function _define_property$6(obj, key, value) {
+function _define_property$3(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -68060,7 +70010,7 @@ function _define_property$6(obj, key, value) {
     }
     return obj;
 }
-function _object_spread$6(target) {
+function _object_spread$3(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
         var ownKeys = Object.keys(source);
@@ -68070,12 +70020,12 @@ function _object_spread$6(target) {
             }));
         }
         ownKeys.forEach(function(key) {
-            _define_property$6(target, key, source[key]);
+            _define_property$3(target, key, source[key]);
         });
     }
     return target;
 }
-function ownKeys$2(object, enumerableOnly) {
+function ownKeys$1(object, enumerableOnly) {
     var keys = Object.keys(object);
     if (Object.getOwnPropertySymbols) {
         var symbols = Object.getOwnPropertySymbols(object);
@@ -68088,20 +70038,20 @@ function ownKeys$2(object, enumerableOnly) {
     }
     return keys;
 }
-function _object_spread_props$2(target, source) {
+function _object_spread_props$1(target, source) {
     source = source != null ? source : {};
     if (Object.getOwnPropertyDescriptors) {
         Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
     } else {
-        ownKeys$2(Object(source)).forEach(function(key) {
+        ownKeys$1(Object(source)).forEach(function(key) {
             Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
         });
     }
     return target;
 }
-function _object_without_properties$6(source, excluded) {
+function _object_without_properties$3(source, excluded) {
     if (source == null) return {};
-    var target = _object_without_properties_loose$6(source, excluded);
+    var target = _object_without_properties_loose$3(source, excluded);
     var key, i;
     if (Object.getOwnPropertySymbols) {
         var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
@@ -68114,7 +70064,7 @@ function _object_without_properties$6(source, excluded) {
     }
     return target;
 }
-function _object_without_properties_loose$6(source, excluded) {
+function _object_without_properties_loose$3(source, excluded) {
     if (source == null) return {};
     var target = {};
     var sourceKeys = Object.keys(source);
@@ -68127,10 +70077,10 @@ function _object_without_properties_loose$6(source, excluded) {
     return target;
 }
 var Switch = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, props = _object_without_properties$6(_param, [
+    var className = _param.className, props = _object_without_properties$3(_param, [
         "className"
     ]);
-    return /*#__PURE__*/ jsx(SwitchPrimitives.Root, _object_spread_props$2(_object_spread$6({
+    return /*#__PURE__*/ jsx(SwitchPrimitives.Root, _object_spread_props$1(_object_spread$3({
         className: cn("peer inline-flex h-5 w-9 shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent shadow-sm transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=unchecked]:bg-input", className)
     }, props), {
         ref: ref,
@@ -68141,7 +70091,7 @@ var Switch = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
 });
 Switch.displayName = SwitchPrimitives.Root.displayName;
 
-function _define_property$5(obj, key, value) {
+function _define_property$2(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -68154,7 +70104,7 @@ function _define_property$5(obj, key, value) {
     }
     return obj;
 }
-function _object_spread$5(target) {
+function _object_spread$2(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
         var ownKeys = Object.keys(source);
@@ -68164,14 +70114,14 @@ function _object_spread$5(target) {
             }));
         }
         ownKeys.forEach(function(key) {
-            _define_property$5(target, key, source[key]);
+            _define_property$2(target, key, source[key]);
         });
     }
     return target;
 }
-function _object_without_properties$5(source, excluded) {
+function _object_without_properties$2(source, excluded) {
     if (source == null) return {};
-    var target = _object_without_properties_loose$5(source, excluded);
+    var target = _object_without_properties_loose$2(source, excluded);
     var key, i;
     if (Object.getOwnPropertySymbols) {
         var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
@@ -68184,7 +70134,7 @@ function _object_without_properties$5(source, excluded) {
     }
     return target;
 }
-function _object_without_properties_loose$5(source, excluded) {
+function _object_without_properties_loose$2(source, excluded) {
     if (source == null) return {};
     var target = {};
     var sourceKeys = Object.keys(source);
@@ -68219,14 +70169,14 @@ var buttonVariants = cva("inline-flex items-center justify-center whitespace-now
     }
 });
 var Button = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, variant = _param.variant, size = _param.size, _param_asChild = _param.asChild, asChild = _param_asChild === void 0 ? false : _param_asChild, props = _object_without_properties$5(_param, [
+    var className = _param.className, variant = _param.variant, size = _param.size, _param_asChild = _param.asChild, asChild = _param_asChild === void 0 ? false : _param_asChild, props = _object_without_properties$2(_param, [
         "className",
         "variant",
         "size",
         "asChild"
     ]);
     var Comp = asChild ? Slot : "button";
-    return /*#__PURE__*/ jsx(Comp, _object_spread$5({
+    return /*#__PURE__*/ jsx(Comp, _object_spread$2({
         className: cn(buttonVariants({
             variant: variant,
             size: size,
@@ -68236,7 +70186,7 @@ var Button = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
     }, props));
 });
 
-function _define_property$4(obj, key, value) {
+function _define_property$1(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -68267,7 +70217,7 @@ function _object_destructuring_empty(o) {
     if (o === null || o === void 0) throw new TypeError("Cannot destructure " + o);
     return o;
 }
-function _object_spread$4(target) {
+function _object_spread$1(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
         var ownKeys = Object.keys(source);
@@ -68277,12 +70227,12 @@ function _object_spread$4(target) {
             }));
         }
         ownKeys.forEach(function(key) {
-            _define_property$4(target, key, source[key]);
+            _define_property$1(target, key, source[key]);
         });
     }
     return target;
 }
-function ownKeys$1(object, enumerableOnly) {
+function ownKeys(object, enumerableOnly) {
     var keys = Object.keys(object);
     if (Object.getOwnPropertySymbols) {
         var symbols = Object.getOwnPropertySymbols(object);
@@ -68295,20 +70245,20 @@ function ownKeys$1(object, enumerableOnly) {
     }
     return keys;
 }
-function _object_spread_props$1(target, source) {
+function _object_spread_props(target, source) {
     source = source != null ? source : {};
     if (Object.getOwnPropertyDescriptors) {
         Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
     } else {
-        ownKeys$1(Object(source)).forEach(function(key) {
+        ownKeys(Object(source)).forEach(function(key) {
             Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
         });
     }
     return target;
 }
-function _object_without_properties$4(source, excluded) {
+function _object_without_properties$1(source, excluded) {
     if (source == null) return {};
-    var target = _object_without_properties_loose$4(source, excluded);
+    var target = _object_without_properties_loose$1(source, excluded);
     var key, i;
     if (Object.getOwnPropertySymbols) {
         var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
@@ -68321,7 +70271,7 @@ function _object_without_properties$4(source, excluded) {
     }
     return target;
 }
-function _object_without_properties_loose$4(source, excluded) {
+function _object_without_properties_loose$1(source, excluded) {
     if (source == null) return {};
     var target = {};
     var sourceKeys = Object.keys(source);
@@ -68334,15 +70284,15 @@ function _object_without_properties_loose$4(source, excluded) {
     return target;
 }
 function Calendar(_param) {
-    var className = _param.className, classNames = _param.classNames, _param_showOutsideDays = _param.showOutsideDays, showOutsideDays = _param_showOutsideDays === void 0 ? true : _param_showOutsideDays, props = _object_without_properties$4(_param, [
+    var className = _param.className, classNames = _param.classNames, _param_showOutsideDays = _param.showOutsideDays, showOutsideDays = _param_showOutsideDays === void 0 ? true : _param_showOutsideDays, props = _object_without_properties$1(_param, [
         "className",
         "classNames",
         "showOutsideDays"
     ]);
-    return /*#__PURE__*/ jsx(DayPicker, _object_spread_props$1(_object_spread$4({
+    return /*#__PURE__*/ jsx(DayPicker, _object_spread_props(_object_spread$1({
         showOutsideDays: showOutsideDays,
         className: cn("p-3", className),
-        classNames: _object_spread$4({
+        classNames: _object_spread$1({
             months: "flex flex-col sm:flex-row space-y-4 sm:space-x-4 sm:space-y-0",
             month: "space-y-4",
             caption: "flex justify-center pt-1 relative items-center",
@@ -68394,7 +70344,7 @@ function Calendar(_param) {
 }
 Calendar.displayName = "Calendar";
 
-function _define_property$3(obj, key, value) {
+function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -68407,7 +70357,7 @@ function _define_property$3(obj, key, value) {
     }
     return obj;
 }
-function _object_spread$3(target) {
+function _object_spread(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
         var ownKeys = Object.keys(source);
@@ -68417,14 +70367,14 @@ function _object_spread$3(target) {
             }));
         }
         ownKeys.forEach(function(key) {
-            _define_property$3(target, key, source[key]);
+            _define_property(target, key, source[key]);
         });
     }
     return target;
 }
-function _object_without_properties$3(source, excluded) {
+function _object_without_properties(source, excluded) {
     if (source == null) return {};
-    var target = _object_without_properties_loose$3(source, excluded);
+    var target = _object_without_properties_loose(source, excluded);
     var key, i;
     if (Object.getOwnPropertySymbols) {
         var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
@@ -68437,7 +70387,7 @@ function _object_without_properties$3(source, excluded) {
     }
     return target;
 }
-function _object_without_properties_loose$3(source, excluded) {
+function _object_without_properties_loose(source, excluded) {
     if (source == null) return {};
     var target = {};
     var sourceKeys = Object.keys(source);
@@ -68452,13 +70402,13 @@ function _object_without_properties_loose$3(source, excluded) {
 var Popover = PopoverPrimitive.Root;
 var PopoverTrigger = PopoverPrimitive.Trigger;
 var PopoverContent = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, _param_align = _param.align, align = _param_align === void 0 ? "center" : _param_align, _param_sideOffset = _param.sideOffset, sideOffset = _param_sideOffset === void 0 ? 4 : _param_sideOffset, props = _object_without_properties$3(_param, [
+    var className = _param.className, _param_align = _param.align, align = _param_align === void 0 ? "center" : _param_align, _param_sideOffset = _param.sideOffset, sideOffset = _param_sideOffset === void 0 ? 4 : _param_sideOffset, props = _object_without_properties(_param, [
         "className",
         "align",
         "sideOffset"
     ]);
     return /*#__PURE__*/ jsx(PopoverPrimitive.Portal, {
-        children: /*#__PURE__*/ jsx(PopoverPrimitive.Content, _object_spread$3({
+        children: /*#__PURE__*/ jsx(PopoverPrimitive.Content, _object_spread({
             ref: ref,
             align: align,
             sideOffset: sideOffset,
@@ -68679,414 +70629,4 @@ var ReactDateRange = function(param) {
     });
 };
 
-function _define_property$2(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _object_spread$2(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property$2(target, key, source[key]);
-        });
-    }
-    return target;
-}
-function ownKeys(object, enumerableOnly) {
-    var keys = Object.keys(object);
-    if (Object.getOwnPropertySymbols) {
-        var symbols = Object.getOwnPropertySymbols(object);
-        if (enumerableOnly) {
-            symbols = symbols.filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-            });
-        }
-        keys.push.apply(keys, symbols);
-    }
-    return keys;
-}
-function _object_spread_props(target, source) {
-    source = source != null ? source : {};
-    if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-        ownKeys(Object(source)).forEach(function(key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
-    }
-    return target;
-}
-function _object_without_properties$2(source, excluded) {
-    if (source == null) return {};
-    var target = _object_without_properties_loose$2(source, excluded);
-    var key, i;
-    if (Object.getOwnPropertySymbols) {
-        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-        for(i = 0; i < sourceSymbolKeys.length; i++){
-            key = sourceSymbolKeys[i];
-            if (excluded.indexOf(key) >= 0) continue;
-            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-            target[key] = source[key];
-        }
-    }
-    return target;
-}
-function _object_without_properties_loose$2(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-    for(i = 0; i < sourceKeys.length; i++){
-        key = sourceKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        target[key] = source[key];
-    }
-    return target;
-}
-var DropdownMenuSubTrigger = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, inset = _param.inset, children = _param.children, props = _object_without_properties$2(_param, [
-        "className",
-        "inset",
-        "children"
-    ]);
-    return /*#__PURE__*/ jsxs(DropdownMenuPrimitive.SubTrigger, _object_spread_props(_object_spread$2({
-        ref: ref,
-        className: cn("flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent data-[state=open]:bg-accent", inset && "pl-8", className)
-    }, props), {
-        children: [
-            children,
-            /*#__PURE__*/ jsx(ChevronRightIcon, {
-                className: "ml-auto h-4 w-4"
-            })
-        ]
-    }));
-});
-DropdownMenuSubTrigger.displayName = DropdownMenuPrimitive.SubTrigger.displayName;
-var DropdownMenuSubContent = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, props = _object_without_properties$2(_param, [
-        "className"
-    ]);
-    return /*#__PURE__*/ jsx(DropdownMenuPrimitive.SubContent, _object_spread$2({
-        ref: ref,
-        className: cn("z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", className)
-    }, props));
-});
-DropdownMenuSubContent.displayName = DropdownMenuPrimitive.SubContent.displayName;
-var DropdownMenuContent = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, _param_sideOffset = _param.sideOffset, sideOffset = _param_sideOffset === void 0 ? 4 : _param_sideOffset, props = _object_without_properties$2(_param, [
-        "className",
-        "sideOffset"
-    ]);
-    return /*#__PURE__*/ jsx(DropdownMenuPrimitive.Portal, {
-        children: /*#__PURE__*/ jsx(DropdownMenuPrimitive.Content, _object_spread$2({
-            ref: ref,
-            sideOffset: sideOffset,
-            className: cn("z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md", "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", className)
-        }, props))
-    });
-});
-DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName;
-var DropdownMenuItem = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, inset = _param.inset, props = _object_without_properties$2(_param, [
-        "className",
-        "inset"
-    ]);
-    return /*#__PURE__*/ jsx(DropdownMenuPrimitive.Item, _object_spread$2({
-        ref: ref,
-        className: cn("relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", inset && "pl-8", className)
-    }, props));
-});
-DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName;
-var DropdownMenuCheckboxItem = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, children = _param.children, checked = _param.checked, props = _object_without_properties$2(_param, [
-        "className",
-        "children",
-        "checked"
-    ]);
-    return /*#__PURE__*/ jsxs(DropdownMenuPrimitive.CheckboxItem, _object_spread_props(_object_spread$2({
-        ref: ref,
-        className: cn("relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className),
-        checked: checked
-    }, props), {
-        children: [
-            /*#__PURE__*/ jsx("span", {
-                className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center",
-                children: /*#__PURE__*/ jsx(DropdownMenuPrimitive.ItemIndicator, {
-                    children: /*#__PURE__*/ jsx(CheckIcon, {
-                        className: "h-4 w-4"
-                    })
-                })
-            }),
-            children
-        ]
-    }));
-});
-DropdownMenuCheckboxItem.displayName = DropdownMenuPrimitive.CheckboxItem.displayName;
-var DropdownMenuRadioItem = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, children = _param.children, props = _object_without_properties$2(_param, [
-        "className",
-        "children"
-    ]);
-    return /*#__PURE__*/ jsxs(DropdownMenuPrimitive.RadioItem, _object_spread_props(_object_spread$2({
-        ref: ref,
-        className: cn("relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className)
-    }, props), {
-        children: [
-            /*#__PURE__*/ jsx("span", {
-                className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center",
-                children: /*#__PURE__*/ jsx(DropdownMenuPrimitive.ItemIndicator, {
-                    children: /*#__PURE__*/ jsx(DotFilledIcon, {
-                        className: "h-4 w-4 fill-current"
-                    })
-                })
-            }),
-            children
-        ]
-    }));
-});
-DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName;
-var DropdownMenuLabel = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, inset = _param.inset, props = _object_without_properties$2(_param, [
-        "className",
-        "inset"
-    ]);
-    return /*#__PURE__*/ jsx(DropdownMenuPrimitive.Label, _object_spread$2({
-        ref: ref,
-        className: cn("px-2 py-1.5 text-sm font-semibold", inset && "pl-8", className)
-    }, props));
-});
-DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName;
-var DropdownMenuSeparator = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, props = _object_without_properties$2(_param, [
-        "className"
-    ]);
-    return /*#__PURE__*/ jsx(DropdownMenuPrimitive.Separator, _object_spread$2({
-        ref: ref,
-        className: cn("-mx-1 my-1 h-px bg-muted", className)
-    }, props));
-});
-DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName;
-
-function _define_property$1(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _object_spread$1(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property$1(target, key, source[key]);
-        });
-    }
-    return target;
-}
-function _object_without_properties$1(source, excluded) {
-    if (source == null) return {};
-    var target = _object_without_properties_loose$1(source, excluded);
-    var key, i;
-    if (Object.getOwnPropertySymbols) {
-        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-        for(i = 0; i < sourceSymbolKeys.length; i++){
-            key = sourceSymbolKeys[i];
-            if (excluded.indexOf(key) >= 0) continue;
-            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-            target[key] = source[key];
-        }
-    }
-    return target;
-}
-function _object_without_properties_loose$1(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-    for(i = 0; i < sourceKeys.length; i++){
-        key = sourceKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        target[key] = source[key];
-    }
-    return target;
-}
-var Input = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, type = _param.type, props = _object_without_properties$1(_param, [
-        "className",
-        "type"
-    ]);
-    return /*#__PURE__*/ jsx("input", _object_spread$1({
-        type: type,
-        className: cn("flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50", className),
-        ref: ref
-    }, props));
-});
-Input.displayName = "Input";
-
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _object_spread(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property(target, key, source[key]);
-        });
-    }
-    return target;
-}
-function _object_without_properties(source, excluded) {
-    if (source == null) return {};
-    var target = _object_without_properties_loose(source, excluded);
-    var key, i;
-    if (Object.getOwnPropertySymbols) {
-        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-        for(i = 0; i < sourceSymbolKeys.length; i++){
-            key = sourceSymbolKeys[i];
-            if (excluded.indexOf(key) >= 0) continue;
-            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-            target[key] = source[key];
-        }
-    }
-    return target;
-}
-function _object_without_properties_loose(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-    for(i = 0; i < sourceKeys.length; i++){
-        key = sourceKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        target[key] = source[key];
-    }
-    return target;
-}
-var Table = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, props = _object_without_properties(_param, [
-        "className"
-    ]);
-    return /*#__PURE__*/ jsx("div", {
-        className: "relative w-full overflow-auto",
-        children: /*#__PURE__*/ jsx("table", _object_spread({
-            ref: ref,
-            className: cn("w-full caption-bottom text-sm", className)
-        }, props))
-    });
-});
-Table.displayName = "Table";
-var TableHeader = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, props = _object_without_properties(_param, [
-        "className"
-    ]);
-    return /*#__PURE__*/ jsx("thead", _object_spread({
-        ref: ref,
-        className: cn("[&_tr]:border-b", className)
-    }, props));
-});
-TableHeader.displayName = "TableHeader";
-var TableBody = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, props = _object_without_properties(_param, [
-        "className"
-    ]);
-    return /*#__PURE__*/ jsx("tbody", _object_spread({
-        ref: ref,
-        className: cn("[&_tr:last-child]:border-0", className)
-    }, props));
-});
-TableBody.displayName = "TableBody";
-var TableFooter = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, props = _object_without_properties(_param, [
-        "className"
-    ]);
-    return /*#__PURE__*/ jsx("tfoot", _object_spread({
-        ref: ref,
-        className: cn("border-t bg-muted/50 font-medium [&>tr]:last:border-b-0", className)
-    }, props));
-});
-TableFooter.displayName = "TableFooter";
-var TableRow = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, props = _object_without_properties(_param, [
-        "className"
-    ]);
-    return /*#__PURE__*/ jsx("tr", _object_spread({
-        ref: ref,
-        className: cn("border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted", className)
-    }, props));
-});
-TableRow.displayName = "TableRow";
-var TableHead = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, props = _object_without_properties(_param, [
-        "className"
-    ]);
-    return /*#__PURE__*/ jsx("th", _object_spread({
-        ref: ref,
-        className: cn("h-10 px-2 text-left align-middle font-medium text-muted-foreground [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]", className)
-    }, props));
-});
-TableHead.displayName = "TableHead";
-var TableCell = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, props = _object_without_properties(_param, [
-        "className"
-    ]);
-    return /*#__PURE__*/ jsx("td", _object_spread({
-        ref: ref,
-        className: cn("p-2 align-middle [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]", className)
-    }, props));
-});
-TableCell.displayName = "TableCell";
-var TableCaption = /*#__PURE__*/ React.forwardRef(function(_param, ref) {
-    var className = _param.className, props = _object_without_properties(_param, [
-        "className"
-    ]);
-    return /*#__PURE__*/ jsx("caption", _object_spread({
-        ref: ref,
-        className: cn("mt-4 text-sm text-muted-foreground", className)
-    }, props));
-});
-TableCaption.displayName = "TableCaption";
-
 export { CkEditor, CustomUpload, DateRangePicker, DropImage, ReactDateRange, Spin, Switch, UiLibrary };