@websolutespa/bom-mixer-ui 0.0.1

package/dist/chunk-4GP5DTTM.mjs

@@ -0,0 +1,1101 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// ../../../../node_modules/@swc/helpers/lib/_extends.js
+var require_extends = __commonJS({
+  "../../../../node_modules/@swc/helpers/lib/_extends.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = _extends;
+    function _extends() {
+      return extends_.apply(this, arguments);
+    }
+    function extends_() {
+      extends_ = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return extends_.apply(this, arguments);
+    }
+  }
+});
+
+// ../../../../node_modules/@swc/helpers/lib/_interop_require_default.js
+var require_interop_require_default = __commonJS({
+  "../../../../node_modules/@swc/helpers/lib/_interop_require_default.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = _interopRequireDefault;
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : {
+        default: obj
+      };
+    }
+  }
+});
+
+// ../../../../node_modules/next/dist/shared/lib/loadable-context.js
+var require_loadable_context = __commonJS({
+  "../../../../node_modules/next/dist/shared/lib/loadable-context.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.LoadableContext = void 0;
+    var _interop_require_default = require_interop_require_default().default;
+    var _react = _interop_require_default(__require("react"));
+    var LoadableContext = _react.default.createContext(null);
+    exports.LoadableContext = LoadableContext;
+    if (process.env.NODE_ENV !== "production") {
+      LoadableContext.displayName = "LoadableContext";
+    }
+  }
+});
+
+// ../../../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.min.js
+var require_use_sync_external_store_shim_production_min = __commonJS({
+  "../../../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.min.js"(exports) {
+    "use strict";
+    var e = __require("react");
+    function h(a, b) {
+      return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b;
+    }
+    var k = "function" === typeof Object.is ? Object.is : h;
+    var l = e.useState;
+    var m = e.useEffect;
+    var n = e.useLayoutEffect;
+    var p = e.useDebugValue;
+    function q(a, b) {
+      var d = b(), f = l({ inst: { value: d, getSnapshot: b } }), c = f[0].inst, g = f[1];
+      n(function() {
+        c.value = d;
+        c.getSnapshot = b;
+        r(c) && g({ inst: c });
+      }, [a, d, b]);
+      m(function() {
+        r(c) && g({ inst: c });
+        return a(function() {
+          r(c) && g({ inst: c });
+        });
+      }, [a]);
+      p(d);
+      return d;
+    }
+    function r(a) {
+      var b = a.getSnapshot;
+      a = a.value;
+      try {
+        var d = b();
+        return !k(a, d);
+      } catch (f) {
+        return true;
+      }
+    }
+    function t(a, b) {
+      return b();
+    }
+    var u = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? t : q;
+    exports.useSyncExternalStore = void 0 !== e.useSyncExternalStore ? e.useSyncExternalStore : u;
+  }
+});
+
+// ../../../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js
+var require_use_sync_external_store_shim_development = __commonJS({
+  "../../../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js"(exports) {
+    "use strict";
+    if (process.env.NODE_ENV !== "production") {
+      (function() {
+        "use strict";
+        if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
+          __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+        }
+        var React2 = __require("react");
+        var ReactSharedInternals = React2.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+        function error(format) {
+          {
+            {
+              for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+                args[_key2 - 1] = arguments[_key2];
+              }
+              printWarning("error", format, args);
+            }
+          }
+        }
+        function printWarning(level, format, args) {
+          {
+            var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+            var stack = ReactDebugCurrentFrame.getStackAddendum();
+            if (stack !== "") {
+              format += "%s";
+              args = args.concat([stack]);
+            }
+            var argsWithFormat = args.map(function(item) {
+              return String(item);
+            });
+            argsWithFormat.unshift("Warning: " + format);
+            Function.prototype.apply.call(console[level], console, argsWithFormat);
+          }
+        }
+        function is(x, y) {
+          return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
+        }
+        var objectIs = typeof Object.is === "function" ? Object.is : is;
+        var useState = React2.useState, useEffect = React2.useEffect, useLayoutEffect = React2.useLayoutEffect, useDebugValue = React2.useDebugValue;
+        var didWarnOld18Alpha = false;
+        var didWarnUncachedGetSnapshot = false;
+        function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+          {
+            if (!didWarnOld18Alpha) {
+              if (React2.startTransition !== void 0) {
+                didWarnOld18Alpha = true;
+                error("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release.");
+              }
+            }
+          }
+          var value = getSnapshot();
+          {
+            if (!didWarnUncachedGetSnapshot) {
+              var cachedValue = getSnapshot();
+              if (!objectIs(value, cachedValue)) {
+                error("The result of getSnapshot should be cached to avoid an infinite loop");
+                didWarnUncachedGetSnapshot = true;
+              }
+            }
+          }
+          var _useState = useState({
+            inst: {
+              value,
+              getSnapshot
+            }
+          }), inst = _useState[0].inst, forceUpdate = _useState[1];
+          useLayoutEffect(function() {
+            inst.value = value;
+            inst.getSnapshot = getSnapshot;
+            if (checkIfSnapshotChanged(inst)) {
+              forceUpdate({
+                inst
+              });
+            }
+          }, [subscribe, value, getSnapshot]);
+          useEffect(function() {
+            if (checkIfSnapshotChanged(inst)) {
+              forceUpdate({
+                inst
+              });
+            }
+            var handleStoreChange = function() {
+              if (checkIfSnapshotChanged(inst)) {
+                forceUpdate({
+                  inst
+                });
+              }
+            };
+            return subscribe(handleStoreChange);
+          }, [subscribe]);
+          useDebugValue(value);
+          return value;
+        }
+        function checkIfSnapshotChanged(inst) {
+          var latestGetSnapshot = inst.getSnapshot;
+          var prevValue = inst.value;
+          try {
+            var nextValue = latestGetSnapshot();
+            return !objectIs(prevValue, nextValue);
+          } catch (error2) {
+            return true;
+          }
+        }
+        function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
+          return getSnapshot();
+        }
+        var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+        var isServerEnvironment = !canUseDOM;
+        var shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
+        var useSyncExternalStore$2 = React2.useSyncExternalStore !== void 0 ? React2.useSyncExternalStore : shim;
+        exports.useSyncExternalStore = useSyncExternalStore$2;
+        if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
+          __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+        }
+      })();
+    }
+  }
+});
+
+// ../../../../node_modules/use-sync-external-store/shim/index.js
+var require_shim = __commonJS({
+  "../../../../node_modules/use-sync-external-store/shim/index.js"(exports, module) {
+    "use strict";
+    if (process.env.NODE_ENV === "production") {
+      module.exports = require_use_sync_external_store_shim_production_min();
+    } else {
+      module.exports = require_use_sync_external_store_shim_development();
+    }
+  }
+});
+
+// ../../../../node_modules/next/dist/shared/lib/loadable.js
+var require_loadable = __commonJS({
+  "../../../../node_modules/next/dist/shared/lib/loadable.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _extends = require_extends().default;
+    var _interop_require_default = require_interop_require_default().default;
+    var _react = _interop_require_default(__require("react"));
+    var _loadableContext = require_loadable_context();
+    var { useSyncExternalStore } = process.env.__NEXT_REACT_ROOT ? __require("react") : require_shim();
+    var ALL_INITIALIZERS = [];
+    var READY_INITIALIZERS = [];
+    var initialized = false;
+    function load(loader) {
+      let promise = loader();
+      let state = {
+        loading: true,
+        loaded: null,
+        error: null
+      };
+      state.promise = promise.then((loaded) => {
+        state.loading = false;
+        state.loaded = loaded;
+        return loaded;
+      }).catch((err) => {
+        state.loading = false;
+        state.error = err;
+        throw err;
+      });
+      return state;
+    }
+    function resolve(obj) {
+      return obj && obj.__esModule ? obj.default : obj;
+    }
+    function createLoadableComponent(loadFn, options) {
+      let opts = Object.assign({
+        loader: null,
+        loading: null,
+        delay: 200,
+        timeout: null,
+        webpack: null,
+        modules: null,
+        suspense: false
+      }, options);
+      if (opts.suspense) {
+        opts.lazy = _react.default.lazy(opts.loader);
+      }
+      let subscription = null;
+      function init() {
+        if (!subscription) {
+          const sub = new LoadableSubscription(loadFn, opts);
+          subscription = {
+            getCurrentValue: sub.getCurrentValue.bind(sub),
+            subscribe: sub.subscribe.bind(sub),
+            retry: sub.retry.bind(sub),
+            promise: sub.promise.bind(sub)
+          };
+        }
+        return subscription.promise();
+      }
+      if (typeof window === "undefined") {
+        ALL_INITIALIZERS.push(init);
+      }
+      if (!initialized && typeof window !== "undefined") {
+        const moduleIds = opts.webpack && typeof __require.resolveWeak === "function" ? opts.webpack() : opts.modules;
+        if (moduleIds) {
+          READY_INITIALIZERS.push((ids) => {
+            for (const moduleId of moduleIds) {
+              if (ids.indexOf(moduleId) !== -1) {
+                return init();
+              }
+            }
+          });
+        }
+      }
+      function useLoadableModule() {
+        init();
+        const context = _react.default.useContext(_loadableContext.LoadableContext);
+        if (context && Array.isArray(opts.modules)) {
+          opts.modules.forEach((moduleName) => {
+            context(moduleName);
+          });
+        }
+      }
+      function LoadableImpl(props, ref) {
+        useLoadableModule();
+        const state = useSyncExternalStore(subscription.subscribe, subscription.getCurrentValue, subscription.getCurrentValue);
+        _react.default.useImperativeHandle(ref, () => ({
+          retry: subscription.retry
+        }), []);
+        return _react.default.useMemo(() => {
+          if (state.loading || state.error) {
+            return _react.default.createElement(opts.loading, {
+              isLoading: state.loading,
+              pastDelay: state.pastDelay,
+              timedOut: state.timedOut,
+              error: state.error,
+              retry: subscription.retry
+            });
+          } else if (state.loaded) {
+            return _react.default.createElement(resolve(state.loaded), props);
+          } else {
+            return null;
+          }
+        }, [
+          props,
+          state
+        ]);
+      }
+      function LazyImpl(props, ref) {
+        useLoadableModule();
+        return _react.default.createElement(opts.lazy, _extends({}, props, {
+          ref
+        }));
+      }
+      const LoadableComponent = opts.suspense ? LazyImpl : LoadableImpl;
+      LoadableComponent.preload = () => init();
+      LoadableComponent.displayName = "LoadableComponent";
+      return _react.default.forwardRef(LoadableComponent);
+    }
+    var LoadableSubscription = class {
+      promise() {
+        return this._res.promise;
+      }
+      retry() {
+        this._clearTimeouts();
+        this._res = this._loadFn(this._opts.loader);
+        this._state = {
+          pastDelay: false,
+          timedOut: false
+        };
+        const { _res: res, _opts: opts } = this;
+        if (res.loading) {
+          if (typeof opts.delay === "number") {
+            if (opts.delay === 0) {
+              this._state.pastDelay = true;
+            } else {
+              this._delay = setTimeout(() => {
+                this._update({
+                  pastDelay: true
+                });
+              }, opts.delay);
+            }
+          }
+          if (typeof opts.timeout === "number") {
+            this._timeout = setTimeout(() => {
+              this._update({
+                timedOut: true
+              });
+            }, opts.timeout);
+          }
+        }
+        this._res.promise.then(() => {
+          this._update({});
+          this._clearTimeouts();
+        }).catch((_err) => {
+          this._update({});
+          this._clearTimeouts();
+        });
+        this._update({});
+      }
+      _update(partial) {
+        this._state = _extends({}, this._state, {
+          error: this._res.error,
+          loaded: this._res.loaded,
+          loading: this._res.loading
+        }, partial);
+        this._callbacks.forEach((callback) => callback());
+      }
+      _clearTimeouts() {
+        clearTimeout(this._delay);
+        clearTimeout(this._timeout);
+      }
+      getCurrentValue() {
+        return this._state;
+      }
+      subscribe(callback) {
+        this._callbacks.add(callback);
+        return () => {
+          this._callbacks.delete(callback);
+        };
+      }
+      constructor(loadFn, opts) {
+        this._loadFn = loadFn;
+        this._opts = opts;
+        this._callbacks = /* @__PURE__ */ new Set();
+        this._delay = null;
+        this._timeout = null;
+        this.retry();
+      }
+    };
+    function Loadable(opts) {
+      return createLoadableComponent(load, opts);
+    }
+    function flushInitializers(initializers, ids) {
+      let promises = [];
+      while (initializers.length) {
+        let init = initializers.pop();
+        promises.push(init(ids));
+      }
+      return Promise.all(promises).then(() => {
+        if (initializers.length) {
+          return flushInitializers(initializers, ids);
+        }
+      });
+    }
+    Loadable.preloadAll = () => {
+      return new Promise((resolveInitializers, reject) => {
+        flushInitializers(ALL_INITIALIZERS).then(resolveInitializers, reject);
+      });
+    };
+    Loadable.preloadReady = (ids = []) => {
+      return new Promise((resolvePreload) => {
+        const res = () => {
+          initialized = true;
+          return resolvePreload();
+        };
+        flushInitializers(READY_INITIALIZERS, ids).then(res, res);
+      });
+    };
+    if (typeof window !== "undefined") {
+      window.__NEXT_PRELOADREADY = Loadable.preloadReady;
+    }
+    var _default = Loadable;
+    exports.default = _default;
+  }
+});
+
+// ../../../../node_modules/next/dist/shared/lib/dynamic.js
+var require_dynamic = __commonJS({
+  "../../../../node_modules/next/dist/shared/lib/dynamic.js"(exports, module) {
+    "use strict";
+    "client";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = dynamic;
+    exports.noSSR = noSSR;
+    var _extends = require_extends().default;
+    var _interop_require_default = require_interop_require_default().default;
+    var _react = _interop_require_default(__require("react"));
+    var _loadable = _interop_require_default(require_loadable());
+    function dynamic(dynamicOptions, options) {
+      let loadableFn = _loadable.default;
+      let loadableOptions = (options == null ? void 0 : options.suspense) ? {} : {
+        // A loading component is not required, so we default it
+        loading: ({ error, isLoading, pastDelay }) => {
+          if (!pastDelay)
+            return null;
+          if (process.env.NODE_ENV === "development") {
+            if (isLoading) {
+              return null;
+            }
+            if (error) {
+              return /* @__PURE__ */ _react.default.createElement("p", null, error.message, /* @__PURE__ */ _react.default.createElement("br", null), error.stack);
+            }
+          }
+          return null;
+        }
+      };
+      if (dynamicOptions instanceof Promise) {
+        loadableOptions.loader = () => dynamicOptions;
+      } else if (typeof dynamicOptions === "function") {
+        loadableOptions.loader = dynamicOptions;
+      } else if (typeof dynamicOptions === "object") {
+        loadableOptions = _extends({}, loadableOptions, dynamicOptions);
+      }
+      loadableOptions = _extends({}, loadableOptions, options);
+      if (!process.env.__NEXT_REACT_ROOT && loadableOptions.suspense) {
+        throw new Error(`Invalid suspense option usage in next/dynamic. Read more: https://nextjs.org/docs/messages/invalid-dynamic-suspense`);
+      }
+      if (loadableOptions.suspense) {
+        if (process.env.NODE_ENV !== "production") {
+          if (loadableOptions.ssr === false) {
+            console.warn(`"ssr: false" is ignored by next/dynamic because you can not enable "suspense" while disabling "ssr" at the same time. Read more: https://nextjs.org/docs/messages/invalid-dynamic-suspense`);
+          }
+          if (loadableOptions.loading != null) {
+            console.warn(`"loading" is ignored by next/dynamic because you have enabled "suspense". Place your loading element in your suspense boundary's "fallback" prop instead. Read more: https://nextjs.org/docs/messages/invalid-dynamic-suspense`);
+          }
+        }
+        delete loadableOptions.ssr;
+        delete loadableOptions.loading;
+      }
+      if (loadableOptions.loadableGenerated) {
+        loadableOptions = _extends({}, loadableOptions, loadableOptions.loadableGenerated);
+        delete loadableOptions.loadableGenerated;
+      }
+      if (typeof loadableOptions.ssr === "boolean" && !loadableOptions.suspense) {
+        if (!loadableOptions.ssr) {
+          delete loadableOptions.ssr;
+          return noSSR(loadableFn, loadableOptions);
+        }
+        delete loadableOptions.ssr;
+      }
+      return loadableFn(loadableOptions);
+    }
+    var isServerSide = typeof window === "undefined";
+    function noSSR(LoadableInitializer, loadableOptions) {
+      delete loadableOptions.webpack;
+      delete loadableOptions.modules;
+      if (!isServerSide) {
+        return LoadableInitializer(loadableOptions);
+      }
+      const Loading = loadableOptions.loading;
+      return () => /* @__PURE__ */ _react.default.createElement(Loading, {
+        error: null,
+        isLoading: true,
+        pastDelay: false,
+        timedOut: false
+      });
+    }
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// ../../../../node_modules/next/dynamic.js
+var require_dynamic2 = __commonJS({
+  "../../../../node_modules/next/dynamic.js"(exports, module) {
+    module.exports = require_dynamic();
+  }
+});
+
+// src/components/utils.ts
+import React from "react";
+import { css } from "styled-components";
+
+// src/components/css.ts
+var CssObj = {
+  "alignContent": "align-content",
+  "alignItems": "align-items",
+  "alignSelf": "align-self",
+  /*
+  "animation": "animation",
+  "animationDelay": "animation-delay",
+  "animationDirection": "animation-direction",
+  "animationDuration": "animation-duration",
+  "animationFillMode": "animation-fill-mode",
+  "animationIterationCount": "animation-iteration-count",
+  "animationName": "animation-name",
+  "animationPlayState": "animation-play-state",
+  "animationTimingFunction": "animation-timing-function",
+  */
+  "aspectRatio": "aspect-ratio",
+  /*
+  "backfaceVisibility": "backface-visibility",
+  */
+  "background": "background",
+  /*
+  "backgroundAttachment": "background-attachment",
+  "backgroundClip": "background-clip",
+  */
+  "backgroundColor": "background-color",
+  /*
+  "backgroundImage": "background-image",
+  "backgroundOrigin": "background-origin",
+  "backgroundPosition": "background-position",
+  "backgroundRepeat": "background-repeat",
+  "backgroundSize": "background-size",
+  */
+  "border": "border",
+  "borderBottom": "border-bottom",
+  /*
+  "borderBottomColor": "border-bottom-color",
+  "borderBottomLeftRadius": "border-bottom-left-radius",
+  "borderBottomRightRadius": "border-bottom-right-radius",
+  "borderBottomStyle": "border-bottom-style",
+  "borderBottomWidth": "border-bottom-width",
+  "borderCollapse": "border-collapse",
+  "borderColor": "border-color",
+  "borderImage": "border-image",
+  "borderImageOutset": "border-image-outset",
+  "borderImageRepeat": "border-image-repeat",
+  "borderImageSlice": "border-image-slice",
+  "borderImageSource": "border-image-source",
+  "borderImageWidth": "border-image-width",
+  */
+  "borderLeft": "border-left",
+  /*
+   "borderLeftColor": "border-left-color",
+   "borderLeftStyle": "border-left-style",
+   "borderLeftWidth": "border-left-width",
+   */
+  "borderRadius": "border-radius",
+  "borderRight": "border-right",
+  /*
+  "borderRightColor": "border-right-color",
+  "borderRightStyle": "border-right-style",
+  "borderRightWidth": "border-right-width",
+  "borderSpacing": "border-spacing",
+  "borderStyle": "border-style",
+  */
+  "borderTop": "border-top",
+  /*
+  "borderTopColor": "border-top-color",
+  "borderTopLeftRadius": "border-top-left-radius",
+  "borderTopRightRadius": "border-top-right-radius",
+  "borderTopStyle": "border-top-style",
+  "borderTopWidth": "border-top-width",
+  "borderWidth": "border-width",
+  */
+  "bottom": "bottom",
+  "boxShadow": "box-shadow",
+  /*
+  "boxSizing": "box-sizing",
+  "captionSide": "caption-side",
+  "clear": "clear",
+  */
+  "clip": "clip",
+  "color": "color",
+  "columnCount": "column-count",
+  "columnFill": "column-fill",
+  "columnGap": "column-gap",
+  "columnRule": "column-rule",
+  /*
+  "columnRuleColor": "column-rule-color",
+  "columnRuleStyle": "column-rule-style",
+  "columnRuleWidth": "column-rule-width",
+  */
+  "columnSpan": "column-span",
+  "columnWidth": "column-width",
+  "columns": "columns",
+  "content": "content",
+  /*
+  "counterIncrement": "counter-increment",
+  "counterReset": "counter-reset",
+  */
+  "cursor": "cursor",
+  "direction": "direction",
+  "display": "display",
+  /*
+  "emptyCells": "empty-cells",
+  */
+  "flex": "flex",
+  "flexBasis": "flex-basis",
+  "flexDirection": "flex-direction",
+  "flexFlow": "flex-flow",
+  "flexGrow": "flex-grow",
+  "flexShrink": "flex-shrink",
+  "flexWrap": "flex-wrap",
+  "float": "float",
+  /*
+  "font": "font",
+  "fontFamily": "font-family",
+  */
+  "fontSize": "font-size",
+  /*
+  "fontSizeAdjust": "font-size-adjust",
+  "fontStretch": "font-stretch",
+  "fontStyle": "font-style",
+  "fontVariant": "font-variant",
+  */
+  "fontWeight": "font-weight",
+  "gap": "gap",
+  "grid": "grid",
+  "gridAutoColumns": "grid-auto-columns",
+  "gridColumnEnd": "grid-column-end",
+  "gridColumnStart": "grid-column-start",
+  "gridTemplate": "grid-template",
+  "gridTemplateColumns": "grid-template-columns",
+  "height": "height",
+  "justifyContent": "justify-content",
+  "left": "left",
+  "letterSpacing": "letter-spacing",
+  "lineHeight": "line-height",
+  /*
+  "listStyle": "list-style",
+  "listStyleImage": "list-style-image",
+  "listStylePosition": "list-style-position",
+  "listStyleType": "list-style-type",
+  */
+  "margin": "margin",
+  "marginBottom": "margin-bottom",
+  "marginLeft": "margin-left",
+  "marginRight": "margin-right",
+  "marginTop": "margin-top",
+  "maxHeight": "max-height",
+  "maxWidth": "max-width",
+  "minHeight": "min-height",
+  "minWidth": "min-width",
+  "opacity": "opacity",
+  "order": "order",
+  "outline": "outline",
+  /*
+  "outlineColor": "outline-color",
+  "outlineOffset": "outline-offset",
+  "outlineStyle": "outline-style",
+  "outlineWidth": "outline-width",
+  */
+  "overflow": "overflow",
+  "overflowX": "overflow-x",
+  "overflowY": "overflow-y",
+  "padding": "padding",
+  "paddingBottom": "padding-bottom",
+  "paddingLeft": "padding-left",
+  "paddingRight": "padding-right",
+  "paddingTop": "padding-top",
+  /*
+  "pageBreakAfter": "page-break-after",
+  "pageBreakBefore": "page-break-before",
+  "pageBreakInside": "page-break-inside",
+  "perspective": "perspective",
+  "perspectiveOrigin": "perspective-origin",
+  */
+  "position": "position",
+  /*
+  "quotes": "quotes",
+  "resize": "resize",
+  */
+  "right": "right",
+  "rowGap": "row-gap",
+  /*
+  "tabSize": "tab-size",
+  "tableLayout": "table-layout",
+  */
+  "textAlign": "text-align",
+  /*
+  "textAlignLast": "text-align-last",
+  */
+  "textDecoration": "text-decoration",
+  /*
+  "textDecorationColor": "text-decoration-color",
+  "textDecorationLine": "text-decoration-line",
+  "textDecorationStyle": "text-decoration-style",
+  "textIndent": "text-indent",
+  "textJustify": "text-justify",
+  "textOverflow": "text-overflow",
+  "textShadow": "text-shadow",
+  */
+  "textTransform": "text-transform",
+  "top": "top",
+  "transform": "transform",
+  /*
+  "transformOrigin": "transform-origin",
+  "transformStyle": "transform-style",
+  */
+  "transition": "transition",
+  /*
+  "transitionDelay": "transition-delay",
+  "transitionDuration": "transition-duration",
+  "transitionProperty": "transition-property",
+  "transitionTimingFunction": "transition-timing-function",
+  "verticalAlign": "vertical-align",
+  */
+  "visibility": "visibility",
+  "whiteSpace": "white-space",
+  "width": "width",
+  /*
+  "wordBreak": "word-break",
+  "wordSpacing": "word-spacing",
+  "wordWrap": "word-wrap",
+  */
+  "zIndex": "z-index"
+};
+var CssMap = new Map(Object.entries(CssObj));
+
+// src/components/utils.ts
+var ObjectKeys = Object.keys;
+function getContainer(props, fluid) {
+  if (fluid) {
+    return `
+    max-width: calc(100% - var(--grid-column-gap) * 2);
+  `;
+  } else {
+    const theme = props.theme;
+    if (theme.maxWidth && theme.mediaQuery) {
+      return ObjectKeys(theme.mediaQuery).map((key) => {
+        const value = theme.mediaQuery[key];
+        return `
+@media(min-width: ${value}px) {
+  max-width: ${theme.container.maxWidth[key]};
+}
+`;
+      }).join("\n");
+    } else {
+      return "";
+    }
+  }
+}
+function getCssResponsive(props, defaultValue = {}) {
+  props = __spreadValues(__spreadValues({}, defaultValue), props);
+  let rules = "";
+  for (const [key, value] of Object.entries(props)) {
+    const rule = key.replace(/(.+?)(Sm|Md|Lg|Xl)?$/, function(m, g1, g2) {
+      const prop = g1;
+      if (CssMap.has(prop)) {
+        const rule2 = `${CssMap.get(prop)}: ${value};`;
+        if (g2) {
+          const size = g2.toLowerCase();
+          return `@media(min-width: ${props.theme.mediaQuery[size]}px) {
+              ${rule2}
+            }`;
+        } else {
+          return rule2;
+        }
+      } else {
+        return "";
+      }
+    });
+    rules += rule + "\n";
+  }
+  return rules;
+}
+function getAspectResponsive(props, defaultValue = {}) {
+  props = __spreadValues(__spreadValues({}, defaultValue), props);
+  let rules = "";
+  for (const [key, value] of Object.entries(props)) {
+    const rule = key.replace(/(.+?)(Sm|Md|Lg|Xl)?$/, function(m, g1, g2) {
+      const prop = g1;
+      if (prop === "aspectRatio") {
+        const rule2 = `
+          position: relative;
+          overflow: hidden;
+        `;
+        if (g2) {
+          const size = g2.toLowerCase();
+          return `@media(min-width: ${props.theme.mediaQuery[size]}px) {
+              ${rule2}
+            }`;
+        } else {
+          return rule2;
+        }
+      } else {
+        return "";
+      }
+    });
+    rules += rule + "\n";
+  }
+  return rules;
+}
+function getGrid(props, defaultValue = {}) {
+  props = __spreadValues(__spreadValues({}, defaultValue), props);
+  return css`
+    ${props.columns ? css`
+      --grid-columns: ${props.columns};
+    ` : ""}
+    ${props.columnGap ? css`
+      --grid-column-gap: ${props.columnGap};
+    ` : ""}
+    ${props.rowGap ? css`
+      --grid-row-gap: ${props.rowGap};
+    ` : ""}
+    ${props.size ? css`
+      --grid-size: ${props.size};
+    ` : ""}
+    display: grid;
+    grid-template-columns: repeat(var(--grid-columns), var(--grid-size));
+    grid-column-gap: var(--grid-column-gap);
+    grid-row-gap: var(--grid-row-gap);
+  `;
+}
+function eachMedia(props, callback) {
+  const theme = props.theme;
+  if (theme.mediaQuery && typeof callback === "function") {
+    return ObjectKeys(theme.mediaQuery).map((key) => {
+      const value = theme.mediaQuery[key];
+      const rule = callback(key);
+      return rule ? `@media(min-width: ${value}px) { ${rule} }` : "";
+    }).join("\n");
+  } else {
+    return "";
+  }
+}
+function getVariant(variants, type) {
+  return type && variants[type] ? variants[type] || "" : "";
+}
+function isChildElement(parent, child) {
+  if (!parent || !child) {
+    return false;
+  }
+  let node = child;
+  while (node) {
+    if (node === parent) {
+      return true;
+    }
+    node = node.parentNode;
+  }
+  return false;
+}
+function mapChildsByType(children, type, mapMethod) {
+  return React.Children.map(children, (child) => {
+    if (!React.isValidElement(child)) {
+      return child;
+    }
+    if (child.type === type) {
+      return mapMethod(child);
+    } else if (child.props.children) {
+      child = React.cloneElement(child, __spreadProps(__spreadValues({}, child.props), {
+        children: mapChildsByType(child.props.children, type, mapMethod)
+      }));
+    }
+    return child;
+  });
+}
+function getChildsByType(children, type) {
+  const items = [];
+  const others = React.Children.map(children, (item) => {
+    if (!React.isValidElement(item)) {
+      return item;
+    }
+    if (item.type === type) {
+      items.push(item);
+      return null;
+    }
+    return item;
+  });
+  const childs = items.length > 0 ? items : void 0;
+  return [childs, others];
+}
+function hasChildOfType(children, type) {
+  const [foundChildren, otherChildren] = getChildsByType(children, type);
+  const hasChildOfType2 = foundChildren !== void 0;
+  return hasChildOfType2;
+}
+function hypenize(text) {
+  return text.replace(new RegExp("(?<![A-Z])[A-Z]|(?<![0-9]|^)[0-9]", "g"), (m) => "-" + m.toLowerCase());
+}
+function camelize(text) {
+  return text.replace(/(^[a-z])|-([a-z0-9])/gi, ($0, $1, $2) => $2 ? $2.toUpperCase() : $1.toUpperCase());
+}
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __require,
+  __objRest,
+  __commonJS,
+  __toESM,
+  __async,
+  ObjectKeys,
+  getContainer,
+  getCssResponsive,
+  getAspectResponsive,
+  getGrid,
+  eachMedia,
+  getVariant,
+  isChildElement,
+  mapChildsByType,
+  getChildsByType,
+  hasChildOfType,
+  hypenize,
+  camelize,
+  require_interop_require_default,
+  require_extends,
+  require_dynamic2 as require_dynamic
+};
+/*! Bundled license information:
+
+use-sync-external-store/cjs/use-sync-external-store-shim.production.min.js:
+  (**
+   * @license React
+   * use-sync-external-store-shim.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+use-sync-external-store/cjs/use-sync-external-store-shim.development.js:
+  (**
+   * @license React
+   * use-sync-external-store-shim.development.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+*/