@dhzh/eslint-plugin-better-tailwindcss 0.0.0-stage → 4.9.0-patch

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../../src/options/schemas/selectors.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAE7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA8K3C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAK1B,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,eAAe,CAAC,CAAC;AAE3D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAG5B,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE7D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAElC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/lib/options/schemas/selectors.js

@@ -0,0 +1,100 @@
+import { array, description, literal, number, optional, pipe, strictObject, string, union } from "valibot";
+import { DEFAULT_SELECTORS } from "../default-options.js";
+import { MatcherType, SelectorKind } from "../../types/rule.js";
+const STRING_SELECTOR_MATCHER_SCHEMA = strictObject({
+    type: pipe(literal(MatcherType.String), description("Matcher type that will be applied."))
+});
+const OBJECT_KEY_SELECTOR_MATCHER_SCHEMA = strictObject({
+    path: optional(pipe(string(), description("Regular expression that filters the object key and matches the content for further processing in a group."))),
+    type: pipe(literal(MatcherType.ObjectKey), description("Matcher type that will be applied."))
+});
+const OBJECT_VALUE_SELECTOR_MATCHER_SCHEMA = strictObject({
+    path: optional(pipe(string(), description("Regular expression that filters the object value and matches the content for further processing in a group."))),
+    type: pipe(literal(MatcherType.ObjectValue), description("Matcher type that will be applied."))
+});
+const ANONYMOUS_FUNCTION_RETURN_SELECTOR_MATCHER_SCHEMA = strictObject({
+    match: pipe(array(union([
+        STRING_SELECTOR_MATCHER_SCHEMA,
+        OBJECT_KEY_SELECTOR_MATCHER_SCHEMA,
+        OBJECT_VALUE_SELECTOR_MATCHER_SCHEMA
+    ])), description("List of nested matchers that target the return value of anonymous functions.")),
+    type: pipe(literal(MatcherType.AnonymousFunctionReturn), description("Matcher type that will be applied."))
+});
+const SELECTOR_MATCH_SCHEMA = pipe(optional(array(union([
+    STRING_SELECTOR_MATCHER_SCHEMA,
+    OBJECT_KEY_SELECTOR_MATCHER_SCHEMA,
+    OBJECT_VALUE_SELECTOR_MATCHER_SCHEMA,
+    ANONYMOUS_FUNCTION_RETURN_SELECTOR_MATCHER_SCHEMA
+]))), description("Optional list of matchers that will be applied."));
+const SELECTOR_NAME_SCHEMA = pipe(string(), description("Regular expression for names that should be linted."));
+const CALLEE_SELECTOR_PATH_SCHEMA = pipe(string(), description("Regular expression for callee paths that should be linted."));
+const TAG_SELECTOR_PATH_SCHEMA = pipe(string(), description("Regular expression for tag paths that should be linted."));
+const CALLEE_SELECTOR_TARGET_VALUE_SCHEMA = optional(union([
+    literal("all"),
+    literal("first"),
+    literal("last"),
+    number()
+]));
+const CALLEE_SELECTOR_TARGET_ARGUMENT_SCHEMA = pipe(CALLEE_SELECTOR_TARGET_VALUE_SCHEMA, description("Optional argument target for call arguments: index, first, last, or all."));
+const CALLEE_SELECTOR_TARGET_CALL_SCHEMA = pipe(CALLEE_SELECTOR_TARGET_VALUE_SCHEMA, description("Optional call target for curried callees: index, first, last, or all."));
+const CALLEE_SELECTOR_LEGACY_CALL_TARGET_SCHEMA = pipe(optional(union([
+    literal("all"),
+    literal("first"),
+    literal("last"),
+    number()
+])), description("Optional call target for curried callees: index, first, last, or all."));
+const ATTRIBUTE_SELECTOR_SCHEMA = strictObject({
+    kind: pipe(literal(SelectorKind.Attribute), description("Selector kind that determines where matching is applied.")),
+    match: SELECTOR_MATCH_SCHEMA,
+    name: SELECTOR_NAME_SCHEMA
+});
+const CALLEE_SELECTOR_SCHEMA = union([
+    strictObject({
+        callTarget: CALLEE_SELECTOR_LEGACY_CALL_TARGET_SCHEMA,
+        kind: pipe(literal(SelectorKind.Callee), description("Selector kind that determines where matching is applied.")),
+        match: SELECTOR_MATCH_SCHEMA,
+        name: SELECTOR_NAME_SCHEMA,
+        path: optional(CALLEE_SELECTOR_PATH_SCHEMA),
+        targetArgument: CALLEE_SELECTOR_TARGET_ARGUMENT_SCHEMA,
+        targetCall: CALLEE_SELECTOR_TARGET_CALL_SCHEMA
+    }),
+    strictObject({
+        callTarget: CALLEE_SELECTOR_LEGACY_CALL_TARGET_SCHEMA,
+        kind: pipe(literal(SelectorKind.Callee), description("Selector kind that determines where matching is applied.")),
+        match: SELECTOR_MATCH_SCHEMA,
+        name: optional(SELECTOR_NAME_SCHEMA),
+        path: CALLEE_SELECTOR_PATH_SCHEMA,
+        targetArgument: CALLEE_SELECTOR_TARGET_ARGUMENT_SCHEMA,
+        targetCall: CALLEE_SELECTOR_TARGET_CALL_SCHEMA
+    })
+]);
+const TAG_SELECTOR_SCHEMA = union([
+    strictObject({
+        kind: pipe(literal(SelectorKind.Tag), description("Selector kind that determines where matching is applied.")),
+        match: SELECTOR_MATCH_SCHEMA,
+        name: SELECTOR_NAME_SCHEMA,
+        path: optional(TAG_SELECTOR_PATH_SCHEMA)
+    }),
+    strictObject({
+        kind: pipe(literal(SelectorKind.Tag), description("Selector kind that determines where matching is applied.")),
+        match: SELECTOR_MATCH_SCHEMA,
+        name: optional(SELECTOR_NAME_SCHEMA),
+        path: TAG_SELECTOR_PATH_SCHEMA
+    })
+]);
+const VARIABLE_SELECTOR_SCHEMA = strictObject({
+    kind: pipe(literal(SelectorKind.Variable), description("Selector kind that determines where matching is applied.")),
+    match: SELECTOR_MATCH_SCHEMA,
+    name: SELECTOR_NAME_SCHEMA
+});
+export const SELECTOR_SCHEMA = union([
+    ATTRIBUTE_SELECTOR_SCHEMA,
+    CALLEE_SELECTOR_SCHEMA,
+    TAG_SELECTOR_SCHEMA,
+    VARIABLE_SELECTOR_SCHEMA
+]);
+export const SELECTORS_SCHEMA = pipe(array(SELECTOR_SCHEMA), description("Flat list of selectors that should get linted."));
+export const SELECTORS_OPTION_SCHEMA = strictObject({
+    selectors: optional(SELECTORS_SCHEMA, DEFAULT_SELECTORS)
+});
+//# sourceMappingURL=selectors.js.map

