@eslint-react/jsx 5.17.1 → 5.17.3

package/dist/index.js

@@ -2,470 +2,7 @@ import { Traverse } from "@eslint-react/ast";
 import { resolve } from "@eslint-react/var";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { getStaticValue } from "@typescript-eslint/utils/ast-utils";
-import { P, match } from "ts-pattern";
 
-//#region src/collapse-multiline-text.ts
-/**
-* Collapse a multiline JSX text string following React's whitespace rules.
-*
-* This mirrors Babel's `cleanJSXElementLiteralChild` algorithm:
-* 1. Split the raw text into lines.
-* 2. Find the last non-empty line.
-* 3. Trim leading spaces on non-first lines and trailing spaces on non-last lines.
-* 4. Collapse tabs into spaces.
-* 5. Append a single space after each non-last non-empty line.
-* @param text The raw JSX text string to collapse.
-* @returns The collapsed string, or `null` if the text contains only whitespace.
-* @see https://github.com/babel/babel/blob/main/packages/babel-types/src/utils/react/cleanJSXElementLiteralChild.ts
-*/
-function collapseMultilineText(text) {
-	const lines = text.split(/\r\n|\n|\r/);
-	let lastNonEmptyLine = 0;
-	for (let i = 0; i < lines.length; i++) if (/[^ \t]/.exec(lines[i] ?? "") != null) lastNonEmptyLine = i;
-	let str = "";
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i] ?? "";
-		const isFirstLine = i === 0;
-		const isLastLine = i === lines.length - 1;
-		const isLastNonEmptyLine = i === lastNonEmptyLine;
-		let trimmedLine = line.replace(/\t/g, " ");
-		if (!isFirstLine) trimmedLine = trimmedLine.replace(/^ +/, "");
-		if (!isLastLine) trimmedLine = trimmedLine.replace(/ +$/, "");
-		if (trimmedLine.length > 0) {
-			if (!isLastNonEmptyLine) trimmedLine += " ";
-			str += trimmedLine;
-		}
-	}
-	return str === "" ? null : str;
-}
-
-//#endregion
-//#region src/get-attribute-name.ts
-/**
-* Get the stringified name of a `JSXAttribute` node.
-*
-* Handles both simple identifiers and namespaced names:
-* - `className` -> `"className"`
-* - `aria-label` -> `"aria-label"`
-* - `xml:space` -> `"xml:space"`.
-* @param node A `JSXAttribute` AST node.
-* @returns The attribute name as a plain string.
-*/
-function getAttributeName(node) {
-	if (node.name.type === AST_NODE_TYPES.JSXIdentifier) return node.name.name;
-	return node.name.namespace.name + ":" + node.name.name.name;
-}
-
-//#endregion
-//#region src/find-attribute.ts
-/**
-* Find a JSX attribute (or spread attribute containing the property) by name on a given element.
-*
-* Returns the last matching attribute to mirror React's behavior where later props win,
-* or `undefined` when the attribute is not present.
-*
-* Spread attributes are resolved when possible: if the spread argument is an identifier
-* that resolves to an object expression, the object's properties are searched for a matching key.
-* Nested object expressions and nested spread identifiers are also resolved.
-* @param context The ESLint rule context (needed for variable resolution in spread attributes).
-* @param element The `JSXElement` node to search.
-* @param name The attribute name to look for (ex: "className").
-* @returns The matching `JSXAttribute` or `JSXSpreadAttribute`, or `undefined` when not found.
-*/
-function findAttribute(context, element, name) {
-	function findProperty(properties, name, seen = /* @__PURE__ */ new Set()) {
-		for (const property of properties) {
-			if (property.type === AST_NODE_TYPES.Property && !property.computed && property.key.type === AST_NODE_TYPES.Identifier && property.key.name === name) return property;
-			if (property.type !== AST_NODE_TYPES.SpreadElement) continue;
-			const argument = property.argument;
-			if (argument.type === AST_NODE_TYPES.Identifier) {
-				const initNode = resolve(context, argument);
-				if (initNode?.type === AST_NODE_TYPES.ObjectExpression) {
-					if (seen.has(initNode)) continue;
-					seen.add(initNode);
-					const found = findProperty(initNode.properties, name, seen);
-					if (found != null) return found;
-				}
-				continue;
-			}
-			if (argument.type === AST_NODE_TYPES.ObjectExpression) {
-				if (seen.has(argument)) continue;
-				seen.add(argument);
-				const found = findProperty(argument.properties, name, seen);
-				if (found != null) return found;
-			}
-		}
-		return null;
-	}
-	return element.openingElement.attributes.findLast((attr) => {
-		if (attr.type === AST_NODE_TYPES.JSXAttribute) return getAttributeName(attr) === name;
-		switch (attr.argument.type) {
-			case AST_NODE_TYPES.Identifier: {
-				const initNode = resolve(context, attr.argument);
-				if (initNode?.type === AST_NODE_TYPES.ObjectExpression) return findProperty(initNode.properties, name) != null;
-				return false;
-			}
-			case AST_NODE_TYPES.ObjectExpression: return findProperty(attr.argument.properties, name) != null;
-		}
-		return false;
-	});
-}
-
-//#endregion
-//#region src/find-parent-attribute.ts
-/**
-* Walk up the AST from `node` to find the nearest ancestor that is a `JSXAttribute`
-* and (optionally) passes a predicate.
-*
-* This is useful when a rule visitor enters a deeply nested node (ex: a `Literal`
-* inside an expression container) and needs to know which JSX attribute it belongs to.
-* @param node The starting node for the upward search.
-* @param test Optional predicate to filter candidate `JSXAttribute` nodes. When omitted every `JSXAttribute` ancestor matches.
-* @returns The first matching `JSXAttribute` ancestor, or `null` if none is found before reaching the root.
-*/
-function findParentAttribute(node, test = () => true) {
-	const guard = (n) => {
-		return n.type === AST_NODE_TYPES.JSXAttribute && test(n);
-	};
-	return Traverse.findParent(node, guard);
-}
-
-//#endregion
-//#region src/resolve-attribute-value.ts
-/**
-* Resolve the value of a JSX attribute (or spread attribute) into a
-* {@link JsxAttributeValue} descriptor that can be inspected further.
-*
-* This is the low-level building block; it operates on a single attribute
-* node that the caller has already located. For the higher-level "find by
-* name and resolve" combo, see {@link getAttributeValue}.
-* @param context The ESLint rule context (needed for scope look-ups).
-* @param attribute A `JSXAttribute` or `JSXSpreadAttribute` node.
-* @returns A discriminated-union descriptor of the attribute's value.
-*/
-function resolveAttributeValue(context, attribute) {
-	if (attribute.type === AST_NODE_TYPES.JSXAttribute) return resolveJsxAttribute(context, attribute);
-	return resolveJsxSpreadAttribute(context, attribute);
-}
-function resolveJsxAttribute(context, node) {
-	const scope = context.sourceCode.getScope(node);
-	if (node.value == null) return {
-		kind: "boolean",
-		node: null,
-		toStatic() {
-			return true;
-		}
-	};
-	switch (node.value.type) {
-		case AST_NODE_TYPES.Literal: {
-			const staticValue = node.value.value;
-			return {
-				kind: "literal",
-				node: node.value,
-				toStatic() {
-					return staticValue;
-				}
-			};
-		}
-		case AST_NODE_TYPES.JSXExpressionContainer: {
-			const expr = node.value.expression;
-			if (expr.type === AST_NODE_TYPES.JSXEmptyExpression) return {
-				kind: "missing",
-				node: expr,
-				toStatic() {
-					return null;
-				}
-			};
-			return {
-				kind: "unknown",
-				node: expr,
-				toStatic() {
-					return getStaticValue(expr, scope)?.value;
-				}
-			};
-		}
-		case AST_NODE_TYPES.JSXElement: return {
-			kind: "element",
-			node: node.value,
-			toStatic() {
-				return null;
-			}
-		};
-		case AST_NODE_TYPES.JSXSpreadChild: return {
-			kind: "spreadChild",
-			getChildren() {
-				return null;
-			},
-			node: node.value.expression,
-			toStatic() {
-				return null;
-			}
-		};
-	}
-}
-function resolveJsxSpreadAttribute(context, node) {
-	const scope = context.sourceCode.getScope(node);
-	return {
-		kind: "spreadProps",
-		getProperty(name) {
-			return match(getStaticValue(node.argument, scope)?.value).with({ [name]: P.select(P.unknown) }, (v) => v).otherwise(() => null);
-		},
-		node: node.argument,
-		toStatic() {
-			return null;
-		}
-	};
-}
-
-//#endregion
-//#region src/get-attribute-static-value.ts
-/**
-* Find an attribute by name on a JSX element and collapse its value to a plain
-* JavaScript value in a single step.
-*
-* This is a convenience composition of {@link findAttribute} ->
-* {@link resolveAttributeValue} -> `toStatic()`, with automatic handling of the
-* `spreadProps` case (extracts the named property from the spread object).
-*
-* Returns `null` when the attribute is absent, `undefined` when the value cannot
-* be statically determined (including empty expression containers), and the
-* resolved static value otherwise.
-* @param context The ESLint rule context.
-* @param element The `JSXElement` node to inspect.
-* @param name The attribute name to look up (ex: "className").
-* @returns The static value of the attribute, `null` when absent, or `undefined` when indeterminate.
-*/
-function getAttributeStaticValue(context, element, name) {
-	const attr = findAttribute(context, element, name);
-	if (attr == null) return null;
-	const resolved = resolveAttributeValue(context, attr);
-	if (resolved.kind === "spreadProps") return resolved.getProperty(name);
-	if (resolved.kind === "missing") return;
-	return resolved.toStatic();
-}
-
-//#endregion
-//#region src/get-attribute-value.ts
-/**
-* Find an attribute by name on a JSX element and resolve its value in a single call.
-*
-* This is a convenience composition of {@link findAttribute} and
-* {@link resolveAttributeValue} that eliminates the most common two-step
-* pattern in lint rules.
-* @param context The ESLint rule context.
-* @param element The `JSXElement` node to search.
-* @param name The attribute name to look up (ex: "className").
-* @returns A {@link JsxAttributeValue} descriptor, or `null` when the attribute is not present on the element.
-*/
-function getAttributeValue(context, element, name) {
-	const attr = findAttribute(context, element, name);
-	if (attr == null) return null;
-	return resolveAttributeValue(context, attr);
-}
-
-//#endregion
-//#region src/is-whitespace.ts
-/**
-* Check whether a JSX child node is whitespace padding that React would
-* trim away during rendering.
-*
-* A child is considered whitespace padding when it is a `JSXText` node whose
-* content is empty after applying React's whitespace normalization
-* (see {@link collapseMultilineText}, modelled after Babel's
-* `cleanJSXElementLiteralChild`). This is the whitespace that appears between
-* JSX tags purely for formatting.
-* @param node A JSX child node.
-* @returns `true` when the node is purely formatting whitespace.
-*/
-function isWhitespace(node) {
-	if (node.type !== AST_NODE_TYPES.JSXText) return false;
-	return collapseMultilineText(node.value) == null && node.value.includes("\n");
-}
-/**
-* Check whether a JSX child node is any whitespace-only text.
-*
-* This is a looser variant of {@link isWhitespace}; it matches every
-* `JSXText` node whose raw content is empty after trimming, regardless of
-* whether it contains a newline.
-* @param node A JSX child node.
-* @returns `true` when the node is a whitespace-only `JSXText`.
-*/
-function isWhitespaceText(node) {
-	if (node.type !== AST_NODE_TYPES.JSXText) return false;
-	return node.raw.trim() === "";
-}
-/**
-* Check whether a JSX child node is an empty string expression (`{""}`).
-*
-* React's reconciler and SSR renderer explicitly skip empty strings,
-* producing no DOM node (see `ReactChildFiber.js` and `ReactFizzConfigDOM.js`).
-* Such expressions are therefore treated as non-rendered children, in the same
-* way as whitespace padding.
-* @param node A JSX child node.
-* @returns `true` when the node is a `{""}` expression container.
-*/
-function isEmptyStringExpression(node) {
-	if (node.type !== AST_NODE_TYPES.JSXExpressionContainer) return false;
-	const expr = node.expression;
-	if (expr.type !== AST_NODE_TYPES.Literal) return false;
-	return expr.value === "";
-}
-
-//#endregion
-//#region src/get-children.ts
-/**
-* Get the meaningful children of a JSX element or fragment.
-*
-* Mirrors Babel's `buildChildren` helper:
-* 1. Iterate over `element.children`.
-* 2. Skip `JSXText` nodes that clean to nothing (padding whitespace).
-* 3. Skip `JSXExpressionContainer` nodes whose expression is empty.
-* 4. Skip `JSXEmptyExpression` nodes.
-* 5. Collect everything else.
-* @param element A `JSXElement` or `JSXFragment` node.
-* @returns An array of children nodes that contribute to rendered output.
-*/
-function getChildren(element) {
-	const elements = [];
-	for (const child of element.children) {
-		if (child.type === AST_NODE_TYPES.JSXText) {
-			if (collapseMultilineText(child.value) == null && child.value.includes("\n")) continue;
-			elements.push(child);
-			continue;
-		}
-		if (child.type === AST_NODE_TYPES.JSXExpressionContainer) {
-			const { expression } = child;
-			if (expression.type === AST_NODE_TYPES.JSXEmptyExpression) continue;
-			if (isEmptyStringExpression(child)) continue;
-			elements.push(child);
-			continue;
-		}
-		elements.push(child);
-	}
-	return elements;
-}
-
-//#endregion
-//#region src/get-element-type.ts
-/**
-* Get the string representation of a JSX element's type.
-*
-* - `<div>` -> `"div"`
-* - `<Foo.Bar>` -> `"Foo.Bar"`
-* - `<React.Fragment>` -> `"React.Fragment"`
-* - `<></>` -> `""`.
-* @param node A `JSXElement` or `JSXFragment` node.
-* @returns The fully-qualified element type string.
-*/
-function getElementFullType(node) {
-	if (node.type === AST_NODE_TYPES.JSXFragment) return "";
-	function getQualifiedName(node) {
-		switch (node.type) {
-			case AST_NODE_TYPES.JSXIdentifier: return node.name;
-			case AST_NODE_TYPES.JSXNamespacedName: return node.namespace.name + ":" + node.name.name;
-			default: return getQualifiedName(node.object) + "." + getQualifiedName(node.property);
-		}
-	}
-	return getQualifiedName(node.openingElement.name);
-}
-/**
-* Get the self name (last dot-separated segment) of a JSX element type.
-*
-* - `<Foo.Bar.Baz>` -> `"Baz"`
-* - `<div>` -> `"div"`
-* - `<></>` -> `""`.
-* @param node A `JSXElement` or `JSXFragment` node.
-* @returns The last segment of the element type, or `""` for fragments.
-*/
-function getElementSelfType(node) {
-	return getElementFullType(node).split(".").at(-1) ?? "";
-}
-
-//#endregion
-//#region src/has-any-attribute.ts
-/**
-* Check whether a JSX element carries at least one of the given attributes.
-*
-* This is a batch variant of {@link hasAttribute} for the common pattern of
-* short-circuiting on multiple prop names.
-*
-* Spread attributes are taken into account (see {@link findAttribute}).
-* @param context The ESLint rule context (needed for variable resolution in spread attributes).
-* @param element The `JSXElement` node to inspect.
-* @param names The attribute names to look for.
-* @returns `true` when at least one of the attributes is present.
-*/
-function hasAnyAttribute(context, element, names) {
-	return names.some((name) => findAttribute(context, element, name) != null);
-}
-
-//#endregion
-//#region src/has-attribute.ts
-/**
-* Check whether a JSX element carries a given attribute (prop).
-*
-* This is a thin convenience wrapper around {@link findAttribute} for the
-* common case where you only need a boolean answer.
-*
-* Spread attributes are taken into account: `<Comp {...{ disabled: true }} />`
-* will report `true` for `"disabled"`.
-* @param context The ESLint rule context (needed for variable resolution in spread attributes).
-* @param element The `JSXElement` node to inspect.
-* @param name The attribute name to look for (ex: "className").
-* @returns `true` when the attribute is present on the element.
-*/
-function hasAttribute(context, element, name) {
-	return findAttribute(context, element, name) != null;
-}
-
-//#endregion
-//#region src/has-children.ts
-/**
-* Check whether a JSX element (or fragment) has meaningful children, that is,
-* at least one child that is not purely whitespace text or an empty string expression.
-*
-* A `JSXText` child whose `raw` content is empty after trimming is considered
-* non-meaningful because it is typically a code-formatting artifact
-* (indentation between tags). While React's client renderer preserves these
-* nodes as text nodes, they rarely represent intentionally rendered content.
-*
-* An empty string expression (`children={""}`) is also considered
-* non-meaningful because React's reconciler and SSR renderer explicitly skip
-* empty strings, producing no DOM node.
-*
-* Unlike {@link getChildren} (which only filters whitespace that contains a
-* newline) this check treats any whitespace-only text as non-meaningful
-* (see {@link isWhitespaceText}). As a result `hasChildren(node)` is not
-* always equal to `getChildren(node).length > 0`: they differ for
-* whitespace-only children that have no newline, such as `<div> </div>` or
-* `<div>\t\t</div>`. Choose the API that matches your rule's intent.
-* @param element A `JSXElement` or `JSXFragment` node.
-* @returns `true` when the element has at least one meaningful child.
-*/
-function hasChildren(element) {
-	if (element.children.length === 0) return false;
-	return !element.children.every((child) => isWhitespaceText(child) || isEmptyStringExpression(child));
-}
-
-//#endregion
-//#region src/has-every-attribute.ts
-/**
-* Check whether a JSX element carries all of the given attributes (props).
-*
-* This is a batch variant of {@link hasAttribute} for the common pattern
-* where a rule needs to verify that a set of required props are all present.
-*
-* Spread attributes are taken into account (see {@link findAttribute}).
-* @param context The ESLint rule context (needed for variable resolution in spread attributes).
-* @param element The `JSXElement` node to inspect.
-* @param names The attribute names to look for.
-* @returns `true` when every name in `names` is present on the element.
-*/
-function hasEveryAttribute(context, element, names) {
-	return names.every((name) => findAttribute(context, element, name) != null);
-}
-
-//#endregion
 //#region ../../.pkgs/eff/dist/index.js
 /**
 * Applies a `pipe` method's variadic arguments to an initial value from left
@@ -749,217 +286,667 @@ const constTrue = constant(true);
 * **Example** (Returning false from a thunk)
 *
 * ```ts
-* import { Function } from "effect"
+* import { Function } from "effect"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(Function.constFalse(), false)
+* ```
+*
+* @category constants
+* @since 2.0.0
+*/
+const constFalse = constant(false);
+/**
+* Returns `null` when called.
+*
+* **When to use**
+*
+* Use when you need a thunk that returns `null` on every invocation.
+*
+* **Example** (Returning null from a thunk)
+*
+* ```ts
+* import { Function } from "effect"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(Function.constNull(), null)
+* ```
+*
+* @category constants
+* @since 2.0.0
+*/
+const constNull = constant(null);
+/**
+* Returns `undefined` when called.
+*
+* **When to use**
+*
+* Use when you need a thunk that returns `undefined` on every invocation.
+*
+* **Example** (Returning undefined from a thunk)
+*
+* ```ts
+* import { Function } from "effect"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(Function.constUndefined(), undefined)
+* ```
+*
+* @category constants
+* @since 2.0.0
+*/
+const constUndefined = constant(void 0);
+/**
+* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
+* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
+*
+* **When to use**
+*
+* Use to compose exactly two unary functions into a reusable unary function.
+*
+* **Example** (Composing two functions)
+*
+* ```ts
+* import { Function } from "effect"
+* import * as assert from "node:assert"
+*
+* const increment = (n: number) => n + 1
+* const square = (n: number) => n * n
+*
+* assert.strictEqual(Function.compose(increment, square)(2), 9)
+* ```
+*
+* @see {@link flow} for composing a left-to-right sequence of functions
+* @see {@link pipe} for applying a value through a left-to-right sequence immediately
+*
+* @category combinators
+* @since 2.0.0
+*/
+const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
+/**
+* Marks an impossible branch by accepting a `never` value and returning any
+* type.
+*
+* **When to use**
+*
+* Use when you need a return value in a branch that exhaustive checks prove
+* cannot be reached.
+*
+* **Gotchas**
+*
+* Calling `absurd` throws, because a value of type `never` should be
+* impossible at runtime.
+*
+* **Example** (Handling impossible values)
+*
+* ```ts
+* import { absurd } from "effect"
+*
+* const handleNever = (value: never) => {
+*   return absurd(value) // This will throw an error if called
+* }
+* ```
+*
+* @category utility types
+* @since 2.0.0
+*/
+const absurd = (_) => {
+	throw new Error("Called `absurd` function which should be uncallable");
+};
+/**
+* Creates a compile-time placeholder for a value of any type.
+*
+* **When to use**
+*
+* Use as a temporary typed placeholder while developing incomplete code.
+*
+* **Gotchas**
+*
+* `hole` is intended for temporary development use. If the placeholder is
+* evaluated at runtime, it throws.
+*
+* **Example** (Creating a development placeholder)
+*
+* ```ts
+* import { hole } from "effect"
+*
+* // Intentionally not called: `hole` throws if the placeholder is evaluated.
+* const buildUser = (id: number): { readonly id: number; readonly name: string } => ({
+*   id,
+*   name: hole<string>()
+* })
+*
+* console.log(typeof buildUser) // "function"
+* ```
+*
+* @category utility types
+* @since 2.0.0
+*/
+const hole = cast(absurd);
+/**
+* Drops the longest prefix of elements from an array that satisfy the given predicate.
+*
+* Supports both data-first and data-last (`pipe`-friendly) call styles.
+*
+* @param pred - The predicate to test each element with.
+* @returns A new array without the matching prefix.
+* @example
+* ```ts
+* import * as assert from "node:assert"
+* import { dropWhile, pipe } from "@local/eff"
+*
+* // data-first
+* assert.deepStrictEqual(dropWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [3, 2, 1])
+*
+* // data-last
+* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], dropWhile((n: number) => n < 3)), [3, 2, 1])
+* ```
+* @category array
+*/
+const dropWhile = dual(2, (xs, pred) => {
+	const len = xs.length;
+	let idx = 0;
+	while (idx < len && pred(xs[idx])) idx++;
+	return xs.slice(idx);
+});
+/**
+* Takes the longest prefix of elements from an array that satisfy the given predicate.
+*
+* Supports both data-first and data-last (`pipe`-friendly) call styles.
+*
+* @param pred - The predicate to test each element with.
+* @returns A new array containing only the matching prefix.
+* @example
+* ```ts
 * import * as assert from "node:assert"
+* import { pipe, takeWhile } from "@local/eff"
 *
-* assert.deepStrictEqual(Function.constFalse(), false)
-* ```
+* // data-first
+* assert.deepStrictEqual(takeWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [1, 2])
 *
-* @category constants
-* @since 2.0.0
+* // data-last
+* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], takeWhile((n: number) => n < 3)), [1, 2])
+* ```
+* @category array
 */
