@vickbk/tests 0.0.0-stage → 0.2.0

package/dist/promises.d.cts

@@ -0,0 +1,34 @@
+//#region src/features/promises/utils/resolvedPromise.d.ts
+/**
+ * Creates a fulfilled promise augmented with Vitest's fulfilled-promise metadata.
+ *
+ * @param value The value with which the promise is fulfilled.
+ * @returns A fulfilled Promise<T> with `status: "fulfilled"` and its `value`.
+ * @example
+ * ```ts
+ * const payload = await resolvedPromise({ id: 1 });
+ * expect(payload).toEqual({ id: 1 });
+ * ```
+ */
+export declare function resolvedPromise<T>(value: T): Promise<T> & {
+  status: "fulfilled";
+  value: T;
+};
+//#endregion
+//#region src/features/promises/utils/rejectedPromise.d.ts
+/**
+ * Creates a rejected promise augmented with Vitest's rejected-promise metadata.
+ *
+ * @param reason The rejection reason, preserved as an unknown value; defaults to `undefined`.
+ * @returns A rejected Promise<never> with `status: "rejected"` and its `reason`.
+ * @example
+ * ```ts
+ * await expect(rejectedPromise(new Error("Request failed"))).rejects.toThrow("Request failed");
+ * ```
+ */
+export declare function rejectedPromise(reason?: unknown): Promise<never> & {
+  status: "rejected";
+  reason: unknown;
+};
+//#endregion
+//# sourceMappingURL=promises.d.cts.map

package/dist/promises.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promises.d.cts","names":[],"sources":["../src/features/promises/utils/resolvedPromise.ts","../src/features/promises/utils/rejectedPromise.ts"],"mappings":";;;;;;;;;;;;wBAWgB,gBAAgB,GAC9B,OAAO,IACN,QAAQ;EAAO;EAAqB,OAAO;;;;;;;;;;;;;;wBCH9B,gBACd,mBACC;EAAmB;EAAoB"}

package/dist/promises.d.mts

@@ -0,0 +1,34 @@
+//#region src/features/promises/utils/resolvedPromise.d.ts
+/**
+ * Creates a fulfilled promise augmented with Vitest's fulfilled-promise metadata.
+ *
+ * @param value The value with which the promise is fulfilled.
+ * @returns A fulfilled Promise<T> with `status: "fulfilled"` and its `value`.
+ * @example
+ * ```ts
+ * const payload = await resolvedPromise({ id: 1 });
+ * expect(payload).toEqual({ id: 1 });
+ * ```
+ */
+export declare function resolvedPromise<T>(value: T): Promise<T> & {
+  status: "fulfilled";
+  value: T;
+};
+//#endregion
+//#region src/features/promises/utils/rejectedPromise.d.ts
+/**
+ * Creates a rejected promise augmented with Vitest's rejected-promise metadata.
+ *
+ * @param reason The rejection reason, preserved as an unknown value; defaults to `undefined`.
+ * @returns A rejected Promise<never> with `status: "rejected"` and its `reason`.
+ * @example
+ * ```ts
+ * await expect(rejectedPromise(new Error("Request failed"))).rejects.toThrow("Request failed");
+ * ```
+ */
+export declare function rejectedPromise(reason?: unknown): Promise<never> & {
+  status: "rejected";
+  reason: unknown;
+};
+//#endregion
+//# sourceMappingURL=promises.d.mts.map

package/dist/promises.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promises.d.mts","names":[],"sources":["../src/features/promises/utils/resolvedPromise.ts","../src/features/promises/utils/rejectedPromise.ts"],"mappings":";;;;;;;;;;;;wBAWgB,gBAAgB,GAC9B,OAAO,IACN,QAAQ;EAAO;EAAqB,OAAO;;;;;;;;;;;;;;wBCH9B,gBACd,mBACC;EAAmB;EAAoB"}

package/dist/promises.mjs

@@ -0,0 +1,43 @@
+//#region src/features/promises/utils/resolvedPromise.ts
+/**
+* Creates a fulfilled promise augmented with Vitest's fulfilled-promise metadata.
+*
+* @param value The value with which the promise is fulfilled.
+* @returns A fulfilled Promise<T> with `status: "fulfilled"` and its `value`.
+* @example
+* ```ts
+* const payload = await resolvedPromise({ id: 1 });
+* expect(payload).toEqual({ id: 1 });
+* ```
+*/
+function resolvedPromise(value) {
+	const promise = Promise.resolve(value);
+	return Object.assign(promise, {
+		status: "fulfilled",
+		value
+	});
+}
+//#endregion
+//#region src/features/promises/utils/rejectedPromise.ts
+/**
+* Creates a rejected promise augmented with Vitest's rejected-promise metadata.
+*
+* @param reason The rejection reason, preserved as an unknown value; defaults to `undefined`.
+* @returns A rejected Promise<never> with `status: "rejected"` and its `reason`.
+* @example
+* ```ts
+* await expect(rejectedPromise(new Error("Request failed"))).rejects.toThrow("Request failed");
+* ```
+*/
+function rejectedPromise(reason = void 0) {
+	const promise = Promise.reject(reason);
+	promise.catch((error) => error);
+	return Object.assign(promise, {
+		status: "rejected",
+		reason
+	});
+}
+//#endregion
+export { rejectedPromise, resolvedPromise };
+
+//# sourceMappingURL=promises.mjs.map