package/lib/options/schemas/selectors.js.map

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

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

@@ -0,0 +1,101 @@
+import type { InferOutput } from "valibot";
+declare const TAG_MATCHER_CONFIG: import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Template literal tag for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+    readonly match: 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 match: 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.">]>;
+    readonly pathPattern: 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>;
+}, undefined>, import("valibot").StrictObjectSchema<{
+    readonly match: 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.">]>;
+    readonly pathPattern: 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>;
+}, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+    match: import("../../types/rule.js").MatcherType.String;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectKey;
+    pathPattern?: string | undefined;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectValue;
+    pathPattern?: string | undefined;
+})[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
+    match: import("../../types/rule.js").MatcherType.String;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectKey;
+    pathPattern?: string | undefined;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectValue;
+    pathPattern?: string | undefined;
+})[]], "List of matchers that will automatically be matched.">]>;
+export type TagMatchers = InferOutput<typeof TAG_MATCHER_CONFIG>;
+declare const TAG_NAME_CONFIG: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Template literal tag that should get linted.">]>;
+export type TagName = InferOutput<typeof TAG_NAME_CONFIG>;
+export declare const TAGS_SCHEMA: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Template literal tag for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+    readonly match: 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 match: 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.">]>;
+    readonly pathPattern: 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>;
+}, undefined>, import("valibot").StrictObjectSchema<{
+    readonly match: 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.">]>;
+    readonly pathPattern: 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>;
+}, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+    match: import("../../types/rule.js").MatcherType.String;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectKey;
+    pathPattern?: string | undefined;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectValue;
+    pathPattern?: string | undefined;
+})[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
+    match: import("../../types/rule.js").MatcherType.String;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectKey;
+    pathPattern?: string | undefined;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectValue;
+    pathPattern?: string | undefined;
+})[]], "List of matchers that will automatically be matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Template literal tag that should get linted.">]>], undefined>, undefined>, import("valibot").DescriptionAction<(string | [string, ({
+    match: import("../../types/rule.js").MatcherType.String;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectKey;
+    pathPattern?: string | undefined;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectValue;
+    pathPattern?: string | undefined;
+})[]])[], "List of template literal tags that should get linted.">]>;
+export type Tags = InferOutput<typeof TAGS_SCHEMA>;
+export declare const TAGS_OPTIONS_SCHEMA: import("valibot").StrictObjectSchema<{
+    readonly tags: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Template literal tag for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly match: 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 match: 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.">]>;
+        readonly pathPattern: 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>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly match: 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.">]>;
+        readonly pathPattern: 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>;
+    }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+        match: import("../../types/rule.js").MatcherType.String;
+    } | {
+        match: import("../../types/rule.js").MatcherType.ObjectKey;
+        pathPattern?: string | undefined;
+    } | {
+        match: import("../../types/rule.js").MatcherType.ObjectValue;
+        pathPattern?: string | undefined;
+    })[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
+        match: import("../../types/rule.js").MatcherType.String;
+    } | {
+        match: import("../../types/rule.js").MatcherType.ObjectKey;
+        pathPattern?: string | undefined;
+    } | {
+        match: import("../../types/rule.js").MatcherType.ObjectValue;
+        pathPattern?: string | undefined;
+    })[]], "List of matchers that will automatically be matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Template literal tag that should get linted.">]>], undefined>, undefined>, import("valibot").DescriptionAction<(string | [string, ({
+        match: import("../../types/rule.js").MatcherType.String;
+    } | {
+        match: import("../../types/rule.js").MatcherType.ObjectKey;
+        pathPattern?: string | undefined;
+    } | {
+        match: import("../../types/rule.js").MatcherType.ObjectValue;
+        pathPattern?: string | undefined;
+    })[]])[], "List of template literal tags that should get linted.">]>, undefined>;
+}, undefined>;
+export type TagsOptions = InferOutput<typeof TAGS_OPTIONS_SCHEMA>;
+export {};
+//# sourceMappingURL=tags.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../../../src/options/schemas/tags.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;gEAkBvB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEjE,QAAA,MAAM,eAAe,qLAGpB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,eAAe,CAAC,CAAC;AAE1D,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAQvB,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG,WAAW,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAE9B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/lib/options/schemas/tags.js

