@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/manager/_manager-chunks/runtime-i-PDAHLR.js

@@ -0,0 +1,2493 @@
+import { a as __toCommonJS, i as __require, n as __esmMin, o as __toESM, t as __commonJSMin } from "./runtime-EITvVbkG.js";
+import { Sr as useState, er as Component, fr as useCallback, lr as init__storybook_global_react, nr as _storybook_global_react_default, rr as _storybook_global_react_exports } from "./runtime-Bly6WJLN.js";
+import { a as _inheritsLoose, i as init_wrapNativeSuper, l as _extends, o as init_inheritsLoose, r as _wrapNativeSuper, s as _assertThisInitialized } from "./runtime-eDVAYF7N.js";
+import { f as require_browser } from "./runtime-D94Vq3oR.js";
+//#region ../../node_modules/prop-types/lib/ReactPropTypesSecret.js
+/**
+* Copyright (c) 2013-present, Facebook, Inc.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_ReactPropTypesSecret = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+}));
+//#endregion
+//#region ../../node_modules/prop-types/factoryWithThrowingShims.js
+/**
+* Copyright (c) 2013-present, Facebook, Inc.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_factoryWithThrowingShims = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var ReactPropTypesSecret = require_ReactPropTypesSecret();
+	function emptyFunction() {}
+	function emptyFunctionWithReset() {}
+	emptyFunctionWithReset.resetWarningCache = emptyFunction;
+	module.exports = function() {
+		function shim(props, propName, componentName, location, propFullName, secret) {
+			if (secret === ReactPropTypesSecret) return;
+			var err = /* @__PURE__ */ new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types");
+			err.name = "Invariant Violation";
+			throw err;
+		}
+		shim.isRequired = shim;
+		function getShim() {
+			return shim;
+		}
+		var ReactPropTypes = {
+			array: shim,
+			bigint: shim,
+			bool: shim,
+			func: shim,
+			number: shim,
+			object: shim,
+			string: shim,
+			symbol: shim,
+			any: shim,
+			arrayOf: getShim,
+			element: shim,
+			elementType: shim,
+			instanceOf: getShim,
+			node: shim,
+			objectOf: getShim,
+			oneOf: getShim,
+			oneOfType: getShim,
+			shape: getShim,
+			exact: getShim,
+			checkPropTypes: emptyFunctionWithReset,
+			resetWarningCache: emptyFunction
+		};
+		ReactPropTypes.PropTypes = ReactPropTypes;
+		return ReactPropTypes;
+	};
+}));
+//#endregion
+//#region ../../node_modules/prop-types/index.js
+var require_prop_types = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_factoryWithThrowingShims()();
+}));
+//#endregion
+//#region ../../node_modules/react-fast-compare/index.js
+var require_react_fast_compare = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var hasElementType = typeof Element !== "undefined";
+	var hasMap = typeof Map === "function";
+	var hasSet = typeof Set === "function";
+	var hasArrayBuffer = typeof ArrayBuffer === "function" && !!ArrayBuffer.isView;
+	function equal(a, b) {
+		if (a === b) return true;
+		if (a && b && typeof a == "object" && typeof b == "object") {
+			if (a.constructor !== b.constructor) return false;
+			var length, i, keys;
+			if (Array.isArray(a)) {
+				length = a.length;
+				if (length != b.length) return false;
+				for (i = length; i-- !== 0;) if (!equal(a[i], b[i])) return false;
+				return true;
+			}
+			var it;
+			if (hasMap && a instanceof Map && b instanceof Map) {
+				if (a.size !== b.size) return false;
+				it = a.entries();
+				while (!(i = it.next()).done) if (!b.has(i.value[0])) return false;
+				it = a.entries();
+				while (!(i = it.next()).done) if (!equal(i.value[1], b.get(i.value[0]))) return false;
+				return true;
+			}
+			if (hasSet && a instanceof Set && b instanceof Set) {
+				if (a.size !== b.size) return false;
+				it = a.entries();
+				while (!(i = it.next()).done) if (!b.has(i.value[0])) return false;
+				return true;
+			}
+			if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+				length = a.length;
+				if (length != b.length) return false;
+				for (i = length; i-- !== 0;) if (a[i] !== b[i]) return false;
+				return true;
+			}
+			if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+			if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === "function" && typeof b.valueOf === "function") return a.valueOf() === b.valueOf();
+			if (a.toString !== Object.prototype.toString && typeof a.toString === "function" && typeof b.toString === "function") return a.toString() === b.toString();
+			keys = Object.keys(a);
+			length = keys.length;
+			if (length !== Object.keys(b).length) return false;
+			for (i = length; i-- !== 0;) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+			if (hasElementType && a instanceof Element) return false;
+			for (i = length; i-- !== 0;) {
+				if ((keys[i] === "_owner" || keys[i] === "__v" || keys[i] === "__o") && a.$$typeof) continue;
+				if (!equal(a[keys[i]], b[keys[i]])) return false;
+			}
+			return true;
+		}
+		return a !== a && b !== b;
+	}
+	module.exports = function isEqual(a, b) {
+		try {
+			return equal(a, b);
+		} catch (error) {
+			if ((error.message || "").match(/stack|recursion/i)) {
+				console.warn("react-fast-compare cannot handle circular refs");
+				return false;
+			}
+			throw error;
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/shallowequal/index.js
+var require_shallowequal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function shallowEqual(objA, objB, compare, compareContext) {
+		var ret = compare ? compare.call(compareContext, objA, objB) : void 0;
+		if (ret !== void 0) return !!ret;
+		if (objA === objB) return true;
+		if (typeof objA !== "object" || !objA || typeof objB !== "object" || !objB) return false;
+		var keysA = Object.keys(objA);
+		var keysB = Object.keys(objB);
+		if (keysA.length !== keysB.length) return false;
+		var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
+		for (var idx = 0; idx < keysA.length; idx++) {
+			var key = keysA[idx];
+			if (!bHasOwnProperty(key)) return false;
+			var valueA = objA[key];
+			var valueB = objB[key];
+			ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;
+			if (ret === false || ret === void 0 && valueA !== valueB) return false;
+		}
+		return true;
+	};
+}));
+//#endregion
+//#region ../../node_modules/react-helmet-async/lib/index.module.js
+function a() {
+	return a = Object.assign || function(t) {
+		for (var e = 1; e < arguments.length; e++) {
+			var r = arguments[e];
+			for (var n in r) Object.prototype.hasOwnProperty.call(r, n) && (t[n] = r[n]);
+		}
+		return t;
+	}, a.apply(this, arguments);
+}
+function s(t, e) {
+	t.prototype = Object.create(e.prototype), t.prototype.constructor = t, c(t, e);
+}
+function c(t, e) {
+	return c = Object.setPrototypeOf || function(t, e) {
+		return t.__proto__ = e, t;
+	}, c(t, e);
+}
+function u(t, e) {
+	if (null == t) return {};
+	var r, n, i = {}, o = Object.keys(t);
+	for (n = 0; n < o.length; n++) e.indexOf(r = o[n]) >= 0 || (i[r] = t[r]);
+	return i;
+}
+var import_prop_types, import_react_fast_compare, import_browser, import_shallowequal, l, p, f, d, h, m, y, T, g, b, v, A, C, O, S, E, I, P, w, x, L, j, M, k, H, N, R, D, U, q, Y, B, K, _, z, F, G, W;
+function init_index_module() {
+	return (init_index_module = __esmMin((() => {
+		init__storybook_global_react();
+		import_prop_types = /* @__PURE__ */ __toESM(require_prop_types());
+		import_react_fast_compare = /* @__PURE__ */ __toESM(require_react_fast_compare());
+		import_browser = /* @__PURE__ */ __toESM(require_browser());
+		import_shallowequal = /* @__PURE__ */ __toESM(require_shallowequal());
+		l = {
+			BASE: "base",
+			BODY: "body",
+			HEAD: "head",
+			HTML: "html",
+			LINK: "link",
+			META: "meta",
+			NOSCRIPT: "noscript",
+			SCRIPT: "script",
+			STYLE: "style",
+			TITLE: "title",
+			FRAGMENT: "Symbol(react.fragment)"
+		};
+		p = { rel: [
+			"amphtml",
+			"canonical",
+			"alternate"
+		] };
+		f = { type: ["application/ld+json"] };
+		d = {
+			charset: "",
+			name: ["robots", "description"],
+			property: [
+				"og:type",
+				"og:title",
+				"og:url",
+				"og:image",
+				"og:image:alt",
+				"og:description",
+				"twitter:url",
+				"twitter:title",
+				"twitter:description",
+				"twitter:image",
+				"twitter:image:alt",
+				"twitter:card",
+				"twitter:site"
+			]
+		};
+		h = Object.keys(l).map(function(t) {
+			return l[t];
+		});
+		m = {
+			accesskey: "accessKey",
+			charset: "charSet",
+			class: "className",
+			contenteditable: "contentEditable",
+			contextmenu: "contextMenu",
+			"http-equiv": "httpEquiv",
+			itemprop: "itemProp",
+			tabindex: "tabIndex"
+		};
+		y = Object.keys(m).reduce(function(t, e) {
+			return t[m[e]] = e, t;
+		}, {});
+		T = function(t, e) {
+			for (var r = t.length - 1; r >= 0; r -= 1) {
+				var n = t[r];
+				if (Object.prototype.hasOwnProperty.call(n, e)) return n[e];
+			}
+			return null;
+		};
+		g = function(t) {
+			var e = T(t, l.TITLE), r = T(t, "titleTemplate");
+			if (Array.isArray(e) && (e = e.join("")), r && e) return r.replace(/%s/g, function() {
+				return e;
+			});
+			var n = T(t, "defaultTitle");
+			return e || n || void 0;
+		};
+		b = function(t) {
+			return T(t, "onChangeClientState") || function() {};
+		};
+		v = function(t, e) {
+			return e.filter(function(e) {
+				return void 0 !== e[t];
+			}).map(function(e) {
+				return e[t];
+			}).reduce(function(t, e) {
+				return a({}, t, e);
+			}, {});
+		};
+		A = function(t, e) {
+			return e.filter(function(t) {
+				return void 0 !== t[l.BASE];
+			}).map(function(t) {
+				return t[l.BASE];
+			}).reverse().reduce(function(e, r) {
+				if (!e.length) for (var n = Object.keys(r), i = 0; i < n.length; i += 1) {
+					var o = n[i].toLowerCase();
+					if (-1 !== t.indexOf(o) && r[o]) return e.concat(r);
+				}
+				return e;
+			}, []);
+		};
+		C = function(t, e, r) {
+			var n = {};
+			return r.filter(function(e) {
+				return !!Array.isArray(e[t]) || (void 0 !== e[t] && console && "function" == typeof console.warn && console.warn("Helmet: " + t + " should be of type \"Array\". Instead found type \"" + typeof e[t] + "\""), !1);
+			}).map(function(e) {
+				return e[t];
+			}).reverse().reduce(function(t, r) {
+				var i = {};
+				r.filter(function(t) {
+					for (var r, o = Object.keys(t), a = 0; a < o.length; a += 1) {
+						var s = o[a], c = s.toLowerCase();
+						-1 === e.indexOf(c) || "rel" === r && "canonical" === t[r].toLowerCase() || "rel" === c && "stylesheet" === t[c].toLowerCase() || (r = c), -1 === e.indexOf(s) || "innerHTML" !== s && "cssText" !== s && "itemprop" !== s || (r = s);
+					}
+					if (!r || !t[r]) return !1;
+					var u = t[r].toLowerCase();
+					return n[r] || (n[r] = {}), i[r] || (i[r] = {}), !n[r][u] && (i[r][u] = !0, !0);
+				}).reverse().forEach(function(e) {
+					return t.push(e);
+				});
+				for (var o = Object.keys(i), s = 0; s < o.length; s += 1) {
+					var c = o[s];
+					n[c] = a({}, n[c], i[c]);
+				}
+				return t;
+			}, []).reverse();
+		};
+		O = function(t, e) {
+			if (Array.isArray(t) && t.length) {
+				for (var r = 0; r < t.length; r += 1) if (t[r][e]) return !0;
+			}
+			return !1;
+		};
+		S = function(t) {
+			return Array.isArray(t) ? t.join("") : t;
+		};
+		E = function(t, e) {
+			return Array.isArray(t) ? t.reduce(function(t, r) {
+				return function(t, e) {
+					for (var r = Object.keys(t), n = 0; n < r.length; n += 1) if (e[r[n]] && e[r[n]].includes(t[r[n]])) return !0;
+					return !1;
+				}(r, e) ? t.priority.push(r) : t.default.push(r), t;
+			}, {
+				priority: [],
+				default: []
+			}) : { default: t };
+		};
+		I = function(t, e) {
+			var r;
+			return a({}, t, ((r = {})[e] = void 0, r));
+		};
+		P = [
+			l.NOSCRIPT,
+			l.SCRIPT,
+			l.STYLE
+		];
+		w = function(t, e) {
+			return void 0 === e && (e = !0), !1 === e ? String(t) : String(t).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+		};
+		x = function(t) {
+			return Object.keys(t).reduce(function(e, r) {
+				var n = void 0 !== t[r] ? r + "=\"" + t[r] + "\"" : "" + r;
+				return e ? e + " " + n : n;
+			}, "");
+		};
+		L = function(t, e) {
+			return void 0 === e && (e = {}), Object.keys(t).reduce(function(e, r) {
+				return e[m[r] || r] = t[r], e;
+			}, e);
+		};
+		j = function(e, r) {
+			return r.map(function(r, n) {
+				var i, o = ((i = { key: n })["data-rh"] = !0, i);
+				return Object.keys(r).forEach(function(t) {
+					var e = m[t] || t;
+					"innerHTML" === e || "cssText" === e ? o.dangerouslySetInnerHTML = { __html: r.innerHTML || r.cssText } : o[e] = r[t];
+				}), _storybook_global_react_default.createElement(e, o);
+			});
+		};
+		M = function(e, r, n) {
+			switch (e) {
+				case l.TITLE: return {
+					toComponent: function() {
+						return n = r.titleAttributes, (i = { key: e = r.title })["data-rh"] = !0, o = L(n, i), [_storybook_global_react_default.createElement(l.TITLE, o, e)];
+						var e, n, i, o;
+					},
+					toString: function() {
+						return function(t, e, r, n) {
+							var i = x(r), o = S(e);
+							return i ? "<" + t + " data-rh=\"true\" " + i + ">" + w(o, n) + "</" + t + ">" : "<" + t + " data-rh=\"true\">" + w(o, n) + "</" + t + ">";
+						}(e, r.title, r.titleAttributes, n);
+					}
+				};
+				case "bodyAttributes":
+				case "htmlAttributes": return {
+					toComponent: function() {
+						return L(r);
+					},
+					toString: function() {
+						return x(r);
+					}
+				};
+				default: return {
+					toComponent: function() {
+						return j(e, r);
+					},
+					toString: function() {
+						return function(t, e, r) {
+							return e.reduce(function(e, n) {
+								var i = Object.keys(n).filter(function(t) {
+									return !("innerHTML" === t || "cssText" === t);
+								}).reduce(function(t, e) {
+									var i = void 0 === n[e] ? e : e + "=\"" + w(n[e], r) + "\"";
+									return t ? t + " " + i : i;
+								}, ""), o = n.innerHTML || n.cssText || "", a = -1 === P.indexOf(t);
+								return e + "<" + t + " data-rh=\"true\" " + i + (a ? "/>" : ">" + o + "</" + t + ">");
+							}, "");
+						}(e, r, n);
+					}
+				};
+			}
+		};
+		k = function(t) {
+			var e = t.baseTag, r = t.bodyAttributes, n = t.encode, i = t.htmlAttributes, o = t.noscriptTags, a = t.styleTags, s = t.title, c = void 0 === s ? "" : s, u = t.titleAttributes, h = t.linkTags, m = t.metaTags, y = t.scriptTags, T = {
+				toComponent: function() {},
+				toString: function() {
+					return "";
+				}
+			};
+			if (t.prioritizeSeoTags) {
+				var g = function(t) {
+					var e = t.linkTags, r = t.scriptTags, n = t.encode, i = E(t.metaTags, d), o = E(e, p), a = E(r, f);
+					return {
+						priorityMethods: {
+							toComponent: function() {
+								return [].concat(j(l.META, i.priority), j(l.LINK, o.priority), j(l.SCRIPT, a.priority));
+							},
+							toString: function() {
+								return M(l.META, i.priority, n) + " " + M(l.LINK, o.priority, n) + " " + M(l.SCRIPT, a.priority, n);
+							}
+						},
+						metaTags: i.default,
+						linkTags: o.default,
+						scriptTags: a.default
+					};
+				}(t);
+				T = g.priorityMethods, h = g.linkTags, m = g.metaTags, y = g.scriptTags;
+			}
+			return {
+				priority: T,
+				base: M(l.BASE, e, n),
+				bodyAttributes: M("bodyAttributes", r, n),
+				htmlAttributes: M("htmlAttributes", i, n),
+				link: M(l.LINK, h, n),
+				meta: M(l.META, m, n),
+				noscript: M(l.NOSCRIPT, o, n),
+				script: M(l.SCRIPT, y, n),
+				style: M(l.STYLE, a, n),
+				title: M(l.TITLE, {
+					title: c,
+					titleAttributes: u
+				}, n)
+			};
+		};
+		H = [];
+		N = function(t, e) {
+			var r = this;
+			void 0 === e && (e = "undefined" != typeof document), this.instances = [], this.value = {
+				setHelmet: function(t) {
+					r.context.helmet = t;
+				},
+				helmetInstances: {
+					get: function() {
+						return r.canUseDOM ? H : r.instances;
+					},
+					add: function(t) {
+						(r.canUseDOM ? H : r.instances).push(t);
+					},
+					remove: function(t) {
+						var e = (r.canUseDOM ? H : r.instances).indexOf(t);
+						(r.canUseDOM ? H : r.instances).splice(e, 1);
+					}
+				}
+			}, this.context = t, this.canUseDOM = e, e || (t.helmet = k({
+				baseTag: [],
+				bodyAttributes: {},
+				encodeSpecialCharacters: !0,
+				htmlAttributes: {},
+				linkTags: [],
+				metaTags: [],
+				noscriptTags: [],
+				scriptTags: [],
+				styleTags: [],
+				title: "",
+				titleAttributes: {}
+			}));
+		};
+		R = _storybook_global_react_default.createContext({});
+		D = import_prop_types.default.shape({
+			setHelmet: import_prop_types.default.func,
+			helmetInstances: import_prop_types.default.shape({
+				get: import_prop_types.default.func,
+				add: import_prop_types.default.func,
+				remove: import_prop_types.default.func
+			})
+		});
+		U = "undefined" != typeof document;
+		q = /*#__PURE__*/ function(e) {
+			function r(t) {
+				var n;
+				return (n = e.call(this, t) || this).helmetData = new N(n.props.context, r.canUseDOM), n;
+			}
+			return s(r, e), r.prototype.render = function() {
+				/*#__PURE__*/ return _storybook_global_react_default.createElement(R.Provider, { value: this.helmetData.value }, this.props.children);
+			}, r;
+		}(Component);
+		q.canUseDOM = U, q.propTypes = {
+			context: import_prop_types.default.shape({ helmet: import_prop_types.default.shape() }),
+			children: import_prop_types.default.node.isRequired
+		}, q.defaultProps = { context: {} }, q.displayName = "HelmetProvider";
+		Y = function(t, e) {
+			var r, n = document.head || document.querySelector(l.HEAD), i = n.querySelectorAll(t + "[data-rh]"), o = [].slice.call(i), a = [];
+			return e && e.length && e.forEach(function(e) {
+				var n = document.createElement(t);
+				for (var i in e) Object.prototype.hasOwnProperty.call(e, i) && ("innerHTML" === i ? n.innerHTML = e.innerHTML : "cssText" === i ? n.styleSheet ? n.styleSheet.cssText = e.cssText : n.appendChild(document.createTextNode(e.cssText)) : n.setAttribute(i, void 0 === e[i] ? "" : e[i]));
+				n.setAttribute("data-rh", "true"), o.some(function(t, e) {
+					return r = e, n.isEqualNode(t);
+				}) ? o.splice(r, 1) : a.push(n);
+			}), o.forEach(function(t) {
+				return t.parentNode.removeChild(t);
+			}), a.forEach(function(t) {
+				return n.appendChild(t);
+			}), {
+				oldTags: o,
+				newTags: a
+			};
+		};
+		B = function(t, e) {
+			var r = document.getElementsByTagName(t)[0];
+			if (r) {
+				for (var n = r.getAttribute("data-rh"), i = n ? n.split(",") : [], o = [].concat(i), a = Object.keys(e), s = 0; s < a.length; s += 1) {
+					var c = a[s], u = e[c] || "";
+					r.getAttribute(c) !== u && r.setAttribute(c, u), -1 === i.indexOf(c) && i.push(c);
+					var l = o.indexOf(c);
+					-1 !== l && o.splice(l, 1);
+				}
+				for (var p = o.length - 1; p >= 0; p -= 1) r.removeAttribute(o[p]);
+				i.length === o.length ? r.removeAttribute("data-rh") : r.getAttribute("data-rh") !== a.join(",") && r.setAttribute("data-rh", a.join(","));
+			}
+		};
+		K = function(t, e) {
+			var r = t.baseTag, n = t.htmlAttributes, i = t.linkTags, o = t.metaTags, a = t.noscriptTags, s = t.onChangeClientState, c = t.scriptTags, u = t.styleTags, p = t.title, f = t.titleAttributes;
+			B(l.BODY, t.bodyAttributes), B(l.HTML, n), function(t, e) {
+				void 0 !== t && document.title !== t && (document.title = S(t)), B(l.TITLE, e);
+			}(p, f);
+			var d = {
+				baseTag: Y(l.BASE, r),
+				linkTags: Y(l.LINK, i),
+				metaTags: Y(l.META, o),
+				noscriptTags: Y(l.NOSCRIPT, a),
+				scriptTags: Y(l.SCRIPT, c),
+				styleTags: Y(l.STYLE, u)
+			}, h = {}, m = {};
+			Object.keys(d).forEach(function(t) {
+				var e = d[t], r = e.newTags, n = e.oldTags;
+				r.length && (h[t] = r), n.length && (m[t] = d[t].oldTags);
+			}), e && e(), s(t, h, m);
+		};
+		_ = null;
+		z = /*#__PURE__*/ function(t) {
+			function e() {
+				for (var e, r = arguments.length, n = new Array(r), i = 0; i < r; i++) n[i] = arguments[i];
+				return (e = t.call.apply(t, [this].concat(n)) || this).rendered = !1, e;
+			}
+			s(e, t);
+			var r = e.prototype;
+			return r.shouldComponentUpdate = function(t) {
+				return !(0, import_shallowequal.default)(t, this.props);
+			}, r.componentDidUpdate = function() {
+				this.emitChange();
+			}, r.componentWillUnmount = function() {
+				this.props.context.helmetInstances.remove(this), this.emitChange();
+			}, r.emitChange = function() {
+				var t, e, r = this.props.context, n = r.setHelmet, i = null, o = (t = r.helmetInstances.get().map(function(t) {
+					var e = a({}, t.props);
+					return delete e.context, e;
+				}), {
+					baseTag: A(["href"], t),
+					bodyAttributes: v("bodyAttributes", t),
+					defer: T(t, "defer"),
+					encode: T(t, "encodeSpecialCharacters"),
+					htmlAttributes: v("htmlAttributes", t),
+					linkTags: C(l.LINK, ["rel", "href"], t),
+					metaTags: C(l.META, [
+						"name",
+						"charset",
+						"http-equiv",
+						"property",
+						"itemprop"
+					], t),
+					noscriptTags: C(l.NOSCRIPT, ["innerHTML"], t),
+					onChangeClientState: b(t),
+					scriptTags: C(l.SCRIPT, ["src", "innerHTML"], t),
+					styleTags: C(l.STYLE, ["cssText"], t),
+					title: g(t),
+					titleAttributes: v("titleAttributes", t),
+					prioritizeSeoTags: O(t, "prioritizeSeoTags")
+				});
+				q.canUseDOM ? (e = o, _ && cancelAnimationFrame(_), e.defer ? _ = requestAnimationFrame(function() {
+					K(e, function() {
+						_ = null;
+					});
+				}) : (K(e), _ = null)) : k && (i = k(o)), n(i);
+			}, r.init = function() {
+				this.rendered || (this.rendered = !0, this.props.context.helmetInstances.add(this), this.emitChange());
+			}, r.render = function() {
+				return this.init(), null;
+			}, e;
+		}(Component);
+		z.propTypes = { context: D.isRequired }, z.displayName = "HelmetDispatcher";
+		F = ["children"];
+		G = ["children"];
+		W = /*#__PURE__*/ function(e) {
+			function r() {
+				return e.apply(this, arguments) || this;
+			}
+			s(r, e);
+			var o = r.prototype;
+			return o.shouldComponentUpdate = function(t) {
+				return !(0, import_react_fast_compare.default)(I(this.props, "helmetData"), I(t, "helmetData"));
+			}, o.mapNestedChildrenToProps = function(t, e) {
+				if (!e) return null;
+				switch (t.type) {
+					case l.SCRIPT:
+					case l.NOSCRIPT: return { innerHTML: e };
+					case l.STYLE: return { cssText: e };
+					default: throw new Error("<" + t.type + " /> elements are self-closing and can not contain children. Refer to our API for more information.");
+				}
+			}, o.flattenArrayTypeChildren = function(t) {
+				var e, r = t.child, n = t.arrayTypeChildren;
+				return a({}, n, ((e = {})[r.type] = [].concat(n[r.type] || [], [a({}, t.newChildProps, this.mapNestedChildrenToProps(r, t.nestedChildren))]), e));
+			}, o.mapObjectTypeChildren = function(t) {
+				var e, r, n = t.child, i = t.newProps, o = t.newChildProps, s = t.nestedChildren;
+				switch (n.type) {
+					case l.TITLE: return a({}, i, ((e = {})[n.type] = s, e.titleAttributes = a({}, o), e));
+					case l.BODY: return a({}, i, { bodyAttributes: a({}, o) });
+					case l.HTML: return a({}, i, { htmlAttributes: a({}, o) });
+					default: return a({}, i, ((r = {})[n.type] = a({}, o), r));
+				}
+			}, o.mapArrayTypeChildrenToProps = function(t, e) {
+				var r = a({}, e);
+				return Object.keys(t).forEach(function(e) {
+					var n;
+					r = a({}, r, ((n = {})[e] = t[e], n));
+				}), r;
+			}, o.warnOnInvalidChildren = function(t, e) {
+				return (0, import_browser.default)(h.some(function(e) {
+					return t.type === e;
+				}), "function" == typeof t.type ? "You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information." : "Only elements types " + h.join(", ") + " are allowed. Helmet does not support rendering <" + t.type + "> elements. Refer to our API for more information."), (0, import_browser.default)(!e || "string" == typeof e || Array.isArray(e) && !e.some(function(t) {
+					return "string" != typeof t;
+				}), "Helmet expects a string as a child of <" + t.type + ">. Did you forget to wrap your children in braces? ( <" + t.type + ">{``}</" + t.type + "> ) Refer to our API for more information."), !0;
+			}, o.mapChildrenToProps = function(e, r) {
+				var n = this, i = {};
+				return _storybook_global_react_default.Children.forEach(e, function(t) {
+					if (t && t.props) {
+						var e = t.props, o = e.children, a = u(e, F), s = Object.keys(a).reduce(function(t, e) {
+							return t[y[e] || e] = a[e], t;
+						}, {}), c = t.type;
+						switch ("symbol" == typeof c ? c = c.toString() : n.warnOnInvalidChildren(t, o), c) {
+							case l.FRAGMENT:
+								r = n.mapChildrenToProps(o, r);
+								break;
+							case l.LINK:
+							case l.META:
+							case l.NOSCRIPT:
+							case l.SCRIPT:
+							case l.STYLE:
+								i = n.flattenArrayTypeChildren({
+									child: t,
+									arrayTypeChildren: i,
+									newChildProps: s,
+									nestedChildren: o
+								});
+								break;
+							default: r = n.mapObjectTypeChildren({
+								child: t,
+								newProps: r,
+								newChildProps: s,
+								nestedChildren: o
+							});
+						}
+					}
+				}), this.mapArrayTypeChildrenToProps(i, r);
+			}, o.render = function() {
+				var e = this.props, r = e.children, n = u(e, G), i = a({}, n), o = n.helmetData;
+				return r && (i = this.mapChildrenToProps(r, i)), !o || o instanceof N || (o = new N(o.context, o.instances)), o ? /*#__PURE__*/ _storybook_global_react_default.createElement(z, a({}, i, {
+					context: o.value,
+					helmetData: void 0
+				})) : /*#__PURE__*/ _storybook_global_react_default.createElement(R.Consumer, null, function(e) {
+					/*#__PURE__*/ return _storybook_global_react_default.createElement(z, a({}, i, { context: e }));
+				});
+			}, r;
+		}(Component);
+		W.propTypes = {
+			base: import_prop_types.default.object,
+			bodyAttributes: import_prop_types.default.object,
+			children: import_prop_types.default.oneOfType([import_prop_types.default.arrayOf(import_prop_types.default.node), import_prop_types.default.node]),
+			defaultTitle: import_prop_types.default.string,
+			defer: import_prop_types.default.bool,
+			encodeSpecialCharacters: import_prop_types.default.bool,
+			htmlAttributes: import_prop_types.default.object,
+			link: import_prop_types.default.arrayOf(import_prop_types.default.object),
+			meta: import_prop_types.default.arrayOf(import_prop_types.default.object),
+			noscript: import_prop_types.default.arrayOf(import_prop_types.default.object),
+			onChangeClientState: import_prop_types.default.func,
+			script: import_prop_types.default.arrayOf(import_prop_types.default.object),
+			style: import_prop_types.default.arrayOf(import_prop_types.default.object),
+			title: import_prop_types.default.string,
+			titleAttributes: import_prop_types.default.object,
+			titleTemplate: import_prop_types.default.string,
+			prioritizeSeoTags: import_prop_types.default.bool,
+			helmetData: import_prop_types.default.object
+		}, W.defaultProps = {
+			defer: !0,
+			encodeSpecialCharacters: !0,
+			prioritizeSeoTags: !1
+		}, W.displayName = "Helmet";
+	})))();
+}
+//#endregion
+//#region ../../node_modules/react-transition-state/dist/esm/internal.mjs
+var STATUS, getState, startOrEnd, getEndStatus, getTimeout, nextTick;
+function init_internal() {
+	return (init_internal = __esmMin((() => {
+		STATUS = [
+			"preEnter",
+			"entering",
+			"entered",
+			"preExit",
+			"exiting",
+			"exited",
+			"unmounted"
+		];
+		getState = (status) => ({
+			$: status,
+			status: STATUS[status],
+			isEnter: status < 3,
+			isMounted: status !== 6,
+			isResolved: status === 2 || status > 4
+		});
+		startOrEnd = (unmounted) => unmounted ? 6 : 5;
+		getEndStatus = (status, unmountOnExit) => {
+			switch (status) {
+				case 1:
+				case 0: return 2;
+				case 4:
+				case 3: return startOrEnd(unmountOnExit);
+			}
+		};
+		getTimeout = (timeout) => typeof timeout === "object" ? [timeout.enter, timeout.exit] : [timeout, timeout];
+		nextTick = (callback, config) => {
+			config.r = requestAnimationFrame(() => {
+				config.r = requestAnimationFrame(callback);
+			});
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/react-transition-state/dist/esm/useTransitionState.mjs
+var updateState, useTransitionState;
+function init_useTransitionState() {
+	return (init_useTransitionState = __esmMin((() => {
+		init_internal();
+		init__storybook_global_react();
+		updateState = (status, setState, ref, onChange) => {
+			clearTimeout(ref.t);
+			cancelAnimationFrame(ref.r);
+			const state = getState(status);
+			setState(state);
+			ref.s = state;
+			onChange?.({ current: state });
+		};
+		useTransitionState = ({ enter = true, exit = true, preEnter, preExit, timeout, initialEntered, mountOnEnter, unmountOnExit, onStateChange: onChange } = {}) => {
+			const [state, setState] = useState(() => getState(initialEntered ? 2 : startOrEnd(mountOnEnter)));
+			const [ref] = useState({
+				s: state,
+				r: 0
+			});
+			const [enterTimeout, exitTimeout] = getTimeout(timeout);
+			const endTransition = useCallback(() => {
+				const status = getEndStatus(ref.s.$, unmountOnExit);
+				if (status) updateState(status, setState, ref, onChange);
+			}, [
+				onChange,
+				unmountOnExit,
+				ref
+			]);
+			return [
+				state,
+				useCallback((toEnter) => {
+					const transitState = (status) => {
+						updateState(status, setState, ref, onChange);
+						switch (status) {
+							case 1:
+								if (enterTimeout >= 0) ref.t = setTimeout(endTransition, enterTimeout);
+								break;
+							case 4:
+								if (exitTimeout >= 0) ref.t = setTimeout(endTransition, exitTimeout);
+								break;
+							case 0:
+							case 3: nextTick(() => transitState(status + 1), ref);
+						}
+					};
+					const enterStage = ref.s.isEnter;
+					if (typeof toEnter !== "boolean") toEnter = !enterStage;
+					if (toEnter) !enterStage && transitState(enter ? preEnter ? 0 : 1 : 2);
+					else enterStage && transitState(exit ? preExit ? 3 : 4 : startOrEnd(unmountOnExit));
+				}, [
+					ref,
+					endTransition,
+					onChange,
+					enter,
+					exit,
+					preEnter,
+					preExit,
+					enterTimeout,
+					exitTimeout,
+					unmountOnExit
+				]),
+				endTransition
+			];
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js
+/**
+* @license React
+* use-sync-external-store-shim.production.js
+*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_use_sync_external_store_shim_production = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var React = (init__storybook_global_react(), __toCommonJS(_storybook_global_react_exports));
+	function is(x, y) {
+		return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+	}
+	var objectIs = "function" === typeof Object.is ? Object.is : is;
+	var useState = React.useState;
+	var useEffect = React.useEffect;
+	var useLayoutEffect = React.useLayoutEffect;
+	var useDebugValue = React.useDebugValue;
+	function useSyncExternalStore$2(subscribe, getSnapshot) {
+		var value = getSnapshot(), _useState = useState({ inst: {
+			value,
+			getSnapshot
+		} }), inst = _useState[0].inst, forceUpdate = _useState[1];
+		useLayoutEffect(function() {
+			inst.value = value;
+			inst.getSnapshot = getSnapshot;
+			checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+		}, [
+			subscribe,
+			value,
+			getSnapshot
+		]);
+		useEffect(function() {
+			checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+			return subscribe(function() {
+				checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+			});
+		}, [subscribe]);
+		useDebugValue(value);
+		return value;
+	}
+	function checkIfSnapshotChanged(inst) {
+		var latestGetSnapshot = inst.getSnapshot;
+		inst = inst.value;
+		try {
+			var nextValue = latestGetSnapshot();
+			return !objectIs(inst, nextValue);
+		} catch (error) {
+			return !0;
+		}
+	}
+	function useSyncExternalStore$1(subscribe, getSnapshot) {
+		return getSnapshot();
+	}
+	var shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+	exports.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
+}));
+//#endregion
+//#region ../../node_modules/use-sync-external-store/shim/index.js
+var require_shim = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_use_sync_external_store_shim_production();
+}));
+//#endregion
+//#region ../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.production.js
+/**
+* @license React
+* use-sync-external-store-shim/with-selector.production.js
+*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_with_selector_production = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var React = (init__storybook_global_react(), __toCommonJS(_storybook_global_react_exports));
+	var shim = require_shim();
+	function is(x, y) {
+		return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+	}
+	var objectIs = "function" === typeof Object.is ? Object.is : is;
+	var useSyncExternalStore = shim.useSyncExternalStore;
+	var useRef = React.useRef;
+	var useEffect = React.useEffect;
+	var useMemo = React.useMemo;
+	var useDebugValue = React.useDebugValue;
+	exports.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+		var instRef = useRef(null);
+		if (null === instRef.current) {
+			var inst = {
+				hasValue: !1,
+				value: null
+			};
+			instRef.current = inst;
+		} else inst = instRef.current;
+		instRef = useMemo(function() {
+			function memoizedSelector(nextSnapshot) {
+				if (!hasMemo) {
+					hasMemo = !0;
+					memoizedSnapshot = nextSnapshot;
+					nextSnapshot = selector(nextSnapshot);
+					if (void 0 !== isEqual && inst.hasValue) {
+						var currentSelection = inst.value;
+						if (isEqual(currentSelection, nextSnapshot)) return memoizedSelection = currentSelection;
+					}
+					return memoizedSelection = nextSnapshot;
+				}
+				currentSelection = memoizedSelection;
+				if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+				var nextSelection = selector(nextSnapshot);
+				if (void 0 !== isEqual && isEqual(currentSelection, nextSelection)) return memoizedSnapshot = nextSnapshot, currentSelection;
+				memoizedSnapshot = nextSnapshot;
+				return memoizedSelection = nextSelection;
+			}
+			var hasMemo = !1, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+			return [function() {
+				return memoizedSelector(getSnapshot());
+			}, null === maybeGetServerSnapshot ? void 0 : function() {
+				return memoizedSelector(maybeGetServerSnapshot());
+			}];
+		}, [
+			getSnapshot,
+			getServerSnapshot,
+			selector,
+			isEqual
+		]);
+		var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+		useEffect(function() {
+			inst.hasValue = !0;
+			inst.value = value;
+		}, [value]);
+		useDebugValue(value);
+		return value;
+	};
+}));
+//#endregion
+//#region ../../node_modules/use-sync-external-store/shim/with-selector.js
+var require_with_selector = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_with_selector_production();
+}));
+//#endregion
+//#region ../../node_modules/memoizerific/memoizerific.js
+var require_memoizerific = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(f) {
+		if (typeof exports === "object" && typeof module !== "undefined") module.exports = f();
+		else if (typeof define === "function" && define.amd) define([], f);
+		else {
+			var g;
+			if (typeof window !== "undefined") g = window;
+			else if (typeof global !== "undefined") g = global;
+			else if (typeof self !== "undefined") g = self;
+			else g = this;
+			g.memoizerific = f();
+		}
+	})(function() {
+		return (function e(t, n, r) {
+			function s(o, u) {
+				if (!n[o]) {
+					if (!t[o]) {
+						var a = typeof __require == "function" && __require;
+						if (!u && a) return a(o, !0);
+						if (i) return i(o, !0);
+						var f = /* @__PURE__ */ new Error("Cannot find module '" + o + "'");
+						throw f.code = "MODULE_NOT_FOUND", f;
+					}
+					var l = n[o] = { exports: {} };
+					t[o][0].call(l.exports, function(e) {
+						var n = t[o][1][e];
+						return s(n ? n : e);
+					}, l, l.exports, e, t, n, r);
+				}
+				return n[o].exports;
+			}
+			var i = typeof __require == "function" && __require;
+			for (var o = 0; o < r.length; o++) s(r[o]);
+			return s;
+		})({
+			1: [function(_dereq_, module, exports) {
+				module.exports = function(forceSimilar) {
+					if (typeof Map !== "function" || forceSimilar) return new (_dereq_("./similar"))();
+					else return /* @__PURE__ */ new Map();
+				};
+			}, { "./similar": 2 }],
+			2: [function(_dereq_, module, exports) {
+				function Similar() {
+					this.list = [];
+					this.lastItem = void 0;
+					this.size = 0;
+					return this;
+				}
+				Similar.prototype.get = function(key) {
+					var index;
+					if (this.lastItem && this.isEqual(this.lastItem.key, key)) return this.lastItem.val;
+					index = this.indexOf(key);
+					if (index >= 0) {
+						this.lastItem = this.list[index];
+						return this.list[index].val;
+					}
+				};
+				Similar.prototype.set = function(key, val) {
+					var index;
+					if (this.lastItem && this.isEqual(this.lastItem.key, key)) {
+						this.lastItem.val = val;
+						return this;
+					}
+					index = this.indexOf(key);
+					if (index >= 0) {
+						this.lastItem = this.list[index];
+						this.list[index].val = val;
+						return this;
+					}
+					this.lastItem = {
+						key,
+						val
+					};
+					this.list.push(this.lastItem);
+					this.size++;
+					return this;
+				};
+				Similar.prototype.delete = function(key) {
+					var index;
+					if (this.lastItem && this.isEqual(this.lastItem.key, key)) this.lastItem = void 0;
+					index = this.indexOf(key);
+					if (index >= 0) {
+						this.size--;
+						return this.list.splice(index, 1)[0];
+					}
+				};
+				Similar.prototype.has = function(key) {
+					var index;
+					if (this.lastItem && this.isEqual(this.lastItem.key, key)) return true;
+					index = this.indexOf(key);
+					if (index >= 0) {
+						this.lastItem = this.list[index];
+						return true;
+					}
+					return false;
+				};
+				Similar.prototype.forEach = function(callback, thisArg) {
+					var i = 0;
+					for (; i < this.size; i++) callback.call(thisArg || this, this.list[i].val, this.list[i].key, this);
+				};
+				Similar.prototype.indexOf = function(key) {
+					var i = 0;
+					for (; i < this.size; i++) if (this.isEqual(this.list[i].key, key)) return i;
+					return -1;
+				};
+				Similar.prototype.isEqual = function(val1, val2) {
+					return val1 === val2 || val1 !== val1 && val2 !== val2;
+				};
+				module.exports = Similar;
+			}, {}],
+			3: [function(_dereq_, module, exports) {
+				var MapOrSimilar = _dereq_("map-or-similar");
+				module.exports = function(limit) {
+					var cache = new MapOrSimilar(false), lru = [];
+					return function(fn) {
+						var memoizerific = function() {
+							var currentCache = cache, newMap, fnResult, argsLengthMinusOne = arguments.length - 1, lruPath = Array(argsLengthMinusOne + 1), isMemoized = true, i;
+							if ((memoizerific.numArgs || memoizerific.numArgs === 0) && memoizerific.numArgs !== argsLengthMinusOne + 1) throw new Error("Memoizerific functions should always be called with the same number of arguments");
+							for (i = 0; i < argsLengthMinusOne; i++) {
+								lruPath[i] = {
+									cacheItem: currentCache,
+									arg: arguments[i]
+								};
+								if (currentCache.has(arguments[i])) {
+									currentCache = currentCache.get(arguments[i]);
+									continue;
+								}
+								isMemoized = false;
+								newMap = new MapOrSimilar(false);
+								currentCache.set(arguments[i], newMap);
+								currentCache = newMap;
+							}
+							if (isMemoized) {
+								if (currentCache.has(arguments[argsLengthMinusOne])) fnResult = currentCache.get(arguments[argsLengthMinusOne]);
+								else isMemoized = false;
+							}
+							if (!isMemoized) {
+								fnResult = fn.apply(null, arguments);
+								currentCache.set(arguments[argsLengthMinusOne], fnResult);
+							}
+							if (limit > 0) {
+								lruPath[argsLengthMinusOne] = {
+									cacheItem: currentCache,
+									arg: arguments[argsLengthMinusOne]
+								};
+								if (isMemoized) moveToMostRecentLru(lru, lruPath);
+								else lru.push(lruPath);
+								if (lru.length > limit) removeCachedResult(lru.shift());
+							}
+							memoizerific.wasMemoized = isMemoized;
+							memoizerific.numArgs = argsLengthMinusOne + 1;
+							return fnResult;
+						};
+						memoizerific.limit = limit;
+						memoizerific.wasMemoized = false;
+						memoizerific.cache = cache;
+						memoizerific.lru = lru;
+						return memoizerific;
+					};
+				};
+				function moveToMostRecentLru(lru, lruPath) {
+					var lruLen = lru.length, lruPathLen = lruPath.length, isMatch, i = 0, ii;
+					for (; i < lruLen; i++) {
+						isMatch = true;
+						for (ii = 0; ii < lruPathLen; ii++) if (!isEqual(lru[i][ii].arg, lruPath[ii].arg)) {
+							isMatch = false;
+							break;
+						}
+						if (isMatch) break;
+					}
+					lru.push(lru.splice(i, 1)[0]);
+				}
+				function removeCachedResult(removedLru) {
+					var removedLruLen = removedLru.length, currentLru = removedLru[removedLruLen - 1], tmp, i;
+					currentLru.cacheItem.delete(currentLru.arg);
+					for (i = removedLruLen - 2; i >= 0; i--) {
+						currentLru = removedLru[i];
+						tmp = currentLru.cacheItem.get(currentLru.arg);
+						if (!tmp || !tmp.size) currentLru.cacheItem.delete(currentLru.arg);
+						else break;
+					}
+				}
+				function isEqual(val1, val2) {
+					return val1 === val2 || val1 !== val1 && val2 !== val2;
+				}
+			}, { "map-or-similar": 1 }]
+		}, {}, [3])(3);
+	});
+}));
+//#endregion
+//#region ../../node_modules/polished/dist/polished.esm.js
+/**
+* Check if a string ends with something
+* @private
+*/
+function endsWith(string, suffix) {
+	return string.substr(-suffix.length) === suffix;
+}
+/**
+* Returns a given CSS value minus its unit of measure.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   '--dimension': stripUnit('100px')
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   --dimension: ${stripUnit('100px')};
+* `
+*
+* // CSS in JS Output
+*
+* element {
+*   '--dimension': 100
+* }
+*/
+function stripUnit(value) {
+	if (typeof value !== "string") return value;
+	return value.match(cssRegex$1) ? parseFloat(value) : value;
+}
+function colorToInt(color) {
+	return Math.round(color * 255);
+}
+function convertToInt(red, green, blue) {
+	return colorToInt(red) + "," + colorToInt(green) + "," + colorToInt(blue);
+}
+function hslToRgb(hue, saturation, lightness, convert) {
+	if (convert === void 0) convert = convertToInt;
+	if (saturation === 0) return convert(lightness, lightness, lightness);
+	var huePrime = (hue % 360 + 360) % 360 / 60;
+	var chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
+	var secondComponent = chroma * (1 - Math.abs(huePrime % 2 - 1));
+	var red = 0;
+	var green = 0;
+	var blue = 0;
+	if (huePrime >= 0 && huePrime < 1) {
+		red = chroma;
+		green = secondComponent;
+	} else if (huePrime >= 1 && huePrime < 2) {
+		red = secondComponent;
+		green = chroma;
+	} else if (huePrime >= 2 && huePrime < 3) {
+		green = chroma;
+		blue = secondComponent;
+	} else if (huePrime >= 3 && huePrime < 4) {
+		green = secondComponent;
+		blue = chroma;
+	} else if (huePrime >= 4 && huePrime < 5) {
+		red = secondComponent;
+		blue = chroma;
+	} else if (huePrime >= 5 && huePrime < 6) {
+		red = chroma;
+		blue = secondComponent;
+	}
+	var lightnessModification = lightness - chroma / 2;
+	var finalRed = red + lightnessModification;
+	var finalGreen = green + lightnessModification;
+	var finalBlue = blue + lightnessModification;
+	return convert(finalRed, finalGreen, finalBlue);
+}
+/**
+* Checks if a string is a CSS named color and returns its equivalent hex value, otherwise returns the original color.
+* @private
+*/
+function nameToHex(color) {
+	if (typeof color !== "string") return color;
+	var normalizedColorName = color.toLowerCase();
+	return namedColorMap[normalizedColorName] ? "#" + namedColorMap[normalizedColorName] : color;
+}
+/**
+* Returns an RgbColor or RgbaColor object. This utility function is only useful
+* if want to extract a color component. With the color util `toColorString` you
+* can convert a RgbColor or RgbaColor object back to a string.
+*
+* @example
+* // Assigns `{ red: 255, green: 0, blue: 0 }` to color1
+* const color1 = parseToRgb('rgb(255, 0, 0)');
+* // Assigns `{ red: 92, green: 102, blue: 112, alpha: 0.75 }` to color2
+* const color2 = parseToRgb('hsla(210, 10%, 40%, 0.75)');
+*/
+function parseToRgb(color) {
+	if (typeof color !== "string") throw new PolishedError(3);
+	var normalizedColor = nameToHex(color);
+	if (normalizedColor.match(hexRegex)) return {
+		red: parseInt("" + normalizedColor[1] + normalizedColor[2], 16),
+		green: parseInt("" + normalizedColor[3] + normalizedColor[4], 16),
+		blue: parseInt("" + normalizedColor[5] + normalizedColor[6], 16)
+	};
+	if (normalizedColor.match(hexRgbaRegex)) {
+		var alpha = parseFloat((parseInt("" + normalizedColor[7] + normalizedColor[8], 16) / 255).toFixed(2));
+		return {
+			red: parseInt("" + normalizedColor[1] + normalizedColor[2], 16),
+			green: parseInt("" + normalizedColor[3] + normalizedColor[4], 16),
+			blue: parseInt("" + normalizedColor[5] + normalizedColor[6], 16),
+			alpha
+		};
+	}
+	if (normalizedColor.match(reducedHexRegex)) return {
+		red: parseInt("" + normalizedColor[1] + normalizedColor[1], 16),
+		green: parseInt("" + normalizedColor[2] + normalizedColor[2], 16),
+		blue: parseInt("" + normalizedColor[3] + normalizedColor[3], 16)
+	};
+	if (normalizedColor.match(reducedRgbaHexRegex)) {
+		var _alpha = parseFloat((parseInt("" + normalizedColor[4] + normalizedColor[4], 16) / 255).toFixed(2));
+		return {
+			red: parseInt("" + normalizedColor[1] + normalizedColor[1], 16),
+			green: parseInt("" + normalizedColor[2] + normalizedColor[2], 16),
+			blue: parseInt("" + normalizedColor[3] + normalizedColor[3], 16),
+			alpha: _alpha
+		};
+	}
+	var rgbMatched = rgbRegex.exec(normalizedColor);
+	if (rgbMatched) return {
+		red: parseInt("" + rgbMatched[1], 10),
+		green: parseInt("" + rgbMatched[2], 10),
+		blue: parseInt("" + rgbMatched[3], 10)
+	};
+	var rgbaMatched = rgbaRegex.exec(normalizedColor.substring(0, 50));
+	if (rgbaMatched) return {
+		red: parseInt("" + rgbaMatched[1], 10),
+		green: parseInt("" + rgbaMatched[2], 10),
+		blue: parseInt("" + rgbaMatched[3], 10),
+		alpha: parseFloat("" + rgbaMatched[4]) > 1 ? parseFloat("" + rgbaMatched[4]) / 100 : parseFloat("" + rgbaMatched[4])
+	};
+	var hslMatched = hslRegex.exec(normalizedColor);
+	if (hslMatched) {
+		var rgbColorString = "rgb(" + hslToRgb(parseInt("" + hslMatched[1], 10), parseInt("" + hslMatched[2], 10) / 100, parseInt("" + hslMatched[3], 10) / 100) + ")";
+		var hslRgbMatched = rgbRegex.exec(rgbColorString);
+		if (!hslRgbMatched) throw new PolishedError(4, normalizedColor, rgbColorString);
+		return {
+			red: parseInt("" + hslRgbMatched[1], 10),
+			green: parseInt("" + hslRgbMatched[2], 10),
+			blue: parseInt("" + hslRgbMatched[3], 10)
+		};
+	}
+	var hslaMatched = hslaRegex.exec(normalizedColor.substring(0, 50));
+	if (hslaMatched) {
+		var _rgbColorString = "rgb(" + hslToRgb(parseInt("" + hslaMatched[1], 10), parseInt("" + hslaMatched[2], 10) / 100, parseInt("" + hslaMatched[3], 10) / 100) + ")";
+		var _hslRgbMatched = rgbRegex.exec(_rgbColorString);
+		if (!_hslRgbMatched) throw new PolishedError(4, normalizedColor, _rgbColorString);
+		return {
+			red: parseInt("" + _hslRgbMatched[1], 10),
+			green: parseInt("" + _hslRgbMatched[2], 10),
+			blue: parseInt("" + _hslRgbMatched[3], 10),
+			alpha: parseFloat("" + hslaMatched[4]) > 1 ? parseFloat("" + hslaMatched[4]) / 100 : parseFloat("" + hslaMatched[4])
+		};
+	}
+	throw new PolishedError(5);
+}
+function rgbToHsl(color) {
+	var red = color.red / 255;
+	var green = color.green / 255;
+	var blue = color.blue / 255;
+	var max = Math.max(red, green, blue);
+	var min = Math.min(red, green, blue);
+	var lightness = (max + min) / 2;
+	if (max === min) {
+		if (color.alpha !== void 0) return {
+			hue: 0,
+			saturation: 0,
+			lightness,
+			alpha: color.alpha
+		};
+		else return {
+			hue: 0,
+			saturation: 0,
+			lightness
+		};
+	}
+	var hue;
+	var delta = max - min;
+	var saturation = lightness > .5 ? delta / (2 - max - min) : delta / (max + min);
+	switch (max) {
+		case red:
+			hue = (green - blue) / delta + (green < blue ? 6 : 0);
+			break;
+		case green:
+			hue = (blue - red) / delta + 2;
+			break;
+		default: hue = (red - green) / delta + 4;
+	}
+	hue *= 60;
+	if (color.alpha !== void 0) return {
+		hue,
+		saturation,
+		lightness,
+		alpha: color.alpha
+	};
+	return {
+		hue,
+		saturation,
+		lightness
+	};
+}
+/**
+* Returns an HslColor or HslaColor object. This utility function is only useful
+* if want to extract a color component. With the color util `toColorString` you
+* can convert a HslColor or HslaColor object back to a string.
+*
+* @example
+* // Assigns `{ hue: 0, saturation: 1, lightness: 0.5 }` to color1
+* const color1 = parseToHsl('rgb(255, 0, 0)');
+* // Assigns `{ hue: 128, saturation: 1, lightness: 0.5, alpha: 0.75 }` to color2
+* const color2 = parseToHsl('hsla(128, 100%, 50%, 0.75)');
+*/
+function parseToHsl(color) {
+	return rgbToHsl(parseToRgb(color));
+}
+function numberToHex(value) {
+	var hex = value.toString(16);
+	return hex.length === 1 ? "0" + hex : hex;
+}
+function colorToHex(color) {
+	return numberToHex(Math.round(color * 255));
+}
+function convertToHex(red, green, blue) {
+	return reduceHexValue$1("#" + colorToHex(red) + colorToHex(green) + colorToHex(blue));
+}
+function hslToHex(hue, saturation, lightness) {
+	return hslToRgb(hue, saturation, lightness, convertToHex);
+}
+/**
+* Returns a string value for the color. The returned result is the smallest possible hex notation.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: hsl(359, 0.75, 0.4),
+*   background: hsl({ hue: 360, saturation: 0.75, lightness: 0.4 }),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${hsl(359, 0.75, 0.4)};
+*   background: ${hsl({ hue: 360, saturation: 0.75, lightness: 0.4 })};
+* `
+*
+* // CSS in JS Output
+*
+* element {
+*   background: "#b3191c";
+*   background: "#b3191c";
+* }
+*/
+function hsl(value, saturation, lightness) {
+	if (typeof value === "number" && typeof saturation === "number" && typeof lightness === "number") return hslToHex(value, saturation, lightness);
+	else if (typeof value === "object" && saturation === void 0 && lightness === void 0) return hslToHex(value.hue, value.saturation, value.lightness);
+	throw new PolishedError(1);
+}
+/**
+* Returns a string value for the color. The returned result is the smallest possible rgba or hex notation.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: hsla(359, 0.75, 0.4, 0.7),
+*   background: hsla({ hue: 360, saturation: 0.75, lightness: 0.4, alpha: 0,7 }),
+*   background: hsla(359, 0.75, 0.4, 1),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${hsla(359, 0.75, 0.4, 0.7)};
+*   background: ${hsla({ hue: 360, saturation: 0.75, lightness: 0.4, alpha: 0,7 })};
+*   background: ${hsla(359, 0.75, 0.4, 1)};
+* `
+*
+* // CSS in JS Output
+*
+* element {
+*   background: "rgba(179,25,28,0.7)";
+*   background: "rgba(179,25,28,0.7)";
+*   background: "#b3191c";
+* }
+*/
+function hsla(value, saturation, lightness, alpha) {
+	if (typeof value === "number" && typeof saturation === "number" && typeof lightness === "number" && typeof alpha === "number") return alpha >= 1 ? hslToHex(value, saturation, lightness) : "rgba(" + hslToRgb(value, saturation, lightness) + "," + alpha + ")";
+	else if (typeof value === "object" && saturation === void 0 && lightness === void 0 && alpha === void 0) return value.alpha >= 1 ? hslToHex(value.hue, value.saturation, value.lightness) : "rgba(" + hslToRgb(value.hue, value.saturation, value.lightness) + "," + value.alpha + ")";
+	throw new PolishedError(2);
+}
+/**
+* Returns a string value for the color. The returned result is the smallest possible hex notation.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: rgb(255, 205, 100),
+*   background: rgb({ red: 255, green: 205, blue: 100 }),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${rgb(255, 205, 100)};
+*   background: ${rgb({ red: 255, green: 205, blue: 100 })};
+* `
+*
+* // CSS in JS Output
+*
+* element {
+*   background: "#ffcd64";
+*   background: "#ffcd64";
+* }
+*/
+function rgb(value, green, blue) {
+	if (typeof value === "number" && typeof green === "number" && typeof blue === "number") return reduceHexValue$1("#" + numberToHex(value) + numberToHex(green) + numberToHex(blue));
+	else if (typeof value === "object" && green === void 0 && blue === void 0) return reduceHexValue$1("#" + numberToHex(value.red) + numberToHex(value.green) + numberToHex(value.blue));
+	throw new PolishedError(6);
+}
+/**
+* Returns a string value for the color. The returned result is the smallest possible rgba or hex notation.
+*
+* Can also be used to fade a color by passing a hex value or named CSS color along with an alpha value.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: rgba(255, 205, 100, 0.7),
+*   background: rgba({ red: 255, green: 205, blue: 100, alpha: 0.7 }),
+*   background: rgba(255, 205, 100, 1),
+*   background: rgba('#ffffff', 0.4),
+*   background: rgba('black', 0.7),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${rgba(255, 205, 100, 0.7)};
+*   background: ${rgba({ red: 255, green: 205, blue: 100, alpha: 0.7 })};
+*   background: ${rgba(255, 205, 100, 1)};
+*   background: ${rgba('#ffffff', 0.4)};
+*   background: ${rgba('black', 0.7)};
+* `
+*
+* // CSS in JS Output
+*
+* element {
+*   background: "rgba(255,205,100,0.7)";
+*   background: "rgba(255,205,100,0.7)";
+*   background: "#ffcd64";
+*   background: "rgba(255,255,255,0.4)";
+*   background: "rgba(0,0,0,0.7)";
+* }
+*/
+function rgba(firstValue, secondValue, thirdValue, fourthValue) {
+	if (typeof firstValue === "string" && typeof secondValue === "number") {
+		var rgbValue = parseToRgb(firstValue);
+		return "rgba(" + rgbValue.red + "," + rgbValue.green + "," + rgbValue.blue + "," + secondValue + ")";
+	} else if (typeof firstValue === "number" && typeof secondValue === "number" && typeof thirdValue === "number" && typeof fourthValue === "number") return fourthValue >= 1 ? rgb(firstValue, secondValue, thirdValue) : "rgba(" + firstValue + "," + secondValue + "," + thirdValue + "," + fourthValue + ")";
+	else if (typeof firstValue === "object" && secondValue === void 0 && thirdValue === void 0 && fourthValue === void 0) return firstValue.alpha >= 1 ? rgb(firstValue.red, firstValue.green, firstValue.blue) : "rgba(" + firstValue.red + "," + firstValue.green + "," + firstValue.blue + "," + firstValue.alpha + ")";
+	throw new PolishedError(7);
+}
+/**
+* Converts a RgbColor, RgbaColor, HslColor or HslaColor object to a color string.
+* This util is useful in case you only know on runtime which color object is
+* used. Otherwise we recommend to rely on `rgb`, `rgba`, `hsl` or `hsla`.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: toColorString({ red: 255, green: 205, blue: 100 }),
+*   background: toColorString({ red: 255, green: 205, blue: 100, alpha: 0.72 }),
+*   background: toColorString({ hue: 240, saturation: 1, lightness: 0.5 }),
+*   background: toColorString({ hue: 360, saturation: 0.75, lightness: 0.4, alpha: 0.72 }),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${toColorString({ red: 255, green: 205, blue: 100 })};
+*   background: ${toColorString({ red: 255, green: 205, blue: 100, alpha: 0.72 })};
+*   background: ${toColorString({ hue: 240, saturation: 1, lightness: 0.5 })};
+*   background: ${toColorString({ hue: 360, saturation: 0.75, lightness: 0.4, alpha: 0.72 })};
+* `
+*
+* // CSS in JS Output
+* element {
+*   background: "#ffcd64";
+*   background: "rgba(255,205,100,0.72)";
+*   background: "#00f";
+*   background: "rgba(179,25,25,0.72)";
+* }
+*/
+function toColorString(color) {
+	if (typeof color !== "object") throw new PolishedError(8);
+	if (isRgba(color)) return rgba(color);
+	if (isRgb(color)) return rgb(color);
+	if (isHsla(color)) return hsla(color);
+	if (isHsl(color)) return hsl(color);
+	throw new PolishedError(8);
+}
+function curried(f, length, acc) {
+	return function fn() {
+		var combined = acc.concat(Array.prototype.slice.call(arguments));
+		return combined.length >= length ? f.apply(this, combined) : curried(f, length, combined);
+	};
+}
+function curry(f) {
+	return curried(f, f.length, []);
+}
+/**
+* Changes the hue of the color. Hue is a number between 0 to 360. The first
+* argument for adjustHue is the amount of degrees the color is rotated around
+* the color wheel, always producing a positive hue value.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: adjustHue(180, '#448'),
+*   background: adjustHue('180', 'rgba(101,100,205,0.7)'),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${adjustHue(180, '#448')};
+*   background: ${adjustHue('180', 'rgba(101,100,205,0.7)')};
+* `
+*
+* // CSS in JS Output
+* element {
+*   background: "#888844";
+*   background: "rgba(136,136,68,0.7)";
+* }
+*/
+function adjustHue(degree, color) {
+	if (color === "transparent") return color;
+	var hslColor = parseToHsl(color);
+	return toColorString(_extends({}, hslColor, { hue: hslColor.hue + parseFloat(degree) }));
+}
+function guard(lowerBoundary, upperBoundary, value) {
+	return Math.max(lowerBoundary, Math.min(upperBoundary, value));
+}
+/**
+* Returns a string value for the darkened color.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: darken(0.2, '#FFCD64'),
+*   background: darken('0.2', 'rgba(255,205,100,0.7)'),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${darken(0.2, '#FFCD64')};
+*   background: ${darken('0.2', 'rgba(255,205,100,0.7)')};
+* `
+*
+* // CSS in JS Output
+*
+* element {
+*   background: "#ffbd31";
+*   background: "rgba(255,189,49,0.7)";
+* }
+*/
+function darken(amount, color) {
+	if (color === "transparent") return color;
+	var hslColor = parseToHsl(color);
+	return toColorString(_extends({}, hslColor, { lightness: guard(0, 1, hslColor.lightness - parseFloat(amount)) }));
+}
+/**
+* Decreases the intensity of a color. Its range is between 0 to 1. The first
+* argument of the desaturate function is the amount by how much the color
+* intensity should be decreased.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: desaturate(0.2, '#CCCD64'),
+*   background: desaturate('0.2', 'rgba(204,205,100,0.7)'),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${desaturate(0.2, '#CCCD64')};
+*   background: ${desaturate('0.2', 'rgba(204,205,100,0.7)')};
+* `
+*
+* // CSS in JS Output
+* element {
+*   background: "#b8b979";
+*   background: "rgba(184,185,121,0.7)";
+* }
+*/
+function desaturate(amount, color) {
+	if (color === "transparent") return color;
+	var hslColor = parseToHsl(color);
+	return toColorString(_extends({}, hslColor, { saturation: guard(0, 1, hslColor.saturation - parseFloat(amount)) }));
+}
+/**
+* Returns a string value for the lightened color.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: lighten(0.2, '#CCCD64'),
+*   background: lighten('0.2', 'rgba(204,205,100,0.7)'),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${lighten(0.2, '#FFCD64')};
+*   background: ${lighten('0.2', 'rgba(204,205,100,0.7)')};
+* `
+*
+* // CSS in JS Output
+*
+* element {
+*   background: "#e5e6b1";
+*   background: "rgba(229,230,177,0.7)";
+* }
+*/
+function lighten(amount, color) {
+	if (color === "transparent") return color;
+	var hslColor = parseToHsl(color);
+	return toColorString(_extends({}, hslColor, { lightness: guard(0, 1, hslColor.lightness + parseFloat(amount)) }));
+}
+/**
+* Mixes the two provided colors together by calculating the average of each of the RGB components weighted to the first color by the provided weight.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: mix(0.5, '#f00', '#00f')
+*   background: mix(0.25, '#f00', '#00f')
+*   background: mix('0.5', 'rgba(255, 0, 0, 0.5)', '#00f')
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${mix(0.5, '#f00', '#00f')};
+*   background: ${mix(0.25, '#f00', '#00f')};
+*   background: ${mix('0.5', 'rgba(255, 0, 0, 0.5)', '#00f')};
+* `
+*
+* // CSS in JS Output
+*
+* element {
+*   background: "#7f007f";
+*   background: "#3f00bf";
+*   background: "rgba(63, 0, 191, 0.75)";
+* }
+*/
+function mix(weight, color, otherColor) {
+	if (color === "transparent") return otherColor;
+	if (otherColor === "transparent") return color;
+	if (weight === 0) return otherColor;
+	var parsedColor1 = parseToRgb(color);
+	var color1 = _extends({}, parsedColor1, { alpha: typeof parsedColor1.alpha === "number" ? parsedColor1.alpha : 1 });
+	var parsedColor2 = parseToRgb(otherColor);
+	var color2 = _extends({}, parsedColor2, { alpha: typeof parsedColor2.alpha === "number" ? parsedColor2.alpha : 1 });
+	var alphaDelta = color1.alpha - color2.alpha;
+	var x = parseFloat(weight) * 2 - 1;
+	var weight1 = ((x * alphaDelta === -1 ? x : x + alphaDelta) / (1 + x * alphaDelta) + 1) / 2;
+	var weight2 = 1 - weight1;
+	return rgba({
+		red: Math.floor(color1.red * weight1 + color2.red * weight2),
+		green: Math.floor(color1.green * weight1 + color2.green * weight2),
+		blue: Math.floor(color1.blue * weight1 + color2.blue * weight2),
+		alpha: color1.alpha * parseFloat(weight) + color2.alpha * (1 - parseFloat(weight))
+	});
+}
+/**
+* Increases the opacity of a color. Its range for the amount is between 0 to 1.
+*
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: opacify(0.1, 'rgba(255, 255, 255, 0.9)');
+*   background: opacify(0.2, 'hsla(0, 0%, 100%, 0.5)'),
+*   background: opacify('0.5', 'rgba(255, 0, 0, 0.2)'),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${opacify(0.1, 'rgba(255, 255, 255, 0.9)')};
+*   background: ${opacify(0.2, 'hsla(0, 0%, 100%, 0.5)')},
+*   background: ${opacify('0.5', 'rgba(255, 0, 0, 0.2)')},
+* `
+*
+* // CSS in JS Output
+*
+* element {
+*   background: "#fff";
+*   background: "rgba(255,255,255,0.7)";
+*   background: "rgba(255,0,0,0.7)";
+* }
+*/
+function opacify(amount, color) {
+	if (color === "transparent") return color;
+	var parsedColor = parseToRgb(color);
+	var alpha = typeof parsedColor.alpha === "number" ? parsedColor.alpha : 1;
+	return rgba(_extends({}, parsedColor, { alpha: guard(0, 1, (alpha * 100 + parseFloat(amount) * 100) / 100) }));
+}
+/**
+* Increases the intensity of a color. Its range is between 0 to 1. The first
+* argument of the saturate function is the amount by how much the color
+* intensity should be increased.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: saturate(0.2, '#CCCD64'),
+*   background: saturate('0.2', 'rgba(204,205,100,0.7)'),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${saturate(0.2, '#FFCD64')};
+*   background: ${saturate('0.2', 'rgba(204,205,100,0.7)')};
+* `
+*
+* // CSS in JS Output
+*
+* element {
+*   background: "#e0e250";
+*   background: "rgba(224,226,80,0.7)";
+* }
+*/
+function saturate(amount, color) {
+	if (color === "transparent") return color;
+	var hslColor = parseToHsl(color);
+	return toColorString(_extends({}, hslColor, { saturation: guard(0, 1, hslColor.saturation + parseFloat(amount)) }));
+}
+/**
+* Sets the hue of a color to the provided value. The hue range can be
+* from 0 and 359.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: setHue(42, '#CCCD64'),
+*   background: setHue('244', 'rgba(204,205,100,0.7)'),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${setHue(42, '#CCCD64')};
+*   background: ${setHue('244', 'rgba(204,205,100,0.7)')};
+* `
+*
+* // CSS in JS Output
+* element {
+*   background: "#cdae64";
+*   background: "rgba(107,100,205,0.7)";
+* }
+*/
+function setHue(hue, color) {
+	if (color === "transparent") return color;
+	return toColorString(_extends({}, parseToHsl(color), { hue: parseFloat(hue) }));
+}
+/**
+* Sets the lightness of a color to the provided value. The lightness range can be
+* from 0 and 1.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: setLightness(0.2, '#CCCD64'),
+*   background: setLightness('0.75', 'rgba(204,205,100,0.7)'),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${setLightness(0.2, '#CCCD64')};
+*   background: ${setLightness('0.75', 'rgba(204,205,100,0.7)')};
+* `
+*
+* // CSS in JS Output
+* element {
+*   background: "#4d4d19";
+*   background: "rgba(223,224,159,0.7)";
+* }
+*/
+function setLightness(lightness, color) {
+	if (color === "transparent") return color;
+	return toColorString(_extends({}, parseToHsl(color), { lightness: parseFloat(lightness) }));
+}
+/**
+* Sets the saturation of a color to the provided value. The saturation range can be
+* from 0 and 1.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: setSaturation(0.2, '#CCCD64'),
+*   background: setSaturation('0.75', 'rgba(204,205,100,0.7)'),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${setSaturation(0.2, '#CCCD64')};
+*   background: ${setSaturation('0.75', 'rgba(204,205,100,0.7)')};
+* `
+*
+* // CSS in JS Output
+* element {
+*   background: "#adad84";
+*   background: "rgba(228,229,76,0.7)";
+* }
+*/
+function setSaturation(saturation, color) {
+	if (color === "transparent") return color;
+	return toColorString(_extends({}, parseToHsl(color), { saturation: parseFloat(saturation) }));
+}
+/**
+* Shades a color by mixing it with black. `shade` can produce
+* hue shifts, where as `darken` manipulates the luminance channel and therefore
+* doesn't produce hue shifts.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: shade(0.25, '#00f')
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${shade(0.25, '#00f')};
+* `
+*
+* // CSS in JS Output
+*
+* element {
+*   background: "#00003f";
+* }
+*/
+function shade(percentage, color) {
+	if (color === "transparent") return color;
+	return mix$1(parseFloat(percentage), "rgb(0, 0, 0)", color);
+}
+/**
+* Tints a color by mixing it with white. `tint` can produce
+* hue shifts, where as `lighten` manipulates the luminance channel and therefore
+* doesn't produce hue shifts.
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: tint(0.25, '#00f')
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${tint(0.25, '#00f')};
+* `
+*
+* // CSS in JS Output
+*
+* element {
+*   background: "#bfbfff";
+* }
+*/
+function tint(percentage, color) {
+	if (color === "transparent") return color;
+	return mix$1(parseFloat(percentage), "rgb(255, 255, 255)", color);
+}
+/**
+* Decreases the opacity of a color. Its range for the amount is between 0 to 1.
+*
+*
+* @example
+* // Styles as object usage
+* const styles = {
+*   background: transparentize(0.1, '#fff'),
+*   background: transparentize(0.2, 'hsl(0, 0%, 100%)'),
+*   background: transparentize('0.5', 'rgba(255, 0, 0, 0.8)'),
+* }
+*
+* // styled-components usage
+* const div = styled.div`
+*   background: ${transparentize(0.1, '#fff')};
+*   background: ${transparentize(0.2, 'hsl(0, 0%, 100%)')};
+*   background: ${transparentize('0.5', 'rgba(255, 0, 0, 0.8)')};
+* `
+*
+* // CSS in JS Output
+*
+* element {
+*   background: "rgba(255,255,255,0.9)";
+*   background: "rgba(255,255,255,0.8)";
+*   background: "rgba(255,0,0,0.3)";
+* }
+*/
+function transparentize(amount, color) {
+	if (color === "transparent") return color;
+	var parsedColor = parseToRgb(color);
+	var alpha = typeof parsedColor.alpha === "number" ? parsedColor.alpha : 1;
+	return rgba(_extends({}, parsedColor, { alpha: guard(0, 1, +(alpha * 100 - parseFloat(amount) * 100).toFixed(2) / 100) }));
+}
+var PolishedError, cssRegex$1, pixelsto, namedColorMap, hexRegex, hexRgbaRegex, reducedHexRegex, reducedRgbaHexRegex, rgbRegex, rgbaRegex, hslRegex, hslaRegex, reduceHexValue$1, isRgb, isRgba, isHsl, isHsla, mix$1, curriedTransparentize$1;
+function init_polished_esm() {
+	return (init_polished_esm = __esmMin((() => {
+		init_inheritsLoose();
+		init_wrapNativeSuper();
+		PolishedError = /*#__PURE__*/ function(_Error) {
+			_inheritsLoose(PolishedError, _Error);
+			function PolishedError(code) {
+				var _this = _Error.call(this, "An error occurred. See https://github.com/styled-components/polished/blob/main/src/internalHelpers/errors.md#" + code + " for more information.") || this;
+				return _assertThisInitialized(_this);
+			}
+			return PolishedError;
+		}(/*#__PURE__*/ _wrapNativeSuper(Error));
+		cssRegex$1 = /^([+-]?(?:\d+|\d*\.\d+))([a-z]*|%)$/;
+		pixelsto = function pxtoFactory(to) {
+			return function(pxval, base) {
+				if (base === void 0) base = "16px";
+				var newPxval = pxval;
+				var newBase = base;
+				if (typeof pxval === "string") {
+					if (!endsWith(pxval, "px")) throw new PolishedError(69, to, pxval);
+					newPxval = stripUnit(pxval);
+				}
+				if (typeof base === "string") {
+					if (!endsWith(base, "px")) throw new PolishedError(70, to, base);
+					newBase = stripUnit(base);
+				}
+				if (typeof newPxval === "string") throw new PolishedError(71, pxval, to);
+				if (typeof newBase === "string") throw new PolishedError(72, base, to);
+				return "" + newPxval / newBase + to;
+			};
+		};
+		pixelsto("em");
+		pixelsto("rem");
+		namedColorMap = {
+			aliceblue: "f0f8ff",
+			antiquewhite: "faebd7",
+			aqua: "00ffff",
+			aquamarine: "7fffd4",
+			azure: "f0ffff",
+			beige: "f5f5dc",
+			bisque: "ffe4c4",
+			black: "000",
+			blanchedalmond: "ffebcd",
+			blue: "0000ff",
+			blueviolet: "8a2be2",
+			brown: "a52a2a",
+			burlywood: "deb887",
+			cadetblue: "5f9ea0",
+			chartreuse: "7fff00",
+			chocolate: "d2691e",
+			coral: "ff7f50",
+			cornflowerblue: "6495ed",
+			cornsilk: "fff8dc",
+			crimson: "dc143c",
+			cyan: "00ffff",
+			darkblue: "00008b",
+			darkcyan: "008b8b",
+			darkgoldenrod: "b8860b",
+			darkgray: "a9a9a9",
+			darkgreen: "006400",
+			darkgrey: "a9a9a9",
+			darkkhaki: "bdb76b",
+			darkmagenta: "8b008b",
+			darkolivegreen: "556b2f",
+			darkorange: "ff8c00",
+			darkorchid: "9932cc",
+			darkred: "8b0000",
+			darksalmon: "e9967a",
+			darkseagreen: "8fbc8f",
+			darkslateblue: "483d8b",
+			darkslategray: "2f4f4f",
+			darkslategrey: "2f4f4f",
+			darkturquoise: "00ced1",
+			darkviolet: "9400d3",
+			deeppink: "ff1493",
+			deepskyblue: "00bfff",
+			dimgray: "696969",
+			dimgrey: "696969",
+			dodgerblue: "1e90ff",
+			firebrick: "b22222",
+			floralwhite: "fffaf0",
+			forestgreen: "228b22",
+			fuchsia: "ff00ff",
+			gainsboro: "dcdcdc",
+			ghostwhite: "f8f8ff",
+			gold: "ffd700",
+			goldenrod: "daa520",
+			gray: "808080",
+			green: "008000",
+			greenyellow: "adff2f",
+			grey: "808080",
+			honeydew: "f0fff0",
+			hotpink: "ff69b4",
+			indianred: "cd5c5c",
+			indigo: "4b0082",
+			ivory: "fffff0",
+			khaki: "f0e68c",
+			lavender: "e6e6fa",
+			lavenderblush: "fff0f5",
+			lawngreen: "7cfc00",
+			lemonchiffon: "fffacd",
+			lightblue: "add8e6",
+			lightcoral: "f08080",
+			lightcyan: "e0ffff",
+			lightgoldenrodyellow: "fafad2",
+			lightgray: "d3d3d3",
+			lightgreen: "90ee90",
+			lightgrey: "d3d3d3",
+			lightpink: "ffb6c1",
+			lightsalmon: "ffa07a",
+			lightseagreen: "20b2aa",
+			lightskyblue: "87cefa",
+			lightslategray: "789",
+			lightslategrey: "789",
+			lightsteelblue: "b0c4de",
+			lightyellow: "ffffe0",
+			lime: "0f0",
+			limegreen: "32cd32",
+			linen: "faf0e6",
+			magenta: "f0f",
+			maroon: "800000",
+			mediumaquamarine: "66cdaa",
+			mediumblue: "0000cd",
+			mediumorchid: "ba55d3",
+			mediumpurple: "9370db",
+			mediumseagreen: "3cb371",
+			mediumslateblue: "7b68ee",
+			mediumspringgreen: "00fa9a",
+			mediumturquoise: "48d1cc",
+			mediumvioletred: "c71585",
+			midnightblue: "191970",
+			mintcream: "f5fffa",
+			mistyrose: "ffe4e1",
+			moccasin: "ffe4b5",
+			navajowhite: "ffdead",
+			navy: "000080",
+			oldlace: "fdf5e6",
+			olive: "808000",
+			olivedrab: "6b8e23",
+			orange: "ffa500",
+			orangered: "ff4500",
+			orchid: "da70d6",
+			palegoldenrod: "eee8aa",
+			palegreen: "98fb98",
+			paleturquoise: "afeeee",
+			palevioletred: "db7093",
+			papayawhip: "ffefd5",
+			peachpuff: "ffdab9",
+			peru: "cd853f",
+			pink: "ffc0cb",
+			plum: "dda0dd",
+			powderblue: "b0e0e6",
+			purple: "800080",
+			rebeccapurple: "639",
+			red: "f00",
+			rosybrown: "bc8f8f",
+			royalblue: "4169e1",
+			saddlebrown: "8b4513",
+			salmon: "fa8072",
+			sandybrown: "f4a460",
+			seagreen: "2e8b57",
+			seashell: "fff5ee",
+			sienna: "a0522d",
+			silver: "c0c0c0",
+			skyblue: "87ceeb",
+			slateblue: "6a5acd",
+			slategray: "708090",
+			slategrey: "708090",
+			snow: "fffafa",
+			springgreen: "00ff7f",
+			steelblue: "4682b4",
+			tan: "d2b48c",
+			teal: "008080",
+			thistle: "d8bfd8",
+			tomato: "ff6347",
+			turquoise: "40e0d0",
+			violet: "ee82ee",
+			wheat: "f5deb3",
+			white: "fff",
+			whitesmoke: "f5f5f5",
+			yellow: "ff0",
+			yellowgreen: "9acd32"
+		};
+		hexRegex = /^#[a-fA-F0-9]{6}$/;
+		hexRgbaRegex = /^#[a-fA-F0-9]{8}$/;
+		reducedHexRegex = /^#[a-fA-F0-9]{3}$/;
+		reducedRgbaHexRegex = /^#[a-fA-F0-9]{4}$/;
+		rgbRegex = /^rgb\(\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*\)$/i;
+		rgbaRegex = /^rgb(?:a)?\(\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*(?:,|\/)\s*([-+]?\d*[.]?\d+[%]?)\s*\)$/i;
+		hslRegex = /^hsl\(\s*(\d{0,3}[.]?[0-9]+(?:deg)?)\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*\)$/i;
+		hslaRegex = /^hsl(?:a)?\(\s*(\d{0,3}[.]?[0-9]+(?:deg)?)\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*(?:,|\/)\s*([-+]?\d*[.]?\d+[%]?)\s*\)$/i;
+		reduceHexValue$1 = function reduceHexValue(value) {
+			if (value.length === 7 && value[1] === value[2] && value[3] === value[4] && value[5] === value[6]) return "#" + value[1] + value[3] + value[5];
+			return value;
+		};
+		isRgb = function isRgb(color) {
+			return typeof color.red === "number" && typeof color.green === "number" && typeof color.blue === "number" && (typeof color.alpha !== "number" || typeof color.alpha === "undefined");
+		};
+		isRgba = function isRgba(color) {
+			return typeof color.red === "number" && typeof color.green === "number" && typeof color.blue === "number" && typeof color.alpha === "number";
+		};
+		isHsl = function isHsl(color) {
+			return typeof color.hue === "number" && typeof color.saturation === "number" && typeof color.lightness === "number" && (typeof color.alpha !== "number" || typeof color.alpha === "undefined");
+		};
+		isHsla = function isHsla(color) {
+			return typeof color.hue === "number" && typeof color.saturation === "number" && typeof color.lightness === "number" && typeof color.alpha === "number";
+		};
+		curry(adjustHue);
+		curry(darken);
+		curry(desaturate);
+		curry(lighten);
+		mix$1 = curry(mix);
+		curry(opacify);
+		curry(saturate);
+		curry(setHue);
+		curry(setLightness);
+		curry(setSaturation);
+		curry(shade);
+		curry(tint);
+		curriedTransparentize$1 = curry(transparentize);
+	})))();
+}
+//#endregion
+//#region ../../node_modules/ts-dedent/esm/index.js
+function dedent(templ) {
+	var values = [];
+	for (var _i = 1; _i < arguments.length; _i++) values[_i - 1] = arguments[_i];
+	var strings = Array.from(typeof templ === "string" ? [templ] : templ);
+	strings[strings.length - 1] = strings[strings.length - 1].replace(/\r?\n([\t ]*)$/, "");
+	var indentLengths = strings.reduce(function(arr, str) {
+		var matches = str.match(/\n([\t ]+|(?!\s).)/g);
+		if (matches) return arr.concat(matches.map(function(match) {
+			var _a, _b;
+			return (_b = (_a = match.match(/[\t ]/g)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+		}));
+		return arr;
+	}, []);
+	if (indentLengths.length) {
+		var pattern_1 = new RegExp("\n[	 ]{".concat(Math.min.apply(Math, indentLengths), "}"), "g");
+		strings = strings.map(function(str) {
+			return str.replace(pattern_1, "\n");
+		});
+	}
+	strings[0] = strings[0].replace(/^\r?\n/, "");
+	var string = strings[0];
+	values.forEach(function(value, i) {
+		var endentations = string.match(/(?:^|\n)( *)$/);
+		var endentation = endentations ? endentations[1] : "";
+		var indentedValue = value;
+		if (typeof value === "string" && value.includes("\n")) indentedValue = String(value).split("\n").map(function(str, i) {
+			return i === 0 ? str : "".concat(endentation).concat(str);
+		}).join("\n");
+		string += indentedValue + strings[i + 1];
+	});
+	return string;
+}
+function init_esm() {
+	return (init_esm = __esmMin((() => {})))();
+}
+//#endregion
+//#region ../../node_modules/react-is/cjs/react-is.production.min.js
+/**
+* @license React
+* react-is.production.min.js
+*
+* Copyright (c) Facebook, Inc. and its affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_is_production_min = /* @__PURE__ */ __commonJSMin(((exports) => {}));
+//#endregion
+//#region ../../node_modules/react-is/index.js
+var require_react_is = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_react_is_production_min();
+}));
+//#endregion
+//#region ../../node_modules/store2/dist/store2.js
+var require_store2 = /* @__PURE__ */ __commonJSMin(((exports, module, this$1) => {
+	/*! store2 - v2.14.4 - 2024-12-26
+	* Copyright (c) 2024 Nathan Bubna; Licensed MIT */
+	(function(window, define) {
+		var _ = {
+			version: "2.14.4",
+			areas: {},
+			apis: {},
+			nsdelim: ".",
+			inherit: function(api, o) {
+				for (var p in api) if (!o.hasOwnProperty(p)) Object.defineProperty(o, p, Object.getOwnPropertyDescriptor(api, p));
+				return o;
+			},
+			stringify: function(d, fn) {
+				return d === void 0 || typeof d === "function" ? d + "" : JSON.stringify(d, fn || _.replace);
+			},
+			parse: function(s, fn) {
+				try {
+					return JSON.parse(s, fn || _.revive);
+				} catch (e) {
+					return s;
+				}
+			},
+			fn: function(name, fn) {
+				_.storeAPI[name] = fn;
+				for (var api in _.apis) _.apis[api][name] = fn;
+			},
+			get: function(area, key) {
+				return area.getItem(key);
+			},
+			set: function(area, key, string) {
+				area.setItem(key, string);
+			},
+			remove: function(area, key) {
+				area.removeItem(key);
+			},
+			key: function(area, i) {
+				return area.key(i);
+			},
+			length: function(area) {
+				return area.length;
+			},
+			clear: function(area) {
+				area.clear();
+			},
+			Store: function(id, area, namespace) {
+				var store = _.inherit(_.storeAPI, function(key, data, overwrite) {
+					if (arguments.length === 0) return store.getAll();
+					if (typeof data === "function") return store.transact(key, data, overwrite);
+					if (data !== void 0) return store.set(key, data, overwrite);
+					if (typeof key === "string" || typeof key === "number") return store.get(key);
+					if (typeof key === "function") return store.each(key);
+					if (!key) return store.clear();
+					return store.setAll(key, data);
+				});
+				store._id = id;
+				try {
+					var testKey = "__store2_test";
+					area.setItem(testKey, "ok");
+					store._area = area;
+					area.removeItem(testKey);
+				} catch (e) {
+					store._area = _.storage("fake");
+				}
+				store._ns = namespace || "";
+				if (!_.areas[id]) _.areas[id] = store._area;
+				if (!_.apis[store._ns + store._id]) _.apis[store._ns + store._id] = store;
+				return store;
+			},
+			storeAPI: {
+				area: function(id, area) {
+					var store = this[id];
+					if (!store || !store.area) {
+						store = _.Store(id, area, this._ns);
+						if (!this[id]) this[id] = store;
+					}
+					return store;
+				},
+				namespace: function(namespace, singleArea, delim) {
+					delim = delim || this._delim || _.nsdelim;
+					if (!namespace) return this._ns ? this._ns.substring(0, this._ns.length - delim.length) : "";
+					var ns = namespace, store = this[ns];
+					if (!store || !store.namespace) {
+						store = _.Store(this._id, this._area, this._ns + ns + delim);
+						store._delim = delim;
+						if (!this[ns]) this[ns] = store;
+						if (!singleArea) for (var name in _.areas) store.area(name, _.areas[name]);
+					}
+					return store;
+				},
+				isFake: function(force) {
+					if (force) {
+						this._real = this._area;
+						this._area = _.storage("fake");
+					} else if (force === false) this._area = this._real || this._area;
+					return this._area.name === "fake";
+				},
+				toString: function() {
+					return "store" + (this._ns ? "." + this.namespace() : "") + "[" + this._id + "]";
+				},
+				has: function(key) {
+					if (this._area.has) return this._area.has(this._in(key));
+					return !!(this._in(key) in this._area);
+				},
+				size: function() {
+					return this.keys().length;
+				},
+				each: function(fn, fill) {
+					for (var i = 0, m = _.length(this._area); i < m; i++) {
+						var key = this._out(_.key(this._area, i));
+						if (key !== void 0) {
+							if (fn.call(this, key, this.get(key), fill) === false) break;
+						}
+						if (m > _.length(this._area)) {
+							m--;
+							i--;
+						}
+					}
+					return fill || this;
+				},
+				keys: function(fillList) {
+					return this.each(function(k, v, list) {
+						list.push(k);
+					}, fillList || []);
+				},
+				get: function(key, alt) {
+					var s = _.get(this._area, this._in(key)), fn;
+					if (typeof alt === "function") {
+						fn = alt;
+						alt = null;
+					}
+					return s !== null ? _.parse(s, fn) : alt != null ? alt : s;
+				},
+				getAll: function(fillObj) {
+					return this.each(function(k, v, all) {
+						all[k] = v;
+					}, fillObj || {});
+				},
+				transact: function(key, fn, alt) {
+					var val = this.get(key, alt), ret = fn(val);
+					this.set(key, ret === void 0 ? val : ret);
+					return this;
+				},
+				set: function(key, data, overwrite) {
+					var d = this.get(key), replacer;
+					if (d != null && overwrite === false) return data;
+					if (typeof overwrite === "function") {
+						replacer = overwrite;
+						overwrite = void 0;
+					}
+					return _.set(this._area, this._in(key), _.stringify(data, replacer), overwrite) || d;
+				},
+				setAll: function(data, overwrite) {
+					var changed, val;
+					for (var key in data) {
+						val = data[key];
+						if (this.set(key, val, overwrite) !== val) changed = true;
+					}
+					return changed;
+				},
+				add: function(key, data, replacer) {
+					var d = this.get(key);
+					if (d instanceof Array) data = d.concat(data);
+					else if (d !== null) {
+						var type = typeof d;
+						if (type === typeof data && type === "object") {
+							for (var k in data) d[k] = data[k];
+							data = d;
+						} else data = d + data;
+					}
+					_.set(this._area, this._in(key), _.stringify(data, replacer));
+					return data;
+				},
+				remove: function(key, alt) {
+					var d = this.get(key, alt);
+					_.remove(this._area, this._in(key));
+					return d;
+				},
+				clear: function() {
+					if (!this._ns) _.clear(this._area);
+					else this.each(function(k) {
+						_.remove(this._area, this._in(k));
+					}, 1);
+					return this;
+				},
+				clearAll: function() {
+					var area = this._area;
+					for (var id in _.areas) if (_.areas.hasOwnProperty(id)) {
+						this._area = _.areas[id];
+						this.clear();
+					}
+					this._area = area;
+					return this;
+				},
+				_in: function(k) {
+					if (typeof k !== "string") k = _.stringify(k);
+					return this._ns ? this._ns + k : k;
+				},
+				_out: function(k) {
+					return this._ns ? k && k.indexOf(this._ns) === 0 ? k.substring(this._ns.length) : void 0 : k;
+				}
+			},
+			storage: function(name) {
+				return _.inherit(_.storageAPI, {
+					items: {},
+					name
+				});
+			},
+			storageAPI: {
+				length: 0,
+				has: function(k) {
+					return this.items.hasOwnProperty(k);
+				},
+				key: function(i) {
+					var c = 0;
+					for (var k in this.items) if (this.has(k) && i === c++) return k;
+				},
+				setItem: function(k, v) {
+					if (!this.has(k)) this.length++;
+					this.items[k] = v;
+				},
+				removeItem: function(k) {
+					if (this.has(k)) {
+						delete this.items[k];
+						this.length--;
+					}
+				},
+				getItem: function(k) {
+					return this.has(k) ? this.items[k] : null;
+				},
+				clear: function() {
+					for (var k in this.items) this.removeItem(k);
+				}
+			}
+		};
+		var store = _.Store("local", (function() {
+			try {
+				return localStorage;
+			} catch (e) {}
+		})());
+		store.local = store;
+		store._ = _;
+		store.area("session", (function() {
+			try {
+				return sessionStorage;
+			} catch (e) {}
+		})());
+		store.area("page", _.storage("page"));
+		if (typeof define === "function" && define.amd !== void 0) define("store2", [], function() {
+			return store;
+		});
+		else if (typeof module !== "undefined" && module.exports) module.exports = store;
+		else {
+			if (window.store) _.conflict = window.store;
+			window.store = store;
+		}
+	})(this$1, this$1 && this$1.define);
+}));
+//#endregion
+export { curriedTransparentize$1 as a, require_with_selector as c, useTransitionState as d, W as f, require_prop_types as h, init_esm as i, require_shim as l, q as m, require_react_is as n, init_polished_esm as o, init_index_module as p, dedent as r, require_memoizerific as s, require_store2 as t, init_useTransitionState as u };