-const constFalse = constant(false);
+const takeWhile = dual(2, (xs, pred) => {
+	const len = xs.length;
+	let idx = 0;
+	while (idx < len && pred(xs[idx])) idx++;
+	return xs.slice(0, idx);
+});
+
+//#endregion
+//#region src/attribute-name.ts
 /**
-* Returns `null` when called.
-*
-* **When to use**
+* Get the stringified name of a `JSXAttribute` node.
 *
-* Use when you need a thunk that returns `null` on every invocation.
+* Handles both simple identifiers and namespaced names:
+* - `className` -> `"className"`
+* - `aria-label` -> `"aria-label"`
+* - `xml:space` -> `"xml:space"`.
+* @param node A `JSXAttribute` AST node.
+* @returns The attribute name as a plain string.
+*/
+function getAttributeName(node) {
+	if (node.name.type === AST_NODE_TYPES.JSXIdentifier) return node.name.name;
+	return node.name.namespace.name + ":" + node.name.name.name;
+}
+/**
+* Check whether a node is a `JSXAttribute` with the given name.
 *
-* **Example** (Returning null from a thunk)
+* Only plain identifier names are matched (ex: `className`); namespaced
+* attributes (ex: `xml:space`) do not match.
 *
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
+* Supports both data-first and data-last (curried) call styles:
+* - `isAttribute(node, "className")`
+* - `isAttribute("className")(node)`.
+* @param node The AST node to test.
+* @param name The attribute name to match (ex: "className").
+* @returns `true` when the node is a `JSXAttribute` named `name`.
+*/
+const isAttribute = dual(2, (node, name) => {
+	return node.type === AST_NODE_TYPES.JSXAttribute && node.name.type === AST_NODE_TYPES.JSXIdentifier && node.name.name === name;
+});
+
+//#endregion
+//#region src/attribute-find.ts
+/**
+* Find a JSX attribute (or spread attribute containing the property) by name on a given element.
 *
-* assert.deepStrictEqual(Function.constNull(), null)
-* ```
+* Returns the last matching attribute to mirror React's behavior where later props win,
+* or `undefined` when the attribute is not present.
 *
-* @category constants
-* @since 2.0.0
+* Spread attributes are resolved when possible: if the spread argument is an identifier
+* that resolves to an object expression, the object's properties are searched for a matching key.
+* Nested object expressions and nested spread identifiers are also resolved
+* (see {@link findSpreadProperty}).
+* @param context The ESLint rule context (needed for variable resolution in spread attributes).
+* @param element The `JSXElement` node to search.
+* @param name The attribute name to look for (ex: "className").
+* @returns The matching `JSXAttribute` or `JSXSpreadAttribute`, or `undefined` when not found.
 */
