eslint-plugin-formatjs 4.2.0 → 4.3.1

package/rules/enforce-plural-rules.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+class PluralRulesEnforcement extends Error {
+    constructor(message) {
+        super();
+        this.message = message;
+    }
+}
+var LDML;
+(function (LDML) {
+    LDML["zero"] = "zero";
+    LDML["one"] = "one";
+    LDML["two"] = "two";
+    LDML["few"] = "few";
+    LDML["many"] = "many";
+    LDML["other"] = "other";
+})(LDML || (LDML = {}));
+function verifyAst(plConfig, ast) {
+    for (const el of ast) {
+        if ((0, icu_messageformat_parser_1.isPluralElement)(el)) {
+            const rules = Object.keys(plConfig);
+            for (const rule of rules) {
+                if (plConfig[rule] && !el.options[rule]) {
+                    throw new PluralRulesEnforcement(`Missing plural rule "${rule}"`);
+                }
+                if (!plConfig[rule] && el.options[rule]) {
+                    throw new PluralRulesEnforcement(`Plural rule "${rule}" is forbidden`);
+                }
+            }
+            const { options } = el;
+            for (const selector of Object.keys(options)) {
+                verifyAst(plConfig, options[selector].value);
+            }
+        }
+    }
+}
+function checkNode(context, node) {
+    const settings = (0, util_1.getSettings)(context);
+    const msgs = (0, util_1.extractMessages)(node, settings);
+    if (!msgs.length) {
+        return;
+    }
+    const plConfig = context.options[0];
+    if (!plConfig) {
+        return;
+    }
+    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        try {
+            verifyAst(context.options[0], (0, icu_messageformat_parser_1.parse)(defaultMessage, {
+                ignoreTag: settings.ignoreTag,
+            }));
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+}
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce plural rules to always specify certain categories like `one`/`other`',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#enforce-plural-rules',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: Object.keys(LDML).reduce((schema, k) => {
+                    schema[k] = {
+                        type: 'boolean',
+                    };
+                    return schema;
+                }, {}),
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => checkNode(context, node),
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;

package/rules/no-camel-case.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=no-camel-case.d.ts.map

package/rules/no-camel-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-camel-case.d.ts","sourceRoot":"","sources":["no-camel-case.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAgE3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA8BhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/no-camel-case.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+const util_1 = require("../util");
+const CAMEL_CASE_REGEX = /[A-Z]/;
+class CamelCase extends Error {
+    constructor() {
+        super(...arguments);
+        this.message = 'Camel case arguments are not allowed';
+    }
+}
+function verifyAst(ast) {
+    for (const el of ast) {
+        if ((0, icu_messageformat_parser_1.isArgumentElement)(el)) {
+            if (CAMEL_CASE_REGEX.test(el.value)) {
+                throw new CamelCase();
+            }
+            continue;
+        }
+        if ((0, icu_messageformat_parser_1.isPluralElement)(el)) {
+            if (CAMEL_CASE_REGEX.test(el.value)) {
+                throw new CamelCase();
+            }
+            const { options } = el;
+            for (const selector of Object.keys(options)) {
+                verifyAst(options[selector].value);
+            }
+        }
+    }
+}
+function checkNode(context, node) {
+    const settings = (0, util_1.getSettings)(context);
+    const msgs = (0, util_1.extractMessages)(node, settings);
+    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        try {
+            verifyAst((0, icu_messageformat_parser_1.parse)(defaultMessage, {
+                ignoreTag: settings.ignoreTag,
+            }));
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+}
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow camel case placeholders in message',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#no-camel-case',
+        },
+        fixable: 'code',
+    },
+    create(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => checkNode(context, node),
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;

package/rules/no-complex-selectors.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=no-complex-selectors.d.ts.map

package/rules/no-complex-selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-complex-selectors.d.ts","sourceRoot":"","sources":["no-complex-selectors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAyE3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UAiDhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/no-complex-selectors.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+const manipulator_1 = require("@formatjs/icu-messageformat-parser/manipulator");
+function calculateComplexity(ast) {
+    if (ast.length === 1) {
+        const el = ast[0];
+        if ((0, icu_messageformat_parser_1.isPluralElement)(el) || (0, icu_messageformat_parser_1.isSelectElement)(el)) {
+            return Object.keys(el.options).reduce((complexity, k) => {
+                return complexity + calculateComplexity(el.options[k].value);
+            }, 0);
+        }
+    }
+    return 1;
+}
+function checkNode(context, node) {
+    const settings = (0, util_1.getSettings)(context);
+    const msgs = (0, util_1.extractMessages)(node, settings);
+    if (!msgs.length) {
+        return;
+    }
+    const config = {
+        limit: 20,
+        ...(context.options[0] || {}),
+    };
+    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        let ast;
+        try {
+            ast = (0, icu_messageformat_parser_1.parse)(defaultMessage, {
+                ignoreTag: settings.ignoreTag,
+            });
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e instanceof Error ? e.message : String(e),
+            });
+            return;
+        }
+        const hoistedAst = (0, manipulator_1.hoistSelectors)(ast);
+        const complexity = calculateComplexity(hoistedAst);
+        if (complexity > config.limit) {
+            context.report({
+                node: messageNode,
+                message: `Message complexity is too high (${complexity} vs limit at ${config.limit})`,
+            });
+        }
+    }
+}
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: `Make sure a sentence is not too complex. 
+Complexity is determined by how many strings are produced when we try to
+flatten the sentence given its selectors. For example:
+"I have {count, plural, one{a dog} other{many dogs}}"
+has the complexity of 2 because flattening the plural selector
+results in 2 sentences: "I have a dog" & "I have many dogs".
+Default complexity limit is 20 
+(using Smartling as a reference: https://help.smartling.com/hc/en-us/articles/360008030994-ICU-MessageFormat)
+`,
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#no-complex-selectors',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    limit: {
+                        type: 'number',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        fixable: 'code',
+    },
+    create(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => checkNode(context, node),
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;

package/rules/no-emoji.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=no-emoji.d.ts.map

package/rules/no-emoji.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-emoji.d.ts","sourceRoot":"","sources":["no-emoji.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AA2B3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA8BhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/no-emoji.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const util_1 = require("../util");
+const emoji_regex_1 = tslib_1.__importDefault(require("emoji-regex"));
+const EMOJI_REGEX = emoji_regex_1.default();
+function checkNode(context, node) {
+    const msgs = (0, util_1.extractMessages)(node, (0, util_1.getSettings)(context));
+    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        if (EMOJI_REGEX.test(defaultMessage)) {
+            context.report({
+                node: messageNode,
+                message: 'Emojis are not allowed',
+            });
+        }
+    }
+}
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow emojis in message',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#no-emoji',
+        },
+        fixable: 'code',
+    },
+    create(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => checkNode(context, node),
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;

package/rules/no-id.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const _default: Rule.RuleModule;
+export default _default;
+//# sourceMappingURL=no-id.d.ts.map

package/rules/no-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-id.d.ts","sourceRoot":"","sources":["no-id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAa,MAAM,QAAQ,CAAA;;AAgCvC,wBA8BoB"}

package/rules/no-id.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+function isComment(token) {
+    return !!token && (token.type === 'Block' || token.type === 'Line');
+}
+function checkNode(context, node) {
+    const msgs = (0, util_1.extractMessages)(node, (0, util_1.getSettings)(context));
+    for (const [{ idPropNode }] of msgs) {
+        if (idPropNode) {
+            context.report({
+                node: idPropNode,
+                message: 'Manual `id` are not allowed in message descriptor',
+                fix(fixer) {
+                    const src = context.getSourceCode();
+                    const token = src.getTokenAfter(idPropNode);
+                    const fixes = [fixer.remove(idPropNode)];
+                    if (token && !isComment(token) && token?.value === ',') {
+                        fixes.push(fixer.remove(token));
+                    }
+                    return fixes;
+                },
+            });
+        }
+    }
+}
+exports.default = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ban explicit ID from MessageDescriptor',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#no-id',
+        },
+        fixable: 'code',
+    },
+    create(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => checkNode(context, node),
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};

