@majoo-ui/react 1.11.2

package/index.umd.js

@@ -0,0 +1,4114 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('prop-types'), require('@stitches/react'), require('@majoo-ui/core'), require('@majoo-ui/helpers'), require('react-transition-group'), require('@majoo-ui/icons'), require('react/jsx-runtime'), require('@radix-ui/react-alert-dialog'), require('@radix-ui/react-avatar'), require('@radix-ui/react-tooltip'), require('@radix-ui/react-progress')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', 'prop-types', '@stitches/react', '@majoo-ui/core', '@majoo-ui/helpers', 'react-transition-group', '@majoo-ui/icons', 'react/jsx-runtime', '@radix-ui/react-alert-dialog', '@radix-ui/react-avatar', '@radix-ui/react-tooltip', '@radix-ui/react-progress'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.React = {}, global.React, global.PropTypes, global.react, global.core, global.helpers, global.reactTransitionGroup, null, global.jsxRuntime, global.AlertDialog, global.AvatarPrimitive, global.TooltipPrimitive, global.ProgressPrimitive));
+})(this, (function (exports, React, PropTypes, react, core, helpers, reactTransitionGroup, icons, jsxRuntime, AlertDialog, AvatarPrimitive, TooltipPrimitive, ProgressPrimitive) { 'use strict';
+
+  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+  function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+      Object.keys(e).forEach(function (k) {
+        if (k !== 'default') {
+          var d = Object.getOwnPropertyDescriptor(e, k);
+          Object.defineProperty(n, k, d.get ? d : {
+            enumerable: true,
+            get: function () { return e[k]; }
+          });
+        }
+      });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+  }
+
+  var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+  var React__namespace = /*#__PURE__*/_interopNamespace(React);
+  var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);
+  var AlertDialog__namespace = /*#__PURE__*/_interopNamespace(AlertDialog);
+  var AvatarPrimitive__namespace = /*#__PURE__*/_interopNamespace(AvatarPrimitive);
+  var TooltipPrimitive__namespace = /*#__PURE__*/_interopNamespace(TooltipPrimitive);
+  var ProgressPrimitive__namespace = /*#__PURE__*/_interopNamespace(ProgressPrimitive);
+
+  var _jsxFileName$g = "C:\\Project\\majoo-ui\\packages\\react\\src\\majoo-provider\\ThemeProvider.js";
+
+  function ThemeProvider({
+    theme,
+    children
+  }) {
+    return /*#__PURE__*/React__default["default"].createElement("div", {
+      className: theme,
+      __self: this,
+      __source: {
+        fileName: _jsxFileName$g,
+        lineNumber: 5,
+        columnNumber: 10
+      }
+    }, children);
+  }
+
+  ThemeProvider.propTypes = {
+    theme: PropTypes__default["default"].object.isRequired,
+    children: PropTypes__default["default"].node.isRequired
+  };
+
+  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+  var check = function (it) {
+    return it && it.Math == Math && it;
+  };
+
+  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+  var global$o =
+    // eslint-disable-next-line es/no-global-this -- safe
+    check(typeof globalThis == 'object' && globalThis) ||
+    check(typeof window == 'object' && window) ||
+    // eslint-disable-next-line no-restricted-globals -- safe
+    check(typeof self == 'object' && self) ||
+    check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
+    // eslint-disable-next-line no-new-func -- fallback
+    (function () { return this; })() || Function('return this')();
+
+  var objectGetOwnPropertyDescriptor = {};
+
+  var fails$a = function (exec) {
+    try {
+      return !!exec();
+    } catch (error) {
+      return true;
+    }
+  };
+
+  var fails$9 = fails$a;
+
+  // Detect IE8's incomplete defineProperty implementation
+  var descriptors = !fails$9(function () {
+    // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+    return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
+  });
+
+  var fails$8 = fails$a;
+
+  var functionBindNative = !fails$8(function () {
+    var test = (function () { /* empty */ }).bind();
+    // eslint-disable-next-line no-prototype-builtins -- safe
+    return typeof test != 'function' || test.hasOwnProperty('prototype');
+  });
+
+  var NATIVE_BIND$1 = functionBindNative;
+
+  var call$6 = Function.prototype.call;
+
+  var functionCall = NATIVE_BIND$1 ? call$6.bind(call$6) : function () {
+    return call$6.apply(call$6, arguments);
+  };
+
+  var objectPropertyIsEnumerable = {};
+
+  var $propertyIsEnumerable = {}.propertyIsEnumerable;
+  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+  var getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
+
+  // Nashorn ~ JDK8 bug
+  var NASHORN_BUG = getOwnPropertyDescriptor$1 && !$propertyIsEnumerable.call({ 1: 2 }, 1);
+
+  // `Object.prototype.propertyIsEnumerable` method implementation
+  // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
+  objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+    var descriptor = getOwnPropertyDescriptor$1(this, V);
+    return !!descriptor && descriptor.enumerable;
+  } : $propertyIsEnumerable;
+
+  var createPropertyDescriptor$3 = function (bitmap, value) {
+    return {
+      enumerable: !(bitmap & 1),
+      configurable: !(bitmap & 2),
+      writable: !(bitmap & 4),
+      value: value
+    };
+  };
+
+  var NATIVE_BIND = functionBindNative;
+
+  var FunctionPrototype$1 = Function.prototype;
+  var bind = FunctionPrototype$1.bind;
+  var call$5 = FunctionPrototype$1.call;
+  var uncurryThis$b = NATIVE_BIND && bind.bind(call$5, call$5);
+
+  var functionUncurryThis = NATIVE_BIND ? function (fn) {
+    return fn && uncurryThis$b(fn);
+  } : function (fn) {
+    return fn && function () {
+      return call$5.apply(fn, arguments);
+    };
+  };
+
+  var uncurryThis$a = functionUncurryThis;
+
+  var toString$1 = uncurryThis$a({}.toString);
+  var stringSlice = uncurryThis$a(''.slice);
+
+  var classofRaw = function (it) {
+    return stringSlice(toString$1(it), 8, -1);
+  };
+
+  var global$n = global$o;
+  var uncurryThis$9 = functionUncurryThis;
+  var fails$7 = fails$a;
+  var classof = classofRaw;
+
+  var Object$4 = global$n.Object;
+  var split = uncurryThis$9(''.split);
+
+  // fallback for non-array-like ES3 and non-enumerable old V8 strings
+  var indexedObject = fails$7(function () {
+    // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+    // eslint-disable-next-line no-prototype-builtins -- safe
+    return !Object$4('z').propertyIsEnumerable(0);
+  }) ? function (it) {
+    return classof(it) == 'String' ? split(it, '') : Object$4(it);
+  } : Object$4;
+
+  var global$m = global$o;
+
+  var TypeError$7 = global$m.TypeError;
+
+  // `RequireObjectCoercible` abstract operation
+  // https://tc39.es/ecma262/#sec-requireobjectcoercible
+  var requireObjectCoercible$2 = function (it) {
+    if (it == undefined) throw TypeError$7("Can't call method on " + it);
+    return it;
+  };
+
+  // toObject with fallback for non-array-like ES3 strings
+  var IndexedObject$1 = indexedObject;
+  var requireObjectCoercible$1 = requireObjectCoercible$2;
+
+  var toIndexedObject$5 = function (it) {
+    return IndexedObject$1(requireObjectCoercible$1(it));
+  };
+
+  // `IsCallable` abstract operation
+  // https://tc39.es/ecma262/#sec-iscallable
+  var isCallable$d = function (argument) {
+    return typeof argument == 'function';
+  };
+
+  var isCallable$c = isCallable$d;
+
+  var isObject$5 = function (it) {
+    return typeof it == 'object' ? it !== null : isCallable$c(it);
+  };
+
+  var global$l = global$o;
+  var isCallable$b = isCallable$d;
+
+  var aFunction = function (argument) {
+    return isCallable$b(argument) ? argument : undefined;
+  };
+
+  var getBuiltIn$4 = function (namespace, method) {
+    return arguments.length < 2 ? aFunction(global$l[namespace]) : global$l[namespace] && global$l[namespace][method];
+  };
+
+  var uncurryThis$8 = functionUncurryThis;
+
+  var objectIsPrototypeOf = uncurryThis$8({}.isPrototypeOf);
+
+  var getBuiltIn$3 = getBuiltIn$4;
+
+  var engineUserAgent = getBuiltIn$3('navigator', 'userAgent') || '';
+
+  var global$k = global$o;
+  var userAgent = engineUserAgent;
+
+  var process = global$k.process;
+  var Deno = global$k.Deno;
+  var versions = process && process.versions || Deno && Deno.version;
+  var v8 = versions && versions.v8;
+  var match, version;
+
+  if (v8) {
+    match = v8.split('.');
+    // in old Chrome, versions of V8 isn't V8 = Chrome / 10
+    // but their correct versions are not interesting for us
+    version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
+  }
+
+  // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
+  // so check `userAgent` even if `.v8` exists, but 0
+  if (!version && userAgent) {
+    match = userAgent.match(/Edge\/(\d+)/);
+    if (!match || match[1] >= 74) {
+      match = userAgent.match(/Chrome\/(\d+)/);
+      if (match) version = +match[1];
+    }
+  }
+
+  var engineV8Version = version;
+
+  /* eslint-disable es/no-symbol -- required for testing */
+
+  var V8_VERSION = engineV8Version;
+  var fails$6 = fails$a;
+
+  // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
+  var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$6(function () {
+    var symbol = Symbol();
+    // Chrome 38 Symbol has incorrect toString conversion
+    // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
+    return !String(symbol) || !(Object(symbol) instanceof Symbol) ||
+      // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
+      !Symbol.sham && V8_VERSION && V8_VERSION < 41;
+  });
+
+  /* eslint-disable es/no-symbol -- required for testing */
+
+  var NATIVE_SYMBOL$1 = nativeSymbol;
+
+  var useSymbolAsUid = NATIVE_SYMBOL$1
+    && !Symbol.sham
+    && typeof Symbol.iterator == 'symbol';
+
+  var global$j = global$o;
+  var getBuiltIn$2 = getBuiltIn$4;
+  var isCallable$a = isCallable$d;
+  var isPrototypeOf = objectIsPrototypeOf;
+  var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
+
+  var Object$3 = global$j.Object;
+
+  var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
+    return typeof it == 'symbol';
+  } : function (it) {
+    var $Symbol = getBuiltIn$2('Symbol');
+    return isCallable$a($Symbol) && isPrototypeOf($Symbol.prototype, Object$3(it));
+  };
+
+  var global$i = global$o;
+
+  var String$3 = global$i.String;
+
+  var tryToString$1 = function (argument) {
+    try {
+      return String$3(argument);
+    } catch (error) {
+      return 'Object';
+    }
+  };
+
+  var global$h = global$o;
+  var isCallable$9 = isCallable$d;
+  var tryToString = tryToString$1;
+
+  var TypeError$6 = global$h.TypeError;
+
+  // `Assert: IsCallable(argument) is true`
+  var aCallable$1 = function (argument) {
+    if (isCallable$9(argument)) return argument;
+    throw TypeError$6(tryToString(argument) + ' is not a function');
+  };
+
+  var aCallable = aCallable$1;
+
+  // `GetMethod` abstract operation
+  // https://tc39.es/ecma262/#sec-getmethod
+  var getMethod$1 = function (V, P) {
+    var func = V[P];
+    return func == null ? undefined : aCallable(func);
+  };
+
+  var global$g = global$o;
+  var call$4 = functionCall;
+  var isCallable$8 = isCallable$d;
+  var isObject$4 = isObject$5;
+
+  var TypeError$5 = global$g.TypeError;
+
+  // `OrdinaryToPrimitive` abstract operation
+  // https://tc39.es/ecma262/#sec-ordinarytoprimitive
+  var ordinaryToPrimitive$1 = function (input, pref) {
+    var fn, val;
+    if (pref === 'string' && isCallable$8(fn = input.toString) && !isObject$4(val = call$4(fn, input))) return val;
+    if (isCallable$8(fn = input.valueOf) && !isObject$4(val = call$4(fn, input))) return val;
+    if (pref !== 'string' && isCallable$8(fn = input.toString) && !isObject$4(val = call$4(fn, input))) return val;
+    throw TypeError$5("Can't convert object to primitive value");
+  };
+
+  var shared$3 = {exports: {}};
+
+  var global$f = global$o;
+
+  // eslint-disable-next-line es/no-object-defineproperty -- safe
+  var defineProperty$3 = Object.defineProperty;
+
+  var setGlobal$3 = function (key, value) {
+    try {
+      defineProperty$3(global$f, key, { value: value, configurable: true, writable: true });
+    } catch (error) {
+      global$f[key] = value;
+    } return value;
+  };
+
+  var global$e = global$o;
+  var setGlobal$2 = setGlobal$3;
+
+  var SHARED = '__core-js_shared__';
+  var store$3 = global$e[SHARED] || setGlobal$2(SHARED, {});
+
+  var sharedStore = store$3;
+
+  var store$2 = sharedStore;
+
+  (shared$3.exports = function (key, value) {
+    return store$2[key] || (store$2[key] = value !== undefined ? value : {});
+  })('versions', []).push({
+    version: '3.21.1',
+    mode: 'global',
+    copyright: '© 2014-2022 Denis Pushkarev (zloirock.ru)',
+    license: 'https://github.com/zloirock/core-js/blob/v3.21.1/LICENSE',
+    source: 'https://github.com/zloirock/core-js'
+  });
+
+  var global$d = global$o;
+  var requireObjectCoercible = requireObjectCoercible$2;
+
+  var Object$2 = global$d.Object;
+
+  // `ToObject` abstract operation
+  // https://tc39.es/ecma262/#sec-toobject
+  var toObject$3 = function (argument) {
+    return Object$2(requireObjectCoercible(argument));
+  };
+
+  var uncurryThis$7 = functionUncurryThis;
+  var toObject$2 = toObject$3;
+
+  var hasOwnProperty = uncurryThis$7({}.hasOwnProperty);
+
+  // `HasOwnProperty` abstract operation
+  // https://tc39.es/ecma262/#sec-hasownproperty
+  var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
+    return hasOwnProperty(toObject$2(it), key);
+  };
+
+  var uncurryThis$6 = functionUncurryThis;
+
+  var id = 0;
+  var postfix = Math.random();
+  var toString = uncurryThis$6(1.0.toString);
+
+  var uid$2 = function (key) {
+    return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
+  };
+
+  var global$c = global$o;
+  var shared$2 = shared$3.exports;
+  var hasOwn$8 = hasOwnProperty_1;
+  var uid$1 = uid$2;
+  var NATIVE_SYMBOL = nativeSymbol;
+  var USE_SYMBOL_AS_UID = useSymbolAsUid;
+
+  var WellKnownSymbolsStore = shared$2('wks');
+  var Symbol$1 = global$c.Symbol;
+  var symbolFor = Symbol$1 && Symbol$1['for'];
+  var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
+
+  var wellKnownSymbol$6 = function (name) {
+    if (!hasOwn$8(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
+      var description = 'Symbol.' + name;
+      if (NATIVE_SYMBOL && hasOwn$8(Symbol$1, name)) {
+        WellKnownSymbolsStore[name] = Symbol$1[name];
+      } else if (USE_SYMBOL_AS_UID && symbolFor) {
+        WellKnownSymbolsStore[name] = symbolFor(description);
+      } else {
+        WellKnownSymbolsStore[name] = createWellKnownSymbol(description);
+      }
+    } return WellKnownSymbolsStore[name];
+  };
+
+  var global$b = global$o;
+  var call$3 = functionCall;
+  var isObject$3 = isObject$5;
+  var isSymbol$1 = isSymbol$2;
+  var getMethod = getMethod$1;
+  var ordinaryToPrimitive = ordinaryToPrimitive$1;
+  var wellKnownSymbol$5 = wellKnownSymbol$6;
+
+  var TypeError$4 = global$b.TypeError;
+  var TO_PRIMITIVE = wellKnownSymbol$5('toPrimitive');
+
+  // `ToPrimitive` abstract operation
+  // https://tc39.es/ecma262/#sec-toprimitive
+  var toPrimitive$1 = function (input, pref) {
+    if (!isObject$3(input) || isSymbol$1(input)) return input;
+    var exoticToPrim = getMethod(input, TO_PRIMITIVE);
+    var result;
+    if (exoticToPrim) {
+      if (pref === undefined) pref = 'default';
+      result = call$3(exoticToPrim, input, pref);
+      if (!isObject$3(result) || isSymbol$1(result)) return result;
+      throw TypeError$4("Can't convert object to primitive value");
+    }
+    if (pref === undefined) pref = 'number';
+    return ordinaryToPrimitive(input, pref);
+  };
+
+  var toPrimitive = toPrimitive$1;
+  var isSymbol = isSymbol$2;
+
+  // `ToPropertyKey` abstract operation
+  // https://tc39.es/ecma262/#sec-topropertykey
+  var toPropertyKey$2 = function (argument) {
+    var key = toPrimitive(argument, 'string');
+    return isSymbol(key) ? key : key + '';
+  };
+
+  var global$a = global$o;
+  var isObject$2 = isObject$5;
+
+  var document$1 = global$a.document;
+  // typeof document.createElement is 'object' in old IE
+  var EXISTS$1 = isObject$2(document$1) && isObject$2(document$1.createElement);
+
+  var documentCreateElement$2 = function (it) {
+    return EXISTS$1 ? document$1.createElement(it) : {};
+  };
+
+  var DESCRIPTORS$8 = descriptors;
+  var fails$5 = fails$a;
+  var createElement = documentCreateElement$2;
+
+  // Thanks to IE8 for its funny defineProperty
+  var ie8DomDefine = !DESCRIPTORS$8 && !fails$5(function () {
+    // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+    return Object.defineProperty(createElement('div'), 'a', {
+      get: function () { return 7; }
+    }).a != 7;
+  });
+
+  var DESCRIPTORS$7 = descriptors;
+  var call$2 = functionCall;
+  var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
+  var createPropertyDescriptor$2 = createPropertyDescriptor$3;
+  var toIndexedObject$4 = toIndexedObject$5;
+  var toPropertyKey$1 = toPropertyKey$2;
+  var hasOwn$7 = hasOwnProperty_1;
+  var IE8_DOM_DEFINE$1 = ie8DomDefine;
+
+  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+  var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
+
+  // `Object.getOwnPropertyDescriptor` method
+  // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
+  objectGetOwnPropertyDescriptor.f = DESCRIPTORS$7 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
+    O = toIndexedObject$4(O);
+    P = toPropertyKey$1(P);
+    if (IE8_DOM_DEFINE$1) try {
+      return $getOwnPropertyDescriptor$1(O, P);
+    } catch (error) { /* empty */ }
+    if (hasOwn$7(O, P)) return createPropertyDescriptor$2(!call$2(propertyIsEnumerableModule$1.f, O, P), O[P]);
+  };
+
+  var objectDefineProperty = {};
+
+  var DESCRIPTORS$6 = descriptors;
+  var fails$4 = fails$a;
+
+  // V8 ~ Chrome 36-
+  // https://bugs.chromium.org/p/v8/issues/detail?id=3334
+  var v8PrototypeDefineBug = DESCRIPTORS$6 && fails$4(function () {
+    // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+    return Object.defineProperty(function () { /* empty */ }, 'prototype', {
+      value: 42,
+      writable: false
+    }).prototype != 42;
+  });
+
+  var global$9 = global$o;
+  var isObject$1 = isObject$5;
+
+  var String$2 = global$9.String;
+  var TypeError$3 = global$9.TypeError;
+
+  // `Assert: Type(argument) is Object`
+  var anObject$5 = function (argument) {
+    if (isObject$1(argument)) return argument;
+    throw TypeError$3(String$2(argument) + ' is not an object');
+  };
+
+  var global$8 = global$o;
+  var DESCRIPTORS$5 = descriptors;
+  var IE8_DOM_DEFINE = ie8DomDefine;
+  var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
+  var anObject$4 = anObject$5;
+  var toPropertyKey = toPropertyKey$2;
+
+  var TypeError$2 = global$8.TypeError;
+  // eslint-disable-next-line es/no-object-defineproperty -- safe
+  var $defineProperty = Object.defineProperty;
+  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+  var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+  var ENUMERABLE = 'enumerable';
+  var CONFIGURABLE$1 = 'configurable';
+  var WRITABLE = 'writable';
+
+  // `Object.defineProperty` method
+  // https://tc39.es/ecma262/#sec-object.defineproperty
+  objectDefineProperty.f = DESCRIPTORS$5 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
+    anObject$4(O);
+    P = toPropertyKey(P);
+    anObject$4(Attributes);
+    if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
+      var current = $getOwnPropertyDescriptor(O, P);
+      if (current && current[WRITABLE]) {
+        O[P] = Attributes.value;
+        Attributes = {
+          configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1],
+          enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
+          writable: false
+        };
+      }
+    } return $defineProperty(O, P, Attributes);
+  } : $defineProperty : function defineProperty(O, P, Attributes) {
+    anObject$4(O);
+    P = toPropertyKey(P);
+    anObject$4(Attributes);
+    if (IE8_DOM_DEFINE) try {
+      return $defineProperty(O, P, Attributes);
+    } catch (error) { /* empty */ }
+    if ('get' in Attributes || 'set' in Attributes) throw TypeError$2('Accessors not supported');
+    if ('value' in Attributes) O[P] = Attributes.value;
+    return O;
+  };
+
+  var DESCRIPTORS$4 = descriptors;
+  var definePropertyModule$3 = objectDefineProperty;
+  var createPropertyDescriptor$1 = createPropertyDescriptor$3;
+
+  var createNonEnumerableProperty$5 = DESCRIPTORS$4 ? function (object, key, value) {
+    return definePropertyModule$3.f(object, key, createPropertyDescriptor$1(1, value));
+  } : function (object, key, value) {
+    object[key] = value;
+    return object;
+  };
+
+  var redefine$3 = {exports: {}};
+
+  var uncurryThis$5 = functionUncurryThis;
+  var isCallable$7 = isCallable$d;
+  var store$1 = sharedStore;
+
+  var functionToString = uncurryThis$5(Function.toString);
+
+  // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
+  if (!isCallable$7(store$1.inspectSource)) {
+    store$1.inspectSource = function (it) {
+      return functionToString(it);
+    };
+  }
+
+  var inspectSource$2 = store$1.inspectSource;
+
+  var global$7 = global$o;
+  var isCallable$6 = isCallable$d;
+  var inspectSource$1 = inspectSource$2;
+
+  var WeakMap$1 = global$7.WeakMap;
+
+  var nativeWeakMap = isCallable$6(WeakMap$1) && /native code/.test(inspectSource$1(WeakMap$1));
+
+  var shared$1 = shared$3.exports;
+  var uid = uid$2;
+
+  var keys = shared$1('keys');
+
+  var sharedKey$3 = function (key) {
+    return keys[key] || (keys[key] = uid(key));
+  };
+
+  var hiddenKeys$4 = {};
+
+  var NATIVE_WEAK_MAP = nativeWeakMap;
+  var global$6 = global$o;
+  var uncurryThis$4 = functionUncurryThis;
+  var isObject = isObject$5;
+  var createNonEnumerableProperty$4 = createNonEnumerableProperty$5;
+  var hasOwn$6 = hasOwnProperty_1;
+  var shared = sharedStore;
+  var sharedKey$2 = sharedKey$3;
+  var hiddenKeys$3 = hiddenKeys$4;
+
+  var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
+  var TypeError$1 = global$6.TypeError;
+  var WeakMap = global$6.WeakMap;
+  var set, get, has;
+
+  var enforce = function (it) {
+    return has(it) ? get(it) : set(it, {});
+  };
+
+  var getterFor = function (TYPE) {
+    return function (it) {
+      var state;
+      if (!isObject(it) || (state = get(it)).type !== TYPE) {
+        throw TypeError$1('Incompatible receiver, ' + TYPE + ' required');
+      } return state;
+    };
+  };
+
+  if (NATIVE_WEAK_MAP || shared.state) {
+    var store = shared.state || (shared.state = new WeakMap());
+    var wmget = uncurryThis$4(store.get);
+    var wmhas = uncurryThis$4(store.has);
+    var wmset = uncurryThis$4(store.set);
+    set = function (it, metadata) {
+      if (wmhas(store, it)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
+      metadata.facade = it;
+      wmset(store, it, metadata);
+      return metadata;
+    };
+    get = function (it) {
+      return wmget(store, it) || {};
+    };
+    has = function (it) {
+      return wmhas(store, it);
+    };
+  } else {
+    var STATE = sharedKey$2('state');
+    hiddenKeys$3[STATE] = true;
+    set = function (it, metadata) {
+      if (hasOwn$6(it, STATE)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
+      metadata.facade = it;
+      createNonEnumerableProperty$4(it, STATE, metadata);
+      return metadata;
+    };
+    get = function (it) {
+      return hasOwn$6(it, STATE) ? it[STATE] : {};
+    };
+    has = function (it) {
+      return hasOwn$6(it, STATE);
+    };
+  }
+
+  var internalState = {
+    set: set,
+    get: get,
+    has: has,
+    enforce: enforce,
+    getterFor: getterFor
+  };
+
+  var DESCRIPTORS$3 = descriptors;
+  var hasOwn$5 = hasOwnProperty_1;
+
+  var FunctionPrototype = Function.prototype;
+  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+  var getDescriptor = DESCRIPTORS$3 && Object.getOwnPropertyDescriptor;
+
+  var EXISTS = hasOwn$5(FunctionPrototype, 'name');
+  // additional protection from minified / mangled / dropped function names
+  var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
+  var CONFIGURABLE = EXISTS && (!DESCRIPTORS$3 || (DESCRIPTORS$3 && getDescriptor(FunctionPrototype, 'name').configurable));
+
+  var functionName = {
+    EXISTS: EXISTS,
+    PROPER: PROPER,
+    CONFIGURABLE: CONFIGURABLE
+  };
+
+  var global$5 = global$o;
+  var isCallable$5 = isCallable$d;
+  var hasOwn$4 = hasOwnProperty_1;
+  var createNonEnumerableProperty$3 = createNonEnumerableProperty$5;
+  var setGlobal$1 = setGlobal$3;
+  var inspectSource = inspectSource$2;
+  var InternalStateModule$1 = internalState;
+  var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE;
+
+  var getInternalState$1 = InternalStateModule$1.get;
+  var enforceInternalState = InternalStateModule$1.enforce;
+  var TEMPLATE = String(String).split('String');
+
+  (redefine$3.exports = function (O, key, value, options) {
+    var unsafe = options ? !!options.unsafe : false;
+    var simple = options ? !!options.enumerable : false;
+    var noTargetGet = options ? !!options.noTargetGet : false;
+    var name = options && options.name !== undefined ? options.name : key;
+    var state;
+    if (isCallable$5(value)) {
+      if (String(name).slice(0, 7) === 'Symbol(') {
+        name = '[' + String(name).replace(/^Symbol\(([^)]*)\)/, '$1') + ']';
+      }
+      if (!hasOwn$4(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) {
+        createNonEnumerableProperty$3(value, 'name', name);
+      }
+      state = enforceInternalState(value);
+      if (!state.source) {
+        state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
+      }
+    }
+    if (O === global$5) {
+      if (simple) O[key] = value;
+      else setGlobal$1(key, value);
+      return;
+    } else if (!unsafe) {
+      delete O[key];
+    } else if (!noTargetGet && O[key]) {
+      simple = true;
+    }
+    if (simple) O[key] = value;
+    else createNonEnumerableProperty$3(O, key, value);
+  // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+  })(Function.prototype, 'toString', function toString() {
+    return isCallable$5(this) && getInternalState$1(this).source || inspectSource(this);
+  });
+
+  var objectGetOwnPropertyNames = {};
+
+  var ceil = Math.ceil;
+  var floor = Math.floor;
+
+  // `ToIntegerOrInfinity` abstract operation
+  // https://tc39.es/ecma262/#sec-tointegerorinfinity
+  var toIntegerOrInfinity$2 = function (argument) {
+    var number = +argument;
+    // eslint-disable-next-line no-self-compare -- safe
+    return number !== number || number === 0 ? 0 : (number > 0 ? floor : ceil)(number);
+  };
+
+  var toIntegerOrInfinity$1 = toIntegerOrInfinity$2;
+
+  var max = Math.max;
+  var min$1 = Math.min;
+
+  // Helper for a popular repeating case of the spec:
+  // Let integer be ? ToInteger(index).
+  // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
+  var toAbsoluteIndex$1 = function (index, length) {
+    var integer = toIntegerOrInfinity$1(index);
+    return integer < 0 ? max(integer + length, 0) : min$1(integer, length);
+  };
+
+  var toIntegerOrInfinity = toIntegerOrInfinity$2;
+
+  var min = Math.min;
+
+  // `ToLength` abstract operation
+  // https://tc39.es/ecma262/#sec-tolength
+  var toLength$1 = function (argument) {
+    return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
+  };
+
+  var toLength = toLength$1;
+
+  // `LengthOfArrayLike` abstract operation
+  // https://tc39.es/ecma262/#sec-lengthofarraylike
+  var lengthOfArrayLike$1 = function (obj) {
+    return toLength(obj.length);
+  };
+
+  var toIndexedObject$3 = toIndexedObject$5;
+  var toAbsoluteIndex = toAbsoluteIndex$1;
+  var lengthOfArrayLike = lengthOfArrayLike$1;
+
+  // `Array.prototype.{ indexOf, includes }` methods implementation
+  var createMethod = function (IS_INCLUDES) {
+    return function ($this, el, fromIndex) {
+      var O = toIndexedObject$3($this);
+      var length = lengthOfArrayLike(O);
+      var index = toAbsoluteIndex(fromIndex, length);
+      var value;
+      // Array#includes uses SameValueZero equality algorithm
+      // eslint-disable-next-line no-self-compare -- NaN check
+      if (IS_INCLUDES && el != el) while (length > index) {
+        value = O[index++];
+        // eslint-disable-next-line no-self-compare -- NaN check
+        if (value != value) return true;
+      // Array#indexOf ignores holes, Array#includes - not
+      } else for (;length > index; index++) {
+        if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
+      } return !IS_INCLUDES && -1;
+    };
+  };
+
+  var arrayIncludes = {
+    // `Array.prototype.includes` method
+    // https://tc39.es/ecma262/#sec-array.prototype.includes
+    includes: createMethod(true),
+    // `Array.prototype.indexOf` method
+    // https://tc39.es/ecma262/#sec-array.prototype.indexof
+    indexOf: createMethod(false)
+  };
+
+  var uncurryThis$3 = functionUncurryThis;
+  var hasOwn$3 = hasOwnProperty_1;
+  var toIndexedObject$2 = toIndexedObject$5;
+  var indexOf = arrayIncludes.indexOf;
+  var hiddenKeys$2 = hiddenKeys$4;
+
+  var push = uncurryThis$3([].push);
+
+  var objectKeysInternal = function (object, names) {
+    var O = toIndexedObject$2(object);
+    var i = 0;
+    var result = [];
+    var key;
+    for (key in O) !hasOwn$3(hiddenKeys$2, key) && hasOwn$3(O, key) && push(result, key);
+    // Don't enum bug & hidden keys
+    while (names.length > i) if (hasOwn$3(O, key = names[i++])) {
+      ~indexOf(result, key) || push(result, key);
+    }
+    return result;
+  };
+
+  // IE8- don't enum bug keys
+  var enumBugKeys$3 = [
+    'constructor',
+    'hasOwnProperty',
+    'isPrototypeOf',
+    'propertyIsEnumerable',
+    'toLocaleString',
+    'toString',
+    'valueOf'
+  ];
+
+  var internalObjectKeys$1 = objectKeysInternal;
+  var enumBugKeys$2 = enumBugKeys$3;
+
+  var hiddenKeys$1 = enumBugKeys$2.concat('length', 'prototype');
+
+  // `Object.getOwnPropertyNames` method
+  // https://tc39.es/ecma262/#sec-object.getownpropertynames
+  // eslint-disable-next-line es/no-object-getownpropertynames -- safe
+  objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+    return internalObjectKeys$1(O, hiddenKeys$1);
+  };
+
+  var objectGetOwnPropertySymbols = {};
+
+  // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
+  objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
+
+  var getBuiltIn$1 = getBuiltIn$4;
+  var uncurryThis$2 = functionUncurryThis;
+  var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
+  var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
+  var anObject$3 = anObject$5;
+
+  var concat$1 = uncurryThis$2([].concat);
+
+  // all object keys, includes non-enumerable and symbols
+  var ownKeys$1 = getBuiltIn$1('Reflect', 'ownKeys') || function ownKeys(it) {
+    var keys = getOwnPropertyNamesModule.f(anObject$3(it));
+    var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f;
+    return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys;
+  };
+
+  var hasOwn$2 = hasOwnProperty_1;
+  var ownKeys = ownKeys$1;
+  var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
+  var definePropertyModule$2 = objectDefineProperty;
+
+  var copyConstructorProperties$1 = function (target, source, exceptions) {
+    var keys = ownKeys(source);
+    var defineProperty = definePropertyModule$2.f;
+    var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+    for (var i = 0; i < keys.length; i++) {
+      var key = keys[i];
+      if (!hasOwn$2(target, key) && !(exceptions && hasOwn$2(exceptions, key))) {
+        defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+      }
+    }
+  };
+
+  var fails$3 = fails$a;
+  var isCallable$4 = isCallable$d;
+
+  var replacement = /#|\.prototype\./;
+
+  var isForced$1 = function (feature, detection) {
+    var value = data[normalize$1(feature)];
+    return value == POLYFILL ? true
+      : value == NATIVE ? false
+      : isCallable$4(detection) ? fails$3(detection)
+      : !!detection;
+  };
+
+  var normalize$1 = isForced$1.normalize = function (string) {
+    return String(string).replace(replacement, '.').toLowerCase();
+  };
+
+  var data = isForced$1.data = {};
+  var NATIVE = isForced$1.NATIVE = 'N';
+  var POLYFILL = isForced$1.POLYFILL = 'P';
+
+  var isForced_1 = isForced$1;
+
+  var global$4 = global$o;
+  var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
+  var createNonEnumerableProperty$2 = createNonEnumerableProperty$5;
+  var redefine$2 = redefine$3.exports;
+  var setGlobal = setGlobal$3;
+  var copyConstructorProperties = copyConstructorProperties$1;
+  var isForced = isForced_1;
+
+  /*
+    options.target      - name of the target object
+    options.global      - target is the global object
+    options.stat        - export as static methods of target
+    options.proto       - export as prototype methods of target
+    options.real        - real prototype method for the `pure` version
+    options.forced      - export even if the native feature is available
+    options.bind        - bind methods to the target, required for the `pure` version
+    options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
+    options.unsafe      - use the simple assignment of property instead of delete + defineProperty
+    options.sham        - add a flag to not completely full polyfills
+    options.enumerable  - export as enumerable property
+    options.noTargetGet - prevent calling a getter on target
+    options.name        - the .name of the function if it does not match the key
+  */
+  var _export = function (options, source) {
+    var TARGET = options.target;
+    var GLOBAL = options.global;
+    var STATIC = options.stat;
+    var FORCED, target, key, targetProperty, sourceProperty, descriptor;
+    if (GLOBAL) {
+      target = global$4;
+    } else if (STATIC) {
+      target = global$4[TARGET] || setGlobal(TARGET, {});
+    } else {
+      target = (global$4[TARGET] || {}).prototype;
+    }
+    if (target) for (key in source) {
+      sourceProperty = source[key];
+      if (options.noTargetGet) {
+        descriptor = getOwnPropertyDescriptor(target, key);
+        targetProperty = descriptor && descriptor.value;
+      } else targetProperty = target[key];
+      FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
+      // contained in target
+      if (!FORCED && targetProperty !== undefined) {
+        if (typeof sourceProperty == typeof targetProperty) continue;
+        copyConstructorProperties(sourceProperty, targetProperty);
+      }
+      // add a flag to not completely full polyfills
+      if (options.sham || (targetProperty && targetProperty.sham)) {
+        createNonEnumerableProperty$2(sourceProperty, 'sham', true);
+      }
+      // extend global
+      redefine$2(target, key, sourceProperty, options);
+    }
+  };
+
+  var internalObjectKeys = objectKeysInternal;
+  var enumBugKeys$1 = enumBugKeys$3;
+
+  // `Object.keys` method
+  // https://tc39.es/ecma262/#sec-object.keys
+  // eslint-disable-next-line es/no-object-keys -- safe
+  var objectKeys$2 = Object.keys || function keys(O) {
+    return internalObjectKeys(O, enumBugKeys$1);
+  };
+
+  var DESCRIPTORS$2 = descriptors;
+  var uncurryThis$1 = functionUncurryThis;
+  var call$1 = functionCall;
+  var fails$2 = fails$a;
+  var objectKeys$1 = objectKeys$2;
+  var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
+  var propertyIsEnumerableModule = objectPropertyIsEnumerable;
+  var toObject$1 = toObject$3;
+  var IndexedObject = indexedObject;
+
+  // eslint-disable-next-line es/no-object-assign -- safe
+  var $assign = Object.assign;
+  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+  var defineProperty$2 = Object.defineProperty;
+  var concat = uncurryThis$1([].concat);
+
+  // `Object.assign` method
+  // https://tc39.es/ecma262/#sec-object.assign
+  var objectAssign = !$assign || fails$2(function () {
+    // should have correct order of operations (Edge bug)
+    if (DESCRIPTORS$2 && $assign({ b: 1 }, $assign(defineProperty$2({}, 'a', {
+      enumerable: true,
+      get: function () {
+        defineProperty$2(this, 'b', {
+          value: 3,
+          enumerable: false
+        });
+      }
+    }), { b: 2 })).b !== 1) return true;
+    // should work with symbols and should have deterministic property order (V8 bug)
+    var A = {};
+    var B = {};
+    // eslint-disable-next-line es/no-symbol -- safe
+    var symbol = Symbol();
+    var alphabet = 'abcdefghijklmnopqrst';
+    A[symbol] = 7;
+    alphabet.split('').forEach(function (chr) { B[chr] = chr; });
+    return $assign({}, A)[symbol] != 7 || objectKeys$1($assign({}, B)).join('') != alphabet;
+  }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`
+    var T = toObject$1(target);
+    var argumentsLength = arguments.length;
+    var index = 1;
+    var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+    var propertyIsEnumerable = propertyIsEnumerableModule.f;
+    while (argumentsLength > index) {
+      var S = IndexedObject(arguments[index++]);
+      var keys = getOwnPropertySymbols ? concat(objectKeys$1(S), getOwnPropertySymbols(S)) : objectKeys$1(S);
+      var length = keys.length;
+      var j = 0;
+      var key;
+      while (length > j) {
+        key = keys[j++];
+        if (!DESCRIPTORS$2 || call$1(propertyIsEnumerable, S, key)) T[key] = S[key];
+      }
+    } return T;
+  } : $assign;
+
+  var $$1 = _export;
+  var assign = objectAssign;
+
+  // `Object.assign` method
+  // https://tc39.es/ecma262/#sec-object.assign
+  // eslint-disable-next-line es/no-object-assign -- required for testing
+  $$1({ target: 'Object', stat: true, forced: Object.assign !== assign }, {
+    assign: assign
+  });
+
+  const {
+    styled,
+    css,
+    globalCss,
+    keyframes,
+    getCssText,
+    theme,
+    createTheme,
+    config
+  } = react.createStitches({
+    theme: {
+      colors: Object.assign({}, core.foundations.colors),
+      space: Object.assign({}, core.foundations.space),
+      shadows: Object.assign({}, core.foundations.shadows),
+      fontSizes: Object.assign({}, core.foundations.fontSizes),
+      fonts: Object.assign({}, core.foundations.fonts),
+      lineHeights: Object.assign({}, core.foundations.lineHeights),
+      letterSpacings: Object.assign({}, core.foundations.letterSpacings),
+      radii: Object.assign({}, core.foundations.radii)
+    },
+    media: {
+      sm: '(min-width: 359px)',
+      md: '(min-width: 767px)',
+      lg: '(min-width: 1023px)',
+      xl: '(min-width: 1199px)',
+      '2xl': '(min-width: 1399px)'
+    },
+    utils: {
+      m: value => ({
+        margin: value
+      }),
+      mt: value => ({
+        marginTop: value
+      }),
+      mr: value => ({
+        marginRight: value
+      }),
+      mb: value => ({
+        marginBottom: value
+      }),
+      ml: value => ({
+        marginLeft: value
+      }),
+      mx: value => ({
+        marginLeft: value,
+        marginRight: value
+      }),
+      my: value => ({
+        marginTop: value,
+        marginBottom: value
+      }),
+      size: value => ({
+        width: value,
+        height: value
+      })
+    }
+  });
+  createTheme({
+    colors: {
+      bgWhite: '#000000',
+      bgDark: '#FFFFFF'
+    }
+  });
+
+  const normalize = {
+    '*,::before,::after': {
+      boxSizing: 'border-box'
+    },
+    html: {
+      lineHeight: 1.15,
+      WebkitTextSizeAdjust: '100%',
+      MozTabSize: '4',
+      tabSize: 4
+    },
+    body: {
+      margin: '0',
+      fontFamily: "system-ui,-apple-system,'Segoe UI',Roboto,Helvetica,Arial,sans-serif,'Apple Color Emoji','Segoe UI Emoji'"
+    },
+    hr: {
+      height: '0',
+      color: 'inherit'
+    },
+    'abbr[title]': {
+      textDecoration: 'underline dotted'
+    },
+    'b,strong': {
+      fontWeight: 'bolder'
+    },
+    'code,kbd,samp,pre': {
+      fontFamily: "ui-monospace,SFMono-Regular,Consolas,'Liberation Mono',Menlo,monospace",
+      fontSize: '1em'
+    },
+    small: {
+      fontSize: '80%'
+    },
+    'sub,sup': {
+      fontSize: '75%',
+      lineHeight: 0,
+      position: 'relative',
+      verticalAlign: 'baseline'
+    },
+    sub: {
+      bottom: '-0.25em'
+    },
+    sup: {
+      top: '-0.5em'
+    },
+    table: {
+      textIndent: '0',
+      borderColor: 'inherit'
+    },
+    'button,input,optgroup,select,textarea': {
+      fontFamily: 'inherit',
+      fontSize: '100%',
+      lineHeight: 1.15,
+      margin: '0'
+    },
+    'button,select': {
+      textTransform: 'none'
+    },
+    "button,[type='button'],[type='reset'],[type='submit']": {
+      WebkitAppearance: 'button'
+    },
+    '::-moz-focus-inner': {
+      borderStyle: 'none',
+      padding: '0'
+    },
+    ':-moz-focusring': {
+      outline: '1px dotted ButtonText'
+    },
+    ':-moz-ui-invalid': {
+      boxShadow: 'none'
+    },
+    legend: {
+      padding: '0'
+    },
+    progress: {
+      verticalAlign: 'baseline'
+    },
+    '::-webkit-inner-spin-button,::-webkit-outer-spin-button': {
+      height: 'auto'
+    },
+    "[type='search']": {
+      WebkitAppearance: 'textfield',
+      outlineOffset: '-2px'
+    },
+    '::-webkit-search-decoration': {
+      WebkitAppearance: 'none'
+    },
+    '::-webkit-file-upload-button': {
+      WebkitAppearance: 'button',
+      font: 'inherit'
+    },
+    summary: {
+      display: 'list-item'
+    }
+  };
+
+  const applyGlobalStyles = additionaStyles => {
+    const globalStyles = globalCss(Object.assign({}, normalize), {
+      '@import': ['url("https://fonts.googleapis.com/css2?family=Inter:wght@100;200;300;400;500;600;700;800;900&display=swap")'],
+      '*': {
+        fontFamily: '$main'
+      },
+      'html,body,#root': {
+        width: '100%',
+        height: '100%'
+      },
+      'h1,h2,h3,h4,h5,h6,p': {
+        margin: '0'
+      },
+      a: {
+        color: 'inherit',
+        textDecoration: 'none'
+      },
+      img: {
+        display: 'block',
+        maxWidth: '100%'
+      },
+      '.noscroll': {
+        overflow: 'hidden'
+      },
+      '.noselect': {
+        userSelect: 'none'
+      },
+      '.full-size': {
+        height: '100%',
+        width: '100%'
+      },
+      '.full-size-layout': {
+        height: '100%',
+        minHeight: '100vh',
+        width: '100%'
+      },
+      '.drag-handle': {
+        cursor: 'move',
+        display: 'inline-block',
+        '&::before': {
+          content: "'......'",
+          display: 'inline-block',
+          width: '10px',
+          wordBreak: 'break-word',
+          whiteSpace: 'normal',
+          letterSpacing: '2px',
+          lineHeight: '4.5px',
+          textAlign: 'center',
+          height: '18px'
+        }
+      },
+      '[data-reach-skip-link]': {
+        border: '0',
+        clip: 'rect(0 0 0 0)',
+        height: '1px',
+        width: '1px',
+        margin: '-1px',
+        padding: '0',
+        overflow: 'hidden',
+        position: 'absolute'
+      },
+      '[data-reach-skip-link]:focus': {
+        padding: '1rem',
+        position: 'fixed',
+        top: '10px',
+        left: '10px',
+        background: 'white',
+        zIndex: 100,
+        width: 'auto',
+        height: 'auto',
+        clip: 'auto'
+      }
+    }, Object.assign({}, additionaStyles));
+    globalStyles();
+  };
+
+  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);
+  }
+
+  function _objectWithoutPropertiesLoose(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 objectDefineProperties = {};
+
+  var DESCRIPTORS$1 = descriptors;
+  var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
+  var definePropertyModule$1 = objectDefineProperty;
+  var anObject$2 = anObject$5;
+  var toIndexedObject$1 = toIndexedObject$5;
+  var objectKeys = objectKeys$2;
+
+  // `Object.defineProperties` method
+  // https://tc39.es/ecma262/#sec-object.defineproperties
+  // eslint-disable-next-line es/no-object-defineproperties -- safe
+  objectDefineProperties.f = DESCRIPTORS$1 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
+    anObject$2(O);
+    var props = toIndexedObject$1(Properties);
+    var keys = objectKeys(Properties);
+    var length = keys.length;
+    var index = 0;
+    var key;
+    while (length > index) definePropertyModule$1.f(O, key = keys[index++], props[key]);
+    return O;
+  };
+
+  var getBuiltIn = getBuiltIn$4;
+
+  var html$1 = getBuiltIn('document', 'documentElement');
+
+  /* global ActiveXObject -- old IE, WSH */
+
+  var anObject$1 = anObject$5;
+  var definePropertiesModule = objectDefineProperties;
+  var enumBugKeys = enumBugKeys$3;
+  var hiddenKeys = hiddenKeys$4;
+  var html = html$1;
+  var documentCreateElement$1 = documentCreateElement$2;
+  var sharedKey$1 = sharedKey$3;
+
+  var GT = '>';
+  var LT = '<';
+  var PROTOTYPE = 'prototype';
+  var SCRIPT = 'script';
+  var IE_PROTO$1 = sharedKey$1('IE_PROTO');
+
+  var EmptyConstructor = function () { /* empty */ };
+
+  var scriptTag = function (content) {
+    return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
+  };
+
+  // Create object with fake `null` prototype: use ActiveX Object with cleared prototype
+  var NullProtoObjectViaActiveX = function (activeXDocument) {
+    activeXDocument.write(scriptTag(''));
+    activeXDocument.close();
+    var temp = activeXDocument.parentWindow.Object;
+    activeXDocument = null; // avoid memory leak
+    return temp;
+  };
+
+  // Create object with fake `null` prototype: use iframe Object with cleared prototype
+  var NullProtoObjectViaIFrame = function () {
+    // Thrash, waste and sodomy: IE GC bug
+    var iframe = documentCreateElement$1('iframe');
+    var JS = 'java' + SCRIPT + ':';
+    var iframeDocument;
+    iframe.style.display = 'none';
+    html.appendChild(iframe);
+    // https://github.com/zloirock/core-js/issues/475
+    iframe.src = String(JS);
+    iframeDocument = iframe.contentWindow.document;
+    iframeDocument.open();
+    iframeDocument.write(scriptTag('document.F=Object'));
+    iframeDocument.close();
+    return iframeDocument.F;
+  };
+
+  // Check for document.domain and active x support
+  // No need to use active x approach when document.domain is not set
+  // see https://github.com/es-shims/es5-shim/issues/150
+  // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
+  // avoid IE GC bug
+  var activeXDocument;
+  var NullProtoObject = function () {
+    try {
+      activeXDocument = new ActiveXObject('htmlfile');
+    } catch (error) { /* ignore */ }
+    NullProtoObject = typeof document != 'undefined'
+      ? document.domain && activeXDocument
+        ? NullProtoObjectViaActiveX(activeXDocument) // old IE
+        : NullProtoObjectViaIFrame()
+      : NullProtoObjectViaActiveX(activeXDocument); // WSH
+    var length = enumBugKeys.length;
+    while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
+    return NullProtoObject();
+  };
+
+  hiddenKeys[IE_PROTO$1] = true;
+
+  // `Object.create` method
+  // https://tc39.es/ecma262/#sec-object.create
+  var objectCreate = Object.create || function create(O, Properties) {
+    var result;
+    if (O !== null) {
+      EmptyConstructor[PROTOTYPE] = anObject$1(O);
+      result = new EmptyConstructor();
+      EmptyConstructor[PROTOTYPE] = null;
+      // add "__proto__" for Object.getPrototypeOf polyfill
+      result[IE_PROTO$1] = O;
+    } else result = NullProtoObject();
+    return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
+  };
+
+  var wellKnownSymbol$4 = wellKnownSymbol$6;
+  var create$1 = objectCreate;
+  var definePropertyModule = objectDefineProperty;
+
+  var UNSCOPABLES = wellKnownSymbol$4('unscopables');
+  var ArrayPrototype = Array.prototype;
+
+  // Array.prototype[@@unscopables]
+  // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+  if (ArrayPrototype[UNSCOPABLES] == undefined) {
+    definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {
+      configurable: true,
+      value: create$1(null)
+    });
+  }
+
+  // add a key to Array.prototype[@@unscopables]
+  var addToUnscopables$1 = function (key) {
+    ArrayPrototype[UNSCOPABLES][key] = true;
+  };
+
+  var iterators = {};
+
+  var fails$1 = fails$a;
+
+  var correctPrototypeGetter = !fails$1(function () {
+    function F() { /* empty */ }
+    F.prototype.constructor = null;
+    // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
+    return Object.getPrototypeOf(new F()) !== F.prototype;
+  });
+
+  var global$3 = global$o;
+  var hasOwn$1 = hasOwnProperty_1;
+  var isCallable$3 = isCallable$d;
+  var toObject = toObject$3;
+  var sharedKey = sharedKey$3;
+  var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
+
+  var IE_PROTO = sharedKey('IE_PROTO');
+  var Object$1 = global$3.Object;
+  var ObjectPrototype = Object$1.prototype;
+
+  // `Object.getPrototypeOf` method
+  // https://tc39.es/ecma262/#sec-object.getprototypeof
+  var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? Object$1.getPrototypeOf : function (O) {
+    var object = toObject(O);
+    if (hasOwn$1(object, IE_PROTO)) return object[IE_PROTO];
+    var constructor = object.constructor;
+    if (isCallable$3(constructor) && object instanceof constructor) {
+      return constructor.prototype;
+    } return object instanceof Object$1 ? ObjectPrototype : null;
+  };
+
+  var fails = fails$a;
+  var isCallable$2 = isCallable$d;
+  var getPrototypeOf$1 = objectGetPrototypeOf;
+  var redefine$1 = redefine$3.exports;
+  var wellKnownSymbol$3 = wellKnownSymbol$6;
+
+  var ITERATOR$2 = wellKnownSymbol$3('iterator');
+  var BUGGY_SAFARI_ITERATORS$1 = false;
+
+  // `%IteratorPrototype%` object
+  // https://tc39.es/ecma262/#sec-%iteratorprototype%-object
+  var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator;
+
+  /* eslint-disable es/no-array-prototype-keys -- safe */
+  if ([].keys) {
+    arrayIterator = [].keys();
+    // Safari 8 has buggy iterators w/o `next`
+    if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true;
+    else {
+      PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator));
+      if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype;
+    }
+  }
+
+  var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$2 == undefined || fails(function () {
+    var test = {};
+    // FF44- legacy iterators case
+    return IteratorPrototype$2[ITERATOR$2].call(test) !== test;
+  });
+
+  if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {};
+
+  // `%IteratorPrototype%[@@iterator]()` method
+  // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
+  if (!isCallable$2(IteratorPrototype$2[ITERATOR$2])) {
+    redefine$1(IteratorPrototype$2, ITERATOR$2, function () {
+      return this;
+    });
+  }
+
+  var iteratorsCore = {
+    IteratorPrototype: IteratorPrototype$2,
+    BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1
+  };
+
+  var defineProperty$1 = objectDefineProperty.f;
+  var hasOwn = hasOwnProperty_1;
+  var wellKnownSymbol$2 = wellKnownSymbol$6;
+
+  var TO_STRING_TAG$1 = wellKnownSymbol$2('toStringTag');
+
+  var setToStringTag$2 = function (target, TAG, STATIC) {
+    if (target && !STATIC) target = target.prototype;
+    if (target && !hasOwn(target, TO_STRING_TAG$1)) {
+      defineProperty$1(target, TO_STRING_TAG$1, { configurable: true, value: TAG });
+    }
+  };
+
+  var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
+  var create = objectCreate;
+  var createPropertyDescriptor = createPropertyDescriptor$3;
+  var setToStringTag$1 = setToStringTag$2;
+  var Iterators$2 = iterators;
+
+  var returnThis$1 = function () { return this; };
+
+  var createIteratorConstructor$1 = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
+    var TO_STRING_TAG = NAME + ' Iterator';
+    IteratorConstructor.prototype = create(IteratorPrototype$1, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
+    setToStringTag$1(IteratorConstructor, TO_STRING_TAG, false);
+    Iterators$2[TO_STRING_TAG] = returnThis$1;
+    return IteratorConstructor;
+  };
+
+  var global$2 = global$o;
+  var isCallable$1 = isCallable$d;
+
+  var String$1 = global$2.String;
+  var TypeError = global$2.TypeError;
+
+  var aPossiblePrototype$1 = function (argument) {
+    if (typeof argument == 'object' || isCallable$1(argument)) return argument;
+    throw TypeError("Can't set " + String$1(argument) + ' as a prototype');
+  };
+
+  /* eslint-disable no-proto -- safe */
+
+  var uncurryThis = functionUncurryThis;
+  var anObject = anObject$5;
+  var aPossiblePrototype = aPossiblePrototype$1;
+
+  // `Object.setPrototypeOf` method
+  // https://tc39.es/ecma262/#sec-object.setprototypeof
+  // Works with __proto__ only. Old v8 can't work with null proto objects.
+  // eslint-disable-next-line es/no-object-setprototypeof -- safe
+  var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
+    var CORRECT_SETTER = false;
+    var test = {};
+    var setter;
+    try {
+      // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+      setter = uncurryThis(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);
+      setter(test, []);
+      CORRECT_SETTER = test instanceof Array;
+    } catch (error) { /* empty */ }
+    return function setPrototypeOf(O, proto) {
+      anObject(O);
+      aPossiblePrototype(proto);
+      if (CORRECT_SETTER) setter(O, proto);
+      else O.__proto__ = proto;
+      return O;
+    };
+  }() : undefined);
+
+  var $ = _export;
+  var call = functionCall;
+  var FunctionName = functionName;
+  var isCallable = isCallable$d;
+  var createIteratorConstructor = createIteratorConstructor$1;
+  var getPrototypeOf = objectGetPrototypeOf;
+  var setPrototypeOf = objectSetPrototypeOf;
+  var setToStringTag = setToStringTag$2;
+  var createNonEnumerableProperty$1 = createNonEnumerableProperty$5;
+  var redefine = redefine$3.exports;
+  var wellKnownSymbol$1 = wellKnownSymbol$6;
+  var Iterators$1 = iterators;
+  var IteratorsCore = iteratorsCore;
+
+  var PROPER_FUNCTION_NAME = FunctionName.PROPER;
+  var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
+  var IteratorPrototype = IteratorsCore.IteratorPrototype;
+  var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
+  var ITERATOR$1 = wellKnownSymbol$1('iterator');
+  var KEYS = 'keys';
+  var VALUES = 'values';
+  var ENTRIES = 'entries';
+
+  var returnThis = function () { return this; };
+
+  var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
+    createIteratorConstructor(IteratorConstructor, NAME, next);
+
+    var getIterationMethod = function (KIND) {
+      if (KIND === DEFAULT && defaultIterator) return defaultIterator;
+      if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];
+      switch (KIND) {
+        case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
+        case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
+        case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
+      } return function () { return new IteratorConstructor(this); };
+    };
+
+    var TO_STRING_TAG = NAME + ' Iterator';
+    var INCORRECT_VALUES_NAME = false;
+    var IterablePrototype = Iterable.prototype;
+    var nativeIterator = IterablePrototype[ITERATOR$1]
+      || IterablePrototype['@@iterator']
+      || DEFAULT && IterablePrototype[DEFAULT];
+    var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
+    var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
+    var CurrentIteratorPrototype, methods, KEY;
+
+    // fix native
+    if (anyNativeIterator) {
+      CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
+      if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
+        if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
+          if (setPrototypeOf) {
+            setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
+          } else if (!isCallable(CurrentIteratorPrototype[ITERATOR$1])) {
+            redefine(CurrentIteratorPrototype, ITERATOR$1, returnThis);
+          }
+        }
+        // Set @@toStringTag to native iterators
+        setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true);
+      }
+    }
+
+    // fix Array.prototype.{ values, @@iterator }.name in V8 / FF
+    if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
+      if (CONFIGURABLE_FUNCTION_NAME) {
+        createNonEnumerableProperty$1(IterablePrototype, 'name', VALUES);
+      } else {
+        INCORRECT_VALUES_NAME = true;
+        defaultIterator = function values() { return call(nativeIterator, this); };
+      }
+    }
+
+    // export additional methods
+    if (DEFAULT) {
+      methods = {
+        values: getIterationMethod(VALUES),
+        keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
+        entries: getIterationMethod(ENTRIES)
+      };
+      if (FORCED) for (KEY in methods) {
+        if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
+          redefine(IterablePrototype, KEY, methods[KEY]);
+        }
+      } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
+    }
+
+    // define iterator
+    if (IterablePrototype[ITERATOR$1] !== defaultIterator) {
+      redefine(IterablePrototype, ITERATOR$1, defaultIterator, { name: DEFAULT });
+    }
+    Iterators$1[NAME] = defaultIterator;
+
+    return methods;
+  };
+
+  var toIndexedObject = toIndexedObject$5;
+  var addToUnscopables = addToUnscopables$1;
+  var Iterators = iterators;
+  var InternalStateModule = internalState;
+  var defineProperty = objectDefineProperty.f;
+  var defineIterator = defineIterator$1;
+  var DESCRIPTORS = descriptors;
+
+  var ARRAY_ITERATOR = 'Array Iterator';
+  var setInternalState = InternalStateModule.set;
+  var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
+
+  // `Array.prototype.entries` method
+  // https://tc39.es/ecma262/#sec-array.prototype.entries
+  // `Array.prototype.keys` method
+  // https://tc39.es/ecma262/#sec-array.prototype.keys
+  // `Array.prototype.values` method
+  // https://tc39.es/ecma262/#sec-array.prototype.values
+  // `Array.prototype[@@iterator]` method
+  // https://tc39.es/ecma262/#sec-array.prototype-@@iterator
+  // `CreateArrayIterator` internal method
+  // https://tc39.es/ecma262/#sec-createarrayiterator
+  var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) {
+    setInternalState(this, {
+      type: ARRAY_ITERATOR,
+      target: toIndexedObject(iterated), // target
+      index: 0,                          // next index
+      kind: kind                         // kind
+    });
+  // `%ArrayIteratorPrototype%.next` method
+  // https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
+  }, function () {
+    var state = getInternalState(this);
+    var target = state.target;
+    var kind = state.kind;
+    var index = state.index++;
+    if (!target || index >= target.length) {
+      state.target = undefined;
+      return { value: undefined, done: true };
+    }
+    if (kind == 'keys') return { value: index, done: false };
+    if (kind == 'values') return { value: target[index], done: false };
+    return { value: [index, target[index]], done: false };
+  }, 'values');
+
+  // argumentsList[@@iterator] is %ArrayProto_values%
+  // https://tc39.es/ecma262/#sec-createunmappedargumentsobject
+  // https://tc39.es/ecma262/#sec-createmappedargumentsobject
+  var values = Iterators.Arguments = Iterators.Array;
+
+  // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+  addToUnscopables('keys');
+  addToUnscopables('values');
+  addToUnscopables('entries');
+
+  // V8 ~ Chrome 45- bug
+  if (DESCRIPTORS && values.name !== 'values') try {
+    defineProperty(values, 'name', { value: 'values' });
+  } catch (error) { /* empty */ }
+
+  // iterable DOM collections
+  // flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
+  var domIterables = {
+    CSSRuleList: 0,
+    CSSStyleDeclaration: 0,
+    CSSValueList: 0,
+    ClientRectList: 0,
+    DOMRectList: 0,
+    DOMStringList: 0,
+    DOMTokenList: 1,
+    DataTransferItemList: 0,
+    FileList: 0,
+    HTMLAllCollection: 0,
+    HTMLCollection: 0,
+    HTMLFormElement: 0,
+    HTMLSelectElement: 0,
+    MediaList: 0,
+    MimeTypeArray: 0,
+    NamedNodeMap: 0,
+    NodeList: 1,
+    PaintRequestList: 0,
+    Plugin: 0,
+    PluginArray: 0,
+    SVGLengthList: 0,
+    SVGNumberList: 0,
+    SVGPathSegList: 0,
+    SVGPointList: 0,
+    SVGStringList: 0,
+    SVGTransformList: 0,
+    SourceBufferList: 0,
+    StyleSheetList: 0,
+    TextTrackCueList: 0,
+    TextTrackList: 0,
+    TouchList: 0
+  };
+
+  // in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
+  var documentCreateElement = documentCreateElement$2;
+
+  var classList = documentCreateElement('span').classList;
+  var DOMTokenListPrototype$1 = classList && classList.constructor && classList.constructor.prototype;
+
+  var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
+
+  var global$1 = global$o;
+  var DOMIterables = domIterables;
+  var DOMTokenListPrototype = domTokenListPrototype;
+  var ArrayIteratorMethods = es_array_iterator;
+  var createNonEnumerableProperty = createNonEnumerableProperty$5;
+  var wellKnownSymbol = wellKnownSymbol$6;
+
+  var ITERATOR = wellKnownSymbol('iterator');
+  var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+  var ArrayValues = ArrayIteratorMethods.values;
+
+  var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
+    if (CollectionPrototype) {
+      // some Chrome versions have non-configurable methods on DOMTokenList
+      if (CollectionPrototype[ITERATOR] !== ArrayValues) try {
+        createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);
+      } catch (error) {
+        CollectionPrototype[ITERATOR] = ArrayValues;
+      }
+      if (!CollectionPrototype[TO_STRING_TAG]) {
+        createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
+      }
+      if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
+        // some Chrome versions have non-configurable methods on DOMTokenList
+        if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
+          createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
+        } catch (error) {
+          CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
+        }
+      }
+    }
+  };
+
+  for (var COLLECTION_NAME in DOMIterables) {
+    handlePrototype(global$1[COLLECTION_NAME] && global$1[COLLECTION_NAME].prototype, COLLECTION_NAME);
+  }
+
+  handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
+
+  var _jsxFileName$f = "C:\\Project\\majoo-ui\\packages\\react\\src\\layout\\box\\Box.js";
+  const BoxComponent = styled('div', {
+    padding: '10px',
+    height: 'auto'
+  });
+  const Box = ({
+    className,
+    children,
+    color,
+    textColor,
+    padding
+  }) => /*#__PURE__*/React__default["default"].createElement(BoxComponent, {
+    className: className,
+    css: {
+      padding: padding,
+      backgroundColor: '$' + color,
+      color: '$' + textColor
+    },
+    __self: undefined,
+    __source: {
+      fileName: _jsxFileName$f,
+      lineNumber: 11,
+      columnNumber: 5
+    }
+  }, children);
+  Box.propTypes = {
+    textColor: PropTypes__default["default"].string,
+    className: PropTypes__default["default"].string,
+    color: PropTypes__default["default"].string,
+    padding: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].number])
+  };
+  Box.defaultProps = {
+    className: '',
+    color: 'white',
+    padding: '20px'
+  };
+
+  function seqNumberVariants(variantFn, max, fromOne) {
+    let variants = {};
+
+    for (let i = fromOne ? 1 : 0; (_ref = i <= max) != null ? _ref : 100; i++) {
+      var _ref;
+
+      variants = Object.assign({}, variants, {
+        [i]: variantFn(i)
+      });
+    }
+
+    return variants;
+  }
+
+  const _excluded$9 = ["children"];
+  var _jsxFileName$e = "C:\\Project\\majoo-ui\\packages\\react\\src\\layout\\flex\\Flex.js";
+  const FlexComponent = styled('div', {
+    boxSizing: 'border-box',
+    display: 'flex',
+    variants: {
+      center: {
+        true: {
+          alignItems: 'center',
+          justifyContent: 'center'
+        }
+      },
+      direction: {
+        row: {
+          flexDirection: 'row'
+        },
+        column: {
+          flexDirection: 'column'
+        },
+        rowReverse: {
+          flexDirection: 'row-reverse'
+        },
+        columnReverse: {
+          flexDirection: 'column-reverse'
+        }
+      },
+      align: {
+        start: {
+          alignItems: 'flex-start'
+        },
+        center: {
+          alignItems: 'center'
+        },
+        end: {
+          alignItems: 'flex-end'
+        },
+        stretch: {
+          alignItems: 'stretch'
+        },
+        baseline: {
+          alignItems: 'baseline'
+        }
+      },
+      justify: {
+        start: {
+          justifyContent: 'flex-start'
+        },
+        center: {
+          justifyContent: 'center'
+        },
+        end: {
+          justifyContent: 'flex-end'
+        },
+        between: {
+          justifyContent: 'space-between'
+        }
+      },
+      wrap: {
+        noWrap: {
+          flexWrap: 'nowrap'
+        },
+        wrap: {
+          flexWrap: 'wrap'
+        },
+        wrapReverse: {
+          flexWrap: 'wrap-reverse'
+        }
+      },
+      gap: seqNumberVariants(value => ({
+        gap: `$spacing-${value < 10 ? '0' + value : value}`
+      }), 12, true)
+    }
+  });
+
+  const Flex = _ref => {
+    let {
+      children
+    } = _ref,
+        props = _objectWithoutPropertiesLoose(_ref, _excluded$9);
+
+    return /*#__PURE__*/React__default["default"].createElement(FlexComponent, _extends({}, props, {
+      css: Object.assign({}, props.css),
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$e,
+        lineNumber: 80,
+        columnNumber: 5
+      }
+    }), children);
+  };
+
+  Flex.propTypes = {
+    center: PropTypes__default["default"].bool,
+    direction: PropTypes__default["default"].string,
+    align: PropTypes__default["default"].string,
+    justify: PropTypes__default["default"].string,
+    wrap: PropTypes__default["default"].string,
+    gap: PropTypes__default["default"].number
+  };
+  Flex.defaultProps = {
+    center: false,
+    direction: 'row',
+    align: 'stretch',
+    justify: 'start',
+    wrap: 'noWrap',
+    gap: 0
+  };
+  Flex.displayName = 'Flex';
+
+  const _excluded$8 = ["children"],
+        _excluded2 = ["children"];
+  var _jsxFileName$d = "C:\\Project\\majoo-ui\\packages\\react\\src\\layout\\grid\\Grid.js";
+  const GridComponent = styled('div', {
+    display: 'grid',
+    variants: {
+      align: {
+        start: {
+          alignItems: 'start'
+        },
+        center: {
+          alignItems: 'center'
+        },
+        end: {
+          alignItems: 'end'
+        },
+        stretch: {
+          alignItems: 'stretch'
+        },
+        baseline: {
+          alignItems: 'baseline'
+        }
+      },
+      justify: {
+        start: {
+          justifyContent: 'start'
+        },
+        center: {
+          justifyContent: 'center'
+        },
+        end: {
+          justifyContent: 'end'
+        },
+        between: {
+          justifyContent: 'space-between'
+        }
+      },
+      flow: {
+        row: {
+          gridAutoFlow: 'row'
+        },
+        column: {
+          gridAutoFlow: 'column'
+        },
+        dense: {
+          gridAutoFlow: 'dense'
+        },
+        rowDense: {
+          gridAutoFlow: 'row dense'
+        },
+        columnDense: {
+          gridAutoFlow: 'column dense'
+        }
+      },
+      columns: seqNumberVariants(value => ({
+        gridTemplateColumns: `repeat(${value}, 1fr)`
+      }), 10),
+      rows: seqNumberVariants(value => ({
+        gridTemplateRows: `repeat(${value}, 1fr)`
+      }), 10),
+      placeItems: {
+        stretch: {
+          placeItems: 'stretch'
+        },
+        start: {
+          placeItems: 'start'
+        },
+        end: {
+          placeItems: 'end'
+        },
+        center: {
+          placeItems: 'center'
+        },
+        left: {
+          placeItems: 'left'
+        },
+        right: {
+          placeItems: 'right'
+        }
+      },
+      gap: {
+        1: {
+          gap: '$spacing-03'
+        },
+        2: {
+          gap: '$spacing-05'
+        },
+        3: {
+          gap: '$spacing-06'
+        },
+        4: {
+          gap: '$spacing-07'
+        },
+        5: {
+          gap: '$spacing-08'
+        },
+        6: {
+          gap: '$spacing-09'
+        },
+        7: {
+          gap: '$spacing-10'
+        },
+        8: {
+          gap: '$spacing-11'
+        },
+        9: {
+          gap: '$spacing-12'
+        }
+      },
+      gapX: {
+        normal: {
+          columnGap: 'normal'
+        },
+        1: {
+          columnGap: '$spacing-03'
+        },
+        2: {
+          columnGap: '$spacing-05'
+        },
+        3: {
+          columnGap: '$spacing-06'
+        },
+        4: {
+          columnGap: '$spacing-07'
+        },
+        5: {
+          columnGap: '$spacing-08'
+        },
+        6: {
+          columnGap: '$spacing-09'
+        },
+        7: {
+          columnGap: '$spacing-10'
+        },
+        8: {
+          columnGap: '$spacing-11'
+        },
+        9: {
+          columnGap: '$spacing-12'
+        }
+      },
+      gapY: {
+        1: {
+          rowGap: '$spacing-03'
+        },
+        2: {
+          rowGap: '$spacing-05'
+        },
+        3: {
+          rowGap: '$spacing-06'
+        },
+        4: {
+          rowGap: '$spacing-07'
+        },
+        5: {
+          rowGap: '$spacing-08'
+        },
+        6: {
+          rowGap: '$spacing-09'
+        },
+        7: {
+          rowGap: '$spacing-10'
+        },
+        8: {
+          rowGap: '$spacing-11'
+        },
+        9: {
+          rowGap: '$spacing-12'
+        }
+      }
+    }
+  });
+  const Grid = _ref => {
+    let {
+      children
+    } = _ref,
+        props = _objectWithoutPropertiesLoose(_ref, _excluded$8);
+
+    return /*#__PURE__*/React__default["default"].createElement(GridComponent, _extends({}, props, {
+      css: Object.assign({}, props.css, {
+        gridAutoColumns: props.autoColumns,
+        gridAutoRows: props.autoRows,
+        gridTemplateColumns: props.templateColumns,
+        gridTemplateRows: props.templateRows
+      }),
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$d,
+        lineNumber: 178,
+        columnNumber: 5
+      }
+    }), children);
+  };
+  Grid.propTypes = {
+    align: PropTypes__default["default"].string,
+    justify: PropTypes__default["default"].string,
+    autoColumns: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].number]),
+    autoRows: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].number]),
+    autoFlow: PropTypes__default["default"].string,
+    templateColumns: PropTypes__default["default"].string,
+    templateRows: PropTypes__default["default"].string,
+    columns: PropTypes__default["default"].number,
+    rows: PropTypes__default["default"].number,
+    gap: PropTypes__default["default"].number,
+    gapX: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].number]),
+    gapY: PropTypes__default["default"].number
+  };
+  Grid.displayName = 'Grid';
+
+  function spanFn(value) {
+    return value === "auto" ? "auto" : `span ${value}/span ${value}`;
+  }
+
+  const GridItemComponent = styled('div', {
+    variants: {
+      colSpan: Object.assign({
+        auto: spanFn('auto')
+      }, seqNumberVariants(value => ({
+        gridColumn: spanFn(value)
+      }), 10, true)),
+      rowSpan: Object.assign({
+        auto: spanFn('auto')
+      }, seqNumberVariants(value => ({
+        gridRow: spanFn(value)
+      }), 10, true))
+    }
+  });
+  const GridItem = _ref2 => {
+    let {
+      children
+    } = _ref2,
+        props = _objectWithoutPropertiesLoose(_ref2, _excluded2);
+
+    return /*#__PURE__*/React__default["default"].createElement(GridItemComponent, _extends({}, props, {
+      css: Object.assign({}, props.css, {
+        gridArea: props.area,
+        gridColumnStart: props.colStart,
+        gridColumnEnd: props.colEnd,
+        gridRowStart: props.rowStart,
+        gridRowEnd: props.rowEnd
+      }),
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$d,
+        lineNumber: 230,
+        columnNumber: 5
+      }
+    }), children);
+  };
+  GridItem.propTypes = {
+    gridArea: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].number]),
+    colSpan: PropTypes__default["default"].number,
+    rowSpan: PropTypes__default["default"].number,
+    colStart: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].number]),
+    colEnd: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].number]),
+    rowStart: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].number]),
+    rowEnd: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].number])
+  };
+  GridItem.displayName = 'Grid Item';
+
+  const _excluded$7 = ["className", "children", "type", "buttonType", "size", "disabled", "onClick", "block", "width", "leftIcon", "rightIcon"];
+  var _jsxFileName$c = "C:\\Project\\majoo-ui\\packages\\react\\src\\components\\button\\Button.js";
+  const ButtonPrimary = {
+    backgroundColor: '$btnPrimary',
+    border: '1px solid $btnPrimary',
+    margin: '2px',
+    color: '$textWhite',
+    '&:hover': {
+      backgroundColor: '$primary600',
+      border: '1px solid $primary600'
+    },
+    '&:active': {
+      backgroundColor: '$primary700',
+      border: '1px solid $primary700'
+    }
+  };
+  const PrimarySecondary = {
+    backgroundColor: '$btnSecondary',
+    border: '1px solid $btnPrimary',
+    color: '$textGreen',
+    '&:hover': {
+      backgroundColor: '$primary50',
+      border: '1px solid $btnPrimary',
+      color: '$textGreen'
+    },
+    '&:active': {
+      backgroundColor: '$primary100',
+      border: '1px solid $btnPrimary'
+    }
+  };
+  const GhostButton = {
+    backgroundColor: '$btnSecondary',
+    border: '1px solid $btnSecondary',
+    margin: '2px',
+    color: '$textGreen',
+    '&:hover': {
+      backgroundColor: '$primary50',
+      border: '1px solid $primary50',
+      color: '$textGreen'
+    },
+    '&:active': {
+      backgroundColor: '$primary100',
+      border: '1px solid $btnPrimary'
+    }
+  };
+  const ButtonNegative = {
+    backgroundColor: '$btnNegative',
+    border: '1px solid $btnNegative',
+    margin: '2px',
+    color: '$textWhite',
+    '&:hover': {
+      backgroundColor: '$red600',
+      border: '1px solid $red600'
+    },
+    '&:active': {
+      backgroundColor: '$red700',
+      border: '1px solid $red700'
+    }
+  };
+  const ButtonNegativeSecondary = {
+    backgroundColor: '$bgWhite',
+    border: '1px solid $btnNegative',
+    margin: '2px',
+    color: '$textRed',
+    '&:hover': {
+      backgroundColor: '$red50',
+      border: '1px solid $textRed'
+    },
+    '&:active': {
+      backgroundColor: '$red100',
+      border: '1px solid $textRed'
+    }
+  };
+  const StyledIconLeft = styled('div', {
+    marginRight: '5px',
+    display: 'inline-block'
+  });
+  const StyledIconRight = styled('div', {
+    marginLeft: '5px',
+    display: 'inline-block'
+  });
+  const ButtonComponent = styled('button', {
+    backgroundColor: '$btnPrimary',
+    border: '1px solid $btnPrimary',
+    borderRadius: '$lg',
+    fontSize: '14px',
+    fontWeight: 400,
+    color: '$textWhite',
+    padding: '10px 12px',
+    margin: '2px',
+    '&:hover': {
+      backgroundColor: '$primary600',
+      border: '1px solid $primary600'
+    },
+    '&:active': {
+      backgroundColor: '$primary700',
+      border: '1px solid $primary700'
+    },
+    '&:disabled': {
+      border: '1px solid $btnDisable',
+      backgroundColor: '$btnDisable',
+      color: '$textDisable',
+      '&:hover': {
+        backgroundColor: '$btnDisable',
+        border: '1px solid $btnDisable'
+      },
+      '&:active': {
+        backgroundColor: '$btnDisable',
+        border: '1px solid $btnDisable'
+      }
+    },
+    variants: {
+      buttonType: {
+        primary: Object.assign({}, ButtonPrimary),
+        secondary: Object.assign({}, PrimarySecondary),
+        ghost: Object.assign({}, GhostButton),
+        negative: Object.assign({}, ButtonNegative),
+        'negative-secondary': Object.assign({}, ButtonNegativeSecondary)
+      },
+      size: {
+        xsmall: {
+          padding: '4px 12px',
+          textAlign: 'center'
+        },
+        small: {
+          padding: '6px 12px',
+          textAlign: 'center'
+        },
+        medium: {
+          padding: '10px 12px',
+          textAlign: 'center'
+        },
+        large: {
+          fontSize: '16px',
+          padding: '14px 16px',
+          textAlign: 'center'
+        }
+      }
+    }
+  });
+  function Button(_ref) {
+    let {
+      className,
+      children,
+      type,
+      buttonType,
+      size,
+      disabled,
+      onClick,
+      block,
+      width,
+      leftIcon,
+      rightIcon
+    } = _ref,
+        props = _objectWithoutPropertiesLoose(_ref, _excluded$7);
+
+    return /*#__PURE__*/React__default["default"].createElement(ButtonComponent, _extends({
+      className: className,
+      type: type,
+      buttonType: buttonType,
+      size: size,
+      onClick: onClick,
+      disabled: disabled,
+      css: {
+        display: block ? 'block' : 'inline-block',
+        width: width
+      }
+    }, props, {
+      __self: this,
+      __source: {
+        fileName: _jsxFileName$c,
+        lineNumber: 155,
+        columnNumber: 5
+      }
+    }), leftIcon !== undefined ? /*#__PURE__*/React__default["default"].createElement(StyledIconLeft, {
+      __self: this,
+      __source: {
+        fileName: _jsxFileName$c,
+        lineNumber: 157,
+        columnNumber: 12
+      }
+    }, leftIcon) : null, children, rightIcon !== undefined ? /*#__PURE__*/React__default["default"].createElement(StyledIconRight, {
+      __self: this,
+      __source: {
+        fileName: _jsxFileName$c,
+        lineNumber: 161,
+        columnNumber: 12
+      }
+    }, rightIcon) : null);
+  }
+  Button.propTypes = {
+    className: PropTypes__default["default"].string,
+    buttonType: PropTypes__default["default"].string,
+    size: PropTypes__default["default"].string,
+    disabled: PropTypes__default["default"].bool,
+    onClick: PropTypes__default["default"].func,
+    block: PropTypes__default["default"].bool,
+    width: PropTypes__default["default"].string,
+    leftIcon: PropTypes__default["default"].element,
+    rightIcon: PropTypes__default["default"].element
+  };
+  Button.defaultProps = {
+    buttonType: 'primary',
+    size: 'medium',
+    disabled: false,
+    block: false
+  };
+
+  const _excluded$6 = ["id", "message", "dismissAfter", "variant", "onAction", "actionText", "onRemove"];
+  var _jsxFileName$b = "C:\\Project\\majoo-ui\\packages\\react\\src\\components\\toast\\Toast.js";
+  const TOAST_WIDTH = 360;
+  const ANIMATION_DURATION = 400; // export interface ToastProps extends Omit<ToastSettings, 'status'>, BoxProps {
+  //   variant?: ToastVariants;
+  // }
+
+  const toastEnter = react.keyframes({
+    '0%': {
+      right: `-${TOAST_WIDTH}px`,
+      opacity: '0'
+    },
+    '100%': {
+      right: '0',
+      opacity: '1'
+    }
+  });
+  const toastExit = react.keyframes({
+    '0%': {
+      transform: 'translateX(0%)',
+      opacity: '1',
+      maxHeight: '200px',
+      marginBottom: '20px'
+    },
+    '40%': {
+      maxHeight: '200px',
+      marginBottom: '20px'
+    },
+    '50%': {
+      transform: 'translateX(100%)',
+      opacity: '0'
+    },
+    '100%': {
+      transform: 'translateX(100%)',
+      opacity: '0',
+      maxHeight: '0',
+      marginBottom: '0'
+    }
+  });
+  const Root = react.styled('div', {
+    display: 'block',
+    width: `${TOAST_WIDTH}px`,
+    height: '100%',
+    position: 'relative',
+    marginBottom: '20px',
+    opacity: 0,
+    '&[state="entering"], &[state="entered"]': {
+      animationFillMode: 'forwards',
+      animationName: toastEnter,
+      animationDuration: `${ANIMATION_DURATION}ms`
+    },
+    '&[state="exiting"]': {
+      animationFillMode: 'forwards',
+      animationName: toastExit,
+      animationDuration: `${ANIMATION_DURATION * 2}ms`
+    },
+    '&[state="entered"]': {
+      right: 0,
+      opacity: '1'
+    }
+  });
+  const StyledToast = react.styled('div', {
+    display: 'inline-flex',
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'center',
+    width: '100%',
+    maxWidth: TOAST_WIDTH,
+    padding: '$spacing-05',
+    textAlign: 'left',
+    borderRadius: 8,
+    backgroundColor: core.foundations.colors.bgDark,
+    color: core.foundations.colors.textWhite,
+    variants: {
+      variant: {
+        news: {
+          backgroundColor: core.foundations.colors.hlNews,
+          color: core.foundations.colors.textWhite
+        },
+        process: {
+          backgroundColor: core.foundations.colors.hlProcess,
+          color: core.foundations.colors.textWhite
+        },
+        success: {
+          backgroundColor: core.foundations.colors.hlSuccess,
+          color: core.foundations.colors.textWhite
+        },
+        failed: {
+          backgroundColor: core.foundations.colors.hlFailed,
+          color: core.foundations.colors.textWhite
+        }
+      }
+    }
+  });
+  const Text$1 = react.styled('span', {
+    display: 'block'
+  });
+
+  const Toast = _ref => {
+    let {
+      id,
+      message,
+      dismissAfter,
+      variant,
+      onAction,
+      actionText,
+      onRemove
+    } = _ref,
+        rest = _objectWithoutPropertiesLoose(_ref, _excluded$6);
+
+    const [isOpen, setIsOpen] = React__namespace.useState(false);
+    const close = React__namespace.useCallback(() => {
+      setIsOpen(false);
+    }, [setIsOpen]);
+    React__namespace.useEffect(() => {
+      let currentTimer = null;
+      setIsOpen(true);
+      currentTimer = setTimeout(() => {
+        close();
+      }, dismissAfter);
+      return () => {
+        if (currentTimer) {
+          clearTimeout(currentTimer);
+        }
+      };
+    }, [dismissAfter]);
+    return /*#__PURE__*/React__namespace.createElement(reactTransitionGroup.Transition, {
+      appear: true,
+      in: isOpen,
+      timeout: {
+        enter: ANIMATION_DURATION + 100,
+        exit: ANIMATION_DURATION + 400
+      },
+      unmountOnExit: true,
+      onExited: onRemove,
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$b,
+        lineNumber: 144,
+        columnNumber: 5
+      }
+    }, state => /*#__PURE__*/React__namespace.createElement(Root, _extends({
+      id: id,
+      state: state
+    }, rest, {
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$b,
+        lineNumber: 155,
+        columnNumber: 9
+      }
+    }), /*#__PURE__*/React__namespace.createElement(StyledToast, {
+      variant: variant,
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$b,
+        lineNumber: 156,
+        columnNumber: 11
+      }
+    }, /*#__PURE__*/React__namespace.createElement(Flex, {
+      align: "center",
+      css: {
+        flex: "1 1 auto"
+      },
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$b,
+        lineNumber: 157,
+        columnNumber: 13
+      }
+    }, /*#__PURE__*/React__namespace.createElement(Text$1, {
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$b,
+        lineNumber: 160,
+        columnNumber: 15
+      }
+    }, message)), onAction && /*#__PURE__*/React__namespace.createElement(Flex, {
+      align: "start",
+      ml: "$spacing-01",
+      css: {},
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$b,
+        lineNumber: 165,
+        columnNumber: 15
+      }
+    }, /*#__PURE__*/React__namespace.createElement(Button, {
+      buttonType: "secondary",
+      onClick: () => {
+        if (onAction) {
+          onAction();
+        }
+
+        close();
+      },
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$b,
+        lineNumber: 168,
+        columnNumber: 17
+      }
+    }, actionText)))));
+  };
+
+  Toast.displayName = 'Toast';
+  Toast.propTypes = {
+    id: PropTypes__default["default"].string,
+    message: PropTypes__default["default"].string,
+    dismissAfter: PropTypes__default["default"].number,
+    variant: PropTypes__default["default"].string,
+    onAction: PropTypes__default["default"].func,
+    actionText: PropTypes__default["default"].string,
+    onRemove: PropTypes__default["default"].func
+  };
+  Toast.defaultProps = {
+    dismissAfter: 5000
+  };
+
+  const ToastContext = /*#__PURE__*/React__namespace.createContext({});
+
+  var _jsxFileName$a = "C:\\Project\\majoo-ui\\packages\\react\\src\\components\\toast\\ToastContainer.js";
+  const ToastBox = styled(Box, {
+    display: 'block',
+    position: 'fixed',
+    bottom: 0,
+    right: 24
+  });
+
+  const ToastContainer = ({
+    toasts
+  }) => {
+    const {
+      removeToast
+    } = React__namespace.useContext(ToastContext);
+    return /*#__PURE__*/React__namespace.createElement(helpers.Portal, {
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$a,
+        lineNumber: 19,
+        columnNumber: 5
+      }
+    }, /*#__PURE__*/React__namespace.createElement(ToastBox, {
+      padding: 0,
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$a,
+        lineNumber: 20,
+        columnNumber: 7
+      }
+    }, toasts.map(toast => {
+      console.log(toast);
+      return /*#__PURE__*/React__namespace.createElement(Toast, _extends({
+        key: toast.id,
+        onRemove: () => removeToast(toast.id)
+      }, toast, {
+        __self: undefined,
+        __source: {
+          fileName: _jsxFileName$a,
+          lineNumber: 24,
+          columnNumber: 13
+        }
+      }));
+    })));
+  };
+
+  const _excluded$5 = ["id"];
+  var _jsxFileName$9 = "C:\\Project\\majoo-ui\\packages\\react\\src\\components\\toast\\context\\ToastProvider.js";
+  let toastCount = 0;
+
+  const ToastProvider = ({
+    children
+  }) => {
+    const [toasts, setToasts] = React__namespace.useState([]);
+
+    const createToastInstance = toast => {
+      const {
+        id
+      } = toast,
+            rest = _objectWithoutPropertiesLoose(toast, _excluded$5); // eslint-disable-next-line no-plusplus
+
+
+      const uniqueId = ++toastCount;
+      const generatedId = `${id || 'toast'}-${uniqueId}`;
+      return Object.assign({
+        id: generatedId
+      }, rest);
+    };
+
+    const addToast = React__namespace.useCallback(toast => {
+      const toastInstance = createToastInstance(toast);
+      setToasts(toastItems => [toastInstance, ...toastItems]);
+      return toastInstance;
+    }, [setToasts]);
+    const removeToast = React__namespace.useCallback(id => {
+      setToasts(toastItems => toastItems.filter(t => t.id !== id));
+    }, [setToasts]);
+    return /*#__PURE__*/React__namespace.createElement(ToastContext.Provider, {
+      value: {
+        addToast,
+        removeToast
+      },
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$9,
+        lineNumber: 40,
+        columnNumber: 5
+      }
+    }, children, /*#__PURE__*/React__namespace.createElement(ToastContainer, {
+      toasts: toasts,
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$9,
+        lineNumber: 42,
+        columnNumber: 7
+      }
+    }));
+  };
+
+  var _jsxFileName$8 = "C:\\Project\\majoo-ui\\packages\\react\\src\\majoo-provider\\MajooProvider.js";
+
+  function MajooProvider({
+    children,
+    theme: theme$1 = theme,
+    extendStyle,
+    disableGlobalStyle
+  }) {
+    !disableGlobalStyle && applyGlobalStyles(extendStyle);
+    return /*#__PURE__*/React__default["default"].createElement(ThemeProvider, {
+      theme: theme$1,
+      __self: this,
+      __source: {
+        fileName: _jsxFileName$8,
+        lineNumber: 15,
+        columnNumber: 10
+      }
+    }, /*#__PURE__*/React__default["default"].createElement(ToastProvider, {
+      __self: this,
+      __source: {
+        fileName: _jsxFileName$8,
+        lineNumber: 16,
+        columnNumber: 5
+      }
+    }, children));
+  }
+
+  MajooProvider.propTypes = {
+    theme: PropTypes__default["default"].object.isRequired,
+    children: PropTypes__default["default"].node.isRequired,
+    extendStyle: PropTypes__default["default"].object,
+    disableGlobalStyle: PropTypes__default["default"].bool
+  };
+
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  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.
+  ***************************************************************************** */
+
+  var __assign = function() {
+      __assign = Object.assign || function __assign(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+              s = arguments[i];
+              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+          }
+          return t;
+      };
+      return __assign.apply(this, arguments);
+  };
+
+  function __rest(s, e) {
+      var t = {};
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+          t[p] = s[p];
+      if (s != null && typeof Object.getOwnPropertySymbols === "function")
+          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+              if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                  t[p[i]] = s[p[i]];
+          }
+      return t;
+  }
+
+  var _jsxFileName$7 = "C:\\Project\\majoo-ui\\packages\\react\\src\\components\\alert\\AlertProvider.js";
+  const StatusContext = /*#__PURE__*/React.createContext();
+
+  const AlertProvider = ({
+    children
+  }) => {
+    const [statusAlert, setStatus] = React.useState();
+    return /*#__PURE__*/React__default["default"].createElement(StatusContext.Provider, {
+      value: {
+        statusAlert,
+        setStatus
+      },
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$7,
+        lineNumber: 8,
+        columnNumber: 5
+      }
+    }, children);
+  };
+
+  var _jsxFileName$6 = "C:\\Project\\majoo-ui\\packages\\react\\src\\components\\alert\\Alert.js";
+  const AlertStyle = styled(AlertDialog__namespace.Content, {
+    backgroundColor: 'white',
+    borderWidth: 0,
+    borderStyle: 'solid',
+    display: 'flex',
+    alignItems: 'center',
+    boxShadow: '$large',
+    width: '90vw',
+    maxHeight: '85vh',
+    padding: '$spacing-05',
+    '&:focus': {
+      outline: 'none'
+    },
+    variants: {
+      status: {
+        success: {
+          color: '$textPrimary',
+          backgroundColor: '$green50'
+        },
+        failed: {
+          color: '$textRed',
+          backgroundColor: '$red50'
+        },
+        process: {
+          color: '$textPrimary',
+          backgroundColor: '$secondary50'
+        },
+        news: {
+          color: '$textPrimary',
+          backgroundColor: '$blue50'
+        }
+      },
+      variant: {
+        subtle: {},
+        solid: {
+          color: '$textPrimary'
+        },
+        'left-accent': {
+          borderInlineStartWidth: '4px'
+        },
+        'top-accent': {
+          borderTopWidth: '4px'
+        }
+      }
+    },
+    compoundVariants: [{
+      status: 'success',
+      variant: 'solid',
+      css: {
+        color: '$white',
+        backgroundColor: '$colors$green500'
+      }
+    }, {
+      status: 'failed',
+      variant: 'solid',
+      css: {
+        color: '$white',
+        backgroundColor: '$colors$red500'
+      }
+    }, {
+      status: 'process',
+      variant: 'solid',
+      css: {
+        color: '$white',
+        backgroundColor: '$colors$secondary500'
+      }
+    }, {
+      status: 'news',
+      variant: 'solid',
+      css: {
+        color: '$white',
+        backgroundColor: '$colors$blue500'
+      }
+    }, {
+      status: 'success',
+      variant: 'left-accent',
+      css: {
+        borderInlineStartColor: '$colors$green500'
+      }
+    }, {
+      status: 'failed',
+      variant: 'left-accent',
+      css: {
+        borderInlineStartColor: '$colors$red500'
+      }
+    }, {
+      status: 'process',
+      variant: 'left-accent',
+      css: {
+        borderInlineStartColor: '$colors$secondary500'
+      }
+    }, {
+      status: 'news',
+      variant: 'left-accent',
+      css: {
+        borderInlineStartColor: '$colors$blue500'
+      }
+    }, {
+      status: 'success',
+      variant: 'top-accent',
+      css: {
+        borderTopColor: '$colors$green500'
+      }
+    }, {
+      status: 'failed',
+      variant: 'top-accent',
+      css: {
+        borderTopColor: '$colors$red500'
+      }
+    }, {
+      status: 'process',
+      variant: 'top-accent',
+      css: {
+        borderTopColor: '$colors$secondary500'
+      }
+    }, {
+      status: 'news',
+      variant: 'top-accent',
+      css: {
+        borderTopColor: '$colors$blue500'
+      }
+    }],
+    defaultVariants: {
+      status: 'success',
+      variant: 'subtle'
+    }
+  });
+  const AlertTitle = styled(AlertDialog__namespace.Title, {
+    fontWeight: 'bold',
+    fontSize: '$section-title'
+  });
+  const AlertDescription = styled(AlertDialog__namespace.Description, {
+    fontSize: '$section-sub-title'
+  });
+  const AlertBase = props => {
+    return /*#__PURE__*/React__default["default"].createElement(AlertProvider, {
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$6,
+        lineNumber: 158,
+        columnNumber: 5
+      }
+    }, /*#__PURE__*/React__default["default"].createElement(AlertDialog__namespace.Root, {
+      defaultOpen: true,
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$6,
+        lineNumber: 159,
+        columnNumber: 7
+      }
+    }, /*#__PURE__*/React__default["default"].createElement(AlertContent, _extends({}, props, {
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$6,
+        lineNumber: 160,
+        columnNumber: 9
+      }
+    }), props.children)));
+  };
+  const AlertContent = props => {
+    const {
+      setStatus
+    } = React.useContext(StatusContext);
+    React.useEffect(() => {
+      setStatus(props.status);
+    });
+    return /*#__PURE__*/React__default["default"].createElement(AlertStyle, _extends({}, props, {
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$6,
+        lineNumber: 171,
+        columnNumber: 10
+      }
+    }));
+  };
+  const AlertIconStyle = styled('div', {});
+  const AlertIconBase = props => {
+    const {
+      statusAlert
+    } = React.useContext(StatusContext);
+
+    const Icon = statusAlert => {
+      switch (statusAlert) {
+        case 'success':
+          return /*#__PURE__*/React__default["default"].createElement("span", {
+            __self: undefined,
+            __source: {
+              fileName: _jsxFileName$6,
+              lineNumber: 180,
+              columnNumber: 16
+            }
+          }, "\u2714");
+
+        case 'failed':
+          return /*#__PURE__*/React__default["default"].createElement("span", {
+            __self: undefined,
+            __source: {
+              fileName: _jsxFileName$6,
+              lineNumber: 182,
+              columnNumber: 16
+            }
+          }, "\u274C");
+
+        case 'news':
+          return /*#__PURE__*/React__default["default"].createElement("span", {
+            __self: undefined,
+            __source: {
+              fileName: _jsxFileName$6,
+              lineNumber: 184,
+              columnNumber: 16
+            }
+          }, "\u2139");
+
+        case 'process':
+          return /*#__PURE__*/React__default["default"].createElement("span", {
+            __self: undefined,
+            __source: {
+              fileName: _jsxFileName$6,
+              lineNumber: 186,
+              columnNumber: 16
+            }
+          }, "\u26A0");
+
+        default:
+          return /*#__PURE__*/React__default["default"].createElement("span", {
+            __self: undefined,
+            __source: {
+              fileName: _jsxFileName$6,
+              lineNumber: 188,
+              columnNumber: 16
+            }
+          }, "\u2714");
+      }
+    };
+
+    return /*#__PURE__*/React__default["default"].createElement(AlertIconStyle, _extends({}, props, {
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$6,
+        lineNumber: 191,
+        columnNumber: 10
+      }
+    }), Icon(statusAlert));
+  };
+  const AlertCloseTrigger = styled(AlertDialog__namespace.Cancel, {});
+  AlertStyle.propTypes = {
+    status: PropTypes__default["default"].oneOf(['success', 'failed', 'process', 'news']),
+    variant: PropTypes__default["default"].oneOf(['subtle', 'solid', 'left-accent', 'top-accent'])
+  };
+  AlertStyle.defaultProps = {
+    status: 'success',
+    variant: 'subtle'
+  };
+
+  var AlertIcon = function AlertIcon(props) {
+    return jsxRuntime.jsx(AlertIconBase, __assign({}, props), void 0);
+  };
+  var Alert = function Alert(props) {
+    return jsxRuntime.jsx(AlertBase, __assign({}, props), void 0);
+  };
+  AlertDescription.displayName = 'AlertDescription';
+  AlertTitle.displayName = 'AlertTitle';
+  AlertCloseTrigger.displayName = 'AlertCloseTrigger';
+
+  var _jsxFileName$5 = "C:\\Project\\majoo-ui\\packages\\react\\src\\components\\card\\Card.js";
+  const StyledTitle = styled('div', {
+    paddingBottom: "10px",
+    marginBottom: "10px",
+    fontWeight: 600,
+    borderBottom: '1px solid $bgBorder',
+    fontSize: '18px'
+  });
+  const CardComponent = styled('div', {
+    margin: '10px',
+    padding: '20px',
+    height: 'auto',
+    $$shadowColor: '$colors$gray200',
+    boxShadow: '0px 4px 16px $$shadowColor',
+    backgroundColor: '$white',
+    borderRadius: '$lg'
+  });
+  const Card = ({
+    className,
+    children,
+    color,
+    radius,
+    padding,
+    title,
+    background,
+    width,
+    textColor
+  }) => {
+    return /*#__PURE__*/React__default["default"].createElement(CardComponent, {
+      className: className,
+      css: {
+        width: width,
+        borderRadius: '$' + radius,
+        padding: padding,
+        background: background,
+        backgroundColor: '$' + color,
+        color: '$' + textColor
+      },
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$5,
+        lineNumber: 25,
+        columnNumber: 5
+      }
+    }, title !== '' ? /*#__PURE__*/React__default["default"].createElement(StyledTitle, {
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$5,
+        lineNumber: 27,
+        columnNumber: 9
+      }
+    }, title) : null, children);
+  };
+  Card.propTypes = {
+    className: PropTypes__default["default"].string,
+    color: PropTypes__default["default"].string,
+    textColor: PropTypes__default["default"].string,
+    radius: PropTypes__default["default"].string,
+    padding: PropTypes__default["default"].string,
+    title: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].element, PropTypes__default["default"].node]),
+    background: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].object]),
+    width: PropTypes__default["default"].string
+  };
+  Card.defaultProps = {
+    className: '',
+    color: 'white',
+    radius: 'lg',
+    padding: '20px',
+    title: '',
+    background: {}
+  };
+
+  const Text = styled('p', {
+    variants: {
+      variant: {
+        link: {
+          fontSize: '$link',
+          lineHeight: '$link',
+          letterSpacing: '$link',
+          fontWeight: '400'
+        },
+        contentButton: {
+          fontSize: '$content-button',
+          lineHeight: '$content-button',
+          letterSpacing: '$content-button',
+          fontWeight: '600'
+        },
+        placeholder: {
+          fontSize: '$placeholder',
+          lineHeight: '$placeholder',
+          letterSpacing: '$placeholder',
+          fontWeight: '400'
+        },
+        breadcrumb: {
+          fontSize: '$breadcrumb',
+          lineHeight: '$breadcrumb',
+          letterSpacing: '$breadcrumb',
+          fontWeight: '500'
+        },
+        label: {
+          fontSize: '$label',
+          lineHeight: '$label',
+          letterSpacing: '$label',
+          fontWeight: '500'
+        },
+        status: {
+          fontSize: '$status',
+          lineHeight: '$status',
+          letterSpacing: '$status',
+          fontWeight: '600'
+        },
+        helper: {
+          fontSize: '$helper',
+          lineHeight: '$helper',
+          letterSpacing: '$helper',
+          fontWeight: '400'
+        },
+        caption: {
+          fontSize: '$caption',
+          lineHeight: '$caption',
+          letterSpacing: '$caption',
+          fontWeight: '400'
+        }
+      },
+      color: {
+        primary: {
+          color: '$textPrimary'
+        },
+        secondary: {
+          color: '$textSecondary'
+        },
+        disable: {
+          color: '$textDisable'
+        },
+        green: {
+          color: '$textGreen'
+        },
+        red: {
+          color: '$textRed'
+        }
+      },
+      uppercase: {
+        true: {
+          textTransform: 'uppercase'
+        }
+      },
+      isTruncated: {
+        true: {
+          textOverflow: 'ellipsis',
+          overflow: 'hidden',
+          whiteSpace: 'nowrap'
+        }
+      }
+    },
+    defaultVariants: {
+      variant: 'label',
+      as: 'p'
+    }
+  });
+  const TextVariantsEnum = ['link', 'contentButton', 'placeholder', 'breadcrumb', 'label', 'status', 'helper', 'caption'];
+  Text.propTypes = {
+    variant: PropTypes__default["default"].oneOf(TextVariantsEnum),
+    uppercase: PropTypes__default["default"].bool,
+    isTruncated: PropTypes__default["default"].bool
+  };
+  Text.defaultProps = {
+    variant: 'label',
+    as: 'p'
+  };
+
+  Text.displayName = 'Text';
+
+  const Heading = styled(Text, {
+    variants: {
+      heading: {
+        h1: {
+          fontSize: '$heading-1',
+          lineHeight: '$heading-1',
+          letterSpacing: '$heading-1',
+          fontWeight: 'bold'
+        },
+        h2: {
+          fontSize: '$heading-2',
+          lineHeight: '$heading-2',
+          letterSpacing: '$heading-2',
+          fontWeight: '600'
+        },
+        h3: {
+          fontSize: '$heading-3',
+          lineHeight: '$heading-3',
+          letterSpacing: '$heading-3',
+          fontWeight: '600'
+        },
+        pageTitle: {
+          fontSize: '$page-title',
+          lineHeight: '$page-title',
+          letterSpacing: '$page-title',
+          fontWeight: '600'
+        },
+        sectionTitle: {
+          fontSize: '$section-title',
+          lineHeight: '$section-title',
+          letterSpacing: '$section-title',
+          fontWeight: '600'
+        },
+        sectionSubTitle: {
+          fontSize: '$section-sub-title',
+          lineHeight: '$section-sub-title',
+          letterSpacing: '$section-sub-title',
+          fontWeight: '600'
+        },
+        headerTabs: {
+          fontSize: '$header-tabs',
+          lineHeight: '$header-tabs',
+          letterSpacing: '$header-tabs',
+          fontWeight: '500'
+        },
+        headerTable: {
+          fontSize: '$header-table',
+          lineHeight: '$header-table',
+          letterSpacing: '$header-table',
+          fontWeight: '600'
+        }
+      }
+    },
+    defaultVariants: {
+      color: 'primary',
+      heading: 'h1',
+      as: 'h1'
+    }
+  });
+  Heading.propTypes = {
+    uppercase: PropTypes__default["default"].bool,
+    isTruncated: PropTypes__default["default"].bool,
+    heading: PropTypes__default["default"].oneOf(['h1', 'h2', 'h3', 'pageTitle', 'sectionTitle', 'sectionSubTitle', 'headerTabs', 'headerTable']),
+    color: PropTypes__default["default"].oneOf(['primary', 'secondary', 'disable', 'green', 'red'])
+  };
+  Heading.defaultProps = {
+    color: 'primary',
+    heading: 'h1',
+    as: 'h1'
+  };
+
+  Heading.displayName = "Heading";
+
+  const Paragraph = styled(Text, {
+    variants: {
+      paragraph: {
+        shortContentBold: {
+          fontSize: '$short-content-bold',
+          lineHeight: '$short-content-bold',
+          letterSpacing: '$short-content-bold',
+          fontWeight: '600',
+          color: '$textSecondary'
+        },
+        shortContentRegular: {
+          fontSize: '$short-content-regular',
+          lineHeight: '$short-content-regular',
+          letterSpacing: '$short-content-regular',
+          fontWeight: '400',
+          color: '$textSecondary'
+        },
+        longContentRegular: {
+          fontSize: '$long-content-regular',
+          lineHeight: '$long-content-regular',
+          letterSpacing: '$long-content-regular',
+          fontWeight: '400',
+          color: '$textSecondary'
+        }
+      }
+    },
+    defaultVariants: {
+      paragraph: 'shortContentRegular',
+      as: 'p'
+    }
+  });
+  Paragraph.propTypes = {
+    paragraph: PropTypes__default["default"].oneOf(['shortContentBold', 'shortContentRegular', 'longContentRegular']),
+    uppercase: PropTypes__default["default"].bool,
+    isTruncated: PropTypes__default["default"].bool
+  };
+  Paragraph.defaultProps = {
+    paragraph: 'shortContentRegular',
+    as: 'p'
+  };
+
+  Paragraph.displayName = 'Paragraph';
+
+  const _excluded$4 = ["children"];
+  var _jsxFileName$4 = "C:\\Project\\majoo-ui\\packages\\react\\src\\components\\breadcrumb\\Breadcrumb.js";
+  const BreadcrumbStyle = styled('nav', {
+    wordWrap: 'break-word',
+    '& li+li:before': {
+      marginInline: '0.5rem',
+      content: '/',
+      fontSize: 12,
+      color: '$textGreen'
+    },
+    '& li:last-child:before': {
+      color: '$textSecondary'
+    }
+  });
+  const Ol = styled('ol', {
+    margin: 0,
+    padding: 0
+  });
+  const BreadcrumbItem = styled('li', {
+    display: 'inline-flex',
+    alignItems: 'center'
+  });
+  const BreadcrumbLinkStyle = styled(Text, {
+    '&:hover': {
+      textDecoration: 'underline'
+    },
+    color: '$textGreen',
+    variants: {
+      isCurrentPage: {
+        true: {
+          color: '$textSecondary'
+        }
+      }
+    }
+  });
+  BreadcrumbLinkStyle.defaultProps = {
+    variant: 'breadcrumb',
+    as: 'a'
+  };
+
+  const BreadcrumbLinkBase = props => {
+    const aria = props.isCurrentPage && {
+      'aria-current': 'page'
+    };
+    return /*#__PURE__*/React__default["default"].createElement(BreadcrumbLinkStyle, _extends({}, props, aria, {
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$4,
+        lineNumber: 42,
+        columnNumber: 10
+      }
+    }));
+  };
+
+  const BreadcrumbBase = _ref => {
+    let {
+      children
+    } = _ref,
+        rest = _objectWithoutPropertiesLoose(_ref, _excluded$4);
+
+    return /*#__PURE__*/React__default["default"].createElement(BreadcrumbStyle, _extends({}, rest, {
+      "aria-label": "breadcrumb",
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$4,
+        lineNumber: 47,
+        columnNumber: 5
+      }
+    }), /*#__PURE__*/React__default["default"].createElement(Ol, {
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$4,
+        lineNumber: 48,
+        columnNumber: 7
+      }
+    }, children));
+  };
+
+  var Breadcrumb = function Breadcrumb(_a) {
+    var children = _a.children,
+        rest = __rest(_a, ["children"]);
+
+    return jsxRuntime.jsx(BreadcrumbBase, __assign({}, rest, {
+      children: children
+    }), void 0);
+  };
+
+  var BreadcrumbLink = function BreadcrumbLink(props) {
+    return jsxRuntime.jsx(BreadcrumbLinkBase, __assign({}, props), void 0);
+  };
+
+  const Badge = styled(Text, {
+    // Reset
+    alignItems: 'center',
+    appearance: 'none',
+    borderWidth: '0',
+    boxSizing: 'border-box',
+    display: 'inline-flex',
+    flexShrink: 0,
+    fontFamily: 'inherit',
+    fontSize: '$caption',
+    justifyContent: 'center',
+    lineHeight: '1',
+    verticalAlign: 'middle',
+    outline: 'none',
+    padding: '$spacing-01 $spacing-02',
+    textDecoration: 'none',
+    userSelect: 'none',
+    WebkitTapHighlightColor: 'rgba(0,0,0,0)',
+    '&:disabled': {
+      backgroundColor: '$btnDisable',
+      pointerEvents: 'none',
+      color: '$textDisable'
+    },
+    '&::before': {
+      boxSizing: 'border-box',
+      content: '""'
+    },
+    '&::after': {
+      boxSizing: 'border-box',
+      content: '""'
+    },
+    // Custom
+    borderRadius: '$md',
+    color: '$textPrimary',
+    whiteSpace: 'nowrap',
+    fontVariantNumeric: 'tabular-nums',
+    backgroundColor: '$btnDisable',
+    variants: {
+      outline: {
+        true: {
+          backgroundColor: 'transparent',
+          border: '1px solid Black'
+        }
+      }
+    }
+  });
+  Badge.defaultProps = {
+    as: 'span'
+  };
+
+  Badge.displayName = 'Badge';
+
+  const _excluded$3 = ["className", "img", "children", "onLoadingStatusChange", "delayMs", "onClick", "css"];
+  var _jsxFileName$3 = "C:\\Project\\majoo-ui\\packages\\react\\src\\components\\avatar\\Avatar.js";
+  const StyledAvatar = styled(AvatarPrimitive__namespace.Root, {
+    margin: '2px',
+    width: '32px',
+    height: '32px',
+    borderRadius: '100%',
+    backgroundColor: '$bgGray',
+    display: 'inline-flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+    verticalAlign: 'middle',
+    overflow: 'hidden',
+    userSelect: 'none'
+  });
+  const StyledImage$1 = styled(AvatarPrimitive__namespace.Image, {
+    width: '100%',
+    height: '100%',
+    objectFit: 'cover',
+    borderRadius: 'inherit'
+  });
+  const StyledFallback = styled(AvatarPrimitive__namespace.Fallback, {
+    width: '100%',
+    height: '100%',
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+    backgroundColor: '$bgGreen',
+    color: '$textWhite',
+    fontSize: '$label',
+    lineHeight: 1,
+    fontWeight: 600
+  });
+  function Avatar(_ref) {
+    let {
+      className,
+      img,
+      children,
+      onLoadingStatusChange,
+      delayMs,
+      onClick,
+      css
+    } = _ref,
+        props = _objectWithoutPropertiesLoose(_ref, _excluded$3);
+
+    return /*#__PURE__*/React__default["default"].createElement(StyledAvatar, _extends({
+      className: className,
+      onClick: onClick,
+      css: Object.assign({}, css)
+    }, props, {
+      __self: this,
+      __source: {
+        fileName: _jsxFileName$3,
+        lineNumber: 42,
+        columnNumber: 9
+      }
+    }), img !== "" ? /*#__PURE__*/React__default["default"].createElement(StyledImage$1, {
+      src: img,
+      alt: "images",
+      onLoadingStatusChange: onLoadingStatusChange,
+      __self: this,
+      __source: {
+        fileName: _jsxFileName$3,
+        lineNumber: 44,
+        columnNumber: 15
+      }
+    }) : null, /*#__PURE__*/React__default["default"].createElement(StyledFallback, {
+      delayMs: delayMs,
+      css: Object.assign({}, css),
+      __self: this,
+      __source: {
+        fileName: _jsxFileName$3,
+        lineNumber: 46,
+        columnNumber: 13
+      }
+    }, children));
+  }
+  Avatar.propTypes = {
+    className: PropTypes__default["default"].string,
+    img: PropTypes__default["default"].string,
+    onLoadingStatusChange: PropTypes__default["default"].func,
+    delayMs: PropTypes__default["default"].number,
+    onClick: PropTypes__default["default"].func
+  };
+  Avatar.defaultProps = {
+    delayMs: 0
+  };
+
+  const _excluded$2 = ["className", "src", "alt", "width", "height", "objectFit", "fallback"];
+  var _jsxFileName$2 = "C:\\Project\\majoo-ui\\packages\\react\\src\\components\\image\\Image.js";
+  const StyledImage = styled('img', {
+    margin: '5px',
+    display: 'inline-block',
+    alignItems: 'center',
+    justifyContent: 'center',
+    variants: {
+      rounded: {
+        true: {
+          borderRadius: '100%'
+        }
+      }
+    }
+  });
+  function Image(_ref) {
+    let {
+      className,
+      src,
+      alt,
+      width,
+      height,
+      objectFit,
+      fallback
+    } = _ref,
+        props = _objectWithoutPropertiesLoose(_ref, _excluded$2);
+
+    return /*#__PURE__*/React__default["default"].createElement(StyledImage, _extends({
+      className: className,
+      src: src,
+      alt: alt,
+      width: width,
+      height: height,
+      srcset: fallback,
+      css: Object.assign({
+        objectFit: objectFit
+      }, props.css)
+    }, props, {
+      __self: this,
+      __source: {
+        fileName: _jsxFileName$2,
+        lineNumber: 21,
+        columnNumber: 9
+      }
+    }));
+  }
+  Image.propTypes = {
+    className: PropTypes__default["default"].string,
+    src: PropTypes__default["default"].string,
+    alt: PropTypes__default["default"].string,
+    width: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].number]),
+    height: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].number]),
+    rounded: PropTypes__default["default"].bool,
+    objectFit: PropTypes__default["default"].string,
+    fallback: PropTypes__default["default"].string
+  };
+  Image.defaultProps = {
+    rounded: false
+  };
+
+  const _excluded$1 = ["children", "label", "color", "contentCss", "withClick"];
+  var _jsxFileName$1 = "C:\\Project\\majoo-ui\\packages\\react\\src\\components\\tooltip\\Tooltip.js";
+  const slideUpAndFade = keyframes({
+    '0%': {
+      opacity: 0,
+      transform: 'translateY(2px)'
+    },
+    '100%': {
+      opacity: 1,
+      transform: 'translateY(0)'
+    }
+  });
+  const slideRightAndFade = keyframes({
+    '0%': {
+      opacity: 0,
+      transform: 'translateX(-2px)'
+    },
+    '100%': {
+      opacity: 1,
+      transform: 'translateX(0)'
+    }
+  });
+  const slideDownAndFade = keyframes({
+    '0%': {
+      opacity: 0,
+      transform: 'translateY(-2px)'
+    },
+    '100%': {
+      opacity: 1,
+      transform: 'translateY(0)'
+    }
+  });
+  const slideLeftAndFade = keyframes({
+    '0%': {
+      opacity: 0,
+      transform: 'translateX(2px)'
+    },
+    '100%': {
+      opacity: 1,
+      transform: 'translateX(0)'
+    }
+  });
+  const StyledContent = styled(TooltipPrimitive__namespace.Content, {
+    borderRadius: 4,
+    padding: '10px 12px',
+    fontSize: '$helper',
+    letterSpacing: '$helper',
+    lineHeight: '$helper',
+    fontWeight: '400',
+    backgroundColor: '$white',
+    boxShadow: '$large',
+    '@media (prefers-reduced-motion: no-preference)': {
+      animationDuration: '400ms',
+      animationTimingFunction: 'cubic-bezier(0.16, 1, 0.3, 1)',
+      animationFillMode: 'forwards',
+      willChange: 'transform, opacity',
+      '&[data-state="delayed-open"]': {
+        '&[data-side="top"]': {
+          animationName: slideDownAndFade
+        },
+        '&[data-side="right"]': {
+          animationName: slideLeftAndFade
+        },
+        '&[data-side="bottom"]': {
+          animationName: slideUpAndFade
+        },
+        '&[data-side="left"]': {
+          animationName: slideRightAndFade
+        }
+      }
+    }
+  });
+  const StyledArrow = styled(TooltipPrimitive__namespace.Arrow, {
+    boxShadow: '$large'
+  });
+  const TooltipBase = styled(TooltipPrimitive__namespace.Root, {
+    defaultVariants: {
+      color: 'ligth'
+    }
+  }); // Exports
+  const TooltipTrigger = TooltipPrimitive__namespace.Trigger;
+  const dark = {
+    color: core.foundations.colors.white,
+    backgroundColor: core.foundations.colors.gray800
+  };
+  const ligth = {
+    color: core.foundations.colors.textPrimary,
+    backgroundColor: core.foundations.colors.bgWhite
+  };
+  const darkArrow = {
+    fill: core.foundations.colors.gray800
+  };
+  const lightArrow = {
+    fill: core.foundations.colors.bgWhite
+  };
+
+  const Tooltip = _ref => {
+    let {
+      children,
+      label,
+      color,
+      withClick
+    } = _ref,
+        rest = _objectWithoutPropertiesLoose(_ref, _excluded$1);
+
+    const [open, setOpen] = React.useState(false);
+    return /*#__PURE__*/React__default["default"].createElement(TooltipBase, _extends({}, rest, {
+      open: withClick ? open : undefined,
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$1,
+        lineNumber: 85,
+        columnNumber: 5
+      }
+    }), /*#__PURE__*/React__default["default"].createElement(TooltipTrigger, {
+      asChild: true,
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$1,
+        lineNumber: 86,
+        columnNumber: 7
+      }
+    }, /*#__PURE__*/React__default["default"].createElement("span", {
+      onClick: () => withClick ? setOpen(!open) : undefined,
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$1,
+        lineNumber: 87,
+        columnNumber: 9
+      }
+    }, children)), /*#__PURE__*/React__default["default"].createElement(StyledContent, {
+      sideOffset: 5,
+      css: color === 'dark' ? dark : ligth,
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$1,
+        lineNumber: 89,
+        columnNumber: 7
+      }
+    }, label, /*#__PURE__*/React__default["default"].createElement(StyledArrow, {
+      css: color === 'dark' ? darkArrow : lightArrow,
+      __self: undefined,
+      __source: {
+        fileName: _jsxFileName$1,
+        lineNumber: 91,
+        columnNumber: 9
+      }
+    })));
+  };
+
+  Tooltip.propTypes = {
+    children: PropTypes__default["default"].node,
+    label: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].node]),
+    color: PropTypes__default["default"].string
+  };
+  Tooltip.defaultProps = {
+    color: 'light'
+  };
+
+  const _excluded = ["className", "value", "max", "getValueLabel", "color", "size", "rounded", "width"];
+  var _jsxFileName = "C:\\Project\\majoo-ui\\packages\\react\\src\\components\\progress\\Progress.js";
+  const StyledProgress = react.styled(ProgressPrimitive__namespace.Root, {
+    position: 'relative',
+    overflow: 'hidden',
+    background: '$chartLightGreen',
+    width: 'auto',
+    height: '12px',
+    margin: '$spacing-04',
+    variants: {
+      rounded: {
+        true: {
+          borderRadius: '100px'
+        }
+      },
+      color: {
+        green: {
+          backgroundColor: '$chartLightGreen'
+        },
+        orange: {
+          backgroundColor: '$chartLightOrange'
+        },
+        blue: {
+          backgroundColor: '$chartLightBlue'
+        },
+        purple: {
+          backgroundColor: '$chartLightPurple'
+        },
+        yellow: {
+          backgroundColor: '$chartLightYellow'
+        },
+        red: {
+          backgroundColor: '$chartLightRed'
+        },
+        dark: {
+          backgroundColor: '$chartLightGray'
+        }
+      },
+      size: {
+        xs: {
+          height: '4px'
+        },
+        sm: {
+          height: '8px'
+        },
+        m: {
+          height: '12px'
+        },
+        l: {
+          height: '16px'
+        },
+        xl: {
+          height: '20px'
+        }
+      }
+    }
+  });
+  const StyledIndicator = react.styled(ProgressPrimitive__namespace.Indicator, {
+    backgroundColor: '$chartGreen',
+    height: '60%',
+    transition: 'width 660ms cubic-bezier(0.65, 0, 0.35, 1)',
+    variants: {
+      rounded: {
+        true: {
+          borderRadius: '100px'
+        }
+      },
+      color: {
+        green: {
+          backgroundColor: '$chartGreen'
+        },
+        orange: {
+          backgroundColor: '$chartOrange'
+        },
+        blue: {
+          backgroundColor: '$chartBlue'
+        },
+        purple: {
+          backgroundColor: '$chartPurple'
+        },
+        yellow: {
+          backgroundColor: '$chartYellow'
+        },
+        red: {
+          backgroundColor: '$chartRed'
+        },
+        dark: {
+          backgroundColor: '$chartDark'
+        }
+      },
+      size: {
+        xs: {
+          height: '100%'
+        },
+        sm: {
+          height: '100%'
+        },
+        m: {
+          margin: "2px 2px 0"
+        },
+        l: {
+          margin: "3px 3px 0"
+        },
+        xl: {
+          margin: "4px 4px 0"
+        }
+      }
+    }
+  });
+  function Progress(_ref) {
+    let {
+      className,
+      value,
+      max,
+      getValueLabel,
+      color,
+      size,
+      rounded,
+      width
+    } = _ref,
+        props = _objectWithoutPropertiesLoose(_ref, _excluded);
+
+    return /*#__PURE__*/React__default["default"].createElement(StyledProgress, _extends({
+      className: className,
+      value: value,
+      max: max,
+      getValueLabel: getValueLabel,
+      color: color,
+      size: size,
+      rounded: rounded,
+      css: Object.assign({
+        width: width
+      }, props.css)
+    }, props, {
+      __self: this,
+      __source: {
+        fileName: _jsxFileName,
+        lineNumber: 89,
+        columnNumber: 5
+      }
+    }), /*#__PURE__*/React__default["default"].createElement(StyledIndicator, {
+      color: color,
+      size: size,
+      rounded: rounded,
+      css: Object.assign({
+        width: `${value}%`
+      }, props.css),
+      __self: this,
+      __source: {
+        fileName: _jsxFileName,
+        lineNumber: 90,
+        columnNumber: 7
+      }
+    }));
+  }
+  Progress.propTypes = {
+    className: PropTypes__default["default"].string,
+    value: PropTypes__default["default"].number,
+    max: PropTypes__default["default"].number,
+    getValueLabel: PropTypes__default["default"].func,
+    color: PropTypes__default["default"].string,
+    size: PropTypes__default["default"].string,
+    rounded: PropTypes__default["default"].bool,
+    width: PropTypes__default["default"].oneOfType([PropTypes__default["default"].string, PropTypes__default["default"].number])
+  };
+  Progress.defaultProps = {
+    max: 100,
+    color: 'green',
+    size: 'm',
+    rounded: true
+  };
+
+  exports.Alert = Alert;
+  exports.AlertCloseTrigger = AlertCloseTrigger;
+  exports.AlertDescription = AlertDescription;
+  exports.AlertIcon = AlertIcon;
+  exports.AlertTitle = AlertTitle;
+  exports.Avatar = Avatar;
+  exports.Badge = Badge;
+  exports.Box = Box;
+  exports.BoxComponent = BoxComponent;
+  exports.Breadcrumb = Breadcrumb;
+  exports.BreadcrumbItem = BreadcrumbItem;
+  exports.BreadcrumbLink = BreadcrumbLink;
+  exports.Button = Button;
+  exports.Card = Card;
+  exports.CardComponent = CardComponent;
+  exports.Flex = Flex;
+  exports.Grid = Grid;
+  exports.GridItem = GridItem;
+  exports.Heading = Heading;
+  exports.Image = Image;
+  exports.MajooProvider = MajooProvider;
+  exports.Paragraph = Paragraph;
+  exports.Progress = Progress;
+  exports.StyledTitle = StyledTitle;
+  exports.Text = Text;
+  exports.ToastContext = ToastContext;
+  exports.Tooltip = Tooltip;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));