-const constNull = constant(null);
+function findAttribute(context, element, name) {
+	return element.openingElement.attributes.findLast((attr) => {
+		if (attr.type === AST_NODE_TYPES.JSXAttribute) return getAttributeName(attr) === name;
+		return findSpreadProperty(context, attr.argument, name) != null;
+	});
+}
 /**
-* Returns `undefined` when called.
-*
-* **When to use**
+* Walk up the AST from `node` to find the nearest ancestor that is a `JSXAttribute`
+* and (optionally) passes a predicate.
 *
-* Use when you need a thunk that returns `undefined` on every invocation.
+* This is useful when a rule visitor enters a deeply nested node (ex: a `Literal`
+* inside an expression container) and needs to know which JSX attribute it belongs to.
+* @param node The starting node for the upward search.
+* @param test Optional predicate to filter candidate `JSXAttribute` nodes. When omitted every `JSXAttribute` ancestor matches.
+* @returns The first matching `JSXAttribute` ancestor, or `undefined` if none is found before reaching the root.
+*/
+function findParentAttribute(node, test = () => true) {
+	const guard = (n) => {
+		return n.type === AST_NODE_TYPES.JSXAttribute && test(n);
+	};
+	return Traverse.findParent(node, guard) ?? void 0;
+}
+/**
+* Find the `Property` node that provides a given key inside a spread argument.
+*
+* This is the single resolution routine shared by {@link findAttribute} (existence
+* checks) and the `spreadProps` variant of `resolveAttributeValue` (value extraction):
+*
+* - An `Identifier` argument is resolved to its initializer via variable
+*   resolution, following alias chains (`const b = a`) like `getStaticValue`
+*   does; an `ObjectExpression` argument is searched directly.
+* - Properties are walked **in reverse** so that later entries win, matching
+*   JavaScript object semantics (`{ ...a, k: 1 }` -> the literal `k`).
+* - Nested `SpreadElement`s (identifiers or inline object expressions) are
+*   searched recursively; a `seen` set guards against circular references.
+* - Plain identifier keys and string literal keys are matched directly;
+*   computed keys are matched when they are statically evaluable
+*   (ex: `{ ["class" + "Name"]: 1 }`).
+* @param context The ESLint rule context (needed for variable resolution).
+* @param argument The spread argument expression to search.
+* @param name The property name to look for.
+* @param seen Internal set of already-visited nodes (cycle guard).
+* @returns The matching `Property` node, or `undefined` when the key is not found.
+*/
+function findSpreadProperty(context, argument, name, seen = /* @__PURE__ */ new Set()) {
+	let objectExpression;
+	if (argument.type === AST_NODE_TYPES.Identifier) {
+		let initNode = resolve(context, argument);
+		while (initNode != null && initNode.type === AST_NODE_TYPES.Identifier && !seen.has(initNode)) {
+			seen.add(initNode);
+			initNode = resolve(context, initNode);
+		}
+		if (initNode?.type === AST_NODE_TYPES.ObjectExpression) objectExpression = initNode;
+	} else if (argument.type === AST_NODE_TYPES.ObjectExpression) objectExpression = argument;
+	if (objectExpression == null || seen.has(objectExpression)) return void 0;
+	seen.add(objectExpression);
+	const { properties } = objectExpression;
+	for (let i = properties.length - 1; i >= 0; i--) {
+		const property = properties[i];
+		if (property == null) continue;
+		if (property.type === AST_NODE_TYPES.Property) {
+			const { key } = property;
+			if (property.computed) {
+				if (getStaticValue(key, context.sourceCode.getScope(key))?.value === name) return property;
+				continue;
+			}
+			if (key.type === AST_NODE_TYPES.Identifier && key.name === name) return property;
+			if (key.type === AST_NODE_TYPES.Literal && key.value === name) return property;
+			continue;
+		}
+		const found = findSpreadProperty(context, property.argument, name, seen);
+		if (found != null) return found;
+	}
+}
+
+//#endregion
+//#region src/attribute-has.ts
+/**
+* Check whether a JSX element carries a given attribute (prop).
 *
-* **Example** (Returning undefined from a thunk)
+* This is a thin convenience wrapper around {@link findAttribute} for the
+* common case where you only need a boolean answer.
 *
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
+* Spread attributes are taken into account: `<Comp {...{ disabled: true }} />`
+* will report `true` for `"disabled"`.
+* @param context The ESLint rule context (needed for variable resolution in spread attributes).
+* @param element The `JSXElement` node to inspect.
+* @param name The attribute name to look for (ex: "className").
+* @returns `true` when the attribute is present on the element.
+*/
+function hasAttribute(context, element, name) {
+	return findAttribute(context, element, name) != null;
+}
+/**
+* Check whether a JSX element carries at least one of the given attributes.
 *
-* assert.deepStrictEqual(Function.constUndefined(), undefined)
-* ```
+* This is a batch variant of {@link hasAttribute} for the common pattern of
+* short-circuiting on multiple prop names.
 *
-* @category constants
-* @since 2.0.0
+* Spread attributes are taken into account (see {@link findAttribute}).
+* @param context The ESLint rule context (needed for variable resolution in spread attributes).
+* @param element The `JSXElement` node to inspect.
+* @param names The attribute names to look for.
+* @returns `true` when at least one of the attributes is present.
 */
