Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →

react-dom

Package Overview

Dependencies

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

react-dom - npm Package Compare versions

Comparing version 0.0.0-experimental-910045696-20230607 to 0.0.0-experimental-91061073-20241121

cjs/react-dom-client.development.js

cjs/react-dom-client.production.js

cjs/react-dom-profiling.development.js

cjs/react-dom-profiling.profiling.js

cjs/react-dom-server-legacy.browser.production.js

cjs/react-dom-server-legacy.node.production.js

cjs/react-dom-server.browser.production.js

cjs/react-dom-server.bun.production.js

cjs/react-dom-server.edge.production.js

cjs/react-dom-server.node.production.js

cjs/react-dom-test-utils.production.js

cjs/react-dom-unstable_testing.production.js

cjs/react-dom.production.js

cjs/react-dom.react-server.development.js

cjs/react-dom.react-server.production.js

client.react-server.js

profiling.react-server.js

react-dom.react-server.js

server.react-server.js

static.react-server.js

unstable_testing.react-server.js

1761

cjs/react-dom-test-utils.development.js

		@@ -11,1750 +11,15 @@ /**

		'use strict';

		if (process.env.NODE_ENV !== "production") {
		(function() {
		'use strict';

		var React = require('react');
		var ReactDOM = require('react-dom');

		var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;

		// by calls to these methods by a Babel plugin.
		//
		// In PROD (or in packages without access to React internals),
		// they are left as they are instead.

		function warn(format) {
		{
		{
		for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
		args[_key - 1] = arguments[_key];
		}

		printWarning('warn', format, args);
		}
		}
		}
		function error(format) {
		{
		{
		for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
		args[_key2 - 1] = arguments[_key2];
		}

		printWarning('error', format, args);
		}
		}
		}

		function printWarning(level, format, args) {
		// When changing this logic, you might want to also
		// update consoleWithStackDev.www.js as well.
		{
		var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
		var stack = ReactDebugCurrentFrame.getStackAddendum();

		if (stack !== '') {
		format += '%s';
		args = args.concat([stack]);
		} // eslint-disable-next-line react-internal/safe-string-coercion


		var argsWithFormat = args.map(function (item) {
		return String(item);
		}); // Careful: RN currently depends on this prefix

		argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
		// breaks IE9: https://github.com/facebook/react/issues/13610
		// eslint-disable-next-line react-internal/no-production-logging

		Function.prototype.apply.call(console[level], console, argsWithFormat);
		}
		}

		/**
		* `ReactInstanceMap` maintains a mapping from a public facing stateful
		* instance (key) and the internal representation (value). This allows public
		* methods to accept the user facing instance as an argument and map them back
		* to internal methods.
		*
		* Note that this module is currently shared and assumed to be stateless.
		* If this becomes an actual Map, that will break.
		*/
		function get(key) {
		return key._reactInternals;
		}

		var FunctionComponent = 0;
		var ClassComponent = 1;

		var HostRoot = 3; // Root of a host tree. Could be nested inside another node.

		var HostComponent = 5;
		var HostText = 6;
		var HostHoistable = 26;
		var HostSingleton = 27;

		var NoFlags =
		/* */
		0;
		var Placement =
		/* */
		2;
		var Hydrating =
		/* */
		4096; // You can change the rest (and add more).

		function getNearestMountedFiber(fiber) {
		var node = fiber;
		var nearestMounted = fiber;

		if (!fiber.alternate) {
		// If there is no alternate, this might be a new tree that isn't inserted
		// yet. If it is, then it will have a pending insertion effect on it.
		var nextNode = node;

		do {
		node = nextNode;

		if ((node.flags & (Placement \| Hydrating)) !== NoFlags) {
		// This is an insertion or in-progress hydration. The nearest possible
		// mounted fiber is the parent but we need to continue to figure out
		// if that one is still mounted.
		nearestMounted = node.return;
		} // $FlowFixMe[incompatible-type] we bail out when we get a null


		nextNode = node.return;
		} while (nextNode);
		} else {
		while (node.return) {
		node = node.return;
		}
		}

		if (node.tag === HostRoot) {
		// TODO: Check if this was a nested HostRoot when used with
		// renderContainerIntoSubtree.
		return nearestMounted;
		} // If we didn't hit the root, that means that we're in an disconnected tree
		// that has been unmounted.


		return null;
		}

		function assertIsMounted(fiber) {
		if (getNearestMountedFiber(fiber) !== fiber) {
		throw new Error('Unable to find node on an unmounted component.');
		}
		}

		function findCurrentFiberUsingSlowPath(fiber) {
		var alternate = fiber.alternate;

		if (!alternate) {
		// If there is no alternate, then we only need to check if it is mounted.
		var nearestMounted = getNearestMountedFiber(fiber);

		if (nearestMounted === null) {
		throw new Error('Unable to find node on an unmounted component.');
		}

		if (nearestMounted !== fiber) {
		return null;
		}

		return fiber;
		} // If we have two possible branches, we'll walk backwards up to the root
		// to see what path the root points to. On the way we may hit one of the
		// special cases and we'll deal with them.


		var a = fiber;
		var b = alternate;

		while (true) {
		var parentA = a.return;

		if (parentA === null) {
		// We're at the root.
		break;
		}

		var parentB = parentA.alternate;

		if (parentB === null) {
		// There is no alternate. This is an unusual case. Currently, it only
		// happens when a Suspense component is hidden. An extra fragment fiber
		// is inserted in between the Suspense fiber and its children. Skip
		// over this extra fragment fiber and proceed to the next parent.
		var nextParent = parentA.return;

		if (nextParent !== null) {
		a = b = nextParent;
		continue;
		} // If there's no parent, we're at the root.


		break;
		} // If both copies of the parent fiber point to the same child, we can
		// assume that the child is current. This happens when we bailout on low
		// priority: the bailed out fiber's child reuses the current child.


		if (parentA.child === parentB.child) {
		var child = parentA.child;

		while (child) {
		if (child === a) {
		// We've determined that A is the current branch.
		assertIsMounted(parentA);
		return fiber;
		}

		if (child === b) {
		// We've determined that B is the current branch.
		assertIsMounted(parentA);
		return alternate;
		}

		child = child.sibling;
		} // We should never have an alternate for any mounting node. So the only
		// way this could possibly happen is if this was unmounted, if at all.


		throw new Error('Unable to find node on an unmounted component.');
		}

		if (a.return !== b.return) {
		// The return pointer of A and the return pointer of B point to different
		// fibers. We assume that return pointers never criss-cross, so A must
		// belong to the child set of A.return, and B must belong to the child
		// set of B.return.
		a = parentA;
		b = parentB;
		} else {
		// The return pointers point to the same fiber. We'll have to use the
		// default, slow path: scan the child sets of each parent alternate to see
		// which child belongs to which set.
		//
		// Search parent A's child set
		var didFindChild = false;
		var _child = parentA.child;

		while (_child) {
		if (_child === a) {
		didFindChild = true;
		a = parentA;
		b = parentB;
		break;
		}

		if (_child === b) {
		didFindChild = true;
		b = parentA;
		a = parentB;
		break;
		}

		_child = _child.sibling;
		}

		if (!didFindChild) {
		// Search parent B's child set
		_child = parentB.child;

		while (_child) {
		if (_child === a) {
		didFindChild = true;
		a = parentB;
		b = parentA;
		break;
		}

		if (_child === b) {
		didFindChild = true;
		b = parentB;
		a = parentA;
		break;
		}

		_child = _child.sibling;
		}

		if (!didFindChild) {
		throw new Error('Child was not found in either parent set. This indicates a bug ' + 'in React related to the return pointer. Please file an issue.');
		}
		}
		}

		if (a.alternate !== b) {
		throw new Error("Return fibers should always be each others' alternates. " + 'This error is likely caused by a bug in React. Please file an issue.');
		}
		} // If the root is not a host container, we're in a disconnected tree. I.e.
		// unmounted.


		if (a.tag !== HostRoot) {
		throw new Error('Unable to find node on an unmounted component.');
		}

		if (a.stateNode.current === a) {
		// We've determined that A is the current branch.
		return fiber;
		} // Otherwise B has to be current branch.


		return alternate;
		}

		var assign = Object.assign;

		/**
		* `charCode` represents the actual "character code" and is safe to use with
		* `String.fromCharCode`. As such, only keys that correspond to printable
		* characters produce a valid `charCode`, the only exception to this is Enter.
		* The Tab-key is considered non-printable and does not have a `charCode`,
		* presumably because it does not produce a tab-character in browsers.
		*
		* @param {object} nativeEvent Native browser event.
		* @return {number} Normalized `charCode` property.
		*/
		function getEventCharCode(nativeEvent) {
		var charCode;
		var keyCode = nativeEvent.keyCode;

		if ('charCode' in nativeEvent) {
		charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.

		if (charCode === 0 && keyCode === 13) {
		charCode = 13;
		}
		} else {
		// IE8 does not implement `charCode`, but `keyCode` has the correct value.
		charCode = keyCode;
		} // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
		// report Enter as charCode 10 when ctrl is pressed.


		if (charCode === 10) {
		charCode = 13;
		} // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
		// Must not discard the (non-)printable Enter-key.


		if (charCode >= 32 \|\| charCode === 13) {
		return charCode;
		}

		return 0;
		}

		function functionThatReturnsTrue() {
		return true;
		}

		function functionThatReturnsFalse() {
		return false;
		} // This is intentionally a factory so that we have different returned constructors.
		// If we had a single constructor, it would be megamorphic and engines would deopt.


		function createSyntheticEvent(Interface) {
		/**
		* Synthetic events are dispatched by event plugins, typically in response to a
		* top-level event delegation handler.
		*
		* These systems should generally use pooling to reduce the frequency of garbage
		* collection. The system should check `isPersistent` to determine whether the
		* event should be released into the pool after being dispatched. Users that
		* need a persisted event should invoke `persist`.
		*
		* Synthetic events (and subclasses) implement the DOM Level 3 Events API by
		* normalizing browser quirks. Subclasses do not necessarily have to implement a
		* DOM interface; custom application-specific events can also subclass this.
		*/
		// $FlowFixMe[missing-this-annot]
		function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
		this._reactName = reactName;
		this._targetInst = targetInst;
		this.type = reactEventType;
		this.nativeEvent = nativeEvent;
		this.target = nativeEventTarget;
		this.currentTarget = null;

		for (var propName in Interface) {
		if (!Interface.hasOwnProperty(propName)) {
		continue;
		}

		var normalize = Interface[propName];

		if (normalize) {
		this[propName] = normalize(nativeEvent);
		} else {
		this[propName] = nativeEvent[propName];
		}
		}

		var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;

		if (defaultPrevented) {
		this.isDefaultPrevented = functionThatReturnsTrue;
		} else {
		this.isDefaultPrevented = functionThatReturnsFalse;
		}

		this.isPropagationStopped = functionThatReturnsFalse;
		return this;
		} // $FlowFixMe[prop-missing] found when upgrading Flow


		assign(SyntheticBaseEvent.prototype, {
		// $FlowFixMe[missing-this-annot]
		preventDefault: function () {
		this.defaultPrevented = true;
		var event = this.nativeEvent;

		if (!event) {
		return;
		}

		if (event.preventDefault) {
		event.preventDefault(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
		} else if (typeof event.returnValue !== 'unknown') {
		event.returnValue = false;
		}

		this.isDefaultPrevented = functionThatReturnsTrue;
		},
		// $FlowFixMe[missing-this-annot]
		stopPropagation: function () {
		var event = this.nativeEvent;

		if (!event) {
		return;
		}

		if (event.stopPropagation) {
		event.stopPropagation(); // $FlowFixMe[illegal-typeof] - flow is not aware of `unknown` in IE
		} else if (typeof event.cancelBubble !== 'unknown') {
		// The ChangeEventPlugin registers a "propertychange" event for
		// IE. This event does not support bubbling or cancelling, and
		// any references to cancelBubble throw "Member not found". A
		// typeof check of "unknown" circumvents this issue (and is also
		// IE specific).
		event.cancelBubble = true;
		}

		this.isPropagationStopped = functionThatReturnsTrue;
		},

		/**
		* We release all dispatched `SyntheticEvent`s after each event loop, adding
		* them back into the pool. This allows a way to hold onto a reference that
		* won't be added back into the pool.
		*/
		persist: function () {// Modern event system doesn't use pooling.
		},

		/**
		* Checks if this event should be released back into the pool.
		*
		* @return {boolean} True if this should not be released, false otherwise.
		*/
		isPersistent: functionThatReturnsTrue
		});
		return SyntheticBaseEvent;
		}
		/**
		* @interface Event
		* @see http://www.w3.org/TR/DOM-Level-3-Events/
		*/


		var EventInterface = {
		eventPhase: 0,
		bubbles: 0,
		cancelable: 0,
		timeStamp: function (event) {
		return event.timeStamp \|\| Date.now();
		},
		defaultPrevented: 0,
		isTrusted: 0
		};
		var SyntheticEvent = createSyntheticEvent(EventInterface);

		var UIEventInterface = assign({}, EventInterface, {
		view: 0,
		detail: 0
		});

		createSyntheticEvent(UIEventInterface);
		var lastMovementX;
		var lastMovementY;
		var lastMouseEvent;

		function updateMouseMovementPolyfillState(event) {
		if (event !== lastMouseEvent) {
		if (lastMouseEvent && event.type === 'mousemove') {
		// $FlowFixMe[unsafe-arithmetic] assuming this is a number
		lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe[unsafe-arithmetic] assuming this is a number

		lastMovementY = event.screenY - lastMouseEvent.screenY;
		} else {
		lastMovementX = 0;
		lastMovementY = 0;
		}

		lastMouseEvent = event;
		}
		}
		/**
		* @interface MouseEvent
		* @see http://www.w3.org/TR/DOM-Level-3-Events/
		*/


		var MouseEventInterface = assign({}, UIEventInterface, {
		screenX: 0,
		screenY: 0,
		clientX: 0,
		clientY: 0,
		pageX: 0,
		pageY: 0,
		ctrlKey: 0,
		shiftKey: 0,
		altKey: 0,
		metaKey: 0,
		getModifierState: getEventModifierState,
		button: 0,
		buttons: 0,
		relatedTarget: function (event) {
		if (event.relatedTarget === undefined) return event.fromElement === event.srcElement ? event.toElement : event.fromElement;
		return event.relatedTarget;
		},
		movementX: function (event) {
		if ('movementX' in event) {
		return event.movementX;
		}

		updateMouseMovementPolyfillState(event);
		return lastMovementX;
		},
		movementY: function (event) {
		if ('movementY' in event) {
		return event.movementY;
		} // Don't need to call updateMouseMovementPolyfillState() here
		// because it's guaranteed to have already run when movementX
		// was copied.


		return lastMovementY;
		}
		});

		createSyntheticEvent(MouseEventInterface);
		/**
		* @interface DragEvent
		* @see http://www.w3.org/TR/DOM-Level-3-Events/
		*/

		var DragEventInterface = assign({}, MouseEventInterface, {
		dataTransfer: 0
		});

		createSyntheticEvent(DragEventInterface);
		/**
		* @interface FocusEvent
		* @see http://www.w3.org/TR/DOM-Level-3-Events/
		*/

		var FocusEventInterface = assign({}, UIEventInterface, {
		relatedTarget: 0
		});

		createSyntheticEvent(FocusEventInterface);
		/**
		* @interface Event
		* @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
		* @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
		*/

		var AnimationEventInterface = assign({}, EventInterface, {
		animationName: 0,
		elapsedTime: 0,
		pseudoElement: 0
		});

		createSyntheticEvent(AnimationEventInterface);
		/**
		* @interface Event
		* @see http://www.w3.org/TR/clipboard-apis/
		*/

		var ClipboardEventInterface = assign({}, EventInterface, {
		clipboardData: function (event) {
		return 'clipboardData' in event ? event.clipboardData : window.clipboardData;
		}
		});

		createSyntheticEvent(ClipboardEventInterface);
		/**
		* @interface Event
		* @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
		*/

		var CompositionEventInterface = assign({}, EventInterface, {
		data: 0
		});

		createSyntheticEvent(CompositionEventInterface);
		/**
		* Normalization of deprecated HTML5 `key` values
		* @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
		*/

		var normalizeKey = {
		Esc: 'Escape',
		Spacebar: ' ',
		Left: 'ArrowLeft',
		Up: 'ArrowUp',
		Right: 'ArrowRight',
		Down: 'ArrowDown',
		Del: 'Delete',
		Win: 'OS',
		Menu: 'ContextMenu',
		Apps: 'ContextMenu',
		Scroll: 'ScrollLock',
		MozPrintableKey: 'Unidentified'
		};
		/**
		* Translation from legacy `keyCode` to HTML5 `key`
		* Only special keys supported, all others depend on keyboard layout or browser
		* @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
		*/

		var translateToKey = {
		'8': 'Backspace',
		'9': 'Tab',
		'12': 'Clear',
		'13': 'Enter',
		'16': 'Shift',
		'17': 'Control',
		'18': 'Alt',
		'19': 'Pause',
		'20': 'CapsLock',
		'27': 'Escape',
		'32': ' ',
		'33': 'PageUp',
		'34': 'PageDown',
		'35': 'End',
		'36': 'Home',
		'37': 'ArrowLeft',
		'38': 'ArrowUp',
		'39': 'ArrowRight',
		'40': 'ArrowDown',
		'45': 'Insert',
		'46': 'Delete',
		'112': 'F1',
		'113': 'F2',
		'114': 'F3',
		'115': 'F4',
		'116': 'F5',
		'117': 'F6',
		'118': 'F7',
		'119': 'F8',
		'120': 'F9',
		'121': 'F10',
		'122': 'F11',
		'123': 'F12',
		'144': 'NumLock',
		'145': 'ScrollLock',
		'224': 'Meta'
		};
		/**
		* @param {object} nativeEvent Native browser event.
		* @return {string} Normalized `key` property.
		*/

		function getEventKey(nativeEvent) {
		if (nativeEvent.key) {
		// Normalize inconsistent values reported by browsers due to
		// implementations of a working draft specification.
		// FireFox implements `key` but returns `MozPrintableKey` for all
		// printable characters (normalized to `Unidentified`), ignore it.
		var key = // $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
		normalizeKey[nativeEvent.key] \|\| nativeEvent.key;

		if (key !== 'Unidentified') {
		return key;
		}
		} // Browser does not implement `key`, polyfill as much of it as we can.


		if (nativeEvent.type === 'keypress') {
		var charCode = getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
		nativeEvent); // The enter-key is technically both printable and non-printable and can
		// thus be captured by `keypress`, no other non-printable key should.

		return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);
		}

		if (nativeEvent.type === 'keydown' \|\| nativeEvent.type === 'keyup') {
		// While user keyboard layout determines the actual meaning of each
		// `keyCode` value, almost all function keys have a universal value.
		// $FlowFixMe[invalid-computed-prop] unable to index with a `mixed` value
		return translateToKey[nativeEvent.keyCode] \|\| 'Unidentified';
		}

		return '';
		}
		/**
		* Translation from modifier key to the associated property in the event.
		* @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
		*/


		var modifierKeyToProp = {
		Alt: 'altKey',
		Control: 'ctrlKey',
		Meta: 'metaKey',
		Shift: 'shiftKey'
		}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
		// getModifierState. If getModifierState is not supported, we map it to a set of
		// modifier keys exposed by the event. In this case, Lock-keys are not supported.
		// $FlowFixMe[missing-local-annot]
		// $FlowFixMe[missing-this-annot]

		function modifierStateGetter(keyArg) {
		var syntheticEvent = this;
		var nativeEvent = syntheticEvent.nativeEvent;

		if (nativeEvent.getModifierState) {
		return nativeEvent.getModifierState(keyArg);
		}

		var keyProp = modifierKeyToProp[keyArg];
		return keyProp ? !!nativeEvent[keyProp] : false;
		}

		function getEventModifierState(nativeEvent) {
		return modifierStateGetter;
		}
		/**
		* @interface KeyboardEvent
		* @see http://www.w3.org/TR/DOM-Level-3-Events/
		*/


		var KeyboardEventInterface = assign({}, UIEventInterface, {
		key: getEventKey,
		code: 0,
		location: 0,
		ctrlKey: 0,
		shiftKey: 0,
		altKey: 0,
		metaKey: 0,
		repeat: 0,
		locale: 0,
		getModifierState: getEventModifierState,
		// Legacy Interface
		charCode: function (event) {
		// `charCode` is the result of a KeyPress event and represents the value of
		// the actual printable character.
		// KeyPress is deprecated, but its replacement is not yet final and not
		// implemented in any major browser. Only KeyPress has charCode.
		if (event.type === 'keypress') {
		return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
		event);
		}

		return 0;
		},
		keyCode: function (event) {
		// `keyCode` is the result of a KeyDown/Up event and represents the value of
		// physical keyboard key.
		// The actual meaning of the value depends on the users' keyboard layout
		// which cannot be detected. Assuming that it is a US keyboard layout
		// provides a surprisingly accurate mapping for US and European users.
		// Due to this, it is left to the user to implement at this time.
		if (event.type === 'keydown' \|\| event.type === 'keyup') {
		return event.keyCode;
		}

		return 0;
		},
		which: function (event) {
		// `which` is an alias for either `keyCode` or `charCode` depending on the
		// type of the event.
		if (event.type === 'keypress') {
		return getEventCharCode( // $FlowFixMe[incompatible-call] unable to narrow to `KeyboardEvent`
		event);
		}

		if (event.type === 'keydown' \|\| event.type === 'keyup') {
		return event.keyCode;
		}

		return 0;
		}
		});

		createSyntheticEvent(KeyboardEventInterface);
		/**
		* @interface PointerEvent
		* @see http://www.w3.org/TR/pointerevents/
		*/

		var PointerEventInterface = assign({}, MouseEventInterface, {
		pointerId: 0,
		width: 0,
		height: 0,
		pressure: 0,
		tangentialPressure: 0,
		tiltX: 0,
		tiltY: 0,
		twist: 0,
		pointerType: 0,
		isPrimary: 0
		});

		createSyntheticEvent(PointerEventInterface);
		/**
		* @interface TouchEvent
		* @see http://www.w3.org/TR/touch-events/
		*/

		var TouchEventInterface = assign({}, UIEventInterface, {
		touches: 0,
		targetTouches: 0,
		changedTouches: 0,
		altKey: 0,
		metaKey: 0,
		ctrlKey: 0,
		shiftKey: 0,
		getModifierState: getEventModifierState
		});

		createSyntheticEvent(TouchEventInterface);
		/**
		* @interface Event
		* @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
		* @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
		*/

		var TransitionEventInterface = assign({}, EventInterface, {
		propertyName: 0,
		elapsedTime: 0,
		pseudoElement: 0
		});

		createSyntheticEvent(TransitionEventInterface);
		/**
		* @interface WheelEvent
		* @see http://www.w3.org/TR/DOM-Level-3-Events/
		*/

		var WheelEventInterface = assign({}, MouseEventInterface, {
		deltaX: function (event) {
		return 'deltaX' in event ? event.deltaX : // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
		'wheelDeltaX' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
		-event.wheelDeltaX : 0;
		},
		deltaY: function (event) {
		return 'deltaY' in event ? event.deltaY : // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
		'wheelDeltaY' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
		-event.wheelDeltaY : // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
		'wheelDelta' in event ? // $FlowFixMe[unsafe-arithmetic] assuming this is a number
		-event.wheelDelta : 0;
		},
		deltaZ: 0,
		// Browsers without "deltaMode" is reporting in raw wheel delta where one
		// notch on the scroll is always +/- 120, roughly equivalent to pixels.
		// A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
		// ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
		deltaMode: 0
		});

		createSyntheticEvent(WheelEventInterface);

		/**
		* HTML nodeType values that represent the type of the node
		*/
		var ELEMENT_NODE = 1;

		var fakeNode = null;

		{
		if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function' && typeof document !== 'undefined' && // $FlowFixMe[method-unbinding]
		typeof document.createEvent === 'function') {
		fakeNode = document.createElement('react');
		}
		}

		function invokeGuardedCallbackImpl(name, func, context) {
		{
		// In DEV mode, we use a special version
		// that plays more nicely with the browser's DevTools. The idea is to preserve
		// "Pause on exceptions" behavior. Because React wraps all user-provided
		// functions in invokeGuardedCallback, and the production version of
		// invokeGuardedCallback uses a try-catch, all user exceptions are treated
		// like caught exceptions, and the DevTools won't pause unless the developer
		// takes the extra step of enabling pause on caught exceptions. This is
		// unintuitive, though, because even though React has caught the error, from
		// the developer's perspective, the error is uncaught.
		//
		// To preserve the expected "Pause on exceptions" behavior, we don't use a
		// try-catch in DEV. Instead, we synchronously dispatch a fake event to a fake
		// DOM node, and call the user-provided callback from inside an event handler
		// for that fake event. If the callback throws, the error is "captured" using
		// event loop context, it does not interrupt the normal program flow.
		// Effectively, this gives us try-catch behavior without actually using
		// try-catch. Neat!
		// fakeNode signifies we are in an environment with a document and window object
		if (fakeNode) {
		var evt = document.createEvent('Event');
		var didCall = false; // Keeps track of whether the user-provided callback threw an error. We
		// set this to true at the beginning, then set it to false right after
		// calling the function. If the function errors, `didError` will never be
		// set to false. This strategy works even if the browser is flaky and
		// fails to call our global error handler, because it doesn't rely on
		// the error event at all.

		var didError = true; // Keeps track of the value of window.event so that we can reset it
		// during the callback to let user code access window.event in the
		// browsers that support it.

		var windowEvent = window.event; // Keeps track of the descriptor of window.event to restore it after event
		// dispatching: https://github.com/facebook/react/issues/13688

		var windowEventDescriptor = Object.getOwnPropertyDescriptor(window, 'event');

		var restoreAfterDispatch = function () {
		// We immediately remove the callback from event listeners so that
		// nested `invokeGuardedCallback` calls do not clash. Otherwise, a
		// nested call would trigger the fake event handlers of any call higher
		// in the stack.
		fakeNode.removeEventListener(evtType, callCallback, false); // We check for window.hasOwnProperty('event') to prevent the
		// window.event assignment in both IE <= 10 as they throw an error
		// "Member not found" in strict mode, and in Firefox which does not
		// support window.event.

		if (typeof window.event !== 'undefined' && window.hasOwnProperty('event')) {
		window.event = windowEvent;
		}
		}; // Create an event handler for our fake event. We will synchronously
		// dispatch our fake event using `dispatchEvent`. Inside the handler, we
		// call the user-provided callback.
		// $FlowFixMe[method-unbinding]


		var _funcArgs = Array.prototype.slice.call(arguments, 3);

		var callCallback = function () {
		didCall = true;
		restoreAfterDispatch(); // $FlowFixMe[incompatible-call] Flow doesn't understand the arguments splicing.

		func.apply(context, _funcArgs);
		didError = false;
		}; // Create a global error event handler. We use this to capture the value
		// that was thrown. It's possible that this error handler will fire more
		// than once; for example, if non-React code also calls `dispatchEvent`
		// and a handler for that event throws. We should be resilient to most of
		// those cases. Even if our error event handler fires more than once, the
		// last error event is always used. If the callback actually does error,
		// we know that the last error event is the correct one, because it's not
		// possible for anything else to have happened in between our callback
		// erroring and the code that follows the `dispatchEvent` call below. If
		// the callback doesn't error, but the error event was fired, we know to
		// ignore it because `didError` will be false, as described above.


		var error; // Use this to track whether the error event is ever called.

		var didSetError = false;
		var isCrossOriginError = false;

		var handleWindowError = function (event) {
		error = event.error;
		didSetError = true;

		if (error === null && event.colno === 0 && event.lineno === 0) {
		isCrossOriginError = true;
		}

		if (event.defaultPrevented) {
		// Some other error handler has prevented default.
		// Browsers silence the error report if this happens.
		// We'll remember this to later decide whether to log it or not.
		if (error != null && typeof error === 'object') {
		try {
		error._suppressLogging = true;
		} catch (inner) {// Ignore.
		}
		}
		}
		}; // Create a fake event type.


		var evtType = "react-" + (name ? name : 'invokeguardedcallback'); // Attach our event handlers

		window.addEventListener('error', handleWindowError);
		fakeNode.addEventListener(evtType, callCallback, false); // Synchronously dispatch our fake event. If the user-provided function
		// errors, it will trigger our global error handler.

		evt.initEvent(evtType, false, false);
		fakeNode.dispatchEvent(evt);

		if (windowEventDescriptor) {
		Object.defineProperty(window, 'event', windowEventDescriptor);
		}

		if (didCall && didError) {
		if (!didSetError) {
		// The callback errored, but the error event never fired.
		// eslint-disable-next-line react-internal/prod-error-codes
		error = new Error('An error was thrown inside one of your components, but React ' + "doesn't know what it was. This is likely due to browser " + 'flakiness. React does its best to preserve the "Pause on ' + 'exceptions" behavior of the DevTools, which requires some ' + "DEV-mode only tricks. It's possible that these don't work in " + 'your browser. Try triggering the error in production mode, ' + 'or switching to a modern browser. If you suspect that this is ' + 'actually an issue with React, please file an issue.');
		} else if (isCrossOriginError) {
		// eslint-disable-next-line react-internal/prod-error-codes
		error = new Error("A cross-origin error was thrown. React doesn't have access to " + 'the actual error object in development. ' + 'See https://reactjs.org/link/crossorigin-error for more information.');
		}

		this.onError(error);
		} // Remove our event listeners


		window.removeEventListener('error', handleWindowError);

		if (didCall) {
		return;
		} else {
		// Something went really wrong, and our event was not dispatched.
		// https://github.com/facebook/react/issues/16734
		// https://github.com/facebook/react/issues/16585
		// Fall back to the production implementation.
		restoreAfterDispatch(); // we fall through and call the prod version instead
		}
		} // We only get here if we are in an environment that either does not support the browser
		// variant or we had trouble getting the browser to emit the error.
		// $FlowFixMe[method-unbinding]


		var funcArgs = Array.prototype.slice.call(arguments, 3);

		try {
		// $FlowFixMe[incompatible-call] Flow doesn't understand the arguments splicing.
		func.apply(context, funcArgs);
		} catch (error) {
		this.onError(error);
		}
		}
		}

		var hasError = false;
		var caughtError = null; // Used by event system to capture/rethrow the first error.

		var hasRethrowError = false;
		var rethrowError = null;
		var reporter = {
		onError: function (error) {
		hasError = true;
		caughtError = error;
		}
		};
		/**
		* Call a function while guarding against errors that happens within it.
		* Returns an error if it throws, otherwise null.
		*
		* In production, this is implemented using a try-catch. The reason we don't
		* use a try-catch directly is so that we can swap out a different
		* implementation in DEV mode.
		*
		* @param {String} name of the guard to use for logging or debugging
		* @param {Function} func The function to invoke
		* @param {*} context The context to use when calling the function
		* @param {...*} args Arguments for function
		*/

		function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
		hasError = false;
		caughtError = null;
		invokeGuardedCallbackImpl.apply(reporter, arguments);
		}
		/**
		* Same as invokeGuardedCallback, but instead of returning an error, it stores
		* it in a global so it can be rethrown by `rethrowCaughtError` later.
		* TODO: See if caughtError and rethrowError can be unified.
		*
		* @param {String} name of the guard to use for logging or debugging
		* @param {Function} func The function to invoke
		* @param {*} context The context to use when calling the function
		* @param {...*} args Arguments for function
		*/

		function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
		invokeGuardedCallback.apply(this, arguments);

		if (hasError) {
		var error = clearCaughtError();

		if (!hasRethrowError) {
		hasRethrowError = true;
		rethrowError = error;
		}
		}
		}
		/**
		* During execution of guarded functions we will capture the first error which
		* we will rethrow to be handled by the top level error handler.
		*/

		function rethrowCaughtError() {
		if (hasRethrowError) {
		var error = rethrowError;
		hasRethrowError = false;
		rethrowError = null;
		throw error;
		}
		}
		function clearCaughtError() {
		if (hasError) {
		var error = caughtError;
		hasError = false;
		caughtError = null;
		return error;
		} else {
		throw new Error('clearCaughtError was called but no error was captured. This error ' + 'is likely caused by a bug in React. Please file an issue.');
		}
		}

		var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare

		function isArray(a) {
		return isArrayImpl(a);
		}

		var SecretInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
		var EventInternals = SecretInternals.Events;
		var getInstanceFromNode = EventInternals[0];
		var getNodeFromInstance = EventInternals[1];
		var getFiberCurrentPropsFromNode = EventInternals[2];
		var enqueueStateRestore = EventInternals[3];
		var restoreStateIfNeeded = EventInternals[4];
		var act = React.unstable_act;

		function Event(suffix) {}

		var hasWarnedAboutDeprecatedMockComponent = false;
		/**
		* @class ReactTestUtils
		*/

		function findAllInRenderedFiberTreeInternal(fiber, test) {
		if (!fiber) {
		return [];
		}

		var currentParent = findCurrentFiberUsingSlowPath(fiber);

		if (!currentParent) {
		return [];
		}

		var node = currentParent;
		var ret = [];

		while (true) {
		if (node.tag === HostComponent \|\| node.tag === HostText \|\| node.tag === ClassComponent \|\| node.tag === FunctionComponent \|\| (node.tag === HostHoistable ) \|\| (node.tag === HostSingleton )) {
		var publicInst = node.stateNode;

		if (test(publicInst)) {
		ret.push(publicInst);
		}
		}

		if (node.child) {
		node.child.return = node;
		node = node.child;
		continue;
		}

		if (node === currentParent) {
		return ret;
		}

		while (!node.sibling) {
		if (!node.return \|\| node.return === currentParent) {
		return ret;
		}

		node = node.return;
		}

		node.sibling.return = node.return;
		node = node.sibling;
		}
		}

		function validateClassInstance(inst, methodName) {
		if (!inst) {
		// This is probably too relaxed but it's existing behavior.
		return;
		}

		if (get(inst)) {
		// This is a public instance indeed.
		return;
		}

		var received;
		var stringified = String(inst);

		if (isArray(inst)) {
		received = 'an array';
		} else if (inst && inst.nodeType === ELEMENT_NODE && inst.tagName) {
		received = 'a DOM node';
		} else if (stringified === '[object Object]') {
		received = 'object with keys {' + Object.keys(inst).join(', ') + '}';
		} else {
		received = stringified;
		}

		throw new Error(methodName + "(...): the first argument must be a React class instance. " + ("Instead received: " + received + "."));
		}
		/**
		* Utilities for making it easy to test React components.
		*
		* See https://reactjs.org/docs/test-utils.html
		*
		* Todo: Support the entire DOM.scry query syntax. For now, these simple
		* utilities will suffice for testing purposes.
		* @lends ReactTestUtils
		*/


		function renderIntoDocument(element) {
		var div = document.createElement('div'); // None of our tests actually require attaching the container to the
		// DOM, and doing so creates a mess that we rely on test isolation to
		// clean up, so we're going to stop honoring the name of this method
		// (and probably rename it eventually) if no problems arise.
		// document.documentElement.appendChild(div);

		return ReactDOM.render(element, div);
		}

		function isElement(element) {
		return React.isValidElement(element);
		}

		function isElementOfType(inst, convenienceConstructor) {
		return React.isValidElement(inst) && inst.type === convenienceConstructor;
		}

		function isDOMComponent(inst) {
		return !!(inst && inst.nodeType === ELEMENT_NODE && inst.tagName);
		}

		function isDOMComponentElement(inst) {
		return !!(inst && React.isValidElement(inst) && !!inst.tagName);
		}

		function isCompositeComponent(inst) {
		if (isDOMComponent(inst)) {
		// Accessing inst.setState warns; just return false as that'll be what
		// this returns when we have DOM nodes as refs directly
		return false;
		}

		return inst != null && typeof inst.render === 'function' && typeof inst.setState === 'function';
		}

		function isCompositeComponentWithType(inst, type) {
		if (!isCompositeComponent(inst)) {
		return false;
		}

		var internalInstance = get(inst);
		var constructor = internalInstance.type;
		return constructor === type;
		}

		function findAllInRenderedTree(inst, test) {
		validateClassInstance(inst, 'findAllInRenderedTree');

		if (!inst) {
		return [];
		}

		var internalInstance = get(inst);
		return findAllInRenderedFiberTreeInternal(internalInstance, test);
		}
		/**
		* Finds all instances of components in the rendered tree that are DOM
		* components with the class name matching `className`.
		* @return {array} an array of all the matches.
		*/


		function scryRenderedDOMComponentsWithClass(root, classNames) {
		validateClassInstance(root, 'scryRenderedDOMComponentsWithClass');
		return findAllInRenderedTree(root, function (inst) {
		if (isDOMComponent(inst)) {
		var className = inst.className;

		if (typeof className !== 'string') {
		// SVG, probably.
		className = inst.getAttribute('class') \|\| '';
		}

		var classList = className.split(/\s+/);

		if (!isArray(classNames)) {
		if (classNames === undefined) {
		throw new Error('TestUtils.scryRenderedDOMComponentsWithClass expects a ' + 'className as a second argument.');
		}

		classNames = classNames.split(/\s+/);
		}

		return classNames.every(function (name) {
		return classList.indexOf(name) !== -1;
		});
		}

		return false;
		});
		}
		/**
		* Like scryRenderedDOMComponentsWithClass but expects there to be one result,
		* and returns that one result, or throws exception if there is any other
		* number of matches besides one.
		* @return {!ReactDOMComponent} The one match.
		*/


		function findRenderedDOMComponentWithClass(root, className) {
		validateClassInstance(root, 'findRenderedDOMComponentWithClass');
		var all = scryRenderedDOMComponentsWithClass(root, className);

		if (all.length !== 1) {
		throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for class:' + className);
		}

		return all[0];
		}
		/**
		* Finds all instances of components in the rendered tree that are DOM
		* components with the tag name matching `tagName`.
		* @return {array} an array of all the matches.
		*/


		function scryRenderedDOMComponentsWithTag(root, tagName) {
		validateClassInstance(root, 'scryRenderedDOMComponentsWithTag');
		return findAllInRenderedTree(root, function (inst) {
		return isDOMComponent(inst) && inst.tagName.toUpperCase() === tagName.toUpperCase();
		});
		}
		/**
		* Like scryRenderedDOMComponentsWithTag but expects there to be one result,
		* and returns that one result, or throws exception if there is any other
		* number of matches besides one.
		* @return {!ReactDOMComponent} The one match.
		*/


		function findRenderedDOMComponentWithTag(root, tagName) {
		validateClassInstance(root, 'findRenderedDOMComponentWithTag');
		var all = scryRenderedDOMComponentsWithTag(root, tagName);

		if (all.length !== 1) {
		throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for tag:' + tagName);
		}

		return all[0];
		}
		/**
		* Finds all instances of components with type equal to `componentType`.
		* @return {array} an array of all the matches.
		*/


		function scryRenderedComponentsWithType(root, componentType) {
		validateClassInstance(root, 'scryRenderedComponentsWithType');
		return findAllInRenderedTree(root, function (inst) {
		return isCompositeComponentWithType(inst, componentType);
		});
		}
		/**
		* Same as `scryRenderedComponentsWithType` but expects there to be one result
		* and returns that one result, or throws exception if there is any other
		* number of matches besides one.
		* @return {!ReactComponent} The one match.
		*/


		function findRenderedComponentWithType(root, componentType) {
		validateClassInstance(root, 'findRenderedComponentWithType');
		var all = scryRenderedComponentsWithType(root, componentType);

		if (all.length !== 1) {
		throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for componentType:' + componentType);
		}

		return all[0];
		}
		/**
		* Pass a mocked component module to this method to augment it with
		* useful methods that allow it to be used as a dummy React component.
		* Instead of rendering as usual, the component will become a simple
		* <div> containing any provided children.
		*
		* @param {object} module the mock function object exported from a
		* module that defines the component to be mocked
		* @param {?string} mockTagName optional dummy root tag name to return
		* from render method (overrides
		* module.mockTagName if provided)
		* @return {object} the ReactTestUtils object (for chaining)
		*/


		function mockComponent(module, mockTagName) {
		{
		if (!hasWarnedAboutDeprecatedMockComponent) {
		hasWarnedAboutDeprecatedMockComponent = true;

		warn('ReactTestUtils.mockComponent() is deprecated. ' + 'Use shallow rendering or jest.mock() instead.\n\n' + 'See https://reactjs.org/link/test-utils-mock-component for more information.');
		}
		}

		mockTagName = mockTagName \|\| module.mockTagName \|\| 'div';
		module.prototype.render.mockImplementation(function () {
		return React.createElement(mockTagName, null, this.props.children);
		});
		return this;
		}

		function nativeTouchData(x, y) {
		return {
		touches: [{
		pageX: x,
		pageY: y
		}]
		};
		} // Start of inline: the below functions were inlined from
		// EventPropagator.js, as they deviated from ReactDOM's newer
		// implementations.

		/**
		* Dispatch the event to the listener.
		* @param {SyntheticEvent} event SyntheticEvent to handle
		* @param {function} listener Application-level callback
		* @param {*} inst Internal component instance
		*/


		function executeDispatch(event, listener, inst) {
		var type = event.type \|\| 'unknown-event';
		event.currentTarget = getNodeFromInstance(inst);
		invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
		event.currentTarget = null;
		}
		/**
		* Standard/simple iteration through an event's collected dispatches.
		*/


		function executeDispatchesInOrder(event) {
		var dispatchListeners = event._dispatchListeners;
		var dispatchInstances = event._dispatchInstances;

		if (isArray(dispatchListeners)) {
		for (var i = 0; i < dispatchListeners.length; i++) {
		if (event.isPropagationStopped()) {
		break;
		} // Listeners and Instances are two parallel arrays that are always in sync.


		executeDispatch(event, dispatchListeners[i], dispatchInstances[i]);
		}
		} else if (dispatchListeners) {
		executeDispatch(event, dispatchListeners, dispatchInstances);
		}

		event._dispatchListeners = null;
		event._dispatchInstances = null;
		}
		/**
		* Dispatches an event and releases it back into the pool, unless persistent.
		*
		* @param {?object} event Synthetic event to be dispatched.
		* @private
		*/


		function executeDispatchesAndRelease(event
		/* ReactSyntheticEvent */
		) {
		if (event) {
		executeDispatchesInOrder(event);

		if (!event.isPersistent()) {
		event.constructor.release(event);
		}
		}
		}

		function isInteractive(tag) {
		return tag === 'button' \|\| tag === 'input' \|\| tag === 'select' \|\| tag === 'textarea';
		}

		function getParent(inst) {
		do {
		inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
		// That is depending on if we want nested subtrees (layers) to bubble
		// events to their parent. We could also go through parentNode on the
		// host node but that wouldn't work for React Native and doesn't let us
		// do the portal feature.
		} while (inst && inst.tag !== HostComponent && (inst.tag !== HostSingleton));

		if (inst) {
		return inst;
		}

		return null;
		}
		/**
		* Simulates the traversal of a two-phase, capture/bubble event dispatch.
		*/


		function traverseTwoPhase(inst, fn, arg) {
		var path = [];

		while (inst) {
		path.push(inst);
		inst = getParent(inst);
		}

		var i;

		for (i = path.length; i-- > 0;) {
		fn(path[i], 'captured', arg);
		}

		for (i = 0; i < path.length; i++) {
		fn(path[i], 'bubbled', arg);
		}
		}

		function shouldPreventMouseEvent(name, type, props) {
		switch (name) {
		case 'onClick':
		case 'onClickCapture':
		case 'onDoubleClick':
		case 'onDoubleClickCapture':
		case 'onMouseDown':
		case 'onMouseDownCapture':
		case 'onMouseMove':
		case 'onMouseMoveCapture':
		case 'onMouseUp':
		case 'onMouseUpCapture':
		case 'onMouseEnter':
		return !!(props.disabled && isInteractive(type));

		default:
		return false;
		}
		}
		/**
		* @param {object} inst The instance, which is the source of events.
		* @param {string} registrationName Name of listener (e.g. `onClick`).
		* @return {?function} The stored callback.
		*/


		function getListener(inst
		/* Fiber */
		, registrationName) {
		// TODO: shouldPreventMouseEvent is DOM-specific and definitely should not
		// live here; needs to be moved to a better place soon
		var stateNode = inst.stateNode;

		if (!stateNode) {
		// Work in progress (ex: onload events in incremental mode).
		return null;
		}

		var props = getFiberCurrentPropsFromNode(stateNode);

		if (!props) {
		// Work in progress.
		return null;
		}

		var listener = props[registrationName];

		if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
		return null;
		}

		if (listener && typeof listener !== 'function') {
		throw new Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof listener + "` type.");
		}

		return listener;
		}

		function listenerAtPhase(inst, event, propagationPhase) {
		var registrationName = event._reactName;

		if (propagationPhase === 'captured') {
		registrationName += 'Capture';
		}

		return getListener(inst, registrationName);
		}

		function accumulateDispatches(inst, ignoredDirection, event) {
		if (inst && event && event._reactName) {
		var registrationName = event._reactName;
		var listener = getListener(inst, registrationName);

		if (listener) {
		if (event._dispatchListeners == null) {
		event._dispatchListeners = [];
		}

		if (event._dispatchInstances == null) {
		event._dispatchInstances = [];
		}

		event._dispatchListeners.push(listener);

		event._dispatchInstances.push(inst);
		}
		}
		}

		function accumulateDirectionalDispatches(inst, phase, event) {
		{
		if (!inst) {
		error('Dispatching inst must not be null');
		}
		}

		var listener = listenerAtPhase(inst, event, phase);

		if (listener) {
		if (event._dispatchListeners == null) {
		event._dispatchListeners = [];
		}

		if (event._dispatchInstances == null) {
		event._dispatchInstances = [];
		}

		event._dispatchListeners.push(listener);

		event._dispatchInstances.push(inst);
		}
		}

		function accumulateDirectDispatchesSingle(event) {
		if (event && event._reactName) {
		accumulateDispatches(event._targetInst, null, event);
		}
		}

		function accumulateTwoPhaseDispatchesSingle(event) {
		if (event && event._reactName) {
		traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
		}
		} // End of inline


		var Simulate = {};
		var directDispatchEventTypes = new Set(['mouseEnter', 'mouseLeave', 'pointerEnter', 'pointerLeave']);
		/**
		* Exports:
		*
		* - `Simulate.click(Element)`
		* - `Simulate.mouseMove(Element)`
		* - `Simulate.change(Element)`
		* - ... (All keys from event plugin `eventTypes` objects)
		*/

		function makeSimulator(eventType) {
		return function (domNode, eventData) {
		if (React.isValidElement(domNode)) {
		throw new Error('TestUtils.Simulate expected a DOM node as the first argument but received ' + 'a React element. Pass the DOM node you wish to simulate the event on instead. ' + 'Note that TestUtils.Simulate will not work if you are using shallow rendering.');
		}

		if (isCompositeComponent(domNode)) {
		throw new Error('TestUtils.Simulate expected a DOM node as the first argument but received ' + 'a component instance. Pass the DOM node you wish to simulate the event on instead.');
		}

		var reactName = 'on' + eventType[0].toUpperCase() + eventType.slice(1);
		var fakeNativeEvent = new Event();
		fakeNativeEvent.target = domNode;
		fakeNativeEvent.type = eventType.toLowerCase();
		var targetInst = getInstanceFromNode(domNode);
		var event = new SyntheticEvent(reactName, fakeNativeEvent.type, targetInst, fakeNativeEvent, domNode); // Since we aren't using pooling, always persist the event. This will make
		// sure it's marked and won't warn when setting additional properties.

		event.persist();
		assign(event, eventData);

		if (directDispatchEventTypes.has(eventType)) {
		accumulateDirectDispatchesSingle(event);
		} else {
		accumulateTwoPhaseDispatchesSingle(event);
		}

		ReactDOM.unstable_batchedUpdates(function () {
		// Normally extractEvent enqueues a state restore, but we'll just always
		// do that since we're by-passing it here.
		enqueueStateRestore(domNode);
		executeDispatchesAndRelease(event);
		rethrowCaughtError();
		});
		restoreStateIfNeeded();
		};
		} // A one-time snapshot with no plans to update. We'll probably want to deprecate Simulate API.


		var simulatedEventTypes = ['blur', 'cancel', 'click', 'close', 'contextMenu', 'copy', 'cut', 'auxClick', 'doubleClick', 'dragEnd', 'dragStart', 'drop', 'focus', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'mouseDown', 'mouseUp', 'paste', 'pause', 'play', 'pointerCancel', 'pointerDown', 'pointerUp', 'rateChange', 'reset', 'resize', 'seeked', 'submit', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'drag', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'mouseMove', 'mouseOut', 'mouseOver', 'pointerMove', 'pointerOut', 'pointerOver', 'scroll', 'toggle', 'touchMove', 'wheel', 'abort', 'animationEnd', 'animationIteration', 'animationStart', 'canPlay', 'canPlayThrough', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'playing', 'progress', 'seeking', 'stalled', 'suspend', 'timeUpdate', 'transitionEnd', 'waiting', 'mouseEnter', 'mouseLeave', 'pointerEnter', 'pointerLeave', 'change', 'select', 'beforeInput', 'compositionEnd', 'compositionStart', 'compositionUpdate'];

		function buildSimulators() {
		simulatedEventTypes.forEach(function (eventType) {
		Simulate[eventType] = makeSimulator(eventType);
		});
		}

		buildSimulators();

		exports.Simulate = Simulate;
		exports.act = act;
		exports.findAllInRenderedTree = findAllInRenderedTree;
		exports.findRenderedComponentWithType = findRenderedComponentWithType;
		exports.findRenderedDOMComponentWithClass = findRenderedDOMComponentWithClass;
		exports.findRenderedDOMComponentWithTag = findRenderedDOMComponentWithTag;
		exports.isCompositeComponent = isCompositeComponent;
		exports.isCompositeComponentWithType = isCompositeComponentWithType;
		exports.isDOMComponent = isDOMComponent;
		exports.isDOMComponentElement = isDOMComponentElement;
		exports.isElement = isElement;
		exports.isElementOfType = isElementOfType;
		exports.mockComponent = mockComponent;
		exports.nativeTouchData = nativeTouchData;
		exports.renderIntoDocument = renderIntoDocument;
		exports.scryRenderedComponentsWithType = scryRenderedComponentsWithType;
		exports.scryRenderedDOMComponentsWithClass = scryRenderedDOMComponentsWithClass;
		exports.scryRenderedDOMComponentsWithTag = scryRenderedDOMComponentsWithTag;
		exports.traverseTwoPhase = traverseTwoPhase;
		"use strict";
		"production" !== process.env.NODE_ENV &&
		(function () {
		var React = require("react"),
		didWarnAboutUsingAct = !1;
		exports.act = function (callback) {
		!1 === didWarnAboutUsingAct &&
		((didWarnAboutUsingAct = !0),
		console.error(
		"`ReactDOMTestUtils.act` is deprecated in favor of `React.act`. Import `act` from `react` instead of `react-dom/test-utils`. See https://react.dev/warnings/react-dom-test-utils for more info."
		));
		return React.act(callback);
		};
		})();
		}

