@eslint-react/ast 5.24.0 → 5.24.2

package/dist/index.js

@@ -10,7 +10,7 @@ var check_exports = /* @__PURE__ */ __exportAll({
 	isConditional: () => isConditional,
 	isDirective: () => isDirective,
 	isExpression: () => isExpression,
-	isFunction: () => isFunction,
+	isFunction: () => isFunction$1,
 	isIdentifier: () => isIdentifier,
 	isJSX: () => isJSX,
 	isJSXElement: () => isJSXElement,
@@ -28,70 +28,41 @@ var check_exports = /* @__PURE__ */ __exportAll({
 	isTypeAssertionExpression: () => isTypeAssertionExpression,
 	isTypeExpression: () => isTypeExpression
 });
-/** Check if a node is of the given type. */
 const is = ASTUtils.isNodeOfType;
-/** Check if a node is one of the given types. */
 const isOneOf = ASTUtils.isNodeOfTypes;
-/**
-* Check if a node is a directive statement (ex: `"use client"`), optionally matching a specific directive name.
-* @param node The node to check.
-* @param name The directive name to match. When omitted, any directive matches.
-* @returns `true` if the node is a matching directive statement.
-*/
 function isDirective(node, name) {
 	return node.type === AST_NODE_TYPES.ExpressionStatement && (name == null || node.directive === name);
 }
-/**
-* Check if a node is an identifier, optionally matching a specific name.
-* @param node The node to check.
-* @param name The identifier name to match. When omitted, any identifier matches.
-* @returns `true` if the node is a matching identifier.
-*/
 function isIdentifier(node, name) {
 	return node.type === AST_NODE_TYPES.Identifier && (name == null || node.name === name);
 }
-/** Check if a node is a call expression. */
 const isCallExpression = is(AST_NODE_TYPES.CallExpression);
-/** Check if a node is a member expression. */
 const isMemberExpression = is(AST_NODE_TYPES.MemberExpression);
-/** Check if a node is an object expression. */
 const isObjectExpression = is(AST_NODE_TYPES.ObjectExpression);
-/** Check if a node is a return statement. */
 const isReturnStatement = is(AST_NODE_TYPES.ReturnStatement);
-/** Check if a node is a class declaration or class expression. */
 const isClass = isOneOf([AST_NODE_TYPES.ClassDeclaration, AST_NODE_TYPES.ClassExpression]);
-/** Check if a node is a function declaration, function expression, or arrow function expression. */
-const isFunction = isOneOf([
+const isFunction$1 = isOneOf([
 	AST_NODE_TYPES.ArrowFunctionExpression,
 	AST_NODE_TYPES.FunctionDeclaration,
 	AST_NODE_TYPES.FunctionExpression
 ]);
-/** Check if a node is a property-like node (property definition, index signature, parameter property, or property signature). */
 const isProperty = isOneOf([
 	AST_NODE_TYPES.PropertyDefinition,
 	AST_NODE_TYPES.TSIndexSignature,
 	AST_NODE_TYPES.TSParameterProperty,
 	AST_NODE_TYPES.TSPropertySignature
 ]);
-/** Check if a node is a property or method definition. */
 const isPropertyOrMethod = isOneOf([AST_NODE_TYPES.PropertyDefinition, AST_NODE_TYPES.MethodDefinition]);
-/** Check if a node is a JSX element. */
 const isJSXElement = is(AST_NODE_TYPES.JSXElement);
-/** Check if a node is a JSX expression container. */
 const isJSXExpressionContainer = is(AST_NODE_TYPES.JSXExpressionContainer);
-/** Check if a node is a JSX spread attribute. */
 const isJSXSpreadAttribute = is(AST_NODE_TYPES.JSXSpreadAttribute);
-/** Check if a node is a JSX fragment. */
 const isJSXFragment = is(AST_NODE_TYPES.JSXFragment);
-/** Check if a node is a JSX element or JSX fragment. */
 const isJSXElementOrFragment = isOneOf([AST_NODE_TYPES.JSXElement, AST_NODE_TYPES.JSXFragment]);
-/** Check if a node can appear as a JSX tag name. */
 const isJSXTagNameExpression = isOneOf([
 	AST_NODE_TYPES.JSXIdentifier,
 	AST_NODE_TYPES.JSXMemberExpression,
 	AST_NODE_TYPES.JSXNamespacedName
 ]);
-/** Check if a node is any JSX-related node. */
 const isJSX = isOneOf([
 	AST_NODE_TYPES.JSXAttribute,
 	AST_NODE_TYPES.JSXClosingElement,
@@ -109,7 +80,6 @@ const isJSX = isOneOf([
 	AST_NODE_TYPES.JSXSpreadChild,
 	AST_NODE_TYPES.JSXText
 ]);
-/** Check if a node is a TypeScript type expression (assertion, non-null, satisfies, or instantiation). */
 const isTypeExpression = isOneOf([
 	AST_NODE_TYPES.TSAsExpression,
 	AST_NODE_TYPES.TSTypeAssertion,
@@ -117,14 +87,12 @@ const isTypeExpression = isOneOf([
 	AST_NODE_TYPES.TSSatisfiesExpression,
 	AST_NODE_TYPES.TSInstantiationExpression
 ]);
-/** Check if a node is a TypeScript type assertion-like expression (as, assertion, non-null, or satisfies). */
 const isTypeAssertionExpression = isOneOf([
 	AST_NODE_TYPES.TSAsExpression,
 	AST_NODE_TYPES.TSTypeAssertion,
 	AST_NODE_TYPES.TSNonNullExpression,
 	AST_NODE_TYPES.TSSatisfiesExpression
 ]);
-/** Check if a node is an expression node. */
 const isExpression = isOneOf([
 	AST_NODE_TYPES.ArrayExpression,
 	AST_NODE_TYPES.ArrayPattern,
@@ -162,7 +130,6 @@ const isExpression = isOneOf([
 	AST_NODE_TYPES.UpdateExpression,
 	AST_NODE_TYPES.YieldExpression
 ]);
-/** Check if a node is a conditional expression or a control flow statement. */
 const isConditional = isOneOf([
 	AST_NODE_TYPES.DoWhileStatement,
 	AST_NODE_TYPES.ForInStatement,
@@ -177,54 +144,6 @@ const isConditional = isOneOf([
 
 //#endregion
 //#region ../../.pkgs/eff/dist/index.js
-/**
-* A function that checks if the passed parameter is a string and narrows its type accordingly.
-*
-* @param data - The variable to check.
-* @returns True if the passed input is a string, false otherwise.
-* @category guards
-*/
-function isString(data) {
-	return typeof data === "string";
-}
-/**
-* 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;
@@ -244,110 +163,14 @@ const pipeArguments = (self, args) => {
 		}
 	}
 };
-/**
-* 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));
@@ -376,287 +199,48 @@ const dual = function(arity, body) {
 		};
 	}
 };
-/**
-* 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;
+const and = dual(2, (a, b) => (data) => a(data) && b(data));
+const or = dual(2, (a, b) => (data) => a(data) || b(data));
+const xor = dual(2, (a, b) => (data) => a(data) !== b(data));
+const eqv = dual(2, (a, b) => (data) => a(data) === b(data));
+const implies = dual(2, (antecedent, consequent) => (data) => !antecedent(data) || consequent(data));
+const nor = dual(2, (a, b) => (data) => !a(data) && !b(data));
+const nand = dual(2, (a, b) => (data) => !a(data) || !b(data));
+function isString(input) {
+	return typeof input === "string";
+}
+function isFunction(input) {
+	return typeof input === "function";
+}
+function isObjectKeyword(input) {
+	return typeof input === "object" && input !== null || isFunction(input);
+}
+const hasProperty = dual(2, (data, property) => isObjectKeyword(data) && property in data);
+const dropWhile = dual(2, (self, predicate) => {
+	const input = Array.isArray(self) ? self : Array.from(self);
+	const len = input.length;
 	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(idx);
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.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;
+const takeWhile = dual(2, (self, predicate) => {
+	const input = Array.isArray(self) ? self : Array.from(self);
+	const len = input.length;
 	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(0, idx);
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.slice(0, idx);
 });
 
 //#endregion
@@ -670,21 +254,10 @@ var extract_exports = /* @__PURE__ */ __exportAll({
 	getPropertyName: () => getPropertyName,
 	unwrap: () => unwrap
 });
-/**
-* Recursively unwrap TypeScript type expressions and chain expressions to get the underlying expression.
-* @param node The node to unwrap.
-* @returns The innermost non-type-expression node.
-*/
 function unwrap(node) {
 	if (isTypeExpression(node) || node.type === AST_NODE_TYPES.ChainExpression) return unwrap(node.expression);
 	return node;
 }
-/**
-* Find a property by name in a list of object literal properties, recursing into spread object expressions.
-* @param properties The object literal properties to search.
-* @param name The property name to look for.
-* @returns The matching `Property` node, or `null` when not found.
-*/
 function findProperty(properties, name) {
 	for (const property of properties) {
 		if (property.type === AST_NODE_TYPES.Property && getPropertyName(property) === name) return property;
@@ -695,23 +268,12 @@ function findProperty(properties, name) {
 	}
 	return null;
 }
-/**
-* Get the name of the callee of a call expression.
-* @param node The call expression to inspect.
-* @returns The callee name (ex: `"useState"`), or `null` when it cannot be statically determined.
-*/
 function getCalleeName(node) {
 	const callee = unwrap(node.callee);
 	if (isIdentifier(callee)) return callee.name;
 	if (callee.type === AST_NODE_TYPES.MemberExpression && !callee.computed && isIdentifier(callee.property)) return callee.property.name;
 	return null;
 }
-/**
-* Get the member chain of an expression (ex: `[a, b, c]` for `a.b.c`), starting from the base object.
-* Type expressions and chain expressions are unwrapped along the way.
-* @param node The expression to inspect.
-* @returns The base node followed by each member property in access order.
-*/
 function getMemberChain(node) {
 	const members = [];
 	let current = unwrap(node);
@@ -723,14 +285,6 @@ function getMemberChain(node) {
 	members.unshift(current);
 	return members;
 }
-/**
-* Collect every write target of an assignment or loop target, expanding
-* destructuring patterns such as `[local, globalValue] = source` or
-* `({ a: obj.x } = source)`. Defaults (`{ a = source }`) are not targets;
-* their left side is.
-* @param node The assignment left side or for-in/of loop target to inspect.
-* @returns The identifier and member expression targets being written.
-*/
 function getAssignmentTargets(node) {
 	const target = unwrap(node);
 	switch (target.type) {
@@ -746,12 +300,6 @@ function getAssignmentTargets(node) {
 		default: return [];
 	}
 }
-/**
-* Get the static name of an object property's key.
-* @param property The property to inspect.
-* @param effort `"min"` only matches plain identifiers; `"max"` also resolves string literals and simple template literals.
-* @returns The property name, or `null` when it cannot be statically determined.
-*/
 function getPropertyName(property, effort = "min") {
 	const key = unwrap(property.key);
 	if (isIdentifier(key) && !property.computed) return key.name;
@@ -760,12 +308,6 @@ function getPropertyName(property, effort = "min") {
 	if (key.type === AST_NODE_TYPES.TemplateLiteral && key.expressions.length === 0) return key.quasis[0]?.value.cooked ?? key.quasis[0]?.value.raw ?? null;
 	return null;
 }
-/**
-* Get the fully qualified name of a node (ex: `React.useState`), falling back to source text when needed.
-* @param node The node to inspect.
-* @param getText A function returning the source text of a node.
-* @returns The fully qualified name.
-*/
 function getFullyQualifiedName(node, getText) {
 	const expr = unwrap(node);
 	switch (expr.type) {
@@ -786,13 +328,6 @@ function getFullyQualifiedName(node, getText) {
 //#endregion
 //#region src/compare.ts
 var compare_exports = /* @__PURE__ */ __exportAll({ isEqual: () => isEqual });
-/**
-* Check if two nodes are structurally equal.
-* @param a The first node to compare.
-* @param b The second node to compare.
-* @returns `true` if the nodes are equal.
-* @see https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/util/isNodeEqual.ts
-*/
 const isEqual = dual(2, (a, b) => {
 	a = isTypeExpression(a) ? unwrap(a) : a;
 	b = isTypeExpression(b) ? unwrap(b) : b;
@@ -859,11 +394,6 @@ function findParent(node, test, stop) {
 	}
 	return null;
 }
-/**
-* Find the nearest `TryStatement` whose `try` block (not `catch`/`finally`) encloses the given node.
-* @param node The node to check.
-* @returns The enclosing `TryStatement`, or `null` when none is found.
-*/
 function findEnclosingTryBlock(node) {
 	const parent = node.parent;
 	if (parent == null || parent.type === AST_NODE_TYPES.Program) return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/ast",
-  "version": "5.24.0",
+  "version": "5.24.2",
   "description": "ESLint React's TSESTree AST utility module.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -37,7 +37,7 @@
     "@local/configs": "0.0.0",
     "@local/eff": "0.0.0",
     "@local/testkit": "0.0.0",
-    "eslint": "^10.11.0",
+    "eslint": "^10.12.0",
     "tsdown": "^0.23.0",
     "typescript": "6.0.3",
     "vitest": "^5.0.3"