-const constUndefined = constant(void 0);
+function hasAnyAttribute(context, element, names) {
+	return names.some((name) => findAttribute(context, element, name) != null);
+}
 /**
-* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
-* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
+* Check whether a JSX element carries all of the given attributes (props).
 *
-* **When to use**
+* This is a batch variant of {@link hasAttribute} for the common pattern
+* where a rule needs to verify that a set of required props are all present.
 *
-* Use to compose exactly two unary functions into a reusable unary function.
+* Spread attributes are taken into account (see {@link findAttribute}).
+* @param context The ESLint rule context (needed for variable resolution in spread attributes).
+* @param element The `JSXElement` node to inspect.
+* @param names The attribute names to look for.
+* @returns `true` when every name in `names` is present on the element.
+*/
+function hasEveryAttribute(context, element, names) {
+	return names.every((name) => findAttribute(context, element, name) != null);
+}
+
+//#endregion
+//#region src/attribute-value.ts
+/**
+* Resolve the value of a JSX attribute (or spread attribute) into an
+* {@link AttributeValue} descriptor that can be inspected further.
 *
-* **Example** (Composing two functions)
+* This is the low-level building block; it operates on a single attribute
+* node that the caller has already located. For the higher-level "find by
+* name and resolve" combo, see {@link getAttributeValue}.
 *
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
+* When the attribute is a `JSXSpreadAttribute`, passing `name` (typically the
+* same name the attribute was found by) makes `toStatic()` return the static
+* value of that named property, eliminating the need to branch on
+* `kind === "spreadProps"` at the call site.
+* @param context The ESLint rule context (needed for scope look-ups).
+* @param attribute A `JSXAttribute` or `JSXSpreadAttribute` node.
+* @param name Optional property name used to resolve `toStatic()` for spread attributes.
+* @returns A discriminated-union descriptor of the attribute's value.
+*/
+function resolveAttributeValue(context, attribute, name) {
+	if (attribute.type === AST_NODE_TYPES.JSXAttribute) return resolveJsxAttribute(context, attribute);
+	return resolveJsxSpreadAttribute(context, attribute, name);
+}
+/**
+* Find an attribute by name on a JSX element and resolve its value in a single call.
 *
-* const increment = (n: number) => n + 1
-* const square = (n: number) => n * n
+* This is a convenience composition of {@link findAttribute} and
+* {@link resolveAttributeValue} that eliminates the most common two-step
+* pattern in lint rules.
+* @param context The ESLint rule context.
+* @param element The `JSXElement` node to search.
+* @param name The attribute name to look up (ex: "className").
+* @returns An {@link AttributeValue} descriptor, or `undefined` when the attribute is not present on the element.
+*/
+function getAttributeValue(context, element, name) {
+	const attr = findAttribute(context, element, name);
+	if (attr == null) return void 0;
+	return resolveAttributeValue(context, attr, name);
+}
+/**
+* Find an attribute by name on a JSX element and collapse its value to a plain
+* JavaScript value in a single step.
 *
-* assert.strictEqual(Function.compose(increment, square)(2), 9)
-* ```
+* This is a convenience composition of {@link findAttribute} ->
+* {@link resolveAttributeValue} -> `toStatic()`, with automatic handling of the
+* `spreadProps` case (extracts the named property from the spread object).
 *
-* @see {@link flow} for composing a left-to-right sequence of functions
-* @see {@link pipe} for applying a value through a left-to-right sequence immediately
+* Returns `undefined` both when the attribute is absent and when its value
+* cannot be statically determined; use {@link findAttribute} or
+* {@link hasAttribute} when presence itself matters.
+* @param context The ESLint rule context.
+* @param element The `JSXElement` node to inspect.
+* @param name The attribute name to look up (ex: "className").
+* @returns The static value of the attribute, or `undefined` when absent or indeterminate.
+*/
+function getAttributeStaticValue(context, element, name) {
+	return getAttributeValue(context, element, name)?.toStatic();
+}
+function resolveJsxAttribute(context, node) {
+	const scope = context.sourceCode.getScope(node);
+	if (node.value == null) return {
+		kind: "boolean",
+		node: null,
+		toStatic() {
+			return true;
+		}
+	};
+	switch (node.value.type) {
+		case AST_NODE_TYPES.Literal: {
+			const staticValue = node.value.value;
+			return {
+				kind: "literal",
+				node: node.value,
+				toStatic() {
+					return staticValue;
+				}
+			};
+		}
+		case AST_NODE_TYPES.JSXExpressionContainer: {
+			const expr = node.value.expression;
+			if (expr.type === AST_NODE_TYPES.JSXEmptyExpression) return {
+				kind: "missing",
+				node: expr,
+				toStatic() {}
+			};
+			return {
+				kind: "unknown",
+				node: expr,
+				toStatic() {
+					return getStaticValue(expr, scope)?.value;
+				}
+			};
+		}
+		case AST_NODE_TYPES.JSXElement: return {
+			kind: "element",
+			node: node.value,
+			toStatic() {}
+		};
+		case AST_NODE_TYPES.JSXSpreadChild: return {
+			kind: "spreadChild",
+			node: node.value,
+			toStatic() {}
+		};
+	}
+}
+function resolveJsxSpreadAttribute(context, node, name) {
+	const getProperty = (propertyName) => {
+		const property = findSpreadProperty(context, node.argument, propertyName);
+		if (property == null) return void 0;
+		const propertyScope = context.sourceCode.getScope(property.value);
+		return getStaticValue(property.value, propertyScope)?.value;
+	};
+	return {
+		kind: "spreadProps",
+		getProperty,
+		node: node.argument,
+		toStatic() {
+			return name == null ? void 0 : getProperty(name);
+		}
+	};
+}
+
+//#endregion
+//#region src/text.ts
+/**
+* Collapse a multiline JSX text string following React's whitespace rules.
 *
-* @category combinators
-* @since 2.0.0
+* This mirrors Babel's `cleanJSXElementLiteralChild` algorithm:
+* 1. Split the raw text into lines.
+* 2. Find the last non-empty line.
+* 3. Trim leading spaces on non-first lines and trailing spaces on non-last lines.
+* 4. Collapse tabs into spaces.
+* 5. Append a single space after each non-last non-empty line.
+* @param text The raw JSX text string to collapse.
+* @returns The collapsed string, or `null` if the text contains only whitespace.
+* @see https://github.com/babel/babel/blob/main/packages/babel-types/src/utils/react/cleanJSXElementLiteralChild.ts
 */
