eslint-plugin-better-tailwindcss 4.3.2 → 4.4.1

package/lib/options/descriptions.d.ts

@@ -1,5 +1,6 @@
 import type { InferOutput } from "valibot";
 export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
+    readonly cwd: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "The working directory to resolve tailwindcss and the config from. Useful in monorepo setups.">]>, undefined>;
     readonly rootFontSize: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").DescriptionAction<number, "The root font size in pixels.">]>, undefined>;
     readonly detectComponentClasses: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").BooleanSchema<undefined>, import("valibot").DescriptionAction<boolean, "Whether to automatically detect custom component classes from the tailwindcss config.">]>, false>;
     readonly tsconfig: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "The path to the tsconfig file. Is used to resolve path aliases in the tsconfig.">]>, undefined>;
@@ -148,6 +149,25 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         }, undefined>, import("valibot").StrictObjectSchema<{
             readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
             readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+            }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
         }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
             type: import("../types/rule.js").MatcherType.String;
         } | {
@@ -156,6 +176,17 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         } | {
             path?: string | undefined;
             type: import("../types/rule.js").MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[];
+            type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
         })[] | undefined, "Optional list of matchers that will be applied.">]>;
         readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
     }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
@@ -169,6 +200,25 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         }, undefined>, import("valibot").StrictObjectSchema<{
             readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
             readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+            }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
         }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
             type: import("../types/rule.js").MatcherType.String;
         } | {
@@ -177,9 +227,22 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         } | {
             path?: string | undefined;
             type: import("../types/rule.js").MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[];
+            type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
         })[] | undefined, "Optional list of matchers that will be applied.">]>;
         readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
         readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for callee paths that should be linted.">]>, undefined>;
+        readonly targetArgument: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"all", undefined>, import("valibot").LiteralSchema<"first", undefined>, import("valibot").LiteralSchema<"last", undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, import("valibot").DescriptionAction<number | "all" | "first" | "last" | undefined, "Optional argument target for call arguments: index, first, last, or all.">]>;
+        readonly targetCall: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"all", undefined>, import("valibot").LiteralSchema<"first", undefined>, import("valibot").LiteralSchema<"last", undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, import("valibot").DescriptionAction<number | "all" | "first" | "last" | undefined, "Optional call target for curried callees: index, first, last, or all.">]>;
     }, undefined>, import("valibot").StrictObjectSchema<{
         readonly callTarget: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"all", undefined>, import("valibot").LiteralSchema<"first", undefined>, import("valibot").LiteralSchema<"last", undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, import("valibot").DescriptionAction<number | "all" | "first" | "last" | undefined, "Optional call target for curried callees: index, first, last, or all.">]>;
         readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").SelectorKind.Callee, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").SelectorKind.Callee, "Selector kind that determines where matching is applied.">]>;
@@ -191,6 +254,25 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         }, undefined>, import("valibot").StrictObjectSchema<{
             readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
             readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+            }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
         }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
             type: import("../types/rule.js").MatcherType.String;
         } | {
@@ -199,10 +281,23 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         } | {
             path?: string | undefined;
             type: import("../types/rule.js").MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[];
+            type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
         })[] | undefined, "Optional list of matchers that will be applied.">]>;
         readonly name: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>, undefined>;
         readonly path: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for callee paths that should be linted.">]>;
-    }, undefined>], undefined>, import("valibot").StrictObjectSchema<{
+        readonly targetArgument: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"all", undefined>, import("valibot").LiteralSchema<"first", undefined>, import("valibot").LiteralSchema<"last", undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, import("valibot").DescriptionAction<number | "all" | "first" | "last" | undefined, "Optional argument target for call arguments: index, first, last, or all.">]>;
+        readonly targetCall: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"all", undefined>, import("valibot").LiteralSchema<"first", undefined>, import("valibot").LiteralSchema<"last", undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, import("valibot").DescriptionAction<number | "all" | "first" | "last" | undefined, "Optional call target for curried callees: index, first, last, or all.">]>;
+    }, undefined>], undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
         readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").SelectorKind.Tag, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").SelectorKind.Tag, "Selector kind that determines where matching is applied.">]>;
         readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
             readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
@@ -212,6 +307,25 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         }, undefined>, import("valibot").StrictObjectSchema<{
             readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
             readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+            }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
         }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
             type: import("../types/rule.js").MatcherType.String;
         } | {
@@ -220,9 +334,72 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         } | {
             path?: string | undefined;
             type: import("../types/rule.js").MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[];
+            type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
         })[] | undefined, "Optional list of matchers that will be applied.">]>;
         readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+        readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for tag paths that should be linted.">]>, undefined>;
     }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").SelectorKind.Tag, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").SelectorKind.Tag, "Selector kind that determines where matching is applied.">]>;
