@eslint-react/jsx 5.16.1 → 5.17.1

package/dist/index.js

@@ -6,7 +6,7 @@ import { P, match } from "ts-pattern";
 
 //#region src/collapse-multiline-text.ts
 /**
-* Collapse a multiline JSX text string following React's whitespace rules
+* Collapse a multiline JSX text string following React's whitespace rules.
 *
 * This mirrors Babel's `cleanJSXElementLiteralChild` algorithm:
 * 1. Split the raw text into lines.
@@ -14,8 +14,8 @@ import { P, match } from "ts-pattern";
 * 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
+* @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) {
@@ -42,14 +42,14 @@ function collapseMultilineText(text) {
 //#endregion
 //#region src/get-attribute-name.ts
 /**
-* Get the stringified name of a `JSXAttribute` node
+* 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
+* - `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;
@@ -59,7 +59,7 @@ function getAttributeName(node) {
 //#endregion
 //#region src/find-attribute.ts
 /**
-* Find a JSX attribute (or spread attribute containing the property) by name on a given element
+* 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.
@@ -67,10 +67,10 @@ function getAttributeName(node) {
 * 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
+* @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()) {
@@ -115,13 +115,13 @@ function findAttribute(context, element, name) {
 //#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
+* 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
+* @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) => {
@@ -134,14 +134,14 @@ function findParentAttribute(node, test = () => true) {
 //#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
+* {@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
+* @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);
@@ -221,7 +221,7 @@ function resolveJsxSpreadAttribute(context, node) {
 //#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
+* JavaScript value in a single step.
 *
 * This is a convenience composition of {@link findAttribute} ->
 * {@link resolveAttributeValue} -> `toStatic()`, with automatic handling of the
@@ -230,10 +230,10 @@ function resolveJsxSpreadAttribute(context, node) {
 * 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
+* @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);
@@ -247,15 +247,15 @@ function getAttributeStaticValue(context, element, name) {
 //#endregion
 //#region src/get-attribute-value.ts
 /**
-* Find an attribute by name on a JSX element and resolve its value in a single call
+* 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
+* @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);
@@ -267,42 +267,42 @@ function getAttributeValue(context, element, name) {
 //#region src/is-whitespace.ts
 /**
 * Check whether a JSX child node is whitespace padding that React would
-* trim away during rendering
+* 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
+* @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
+* 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`
+* @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 (`{""}`)
+* 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
+* @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;
@@ -314,7 +314,7 @@ function isEmptyStringExpression(node) {
 //#endregion
 //#region src/get-children.ts
 /**
-* Get the meaningful children of a JSX element or fragment
+* Get the meaningful children of a JSX element or fragment.
 *
 * Mirrors Babel's `buildChildren` helper:
 * 1. Iterate over `element.children`.
@@ -322,8 +322,8 @@ function isEmptyStringExpression(node) {
 * 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
+* @param element A `JSXElement` or `JSXFragment` node.
+* @returns An array of children nodes that contribute to rendered output.
 */
 function getChildren(element) {
 	const elements = [];
@@ -348,14 +348,14 @@ function getChildren(element) {
 //#endregion
 //#region src/get-element-type.ts
 /**
-* Get the string representation of a JSX element's type
+* 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
+* - `<></>` -> `""`.
+* @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 "";
@@ -369,13 +369,13 @@ function getElementFullType(node) {
 	return getQualifiedName(node.openingElement.name);
 }
 /**
-* Get the self name (last dot-separated segment) of a JSX element type
+* 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
+* - `<></>` -> `""`.
+* @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) ?? "";
@@ -384,16 +384,16 @@ function getElementSelfType(node) {
 //#endregion
 //#region src/has-any-attribute.ts
 /**
-* Check whether a JSX element carries at least one of the given attributes
+* 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
+* @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);
@@ -402,17 +402,17 @@ function hasAnyAttribute(context, element, names) {
 //#endregion
 //#region src/has-attribute.ts
 /**
-* Check whether a JSX element carries a given attribute (prop)
+* 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
+* @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;
@@ -422,7 +422,7 @@ function hasAttribute(context, element, name) {
 //#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
+* 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
@@ -439,8 +439,8 @@ function hasAttribute(context, element, name) {
 * 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
+* @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;
@@ -450,26 +450,519 @@ function hasChildren(element) {
 //#endregion
 //#region src/has-every-attribute.ts
 /**
-* Check whether a JSX element carries all of the given attributes (props)
+* 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
+* @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
+* to right.
+*
+* **When to use**
+*
+* Use to implement a custom `.pipe(...)` method from JavaScript's `arguments`
+* object.
+*
+* **Details**
+*
+* This helper is intended for implementing `Pipeable.pipe` methods that
+* receive JavaScript's `arguments` object. With no functions it returns the
+* original value; otherwise it feeds each result into the next function.
+*
+* **Example** (Implementing a pipe method)
+*
+* ```ts
+* import { Pipeable } from "effect"
+*
+* class NumberBox {
+*   constructor(readonly value: number) {}
+*
+*   pipe(..._fns: ReadonlyArray<(value: number) => number>): number {
+*     return Pipeable.pipeArguments(this.value, arguments) as number
+*   }
+* }
+*
+* const result = new NumberBox(5).pipe(
+*   (n) => n + 2,
+*   (n) => n * 3
+* )
+* console.log(result) // 21
+* ```
+*
+* @category combinators
+* @since 2.0.0
+*/
+const pipeArguments = (self, args) => {
+	switch (args.length) {
+		case 0: return self;
+		case 1: return args[0](self);
+		case 2: return args[1](args[0](self));
+		case 3: return args[2](args[1](args[0](self)));
+		case 4: return args[3](args[2](args[1](args[0](self))));
+		case 5: return args[4](args[3](args[2](args[1](args[0](self)))));
+		case 6: return args[5](args[4](args[3](args[2](args[1](args[0](self))))));
+		case 7: return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));
+		case 8: return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));
+		case 9: return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));
+		default: {
+			let ret = self;
+			for (let i = 0, len = args.length; i < len; i++) ret = args[i](ret);
+			return ret;
+		}
+	}
+};
+/**
+* Reusable prototype that implements `Pipeable.pipe`.
+*
+* **When to use**
+*
+* Use when classes or object prototypes can reuse this value when they need the
+* standard pipe implementation backed by `pipeArguments`.
+*
+* @category prototypes
+* @since 3.15.0
+*/
+const Prototype = { pipe() {
+	return pipeArguments(this, arguments);
+} };
+/**
+* Provides a base constructor whose instances implement the standard `Pipeable.pipe`
+* method.
+*
+* **When to use**
+*
+* Use when you need to define a class that supports Effect-style method
+* chaining through `.pipe(...)`.
+*
+* @category constructors
+* @since 3.15.0
+*/
+const Class = (function() {
+	function PipeableBase() {}
+	PipeableBase.prototype = Prototype;
+	return PipeableBase;
+})();
+/**
+* Provides small helpers for defining and reusing TypeScript functions.
+*
+* The main helpers are `pipe` and `flow` for left-to-right composition and
+* `dual` for APIs that support both direct and pipe-friendly call styles. The
+* module also contains small identity, constant, tuple, type-level, and
+* memoization helpers used across the library.
+*
+* @since 2.0.0
+*/
+/**
+* Creates a function that can be called in data-first style or data-last
+* (`pipe`-friendly) style.
+*
+* **When to use**
+*
+* Use to expose one implementation through both direct and `pipe`-friendly
+* call styles.
+*
+* **Details**
+*
+* Pass either the arity of the uncurried function or a predicate that decides
+* whether the current call is data-first. Arity is the common case. Use a
+* predicate when optional arguments make arity ambiguous.
+*
+* **Example** (Selecting data-first or data-last style by arity)
+*
+* ```ts
+* import { Function, pipe } from "effect"
+*
+* const sum = Function.dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(2, (self, that) => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Defining overloads with call signatures)
+*
+* ```ts
+* import { Function, pipe } from "effect"
+*
+* const sum: {
+*   (that: number): (self: number) => number
+*   (self: number, that: number): number
+* } = Function.dual(2, (self: number, that: number): number => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Selecting data-first or data-last style with a predicate)
+*
+* ```ts
+* import { Function, pipe } from "effect"
+*
+* const sum = Function.dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(
+*   (args) => args.length === 2,
+*   (self, that) => self + that
+* )
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* @category combinators
+* @since 2.0.0
+*/
+const dual = function(arity, body) {
+	if (typeof arity === "function") return function() {
+		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
+	};
+	switch (arity) {
+		case 0:
+		case 1: throw new RangeError(`Invalid arity ${arity}`);
+		case 2: return function(a, b) {
+			if (arguments.length >= 2) return body(a, b);
+			return function(self) {
+				return body(self, a);
+			};
+		};
+		case 3: return function(a, b, c) {
+			if (arguments.length >= 3) return body(a, b, c);
+			return function(self) {
+				return body(self, a, b);
+			};
+		};
+		default: return function() {
+			if (arguments.length >= arity) return body.apply(this, arguments);
+			const args = arguments;
+			return function(self) {
+				return body(self, ...args);
+			};
+		};
+	}
+};
+/**
+* Returns its input argument unchanged.
+*
+* **When to use**
+*
+* Use to return a value unchanged where a function is required.
+*
+* **Example** (Returning the same value)
+*
+* ```ts
+* import { identity } from "effect"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(identity(5), 5)
+* ```
+*
+* @category combinators
+* @since 2.0.0
+*/
+const identity = (a) => a;
+/**
+* Returns the input value with a different static type.
+*
+* **When to use**
+*
+* Use when you need an explicit type-level cast and accept that the value is
+* returned unchanged at runtime.
+*
+* **Gotchas**
+*
+* This is a type-level cast only; it performs no runtime validation or
+* conversion.
+*
+* @see {@link satisfies} for checking assignability without changing the resulting type
+*
+* @category utility types
+* @since 4.0.0
+*/
+const cast = identity;
+/**
+* Creates a zero-argument function that always returns the provided value.
+*
+* **When to use**
+*
+* Use when you need a thunk or callback that returns the same value on every
+* invocation.
+*
+* **Example** (Creating a constant thunk)
+*
+* ```ts
+* import { Function } from "effect"
+* import * as assert from "node:assert"
+*
+* const constNull = Function.constant(null)
+*
+* assert.deepStrictEqual(constNull(), null)
+* assert.deepStrictEqual(constNull(), null)
+* ```
+*
+* @category constructors
+* @since 2.0.0
+*/
+const constant = (value) => () => value;
+/**
+* Returns `true` when called.
+*
+* **When to use**
+*
+* Use when you need a thunk that returns `true` on every invocation.
+*
+* **Example** (Returning true from a thunk)
+*
+* ```ts
+* import { Function } from "effect"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(Function.constTrue(), true)
+* ```
+*
+* @category constants
+* @since 2.0.0
+*/
+const constTrue = constant(true);
+/**
+* Returns `false` when called.
+*
+* **When to use**
+*
+* Use when you need a thunk that returns `false` on every invocation.
+*
+* **Example** (Returning false from a thunk)
+*
+* ```ts
+* 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"
+*
+* // data-first
+* assert.deepStrictEqual(takeWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [1, 2])
+*
+* // data-last
+* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], takeWhile((n: number) => n < 3)), [1, 2])
+* ```
+* @category array
+*/
+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/is-attribute.ts
+/**
+* Check whether a node is a `JSXAttribute` with the given name.
+*
+* Only plain identifier names are matched (ex: `className`); namespaced
+* attributes (ex: `xml:space`) do not match.
+*
+* 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/is-element.ts
 /**
 * Check whether a node is a `JSXElement` (or `JSXFragment`) and optionally
-* matches a given test
+* matches a given test.
 *
 * Modelled after
 * [`hast-util-is-element`](https://github.com/syntax-tree/hast-util-is-element):
@@ -477,9 +970,9 @@ function hasEveryAttribute(context, element, names) {
 *
 * When called without a test, the function acts as a simple type-guard
 * for `JSXElement | JSXFragment`.
-* @param node The AST node to test
-* @param test Optional test to match the element type against
-* @returns `true` when the node is a matching JSX element
+* @param node The AST node to test.
+* @param test Optional test to match the element type against.
+* @returns `true` when the node is a matching JSX element.
 */
 function isElement(node, test) {
 	if (node == null) return false;
@@ -496,7 +989,7 @@ function isElement(node, test) {
 //#endregion
 //#region src/is-fragment-element.ts
 /**
-* Check whether a node is a React Fragment element
+* Check whether a node is a React Fragment element.
 *
 * Recognizes both the shorthand `<>...</>` syntax (`JSXFragment`) and the
 * explicit `<Fragment>` / `<React.Fragment>` form (`JSXElement`).
@@ -504,9 +997,9 @@ function isElement(node, test) {
 * The comparison is performed against the self name (last dot-separated
 * segment) of both the node and the configured factory, so `<React.Fragment>`
 * matches `"React.Fragment"` and `<Fragment>` matches `"Fragment"`.
-* @param node The AST node to test
-* @param jsxFragmentFactory The configured fragment factory string (ex: "React.Fragment")
-* @returns `true` when the node represents a React Fragment
+* @param node The AST node to test.
+* @param jsxFragmentFactory The configured fragment factory string (ex: "React.Fragment").
+* @returns `true` when the node represents a React Fragment.
 */
 function isFragmentElement(node, jsxFragmentFactory = "React.Fragment") {
 	if (node.type === AST_NODE_TYPES.JSXFragment) return true;
@@ -518,13 +1011,13 @@ function isFragmentElement(node, jsxFragmentFactory = "React.Fragment") {
 //#endregion
 //#region src/is-host-element.ts
 /**
-* Check whether a node is a host (intrinsic / DOM) element
+* Check whether a node is a host (intrinsic / DOM) element.
 *
 * A host element is a `JSXElement` whose tag name is a plain `JSXIdentifier`
 * starting with a lowercase letter, the same heuristic React uses to
 * distinguish `<div>` from `<MyComponent>`.
-* @param node The AST node to test
-* @returns `true` when the node is a `JSXElement` with a lowercase tag name
+* @param node The AST node to test.
+* @returns `true` when the node is a `JSXElement` with a lowercase tag name.
 */
 function isHostElement(node) {
 	if (node.type !== AST_NODE_TYPES.JSXElement) return false;
@@ -537,7 +1030,7 @@ function isHostElement(node) {
 //#endregion
 //#region src/jsx-detection-hint.ts
 /**
-* Hints for JSX detection
+* Hints for JSX detection.
 */
 const JsxDetectionHint = {
 	None: 0n,
@@ -554,7 +1047,7 @@ const JsxDetectionHint = {
 	RequireBothBranchesOfConditionalExpressionToBeJsx: 1n << 10n
 };
 /**
-* Default JSX detection hint
+* Default JSX detection hint.
 *
 * Skips number, bigint, boolean, string, and undefined literals,
 * the value types that are commonly returned alongside JSX in React
@@ -563,4 +1056,4 @@ const JsxDetectionHint = {
 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, isElement, isEmptyStringExpression, isFragmentElement, isHostElement, isWhitespace, isWhitespaceText, resolveAttributeValue };
+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 };