colibri-ui 0.0.1

package/esm/node_modules/react/cjs/react.production.min.js

@@ -0,0 +1,354 @@
+import _typeof from '../../@babel/runtime/helpers/esm/typeof.js';
+import '../../../_virtual/_commonjsHelpers.js';
+import { __exports as react_production_min } from '../../../_virtual/react.production.min.js';
+
+var hasRequiredReact_production_min;
+function requireReact_production_min() {
+  if (hasRequiredReact_production_min) return react_production_min;
+  hasRequiredReact_production_min = 1;
+  'use strict';
+  var l = Symbol["for"]("react.element"),
+    n = Symbol["for"]("react.portal"),
+    p = Symbol["for"]("react.fragment"),
+    q = Symbol["for"]("react.strict_mode"),
+    r = Symbol["for"]("react.profiler"),
+    t = Symbol["for"]("react.provider"),
+    u = Symbol["for"]("react.context"),
+    v = Symbol["for"]("react.forward_ref"),
+    w = Symbol["for"]("react.suspense"),
+    x = Symbol["for"]("react.memo"),
+    y = Symbol["for"]("react.lazy"),
+    z = Symbol.iterator;
+  function A(a) {
+    if (null === a || "object" !== _typeof(a)) return null;
+    a = z && a[z] || a["@@iterator"];
+    return "function" === typeof a ? a : null;
+  }
+  var B = {
+      isMounted: function isMounted() {
+        return !1;
+      },
+      enqueueForceUpdate: function enqueueForceUpdate() {},
+      enqueueReplaceState: function enqueueReplaceState() {},
+      enqueueSetState: function enqueueSetState() {}
+    },
+    C = Object.assign,
+    D = {};
+  function E(a, b, e) {
+    this.props = a;
+    this.context = b;
+    this.refs = D;
+    this.updater = e || B;
+  }
+  E.prototype.isReactComponent = {};
+  E.prototype.setState = function (a, b) {
+    if ("object" !== _typeof(a) && "function" !== typeof a && null != a) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+    this.updater.enqueueSetState(this, a, b, "setState");
+  };
+  E.prototype.forceUpdate = function (a) {
+    this.updater.enqueueForceUpdate(this, a, "forceUpdate");
+  };
+  function F() {}
+  F.prototype = E.prototype;
+  function G(a, b, e) {
+    this.props = a;
+    this.context = b;
+    this.refs = D;
+    this.updater = e || B;
+  }
+  var H = G.prototype = new F();
+  H.constructor = G;
+  C(H, E.prototype);
+  H.isPureReactComponent = !0;
+  var I = Array.isArray,
+    J = Object.prototype.hasOwnProperty,
+    K = {
+      current: null
+    },
+    L = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    };
+  function M(a, b, e) {
+    var d,
+      c = {},
+      k = null,
+      h = null;
+    if (null != b) for (d in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b) J.call(b, d) && !L.hasOwnProperty(d) && (c[d] = b[d]);
+    var g = arguments.length - 2;
+    if (1 === g) c.children = e;else if (1 < g) {
+      for (var f = Array(g), m = 0; m < g; m++) f[m] = arguments[m + 2];
+      c.children = f;
+    }
+    if (a && a.defaultProps) for (d in g = a.defaultProps, g) void 0 === c[d] && (c[d] = g[d]);
+    return {
+      $$typeof: l,
+      type: a,
+      key: k,
+      ref: h,
+      props: c,
+      _owner: K.current
+    };
+  }
+  function N(a, b) {
+    return {
+      $$typeof: l,
+      type: a.type,
+      key: b,
+      ref: a.ref,
+      props: a.props,
+      _owner: a._owner
+    };
+  }
+  function O(a) {
+    return "object" === _typeof(a) && null !== a && a.$$typeof === l;
+  }
+  function escape(a) {
+    var b = {
+      "=": "=0",
+      ":": "=2"
+    };
+    return "$" + a.replace(/[=:]/g, function (a) {
+      return b[a];
+    });
+  }
+  var P = /\/+/g;
+  function Q(a, b) {
+    return "object" === _typeof(a) && null !== a && null != a.key ? escape("" + a.key) : b.toString(36);
+  }
+  function R(a, b, e, d, c) {
+    var k = _typeof(a);
+    if ("undefined" === k || "boolean" === k) a = null;
+    var h = !1;
+    if (null === a) h = !0;else switch (k) {
+      case "string":
+      case "number":
+        h = !0;
+        break;
+      case "object":
+        switch (a.$$typeof) {
+          case l:
+          case n:
+            h = !0;
+        }
+    }
+    if (h) return h = a, c = c(h), a = "" === d ? "." + Q(h, 0) : d, I(c) ? (e = "", null != a && (e = a.replace(P, "$&/") + "/"), R(c, b, e, "", function (a) {
+      return a;
+    })) : null != c && (O(c) && (c = N(c, e + (!c.key || h && h.key === c.key ? "" : ("" + c.key).replace(P, "$&/") + "/") + a)), b.push(c)), 1;
+    h = 0;
+    d = "" === d ? "." : d + ":";
+    if (I(a)) for (var g = 0; g < a.length; g++) {
+      k = a[g];
+      var f = d + Q(k, g);
+      h += R(k, b, e, f, c);
+    } else if (f = A(a), "function" === typeof f) for (a = f.call(a), g = 0; !(k = a.next()).done;) k = k.value, f = d + Q(k, g++), h += R(k, b, e, f, c);else if ("object" === k) throw b = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
+    return h;
+  }
+  function S(a, b, e) {
+    if (null == a) return a;
+    var d = [],
+      c = 0;
+    R(a, d, "", "", function (a) {
+      return b.call(e, a, c++);
+    });
+    return d;
+  }
+  function T(a) {
+    if (-1 === a._status) {
+      var b = a._result;
+      b = b();
+      b.then(function (b) {
+        if (0 === a._status || -1 === a._status) a._status = 1, a._result = b;
+      }, function (b) {
+        if (0 === a._status || -1 === a._status) a._status = 2, a._result = b;
+      });
+      -1 === a._status && (a._status = 0, a._result = b);
+    }
+    if (1 === a._status) return a._result["default"];
+    throw a._result;
+  }
+  var U = {
+      current: null
+    },
+    V = {
+      transition: null
+    },
+    W = {
+      ReactCurrentDispatcher: U,
+      ReactCurrentBatchConfig: V,
+      ReactCurrentOwner: K
+    };
+  function X() {
+    throw Error("act(...) is not supported in production builds of React.");
+  }
+  react_production_min.Children = {
+    map: S,
+    forEach: function forEach(a, b, e) {
+      S(a, function () {
+        b.apply(this, arguments);
+      }, e);
+    },
+    count: function count(a) {
+      var b = 0;
+      S(a, function () {
+        b++;
+      });
+      return b;
+    },
+    toArray: function toArray(a) {
+      return S(a, function (a) {
+        return a;
+      }) || [];
+    },
+    only: function only(a) {
+      if (!O(a)) throw Error("React.Children.only expected to receive a single React element child.");
+      return a;
+    }
+  };
+  react_production_min.Component = E;
+  react_production_min.Fragment = p;
+  react_production_min.Profiler = r;
+  react_production_min.PureComponent = G;
+  react_production_min.StrictMode = q;
+  react_production_min.Suspense = w;
+  react_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W;
+  react_production_min.act = X;
+  react_production_min.cloneElement = function (a, b, e) {
+    if (null === a || void 0 === a) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + ".");
+    var d = C({}, a.props),
+      c = a.key,
+      k = a.ref,
+      h = a._owner;
+    if (null != b) {
+      void 0 !== b.ref && (k = b.ref, h = K.current);
+      void 0 !== b.key && (c = "" + b.key);
+      if (a.type && a.type.defaultProps) var g = a.type.defaultProps;
+      for (f in b) J.call(b, f) && !L.hasOwnProperty(f) && (d[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
+    }
+    var f = arguments.length - 2;
+    if (1 === f) d.children = e;else if (1 < f) {
+      g = Array(f);
+      for (var m = 0; m < f; m++) g[m] = arguments[m + 2];
+      d.children = g;
+    }
+    return {
+      $$typeof: l,
+      type: a.type,
+      key: c,
+      ref: k,
+      props: d,
+      _owner: h
+    };
+  };
+  react_production_min.createContext = function (a) {
+    a = {
+      $$typeof: u,
+      _currentValue: a,
+      _currentValue2: a,
+      _threadCount: 0,
+      Provider: null,
+      Consumer: null,
+      _defaultValue: null,
+      _globalName: null
+    };
+    a.Provider = {
+      $$typeof: t,
+      _context: a
+    };
+    return a.Consumer = a;
+  };
+  react_production_min.createElement = M;
+  react_production_min.createFactory = function (a) {
+    var b = M.bind(null, a);
+    b.type = a;
+    return b;
+  };
+  react_production_min.createRef = function () {
+    return {
+      current: null
+    };
+  };
+  react_production_min.forwardRef = function (a) {
+    return {
+      $$typeof: v,
+      render: a
+    };
+  };
+  react_production_min.isValidElement = O;
+  react_production_min.lazy = function (a) {
+    return {
+      $$typeof: y,
+      _payload: {
+        _status: -1,
+        _result: a
+      },
+      _init: T
+    };
+  };
+  react_production_min.memo = function (a, b) {
+    return {
+      $$typeof: x,
+      type: a,
+      compare: void 0 === b ? null : b
+    };
+  };
+  react_production_min.startTransition = function (a) {
+    var b = V.transition;
+    V.transition = {};
+    try {
+      a();
+    } finally {
+      V.transition = b;
+    }
+  };
+  react_production_min.unstable_act = X;
+  react_production_min.useCallback = function (a, b) {
+    return U.current.useCallback(a, b);
+  };
+  react_production_min.useContext = function (a) {
+    return U.current.useContext(a);
+  };
+  react_production_min.useDebugValue = function () {};
+  react_production_min.useDeferredValue = function (a) {
+    return U.current.useDeferredValue(a);
+  };
+  react_production_min.useEffect = function (a, b) {
+    return U.current.useEffect(a, b);
+  };
+  react_production_min.useId = function () {
+    return U.current.useId();
+  };
+  react_production_min.useImperativeHandle = function (a, b, e) {
+    return U.current.useImperativeHandle(a, b, e);
+  };
+  react_production_min.useInsertionEffect = function (a, b) {
+    return U.current.useInsertionEffect(a, b);
+  };
+  react_production_min.useLayoutEffect = function (a, b) {
+    return U.current.useLayoutEffect(a, b);
+  };
+  react_production_min.useMemo = function (a, b) {
+    return U.current.useMemo(a, b);
+  };
+  react_production_min.useReducer = function (a, b, e) {
+    return U.current.useReducer(a, b, e);
+  };
+  react_production_min.useRef = function (a) {
+    return U.current.useRef(a);
+  };
+  react_production_min.useState = function (a) {
+    return U.current.useState(a);
+  };
+  react_production_min.useSyncExternalStore = function (a, b, e) {
+    return U.current.useSyncExternalStore(a, b, e);
+  };
+  react_production_min.useTransition = function () {
+    return U.current.useTransition();
+  };
+  react_production_min.version = "18.3.1";
+  return react_production_min;
+}
+
+export { requireReact_production_min as __require };