client.js

		'use strict';

		var m = require('react-dom');
		function checkDCE() {
		/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
		if (
		typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined' \|\|
		typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== 'function'
		) {
		return;
		}
		if (process.env.NODE_ENV !== 'production') {
		// This branch is unreachable because this function is only called
		// in production, but the condition is true only in development.
		// Therefore if the branch is still here, dead code elimination wasn't
		// properly applied.
		// Don't change the message. React DevTools relies on it. Also make sure
		// this message doesn't occur elsewhere in this function, or it will cause
		// a false positive.
		throw new Error('^_^');
		}
		try {
		// Verify that the code above has been dead code eliminated (DCE'd).
		__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
		} catch (err) {
		// DevTools shouldn't crash React, no matter what.
		// We should still report in case we break this code.
		console.error(err);
		}
		}

		if (process.env.NODE_ENV === 'production') {
		exports.createRoot = m.createRoot;
		exports.hydrateRoot = m.hydrateRoot;
		// DCE check should happen before ReactDOM bundle executes so that
		// DevTools can report bad minification during injection.
		checkDCE();
		module.exports = require('./cjs/react-dom-client.production.js');
		} else {
		var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
		exports.createRoot = function (c, o) {
		i.usingClientEntryPoint = true;
		try {
		return m.createRoot(c, o);
		} finally {
		i.usingClientEntryPoint = false;
		}
		};
		exports.hydrateRoot = function (c, h, o) {
		i.usingClientEntryPoint = true;
		try {
		return m.hydrateRoot(c, h, o);
		} finally {
		i.usingClientEntryPoint = false;
		}
		};
		module.exports = require('./cjs/react-dom-client.development.js');
		}