-const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
+function collapseMultilineText(text) {
+	const lines = text.split(/\r\n|\n|\r/);
+	let lastNonEmptyLine = 0;
+	for (let i = 0; i < lines.length; i++) if (/[^ \t]/.exec(lines[i] ?? "") != null) lastNonEmptyLine = i;
+	let str = "";
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i] ?? "";
+		const isFirstLine = i === 0;
+		const isLastLine = i === lines.length - 1;
+		const isLastNonEmptyLine = i === lastNonEmptyLine;
+		let trimmedLine = line.replace(/\t/g, " ");
+		if (!isFirstLine) trimmedLine = trimmedLine.replace(/^ +/, "");
+		if (!isLastLine) trimmedLine = trimmedLine.replace(/ +$/, "");
+		if (trimmedLine.length > 0) {
+			if (!isLastNonEmptyLine) trimmedLine += " ";
+			str += trimmedLine;
+		}
+	}
+	return str === "" ? null : str;
+}
 /**
-* Marks an impossible branch by accepting a `never` value and returning any
-* type.
-*
-* **When to use**
-*
-* Use when you need a return value in a branch that exhaustive checks prove
-* cannot be reached.
-*
-* **Gotchas**
-*
-* Calling `absurd` throws, because a value of type `never` should be
-* impossible at runtime.
-*
-* **Example** (Handling impossible values)
-*
-* ```ts
-* import { absurd } from "effect"
+* Check whether a JSX child node is whitespace padding that React would
+* trim away during rendering.
 *
-* const handleNever = (value: never) => {
-*   return absurd(value) // This will throw an error if called
-* }
-* ```
+* A child is considered whitespace padding when it is a `JSXText` node whose
+* content is empty after applying React's whitespace normalization
+* (see {@link collapseMultilineText}, modelled after Babel's
+* `cleanJSXElementLiteralChild`) **and** it contains a newline. This is the
+* whitespace that appears between JSX tags purely for formatting.
 *
-* @category utility types
-* @since 2.0.0
+* For the looser "any whitespace-only text" check, see {@link isWhitespaceText}.
+* @param node A JSX child node.
+* @returns `true` when the node is purely formatting whitespace.
 */