@@ -0,0 +1,19 @@
+import { array, description, optional, pipe, strictObject, string, tuple, union } from "valibot";
+import { OBJECT_KEY_MATCHER_SCHEMA, OBJECT_VALUE_MATCHER_SCHEMA, STRING_MATCHER_SCHEMA } from "../schemas/matchers.js";
+const TAG_MATCHER_CONFIG = pipe(tuple([
+    pipe(string(), description("Template literal tag for which children get linted if matched.")),
+    pipe(array(union([
+        STRING_MATCHER_SCHEMA,
+        OBJECT_KEY_MATCHER_SCHEMA,
+        OBJECT_VALUE_MATCHER_SCHEMA
+    ])), description("List of matchers that will be applied."))
+]), description("List of matchers that will automatically be matched."));
+const TAG_NAME_CONFIG = pipe(string(), description("Template literal tag that should get linted."));
+export const TAGS_SCHEMA = pipe(array(union([
+    TAG_MATCHER_CONFIG,
+    TAG_NAME_CONFIG
+])), description("List of template literal tags that should get linted."));
+export const TAGS_OPTIONS_SCHEMA = strictObject({
+    tags: optional(TAGS_SCHEMA)
+});
+//# sourceMappingURL=tags.js.map

package/lib/options/schemas/tags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.js","sourceRoot":"","sources":["../../../src/options/schemas/tags.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,WAAW,EACX,QAAQ,EACR,IAAI,EACJ,YAAY,EACZ,MAAM,EACN,KAAK,EACL,KAAK,EACN,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,yBAAyB,EACzB,2BAA2B,EAC3B,qBAAqB,EACtB,MAAM,gDAAgD,CAAC;AAKxD,MAAM,kBAAkB,GAAG,IAAI,CAC7B,KAAK,CAAC;IACJ,IAAI,CACF,MAAM,EAAE,EACR,WAAW,CAAC,gEAAgE,CAAC,CAC9E;IACD,IAAI,CACF,KAAK,CACH,KAAK,CAAC;QACJ,qBAAqB;QACrB,yBAAyB;QACzB,2BAA2B;KAC5B,CAAC,CACH,EACD,WAAW,CAAC,wCAAwC,CAAC,CACtD;CACF,CAAC,EACF,WAAW,CAAC,sDAAsD,CAAC,CACpE,CAAC;AAIF,MAAM,eAAe,GAAG,IAAI,CAC1B,MAAM,EAAE,EACR,WAAW,CAAC,8CAA8C,CAAC,CAC5D,CAAC;AAIF,MAAM,CAAC,MAAM,WAAW,GAAG,IAAI,CAC7B,KAAK,CACH,KAAK,CAAC;IACJ,kBAAkB;IAClB,eAAe;CAChB,CAAC,CACH,EACD,WAAW,CAAC,uDAAuD,CAAC,CACrE,CAAC;AAIF,MAAM,CAAC,MAAM,mBAAmB,GAAG,YAAY,CAAC;IAC9C,IAAI,EAAE,QAAQ,CAAC,WAAW,CAAC;CAC5B,CAAC,CAAC"}

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