index.js

		@@ -35,5 +35,5 @@ 'use strict';
		checkDCE();
		module.exports = require('./cjs/react-dom.production.min.js');
		module.exports = require('./cjs/react-dom.production.js');
		} else {
		module.exports = require('./cjs/react-dom.development.js');
		}

package.json

		{
		"name": "react-dom",
		"version": "0.0.0-experimental-910045696-20230607",
		"version": "0.0.0-experimental-91061073-20241121",
		"description": "React package for working with the DOM.",
		@@ -18,9 +18,8 @@ "main": "index.js",
		},
		"homepage": "https://reactjs.org/",
		"homepage": "https://react.dev/",
		"dependencies": {
		"loose-envify": "^1.1.0",
		"scheduler": "0.0.0-experimental-910045696-20230607"
		"scheduler": "0.0.0-experimental-91061073-20241121"
		},
		"peerDependencies": {
		"react": "0.0.0-experimental-910045696-20230607"
		"react": "0.0.0-experimental-91061073-20241121"
		},
		@@ -30,52 +29,92 @@ "files": [
		"README.md",
		"client.js",
		"client.react-server.js",
		"index.js",
		"client.js",
		"profiling.js",
		"server.js",
		"profiling.react-server.js",
		"react-dom.react-server.js",
		"server.browser.js",
		"server.bun.js",
		"server.edge.js",
		"server.js",
		"server.node.js",
		"server.bun.js",
		"static.js",
		"server.react-server.js",
		"static.browser.js",
		"static.edge.js",
		"static.js",
		"static.node.js",
		"server-rendering-stub.js",
		"static.react-server.js",
		"test-utils.js",
		"unstable_testing.js",
		"unstable_testing.react-server.js",
		"unstable_server-external-runtime.js",
		"cjs/",
		"umd/"
		"cjs/"
		],
		"exports": {
		".": "./index.js",
		"./client": "./client.js",
		".": {
		"react-server": "./react-dom.react-server.js",
		"default": "./index.js"
		},
		"./client": {
		"react-server": "./client.react-server.js",
		"default": "./client.js"
		},
		"./server": {
		"react-server": "./server.react-server.js",
		"workerd": "./server.edge.js",
		"edge-light": "./server.edge.js",
		"bun": "./server.bun.js",
		"deno": "./server.browser.js",
		"worker": "./server.browser.js",
		"node": "./server.node.js",
		"edge-light": "./server.edge.js",
		"browser": "./server.browser.js",
		"default": "./server.node.js"
		},
		"./server.browser": "./server.browser.js",
		"./server.bun": "./server.bun.js",
		"./server.edge": "./server.edge.js",
		"./server.node": "./server.node.js",
		"./server.browser": {
		"react-server": "./server.react-server.js",
		"default": "./server.browser.js"
		},
		"./server.bun": {
		"react-server": "./server.react-server.js",
		"default": "./server.bun.js"
		},
		"./server.edge": {
		"react-server": "./server.react-server.js",
		"default": "./server.edge.js"
		},
		"./server.node": {
		"react-server": "./server.react-server.js",
		"default": "./server.node.js"
		},
		"./static": {
		"react-server": "./static.react-server.js",
		"workerd": "./static.edge.js",
		"edge-light": "./static.edge.js",
		"deno": "./static.browser.js",
		"worker": "./static.browser.js",
		"node": "./static.node.js",
		"edge-light": "./static.edge.js",
		"browser": "./static.browser.js",
		"default": "./static.node.js"
		},
		"./static.browser": "./static.browser.js",
		"./static.edge": "./static.edge.js",
		"./static.node": "./static.node.js",
		"./server-rendering-stub": "./server-rendering-stub.js",
		"./profiling": "./profiling.js",
		"./static.browser": {
		"react-server": "./static.react-server.js",
		"default": "./static.browser.js"
		},
		"./static.edge": {
		"react-server": "./static.react-server.js",
		"default": "./static.edge.js"
		},
		"./static.node": {
		"react-server": "./static.react-server.js",
		"default": "./static.node.js"
		},
		"./profiling": {
		"react-server": "./profiling.react-server.js",
		"default": "./profiling.js"
		},
		"./test-utils": "./test-utils.js",
		"./unstable_testing": "./unstable_testing.js",
		"./unstable_testing": {
		"react-server": "./unstable_testing.react-server.js",
		"default": "./unstable_testing.js"
		},
		"./unstable_server-external-runtime": "./unstable_server-external-runtime.js",
		@@ -87,8 +126,3 @@ "./package.json": "./package.json"
		"./static.js": "./static.browser.js"
		},
		"browserify": {
		"transform": [
		"loose-envify"
		]
		}
		}