package/dist/promises.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"promises.mjs","names":[],"sources":["../src/features/promises/utils/resolvedPromise.ts","../src/features/promises/utils/rejectedPromise.ts"],"sourcesContent":["/**\n * Creates a fulfilled promise augmented with Vitest's fulfilled-promise metadata.\n *\n * @param value The value with which the promise is fulfilled.\n * @returns A fulfilled Promise<T> with `status: \"fulfilled\"` and its `value`.\n * @example\n * ```ts\n * const payload = await resolvedPromise({ id: 1 });\n * expect(payload).toEqual({ id: 1 });\n * ```\n */\nexport function resolvedPromise<T>(\n  value: T,\n): Promise<T> & { status: \"fulfilled\"; value: T } {\n  const promise = Promise.resolve(value);\n  return Object.assign(promise, { status: \"fulfilled\" as const, value });\n}\n","/**\n * Creates a rejected promise augmented with Vitest's rejected-promise metadata.\n *\n * @param reason The rejection reason, preserved as an unknown value; defaults to `undefined`.\n * @returns A rejected Promise<never> with `status: \"rejected\"` and its `reason`.\n * @example\n * ```ts\n * await expect(rejectedPromise(new Error(\"Request failed\"))).rejects.toThrow(\"Request failed\");\n * ```\n */\nexport function rejectedPromise(\n  reason: unknown = undefined,\n): Promise<never> & { status: \"rejected\"; reason: unknown } {\n  const promise = Promise.reject<never>(reason);\n\n  promise.catch((error) => error);\n\n  return Object.assign(promise, { status: \"rejected\" as const, reason });\n}\n"],"mappings":";;;;;;;;;;;;AAWA,SAAgB,gBACd,OACgD;CAChD,MAAM,UAAU,QAAQ,QAAQ,KAAK;CACrC,OAAO,OAAO,OAAO,SAAS;EAAE,QAAQ;EAAsB;CAAM,CAAC;AACvE;;;;;;;;;;;;;ACNA,SAAgB,gBACd,SAAkB,KAAA,GACwC;CAC1D,MAAM,UAAU,QAAQ,OAAc,MAAM;CAE5C,QAAQ,OAAO,UAAU,KAAK;CAE9B,OAAO,OAAO,OAAO,SAAS;EAAE,QAAQ;EAAqB;CAAO,CAAC;AACvE"}

package/dist/react.cjs

