test-renderer 0.14.0 → 0.16.0

package/dist/index.js

@@ -1,837 +1,580 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-
-// src/renderer.ts
-import { ConcurrentRoot } from "react-reconciler/constants";
-
-// src/constants.ts
-var Tag = {
-  Container: "CONTAINER",
-  Instance: "INSTANCE",
-  Text: "TEXT"
+import { ConcurrentRoot, DefaultEventPriority, NoEventPriority } from "react-reconciler/constants.js";
+import ReactReconciler from "react-reconciler";
+//#region src/constants.ts
+const Tag = {
+	Container: "CONTAINER",
+	Instance: "INSTANCE",
+	Text: "TEXT"
 };
-var CONTAINER_TYPE = "";
-
-// src/query-all.ts
-function queryAll(element, predicate, options) {
-  var _a, _b;
-  const includeSelf = (_a = options == null ? void 0 : options.includeSelf) != null ? _a : false;
-  const matchDeepestOnly = (_b = options == null ? void 0 : options.matchDeepestOnly) != null ? _b : false;
-  const results = [];
-  const matchingDescendants = [];
-  element.children.forEach((child) => {
-    if (typeof child === "string") {
-      return;
-    }
-    matchingDescendants.push(...queryAll(child, predicate, __spreadProps(__spreadValues({}, options), { includeSelf: true })));
-  });
-  if (includeSelf && // When matchDeepestOnly = true: add current element only if no descendants match
-  (matchingDescendants.length === 0 || !matchDeepestOnly) && predicate(element)) {
-    results.push(element);
-  }
-  results.push(...matchingDescendants);
-  return results;
+//#endregion
+//#region src/performance.ts
+function mark(name, details) {
+	if (!globalThis.TEST_RENDERER_ENABLE_PROFILING) return;
+	performance.mark(`test-renderer/${name}`, { detail: details });
 }
-
-// src/render-to-json.ts
-function renderContainerToJson(instance) {
-  return {
-    type: CONTAINER_TYPE,
-    props: {},
-    children: renderChildrenToJson(instance.children),
-    $$typeof: /* @__PURE__ */ Symbol.for("react.test.json")
-  };
+function measureStart(name) {
+	if (!globalThis.TEST_RENDERER_ENABLE_PROFILING) return;
+	performance.mark(`test-renderer/${name}:start`);
 }
-function renderInstanceToJson(instance) {
-  if (instance.isHidden) {
-    return null;
-  }
-  const _a = instance.props, { children: _children } = _a, restProps = __objRest(_a, ["children"]);
-  return {
-    type: instance.type,
-    props: restProps,
-    children: renderChildrenToJson(instance.children),
-    $$typeof: /* @__PURE__ */ Symbol.for("react.test.json")
-  };
+function measureEnd(name, details) {
+	if (!globalThis.TEST_RENDERER_ENABLE_PROFILING) return;
+	performance.mark(`test-renderer/${name}:end`);
+	performance.measure(`test-renderer/${name}`, {
+		start: `test-renderer/${name}:start`,
+		end: `test-renderer/${name}:end`,
+		detail: details
+	});
 }
-function renderTextInstanceToJson(instance) {
-  if (instance.isHidden) {
-    return null;
-  }
-  return instance.text;
+//#endregion
+//#region src/query-all.ts
+/**
+* Find all descendant elements matching the predicate.
+*
+* @param instance - Root TestInstance to search from.
+* @param predicate - Function that returns true for matching elements.
+* @param options - Optional query configuration.
+* @returns Array of matching elements in tree order.
+*/
+function queryAll(instance, predicate, options) {
+	const includeSelf = options?.includeSelf ?? false;
+	const matchDeepestOnly = options?.matchDeepestOnly ?? false;
+	const results = [];
+	const matchingDescendants = [];
+	instance.children.forEach((child) => {
+		if (typeof child === "string") return;
+		matchingDescendants.push(...queryAll(child, predicate, {
+			...options,
+			includeSelf: true
+		}));
+	});
+	if (includeSelf && (matchingDescendants.length === 0 || !matchDeepestOnly) && predicate(instance)) results.push(instance);
+	results.push(...matchingDescendants);
+	return results;
 }
-function renderChildrenToJson(children) {
-  const result = [];
-  for (const child of children) {
-    if (child.tag === Tag.Instance) {
-      const renderedChild = renderInstanceToJson(child);
-      if (renderedChild != null) {
-        result.push(renderedChild);
-      }
-    } else {
-      const renderedChild = renderTextInstanceToJson(child);
-      if (renderedChild != null) {
-        result.push(renderedChild);
-      }
-    }
-  }
-  return result;
+//#endregion
+//#region src/to-json.ts
+function containerToJson(container) {
+	return {
+		type: "",
+		props: {},
+		children: childrenToJson(container.children),
+		$$typeof: Symbol.for("react.test.json")
+	};
 }
-
-// src/host-element.ts
-var instanceMap = /* @__PURE__ */ new WeakMap();
-var HostElement = class _HostElement {
-  constructor(instance) {
-    this.instance = instance;
-  }
-  /** The element type (e.g., "div", "span"). Empty string for container. */
-  get type() {
-    return this.instance.tag === Tag.Instance ? this.instance.type : CONTAINER_TYPE;
-  }
-  /** The element's props object. */
-  get props() {
-    return this.instance.tag === Tag.Instance ? this.instance.props : {};
-  }
-  /** The parent element, or null if this is the root container. */
-  get parent() {
-    const parentInstance = this.instance.parent;
-    if (parentInstance == null) {
-      return null;
-    }
-    return _HostElement.fromInstance(parentInstance);
-  }
-  /** Array of child nodes (elements and text strings). Hidden children are excluded. */
-  get children() {
-    const result = this.instance.children.filter((child) => !child.isHidden).map((child) => getHostNodeForInstance(child));
-    return result;
-  }
-  /**
-   * Access to the underlying React Fiber node. This is an unstable API that exposes
-   * internal react-reconciler structures which may change without warning in future
-   * React versions. Use with caution and only when absolutely necessary.
-   *
-   * @returns The Fiber node for this instance, or null if this is a container.
-   */
-  get unstable_fiber() {
-    return this.instance.tag === Tag.Instance ? this.instance.unstable_fiber : null;
-  }
-  /**
-   * Convert this element to a JSON representation suitable for snapshots.
-   *
-   * @returns JSON element or null if the element is hidden.
-   */
-  toJSON() {
-    return this.instance.tag === Tag.Container ? renderContainerToJson(this.instance) : renderInstanceToJson(this.instance);
-  }
-  /**
-   * Find all descendant elements matching the predicate.
-   *
-   * @param predicate - Function that returns true for matching elements.
-   * @param options - Optional query configuration.
-   * @returns Array of matching elements.
-   */
-  queryAll(predicate, options) {
-    return queryAll(this, predicate, options);
-  }
-  /** @internal */
-  static fromInstance(instance) {
-    const hostElement = instanceMap.get(instance);
-    if (hostElement) {
-      return hostElement;
-    }
-    const result = new _HostElement(instance);
-    instanceMap.set(instance, result);
-    return result;
-  }
+function instanceToJson(instance) {
+	const shouldExcludeHidden = instance.rootContainer.config.transformHiddenInstanceProps == null;
+	if (instance.isHidden && shouldExcludeHidden) return null;
+	const { children: _children, ...restProps } = instance.props;
+	return {
+		type: instance.type,
+		props: restProps,
+		children: childrenToJson(instance.children),
+		$$typeof: Symbol.for("react.test.json")
+	};
+}
+function textInstanceToJson(instance) {
+	const shouldExcludeHidden = instance.rootContainer.config.transformHiddenInstanceProps == null;
+	if (instance.isHidden && shouldExcludeHidden) return null;
+	return instance.text;
+}
+function childrenToJson(children) {
+	const result = [];
+	for (const child of children) if (child.tag === Tag.Instance) {
+		const renderedChild = instanceToJson(child);
+		if (renderedChild != null) result.push(renderedChild);
+	} else {
+		const renderedChild = textInstanceToJson(child);
+		if (renderedChild != null) result.push(renderedChild);
+	}
+	return result;
+}
+//#endregion
+//#region src/test-instance.ts
+const instanceMap = /* @__PURE__ */ new WeakMap();
+/**
+* Represents a rendered host element in the test renderer tree.
+* Provides a DOM-like API for querying and inspecting rendered components.
+*/
+var TestInstance = class TestInstance {
+	constructor(instance) {
+		this.instance = instance;
+	}
+	/** The element type (e.g., "div", "span"). Empty string for container. */
+	get type() {
+		return this.instance.tag === Tag.Instance ? this.instance.type : "";
+	}
+	/** The element's props object. */
+	get props() {
+		return this.instance.tag === Tag.Instance ? this.instance.props : {};
+	}
+	/** The parent element, or null if this is the root container. */
+	get parent() {
+		const parentInstance = this.instance.parent;
+		if (parentInstance == null) return null;
+		return TestInstance.fromInstance(parentInstance);
+	}
+	/** Array of child nodes (elements and text strings). Hidden children are excluded by default. */
+	get children() {
+		const shouldExcludeHiddenChildren = (this.instance.tag === Tag.Container ? this.instance : this.instance.rootContainer).config.transformHiddenInstanceProps == null;
+		return this.instance.children.filter((child) => !child.isHidden || !shouldExcludeHiddenChildren).map((child) => getTestNodeForInstance(child));
+	}
+	/**
+	* Access to the underlying React Fiber node. This is an unstable API that exposes
+	* internal react-reconciler structures which may change without warning in future
+	* React versions. Use with caution and only when absolutely necessary.
+	*
+	* @returns The Fiber node for this instance, or null if this is a container.
+	*/
+	get unstable_fiber() {
+		return this.instance.tag === Tag.Instance ? this.instance.unstable_fiber : null;
+	}
+	/**
+	* Convert this element to a JSON representation suitable for snapshots.
+	*
+	* @returns JSON element or null if the element is hidden and hidden nodes are excluded.
+	*/
+	toJSON() {
+		return this.instance.tag === Tag.Container ? containerToJson(this.instance) : instanceToJson(this.instance);
+	}
+	/**
+	* Find all descendant elements matching the predicate.
+	*
+	* @param predicate - Function that returns true for matching elements.
+	* @param options - Optional query configuration.
+	* @returns Array of matching elements.
+	*/
+	queryAll(predicate, options) {
+		return queryAll(this, predicate, options);
+	}
+	/** @internal */
+	static fromInstance(instance) {
+		const testInstance = instanceMap.get(instance);
+		if (testInstance) return testInstance;
+		const result = new TestInstance(instance);
+		instanceMap.set(instance, result);
+		return result;
+	}
 };
-function getHostNodeForInstance(instance) {
-  switch (instance.tag) {
-    case Tag.Text:
-      return instance.text;
-    case Tag.Instance:
-      return HostElement.fromInstance(instance);
-  }
+function getTestNodeForInstance(instance) {
+	switch (instance.tag) {
+		case Tag.Text: return instance.text;
+		case Tag.Instance: return TestInstance.fromInstance(instance);
+	}
 }
-
-// src/reconciler.ts
-import ReactReconciler from "react-reconciler";
-import { DefaultEventPriority, NoEventPriority } from "react-reconciler/constants";
-
-// src/utils.ts
+//#endregion
+//#region src/utils.ts
 function formatComponentList(names) {
-  if (names.length === 0) {
-    return "";
-  }
-  if (names.length === 1) {
-    return `<${names[0]}>`;
-  }
-  if (names.length === 2) {
-    return `<${names[0]}> or <${names[1]}>`;
-  }
-  const allButLast = names.slice(0, -1);
-  const last = names[names.length - 1];
-  return `${allButLast.map((name) => `<${name}>`).join(", ")}, or <${last}>`;
+	if (names.length === 0) return "";
+	if (names.length === 1) return `<${names[0]}>`;
+	if (names.length === 2) return `<${names[0]}> or <${names[1]}>`;
+	const allButLast = names.slice(0, -1);
+	const last = names[names.length - 1];
+	return `${allButLast.map((name) => `<${name}>`).join(", ")}, or <${last}>`;
 }
-
-// src/reconciler.ts
-var nodeToInstanceMap = /* @__PURE__ */ new WeakMap();
-var currentUpdatePriority = NoEventPriority;
-var hostConfig = {
-  /**
-   * The reconciler has two modes: mutation mode and persistent mode. You must specify one of them.
-   *
-   * If your target platform is similar to the DOM and has methods similar to `appendChild`, `removeChild`,
-   * and so on, you'll want to use the **mutation mode**. This is the same mode used by React DOM, React ART,
-   * and the classic React Native renderer.
-   *
-   * ```js
-   * const HostConfig = {
-   *   // ...
-   *   supportsMutation: true,
-   *   // ...
-   * }
-   * ```
-   *
-   * Depending on the mode, the reconciler will call different methods on your host config.
-   * If you're not sure which one you want, you likely need the mutation mode.
-   */
-  supportsMutation: true,
-  /**
-   * The reconciler has two modes: mutation mode and persistent mode. You must specify one of them.
-   *
-   * If your target platform has immutable trees, you'll want the **persistent mode** instead. In that mode,
-   * existing nodes are never mutated, and instead every change clones the parent tree and then replaces
-   * the whole parent tree at the root. This is the node used by the new React Native renderer, codenamed "Fabric".
-   *
-   * ```js
-   * const HostConfig = {
-   *   // ...
-   *   supportsPersistence: true,
-   *   // ...
-   * }
-   * ```
-   *
-   * Depending on the mode, the reconciler will call different methods on your host config.
-   * If you're not sure which one you want, you likely need the mutation mode.
-   */
-  supportsPersistence: false,
-  /**
-   * #### `createInstance(type, props, rootContainer, hostContext, internalHandle)`
-   *
-   * This method should return a newly created node. For example, the DOM renderer would call
-   * `document.createElement(type)` here and then set the properties from `props`.
-   *
-   * You can use `rootContainer` to access the root container associated with that tree. For example,
-   * in the DOM renderer, this is useful to get the correct `document` reference that the root belongs to.
-   *
-   * The `hostContext` parameter lets you keep track of some information about your current place in
-   * the tree. To learn more about it, see `getChildHostContext` below.
-   *
-   * The `internalHandle` data structure is meant to be opaque. If you bend the rules and rely on its
-   * internal fields, be aware that it may change significantly between versions. You're taking on additional
-   * maintenance risk by reading from it, and giving up all guarantees if you write something to it.
-   *
-   * This method happens **in the render phase**. It can (and usually should) mutate the node it has
-   * just created before returning it, but it must not modify any other nodes. It must not register
-   * any event handlers on the parent tree. This is because an instance being created doesn't guarantee
-   * it would be placed in the tree — it could be left unused and later collected by GC. If you need to do
-   * something when an instance is definitely in the tree, look at `commitMount` instead.
-   */
-  createInstance(type, props, rootContainer, _hostContext, internalHandle) {
-    return {
-      tag: Tag.Instance,
-      type,
-      props,
-      isHidden: false,
-      children: [],
-      parent: null,
-      rootContainer,
-      unstable_fiber: internalHandle
-    };
-  },
-  /**
-   * #### `createTextInstance(text, rootContainer, hostContext, internalHandle)`
-   *
-   * Same as `createInstance`, but for text nodes. If your renderer doesn't support text nodes, you can
-   * throw here.
-   */
-  createTextInstance(text, rootContainer, hostContext, _internalHandle) {
-    var _a;
-    if (rootContainer.config.textComponentTypes && !hostContext.isInsideText) {
-      const componentTypes = (_a = rootContainer.config.publicTextComponentTypes) != null ? _a : rootContainer.config.textComponentTypes;
-      throw new Error(
-        `Invariant Violation: Text strings must be rendered within a ${formatComponentList(
-          componentTypes
-        )} component. Detected attempt to render "${text}" string within a <${hostContext.type}> component.`
-      );
-    }
-    return {
-      tag: Tag.Text,
-      text,
-      parent: null,
-      isHidden: false
-    };
-  },
-  /**
-   * #### `appendInitialChild(parentInstance, child)`
-   *
-   * This method should mutate the `parentInstance` and add the child to its list of children.
-   * For example, in the DOM this would translate to a `parentInstance.appendChild(child)` call.
-   *
-   * This method happens **in the render phase**. It can mutate `parentInstance` and `child`, but it
-   * must not modify any other nodes. It's called while the tree is still being built up and not connected
-   * to the actual tree on the screen.
-   */
-  appendInitialChild: appendChild,
-  /**
-   * #### `finalizeInitialChildren(instance, type, props, rootContainer, hostContext)`
-   *
-   * In this method, you can perform some final mutations on the `instance`. Unlike with `createInstance`,
-   * by the time `finalizeInitialChildren` is called, all the initial children have already been added to
-   * the `instance`, but the instance itself has not yet been connected to the tree on the screen.
-   *
-   * This method happens **in the render phase**. It can mutate `instance`, but it must not modify any other
-   * nodes. It's called while the tree is still being built up and not connected to the actual tree on the screen.
-   *
-   * There is a second purpose to this method. It lets you specify whether there is some work that needs to
-   * happen when the node is connected to the tree on the screen. If you return `true`, the instance will
-   * receive a `commitMount` call later. See its documentation below.
-   *
-   * If you don't want to do anything here, you should return `false`.
-   */
-  finalizeInitialChildren(_instance, _type, _props, _rootContainer, _hostContext) {
-    return false;
-  },
-  /**
-   * #### `shouldSetTextContent(type, props)`
-   *
-   * Some target platforms support setting an instance's text content without manually creating a text node.
-   * For example, in the DOM, you can set `node.textContent` instead of creating a text node and appending it.
-   *
-   * If you return `true` from this method, React will assume that this node's children are text, and will
-   * not create nodes for them. It will instead rely on you to have filled that text during `createInstance`.
-   * This is a performance optimization. For example, the DOM renderer returns `true` only if `type` is a
-   * known text-only parent (like `'textarea'`) or if `props.children` has a `'string'` type. If you return `true`,
-   *  you will need to implement `resetTextContent` too.
-   *
-   * If you don't want to do anything here, you should return `false`.
-   * This method happens **in the render phase**. Do not mutate the tree from it.
-   */
-  shouldSetTextContent(_type, _props) {
-    return false;
-  },
-  setCurrentUpdatePriority(newPriority) {
-    currentUpdatePriority = newPriority;
-  },
-  getCurrentUpdatePriority() {
-    return currentUpdatePriority;
-  },
-  resolveUpdatePriority() {
-    return currentUpdatePriority || DefaultEventPriority;
-  },
-  shouldAttemptEagerTransition() {
-    return false;
-  },
-  /**
-   * #### `getRootHostContext(rootContainer)`
-   *
-   * This method lets you return the initial host context from the root of the tree. See `getChildHostContext`
-   * for the explanation of host context.
-   *
-   * If you don't intend to use host context, you can return `null`.
-   * This method happens **in the render phase**. Do not mutate the tree from it.
-   */
-  getRootHostContext(rootContainer) {
-    return {
-      type: "ROOT",
-      config: rootContainer.config,
-      isInsideText: false
-    };
-  },
-  /**
-   * #### `getChildHostContext(parentHostContext, type, rootContainer)`
-   *
-   * Host context lets you track some information about where you are in the tree so that it's available
-   * inside `createInstance` as the `hostContext` parameter. For example, the DOM renderer uses it to track
-   * whether it's inside an HTML or an SVG tree, because `createInstance` implementation needs to be
-   * different for them.
-   *
-   * If the node of this `type` does not influence the context you want to pass down, you can return
-   * `parentHostContext`. Alternatively, you can return any custom object representing the information
-   * you want to pass down.
-   *
-   * If you don't want to do anything here, return `parentHostContext`.
-   *
-   * This method happens **in the render phase**. Do not mutate the tree from it.
-   */
-  getChildHostContext(parentHostContext, type) {
-    var _a;
-    const isInsideText = Boolean((_a = parentHostContext.config.textComponentTypes) == null ? void 0 : _a.includes(type));
-    return __spreadProps(__spreadValues({}, parentHostContext), { type, isInsideText });
-  },
-  /**
-   * #### `getPublicInstance(instance)`
-   *
-   * Determines what object gets exposed as a ref. You'll likely want to return the `instance` itself. But
-   * in some cases it might make sense to only expose some part of it.
-   *
-   * If you don't want to do anything here, return `instance`.
-   */
-  getPublicInstance(instance) {
-    switch (instance.tag) {
-      case Tag.Instance: {
-        const createNodeMock = instance.rootContainer.config.createNodeMock;
-        const mockNode = createNodeMock({
-          type: instance.type,
-          props: instance.props,
-          key: null
-        });
-        nodeToInstanceMap.set(mockNode, instance);
-        return mockNode;
-      }
-      default:
-        return instance;
-    }
-  },
-  /**
-   * #### `prepareForCommit(containerInfo)`
-   *
-   * This method lets you store some information before React starts making changes to the tree on
-   * the screen. For example, the DOM renderer stores the current text selection so that it can later
-   * restore it. This method is mirrored by `resetAfterCommit`.
-   *
-   * Even if you don't want to do anything here, you need to return `null` from it.
-   */
-  prepareForCommit(_containerInfo) {
-    return null;
-  },
-  /**
-   * #### `resetAfterCommit(containerInfo)`
-   *
-   * This method is called right after React has performed the tree mutations. You can use it to restore
-   * something you've stored in `prepareForCommit` — for example, text selection.
-   *
-   * You can leave it empty.
-   */
-  resetAfterCommit(_containerInfo) {
-  },
-  /**
-   * #### `preparePortalMount(containerInfo)`
-   *
-   * This method is called for a container that's used as a portal target. Usually you can leave it empty.
-   */
-  preparePortalMount(_containerInfo) {
-  },
-  /**
-   * #### `scheduleTimeout(fn, delay)`
-   *
-   * You can proxy this to `setTimeout` or its equivalent in your environment.
-   */
-  scheduleTimeout: setTimeout,
-  /**
-   * #### `cancelTimeout(id)`
-   *
-   * You can proxy this to `clearTimeout` or its equivalent in your environment.
-   */
-  cancelTimeout: clearTimeout,
-  /**
-   * #### `noTimeout`
-   *
-   * This is a property (not a function) that should be set to something that can never be a valid timeout ID.
-   * For example, you can set it to `-1`.
-   */
-  noTimeout: -1,
-  /**
-   * #### `supportsMicrotasks`
-   *
-   * Set this to `true` to indicate that your renderer supports `scheduleMicrotask`. We use microtasks as part
-   * of our discrete event implementation in React DOM. If you're not sure if your renderer should support this,
-   * you probably should. The option to not implement `scheduleMicrotask` exists so that platforms with more control
-   * over user events, like React Native, can choose to use a different mechanism.
-   */
-  supportsMicrotasks: true,
-  /**
-   * #### `scheduleMicrotask(fn)`
-   *
-   * Optional. You can proxy this to `queueMicrotask` or its equivalent in your environment.
-   */
-  scheduleMicrotask: queueMicrotask,
-  /**
-   * #### `isPrimaryRenderer`
-   *
-   * This is a property (not a function) that should be set to `true` if your renderer is the main one on the
-   * page. For example, if you're writing a renderer for the Terminal, it makes sense to set it to `true`, but
-   * if your renderer is used *on top of* React DOM or some other existing renderer, set it to `false`.
-   */
-  isPrimaryRenderer: true,
-  /**
-   * Whether the renderer shouldn't trigger missing `act()` warnings
-   */
-  warnsIfNotActing: true,
-  getInstanceFromNode(node) {
-    const instance = nodeToInstanceMap.get(node);
-    if (instance !== void 0) {
-      return instance.unstable_fiber;
-    }
-    return null;
-  },
-  beforeActiveInstanceBlur() {
-  },
-  afterActiveInstanceBlur() {
-  },
-  prepareScopeUpdate(scopeInstance, instance) {
-    nodeToInstanceMap.set(scopeInstance, instance);
-  },
-  getInstanceFromScope(scopeInstance) {
-    var _a;
-    return (_a = nodeToInstanceMap.get(scopeInstance)) != null ? _a : null;
-  },
-  detachDeletedInstance(_node) {
-  },
-  /**
-   * #### `appendChild(parentInstance, child)`
-   *
-   * This method should mutate the `parentInstance` and add the child to its list of children. For example,
-   * in the DOM this would translate to a `parentInstance.appendChild(child)` call.
-   *
-   * Although this method currently runs in the commit phase, you still should not mutate any other nodes
-   * in it. If you need to do some additional work when a node is definitely connected to the visible tree, look at `commitMount`.
-   */
-  appendChild,
-  /**
-   * #### `appendChildToContainer(container, child)`
-   *
-   * Same as `appendChild`, but for when a node is attached to the root container. This is useful if attaching
-   * to the root has a slightly different implementation, or if the root container nodes are of a different
-   * type than the rest of the tree.
-   */
-  appendChildToContainer: appendChild,
-  /**
-   * #### `insertBefore(parentInstance, child, beforeChild)`
-   *
-   * This method should mutate the `parentInstance` and place the `child` before `beforeChild` in the list of
-   * its children. For example, in the DOM this would translate to a `parentInstance.insertBefore(child, beforeChild)` call.
-   *
-   * Note that React uses this method both for insertions and for reordering nodes. Similar to DOM, it is expected
-   * that you can call `insertBefore` to reposition an existing child. Do not mutate any other parts of the tree from it.
-   */
-  insertBefore,
-  /**
-   * #### `insertInContainerBefore(container, child, beforeChild)
-   *
-   * Same as `insertBefore`, but for when a node is attached to the root container. This is useful if attaching
-   * to the root has a slightly different implementation, or if the root container nodes are of a different type
-   * than the rest of the tree.
-   */
-  insertInContainerBefore: insertBefore,
-  /**
-   * #### `removeChild(parentInstance, child)`
-   *
-   * This method should mutate the `parentInstance` to remove the `child` from the list of its children.
-   *
-   * React will only call it for the top-level node that is being removed. It is expected that garbage collection
-   * would take care of the whole subtree. You are not expected to traverse the child tree in it.
-   */
-  removeChild,
-  /**
-   * #### `removeChildFromContainer(container, child)`
-   *
-   * Same as `removeChild`, but for when a node is detached from the root container. This is useful if attaching
-   * to the root has a slightly different implementation, or if the root container nodes are of a different type
-   * than the rest of the tree.
-   */
-  removeChildFromContainer: removeChild,
-  /**
-   * #### `resetTextContent(instance)`
-   *
-   * If you returned `true` from `shouldSetTextContent` for the previous props, but returned `false` from
-   * `shouldSetTextContent` for the next props, React will call this method so that you can clear the text
-   * content you were managing manually. For example, in the DOM you could set `node.textContent = ''`.
-   *
-   * If you never return `true` from `shouldSetTextContent`, you can leave it empty.
-   */
-  resetTextContent(_instance) {
-  },
-  /**
-   * #### `commitTextUpdate(textInstance, prevText, nextText)`
-   *
-   * This method should mutate the `textInstance` and update its text content to `nextText`.
-   *
-   * Here, `textInstance` is a node created by `createTextInstance`.
-   */
-  commitTextUpdate(textInstance, _oldText, newText) {
-    textInstance.text = newText;
-  },
-  /**
-   * #### `commitMount(instance, type, props, internalHandle)`
-   *
-   * This method is only called if you returned `true` from `finalizeInitialChildren` for this instance.
-   *
-   * It lets you do some additional work after the node is actually attached to the tree on the screen for
-   * the first time. For example, the DOM renderer uses it to trigger focus on nodes with the `autoFocus` attribute.
-   *
-   * Note that `commitMount` does not mirror `removeChild` one to one because `removeChild` is only called for
-   * the top-level removed node. This is why ideally `commitMount` should not mutate any nodes other than the
-   * `instance` itself. For example, if it registers some events on some node above, it will be your responsibility
-   * to traverse the tree in `removeChild` and clean them up, which is not ideal.
-   *
-   * The `internalHandle` data structure is meant to be opaque. If you bend the rules and rely on its internal
-   * fields, be aware that it may change significantly between versions. You're taking on additional maintenance
-   * risk by reading from it, and giving up all guarantees if you write something to it.
-   *
-   * If you never return `true` from `finalizeInitialChildren`, you can leave it empty.
-   */
-  commitMount(_instance, _type, _props, _internalHandle) {
-  },
-  /**
-   * #### `commitUpdate(instance, type, prevProps, nextProps, internalHandle)`
-   *
-   * This method should mutate the `instance` according to the set of changes in `updatePayload`. Here, `updatePayload`
-   *  is the object that you've returned from `prepareUpdate` and has an arbitrary structure that makes sense for your
-   * renderer. For example, the DOM renderer returns an update payload like `[prop1, value1, prop2, value2, ...]` from
-   * `prepareUpdate`, and that structure gets passed into `commitUpdate`. Ideally, all the diffing and calculation
-   * should happen inside `prepareUpdate` so that `commitUpdate` can be fast and straightforward.
-   *
-   * The `internalHandle` data structure is meant to be opaque. If you bend the rules and rely on its internal fields,
-   *  be aware that it may change significantly between versions. You're taking on additional maintenance risk by
-   * reading from it, and giving up all guarantees if you write something to it.
-   */
-  // @ts-expect-error @types/react-reconciler types don't fully match react-reconciler's actual Flow types.
-  // Correctness is verified through tests.
-  commitUpdate(instance, type, _prevProps, nextProps, internalHandle) {
-    instance.type = type;
-    instance.props = nextProps;
-    instance.unstable_fiber = internalHandle;
-  },
-  /**
-   * #### `hideInstance(instance)`
-   *
-   * This method should make the `instance` invisible without removing it from the tree. For example, it can apply
-   * visual styling to hide it. It is used by Suspense to hide the tree while the fallback is visible.
-   */
-  hideInstance(instance) {
-    instance.isHidden = true;
-  },
-  /**
-   * #### `hideTextInstance(textInstance)`
-   *
-   * Same as `hideInstance`, but for nodes created by `createTextInstance`.
-   */
-  hideTextInstance(textInstance) {
-    textInstance.isHidden = true;
-  },
-  /**
-   * #### `unhideInstance(instance, props)`
-   *
-   * This method should make the `instance` visible, undoing what `hideInstance` did.
-   */
-  unhideInstance(instance, _props) {
-    instance.isHidden = false;
-  },
-  /**
-   * #### `unhideTextInstance(textInstance, text)`
-   *
-   * Same as `unhideInstance`, but for nodes created by `createTextInstance`.
-   */
-  unhideTextInstance(textInstance, _text) {
-    textInstance.isHidden = false;
-  },
-  /**
-   * #### `clearContainer(container)`
-   *
-   * This method should mutate the `container` root node and remove all children from it.
-   */
-  clearContainer(container) {
-    container.children.forEach((child) => {
-      child.parent = null;
-    });
-    container.children.splice(0);
-  },
-  /**
-   * #### `maySuspendCommit(type, props)`
-   *
-   * This method is called during render to determine if the Host Component type and props require
-   * some kind of loading process to complete before committing an update.
-   */
-  maySuspendCommit(_type, _props) {
-    return false;
-  },
-  /**
-   * #### `preloadInstance(type, props)`
-   *
-   * This method may be called during render if the Host Component type and props might suspend a commit.
-   * It can be used to initiate any work that might shorten the duration of a suspended commit.
-   */
-  preloadInstance(_type, _props) {
-    return true;
-  },
-  /**
-   * #### `startSuspendingCommit()`
-   *
-   * This method is called just before the commit phase. Use it to set up any necessary state while any Host
-   * Components that might suspend this commit are evaluated to determine if the commit must be suspended.
-   */
-  startSuspendingCommit() {
-  },
-  /**
-   * #### `suspendInstance(type, props)`
-   *
-   * This method is called after `startSuspendingCommit` for each Host Component that indicated it might
-   * suspend a commit.
-   */
-  suspendInstance() {
-  },
-  /**
-   * #### `waitForCommitToBeReady()`
-   *
-   * This method is called after all `suspendInstance` calls are complete.
-   *
-   * Return `null` if the commit can happen immediately.
-   * Return `(initiateCommit: Function) => Function` if the commit must be suspended. The argument to this
-   * callback will initiate the commit when called. The return value is a cancellation function that the
-   * Reconciler can use to abort the commit.
-   */
-  waitForCommitToBeReady() {
-    return null;
-  },
-  // -------------------
-  // Hydration Methods
-  //    (optional)
-  // You can optionally implement hydration to "attach" to the existing tree during the initial render instead
-  // of creating it from scratch. For example, the DOM renderer uses this to attach to an HTML markup.
-  //
-  // To support hydration, you need to declare `supportsHydration: true` and then implement the methods in
-  // the "Hydration" section [listed in this file](https://github.com/facebook/react/blob/master/packages/react-reconciler/src/forks/ReactFiberHostConfig.custom.js).
-  // File an issue if you need help.
-  // -------------------
-  supportsHydration: false,
-  NotPendingTransition: null,
-  resetFormInstance(_form) {
-  },
-  requestPostPaintCallback(_callback) {
-  }
-};
-var TestReconciler = ReactReconciler(hostConfig);
+//#endregion
+//#region src/reconciler.ts
+const nodeToInstanceMap = /* @__PURE__ */ new WeakMap();
+let currentUpdatePriority = NoEventPriority;
+const TestReconciler = ReactReconciler({
+	supportsMutation: true,
+	supportsPersistence: false,
+	createInstance(type, props, rootContainer, _hostContext, internalHandle) {
+		mark("reconciler/createInstance", { type });
+		return {
+			tag: Tag.Instance,
+			type,
+			props,
+			propsBeforeHiding: null,
+			isHidden: false,
+			children: [],
+			parent: null,
+			rootContainer,
+			unstable_fiber: internalHandle
+		};
+	},
+	createTextInstance(text, rootContainer, hostContext, _internalHandle) {
+		mark("reconciler/createTextInstance", { text });
+		if (rootContainer.config.textComponentTypes && !hostContext.isInsideText) {
+			const componentTypes = rootContainer.config.publicTextComponentTypes ?? rootContainer.config.textComponentTypes;
+			throw new Error(`Invariant Violation: Text strings must be rendered within a ${formatComponentList(componentTypes)} component. Detected attempt to render "${text}" string within a <${hostContext.type}> component.`);
+		}
+		return {
+			tag: Tag.Text,
+			text,
+			parent: null,
+			rootContainer,
+			isHidden: false
+		};
+	},
+	appendInitialChild(parentInstance, child) {
+		if (globalThis.TEST_RENDERER_ENABLE_PROFILING) mark("reconciler/appendInitialChild", {
+			parentType: parentInstance.type,
+			childType: formatInstanceType(child)
+		});
+		appendChild(parentInstance, child);
+	},
+	finalizeInitialChildren(instance, _type, _props, _rootContainer, _hostContext) {
+		mark("reconciler/finalizeInitialChildren", { type: instance.type });
+		return false;
+	},
+	shouldSetTextContent(type, _props) {
+		mark("reconciler/shouldSetTextContent", {
+			type,
+			result: false
+		});
+		return false;
+	},
+	setCurrentUpdatePriority(priority) {
+		mark("reconciler/setCurrentUpdatePriority", { priority });
+		currentUpdatePriority = priority;
+	},
+	getCurrentUpdatePriority() {
+		return currentUpdatePriority;
+	},
+	resolveUpdatePriority() {
+		const priority = currentUpdatePriority || DefaultEventPriority;
+		mark("reconciler/resolveUpdatePriority", { priority });
+		return priority;
+	},
+	trackSchedulerEvent() {
+		mark("reconciler/trackSchedulerEvent");
+	},
+	resolveEventType() {
+		mark("reconciler/resolveEventType");
+		return null;
+	},
+	resolveEventTimeStamp() {
+		const timestamp = -1.1;
+		mark("reconciler/resolveEventTimeStamp", { timestamp });
+		return timestamp;
+	},
+	shouldAttemptEagerTransition() {
+		mark("reconciler/shouldAttemptEagerTransition", { result: false });
+		return false;
+	},
+	getRootHostContext(rootContainer) {
+		mark("reconciler/getRootHostContext");
+		return {
+			type: "ROOT",
+			config: rootContainer.config,
+			isInsideText: false
+		};
+	},
+	getChildHostContext(parentHostContext, type) {
+		mark("reconciler/getChildHostContext", { type });
+		const isInsideText = Boolean(parentHostContext.config.textComponentTypes?.includes(type));
+		return {
+			...parentHostContext,
+			type,
+			isInsideText
+		};
+	},
+	getPublicInstance(instance) {
+		if (globalThis.TEST_RENDERER_ENABLE_PROFILING) mark("reconciler/getPublicInstance", { type: formatInstanceType(instance) });
+		switch (instance.tag) {
+			case Tag.Instance: {
+				const testInstance = TestInstance.fromInstance(instance);
+				nodeToInstanceMap.set(testInstance, instance);
+				return testInstance;
+			}
+			default: return null;
+		}
+	},
+	prepareForCommit(_containerInfo) {
+		mark("reconciler/prepareForCommit");
+		measureStart("react/commit");
+		return null;
+	},
+	resetAfterCommit(_containerInfo) {
+		measureEnd("react/commit");
+		mark("reconciler/resetAfterCommit");
+	},
+	preparePortalMount(_containerInfo) {
+		mark("reconciler/preparePortalMount");
+	},
+	scheduleTimeout(fn, delay) {
+		const id = setTimeout(() => {
+			mark("reconciler/scheduled timeout:start");
+			fn();
+			mark("reconciler/scheduled timeout:end");
+		}, delay);
+		mark("reconciler/scheduleTimeout", { id });
+		return id;
+	},
+	cancelTimeout(id) {
+		mark("reconciler/cancelTimeout", { id });
+		clearTimeout(id);
+	},
+	noTimeout: -1,
+	supportsMicrotasks: true,
+	scheduleMicrotask(fn) {
+		mark("reconciler/scheduleMicrotask");
+		queueMicrotask(() => {
+			mark("reconciler/scheduled microtask:start");
+			fn();
+			mark("reconciler/scheduled microtask:end");
+		});
+	},
+	isPrimaryRenderer: true,
+	warnsIfNotActing: true,
+	getInstanceFromNode(node) {
+		mark("reconciler/getInstanceFromNode");
+		const instance = nodeToInstanceMap.get(node);
+		if (instance !== void 0) return instance.unstable_fiber;
+		return null;
+	},
+	beforeActiveInstanceBlur() {
+		mark("reconciler/beforeActiveInstanceBlur");
+	},
+	afterActiveInstanceBlur() {
+		mark("reconciler/afterActiveInstanceBlur");
+	},
+	prepareScopeUpdate(scopeInstance, instance) {
+		mark("reconciler/prepareScopeUpdate");
+		nodeToInstanceMap.set(scopeInstance, instance);
+	},
+	getInstanceFromScope(scopeInstance) {
+		mark("reconciler/getInstanceFromScope");
+		return nodeToInstanceMap.get(scopeInstance) ?? null;
+	},
+	detachDeletedInstance(_node) {
+		mark("reconciler/detachDeletedInstance");
+	},
+	appendChild(parentInstance, child) {
+		if (globalThis.TEST_RENDERER_ENABLE_PROFILING) mark("reconciler/appendChild", {
+			parentType: parentInstance.type,
+			childType: formatInstanceType(child)
+		});
+		appendChild(parentInstance, child);
+	},
+	appendChildToContainer(container, child) {
+		if (globalThis.TEST_RENDERER_ENABLE_PROFILING) mark("reconciler/appendChildToContainer", { childType: formatInstanceType(child) });
+		appendChild(container, child);
+	},
+	insertBefore(parentInstance, child, beforeChild) {
+		if (globalThis.TEST_RENDERER_ENABLE_PROFILING) mark("reconciler/insertBefore", {
+			parentType: parentInstance.type,
+			childType: formatInstanceType(child),
+			beforeChildType: formatInstanceType(beforeChild)
+		});
+		insertBefore(parentInstance, child, beforeChild);
+	},
+	insertInContainerBefore(container, child, beforeChild) {
+		if (globalThis.TEST_RENDERER_ENABLE_PROFILING) mark("reconciler/insertInContainerBefore", {
+			childType: formatInstanceType(child),
+			beforeChildType: formatInstanceType(beforeChild)
+		});
+		insertBefore(container, child, beforeChild);
+	},
+	removeChild(parentInstance, child) {
+		if (globalThis.TEST_RENDERER_ENABLE_PROFILING) mark("reconciler/removeChild", {
+			parentType: parentInstance.type,
+			childType: formatInstanceType(child)
+		});
+		removeChild(parentInstance, child);
+	},
+	removeChildFromContainer(container, child) {
+		if (globalThis.TEST_RENDERER_ENABLE_PROFILING) mark("reconciler/removeChildFromContainer", { childType: formatInstanceType(child) });
+		removeChild(container, child);
+	},
+	resetTextContent(instance) {
+		mark("reconciler/resetTextContent", { type: instance.type });
+	},
+	commitTextUpdate(textInstance, oldText, newText) {
+		mark("reconciler/commitTextUpdate", {
+			oldText,
+			newText
+		});
+		textInstance.text = newText;
+	},
+	commitMount(_instance, type, _props, _internalHandle) {
+		mark("reconciler/commitMount", { type });
+	},
+	commitUpdate(instance, type, _prevProps, nextProps, internalHandle) {
+		mark("reconciler/commitUpdate", { type });
+		instance.type = type;
+		if (instance.isHidden && instance.rootContainer.config.transformHiddenInstanceProps != null) {
+			instance.propsBeforeHiding = nextProps;
+			instance.props = instance.rootContainer.config.transformHiddenInstanceProps({
+				props: nextProps,
+				type: instance.type
+			});
+		} else {
+			instance.props = nextProps;
+			instance.propsBeforeHiding = null;
+		}
+		instance.unstable_fiber = internalHandle;
+	},
+	hideInstance(instance) {
+		mark("reconciler/hideInstance", { type: instance.type });
+		if (instance.isHidden) return;
+		instance.isHidden = true;
+		instance.propsBeforeHiding = instance.props;
+		const transformHiddenInstanceProps = instance.rootContainer.config.transformHiddenInstanceProps;
+		if (transformHiddenInstanceProps) {
+			const { props, type } = instance;
+			instance.props = transformHiddenInstanceProps({
+				props,
+				type
+			});
+		}
+	},
+	hideTextInstance(textInstance) {
+		mark("reconciler/hideTextInstance", { text: textInstance.text });
+		textInstance.isHidden = true;
+	},
+	unhideInstance(instance, _props) {
+		mark("reconciler/unhideInstance", { type: instance.type });
+		instance.isHidden = false;
+		if (instance.rootContainer.config.transformHiddenInstanceProps && instance.propsBeforeHiding) {
+			instance.props = instance.propsBeforeHiding;
+			instance.propsBeforeHiding = null;
+		}
+	},
+	unhideTextInstance(textInstance, _text) {
+		mark("reconciler/unhideTextInstance", { text: textInstance.text });
+		textInstance.isHidden = false;
+	},
+	clearContainer(container) {
+		mark("reconciler/clearContainer");
+		container.children.forEach((child) => {
+			child.parent = null;
+		});
+		container.children.splice(0);
+	},
+	maySuspendCommit(type, _props) {
+		mark("reconciler/maySuspendCommit", { type });
+		return false;
+	},
+	preloadInstance(type, _props) {
+		mark("reconciler/preloadInstance", { type });
+		return true;
+	},
+	startSuspendingCommit() {
+		mark("reconciler/startSuspendingCommit");
+	},
+	suspendInstance(type, _props) {
+		mark("reconciler/suspendInstance", { type });
+	},
+	waitForCommitToBeReady(type, _props) {
+		mark("reconciler/waitForCommitToBeReady", { type });
+		return null;
+	},
+	supportsHydration: false,
+	NotPendingTransition: null,
+	resetFormInstance(_form) {
+		mark("reconciler/resetFormInstance");
+	},
+	requestPostPaintCallback(_callback) {
+		mark("reconciler/requestPostPaintCallback");
+	}
+});
+/**
+* This method should mutate the `parentInstance` and add the child to its list of children. For example,
+* in the DOM this would translate to a `parentInstance.appendChild(child)` call.
+*
+* Although this method currently runs in the commit phase, you still should not mutate any other nodes
+* in it. If you need to do some additional work when a node is definitely connected to the visible tree,
+* look at `commitMount`.
+*/
 function appendChild(parentInstance, child) {
-  const index = parentInstance.children.indexOf(child);
-  if (index !== -1) {
-    parentInstance.children.splice(index, 1);
-  }
-  child.parent = parentInstance;
-  parentInstance.children.push(child);
+	const index = parentInstance.children.indexOf(child);
+	if (index !== -1) parentInstance.children.splice(index, 1);
+	child.parent = parentInstance;
+	parentInstance.children.push(child);
 }
+/**
+* This method should mutate the `parentInstance` and place the `child` before `beforeChild` in the list
+* of its children. For example, in the DOM this would translate to a
+* `parentInstance.insertBefore(child, beforeChild)` call.
+*
+* Note that React uses this method both for insertions and for reordering nodes. Similar to DOM, it is
+* expected that you can call `insertBefore` to reposition an existing child. Do not mutate any other parts
+* of the tree from it.
+*/
 function insertBefore(parentInstance, child, beforeChild) {
-  const index = parentInstance.children.indexOf(child);
-  if (index !== -1) {
-    parentInstance.children.splice(index, 1);
-  }
-  child.parent = parentInstance;
-  const beforeIndex = parentInstance.children.indexOf(beforeChild);
-  parentInstance.children.splice(beforeIndex, 0, child);
+	const index = parentInstance.children.indexOf(child);
+	if (index !== -1) parentInstance.children.splice(index, 1);
+	child.parent = parentInstance;
+	const beforeIndex = parentInstance.children.indexOf(beforeChild);
+	parentInstance.children.splice(beforeIndex, 0, child);
 }
+/**
+* This method should mutate the `parentInstance` to remove the `child` from the list of its children.
+*
+* React will only call it for the top-level node that is being removed. It is expected that garbage
+* collection would take care of the whole subtree. You are not expected to traverse the child tree in it.
+*/
 function removeChild(parentInstance, child) {
-  const index = parentInstance.children.indexOf(child);
-  parentInstance.children.splice(index, 1);
-  child.parent = null;
+	const index = parentInstance.children.indexOf(child);
+	parentInstance.children.splice(index, 1);
+	child.parent = null;
 }
-
-// src/renderer.ts
-var defaultCreateMockNode = () => ({});
-var defaultOnUncaughtError = (error, errorInfo) => {
-  console.error("Uncaught error:", error, errorInfo);
+function formatInstanceType(instance) {
+	return instance.tag === Tag.Text ? `text: "${instance.text}"` : instance.type;
+}
+//#endregion
+//#region src/renderer.ts
+const defaultOnUncaughtError = (error, errorInfo) => {
+	console.error("Uncaught error:", error, errorInfo);
 };
-var defaultOnCaughtError = (error, errorInfo) => {
-  console.error("Caught error:", error, errorInfo);
+const defaultOnCaughtError = (error, errorInfo) => {
+	console.error("Caught error:", error, errorInfo);
 };
-var defaultOnRecoverableError = (error, errorInfo) => {
-  console.error("Recoverable error:", error, errorInfo);
+const defaultOnRecoverableError = (error, errorInfo) => {
+	console.error("Recoverable error:", error, errorInfo);
 };
+/**
+* Create a new test renderer root instance.
+*
+* @param options - Optional configuration for the renderer.
+* @returns A Root instance with render, unmount, and container properties.
+*/
 function createRoot(options) {
-  var _a, _b, _c, _d, _e, _f;
-  let container = {
-    tag: Tag.Container,
-    parent: null,
-    children: [],
-    isHidden: false,
-    config: {
-      textComponentTypes: options == null ? void 0 : options.textComponentTypes,
-      publicTextComponentTypes: options == null ? void 0 : options.publicTextComponentTypes,
-      createNodeMock: (_a = options == null ? void 0 : options.createNodeMock) != null ? _a : defaultCreateMockNode
-    }
-  };
-  let containerFiber = TestReconciler.createContainer(
-    container,
-    ConcurrentRoot,
-    null,
-    // hydrationCallbacks
-    (_b = options == null ? void 0 : options.isStrictMode) != null ? _b : false,
-    false,
-    // concurrentUpdatesByDefaultOverride
-    (_c = options == null ? void 0 : options.identifierPrefix) != null ? _c : "",
-    (_d = options == null ? void 0 : options.onUncaughtError) != null ? _d : defaultOnUncaughtError,
-    (_e = options == null ? void 0 : options.onCaughtError) != null ? _e : defaultOnCaughtError,
-    // @ts-expect-error @types/react-reconciler types don't include onRecoverableError parameter
-    // in the createContainer signature, but react-reconciler's actual Flow types do.
-    // Correctness is verified through tests.
-    (_f = options == null ? void 0 : options.onRecoverableError) != null ? _f : defaultOnRecoverableError,
-    null
-    // transitionCallbacks
-  );
-  const render = (element) => {
-    if (containerFiber == null) {
-      throw new Error("Cannot render after unmount");
-    }
-    TestReconciler.updateContainer(element, containerFiber, null, null);
-  };
-  const unmount = () => {
-    if (container == null) {
-      return;
-    }
-    TestReconciler.updateContainer(null, containerFiber, null, null);
-    containerFiber = null;
-    container = null;
-  };
-  return {
-    render,
-    unmount,
-    get container() {
-      if (container == null) {
-        throw new Error("Cannot access .container on unmounted test renderer");
-      }
-      return HostElement.fromInstance(container);
-    }
-  };
+	measureStart("createRoot");
+	let container = {
+		tag: Tag.Container,
+		parent: null,
+		children: [],
+		isHidden: false,
+		config: {
+			textComponentTypes: options?.textComponentTypes,
+			publicTextComponentTypes: options?.publicTextComponentTypes,
+			transformHiddenInstanceProps: options?.transformHiddenInstanceProps
+		}
+	};
+	let containerFiber = TestReconciler.createContainer(container, ConcurrentRoot, null, options?.isStrictMode ?? false, false, options?.identifierPrefix ?? "", options?.onUncaughtError ?? defaultOnUncaughtError, options?.onCaughtError ?? defaultOnCaughtError, options?.onRecoverableError ?? defaultOnRecoverableError, null);
+	measureEnd("createRoot");
+	const render = (element) => {
+		if (containerFiber == null) throw new Error("Cannot render after unmount");
+		measureStart("render");
+		try {
+			TestReconciler.updateContainer(element, containerFiber, null, null);
+		} finally {
+			measureEnd("render", { elementType: String(element.type) });
+		}
+	};
+	const unmount = () => {
+		if (container == null) return;
+		measureStart("unmount");
+		try {
+			TestReconciler.updateContainer(null, containerFiber, null, null);
+		} finally {
+			measureEnd("unmount");
+		}
+		containerFiber = null;
+		container = null;
+	};
+	return {
+		render,
+		unmount,
+		get container() {
+			if (container == null) throw new Error("Cannot access .container on unmounted test renderer");
+			return TestInstance.fromInstance(container);
+		}
+	};
 }
-export {
-  createRoot
-};
+//#endregion
+export { createRoot };
+
 //# sourceMappingURL=index.js.map