@sovann72-dev/lynqify-ui 1.0.4 → 1.0.8

package/dist/index-BCEcU3oG.js

@@ -0,0 +1,1955 @@
+import V, { useRef as ar, useState as Et, useDebugValue as yt, useEffect as _t, createContext as Re, useMemo as Se, createRef as ur, memo as cr, createElement as gt, useContext as we, forwardRef as lr, version as Qe, useLayoutEffect as fr } from "react";
+import dr, { flushSync as hr } from "react-dom";
+import { d as pr, f as vr, aX as mr, ax as Er, j as yr, a6 as _r, E as gr } from "./core-DSeuwlI1.js";
+var re = { exports: {} }, me = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var et;
+function Sr() {
+  if (et) return me;
+  et = 1;
+  var e = V;
+  function t(y, S) {
+    return y === S && (y !== 0 || 1 / y === 1 / S) || y !== y && S !== S;
+  }
+  var i = typeof Object.is == "function" ? Object.is : t, n = e.useState, o = e.useEffect, s = e.useLayoutEffect, c = e.useDebugValue;
+  function f(y, S) {
+    var m = S(), g = n({ inst: { value: m, getSnapshot: S } }), R = g[0].inst, h = g[1];
+    return s(
+      function() {
+        R.value = m, R.getSnapshot = S, l(R) && h({ inst: R });
+      },
+      [y, m, S]
+    ), o(
+      function() {
+        return l(R) && h({ inst: R }), y(function() {
+          l(R) && h({ inst: R });
+        });
+      },
+      [y]
+    ), c(m), m;
+  }
+  function l(y) {
+    var S = y.getSnapshot;
+    y = y.value;
+    try {
+      var m = S();
+      return !i(y, m);
+    } catch {
+      return !0;
+    }
+  }
+  function _(y, S) {
+    return S();
+  }
+  var d = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? _ : f;
+  return me.useSyncExternalStore = e.useSyncExternalStore !== void 0 ? e.useSyncExternalStore : d, me;
+}
+var Ee = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var tt;
+function br() {
+  return tt || (tt = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(m, g) {
+      return m === g && (m !== 0 || 1 / m === 1 / g) || m !== m && g !== g;
+    }
+    function t(m, g) {
+      d || o.startTransition === void 0 || (d = !0, console.error(
+        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+      ));
+      var R = g();
+      if (!y) {
+        var h = g();
+        s(R, h) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), y = !0);
+      }
+      h = c({
+        inst: { value: R, getSnapshot: g }
+      });
+      var p = h[0].inst, v = h[1];
+      return l(
+        function() {
+          p.value = R, p.getSnapshot = g, i(p) && v({ inst: p });
+        },
+        [m, R, g]
+      ), f(
+        function() {
+          return i(p) && v({ inst: p }), m(function() {
+            i(p) && v({ inst: p });
+          });
+        },
+        [m]
+      ), _(R), R;
+    }
+    function i(m) {
+      var g = m.getSnapshot;
+      m = m.value;
+      try {
+        var R = g();
+        return !s(m, R);
+      } catch {
+        return !0;
+      }
+    }
+    function n(m, g) {
+      return g();
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var o = V, s = typeof Object.is == "function" ? Object.is : e, c = o.useState, f = o.useEffect, l = o.useLayoutEffect, _ = o.useDebugValue, d = !1, y = !1, S = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? n : t;
+    Ee.useSyncExternalStore = o.useSyncExternalStore !== void 0 ? o.useSyncExternalStore : S, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), Ee;
+}
+var rt;
+function Oe() {
+  return rt || (rt = 1, process.env.NODE_ENV === "production" ? re.exports = Sr() : re.exports = br()), re.exports;
+}
+var St = Oe(), ne = { exports: {} }, H = {};
+/**
+ * @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 nt;
+function Rr() {
+  if (nt) return H;
+  nt = 1;
+  var e = V, t = Symbol.for("react.element"), i = Symbol.for("react.fragment"), n = Object.prototype.hasOwnProperty, o = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, s = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function c(f, l, _) {
+    var d, y = {}, S = null, m = null;
+    _ !== void 0 && (S = "" + _), l.key !== void 0 && (S = "" + l.key), l.ref !== void 0 && (m = l.ref);
+    for (d in l) n.call(l, d) && !s.hasOwnProperty(d) && (y[d] = l[d]);
+    if (f && f.defaultProps) for (d in l = f.defaultProps, l) y[d] === void 0 && (y[d] = l[d]);
+    return { $$typeof: t, type: f, key: S, ref: m, props: y, _owner: o.current };
+  }
+  return H.Fragment = i, H.jsx = c, H.jsxs = c, H;
+}
+var J = {};
+/**
+ * @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 it;
+function wr() {
+  return it || (it = 1, process.env.NODE_ENV !== "production" && (function() {
+    var e = V, t = Symbol.for("react.element"), i = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), o = Symbol.for("react.strict_mode"), s = Symbol.for("react.profiler"), c = Symbol.for("react.provider"), f = Symbol.for("react.context"), l = Symbol.for("react.forward_ref"), _ = Symbol.for("react.suspense"), d = Symbol.for("react.suspense_list"), y = Symbol.for("react.memo"), S = Symbol.for("react.lazy"), m = Symbol.for("react.offscreen"), g = Symbol.iterator, R = "@@iterator";
+    function h(r) {
+      if (r === null || typeof r != "object")
+        return null;
+      var a = g && r[g] || r[R];
+      return typeof a == "function" ? a : null;
+    }
+    var p = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function v(r) {
+      {
+        for (var a = arguments.length, u = new Array(a > 1 ? a - 1 : 0), E = 1; E < a; E++)
+          u[E - 1] = arguments[E];
+        M("error", r, u);
+      }
+    }
+    function M(r, a, u) {
+      {
+        var E = p.ReactDebugCurrentFrame, O = E.getStackAddendum();
+        O !== "" && (a += "%s", u = u.concat([O]));
+        var C = u.map(function(w) {
+          return String(w);
+        });
+        C.unshift("Warning: " + a), Function.prototype.apply.call(console[r], console, C);
+      }
+    }
+    var D = !1, A = !1, T = !1, P = !1, W = !1, Ae;
+    Ae = Symbol.for("react.module.reference");
+    function Pt(r) {
+      return !!(typeof r == "string" || typeof r == "function" || r === n || r === s || W || r === o || r === _ || r === d || P || r === m || D || A || T || typeof r == "object" && r !== null && (r.$$typeof === S || r.$$typeof === y || r.$$typeof === c || r.$$typeof === f || r.$$typeof === l || // 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.
+      r.$$typeof === Ae || r.getModuleId !== void 0));
+    }
+    function It(r, a, u) {
+      var E = r.displayName;
+      if (E)
+        return E;
+      var O = a.displayName || a.name || "";
+      return O !== "" ? u + "(" + O + ")" : u;
+    }
+    function xe(r) {
+      return r.displayName || "Context";
+    }
+    function q(r) {
+      if (r == null)
+        return null;
+      if (typeof r.tag == "number" && v("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof r == "function")
+        return r.displayName || r.name || null;
+      if (typeof r == "string")
+        return r;
+      switch (r) {
+        case n:
+          return "Fragment";
+        case i:
+          return "Portal";
+        case s:
+          return "Profiler";
+        case o:
+          return "StrictMode";
+        case _:
+          return "Suspense";
+        case d:
+          return "SuspenseList";
+      }
+      if (typeof r == "object")
+        switch (r.$$typeof) {
+          case f:
+            var a = r;
+            return xe(a) + ".Consumer";
+          case c:
+            var u = r;
+            return xe(u._context) + ".Provider";
+          case l:
+            return It(r, r.render, "ForwardRef");
+          case y:
+            var E = r.displayName || null;
+            return E !== null ? E : q(r.type) || "Memo";
+          case S: {
+            var O = r, C = O._payload, w = O._init;
+            try {
+              return q(w(C));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var F = Object.assign, z = 0, je, De, Pe, Ie, Me, Ve, ke;
+    function Ne() {
+    }
+    Ne.__reactDisabledLog = !0;
+    function Mt() {
+      {
+        if (z === 0) {
+          je = console.log, De = console.info, Pe = console.warn, Ie = console.error, Me = console.group, Ve = console.groupCollapsed, ke = console.groupEnd;
+          var r = {
+            configurable: !0,
+            enumerable: !0,
+            value: Ne,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: r,
+            log: r,
+            warn: r,
+            error: r,
+            group: r,
+            groupCollapsed: r,
+            groupEnd: r
+          });
+        }
+        z++;
+      }
+    }
+    function Vt() {
+      {
+        if (z--, z === 0) {
+          var r = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: F({}, r, {
+              value: je
+            }),
+            info: F({}, r, {
+              value: De
+            }),
+            warn: F({}, r, {
+              value: Pe
+            }),
+            error: F({}, r, {
+              value: Ie
+            }),
+            group: F({}, r, {
+              value: Me
+            }),
+            groupCollapsed: F({}, r, {
+              value: Ve
+            }),
+            groupEnd: F({}, r, {
+              value: ke
+            })
+          });
+        }
+        z < 0 && v("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var ue = p.ReactCurrentDispatcher, ce;
+    function Z(r, a, u) {
+      {
+        if (ce === void 0)
+          try {
+            throw Error();
+          } catch (O) {
+            var E = O.stack.trim().match(/\n( *(at )?)/);
+            ce = E && E[1] || "";
+          }
+        return `
+` + ce + r;
+      }
+    }
+    var le = !1, Q;
+    {
+      var kt = typeof WeakMap == "function" ? WeakMap : Map;
+      Q = new kt();
+    }
+    function Le(r, a) {
+      if (!r || le)
+        return "";
+      {
+        var u = Q.get(r);
+        if (u !== void 0)
+          return u;
+      }
+      var E;
+      le = !0;
+      var O = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var C;
+      C = ue.current, ue.current = null, Mt();
+      try {
+        if (a) {
+          var w = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(w.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(w, []);
+            } catch (N) {
+              E = N;
+            }
+            Reflect.construct(r, [], w);
+          } else {
+            try {
+              w.call();
+            } catch (N) {
+              E = N;
+            }
+            r.call(w.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (N) {
+            E = N;
+          }
+          r();
+        }
+      } catch (N) {
+        if (N && E && typeof N.stack == "string") {
+          for (var b = N.stack.split(`
+`), k = E.stack.split(`
+`), x = b.length - 1, j = k.length - 1; x >= 1 && j >= 0 && b[x] !== k[j]; )
+            j--;
+          for (; x >= 1 && j >= 0; x--, j--)
+            if (b[x] !== k[j]) {
+              if (x !== 1 || j !== 1)
+                do
+                  if (x--, j--, j < 0 || b[x] !== k[j]) {
+                    var L = `
+` + b[x].replace(" at new ", " at ");
+                    return r.displayName && L.includes("<anonymous>") && (L = L.replace("<anonymous>", r.displayName)), typeof r == "function" && Q.set(r, L), L;
+                  }
+                while (x >= 1 && j >= 0);
+              break;
+            }
+        }
+      } finally {
+        le = !1, ue.current = C, Vt(), Error.prepareStackTrace = O;
+      }
+      var Y = r ? r.displayName || r.name : "", $ = Y ? Z(Y) : "";
+      return typeof r == "function" && Q.set(r, $), $;
+    }
+    function Nt(r, a, u) {
+      return Le(r, !1);
+    }
+    function Lt(r) {
+      var a = r.prototype;
+      return !!(a && a.isReactComponent);
+    }
+    function ee(r, a, u) {
+      if (r == null)
+        return "";
+      if (typeof r == "function")
+        return Le(r, Lt(r));
+      if (typeof r == "string")
+        return Z(r);
+      switch (r) {
+        case _:
+          return Z("Suspense");
+        case d:
+          return Z("SuspenseList");
+      }
+      if (typeof r == "object")
+        switch (r.$$typeof) {
+          case l:
+            return Nt(r.render);
+          case y:
+            return ee(r.type, a, u);
+          case S: {
+            var E = r, O = E._payload, C = E._init;
+            try {
+              return ee(C(O), a, u);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var K = Object.prototype.hasOwnProperty, qe = {}, Ue = p.ReactDebugCurrentFrame;
+    function te(r) {
+      if (r) {
+        var a = r._owner, u = ee(r.type, r._source, a ? a.type : null);
+        Ue.setExtraStackFrame(u);
+      } else
+        Ue.setExtraStackFrame(null);
+    }
+    function qt(r, a, u, E, O) {
+      {
+        var C = Function.call.bind(K);
+        for (var w in r)
+          if (C(r, w)) {
+            var b = void 0;
+            try {
+              if (typeof r[w] != "function") {
+                var k = Error((E || "React class") + ": " + u + " type `" + w + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof r[w] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw k.name = "Invariant Violation", k;
+              }
+              b = r[w](a, w, E, u, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (x) {
+              b = x;
+            }
+            b && !(b instanceof Error) && (te(O), v("%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", u, w, typeof b), te(null)), b instanceof Error && !(b.message in qe) && (qe[b.message] = !0, te(O), v("Failed %s type: %s", u, b.message), te(null));
+          }
+      }
+    }
+    var Ut = Array.isArray;
+    function fe(r) {
+      return Ut(r);
+    }
+    function Wt(r) {
+      {
+        var a = typeof Symbol == "function" && Symbol.toStringTag, u = a && r[Symbol.toStringTag] || r.constructor.name || "Object";
+        return u;
+      }
+    }
+    function Ft(r) {
+      try {
+        return We(r), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function We(r) {
+      return "" + r;
+    }
+    function Fe(r) {
+      if (Ft(r))
+        return v("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Wt(r)), We(r);
+    }
+    var $e = p.ReactCurrentOwner, $t = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, Be, Ge;
+    function Bt(r) {
+      if (K.call(r, "ref")) {
+        var a = Object.getOwnPropertyDescriptor(r, "ref").get;
+        if (a && a.isReactWarning)
+          return !1;
+      }
+      return r.ref !== void 0;
+    }
+    function Gt(r) {
+      if (K.call(r, "key")) {
+        var a = Object.getOwnPropertyDescriptor(r, "key").get;
+        if (a && a.isReactWarning)
+          return !1;
+      }
+      return r.key !== void 0;
+    }
+    function Yt(r, a) {
+      typeof r.ref == "string" && $e.current;
+    }
+    function zt(r, a) {
+      {
+        var u = function() {
+          Be || (Be = !0, v("%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)", a));
+        };
+        u.isReactWarning = !0, Object.defineProperty(r, "key", {
+          get: u,
+          configurable: !0
+        });
+      }
+    }
+    function Kt(r, a) {
+      {
+        var u = function() {
+          Ge || (Ge = !0, v("%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)", a));
+        };
+        u.isReactWarning = !0, Object.defineProperty(r, "ref", {
+          get: u,
+          configurable: !0
+        });
+      }
+    }
+    var Ht = function(r, a, u, E, O, C, w) {
+      var b = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: t,
+        // Built-in properties that belong on the element
+        type: r,
+        key: a,
+        ref: u,
+        props: w,
+        // Record the component responsible for creating this element.
+        _owner: C
+      };
+      return b._store = {}, Object.defineProperty(b._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(b, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: E
+      }), Object.defineProperty(b, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: O
+      }), Object.freeze && (Object.freeze(b.props), Object.freeze(b)), b;
+    };
+    function Jt(r, a, u, E, O) {
+      {
+        var C, w = {}, b = null, k = null;
+        u !== void 0 && (Fe(u), b = "" + u), Gt(a) && (Fe(a.key), b = "" + a.key), Bt(a) && (k = a.ref, Yt(a, O));
+        for (C in a)
+          K.call(a, C) && !$t.hasOwnProperty(C) && (w[C] = a[C]);
+        if (r && r.defaultProps) {
+          var x = r.defaultProps;
+          for (C in x)
+            w[C] === void 0 && (w[C] = x[C]);
+        }
+        if (b || k) {
+          var j = typeof r == "function" ? r.displayName || r.name || "Unknown" : r;
+          b && zt(w, j), k && Kt(w, j);
+        }
+        return Ht(r, b, k, O, E, $e.current, w);
+      }
+    }
+    var de = p.ReactCurrentOwner, Ye = p.ReactDebugCurrentFrame;
+    function G(r) {
+      if (r) {
+        var a = r._owner, u = ee(r.type, r._source, a ? a.type : null);
+        Ye.setExtraStackFrame(u);
+      } else
+        Ye.setExtraStackFrame(null);
+    }
+    var he;
+    he = !1;
+    function pe(r) {
+      return typeof r == "object" && r !== null && r.$$typeof === t;
+    }
+    function ze() {
+      {
+        if (de.current) {
+          var r = q(de.current.type);
+          if (r)
+            return `
+
+Check the render method of \`` + r + "`.";
+        }
+        return "";
+      }
+    }
+    function Xt(r) {
+      return "";
+    }
+    var Ke = {};
+    function Zt(r) {
+      {
+        var a = ze();
+        if (!a) {
+          var u = typeof r == "string" ? r : r.displayName || r.name;
+          u && (a = `
+
+Check the top-level render call using <` + u + ">.");
+        }
+        return a;
+      }
+    }
+    function He(r, a) {
+      {
+        if (!r._store || r._store.validated || r.key != null)
+          return;
+        r._store.validated = !0;
+        var u = Zt(a);
+        if (Ke[u])
+          return;
+        Ke[u] = !0;
+        var E = "";
+        r && r._owner && r._owner !== de.current && (E = " It was passed a child from " + q(r._owner.type) + "."), G(r), v('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', u, E), G(null);
+      }
+    }
+    function Je(r, a) {
+      {
+        if (typeof r != "object")
+          return;
+        if (fe(r))
+          for (var u = 0; u < r.length; u++) {
+            var E = r[u];
+            pe(E) && He(E, a);
+          }
+        else if (pe(r))
+          r._store && (r._store.validated = !0);
+        else if (r) {
+          var O = h(r);
+          if (typeof O == "function" && O !== r.entries)
+            for (var C = O.call(r), w; !(w = C.next()).done; )
+              pe(w.value) && He(w.value, a);
+        }
+      }
+    }
+    function Qt(r) {
+      {
+        var a = r.type;
+        if (a == null || typeof a == "string")
+          return;
+        var u;
+        if (typeof a == "function")
+          u = a.propTypes;
+        else if (typeof a == "object" && (a.$$typeof === l || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        a.$$typeof === y))
+          u = a.propTypes;
+        else
+          return;
+        if (u) {
+          var E = q(a);
+          qt(u, r.props, "prop", E, r);
+        } else if (a.PropTypes !== void 0 && !he) {
+          he = !0;
+          var O = q(a);
+          v("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", O || "Unknown");
+        }
+        typeof a.getDefaultProps == "function" && !a.getDefaultProps.isReactClassApproved && v("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function er(r) {
+      {
+        for (var a = Object.keys(r.props), u = 0; u < a.length; u++) {
+          var E = a[u];
+          if (E !== "children" && E !== "key") {
+            G(r), v("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", E), G(null);
+            break;
+          }
+        }
+        r.ref !== null && (G(r), v("Invalid attribute `ref` supplied to `React.Fragment`."), G(null));
+      }
+    }
+    var Xe = {};
+    function Ze(r, a, u, E, O, C) {
+      {
+        var w = Pt(r);
+        if (!w) {
+          var b = "";
+          (r === void 0 || typeof r == "object" && r !== null && Object.keys(r).length === 0) && (b += " 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 k = Xt();
+          k ? b += k : b += ze();
+          var x;
+          r === null ? x = "null" : fe(r) ? x = "array" : r !== void 0 && r.$$typeof === t ? (x = "<" + (q(r.type) || "Unknown") + " />", b = " Did you accidentally export a JSX literal instead of a component?") : x = typeof r, v("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", x, b);
+        }
+        var j = Jt(r, a, u, O, C);
+        if (j == null)
+          return j;
+        if (w) {
+          var L = a.children;
+          if (L !== void 0)
+            if (E)
+              if (fe(L)) {
+                for (var Y = 0; Y < L.length; Y++)
+                  Je(L[Y], r);
+                Object.freeze && Object.freeze(L);
+              } else
+                v("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
+              Je(L, r);
+        }
+        if (K.call(a, "key")) {
+          var $ = q(r), N = Object.keys(a).filter(function(sr) {
+            return sr !== "key";
+          }), ve = N.length > 0 ? "{key: someKey, " + N.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!Xe[$ + ve]) {
+            var or = N.length > 0 ? "{" + N.join(": ..., ") + ": ...}" : "{}";
+            v(`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} />`, ve, $, or, $), Xe[$ + ve] = !0;
+          }
+        }
+        return r === n ? er(j) : Qt(j), j;
+      }
+    }
+    function tr(r, a, u) {
+      return Ze(r, a, u, !0);
+    }
+    function rr(r, a, u) {
+      return Ze(r, a, u, !1);
+    }
+    var nr = rr, ir = tr;
+    J.Fragment = n, J.jsx = nr, J.jsxs = ir;
+  })()), J;
+}
+var ot;
+function Or() {
+  return ot || (ot = 1, process.env.NODE_ENV === "production" ? ne.exports = Rr() : ne.exports = wr()), ne.exports;
+}
+var I = Or();
+const { getOwnPropertyNames: Cr, getOwnPropertySymbols: Tr } = Object, { hasOwnProperty: Ar } = Object.prototype;
+function ye(e, t) {
+  return function(n, o, s) {
+    return e(n, o, s) && t(n, o, s);
+  };
+}
+function ie(e) {
+  return function(i, n, o) {
+    if (!i || !n || typeof i != "object" || typeof n != "object")
+      return e(i, n, o);
+    const { cache: s } = o, c = s.get(i), f = s.get(n);
+    if (c && f)
+      return c === n && f === i;
+    s.set(i, n), s.set(n, i);
+    const l = e(i, n, o);
+    return s.delete(i), s.delete(n), l;
+  };
+}
+function xr(e) {
+  return e != null ? e[Symbol.toStringTag] : void 0;
+}
+function st(e) {
+  return Cr(e).concat(Tr(e));
+}
+const jr = (
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  Object.hasOwn || ((e, t) => Ar.call(e, t))
+);
+function B(e, t) {
+  return e === t || !e && !t && e !== e && t !== t;
+}
+const Dr = "__v", Pr = "__o", Ir = "_owner", { getOwnPropertyDescriptor: at, keys: ut } = Object;
+function Mr(e, t) {
+  return e.byteLength === t.byteLength && se(new Uint8Array(e), new Uint8Array(t));
+}
+function Vr(e, t, i) {
+  let n = e.length;
+  if (t.length !== n)
+    return !1;
+  for (; n-- > 0; )
+    if (!i.equals(e[n], t[n], n, n, e, t, i))
+      return !1;
+  return !0;
+}
+function kr(e, t) {
+  return e.byteLength === t.byteLength && se(new Uint8Array(e.buffer, e.byteOffset, e.byteLength), new Uint8Array(t.buffer, t.byteOffset, t.byteLength));
+}
+function Nr(e, t) {
+  return B(e.getTime(), t.getTime());
+}
+function Lr(e, t) {
+  return e.name === t.name && e.message === t.message && e.cause === t.cause && e.stack === t.stack;
+}
+function qr(e, t) {
+  return e === t;
+}
+function ct(e, t, i) {
+  const n = e.size;
+  if (n !== t.size)
+    return !1;
+  if (!n)
+    return !0;
+  const o = new Array(n), s = e.entries();
+  let c, f, l = 0;
+  for (; (c = s.next()) && !c.done; ) {
+    const _ = t.entries();
+    let d = !1, y = 0;
+    for (; (f = _.next()) && !f.done; ) {
+      if (o[y]) {
+        y++;
+        continue;
+      }
+      const S = c.value, m = f.value;
+      if (i.equals(S[0], m[0], l, y, e, t, i) && i.equals(S[1], m[1], S[0], m[0], e, t, i)) {
+        d = o[y] = !0;
+        break;
+      }
+      y++;
+    }
+    if (!d)
+      return !1;
+    l++;
+  }
+  return !0;
+}
+const Ur = B;
+function Wr(e, t, i) {
+  const n = ut(e);
+  let o = n.length;
+  if (ut(t).length !== o)
+    return !1;
+  for (; o-- > 0; )
+    if (!bt(e, t, i, n[o]))
+      return !1;
+  return !0;
+}
+function X(e, t, i) {
+  const n = st(e);
+  let o = n.length;
+  if (st(t).length !== o)
+    return !1;
+  let s, c, f;
+  for (; o-- > 0; )
+    if (s = n[o], !bt(e, t, i, s) || (c = at(e, s), f = at(t, s), (c || f) && (!c || !f || c.configurable !== f.configurable || c.enumerable !== f.enumerable || c.writable !== f.writable)))
+      return !1;
+  return !0;
+}
+function Fr(e, t) {
+  return B(e.valueOf(), t.valueOf());
+}
+function $r(e, t) {
+  return e.source === t.source && e.flags === t.flags;
+}
+function lt(e, t, i) {
+  const n = e.size;
+  if (n !== t.size)
+    return !1;
+  if (!n)
+    return !0;
+  const o = new Array(n), s = e.values();
+  let c, f;
+  for (; (c = s.next()) && !c.done; ) {
+    const l = t.values();
+    let _ = !1, d = 0;
+    for (; (f = l.next()) && !f.done; ) {
+      if (!o[d] && i.equals(c.value, f.value, c.value, f.value, e, t, i)) {
+        _ = o[d] = !0;
+        break;
+      }
+      d++;
+    }
+    if (!_)
+      return !1;
+  }
+  return !0;
+}
+function se(e, t) {
+  let i = e.byteLength;
+  if (t.byteLength !== i || e.byteOffset !== t.byteOffset)
+    return !1;
+  for (; i-- > 0; )
+    if (e[i] !== t[i])
+      return !1;
+  return !0;
+}
+function Br(e, t) {
+  return e.hostname === t.hostname && e.pathname === t.pathname && e.protocol === t.protocol && e.port === t.port && e.hash === t.hash && e.username === t.username && e.password === t.password;
+}
+function bt(e, t, i, n) {
+  return (n === Ir || n === Pr || n === Dr) && (e.$$typeof || t.$$typeof) ? !0 : jr(t, n) && i.equals(e[n], t[n], n, n, e, t, i);
+}
+const Gr = "[object ArrayBuffer]", Yr = "[object Arguments]", zr = "[object Boolean]", Kr = "[object DataView]", Hr = "[object Date]", Jr = "[object Error]", Xr = "[object Map]", Zr = "[object Number]", Qr = "[object Object]", en = "[object RegExp]", tn = "[object Set]", rn = "[object String]", nn = {
+  "[object Int8Array]": !0,
+  "[object Uint8Array]": !0,
+  "[object Uint8ClampedArray]": !0,
+  "[object Int16Array]": !0,
+  "[object Uint16Array]": !0,
+  "[object Int32Array]": !0,
+  "[object Uint32Array]": !0,
+  "[object Float16Array]": !0,
+  "[object Float32Array]": !0,
+  "[object Float64Array]": !0,
+  "[object BigInt64Array]": !0,
+  "[object BigUint64Array]": !0
+}, on = "[object URL]", sn = Object.prototype.toString;
+function an({ areArrayBuffersEqual: e, areArraysEqual: t, areDataViewsEqual: i, areDatesEqual: n, areErrorsEqual: o, areFunctionsEqual: s, areMapsEqual: c, areNumbersEqual: f, areObjectsEqual: l, arePrimitiveWrappersEqual: _, areRegExpsEqual: d, areSetsEqual: y, areTypedArraysEqual: S, areUrlsEqual: m, unknownTagComparators: g }) {
+  return function(h, p, v) {
+    if (h === p)
+      return !0;
+    if (h == null || p == null)
+      return !1;
+    const M = typeof h;
+    if (M !== typeof p)
+      return !1;
+    if (M !== "object")
+      return M === "number" ? f(h, p, v) : M === "function" ? s(h, p, v) : !1;
+    const D = h.constructor;
+    if (D !== p.constructor)
+      return !1;
+    if (D === Object)
+      return l(h, p, v);
+    if (Array.isArray(h))
+      return t(h, p, v);
+    if (D === Date)
+      return n(h, p, v);
+    if (D === RegExp)
+      return d(h, p, v);
+    if (D === Map)
+      return c(h, p, v);
+    if (D === Set)
+      return y(h, p, v);
+    const A = sn.call(h);
+    if (A === Hr)
+      return n(h, p, v);
+    if (A === en)
+      return d(h, p, v);
+    if (A === Xr)
+      return c(h, p, v);
+    if (A === tn)
+      return y(h, p, v);
+    if (A === Qr)
+      return typeof h.then != "function" && typeof p.then != "function" && l(h, p, v);
+    if (A === on)
+      return m(h, p, v);
+    if (A === Jr)
+      return o(h, p, v);
+    if (A === Yr)
+      return l(h, p, v);
+    if (nn[A])
+      return S(h, p, v);
+    if (A === Gr)
+      return e(h, p, v);
+    if (A === Kr)
+      return i(h, p, v);
+    if (A === zr || A === Zr || A === rn)
+      return _(h, p, v);
+    if (g) {
+      let T = g[A];
+      if (!T) {
+        const P = xr(h);
+        P && (T = g[P]);
+      }
+      if (T)
+        return T(h, p, v);
+    }
+    return !1;
+  };
+}
+function un({ circular: e, createCustomConfig: t, strict: i }) {
+  let n = {
+    areArrayBuffersEqual: Mr,
+    areArraysEqual: i ? X : Vr,
+    areDataViewsEqual: kr,
+    areDatesEqual: Nr,
+    areErrorsEqual: Lr,
+    areFunctionsEqual: qr,
+    areMapsEqual: i ? ye(ct, X) : ct,
+    areNumbersEqual: Ur,
+    areObjectsEqual: i ? X : Wr,
+    arePrimitiveWrappersEqual: Fr,
+    areRegExpsEqual: $r,
+    areSetsEqual: i ? ye(lt, X) : lt,
+    areTypedArraysEqual: i ? ye(se, X) : se,
+    areUrlsEqual: Br,
+    unknownTagComparators: void 0
+  };
+  if (t && (n = Object.assign({}, n, t(n))), e) {
+    const o = ie(n.areArraysEqual), s = ie(n.areMapsEqual), c = ie(n.areObjectsEqual), f = ie(n.areSetsEqual);
+    n = Object.assign({}, n, {
+      areArraysEqual: o,
+      areMapsEqual: s,
+      areObjectsEqual: c,
+      areSetsEqual: f
+    });
+  }
+  return n;
+}
+function cn(e) {
+  return function(t, i, n, o, s, c, f) {
+    return e(t, i, f);
+  };
+}
+function ln({ circular: e, comparator: t, createState: i, equals: n, strict: o }) {
+  if (i)
+    return function(f, l) {
+      const { cache: _ = e ? /* @__PURE__ */ new WeakMap() : void 0, meta: d } = i();
+      return t(f, l, {
+        cache: _,
+        equals: n,
+        meta: d,
+        strict: o
+      });
+    };
+  if (e)
+    return function(f, l) {
+      return t(f, l, {
+        cache: /* @__PURE__ */ new WeakMap(),
+        equals: n,
+        meta: void 0,
+        strict: o
+      });
+    };
+  const s = {
+    cache: void 0,
+    equals: n,
+    meta: void 0,
+    strict: o
+  };
+  return function(f, l) {
+    return t(f, l, s);
+  };
+}
+const fn = U();
+U({ strict: !0 });
+U({ circular: !0 });
+U({
+  circular: !0,
+  strict: !0
+});
+U({
+  createInternalComparator: () => B
+});
+U({
+  strict: !0,
+  createInternalComparator: () => B
+});
+U({
+  circular: !0,
+  createInternalComparator: () => B
+});
+U({
+  circular: !0,
+  createInternalComparator: () => B,
+  strict: !0
+});
+function U(e = {}) {
+  const { circular: t = !1, createInternalComparator: i, createState: n, strict: o = !1 } = e, s = un(e), c = an(s), f = i ? i(c) : cn(c);
+  return ln({ circular: t, comparator: c, createState: n, equals: f, strict: o });
+}
+var oe = { exports: {} }, _e = {};
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var ft;
+function dn() {
+  if (ft) return _e;
+  ft = 1;
+  var e = V, t = Oe();
+  function i(_, d) {
+    return _ === d && (_ !== 0 || 1 / _ === 1 / d) || _ !== _ && d !== d;
+  }
+  var n = typeof Object.is == "function" ? Object.is : i, o = t.useSyncExternalStore, s = e.useRef, c = e.useEffect, f = e.useMemo, l = e.useDebugValue;
+  return _e.useSyncExternalStoreWithSelector = function(_, d, y, S, m) {
+    var g = s(null);
+    if (g.current === null) {
+      var R = { hasValue: !1, value: null };
+      g.current = R;
+    } else R = g.current;
+    g = f(
+      function() {
+        function p(T) {
+          if (!v) {
+            if (v = !0, M = T, T = S(T), m !== void 0 && R.hasValue) {
+              var P = R.value;
+              if (m(P, T))
+                return D = P;
+            }
+            return D = T;
+          }
+          if (P = D, n(M, T)) return P;
+          var W = S(T);
+          return m !== void 0 && m(P, W) ? (M = T, P) : (M = T, D = W);
+        }
+        var v = !1, M, D, A = y === void 0 ? null : y;
+        return [
+          function() {
+            return p(d());
+          },
+          A === null ? void 0 : function() {
+            return p(A());
+          }
+        ];
+      },
+      [d, y, S, m]
+    );
+    var h = o(_, g[0], g[1]);
+    return c(
+      function() {
+        R.hasValue = !0, R.value = h;
+      },
+      [h]
+    ), l(h), h;
+  }, _e;
+}
+var ge = {};
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var dt;
+function hn() {
+  return dt || (dt = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(_, d) {
+      return _ === d && (_ !== 0 || 1 / _ === 1 / d) || _ !== _ && d !== d;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var t = V, i = Oe(), n = typeof Object.is == "function" ? Object.is : e, o = i.useSyncExternalStore, s = t.useRef, c = t.useEffect, f = t.useMemo, l = t.useDebugValue;
+    ge.useSyncExternalStoreWithSelector = function(_, d, y, S, m) {
+      var g = s(null);
+      if (g.current === null) {
+        var R = { hasValue: !1, value: null };
+        g.current = R;
+      } else R = g.current;
+      g = f(
+        function() {
+          function p(T) {
+            if (!v) {
+              if (v = !0, M = T, T = S(T), m !== void 0 && R.hasValue) {
+                var P = R.value;
+                if (m(P, T))
+                  return D = P;
+              }
+              return D = T;
+            }
+            if (P = D, n(M, T))
+              return P;
+            var W = S(T);
+            return m !== void 0 && m(P, W) ? (M = T, P) : (M = T, D = W);
+          }
+          var v = !1, M, D, A = y === void 0 ? null : y;
+          return [
+            function() {
+              return p(d());
+            },
+            A === null ? void 0 : function() {
+              return p(A());
+            }
+          ];
+        },
+        [d, y, S, m]
+      );
+      var h = o(_, g[0], g[1]);
+      return c(
+        function() {
+          R.hasValue = !0, R.value = h;
+        },
+        [h]
+      ), l(h), h;
+    }, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), ge;
+}
+var ht;
+function pn() {
+  return ht || (ht = 1, process.env.NODE_ENV === "production" ? oe.exports = dn() : oe.exports = hn()), oe.exports;
+}
+var vn = pn(), mn = (...e) => (t) => {
+  e.forEach((i) => {
+    typeof i == "function" ? i(t) : i && (i.current = t);
+  });
+}, En = ({ contentComponent: e }) => {
+  const t = St.useSyncExternalStore(
+    e.subscribe,
+    e.getSnapshot,
+    e.getServerSnapshot
+  );
+  return /* @__PURE__ */ I.jsx(I.Fragment, { children: Object.values(t) });
+};
+function yn() {
+  const e = /* @__PURE__ */ new Set();
+  let t = {};
+  return {
+    /**
+     * Subscribe to the editor instance's changes.
+     */
+    subscribe(i) {
+      return e.add(i), () => {
+        e.delete(i);
+      };
+    },
+    getSnapshot() {
+      return t;
+    },
+    getServerSnapshot() {
+      return t;
+    },
+    /**
+     * Adds a new NodeView Renderer to the editor.
+     */
+    setRenderer(i, n) {
+      t = {
+        ...t,
+        [i]: dr.createPortal(n.reactElement, n.element, i)
+      }, e.forEach((o) => o());
+    },
+    /**
+     * Removes a NodeView Renderer from the editor.
+     */
+    removeRenderer(i) {
+      const n = { ...t };
+      delete n[i], t = n, e.forEach((o) => o());
+    }
+  };
+}
+var _n = class extends V.Component {
+  constructor(e) {
+    super(e), this.editorContentRef = V.createRef();
+  }
+  componentDidMount() {
+    this.init();
+  }
+  componentDidUpdate() {
+    this.init();
+  }
+  init() {
+    var e;
+    const t = this.props.editor;
+    if (t && !t.isDestroyed && ((e = t.view.dom) != null && e.parentNode)) {
+      if (t.contentComponent)
+        return;
+      const i = this.editorContentRef.current;
+      i.append(...t.view.dom.parentNode.childNodes), t.setOptions({
+        element: i
+      }), t.contentComponent = yn(), t.createNodeViews(), t.isEditorContentInitialized = !0, this.forceUpdate();
+    }
+  }
+  componentWillUnmount() {
+    var e;
+    const t = this.props.editor;
+    if (t) {
+      t.isEditorContentInitialized = !1, t.isDestroyed || t.view.setProps({
+        nodeViews: {}
+      }), t.contentComponent = null;
+      try {
+        if (!((e = t.view.dom) != null && e.parentNode))
+          return;
+        const i = document.createElement("div");
+        i.append(...t.view.dom.parentNode.childNodes), t.setOptions({
+          element: i
+        });
+      } catch {
+      }
+    }
+  }
+  render() {
+    const { editor: e, innerRef: t, ...i } = this.props;
+    return /* @__PURE__ */ I.jsxs(I.Fragment, { children: [
+      /* @__PURE__ */ I.jsx("div", { ref: mn(t, this.editorContentRef), ...i }),
+      (e == null ? void 0 : e.contentComponent) && /* @__PURE__ */ I.jsx(En, { contentComponent: e.contentComponent })
+    ] });
+  }
+}, gn = lr(
+  (e, t) => {
+    const i = V.useMemo(() => Math.floor(Math.random() * 4294967295).toString(), [e.editor]);
+    return V.createElement(_n, {
+      key: i,
+      innerRef: t,
+      ...e
+    });
+  }
+), Rt = V.memo(gn), Sn = typeof window < "u" ? fr : _t, bn = class {
+  constructor(e) {
+    this.transactionNumber = 0, this.lastTransactionNumber = 0, this.subscribers = /* @__PURE__ */ new Set(), this.editor = e, this.lastSnapshot = { editor: e, transactionNumber: 0 }, this.getSnapshot = this.getSnapshot.bind(this), this.getServerSnapshot = this.getServerSnapshot.bind(this), this.watch = this.watch.bind(this), this.subscribe = this.subscribe.bind(this);
+  }
+  /**
+   * Get the current editor instance.
+   */
+  getSnapshot() {
+    return this.transactionNumber === this.lastTransactionNumber ? this.lastSnapshot : (this.lastTransactionNumber = this.transactionNumber, this.lastSnapshot = { editor: this.editor, transactionNumber: this.transactionNumber }, this.lastSnapshot);
+  }
+  /**
+   * Always disable the editor on the server-side.
+   */
+  getServerSnapshot() {
+    return { editor: null, transactionNumber: 0 };
+  }
+  /**
+   * Subscribe to the editor instance's changes.
+   */
+  subscribe(e) {
+    return this.subscribers.add(e), () => {
+      this.subscribers.delete(e);
+    };
+  }
+  /**
+   * Watch the editor instance for changes.
+   */
+  watch(e) {
+    if (this.editor = e, this.editor) {
+      const t = () => {
+        this.transactionNumber += 1, this.subscribers.forEach((n) => n());
+      }, i = this.editor;
+      return i.on("transaction", t), () => {
+        i.off("transaction", t);
+      };
+    }
+  }
+};
+function wt(e) {
+  var t;
+  const [i] = Et(() => new bn(e.editor)), n = vn.useSyncExternalStoreWithSelector(
+    i.subscribe,
+    i.getSnapshot,
+    i.getServerSnapshot,
+    e.selector,
+    (t = e.equalityFn) != null ? t : fn
+  );
+  return Sn(() => i.watch(e.editor), [e.editor, i]), yt(n), n;
+}
+var pt = process.env.NODE_ENV !== "production", be = typeof window > "u", Rn = be || !!(typeof window < "u" && window.next), wn = class Ot {
+  constructor(t) {
+    this.editor = null, this.subscriptions = /* @__PURE__ */ new Set(), this.isComponentMounted = !1, this.previousDeps = null, this.instanceId = "", this.options = t, this.subscriptions = /* @__PURE__ */ new Set(), this.setEditor(this.getInitialEditor()), this.scheduleDestroy(), this.getEditor = this.getEditor.bind(this), this.getServerSnapshot = this.getServerSnapshot.bind(this), this.subscribe = this.subscribe.bind(this), this.refreshEditorInstance = this.refreshEditorInstance.bind(this), this.scheduleDestroy = this.scheduleDestroy.bind(this), this.onRender = this.onRender.bind(this), this.createEditor = this.createEditor.bind(this);
+  }
+  setEditor(t) {
+    this.editor = t, this.instanceId = Math.random().toString(36).slice(2, 9), this.subscriptions.forEach((i) => i());
+  }
+  getInitialEditor() {
+    if (this.options.current.immediatelyRender === void 0) {
+      if (be || Rn) {
+        if (pt)
+          throw new Error(
+            "Tiptap Error: SSR has been detected, please set `immediatelyRender` explicitly to `false` to avoid hydration mismatches."
+          );
+        return null;
+      }
+      return this.createEditor();
+    }
+    if (this.options.current.immediatelyRender && be && pt)
+      throw new Error(
+        "Tiptap Error: SSR has been detected, and `immediatelyRender` has been set to `true` this is an unsupported configuration that may result in errors, explicitly set `immediatelyRender` to `false` to avoid hydration mismatches."
+      );
+    return this.options.current.immediatelyRender ? this.createEditor() : null;
+  }
+  /**
+   * Create a new editor instance. And attach event listeners.
+   */
+  createEditor() {
+    const t = {
+      ...this.options.current,
+      // Always call the most recent version of the callback function by default
+      onBeforeCreate: (...n) => {
+        var o, s;
+        return (s = (o = this.options.current).onBeforeCreate) == null ? void 0 : s.call(o, ...n);
+      },
+      onBlur: (...n) => {
+        var o, s;
+        return (s = (o = this.options.current).onBlur) == null ? void 0 : s.call(o, ...n);
+      },
+      onCreate: (...n) => {
+        var o, s;
+        return (s = (o = this.options.current).onCreate) == null ? void 0 : s.call(o, ...n);
+      },
+      onDestroy: (...n) => {
+        var o, s;
+        return (s = (o = this.options.current).onDestroy) == null ? void 0 : s.call(o, ...n);
+      },
+      onFocus: (...n) => {
+        var o, s;
+        return (s = (o = this.options.current).onFocus) == null ? void 0 : s.call(o, ...n);
+      },
+      onSelectionUpdate: (...n) => {
+        var o, s;
+        return (s = (o = this.options.current).onSelectionUpdate) == null ? void 0 : s.call(o, ...n);
+      },
+      onTransaction: (...n) => {
+        var o, s;
+        return (s = (o = this.options.current).onTransaction) == null ? void 0 : s.call(o, ...n);
+      },
+      onUpdate: (...n) => {
+        var o, s;
+        return (s = (o = this.options.current).onUpdate) == null ? void 0 : s.call(o, ...n);
+      },
+      onContentError: (...n) => {
+        var o, s;
+        return (s = (o = this.options.current).onContentError) == null ? void 0 : s.call(o, ...n);
+      },
+      onDrop: (...n) => {
+        var o, s;
+        return (s = (o = this.options.current).onDrop) == null ? void 0 : s.call(o, ...n);
+      },
+      onPaste: (...n) => {
+        var o, s;
+        return (s = (o = this.options.current).onPaste) == null ? void 0 : s.call(o, ...n);
+      },
+      onDelete: (...n) => {
+        var o, s;
+        return (s = (o = this.options.current).onDelete) == null ? void 0 : s.call(o, ...n);
+      }
+    };
+    return new gr(t);
+  }
+  /**
+   * Get the current editor instance.
+   */
+  getEditor() {
+    return this.editor;
+  }
+  /**
+   * Always disable the editor on the server-side.
+   */
+  getServerSnapshot() {
+    return null;
+  }
+  /**
+   * Subscribe to the editor instance's changes.
+   */
+  subscribe(t) {
+    return this.subscriptions.add(t), () => {
+      this.subscriptions.delete(t);
+    };
+  }
+  static compareOptions(t, i) {
+    return Object.keys(t).every((n) => [
+      "onCreate",
+      "onBeforeCreate",
+      "onDestroy",
+      "onUpdate",
+      "onTransaction",
+      "onFocus",
+      "onBlur",
+      "onSelectionUpdate",
+      "onContentError",
+      "onDrop",
+      "onPaste"
+    ].includes(n) ? !0 : n === "extensions" && t.extensions && i.extensions ? t.extensions.length !== i.extensions.length ? !1 : t.extensions.every((o, s) => {
+      var c;
+      return o === ((c = i.extensions) == null ? void 0 : c[s]);
+    }) : t[n] === i[n]);
+  }
+  /**
+   * On each render, we will create, update, or destroy the editor instance.
+   * @param deps The dependencies to watch for changes
+   * @returns A cleanup function
+   */
+  onRender(t) {
+    return () => (this.isComponentMounted = !0, clearTimeout(this.scheduledDestructionTimeout), this.editor && !this.editor.isDestroyed && t.length === 0 ? Ot.compareOptions(this.options.current, this.editor.options) || this.editor.setOptions({
+      ...this.options.current,
+      editable: this.editor.isEditable
+    }) : this.refreshEditorInstance(t), () => {
+      this.isComponentMounted = !1, this.scheduleDestroy();
+    });
+  }
+  /**
+   * Recreate the editor instance if the dependencies have changed.
+   */
+  refreshEditorInstance(t) {
+    if (this.editor && !this.editor.isDestroyed) {
+      if (this.previousDeps === null) {
+        this.previousDeps = t;
+        return;
+      }
+      if (this.previousDeps.length === t.length && this.previousDeps.every((n, o) => n === t[o]))
+        return;
+    }
+    this.editor && !this.editor.isDestroyed && this.editor.destroy(), this.setEditor(this.createEditor()), this.previousDeps = t;
+  }
+  /**
+   * Schedule the destruction of the editor instance.
+   * This will only destroy the editor if it was not mounted on the next tick.
+   * This is to avoid destroying the editor instance when it's actually still mounted.
+   */
+  scheduleDestroy() {
+    const t = this.instanceId, i = this.editor;
+    this.scheduledDestructionTimeout = setTimeout(() => {
+      if (this.isComponentMounted && this.instanceId === t) {
+        i && i.setOptions(this.options.current);
+        return;
+      }
+      i && !i.isDestroyed && (i.destroy(), this.instanceId === t && this.setEditor(null));
+    }, 1);
+  }
+};
+function On(e = {}, t = []) {
+  const i = ar(e);
+  i.current = e;
+  const [n] = Et(() => new wn(i)), o = St.useSyncExternalStore(
+    n.subscribe,
+    n.getEditor,
+    n.getServerSnapshot
+  );
+  return yt(o), _t(n.onRender(t)), wt({
+    editor: o,
+    selector: ({ transactionNumber: s }) => e.shouldRerenderOnTransaction === !1 || e.shouldRerenderOnTransaction === void 0 ? null : e.immediatelyRender && s === 0 ? 0 : s + 1
+  }), o;
+}
+var ae = Re({
+  editor: null
+}), Cn = ae.Consumer, Vn = () => we(ae);
+function kn({
+  children: e,
+  slotAfter: t,
+  slotBefore: i,
+  editorContainerProps: n = {},
+  ...o
+}) {
+  const s = On(o), c = Se(() => ({ editor: s }), [s]);
+  return s ? /* @__PURE__ */ I.jsxs(ae.Provider, { value: c, children: [
+    i,
+    /* @__PURE__ */ I.jsx(Cn, { children: ({ editor: f }) => /* @__PURE__ */ I.jsx(Rt, { editor: f, ...n }) }),
+    e,
+    t
+  ] }) : null;
+}
+var Ce = Re({
+  onDragStart: () => {
+  },
+  nodeViewContentChildren: void 0,
+  nodeViewContentRef: () => {
+  }
+}), Nn = ({ children: e, content: t }) => gt(Ce.Provider, { value: { nodeViewContentChildren: t } }, e), Ct = () => we(Ce);
+function Ln({
+  as: e = "div",
+  ...t
+}) {
+  const { nodeViewContentRef: i, nodeViewContentChildren: n } = Ct();
+  return (
+    // @ts-ignore
+    /* @__PURE__ */ I.jsx(
+      e,
+      {
+        ...t,
+        ref: i,
+        "data-node-view-content": "",
+        style: {
+          whiteSpace: "pre-wrap",
+          ...t.style
+        },
+        children: n
+      }
+    )
+  );
+}
+var qn = V.forwardRef((e, t) => {
+  const { onDragStart: i } = Ct(), n = e.as || "div";
+  return (
+    // @ts-ignore
+    /* @__PURE__ */ I.jsx(
+      n,
+      {
+        ...e,
+        ref: t,
+        "data-node-view-wrapper": "",
+        onDragStart: i,
+        style: {
+          whiteSpace: "normal",
+          ...e.style
+        }
+      }
+    )
+  );
+});
+function vt(e) {
+  return !!(typeof e == "function" && e.prototype && e.prototype.isReactComponent);
+}
+function mt(e) {
+  return !!(typeof e == "object" && e.$$typeof && (e.$$typeof.toString() === "Symbol(react.forward_ref)" || e.$$typeof.description === "react.forward_ref"));
+}
+function Tn(e) {
+  return !!(typeof e == "object" && e.$$typeof && (e.$$typeof.toString() === "Symbol(react.memo)" || e.$$typeof.description === "react.memo"));
+}
+function An(e) {
+  if (vt(e) || mt(e))
+    return !0;
+  if (Tn(e)) {
+    const t = e.type;
+    if (t)
+      return vt(t) || mt(t);
+  }
+  return !1;
+}
+function xn() {
+  try {
+    if (Qe)
+      return parseInt(Qe.split(".")[0], 10) >= 19;
+  } catch {
+  }
+  return !1;
+}
+var Tt = class {
+  /**
+   * Immediately creates element and renders the provided React component.
+   */
+  constructor(e, { editor: t, props: i = {}, as: n = "div", className: o = "" }) {
+    this.ref = null, this.destroyed = !1, this.id = Math.floor(Math.random() * 4294967295).toString(), this.component = e, this.editor = t, this.props = i, this.element = document.createElement(n), this.element.classList.add("react-renderer"), o && this.element.classList.add(...o.split(" ")), this.editor.isEditorContentInitialized ? hr(() => {
+      this.render();
+    }) : queueMicrotask(() => {
+      this.destroyed || this.render();
+    });
+  }
+  /**
+   * Render the React component.
+   */
+  render() {
+    var e;
+    if (this.destroyed)
+      return;
+    const t = this.component, i = this.props, n = this.editor, o = xn(), s = An(t), c = { ...i };
+    c.ref && !(o || s) && delete c.ref, !c.ref && (o || s) && (c.ref = (f) => {
+      this.ref = f;
+    }), this.reactElement = /* @__PURE__ */ I.jsx(t, { ...c }), (e = n == null ? void 0 : n.contentComponent) == null || e.setRenderer(this.id, this);
+  }
+  /**
+   * Re-renders the React component with new props.
+   */
+  updateProps(e = {}) {
+    this.destroyed || (this.props = {
+      ...this.props,
+      ...e
+    }, this.render());
+  }
+  /**
+   * Destroy the React component.
+   */
+  destroy() {
+    var e;
+    this.destroyed = !0;
+    const t = this.editor;
+    (e = t == null ? void 0 : t.contentComponent) == null || e.removeRenderer(this.id);
+    try {
+      this.element && this.element.parentNode && this.element.parentNode.removeChild(this.element);
+    } catch {
+    }
+  }
+  /**
+   * Update the attributes of the element that holds the React component.
+   */
+  updateAttributes(e) {
+    Object.keys(e).forEach((t) => {
+      this.element.setAttribute(t, e[t]);
+    });
+  }
+}, At = V.createContext({
+  markViewContentRef: () => {
+  }
+}), Un = (e) => {
+  const { as: t = "span", ...i } = e, { markViewContentRef: n } = V.useContext(At);
+  return (
+    // @ts-ignore
+    /* @__PURE__ */ I.jsx(t, { ...i, ref: n, "data-mark-view-content": "" })
+  );
+}, jn = class extends pr {
+  constructor(e, t, i) {
+    super(e, t, i);
+    const { as: n = "span", attrs: o, className: s = "" } = i || {}, c = { ...t, updateAttributes: this.updateAttributes.bind(this) };
+    this.contentDOMElement = document.createElement("span");
+    const l = {
+      markViewContentRef: (d) => {
+        d && !d.contains(this.contentDOMElement) && d.appendChild(this.contentDOMElement);
+      }
+    }, _ = V.memo((d) => /* @__PURE__ */ I.jsx(At.Provider, { value: l, children: V.createElement(e, d) }));
+    _.displayName = "ReactMarkView", this.renderer = new Tt(_, {
+      editor: t.editor,
+      props: c,
+      as: n,
+      className: `mark-${t.mark.type.name} ${s}`.trim()
+    }), o && this.renderer.updateAttributes(o);
+  }
+  get dom() {
+    return this.renderer.element;
+  }
+  get contentDOM() {
+    return this.contentDOMElement;
+  }
+};
+function Wn(e, t = {}) {
+  return (i) => new jn(e, i, t);
+}
+var Dn = class extends vr {
+  constructor(e, t, i) {
+    if (super(e, t, i), this.selectionRafId = null, this.positionCheckCallback = null, this.cachedExtensionWithSyncedStorage = null, !this.node.isLeaf) {
+      this.options.contentDOMElementTag ? this.contentDOMElement = document.createElement(this.options.contentDOMElementTag) : this.contentDOMElement = document.createElement(this.node.isInline ? "span" : "div"), this.contentDOMElement.dataset.nodeViewContentReact = "", this.contentDOMElement.dataset.nodeViewWrapper = "", this.contentDOMElement.style.whiteSpace = "inherit";
+      const n = this.dom.querySelector("[data-node-view-content]");
+      if (!n)
+        return;
+      n.appendChild(this.contentDOMElement);
+    }
+  }
+  /**
+   * Returns a proxy of the extension that redirects storage access to the editor's mutable storage.
+   * This preserves the original prototype chain (instanceof checks, methods like configure/extend work).
+   * Cached to avoid proxy creation on every update.
+   */
+  get extensionWithSyncedStorage() {
+    if (!this.cachedExtensionWithSyncedStorage) {
+      const e = this.editor, t = this.extension;
+      this.cachedExtensionWithSyncedStorage = new Proxy(t, {
+        get(i, n, o) {
+          var s;
+          return n === "storage" ? (s = e.storage[t.name]) != null ? s : {} : Reflect.get(i, n, o);
+        }
+      });
+    }
+    return this.cachedExtensionWithSyncedStorage;
+  }
+  /**
+   * Setup the React component.
+   * Called on initialization.
+   */
+  mount() {
+    const e = {
+      editor: this.editor,
+      node: this.node,
+      decorations: this.decorations,
+      innerDecorations: this.innerDecorations,
+      view: this.view,
+      selected: !1,
+      extension: this.extensionWithSyncedStorage,
+      HTMLAttributes: this.HTMLAttributes,
+      getPos: () => this.getPos(),
+      updateAttributes: (l = {}) => this.updateAttributes(l),
+      deleteNode: () => this.deleteNode(),
+      ref: ur()
+    };
+    if (!this.component.displayName) {
+      const l = (_) => _.charAt(0).toUpperCase() + _.substring(1);
+      this.component.displayName = l(this.extension.name);
+    }
+    const n = { onDragStart: this.onDragStart.bind(this), nodeViewContentRef: (l) => {
+      l && this.contentDOMElement && l.firstChild !== this.contentDOMElement && (l.hasAttribute("data-node-view-wrapper") && l.removeAttribute("data-node-view-wrapper"), l.appendChild(this.contentDOMElement));
+    } }, o = this.component, s = cr((l) => /* @__PURE__ */ I.jsx(Ce.Provider, { value: n, children: gt(o, l) }));
+    s.displayName = "ReactNodeView";
+    let c = this.node.isInline ? "span" : "div";
+    this.options.as && (c = this.options.as);
+    const { className: f = "" } = this.options;
+    this.handleSelectionUpdate = this.handleSelectionUpdate.bind(this), this.renderer = new Tt(s, {
+      editor: this.editor,
+      props: e,
+      as: c,
+      className: `node-${this.node.type.name} ${f}`.trim()
+    }), this.editor.on("selectionUpdate", this.handleSelectionUpdate), this.updateElementAttributes(), this.currentPos = this.getPos(), this.positionCheckCallback = () => {
+      const l = this.getPos();
+      typeof l != "number" || l === this.currentPos || (this.currentPos = l, this.renderer.updateProps({ getPos: () => this.getPos() }), typeof this.options.attrs == "function" && this.updateElementAttributes());
+    }, mr(this.editor, this.positionCheckCallback);
+  }
+  /**
+   * Return the DOM element.
+   * This is the element that will be used to display the node view.
+   */
+  get dom() {
+    var e;
+    if (this.renderer.element.firstElementChild && !((e = this.renderer.element.firstElementChild) != null && e.hasAttribute("data-node-view-wrapper")))
+      throw Error("Please use the NodeViewWrapper component for your node view.");
+    return this.renderer.element;
+  }
+  /**
+   * Return the content DOM element.
+   * This is the element that will be used to display the rich-text content of the node.
+   */
+  get contentDOM() {
+    return this.node.isLeaf ? null : this.contentDOMElement;
+  }
+  /**
+   * On editor selection update, check if the node is selected.
+   * If it is, call `selectNode`, otherwise call `deselectNode`.
+   */
+  handleSelectionUpdate() {
+    this.selectionRafId && (cancelAnimationFrame(this.selectionRafId), this.selectionRafId = null), this.selectionRafId = requestAnimationFrame(() => {
+      this.selectionRafId = null;
+      const e = this.currentPos;
+      if (typeof e != "number")
+        return;
+      if (Er({
+        selection: this.editor.state.selection,
+        pos: e,
+        nodeSize: this.node.nodeSize,
+        selectedOnTextSelection: this.options.selectedOnTextSelection
+      })) {
+        if (this.renderer.props.selected)
+          return;
+        this.selectNode();
+      } else {
+        if (!this.renderer.props.selected)
+          return;
+        this.deselectNode();
+      }
+    });
+  }
+  /**
+   * On update, update the React component.
+   * To prevent unnecessary updates, the `update` option can be used.
+   */
+  update(e, t, i) {
+    const n = (s) => {
+      this.renderer.updateProps(s), typeof this.options.attrs == "function" && this.updateElementAttributes();
+    };
+    if (e.type !== this.node.type)
+      return !1;
+    if (typeof this.options.update == "function") {
+      const s = this.node, c = this.decorations, f = this.innerDecorations;
+      return this.node = e, this.decorations = t, this.innerDecorations = i, this.currentPos = this.getPos(), this.options.update({
+        oldNode: s,
+        oldDecorations: c,
+        newNode: e,
+        newDecorations: t,
+        oldInnerDecorations: f,
+        innerDecorations: i,
+        updateProps: () => n({ node: e, decorations: t, innerDecorations: i, extension: this.extensionWithSyncedStorage })
+      });
+    }
+    const o = this.getPos();
+    return e === this.node && this.decorations === t && this.innerDecorations === i ? (o === this.currentPos || (this.currentPos = o, n({
+      node: e,
+      decorations: t,
+      innerDecorations: i,
+      extension: this.extensionWithSyncedStorage,
+      getPos: () => this.getPos()
+    })), !0) : (this.node = e, this.decorations = t, this.innerDecorations = i, this.currentPos = o, n({ node: e, decorations: t, innerDecorations: i, extension: this.extensionWithSyncedStorage }), !0);
+  }
+  /**
+   * Select the node.
+   * Add the `selected` prop and the `ProseMirror-selectednode` class.
+   */
+  selectNode() {
+    this.renderer.updateProps({
+      selected: !0
+    }), this.renderer.element.classList.add("ProseMirror-selectednode");
+  }
+  /**
+   * Deselect the node.
+   * Remove the `selected` prop and the `ProseMirror-selectednode` class.
+   */
+  deselectNode() {
+    this.renderer.updateProps({
+      selected: !1
+    }), this.renderer.element.classList.remove("ProseMirror-selectednode");
+  }
+  /**
+   * Destroy the React component instance.
+   */
+  destroy() {
+    this.renderer.destroy(), this.editor.off("selectionUpdate", this.handleSelectionUpdate), this.positionCheckCallback && (yr(this.editor, this.positionCheckCallback), this.positionCheckCallback = null), this.contentDOMElement = null, this.selectionRafId && (cancelAnimationFrame(this.selectionRafId), this.selectionRafId = null);
+  }
+  /**
+   * Update the attributes of the top-level element that holds the React component.
+   * Applying the attributes defined in the `attrs` option.
+   */
+  updateElementAttributes() {
+    if (this.options.attrs) {
+      let e = {};
+      if (typeof this.options.attrs == "function") {
+        const t = this.editor.extensionManager.attributes, i = _r(this.node, t);
+        e = this.options.attrs({ node: this.node, HTMLAttributes: i });
+      } else
+        e = this.options.attrs;
+      this.renderer.updateAttributes(e);
+    }
+  }
+};
+function Fn(e, t) {
+  return (i) => i.editor.contentComponent ? new Dn(e, i, t) : {};
+}
+var Te = Re({
+  get editor() {
+    throw new Error("useTiptap must be used within a <Tiptap> provider");
+  }
+});
+Te.displayName = "TiptapContext";
+var xt = () => we(Te);
+function $n(e, t) {
+  const { editor: i } = xt();
+  return wt({
+    editor: i,
+    selector: e,
+    equalityFn: t
+  });
+}
+function jt({ editor: e, instance: t, children: i }) {
+  const n = e ?? t;
+  if (!n)
+    throw new Error("Tiptap: An editor instance is required. Pass a non-null `editor` prop.");
+  const o = Se(() => ({ editor: n }), [n]), s = Se(() => ({ editor: n }), [n]);
+  return /* @__PURE__ */ I.jsx(ae.Provider, { value: s, children: /* @__PURE__ */ I.jsx(Te.Provider, { value: o, children: i }) });
+}
+jt.displayName = "Tiptap";
+function Dt({ ...e }) {
+  const { editor: t } = xt();
+  return /* @__PURE__ */ I.jsx(Rt, { editor: t, ...e });
+}
+Dt.displayName = "Tiptap.Content";
+var Bn = Object.assign(jt, {
+  /**
+   * The Tiptap Content component that renders the EditorContent with the editor instance from the context.
+   * @see TiptapContent
+   */
+  Content: Dt
+});
+export {
+  Cn as E,
+  Un as M,
+  Ln as N,
+  _n as P,
+  jn as R,
+  Bn as T,
+  Rt as a,
+  ae as b,
+  kn as c,
+  qn as d,
+  At as e,
+  Wn as f,
+  Dn as g,
+  Nn as h,
+  Ce as i,
+  Fn as j,
+  Tt as k,
+  Dt as l,
+  Te as m,
+  jt as n,
+  On as o,
+  wt as p,
+  Ct as q,
+  xt as r,
+  $n as s,
+  I as t,
+  Vn as u
+};