@@ -0,0 +1,173 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react, 1);
+//#region src/features/react/utils/resolveArrayChild.ts
+/**
+* Resolves one array child and supplies a stable key when the result is an
+* element without one.
+*
+* @param child - The child value to resolve.
+* @param index - The child's position in its containing array.
+* @param resolveTree - The recursive tree resolver.
+* @returns The resolved child.
+* @example
+* ```ts
+* await resolveArrayChild(<Page />, 0, resolveRscTree);
+* ```
+*/
+async function resolveArrayChild(child, index, resolveTree) {
+	const resolvedChild = await resolveTree(child);
+	if (react.isValidElement(resolvedChild)) {
+		const keyToUse = resolvedChild.key ?? child?.key ?? `rsc-key-${index}`;
+		return react.cloneElement(resolvedChild, { key: keyToUse });
+	}
+	return resolvedChild;
+}
+//#endregion
+//#region src/features/react/utils/isClassComponent.ts
+/**
+* Determines whether a component type is a React class component.
+*
+* @param type - The value to inspect.
+* @returns `true` when the value is a React class component.
+* @example
+* ```ts
+* isClassComponent(MyClassComponent); // true
+* ```
+*/
+function isClassComponent(type) {
+	return typeof type === "function" && Boolean(type.prototype?.isReactComponent);
+}
+//#endregion
+//#region src/features/react/utils/executeServerComponent.ts
+/**
+* Executes a server component and awaits an asynchronous result when present.
+* Component errors intentionally propagate to the caller.
+*
+* @param type - The server component to execute.
+* @param props - Props passed to the component.
+* @returns The component's resolved render result.
+* @example
+* ```ts
+* await executeServerComponent(Page, { title: "Hello" });
+* ```
+*/
+async function executeServerComponent(type, props) {
+	if (isClassComponent(type)) return new type(props).render();
+	return await type(props);
+}
+//#endregion
+//#region src/features/react/utils/isClientComponent.ts
+/**
+* Determines whether a component should be kept behind a client boundary.
+* React client/module references and functions containing hook calls are not
+* invoked directly by the resolver.
+*
+* @param type - The React element type to inspect.
+* @returns `true` when the type represents a client boundary.
+* @example
+* ```ts
+* isClientComponent({ $$typeof: Symbol.for("react.client.reference") }); // true
+* ```
+*/
+function isClientComponent(type) {
+	if (type === null || typeof type !== "function" && typeof type !== "object") return false;
+	const reference = type;
+	if (reference.$$typeof === Symbol.for("react.client.reference") || reference.$$typeof === Symbol.for("react.module.reference") || typeof reference.$$id === "string") return true;
+	return typeof type === "function" && /\buse[A-Z0-9_]\w*\s*\(/.test(Function.prototype.toString.call(type));
+}
+//#endregion
+//#region src/features/react/utils/resolveProps.ts
+/**
+* Resolves React elements and arrays nested in a component's props.
+*
+* @param props - The component props to inspect.
+* @param resolveTree - The recursive tree resolver.
+* @returns Updated props and whether any prop value changed.
+* @example
+* ```ts
+* const result = await resolveProps({ children: <Page /> }, resolveRscTree);
+* ```
+*/
+async function resolveProps(props, resolveTree) {
+	const newProps = { ...props };
+	let hasChanged = false;
+	for (const key of Object.keys(newProps)) {
+		const value = newProps[key];
+		if (react.isValidElement(value) || Array.isArray(value)) {
+			const resolved = await resolveTree(value);
+			if (resolved !== value) {
+				newProps[key] = resolved;
+				hasChanged = true;
+			}
+		}
+	}
+	return {
+		newProps,
+		hasChanged
+	};
+}
+//#endregion
+//#region src/features/react/utils/resolveElement.ts
+/**
+* Resolves a server component element or recursively updates its element props.
+* Client component boundaries remain untouched and component errors propagate.
+*
+* @param node - The React element to resolve.
+* @param resolveTree - The recursive tree resolver.
+* @returns The resolved render result or the updated original element.
+* @example
+* ```ts
+* await resolveElement(<ServerPage />, resolveRscTree);
+* ```
+*/
+async function resolveElement(node, resolveTree) {
+	const { type, props } = node;
+	if (typeof type === "function" && !isClientComponent(type)) return resolveTree(await executeServerComponent(type, props));
+	if (props && typeof props === "object") {
+		const { newProps, hasChanged } = await resolveProps(props, resolveTree);
+		if (hasChanged) return react.cloneElement(node, newProps);
+	}
+	return node;
+}
+//#endregion
+//#region src/features/react/utils/traverseTree.ts
+/**
+* Traverses arrays and React elements, delegating component resolution.
+*
+* @param node - The tree value to visit.
+* @param resolveTree - The recursive tree resolver.
+* @returns The traversed value with server components resolved.
+* @example
+* ```ts
+* await traverseTree(tree, resolveRscTree);
+* ```
+*/
+async function traverseTree(node, resolveTree) {
+	if (!node || typeof node !== "object") return node;
+	if (Array.isArray(node)) return Promise.all(node.map((child, index) => resolveArrayChild(child, index, resolveTree)));
+	if (react.isValidElement(node)) return resolveElement(node, resolveTree);
+	return node;
+}
+//#endregion
+//#region src/features/react/utils/resolveRscTree.ts
+/**
+* Recursively resolves synchronous and asynchronous React Server Components.
+* Client component boundaries are preserved, and component errors are allowed
+* to reject the returned promise.
+*
+* @param node - The React node or tree to resolve.
+* @returns A promise for the resolved React tree.
+* @example
+* ```ts
+* const resolved = await resolveRscTree(<ServerPage />);
+* ```
+*/
+async function resolveRscTree(node) {
+	return traverseTree(node, resolveRscTree);
+}
+//#endregion
+exports.resolveRscTree = resolveRscTree;
+
+//# sourceMappingURL=react.cjs.map

package/dist/react.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.cjs","names":["React","ClassComponent","FunctionComponent","React","React","React"],"sources":["../src/features/react/utils/resolveArrayChild.ts","../src/features/react/utils/isClassComponent.ts","../src/features/react/utils/executeServerComponent.ts","../src/features/react/utils/isClientComponent.ts","../src/features/react/utils/resolveProps.ts","../src/features/react/utils/resolveElement.ts","../src/features/react/utils/traverseTree.ts","../src/features/react/utils/resolveRscTree.ts"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport * as React from \"react\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Resolves one array child and supplies a stable key when the result is an\n * element without one.\n *\n * @param child - The child value to resolve.\n * @param index - The child's position in its containing array.\n * @param resolveTree - The recursive tree resolver.\n * @returns The resolved child.\n * @example\n * ```ts\n * await resolveArrayChild(<Page />, 0, resolveRscTree);\n * ```\n */\nexport async function resolveArrayChild(\n  child: ReactNode,\n  index: number,\n  resolveTree: ResolveTree,\n): Promise<ReactNode> {\n  const resolvedChild = await resolveTree(child);\n  if (React.isValidElement(resolvedChild)) {\n    const keyToUse =\n      resolvedChild.key ??\n      (child as { key?: string })?.key ??\n      `rsc-key-${index}`;\n    return React.cloneElement(resolvedChild, { key: keyToUse });\n  }\n  return resolvedChild;\n}\n","/**\n * Determines whether a component type is a React class component.\n *\n * @param type - The value to inspect.\n * @returns `true` when the value is a React class component.\n * @example\n * ```ts\n * isClassComponent(MyClassComponent); // true\n * ```\n */\nexport function isClassComponent(type: unknown): boolean {\n  return (\n    typeof type === \"function\" &&\n    Boolean(\n      (type as { prototype?: { isReactComponent?: unknown } }).prototype\n        ?.isReactComponent,\n    )\n  );\n}\n","import type * as React from \"react\";\nimport type { ReactNode } from \"react\";\nimport { isClassComponent } from \"./isClassComponent\";\n\n/**\n * Executes a server component and awaits an asynchronous result when present.\n * Component errors intentionally propagate to the caller.\n *\n * @param type - The server component to execute.\n * @param props - Props passed to the component.\n * @returns The component's resolved render result.\n * @example\n * ```ts\n * await executeServerComponent(Page, { title: \"Hello\" });\n * ```\n */\nexport async function executeServerComponent(\n  type: React.ComponentType<Record<string, unknown>>,\n  props: Record<string, unknown>,\n): Promise<ReactNode> {\n  if (isClassComponent(type)) {\n    const ClassComponent = type as React.ComponentClass<\n      Record<string, unknown>\n    >;\n    return new ClassComponent(props).render();\n  }\n\n  const FunctionComponent = type as React.FunctionComponent<\n    Record<string, unknown>\n  >;\n  return await FunctionComponent(props);\n}\n","/**\n * Determines whether a component should be kept behind a client boundary.\n * React client/module references and functions containing hook calls are not\n * invoked directly by the resolver.\n *\n * @param type - The React element type to inspect.\n * @returns `true` when the type represents a client boundary.\n * @example\n * ```ts\n * isClientComponent({ $$typeof: Symbol.for(\"react.client.reference\") }); // true\n * ```\n */\nexport function isClientComponent(type: unknown): boolean {\n  if (type === null || (typeof type !== \"function\" && typeof type !== \"object\")) {\n    return false;\n  }\n\n  const reference = type as { $$typeof?: symbol; $$id?: unknown };\n  if (\n    reference.$$typeof === Symbol.for(\"react.client.reference\") ||\n    reference.$$typeof === Symbol.for(\"react.module.reference\") ||\n    typeof reference.$$id === \"string\"\n  ) {\n    return true;\n  }\n\n  return (\n    typeof type === \"function\" &&\n    /\\buse[A-Z0-9_]\\w*\\s*\\(/.test(Function.prototype.toString.call(type))\n  );\n}\n","import * as React from \"react\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Resolves React elements and arrays nested in a component's props.\n *\n * @param props - The component props to inspect.\n * @param resolveTree - The recursive tree resolver.\n * @returns Updated props and whether any prop value changed.\n * @example\n * ```ts\n * const result = await resolveProps({ children: <Page /> }, resolveRscTree);\n * ```\n */\nexport async function resolveProps(\n  props: Record<string, unknown>,\n  resolveTree: ResolveTree,\n): Promise<{ newProps: Record<string, unknown>; hasChanged: boolean }> {\n  const newProps: Record<string, unknown> = { ...props };\n  let hasChanged = false;\n\n  for (const key of Object.keys(newProps)) {\n    const value = newProps[key];\n    if (React.isValidElement(value) || Array.isArray(value)) {\n      const resolved = await resolveTree(value as React.ReactNode);\n      if (resolved !== value) {\n        newProps[key] = resolved;\n        hasChanged = true;\n      }\n    }\n  }\n\n  return { newProps, hasChanged };\n}\n","import type { ReactNode } from \"react\";\nimport * as React from \"react\";\nimport { executeServerComponent } from \"./executeServerComponent\";\nimport { isClientComponent } from \"./isClientComponent\";\nimport { resolveProps } from \"./resolveProps\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Resolves a server component element or recursively updates its element props.\n * Client component boundaries remain untouched and component errors propagate.\n *\n * @param node - The React element to resolve.\n * @param resolveTree - The recursive tree resolver.\n * @returns The resolved render result or the updated original element.\n * @example\n * ```ts\n * await resolveElement(<ServerPage />, resolveRscTree);\n * ```\n */\nexport async function resolveElement(\n  node: React.ReactElement,\n  resolveTree: ResolveTree,\n): Promise<ReactNode> {\n  const { type, props } = node;\n\n  if (typeof type === \"function\" && !isClientComponent(type)) {\n    const serverResult = await executeServerComponent(\n      type as React.ComponentType<Record<string, unknown>>,\n      props as Record<string, unknown>,\n    );\n    return resolveTree(serverResult);\n  }\n\n  if (props && typeof props === \"object\") {\n    const { newProps, hasChanged } = await resolveProps(\n      props as Record<string, unknown>,\n      resolveTree,\n    );\n    if (hasChanged) {\n      return React.cloneElement(node, newProps);\n    }\n  }\n\n  return node;\n}\n","import * as React from \"react\";\nimport type { ReactNode } from \"react\";\nimport { resolveArrayChild } from \"./resolveArrayChild\";\nimport { resolveElement } from \"./resolveElement\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Traverses arrays and React elements, delegating component resolution.\n *\n * @param node - The tree value to visit.\n * @param resolveTree - The recursive tree resolver.\n * @returns The traversed value with server components resolved.\n * @example\n * ```ts\n * await traverseTree(tree, resolveRscTree);\n * ```\n */\nexport async function traverseTree(\n  node: ReactNode,\n  resolveTree: ResolveTree,\n): Promise<ReactNode> {\n  if (!node || typeof node !== \"object\") return node;\n\n  if (Array.isArray(node)) {\n    return Promise.all(\n      node.map((child, index) => resolveArrayChild(child, index, resolveTree)),\n    );\n  }\n\n  if (React.isValidElement(node)) {\n    return resolveElement(node, resolveTree);\n  }\n\n  return node;\n}\n","import type { ReactNode } from \"react\";\nimport { traverseTree } from \"./traverseTree\";\n\n/**\n * Recursively resolves synchronous and asynchronous React Server Components.\n * Client component boundaries are preserved, and component errors are allowed\n * to reject the returned promise.\n *\n * @param node - The React node or tree to resolve.\n * @returns A promise for the resolved React tree.\n * @example\n * ```ts\n * const resolved = await resolveRscTree(<ServerPage />);\n * ```\n */\nexport async function resolveRscTree(node: ReactNode): Promise<ReactNode> {\n  return traverseTree(node, resolveRscTree);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,eAAsB,kBACpB,OACA,OACA,aACoB;CACpB,MAAM,gBAAgB,MAAM,YAAY,KAAK;CAC7C,IAAIA,MAAM,eAAe,aAAa,GAAG;EACvC,MAAM,WACJ,cAAc,OACb,OAA4B,OAC7B,WAAW;EACb,OAAOA,MAAM,aAAa,eAAe,EAAE,KAAK,SAAS,CAAC;CAC5D;CACA,OAAO;AACT;;;;;;;;;;;;;ACrBA,SAAgB,iBAAiB,MAAwB;CACvD,OACE,OAAO,SAAS,cAChB,QACG,KAAwD,WACrD,gBACN;AAEJ;;;;;;;;;;;;;;;ACFA,eAAsB,uBACpB,MACA,OACoB;CACpB,IAAI,iBAAiB,IAAI,GAIvB,OAAO,IAAIC,KAAe,KAAK,CAAC,CAAC,OAAO;CAM1C,OAAO,MAAMC,KAAkB,KAAK;AACtC;;;;;;;;;;;;;;;ACnBA,SAAgB,kBAAkB,MAAwB;CACxD,IAAI,SAAS,QAAS,OAAO,SAAS,cAAc,OAAO,SAAS,UAClE,OAAO;CAGT,MAAM,YAAY;CAClB,IACE,UAAU,aAAa,OAAO,IAAI,wBAAwB,KAC1D,UAAU,aAAa,OAAO,IAAI,wBAAwB,KAC1D,OAAO,UAAU,SAAS,UAE1B,OAAO;CAGT,OACE,OAAO,SAAS,cAChB,yBAAyB,KAAK,SAAS,UAAU,SAAS,KAAK,IAAI,CAAC;AAExE;;;;;;;;;;;;;;AChBA,eAAsB,aACpB,OACA,aACqE;CACrE,MAAM,WAAoC,EAAE,GAAG,MAAM;CACrD,IAAI,aAAa;CAEjB,KAAK,MAAM,OAAO,OAAO,KAAK,QAAQ,GAAG;EACvC,MAAM,QAAQ,SAAS;EACvB,IAAIC,MAAM,eAAe,KAAK,KAAK,MAAM,QAAQ,KAAK,GAAG;GACvD,MAAM,WAAW,MAAM,YAAY,KAAwB;GAC3D,IAAI,aAAa,OAAO;IACtB,SAAS,OAAO;IAChB,aAAa;GACf;EACF;CACF;CAEA,OAAO;EAAE;EAAU;CAAW;AAChC;;;;;;;;;;;;;;;ACdA,eAAsB,eACpB,MACA,aACoB;CACpB,MAAM,EAAE,MAAM,UAAU;CAExB,IAAI,OAAO,SAAS,cAAc,CAAC,kBAAkB,IAAI,GAKvD,OAAO,YAAY,MAJQ,uBACzB,MACA,KACF,CAC+B;CAGjC,IAAI,SAAS,OAAO,UAAU,UAAU;EACtC,MAAM,EAAE,UAAU,eAAe,MAAM,aACrC,OACA,WACF;EACA,IAAI,YACF,OAAOC,MAAM,aAAa,MAAM,QAAQ;CAE5C;CAEA,OAAO;AACT;;;;;;;;;;;;;;AC3BA,eAAsB,aACpB,MACA,aACoB;CACpB,IAAI,CAAC,QAAQ,OAAO,SAAS,UAAU,OAAO;CAE9C,IAAI,MAAM,QAAQ,IAAI,GACpB,OAAO,QAAQ,IACb,KAAK,KAAK,OAAO,UAAU,kBAAkB,OAAO,OAAO,WAAW,CAAC,CACzE;CAGF,IAAIC,MAAM,eAAe,IAAI,GAC3B,OAAO,eAAe,MAAM,WAAW;CAGzC,OAAO;AACT;;;;;;;;;;;;;;;ACnBA,eAAsB,eAAe,MAAqC;CACxE,OAAO,aAAa,MAAM,cAAc;AAC1C"}

