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

package/lib/rules/enforce-consistent-variable-syntax.d.ts

@@ -0,0 +1,225 @@
+export declare const enforceConsistentVariableSyntax: {
+    category: "stylistic";
+    messages: {
+        readonly incorrect: "Incorrect variable syntax: {{ className }}.";
+    } | undefined;
+    name: "enforce-consistent-variable-syntax";
+    readonly options: {
+        cwd?: string | undefined;
+        rootFontSize?: number | undefined;
+        detectComponentClasses: boolean;
+        tsconfig?: string | undefined;
+        tailwindConfig?: string | undefined;
+        messageStyle: "visual" | "compact" | "raw";
+        entryPoint?: string | undefined;
+        tags?: (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;
+        })[]])[] | undefined;
+        variables?: (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;
+        })[]])[] | undefined;
+        attributes?: (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;
+        })[]])[] | undefined;
+        callees?: (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;
+        })[]])[] | undefined;
+        selectors: ({
+            callTarget?: number | "all" | "first" | "last" | undefined;
+            kind: import("../types/rule.js").SelectorKind.Callee;
+            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;
+            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;
+            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 | undefined;
+            path: string;
+            targetArgument?: number | "all" | "first" | "last" | undefined;
+            targetCall?: number | "all" | "first" | "last" | undefined;
+        } | {
+            kind: import("../types/rule.js").SelectorKind.Tag;
+            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;
+            path?: string | undefined;
+        } | {
+            kind: import("../types/rule.js").SelectorKind.Tag;
+            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 | 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;
+        } | {
+            kind: import("../types/rule.js").SelectorKind.Variable;
+            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;
+        })[];
+    } & {
+        syntax: "variable" | "shorthand";
+    };
+    recommended: false;
+    rule: {
+        create: (ctx: import("eslint").Rule.RuleContext) => import("eslint").Rule.RuleListener;
+        meta: {
+            messages?: {
+                readonly incorrect: "Incorrect variable syntax: {{ className }}.";
+            };
+            docs: {
+                description: string;
+                recommended: boolean;
+                url: string;
+            };
+            fixable: "code" | undefined;
+            schema: {
+                additionalProperties: false;
+                properties: Record<string, boolean | import("@valibot/to-json-schema").JsonSchema> | undefined;
+                type: "object";
+            }[];
+            type: "problem" | "layout";
+        };
+    };
+};
+//# sourceMappingURL=enforce-consistent-variable-syntax.d.ts.map

package/lib/rules/enforce-consistent-variable-syntax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-consistent-variable-syntax.d.ts","sourceRoot":"","sources":["../../src/rules/enforce-consistent-variable-syntax.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8B1C,CAAC"}

package/lib/rules/enforce-consistent-variable-syntax.js

