UNPKG

react/cjs/react.production.js

Version:

17.2 kBJavaScriptView Raw

1/**
* @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.
*/
10
11"use strict";
12var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
REACT_PORTAL_TYPE = Symbol.for("react.portal"),
REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
REACT_CONTEXT_TYPE = Symbol.for("react.context"),
REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
REACT_MEMO_TYPE = Symbol.for("react.memo"),
REACT_LAZY_TYPE = Symbol.for("react.lazy"),
REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),
MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
25function getIteratorFn(maybeIterable) {
if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
maybeIterable =
  (MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
  maybeIterable["@@iterator"];
return "function" === typeof maybeIterable ? maybeIterable : null;
31}
32var ReactNoopUpdateQueue = {
  isMounted: function () {
    return !1;
  },
  enqueueForceUpdate: function () {},
  enqueueReplaceState: function () {},
  enqueueSetState: function () {}
},
assign = Object.assign,
emptyObject = {};
42function Component(props, context, updater) {
this.props = props;
this.context = context;
this.refs = emptyObject;
this.updater = updater || ReactNoopUpdateQueue;
47}
48Component.prototype.isReactComponent = {};
49Component.prototype.setState = function (partialState, callback) {
if (
  "object" !== typeof partialState &&
  "function" !== typeof partialState &&
  null != partialState
)
  throw Error(
    "takes an object of state variables to update or a function which returns an object of state variables."
  );
this.updater.enqueueSetState(this, partialState, callback, "setState");
59};
60Component.prototype.forceUpdate = function (callback) {
this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
62};
63function ComponentDummy() {}
64ComponentDummy.prototype = Component.prototype;
65function PureComponent(props, context, updater) {
this.props = props;
this.context = context;
this.refs = emptyObject;
this.updater = updater || ReactNoopUpdateQueue;
70}
71var pureComponentPrototype = (PureComponent.prototype = new ComponentDummy());
72pureComponentPrototype.constructor = PureComponent;
73assign(pureComponentPrototype, Component.prototype);
74pureComponentPrototype.isPureReactComponent = !0;
75var isArrayImpl = Array.isArray;
76function noop() {}
77var ReactSharedInternals = { H: null, A: null, T: null, S: null },
hasOwnProperty = Object.prototype.hasOwnProperty;
79function ReactElement(type, key, props) {
var refProp = props.ref;
return {
  $$typeof: REACT_ELEMENT_TYPE,
  type: type,
  key: key,
  ref: void 0 !== refProp ? refProp : null,
  props: props
};
88}
89function cloneAndReplaceKey(oldElement, newKey) {
return ReactElement(oldElement.type, newKey, oldElement.props);
91}
92function isValidElement(object) {
return (
  "object" === typeof object &&
  null !== object &&
  object.$$typeof === REACT_ELEMENT_TYPE
);
98}
99function escape(key) {
var escaperLookup = { "=": "=0", ":": "=2" };
return (
  "$" +
  key.replace(/[=:]/g, function (match) {
    return escaperLookup[match];
  })
);
107}
108var userProvidedKeyEscapeRegex = /\/+/g;
109function getElementKey(element, index) {
return "object" === typeof element && null !== element && null != element.key
  ? escape("" + element.key)
  : index.toString(36);
113}
114function resolveThenable(thenable) {
switch (thenable.status) {
  case "fulfilled":
    return thenable.value;
  case "rejected":
    throw thenable.reason;
  default:
    switch (
      ("string" === typeof thenable.status
        ? thenable.then(noop, noop)
        : ((thenable.status = "pending"),
          thenable.then(
            function (fulfilledValue) {
              "pending" === thenable.status &&
                ((thenable.status = "fulfilled"),
                (thenable.value = fulfilledValue));
            },
            function (error) {
              "pending" === thenable.status &&
                ((thenable.status = "rejected"), (thenable.reason = error));
            }
          )),
      thenable.status)
    ) {
      case "fulfilled":
        return thenable.value;
      case "rejected":
        throw thenable.reason;
    }
}
throw thenable;
145}
146function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
var type = typeof children;
if ("undefined" === type || "boolean" === type) children = null;
var invokeCallback = !1;
if (null === children) invokeCallback = !0;
else
  switch (type) {
    case "bigint":
    case "string":
    case "number":
      invokeCallback = !0;
      break;
    case "object":
      switch (children.$$typeof) {
        case REACT_ELEMENT_TYPE:
        case REACT_PORTAL_TYPE:
          invokeCallback = !0;
          break;
        case REACT_LAZY_TYPE:
          return (
            (invokeCallback = children._init),
            mapIntoArray(
              invokeCallback(children._payload),
              array,
              escapedPrefix,
              nameSoFar,
              callback
            )
          );
      }
  }
if (invokeCallback)
  return (
    (callback = callback(children)),
    (invokeCallback =
      "" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar),
    isArrayImpl(callback)
      ? ((escapedPrefix = ""),
        null != invokeCallback &&
          (escapedPrefix =
            invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"),
        mapIntoArray(callback, array, escapedPrefix, "", function (c) {
          return c;
        }))
      : null != callback &&
        (isValidElement(callback) &&
          (callback = cloneAndReplaceKey(
            callback,
            escapedPrefix +
              (null == callback.key ||
              (children && children.key === callback.key)
                ? ""
                : ("" + callback.key).replace(
                    userProvidedKeyEscapeRegex,
                    "$&/"
                  ) + "/") +
              invokeCallback
          )),
        array.push(callback)),
    1
  );
invokeCallback = 0;
var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";
if (isArrayImpl(children))
  for (var i = 0; i < children.length; i++)
    (nameSoFar = children[i]),
      (type = nextNamePrefix + getElementKey(nameSoFar, i)),
      (invokeCallback += mapIntoArray(
        nameSoFar,
        array,
        escapedPrefix,
        type,
        callback
      ));
else if (((i = getIteratorFn(children)), "function" === typeof i))
  for (
    children = i.call(children), i = 0;
    !(nameSoFar = children.next()).done;
224
  )
    (nameSoFar = nameSoFar.value),
      (type = nextNamePrefix + getElementKey(nameSoFar, i++)),
      (invokeCallback += mapIntoArray(
        nameSoFar,
        array,
        escapedPrefix,
        type,
        callback
      ));
else if ("object" === type) {
  if ("function" === typeof children.then)
    return mapIntoArray(
      resolveThenable(children),
      array,
      escapedPrefix,
      nameSoFar,
      callback
    );
  array = String(children);
  throw Error(
    "Objects are not valid as a React child (found: " +
      ("[object Object]" === array
        ? "object with keys {" + Object.keys(children).join(", ") + "}"
        : array) +
      "). If you meant to render a collection of children, use an array instead."
  );
}
return invokeCallback;
254}
255function mapChildren(children, func, context) {
if (null == children) return children;
var result = [],
  count = 0;
mapIntoArray(children, result, "", "", function (child) {
  return func.call(context, child, count++);
});
return result;
263}
264function lazyInitializer(payload) {
if (-1 === payload._status) {
  var ctor = payload._result;
  ctor = ctor();
  ctor.then(
    function (moduleObject) {
      if (0 === payload._status || -1 === payload._status)
        (payload._status = 1), (payload._result = moduleObject);
    },
    function (error) {
      if (0 === payload._status || -1 === payload._status)
        (payload._status = 2), (payload._result = error);
    }
  );
  -1 === payload._status && ((payload._status = 0), (payload._result = ctor));
}
if (1 === payload._status) return payload._result.default;
throw payload._result;
282}
283var reportGlobalError =
  "function" === typeof reportError
    ? reportError
    : function (error) {
        if (
          "object" === typeof window &&
          "function" === typeof window.ErrorEvent
        ) {
          var event = new window.ErrorEvent("error", {
            bubbles: !0,
            cancelable: !0,
            message:
              "object" === typeof error &&
              null !== error &&
              "string" === typeof error.message
                ? String(error.message)
                : String(error),
            error: error
          });
          if (!window.dispatchEvent(event)) return;
        } else if (
          "object" === typeof process &&
          "function" === typeof process.emit
        ) {
          process.emit("uncaughtException", error);
          return;
        }
        console.error(error);
      },
Children = {
  map: mapChildren,
  forEach: function (children, forEachFunc, forEachContext) {
    mapChildren(
      children,
      function () {
        forEachFunc.apply(this, arguments);
      },
      forEachContext
    );
  },
  count: function (children) {
    var n = 0;
    mapChildren(children, function () {
      n++;
    });
    return n;
  },
  toArray: function (children) {
    return (
      mapChildren(children, function (child) {
        return child;
      }) || []
    );
  },
  only: function (children) {
    if (!isValidElement(children))
      throw Error(
        "React.Children.only expected to receive a single React element child."
      );
    return children;
  }
};
345exports.Activity = REACT_ACTIVITY_TYPE;
346exports.Children = Children;
347exports.Component = Component;
348exports.Fragment = REACT_FRAGMENT_TYPE;
349exports.Profiler = REACT_PROFILER_TYPE;
350exports.PureComponent = PureComponent;
351exports.StrictMode = REACT_STRICT_MODE_TYPE;
352exports.Suspense = REACT_SUSPENSE_TYPE;
353exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE =
ReactSharedInternals;
355exports.__COMPILER_RUNTIME = {
__proto__: null,
c: function (size) {
  return ReactSharedInternals.H.useMemoCache(size);
}
360};
361exports.cache = function (fn) {
return function () {
  return fn.apply(null, arguments);
};
365};
366exports.cacheSignal = function () {
return null;
368};
369exports.cloneElement = function (element, config, children) {
if (null === element || void 0 === element)
  throw Error(
    "The argument must be a React element, but you passed " + element + "."
  );
var props = assign({}, element.props),
  key = element.key;
if (null != config)
  for (propName in (void 0 !== config.key && (key = "" + config.key), config))
    !hasOwnProperty.call(config, propName) ||
      "key" === propName ||
      "__self" === propName ||
      "__source" === propName ||
      ("ref" === propName && void 0 === config.ref) ||
      (props[propName] = config[propName]);
var propName = arguments.length - 2;
if (1 === propName) props.children = children;
else if (1 < propName) {
  for (var childArray = Array(propName), i = 0; i < propName; i++)
    childArray[i] = arguments[i + 2];
  props.children = childArray;
}
return ReactElement(element.type, key, props);
392};
393exports.createContext = function (defaultValue) {
defaultValue = {
  $$typeof: REACT_CONTEXT_TYPE,
  _currentValue: defaultValue,
  _currentValue2: defaultValue,
  _threadCount: 0,
  Provider: null,
  Consumer: null
};
defaultValue.Provider = defaultValue;
defaultValue.Consumer = {
  $$typeof: REACT_CONSUMER_TYPE,
  _context: defaultValue
};
return defaultValue;
408};
409exports.createElement = function (type, config, children) {
var propName,
  props = {},
  key = null;
if (null != config)
  for (propName in (void 0 !== config.key && (key = "" + config.key), config))
    hasOwnProperty.call(config, propName) &&
      "key" !== propName &&
      "__self" !== propName &&
      "__source" !== propName &&
      (props[propName] = config[propName]);
var childrenLength = arguments.length - 2;
if (1 === childrenLength) props.children = children;
else if (1 < childrenLength) {
  for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++)
    childArray[i] = arguments[i + 2];
  props.children = childArray;
}
if (type && type.defaultProps)
  for (propName in ((childrenLength = type.defaultProps), childrenLength))
    void 0 === props[propName] &&
      (props[propName] = childrenLength[propName]);
return ReactElement(type, key, props);
432};
433exports.createRef = function () {
return { current: null };
435};
436exports.forwardRef = function (render) {
return { $$typeof: REACT_FORWARD_REF_TYPE, render: render };
438};
439exports.isValidElement = isValidElement;
440exports.lazy = function (ctor) {
return {
  $$typeof: REACT_LAZY_TYPE,
  _payload: { _status: -1, _result: ctor },
  _init: lazyInitializer
};
446};
447exports.memo = function (type, compare) {
return {
  $$typeof: REACT_MEMO_TYPE,
  type: type,
  compare: void 0 === compare ? null : compare
};
453};
454exports.startTransition = function (scope) {
var prevTransition = ReactSharedInternals.T,
  currentTransition = {};
ReactSharedInternals.T = currentTransition;
try {
  var returnValue = scope(),
    onStartTransitionFinish = ReactSharedInternals.S;
  null !== onStartTransitionFinish &&
    onStartTransitionFinish(currentTransition, returnValue);
  "object" === typeof returnValue &&
    null !== returnValue &&
    "function" === typeof returnValue.then &&
    returnValue.then(noop, reportGlobalError);
} catch (error) {
  reportGlobalError(error);
} finally {
  null !== prevTransition &&
    null !== currentTransition.types &&
    (prevTransition.types = currentTransition.types),
    (ReactSharedInternals.T = prevTransition);
}
475};
476exports.unstable_useCacheRefresh = function () {
return ReactSharedInternals.H.useCacheRefresh();
478};
479exports.use = function (usable) {
return ReactSharedInternals.H.use(usable);
481};
482exports.useActionState = function (action, initialState, permalink) {
return ReactSharedInternals.H.useActionState(action, initialState, permalink);
484};
485exports.useCallback = function (callback, deps) {
return ReactSharedInternals.H.useCallback(callback, deps);
487};
488exports.useContext = function (Context) {
return ReactSharedInternals.H.useContext(Context);
490};
491exports.useDebugValue = function () {};
492exports.useDeferredValue = function (value, initialValue) {
return ReactSharedInternals.H.useDeferredValue(value, initialValue);
494};
495exports.useEffect = function (create, deps) {
return ReactSharedInternals.H.useEffect(create, deps);
497};
498exports.useEffectEvent = function (callback) {
return ReactSharedInternals.H.useEffectEvent(callback);
500};
501exports.useId = function () {
return ReactSharedInternals.H.useId();
503};
504exports.useImperativeHandle = function (ref, create, deps) {
return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
506};
507exports.useInsertionEffect = function (create, deps) {
return ReactSharedInternals.H.useInsertionEffect(create, deps);
509};
510exports.useLayoutEffect = function (create, deps) {
return ReactSharedInternals.H.useLayoutEffect(create, deps);
512};
513exports.useMemo = function (create, deps) {
return ReactSharedInternals.H.useMemo(create, deps);
515};
516exports.useOptimistic = function (passthrough, reducer) {
return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
518};
519exports.useReducer = function (reducer, initialArg, init) {
return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
521};
522exports.useRef = function (initialValue) {
return ReactSharedInternals.H.useRef(initialValue);
524};
525exports.useState = function (initialState) {
return ReactSharedInternals.H.useState(initialState);
527};
528exports.useSyncExternalStore = function (
subscribe,
getSnapshot,
getServerSnapshot
532) {
return ReactSharedInternals.H.useSyncExternalStore(
  subscribe,
  getSnapshot,
  getServerSnapshot
);
538};
539exports.useTransition = function () {
return ReactSharedInternals.H.useTransition();
541};
542exports.version = "19.2.3";