package/dist/react.d.cts

@@ -0,0 +1,17 @@
+import { ReactNode } from "react";
+//#region src/features/react/utils/resolveRscTree.d.ts
+/**
+ * Recursively resolves synchronous and asynchronous React Server Components.
+ * Client component boundaries are preserved, and component errors are allowed
+ * to reject the returned promise.
+ *
+ * @param node - The React node or tree to resolve.
+ * @returns A promise for the resolved React tree.
+ * @example
+ * ```ts
+ * const resolved = await resolveRscTree(<ServerPage />);
+ * ```
+ */
+export declare function resolveRscTree(node: ReactNode): Promise<ReactNode>;
+//#endregion
+//# sourceMappingURL=react.d.cts.map

package/dist/react.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.cts","names":[],"sources":["../src/features/react/utils/resolveRscTree.ts"],"mappings":";;;;;;;;;;;;;;wBAesB,eAAe,MAAM,YAAY,QAAQ"}

package/dist/react.d.mts

@@ -0,0 +1,17 @@
+import { ReactNode } from "react";
+//#region src/features/react/utils/resolveRscTree.d.ts
+/**
+ * Recursively resolves synchronous and asynchronous React Server Components.
+ * Client component boundaries are preserved, and component errors are allowed
+ * to reject the returned promise.
+ *
+ * @param node - The React node or tree to resolve.
+ * @returns A promise for the resolved React tree.
+ * @example
+ * ```ts
+ * const resolved = await resolveRscTree(<ServerPage />);
+ * ```
+ */
+export declare function resolveRscTree(node: ReactNode): Promise<ReactNode>;
+//#endregion
+//# sourceMappingURL=react.d.mts.map

