@zoom/videosdk-ui-toolkit
Version:
The Zoom Video SDK UI toolkit is a prebuilt video chat user interface powered by the Zoom Video SDK.
1,291 lines (1,285 loc) • 8.59 MB
JavaScript
function jYe(e, t) {
for (var r = 0; r < t.length; r++) {
const n = t[r];
if (typeof n != "string" && !Array.isArray(n)) {
for (const i in n)
if (i !== "default" && !(i in e)) {
const a = Object.getOwnPropertyDescriptor(n, i);
a && Object.defineProperty(e, i, a.get ? a : {
enumerable: !0,
get: () => n[i]
});
}
}
}
return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
}
var KE = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
function $b(e) {
return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
}
var QY = { exports: {} }, $Y = { exports: {} }, zF = { exports: {} };
zF.exports;
var Ege;
function VYe() {
return Ege || (Ege = 1, (function(e, t) {
(function() {
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
var r = "18.3.1", n = /* @__PURE__ */ Symbol.for("react.element"), i = /* @__PURE__ */ Symbol.for("react.portal"), a = /* @__PURE__ */ Symbol.for("react.fragment"), s = /* @__PURE__ */ Symbol.for("react.strict_mode"), l = /* @__PURE__ */ Symbol.for("react.profiler"), u = /* @__PURE__ */ Symbol.for("react.provider"), d = /* @__PURE__ */ Symbol.for("react.context"), h = /* @__PURE__ */ Symbol.for("react.forward_ref"), m = /* @__PURE__ */ Symbol.for("react.suspense"), w = /* @__PURE__ */ Symbol.for("react.suspense_list"), b = /* @__PURE__ */ Symbol.for("react.memo"), R = /* @__PURE__ */ Symbol.for("react.lazy"), x = /* @__PURE__ */ Symbol.for("react.offscreen"), M = Symbol.iterator, N = "@@iterator";
function V(Lt) {
if (Lt === null || typeof Lt != "object")
return null;
var _r = M && Lt[M] || Lt[N];
return typeof _r == "function" ? _r : null;
}
var Q = {
/**
* @internal
* @type {ReactComponent}
*/
current: null
}, X = {
transition: null
}, te = {
current: null,
// Used to reproduce behavior of `batchedUpdates` in legacy mode.
isBatchingLegacy: !1,
didScheduleLegacyUpdate: !1
}, ie = {
/**
* @internal
* @type {ReactComponent}
*/
current: null
}, le = {}, pe = null;
function ge(Lt) {
pe = Lt;
}
le.setExtraStackFrame = function(Lt) {
pe = Lt;
}, le.getCurrentStack = null, le.getStackAddendum = function() {
var Lt = "";
pe && (Lt += pe);
var _r = le.getCurrentStack;
return _r && (Lt += _r() || ""), Lt;
};
var ye = !1, _e = !1, be = !1, He = !1, ke = !1, Ze = {
ReactCurrentDispatcher: Q,
ReactCurrentBatchConfig: X,
ReactCurrentOwner: ie
};
Ze.ReactDebugCurrentFrame = le, Ze.ReactCurrentActQueue = te;
function ht(Lt) {
{
for (var _r = arguments.length, zn = new Array(_r > 1 ? _r - 1 : 0), Si = 1; Si < _r; Si++)
zn[Si - 1] = arguments[Si];
Je("warn", Lt, zn);
}
}
function yt(Lt) {
{
for (var _r = arguments.length, zn = new Array(_r > 1 ? _r - 1 : 0), Si = 1; Si < _r; Si++)
zn[Si - 1] = arguments[Si];
Je("error", Lt, zn);
}
}
function Je(Lt, _r, zn) {
{
var Si = Ze.ReactDebugCurrentFrame, Qa = Si.getStackAddendum();
Qa !== "" && (_r += "%s", zn = zn.concat([Qa]));
var Ks = zn.map(function(qs) {
return String(qs);
});
Ks.unshift("Warning: " + _r), Function.prototype.apply.call(console[Lt], console, Ks);
}
}
var Tt = {};
function xt(Lt, _r) {
{
var zn = Lt.constructor, Si = zn && (zn.displayName || zn.name) || "ReactClass", Qa = Si + "." + _r;
if (Tt[Qa])
return;
yt("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", _r, Si), Tt[Qa] = !0;
}
}
var ft = {
/**
* Checks whether or not this composite component is mounted.
* @param {ReactClass} publicInstance The instance we want to test.
* @return {boolean} True if mounted, false otherwise.
* @protected
* @final
*/
isMounted: function(Lt) {
return !1;
},
/**
* Forces an update. This should only be invoked when it is known with
* certainty that we are **not** in a DOM transaction.
*
* You may want to call this when you know that some deeper aspect of the
* component's state has changed but `setState` was not called.
*
* This will not invoke `shouldComponentUpdate`, but it will invoke
* `componentWillUpdate` and `componentDidUpdate`.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {?function} callback Called after component is updated.
* @param {?string} callerName name of the calling function in the public API.
* @internal
*/
enqueueForceUpdate: function(Lt, _r, zn) {
xt(Lt, "forceUpdate");
},
/**
* Replaces all of the state. Always use this or `setState` to mutate state.
* You should treat `this.state` as immutable.
*
* There is no guarantee that `this.state` will be immediately updated, so
* accessing `this.state` after calling this method may return the old value.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} completeState Next state.
* @param {?function} callback Called after component is updated.
* @param {?string} callerName name of the calling function in the public API.
* @internal
*/
enqueueReplaceState: function(Lt, _r, zn, Si) {
xt(Lt, "replaceState");
},
/**
* Sets a subset of the state. This only exists because _pendingState is
* internal. This provides a merging strategy that is not available to deep
* properties which is confusing. TODO: Expose pendingState or don't use it
* during the merge.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} partialState Next partial state to be merged with state.
* @param {?function} callback Called after component is updated.
* @param {?string} Name of the calling function in the public API.
* @internal
*/
enqueueSetState: function(Lt, _r, zn, Si) {
xt(Lt, "setState");
}
}, Ue = Object.assign, st = {};
Object.freeze(st);
function Ct(Lt, _r, zn) {
this.props = Lt, this.context = _r, this.refs = st, this.updater = zn || ft;
}
Ct.prototype.isReactComponent = {}, Ct.prototype.setState = function(Lt, _r) {
if (typeof Lt != "object" && typeof Lt != "function" && Lt != null)
throw new Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
this.updater.enqueueSetState(this, Lt, _r, "setState");
}, Ct.prototype.forceUpdate = function(Lt) {
this.updater.enqueueForceUpdate(this, Lt, "forceUpdate");
};
{
var bt = {
isMounted: ["isMounted", "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."],
replaceState: ["replaceState", "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."]
}, Nt = function(Lt, _r) {
Object.defineProperty(Ct.prototype, Lt, {
get: function() {
ht("%s(...) is deprecated in plain JavaScript React classes. %s", _r[0], _r[1]);
}
});
};
for (var Kt in bt)
bt.hasOwnProperty(Kt) && Nt(Kt, bt[Kt]);
}
function Er() {
}
Er.prototype = Ct.prototype;
function Xt(Lt, _r, zn) {
this.props = Lt, this.context = _r, this.refs = st, this.updater = zn || ft;
}
var Zt = Xt.prototype = new Er();
Zt.constructor = Xt, Ue(Zt, Ct.prototype), Zt.isPureReactComponent = !0;
function Tr() {
var Lt = {
current: null
};
return Object.seal(Lt), Lt;
}
var ar = Array.isArray;
function zr(Lt) {
return ar(Lt);
}
function sn(Lt) {
{
var _r = typeof Symbol == "function" && Symbol.toStringTag, zn = _r && Lt[Symbol.toStringTag] || Lt.constructor.name || "Object";
return zn;
}
}
function qe(Lt) {
try {
return nn(Lt), !1;
} catch {
return !0;
}
}
function nn(Lt) {
return "" + Lt;
}
function bn(Lt) {
if (qe(Lt))
return yt("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", sn(Lt)), nn(Lt);
}
function an(Lt, _r, zn) {
var Si = Lt.displayName;
if (Si)
return Si;
var Qa = _r.displayName || _r.name || "";
return Qa !== "" ? zn + "(" + Qa + ")" : zn;
}
function Nn(Lt) {
return Lt.displayName || "Context";
}
function Hi(Lt) {
if (Lt == null)
return null;
if (typeof Lt.tag == "number" && yt("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof Lt == "function")
return Lt.displayName || Lt.name || null;
if (typeof Lt == "string")
return Lt;
switch (Lt) {
case a:
return "Fragment";
case i:
return "Portal";
case l:
return "Profiler";
case s:
return "StrictMode";
case m:
return "Suspense";
case w:
return "SuspenseList";
}
if (typeof Lt == "object")
switch (Lt.$$typeof) {
case d:
var _r = Lt;
return Nn(_r) + ".Consumer";
case u:
var zn = Lt;
return Nn(zn._context) + ".Provider";
case h:
return an(Lt, Lt.render, "ForwardRef");
case b:
var Si = Lt.displayName || null;
return Si !== null ? Si : Hi(Lt.type) || "Memo";
case R: {
var Qa = Lt, Ks = Qa._payload, qs = Qa._init;
try {
return Hi(qs(Ks));
} catch {
return null;
}
}
}
return null;
}
var ri = Object.prototype.hasOwnProperty, ki = {
key: !0,
ref: !0,
__self: !0,
__source: !0
}, ji, Qn, cn;
cn = {};
function Dn(Lt) {
if (ri.call(Lt, "ref")) {
var _r = Object.getOwnPropertyDescriptor(Lt, "ref").get;
if (_r && _r.isReactWarning)
return !1;
}
return Lt.ref !== void 0;
}
function Pr(Lt) {
if (ri.call(Lt, "key")) {
var _r = Object.getOwnPropertyDescriptor(Lt, "key").get;
if (_r && _r.isReactWarning)
return !1;
}
return Lt.key !== void 0;
}
function Ln(Lt, _r) {
var zn = function() {
ji || (ji = !0, yt("%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)", _r));
};
zn.isReactWarning = !0, Object.defineProperty(Lt, "key", {
get: zn,
configurable: !0
});
}
function wi(Lt, _r) {
var zn = function() {
Qn || (Qn = !0, yt("%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)", _r));
};
zn.isReactWarning = !0, Object.defineProperty(Lt, "ref", {
get: zn,
configurable: !0
});
}
function Cn(Lt) {
if (typeof Lt.ref == "string" && ie.current && Lt.__self && ie.current.stateNode !== Lt.__self) {
var _r = Hi(ie.current.type);
cn[_r] || (yt('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', _r, Lt.ref), cn[_r] = !0);
}
}
var Pn = function(Lt, _r, zn, Si, Qa, Ks, qs) {
var jo = {
// This tag allows us to uniquely identify this as a React Element
$$typeof: n,
// Built-in properties that belong on the element
type: Lt,
key: _r,
ref: zn,
props: qs,
// Record the component responsible for creating this element.
_owner: Ks
};
return jo._store = {}, Object.defineProperty(jo._store, "validated", {
configurable: !1,
enumerable: !1,
writable: !0,
value: !1
}), Object.defineProperty(jo, "_self", {
configurable: !1,
enumerable: !1,
writable: !1,
value: Si
}), Object.defineProperty(jo, "_source", {
configurable: !1,
enumerable: !1,
writable: !1,
value: Qa
}), Object.freeze && (Object.freeze(jo.props), Object.freeze(jo)), jo;
};
function ln(Lt, _r, zn) {
var Si, Qa = {}, Ks = null, qs = null, jo = null, mi = null;
if (_r != null) {
Dn(_r) && (qs = _r.ref, Cn(_r)), Pr(_r) && (bn(_r.key), Ks = "" + _r.key), jo = _r.__self === void 0 ? null : _r.__self, mi = _r.__source === void 0 ? null : _r.__source;
for (Si in _r)
ri.call(_r, Si) && !ki.hasOwnProperty(Si) && (Qa[Si] = _r[Si]);
}
var Nu = arguments.length - 2;
if (Nu === 1)
Qa.children = zn;
else if (Nu > 1) {
for (var Fi = Array(Nu), z = 0; z < Nu; z++)
Fi[z] = arguments[z + 2];
Object.freeze && Object.freeze(Fi), Qa.children = Fi;
}
if (Lt && Lt.defaultProps) {
var Rt = Lt.defaultProps;
for (Si in Rt)
Qa[Si] === void 0 && (Qa[Si] = Rt[Si]);
}
if (Ks || qs) {
var yr = typeof Lt == "function" ? Lt.displayName || Lt.name || "Unknown" : Lt;
Ks && Ln(Qa, yr), qs && wi(Qa, yr);
}
return Pn(Lt, Ks, qs, jo, mi, ie.current, Qa);
}
function di(Lt, _r) {
var zn = Pn(Lt.type, _r, Lt.ref, Lt._self, Lt._source, Lt._owner, Lt.props);
return zn;
}
function Ta(Lt, _r, zn) {
if (Lt == null)
throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + Lt + ".");
var Si, Qa = Ue({}, Lt.props), Ks = Lt.key, qs = Lt.ref, jo = Lt._self, mi = Lt._source, Nu = Lt._owner;
if (_r != null) {
Dn(_r) && (qs = _r.ref, Nu = ie.current), Pr(_r) && (bn(_r.key), Ks = "" + _r.key);
var Fi;
Lt.type && Lt.type.defaultProps && (Fi = Lt.type.defaultProps);
for (Si in _r)
ri.call(_r, Si) && !ki.hasOwnProperty(Si) && (_r[Si] === void 0 && Fi !== void 0 ? Qa[Si] = Fi[Si] : Qa[Si] = _r[Si]);
}
var z = arguments.length - 2;
if (z === 1)
Qa.children = zn;
else if (z > 1) {
for (var Rt = Array(z), yr = 0; yr < z; yr++)
Rt[yr] = arguments[yr + 2];
Qa.children = Rt;
}
return Pn(Lt.type, Ks, qs, jo, mi, Nu, Qa);
}
function ra(Lt) {
return typeof Lt == "object" && Lt !== null && Lt.$$typeof === n;
}
var ua = ".", Ja = ":";
function gs(Lt) {
var _r = /[=:]/g, zn = {
"=": "=0",
":": "=2"
}, Si = Lt.replace(_r, function(Qa) {
return zn[Qa];
});
return "$" + Si;
}
var La = !1, Wa = /\/+/g;
function vo(Lt) {
return Lt.replace(Wa, "$&/");
}
function Es(Lt, _r) {
return typeof Lt == "object" && Lt !== null && Lt.key != null ? (bn(Lt.key), gs("" + Lt.key)) : _r.toString(36);
}
function ms(Lt, _r, zn, Si, Qa) {
var Ks = typeof Lt;
(Ks === "undefined" || Ks === "boolean") && (Lt = null);
var qs = !1;
if (Lt === null)
qs = !0;
else
switch (Ks) {
case "string":
case "number":
qs = !0;
break;
case "object":
switch (Lt.$$typeof) {
case n:
case i:
qs = !0;
}
}
if (qs) {
var jo = Lt, mi = Qa(jo), Nu = Si === "" ? ua + Es(jo, 0) : Si;
if (zr(mi)) {
var Fi = "";
Nu != null && (Fi = vo(Nu) + "/"), ms(mi, _r, Fi, "", function(Ft) {
return Ft;
});
} else mi != null && (ra(mi) && (mi.key && (!jo || jo.key !== mi.key) && bn(mi.key), mi = di(
mi,
// Keep both the (mapped) and old keys if they differ, just as
// traverseAllChildren used to do for objects as children
zn + // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
(mi.key && (!jo || jo.key !== mi.key) ? (
// $FlowFixMe Flow incorrectly thinks existing element's key can be a number
// eslint-disable-next-line react-internal/safe-string-coercion
vo("" + mi.key) + "/"
) : "") + Nu
)), _r.push(mi));
return 1;
}
var z, Rt, yr = 0, Lr = Si === "" ? ua : Si + Ja;
if (zr(Lt))
for (var fn = 0; fn < Lt.length; fn++)
z = Lt[fn], Rt = Lr + Es(z, fn), yr += ms(z, _r, zn, Rt, Qa);
else {
var Ni = V(Lt);
if (typeof Ni == "function") {
var Ye = Lt;
Ni === Ye.entries && (La || ht("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), La = !0);
for (var tt = Ni.call(Ye), je, lt = 0; !(je = tt.next()).done; )
z = je.value, Rt = Lr + Es(z, lt++), yr += ms(z, _r, zn, Rt, Qa);
} else if (Ks === "object") {
var St = String(Lt);
throw new Error("Objects are not valid as a React child (found: " + (St === "[object Object]" ? "object with keys {" + Object.keys(Lt).join(", ") + "}" : St) + "). If you meant to render a collection of children, use an array instead.");
}
}
return yr;
}
function rl(Lt, _r, zn) {
if (Lt == null)
return Lt;
var Si = [], Qa = 0;
return ms(Lt, Si, "", "", function(Ks) {
return _r.call(zn, Ks, Qa++);
}), Si;
}
function $u(Lt) {
var _r = 0;
return rl(Lt, function() {
_r++;
}), _r;
}
function Hs(Lt, _r, zn) {
rl(Lt, function() {
_r.apply(this, arguments);
}, zn);
}
function qa(Lt) {
return rl(Lt, function(_r) {
return _r;
}) || [];
}
function js(Lt) {
if (!ra(Lt))
throw new Error("React.Children.only expected to receive a single React element child.");
return Lt;
}
function ha(Lt) {
var _r = {
$$typeof: d,
// As a workaround to support multiple concurrent renderers, we categorize
// some renderers as primary and others as secondary. We only expect
// there to be two concurrent renderers at most: React Native (primary) and
// Fabric (secondary); React DOM (primary) and React ART (secondary).
// Secondary renderers store their context values on separate fields.
_currentValue: Lt,
_currentValue2: Lt,
// Used to track how many concurrent renderers this context currently
// supports within in a single renderer. Such as parallel server rendering.
_threadCount: 0,
// These are circular
Provider: null,
Consumer: null,
// Add these to use same hidden class in VM as ServerContext
_defaultValue: null,
_globalName: null
};
_r.Provider = {
$$typeof: u,
_context: _r
};
var zn = !1, Si = !1, Qa = !1;
{
var Ks = {
$$typeof: d,
_context: _r
};
Object.defineProperties(Ks, {
Provider: {
get: function() {
return Si || (Si = !0, yt("Rendering <Context.Consumer.Provider> is not supported and will be removed in a future major release. Did you mean to render <Context.Provider> instead?")), _r.Provider;
},
set: function(qs) {
_r.Provider = qs;
}
},
_currentValue: {
get: function() {
return _r._currentValue;
},
set: function(qs) {
_r._currentValue = qs;
}
},
_currentValue2: {
get: function() {
return _r._currentValue2;
},
set: function(qs) {
_r._currentValue2 = qs;
}
},
_threadCount: {
get: function() {
return _r._threadCount;
},
set: function(qs) {
_r._threadCount = qs;
}
},
Consumer: {
get: function() {
return zn || (zn = !0, yt("Rendering <Context.Consumer.Consumer> is not supported and will be removed in a future major release. Did you mean to render <Context.Consumer> instead?")), _r.Consumer;
}
},
displayName: {
get: function() {
return _r.displayName;
},
set: function(qs) {
Qa || (ht("Setting `displayName` on Context.Consumer has no effect. You should set it directly on the context with Context.displayName = '%s'.", qs), Qa = !0);
}
}
}), _r.Consumer = Ks;
}
return _r._currentRenderer = null, _r._currentRenderer2 = null, _r;
}
var kl = -1, zs = 0, _i = 1, Aa = 2;
function Di(Lt) {
if (Lt._status === kl) {
var _r = Lt._result, zn = _r();
if (zn.then(function(Ks) {
if (Lt._status === zs || Lt._status === kl) {
var qs = Lt;
qs._status = _i, qs._result = Ks;
}
}, function(Ks) {
if (Lt._status === zs || Lt._status === kl) {
var qs = Lt;
qs._status = Aa, qs._result = Ks;
}
}), Lt._status === kl) {
var Si = Lt;
Si._status = zs, Si._result = zn;
}
}
if (Lt._status === _i) {
var Qa = Lt._result;
return Qa === void 0 && yt(`lazy: Expected the result of a dynamic import() call. Instead received: %s
Your code should look like:
const MyComponent = lazy(() => import('./MyComponent'))
Did you accidentally put curly braces around the import?`, Qa), "default" in Qa || yt(`lazy: Expected the result of a dynamic import() call. Instead received: %s
Your code should look like:
const MyComponent = lazy(() => import('./MyComponent'))`, Qa), Qa.default;
} else
throw Lt._result;
}
function Ps(Lt) {
var _r = {
// We use these fields to store the result.
_status: kl,
_result: Lt
}, zn = {
$$typeof: R,
_payload: _r,
_init: Di
};
{
var Si, Qa;
Object.defineProperties(zn, {
defaultProps: {
configurable: !0,
get: function() {
return Si;
},
set: function(Ks) {
yt("React.lazy(...): It is not supported to assign `defaultProps` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."), Si = Ks, Object.defineProperty(zn, "defaultProps", {
enumerable: !0
});
}
},
propTypes: {
configurable: !0,
get: function() {
return Qa;
},
set: function(Ks) {
yt("React.lazy(...): It is not supported to assign `propTypes` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."), Qa = Ks, Object.defineProperty(zn, "propTypes", {
enumerable: !0
});
}
}
});
}
return zn;
}
function xo(Lt) {
Lt != null && Lt.$$typeof === b ? yt("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : typeof Lt != "function" ? yt("forwardRef requires a render function but was given %s.", Lt === null ? "null" : typeof Lt) : Lt.length !== 0 && Lt.length !== 2 && yt("forwardRef render functions accept exactly two parameters: props and ref. %s", Lt.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."), Lt != null && (Lt.defaultProps != null || Lt.propTypes != null) && yt("forwardRef render functions do not support propTypes or defaultProps. Did you accidentally pass a React component?");
var _r = {
$$typeof: h,
render: Lt
};
{
var zn;
Object.defineProperty(_r, "displayName", {
enumerable: !1,
configurable: !0,
get: function() {
return zn;
},
set: function(Si) {
zn = Si, !Lt.name && !Lt.displayName && (Lt.displayName = Si);
}
});
}
return _r;
}
var Br;
Br = /* @__PURE__ */ Symbol.for("react.module.reference");
function Li(Lt) {
return !!(typeof Lt == "string" || typeof Lt == "function" || Lt === a || Lt === l || ke || Lt === s || Lt === m || Lt === w || He || Lt === x || ye || _e || be || typeof Lt == "object" && Lt !== null && (Lt.$$typeof === R || Lt.$$typeof === b || Lt.$$typeof === u || Lt.$$typeof === d || Lt.$$typeof === h || // 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.
Lt.$$typeof === Br || Lt.getModuleId !== void 0));
}
function ya(Lt, _r) {
Li(Lt) || yt("memo: The first argument must be a component. Instead received: %s", Lt === null ? "null" : typeof Lt);
var zn = {
$$typeof: b,
type: Lt,
compare: _r === void 0 ? null : _r
};
{
var Si;
Object.defineProperty(zn, "displayName", {
enumerable: !1,
configurable: !0,
get: function() {
return Si;
},
set: function(Qa) {
Si = Qa, !Lt.name && !Lt.displayName && (Lt.displayName = Qa);
}
});
}
return zn;
}
function Ua() {
var Lt = Q.current;
return Lt === null && yt(`Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
1. You might have mismatching versions of React and the renderer (such as React DOM)
2. You might be breaking the Rules of Hooks
3. You might have more than one copy of React in the same app
See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.`), Lt;
}
function Os(Lt) {
var _r = Ua();
if (Lt._context !== void 0) {
var zn = Lt._context;
zn.Consumer === Lt ? yt("Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be removed in a future major release. Did you mean to call useContext(Context) instead?") : zn.Provider === Lt && yt("Calling useContext(Context.Provider) is not supported. Did you mean to call useContext(Context) instead?");
}
return _r.useContext(Lt);
}
function xs(Lt) {
var _r = Ua();
return _r.useState(Lt);
}
function wo(Lt, _r, zn) {
var Si = Ua();
return Si.useReducer(Lt, _r, zn);
}
function Uo(Lt) {
var _r = Ua();
return _r.useRef(Lt);
}
function cu(Lt, _r) {
var zn = Ua();
return zn.useEffect(Lt, _r);
}
function wa(Lt, _r) {
var zn = Ua();
return zn.useInsertionEffect(Lt, _r);
}
function Wr(Lt, _r) {
var zn = Ua();
return zn.useLayoutEffect(Lt, _r);
}
function Wi(Lt, _r) {
var zn = Ua();
return zn.useCallback(Lt, _r);
}
function vs(Lt, _r) {
var zn = Ua();
return zn.useMemo(Lt, _r);
}
function ia(Lt, _r, zn) {
var Si = Ua();
return Si.useImperativeHandle(Lt, _r, zn);
}
function lo(Lt, _r) {
{
var zn = Ua();
return zn.useDebugValue(Lt, _r);
}
}
function Rs() {
var Lt = Ua();
return Lt.useTransition();
}
function Hl(Lt) {
var _r = Ua();
return _r.useDeferredValue(Lt);
}
function ns() {
var Lt = Ua();
return Lt.useId();
}
function Dl(Lt, _r, zn) {
var Si = Ua();
return Si.useSyncExternalStore(Lt, _r, zn);
}
var yu = 0, Yo, nl, Qs, ko, xl, ju, Uh;
function Fo() {
}
Fo.__reactDisabledLog = !0;
function ic() {
{
if (yu === 0) {
Yo = console.log, nl = console.info, Qs = console.warn, ko = console.error, xl = console.group, ju = console.groupCollapsed, Uh = console.groupEnd;
var Lt = {
configurable: !0,
enumerable: !0,
value: Fo,
writable: !0
};
Object.defineProperties(console, {
info: Lt,
log: Lt,
warn: Lt,
error: Lt,
group: Lt,
groupCollapsed: Lt,
groupEnd: Lt
});
}
yu++;
}
}
function Kl() {
{
if (yu--, yu === 0) {
var Lt = {
configurable: !0,
enumerable: !0,
writable: !0
};
Object.defineProperties(console, {
log: Ue({}, Lt, {
value: Yo
}),
info: Ue({}, Lt, {
value: nl
}),
warn: Ue({}, Lt, {
value: Qs
}),
error: Ue({}, Lt, {
value: ko
}),
group: Ue({}, Lt, {
value: xl
}),
groupCollapsed: Ue({}, Lt, {
value: ju
}),
groupEnd: Ue({}, Lt, {
value: Uh
})
});
}
yu < 0 && yt("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
}
}
var Sd = Ze.ReactCurrentDispatcher, Rl;
function Uc(Lt, _r, zn) {
{
if (Rl === void 0)
try {
throw Error();
} catch (Qa) {
var Si = Qa.stack.trim().match(/\n( *(at )?)/);
Rl = Si && Si[1] || "";
}
return `
` + Rl + Lt;
}
}
var Af = !1, gf;
{
var ac = typeof WeakMap == "function" ? WeakMap : Map;
gf = new ac();
}
function ql(Lt, _r) {
if (!Lt || Af)
return "";
{
var zn = gf.get(Lt);
if (zn !== void 0)
return zn;
}
var Si;
Af = !0;
var Qa = Error.prepareStackTrace;
Error.prepareStackTrace = void 0;
var Ks;
Ks = Sd.current, Sd.current = null, ic();
try {
if (_r) {
var qs = function() {
throw Error();
};
if (Object.defineProperty(qs.prototype, "props", {
set: function() {
throw Error();
}
}), typeof Reflect == "object" && Reflect.construct) {
try {
Reflect.construct(qs, []);
} catch (Lr) {
Si = Lr;
}
Reflect.construct(Lt, [], qs);
} else {
try {
qs.call();
} catch (Lr) {
Si = Lr;
}
Lt.call(qs.prototype);
}
} else {
try {
throw Error();
} catch (Lr) {
Si = Lr;
}
Lt();
}
} catch (Lr) {
if (Lr && Si && typeof Lr.stack == "string") {
for (var jo = Lr.stack.split(`
`), mi = Si.stack.split(`
`), Nu = jo.length - 1, Fi = mi.length - 1; Nu >= 1 && Fi >= 0 && jo[Nu] !== mi[Fi]; )
Fi--;
for (; Nu >= 1 && Fi >= 0; Nu--, Fi--)
if (jo[Nu] !== mi[Fi]) {
if (Nu !== 1 || Fi !== 1)
do
if (Nu--, Fi--, Fi < 0 || jo[Nu] !== mi[Fi]) {
var z = `
` + jo[Nu].replace(" at new ", " at ");
return Lt.displayName && z.includes("<anonymous>") && (z = z.replace("<anonymous>", Lt.displayName)), typeof Lt == "function" && gf.set(Lt, z), z;
}
while (Nu >= 1 && Fi >= 0);
break;
}
}
} finally {
Af = !1, Sd.current = Ks, Kl(), Error.prepareStackTrace = Qa;
}
var Rt = Lt ? Lt.displayName || Lt.name : "", yr = Rt ? Uc(Rt) : "";
return typeof Lt == "function" && gf.set(Lt, yr), yr;
}
function il(Lt, _r, zn) {
return ql(Lt, !1);
}
function nu(Lt) {
var _r = Lt.prototype;
return !!(_r && _r.isReactComponent);
}
function jd(Lt, _r, zn) {
if (Lt == null)
return "";
if (typeof Lt == "function")
return ql(Lt, nu(Lt));
if (typeof Lt == "string")
return Uc(Lt);
switch (Lt) {
case m:
return Uc("Suspense");
case w:
return Uc("SuspenseList");
}
if (typeof Lt == "object")
switch (Lt.$$typeof) {
case h:
return il(Lt.render);
case b:
return jd(Lt.type, _r, zn);
case R: {
var Si = Lt, Qa = Si._payload, Ks = Si._init;
try {
return jd(Ks(Qa), _r, zn);
} catch {
}
}
}
return "";
}
var ze = {}, he = Ze.ReactDebugCurrentFrame;
function Te(Lt) {
if (Lt) {
var _r = Lt._owner, zn = jd(Lt.type, Lt._source, _r ? _r.type : null);
he.setExtraStackFrame(zn);
} else
he.setExtraStackFrame(null);
}
function et(Lt, _r, zn, Si, Qa) {
{
var Ks = Function.call.bind(ri);
for (var qs in Lt)
if (Ks(Lt, qs)) {
var jo = void 0;
try {
if (typeof Lt[qs] != "function") {
var mi = Error((Si || "React class") + ": " + zn + " type `" + qs + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof Lt[qs] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
throw mi.name = "Invariant Violation", mi;
}
jo = Lt[qs](_r, qs, Si, zn, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
} catch (Nu) {
jo = Nu;
}
jo && !(jo instanceof Error) && (Te(Qa), yt("%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).", Si || "React class", zn, qs, typeof jo), Te(null)), jo instanceof Error && !(jo.message in ze) && (ze[jo.message] = !0, Te(Qa), yt("Failed %s type: %s", zn, jo.message), Te(null));
}
}
}
function It(Lt) {
if (Lt) {
var _r = Lt._owner, zn = jd(Lt.type, Lt._source, _r ? _r.type : null);
ge(zn);
} else
ge(null);
}
var Mt;
Mt = !1;
function Vt() {
if (ie.current) {
var Lt = Hi(ie.current.type);
if (Lt)
return `
Check the render method of \`` + Lt + "`.";
}
return "";
}
function er(Lt) {
if (Lt !== void 0) {
var _r = Lt.fileName.replace(/^.*[\\\/]/, ""), zn = Lt.lineNumber;
return `
Check your code at ` + _r + ":" + zn + ".";
}
return "";
}
function Sr(Lt) {
return Lt != null ? er(Lt.__source) : "";
}
var fr = {};
function Dr(Lt) {
var _r = Vt();
if (!_r) {
var zn = typeof Lt == "string" ? Lt : Lt.displayName || Lt.name;
zn && (_r = `
Check the top-level render call using <` + zn + ">.");
}
return _r;
}
function Sn(Lt, _r) {
if (!(!Lt._store || Lt._store.validated || Lt.key != null)) {
Lt._store.validated = !0;
var zn = Dr(_r);
if (!fr[zn]) {
fr[zn] = !0;
var Si = "";
Lt && Lt._owner && Lt._owner !== ie.current && (Si = " It was passed a child from " + Hi(Lt._owner.type) + "."), It(Lt), yt('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', zn, Si), It(null);
}
}
}
function Ai(Lt, _r) {
if (typeof Lt == "object") {
if (zr(Lt))
for (var zn = 0; zn < Lt.length; zn++) {
var Si = Lt[zn];
ra(Si) && Sn(Si, _r);
}
else if (ra(Lt))
Lt._store && (Lt._store.validated = !0);
else if (Lt) {
var Qa = V(Lt);
if (typeof Qa == "function" && Qa !== Lt.entries)
for (var Ks = Qa.call(Lt), qs; !(qs = Ks.next()).done; )
ra(qs.value) && Sn(qs.value, _r);
}
}
}
function Fr(Lt) {
{
var _r = Lt.type;
if (_r == null || typeof _r == "string")
return;
var zn;
if (typeof _r == "function")
zn = _r.propTypes;
else if (typeof _r == "object" && (_r.$$typeof === h || // Note: Memo only checks outer props here.
// Inner props are checked in the reconciler.
_r.$$typeof === b))
zn = _r.propTypes;
else
return;
if (zn) {
var Si = Hi(_r);
et(zn, Lt.props, "prop", Si, Lt);
} else if (_r.PropTypes !== void 0 && !Mt) {
Mt = !0;
var Qa = Hi(_r);
yt("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", Qa || "Unknown");
}
typeof _r.getDefaultProps == "function" && !_r.getDefaultProps.isReactClassApproved && yt("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
}
}
function Bn(Lt) {
{
for (var _r = Object.keys(Lt.props), zn = 0; zn < _r.length; zn++) {
var Si = _r[zn];
if (Si !== "children" && Si !== "key") {
It(Lt), yt("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", Si), It(null);
break;
}
}
Lt.ref !== null && (It(Lt), yt("Invalid attribute `ref` supplied to `React.Fragment`."), It(null));
}
}
function xi(Lt, _r, zn) {
var Si = Li(Lt);
if (!Si) {
var Qa = "";
(Lt === void 0 || typeof Lt == "object" && Lt !== null && Object.keys(Lt).length === 0) && (Qa += " 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 Ks = Sr(_r);
Ks ? Qa += Ks : Qa += Vt();
var qs;
Lt === null ? qs = "null" : zr(Lt) ? qs = "array" : Lt !== void 0 && Lt.$$typeof === n ? (qs = "<" + (Hi(Lt.type) || "Unknown") + " />", Qa = " Did you accidentally export a JSX literal instead of a component?") : qs = typeof Lt, yt("React.createElement: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", qs, Qa);
}
var jo = ln.apply(this, arguments);
if (jo == null)
return jo;
if (Si)
for (var mi = 2; mi < arguments.length; mi++)
Ai(arguments[mi], Lt);
return Lt === a ? Bn(jo) : Fr(jo), jo;
}
var vi = !1;
function qi(Lt) {
var _r = xi.bind(null, Lt);
return _r.type = Lt, vi || (vi = !0, ht("React.createFactory() is deprecated and will be removed in a future major release. Consider using JSX or use React.createElement() directly instead.")), Object.defineProperty(_r, "type", {
enumerable: !1,
get: function() {
return ht("Factory.type is deprecated. Access the class directly before passing it to createFactory."), Object.defineProperty(this, "type", {
value: Lt
}), Lt;
}
}), _r;
}
function Ri(Lt, _r, zn) {
for (var Si = Ta.apply(this, arguments), Qa = 2; Qa < arguments.length; Qa++)
Ai(arguments[Qa], Si.type);
return Fr(Si), Si;
}
function Fa(Lt, _r) {
var zn = X.transition;
X.transition = {};
var Si = X.transition;
X.transition._updatedFibers = /* @__PURE__ */ new Set();
try {
Lt();
} finally {
if (X.transition = zn, zn === null && Si._updatedFibers) {
var Qa = Si._updatedFibers.size;
Qa > 10 && ht("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."), Si._updatedFibers.clear();
}
}
}
var sa = !1, ca = null;
function Bs(Lt) {
if (ca === null)
try {
var _r = ("require" + Math.random()).slice(0, 7), zn = e && e[_r];
ca = zn.call(e, "timers").setImmediate;
} catch {
ca = function(Qa) {
sa === !1 && (sa = !0, typeof MessageChannel > "u" && yt("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."));
var Ks = new MessageChannel();
Ks.port1.onmessage = Qa, Ks.port2.postMessage(void 0);
};
}
return ca(Lt);
}
var fo = 0, ho = !1;
function Na(Lt) {
{
var _r = fo;
fo++, te.current === null && (te.current = []);
var zn = te.isBatchingLegacy, Si;
try {
if (te.isBatchingLegacy = !0, Si = Lt(), !zn && te.didScheduleLegacyUpdate) {
var Qa = te.current;
Qa !== null && (te.didScheduleLegacyUpdate = !1, vc(Qa));
}
} catch (Rt) {
throw Ku(_r), Rt;
} finally {
te.isBatchingLegacy = zn;
}
if (Si !== null && typeof Si == "object" && typeof Si.then == "function") {
var Ks = Si, qs = !1, jo = {
then: function(Rt, yr) {
qs = !0, Ks.then(function(Lr) {
Ku(_r), fo === 0 ? Od(Lr, Rt, yr) : Rt(Lr);
}, function(Lr) {
Ku(_r), yr(Lr);
});
}
};
return !ho && typeof Promise < "u" && Promise.resolve().then(function() {
}).then(function() {
qs || (ho = !0, yt("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
}), jo;
} else {
var mi = Si;
if (Ku(_r), fo === 0) {
var Nu = te.current;
Nu !== null && (vc(Nu), te.current = null);
var Fi = {
then: function(Rt, yr) {
te.current === null ? (te.current = [], Od(mi, Rt, yr)) : Rt(mi);
}
};
return Fi;
} else {
var z = {
then: function(Rt, yr) {
Rt(mi);
}
};
return z;
}
}
}
}
function Ku(Lt) {
Lt !== fo - 1 && yt("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "), fo = Lt;
}
function Od(Lt, _r, zn) {
{
var Si = te.current;
if (Si !== null)
try {
vc(Si), Bs(function() {
Si.length === 0 ? (te.current = null, _r(Lt)) : Od(Lt, _r, zn);
});
} catch (Qa) {
zn(Qa);
}
else
_r(Lt);
}
}
var Cc = !1;
function vc(Lt) {
if (!Cc) {
Cc = !0;
var _r = 0;
try {
for (; _r < Lt.length; _r++) {
var zn = Lt[_r];
do
zn = zn(!0);
while (zn !== null);
}
Lt.length = 0;
} catch (Si) {
throw Lt = Lt.slice(_r + 1), Si;
} finally {
Cc = !1;
}
}
}
var np = xi, eA = Ri, Fh = qi, Ep = {
map: rl,
forEach: Hs,
count: $u,
toArray: qa,
only: js
};
t.Children = Ep, t.Component = Ct, t.Fragment = a, t.Profiler = l, t.PureComponent = Xt, t.StrictMode = s, t.Suspense = m, t.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Ze, t.act = Na, t.cloneElement = eA, t.createContext = ha, t.createElement = np, t.createFactory = Fh, t.createRef = Tr, t.forwardRef = xo, t.isValidElement = ra, t.lazy = Ps, t.memo = ya, t.startTransition = Fa, t.unstable_act = Na, t.useCallback = Wi, t.useContext = Os, t.useDebugValue = lo, t.useDeferredValue = Hl, t.useEffect = cu, t.useId = ns, t.useImperativeHandle = ia, t.useInsertionEffect = wa, t.useLayoutEffect = Wr, t.useMemo = vs, t.useReducer = wo, t.useRef = Uo, t.useState = xs, t.useSyncExternalStore = Dl, t.useTransition = Rs, t.version = r, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
})();
})(zF, zF.exports)), zF.exports;
}
var Ige;
function x2() {
return Ige || (Ige = 1, $Y.exports = VYe()), $Y.exports;
}
var LU = {}, Tge;
function HYe() {
if (Tge) return LU;
Tge = 1;
return (function() {
var e = x2(), t = /* @__PURE__ */ Symbol.for("react.element"), r = /* @__PURE__ */ Symbol.for("react.portal"), n = /* @__PURE__ */ Symbol.for("react.fragment"), i = /* @__PURE__ */ Symbol.for("react.strict_mode"), a = /* @__PURE__ */ Symbol.for("react.profiler"), s = /* @__PURE__ */ Symbol.for("react.provider"), l = /* @__PURE__ */ Symbol.for("react.context"), u = /* @__PURE__ */ Symbol.for("react.forward_ref"), d = /* @__PURE__ */ Symbol.for("react.suspense"), h = /* @__PURE__ */ Symbol.for("react.suspense_list"), m = /* @__PURE__ */ Symbol.for("react.memo"), w = /* @__PURE__ */ Symbol.for("react.lazy"), b = /* @__