-const absurd = (_) => {
-	throw new Error("Called `absurd` function which should be uncallable");
-};
+function isPaddingWhitespace(node) {
+	if (node.type !== AST_NODE_TYPES.JSXText) return false;
+	return collapseMultilineText(node.value) == null && node.value.includes("\n");
+}
 /**
-* Creates a compile-time placeholder for a value of any type.
-*
-* **When to use**
-*
-* Use as a temporary typed placeholder while developing incomplete code.
-*
-* **Gotchas**
-*
-* `hole` is intended for temporary development use. If the placeholder is
-* evaluated at runtime, it throws.
-*
-* **Example** (Creating a development placeholder)
-*
-* ```ts
-* import { hole } from "effect"
-*
-* // Intentionally not called: `hole` throws if the placeholder is evaluated.
-* const buildUser = (id: number): { readonly id: number; readonly name: string } => ({
-*   id,
-*   name: hole<string>()
-* })
-*
-* console.log(typeof buildUser) // "function"
-* ```
+* Check whether a JSX child node is any whitespace-only text.
 *
-* @category utility types
-* @since 2.0.0
+* This is a looser variant of {@link isPaddingWhitespace}; it matches every
+* `JSXText` node whose raw content is empty after trimming, regardless of
+* whether it contains a newline.
+* @param node A JSX child node.
+* @returns `true` when the node is a whitespace-only `JSXText`.
 */
