@zhin.js/console 1.0.8 → 1.0.10

package/dist/react.js

@@ -0,0 +1,421 @@
+import { g as J } from "./_commonjsHelpers-C6fGbg64.js";
+var d = { exports: {} }, n = {};
+/**
+ * @license React
+ * react.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 M;
+function F() {
+  if (M) return n;
+  M = 1;
+  var y = Symbol.for("react.transitional.element"), L = Symbol.for("react.portal"), $ = Symbol.for("react.fragment"), U = Symbol.for("react.strict_mode"), Y = Symbol.for("react.profiler"), D = Symbol.for("react.consumer"), b = Symbol.for("react.context"), k = Symbol.for("react.forward_ref"), q = Symbol.for("react.suspense"), z = Symbol.for("react.memo"), A = Symbol.for("react.lazy"), G = Symbol.for("react.activity"), h = Symbol.iterator;
+  function W(t) {
+    return t === null || typeof t != "object" ? null : (t = h && t[h] || t["@@iterator"], typeof t == "function" ? t : null);
+  }
+  var O = {
+    isMounted: function() {
+      return !1;
+    },
+    enqueueForceUpdate: function() {
+    },
+    enqueueReplaceState: function() {
+    },
+    enqueueSetState: function() {
+    }
+  }, g = Object.assign, N = {};
+  function l(t, e, u) {
+    this.props = t, this.context = e, this.refs = N, this.updater = u || O;
+  }
+  l.prototype.isReactComponent = {}, l.prototype.setState = function(t, e) {
+    if (typeof t != "object" && typeof t != "function" && t != null)
+      throw Error(
+        "takes an object of state variables to update or a function which returns an object of state variables."
+      );
+    this.updater.enqueueSetState(this, t, e, "setState");
+  }, l.prototype.forceUpdate = function(t) {
+    this.updater.enqueueForceUpdate(this, t, "forceUpdate");
+  };
+  function P() {
+  }
+  P.prototype = l.prototype;
+  function R(t, e, u) {
+    this.props = t, this.context = e, this.refs = N, this.updater = u || O;
+  }
+  var m = R.prototype = new P();
+  m.constructor = R, g(m, l.prototype), m.isPureReactComponent = !0;
+  var w = Array.isArray;
+  function v() {
+  }
+  var f = { H: null, A: null, T: null, S: null }, I = Object.prototype.hasOwnProperty;
+  function T(t, e, u) {
+    var o = u.ref;
+    return {
+      $$typeof: y,
+      type: t,
+      key: e,
+      ref: o !== void 0 ? o : null,
+      props: u
+    };
+  }
+  function K(t, e) {
+    return T(t.type, e, t.props);
+  }
+  function C(t) {
+    return typeof t == "object" && t !== null && t.$$typeof === y;
+  }
+  function V(t) {
+    var e = { "=": "=0", ":": "=2" };
+    return "$" + t.replace(/[=:]/g, function(u) {
+      return e[u];
+    });
+  }
+  var H = /\/+/g;
+  function S(t, e) {
+    return typeof t == "object" && t !== null && t.key != null ? V("" + t.key) : e.toString(36);
+  }
+  function B(t) {
+    switch (t.status) {
+      case "fulfilled":
+        return t.value;
+      case "rejected":
+        throw t.reason;
+      default:
+        switch (typeof t.status == "string" ? t.then(v, v) : (t.status = "pending", t.then(
+          function(e) {
+            t.status === "pending" && (t.status = "fulfilled", t.value = e);
+          },
+          function(e) {
+            t.status === "pending" && (t.status = "rejected", t.reason = e);
+          }
+        )), t.status) {
+          case "fulfilled":
+            return t.value;
+          case "rejected":
+            throw t.reason;
+        }
+    }
+    throw t;
+  }
+  function _(t, e, u, o, s) {
+    var c = typeof t;
+    (c === "undefined" || c === "boolean") && (t = null);
+    var i = !1;
+    if (t === null) i = !0;
+    else
+      switch (c) {
+        case "bigint":
+        case "string":
+        case "number":
+          i = !0;
+          break;
+        case "object":
+          switch (t.$$typeof) {
+            case y:
+            case L:
+              i = !0;
+              break;
+            case A:
+              return i = t._init, _(
+                i(t._payload),
+                e,
+                u,
+                o,
+                s
+              );
+          }
+      }
+    if (i)
+      return s = s(t), i = o === "" ? "." + S(t, 0) : o, w(s) ? (u = "", i != null && (u = i.replace(H, "$&/") + "/"), _(s, e, u, "", function(Z) {
+        return Z;
+      })) : s != null && (C(s) && (s = K(
+        s,
+        u + (s.key == null || t && t.key === s.key ? "" : ("" + s.key).replace(
+          H,
+          "$&/"
+        ) + "/") + i
+      )), e.push(s)), 1;
+    i = 0;
+    var p = o === "" ? "." : o + ":";
+    if (w(t))
+      for (var a = 0; a < t.length; a++)
+        o = t[a], c = p + S(o, a), i += _(
+          o,
+          e,
+          u,
+          c,
+          s
+        );
+    else if (a = W(t), typeof a == "function")
+      for (t = a.call(t), a = 0; !(o = t.next()).done; )
+        o = o.value, c = p + S(o, a++), i += _(
+          o,
+          e,
+          u,
+          c,
+          s
+        );
+    else if (c === "object") {
+      if (typeof t.then == "function")
+        return _(
+          B(t),
+          e,
+          u,
+          o,
+          s
+        );
+      throw e = String(t), Error(
+        "Objects are not valid as a React child (found: " + (e === "[object Object]" ? "object with keys {" + Object.keys(t).join(", ") + "}" : e) + "). If you meant to render a collection of children, use an array instead."
+      );
+    }
+    return i;
+  }
+  function E(t, e, u) {
+    if (t == null) return t;
+    var o = [], s = 0;
+    return _(t, o, "", "", function(c) {
+      return e.call(u, c, s++);
+    }), o;
+  }
+  function Q(t) {
+    if (t._status === -1) {
+      var e = t._result;
+      e = e(), e.then(
+        function(u) {
+          (t._status === 0 || t._status === -1) && (t._status = 1, t._result = u);
+        },
+        function(u) {
+          (t._status === 0 || t._status === -1) && (t._status = 2, t._result = u);
+        }
+      ), t._status === -1 && (t._status = 0, t._result = e);
+    }
+    if (t._status === 1) return t._result.default;
+    throw t._result;
+  }
+  var j = typeof reportError == "function" ? reportError : function(t) {
+    if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+      var e = new window.ErrorEvent("error", {
+        bubbles: !0,
+        cancelable: !0,
+        message: typeof t == "object" && t !== null && typeof t.message == "string" ? String(t.message) : String(t),
+        error: t
+      });
+      if (!window.dispatchEvent(e)) return;
+    } else if (typeof process == "object" && typeof process.emit == "function") {
+      process.emit("uncaughtException", t);
+      return;
+    }
+    console.error(t);
+  }, X = {
+    map: E,
+    forEach: function(t, e, u) {
+      E(
+        t,
+        function() {
+          e.apply(this, arguments);
+        },
+        u
+      );
+    },
+    count: function(t) {
+      var e = 0;
+      return E(t, function() {
+        e++;
+      }), e;
+    },
+    toArray: function(t) {
+      return E(t, function(e) {
+        return e;
+      }) || [];
+    },
+    only: function(t) {
+      if (!C(t))
+        throw Error(
+          "React.Children.only expected to receive a single React element child."
+        );
+      return t;
+    }
+  };
+  return n.Activity = G, n.Children = X, n.Component = l, n.Fragment = $, n.Profiler = Y, n.PureComponent = R, n.StrictMode = U, n.Suspense = q, n.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = f, n.__COMPILER_RUNTIME = {
+    __proto__: null,
+    c: function(t) {
+      return f.H.useMemoCache(t);
+    }
+  }, n.cache = function(t) {
+    return function() {
+      return t.apply(null, arguments);
+    };
+  }, n.cacheSignal = function() {
+    return null;
+  }, n.cloneElement = function(t, e, u) {
+    if (t == null)
+      throw Error(
+        "The argument must be a React element, but you passed " + t + "."
+      );
+    var o = g({}, t.props), s = t.key;
+    if (e != null)
+      for (c in e.key !== void 0 && (s = "" + e.key), e)
+        !I.call(e, c) || c === "key" || c === "__self" || c === "__source" || c === "ref" && e.ref === void 0 || (o[c] = e[c]);
+    var c = arguments.length - 2;
+    if (c === 1) o.children = u;
+    else if (1 < c) {
+      for (var i = Array(c), p = 0; p < c; p++)
+        i[p] = arguments[p + 2];
+      o.children = i;
+    }
+    return T(t.type, s, o);
+  }, n.createContext = function(t) {
+    return t = {
+      $$typeof: b,
+      _currentValue: t,
+      _currentValue2: t,
+      _threadCount: 0,
+      Provider: null,
+      Consumer: null
+    }, t.Provider = t, t.Consumer = {
+      $$typeof: D,
+      _context: t
+    }, t;
+  }, n.createElement = function(t, e, u) {
+    var o, s = {}, c = null;
+    if (e != null)
+      for (o in e.key !== void 0 && (c = "" + e.key), e)
+        I.call(e, o) && o !== "key" && o !== "__self" && o !== "__source" && (s[o] = e[o]);
+    var i = arguments.length - 2;
+    if (i === 1) s.children = u;
+    else if (1 < i) {
+      for (var p = Array(i), a = 0; a < i; a++)
+        p[a] = arguments[a + 2];
+      s.children = p;
+    }
+    if (t && t.defaultProps)
+      for (o in i = t.defaultProps, i)
+        s[o] === void 0 && (s[o] = i[o]);
+    return T(t, c, s);
+  }, n.createRef = function() {
+    return { current: null };
+  }, n.forwardRef = function(t) {
+    return { $$typeof: k, render: t };
+  }, n.isValidElement = C, n.lazy = function(t) {
+    return {
+      $$typeof: A,
+      _payload: { _status: -1, _result: t },
+      _init: Q
+    };
+  }, n.memo = function(t, e) {
+    return {
+      $$typeof: z,
+      type: t,
+      compare: e === void 0 ? null : e
+    };
+  }, n.startTransition = function(t) {
+    var e = f.T, u = {};
+    f.T = u;
+    try {
+      var o = t(), s = f.S;
+      s !== null && s(u, o), typeof o == "object" && o !== null && typeof o.then == "function" && o.then(v, j);
+    } catch (c) {
+      j(c);
+    } finally {
+      e !== null && u.types !== null && (e.types = u.types), f.T = e;
+    }
+  }, n.unstable_useCacheRefresh = function() {
+    return f.H.useCacheRefresh();
+  }, n.use = function(t) {
+    return f.H.use(t);
+  }, n.useActionState = function(t, e, u) {
+    return f.H.useActionState(t, e, u);
+  }, n.useCallback = function(t, e) {
+    return f.H.useCallback(t, e);
+  }, n.useContext = function(t) {
+    return f.H.useContext(t);
+  }, n.useDebugValue = function() {
+  }, n.useDeferredValue = function(t, e) {
+    return f.H.useDeferredValue(t, e);
+  }, n.useEffect = function(t, e) {
+    return f.H.useEffect(t, e);
+  }, n.useEffectEvent = function(t) {
+    return f.H.useEffectEvent(t);
+  }, n.useId = function() {
+    return f.H.useId();
+  }, n.useImperativeHandle = function(t, e, u) {
+    return f.H.useImperativeHandle(t, e, u);
+  }, n.useInsertionEffect = function(t, e) {
+    return f.H.useInsertionEffect(t, e);
+  }, n.useLayoutEffect = function(t, e) {
+    return f.H.useLayoutEffect(t, e);
+  }, n.useMemo = function(t, e) {
+    return f.H.useMemo(t, e);
+  }, n.useOptimistic = function(t, e) {
+    return f.H.useOptimistic(t, e);
+  }, n.useReducer = function(t, e, u) {
+    return f.H.useReducer(t, e, u);
+  }, n.useRef = function(t) {
+    return f.H.useRef(t);
+  }, n.useState = function(t) {
+    return f.H.useState(t);
+  }, n.useSyncExternalStore = function(t, e, u) {
+    return f.H.useSyncExternalStore(
+      t,
+      e,
+      u
+    );
+  }, n.useTransition = function() {
+    return f.H.useTransition();
+  }, n.version = "19.2.0", n;
+}
+var x;
+function tt() {
+  return x || (x = 1, d.exports = F()), d.exports;
+}
+var et = tt();
+const r = /* @__PURE__ */ J(et), rt = r.Activity, ot = r.Children, ut = r.Component, st = r.Fragment, ct = r.Profiler, ft = r.PureComponent, it = r.StrictMode, at = r.Suspense, pt = r.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, lt = r.__COMPILER_RUNTIME, _t = r.cache, Et = r.cacheSignal, yt = r.cloneElement, Rt = r.createContext, mt = r.createElement, vt = r.createRef, Tt = r.forwardRef, Ct = r.isValidElement, St = r.lazy, dt = r.memo, At = r.startTransition, ht = r.unstable_useCacheRefresh, Ot = r.use, gt = r.useActionState, Nt = r.useCallback, Pt = r.useContext, wt = r.useDebugValue, It = r.useDeferredValue, Ht = r.useEffect, jt = r.useEffectEvent, Mt = r.useId, xt = r.useImperativeHandle, Lt = r.useInsertionEffect, $t = r.useLayoutEffect, Ut = r.useMemo, Yt = r.useOptimistic, Dt = r.useReducer, bt = r.useRef, kt = r.useState, qt = r.useSyncExternalStore, zt = r.useTransition, Gt = r.version, Wt = r.default || r;
+export {
+  rt as Activity,
+  ot as Children,
+  ut as Component,
+  st as Fragment,
+  ct as Profiler,
+  ft as PureComponent,
+  it as StrictMode,
+  at as Suspense,
+  pt as __CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+  lt as __COMPILER_RUNTIME,
+  _t as cache,
+  Et as cacheSignal,
+  yt as cloneElement,
+  Rt as createContext,
+  mt as createElement,
+  vt as createRef,
+  Wt as default,
+  Tt as forwardRef,
+  Ct as isValidElement,
+  St as lazy,
+  dt as memo,
+  At as startTransition,
+  ht as unstable_useCacheRefresh,
+  Ot as use,
+  gt as useActionState,
+  Nt as useCallback,
+  Pt as useContext,
+  wt as useDebugValue,
+  It as useDeferredValue,
+  Ht as useEffect,
+  jt as useEffectEvent,
+  Mt as useId,
+  xt as useImperativeHandle,
+  Lt as useInsertionEffect,
+  $t as useLayoutEffect,
+  Ut as useMemo,
+  Yt as useOptimistic,
+  Dt as useReducer,
+  bt as useRef,
+  kt as useState,
+  qt as useSyncExternalStore,
+  zt as useTransition,
+  Gt as version
+};