package/esm/node_modules/react/index.js

@@ -0,0 +1,16 @@
+import { getDefaultExportFromCjs } from '../../_virtual/_commonjsHelpers.js';
+import { __module as react$1 } from '../../_virtual/index.js';
+import { __require as requireReact_production_min } from './cjs/react.production.min.js';
+import { __require as requireReact_development } from './cjs/react.development.js';
+
+var react = react$1.exports;
+'use strict';
+if (process.env.NODE_ENV === 'production') {
+  react$1.exports = requireReact_production_min();
+} else {
+  react$1.exports = requireReact_development();
+}
+var reactExports = react$1.exports;
+var index = /*@__PURE__*/getDefaultExportFromCjs(reactExports);
+
+export { index as default, reactExports as r };

package/esm/node_modules/react/jsx-runtime.js

@@ -0,0 +1,16 @@
+import { getDefaultExportFromCjs } from '../../_virtual/_commonjsHelpers.js';
+import { __module as jsxRuntime$2 } from '../../_virtual/jsx-runtime.js';
+import { __require as requireReactJsxRuntime_production_min } from './cjs/react-jsx-runtime.production.min.js';
+import { __require as requireReactJsxRuntime_development } from './cjs/react-jsx-runtime.development.js';
+
+var jsxRuntime = jsxRuntime$2.exports;
+'use strict';
+if (process.env.NODE_ENV === 'production') {
+  jsxRuntime$2.exports = requireReactJsxRuntime_production_min();
+} else {
+  jsxRuntime$2.exports = requireReactJsxRuntime_development();
+}
+var jsxRuntimeExports = jsxRuntime$2.exports;
+var jsxRuntime$1 = /*@__PURE__*/getDefaultExportFromCjs(jsxRuntimeExports);
+
+export { jsxRuntime$1 as default, jsxRuntimeExports as j };