@@ -0,0 +1,164 @@
+import { description, literal, optional, pipe, strictObject, union } from "valibot";
+import { createGetDissectedClasses, getDissectedClasses } from "../tailwindcss/dissect-classes.js";
+import { buildClass } from "../utils/class.js";
+import { async } from "../utils/context.js";
+import { lintClasses } from "../utils/lint.js";
+import { getCachedRegex } from "../async-utils/regex.js";
+import { createRule } from "../utils/rule.js";
+import { splitClasses } from "../utils/utils.js";
+export const enforceConsistentVariableSyntax = createRule({
+    autofix: true,
+    category: "stylistic",
+    description: "Enforce consistent syntax for css variables.",
+    docs: "https://github.com/schoero/eslint-plugin-better-tailwindcss/blob/main/docs/rules/enforce-consistent-variable-syntax.md",
+    name: "enforce-consistent-variable-syntax",
+    recommended: false,
+    messages: {
+        incorrect: "Incorrect variable syntax: {{ className }}."
+    },
+    schema: strictObject({
+        syntax: optional(pipe(union([
+            literal("shorthand"),
+            literal("variable")
+        ]), description("The syntax to enforce for css variables in tailwindcss class strings.")), "shorthand")
+    }),
+    initialize: ctx => {
+        createGetDissectedClasses(ctx);
+    },
+    lintLiterals: (ctx, literals) => lintLiterals(ctx, literals)
+});
+function lintLiterals(ctx, literals) {
+    const { syntax } = ctx.options;
+    const asyncCtx = async(ctx);
+    for (const literal of literals) {
+        const classes = splitClasses(literal.content);
+        const { dissectedClasses, warnings } = getDissectedClasses(asyncCtx, classes);
+        lintClasses(ctx, literal, className => {
+            const dissectedClass = dissectedClasses[className];
+            if (!dissectedClass) {
+                return;
+            }
+            // skip variable definitions
+            if (dissectedClass.base.includes(":")) {
+                return;
+            }
+            const { after: afterParentheses, before: beforeParentheses, characters: charactersParentheses } = extractBalanced(dissectedClass.base);
+            const { after: afterSquareBrackets, before: beforeSquareBrackets, characters: charactersSquareBrackets } = extractBalanced(dissectedClass.base, "[", "]");
+            if (syntax === "shorthand") {
+                if (!charactersSquareBrackets) {
+                    return;
+                }
+                if (isBeginningOfArbitraryVariable(charactersSquareBrackets)) {
+                    const { after, characters } = extractBalanced(charactersSquareBrackets);
+                    if (trimTailwindWhitespace(after).length > 0) {
+                        return;
+                    }
+                    const fixedClass = ctx.version.major >= 4
+                        ? buildClass(ctx, { ...dissectedClass, base: [...beforeSquareBrackets, `(${characters})`, ...afterSquareBrackets].join("") })
+                        : buildClass(ctx, { ...dissectedClass, base: [...beforeSquareBrackets, `[${characters}]`, ...afterSquareBrackets].join("") });
+                    return {
+                        data: { className },
+                        fix: fixedClass,
+                        id: "incorrect",
+                        warnings
+                    };
+                }
+                if (isBeginningOfArbitraryShorthand(charactersSquareBrackets)) {
+                    if (ctx.version.major <= 3) {
+                        return;
+                    }
+                    const fixedClass = buildClass(ctx, {
+                        ...dissectedClass,
+                        base: [...beforeSquareBrackets, `(${charactersSquareBrackets})`, ...afterSquareBrackets].join("")
+                    });
+                    return {
+                        data: { className },
+                        fix: fixedClass,
+                        id: "incorrect",
+                        warnings
+                    };
+                }
+            }
+            if (syntax === "variable") {
+                if (charactersSquareBrackets && isBeginningOfArbitraryVariable(charactersSquareBrackets)) {
+                    return;
+                }
+                if (isBeginningOfArbitraryShorthand(charactersSquareBrackets)) {
+                    const fixedClass = buildClass(ctx, {
+                        ...dissectedClass,
+                        base: [...beforeSquareBrackets, `[var(${charactersSquareBrackets})]`, ...afterSquareBrackets].join("")
+                    });
+                    return {
+                        data: { className },
+                        fix: fixedClass,
+                        id: "incorrect",
+                        warnings
+                    };
+                }
+                if (isBeginningOfArbitraryShorthand(charactersParentheses)) {
+                    const fixedClass = buildClass(ctx, {
+                        ...dissectedClass,
+                        base: [
+                            ...beforeParentheses,
+                            `[var(${charactersParentheses})]`,
+                            ...afterParentheses
+                        ].join("")
+                    });
+                    return {
+                        data: { className },
+                        fix: fixedClass,
+                        id: "incorrect",
+                        warnings
+                    };
+                }
+            }
+        });
+    }
+}
+function isBeginningOfArbitraryShorthand(base) {
+    return getCachedRegex(/^_*--(?![\w-]+\()/).test(base);
+}
+function isBeginningOfArbitraryVariable(base) {
+    return getCachedRegex(/^_*var\(_*--/).test(base);
+}
+function extractBalanced(className, start = "(", end = ")") {
+    const before = [];
+    const characters = [];
+    const after = [];
+    for (let i = 0, parenthesesCount = 0, hasStarted = false, hasEnded = false; i < className.length; i++) {
+        if (className[i] === start) {
+            parenthesesCount++;
+            if (!hasStarted) {
+                hasStarted = true;
+                continue;
+            }
+        }
+        if (!hasStarted && !hasEnded) {
+            before.push(className[i]);
+            continue;
+        }
+        if (className[i] === end) {
+            parenthesesCount--;
+            if (parenthesesCount === 0) {
+                hasEnded = true;
+                continue;
+            }
+        }
+        if (!hasEnded) {
+            characters.push(className[i]);
+            continue;
+        }
+        else {
+            after.push(className[i]);
+        }
+    }
+    return {
+        after: after.join(""),
+        before: before.join(""),
+        characters: characters.join("")
+    };
+}
+function trimTailwindWhitespace(className) {
+    return className.replace(/^_+|_+$/g, "");
+}
+//# sourceMappingURL=enforce-consistent-variable-syntax.js.map

package/lib/rules/enforce-consistent-variable-syntax.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-consistent-variable-syntax.js","sourceRoot":"","sources":["../../src/rules/enforce-consistent-variable-syntax.ts"],"names":[],"mappings":"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"}

package/lib/rules/enforce-consistent-variant-order.d.ts

@@ -0,0 +1,225 @@
+export declare const enforceConsistentVariantOrder: {
+    category: "stylistic";
+    messages: {
+        readonly order: "Incorrect variant order. '{{ className }}' should be '{{ fix }}'.";
+    } | undefined;
+    name: "enforce-consistent-variant-order";
+    readonly options: {
+        cwd?: string | undefined;
+        rootFontSize?: number | undefined;
+        detectComponentClasses: boolean;
+        tsconfig?: string | undefined;
+        tailwindConfig?: string | undefined;
+        messageStyle: "visual" | "compact" | "raw";
+        entryPoint?: string | undefined;
+        tags?: (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;
+        })[]])[] | undefined;
+        variables?: (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;
+        })[]])[] | undefined;
+        attributes?: (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;
+        })[]])[] | undefined;
+        callees?: (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;
+        })[]])[] | undefined;
+        selectors: ({
+            callTarget?: number | "all" | "first" | "last" | undefined;
+            kind: import("../types/rule.js").SelectorKind.Callee;
+            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;
+            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;
+            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 | undefined;
+            path: string;
+            targetArgument?: number | "all" | "first" | "last" | undefined;
+            targetCall?: number | "all" | "first" | "last" | undefined;
+        } | {
+            kind: import("../types/rule.js").SelectorKind.Tag;
+            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;
+            path?: string | undefined;
+        } | {
+            kind: import("../types/rule.js").SelectorKind.Tag;
+            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 | 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;
+        } | {
+            kind: import("../types/rule.js").SelectorKind.Variable;
+            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;
+        })[];
+    } & {
+        [x: string]: unknown;
+    };
+    recommended: false;
+    rule: {
+        create: (ctx: import("eslint").Rule.RuleContext) => import("eslint").Rule.RuleListener;
+        meta: {
+            messages?: {
+                readonly order: "Incorrect variant order. '{{ className }}' should be '{{ fix }}'.";
+            };
+            docs: {
+                description: string;
+                recommended: boolean;
+                url: string;
+            };
+            fixable: "code" | undefined;
+            schema: {
+                additionalProperties: false;
+                properties: Record<string, boolean | import("@valibot/to-json-schema").JsonSchema> | undefined;
+                type: "object";
+            }[];
+            type: "problem" | "layout";
+        };
+    };
+};
+//# sourceMappingURL=enforce-consistent-variant-order.d.ts.map

package/lib/rules/enforce-consistent-variant-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-consistent-variant-order.d.ts","sourceRoot":"","sources":["../../src/rules/enforce-consistent-variant-order.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqExC,CAAC"}