+        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+            }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
+        }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+            type: import("../types/rule.js").MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: import("../types/rule.js").MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: import("../types/rule.js").MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[];
+            type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+        })[] | undefined, "Optional list of matchers that will be applied.">]>;
+        readonly name: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>, undefined>;
+        readonly path: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for tag paths that should be linted.">]>;
+    }, undefined>], undefined>, import("valibot").StrictObjectSchema<{
         readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").SelectorKind.Variable, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").SelectorKind.Variable, "Selector kind that determines where matching is applied.">]>;
         readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
             readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
@@ -232,6 +409,25 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         }, undefined>, import("valibot").StrictObjectSchema<{
             readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
             readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
+                readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+            }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
         }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
             type: import("../types/rule.js").MatcherType.String;
         } | {
@@ -240,6 +436,17 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         } | {
             path?: string | undefined;
             type: import("../types/rule.js").MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[];
+            type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
         })[] | undefined, "Optional list of matchers that will be applied.">]>;
         readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
     }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
@@ -253,9 +460,22 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         } | {
             path?: string | undefined;
             type: import("../types/rule.js").MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[];
+            type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
         })[] | undefined;
         name: string;
         path?: string | undefined;
+        targetArgument?: number | "all" | "first" | "last" | undefined;
+        targetCall?: number | "all" | "first" | "last" | undefined;
     } | {
         callTarget?: number | "all" | "first" | "last" | undefined;
         kind: import("../types/rule.js").SelectorKind.Callee;
@@ -267,11 +487,24 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         } | {
             path?: string | undefined;
             type: import("../types/rule.js").MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[];
+            type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
         })[] | undefined;
         name?: string | undefined;
         path: string;
+        targetArgument?: number | "all" | "first" | "last" | undefined;
+        targetCall?: number | "all" | "first" | "last" | undefined;
     } | {
-        kind: import("../types/rule.js").SelectorKind.Attribute;
+        kind: import("../types/rule.js").SelectorKind.Tag;
         match?: ({
             type: import("../types/rule.js").MatcherType.String;
         } | {
@@ -280,8 +513,20 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         } | {
             path?: string | undefined;
             type: import("../types/rule.js").MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[];
+            type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
         })[] | undefined;
         name: string;
+        path?: string | undefined;
     } | {
         kind: import("../types/rule.js").SelectorKind.Tag;
         match?: ({
@@ -292,6 +537,41 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         } | {
             path?: string | undefined;
             type: import("../types/rule.js").MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[];
+            type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+        })[] | undefined;
+        name?: string | undefined;
+        path: string;
+    } | {
+        kind: import("../types/rule.js").SelectorKind.Attribute;
+        match?: ({
+            type: import("../types/rule.js").MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: import("../types/rule.js").MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: import("../types/rule.js").MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[];
+            type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
         })[] | undefined;
         name: string;
     } | {
@@ -304,6 +584,17 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
         } | {
             path?: string | undefined;
             type: import("../types/rule.js").MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            })[];