@@ -0,0 +1,100 @@
+import type { InferOutput } from "valibot";
+export declare const VARIABLE_MATCHER_CONFIG: import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Variable name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+    readonly match: 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 match: 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.">]>;
+    readonly pathPattern: 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>;
+}, undefined>, import("valibot").StrictObjectSchema<{
+    readonly match: 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.">]>;
+    readonly pathPattern: 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>;
+}, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+    match: import("../../types/rule.js").MatcherType.String;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectKey;
+    pathPattern?: string | undefined;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectValue;
+    pathPattern?: string | undefined;
+})[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
+    match: import("../../types/rule.js").MatcherType.String;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectKey;
+    pathPattern?: string | undefined;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectValue;
+    pathPattern?: string | undefined;
+})[]], "List of matchers that will automatically be matched.">]>;
+export type VariableMatchers = InferOutput<typeof VARIABLE_MATCHER_CONFIG>;
+export declare const VARIABLE_NAME_CONFIG: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Variable name for which children get linted.">]>;
+export type VariableName = InferOutput<typeof VARIABLE_NAME_CONFIG>;
+export declare const VARIABLES_SCHEMA: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Variable name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+    readonly match: 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 match: 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.">]>;
+    readonly pathPattern: 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>;
+}, undefined>, import("valibot").StrictObjectSchema<{
+    readonly match: 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.">]>;
+    readonly pathPattern: 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>;
+}, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+    match: import("../../types/rule.js").MatcherType.String;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectKey;
+    pathPattern?: string | undefined;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectValue;
+    pathPattern?: string | undefined;
+})[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
+    match: import("../../types/rule.js").MatcherType.String;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectKey;
+    pathPattern?: string | undefined;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectValue;
+    pathPattern?: string | undefined;
+})[]], "List of matchers that will automatically be matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Variable name for which children get linted.">]>], undefined>, undefined>, import("valibot").DescriptionAction<(string | [string, ({
+    match: import("../../types/rule.js").MatcherType.String;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectKey;
+    pathPattern?: string | undefined;
+} | {
+    match: import("../../types/rule.js").MatcherType.ObjectValue;
+    pathPattern?: string | undefined;
+})[]])[], "List of variable names which values should get linted.">]>;
+export type Variables = InferOutput<typeof VARIABLES_SCHEMA>;
+export declare const VARIABLES_OPTION_SCHEMA: import("valibot").StrictObjectSchema<{
+    readonly variables: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Variable name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly match: 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 match: 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.">]>;
+        readonly pathPattern: 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>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly match: 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.">]>;
+        readonly pathPattern: 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>;
+    }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+        match: import("../../types/rule.js").MatcherType.String;
+    } | {
+        match: import("../../types/rule.js").MatcherType.ObjectKey;
+        pathPattern?: string | undefined;
+    } | {
+        match: import("../../types/rule.js").MatcherType.ObjectValue;
+        pathPattern?: string | undefined;
+    })[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
+        match: import("../../types/rule.js").MatcherType.String;
+    } | {
+        match: import("../../types/rule.js").MatcherType.ObjectKey;
+        pathPattern?: string | undefined;
+    } | {
+        match: import("../../types/rule.js").MatcherType.ObjectValue;
+        pathPattern?: string | undefined;
+    })[]], "List of matchers that will automatically be matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Variable name for which children get linted.">]>], undefined>, undefined>, import("valibot").DescriptionAction<(string | [string, ({
+        match: import("../../types/rule.js").MatcherType.String;
+    } | {
+        match: import("../../types/rule.js").MatcherType.ObjectKey;
+        pathPattern?: string | undefined;
+    } | {
+        match: import("../../types/rule.js").MatcherType.ObjectValue;
+        pathPattern?: string | undefined;
+    })[]])[], "List of variable names which values should get linted.">]>, undefined>;
+}, undefined>;
+export type VariablesOptions = InferOutput<typeof VARIABLES_OPTION_SCHEMA>;
+//# sourceMappingURL=variables.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"variables.d.ts","sourceRoot":"","sources":["../../../src/options/schemas/variables.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;gEAkBnC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE3E,eAAO,MAAM,oBAAoB,qLAGhC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEpE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAQ5B,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE7D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAElC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/lib/options/schemas/variables.js