-const hole = cast(absurd);
+function isWhitespaceText(node) {
+	if (node.type !== AST_NODE_TYPES.JSXText) return false;
+	return node.raw.trim() === "";
+}
 /**
-* Drops the longest prefix of elements from an array that satisfy the given predicate.
-*
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
-*
-* @param pred - The predicate to test each element with.
-* @returns A new array without the matching prefix.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { dropWhile, pipe } from "@local/eff"
-*
-* // data-first
-* assert.deepStrictEqual(dropWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [3, 2, 1])
+* Check whether a JSX child node is an empty string expression (`{""}`).
 *
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], dropWhile((n: number) => n < 3)), [3, 2, 1])
-* ```
-* @category array
+* React's reconciler and SSR renderer explicitly skip empty strings,
+* producing no DOM node (see `ReactChildFiber.js` and `ReactFizzConfigDOM.js`).
+* Such expressions are therefore treated as non-rendered children, in the same
+* way as whitespace padding.
+* @param node A JSX child node.
+* @returns `true` when the node is a `{""}` expression container.
 */
-const dropWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
-	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(idx);
-});
+function isEmptyStringExpression(node) {
+	if (node.type !== AST_NODE_TYPES.JSXExpressionContainer) return false;
+	const expr = node.expression;
+	if (expr.type !== AST_NODE_TYPES.Literal) return false;
+	return expr.value === "";
+}
+
+//#endregion
+//#region src/children.ts
 /**
-* Takes the longest prefix of elements from an array that satisfy the given predicate.
+* Get the meaningful children of a JSX element or fragment.
 *
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
+* Mirrors Babel's `buildChildren` helper:
+* 1. Iterate over `element.children`.
+* 2. Skip `JSXText` nodes that clean to nothing (padding whitespace).
+* 3. Skip `JSXExpressionContainer` nodes whose expression is empty.
+* 4. Skip empty string expressions (`{""}`), which produce no DOM node.
+* 5. Collect everything else.
+* @param element A `JSXElement` or `JSXFragment` node.
+* @returns An array of children nodes that contribute to rendered output.
+*/
+function getChildren(element) {
+	const children = [];
+	for (const child of element.children) {
+		if (isPaddingWhitespace(child)) continue;
+		if (child.type === AST_NODE_TYPES.JSXExpressionContainer) {
+			if (child.expression.type === AST_NODE_TYPES.JSXEmptyExpression) continue;
+			if (isEmptyStringExpression(child)) continue;
+		}
+		children.push(child);
+	}
+	return children;
+}
+/**
+* Check whether a JSX element (or fragment) has meaningful children, that is,
+* at least one child that is not purely whitespace text or an empty string expression.
 *
-* @param pred - The predicate to test each element with.
-* @returns A new array containing only the matching prefix.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { pipe, takeWhile } from "@local/eff"
+* A `JSXText` child whose `raw` content is empty after trimming is considered
+* non-meaningful because it is typically a code-formatting artifact
+* (indentation between tags). While React's client renderer preserves these
+* nodes as text nodes, they rarely represent intentionally rendered content.
 *
-* // data-first
-* assert.deepStrictEqual(takeWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [1, 2])
+* An empty string expression (`children={""}`) is also considered
+* non-meaningful because React's reconciler and SSR renderer explicitly skip
+* empty strings, producing no DOM node.
 *
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], takeWhile((n: number) => n < 3)), [1, 2])
-* ```
-* @category array
+* Unlike {@link getChildren} (which only filters whitespace that contains a
+* newline) this check treats any whitespace-only text as non-meaningful
+* (see {@link isWhitespaceText}). As a result `hasChildren(node)` is not
+* always equal to `getChildren(node).length > 0`: they differ for
+* whitespace-only children that have no newline, such as `<div> </div>` or
+* `<div>\t\t</div>`. Choose the API that matches your rule's intent.
+* @param element A `JSXElement` or `JSXFragment` node.
+* @returns `true` when the element has at least one meaningful child.
 */