package/dist/react.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.mts","names":[],"sources":["../src/features/react/utils/resolveRscTree.ts"],"mappings":";;;;;;;;;;;;;;wBAesB,eAAe,MAAM,YAAY,QAAQ"}

package/dist/react.mjs

@@ -0,0 +1,170 @@
+import * as React from "react";
+//#region src/features/react/utils/resolveArrayChild.ts
+/**
+* Resolves one array child and supplies a stable key when the result is an
+* element without one.
+*
+* @param child - The child value to resolve.
+* @param index - The child's position in its containing array.
+* @param resolveTree - The recursive tree resolver.
+* @returns The resolved child.
+* @example
+* ```ts
+* await resolveArrayChild(<Page />, 0, resolveRscTree);
+* ```
+*/
+async function resolveArrayChild(child, index, resolveTree) {
+	const resolvedChild = await resolveTree(child);
+	if (React.isValidElement(resolvedChild)) {
+		const keyToUse = resolvedChild.key ?? child?.key ?? `rsc-key-${index}`;
+		return React.cloneElement(resolvedChild, { key: keyToUse });
+	}
+	return resolvedChild;
+}
+//#endregion
+//#region src/features/react/utils/isClassComponent.ts
+/**
+* Determines whether a component type is a React class component.
+*
+* @param type - The value to inspect.
+* @returns `true` when the value is a React class component.
+* @example
+* ```ts
+* isClassComponent(MyClassComponent); // true
+* ```
+*/
+function isClassComponent(type) {
+	return typeof type === "function" && Boolean(type.prototype?.isReactComponent);
+}
+//#endregion
+//#region src/features/react/utils/executeServerComponent.ts
+/**
+* Executes a server component and awaits an asynchronous result when present.
+* Component errors intentionally propagate to the caller.
+*
+* @param type - The server component to execute.
+* @param props - Props passed to the component.
+* @returns The component's resolved render result.
+* @example
+* ```ts
+* await executeServerComponent(Page, { title: "Hello" });
+* ```
+*/
+async function executeServerComponent(type, props) {
+	if (isClassComponent(type)) return new type(props).render();
+	return await type(props);
+}
+//#endregion
+//#region src/features/react/utils/isClientComponent.ts
+/**
+* Determines whether a component should be kept behind a client boundary.
+* React client/module references and functions containing hook calls are not
+* invoked directly by the resolver.
+*
+* @param type - The React element type to inspect.
+* @returns `true` when the type represents a client boundary.
+* @example
+* ```ts
+* isClientComponent({ $$typeof: Symbol.for("react.client.reference") }); // true
+* ```
+*/
+function isClientComponent(type) {
+	if (type === null || typeof type !== "function" && typeof type !== "object") return false;
+	const reference = type;
+	if (reference.$$typeof === Symbol.for("react.client.reference") || reference.$$typeof === Symbol.for("react.module.reference") || typeof reference.$$id === "string") return true;
+	return typeof type === "function" && /\buse[A-Z0-9_]\w*\s*\(/.test(Function.prototype.toString.call(type));
+}
+//#endregion
+//#region src/features/react/utils/resolveProps.ts
+/**
+* Resolves React elements and arrays nested in a component's props.
+*
+* @param props - The component props to inspect.
+* @param resolveTree - The recursive tree resolver.
+* @returns Updated props and whether any prop value changed.
+* @example
+* ```ts
+* const result = await resolveProps({ children: <Page /> }, resolveRscTree);
+* ```
+*/
+async function resolveProps(props, resolveTree) {
+	const newProps = { ...props };
+	let hasChanged = false;
+	for (const key of Object.keys(newProps)) {
+		const value = newProps[key];
+		if (React.isValidElement(value) || Array.isArray(value)) {
+			const resolved = await resolveTree(value);
+			if (resolved !== value) {
+				newProps[key] = resolved;
+				hasChanged = true;
+			}
+		}
+	}
+	return {
+		newProps,
+		hasChanged
+	};
+}
+//#endregion
+//#region src/features/react/utils/resolveElement.ts
+/**
+* Resolves a server component element or recursively updates its element props.
+* Client component boundaries remain untouched and component errors propagate.
+*
+* @param node - The React element to resolve.
+* @param resolveTree - The recursive tree resolver.
+* @returns The resolved render result or the updated original element.
+* @example
+* ```ts
+* await resolveElement(<ServerPage />, resolveRscTree);
+* ```
+*/
+async function resolveElement(node, resolveTree) {
+	const { type, props } = node;
+	if (typeof type === "function" && !isClientComponent(type)) return resolveTree(await executeServerComponent(type, props));
+	if (props && typeof props === "object") {
+		const { newProps, hasChanged } = await resolveProps(props, resolveTree);
+		if (hasChanged) return React.cloneElement(node, newProps);
+	}
+	return node;
+}
+//#endregion
+//#region src/features/react/utils/traverseTree.ts
+/**
+* Traverses arrays and React elements, delegating component resolution.
+*
+* @param node - The tree value to visit.
+* @param resolveTree - The recursive tree resolver.
+* @returns The traversed value with server components resolved.
+* @example
+* ```ts
+* await traverseTree(tree, resolveRscTree);
+* ```
+*/
+async function traverseTree(node, resolveTree) {
+	if (!node || typeof node !== "object") return node;
+	if (Array.isArray(node)) return Promise.all(node.map((child, index) => resolveArrayChild(child, index, resolveTree)));
+	if (React.isValidElement(node)) return resolveElement(node, resolveTree);
+	return node;
+}
+//#endregion
+//#region src/features/react/utils/resolveRscTree.ts
+/**
+* Recursively resolves synchronous and asynchronous React Server Components.
+* Client component boundaries are preserved, and component errors are allowed
+* to reject the returned promise.
+*
+* @param node - The React node or tree to resolve.
+* @returns A promise for the resolved React tree.
+* @example
+* ```ts
+* const resolved = await resolveRscTree(<ServerPage />);
+* ```
+*/
+async function resolveRscTree(node) {
+	return traverseTree(node, resolveRscTree);
+}
+//#endregion
+export { resolveRscTree };
+
+//# sourceMappingURL=react.mjs.map

package/dist/react.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.mjs","names":["ClassComponent","FunctionComponent"],"sources":["../src/features/react/utils/resolveArrayChild.ts","../src/features/react/utils/isClassComponent.ts","../src/features/react/utils/executeServerComponent.ts","../src/features/react/utils/isClientComponent.ts","../src/features/react/utils/resolveProps.ts","../src/features/react/utils/resolveElement.ts","../src/features/react/utils/traverseTree.ts","../src/features/react/utils/resolveRscTree.ts"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport * as React from \"react\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Resolves one array child and supplies a stable key when the result is an\n * element without one.\n *\n * @param child - The child value to resolve.\n * @param index - The child's position in its containing array.\n * @param resolveTree - The recursive tree resolver.\n * @returns The resolved child.\n * @example\n * ```ts\n * await resolveArrayChild(<Page />, 0, resolveRscTree);\n * ```\n */\nexport async function resolveArrayChild(\n  child: ReactNode,\n  index: number,\n  resolveTree: ResolveTree,\n): Promise<ReactNode> {\n  const resolvedChild = await resolveTree(child);\n  if (React.isValidElement(resolvedChild)) {\n    const keyToUse =\n      resolvedChild.key ??\n      (child as { key?: string })?.key ??\n      `rsc-key-${index}`;\n    return React.cloneElement(resolvedChild, { key: keyToUse });\n  }\n  return resolvedChild;\n}\n","/**\n * Determines whether a component type is a React class component.\n *\n * @param type - The value to inspect.\n * @returns `true` when the value is a React class component.\n * @example\n * ```ts\n * isClassComponent(MyClassComponent); // true\n * ```\n */\nexport function isClassComponent(type: unknown): boolean {\n  return (\n    typeof type === \"function\" &&\n    Boolean(\n      (type as { prototype?: { isReactComponent?: unknown } }).prototype\n        ?.isReactComponent,\n    )\n  );\n}\n","import type * as React from \"react\";\nimport type { ReactNode } from \"react\";\nimport { isClassComponent } from \"./isClassComponent\";\n\n/**\n * Executes a server component and awaits an asynchronous result when present.\n * Component errors intentionally propagate to the caller.\n *\n * @param type - The server component to execute.\n * @param props - Props passed to the component.\n * @returns The component's resolved render result.\n * @example\n * ```ts\n * await executeServerComponent(Page, { title: \"Hello\" });\n * ```\n */\nexport async function executeServerComponent(\n  type: React.ComponentType<Record<string, unknown>>,\n  props: Record<string, unknown>,\n): Promise<ReactNode> {\n  if (isClassComponent(type)) {\n    const ClassComponent = type as React.ComponentClass<\n      Record<string, unknown>\n    >;\n    return new ClassComponent(props).render();\n  }\n\n  const FunctionComponent = type as React.FunctionComponent<\n    Record<string, unknown>\n  >;\n  return await FunctionComponent(props);\n}\n","/**\n * Determines whether a component should be kept behind a client boundary.\n * React client/module references and functions containing hook calls are not\n * invoked directly by the resolver.\n *\n * @param type - The React element type to inspect.\n * @returns `true` when the type represents a client boundary.\n * @example\n * ```ts\n * isClientComponent({ $$typeof: Symbol.for(\"react.client.reference\") }); // true\n * ```\n */\nexport function isClientComponent(type: unknown): boolean {\n  if (type === null || (typeof type !== \"function\" && typeof type !== \"object\")) {\n    return false;\n  }\n\n  const reference = type as { $$typeof?: symbol; $$id?: unknown };\n  if (\n    reference.$$typeof === Symbol.for(\"react.client.reference\") ||\n    reference.$$typeof === Symbol.for(\"react.module.reference\") ||\n    typeof reference.$$id === \"string\"\n  ) {\n    return true;\n  }\n\n  return (\n    typeof type === \"function\" &&\n    /\\buse[A-Z0-9_]\\w*\\s*\\(/.test(Function.prototype.toString.call(type))\n  );\n}\n","import * as React from \"react\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Resolves React elements and arrays nested in a component's props.\n *\n * @param props - The component props to inspect.\n * @param resolveTree - The recursive tree resolver.\n * @returns Updated props and whether any prop value changed.\n * @example\n * ```ts\n * const result = await resolveProps({ children: <Page /> }, resolveRscTree);\n * ```\n */\nexport async function resolveProps(\n  props: Record<string, unknown>,\n  resolveTree: ResolveTree,\n): Promise<{ newProps: Record<string, unknown>; hasChanged: boolean }> {\n  const newProps: Record<string, unknown> = { ...props };\n  let hasChanged = false;\n\n  for (const key of Object.keys(newProps)) {\n    const value = newProps[key];\n    if (React.isValidElement(value) || Array.isArray(value)) {\n      const resolved = await resolveTree(value as React.ReactNode);\n      if (resolved !== value) {\n        newProps[key] = resolved;\n        hasChanged = true;\n      }\n    }\n  }\n\n  return { newProps, hasChanged };\n}\n","import type { ReactNode } from \"react\";\nimport * as React from \"react\";\nimport { executeServerComponent } from \"./executeServerComponent\";\nimport { isClientComponent } from \"./isClientComponent\";\nimport { resolveProps } from \"./resolveProps\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Resolves a server component element or recursively updates its element props.\n * Client component boundaries remain untouched and component errors propagate.\n *\n * @param node - The React element to resolve.\n * @param resolveTree - The recursive tree resolver.\n * @returns The resolved render result or the updated original element.\n * @example\n * ```ts\n * await resolveElement(<ServerPage />, resolveRscTree);\n * ```\n */\nexport async function resolveElement(\n  node: React.ReactElement,\n  resolveTree: ResolveTree,\n): Promise<ReactNode> {\n  const { type, props } = node;\n\n  if (typeof type === \"function\" && !isClientComponent(type)) {\n    const serverResult = await executeServerComponent(\n      type as React.ComponentType<Record<string, unknown>>,\n      props as Record<string, unknown>,\n    );\n    return resolveTree(serverResult);\n  }\n\n  if (props && typeof props === \"object\") {\n    const { newProps, hasChanged } = await resolveProps(\n      props as Record<string, unknown>,\n      resolveTree,\n    );\n    if (hasChanged) {\n      return React.cloneElement(node, newProps);\n    }\n  }\n\n  return node;\n}\n","import * as React from \"react\";\nimport type { ReactNode } from \"react\";\nimport { resolveArrayChild } from \"./resolveArrayChild\";\nimport { resolveElement } from \"./resolveElement\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Traverses arrays and React elements, delegating component resolution.\n *\n * @param node - The tree value to visit.\n * @param resolveTree - The recursive tree resolver.\n * @returns The traversed value with server components resolved.\n * @example\n * ```ts\n * await traverseTree(tree, resolveRscTree);\n * ```\n */\nexport async function traverseTree(\n  node: ReactNode,\n  resolveTree: ResolveTree,\n): Promise<ReactNode> {\n  if (!node || typeof node !== \"object\") return node;\n\n  if (Array.isArray(node)) {\n    return Promise.all(\n      node.map((child, index) => resolveArrayChild(child, index, resolveTree)),\n    );\n  }\n\n  if (React.isValidElement(node)) {\n    return resolveElement(node, resolveTree);\n  }\n\n  return node;\n}\n","import type { ReactNode } from \"react\";\nimport { traverseTree } from \"./traverseTree\";\n\n/**\n * Recursively resolves synchronous and asynchronous React Server Components.\n * Client component boundaries are preserved, and component errors are allowed\n * to reject the returned promise.\n *\n * @param node - The React node or tree to resolve.\n * @returns A promise for the resolved React tree.\n * @example\n * ```ts\n * const resolved = await resolveRscTree(<ServerPage />);\n * ```\n */\nexport async function resolveRscTree(node: ReactNode): Promise<ReactNode> {\n  return traverseTree(node, resolveRscTree);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAiBA,eAAsB,kBACpB,OACA,OACA,aACoB;CACpB,MAAM,gBAAgB,MAAM,YAAY,KAAK;CAC7C,IAAI,MAAM,eAAe,aAAa,GAAG;EACvC,MAAM,WACJ,cAAc,OACb,OAA4B,OAC7B,WAAW;EACb,OAAO,MAAM,aAAa,eAAe,EAAE,KAAK,SAAS,CAAC;CAC5D;CACA,OAAO;AACT;;;;;;;;;;;;;ACrBA,SAAgB,iBAAiB,MAAwB;CACvD,OACE,OAAO,SAAS,cAChB,QACG,KAAwD,WACrD,gBACN;AAEJ;;;;;;;;;;;;;;;ACFA,eAAsB,uBACpB,MACA,OACoB;CACpB,IAAI,iBAAiB,IAAI,GAIvB,OAAO,IAAIA,KAAe,KAAK,CAAC,CAAC,OAAO;CAM1C,OAAO,MAAMC,KAAkB,KAAK;AACtC;;;;;;;;;;;;;;;ACnBA,SAAgB,kBAAkB,MAAwB;CACxD,IAAI,SAAS,QAAS,OAAO,SAAS,cAAc,OAAO,SAAS,UAClE,OAAO;CAGT,MAAM,YAAY;CAClB,IACE,UAAU,aAAa,OAAO,IAAI,wBAAwB,KAC1D,UAAU,aAAa,OAAO,IAAI,wBAAwB,KAC1D,OAAO,UAAU,SAAS,UAE1B,OAAO;CAGT,OACE,OAAO,SAAS,cAChB,yBAAyB,KAAK,SAAS,UAAU,SAAS,KAAK,IAAI,CAAC;AAExE;;;;;;;;;;;;;;AChBA,eAAsB,aACpB,OACA,aACqE;CACrE,MAAM,WAAoC,EAAE,GAAG,MAAM;CACrD,IAAI,aAAa;CAEjB,KAAK,MAAM,OAAO,OAAO,KAAK,QAAQ,GAAG;EACvC,MAAM,QAAQ,SAAS;EACvB,IAAI,MAAM,eAAe,KAAK,KAAK,MAAM,QAAQ,KAAK,GAAG;GACvD,MAAM,WAAW,MAAM,YAAY,KAAwB;GAC3D,IAAI,aAAa,OAAO;IACtB,SAAS,OAAO;IAChB,aAAa;GACf;EACF;CACF;CAEA,OAAO;EAAE;EAAU;CAAW;AAChC;;;;;;;;;;;;;;;ACdA,eAAsB,eACpB,MACA,aACoB;CACpB,MAAM,EAAE,MAAM,UAAU;CAExB,IAAI,OAAO,SAAS,cAAc,CAAC,kBAAkB,IAAI,GAKvD,OAAO,YAAY,MAJQ,uBACzB,MACA,KACF,CAC+B;CAGjC,IAAI,SAAS,OAAO,UAAU,UAAU;EACtC,MAAM,EAAE,UAAU,eAAe,MAAM,aACrC,OACA,WACF;EACA,IAAI,YACF,OAAO,MAAM,aAAa,MAAM,QAAQ;CAE5C;CAEA,OAAO;AACT;;;;;;;;;;;;;;AC3BA,eAAsB,aACpB,MACA,aACoB;CACpB,IAAI,CAAC,QAAQ,OAAO,SAAS,UAAU,OAAO;CAE9C,IAAI,MAAM,QAAQ,IAAI,GACpB,OAAO,QAAQ,IACb,KAAK,KAAK,OAAO,UAAU,kBAAkB,OAAO,OAAO,WAAW,CAAC,CACzE;CAGF,IAAI,MAAM,eAAe,IAAI,GAC3B,OAAO,eAAe,MAAM,WAAW;CAGzC,OAAO;AACT;;;;;;;;;;;;;;;ACnBA,eAAsB,eAAe,MAAqC;CACxE,OAAO,aAAa,MAAM,cAAc;AAC1C"}