@@ -0,0 +1,19 @@
+import { array, description, optional, pipe, strictObject, string, tuple, union } from "valibot";
+import { OBJECT_KEY_MATCHER_SCHEMA, OBJECT_VALUE_MATCHER_SCHEMA, STRING_MATCHER_SCHEMA } from "../schemas/matchers.js";
+export const VARIABLE_MATCHER_CONFIG = pipe(tuple([
+    pipe(string(), description("Variable name for which children get linted if matched.")),
+    pipe(array(union([
+        STRING_MATCHER_SCHEMA,
+        OBJECT_KEY_MATCHER_SCHEMA,
+        OBJECT_VALUE_MATCHER_SCHEMA
+    ])), description("List of matchers that will be applied."))
+]), description("List of matchers that will automatically be matched."));
+export const VARIABLE_NAME_CONFIG = pipe(string(), description("Variable name for which children get linted."));
+export const VARIABLES_SCHEMA = pipe(array(union([
+    VARIABLE_MATCHER_CONFIG,
+    VARIABLE_NAME_CONFIG
+])), description("List of variable names which values should get linted."));
+export const VARIABLES_OPTION_SCHEMA = strictObject({
+    variables: optional(VARIABLES_SCHEMA)
+});
+//# sourceMappingURL=variables.js.map

package/lib/options/schemas/variables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variables.js","sourceRoot":"","sources":["../../../src/options/schemas/variables.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,WAAW,EACX,QAAQ,EACR,IAAI,EACJ,YAAY,EACZ,MAAM,EACN,KAAK,EACL,KAAK,EACN,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,yBAAyB,EACzB,2BAA2B,EAC3B,qBAAqB,EACtB,MAAM,gDAAgD,CAAC;AAKxD,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,CACzC,KAAK,CAAC;IACJ,IAAI,CACF,MAAM,EAAE,EACR,WAAW,CAAC,yDAAyD,CAAC,CACvE;IACD,IAAI,CACF,KAAK,CACH,KAAK,CAAC;QACJ,qBAAqB;QACrB,yBAAyB;QACzB,2BAA2B;KAC5B,CAAC,CACH,EACD,WAAW,CAAC,wCAAwC,CAAC,CACtD;CACF,CAAC,EACF,WAAW,CAAC,sDAAsD,CAAC,CACpE,CAAC;AAIF,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,CACtC,MAAM,EAAE,EACR,WAAW,CAAC,8CAA8C,CAAC,CAC5D,CAAC;AAIF,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,CAClC,KAAK,CACH,KAAK,CAAC;IACJ,uBAAuB;IACvB,oBAAoB;CACrB,CAAC,CACH,EACD,WAAW,CAAC,wDAAwD,CAAC,CACtE,CAAC;AAIF,MAAM,CAAC,MAAM,uBAAuB,GAAG,YAAY,CAAC;IAClD,SAAS,EAAE,QAAQ,CAAC,gBAAgB,CAAC;CACtC,CAAC,CAAC"}

