@popmenu/web-icons 0.33.0 → 0.36.0

package/build/index.js

@@ -28,10 +28,10 @@ var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
 var _path$1n;
 
-function _extends$2f() { _extends$2f = 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$2f.apply(this, arguments); }
+function _extends$2j() { _extends$2j = 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$2j.apply(this, arguments); }
 
 function SvgArrowUp(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2f({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2j({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -46,10 +46,10 @@ function SvgArrowUp(props) {
 
 var _path$1m;
 
-function _extends$2e() { _extends$2e = 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$2e.apply(this, arguments); }
+function _extends$2i() { _extends$2i = 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$2i.apply(this, arguments); }
 
 function SvgArrowDown(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2e({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2i({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -64,10 +64,10 @@ function SvgArrowDown(props) {
 
 var _path$1l;
 
-function _extends$2d() { _extends$2d = 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$2d.apply(this, arguments); }
+function _extends$2h() { _extends$2h = 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$2h.apply(this, arguments); }
 
 function SvgArrowLeft(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2d({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2h({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -82,10 +82,10 @@ function SvgArrowLeft(props) {
 
 var _path$1k;
 
-function _extends$2c() { _extends$2c = 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$2c.apply(this, arguments); }
+function _extends$2g() { _extends$2g = 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$2g.apply(this, arguments); }
 
 function SvgArrowRight(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2c({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2g({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -98,19 +98,19 @@ function SvgArrowRight(props) {
   })));
 }
 
-var _g$T;
+var _g$V;
 
-function _extends$2b() { _extends$2b = 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$2b.apply(this, arguments); }
+function _extends$2f() { _extends$2f = 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$2f.apply(this, arguments); }
 
 function SvgRefresh(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2b({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2f({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$T || (_g$T = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$V || (_g$V = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M15.333 2.667v4h-4M.667 13.334v-4h4"
@@ -121,10 +121,10 @@ function SvgRefresh(props) {
 
 var _path$1j;
 
-function _extends$2a() { _extends$2a = 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$2a.apply(this, arguments); }
+function _extends$2e() { _extends$2e = 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$2e.apply(this, arguments); }
 
 function SvgChevronDown(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2a({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2e({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -139,10 +139,10 @@ function SvgChevronDown(props) {
 
 var _path$1i;
 
-function _extends$29() { _extends$29 = 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$29.apply(this, arguments); }
+function _extends$2d() { _extends$2d = 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$2d.apply(this, arguments); }
 
 function SvgChevronUp(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$29({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2d({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -157,10 +157,10 @@ function SvgChevronUp(props) {
 
 var _path$1h;
 
-function _extends$28() { _extends$28 = 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$28.apply(this, arguments); }
+function _extends$2c() { _extends$2c = 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$2c.apply(this, arguments); }
 
 function SvgChevronLeft(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$28({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2c({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -175,10 +175,10 @@ function SvgChevronLeft(props) {
 
 var _path$1g;
 
-function _extends$27() { _extends$27 = 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$27.apply(this, arguments); }
+function _extends$2b() { _extends$2b = 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$2b.apply(this, arguments); }
 
 function SvgChevronRight(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$27({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2b({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -193,10 +193,10 @@ function SvgChevronRight(props) {
 
 var _path$1f;
 
-function _extends$26() { _extends$26 = 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$26.apply(this, arguments); }
+function _extends$2a() { _extends$2a = 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$2a.apply(this, arguments); }
 
 function SvgChevronsLeft(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$26({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2a({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -211,10 +211,10 @@ function SvgChevronsLeft(props) {
 
 var _path$1e;
 
-function _extends$25() { _extends$25 = 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$25.apply(this, arguments); }
+function _extends$29() { _extends$29 = 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$29.apply(this, arguments); }
 
 function SvgChevronsRight(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$25({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$29({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -227,19 +227,19 @@ function SvgChevronsRight(props) {
   })));
 }
 
-var _g$S;
+var _g$U;
 
-function _extends$24() { _extends$24 = 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$24.apply(this, arguments); }
+function _extends$28() { _extends$28 = 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$28.apply(this, arguments); }
 
 function SvgCircleArrowUp(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$24({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$28({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$S || (_g$S = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$U || (_g$U = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M8 14.667A6.667 6.667 0 108 1.334a6.667 6.667 0 000 13.333z"
@@ -248,19 +248,19 @@ function SvgCircleArrowUp(props) {
   }))));
 }
 
-var _g$R;
+var _g$T;
 
-function _extends$23() { _extends$23 = 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$23.apply(this, arguments); }
+function _extends$27() { _extends$27 = 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$27.apply(this, arguments); }
 
 function SvgCircleArrowDown(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$23({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$27({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$R || (_g$R = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$T || (_g$T = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M8 14.667A6.667 6.667 0 108 1.334a6.667 6.667 0 000 13.333z"
@@ -269,38 +269,38 @@ function SvgCircleArrowDown(props) {
   }))));
 }
 
-var _g$Q;
+var _g$S;
 
-function _extends$22() { _extends$22 = 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$22.apply(this, arguments); }
+function _extends$26() { _extends$26 = 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$26.apply(this, arguments); }
 
 function SvgCompare(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$22({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$26({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$Q || (_g$Q = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$S || (_g$S = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M15.333 10.666H8m2.667 2.667L8 10.667 10.667 8M.667 6H8M5.333 8.667L8 6 5.333 3.333"
   }))));
 }
 
-var _g$P;
+var _g$R;
 
-function _extends$21() { _extends$21 = 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$21.apply(this, arguments); }
+function _extends$25() { _extends$25 = 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$25.apply(this, arguments); }
 
 function SvgReply(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$21({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$25({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$P || (_g$P = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$R || (_g$R = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M6.333 10.667L3 7.333 6.333 4"
@@ -309,19 +309,19 @@ function SvgReply(props) {
   }))));
 }
 
-var _g$O;
+var _g$Q;
 
-function _extends$20() { _extends$20 = 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$20.apply(this, arguments); }
+function _extends$24() { _extends$24 = 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$24.apply(this, arguments); }
 
 function SvgForward(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$20({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$24({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$O || (_g$O = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$Q || (_g$Q = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M10.5 10.667l3.334-3.334L10.5 4"
@@ -332,10 +332,10 @@ function SvgForward(props) {
 
 var _path$1d;
 
-function _extends$1$() { _extends$1$ = 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$1$.apply(this, arguments); }
+function _extends$23() { _extends$23 = 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$23.apply(this, arguments); }
 
 function SvgNavigation(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1$({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$23({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -350,10 +350,10 @@ function SvgNavigation(props) {
 
 var _path$1c;
 
-function _extends$1_() { _extends$1_ = 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$1_.apply(this, arguments); }
+function _extends$22() { _extends$22 = 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$22.apply(this, arguments); }
 
 function SvgSort(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1_({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$22({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -366,19 +366,19 @@ function SvgSort(props) {
   })));
 }
 
-var _g$N;
+var _g$P;
 
-function _extends$1Z() { _extends$1Z = 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$1Z.apply(this, arguments); }
+function _extends$21() { _extends$21 = 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$21.apply(this, arguments); }
 
 function SvgUndo(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1Z({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$21({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$N || (_g$N = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$P || (_g$P = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M.667 2.667v4h4"
@@ -389,10 +389,10 @@ function SvgUndo(props) {
 
 var _path$1b;
 
-function _extends$1Y() { _extends$1Y = 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$1Y.apply(this, arguments); }
+function _extends$20() { _extends$20 = 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$20.apply(this, arguments); }
 
 function SvgBarChart(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1Y({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$20({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -407,10 +407,10 @@ function SvgBarChart(props) {
 
 var _path$1a;
 
-function _extends$1X() { _extends$1X = 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$1X.apply(this, arguments); }
+function _extends$1$() { _extends$1$ = 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$1$.apply(this, arguments); }
 
 function SvgBell(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1X({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1$({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -425,10 +425,10 @@ function SvgBell(props) {
 
 var _path$19;
 
-function _extends$1W() { _extends$1W = 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$1W.apply(this, arguments); }
+function _extends$1_() { _extends$1_ = 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$1_.apply(this, arguments); }
 
 function SvgBookmark(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1W({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1_({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -443,10 +443,10 @@ function SvgBookmark(props) {
 
 var _path$18;
 
-function _extends$1V() { _extends$1V = 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$1V.apply(this, arguments); }
+function _extends$1Z() { _extends$1Z = 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$1Z.apply(this, arguments); }
 
 function SvgCalendar(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1V({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1Z({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -461,10 +461,10 @@ function SvgCalendar(props) {
 
 var _path$17;
 
-function _extends$1U() { _extends$1U = 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$1U.apply(this, arguments); }
+function _extends$1Y() { _extends$1Y = 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$1Y.apply(this, arguments); }
 
 function SvgCartPlus(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1U({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1Y({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -479,10 +479,10 @@ function SvgCartPlus(props) {
 
 var _path$16;
 
-function _extends$1T() { _extends$1T = 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$1T.apply(this, arguments); }
+function _extends$1X() { _extends$1X = 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$1X.apply(this, arguments); }
 
 function SvgCart(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1T({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1X({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -497,10 +497,10 @@ function SvgCart(props) {
 
 var _path$15;
 
-function _extends$1S() { _extends$1S = 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$1S.apply(this, arguments); }
+function _extends$1W() { _extends$1W = 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$1W.apply(this, arguments); }
 
 function SvgCheck(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1S({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1W({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -513,19 +513,19 @@ function SvgCheck(props) {
   })));
 }
 
-var _g$M;
+var _g$O;
 
-function _extends$1R() { _extends$1R = 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$1R.apply(this, arguments); }
+function _extends$1V() { _extends$1V = 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$1V.apply(this, arguments); }
 
 function SvgCheckCircle(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1R({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1V({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$M || (_g$M = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$O || (_g$O = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M14.667 7.387V8a6.667 6.667 0 11-3.954-6.093"
@@ -534,19 +534,19 @@ function SvgCheckCircle(props) {
   }))));
 }
 
-var _g$L;
+var _g$N;
 
-function _extends$1Q() { _extends$1Q = 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$1Q.apply(this, arguments); }
+function _extends$1U() { _extends$1U = 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$1U.apply(this, arguments); }
 
 function SvgClock(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1Q({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1U({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$L || (_g$L = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$N || (_g$N = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M8 14.667A6.667 6.667 0 108 1.334a6.667 6.667 0 000 13.333z"
@@ -557,10 +557,10 @@ function SvgClock(props) {
 
 var _path$14;
 
-function _extends$1P() { _extends$1P = 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$1P.apply(this, arguments); }
+function _extends$1T() { _extends$1T = 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$1T.apply(this, arguments); }
 
 function SvgX(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1P({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1T({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -575,10 +575,10 @@ function SvgX(props) {
 
 var _path$13;
 
-function _extends$1O() { _extends$1O = 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$1O.apply(this, arguments); }
+function _extends$1S() { _extends$1S = 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$1S.apply(this, arguments); }
 
 function SvgXCircle(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1O({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1S({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -593,10 +593,10 @@ function SvgXCircle(props) {
 
 var _path$12;
 
-function _extends$1N() { _extends$1N = 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$1N.apply(this, arguments); }
+function _extends$1R() { _extends$1R = 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$1R.apply(this, arguments); }
 
 function SvgXOctagon(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1N({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1R({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -611,10 +611,10 @@ function SvgXOctagon(props) {
 
 var _path$11;
 
-function _extends$1M() { _extends$1M = 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$1M.apply(this, arguments); }
+function _extends$1Q() { _extends$1Q = 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$1Q.apply(this, arguments); }
 
 function SvgExternalLink(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1M({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1Q({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -627,19 +627,19 @@ function SvgExternalLink(props) {
   })));
 }
 
-var _g$K;
+var _g$M;
 
-function _extends$1L() { _extends$1L = 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$1L.apply(this, arguments); }
+function _extends$1P() { _extends$1P = 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$1P.apply(this, arguments); }
 
 function SvgEye(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1L({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1P({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$K || (_g$K = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$M || (_g$M = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M.667 8S3.333 2.667 8 2.667 15.333 8 15.333 8 12.667 13.333 8 13.333.667 8 .667 8z"
@@ -650,10 +650,10 @@ function SvgEye(props) {
 
 var _path$10;
 
-function _extends$1K() { _extends$1K = 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$1K.apply(this, arguments); }
+function _extends$1O() { _extends$1O = 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$1O.apply(this, arguments); }
 
 function SvgEyeOff(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1K({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1O({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -666,19 +666,19 @@ function SvgEyeOff(props) {
   })));
 }
 
-var _g$J;
+var _g$L;
 
-function _extends$1J() { _extends$1J = 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$1J.apply(this, arguments); }
+function _extends$1N() { _extends$1N = 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$1N.apply(this, arguments); }
 
 function SvgFace(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1J({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1N({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$J || (_g$J = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$L || (_g$L = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M8 14.667A6.667 6.667 0 108 1.334a6.667 6.667 0 000 13.333z"
@@ -689,10 +689,10 @@ function SvgFace(props) {
 
 var _path$$;
 
-function _extends$1I() { _extends$1I = 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$1I.apply(this, arguments); }
+function _extends$1M() { _extends$1M = 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$1M.apply(this, arguments); }
 
 function SvgFilter(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1I({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1M({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -705,19 +705,19 @@ function SvgFilter(props) {
   })));
 }
 
-var _g$I;
+var _g$K;
 
-function _extends$1H() { _extends$1H = 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$1H.apply(this, arguments); }
+function _extends$1L() { _extends$1L = 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$1L.apply(this, arguments); }
 
 function SvgGift(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1H({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1L({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$I || (_g$I = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$K || (_g$K = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M13.333 8v6.667H2.667V8m12-3.333H1.333V8h13.334V4.667zM8 14.666v-10m0 .001H5a1.667 1.667 0 010-3.333c2.333 0 3 3.333 3 3.333z"
@@ -728,10 +728,10 @@ function SvgGift(props) {
 
 var _path$_;
 
-function _extends$1G() { _extends$1G = 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$1G.apply(this, arguments); }
+function _extends$1K() { _extends$1K = 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$1K.apply(this, arguments); }
 
 function SvgHeart(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1G({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1K({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -744,19 +744,19 @@ function SvgHeart(props) {
   })));
 }
 
-var _g$H;
+var _g$J;
 
-function _extends$1F() { _extends$1F = 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$1F.apply(this, arguments); }
+function _extends$1J() { _extends$1J = 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$1J.apply(this, arguments); }
 
 function SvgHelp(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1F({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1J({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$H || (_g$H = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$J || (_g$J = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M8 14.667A6.667 6.667 0 108 1.334a6.667 6.667 0 000 13.333z"
@@ -765,19 +765,19 @@ function SvgHelp(props) {
   }))));
 }
 
-var _g$G;
+var _g$I;
 
-function _extends$1E() { _extends$1E = 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$1E.apply(this, arguments); }
+function _extends$1I() { _extends$1I = 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$1I.apply(this, arguments); }
 
 function SvgHome(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1E({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1I({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$G || (_g$G = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$I || (_g$I = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M2 6l6-4.667L14 6v7.334a1.333 1.333 0 01-1.333 1.333H3.333A1.333 1.333 0 012 13.334V6z"
@@ -788,10 +788,10 @@ function SvgHome(props) {
 
 var _path$Z;
 
-function _extends$1D() { _extends$1D = 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$1D.apply(this, arguments); }
+function _extends$1H() { _extends$1H = 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$1H.apply(this, arguments); }
 
 function SvgInfo(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1D({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1H({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -804,19 +804,19 @@ function SvgInfo(props) {
   })));
 }
 
-var _g$F;
+var _g$H;
 
-function _extends$1C() { _extends$1C = 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$1C.apply(this, arguments); }
+function _extends$1G() { _extends$1G = 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$1G.apply(this, arguments); }
 
 function SvgLock(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1C({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1G({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$F || (_g$F = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$H || (_g$H = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M12.667 7.333H3.333C2.597 7.333 2 7.93 2 8.668v4.667c0 .736.597 1.333 1.333 1.333h9.334c.736 0 1.333-.597 1.333-1.333V8.667c0-.737-.597-1.333-1.333-1.333z"
@@ -825,19 +825,19 @@ function SvgLock(props) {
   }))));
 }
 
-var _g$E;
+var _g$G;
 
-function _extends$1B() { _extends$1B = 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$1B.apply(this, arguments); }
+function _extends$1F() { _extends$1F = 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$1F.apply(this, arguments); }
 
 function SvgMail(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1B({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1F({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$E || (_g$E = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$G || (_g$G = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M2.667 2.667h10.666c.734 0 1.334.6 1.334 1.333v8c0 .733-.6 1.333-1.334 1.333H2.667c-.734 0-1.334-.6-1.334-1.333V4c0-.733.6-1.333 1.334-1.333z"
@@ -846,19 +846,19 @@ function SvgMail(props) {
   }))));
 }
 
-var _g$D;
+var _g$F;
 
-function _extends$1A() { _extends$1A = 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$1A.apply(this, arguments); }
+function _extends$1E() { _extends$1E = 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$1E.apply(this, arguments); }
 
 function SvgMapPin(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1A({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1E({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$D || (_g$D = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$F || (_g$F = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M14 6.667c0 4.666-6 8.666-6 8.666s-6-4-6-8.667a6 6 0 0112 0z"
@@ -869,10 +869,10 @@ function SvgMapPin(props) {
 
 var _path$Y;
 
-function _extends$1z() { _extends$1z = 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$1z.apply(this, arguments); }
+function _extends$1D() { _extends$1D = 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$1D.apply(this, arguments); }
 
 function SvgMaximize(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1z({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1D({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -887,10 +887,10 @@ function SvgMaximize(props) {
 
 var _path$X;
 
-function _extends$1y() { _extends$1y = 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$1y.apply(this, arguments); }
+function _extends$1C() { _extends$1C = 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$1C.apply(this, arguments); }
 
 function SvgMaximizeAlt(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1y({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1C({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -905,10 +905,10 @@ function SvgMaximizeAlt(props) {
 
 var _path$W;
 
-function _extends$1x() { _extends$1x = 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$1x.apply(this, arguments); }
+function _extends$1B() { _extends$1B = 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$1B.apply(this, arguments); }
 
 function SvgMessage(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1x({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1B({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -923,10 +923,10 @@ function SvgMessage(props) {
 
 var _path$V;
 
-function _extends$1w() { _extends$1w = 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$1w.apply(this, arguments); }
+function _extends$1A() { _extends$1A = 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$1A.apply(this, arguments); }
 
 function SvgMessageSquare(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1w({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1A({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -941,10 +941,10 @@ function SvgMessageSquare(props) {
 
 var _path$U;
 
-function _extends$1v() { _extends$1v = 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$1v.apply(this, arguments); }
+function _extends$1z() { _extends$1z = 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$1z.apply(this, arguments); }
 
 function SvgMinimizeAlt(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1v({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1z({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -959,10 +959,10 @@ function SvgMinimizeAlt(props) {
 
 var _path$T;
 
-function _extends$1u() { _extends$1u = 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$1u.apply(this, arguments); }
+function _extends$1y() { _extends$1y = 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$1y.apply(this, arguments); }
 
 function SvgMinus(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1u({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1y({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -977,10 +977,10 @@ function SvgMinus(props) {
 
 var _path$S;
 
-function _extends$1t() { _extends$1t = 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$1t.apply(this, arguments); }
+function _extends$1x() { _extends$1x = 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$1x.apply(this, arguments); }
 
 function SvgMinusCircle(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1t({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1x({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -995,10 +995,10 @@ function SvgMinusCircle(props) {
 
 var _path$R;
 
-function _extends$1s() { _extends$1s = 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$1s.apply(this, arguments); }
+function _extends$1w() { _extends$1w = 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$1w.apply(this, arguments); }
 
 function SvgMore(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1s({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1w({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1013,10 +1013,10 @@ function SvgMore(props) {
 
 var _path$Q;
 
-function _extends$1r() { _extends$1r = 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$1r.apply(this, arguments); }
+function _extends$1v() { _extends$1v = 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$1v.apply(this, arguments); }
 
 function SvgMoreHorizontal(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1r({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1v({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1031,10 +1031,10 @@ function SvgMoreHorizontal(props) {
 
 var _path$P;
 
-function _extends$1q() { _extends$1q = 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$1q.apply(this, arguments); }
+function _extends$1u() { _extends$1u = 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$1u.apply(this, arguments); }
 
 function SvgPlus(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1q({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1u({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1049,10 +1049,10 @@ function SvgPlus(props) {
 
 var _path$O;
 
-function _extends$1p() { _extends$1p = 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$1p.apply(this, arguments); }
+function _extends$1t() { _extends$1t = 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$1t.apply(this, arguments); }
 
 function SvgPlusCircle(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1p({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1t({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1065,19 +1065,19 @@ function SvgPlusCircle(props) {
   })));
 }
 
-var _g$C;
+var _g$E;
 
-function _extends$1o() { _extends$1o = 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$1o.apply(this, arguments); }
+function _extends$1s() { _extends$1s = 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$1s.apply(this, arguments); }
 
 function SvgProfile(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1o({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1s({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$C || (_g$C = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$E || (_g$E = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M3.333 12.667v0a2 2 0 012-2h5.334a2 2 0 012 2v0"
@@ -1098,10 +1098,10 @@ function SvgProfile(props) {
 
 var _path$N;
 
-function _extends$1n() { _extends$1n = 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$1n.apply(this, arguments); }
+function _extends$1r() { _extends$1r = 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$1r.apply(this, arguments); }
 
 function SvgSearch(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1n({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1r({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1116,10 +1116,10 @@ function SvgSearch(props) {
 
 var _path$M;
 
-function _extends$1m() { _extends$1m = 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$1m.apply(this, arguments); }
+function _extends$1q() { _extends$1q = 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$1q.apply(this, arguments); }
 
 function SvgSend(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1m({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1q({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1132,19 +1132,19 @@ function SvgSend(props) {
   })));
 }
 
-var _g$B;
+var _g$D;
 
-function _extends$1l() { _extends$1l = 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$1l.apply(this, arguments); }
+function _extends$1p() { _extends$1p = 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$1p.apply(this, arguments); }
 
 function SvgSettings(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1l({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1p({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$B || (_g$B = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$D || (_g$D = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M8 10a2 2 0 100-4 2 2 0 000 4z"
@@ -1155,10 +1155,10 @@ function SvgSettings(props) {
 
 var _path$L;
 
-function _extends$1k() { _extends$1k = 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$1k.apply(this, arguments); }
+function _extends$1o() { _extends$1o = 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$1o.apply(this, arguments); }
 
 function SvgShare(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1k({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1o({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1173,10 +1173,10 @@ function SvgShare(props) {
 
 var _path$K;
 
-function _extends$1j() { _extends$1j = 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$1j.apply(this, arguments); }
+function _extends$1n() { _extends$1n = 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$1n.apply(this, arguments); }
 
 function SvgShield(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1j({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1n({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1191,10 +1191,10 @@ function SvgShield(props) {
 
 var _path$J;
 
-function _extends$1i() { _extends$1i = 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$1i.apply(this, arguments); }
+function _extends$1m() { _extends$1m = 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$1m.apply(this, arguments); }
 
 function SvgSlash(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1i({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1m({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1209,10 +1209,10 @@ function SvgSlash(props) {
 
 var _path$I;
 
-function _extends$1h() { _extends$1h = 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$1h.apply(this, arguments); }
+function _extends$1l() { _extends$1l = 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$1l.apply(this, arguments); }
 
 function SvgTag(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1h({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1l({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1227,10 +1227,10 @@ function SvgTag(props) {
 
 var _path$H;
 
-function _extends$1g() { _extends$1g = 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$1g.apply(this, arguments); }
+function _extends$1k() { _extends$1k = 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$1k.apply(this, arguments); }
 
 function SvgThumbsUp(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1g({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1k({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1245,10 +1245,10 @@ function SvgThumbsUp(props) {
 
 var _path$G;
 
-function _extends$1f() { _extends$1f = 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$1f.apply(this, arguments); }
+function _extends$1j() { _extends$1j = 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$1j.apply(this, arguments); }
 
 function SvgThumbsDown(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1f({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1j({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1261,19 +1261,19 @@ function SvgThumbsDown(props) {
   })));
 }
 
-var _g$A;
+var _g$C;
 
-function _extends$1e() { _extends$1e = 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$1e.apply(this, arguments); }
+function _extends$1i() { _extends$1i = 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$1i.apply(this, arguments); }
 
 function SvgTrend(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1e({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1i({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$A || (_g$A = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$C || (_g$C = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M15.333 4L9 10.333 5.667 7l-5 5"
@@ -1282,19 +1282,19 @@ function SvgTrend(props) {
   }))));
 }
 
-var _g$z;
+var _g$B;
 
-function _extends$1d() { _extends$1d = 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$1d.apply(this, arguments); }
+function _extends$1h() { _extends$1h = 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$1h.apply(this, arguments); }
 
 function SvgTrendDown(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1d({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1h({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$z || (_g$z = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$B || (_g$B = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M15.333 12L9 5.667 5.667 9l-5-5"
@@ -1305,10 +1305,10 @@ function SvgTrendDown(props) {
 
 var _path$F;
 
-function _extends$1c() { _extends$1c = 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$1c.apply(this, arguments); }
+function _extends$1g() { _extends$1g = 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$1g.apply(this, arguments); }
 
 function SvgUser(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1c({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1g({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1323,10 +1323,10 @@ function SvgUser(props) {
 
 var _path$E;
 
-function _extends$1b() { _extends$1b = 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$1b.apply(this, arguments); }
+function _extends$1f() { _extends$1f = 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$1f.apply(this, arguments); }
 
 function SvgUsers(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1b({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1f({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1341,10 +1341,10 @@ function SvgUsers(props) {
 
 var _path$D;
 
-function _extends$1a() { _extends$1a = 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$1a.apply(this, arguments); }
+function _extends$1e() { _extends$1e = 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$1e.apply(this, arguments); }
 
 function SvgZap(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1a({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1e({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1357,19 +1357,19 @@ function SvgZap(props) {
   })));
 }
 
-var _g$y;
+var _g$A;
 
-function _extends$19() { _extends$19 = 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$19.apply(this, arguments); }
+function _extends$1d() { _extends$1d = 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$1d.apply(this, arguments); }
 
 function SvgDrag(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$19({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1d({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$y || (_g$y = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$A || (_g$A = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("circle", {
     cx: 6,
@@ -1400,10 +1400,10 @@ function SvgDrag(props) {
 
 var _path$C;
 
-function _extends$18() { _extends$18 = 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$18.apply(this, arguments); }
+function _extends$1c() { _extends$1c = 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$1c.apply(this, arguments); }
 
 function SvgError(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$18({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1c({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1418,10 +1418,10 @@ function SvgError(props) {
 
 var _path$B;
 
-function _extends$17() { _extends$17 = 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$17.apply(this, arguments); }
+function _extends$1b() { _extends$1b = 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$1b.apply(this, arguments); }
 
 function SvgWarning(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$17({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1b({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1436,10 +1436,10 @@ function SvgWarning(props) {
 
 var _path$A;
 
-function _extends$16() { _extends$16 = 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$16.apply(this, arguments); }
+function _extends$1a() { _extends$1a = 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$1a.apply(this, arguments); }
 
 function SvgShoppingBag(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$16({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1a({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1452,19 +1452,19 @@ function SvgShoppingBag(props) {
   })));
 }
 
-var _g$x;
+var _g$z;
 
-function _extends$15() { _extends$15 = 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$15.apply(this, arguments); }
+function _extends$19() { _extends$19 = 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$19.apply(this, arguments); }
 
 function SvgBold(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$15({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$19({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$x || (_g$x = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$z || (_g$z = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M4 2.667h5.333a2.667 2.667 0 110 5.333H4V2.667z"
@@ -1475,10 +1475,10 @@ function SvgBold(props) {
 
 var _path$z;
 
-function _extends$14() { _extends$14 = 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$14.apply(this, arguments); }
+function _extends$18() { _extends$18 = 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$18.apply(this, arguments); }
 
 function SvgCode(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$14({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$18({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1491,19 +1491,19 @@ function SvgCode(props) {
   })));
 }
 
-var _g$w;
+var _g$y;
 
-function _extends$13() { _extends$13 = 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$13.apply(this, arguments); }
+function _extends$17() { _extends$17 = 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$17.apply(this, arguments); }
 
 function SvgCopy(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$13({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$17({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$w || (_g$w = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$y || (_g$y = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M13.333 6h-6C6.597 6 6 6.597 6 7.333v6c0 .737.597 1.334 1.333 1.334h6c.737 0 1.334-.597 1.334-1.334v-6c0-.736-.597-1.333-1.334-1.333z"
@@ -1514,10 +1514,10 @@ function SvgCopy(props) {
 
 var _path$y;
 
-function _extends$12() { _extends$12 = 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$12.apply(this, arguments); }
+function _extends$16() { _extends$16 = 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$16.apply(this, arguments); }
 
 function SvgDownload(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$12({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$16({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1532,10 +1532,10 @@ function SvgDownload(props) {
 
 var _path$x;
 
-function _extends$11() { _extends$11 = 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$11.apply(this, arguments); }
+function _extends$15() { _extends$15 = 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$15.apply(this, arguments); }
 
 function SvgEdit(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$11({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$15({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1550,10 +1550,10 @@ function SvgEdit(props) {
 
 var _path$w;
 
-function _extends$10() { _extends$10 = 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$10.apply(this, arguments); }
+function _extends$14() { _extends$14 = 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$14.apply(this, arguments); }
 
 function SvgEditLine(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$10({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$14({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1566,19 +1566,19 @@ function SvgEditLine(props) {
   })));
 }
 
-var _g$v;
+var _g$x;
 
-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 _extends$13() { _extends$13 = 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$13.apply(this, arguments); }
 
 function SvgFile(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$$({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$13({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$v || (_g$v = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$x || (_g$x = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M8.667 1.333H4a1.333 1.333 0 00-1.333 1.334v10.666A1.333 1.333 0 004 14.668h8a1.333 1.333 0 001.333-1.333V6L8.667 1.333z"
@@ -1587,19 +1587,19 @@ function SvgFile(props) {
   }))));
 }
 
-var _g$u;
+var _g$w;
 
-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 _extends$12() { _extends$12 = 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$12.apply(this, arguments); }
 
 function SvgFilePlus(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$_({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$12({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$u || (_g$u = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$w || (_g$w = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M9.333 1.333H4a1.333 1.333 0 00-1.333 1.334v10.666A1.333 1.333 0 004 14.668h8a1.333 1.333 0 001.333-1.333v-8l-4-4z"
@@ -1608,19 +1608,19 @@ function SvgFilePlus(props) {
   }))));
 }
 
-var _g$t;
+var _g$v;
 
-function _extends$Z() { _extends$Z = 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$Z.apply(this, arguments); }
+function _extends$11() { _extends$11 = 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$11.apply(this, arguments); }
 
 function SvgFileText(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$Z({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$11({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$t || (_g$t = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$v || (_g$v = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M9.333 1.333H4a1.333 1.333 0 00-1.333 1.334v10.666A1.333 1.333 0 004 14.668h8a1.333 1.333 0 001.333-1.333v-8l-4-4z"
@@ -1629,19 +1629,19 @@ function SvgFileText(props) {
   }))));
 }
 
-var _g$s;
+var _g$u;
 
-function _extends$Y() { _extends$Y = 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$Y.apply(this, arguments); }
+function _extends$10() { _extends$10 = 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$10.apply(this, arguments); }
 
 function SvgImage(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$Y({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$10({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$s || (_g$s = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$u || (_g$u = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M12.667 2H3.333C2.597 2 2 2.597 2 3.333v9.334C2 13.403 2.597 14 3.333 14h9.334c.736 0 1.333-.597 1.333-1.333V3.333C14 2.597 13.403 2 12.667 2z"
@@ -1652,10 +1652,10 @@ function SvgImage(props) {
 
 var _path$v;
 
-function _extends$X() { _extends$X = 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$X.apply(this, arguments); }
+function _extends$$() { _extends$$ = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$$.apply(this, arguments); }
 
 function SvgLayout(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$X({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$$({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1668,19 +1668,19 @@ function SvgLayout(props) {
   })));
 }
 
-var _g$r;
+var _g$t;
 
-function _extends$W() { _extends$W = 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$W.apply(this, arguments); }
+function _extends$_() { _extends$_ = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$_.apply(this, arguments); }
 
 function SvgLink(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$W({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$_({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$r || (_g$r = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$t || (_g$t = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M6.667 8.666a3.333 3.333 0 005.026.36l2-2A3.333 3.333 0 008.98 2.313l-1.147 1.14"
@@ -1691,10 +1691,10 @@ function SvgLink(props) {
 
 var _path$u;
 
-function _extends$V() { _extends$V = 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$V.apply(this, arguments); }
+function _extends$Z() { _extends$Z = 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$Z.apply(this, arguments); }
 
 function SvgLinkHorizontal(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$V({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$Z({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1709,10 +1709,10 @@ function SvgLinkHorizontal(props) {
 
 var _path$t;
 
-function _extends$U() { _extends$U = 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$U.apply(this, arguments); }
+function _extends$Y() { _extends$Y = 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$Y.apply(this, arguments); }
 
 function SvgList(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$U({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$Y({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1727,10 +1727,10 @@ function SvgList(props) {
 
 var _path$s;
 
-function _extends$T() { _extends$T = 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$T.apply(this, arguments); }
+function _extends$X() { _extends$X = 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$X.apply(this, arguments); }
 
 function SvgMenu(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$T({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$X({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1745,10 +1745,10 @@ function SvgMenu(props) {
 
 var _path$r;
 
-function _extends$S() { _extends$S = 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$S.apply(this, arguments); }
+function _extends$W() { _extends$W = 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$W.apply(this, arguments); }
 
 function SvgPaperclip(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$S({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$W({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1761,19 +1761,19 @@ function SvgPaperclip(props) {
   })));
 }
 
-var _g$q;
+var _g$s;
 
-function _extends$R() { _extends$R = 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$R.apply(this, arguments); }
+function _extends$V() { _extends$V = 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$V.apply(this, arguments); }
 
 function SvgSave(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$R({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$V({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$q || (_g$q = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$s || (_g$s = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M12.667 14H3.333A1.334 1.334 0 012 12.667V3.333A1.333 1.333 0 013.333 2h7.334L14 5.333v7.334A1.334 1.334 0 0112.667 14z"
@@ -1784,10 +1784,10 @@ function SvgSave(props) {
 
 var _path$q;
 
-function _extends$Q() { _extends$Q = 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$Q.apply(this, arguments); }
+function _extends$U() { _extends$U = 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$U.apply(this, arguments); }
 
 function SvgTrash(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$Q({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$U({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1802,10 +1802,10 @@ function SvgTrash(props) {
 
 var _path$p;
 
-function _extends$P() { _extends$P = 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$P.apply(this, arguments); }
+function _extends$T() { _extends$T = 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$T.apply(this, arguments); }
 
 function SvgType(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$P({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$T({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1820,10 +1820,10 @@ function SvgType(props) {
 
 var _path$o;
 
-function _extends$O() { _extends$O = 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$O.apply(this, arguments); }
+function _extends$S() { _extends$S = 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$S.apply(this, arguments); }
 
 function SvgUpload(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$O({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$S({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1836,19 +1836,19 @@ function SvgUpload(props) {
   })));
 }
 
-var _g$p, _defs$6;
+var _g$r, _defs$6;
 
-function _extends$N() { _extends$N = 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$N.apply(this, arguments); }
+function _extends$R() { _extends$R = 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$R.apply(this, arguments); }
 
 function SvgUploadCloud(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$N({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$R({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$p || (_g$p = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$r || (_g$r = /*#__PURE__*/React__namespace.createElement("g", {
     clipPath: "url(#upload-cloud_svg__clip0_8_2783)",
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
@@ -1865,19 +1865,19 @@ function SvgUploadCloud(props) {
   })))));
 }
 
-var _g$o;
+var _g$q;
 
-function _extends$M() { _extends$M = 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$M.apply(this, arguments); }
+function _extends$Q() { _extends$Q = 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$Q.apply(this, arguments); }
 
 function SvgDatabase(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$M({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$Q({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$o || (_g$o = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$q || (_g$q = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M8 5.333c3.314 0 6-.895 6-2 0-1.104-2.686-2-6-2s-6 .896-6 2c0 1.105 2.686 2 6 2zM14 8c0 1.107-2.667 2-6 2s-6-.893-6-2"
@@ -1888,10 +1888,10 @@ function SvgDatabase(props) {
 
 var _path$n;
 
-function _extends$L() { _extends$L = 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$L.apply(this, arguments); }
+function _extends$P() { _extends$P = 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$P.apply(this, arguments); }
 
 function SvgMonitor(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$L({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$P({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1904,19 +1904,19 @@ function SvgMonitor(props) {
   })));
 }
 
-var _g$n;
+var _g$p;
 
-function _extends$K() { _extends$K = 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$K.apply(this, arguments); }
+function _extends$O() { _extends$O = 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$O.apply(this, arguments); }
 
 function SvgPrinter(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$K({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$O({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$n || (_g$n = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$p || (_g$p = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M4 6V1.333h8V6"
@@ -1929,10 +1929,10 @@ function SvgPrinter(props) {
 
 var _path$m;
 
-function _extends$J() { _extends$J = 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$J.apply(this, arguments); }
+function _extends$N() { _extends$N = 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$N.apply(this, arguments); }
 
 function SvgSmartphone(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$J({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$N({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1947,10 +1947,10 @@ function SvgSmartphone(props) {
 
 var _path$l;
 
-function _extends$I() { _extends$I = 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$I.apply(this, arguments); }
+function _extends$M() { _extends$M = 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$M.apply(this, arguments); }
 
 function SvgFacebook(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$I({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$M({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1965,10 +1965,10 @@ function SvgFacebook(props) {
 
 var _path$k;
 
-function _extends$H() { _extends$H = 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$H.apply(this, arguments); }
+function _extends$L() { _extends$L = 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$L.apply(this, arguments); }
 
 function SvgLinkedin(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$H({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$L({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1983,10 +1983,10 @@ function SvgLinkedin(props) {
 
 var _path$j;
 
-function _extends$G() { _extends$G = 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$G.apply(this, arguments); }
+function _extends$K() { _extends$K = 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$K.apply(this, arguments); }
 
 function SvgTwitter(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$G({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$K({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -1999,19 +1999,19 @@ function SvgTwitter(props) {
   })));
 }
 
-var _g$m;
+var _g$o;
 
-function _extends$F() { _extends$F = 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$F.apply(this, arguments); }
+function _extends$J() { _extends$J = 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$J.apply(this, arguments); }
 
 function SvgYoutube(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$F({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$J({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$m || (_g$m = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$o || (_g$o = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M15.027 4.28a1.853 1.853 0 00-1.294-1.334C12.587 2.667 8 2.667 8 2.667s-4.587 0-5.733.307A1.853 1.853 0 00.973 4.306a19.333 19.333 0 00-.306 3.527 19.318 19.318 0 00.306 3.553 1.854 1.854 0 001.294 1.28c1.146.307 5.733.307 5.733.307s4.587 0 5.733-.307a1.854 1.854 0 001.294-1.333 19.33 19.33 0 00.306-3.5 19.33 19.33 0 00-.306-3.553v0z"
@@ -2022,10 +2022,10 @@ function SvgYoutube(props) {
 
 var _path$i;
 
-function _extends$E() { _extends$E = 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$E.apply(this, arguments); }
+function _extends$I() { _extends$I = 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$I.apply(this, arguments); }
 
 function SvgPause(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$E({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$I({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2040,10 +2040,10 @@ function SvgPause(props) {
 
 var _path$h;
 
-function _extends$D() { _extends$D = 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$D.apply(this, arguments); }
+function _extends$H() { _extends$H = 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$H.apply(this, arguments); }
 
 function SvgPlay(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$D({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$H({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2056,19 +2056,19 @@ function SvgPlay(props) {
   })));
 }
 
-var _g$l;
+var _g$n;
 
-function _extends$C() { _extends$C = 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$C.apply(this, arguments); }
+function _extends$G() { _extends$G = 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$G.apply(this, arguments); }
 
 function SvgRepeat(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$C({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$G({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$l || (_g$l = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$n || (_g$n = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M11.333.667L14 3.333 11.333 6"
@@ -2081,10 +2081,10 @@ function SvgRepeat(props) {
 
 var _path$g;
 
-function _extends$B() { _extends$B = 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$B.apply(this, arguments); }
+function _extends$F() { _extends$F = 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$F.apply(this, arguments); }
 
 function SvgShuffle(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$B({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$F({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2099,10 +2099,10 @@ function SvgShuffle(props) {
 
 var _path$f;
 
-function _extends$A() { _extends$A = 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$A.apply(this, arguments); }
+function _extends$E() { _extends$E = 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$E.apply(this, arguments); }
 
 function SvgVolumeDown(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$A({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$E({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2117,10 +2117,10 @@ function SvgVolumeDown(props) {
 
 var _path$e;
 
-function _extends$z() { _extends$z = 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$z.apply(this, arguments); }
+function _extends$D() { _extends$D = 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$D.apply(this, arguments); }
 
 function SvgVolumeMute(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$z({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$D({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2135,10 +2135,10 @@ function SvgVolumeMute(props) {
 
 var _path$d;
 
-function _extends$y() { _extends$y = 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$y.apply(this, arguments); }
+function _extends$C() { _extends$C = 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$C.apply(this, arguments); }
 
 function SvgVolumeOff(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$y({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$C({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2153,10 +2153,10 @@ function SvgVolumeOff(props) {
 
 var _path$c;
 
-function _extends$x() { _extends$x = 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$x.apply(this, arguments); }
+function _extends$B() { _extends$B = 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$B.apply(this, arguments); }
 
 function SvgVolumeUp(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$x({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$B({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2169,19 +2169,19 @@ function SvgVolumeUp(props) {
   })));
 }
 
-var _g$k, _defs$5;
+var _g$m, _defs$5;
 
-function _extends$w() { _extends$w = 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$w.apply(this, arguments); }
+function _extends$A() { _extends$A = 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$A.apply(this, arguments); }
 
 function SvgDinning(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$w({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$A({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$k || (_g$k = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$m || (_g$m = /*#__PURE__*/React__namespace.createElement("g", {
     clipPath: "url(#dinning_svg__clip0_8_6317)",
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
@@ -2202,19 +2202,19 @@ function SvgDinning(props) {
   })))));
 }
 
-var _g$j;
+var _g$l;
 
-function _extends$v() { _extends$v = 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$v.apply(this, arguments); }
+function _extends$z() { _extends$z = 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$z.apply(this, arguments); }
 
 function SvgFoodDome(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$v({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$z({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$j || (_g$j = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$l || (_g$l = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M8 5.333c-4.518 0-5.882 3.556-6 5.334h12c-.118-1.778-1.482-5.333-6-5.333z"
@@ -2227,38 +2227,38 @@ function SvgFoodDome(props) {
   }))));
 }
 
-var _g$i;
+var _g$k;
 
-function _extends$u() { _extends$u = 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$u.apply(this, arguments); }
+function _extends$y() { _extends$y = 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$y.apply(this, arguments); }
 
 function SvgRestaurantMenu(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$u({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$y({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$i || (_g$i = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$k || (_g$k = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M11.334.667l-8 2.666h8V.667zM3.333 3.333h9.333v11.333H3.333zM5.333 8h5.334m-5.334 2.333h1m2 0h2.334"
   }))));
 }
 
-var _g$h;
+var _g$j;
 
-function _extends$t() { _extends$t = 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$t.apply(this, arguments); }
+function _extends$x() { _extends$x = 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$x.apply(this, arguments); }
 
 function SvgTruck(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$t({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$x({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$h || (_g$h = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$j || (_g$j = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M10.667 2h-10v8.667h10V2zm0 3.333h2.666l2 2v3.334h-4.666V5.334z"
@@ -2267,19 +2267,19 @@ function SvgTruck(props) {
   }))));
 }
 
-var _g$g;
+var _g$i;
 
-function _extends$s() { _extends$s = 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$s.apply(this, arguments); }
+function _extends$w() { _extends$w = 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$w.apply(this, arguments); }
 
 function SvgBook(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$s({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$w({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$g || (_g$g = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$i || (_g$i = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M2.667 13a1.666 1.666 0 011.666-1.666h9"
@@ -2290,10 +2290,10 @@ function SvgBook(props) {
 
 var _path$b;
 
-function _extends$r() { _extends$r = 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$r.apply(this, arguments); }
+function _extends$v() { _extends$v = 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$v.apply(this, arguments); }
 
 function SvgCircle(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$r({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$v({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2308,10 +2308,10 @@ function SvgCircle(props) {
 
 var _path$a;
 
-function _extends$q() { _extends$q = 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$q.apply(this, arguments); }
+function _extends$u() { _extends$u = 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$u.apply(this, arguments); }
 
 function SvgCreditCard(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$q({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$u({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2326,10 +2326,10 @@ function SvgCreditCard(props) {
 
 var _path$9;
 
-function _extends$p() { _extends$p = 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$p.apply(this, arguments); }
+function _extends$t() { _extends$t = 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$t.apply(this, arguments); }
 
 function SvgDollarSign(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$p({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$t({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2342,19 +2342,19 @@ function SvgDollarSign(props) {
   })));
 }
 
-var _g$f;
+var _g$h;
 
-function _extends$o() { _extends$o = 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$o.apply(this, arguments); }
+function _extends$s() { _extends$s = 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$s.apply(this, arguments); }
 
 function SvgGitMerge(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$o({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$s({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$f || (_g$f = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$h || (_g$h = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M12 14a2 2 0 100-4 2 2 0 000 4zM4 6a2 2 0 100-4 2 2 0 000 4z"
@@ -2363,19 +2363,19 @@ function SvgGitMerge(props) {
   }))));
 }
 
-var _g$e;
+var _g$g;
 
-function _extends$n() { _extends$n = 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$n.apply(this, arguments); }
+function _extends$r() { _extends$r = 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$r.apply(this, arguments); }
 
 function SvgGlobe(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$n({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$r({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$e || (_g$e = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$g || (_g$g = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M8 14.667A6.667 6.667 0 108 1.334a6.667 6.667 0 000 13.333zM1.333 8h13.334"
@@ -2386,10 +2386,10 @@ function SvgGlobe(props) {
 
 var _path$8;
 
-function _extends$m() { _extends$m = 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$m.apply(this, arguments); }
+function _extends$q() { _extends$q = 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$q.apply(this, arguments); }
 
 function SvgPercent(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$m({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$q({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2402,19 +2402,19 @@ function SvgPercent(props) {
   })));
 }
 
-var _g$d;
+var _g$f;
 
-function _extends$l() { _extends$l = 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$l.apply(this, arguments); }
+function _extends$p() { _extends$p = 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$p.apply(this, arguments); }
 
 function SvgServiceBell(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$l({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$p({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$d || (_g$d = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$f || (_g$f = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M8 5.333c-4.518 0-5.882 3.556-6 5.334h12c-.118-1.778-1.482-5.333-6-5.333zM14.667 12.666H1.333M8 11v1.5M8 5.333v-2m-1.333 0h2.666"
@@ -2423,10 +2423,10 @@ function SvgServiceBell(props) {
 
 var _path$7;
 
-function _extends$k() { _extends$k = 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$k.apply(this, arguments); }
+function _extends$o() { _extends$o = 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$o.apply(this, arguments); }
 
 function SvgStar(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$k({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$o({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2439,19 +2439,19 @@ function SvgStar(props) {
   })));
 }
 
-var _g$c;
+var _g$e;
 
-function _extends$j() { _extends$j = 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$j.apply(this, arguments); }
+function _extends$n() { _extends$n = 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$n.apply(this, arguments); }
 
 function SvgCamera(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$j({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$n({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$c || (_g$c = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$e || (_g$e = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M15.333 12.667A1.334 1.334 0 0114 14H2a1.334 1.334 0 01-1.333-1.333V5.333A1.333 1.333 0 012 4h2.667L6 2h4l1.333 2H14a1.333 1.333 0 011.333 1.333v7.334z"
@@ -2460,19 +2460,19 @@ function SvgCamera(props) {
   }))));
 }
 
-var _g$b;
+var _g$d;
 
-function _extends$i() { _extends$i = 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$i.apply(this, arguments); }
+function _extends$m() { _extends$m = 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$m.apply(this, arguments); }
 
 function SvgCameraPlus(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$i({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$m({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$b || (_g$b = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$d || (_g$d = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M15.333 13.879a1.152 1.152 0 01-1.151 1.151H3.818a1.152 1.152 0 01-1.151-1.151V7.545a1.152 1.152 0 011.151-1.151h2.303l1.152-1.728h3.454l1.152 1.728h2.303a1.152 1.152 0 011.151 1.151v6.334z"
@@ -2483,10 +2483,10 @@ function SvgCameraPlus(props) {
 
 var _path$6;
 
-function _extends$h() { _extends$h = 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$h.apply(this, arguments); }
+function _extends$l() { _extends$l = 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$l.apply(this, arguments); }
 
 function SvgPhone(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$h({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$l({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2501,10 +2501,10 @@ function SvgPhone(props) {
 
 var _path$5;
 
-function _extends$g() { _extends$g = 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$g.apply(this, arguments); }
+function _extends$k() { _extends$k = 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$k.apply(this, arguments); }
 
 function SvgWifi(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$g({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$k({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2517,19 +2517,19 @@ function SvgWifi(props) {
   })));
 }
 
-var _g$a;
+var _g$c;
 
-function _extends$f() { _extends$f = 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$f.apply(this, arguments); }
+function _extends$j() { _extends$j = 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$j.apply(this, arguments); }
 
 function SvgChefhat(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$f({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$j({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$a || (_g$a = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$c || (_g$c = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M5.333 8.334C5.333 9 6.527 10 8 10c1.473 0 2.666-1 2.666-1.666M10.667 8.733c.249.48 1.14.6 1.555.6 1.719 0 3.112-1.343 3.112-3 0-1.656-1.393-3-3.112-3h-1.244m.355.667a3.333 3.333 0 00-6.667 0"
@@ -2538,38 +2538,38 @@ function SvgChefhat(props) {
   }))));
 }
 
-var _g$9;
+var _g$b;
 
-function _extends$e() { _extends$e = 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$e.apply(this, arguments); }
+function _extends$i() { _extends$i = 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$i.apply(this, arguments); }
 
 function SvgChair(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$e({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$i({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$9 || (_g$9 = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$b || (_g$b = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M3.333 12v2.667m10-2.667v2.667M3.333 10c0-.975.79-1.765 1.765-1.765h6.47c.975 0 1.765.79 1.765 1.765v1.765h-10V10zm2-2V2.762c0-.789.2-1.429 1.052-1.429h3.896c.852 0 1.052.64 1.052 1.43V8"
   }))));
 }
 
-var _g$8;
+var _g$a;
 
-function _extends$d() { _extends$d = 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$d.apply(this, arguments); }
+function _extends$h() { _extends$h = 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$h.apply(this, arguments); }
 
 function SvgAccessibility(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$d({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$h({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$8 || (_g$8 = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$a || (_g$a = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M8.68 14.667l-.674-4-.657 4c-1.064 1.066-2.214.444-2.656 0l.666-6-1.353 1S1.673 10 2.04 7.334l3.3-2 2.667.333 2.667-.333 3.334 2s.332 2.333-2 2.333l-1.337-1 .666 6c-1.07 1.066-2.22.444-2.663 0"
@@ -2580,19 +2580,19 @@ function SvgAccessibility(props) {
   }))));
 }
 
-var _g$7;
+var _g$9;
 
-function _extends$c() { _extends$c = 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$c.apply(this, arguments); }
+function _extends$g() { _extends$g = 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$g.apply(this, arguments); }
 
 function SvgMegaphone(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$c({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$g({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$7 || (_g$7 = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$9 || (_g$9 = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M1.333 4.96v2.08c0 .899.728 1.627 1.626 1.627h2.602c1.983 0 4.887 1.171 7.055 2.238.924.455 2.05-.201 2.05-1.231V2.283c0-1.02-1.103-1.666-2.017-1.212-3.953 1.965-6.246 2.262-7.088 2.262H2.959c-.898 0-1.626.728-1.626 1.626z"
@@ -2603,10 +2603,10 @@ function SvgMegaphone(props) {
 
 var _path$4;
 
-function _extends$b() { _extends$b = 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$b.apply(this, arguments); }
+function _extends$f() { _extends$f = 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$f.apply(this, arguments); }
 
 function SvgColorFill(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$b({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$f({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2621,10 +2621,10 @@ function SvgColorFill(props) {
 
 var _path$3, _path2$1, _path3$1;
 
-function _extends$a() { _extends$a = 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$a.apply(this, arguments); }
+function _extends$e() { _extends$e = 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$e.apply(this, arguments); }
 
 function SvgTogoBag(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$a({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$e({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
@@ -2643,19 +2643,19 @@ function SvgTogoBag(props) {
   })));
 }
 
-var _g$6, _defs$4;
+var _g$8, _defs$4;
 
-function _extends$9() { _extends$9 = 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$9.apply(this, arguments); }
+function _extends$d() { _extends$d = 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$d.apply(this, arguments); }
 
 function SvgQrCode(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$9({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$d({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$6 || (_g$6 = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$8 || (_g$8 = /*#__PURE__*/React__namespace.createElement("g", {
     clipPath: "url(#qr-code_svg__clip0_516_1903)",
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
@@ -2674,19 +2674,19 @@ function SvgQrCode(props) {
   })))));
 }
 
-var _g$5;
+var _g$7;
 
-function _extends$8() { _extends$8 = 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$8.apply(this, arguments); }
+function _extends$c() { _extends$c = 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$c.apply(this, arguments); }
 
 function SvgInstagram(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$8({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$c({
     viewBox: "0 0 16 16",
     fill: "none",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     width: "1em",
     height: "1em"
-  }, props), _g$5 || (_g$5 = /*#__PURE__*/React__namespace.createElement("g", {
+  }, props), _g$7 || (_g$7 = /*#__PURE__*/React__namespace.createElement("g", {
     stroke: "currentColor"
   }, /*#__PURE__*/React__namespace.createElement("path", {
     d: "M11.333 1.333H4.667a3.333 3.333 0 00-3.334 3.334v6.667a3.333 3.333 0 003.334 3.333h6.666a3.333 3.333 0 003.334-3.333V4.667a3.333 3.333 0 00-3.334-3.333z"
@@ -2695,6 +2695,118 @@ function SvgInstagram(props) {
   }))));
 }
 
+var _g$6;
+
+function _extends$b() { _extends$b = 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$b.apply(this, arguments); }
+
+function SvgModGroupParent(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$b({
+    viewBox: "0 0 16 16",
+    fill: "none",
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    width: "1em",
+    height: "1em"
+  }, props), _g$6 || (_g$6 = /*#__PURE__*/React__namespace.createElement("g", {
+    fill: "currentColor"
+  }, /*#__PURE__*/React__namespace.createElement("circle", {
+    cx: 3,
+    cy: 8,
+    r: 2.5
+  }), /*#__PURE__*/React__namespace.createElement("circle", {
+    cx: 8,
+    cy: 3,
+    r: 2.5
+  }), /*#__PURE__*/React__namespace.createElement("circle", {
+    cx: 13,
+    cy: 8,
+    r: 2.5
+  }), /*#__PURE__*/React__namespace.createElement("circle", {
+    cx: 8,
+    cy: 13,
+    r: 2.5
+  }))));
+}
+
+var _g$5;
+
+function _extends$a() { _extends$a = 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$a.apply(this, arguments); }
+
+function SvgModGroupChild(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$a({
+    viewBox: "0 0 16 16",
+    fill: "none",
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    width: "1em",
+    height: "1em"
+  }, props), _g$5 || (_g$5 = /*#__PURE__*/React__namespace.createElement("g", {
+    stroke: "currentColor"
+  }, /*#__PURE__*/React__namespace.createElement("circle", {
+    cx: 3,
+    cy: 8,
+    r: 2
+  }), /*#__PURE__*/React__namespace.createElement("circle", {
+    cx: 8,
+    cy: 3,
+    r: 2
+  }), /*#__PURE__*/React__namespace.createElement("circle", {
+    cx: 13,
+    cy: 8,
+    r: 2
+  }), /*#__PURE__*/React__namespace.createElement("circle", {
+    cx: 8,
+    cy: 13,
+    r: 2
+  }))));
+}
+
+var _rect$1;
+
+function _extends$9() { _extends$9 = 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$9.apply(this, arguments); }
+
+function SvgModItemParent(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$9({
+    viewBox: "0 0 16 16",
+    fill: "none",
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    width: "1em",
+    height: "1em"
+  }, props), _rect$1 || (_rect$1 = /*#__PURE__*/React__namespace.createElement("rect", {
+    x: 8,
+    y: 1,
+    width: 10,
+    height: 10,
+    rx: 2,
+    transform: "rotate(45 8 1)",
+    fill: "currentColor"
+  })));
+}
+
+var _rect;
+
+function _extends$8() { _extends$8 = 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$8.apply(this, arguments); }
+
+function SvgModItemChild(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$8({
+    viewBox: "0 0 16 16",
+    fill: "none",
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    width: "1em",
+    height: "1em"
+  }, props), _rect || (_rect = /*#__PURE__*/React__namespace.createElement("rect", {
+    x: 8,
+    y: 2,
+    width: 9,
+    height: 9,
+    rx: 2,
+    transform: "rotate(45 8 2)",
+    stroke: "currentColor"
+  })));
+}
+
 var _path$2;
 
 function _extends$7() { _extends$7 = 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$7.apply(this, arguments); }
@@ -3004,6 +3116,10 @@ exports.MessageSquare = SvgMessageSquare;
 exports.MinimizeAlt = SvgMinimizeAlt;
 exports.Minus = SvgMinus;
 exports.MinusCircle = SvgMinusCircle;
+exports.ModGroupChild = SvgModGroupChild;
+exports.ModGroupParent = SvgModGroupParent;
+exports.ModItemChild = SvgModItemChild;
+exports.ModItemParent = SvgModItemParent;
 exports.Monitor = SvgMonitor;
 exports.More = SvgMore;
 exports.MoreHorizontal = SvgMoreHorizontal;