package/dist/rolldown-runtime-VH7oDXx4.cjs

@@ -0,0 +1,28 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/types-BlSFP07Z.d.cts

@@ -0,0 +1,8 @@
+//#region src/shared/regex/types.d.ts
+type TEXT_PATTERN = RegExp | string;
+type LABEL_LOCATOR = [TEXT_PATTERN, string];
+type TEXT_WITH_NTH = [TEXT_PATTERN, number];
+type TEXT_MATCHER = TEXT_PATTERN | TEXT_WITH_NTH;
+//#endregion
+export { TEXT_WITH_NTH as i, TEXT_MATCHER as n, TEXT_PATTERN as r, LABEL_LOCATOR as t };
+//# sourceMappingURL=types-BlSFP07Z.d.cts.map

package/dist/types-BlSFP07Z.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BlSFP07Z.d.cts","names":[],"sources":["../src/shared/regex/types.ts"],"mappings":";KAAY,eAAe;KACf,iBAAiB;KACjB,iBAAiB;KACjB,eAAe,eAAe"}

package/dist/types-BlSFP07Z.d.mts

@@ -0,0 +1,8 @@
+//#region src/shared/regex/types.d.ts
+type TEXT_PATTERN = RegExp | string;
+type LABEL_LOCATOR = [TEXT_PATTERN, string];
+type TEXT_WITH_NTH = [TEXT_PATTERN, number];
+type TEXT_MATCHER = TEXT_PATTERN | TEXT_WITH_NTH;
+//#endregion
+export { TEXT_WITH_NTH as i, TEXT_MATCHER as n, TEXT_PATTERN as r, LABEL_LOCATOR as t };
+//# sourceMappingURL=types-BlSFP07Z.d.mts.map