package/lib/options/tags/twc.d.ts

@@ -0,0 +1,36 @@
+import { MatcherType, SelectorKind } from "../../types/rule.js";
+export declare const TWC_TAG: {
+    kind: SelectorKind.Tag;
+    path: string;
+};
+export declare const TWC_CALLEE_STRINGS: {
+    kind: SelectorKind.Callee;
+    match: ({
+        type: MatcherType.String;
+        match?: never;
+    } | {
+        match: {
+            type: MatcherType.String;
+        }[];
+        type: MatcherType.AnonymousFunctionReturn;
+    })[];
+    path: string;
+};
+/** @see https://github.com/gregberge/twc */
+export declare const TWC: ({
+    kind: SelectorKind.Tag;
+    path: string;
+} | {
+    kind: SelectorKind.Callee;
+    match: ({
+        type: MatcherType.String;
+        match?: never;
+    } | {
+        match: {
+            type: MatcherType.String;
+        }[];
+        type: MatcherType.AnonymousFunctionReturn;
+    })[];
+    path: string;
+})[];
+//# sourceMappingURL=twc.d.ts.map

package/lib/options/tags/twc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"twc.d.ts","sourceRoot":"","sources":["../../../src/options/tags/twc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAK7E,eAAO,MAAM,OAAO;;;CAGG,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;CAcL,CAAC;AAE3B,4CAA4C;AAC5C,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;IAGK,CAAC"}

package/lib/options/tags/twc.js

@@ -0,0 +1,26 @@
+import { MatcherType, SelectorKind } from "../../types/rule.js";
+export const TWC_TAG = {
+    kind: SelectorKind.Tag,
+    path: "twc(\\.\\w+)?"
+};
+export const TWC_CALLEE_STRINGS = {
+    kind: SelectorKind.Callee,
+    match: [
+        {
+            type: MatcherType.String
+        },
+        {
+            match: [{
+                    type: MatcherType.String
+                }],
+            type: MatcherType.AnonymousFunctionReturn
+        }
+    ],
+    path: "^twc\\.\\w+"
+};
+/** @see https://github.com/gregberge/twc */
+export const TWC = [
+    TWC_TAG,
+    TWC_CALLEE_STRINGS
+];
+//# sourceMappingURL=twc.js.map

package/lib/options/tags/twc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"twc.js","sourceRoot":"","sources":["../../../src/options/tags/twc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAK7E,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,IAAI,EAAE,YAAY,CAAC,GAAG;IACtB,IAAI,EAAE,eAAe;CACA,CAAC;AAExB,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,IAAI,EAAE,YAAY,CAAC,MAAM;IACzB,KAAK,EAAE;QACL;YACE,IAAI,EAAE,WAAW,CAAC,MAAM;SACzB;QACD;YACE,KAAK,EAAE,CAAC;oBACN,IAAI,EAAE,WAAW,CAAC,MAAM;iBACzB,CAAC;YACF,IAAI,EAAE,WAAW,CAAC,uBAAuB;SAC1C;KACF;IACD,IAAI,EAAE,aAAa;CACK,CAAC;AAE3B,4CAA4C;AAC5C,MAAM,CAAC,MAAM,GAAG,GAAG;IACjB,OAAO;IACP,kBAAkB;CACC,CAAC"}

package/lib/options/tags/twx.d.ts

@@ -0,0 +1,36 @@
+import { MatcherType, SelectorKind } from "../../types/rule.js";
+export declare const TWX_TAG: {
+    kind: SelectorKind.Tag;
+    path: string;
+};
+export declare const TWX_CALLEE_STRINGS: {
+    kind: SelectorKind.Callee;
+    match: ({
+        type: MatcherType.String;
+        match?: never;
+    } | {
+        match: {
+            type: MatcherType.String;
+        }[];
+        type: MatcherType.AnonymousFunctionReturn;
+    })[];
+    path: string;
+};
+/** @see https://github.com/gregberge/twc */
+export declare const TWX: ({
+    kind: SelectorKind.Tag;
+    path: string;
+} | {
+    kind: SelectorKind.Callee;
+    match: ({
+        type: MatcherType.String;
+        match?: never;
+    } | {
+        match: {
+            type: MatcherType.String;
+        }[];
+        type: MatcherType.AnonymousFunctionReturn;
+    })[];
+    path: string;
+})[];
+//# sourceMappingURL=twx.d.ts.map

