@angular-eslint/eslint-plugin-template 22.6.1-alpha.2 → 22.6.1-alpha.3

package/README.md

@@ -72,7 +72,7 @@ The premade flat configs that combine these rules are provided by the umbrella [
 | [`prefer-contextual-for-variables`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-contextual-for-variables.md) | Ensures that contextual variables are used in @for blocks where possible instead of aliasing them. |  | :wrench: |  |  |
 | [`prefer-control-flow`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-control-flow.md) | Ensures that the built-in control flow is used. | :white_check_mark: |  |  |  |
 | [`prefer-ngsrc`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-ngsrc.md) | Ensures ngSrc is used instead of src for img elements |  |  | :bulb: |  |
-| [`prefer-style-binding`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-style-binding.md) | Suggests using [style] bindings over ngStyle where applicable |  |  |  |  |
+| [`prefer-style-binding`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-style-binding.md) | Suggests using [style] bindings over ngStyle where applicable |  | :wrench: | :bulb: |  |
 | [`prefer-template-literal`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-template-literal.md) | Ensure that template literals are used instead of concatenating strings or expressions. |  | :wrench: |  |  |
 | [`require-switch-default`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/require-switch-default.md) | Requires a `@default` block on every `@switch` to ensure all cases are handled. This is the template equivalent of the `@typescript-eslint/switch-exhaustiveness-check` rule. |  |  |  |  |
 | [`role-has-required-aria`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/role-has-required-aria.md) | [Accessibility] Ensures elements with ARIA roles have all required properties for that role. |  |  | :bulb: | :accessibility: |

package/dist/index.d.ts

@@ -1,12 +1,14 @@
+import { createProcessor } from './processors';
 declare const _default: {
+    createProcessor: typeof createProcessor;
     processors: {
         'extract-inline-html': {
             meta: {
                 name: string;
             };
-            preprocess: typeof import("./processors").preprocessComponentFile;
-            postprocess: typeof import("./processors").postprocessComponentFile;
-            supportsAutofix: boolean;
+            preprocess: typeof import("./inline-templates").preprocessComponentFile;
+            postprocess: typeof import("./inline-templates").postprocessComponentFile;
+            supportsAutofix: true;
         };
     };
     rules: {
@@ -115,7 +117,7 @@ declare const _default: {
         "prefer-static-string-properties": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferStaticStringProperties", import("./rules/prefer-static-string-properties").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        "prefer-style-binding": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferStyleBinding", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        "prefer-style-binding": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-style-binding").MessageIds, import("./rules/prefer-style-binding").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
         "prefer-template-literal": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferTemplateLiteral", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsHA,kBA8CE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAmB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsH3D,kBA+CE"}

package/dist/index.js

@@ -32,10 +32,7 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const processors_1 = __importDefault(require("./processors"));
+const processors_1 = __importStar(require("./processors"));
 const alt_text_1 = __importStar(require("./rules/alt-text"));
 const attributes_order_1 = __importStar(require("./rules/attributes-order"));
 const banana_in_box_1 = __importStar(require("./rules/banana-in-box"));
@@ -79,6 +76,7 @@ const table_scope_1 = __importStar(require("./rules/table-scope"));
 const use_track_by_function_1 = __importStar(require("./rules/use-track-by-function"));
 const valid_aria_1 = __importStar(require("./rules/valid-aria"));
 module.exports = {
+    createProcessor: processors_1.createProcessor,
     processors: processors_1.default,
     rules: {
         [alt_text_1.RULE_NAME]: alt_text_1.default,

package/dist/inline-styles.d.ts

@@ -0,0 +1,15 @@
+import { postprocessComponentFile, type PreprocessResult } from './inline-templates';
+export declare const inlineStyleLanguages: readonly ["css", "scss", "sass", "less"];
+export type InlineStyleLanguage = (typeof inlineStyleLanguages)[number];
+declare function postprocessInlineStyles(multiDimensionalMessages: Parameters<typeof postprocessComponentFile>[0], filename: string): readonly unknown[];
+export interface InlineStylesProcessor {
+    meta: {
+        name: string;
+    };
+    preprocess: (text: string, filename: string) => PreprocessResult;
+    postprocess: typeof postprocessInlineStyles;
+    supportsAutofix: true;
+}
+export declare function createInlineStylesProcessor(inlineStyleLanguage: InlineStyleLanguage, inlineTemplates: boolean): InlineStylesProcessor;
+export {};
+//# sourceMappingURL=inline-styles.d.ts.map

package/dist/inline-styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-styles.d.ts","sourceRoot":"","sources":["../src/inline-styles.ts"],"names":[],"mappings":"AASA,OAAO,EAIL,wBAAwB,EACxB,KAAK,gBAAgB,EACtB,MAAM,oBAAoB,CAAC;AAoU5B,eAAO,MAAM,oBAAoB,0CAA2C,CAAC;AAE7E,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AA8ExE,iBAAS,uBAAuB,CAC9B,wBAAwB,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CAAC,EACxE,QAAQ,EAAE,MAAM,GACf,SAAS,OAAO,EAAE,CAkCpB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACvB,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,gBAAgB,CAAC;IACjE,WAAW,EAAE,OAAO,uBAAuB,CAAC;IAC5C,eAAe,EAAE,IAAI,CAAC;CACvB;AAED,wBAAgB,2BAA2B,CACzC,mBAAmB,EAAE,mBAAmB,EACxC,eAAe,EAAE,OAAO,GACvB,qBAAqB,CAevB"}

package/dist/inline-styles.js

@@ -0,0 +1,335 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inlineStyleLanguages = void 0;
+exports.createInlineStylesProcessor = createInlineStylesProcessor;
+const path_1 = require("path");
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+const typescript_1 = __importDefault(require("typescript"));
+const inline_templates_1 = require("./inline-templates");
+function createTextSource(text) {
+    const lineStarts = [0];
+    for (let index = 0; index < text.length; index++) {
+        const character = text.charCodeAt(index);
+        if (character === 13 && text.charCodeAt(index + 1) === 10) {
+            index++;
+        }
+        if (character === 10 ||
+            character === 13 ||
+            character === 0x2028 ||
+            character === 0x2029) {
+            lineStarts.push(index + 1);
+        }
+    }
+    return {
+        text,
+        offsetAt(line, column) {
+            const start = lineStarts[line - 1];
+            if (start === undefined || column < 1 || !Number.isInteger(column)) {
+                return undefined;
+            }
+            const offset = start + column - 1;
+            const nextStart = lineStarts[line];
+            if (nextStart !== undefined ? offset >= nextStart : offset > text.length) {
+                return undefined;
+            }
+            return offset;
+        },
+        locationAt(offset) {
+            let start = 0;
+            let end = lineStarts.length;
+            while (start + 1 < end) {
+                const middle = Math.floor((start + end) / 2);
+                if (lineStarts[middle] > offset) {
+                    end = middle;
+                }
+                else {
+                    start = middle;
+                }
+            }
+            return { line: start + 1, column: offset - lineStarts[start] + 1 };
+        },
+    };
+}
+const unsafeLiteralFixText = {
+    "'": /[\\'\r\n]/,
+    '"': /[\\"\r\n]/,
+    '`': /[\\`]|\$\{/,
+};
+function mapLiteral(literal, sourceFile, source) {
+    const start = literal.getStart(sourceFile);
+    const quote = sourceFile.text[start];
+    const raw = sourceFile.text.slice(start + 1, literal.end - 1);
+    const offsets = [start + 1];
+    const scanner = typescript_1.default.createScanner(typescript_1.default.ScriptTarget.Latest, false);
+    let text = '';
+    for (let index = 0; index < raw.length;) {
+        const escape = raw[index] === '\\'
+            ? /^\\(?:u\{[\da-fA-F]+\}|u[\da-fA-F]{4}|x[\da-fA-F]{2}|\r\n|[\s\S])/.exec(raw.slice(index))?.[0]
+            : undefined;
+        const chunk = escape ?? (raw.startsWith('\r\n', index) ? '\r\n' : raw[index]);
+        let decoded = chunk;
+        if (escape) {
+            scanner.setText(quote + chunk + quote);
+            scanner.scan();
+            decoded = scanner.getTokenValue();
+        }
+        else if (quote === '`' && chunk.startsWith('\r')) {
+            decoded = '\n';
+        }
+        index += chunk.length;
+        text += decoded;
+        for (let count = 0; count < decoded.length; count++) {
+            offsets.push(start + 1 + index);
+        }
+        if (!decoded.length) {
+            offsets[offsets.length - 1] = start + 1 + index;
+        }
+    }
+    if (text !== literal.text) {
+        return undefined;
+    }
+    return {
+        kind: 'component',
+        text,
+        offsets,
+        source,
+        virtualSource: createTextSource(text),
+        unsafeFixText: [unsafeLiteralFixText[quote]],
+    };
+}
+function extractTemplateStyles(template) {
+    const styles = [];
+    const parsed = new bundled_angular_compiler_1.HtmlParser().parse(template.text, 'template.html', {
+        tokenizeBlocks: true,
+    });
+    class StyleVisitor extends bundled_angular_compiler_1.RecursiveVisitor {
+        visitAttribute(attribute) {
+            if (attribute.name !== 'style' || !attribute.valueSpan) {
+                return;
+            }
+            const valueTokens = attribute.valueTokens ?? [];
+            // Interpolation tokens are [start, expression, end]; like [style] bindings they are not static CSS
+            if (valueTokens.some((token) => token.parts.length === 3)) {
+                return;
+            }
+            const offsets = [attribute.valueSpan.start.offset];
+            let value = '';
+            for (const token of valueTokens) {
+                const decoded = token.parts[0];
+                const start = token.sourceSpan.start.offset;
+                const end = token.sourceSpan.end.offset;
+                const raw = template.text.slice(start, end);
+                let rawIndex = 0;
+                for (let index = 0; index < decoded.length; index++) {
+                    rawIndex +=
+                        raw.startsWith('\r\n', rawIndex) && decoded[index] === '\n' ? 2 : 1;
+                    offsets.push(token.parts.length > 1 ? end : start + rawIndex);
+                }
+                value += decoded;
+            }
+            if (value !== attribute.value) {
+                return;
+            }
+            const start = offsets[0];
+            const end = offsets[offsets.length - 1];
+            const quote = template.text[start - 1];
+            const text = `a{${value}}`;
+            styles.push({
+                kind: 'attribute',
+                text,
+                offsets: [start, start, ...offsets, end].map((offset) => template.offsets[offset]),
+                source: template.source,
+                virtualSource: createTextSource(text),
+                unsafeFixText: [
+                    ...template.unsafeFixText,
+                    quote === '"' || quote === "'"
+                        ? new RegExp(`[${quote}&]`)
+                        : /[\s=<>"'`&]/,
+                ],
+            });
+        }
+    }
+    (0, bundled_angular_compiler_1.visitAll)(new StyleVisitor(), parsed.rootNodes);
+    return styles;
+}
+function extractComponentStyles(sourceFile) {
+    const styles = [];
+    const source = createTextSource(sourceFile.text);
+    for (const metadata of (0, inline_templates_1.getComponentMetadata)(sourceFile)) {
+        for (const property of metadata.properties) {
+            if (!typescript_1.default.isPropertyAssignment(property)) {
+                continue;
+            }
+            const propertyName = property.name.getText(sourceFile);
+            if (propertyName !== 'styles' && propertyName !== 'template') {
+                continue;
+            }
+            const values = typescript_1.default.isArrayLiteralExpression(property.initializer)
+                ? property.initializer.elements
+                : [property.initializer];
+            for (const value of values) {
+                if (!typescript_1.default.isStringLiteral(value) &&
+                    !typescript_1.default.isNoSubstitutionTemplateLiteral(value)) {
+                    continue;
+                }
+                const mapped = mapLiteral(value, sourceFile, source);
+                if (!mapped) {
+                    continue;
+                }
+                if (propertyName === 'template') {
+                    styles.push(...extractTemplateStyles(mapped));
+                }
+                else {
+                    styles.push(mapped);
+                }
+            }
+        }
+    }
+    return styles;
+}
+function mapStyleMessage(message, style) {
+    function location(line, column, fallbackOffset) {
+        const offset = style.virtualSource.offsetAt(line, column);
+        const sourceOffset = (offset === undefined ? undefined : style.offsets[offset]) ??
+            fallbackOffset;
+        return style.source.locationAt(sourceOffset);
+    }
+    function fix(edit) {
+        const [startOffset, endOffset] = edit.range;
+        const start = style.offsets[startOffset];
+        const end = style.offsets[endOffset];
+        if (start === undefined || end === undefined) {
+            return undefined;
+        }
+        if (style.source.text.slice(start, end) !==
+            style.text.slice(startOffset, endOffset)) {
+            return undefined;
+        }
+        if (style.unsafeFixText.some((pattern) => pattern.test(edit.text))) {
+            return undefined;
+        }
+        const boundaryText = style.source.text.slice(Math.max(0, start - 1), start) +
+            edit.text +
+            style.source.text.slice(end, end + 1);
+        if (boundaryText.includes('${') &&
+            style.unsafeFixText.some((pattern) => pattern.test('${'))) {
+            return undefined;
+        }
+        return { ...edit, range: [start, end] };
+    }
+    const mapped = { ...message };
+    if (message.line !== undefined && message.column !== undefined) {
+        Object.assign(mapped, location(message.line, message.column, style.offsets[0]));
+    }
+    if (message.endLine !== undefined && message.endColumn !== undefined) {
+        const end = location(message.endLine, message.endColumn, style.offsets[style.offsets.length - 1]);
+        mapped.endLine = end.line;
+        mapped.endColumn = end.column;
+    }
+    if (message.fix) {
+        mapped.fix = fix(message.fix);
+    }
+    if (message.suggestions) {
+        mapped.suggestions = message.suggestions.flatMap((suggestion) => {
+            const edit = suggestion.fix ? fix(suggestion.fix) : undefined;
+            return edit ? [{ ...suggestion, fix: edit }] : [];
+        });
+    }
+    return mapped;
+}
+const pendingStyles = new Map();
+exports.inlineStyleLanguages = ['css', 'scss', 'sass', 'less'];
+function preprocessInlineStyles(text, filename, inlineStyleLanguage, inlineTemplates) {
+    pendingStyles.delete(filename);
+    const baseFilename = (0, path_1.basename)(filename);
+    if (filename.endsWith('.html')) {
+        if (/inline-template-.+-\d+\.component\.html$/.test(baseFilename) ||
+            !/\bstyle\s*=/i.test(text)) {
+            return [text];
+        }
+        let styles;
+        try {
+            styles = extractTemplateStyles({
+                text,
+                source: createTextSource(text),
+                offsets: Array.from({ length: text.length + 1 }, (_, index) => index),
+                unsafeFixText: [],
+            });
+        }
+        catch {
+            return [text];
+        }
+        if (!styles.length) {
+            return [text];
+        }
+        pendingStyles.set(filename, { templateCount: 1, styles });
+        return [
+            text,
+            ...styles.map((style, index) => ({
+                text: style.text,
+                filename: `attribute-style-${baseFilename}-${index + 1}.css`,
+            })),
+        ];
+    }
+    if (!filename.endsWith('.ts') ||
+        !(0, inline_templates_1.isFileLikelyToContainComponentDeclarations)(text, filename)) {
+        return [text];
+    }
+    const sourceFile = typescript_1.default.createSourceFile(filename, text, typescript_1.default.ScriptTarget.Latest, 
+    /* setParentNodes */ true);
+    const templates = inlineTemplates
+        ? (0, inline_templates_1.preprocessComponentFile)(text, filename, sourceFile)
+        : [text];
+    let styles;
+    try {
+        styles = extractComponentStyles(sourceFile);
+    }
+    catch {
+        return templates;
+    }
+    pendingStyles.set(filename, { templateCount: templates.length, styles });
+    return [
+        ...templates,
+        ...styles.map((style, index) => ({
+            text: style.text,
+            filename: style.kind === 'attribute'
+                ? `attribute-style-${baseFilename}-${index + 1}.css`
+                : `inline-style-${baseFilename}-${index + 1}.${inlineStyleLanguage}`,
+        })),
+    ];
+}
+function postprocessInlineStyles(multiDimensionalMessages, filename) {
+    const pending = pendingStyles.get(filename);
+    pendingStyles.delete(filename);
+    if (!pending) {
+        return (0, inline_templates_1.postprocessComponentFile)(multiDimensionalMessages, filename);
+    }
+    const results = (0, inline_templates_1.postprocessComponentFile)(multiDimensionalMessages.slice(0, pending.templateCount), filename);
+    return [
+        ...results,
+        ...pending.styles.flatMap((style, index) => (multiDimensionalMessages[pending.templateCount + index] ?? [])
+            .filter((message) => {
+            if (style.kind !== 'attribute' ||
+                message.fatal === true) {
+                return true;
+            }
+            const offset = style.virtualSource.offsetAt(message.line, message.column);
+            return (offset === undefined ||
+                (offset >= 2 && offset !== style.text.length - 1));
+        })
+            .map((message) => mapStyleMessage(message, style))),
+    ];
+}
+function createInlineStylesProcessor(inlineStyleLanguage, inlineTemplates) {
+    return {
+        meta: {
+            name: `extract-inline[${inlineTemplates ? 'templates,' : ''}styles=${inlineStyleLanguage}]`,
+        },
+        preprocess: (text, filename) => preprocessInlineStyles(text, filename, inlineStyleLanguage, inlineTemplates),
+        postprocess: postprocessInlineStyles,
+        supportsAutofix: true,
+    };
+}

package/dist/inline-templates.d.ts

@@ -0,0 +1,40 @@
+import ts from 'typescript';
+/**
+ * Because ultimately a user is in control of how and when this processor gets invoked,
+ * we can't fully protect them against doing more work than is necessary in all cases.
+ *
+ * Therefore, before we do a full parse of a TypeScript file to try and extract one or
+ * more Component declarations we want to do a really quick check for whether or not
+ * a file is likely to contain them.
+ */
+export declare function isFileLikelyToContainComponentDeclarations(text: string, filename: string): boolean;
+export type PreprocessResult = (string | {
+    text: string;
+    filename: string;
+})[];
+export declare function preprocessComponentFile(text: string, filename: string, 
+/** Lets callers that already parsed the file avoid a second full parse */
+parsedSourceFile?: ts.SourceFile): PreprocessResult;
+export declare function getComponentMetadata(sourceFile: ts.SourceFile): ts.ObjectLiteralExpression[];
+export declare function postprocessComponentFile(multiDimensionalMessages: {
+    ruleId: string;
+    severity: number;
+    message: string;
+    line: number;
+    column: number;
+    nodeType: string;
+    messageId: string;
+    endLine: number;
+    endColumn: number;
+    fix?: {
+        range: number[];
+        text: string;
+    };
+    suggestions?: {
+        fix: {
+            range: number[];
+            text: string;
+        };
+    }[];
+}[][], filename: string): readonly unknown[];
+//# sourceMappingURL=inline-templates.d.ts.map

package/dist/inline-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-templates.d.ts","sourceRoot":"","sources":["../src/inline-templates.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,YAAY,CAAC;AAI5B;;;;;;;GAOG;AACH,wBAAgB,0CAA0C,CACxD,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,OAAO,CA2BT;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,CAAC;AAE/E,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM;AAChB,0EAA0E;AAC1E,gBAAgB,CAAC,EAAE,EAAE,CAAC,UAAU,GAC/B,gBAAgB,CAwGlB;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,EAAE,CAAC,UAAU,GACxB,EAAE,CAAC,uBAAuB,EAAE,CAiB9B;AAyDD,wBAAgB,wBAAwB,CACtC,wBAAwB,EAAE;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE;QACJ,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,WAAW,CAAC,EAAE;QACZ,GAAG,EAAE;YACH,KAAK,EAAE,MAAM,EAAE,CAAC;YAChB,IAAI,EAAE,MAAM,CAAC;SACd,CAAC;KACH,EAAE,CAAC;CACL,EAAE,EAAE,EACL,QAAQ,EAAE,MAAM,GACf,SAAS,OAAO,EAAE,CA6EpB"}