-const takeWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
-	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(0, idx);
-});
+function hasChildren(element) {
+	if (element.children.length === 0) return false;
+	return !element.children.every((child) => isWhitespaceText(child) || isEmptyStringExpression(child));
+}
 
 //#endregion
-//#region src/is-attribute.ts
+//#region src/element-type.ts
 /**
-* Check whether a node is a `JSXAttribute` with the given name.
+* Get the string representation of a JSX element's type.
 *
-* Only plain identifier names are matched (ex: `className`); namespaced
-* attributes (ex: `xml:space`) do not match.
+* - `<div>` -> `"div"`
+* - `<Foo.Bar>` -> `"Foo.Bar"`
+* - `<React.Fragment>` -> `"React.Fragment"`
+* - `<xml:space>` -> `"xml:space"`
+* - `<></>` -> `""`.
+* @param node A `JSXElement` or `JSXFragment` node.
+* @returns The fully-qualified element type string.
+*/
+function getElementFullType(node) {
+	if (node.type === AST_NODE_TYPES.JSXFragment) return "";
+	function getQualifiedName(node) {
+		switch (node.type) {
+			case AST_NODE_TYPES.JSXIdentifier: return node.name;
+			case AST_NODE_TYPES.JSXNamespacedName: return node.namespace.name + ":" + node.name.name;
+			default: return getQualifiedName(node.object) + "." + getQualifiedName(node.property);
+		}
+	}
+	return getQualifiedName(node.openingElement.name);
+}
+/**
+* Get the self name (last dot-separated segment) of a JSX element type.
 *
-* Supports both data-first and data-last (curried) call styles:
-* - `isAttribute(node, "className")`
-* - `isAttribute("className")(node)`.
-* @param node The AST node to test.
-* @param name The attribute name to match (ex: "className").
-* @returns `true` when the node is a `JSXAttribute` named `name`.
+* - `<Foo.Bar.Baz>` -> `"Baz"`
+* - `<div>` -> `"div"`
+* - `<></>` -> `""`.
+* @param node A `JSXElement` or `JSXFragment` node.
+* @returns The last segment of the element type, or `""` for fragments.
 */
-const isAttribute = dual(2, (node, name) => {
-	return node.type === AST_NODE_TYPES.JSXAttribute && node.name.type === AST_NODE_TYPES.JSXIdentifier && node.name.name === name;
-});
+function getElementSelfType(node) {
+	return getElementFullType(node).split(".").at(-1) ?? "";
+}
 
 //#endregion
-//#region src/is-element.ts
+//#region src/element-is.ts
 /**
 * Check whether a node is a `JSXElement` (or `JSXFragment`) and optionally
 * matches a given test.
@@ -985,9 +972,6 @@ function isElement(node, test) {
 		default: return test.includes(elementType);
 	}
 }
-
-//#endregion
-//#region src/is-fragment-element.ts
 /**
 * Check whether a node is a React Fragment element.
 *
@@ -1007,9 +991,6 @@ function isFragmentElement(node, jsxFragmentFactory = "React.Fragment") {
 	const fragment = jsxFragmentFactory.split(".").at(-1) ?? "Fragment";
 	return getElementFullType(node).split(".").at(-1) === fragment;
 }
-
-//#endregion
-//#region src/is-host-element.ts
 /**
 * Check whether a node is a host (intrinsic / DOM) element.
 *
@@ -1028,32 +1009,4 @@ function isHostElement(node) {
 }
 
 //#endregion
-//#region src/jsx-detection-hint.ts
-/**
-* Hints for JSX detection.
-*/
-const JsxDetectionHint = {
-	None: 0n,
-	DoNotIncludeJsxWithNullValue: 1n << 0n,
-	DoNotIncludeJsxWithNumberValue: 1n << 1n,
-	DoNotIncludeJsxWithBigIntValue: 1n << 2n,
-	DoNotIncludeJsxWithStringValue: 1n << 3n,
-	DoNotIncludeJsxWithBooleanValue: 1n << 4n,
-	DoNotIncludeJsxWithUndefinedValue: 1n << 5n,
-	DoNotIncludeJsxWithEmptyArrayValue: 1n << 6n,
-	DoNotIncludeJsxWithCreateElementValue: 1n << 7n,
-	RequireAllArrayElementsToBeJsx: 1n << 8n,
-	RequireBothSidesOfLogicalExpressionToBeJsx: 1n << 9n,
-	RequireBothBranchesOfConditionalExpressionToBeJsx: 1n << 10n
-};
-/**
-* Default JSX detection hint.
-*
-* Skips number, bigint, boolean, string, and undefined literals,
-* the value types that are commonly returned alongside JSX in React
-* components but are not themselves renderable elements.
-*/
-const DEFAULT_JSX_DETECTION_HINT = 0n | JsxDetectionHint.DoNotIncludeJsxWithNumberValue | JsxDetectionHint.DoNotIncludeJsxWithBigIntValue | JsxDetectionHint.DoNotIncludeJsxWithBooleanValue | JsxDetectionHint.DoNotIncludeJsxWithStringValue | JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue;
-
-//#endregion
-export { DEFAULT_JSX_DETECTION_HINT, JsxDetectionHint, collapseMultilineText, findAttribute, findParentAttribute, getAttributeName, getAttributeStaticValue, getAttributeValue, getChildren, getElementFullType, getElementSelfType, hasAnyAttribute, hasAttribute, hasChildren, hasEveryAttribute, isAttribute, isElement, isEmptyStringExpression, isFragmentElement, isHostElement, isWhitespace, isWhitespaceText, resolveAttributeValue };
+export { collapseMultilineText, findAttribute, findParentAttribute, findSpreadProperty, getAttributeName, getAttributeStaticValue, getAttributeValue, getChildren, getElementFullType, getElementSelfType, hasAnyAttribute, hasAttribute, hasChildren, hasEveryAttribute, isAttribute, isElement, isEmptyStringExpression, isFragmentElement, isHostElement, isPaddingWhitespace, isWhitespaceText, resolveAttributeValue };