package/rules/no-invalid-icu.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=no-invalid-icu.d.ts.map

package/rules/no-invalid-icu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-invalid-icu.d.ts","sourceRoot":"","sources":["no-invalid-icu.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAqC3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA6BhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/no-invalid-icu.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+const util_1 = require("../util");
+function checkNode(context, node) {
+    const settings = (0, util_1.getSettings)(context);
+    const msgs = (0, util_1.extractMessages)(node, settings);
+    if (!msgs.length) {
+        return;
+    }
+    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        try {
+            (0, icu_messageformat_parser_1.parse)(defaultMessage, {
+                ignoreTag: settings.ignoreTag,
+            });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : e;
+            context.report({
+                node: messageNode,
+                message: `Error parsing ICU string: ${msg}`,
+            });
+        }
+    }
+}
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: `Make sure ICU messages are formatted correctly with no bad select statements, plurals, etc.`,
+            category: 'Errors',
+            recommended: true,
+        },
+        fixable: 'code',
+    },
+    create(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => checkNode(context, node),
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;

package/rules/no-literal-string-in-jsx.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=no-literal-string-in-jsx.d.ts.map

package/rules/no-literal-string-in-jsx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-literal-string-in-jsx.d.ts","sourceRoot":"","sources":["no-literal-string-in-jsx.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAqDhC,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA4JhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/no-literal-string-in-jsx.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const picomatch_1 = tslib_1.__importDefault(require("picomatch"));
+const typescript_estree_1 = require("@typescript-eslint/typescript-estree");
+const propMatcherSchema = {
+    type: 'array',
+    items: {
+        type: 'array',
+        items: [{ type: 'string' }, { type: 'string' }],
+    },
+};
+const defaultPropIncludePattern = [
+    ['*', 'aria-{label,description,details,errormessage}'],
+    ['[a-z]*([a-z0-9])', '(placeholder|title)'],
+    ['img', 'alt'],
+];
+const defaultPropExcludePattern = [];
+function stringifyJsxTagName(tagName) {
+    switch (tagName.type) {
+        case typescript_estree_1.TSESTree.AST_NODE_TYPES.JSXIdentifier:
+            return tagName.name;
+        case typescript_estree_1.TSESTree.AST_NODE_TYPES.JSXMemberExpression:
+            return `${stringifyJsxTagName(tagName.object)}.${tagName.property.name}`;
+        case typescript_estree_1.TSESTree.AST_NODE_TYPES.JSXNamespacedName:
+            return `${tagName.namespace.name}:${tagName.name.name}`;
+    }
+}
+function compilePropMatcher(propMatcher) {
+    return propMatcher.map(([tagNamePattern, propNamePattern]) => {
+        return [
+            picomatch_1.default.makeRe(tagNamePattern, { contains: false }),
+            picomatch_1.default.makeRe(propNamePattern, { contains: false }),
+        ];
+    });
+}
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow untranslated literal strings without translation.',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#no-literal-string-in-jsx',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    props: {
+                        type: 'object',
+                        properties: {
+                            include: {
+                                ...propMatcherSchema,
+                            },
+                            exclude: {
+                                ...propMatcherSchema,
+                            },
+                        },
+                    },
+                },
+            },
+        ],
+    },
+    // TODO: Vue support
+    create(context) {
+        const userConfig = context.options[0] || {};
+        const propIncludePattern = compilePropMatcher([
+            ...defaultPropIncludePattern,
+            ...(userConfig.props?.include ?? []),
+        ]);
+        const propExcludePattern = compilePropMatcher([
+            ...defaultPropExcludePattern,
+            ...(userConfig.props?.exclude ?? []),
+        ]);
+        const lexicalJsxStack = [];
+        const shouldSkipCurrentJsxAttribute = (node) => {
+            const currentJsxNode = lexicalJsxStack[lexicalJsxStack.length - 1];
+            if (currentJsxNode.type === 'JSXFragment') {
+                return false;
+            }
+            const nameString = stringifyJsxTagName(currentJsxNode.openingElement.name);
+            const attributeName = typeof node.name.name === 'string'
+                ? node.name.name
+                : node.name.name.name;
+            // match exclude
+            for (const [tagNamePattern, propNamePattern] of propExcludePattern) {
+                if (tagNamePattern.test(nameString) &&
+                    propNamePattern.test(attributeName)) {
+                    return true;
+                }
+            }
+            // match include
+            for (const [tagNamePattern, propNamePattern] of propIncludePattern) {
+                if (tagNamePattern.test(nameString) &&
+                    propNamePattern.test(attributeName)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        const checkJSXExpression = (node) => {
+            // Check if this is either a string literal / template literal, or the concat of them.
+            if ((node.type === 'Literal' && typeof node.value === 'string') ||
+                node.type === 'TemplateLiteral') {
+                context.report({
+                    node: node,
+                    message: 'Cannot have untranslated text in JSX',
+                });
+            }
+            else if (node.type === 'BinaryExpression' && node.operator === '+') {
+                checkJSXExpression(node.left);
+                checkJSXExpression(node.right);
+            }
+        };
+        return {
+            JSXElement: (node) => {
+                lexicalJsxStack.push(node);
+            },
+            'JSXElement:exit': () => {
+                lexicalJsxStack.pop();
+            },
+            JSXFragment: (node) => {
+                lexicalJsxStack.push(node);
+            },
+            'JSXFragment:exit': () => {
+                lexicalJsxStack.pop();
+            },
+            JSXAttribute: (node) => {
+                if (shouldSkipCurrentJsxAttribute(node)) {
+                    return;
+                }
+                if (!node.value) {
+                    return;
+                }
+                if (node.value.type === 'Literal') {
+                    context.report({
+                        node: node,
+                        message: 'Cannot have untranslated text in JSX',
+                    });
+                }
+                else if (node.value.type === 'JSXExpressionContainer' &&
+                    node.value.expression.type !== 'JSXEmptyExpression') {
+                    checkJSXExpression(node.value.expression);
+                }
+            },
+            JSXText: (node) => {
+                // Ignore purely spacing fragments
+                if (!node.value.replace(/\s*/gm, '')) {
+                    return;
+                }
+                context.report({
+                    node: node,
+                    message: 'Cannot have untranslated text in JSX',
+                });
+            },
+            // Children expression container
+            'JSXElement > JSXExpressionContainer': (node) => {
+                if (node.expression.type !== 'JSXEmptyExpression') {
+                    checkJSXExpression(node.expression);
+                }
+            },
+        };
+    },
+};
+exports.default = rule;

package/rules/no-multiple-plurals.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=no-multiple-plurals.d.ts.map

package/rules/no-multiple-plurals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-multiple-plurals.d.ts","sourceRoot":"","sources":["no-multiple-plurals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAwD3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA8BhB,CAAA;AAED,eAAe,IAAI,CAAA"}