b32cf4c374
Install react-router-dom to support client-side navigation. This is a prerequisite for implementing the multi-step authentication flow and other routed features. Additionally, this commit includes minor copy improvements to the password reset forms for better clarity.
547 lines
17 KiB
JavaScript
547 lines
17 KiB
JavaScript
/**
|
|
* @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.
|
|
*/
|
|
|
|
"use strict";
|
|
var 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"),
|
|
MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
|
|
function 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;
|
|
}
|
|
var ReactNoopUpdateQueue = {
|
|
isMounted: function () {
|
|
return !1;
|
|
},
|
|
enqueueForceUpdate: function () {},
|
|
enqueueReplaceState: function () {},
|
|
enqueueSetState: function () {}
|
|
},
|
|
assign = Object.assign,
|
|
emptyObject = {};
|
|
function Component(props, context, updater) {
|
|
this.props = props;
|
|
this.context = context;
|
|
this.refs = emptyObject;
|
|
this.updater = updater || ReactNoopUpdateQueue;
|
|
}
|
|
Component.prototype.isReactComponent = {};
|
|
Component.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");
|
|
};
|
|
Component.prototype.forceUpdate = function (callback) {
|
|
this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
|
|
};
|
|
function ComponentDummy() {}
|
|
ComponentDummy.prototype = Component.prototype;
|
|
function PureComponent(props, context, updater) {
|
|
this.props = props;
|
|
this.context = context;
|
|
this.refs = emptyObject;
|
|
this.updater = updater || ReactNoopUpdateQueue;
|
|
}
|
|
var pureComponentPrototype = (PureComponent.prototype = new ComponentDummy());
|
|
pureComponentPrototype.constructor = PureComponent;
|
|
assign(pureComponentPrototype, Component.prototype);
|
|
pureComponentPrototype.isPureReactComponent = !0;
|
|
var isArrayImpl = Array.isArray,
|
|
ReactSharedInternals = { H: null, A: null, T: null, S: null, V: null },
|
|
hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
function ReactElement(type, key, self, source, owner, props) {
|
|
self = props.ref;
|
|
return {
|
|
$$typeof: REACT_ELEMENT_TYPE,
|
|
type: type,
|
|
key: key,
|
|
ref: void 0 !== self ? self : null,
|
|
props: props
|
|
};
|
|
}
|
|
function cloneAndReplaceKey(oldElement, newKey) {
|
|
return ReactElement(
|
|
oldElement.type,
|
|
newKey,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
oldElement.props
|
|
);
|
|
}
|
|
function isValidElement(object) {
|
|
return (
|
|
"object" === typeof object &&
|
|
null !== object &&
|
|
object.$$typeof === REACT_ELEMENT_TYPE
|
|
);
|
|
}
|
|
function escape(key) {
|
|
var escaperLookup = { "=": "=0", ":": "=2" };
|
|
return (
|
|
"$" +
|
|
key.replace(/[=:]/g, function (match) {
|
|
return escaperLookup[match];
|
|
})
|
|
);
|
|
}
|
|
var userProvidedKeyEscapeRegex = /\/+/g;
|
|
function getElementKey(element, index) {
|
|
return "object" === typeof element && null !== element && null != element.key
|
|
? escape("" + element.key)
|
|
: index.toString(36);
|
|
}
|
|
function noop$1() {}
|
|
function resolveThenable(thenable) {
|
|
switch (thenable.status) {
|
|
case "fulfilled":
|
|
return thenable.value;
|
|
case "rejected":
|
|
throw thenable.reason;
|
|
default:
|
|
switch (
|
|
("string" === typeof thenable.status
|
|
? thenable.then(noop$1, noop$1)
|
|
: ((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;
|
|
}
|
|
function 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;
|
|
|
|
)
|
|
(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;
|
|
}
|
|
function 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;
|
|
}
|
|
function 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;
|
|
}
|
|
var 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);
|
|
};
|
|
function noop() {}
|
|
exports.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;
|
|
}
|
|
};
|
|
exports.Component = Component;
|
|
exports.Fragment = REACT_FRAGMENT_TYPE;
|
|
exports.Profiler = REACT_PROFILER_TYPE;
|
|
exports.PureComponent = PureComponent;
|
|
exports.StrictMode = REACT_STRICT_MODE_TYPE;
|
|
exports.Suspense = REACT_SUSPENSE_TYPE;
|
|
exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE =
|
|
ReactSharedInternals;
|
|
exports.__COMPILER_RUNTIME = {
|
|
__proto__: null,
|
|
c: function (size) {
|
|
return ReactSharedInternals.H.useMemoCache(size);
|
|
}
|
|
};
|
|
exports.cache = function (fn) {
|
|
return function () {
|
|
return fn.apply(null, arguments);
|
|
};
|
|
};
|
|
exports.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,
|
|
owner = void 0;
|
|
if (null != config)
|
|
for (propName in (void 0 !== config.ref && (owner = void 0),
|
|
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, void 0, void 0, owner, props);
|
|
};
|
|
exports.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;
|
|
};
|
|
exports.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, void 0, void 0, null, props);
|
|
};
|
|
exports.createRef = function () {
|
|
return { current: null };
|
|
};
|
|
exports.forwardRef = function (render) {
|
|
return { $$typeof: REACT_FORWARD_REF_TYPE, render: render };
|
|
};
|
|
exports.isValidElement = isValidElement;
|
|
exports.lazy = function (ctor) {
|
|
return {
|
|
$$typeof: REACT_LAZY_TYPE,
|
|
_payload: { _status: -1, _result: ctor },
|
|
_init: lazyInitializer
|
|
};
|
|
};
|
|
exports.memo = function (type, compare) {
|
|
return {
|
|
$$typeof: REACT_MEMO_TYPE,
|
|
type: type,
|
|
compare: void 0 === compare ? null : compare
|
|
};
|
|
};
|
|
exports.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 {
|
|
ReactSharedInternals.T = prevTransition;
|
|
}
|
|
};
|
|
exports.unstable_useCacheRefresh = function () {
|
|
return ReactSharedInternals.H.useCacheRefresh();
|
|
};
|
|
exports.use = function (usable) {
|
|
return ReactSharedInternals.H.use(usable);
|
|
};
|
|
exports.useActionState = function (action, initialState, permalink) {
|
|
return ReactSharedInternals.H.useActionState(action, initialState, permalink);
|
|
};
|
|
exports.useCallback = function (callback, deps) {
|
|
return ReactSharedInternals.H.useCallback(callback, deps);
|
|
};
|
|
exports.useContext = function (Context) {
|
|
return ReactSharedInternals.H.useContext(Context);
|
|
};
|
|
exports.useDebugValue = function () {};
|
|
exports.useDeferredValue = function (value, initialValue) {
|
|
return ReactSharedInternals.H.useDeferredValue(value, initialValue);
|
|
};
|
|
exports.useEffect = function (create, createDeps, update) {
|
|
var dispatcher = ReactSharedInternals.H;
|
|
if ("function" === typeof update)
|
|
throw Error(
|
|
"useEffect CRUD overload is not enabled in this build of React."
|
|
);
|
|
return dispatcher.useEffect(create, createDeps);
|
|
};
|
|
exports.useId = function () {
|
|
return ReactSharedInternals.H.useId();
|
|
};
|
|
exports.useImperativeHandle = function (ref, create, deps) {
|
|
return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
|
|
};
|
|
exports.useInsertionEffect = function (create, deps) {
|
|
return ReactSharedInternals.H.useInsertionEffect(create, deps);
|
|
};
|
|
exports.useLayoutEffect = function (create, deps) {
|
|
return ReactSharedInternals.H.useLayoutEffect(create, deps);
|
|
};
|
|
exports.useMemo = function (create, deps) {
|
|
return ReactSharedInternals.H.useMemo(create, deps);
|
|
};
|
|
exports.useOptimistic = function (passthrough, reducer) {
|
|
return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
|
|
};
|
|
exports.useReducer = function (reducer, initialArg, init) {
|
|
return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
|
|
};
|
|
exports.useRef = function (initialValue) {
|
|
return ReactSharedInternals.H.useRef(initialValue);
|
|
};
|
|
exports.useState = function (initialState) {
|
|
return ReactSharedInternals.H.useState(initialState);
|
|
};
|
|
exports.useSyncExternalStore = function (
|
|
subscribe,
|
|
getSnapshot,
|
|
getServerSnapshot
|
|
) {
|
|
return ReactSharedInternals.H.useSyncExternalStore(
|
|
subscribe,
|
|
getSnapshot,
|
|
getServerSnapshot
|
|
);
|
|
};
|
|
exports.useTransition = function () {
|
|
return ReactSharedInternals.H.useTransition();
|
|
};
|
|
exports.version = "19.1.1";
|