build(deps): add react-router-dom
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.
This commit is contained in:
Emmanuel Rizky
546
node_modules/react/cjs/react.production.js
generated
vendored
Normal file
546
node_modules/react/cjs/react.production.js
generated
vendored
Normal file
@@ -0,0 +1,546 @@
|
||||
/**
|
||||
* @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";
|
||||
Reference in New Issue
Block a user