profiling.js

		@@ -35,5 +35,5 @@ 'use strict';
		checkDCE();
		module.exports = require('./cjs/react-dom.profiling.min.js');
		module.exports = require('./cjs/react-dom-profiling.profiling.js');
		} else {
		module.exports = require('./cjs/react-dom.development.js');
		module.exports = require('./cjs/react-dom-profiling.development.js');
		}

server.browser.js

		@@ -5,4 +5,4 @@ 'use strict';
		if (process.env.NODE_ENV === 'production') {
		l = require('./cjs/react-dom-server-legacy.browser.production.min.js');
		s = require('./cjs/react-dom-server.browser.production.min.js');
		l = require('./cjs/react-dom-server-legacy.browser.production.js');
		s = require('./cjs/react-dom-server.browser.production.js');
		} else {
		@@ -16,4 +16,5 @@ l = require('./cjs/react-dom-server-legacy.browser.development.js');
		exports.renderToStaticMarkup = l.renderToStaticMarkup;
		exports.renderToNodeStream = l.renderToNodeStream;
		exports.renderToStaticNodeStream = l.renderToStaticNodeStream;
		exports.renderToReadableStream = s.renderToReadableStream;
		if (s.resume) {
		exports.resume = s.resume;
		}

server.bun.js

		@@ -6,4 +6,4 @@ 'use strict';
		if (process.env.NODE_ENV === 'production') {
		b = require('./cjs/react-dom-server.bun.production.min.js');
		l = require('./cjs/react-dom-server-legacy.browser.production.min.js');
		b = require('./cjs/react-dom-server.bun.production.js');
		l = require('./cjs/react-dom-server-legacy.browser.production.js');
		} else {
		@@ -16,5 +16,6 @@ b = require('./cjs/react-dom-server.bun.development.js');
		exports.renderToReadableStream = b.renderToReadableStream;
		exports.renderToNodeStream = b.renderToNodeStream;
		exports.renderToStaticNodeStream = b.renderToStaticNodeStream;
		if (b.resume) {
		exports.resume = b.resume;
		}
		exports.renderToString = l.renderToString;
		exports.renderToStaticMarkup = l.renderToStaticMarkup;

server.edge.js

		@@ -6,4 +6,4 @@ 'use strict';
		if (process.env.NODE_ENV === 'production') {
		b = require('./cjs/react-dom-server.edge.production.min.js');
		l = require('./cjs/react-dom-server-legacy.browser.production.min.js');
		b = require('./cjs/react-dom-server.edge.production.js');
		l = require('./cjs/react-dom-server-legacy.browser.production.js');
		} else {
		@@ -16,5 +16,6 @@ b = require('./cjs/react-dom-server.edge.development.js');
		exports.renderToReadableStream = b.renderToReadableStream;
		exports.renderToNodeStream = b.renderToNodeStream;
		exports.renderToStaticNodeStream = b.renderToStaticNodeStream;
		exports.renderToString = l.renderToString;
		exports.renderToStaticMarkup = l.renderToStaticMarkup;
		if (b.resume) {
		exports.resume = b.resume;
		}

server.node.js

		@@ -5,4 +5,4 @@ 'use strict';
		if (process.env.NODE_ENV === 'production') {
		l = require('./cjs/react-dom-server-legacy.node.production.min.js');
		s = require('./cjs/react-dom-server.node.production.min.js');
		l = require('./cjs/react-dom-server-legacy.node.production.js');
		s = require('./cjs/react-dom-server.node.production.js');
		} else {
		@@ -16,4 +16,5 @@ l = require('./cjs/react-dom-server-legacy.node.development.js');
		exports.renderToStaticMarkup = l.renderToStaticMarkup;
		exports.renderToNodeStream = l.renderToNodeStream;
		exports.renderToStaticNodeStream = l.renderToStaticNodeStream;
		exports.renderToPipeableStream = s.renderToPipeableStream;
		if (s.resumeToPipeableStream) {
		exports.resumeToPipeableStream = s.resumeToPipeableStream;
		}

static.browser.js

		'use strict';

		var s;
		if (process.env.NODE_ENV === 'production') {
		module.exports = require('./cjs/react-dom-static.browser.production.min.js');
		s = require('./cjs/react-dom-server.browser.production.js');
		} else {
		module.exports = require('./cjs/react-dom-static.browser.development.js');
		s = require('./cjs/react-dom-server.browser.development.js');
		}

		exports.version = s.version;
		exports.prerender = s.prerender;
		exports.resumeAndPrerender = s.resumeAndPrerender;

static.edge.js

		'use strict';

		var s;
		if (process.env.NODE_ENV === 'production') {
		module.exports = require('./cjs/react-dom-static.edge.production.min.js');
		s = require('./cjs/react-dom-server.edge.production.js');
		} else {
		module.exports = require('./cjs/react-dom-static.edge.development.js');
		s = require('./cjs/react-dom-server.edge.development.js');
		}

		exports.version = s.version;
		exports.prerender = s.prerender;
		exports.resumeAndPrerender = s.resumeAndPrerender;

static.node.js

		'use strict';

		var s;
		if (process.env.NODE_ENV === 'production') {
		module.exports = require('./cjs/react-dom-static.node.production.min.js');
		s = require('./cjs/react-dom-server.node.production.js');
		} else {
		module.exports = require('./cjs/react-dom-static.node.development.js');
		s = require('./cjs/react-dom-server.node.development.js');
		}

		exports.version = s.version;
		exports.prerenderToNodeStream = s.prerenderToNodeStream;
		exports.resumeAndPrerenderToNodeStream = s.resumeAndPrerenderToNodeStream;

test-utils.js

		'use strict';

		if (process.env.NODE_ENV === 'production') {
		module.exports = require('./cjs/react-dom-test-utils.production.min.js');
		module.exports = require('./cjs/react-dom-test-utils.production.js');
		} else {
		module.exports = require('./cjs/react-dom-test-utils.development.js');
		}

243

unstable_server-external-runtime.js

		@@ -1,7 +0,236 @@
		(function(){function p(b,a,d){a=document.getElementById(a);a.parentNode.removeChild(a);var c=document.getElementById(b);if(c){b=c.previousSibling;if(d)b.data="$!",c.setAttribute("data-dgst",d);else{d=b.parentNode;c=b.nextSibling;var f=0;do{if(c&&8===c.nodeType){var e=c.data;if("/$"===e)if(0===f)break;else f--;else"$"!==e&&"$?"!==e&&"$!"!==e\|\|f++}e=c.nextSibling;d.removeChild(c);c=e}while(c);for(;a.firstChild;)d.insertBefore(a.firstChild,c);b.data="$"}b._reactRetry&&b._reactRetry()}}function B(b,a,
		d){for(var c=new Map,f=document,e,h,q=f.querySelectorAll("link[data-precedence],style[data-precedence]"),w=[],r=0;h=q[r++];)"not all"===h.getAttribute("media")?w.push(h):("LINK"===h.tagName&&v.set(h.getAttribute("href"),h),c.set(h.dataset.precedence,e=h));h=0;q=[];var t,g;for(r=!0;;){if(r){var n=d[h++];if(!n){r=!1;h=0;continue}var k=!1,u=0;var l=n[u++];if(g=v.get(l)){var m=g._p;k=!0}else{g=f.createElement("link");g.href=l;g.rel="stylesheet";for(g.dataset.precedence=t=n[u++];m=n[u++];)g.setAttribute(m,
		n[u++]);m=g._p=new Promise(function(C,D){g.onload=C;g.onerror=D});v.set(l,g)}l=g.getAttribute("media");!m\|\|"l"===m.s\|\|l&&!window.matchMedia(l).matches\|\|q.push(m);if(k)continue}else{g=w[h++];if(!g)break;t=g.getAttribute("data-precedence");g.removeAttribute("media")}k=c.get(t)\|\|e;k===e&&(e=g);c.set(t,g);k?k.parentNode.insertBefore(g,k.nextSibling):(k=f.head,k.insertBefore(g,k.firstChild))}Promise.all(q).then(p.bind(null,b,a,""),p.bind(null,b,a,"Resource failed to load"))}function x(b){b=b.querySelectorAll("template");
		for(var a=0;a<b.length;a++)y(b[a])}function z(b){function a(c){for(var f=0;f<c.length;f++)for(var e=c[f].addedNodes,h=0;h<e.length;h++)e[h].parentNode&&y(e[h])}var d=new MutationObserver(a);d.observe(b,{childList:!0});window.addEventListener("DOMContentLoaded",function(){a(d.takeRecords());d.disconnect()})}function y(b){if(1===b.nodeType&&b.dataset){var a=b.dataset;if(null!=a.rxi){var d=a.dgst,c=a.msg,f=a.stck,e=document.getElementById(a.bid);e&&(a=e.previousSibling,a.data="$!",e=e.dataset,d&&(e.dgst=
		d),c&&(e.msg=c),f&&(e.stck=f),a._reactRetry&&a._reactRetry());b.remove()}else if(null!=a.rri)B(a.bid,a.sid,JSON.parse(a.sty)),b.remove();else if(null!=a.rci)p(a.bid,a.sid),b.remove();else if(null!=a.rsi){d=a.pid;c=document.getElementById(a.sid);d=document.getElementById(d);for(c.parentNode.removeChild(c);c.firstChild;)d.parentNode.insertBefore(c.firstChild,d);d.parentNode.removeChild(d);b.remove()}}}var v=new Map;(function(){addEventListener("submit",function(b){if(!b.defaultPrevented){var a=b.target,
		d=b.submitter,c=a.action,f=d;if(d){var e=d.getAttribute("formAction");null!=e&&(c=e,f=null)}"javascript:throw new Error('A React form was unexpectedly submitted.')"===c&&(b.preventDefault(),f?(b=document.createElement("input"),b.name=f.name,b.value=f.value,f.parentNode.insertBefore(b,f),f=new FormData(a),b.parentNode.removeChild(b)):f=new FormData(a),b=a.getRootNode(),(b.$$reactFormReplay=b.$$reactFormReplay\|\|[]).push(a,d,f))}})})();window.$RC\|\|(window.$RC=p,window.$RM=new Map);if(null!=document.body)"loading"===
		document.readyState&&z(document.body),x(document.body);else{var A=new MutationObserver(function(){null!=document.body&&("loading"===document.readyState&&z(document.body),x(document.body),A.disconnect())});A.observe(document.documentElement,{childList:!0})}})();
		(function () {
		function completeBoundary(suspenseBoundaryID, contentID, errorDigest) {
		contentID = document.getElementById(contentID);
		contentID.parentNode.removeChild(contentID);
		var suspenseIdNode = document.getElementById(suspenseBoundaryID);
		if (suspenseIdNode) {
		suspenseBoundaryID = suspenseIdNode.previousSibling;
		if (errorDigest)
		(suspenseBoundaryID.data = "$!"),
		suspenseIdNode.setAttribute("data-dgst", errorDigest);
		else {
		errorDigest = suspenseBoundaryID.parentNode;
		suspenseIdNode = suspenseBoundaryID.nextSibling;
		var depth = 0;
		do {
		if (suspenseIdNode && 8 === suspenseIdNode.nodeType) {
		var data = suspenseIdNode.data;
		if ("/$" === data)
		if (0 === depth) break;
		else depth--;
		else ("$" !== data && "$?" !== data && "$!" !== data) \|\| depth++;
		}
		data = suspenseIdNode.nextSibling;
		errorDigest.removeChild(suspenseIdNode);
		suspenseIdNode = data;
		} while (suspenseIdNode);
		for (; contentID.firstChild; )
		errorDigest.insertBefore(contentID.firstChild, suspenseIdNode);
		suspenseBoundaryID.data = "$";
		}
		suspenseBoundaryID._reactRetry && suspenseBoundaryID._reactRetry();
		}
		}
		function completeBoundaryWithStyles(
		suspenseBoundaryID,
		contentID,
		stylesheetDescriptors
		) {
		function cleanupWith(cb) {
		this._p = null;
		cb();
		}
		for (
		var precedences = new Map(),
		thisDocument = document,
		lastResource,
		node,
		nodes = thisDocument.querySelectorAll(
		"link[data-precedence],style[data-precedence]"
		),
		styleTagsToHoist = [],
		i$0 = 0;
		(node = nodes[i$0++]);

		)
		"not all" === node.getAttribute("media")
		? styleTagsToHoist.push(node)
		: ("LINK" === node.tagName &&
		resourceMap.set(node.getAttribute("href"), node),
		precedences.set(node.dataset.precedence, (lastResource = node)));
		node = 0;
		nodes = [];
		var precedence, resourceEl;
		for (i$0 = !0; ; ) {
		if (i$0) {
		var stylesheetDescriptor = stylesheetDescriptors[node++];
		if (!stylesheetDescriptor) {
		i$0 = !1;
		node = 0;
		continue;
		}
		var avoidInsert = !1,
		j = 0;
		var href = stylesheetDescriptor[j++];
		if ((resourceEl = resourceMap.get(href))) {
		var attr = resourceEl._p;
		avoidInsert = !0;
		} else {
		resourceEl = thisDocument.createElement("link");
		resourceEl.href = href;
		resourceEl.rel = "stylesheet";
		for (
		resourceEl.dataset.precedence = precedence =
		stylesheetDescriptor[j++];
		(attr = stylesheetDescriptor[j++]);

		)
		resourceEl.setAttribute(attr, stylesheetDescriptor[j++]);
		attr = resourceEl._p = new Promise(function (resolve, reject) {
		resourceEl.onload = cleanupWith.bind(resourceEl, resolve);
		resourceEl.onerror = cleanupWith.bind(resourceEl, reject);
		});
		resourceMap.set(href, resourceEl);
		}
		href = resourceEl.getAttribute("media");
		!attr \|\| (href && !window.matchMedia(href).matches) \|\| nodes.push(attr);
		if (avoidInsert) continue;
		} else {
		resourceEl = styleTagsToHoist[node++];
		if (!resourceEl) break;
		precedence = resourceEl.getAttribute("data-precedence");
		resourceEl.removeAttribute("media");
		}
		avoidInsert = precedences.get(precedence) \|\| lastResource;
		avoidInsert === lastResource && (lastResource = resourceEl);
		precedences.set(precedence, resourceEl);
		avoidInsert
		? avoidInsert.parentNode.insertBefore(
		resourceEl,
		avoidInsert.nextSibling
		)
		: ((avoidInsert = thisDocument.head),
		avoidInsert.insertBefore(resourceEl, avoidInsert.firstChild));
		}
		Promise.all(nodes).then(
		completeBoundary.bind(null, suspenseBoundaryID, contentID, ""),
		completeBoundary.bind(
		null,
		suspenseBoundaryID,
		contentID,
		"Resource failed to load"
		)
		);
		}
		function handleExistingNodes(target) {
		target = target.querySelectorAll("template");
		for (var i = 0; i < target.length; i++) handleNode(target[i]);
		}
		function installFizzInstrObserver(target) {
		function handleMutations(mutations) {
		for (var i = 0; i < mutations.length; i++)
		for (
		var addedNodes = mutations[i].addedNodes, j = 0;
		j < addedNodes.length;
		j++
		)
		addedNodes[j].parentNode && handleNode(addedNodes[j]);
		}
		var fizzInstrObserver = new MutationObserver(handleMutations);
		fizzInstrObserver.observe(target, { childList: !0 });
		window.addEventListener("DOMContentLoaded", function () {
		handleMutations(fizzInstrObserver.takeRecords());
		fizzInstrObserver.disconnect();
		});
		}
		function handleNode(node_) {
		if (1 === node_.nodeType && node_.dataset) {
		var dataset = node_.dataset;
		if (null != dataset.rxi) {
		var errorDigest = dataset.dgst,
		errorMsg = dataset.msg,
		errorStack = dataset.stck,
		errorComponentStack = dataset.cstck,
		suspenseIdNode = document.getElementById(dataset.bid);
		suspenseIdNode &&
		((dataset = suspenseIdNode.previousSibling),
		(dataset.data = "$!"),
		(suspenseIdNode = suspenseIdNode.dataset),
		errorDigest && (suspenseIdNode.dgst = errorDigest),
		errorMsg && (suspenseIdNode.msg = errorMsg),
		errorStack && (suspenseIdNode.stck = errorStack),
		errorComponentStack && (suspenseIdNode.cstck = errorComponentStack),
		dataset._reactRetry && dataset._reactRetry());
		node_.remove();
		} else if (null != dataset.rri)
		completeBoundaryWithStyles(
		dataset.bid,
		dataset.sid,
		JSON.parse(dataset.sty)
		),
		node_.remove();
		else if (null != dataset.rci)
		completeBoundary(dataset.bid, dataset.sid), node_.remove();
		else if (null != dataset.rsi) {
		errorDigest = dataset.pid;
		errorMsg = document.getElementById(dataset.sid);
		errorDigest = document.getElementById(errorDigest);
		for (errorMsg.parentNode.removeChild(errorMsg); errorMsg.firstChild; )
		errorDigest.parentNode.insertBefore(errorMsg.firstChild, errorDigest);
		errorDigest.parentNode.removeChild(errorDigest);
		node_.remove();
		}
		}
		}
		var resourceMap = new Map();
		(function () {
		addEventListener("submit", function (event) {
		if (!event.defaultPrevented) {
		var form = event.target,
		submitter = event.submitter,
		action = form.action,
		formDataSubmitter = submitter;
		if (submitter) {
		var submitterAction = submitter.getAttribute("formAction");
		null != submitterAction &&
		((action = submitterAction), (formDataSubmitter = null));
		}
		"javascript:throw new Error('React form unexpectedly submitted.')" ===
		action &&
		(event.preventDefault(),
		formDataSubmitter
		? ((event = document.createElement("input")),
		(event.name = formDataSubmitter.name),
		(event.value = formDataSubmitter.value),
		formDataSubmitter.parentNode.insertBefore(
		event,
		formDataSubmitter
		),
		(formDataSubmitter = new FormData(form)),
		event.parentNode.removeChild(event))
		: (formDataSubmitter = new FormData(form)),
		(event = form.ownerDocument \|\| form),
		(event.$$reactFormReplay = event.$$reactFormReplay \|\| []).push(
		form,
		submitter,
		formDataSubmitter
		));
		}
		});
		})();
		window.$RC \|\| ((window.$RC = completeBoundary), (window.$RM = new Map()));
		if (null != document.body)
		"loading" === document.readyState &&
		installFizzInstrObserver(document.body),
		handleExistingNodes(document.body);
		else {
		var domBodyObserver = new MutationObserver(function () {
		null != document.body &&
		("loading" === document.readyState &&
		installFizzInstrObserver(document.body),
		handleExistingNodes(document.body),
		domBodyObserver.disconnect());
		});
		domBodyObserver.observe(document.documentElement, { childList: !0 });
		}
		})();

unstable_testing.js

		@@ -35,5 +35,5 @@ 'use strict';
		checkDCE();
		module.exports = require('./cjs/react-dom-unstable_testing.production.min.js');
		module.exports = require('./cjs/react-dom-unstable_testing.production.js');
		} else {
		module.exports = require('./cjs/react-dom-unstable_testing.development.js');
		}

cjs/react-dom-server-legacy.browser.production.min.js

cjs/react-dom-server-legacy.node.production.min.js

cjs/react-dom-server-rendering-stub.development.js

cjs/react-dom-server-rendering-stub.production.min.js

cjs/react-dom-server.browser.production.min.js

cjs/react-dom-server.bun.production.min.js

cjs/react-dom-server.edge.production.min.js

cjs/react-dom-server.node.production.min.js

cjs/react-dom-static.browser.development.js

cjs/react-dom-static.browser.production.min.js

cjs/react-dom-static.edge.development.js

cjs/react-dom-static.edge.production.min.js

cjs/react-dom-static.node.development.js

cjs/react-dom-static.node.production.min.js

cjs/react-dom-test-utils.production.min.js

cjs/react-dom-unstable_testing.production.min.js

cjs/react-dom.production.min.js

cjs/react-dom.profiling.min.js

server-rendering-stub.js

umd/react-dom-server-legacy.browser.development.js

umd/react-dom-server-legacy.browser.production.min.js

umd/react-dom-server-rendering-stub.development.js

umd/react-dom-server-rendering-stub.production.min.js

umd/react-dom-server.browser.development.js

umd/react-dom-server.browser.production.min.js

umd/react-dom-test-utils.development.js

umd/react-dom-test-utils.production.min.js

umd/react-dom.development.js

umd/react-dom.production.min.js

umd/react-dom.profiling.min.js

cjs/react-dom-server-legacy.browser.development.js