1	`/**`
2	`* @license React`
3	`* react.production.js`
4	`*`
5	`* Copyright (c) Meta Platforms, Inc. and affiliates.`
6	`*`
7	`* This source code is licensed under the MIT license found in the`
8	`* LICENSE file in the root directory of this source tree.`
9	`*/`
10
11	`"use strict";`
12	`var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),`
13	`REACT_PORTAL_TYPE = Symbol.for("react.portal"),`
14	`REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),`
15	`REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),`
16	`REACT_PROFILER_TYPE = Symbol.for("react.profiler"),`
17	`REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),`
18	`REACT_CONTEXT_TYPE = Symbol.for("react.context"),`
19	`REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),`
20	`REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),`
21	`REACT_MEMO_TYPE = Symbol.for("react.memo"),`
22	`REACT_LAZY_TYPE = Symbol.for("react.lazy"),`
23	`REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),`
24	`MAYBE_ITERATOR_SYMBOL = Symbol.iterator;`
25	`function getIteratorFn(maybeIterable) {`
26	`if (null === maybeIterable \|\| "object" !== typeof maybeIterable) return null;`
27	`maybeIterable =`
28	`(MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) \|\|`
29	`maybeIterable["@@iterator"];`
30	`return "function" === typeof maybeIterable ? maybeIterable : null;`
31	`}`
32	`var ReactNoopUpdateQueue = {`
33	`isMounted: function () {`
34	`return !1;`
35	`},`
36	`enqueueForceUpdate: function () {},`
37	`enqueueReplaceState: function () {},`
38	`enqueueSetState: function () {}`
39	`},`
40	`assign = Object.assign,`
41	`emptyObject = {};`
42	`function Component(props, context, updater) {`
43	`this.props = props;`
44	`this.context = context;`
45	`this.refs = emptyObject;`
46	`this.updater = updater \|\| ReactNoopUpdateQueue;`
47	`}`
48	`Component.prototype.isReactComponent = {};`
49	`Component.prototype.setState = function (partialState, callback) {`
50	`if (`
51	`"object" !== typeof partialState &&`
52	`"function" !== typeof partialState &&`
53	`null != partialState`
54	`)`
55	`throw Error(`
56	`"takes an object of state variables to update or a function which returns an object of state variables."`
57	`);`
58	`this.updater.enqueueSetState(this, partialState, callback, "setState");`
59	`};`
60	`Component.prototype.forceUpdate = function (callback) {`
61	`this.updater.enqueueForceUpdate(this, callback, "forceUpdate");`
62	`};`
63	`function ComponentDummy() {}`
64	`ComponentDummy.prototype = Component.prototype;`
65	`function PureComponent(props, context, updater) {`
66	`this.props = props;`
67	`this.context = context;`
68	`this.refs = emptyObject;`
69	`this.updater = updater \|\| ReactNoopUpdateQueue;`
70	`}`
71	`var pureComponentPrototype = (PureComponent.prototype = new ComponentDummy());`
72	`pureComponentPrototype.constructor = PureComponent;`
73	`assign(pureComponentPrototype, Component.prototype);`
74	`pureComponentPrototype.isPureReactComponent = !0;`
75	`var isArrayImpl = Array.isArray;`
76	`function noop() {}`
77	`var ReactSharedInternals = { H: null, A: null, T: null, S: null },`
78	`hasOwnProperty = Object.prototype.hasOwnProperty;`
79	`function ReactElement(type, key, props) {`
80	`var refProp = props.ref;`
81	`return {`
82	`$$typeof: REACT_ELEMENT_TYPE,`
83	`type: type,`
84	`key: key,`
85	`ref: void 0 !== refProp ? refProp : null,`
86	`props: props`
87	`};`
88	`}`
89	`function cloneAndReplaceKey(oldElement, newKey) {`
90	`return ReactElement(oldElement.type, newKey, oldElement.props);`
91	`}`
92	`function isValidElement(object) {`
93	`return (`
94	`"object" === typeof object &&`
95	`null !== object &&`
96	`object.$$typeof === REACT_ELEMENT_TYPE`
97	`);`
98	`}`
99	`function escape(key) {`
100	`var escaperLookup = { "=": "=0", ":": "=2" };`
101	`return (`
102	`"$" +`
103	`key.replace(/[=:]/g, function (match) {`
104	`return escaperLookup[match];`
105	`})`
106	`);`
107	`}`
108	`var userProvidedKeyEscapeRegex = /\/+/g;`
109	`function getElementKey(element, index) {`
110	`return "object" === typeof element && null !== element && null != element.key`
111	`? escape("" + element.key)`
112	`: index.toString(36);`
113	`}`
114	`function resolveThenable(thenable) {`
115	`switch (thenable.status) {`
116	`case "fulfilled":`
117	`return thenable.value;`
118	`case "rejected":`
119	`throw thenable.reason;`
120	`default:`
121	`switch (`
122	`("string" === typeof thenable.status`
123	`? thenable.then(noop, noop)`
124	`: ((thenable.status = "pending"),`
125	`thenable.then(`
126	`function (fulfilledValue) {`
127	`"pending" === thenable.status &&`
128	`((thenable.status = "fulfilled"),`
129	`(thenable.value = fulfilledValue));`
130	`},`
131	`function (error) {`
132	`"pending" === thenable.status &&`
133	`((thenable.status = "rejected"), (thenable.reason = error));`
134	`}`
135	`)),`
136	`thenable.status)`
137	`) {`
138	`case "fulfilled":`
139	`return thenable.value;`
140	`case "rejected":`
141	`throw thenable.reason;`
142	`}`
143	`}`
144	`throw thenable;`
145	`}`
146	`function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {`
147	`var type = typeof children;`
148	`if ("undefined" === type \|\| "boolean" === type) children = null;`
149	`var invokeCallback = !1;`
150	`if (null === children) invokeCallback = !0;`
151	`else`
152	`switch (type) {`
153	`case "bigint":`
154	`case "string":`
155	`case "number":`
156	`invokeCallback = !0;`
157	`break;`
158	`case "object":`
159	`switch (children.$$typeof) {`
160	`case REACT_ELEMENT_TYPE:`
161	`case REACT_PORTAL_TYPE:`
162	`invokeCallback = !0;`
163	`break;`
164	`case REACT_LAZY_TYPE:`
165	`return (`
166	`(invokeCallback = children._init),`
167	`mapIntoArray(`
168	`invokeCallback(children._payload),`
169	`array,`
170	`escapedPrefix,`
171	`nameSoFar,`
172	`callback`
173	`)`
174	`);`
175	`}`
176	`}`
177	`if (invokeCallback)`
178	`return (`
179	`(callback = callback(children)),`
180	`(invokeCallback =`
181	`"" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar),`
182	`isArrayImpl(callback)`
183	`? ((escapedPrefix = ""),`
184	`null != invokeCallback &&`
185	`(escapedPrefix =`
186	`invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"),`
187	`mapIntoArray(callback, array, escapedPrefix, "", function (c) {`
188	`return c;`
189	`}))`
190	`: null != callback &&`
191	`(isValidElement(callback) &&`
192	`(callback = cloneAndReplaceKey(`
193	`callback,`
194	`escapedPrefix +`
195	`(null == callback.key \|\|`
196	`(children && children.key === callback.key)`
197	`? ""`
198	`: ("" + callback.key).replace(`
199	`userProvidedKeyEscapeRegex,`
200	`"$&/"`
201	`) + "/") +`
202	`invokeCallback`
203	`)),`
204	`array.push(callback)),`
205	`1`
206	`);`
207	`invokeCallback = 0;`
208	`var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";`
209	`if (isArrayImpl(children))`
210	`for (var i = 0; i < children.length; i++)`
211	`(nameSoFar = children[i]),`
212	`(type = nextNamePrefix + getElementKey(nameSoFar, i)),`
213	`(invokeCallback += mapIntoArray(`
214	`nameSoFar,`
215	`array,`
216	`escapedPrefix,`
217	`type,`
218	`callback`
219	`));`
220	`else if (((i = getIteratorFn(children)), "function" === typeof i))`
221	`for (`
222	`children = i.call(children), i = 0;`
223	`!(nameSoFar = children.next()).done;`
224
225	`)`
226	`(nameSoFar = nameSoFar.value),`
227	`(type = nextNamePrefix + getElementKey(nameSoFar, i++)),`
228	`(invokeCallback += mapIntoArray(`
229	`nameSoFar,`
230	`array,`
231	`escapedPrefix,`
232	`type,`
233	`callback`
234	`));`
235	`else if ("object" === type) {`
236	`if ("function" === typeof children.then)`
237	`return mapIntoArray(`
238	`resolveThenable(children),`
239	`array,`
240	`escapedPrefix,`
241	`nameSoFar,`
242	`callback`
243	`);`
244	`array = String(children);`
245	`throw Error(`
246	`"Objects are not valid as a React child (found: " +`
247	`("[object Object]" === array`
248	`? "object with keys {" + Object.keys(children).join(", ") + "}"`
249	`: array) +`
250	`"). If you meant to render a collection of children, use an array instead."`
251	`);`
252	`}`
253	`return invokeCallback;`
254	`}`
255	`function mapChildren(children, func, context) {`
256	`if (null == children) return children;`
257	`var result = [],`
258	`count = 0;`
259	`mapIntoArray(children, result, "", "", function (child) {`
260	`return func.call(context, child, count++);`
261	`});`
262	`return result;`
263	`}`
264	`function lazyInitializer(payload) {`
265	`if (-1 === payload._status) {`
266	`var ctor = payload._result;`
267	`ctor = ctor();`
268	`ctor.then(`
269	`function (moduleObject) {`
270	`if (0 === payload._status \|\| -1 === payload._status)`
271	`(payload._status = 1), (payload._result = moduleObject);`
272	`},`
273	`function (error) {`
274	`if (0 === payload._status \|\| -1 === payload._status)`
275	`(payload._status = 2), (payload._result = error);`
276	`}`
277	`);`
278	`-1 === payload._status && ((payload._status = 0), (payload._result = ctor));`
279	`}`
280	`if (1 === payload._status) return payload._result.default;`
281	`throw payload._result;`
282	`}`
283	`var reportGlobalError =`
284	`"function" === typeof reportError`
285	`? reportError`
286	`: function (error) {`
287	`if (`
288	`"object" === typeof window &&`
289	`"function" === typeof window.ErrorEvent`
290	`) {`
291	`var event = new window.ErrorEvent("error", {`
292	`bubbles: !0,`
293	`cancelable: !0,`
294	`message:`
295	`"object" === typeof error &&`
296	`null !== error &&`
297	`"string" === typeof error.message`
298	`? String(error.message)`
299	`: String(error),`
300	`error: error`
301	`});`
302	`if (!window.dispatchEvent(event)) return;`
303	`} else if (`
304	`"object" === typeof process &&`
305	`"function" === typeof process.emit`
306	`) {`
307	`process.emit("uncaughtException", error);`
308	`return;`
309	`}`
310	`console.error(error);`
311	`},`
312	`Children = {`
313	`map: mapChildren,`
314	`forEach: function (children, forEachFunc, forEachContext) {`
315	`mapChildren(`
316	`children,`
317	`function () {`
318	`forEachFunc.apply(this, arguments);`
319	`},`
320	`forEachContext`
321	`);`
322	`},`
323	`count: function (children) {`
324	`var n = 0;`
325	`mapChildren(children, function () {`
326	`n++;`
327	`});`
328	`return n;`
329	`},`
330	`toArray: function (children) {`
331	`return (`
332	`mapChildren(children, function (child) {`
333	`return child;`
334	`}) \|\| []`
335	`);`
336	`},`
337	`only: function (children) {`
338	`if (!isValidElement(children))`
339	`throw Error(`
340	`"React.Children.only expected to receive a single React element child."`
341	`);`
342	`return children;`
343	`}`
344	`};`
345	`exports.Activity = REACT_ACTIVITY_TYPE;`
346	`exports.Children = Children;`
347	`exports.Component = Component;`
348	`exports.Fragment = REACT_FRAGMENT_TYPE;`
349	`exports.Profiler = REACT_PROFILER_TYPE;`
350	`exports.PureComponent = PureComponent;`
351	`exports.StrictMode = REACT_STRICT_MODE_TYPE;`
352	`exports.Suspense = REACT_SUSPENSE_TYPE;`
353	`exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE =`
354	`ReactSharedInternals;`
355	`exports.__COMPILER_RUNTIME = {`
356	`__proto__: null,`
357	`c: function (size) {`
358	`return ReactSharedInternals.H.useMemoCache(size);`
359	`}`
360	`};`
361	`exports.cache = function (fn) {`
362	`return function () {`
363	`return fn.apply(null, arguments);`
364	`};`
365	`};`
366	`exports.cacheSignal = function () {`
367	`return null;`
368	`};`
369	`exports.cloneElement = function (element, config, children) {`
370	`if (null === element \|\| void 0 === element)`
371	`throw Error(`
372	`"The argument must be a React element, but you passed " + element + "."`
373	`);`
374	`var props = assign({}, element.props),`
375	`key = element.key;`
376	`if (null != config)`
377	`for (propName in (void 0 !== config.key && (key = "" + config.key), config))`
378	`!hasOwnProperty.call(config, propName) \|\|`
379	`"key" === propName \|\|`
380	`"__self" === propName \|\|`
381	`"__source" === propName \|\|`
382	`("ref" === propName && void 0 === config.ref) \|\|`
383	`(props[propName] = config[propName]);`
384	`var propName = arguments.length - 2;`
385	`if (1 === propName) props.children = children;`
386	`else if (1 < propName) {`
387	`for (var childArray = Array(propName), i = 0; i < propName; i++)`
388	`childArray[i] = arguments[i + 2];`
389	`props.children = childArray;`
390	`}`
391	`return ReactElement(element.type, key, props);`
392	`};`
393	`exports.createContext = function (defaultValue) {`
394	`defaultValue = {`
395	`$$typeof: REACT_CONTEXT_TYPE,`
396	`_currentValue: defaultValue,`
397	`_currentValue2: defaultValue,`
398	`_threadCount: 0,`
399	`Provider: null,`
400	`Consumer: null`
401	`};`
402	`defaultValue.Provider = defaultValue;`
403	`defaultValue.Consumer = {`
404	`$$typeof: REACT_CONSUMER_TYPE,`
405	`_context: defaultValue`
406	`};`
407	`return defaultValue;`
408	`};`
409	`exports.createElement = function (type, config, children) {`
410	`var propName,`
411	`props = {},`
412	`key = null;`
413	`if (null != config)`
414	`for (propName in (void 0 !== config.key && (key = "" + config.key), config))`
415	`hasOwnProperty.call(config, propName) &&`
416	`"key" !== propName &&`
417	`"__self" !== propName &&`
418	`"__source" !== propName &&`
419	`(props[propName] = config[propName]);`
420	`var childrenLength = arguments.length - 2;`
421	`if (1 === childrenLength) props.children = children;`
422	`else if (1 < childrenLength) {`
423	`for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++)`
424	`childArray[i] = arguments[i + 2];`
425	`props.children = childArray;`
426	`}`
427	`if (type && type.defaultProps)`
428	`for (propName in ((childrenLength = type.defaultProps), childrenLength))`
429	`void 0 === props[propName] &&`
430	`(props[propName] = childrenLength[propName]);`
431	`return ReactElement(type, key, props);`
432	`};`
433	`exports.createRef = function () {`
434	`return { current: null };`
435	`};`
436	`exports.forwardRef = function (render) {`
437	`return { $$typeof: REACT_FORWARD_REF_TYPE, render: render };`
438	`};`
439	`exports.isValidElement = isValidElement;`
440	`exports.lazy = function (ctor) {`
441	`return {`
442	`$$typeof: REACT_LAZY_TYPE,`
443	`_payload: { _status: -1, _result: ctor },`
444	`_init: lazyInitializer`
445	`};`
446	`};`
447	`exports.memo = function (type, compare) {`
448	`return {`
449	`$$typeof: REACT_MEMO_TYPE,`
450	`type: type,`
451	`compare: void 0 === compare ? null : compare`
452	`};`
453	`};`
454	`exports.startTransition = function (scope) {`
455	`var prevTransition = ReactSharedInternals.T,`
456	`currentTransition = {};`
457	`ReactSharedInternals.T = currentTransition;`
458	`try {`
459	`var returnValue = scope(),`
460	`onStartTransitionFinish = ReactSharedInternals.S;`
461	`null !== onStartTransitionFinish &&`
462	`onStartTransitionFinish(currentTransition, returnValue);`
463	`"object" === typeof returnValue &&`
464	`null !== returnValue &&`
465	`"function" === typeof returnValue.then &&`
466	`returnValue.then(noop, reportGlobalError);`
467	`} catch (error) {`
468	`reportGlobalError(error);`
469	`} finally {`
470	`null !== prevTransition &&`
471	`null !== currentTransition.types &&`
472	`(prevTransition.types = currentTransition.types),`
473	`(ReactSharedInternals.T = prevTransition);`
474	`}`
475	`};`
476	`exports.unstable_useCacheRefresh = function () {`
477	`return ReactSharedInternals.H.useCacheRefresh();`
478	`};`
479	`exports.use = function (usable) {`
480	`return ReactSharedInternals.H.use(usable);`
481	`};`
482	`exports.useActionState = function (action, initialState, permalink) {`
483	`return ReactSharedInternals.H.useActionState(action, initialState, permalink);`
484	`};`
485	`exports.useCallback = function (callback, deps) {`
486	`return ReactSharedInternals.H.useCallback(callback, deps);`
487	`};`
488	`exports.useContext = function (Context) {`
489	`return ReactSharedInternals.H.useContext(Context);`
490	`};`
491	`exports.useDebugValue = function () {};`
492	`exports.useDeferredValue = function (value, initialValue) {`
493	`return ReactSharedInternals.H.useDeferredValue(value, initialValue);`
494	`};`
495	`exports.useEffect = function (create, deps) {`
496	`return ReactSharedInternals.H.useEffect(create, deps);`
497	`};`
498	`exports.useEffectEvent = function (callback) {`
499	`return ReactSharedInternals.H.useEffectEvent(callback);`
500	`};`
501	`exports.useId = function () {`
502	`return ReactSharedInternals.H.useId();`
503	`};`
504	`exports.useImperativeHandle = function (ref, create, deps) {`
505	`return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);`
506	`};`
507	`exports.useInsertionEffect = function (create, deps) {`
508	`return ReactSharedInternals.H.useInsertionEffect(create, deps);`
509	`};`
510	`exports.useLayoutEffect = function (create, deps) {`
511	`return ReactSharedInternals.H.useLayoutEffect(create, deps);`
512	`};`
513	`exports.useMemo = function (create, deps) {`
514	`return ReactSharedInternals.H.useMemo(create, deps);`
515	`};`
516	`exports.useOptimistic = function (passthrough, reducer) {`
517	`return ReactSharedInternals.H.useOptimistic(passthrough, reducer);`
518	`};`
519	`exports.useReducer = function (reducer, initialArg, init) {`
520	`return ReactSharedInternals.H.useReducer(reducer, initialArg, init);`
521	`};`
522	`exports.useRef = function (initialValue) {`
523	`return ReactSharedInternals.H.useRef(initialValue);`
524	`};`
525	`exports.useState = function (initialState) {`
526	`return ReactSharedInternals.H.useState(initialState);`
527	`};`
528	`exports.useSyncExternalStore = function (`
529	`subscribe,`
530	`getSnapshot,`
531	`getServerSnapshot`
532	`) {`
533	`return ReactSharedInternals.H.useSyncExternalStore(`
534	`subscribe,`
535	`getSnapshot,`
536	`getServerSnapshot`
537	`);`
538	`};`
539	`exports.useTransition = function () {`
540	`return ReactSharedInternals.H.useTransition();`
541	`};`
542	`exports.version = "19.2.3";`