package/esm/node_modules/react-is/cjs/react-is.development.js

@@ -0,0 +1,170 @@
+import _typeof from '../../@babel/runtime/helpers/esm/typeof.js';
+import '../../../_virtual/_commonjsHelpers.js';
+import { __exports as reactIs_development } from '../../../_virtual/react-is.development.js';
+
+var hasRequiredReactIs_development;
+function requireReactIs_development() {
+  if (hasRequiredReactIs_development) return reactIs_development;
+  hasRequiredReactIs_development = 1;
+  'use strict';
+  if (process.env.NODE_ENV !== "production") {
+    (function () {
+      'use strict';
+
+      // The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+      // nor polyfill, then a plain number is used for performance.
+      var hasSymbol = typeof Symbol === 'function' && Symbol["for"];
+      var REACT_ELEMENT_TYPE = hasSymbol ? Symbol["for"]('react.element') : 0xeac7;
+      var REACT_PORTAL_TYPE = hasSymbol ? Symbol["for"]('react.portal') : 0xeaca;
+      var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol["for"]('react.fragment') : 0xeacb;
+      var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol["for"]('react.strict_mode') : 0xeacc;
+      var REACT_PROFILER_TYPE = hasSymbol ? Symbol["for"]('react.profiler') : 0xead2;
+      var REACT_PROVIDER_TYPE = hasSymbol ? Symbol["for"]('react.provider') : 0xeacd;
+      var REACT_CONTEXT_TYPE = hasSymbol ? Symbol["for"]('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
+      // (unstable) APIs that have been removed. Can we remove the symbols?
+
+      var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol["for"]('react.async_mode') : 0xeacf;
+      var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol["for"]('react.concurrent_mode') : 0xeacf;
+      var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol["for"]('react.forward_ref') : 0xead0;
+      var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol["for"]('react.suspense') : 0xead1;
+      var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol["for"]('react.suspense_list') : 0xead8;
+      var REACT_MEMO_TYPE = hasSymbol ? Symbol["for"]('react.memo') : 0xead3;
+      var REACT_LAZY_TYPE = hasSymbol ? Symbol["for"]('react.lazy') : 0xead4;
+      var REACT_BLOCK_TYPE = hasSymbol ? Symbol["for"]('react.block') : 0xead9;
+      var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol["for"]('react.fundamental') : 0xead5;
+      var REACT_RESPONDER_TYPE = hasSymbol ? Symbol["for"]('react.responder') : 0xead6;
+      var REACT_SCOPE_TYPE = hasSymbol ? Symbol["for"]('react.scope') : 0xead7;
+      function isValidElementType(type) {
+        return typeof type === 'string' || typeof type === 'function' ||
+        // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+        type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || _typeof(type) === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+      }
+      function typeOf(object) {
+        if (_typeof(object) === 'object' && object !== null) {
+          var $$typeof = object.$$typeof;
+          switch ($$typeof) {
+            case REACT_ELEMENT_TYPE:
+              var type = object.type;
+              switch (type) {
+                case REACT_ASYNC_MODE_TYPE:
+                case REACT_CONCURRENT_MODE_TYPE:
+                case REACT_FRAGMENT_TYPE:
+                case REACT_PROFILER_TYPE:
+                case REACT_STRICT_MODE_TYPE:
+                case REACT_SUSPENSE_TYPE:
+                  return type;
+                default:
+                  var $$typeofType = type && type.$$typeof;
+                  switch ($$typeofType) {
+                    case REACT_CONTEXT_TYPE:
+                    case REACT_FORWARD_REF_TYPE:
+                    case REACT_LAZY_TYPE:
+                    case REACT_MEMO_TYPE:
+                    case REACT_PROVIDER_TYPE:
+                      return $$typeofType;
+                    default:
+                      return $$typeof;
+                  }
+              }
+            case REACT_PORTAL_TYPE:
+              return $$typeof;
+          }
+        }
+        return undefined;
+      } // AsyncMode is deprecated along with isAsyncMode
+
+      var AsyncMode = REACT_ASYNC_MODE_TYPE;
+      var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+      var ContextConsumer = REACT_CONTEXT_TYPE;
+      var ContextProvider = REACT_PROVIDER_TYPE;
+      var Element = REACT_ELEMENT_TYPE;
+      var ForwardRef = REACT_FORWARD_REF_TYPE;
+      var Fragment = REACT_FRAGMENT_TYPE;
+      var Lazy = REACT_LAZY_TYPE;
+      var Memo = REACT_MEMO_TYPE;
+      var Portal = REACT_PORTAL_TYPE;
+      var Profiler = REACT_PROFILER_TYPE;
+      var StrictMode = REACT_STRICT_MODE_TYPE;
+      var Suspense = REACT_SUSPENSE_TYPE;
+      var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
+
+      function isAsyncMode(object) {
+        {
+          if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+            hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+            console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
+          }
+        }
+        return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+      }
+      function isConcurrentMode(object) {
+        return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+      }
+      function isContextConsumer(object) {
+        return typeOf(object) === REACT_CONTEXT_TYPE;
+      }
+      function isContextProvider(object) {
+        return typeOf(object) === REACT_PROVIDER_TYPE;
+      }
+      function isElement(object) {
+        return _typeof(object) === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+      }
+      function isForwardRef(object) {
+        return typeOf(object) === REACT_FORWARD_REF_TYPE;
+      }
+      function isFragment(object) {
+        return typeOf(object) === REACT_FRAGMENT_TYPE;
+      }
+      function isLazy(object) {
+        return typeOf(object) === REACT_LAZY_TYPE;
+      }
+      function isMemo(object) {
+        return typeOf(object) === REACT_MEMO_TYPE;
+      }
+      function isPortal(object) {
+        return typeOf(object) === REACT_PORTAL_TYPE;
+      }
+      function isProfiler(object) {
+        return typeOf(object) === REACT_PROFILER_TYPE;
+      }
+      function isStrictMode(object) {
+        return typeOf(object) === REACT_STRICT_MODE_TYPE;
+      }
+      function isSuspense(object) {
+        return typeOf(object) === REACT_SUSPENSE_TYPE;
+      }
+      reactIs_development.AsyncMode = AsyncMode;
+      reactIs_development.ConcurrentMode = ConcurrentMode;
+      reactIs_development.ContextConsumer = ContextConsumer;
+      reactIs_development.ContextProvider = ContextProvider;
+      reactIs_development.Element = Element;
+      reactIs_development.ForwardRef = ForwardRef;
+      reactIs_development.Fragment = Fragment;
+      reactIs_development.Lazy = Lazy;
+      reactIs_development.Memo = Memo;
+      reactIs_development.Portal = Portal;
+      reactIs_development.Profiler = Profiler;
+      reactIs_development.StrictMode = StrictMode;
+      reactIs_development.Suspense = Suspense;
+      reactIs_development.isAsyncMode = isAsyncMode;
+      reactIs_development.isConcurrentMode = isConcurrentMode;
+      reactIs_development.isContextConsumer = isContextConsumer;
+      reactIs_development.isContextProvider = isContextProvider;
+      reactIs_development.isElement = isElement;
+      reactIs_development.isForwardRef = isForwardRef;
+      reactIs_development.isFragment = isFragment;
+      reactIs_development.isLazy = isLazy;
+      reactIs_development.isMemo = isMemo;
+      reactIs_development.isPortal = isPortal;
+      reactIs_development.isProfiler = isProfiler;
+      reactIs_development.isStrictMode = isStrictMode;
+      reactIs_development.isSuspense = isSuspense;
+      reactIs_development.isValidElementType = isValidElementType;
+      reactIs_development.typeOf = typeOf;
+    })();
+  }
+  return reactIs_development;
+}
+
+export { requireReactIs_development as __require };

package/esm/node_modules/react-is/cjs/react-is.production.min.js

@@ -0,0 +1,119 @@
+import _typeof from '../../@babel/runtime/helpers/esm/typeof.js';
+import '../../../_virtual/_commonjsHelpers.js';
+import { __exports as reactIs_production_min } from '../../../_virtual/react-is.production.min.js';
+
+var hasRequiredReactIs_production_min;
+function requireReactIs_production_min() {
+  if (hasRequiredReactIs_production_min) return reactIs_production_min;
+  hasRequiredReactIs_production_min = 1;
+  'use strict';
+  var b = "function" === typeof Symbol && Symbol["for"],
+    c = b ? Symbol["for"]("react.element") : 60103,
+    d = b ? Symbol["for"]("react.portal") : 60106,
+    e = b ? Symbol["for"]("react.fragment") : 60107,
+    f = b ? Symbol["for"]("react.strict_mode") : 60108,
+    g = b ? Symbol["for"]("react.profiler") : 60114,
+    h = b ? Symbol["for"]("react.provider") : 60109,
+    k = b ? Symbol["for"]("react.context") : 60110,
+    l = b ? Symbol["for"]("react.async_mode") : 60111,
+    m = b ? Symbol["for"]("react.concurrent_mode") : 60111,
+    n = b ? Symbol["for"]("react.forward_ref") : 60112,
+    p = b ? Symbol["for"]("react.suspense") : 60113,
+    q = b ? Symbol["for"]("react.suspense_list") : 60120,
+    r = b ? Symbol["for"]("react.memo") : 60115,
+    t = b ? Symbol["for"]("react.lazy") : 60116,
+    v = b ? Symbol["for"]("react.block") : 60121,
+    w = b ? Symbol["for"]("react.fundamental") : 60117,
+    x = b ? Symbol["for"]("react.responder") : 60118,
+    y = b ? Symbol["for"]("react.scope") : 60119;
+  function z(a) {
+    if ("object" === _typeof(a) && null !== a) {
+      var u = a.$$typeof;
+      switch (u) {
+        case c:
+          switch (a = a.type, a) {
+            case l:
+            case m:
+            case e:
+            case g:
+            case f:
+            case p:
+              return a;
+            default:
+              switch (a = a && a.$$typeof, a) {
+                case k:
+                case n:
+                case t:
+                case r:
+                case h:
+                  return a;
+                default:
+                  return u;
+              }
+          }
+        case d:
+          return u;
+      }
+    }
+  }
+  function A(a) {
+    return z(a) === m;
+  }
+  reactIs_production_min.AsyncMode = l;
+  reactIs_production_min.ConcurrentMode = m;
+  reactIs_production_min.ContextConsumer = k;
+  reactIs_production_min.ContextProvider = h;
+  reactIs_production_min.Element = c;
+  reactIs_production_min.ForwardRef = n;
+  reactIs_production_min.Fragment = e;
+  reactIs_production_min.Lazy = t;
+  reactIs_production_min.Memo = r;
+  reactIs_production_min.Portal = d;
+  reactIs_production_min.Profiler = g;
+  reactIs_production_min.StrictMode = f;
+  reactIs_production_min.Suspense = p;
+  reactIs_production_min.isAsyncMode = function (a) {
+    return A(a) || z(a) === l;
+  };
+  reactIs_production_min.isConcurrentMode = A;
+  reactIs_production_min.isContextConsumer = function (a) {
+    return z(a) === k;
+  };
+  reactIs_production_min.isContextProvider = function (a) {
+    return z(a) === h;
+  };
+  reactIs_production_min.isElement = function (a) {
+    return "object" === _typeof(a) && null !== a && a.$$typeof === c;
+  };
+  reactIs_production_min.isForwardRef = function (a) {
+    return z(a) === n;
+  };
+  reactIs_production_min.isFragment = function (a) {
+    return z(a) === e;
+  };
+  reactIs_production_min.isLazy = function (a) {
+    return z(a) === t;
+  };
+  reactIs_production_min.isMemo = function (a) {
+    return z(a) === r;
+  };
+  reactIs_production_min.isPortal = function (a) {
+    return z(a) === d;
+  };
+  reactIs_production_min.isProfiler = function (a) {
+    return z(a) === g;
+  };
+  reactIs_production_min.isStrictMode = function (a) {
+    return z(a) === f;
+  };
+  reactIs_production_min.isSuspense = function (a) {
+    return z(a) === p;
+  };
+  reactIs_production_min.isValidElementType = function (a) {
+    return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || "object" === _typeof(a) && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);
+  };
+  reactIs_production_min.typeOf = z;
+  return reactIs_production_min;
+}
+
+export { requireReactIs_production_min as __require };

package/esm/node_modules/react-is/index.js

@@ -0,0 +1,16 @@
+import { getDefaultExportFromCjs } from '../../_virtual/_commonjsHelpers.js';
+import { __module as reactIs$1 } from '../../_virtual/index4.js';
+import { __require as requireReactIs_production_min } from './cjs/react-is.production.min.js';
+import { __require as requireReactIs_development } from './cjs/react-is.development.js';
+
+var reactIs = reactIs$1.exports;
+'use strict';
+if (process.env.NODE_ENV === 'production') {
+  reactIs$1.exports = requireReactIs_production_min();
+} else {
+  reactIs$1.exports = requireReactIs_development();
+}
+var reactIsExports = reactIs$1.exports;
+var index = /*@__PURE__*/getDefaultExportFromCjs(reactIsExports);
+
+export { index as default, reactIsExports as r };