package/lib/options/tags/twx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"twx.d.ts","sourceRoot":"","sources":["../../../src/options/tags/twx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAK7E,eAAO,MAAM,OAAO;;;CAGG,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;CAcL,CAAC;AAE3B,4CAA4C;AAC5C,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;IAGK,CAAC"}

package/lib/options/tags/twx.js

@@ -0,0 +1,26 @@
+import { MatcherType, SelectorKind } from "../../types/rule.js";
+export const TWX_TAG = {
+    kind: SelectorKind.Tag,
+    path: "twx(\\.\\w+)?"
+};
+export const TWX_CALLEE_STRINGS = {
+    kind: SelectorKind.Callee,
+    match: [
+        {
+            type: MatcherType.String
+        },
+        {
+            match: [{
+                    type: MatcherType.String
+                }],
+            type: MatcherType.AnonymousFunctionReturn
+        }
+    ],
+    path: "^twx\\.\\w+"
+};
+/** @see https://github.com/gregberge/twc */
+export const TWX = [
+    TWX_TAG,
+    TWX_CALLEE_STRINGS
+];
+//# sourceMappingURL=twx.js.map

package/lib/options/tags/twx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"twx.js","sourceRoot":"","sources":["../../../src/options/tags/twx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAK7E,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,IAAI,EAAE,YAAY,CAAC,GAAG;IACtB,IAAI,EAAE,eAAe;CACA,CAAC;AAExB,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,IAAI,EAAE,YAAY,CAAC,MAAM;IACzB,KAAK,EAAE;QACL;YACE,IAAI,EAAE,WAAW,CAAC,MAAM;SACzB;QACD;YACE,KAAK,EAAE,CAAC;oBACN,IAAI,EAAE,WAAW,CAAC,MAAM;iBACzB,CAAC;YACF,IAAI,EAAE,WAAW,CAAC,uBAAuB;SAC1C;KACF;IACD,IAAI,EAAE,aAAa;CACK,CAAC;AAE3B,4CAA4C;AAC5C,MAAM,CAAC,MAAM,GAAG,GAAG;IACjB,OAAO;IACP,kBAAkB;CACC,CAAC"}

package/lib/parsers/angular.d.ts

@@ -0,0 +1,11 @@
+import type { AST, TmplAstBoundAttribute, TmplAstElement, TmplAstTextAttribute } from "@angular/compiler";
+import type { Rule } from "eslint";
+import type { Literal } from "../types/ast.js";
+import type { AttributeSelector } from "../types/rule.js";
+export declare function getAttributesByAngularElement(ctx: Rule.RuleContext, node: TmplAstElement): (TmplAstBoundAttribute | TmplAstTextAttribute)[];
+export declare function getLiteralsByAngularAttribute(ctx: Rule.RuleContext, attribute: TmplAstBoundAttribute | TmplAstTextAttribute, selectors: AttributeSelector[]): Literal[];
+export type Parent = {
+    parent: AST;
+};
+export declare function isAST(ast: unknown): ast is AST;
+//# sourceMappingURL=angular.d.ts.map

package/lib/parsers/angular.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular.d.ts","sourceRoot":"","sources":["../../src/parsers/angular.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,GAAG,EAcH,qBAAqB,EACrB,cAAc,EAEd,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAGnC,OAAO,KAAK,EAAc,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,KAAK,EAAE,iBAAiB,EAAqC,MAAM,kCAAkC,CAAC;AAK7G,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,EAAE,cAAc,GAAG,CAAC,qBAAqB,GAAG,oBAAoB,CAAC,EAAE,CAK3I;AAED,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,SAAS,EAAE,qBAAqB,GAAG,oBAAoB,EAAE,SAAS,EAAE,iBAAiB,EAAE,GAAG,OAAO,EAAE,CA6BvK;AAkeD,MAAM,MAAM,MAAM,GAAG;IACnB,MAAM,EAAE,GAAG,CAAC;CACb,CAAC;AAgWF,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,GAAG,CAE9C"}