font-controls 1.0.0

package/dist/font-controls.js

@@ -0,0 +1,2840 @@
+import Ie, { useState as Ae, useEffect as wt } from "react";
+import Xt from "react-dom";
+function Cr(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var at = { exports: {} }, De = {};
+/**
+ * @license React
+ * react-jsx-runtime.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 Pt;
+function wr() {
+  if (Pt) return De;
+  Pt = 1;
+  var e = Ie, t = Symbol.for("react.element"), r = Symbol.for("react.fragment"), o = Object.prototype.hasOwnProperty, a = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, u = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function p(c, d, m) {
+    var g, T = {}, A = null, Y = null;
+    m !== void 0 && (A = "" + m), d.key !== void 0 && (A = "" + d.key), d.ref !== void 0 && (Y = d.ref);
+    for (g in d) o.call(d, g) && !u.hasOwnProperty(g) && (T[g] = d[g]);
+    if (c && c.defaultProps) for (g in d = c.defaultProps, d) T[g] === void 0 && (T[g] = d[g]);
+    return { $$typeof: t, type: c, key: A, ref: Y, props: T, _owner: a.current };
+  }
+  return De.Fragment = r, De.jsx = p, De.jsxs = p, De;
+}
+var Ne = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Rt;
+function Pr() {
+  return Rt || (Rt = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = Ie, t = Symbol.for("react.element"), r = Symbol.for("react.portal"), o = Symbol.for("react.fragment"), a = Symbol.for("react.strict_mode"), u = Symbol.for("react.profiler"), p = Symbol.for("react.provider"), c = Symbol.for("react.context"), d = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), g = Symbol.for("react.suspense_list"), T = Symbol.for("react.memo"), A = Symbol.for("react.lazy"), Y = Symbol.for("react.offscreen"), q = Symbol.iterator, X = "@@iterator";
+    function _(n) {
+      if (n === null || typeof n != "object")
+        return null;
+      var s = q && n[q] || n[X];
+      return typeof s == "function" ? s : null;
+    }
+    var x = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function b(n) {
+      {
+        for (var s = arguments.length, v = new Array(s > 1 ? s - 1 : 0), E = 1; E < s; E++)
+          v[E - 1] = arguments[E];
+        C("error", n, v);
+      }
+    }
+    function C(n, s, v) {
+      {
+        var E = x.ReactDebugCurrentFrame, W = E.getStackAddendum();
+        W !== "" && (s += "%s", v = v.concat([W]));
+        var B = v.map(function(F) {
+          return String(F);
+        });
+        B.unshift("Warning: " + s), Function.prototype.apply.call(console[n], console, B);
+      }
+    }
+    var S = !1, i = !1, k = !1, Z = !1, Q = !1, G;
+    G = Symbol.for("react.module.reference");
+    function J(n) {
+      return !!(typeof n == "string" || typeof n == "function" || n === o || n === u || Q || n === a || n === m || n === g || Z || n === Y || S || i || k || typeof n == "object" && n !== null && (n.$$typeof === A || n.$$typeof === T || n.$$typeof === p || n.$$typeof === c || n.$$typeof === d || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      n.$$typeof === G || n.getModuleId !== void 0));
+    }
+    function me(n, s, v) {
+      var E = n.displayName;
+      if (E)
+        return E;
+      var W = s.displayName || s.name || "";
+      return W !== "" ? v + "(" + W + ")" : v;
+    }
+    function be(n) {
+      return n.displayName || "Context";
+    }
+    function ne(n) {
+      if (n == null)
+        return null;
+      if (typeof n.tag == "number" && b("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof n == "function")
+        return n.displayName || n.name || null;
+      if (typeof n == "string")
+        return n;
+      switch (n) {
+        case o:
+          return "Fragment";
+        case r:
+          return "Portal";
+        case u:
+          return "Profiler";
+        case a:
+          return "StrictMode";
+        case m:
+          return "Suspense";
+        case g:
+          return "SuspenseList";
+      }
+      if (typeof n == "object")
+        switch (n.$$typeof) {
+          case c:
+            var s = n;
+            return be(s) + ".Consumer";
+          case p:
+            var v = n;
+            return be(v._context) + ".Provider";
+          case d:
+            return me(n, n.render, "ForwardRef");
+          case T:
+            var E = n.displayName || null;
+            return E !== null ? E : ne(n.type) || "Memo";
+          case A: {
+            var W = n, B = W._payload, F = W._init;
+            try {
+              return ne(F(B));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var K = Object.assign, he = 0, ee, le, ve, Se, l, y, O;
+    function j() {
+    }
+    j.__reactDisabledLog = !0;
+    function w() {
+      {
+        if (he === 0) {
+          ee = console.log, le = console.info, ve = console.warn, Se = console.error, l = console.group, y = console.groupCollapsed, O = console.groupEnd;
+          var n = {
+            configurable: !0,
+            enumerable: !0,
+            value: j,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: n,
+            log: n,
+            warn: n,
+            error: n,
+            group: n,
+            groupCollapsed: n,
+            groupEnd: n
+          });
+        }
+        he++;
+      }
+    }
+    function $() {
+      {
+        if (he--, he === 0) {
+          var n = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: K({}, n, {
+              value: ee
+            }),
+            info: K({}, n, {
+              value: le
+            }),
+            warn: K({}, n, {
+              value: ve
+            }),
+            error: K({}, n, {
+              value: Se
+            }),
+            group: K({}, n, {
+              value: l
+            }),
+            groupCollapsed: K({}, n, {
+              value: y
+            }),
+            groupEnd: K({}, n, {
+              value: O
+            })
+          });
+        }
+        he < 0 && b("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var P = x.ReactCurrentDispatcher, R;
+    function D(n, s, v) {
+      {
+        if (R === void 0)
+          try {
+            throw Error();
+          } catch (W) {
+            var E = W.stack.trim().match(/\n( *(at )?)/);
+            R = E && E[1] || "";
+          }
+        return `
+` + R + n;
+      }
+    }
+    var I = !1, N;
+    {
+      var te = typeof WeakMap == "function" ? WeakMap : Map;
+      N = new te();
+    }
+    function h(n, s) {
+      if (!n || I)
+        return "";
+      {
+        var v = N.get(n);
+        if (v !== void 0)
+          return v;
+      }
+      var E;
+      I = !0;
+      var W = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var B;
+      B = P.current, P.current = null, w();
+      try {
+        if (s) {
+          var F = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(F.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(F, []);
+            } catch (se) {
+              E = se;
+            }
+            Reflect.construct(n, [], F);
+          } else {
+            try {
+              F.call();
+            } catch (se) {
+              E = se;
+            }
+            n.call(F.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (se) {
+            E = se;
+          }
+          n();
+        }
+      } catch (se) {
+        if (se && E && typeof se.stack == "string") {
+          for (var M = se.stack.split(`
+`), oe = E.stack.split(`
+`), H = M.length - 1, z = oe.length - 1; H >= 1 && z >= 0 && M[H] !== oe[z]; )
+            z--;
+          for (; H >= 1 && z >= 0; H--, z--)
+            if (M[H] !== oe[z]) {
+              if (H !== 1 || z !== 1)
+                do
+                  if (H--, z--, z < 0 || M[H] !== oe[z]) {
+                    var de = `
+` + M[H].replace(" at new ", " at ");
+                    return n.displayName && de.includes("<anonymous>") && (de = de.replace("<anonymous>", n.displayName)), typeof n == "function" && N.set(n, de), de;
+                  }
+                while (H >= 1 && z >= 0);
+              break;
+            }
+        }
+      } finally {
+        I = !1, P.current = B, $(), Error.prepareStackTrace = W;
+      }
+      var Re = n ? n.displayName || n.name : "", _e = Re ? D(Re) : "";
+      return typeof n == "function" && N.set(n, _e), _e;
+    }
+    function fe(n, s, v) {
+      return h(n, !1);
+    }
+    function we(n) {
+      var s = n.prototype;
+      return !!(s && s.isReactComponent);
+    }
+    function Te(n, s, v) {
+      if (n == null)
+        return "";
+      if (typeof n == "function")
+        return h(n, we(n));
+      if (typeof n == "string")
+        return D(n);
+      switch (n) {
+        case m:
+          return D("Suspense");
+        case g:
+          return D("SuspenseList");
+      }
+      if (typeof n == "object")
+        switch (n.$$typeof) {
+          case d:
+            return fe(n.render);
+          case T:
+            return Te(n.type, s, v);
+          case A: {
+            var E = n, W = E._payload, B = E._init;
+            try {
+              return Te(B(W), s, v);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var Oe = Object.prototype.hasOwnProperty, dt = {}, pt = x.ReactDebugCurrentFrame;
+    function ke(n) {
+      if (n) {
+        var s = n._owner, v = Te(n.type, n._source, s ? s.type : null);
+        pt.setExtraStackFrame(v);
+      } else
+        pt.setExtraStackFrame(null);
+    }
+    function nr(n, s, v, E, W) {
+      {
+        var B = Function.call.bind(Oe);
+        for (var F in n)
+          if (B(n, F)) {
+            var M = void 0;
+            try {
+              if (typeof n[F] != "function") {
+                var oe = Error((E || "React class") + ": " + v + " type `" + F + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof n[F] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw oe.name = "Invariant Violation", oe;
+              }
+              M = n[F](s, F, E, v, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (H) {
+              M = H;
+            }
+            M && !(M instanceof Error) && (ke(W), b("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", E || "React class", v, F, typeof M), ke(null)), M instanceof Error && !(M.message in dt) && (dt[M.message] = !0, ke(W), b("Failed %s type: %s", v, M.message), ke(null));
+          }
+      }
+    }
+    var or = Array.isArray;
+    function Xe(n) {
+      return or(n);
+    }
+    function ar(n) {
+      {
+        var s = typeof Symbol == "function" && Symbol.toStringTag, v = s && n[Symbol.toStringTag] || n.constructor.name || "Object";
+        return v;
+      }
+    }
+    function ir(n) {
+      try {
+        return ht(n), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function ht(n) {
+      return "" + n;
+    }
+    function vt(n) {
+      if (ir(n))
+        return b("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", ar(n)), ht(n);
+    }
+    var gt = x.ReactCurrentOwner, sr = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, yt, mt;
+    function lr(n) {
+      if (Oe.call(n, "ref")) {
+        var s = Object.getOwnPropertyDescriptor(n, "ref").get;
+        if (s && s.isReactWarning)
+          return !1;
+      }
+      return n.ref !== void 0;
+    }
+    function ur(n) {
+      if (Oe.call(n, "key")) {
+        var s = Object.getOwnPropertyDescriptor(n, "key").get;
+        if (s && s.isReactWarning)
+          return !1;
+      }
+      return n.key !== void 0;
+    }
+    function cr(n, s) {
+      typeof n.ref == "string" && gt.current;
+    }
+    function fr(n, s) {
+      {
+        var v = function() {
+          yt || (yt = !0, b("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", s));
+        };
+        v.isReactWarning = !0, Object.defineProperty(n, "key", {
+          get: v,
+          configurable: !0
+        });
+      }
+    }
+    function dr(n, s) {
+      {
+        var v = function() {
+          mt || (mt = !0, b("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", s));
+        };
+        v.isReactWarning = !0, Object.defineProperty(n, "ref", {
+          get: v,
+          configurable: !0
+        });
+      }
+    }
+    var pr = function(n, s, v, E, W, B, F) {
+      var M = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: t,
+        // Built-in properties that belong on the element
+        type: n,
+        key: s,
+        ref: v,
+        props: F,
+        // Record the component responsible for creating this element.
+        _owner: B
+      };
+      return M._store = {}, Object.defineProperty(M._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(M, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: E
+      }), Object.defineProperty(M, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: W
+      }), Object.freeze && (Object.freeze(M.props), Object.freeze(M)), M;
+    };
+    function hr(n, s, v, E, W) {
+      {
+        var B, F = {}, M = null, oe = null;
+        v !== void 0 && (vt(v), M = "" + v), ur(s) && (vt(s.key), M = "" + s.key), lr(s) && (oe = s.ref, cr(s, W));
+        for (B in s)
+          Oe.call(s, B) && !sr.hasOwnProperty(B) && (F[B] = s[B]);
+        if (n && n.defaultProps) {
+          var H = n.defaultProps;
+          for (B in H)
+            F[B] === void 0 && (F[B] = H[B]);
+        }
+        if (M || oe) {
+          var z = typeof n == "function" ? n.displayName || n.name || "Unknown" : n;
+          M && fr(F, z), oe && dr(F, z);
+        }
+        return pr(n, M, oe, W, E, gt.current, F);
+      }
+    }
+    var qe = x.ReactCurrentOwner, bt = x.ReactDebugCurrentFrame;
+    function Pe(n) {
+      if (n) {
+        var s = n._owner, v = Te(n.type, n._source, s ? s.type : null);
+        bt.setExtraStackFrame(v);
+      } else
+        bt.setExtraStackFrame(null);
+    }
+    var Be;
+    Be = !1;
+    function Ve(n) {
+      return typeof n == "object" && n !== null && n.$$typeof === t;
+    }
+    function St() {
+      {
+        if (qe.current) {
+          var n = ne(qe.current.type);
+          if (n)
+            return `
+
+Check the render method of \`` + n + "`.";
+        }
+        return "";
+      }
+    }
+    function vr(n) {
+      return "";
+    }
+    var xt = {};
+    function gr(n) {
+      {
+        var s = St();
+        if (!s) {
+          var v = typeof n == "string" ? n : n.displayName || n.name;
+          v && (s = `
+
+Check the top-level render call using <` + v + ">.");
+        }
+        return s;
+      }
+    }
+    function Et(n, s) {
+      {
+        if (!n._store || n._store.validated || n.key != null)
+          return;
+        n._store.validated = !0;
+        var v = gr(s);
+        if (xt[v])
+          return;
+        xt[v] = !0;
+        var E = "";
+        n && n._owner && n._owner !== qe.current && (E = " It was passed a child from " + ne(n._owner.type) + "."), Pe(n), b('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', v, E), Pe(null);
+      }
+    }
+    function Tt(n, s) {
+      {
+        if (typeof n != "object")
+          return;
+        if (Xe(n))
+          for (var v = 0; v < n.length; v++) {
+            var E = n[v];
+            Ve(E) && Et(E, s);
+          }
+        else if (Ve(n))
+          n._store && (n._store.validated = !0);
+        else if (n) {
+          var W = _(n);
+          if (typeof W == "function" && W !== n.entries)
+            for (var B = W.call(n), F; !(F = B.next()).done; )
+              Ve(F.value) && Et(F.value, s);
+        }
+      }
+    }
+    function yr(n) {
+      {
+        var s = n.type;
+        if (s == null || typeof s == "string")
+          return;
+        var v;
+        if (typeof s == "function")
+          v = s.propTypes;
+        else if (typeof s == "object" && (s.$$typeof === d || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        s.$$typeof === T))
+          v = s.propTypes;
+        else
+          return;
+        if (v) {
+          var E = ne(s);
+          nr(v, n.props, "prop", E, n);
+        } else if (s.PropTypes !== void 0 && !Be) {
+          Be = !0;
+          var W = ne(s);
+          b("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", W || "Unknown");
+        }
+        typeof s.getDefaultProps == "function" && !s.getDefaultProps.isReactClassApproved && b("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function mr(n) {
+      {
+        for (var s = Object.keys(n.props), v = 0; v < s.length; v++) {
+          var E = s[v];
+          if (E !== "children" && E !== "key") {
+            Pe(n), b("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", E), Pe(null);
+            break;
+          }
+        }
+        n.ref !== null && (Pe(n), b("Invalid attribute `ref` supplied to `React.Fragment`."), Pe(null));
+      }
+    }
+    var _t = {};
+    function Ct(n, s, v, E, W, B) {
+      {
+        var F = J(n);
+        if (!F) {
+          var M = "";
+          (n === void 0 || typeof n == "object" && n !== null && Object.keys(n).length === 0) && (M += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var oe = vr();
+          oe ? M += oe : M += St();
+          var H;
+          n === null ? H = "null" : Xe(n) ? H = "array" : n !== void 0 && n.$$typeof === t ? (H = "<" + (ne(n.type) || "Unknown") + " />", M = " Did you accidentally export a JSX literal instead of a component?") : H = typeof n, b("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", H, M);
+        }
+        var z = hr(n, s, v, W, B);
+        if (z == null)
+          return z;
+        if (F) {
+          var de = s.children;
+          if (de !== void 0)
+            if (E)
+              if (Xe(de)) {
+                for (var Re = 0; Re < de.length; Re++)
+                  Tt(de[Re], n);
+                Object.freeze && Object.freeze(de);
+              } else
+                b("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              Tt(de, n);
+        }
+        if (Oe.call(s, "key")) {
+          var _e = ne(n), se = Object.keys(s).filter(function(_r) {
+            return _r !== "key";
+          }), He = se.length > 0 ? "{key: someKey, " + se.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!_t[_e + He]) {
+            var Tr = se.length > 0 ? "{" + se.join(": ..., ") + ": ...}" : "{}";
+            b(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, He, _e, Tr, _e), _t[_e + He] = !0;
+          }
+        }
+        return n === o ? mr(z) : yr(z), z;
+      }
+    }
+    function br(n, s, v) {
+      return Ct(n, s, v, !0);
+    }
+    function Sr(n, s, v) {
+      return Ct(n, s, v, !1);
+    }
+    var xr = Sr, Er = br;
+    Ne.Fragment = o, Ne.jsx = xr, Ne.jsxs = Er;
+  }()), Ne;
+}
+process.env.NODE_ENV === "production" ? at.exports = wr() : at.exports = Pr();
+var f = at.exports, Ye = { exports: {} }, qt = {}, it = { exports: {} }, $e = { exports: {} }, L = {};
+/** @license React v16.13.1
+ * 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 jt;
+function Rr() {
+  if (jt) return L;
+  jt = 1;
+  var e = typeof Symbol == "function" && Symbol.for, t = e ? Symbol.for("react.element") : 60103, r = e ? Symbol.for("react.portal") : 60106, o = e ? Symbol.for("react.fragment") : 60107, a = e ? Symbol.for("react.strict_mode") : 60108, u = e ? Symbol.for("react.profiler") : 60114, p = e ? Symbol.for("react.provider") : 60109, c = e ? Symbol.for("react.context") : 60110, d = e ? Symbol.for("react.async_mode") : 60111, m = e ? Symbol.for("react.concurrent_mode") : 60111, g = e ? Symbol.for("react.forward_ref") : 60112, T = e ? Symbol.for("react.suspense") : 60113, A = e ? Symbol.for("react.suspense_list") : 60120, Y = e ? Symbol.for("react.memo") : 60115, q = e ? Symbol.for("react.lazy") : 60116, X = e ? Symbol.for("react.block") : 60121, _ = e ? Symbol.for("react.fundamental") : 60117, x = e ? Symbol.for("react.responder") : 60118, b = e ? Symbol.for("react.scope") : 60119;
+  function C(i) {
+    if (typeof i == "object" && i !== null) {
+      var k = i.$$typeof;
+      switch (k) {
+        case t:
+          switch (i = i.type, i) {
+            case d:
+            case m:
+            case o:
+            case u:
+            case a:
+            case T:
+              return i;
+            default:
+              switch (i = i && i.$$typeof, i) {
+                case c:
+                case g:
+                case q:
+                case Y:
+                case p:
+                  return i;
+                default:
+                  return k;
+              }
+          }
+        case r:
+          return k;
+      }
+    }
+  }
+  function S(i) {
+    return C(i) === m;
+  }
+  return L.AsyncMode = d, L.ConcurrentMode = m, L.ContextConsumer = c, L.ContextProvider = p, L.Element = t, L.ForwardRef = g, L.Fragment = o, L.Lazy = q, L.Memo = Y, L.Portal = r, L.Profiler = u, L.StrictMode = a, L.Suspense = T, L.isAsyncMode = function(i) {
+    return S(i) || C(i) === d;
+  }, L.isConcurrentMode = S, L.isContextConsumer = function(i) {
+    return C(i) === c;
+  }, L.isContextProvider = function(i) {
+    return C(i) === p;
+  }, L.isElement = function(i) {
+    return typeof i == "object" && i !== null && i.$$typeof === t;
+  }, L.isForwardRef = function(i) {
+    return C(i) === g;
+  }, L.isFragment = function(i) {
+    return C(i) === o;
+  }, L.isLazy = function(i) {
+    return C(i) === q;
+  }, L.isMemo = function(i) {
+    return C(i) === Y;
+  }, L.isPortal = function(i) {
+    return C(i) === r;
+  }, L.isProfiler = function(i) {
+    return C(i) === u;
+  }, L.isStrictMode = function(i) {
+    return C(i) === a;
+  }, L.isSuspense = function(i) {
+    return C(i) === T;
+  }, L.isValidElementType = function(i) {
+    return typeof i == "string" || typeof i == "function" || i === o || i === m || i === u || i === a || i === T || i === A || typeof i == "object" && i !== null && (i.$$typeof === q || i.$$typeof === Y || i.$$typeof === p || i.$$typeof === c || i.$$typeof === g || i.$$typeof === _ || i.$$typeof === x || i.$$typeof === b || i.$$typeof === X);
+  }, L.typeOf = C, L;
+}
+var U = {};
+/** @license React v16.13.1
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ot;
+function jr() {
+  return Ot || (Ot = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = typeof Symbol == "function" && Symbol.for, t = e ? Symbol.for("react.element") : 60103, r = e ? Symbol.for("react.portal") : 60106, o = e ? Symbol.for("react.fragment") : 60107, a = e ? Symbol.for("react.strict_mode") : 60108, u = e ? Symbol.for("react.profiler") : 60114, p = e ? Symbol.for("react.provider") : 60109, c = e ? Symbol.for("react.context") : 60110, d = e ? Symbol.for("react.async_mode") : 60111, m = e ? Symbol.for("react.concurrent_mode") : 60111, g = e ? Symbol.for("react.forward_ref") : 60112, T = e ? Symbol.for("react.suspense") : 60113, A = e ? Symbol.for("react.suspense_list") : 60120, Y = e ? Symbol.for("react.memo") : 60115, q = e ? Symbol.for("react.lazy") : 60116, X = e ? Symbol.for("react.block") : 60121, _ = e ? Symbol.for("react.fundamental") : 60117, x = e ? Symbol.for("react.responder") : 60118, b = e ? Symbol.for("react.scope") : 60119;
+    function C(h) {
+      return typeof h == "string" || typeof h == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+      h === o || h === m || h === u || h === a || h === T || h === A || typeof h == "object" && h !== null && (h.$$typeof === q || h.$$typeof === Y || h.$$typeof === p || h.$$typeof === c || h.$$typeof === g || h.$$typeof === _ || h.$$typeof === x || h.$$typeof === b || h.$$typeof === X);
+    }
+    function S(h) {
+      if (typeof h == "object" && h !== null) {
+        var fe = h.$$typeof;
+        switch (fe) {
+          case t:
+            var we = h.type;
+            switch (we) {
+              case d:
+              case m:
+              case o:
+              case u:
+              case a:
+              case T:
+                return we;
+              default:
+                var Te = we && we.$$typeof;
+                switch (Te) {
+                  case c:
+                  case g:
+                  case q:
+                  case Y:
+                  case p:
+                    return Te;
+                  default:
+                    return fe;
+                }
+            }
+          case r:
+            return fe;
+        }
+      }
+    }
+    var i = d, k = m, Z = c, Q = p, G = t, J = g, me = o, be = q, ne = Y, K = r, he = u, ee = a, le = T, ve = !1;
+    function Se(h) {
+      return ve || (ve = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.")), l(h) || S(h) === d;
+    }
+    function l(h) {
+      return S(h) === m;
+    }
+    function y(h) {
+      return S(h) === c;
+    }
+    function O(h) {
+      return S(h) === p;
+    }
+    function j(h) {
+      return typeof h == "object" && h !== null && h.$$typeof === t;
+    }
+    function w(h) {
+      return S(h) === g;
+    }
+    function $(h) {
+      return S(h) === o;
+    }
+    function P(h) {
+      return S(h) === q;
+    }
+    function R(h) {
+      return S(h) === Y;
+    }
+    function D(h) {
+      return S(h) === r;
+    }
+    function I(h) {
+      return S(h) === u;
+    }
+    function N(h) {
+      return S(h) === a;
+    }
+    function te(h) {
+      return S(h) === T;
+    }
+    U.AsyncMode = i, U.ConcurrentMode = k, U.ContextConsumer = Z, U.ContextProvider = Q, U.Element = G, U.ForwardRef = J, U.Fragment = me, U.Lazy = be, U.Memo = ne, U.Portal = K, U.Profiler = he, U.StrictMode = ee, U.Suspense = le, U.isAsyncMode = Se, U.isConcurrentMode = l, U.isContextConsumer = y, U.isContextProvider = O, U.isElement = j, U.isForwardRef = w, U.isFragment = $, U.isLazy = P, U.isMemo = R, U.isPortal = D, U.isProfiler = I, U.isStrictMode = N, U.isSuspense = te, U.isValidElementType = C, U.typeOf = S;
+  }()), U;
+}
+var Dt;
+function Bt() {
+  return Dt || (Dt = 1, process.env.NODE_ENV === "production" ? $e.exports = Rr() : $e.exports = jr()), $e.exports;
+}
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var ze, Nt;
+function Or() {
+  if (Nt) return ze;
+  Nt = 1;
+  var e = Object.getOwnPropertySymbols, t = Object.prototype.hasOwnProperty, r = Object.prototype.propertyIsEnumerable;
+  function o(u) {
+    if (u == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(u);
+  }
+  function a() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var u = new String("abc");
+      if (u[5] = "de", Object.getOwnPropertyNames(u)[0] === "5")
+        return !1;
+      for (var p = {}, c = 0; c < 10; c++)
+        p["_" + String.fromCharCode(c)] = c;
+      var d = Object.getOwnPropertyNames(p).map(function(g) {
+        return p[g];
+      });
+      if (d.join("") !== "0123456789")
+        return !1;
+      var m = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(g) {
+        m[g] = g;
+      }), Object.keys(Object.assign({}, m)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return ze = a() ? Object.assign : function(u, p) {
+    for (var c, d = o(u), m, g = 1; g < arguments.length; g++) {
+      c = Object(arguments[g]);
+      for (var T in c)
+        t.call(c, T) && (d[T] = c[T]);
+      if (e) {
+        m = e(c);
+        for (var A = 0; A < m.length; A++)
+          r.call(c, m[A]) && (d[m[A]] = c[m[A]]);
+      }
+    }
+    return d;
+  }, ze;
+}
+var Ge, Mt;
+function lt() {
+  if (Mt) return Ge;
+  Mt = 1;
+  var e = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return Ge = e, Ge;
+}
+var Je, At;
+function Vt() {
+  return At || (At = 1, Je = Function.call.bind(Object.prototype.hasOwnProperty)), Je;
+}
+var Ke, kt;
+function Dr() {
+  if (kt) return Ke;
+  kt = 1;
+  var e = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var t = lt(), r = {}, o = Vt();
+    e = function(u) {
+      var p = "Warning: " + u;
+      typeof console < "u" && console.error(p);
+      try {
+        throw new Error(p);
+      } catch {
+      }
+    };
+  }
+  function a(u, p, c, d, m) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var g in u)
+        if (o(u, g)) {
+          var T;
+          try {
+            if (typeof u[g] != "function") {
+              var A = Error(
+                (d || "React class") + ": " + c + " type `" + g + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof u[g] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw A.name = "Invariant Violation", A;
+            }
+            T = u[g](p, g, d, c, null, t);
+          } catch (q) {
+            T = q;
+          }
+          if (T && !(T instanceof Error) && e(
+            (d || "React class") + ": type specification of " + c + " `" + g + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof T + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), T instanceof Error && !(T.message in r)) {
+            r[T.message] = !0;
+            var Y = m ? m() : "";
+            e(
+              "Failed " + c + " type: " + T.message + (Y ?? "")
+            );
+          }
+        }
+    }
+  }
+  return a.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (r = {});
+  }, Ke = a, Ke;
+}
+var Ze, $t;
+function Nr() {
+  if ($t) return Ze;
+  $t = 1;
+  var e = Bt(), t = Or(), r = lt(), o = Vt(), a = Dr(), u = function() {
+  };
+  process.env.NODE_ENV !== "production" && (u = function(c) {
+    var d = "Warning: " + c;
+    typeof console < "u" && console.error(d);
+    try {
+      throw new Error(d);
+    } catch {
+    }
+  });
+  function p() {
+    return null;
+  }
+  return Ze = function(c, d) {
+    var m = typeof Symbol == "function" && Symbol.iterator, g = "@@iterator";
+    function T(l) {
+      var y = l && (m && l[m] || l[g]);
+      if (typeof y == "function")
+        return y;
+    }
+    var A = "<<anonymous>>", Y = {
+      array: x("array"),
+      bigint: x("bigint"),
+      bool: x("boolean"),
+      func: x("function"),
+      number: x("number"),
+      object: x("object"),
+      string: x("string"),
+      symbol: x("symbol"),
+      any: b(),
+      arrayOf: C,
+      element: S(),
+      elementType: i(),
+      instanceOf: k,
+      node: J(),
+      objectOf: Q,
+      oneOf: Z,
+      oneOfType: G,
+      shape: be,
+      exact: ne
+    };
+    function q(l, y) {
+      return l === y ? l !== 0 || 1 / l === 1 / y : l !== l && y !== y;
+    }
+    function X(l, y) {
+      this.message = l, this.data = y && typeof y == "object" ? y : {}, this.stack = "";
+    }
+    X.prototype = Error.prototype;
+    function _(l) {
+      if (process.env.NODE_ENV !== "production")
+        var y = {}, O = 0;
+      function j($, P, R, D, I, N, te) {
+        if (D = D || A, N = N || R, te !== r) {
+          if (d) {
+            var h = 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"
+            );
+            throw h.name = "Invariant Violation", h;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var fe = D + ":" + R;
+            !y[fe] && // Avoid spamming the console because they are often not actionable except for lib authors
+            O < 3 && (u(
+              "You are manually calling a React.PropTypes validation function for the `" + N + "` prop on `" + D + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
+            ), y[fe] = !0, O++);
+          }
+        }
+        return P[R] == null ? $ ? P[R] === null ? new X("The " + I + " `" + N + "` is marked as required " + ("in `" + D + "`, but its value is `null`.")) : new X("The " + I + " `" + N + "` is marked as required in " + ("`" + D + "`, but its value is `undefined`.")) : null : l(P, R, D, I, N);
+      }
+      var w = j.bind(null, !1);
+      return w.isRequired = j.bind(null, !0), w;
+    }
+    function x(l) {
+      function y(O, j, w, $, P, R) {
+        var D = O[j], I = ee(D);
+        if (I !== l) {
+          var N = le(D);
+          return new X(
+            "Invalid " + $ + " `" + P + "` of type " + ("`" + N + "` supplied to `" + w + "`, expected ") + ("`" + l + "`."),
+            { expectedType: l }
+          );
+        }
+        return null;
+      }
+      return _(y);
+    }
+    function b() {
+      return _(p);
+    }
+    function C(l) {
+      function y(O, j, w, $, P) {
+        if (typeof l != "function")
+          return new X("Property `" + P + "` of component `" + w + "` has invalid PropType notation inside arrayOf.");
+        var R = O[j];
+        if (!Array.isArray(R)) {
+          var D = ee(R);
+          return new X("Invalid " + $ + " `" + P + "` of type " + ("`" + D + "` supplied to `" + w + "`, expected an array."));
+        }
+        for (var I = 0; I < R.length; I++) {
+          var N = l(R, I, w, $, P + "[" + I + "]", r);
+          if (N instanceof Error)
+            return N;
+        }
+        return null;
+      }
+      return _(y);
+    }
+    function S() {
+      function l(y, O, j, w, $) {
+        var P = y[O];
+        if (!c(P)) {
+          var R = ee(P);
+          return new X("Invalid " + w + " `" + $ + "` of type " + ("`" + R + "` supplied to `" + j + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return _(l);
+    }
+    function i() {
+      function l(y, O, j, w, $) {
+        var P = y[O];
+        if (!e.isValidElementType(P)) {
+          var R = ee(P);
+          return new X("Invalid " + w + " `" + $ + "` of type " + ("`" + R + "` supplied to `" + j + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return _(l);
+    }
+    function k(l) {
+      function y(O, j, w, $, P) {
+        if (!(O[j] instanceof l)) {
+          var R = l.name || A, D = Se(O[j]);
+          return new X("Invalid " + $ + " `" + P + "` of type " + ("`" + D + "` supplied to `" + w + "`, expected ") + ("instance of `" + R + "`."));
+        }
+        return null;
+      }
+      return _(y);
+    }
+    function Z(l) {
+      if (!Array.isArray(l))
+        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? u(
+          "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."
+        ) : u("Invalid argument supplied to oneOf, expected an array.")), p;
+      function y(O, j, w, $, P) {
+        for (var R = O[j], D = 0; D < l.length; D++)
+          if (q(R, l[D]))
+            return null;
+        var I = JSON.stringify(l, function(te, h) {
+          var fe = le(h);
+          return fe === "symbol" ? String(h) : h;
+        });
+        return new X("Invalid " + $ + " `" + P + "` of value `" + String(R) + "` " + ("supplied to `" + w + "`, expected one of " + I + "."));
+      }
+      return _(y);
+    }
+    function Q(l) {
+      function y(O, j, w, $, P) {
+        if (typeof l != "function")
+          return new X("Property `" + P + "` of component `" + w + "` has invalid PropType notation inside objectOf.");
+        var R = O[j], D = ee(R);
+        if (D !== "object")
+          return new X("Invalid " + $ + " `" + P + "` of type " + ("`" + D + "` supplied to `" + w + "`, expected an object."));
+        for (var I in R)
+          if (o(R, I)) {
+            var N = l(R, I, w, $, P + "." + I, r);
+            if (N instanceof Error)
+              return N;
+          }
+        return null;
+      }
+      return _(y);
+    }
+    function G(l) {
+      if (!Array.isArray(l))
+        return process.env.NODE_ENV !== "production" && u("Invalid argument supplied to oneOfType, expected an instance of array."), p;
+      for (var y = 0; y < l.length; y++) {
+        var O = l[y];
+        if (typeof O != "function")
+          return u(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + ve(O) + " at index " + y + "."
+          ), p;
+      }
+      function j(w, $, P, R, D) {
+        for (var I = [], N = 0; N < l.length; N++) {
+          var te = l[N], h = te(w, $, P, R, D, r);
+          if (h == null)
+            return null;
+          h.data && o(h.data, "expectedType") && I.push(h.data.expectedType);
+        }
+        var fe = I.length > 0 ? ", expected one of type [" + I.join(", ") + "]" : "";
+        return new X("Invalid " + R + " `" + D + "` supplied to " + ("`" + P + "`" + fe + "."));
+      }
+      return _(j);
+    }
+    function J() {
+      function l(y, O, j, w, $) {
+        return K(y[O]) ? null : new X("Invalid " + w + " `" + $ + "` supplied to " + ("`" + j + "`, expected a ReactNode."));
+      }
+      return _(l);
+    }
+    function me(l, y, O, j, w) {
+      return new X(
+        (l || "React class") + ": " + y + " type `" + O + "." + j + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + w + "`."
+      );
+    }
+    function be(l) {
+      function y(O, j, w, $, P) {
+        var R = O[j], D = ee(R);
+        if (D !== "object")
+          return new X("Invalid " + $ + " `" + P + "` of type `" + D + "` " + ("supplied to `" + w + "`, expected `object`."));
+        for (var I in l) {
+          var N = l[I];
+          if (typeof N != "function")
+            return me(w, $, P, I, le(N));
+          var te = N(R, I, w, $, P + "." + I, r);
+          if (te)
+            return te;
+        }
+        return null;
+      }
+      return _(y);
+    }
+    function ne(l) {
+      function y(O, j, w, $, P) {
+        var R = O[j], D = ee(R);
+        if (D !== "object")
+          return new X("Invalid " + $ + " `" + P + "` of type `" + D + "` " + ("supplied to `" + w + "`, expected `object`."));
+        var I = t({}, O[j], l);
+        for (var N in I) {
+          var te = l[N];
+          if (o(l, N) && typeof te != "function")
+            return me(w, $, P, N, le(te));
+          if (!te)
+            return new X(
+              "Invalid " + $ + " `" + P + "` key `" + N + "` supplied to `" + w + "`.\nBad object: " + JSON.stringify(O[j], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(l), null, "  ")
+            );
+          var h = te(R, N, w, $, P + "." + N, r);
+          if (h)
+            return h;
+        }
+        return null;
+      }
+      return _(y);
+    }
+    function K(l) {
+      switch (typeof l) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !l;
+        case "object":
+          if (Array.isArray(l))
+            return l.every(K);
+          if (l === null || c(l))
+            return !0;
+          var y = T(l);
+          if (y) {
+            var O = y.call(l), j;
+            if (y !== l.entries) {
+              for (; !(j = O.next()).done; )
+                if (!K(j.value))
+                  return !1;
+            } else
+              for (; !(j = O.next()).done; ) {
+                var w = j.value;
+                if (w && !K(w[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function he(l, y) {
+      return l === "symbol" ? !0 : y ? y["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && y instanceof Symbol : !1;
+    }
+    function ee(l) {
+      var y = typeof l;
+      return Array.isArray(l) ? "array" : l instanceof RegExp ? "object" : he(y, l) ? "symbol" : y;
+    }
+    function le(l) {
+      if (typeof l > "u" || l === null)
+        return "" + l;
+      var y = ee(l);
+      if (y === "object") {
+        if (l instanceof Date)
+          return "date";
+        if (l instanceof RegExp)
+          return "regexp";
+      }
+      return y;
+    }
+    function ve(l) {
+      var y = le(l);
+      switch (y) {
+        case "array":
+        case "object":
+          return "an " + y;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + y;
+        default:
+          return y;
+      }
+    }
+    function Se(l) {
+      return !l.constructor || !l.constructor.name ? A : l.constructor.name;
+    }
+    return Y.checkPropTypes = a, Y.resetWarningCache = a.resetWarningCache, Y.PropTypes = Y, Y;
+  }, Ze;
+}
+var Qe, Ft;
+function Mr() {
+  if (Ft) return Qe;
+  Ft = 1;
+  var e = lt();
+  function t() {
+  }
+  function r() {
+  }
+  return r.resetWarningCache = t, Qe = function() {
+    function o(p, c, d, m, g, T) {
+      if (T !== e) {
+        var A = 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"
+        );
+        throw A.name = "Invariant Violation", A;
+      }
+    }
+    o.isRequired = o;
+    function a() {
+      return o;
+    }
+    var u = {
+      array: o,
+      bigint: o,
+      bool: o,
+      func: o,
+      number: o,
+      object: o,
+      string: o,
+      symbol: o,
+      any: o,
+      arrayOf: a,
+      element: o,
+      elementType: o,
+      instanceOf: a,
+      node: o,
+      objectOf: a,
+      oneOf: a,
+      oneOfType: a,
+      shape: a,
+      exact: a,
+      checkPropTypes: r,
+      resetWarningCache: t
+    };
+    return u.PropTypes = u, u;
+  }, Qe;
+}
+if (process.env.NODE_ENV !== "production") {
+  var Ar = Bt(), kr = !0;
+  it.exports = Nr()(Ar.isElement, kr);
+} else
+  it.exports = Mr()();
+var Ht = it.exports, st = { exports: {} };
+function zt(e) {
+  var t, r, o = "";
+  if (typeof e == "string" || typeof e == "number") o += e;
+  else if (typeof e == "object") if (Array.isArray(e)) {
+    var a = e.length;
+    for (t = 0; t < a; t++) e[t] && (r = zt(e[t])) && (o && (o += " "), o += r);
+  } else for (r in e) e[r] && (o && (o += " "), o += r);
+  return o;
+}
+function It() {
+  for (var e, t, r = 0, o = "", a = arguments.length; r < a; r++) (e = arguments[r]) && (t = zt(e)) && (o && (o += " "), o += t);
+  return o;
+}
+st.exports = It, st.exports.clsx = It;
+var $r = st.exports, V = {}, ge = {};
+Object.defineProperty(ge, "__esModule", {
+  value: !0
+});
+ge.dontSetMe = Lr;
+ge.findInArray = Fr;
+ge.int = Wr;
+ge.isFunction = Ir;
+ge.isNum = Yr;
+function Fr(e, t) {
+  for (let r = 0, o = e.length; r < o; r++)
+    if (t.apply(t, [e[r], r, e])) return e[r];
+}
+function Ir(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Function]";
+}
+function Yr(e) {
+  return typeof e == "number" && !isNaN(e);
+}
+function Wr(e) {
+  return parseInt(e, 10);
+}
+function Lr(e, t, r) {
+  if (e[t])
+    return new Error(`Invalid prop ${t} passed to ${r} - do not set this, set it on the child.`);
+}
+var Ce = {};
+Object.defineProperty(Ce, "__esModule", {
+  value: !0
+});
+Ce.browserPrefixToKey = Jt;
+Ce.browserPrefixToStyle = Ur;
+Ce.default = void 0;
+Ce.getPrefix = Gt;
+const et = ["Moz", "Webkit", "O", "ms"];
+function Gt() {
+  var r, o;
+  let e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "transform";
+  if (typeof window > "u") return "";
+  const t = (o = (r = window.document) == null ? void 0 : r.documentElement) == null ? void 0 : o.style;
+  if (!t || e in t) return "";
+  for (let a = 0; a < et.length; a++)
+    if (Jt(e, et[a]) in t) return et[a];
+  return "";
+}
+function Jt(e, t) {
+  return t ? `${t}${Xr(e)}` : e;
+}
+function Ur(e, t) {
+  return t ? `-${t.toLowerCase()}-${e}` : e;
+}
+function Xr(e) {
+  let t = "", r = !0;
+  for (let o = 0; o < e.length; o++)
+    r ? (t += e[o].toUpperCase(), r = !1) : e[o] === "-" ? r = !0 : t += e[o];
+  return t;
+}
+Ce.default = Gt();
+Object.defineProperty(V, "__esModule", {
+  value: !0
+});
+V.addClassName = Qt;
+V.addEvent = Br;
+V.addUserSelectStyles = rn;
+V.createCSSTransform = Zr;
+V.createSVGTransform = Qr;
+V.getTouch = en;
+V.getTouchIdentifier = tn;
+V.getTranslation = ut;
+V.innerHeight = Gr;
+V.innerWidth = Jr;
+V.matchesSelector = Zt;
+V.matchesSelectorAndParentsTo = qr;
+V.offsetXYFromParent = Kr;
+V.outerHeight = Hr;
+V.outerWidth = zr;
+V.removeClassName = er;
+V.removeEvent = Vr;
+V.scheduleRemoveUserSelectStyles = nn;
+var ce = ge, Yt = Kt(Ce);
+function Kt(e, t) {
+  if (typeof WeakMap == "function") var r = /* @__PURE__ */ new WeakMap(), o = /* @__PURE__ */ new WeakMap();
+  return (Kt = function(a, u) {
+    if (!u && a && a.__esModule) return a;
+    var p, c, d = { __proto__: null, default: a };
+    if (a === null || typeof a != "object" && typeof a != "function") return d;
+    if (p = u ? o : r) {
+      if (p.has(a)) return p.get(a);
+      p.set(a, d);
+    }
+    for (const m in a) m !== "default" && {}.hasOwnProperty.call(a, m) && ((c = (p = Object.defineProperty) && Object.getOwnPropertyDescriptor(a, m)) && (c.get || c.set) ? p(d, m, c) : d[m] = a[m]);
+    return d;
+  })(e, t);
+}
+let Fe = "";
+function Zt(e, t) {
+  return Fe || (Fe = (0, ce.findInArray)(["matches", "webkitMatchesSelector", "mozMatchesSelector", "msMatchesSelector", "oMatchesSelector"], function(r) {
+    return (0, ce.isFunction)(e[r]);
+  })), (0, ce.isFunction)(e[Fe]) ? e[Fe](t) : !1;
+}
+function qr(e, t, r) {
+  let o = e;
+  do {
+    if (Zt(o, t)) return !0;
+    if (o === r) return !1;
+    o = o.parentNode;
+  } while (o);
+  return !1;
+}
+function Br(e, t, r, o) {
+  if (!e) return;
+  const a = {
+    capture: !0,
+    ...o
+  };
+  e.addEventListener ? e.addEventListener(t, r, a) : e.attachEvent ? e.attachEvent("on" + t, r) : e["on" + t] = r;
+}
+function Vr(e, t, r, o) {
+  if (!e) return;
+  const a = {
+    capture: !0,
+    ...o
+  };
+  e.removeEventListener ? e.removeEventListener(t, r, a) : e.detachEvent ? e.detachEvent("on" + t, r) : e["on" + t] = null;
+}
+function Hr(e) {
+  let t = e.clientHeight;
+  const r = e.ownerDocument.defaultView.getComputedStyle(e);
+  return t += (0, ce.int)(r.borderTopWidth), t += (0, ce.int)(r.borderBottomWidth), t;
+}
+function zr(e) {
+  let t = e.clientWidth;
+  const r = e.ownerDocument.defaultView.getComputedStyle(e);
+  return t += (0, ce.int)(r.borderLeftWidth), t += (0, ce.int)(r.borderRightWidth), t;
+}
+function Gr(e) {
+  let t = e.clientHeight;
+  const r = e.ownerDocument.defaultView.getComputedStyle(e);
+  return t -= (0, ce.int)(r.paddingTop), t -= (0, ce.int)(r.paddingBottom), t;
+}
+function Jr(e) {
+  let t = e.clientWidth;
+  const r = e.ownerDocument.defaultView.getComputedStyle(e);
+  return t -= (0, ce.int)(r.paddingLeft), t -= (0, ce.int)(r.paddingRight), t;
+}
+function Kr(e, t, r) {
+  const a = t === t.ownerDocument.body ? {
+    left: 0,
+    top: 0
+  } : t.getBoundingClientRect(), u = (e.clientX + t.scrollLeft - a.left) / r, p = (e.clientY + t.scrollTop - a.top) / r;
+  return {
+    x: u,
+    y: p
+  };
+}
+function Zr(e, t) {
+  const r = ut(e, t, "px");
+  return {
+    [(0, Yt.browserPrefixToKey)("transform", Yt.default)]: r
+  };
+}
+function Qr(e, t) {
+  return ut(e, t, "");
+}
+function ut(e, t, r) {
+  let {
+    x: o,
+    y: a
+  } = e, u = `translate(${o}${r},${a}${r})`;
+  if (t) {
+    const p = `${typeof t.x == "string" ? t.x : t.x + r}`, c = `${typeof t.y == "string" ? t.y : t.y + r}`;
+    u = `translate(${p}, ${c})` + u;
+  }
+  return u;
+}
+function en(e, t) {
+  return e.targetTouches && (0, ce.findInArray)(e.targetTouches, (r) => t === r.identifier) || e.changedTouches && (0, ce.findInArray)(e.changedTouches, (r) => t === r.identifier);
+}
+function tn(e) {
+  if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;
+  if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;
+}
+function rn(e) {
+  if (!e) return;
+  let t = e.getElementById("react-draggable-style-el");
+  t || (t = e.createElement("style"), t.type = "text/css", t.id = "react-draggable-style-el", t.innerHTML = `.react-draggable-transparent-selection *::-moz-selection {all: inherit;}
+`, t.innerHTML += `.react-draggable-transparent-selection *::selection {all: inherit;}
+`, e.getElementsByTagName("head")[0].appendChild(t)), e.body && Qt(e.body, "react-draggable-transparent-selection");
+}
+function nn(e) {
+  window.requestAnimationFrame ? window.requestAnimationFrame(() => {
+    Wt(e);
+  }) : Wt(e);
+}
+function Wt(e) {
+  if (e)
+    try {
+      if (e.body && er(e.body, "react-draggable-transparent-selection"), e.selection)
+        e.selection.empty();
+      else {
+        const t = (e.defaultView || window).getSelection();
+        t && t.type !== "Caret" && t.removeAllRanges();
+      }
+    } catch {
+    }
+}
+function Qt(e, t) {
+  e.classList ? e.classList.add(t) : e.className.match(new RegExp(`(?:^|\\s)${t}(?!\\S)`)) || (e.className += ` ${t}`);
+}
+function er(e, t) {
+  e.classList ? e.classList.remove(t) : e.className = e.className.replace(new RegExp(`(?:^|\\s)${t}(?!\\S)`, "g"), "");
+}
+var ye = {};
+Object.defineProperty(ye, "__esModule", {
+  value: !0
+});
+ye.canDragX = sn;
+ye.canDragY = ln;
+ye.createCoreData = cn;
+ye.createDraggableData = fn;
+ye.getBoundPosition = on;
+ye.getControlPosition = un;
+ye.snapToGrid = an;
+var ue = ge, je = V;
+function on(e, t, r) {
+  if (!e.props.bounds) return [t, r];
+  let {
+    bounds: o
+  } = e.props;
+  o = typeof o == "string" ? o : dn(o);
+  const a = ct(e);
+  if (typeof o == "string") {
+    const {
+      ownerDocument: u
+    } = a, p = u.defaultView;
+    let c;
+    if (o === "parent" ? c = a.parentNode : c = a.getRootNode().querySelector(o), !(c instanceof p.HTMLElement))
+      throw new Error('Bounds selector "' + o + '" could not find an element.');
+    const d = c, m = p.getComputedStyle(a), g = p.getComputedStyle(d);
+    o = {
+      left: -a.offsetLeft + (0, ue.int)(g.paddingLeft) + (0, ue.int)(m.marginLeft),
+      top: -a.offsetTop + (0, ue.int)(g.paddingTop) + (0, ue.int)(m.marginTop),
+      right: (0, je.innerWidth)(d) - (0, je.outerWidth)(a) - a.offsetLeft + (0, ue.int)(g.paddingRight) - (0, ue.int)(m.marginRight),
+      bottom: (0, je.innerHeight)(d) - (0, je.outerHeight)(a) - a.offsetTop + (0, ue.int)(g.paddingBottom) - (0, ue.int)(m.marginBottom)
+    };
+  }
+  return (0, ue.isNum)(o.right) && (t = Math.min(t, o.right)), (0, ue.isNum)(o.bottom) && (r = Math.min(r, o.bottom)), (0, ue.isNum)(o.left) && (t = Math.max(t, o.left)), (0, ue.isNum)(o.top) && (r = Math.max(r, o.top)), [t, r];
+}
+function an(e, t, r) {
+  const o = Math.round(t / e[0]) * e[0], a = Math.round(r / e[1]) * e[1];
+  return [o, a];
+}
+function sn(e) {
+  return e.props.axis === "both" || e.props.axis === "x";
+}
+function ln(e) {
+  return e.props.axis === "both" || e.props.axis === "y";
+}
+function un(e, t, r) {
+  const o = typeof t == "number" ? (0, je.getTouch)(e, t) : null;
+  if (typeof t == "number" && !o) return null;
+  const a = ct(r), u = r.props.offsetParent || a.offsetParent || a.ownerDocument.body;
+  return (0, je.offsetXYFromParent)(o || e, u, r.props.scale);
+}
+function cn(e, t, r) {
+  const o = !(0, ue.isNum)(e.lastX), a = ct(e);
+  return o ? {
+    node: a,
+    deltaX: 0,
+    deltaY: 0,
+    lastX: t,
+    lastY: r,
+    x: t,
+    y: r
+  } : {
+    node: a,
+    deltaX: t - e.lastX,
+    deltaY: r - e.lastY,
+    lastX: e.lastX,
+    lastY: e.lastY,
+    x: t,
+    y: r
+  };
+}
+function fn(e, t) {
+  const r = e.props.scale;
+  return {
+    node: t.node,
+    x: e.state.x + t.deltaX / r,
+    y: e.state.y + t.deltaY / r,
+    deltaX: t.deltaX / r,
+    deltaY: t.deltaY / r,
+    lastX: e.state.x,
+    lastY: e.state.y
+  };
+}
+function dn(e) {
+  return {
+    left: e.left,
+    top: e.top,
+    right: e.right,
+    bottom: e.bottom
+  };
+}
+function ct(e) {
+  const t = e.findDOMNode();
+  if (!t)
+    throw new Error("<DraggableCore>: Unmounted during event!");
+  return t;
+}
+var We = {}, Le = {};
+Object.defineProperty(Le, "__esModule", {
+  value: !0
+});
+Le.default = pn;
+function pn() {
+}
+Object.defineProperty(We, "__esModule", {
+  value: !0
+});
+We.default = void 0;
+var tt = tr(Ie), ae = ft(Ht), hn = ft(Xt), re = V, xe = ye, rt = ge, Me = ft(Le);
+function ft(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+function tr(e, t) {
+  if (typeof WeakMap == "function") var r = /* @__PURE__ */ new WeakMap(), o = /* @__PURE__ */ new WeakMap();
+  return (tr = function(a, u) {
+    if (!u && a && a.__esModule) return a;
+    var p, c, d = { __proto__: null, default: a };
+    if (a === null || typeof a != "object" && typeof a != "function") return d;
+    if (p = u ? o : r) {
+      if (p.has(a)) return p.get(a);
+      p.set(a, d);
+    }
+    for (const m in a) m !== "default" && {}.hasOwnProperty.call(a, m) && ((c = (p = Object.defineProperty) && Object.getOwnPropertyDescriptor(a, m)) && (c.get || c.set) ? p(d, m, c) : d[m] = a[m]);
+    return d;
+  })(e, t);
+}
+function ie(e, t, r) {
+  return (t = vn(t)) in e ? Object.defineProperty(e, t, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = r, e;
+}
+function vn(e) {
+  var t = gn(e, "string");
+  return typeof t == "symbol" ? t : t + "";
+}
+function gn(e, t) {
+  if (typeof e != "object" || !e) return e;
+  var r = e[Symbol.toPrimitive];
+  if (r !== void 0) {
+    var o = r.call(e, t);
+    if (typeof o != "object") return o;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(e);
+}
+const pe = {
+  touch: {
+    start: "touchstart",
+    move: "touchmove",
+    stop: "touchend"
+  },
+  mouse: {
+    start: "mousedown",
+    move: "mousemove",
+    stop: "mouseup"
+  }
+};
+let Ee = pe.mouse, Ue = class extends tt.Component {
+  constructor() {
+    super(...arguments), ie(this, "dragging", !1), ie(this, "lastX", NaN), ie(this, "lastY", NaN), ie(this, "touchIdentifier", null), ie(this, "mounted", !1), ie(this, "handleDragStart", (t) => {
+      if (this.props.onMouseDown(t), !this.props.allowAnyClick && typeof t.button == "number" && t.button !== 0) return !1;
+      const r = this.findDOMNode();
+      if (!r || !r.ownerDocument || !r.ownerDocument.body)
+        throw new Error("<DraggableCore> not mounted on DragStart!");
+      const {
+        ownerDocument: o
+      } = r;
+      if (this.props.disabled || !(t.target instanceof o.defaultView.Node) || this.props.handle && !(0, re.matchesSelectorAndParentsTo)(t.target, this.props.handle, r) || this.props.cancel && (0, re.matchesSelectorAndParentsTo)(t.target, this.props.cancel, r))
+        return;
+      t.type === "touchstart" && !this.props.allowMobileScroll && t.preventDefault();
+      const a = (0, re.getTouchIdentifier)(t);
+      this.touchIdentifier = a;
+      const u = (0, xe.getControlPosition)(t, a, this);
+      if (u == null) return;
+      const {
+        x: p,
+        y: c
+      } = u, d = (0, xe.createCoreData)(this, p, c);
+      (0, Me.default)("DraggableCore: handleDragStart: %j", d), (0, Me.default)("calling", this.props.onStart), !(this.props.onStart(t, d) === !1 || this.mounted === !1) && (this.props.enableUserSelectHack && (0, re.addUserSelectStyles)(o), this.dragging = !0, this.lastX = p, this.lastY = c, (0, re.addEvent)(o, Ee.move, this.handleDrag), (0, re.addEvent)(o, Ee.stop, this.handleDragStop));
+    }), ie(this, "handleDrag", (t) => {
+      const r = (0, xe.getControlPosition)(t, this.touchIdentifier, this);
+      if (r == null) return;
+      let {
+        x: o,
+        y: a
+      } = r;
+      if (Array.isArray(this.props.grid)) {
+        let c = o - this.lastX, d = a - this.lastY;
+        if ([c, d] = (0, xe.snapToGrid)(this.props.grid, c, d), !c && !d) return;
+        o = this.lastX + c, a = this.lastY + d;
+      }
+      const u = (0, xe.createCoreData)(this, o, a);
+      if ((0, Me.default)("DraggableCore: handleDrag: %j", u), this.props.onDrag(t, u) === !1 || this.mounted === !1) {
+        try {
+          this.handleDragStop(new MouseEvent("mouseup"));
+        } catch {
+          const d = document.createEvent("MouseEvents");
+          d.initMouseEvent("mouseup", !0, !0, window, 0, 0, 0, 0, 0, !1, !1, !1, !1, 0, null), this.handleDragStop(d);
+        }
+        return;
+      }
+      this.lastX = o, this.lastY = a;
+    }), ie(this, "handleDragStop", (t) => {
+      if (!this.dragging) return;
+      const r = (0, xe.getControlPosition)(t, this.touchIdentifier, this);
+      if (r == null) return;
+      let {
+        x: o,
+        y: a
+      } = r;
+      if (Array.isArray(this.props.grid)) {
+        let d = o - this.lastX || 0, m = a - this.lastY || 0;
+        [d, m] = (0, xe.snapToGrid)(this.props.grid, d, m), o = this.lastX + d, a = this.lastY + m;
+      }
+      const u = (0, xe.createCoreData)(this, o, a);
+      if (this.props.onStop(t, u) === !1 || this.mounted === !1) return !1;
+      const c = this.findDOMNode();
+      c && this.props.enableUserSelectHack && (0, re.scheduleRemoveUserSelectStyles)(c.ownerDocument), (0, Me.default)("DraggableCore: handleDragStop: %j", u), this.dragging = !1, this.lastX = NaN, this.lastY = NaN, c && ((0, Me.default)("DraggableCore: Removing handlers"), (0, re.removeEvent)(c.ownerDocument, Ee.move, this.handleDrag), (0, re.removeEvent)(c.ownerDocument, Ee.stop, this.handleDragStop));
+    }), ie(this, "onMouseDown", (t) => (Ee = pe.mouse, this.handleDragStart(t))), ie(this, "onMouseUp", (t) => (Ee = pe.mouse, this.handleDragStop(t))), ie(this, "onTouchStart", (t) => (Ee = pe.touch, this.handleDragStart(t))), ie(this, "onTouchEnd", (t) => (Ee = pe.touch, this.handleDragStop(t)));
+  }
+  componentDidMount() {
+    this.mounted = !0;
+    const t = this.findDOMNode();
+    t && (0, re.addEvent)(t, pe.touch.start, this.onTouchStart, {
+      passive: !1
+    });
+  }
+  componentWillUnmount() {
+    this.mounted = !1;
+    const t = this.findDOMNode();
+    if (t) {
+      const {
+        ownerDocument: r
+      } = t;
+      (0, re.removeEvent)(r, pe.mouse.move, this.handleDrag), (0, re.removeEvent)(r, pe.touch.move, this.handleDrag), (0, re.removeEvent)(r, pe.mouse.stop, this.handleDragStop), (0, re.removeEvent)(r, pe.touch.stop, this.handleDragStop), (0, re.removeEvent)(t, pe.touch.start, this.onTouchStart, {
+        passive: !1
+      }), this.props.enableUserSelectHack && (0, re.scheduleRemoveUserSelectStyles)(r);
+    }
+  }
+  // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find
+  // the underlying DOM node ourselves. See the README for more information.
+  findDOMNode() {
+    var t, r, o;
+    return (t = this.props) != null && t.nodeRef ? (o = (r = this.props) == null ? void 0 : r.nodeRef) == null ? void 0 : o.current : hn.default.findDOMNode(this);
+  }
+  render() {
+    return /* @__PURE__ */ tt.cloneElement(tt.Children.only(this.props.children), {
+      // Note: mouseMove handler is attached to document so it will still function
+      // when the user drags quickly and leaves the bounds of the element.
+      onMouseDown: this.onMouseDown,
+      onMouseUp: this.onMouseUp,
+      // onTouchStart is added on `componentDidMount` so they can be added with
+      // {passive: false}, which allows it to cancel. See
+      // https://developers.google.com/web/updates/2017/01/scrolling-intervention
+      onTouchEnd: this.onTouchEnd
+    });
+  }
+};
+We.default = Ue;
+ie(Ue, "displayName", "DraggableCore");
+ie(Ue, "propTypes", {
+  /**
+   * `allowAnyClick` allows dragging using any mouse button.
+   * By default, we only accept the left button.
+   *
+   * Defaults to `false`.
+   */
+  allowAnyClick: ae.default.bool,
+  /**
+   * `allowMobileScroll` turns off cancellation of the 'touchstart' event
+   * on mobile devices. Only enable this if you are having trouble with click
+   * events. Prefer using 'handle' / 'cancel' instead.
+   *
+   * Defaults to `false`.
+   */
+  allowMobileScroll: ae.default.bool,
+  children: ae.default.node.isRequired,
+  /**
+   * `disabled`, if true, stops the <Draggable> from dragging. All handlers,
+   * with the exception of `onMouseDown`, will not fire.
+   */
+  disabled: ae.default.bool,
+  /**
+   * By default, we add 'user-select:none' attributes to the document body
+   * to prevent ugly text selection during drag. If this is causing problems
+   * for your app, set this to `false`.
+   */
+  enableUserSelectHack: ae.default.bool,
+  /**
+   * `offsetParent`, if set, uses the passed DOM node to compute drag offsets
+   * instead of using the parent node.
+   */
+  offsetParent: function(e, t) {
+    if (e[t] && e[t].nodeType !== 1)
+      throw new Error("Draggable's offsetParent must be a DOM Node.");
+  },
+  /**
+   * `grid` specifies the x and y that dragging should snap to.
+   */
+  grid: ae.default.arrayOf(ae.default.number),
+  /**
+   * `handle` specifies a selector to be used as the handle that initiates drag.
+   *
+   * Example:
+   *
+   * ```jsx
+   *   let App = React.createClass({
+   *       render: function () {
+   *         return (
+   *            <Draggable handle=".handle">
+   *              <div>
+   *                  <div className="handle">Click me to drag</div>
+   *                  <div>This is some other content</div>
+   *              </div>
+   *           </Draggable>
+   *         );
+   *       }
+   *   });
+   * ```
+   */
+  handle: ae.default.string,
+  /**
+   * `cancel` specifies a selector to be used to prevent drag initialization.
+   *
+   * Example:
+   *
+   * ```jsx
+   *   let App = React.createClass({
+   *       render: function () {
+   *           return(
+   *               <Draggable cancel=".cancel">
+   *                   <div>
+   *                     <div className="cancel">You can't drag from here</div>
+   *                     <div>Dragging here works fine</div>
+   *                   </div>
+   *               </Draggable>
+   *           );
+   *       }
+   *   });
+   * ```
+   */
+  cancel: ae.default.string,
+  /* If running in React Strict mode, ReactDOM.findDOMNode() is deprecated.
+   * Unfortunately, in order for <Draggable> to work properly, we need raw access
+   * to the underlying DOM node. If you want to avoid the warning, pass a `nodeRef`
+   * as in this example:
+   *
+   * function MyComponent() {
+   *   const nodeRef = React.useRef(null);
+   *   return (
+   *     <Draggable nodeRef={nodeRef}>
+   *       <div ref={nodeRef}>Example Target</div>
+   *     </Draggable>
+   *   );
+   * }
+   *
+   * This can be used for arbitrarily nested components, so long as the ref ends up
+   * pointing to the actual child DOM node and not a custom component.
+   */
+  nodeRef: ae.default.object,
+  /**
+   * Called when dragging starts.
+   * If this function returns the boolean false, dragging will be canceled.
+   */
+  onStart: ae.default.func,
+  /**
+   * Called while dragging.
+   * If this function returns the boolean false, dragging will be canceled.
+   */
+  onDrag: ae.default.func,
+  /**
+   * Called when dragging stops.
+   * If this function returns the boolean false, the drag will remain active.
+   */
+  onStop: ae.default.func,
+  /**
+   * A workaround option which can be passed if onMouseDown needs to be accessed,
+   * since it'll always be blocked (as there is internal use of onMouseDown)
+   */
+  onMouseDown: ae.default.func,
+  /**
+   * `scale`, if set, applies scaling while dragging an element
+   */
+  scale: ae.default.number,
+  /**
+   * These properties should be defined on the child, not here.
+   */
+  className: rt.dontSetMe,
+  style: rt.dontSetMe,
+  transform: rt.dontSetMe
+});
+ie(Ue, "defaultProps", {
+  allowAnyClick: !1,
+  // by default only accept left click
+  allowMobileScroll: !1,
+  disabled: !1,
+  enableUserSelectHack: !0,
+  onStart: function() {
+  },
+  onDrag: function() {
+  },
+  onStop: function() {
+  },
+  onMouseDown: function() {
+  },
+  scale: 1
+});
+(function(e) {
+  Object.defineProperty(e, "__esModule", {
+    value: !0
+  }), Object.defineProperty(e, "DraggableCore", {
+    enumerable: !0,
+    get: function() {
+      return d.default;
+    }
+  }), e.default = void 0;
+  var t = T(Ie), r = g(Ht), o = g(Xt), a = $r, u = V, p = ye, c = ge, d = g(We), m = g(Le);
+  function g(x) {
+    return x && x.__esModule ? x : { default: x };
+  }
+  function T(x, b) {
+    if (typeof WeakMap == "function") var C = /* @__PURE__ */ new WeakMap(), S = /* @__PURE__ */ new WeakMap();
+    return (T = function(i, k) {
+      if (!k && i && i.__esModule) return i;
+      var Z, Q, G = { __proto__: null, default: i };
+      if (i === null || typeof i != "object" && typeof i != "function") return G;
+      if (Z = k ? S : C) {
+        if (Z.has(i)) return Z.get(i);
+        Z.set(i, G);
+      }
+      for (const J in i) J !== "default" && {}.hasOwnProperty.call(i, J) && ((Q = (Z = Object.defineProperty) && Object.getOwnPropertyDescriptor(i, J)) && (Q.get || Q.set) ? Z(G, J, Q) : G[J] = i[J]);
+      return G;
+    })(x, b);
+  }
+  function A() {
+    return A = Object.assign ? Object.assign.bind() : function(x) {
+      for (var b = 1; b < arguments.length; b++) {
+        var C = arguments[b];
+        for (var S in C) ({}).hasOwnProperty.call(C, S) && (x[S] = C[S]);
+      }
+      return x;
+    }, A.apply(null, arguments);
+  }
+  function Y(x, b, C) {
+    return (b = q(b)) in x ? Object.defineProperty(x, b, { value: C, enumerable: !0, configurable: !0, writable: !0 }) : x[b] = C, x;
+  }
+  function q(x) {
+    var b = X(x, "string");
+    return typeof b == "symbol" ? b : b + "";
+  }
+  function X(x, b) {
+    if (typeof x != "object" || !x) return x;
+    var C = x[Symbol.toPrimitive];
+    if (C !== void 0) {
+      var S = C.call(x, b);
+      if (typeof S != "object") return S;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (b === "string" ? String : Number)(x);
+  }
+  class _ extends t.Component {
+    // React 16.3+
+    // Arity (props, state)
+    static getDerivedStateFromProps(b, C) {
+      let {
+        position: S
+      } = b, {
+        prevPropsPosition: i
+      } = C;
+      return S && (!i || S.x !== i.x || S.y !== i.y) ? ((0, m.default)("Draggable: getDerivedStateFromProps %j", {
+        position: S,
+        prevPropsPosition: i
+      }), {
+        x: S.x,
+        y: S.y,
+        prevPropsPosition: {
+          ...S
+        }
+      }) : null;
+    }
+    constructor(b) {
+      super(b), Y(this, "onDragStart", (C, S) => {
+        if ((0, m.default)("Draggable: onDragStart: %j", S), this.props.onStart(C, (0, p.createDraggableData)(this, S)) === !1) return !1;
+        this.setState({
+          dragging: !0,
+          dragged: !0
+        });
+      }), Y(this, "onDrag", (C, S) => {
+        if (!this.state.dragging) return !1;
+        (0, m.default)("Draggable: onDrag: %j", S);
+        const i = (0, p.createDraggableData)(this, S), k = {
+          x: i.x,
+          y: i.y,
+          slackX: 0,
+          slackY: 0
+        };
+        if (this.props.bounds) {
+          const {
+            x: Q,
+            y: G
+          } = k;
+          k.x += this.state.slackX, k.y += this.state.slackY;
+          const [J, me] = (0, p.getBoundPosition)(this, k.x, k.y);
+          k.x = J, k.y = me, k.slackX = this.state.slackX + (Q - k.x), k.slackY = this.state.slackY + (G - k.y), i.x = k.x, i.y = k.y, i.deltaX = k.x - this.state.x, i.deltaY = k.y - this.state.y;
+        }
+        if (this.props.onDrag(C, i) === !1) return !1;
+        this.setState(k);
+      }), Y(this, "onDragStop", (C, S) => {
+        if (!this.state.dragging || this.props.onStop(C, (0, p.createDraggableData)(this, S)) === !1) return !1;
+        (0, m.default)("Draggable: onDragStop: %j", S);
+        const k = {
+          dragging: !1,
+          slackX: 0,
+          slackY: 0
+        };
+        if (!!this.props.position) {
+          const {
+            x: Q,
+            y: G
+          } = this.props.position;
+          k.x = Q, k.y = G;
+        }
+        this.setState(k);
+      }), this.state = {
+        // Whether or not we are currently dragging.
+        dragging: !1,
+        // Whether or not we have been dragged before.
+        dragged: !1,
+        // Current transform x and y.
+        x: b.position ? b.position.x : b.defaultPosition.x,
+        y: b.position ? b.position.y : b.defaultPosition.y,
+        prevPropsPosition: {
+          ...b.position
+        },
+        // Used for compensating for out-of-bounds drags
+        slackX: 0,
+        slackY: 0,
+        // Can only determine if SVG after mounting
+        isElementSVG: !1
+      }, b.position && !(b.onDrag || b.onStop) && console.warn("A `position` was applied to this <Draggable>, without drag handlers. This will make this component effectively undraggable. Please attach `onDrag` or `onStop` handlers so you can adjust the `position` of this element.");
+    }
+    componentDidMount() {
+      typeof window.SVGElement < "u" && this.findDOMNode() instanceof window.SVGElement && this.setState({
+        isElementSVG: !0
+      });
+    }
+    componentWillUnmount() {
+      this.state.dragging && this.setState({
+        dragging: !1
+      });
+    }
+    // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find
+    // the underlying DOM node ourselves. See the README for more information.
+    findDOMNode() {
+      var b, C;
+      return ((C = (b = this.props) == null ? void 0 : b.nodeRef) == null ? void 0 : C.current) ?? o.default.findDOMNode(this);
+    }
+    render() {
+      const {
+        axis: b,
+        bounds: C,
+        children: S,
+        defaultPosition: i,
+        defaultClassName: k,
+        defaultClassNameDragging: Z,
+        defaultClassNameDragged: Q,
+        position: G,
+        positionOffset: J,
+        scale: me,
+        ...be
+      } = this.props;
+      let ne = {}, K = null;
+      const ee = !!!G || this.state.dragging, le = G || i, ve = {
+        // Set left if horizontal drag is enabled
+        x: (0, p.canDragX)(this) && ee ? this.state.x : le.x,
+        // Set top if vertical drag is enabled
+        y: (0, p.canDragY)(this) && ee ? this.state.y : le.y
+      };
+      this.state.isElementSVG ? K = (0, u.createSVGTransform)(ve, J) : ne = (0, u.createCSSTransform)(ve, J);
+      const Se = (0, a.clsx)(S.props.className || "", k, {
+        [Z]: this.state.dragging,
+        [Q]: this.state.dragged
+      });
+      return /* @__PURE__ */ t.createElement(d.default, A({}, be, {
+        onStart: this.onDragStart,
+        onDrag: this.onDrag,
+        onStop: this.onDragStop
+      }), /* @__PURE__ */ t.cloneElement(t.Children.only(S), {
+        className: Se,
+        style: {
+          ...S.props.style,
+          ...ne
+        },
+        transform: K
+      }));
+    }
+  }
+  e.default = _, Y(_, "displayName", "Draggable"), Y(_, "propTypes", {
+    // Accepts all props <DraggableCore> accepts.
+    ...d.default.propTypes,
+    /**
+     * `axis` determines which axis the draggable can move.
+     *
+     *  Note that all callbacks will still return data as normal. This only
+     *  controls flushing to the DOM.
+     *
+     * 'both' allows movement horizontally and vertically.
+     * 'x' limits movement to horizontal axis.
+     * 'y' limits movement to vertical axis.
+     * 'none' limits all movement.
+     *
+     * Defaults to 'both'.
+     */
+    axis: r.default.oneOf(["both", "x", "y", "none"]),
+    /**
+     * `bounds` determines the range of movement available to the element.
+     * Available values are:
+     *
+     * 'parent' restricts movement within the Draggable's parent node.
+     *
+     * Alternatively, pass an object with the following properties, all of which are optional:
+     *
+     * {left: LEFT_BOUND, right: RIGHT_BOUND, bottom: BOTTOM_BOUND, top: TOP_BOUND}
+     *
+     * All values are in px.
+     *
+     * Example:
+     *
+     * ```jsx
+     *   let App = React.createClass({
+     *       render: function () {
+     *         return (
+     *            <Draggable bounds={{right: 300, bottom: 300}}>
+     *              <div>Content</div>
+     *           </Draggable>
+     *         );
+     *       }
+     *   });
+     * ```
+     */
+    bounds: r.default.oneOfType([r.default.shape({
+      left: r.default.number,
+      right: r.default.number,
+      top: r.default.number,
+      bottom: r.default.number
+    }), r.default.string, r.default.oneOf([!1])]),
+    defaultClassName: r.default.string,
+    defaultClassNameDragging: r.default.string,
+    defaultClassNameDragged: r.default.string,
+    /**
+     * `defaultPosition` specifies the x and y that the dragged item should start at
+     *
+     * Example:
+     *
+     * ```jsx
+     *      let App = React.createClass({
+     *          render: function () {
+     *              return (
+     *                  <Draggable defaultPosition={{x: 25, y: 25}}>
+     *                      <div>I start with transformX: 25px and transformY: 25px;</div>
+     *                  </Draggable>
+     *              );
+     *          }
+     *      });
+     * ```
+     */
+    defaultPosition: r.default.shape({
+      x: r.default.number,
+      y: r.default.number
+    }),
+    positionOffset: r.default.shape({
+      x: r.default.oneOfType([r.default.number, r.default.string]),
+      y: r.default.oneOfType([r.default.number, r.default.string])
+    }),
+    /**
+     * `position`, if present, defines the current position of the element.
+     *
+     *  This is similar to how form elements in React work - if no `position` is supplied, the component
+     *  is uncontrolled.
+     *
+     * Example:
+     *
+     * ```jsx
+     *      let App = React.createClass({
+     *          render: function () {
+     *              return (
+     *                  <Draggable position={{x: 25, y: 25}}>
+     *                      <div>I start with transformX: 25px and transformY: 25px;</div>
+     *                  </Draggable>
+     *              );
+     *          }
+     *      });
+     * ```
+     */
+    position: r.default.shape({
+      x: r.default.number,
+      y: r.default.number
+    }),
+    /**
+     * These properties should be defined on the child, not here.
+     */
+    className: c.dontSetMe,
+    style: c.dontSetMe,
+    transform: c.dontSetMe
+  }), Y(_, "defaultProps", {
+    ...d.default.defaultProps,
+    axis: "both",
+    bounds: !1,
+    defaultClassName: "react-draggable",
+    defaultClassNameDragging: "react-draggable-dragging",
+    defaultClassNameDragged: "react-draggable-dragged",
+    defaultPosition: {
+      x: 0,
+      y: 0
+    },
+    scale: 1
+  });
+})(qt);
+const {
+  default: rr,
+  DraggableCore: yn
+} = qt;
+Ye.exports = rr;
+Ye.exports.default = rr;
+Ye.exports.DraggableCore = yn;
+var mn = Ye.exports;
+const bn = /* @__PURE__ */ Cr(mn), Sn = ({
+  title: e,
+  collapsed: t = !1,
+  draggable: r = !0,
+  position: o = { x: 20, y: 20 },
+  children: a
+}) => {
+  const [u, p] = Ae(t);
+  return /* @__PURE__ */ f.jsx(
+    bn,
+    {
+      handle: ".font-controls-header",
+      disabled: !r,
+      defaultPosition: o,
+      bounds: "parent",
+      children: /* @__PURE__ */ f.jsxs("div", { className: "font-controls-panel", children: [
+        /* @__PURE__ */ f.jsxs("div", { className: "font-controls-header", children: [
+          /* @__PURE__ */ f.jsx("h3", { className: "font-controls-title", children: e }),
+          /* @__PURE__ */ f.jsx(
+            "button",
+            {
+              className: `font-controls-toggle ${u ? "collapsed" : ""}`,
+              onClick: () => p(!u),
+              type: "button",
+              "aria-label": u ? "Expand" : "Collapse",
+              children: /* @__PURE__ */ f.jsx(
+                "svg",
+                {
+                  viewBox: "0 0 24 24",
+                  fill: "none",
+                  stroke: "currentColor",
+                  strokeWidth: "2",
+                  strokeLinecap: "round",
+                  strokeLinejoin: "round",
+                  children: /* @__PURE__ */ f.jsx("polyline", { points: "6 9 12 15 18 9" })
+                }
+              )
+            }
+          )
+        ] }),
+        !u && /* @__PURE__ */ f.jsx("div", { className: "font-controls-content", children: a })
+      ] })
+    }
+  );
+}, xn = ({
+  value: e,
+  onChange: t,
+  fontFamilies: r
+}) => /* @__PURE__ */ f.jsxs("div", { className: "font-control-group", children: [
+  /* @__PURE__ */ f.jsx("label", { className: "font-control-label", children: "Font Family" }),
+  /* @__PURE__ */ f.jsx(
+    "select",
+    {
+      className: "font-control-input font-control-select",
+      value: e,
+      onChange: (o) => t(o.target.value),
+      style: { fontFamily: e },
+      children: r.map((o) => /* @__PURE__ */ f.jsx("option", { value: o, style: { fontFamily: o }, children: o }, o))
+    }
+  )
+] }), En = ({
+  value: e,
+  onChange: t,
+  min: r,
+  max: o,
+  step: a
+}) => /* @__PURE__ */ f.jsxs("div", { className: "font-control-group", children: [
+  /* @__PURE__ */ f.jsx("label", { className: "font-control-label", children: "Font Size" }),
+  /* @__PURE__ */ f.jsxs("div", { className: "font-control-slider-container", children: [
+    /* @__PURE__ */ f.jsx(
+      "input",
+      {
+        type: "range",
+        className: "font-control-slider",
+        min: r,
+        max: o,
+        step: a,
+        value: e,
+        onChange: (u) => t(Number(u.target.value))
+      }
+    ),
+    /* @__PURE__ */ f.jsx(
+      "input",
+      {
+        type: "number",
+        className: "font-control-input font-control-number",
+        min: r,
+        max: o,
+        step: a,
+        value: e,
+        onChange: (u) => t(Number(u.target.value))
+      }
+    )
+  ] })
+] }), Tn = [
+  { value: 100, label: "Thin" },
+  { value: 200, label: "Extra Light" },
+  { value: 300, label: "Light" },
+  { value: 400, label: "Regular" },
+  { value: 500, label: "Medium" },
+  { value: 600, label: "Semi Bold" },
+  { value: 700, label: "Bold" },
+  { value: 800, label: "Extra Bold" },
+  { value: 900, label: "Black" }
+], _n = ({
+  value: e,
+  onChange: t
+}) => /* @__PURE__ */ f.jsxs("div", { className: "font-control-group", children: [
+  /* @__PURE__ */ f.jsx("label", { className: "font-control-label", children: "Font Weight" }),
+  /* @__PURE__ */ f.jsx(
+    "select",
+    {
+      className: "font-control-input font-control-select",
+      value: e,
+      onChange: (r) => t(Number(r.target.value)),
+      children: Tn.map((r) => /* @__PURE__ */ f.jsxs("option", { value: r.value, children: [
+        r.label,
+        " (",
+        r.value,
+        ")"
+      ] }, r.value))
+    }
+  )
+] }), Cn = ({
+  value: e,
+  onChange: t
+}) => /* @__PURE__ */ f.jsxs("div", { className: "font-control-group", children: [
+  /* @__PURE__ */ f.jsx("label", { className: "font-control-label", children: "Line Height" }),
+  /* @__PURE__ */ f.jsxs("div", { className: "font-control-slider-container", children: [
+    /* @__PURE__ */ f.jsx(
+      "input",
+      {
+        type: "range",
+        className: "font-control-slider",
+        min: 0.5,
+        max: 3,
+        step: 0.1,
+        value: e,
+        onChange: (r) => t(Number(r.target.value))
+      }
+    ),
+    /* @__PURE__ */ f.jsx(
+      "input",
+      {
+        type: "number",
+        className: "font-control-input font-control-number",
+        min: 0.5,
+        max: 3,
+        step: 0.1,
+        value: e,
+        onChange: (r) => t(Number(r.target.value))
+      }
+    )
+  ] })
+] }), wn = ({
+  value: e,
+  onChange: t
+}) => /* @__PURE__ */ f.jsxs("div", { className: "font-control-group", children: [
+  /* @__PURE__ */ f.jsx("label", { className: "font-control-label", children: "Letter Spacing" }),
+  /* @__PURE__ */ f.jsxs("div", { className: "font-control-slider-container", children: [
+    /* @__PURE__ */ f.jsx(
+      "input",
+      {
+        type: "range",
+        className: "font-control-slider",
+        min: -5,
+        max: 10,
+        step: 0.1,
+        value: e,
+        onChange: (r) => t(Number(r.target.value))
+      }
+    ),
+    /* @__PURE__ */ f.jsx(
+      "input",
+      {
+        type: "number",
+        className: "font-control-input font-control-number",
+        min: -5,
+        max: 10,
+        step: 0.1,
+        value: e,
+        onChange: (r) => t(Number(r.target.value))
+      }
+    )
+  ] })
+] }), Pn = [
+  { value: "none", label: "None" },
+  { value: "uppercase", label: "UPPERCASE" },
+  { value: "lowercase", label: "lowercase" },
+  { value: "capitalize", label: "Capitalize" }
+], Rn = ({
+  value: e,
+  onChange: t
+}) => /* @__PURE__ */ f.jsxs("div", { className: "font-control-group", children: [
+  /* @__PURE__ */ f.jsx("label", { className: "font-control-label", children: "Text Transform" }),
+  /* @__PURE__ */ f.jsx(
+    "select",
+    {
+      className: "font-control-input font-control-select",
+      value: e,
+      onChange: (r) => t(r.target.value),
+      children: Pn.map((r) => /* @__PURE__ */ f.jsx("option", { value: r.value, children: r.label }, r.value))
+    }
+  )
+] }), jn = ({
+  value: e,
+  onChange: t
+}) => /* @__PURE__ */ f.jsxs("div", { className: "font-control-group", children: [
+  /* @__PURE__ */ f.jsx("label", { className: "font-control-label", children: "Text Color" }),
+  /* @__PURE__ */ f.jsxs("div", { className: "font-control-color-input", children: [
+    /* @__PURE__ */ f.jsx("div", { className: "font-control-color-preview", children: /* @__PURE__ */ f.jsx(
+      "input",
+      {
+        type: "color",
+        value: e,
+        onChange: (r) => t(r.target.value)
+      }
+    ) }),
+    /* @__PURE__ */ f.jsx(
+      "input",
+      {
+        type: "text",
+        className: "font-control-input font-control-text-input",
+        value: e,
+        onChange: (r) => t(r.target.value),
+        placeholder: "#000000"
+      }
+    )
+  ] })
+] }), On = [
+  { value: "left", icon: "⬅" },
+  { value: "center", icon: "↔" },
+  { value: "right", icon: "➡" },
+  { value: "justify", icon: "⬌" }
+], Dn = ({
+  value: e,
+  onChange: t
+}) => /* @__PURE__ */ f.jsxs("div", { className: "font-control-group", children: [
+  /* @__PURE__ */ f.jsx("label", { className: "font-control-label", children: "Text Align" }),
+  /* @__PURE__ */ f.jsx("div", { className: "font-control-button-group", children: On.map((r) => /* @__PURE__ */ f.jsx(
+    "button",
+    {
+      className: `font-control-button ${e === r.value ? "active" : ""}`,
+      onClick: () => t(r.value),
+      type: "button",
+      children: r.icon
+    },
+    r.value
+  )) })
+] }), nt = ({
+  title: e,
+  code: t,
+  language: r = "css"
+}) => {
+  const [o, a] = Ae(!1), u = async () => {
+    try {
+      await navigator.clipboard.writeText(t), a(!0), setTimeout(() => a(!1), 2e3);
+    } catch (p) {
+      console.error("Failed to copy:", p);
+    }
+  };
+  return /* @__PURE__ */ f.jsxs("div", { className: "font-control-code-block", children: [
+    /* @__PURE__ */ f.jsxs("div", { className: "font-control-code-header", children: [
+      /* @__PURE__ */ f.jsx("span", { className: "font-control-code-title", children: e }),
+      /* @__PURE__ */ f.jsx(
+        "button",
+        {
+          className: "font-control-copy-button",
+          onClick: u,
+          type: "button",
+          children: o ? /* @__PURE__ */ f.jsxs(f.Fragment, { children: [
+            /* @__PURE__ */ f.jsx(
+              "svg",
+              {
+                viewBox: "0 0 24 24",
+                fill: "none",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                children: /* @__PURE__ */ f.jsx("polyline", { points: "20 6 9 17 4 12" })
+              }
+            ),
+            "Copied!"
+          ] }) : /* @__PURE__ */ f.jsxs(f.Fragment, { children: [
+            /* @__PURE__ */ f.jsxs(
+              "svg",
+              {
+                viewBox: "0 0 24 24",
+                fill: "none",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                children: [
+                  /* @__PURE__ */ f.jsx("rect", { x: "9", y: "9", width: "13", height: "13", rx: "2", ry: "2" }),
+                  /* @__PURE__ */ f.jsx("path", { d: "M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" })
+                ]
+              }
+            ),
+            "Copy"
+          ] })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ f.jsx("pre", { className: "font-control-code-content", children: /* @__PURE__ */ f.jsx("code", { className: `language-${r}`, children: t }) })
+  ] });
+}, Lt = /* @__PURE__ */ new Set();
+function Nn(e) {
+  if (Lt.has(e))
+    return;
+  const t = document.createElement("link");
+  t.rel = "stylesheet", t.href = `https://fonts.googleapis.com/css2?family=${e.replace(/ /g, "+")}:wght@100;200;300;400;500;600;700;800;900&display=swap`, document.head.appendChild(t), Lt.add(e);
+}
+function Mn(e) {
+  if (!document.querySelector('link[href*="fonts.googleapis.com"]')) {
+    const t = document.createElement("link");
+    t.rel = "preconnect", t.href = "https://fonts.googleapis.com";
+    const r = document.createElement("link");
+    r.rel = "preconnect", r.href = "https://fonts.gstatic.com", r.crossOrigin = "anonymous", document.head.appendChild(t), document.head.appendChild(r);
+  }
+  e.forEach(Nn);
+}
+function An(e) {
+  return [
+    "Arial",
+    "Helvetica",
+    "Times New Roman",
+    "Georgia",
+    "Verdana"
+  ].includes(e) ? `<!-- ${e} is a system font, no import needed -->` : `<!-- Add this to your HTML <head> -->
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="${`https://fonts.googleapis.com/css2?family=${e.replace(/ /g, "+")}:wght@100;200;300;400;500;600;700;800;900&display=swap`}" rel="stylesheet">`;
+}
+function kn(e) {
+  return `<h1 style={{
+  fontFamily: '${e.fontFamily}',
+  fontSize: '${e.fontSize}px',
+  fontWeight: ${e.fontWeight},
+  lineHeight: ${e.lineHeight},
+  letterSpacing: '${e.letterSpacing}px',
+  textTransform: '${e.textTransform}',
+  color: '${e.color}',
+  textAlign: '${e.textAlign}'
+}}>
+  Your Text Here
+</h1>`;
+}
+function $n(e) {
+  return `.my-text {
+  font-family: '${e.fontFamily}', sans-serif;
+  font-size: ${e.fontSize}px;
+  font-weight: ${e.fontWeight};
+  line-height: ${e.lineHeight};
+  letter-spacing: ${e.letterSpacing}px;
+  text-transform: ${e.textTransform};
+  color: ${e.color};
+  text-align: ${e.textAlign};
+}`;
+}
+const Fn = [
+  // Sans-serif - Modern & Clean
+  "Inter",
+  "Roboto",
+  "Open Sans",
+  "Lato",
+  "Montserrat",
+  "Poppins",
+  "Raleway",
+  "Work Sans",
+  "Nunito",
+  "Source Sans Pro",
+  "DM Sans",
+  // Serif - Classic & Elegant
+  "Playfair Display",
+  "Merriweather",
+  "Lora",
+  "Crimson Text",
+  "EB Garamond",
+  // Monospace - Code & Tech
+  "Fira Code",
+  "JetBrains Mono",
+  "Inconsolata",
+  "Source Code Pro",
+  // Display - Bold & Creative
+  "Bebas Neue",
+  "Oswald",
+  "Righteous",
+  "Permanent Marker",
+  "Pacifico"
+], ot = {
+  fontFamily: "Arial",
+  fontSize: 16,
+  fontWeight: 400,
+  lineHeight: 1.5,
+  letterSpacing: 0,
+  textTransform: "none",
+  color: "#000000",
+  textAlign: "left"
+}, Ln = ({
+  value: e,
+  onChange: t,
+  fontFamilies: r = Fn,
+  minFontSize: o = 8,
+  maxFontSize: a = 120,
+  fontSizeStep: u = 1,
+  title: p = "Font Controls",
+  collapsed: c = !1,
+  draggable: d = !0,
+  position: m
+}) => {
+  const [g, T] = Ae({
+    ...ot,
+    ...e
+  }), [A, Y] = Ae(!1);
+  wt(() => {
+    e && T((_) => ({ ..._, ...e }));
+  }, [e]), wt(() => {
+    Mn(r);
+  }, [r]);
+  const q = (_, x) => {
+    const b = { ...g, [_]: x };
+    T(b), t == null || t(b);
+  }, X = () => {
+    T(ot), t == null || t(ot);
+  };
+  return /* @__PURE__ */ f.jsxs(
+    Sn,
+    {
+      title: p,
+      collapsed: c,
+      draggable: d,
+      position: m,
+      children: [
+        /* @__PURE__ */ f.jsx(
+          xn,
+          {
+            value: g.fontFamily,
+            onChange: (_) => q("fontFamily", _),
+            fontFamilies: r
+          }
+        ),
+        /* @__PURE__ */ f.jsx(
+          En,
+          {
+            value: g.fontSize,
+            onChange: (_) => q("fontSize", _),
+            min: o,
+            max: a,
+            step: u
+          }
+        ),
+        /* @__PURE__ */ f.jsx(
+          _n,
+          {
+            value: g.fontWeight,
+            onChange: (_) => q("fontWeight", _)
+          }
+        ),
+        /* @__PURE__ */ f.jsx(
+          Cn,
+          {
+            value: g.lineHeight,
+            onChange: (_) => q("lineHeight", _)
+          }
+        ),
+        /* @__PURE__ */ f.jsx(
+          wn,
+          {
+            value: g.letterSpacing,
+            onChange: (_) => q("letterSpacing", _)
+          }
+        ),
+        /* @__PURE__ */ f.jsx(
+          Rn,
+          {
+            value: g.textTransform,
+            onChange: (_) => q("textTransform", _)
+          }
+        ),
+        /* @__PURE__ */ f.jsx(
+          jn,
+          {
+            value: g.color,
+            onChange: (_) => q("color", _)
+          }
+        ),
+        /* @__PURE__ */ f.jsx(
+          Dn,
+          {
+            value: g.textAlign,
+            onChange: (_) => q("textAlign", _)
+          }
+        ),
+        /* @__PURE__ */ f.jsxs(
+          "button",
+          {
+            className: "font-control-reset-button",
+            onClick: X,
+            type: "button",
+            children: [
+              /* @__PURE__ */ f.jsxs(
+                "svg",
+                {
+                  viewBox: "0 0 24 24",
+                  fill: "none",
+                  stroke: "currentColor",
+                  strokeWidth: "2",
+                  strokeLinecap: "round",
+                  strokeLinejoin: "round",
+                  children: [
+                    /* @__PURE__ */ f.jsx("polyline", { points: "1 4 1 10 7 10" }),
+                    /* @__PURE__ */ f.jsx("polyline", { points: "23 20 23 14 17 14" }),
+                    /* @__PURE__ */ f.jsx("path", { d: "M20.49 9A9 9 0 0 0 5.64 5.64L1 10m22 4l-4.64 4.36A9 9 0 0 1 3.51 15" })
+                  ]
+                }
+              ),
+              "Reset to Default"
+            ]
+          }
+        ),
+        /* @__PURE__ */ f.jsxs("div", { className: "font-control-export-section", children: [
+          /* @__PURE__ */ f.jsxs(
+            "button",
+            {
+              className: "font-control-export-toggle",
+              onClick: () => Y(!A),
+              type: "button",
+              children: [
+                /* @__PURE__ */ f.jsx(
+                  "svg",
+                  {
+                    viewBox: "0 0 24 24",
+                    fill: "none",
+                    stroke: "currentColor",
+                    strokeWidth: "2",
+                    className: A ? "rotated" : "",
+                    children: /* @__PURE__ */ f.jsx("polyline", { points: "9 18 15 12 9 6" })
+                  }
+                ),
+                "Export Configuration"
+              ]
+            }
+          ),
+          A && /* @__PURE__ */ f.jsxs("div", { className: "font-control-export-content", children: [
+            /* @__PURE__ */ f.jsx(
+              nt,
+              {
+                title: "1. Google Fonts Import (HTML)",
+                code: An(g.fontFamily),
+                language: "html"
+              }
+            ),
+            /* @__PURE__ */ f.jsx(
+              nt,
+              {
+                title: "2. React/JSX Inline Styles",
+                code: kn(g),
+                language: "tsx"
+              }
+            ),
+            /* @__PURE__ */ f.jsx(
+              nt,
+              {
+                title: "3. CSS Class",
+                code: $n(g),
+                language: "css"
+              }
+            )
+          ] })
+        ] })
+      ]
+    }
+  );
+}, Ut = {
+  fontFamily: "Arial",
+  fontSize: 16,
+  fontWeight: 400,
+  lineHeight: 1.5,
+  letterSpacing: 0,
+  textTransform: "none",
+  color: "#000000",
+  textAlign: "left"
+}, Un = (e) => {
+  const [t, r] = Ae({
+    ...Ut,
+    ...e
+  });
+  return {
+    config: t,
+    setConfig: r,
+    updateConfig: (u, p) => {
+      r((c) => ({ ...c, [u]: p }));
+    },
+    resetConfig: () => {
+      r({ ...Ut, ...e });
+    }
+  };
+};
+export {
+  Ln as FontControls,
+  Mn as loadAllDefaultFonts,
+  Nn as loadGoogleFont,
+  Un as useFontControls
+};