+            type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
         })[] | undefined;
         name: string;
     })[], "Flat list of selectors that should get linted.">]>, ({
@@ -325,6 +616,21 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
             type: import("../types/rule.js").MatcherType.ObjectValue;
         }[];
         name: string;
+    } | {
+        kind: import("../types/rule.js").SelectorKind.Tag;
+        path: string;
+    } | {
+        kind: import("../types/rule.js").SelectorKind.Callee;
+        match: ({
+            type: import("../types/rule.js").MatcherType.String;
+            match?: never;
+        } | {
+            match: {
+                type: import("../types/rule.js").MatcherType.String;
+            }[];
+            type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+        })[];
+        path: string;
     } | {
         kind: import("../types/rule.js").SelectorKind.Attribute;
         name: string;

package/lib/options/descriptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"descriptions.d.ts","sourceRoot":"","sources":["../../src/options/descriptions.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAYzB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC"}
+{"version":3,"file":"descriptions.d.ts","sourceRoot":"","sources":["../../src/options/descriptions.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAazB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/lib/options/descriptions.js

@@ -1,7 +1,7 @@
 import { strictObject } from "valibot";
 import { ATTRIBUTES_OPTION_SCHEMA } from "./schemas/attributes.js";
 import { CALLEES_OPTION_SCHEMA } from "./schemas/callees.js";
-import { DETECT_COMPONENT_CLASSES_OPTION_SCHEMA, ENTRYPOINT_OPTION_SCHEMA, MESSAGE_STYLE_OPTION_SCHEMA, ROOT_FONT_SIZE_OPTION_SCHEMA, TAILWIND_OPTION_SCHEMA, TSCONFIG_OPTION_SCHEMA } from "./schemas/common.js";
+import { CWD_OPTION_SCHEMA, DETECT_COMPONENT_CLASSES_OPTION_SCHEMA, ENTRYPOINT_OPTION_SCHEMA, MESSAGE_STYLE_OPTION_SCHEMA, ROOT_FONT_SIZE_OPTION_SCHEMA, TAILWIND_OPTION_SCHEMA, TSCONFIG_OPTION_SCHEMA } from "./schemas/common.js";
 import { SELECTORS_OPTION_SCHEMA } from "./schemas/selectors.js";
 import { TAGS_OPTIONS_SCHEMA } from "./schemas/tags.js";
 import { VARIABLES_OPTION_SCHEMA } from "./schemas/variables.js";
@@ -16,6 +16,7 @@ export const COMMON_OPTIONS = strictObject({
     ...TAILWIND_OPTION_SCHEMA.entries,
     ...TSCONFIG_OPTION_SCHEMA.entries,
     ...DETECT_COMPONENT_CLASSES_OPTION_SCHEMA.entries,
-    ...ROOT_FONT_SIZE_OPTION_SCHEMA.entries
+    ...ROOT_FONT_SIZE_OPTION_SCHEMA.entries,
+    ...CWD_OPTION_SCHEMA.entries
 });
 //# sourceMappingURL=descriptions.js.map

package/lib/options/descriptions.js.map

@@ -1 +1 @@
-{"version":3,"file":"descriptions.js","sourceRoot":"","sources":["../../src/options/descriptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,OAAO,EAAE,wBAAwB,EAAE,MAAM,kDAAkD,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,+CAA+C,CAAC;AACtF,OAAO,EACL,sCAAsC,EACtC,wBAAwB,EACxB,2BAA2B,EAC3B,4BAA4B,EAC5B,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,iDAAiD,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AACjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iDAAiD,CAAC;AAK1F,MAAM,CAAC,MAAM,cAAc,GAAG,YAAY,CAAC;IACzC,GAAG,uBAAuB,CAAC,OAAO;IAClC,GAAG,qBAAqB,CAAC,OAAO;IAChC,GAAG,wBAAwB,CAAC,OAAO;IACnC,GAAG,uBAAuB,CAAC,OAAO;IAClC,GAAG,mBAAmB,CAAC,OAAO;IAC9B,GAAG,wBAAwB,CAAC,OAAO;IACnC,GAAG,2BAA2B,CAAC,OAAO;IACtC,GAAG,sBAAsB,CAAC,OAAO;IACjC,GAAG,sBAAsB,CAAC,OAAO;IACjC,GAAG,sCAAsC,CAAC,OAAO;IACjD,GAAG,4BAA4B,CAAC,OAAO;CACxC,CAAC,CAAC"}
+{"version":3,"file":"descriptions.js","sourceRoot":"","sources":["../../src/options/descriptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,OAAO,EAAE,wBAAwB,EAAE,MAAM,kDAAkD,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,+CAA+C,CAAC;AACtF,OAAO,EACL,iBAAiB,EACjB,sCAAsC,EACtC,wBAAwB,EACxB,2BAA2B,EAC3B,4BAA4B,EAC5B,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,iDAAiD,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AACjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iDAAiD,CAAC;AAK1F,MAAM,CAAC,MAAM,cAAc,GAAG,YAAY,CAAC;IACzC,GAAG,uBAAuB,CAAC,OAAO;IAClC,GAAG,qBAAqB,CAAC,OAAO;IAChC,GAAG,wBAAwB,CAAC,OAAO;IACnC,GAAG,uBAAuB,CAAC,OAAO;IAClC,GAAG,mBAAmB,CAAC,OAAO;IAC9B,GAAG,wBAAwB,CAAC,OAAO;IACnC,GAAG,2BAA2B,CAAC,OAAO;IACtC,GAAG,sBAAsB,CAAC,OAAO;IACjC,GAAG,sBAAsB,CAAC,OAAO;IACjC,GAAG,sCAAsC,CAAC,OAAO;IACjD,GAAG,4BAA4B,CAAC,OAAO;IACvC,GAAG,iBAAiB,CAAC,OAAO;CAC7B,CAAC,CAAC"}

package/lib/options/migrate.js

@@ -66,6 +66,9 @@ function toSelectorMatcher(matcher) {
     };
 }
 function toLegacyMatcher(matcher) {
+    if (matcher.type === MatcherType.AnonymousFunctionReturn) {
+        return;
+    }
     if (matcher.type === MatcherType.String) {
         return {
             match: matcher.type
@@ -79,37 +82,51 @@ function toLegacyMatcher(matcher) {
     };
 }
 function migrateLegacySelector(selector, kind) {
-    if (typeof selector === "string") {
+    const name = typeof selector === "string" ? selector : selector[0];
+    const path = kind === SelectorKind.Callee || kind === SelectorKind.Tag ? name : undefined;
+    const matchers = typeof selector === "string" ? undefined : selector[1].map(toSelectorMatcher);
+    if (matchers === undefined) {
         return {
             kind,
-            name: selector
+            name,
+            ...path ? { path } : {}
         };
     }
     return {
         kind,
-        match: selector[1].map(toSelectorMatcher),
-        name: selector[0]
+        match: matchers,
+        name,
+        ...path ? { path } : {}
     };
 }
 function migrateFlatSelector(selector) {
-    if (selector.kind === SelectorKind.Callee) {
-        if (selector.name === undefined) {
-            return;
-        }
+    if (selector.kind === SelectorKind.Callee || selector.kind === SelectorKind.Tag) {
         if (selector.match === undefined) {
-            return selector.name;
+            return selector.name ?? selector.path;
+        }
+        const legacyMatchers = selector.match
+            .map(toLegacyMatcher)
+            .filter((matcher) => matcher !== undefined);
+        if (legacyMatchers.length !== selector.match.length) {
+            return;
         }
         return [
-            selector.name,
-            selector.match.map(toLegacyMatcher)
+            selector.name ?? selector.path,
+            legacyMatchers
         ];
     }
     if (selector.match === undefined) {
         return selector.name;
     }
+    const legacyMatchers = selector.match
+        .map(toLegacyMatcher)
+        .filter((matcher) => matcher !== undefined);
+    if (legacyMatchers.length !== selector.match.length) {
+        return;
+    }
     return [
         selector.name,
-        selector.match.map(toLegacyMatcher)
+        legacyMatchers
     ];
 }
 //# sourceMappingURL=migrate.js.map

package/lib/options/migrate.js.map

@@ -1 +1 @@
-{"version":3,"file":"migrate.js","sourceRoot":"","sources":["../../src/options/migrate.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"migrate.js","sourceRoot":"","sources":["../../src/options/migrate.ts"],"names":[],"mappings":"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"}

package/lib/options/schemas/common.d.ts

@@ -23,4 +23,8 @@ export declare const ROOT_FONT_SIZE_OPTION_SCHEMA: import("valibot").StrictObjec
     readonly rootFontSize: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").DescriptionAction<number, "The root font size in pixels.">]>, undefined>;
 }, undefined>;
 export type RootFontSizeOption = InferOutput<typeof ROOT_FONT_SIZE_OPTION_SCHEMA>;
+export declare const CWD_OPTION_SCHEMA: import("valibot").StrictObjectSchema<{
+    readonly cwd: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "The working directory to resolve tailwindcss and the config from. Useful in monorepo setups.">]>, undefined>;
+}, undefined>;
+export type CwdOption = InferOutput<typeof CWD_OPTION_SCHEMA>;
 //# sourceMappingURL=common.d.ts.map

package/lib/options/schemas/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/options/schemas/common.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,eAAO,MAAM,wBAAwB;;aAQnC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE5E,eAAO,MAAM,sBAAsB;;aAQjC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE9E,eAAO,MAAM,sBAAsB;;aAQjC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAExE,eAAO,MAAM,2BAA2B;;aActC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEjF,eAAO,MAAM,sCAAsC;;aAQjD,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,WAAW,CAAC,OAAO,sCAAsC,CAAC,CAAC;AAEtG,eAAO,MAAM,4BAA4B;;aAQvC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAC"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/options/schemas/common.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,eAAO,MAAM,wBAAwB;;aAQnC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE5E,eAAO,MAAM,sBAAsB;;aAQjC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE9E,eAAO,MAAM,sBAAsB;;aAQjC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAExE,eAAO,MAAM,2BAA2B;;aActC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEjF,eAAO,MAAM,sCAAsC;;aAQjD,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,WAAW,CAAC,OAAO,sCAAsC,CAAC,CAAC;AAEtG,eAAO,MAAM,4BAA4B;;aAQvC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,iBAAiB;;aAQ5B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC"}