package/dist/types-BlSFP07Z.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BlSFP07Z.d.mts","names":[],"sources":["../src/shared/regex/types.ts"],"mappings":";KAAY,eAAe;KACf,iBAAiB;KACjB,iBAAiB;KACjB,eAAe,eAAe"}

package/dist/vitest/console.d.mts

@@ -0,0 +1,2 @@
+import { n as shutConsole, t as resetConsole } from "../index-DtGBqDev.mjs";
+export { resetConsole, shutConsole };

package/dist/vitest/console.mjs

@@ -0,0 +1 @@
+export { t as resetConsole, n as shutConsole } from "../console-Cf1taTRK.mjs";

package/dist/vitest/dom.d.mts

@@ -0,0 +1,2 @@
+import { a as shouldSee, c as shouldHaveTestId, d as isChecked, f as clickLabelInput, h as ToggleState, i as togglePopover, l as shouldHaveAttributes, m as ToggleConfig, n as userTypes, o as shouldNotSee, p as fireEvent, r as userClicks, s as shouldNotHaveTestId, t as userTypesMultiple, u as isNotChecked } from "../index-CKsosUpb.mjs";
+export { type ToggleConfig, type ToggleState, clickLabelInput, fireEvent, isChecked, isNotChecked, shouldHaveAttributes, shouldHaveTestId, shouldNotHaveTestId, shouldNotSee, shouldSee, togglePopover, userClicks, userTypes, userTypesMultiple };

package/dist/vitest/dom.mjs

@@ -0,0 +1 @@
+export { f as clickLabelInput, p as fireEvent, d as isChecked, u as isNotChecked, l as shouldHaveAttributes, c as shouldHaveTestId, s as shouldNotHaveTestId, o as shouldNotSee, a as shouldSee, i as togglePopover, r as userClicks, n as userTypes, t as userTypesMultiple } from "../dom-DeHbD1ni.mjs";