eslint-plugin-formatjs 2.17.7

package/rules/enforce-plural-rules.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var util_1 = require("../util");
+var icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+var PluralRulesEnforcement = /** @class */ (function (_super) {
+    tslib_1.__extends(PluralRulesEnforcement, _super);
+    function PluralRulesEnforcement(message) {
+        var _this = _super.call(this) || this;
+        _this.message = message;
+        return _this;
+    }
+    return PluralRulesEnforcement;
+}(Error));
+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 (var _i = 0, ast_1 = ast; _i < ast_1.length; _i++) {
+        var el = ast_1[_i];
+        if (icu_messageformat_parser_1.isPluralElement(el)) {
+            var rules = Object.keys(plConfig);
+            for (var _a = 0, rules_1 = rules; _a < rules_1.length; _a++) {
+                var rule_1 = rules_1[_a];
+                if (plConfig[rule_1] && !el.options[rule_1]) {
+                    throw new PluralRulesEnforcement("Missing plural rule \"" + rule_1 + "\"");
+                }
+                if (!plConfig[rule_1] && el.options[rule_1]) {
+                    throw new PluralRulesEnforcement("Plural rule \"" + rule_1 + "\" is forbidden");
+                }
+            }
+            var options = el.options;
+            for (var _b = 0, _c = Object.keys(options); _b < _c.length; _b++) {
+                var selector = _c[_b];
+                verifyAst(plConfig, options[selector].value);
+            }
+        }
+    }
+}
+function checkNode(context, node) {
+    var msgs = util_1.extractMessages(node, context.settings);
+    if (!msgs.length) {
+        return;
+    }
+    var plConfig = context.options[0];
+    if (!plConfig) {
+        return;
+    }
+    for (var _i = 0, msgs_1 = msgs; _i < msgs_1.length; _i++) {
+        var _a = msgs_1[_i][0], defaultMessage = _a.message.defaultMessage, messageNode = _a.messageNode;
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        try {
+            verifyAst(context.options[0], icu_messageformat_parser_1.parse(defaultMessage, {
+                ignoreTag: context.settings.ignoreTag,
+            }));
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e.message,
+            });
+        }
+    }
+}
+var 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(function (schema, k) {
+                    schema[k] = {
+                        type: 'boolean',
+                    };
+                    return schema;
+                }, {}),
+                additionalProperties: false,
+            },
+        ],
+    },
+    create: function (context) {
+        var callExpressionVisitor = function (node) {
+            return checkNode(context, node);
+        };
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: function (node) { return 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":["../../../../../../packages/eslint-plugin-formatjs/rules/no-camel-case.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AA+D3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA8BhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/no-camel-case.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+var util_1 = require("../util");
+var CAMEL_CASE_REGEX = /[A-Z]/;
+var CamelCase = /** @class */ (function (_super) {
+    tslib_1.__extends(CamelCase, _super);
+    function CamelCase() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.message = 'Camel case arguments are not allowed';
+        return _this;
+    }
+    return CamelCase;
+}(Error));
+function verifyAst(ast) {
+    for (var _i = 0, ast_1 = ast; _i < ast_1.length; _i++) {
+        var el = ast_1[_i];
+        if (icu_messageformat_parser_1.isArgumentElement(el)) {
+            if (CAMEL_CASE_REGEX.test(el.value)) {
+                throw new CamelCase();
+            }
+            continue;
+        }
+        if (icu_messageformat_parser_1.isPluralElement(el)) {
+            if (CAMEL_CASE_REGEX.test(el.value)) {
+                throw new CamelCase();
+            }
+            var options = el.options;
+            for (var _a = 0, _b = Object.keys(options); _a < _b.length; _a++) {
+                var selector = _b[_a];
+                verifyAst(options[selector].value);
+            }
+        }
+    }
+}
+function checkNode(context, node) {
+    var msgs = util_1.extractMessages(node, context.settings);
+    for (var _i = 0, msgs_1 = msgs; _i < msgs_1.length; _i++) {
+        var _a = msgs_1[_i][0], defaultMessage = _a.message.defaultMessage, messageNode = _a.messageNode;
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        try {
+            verifyAst(icu_messageformat_parser_1.parse(defaultMessage, {
+                ignoreTag: context.settings.ignoreTag,
+            }));
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e.message,
+            });
+        }
+    }
+}
+var 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: function (context) {
+        var callExpressionVisitor = function (node) {
+            return checkNode(context, node);
+        };
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: function (node) { return 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":["../../../../../../packages/eslint-plugin-formatjs/rules/no-complex-selectors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AA8D3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UAiDhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/no-complex-selectors.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var util_1 = require("../util");
+var icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+var manipulator_1 = require("@formatjs/icu-messageformat-parser/manipulator");
+function calculateComplexity(ast) {
+    if (ast.length === 1) {
+        var el_1 = ast[0];
+        if (icu_messageformat_parser_1.isPluralElement(el_1) || icu_messageformat_parser_1.isSelectElement(el_1)) {
+            return Object.keys(el_1.options).reduce(function (complexity, k) {
+                return complexity + calculateComplexity(el_1.options[k].value);
+            }, 0);
+        }
+    }
+    return 1;
+}
+function checkNode(context, node) {
+    var msgs = util_1.extractMessages(node, context.settings);
+    if (!msgs.length) {
+        return;
+    }
+    var config = tslib_1.__assign({ limit: 20 }, (context.options[0] || {}));
+    for (var _i = 0, msgs_1 = msgs; _i < msgs_1.length; _i++) {
+        var _a = msgs_1[_i][0], defaultMessage = _a.message.defaultMessage, messageNode = _a.messageNode;
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        var hoistedAst = manipulator_1.hoistSelectors(icu_messageformat_parser_1.parse(defaultMessage, {
+            ignoreTag: context.settings.ignoreTag,
+        }));
+        var complexity = calculateComplexity(hoistedAst);
+        if (complexity > config.limit) {
+            context.report({
+                node: messageNode,
+                message: "Message complexity is too high (" + complexity + " vs limit at " + config.limit + ")",
+            });
+        }
+    }
+}
+var rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: "Make sure a sentence is not too complex. \nComplexity is determined by how many strings are produced when we try to\nflatten the sentence given its selectors. For example:\n\"I have {count, plural, one{a dog} other{many dogs}}\"\nhas the complexity of 2 because flattening the plural selector\nresults in 2 sentences: \"I have a dog\" & \"I have many dogs\".\nDefault complexity limit is 20 \n(using Smartling as a reference: https://help.smartling.com/hc/en-us/articles/360008030994-ICU-MessageFormat)\n",
+            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: function (context) {
+        var callExpressionVisitor = function (node) {
+            return checkNode(context, node);
+        };
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: function (node) { return 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":["../../../../../../packages/eslint-plugin-formatjs/rules/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,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var util_1 = require("../util");
+var emoji_regex_1 = tslib_1.__importDefault(require("emoji-regex"));
+var EMOJI_REGEX = emoji_regex_1.default();
+function checkNode(context, node) {
+    var msgs = util_1.extractMessages(node, context.settings);
+    for (var _i = 0, msgs_1 = msgs; _i < msgs_1.length; _i++) {
+        var _a = msgs_1[_i][0], defaultMessage = _a.message.defaultMessage, messageNode = _a.messageNode;
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        if (EMOJI_REGEX.test(defaultMessage)) {
+            context.report({
+                node: messageNode,
+                message: 'Emojis are not allowed',
+            });
+        }
+    }
+}
+var 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: function (context) {
+        var callExpressionVisitor = function (node) {
+            return checkNode(context, node);
+        };
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: function (node) { return 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":["../../../../../../packages/eslint-plugin-formatjs/rules/no-id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAa,MAAM,QAAQ,CAAA;;AAgCvC,wBA8BoB"}

package/rules/no-id.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../util");
+function isComment(token) {
+    return !!token && (token.type === 'Block' || token.type === 'Line');
+}
+function checkNode(context, node) {
+    var msgs = util_1.extractMessages(node, context.settings);
+    var _loop_1 = function (idPropNode) {
+        if (idPropNode) {
+            context.report({
+                node: idPropNode,
+                message: 'Manual `id` are not allowed in message descriptor',
+                fix: function (fixer) {
+                    var src = context.getSourceCode();
+                    var token = src.getTokenAfter(idPropNode);
+                    var fixes = [fixer.remove(idPropNode)];
+                    if (token && !isComment(token) && (token === null || token === void 0 ? void 0 : token.value) === ',') {
+                        fixes.push(fixer.remove(token));
+                    }
+                    return fixes;
+                },
+            });
+        }
+    };
+    for (var _i = 0, msgs_1 = msgs; _i < msgs_1.length; _i++) {
+        var idPropNode = msgs_1[_i][0].idPropNode;
+        _loop_1(idPropNode);
+    }
+}
+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: function (context) {
+        var callExpressionVisitor = function (node) {
+            return checkNode(context, node);
+        };
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: function (node) { return checkNode(context, node); },
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};

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":["../../../../../../packages/eslint-plugin-formatjs/rules/no-multiple-plurals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAuD3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA8BhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/no-multiple-plurals.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var util_1 = require("../util");
+var icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+var MultiplePlurals = /** @class */ (function (_super) {
+    tslib_1.__extends(MultiplePlurals, _super);
+    function MultiplePlurals() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.message = 'Cannot specify more than 1 plural rules';
+        return _this;
+    }
+    return MultiplePlurals;
+}(Error));
+function verifyAst(ast, pluralCount) {
+    if (pluralCount === void 0) { pluralCount = { count: 0 }; }
+    for (var _i = 0, ast_1 = ast; _i < ast_1.length; _i++) {
+        var el = ast_1[_i];
+        if (icu_messageformat_parser_1.isPluralElement(el)) {
+            pluralCount.count++;
+            if (pluralCount.count > 1) {
+                throw new MultiplePlurals();
+            }
+            var options = el.options;
+            for (var _a = 0, _b = Object.keys(options); _a < _b.length; _a++) {
+                var selector = _b[_a];
+                verifyAst(options[selector].value, pluralCount);
+            }
+        }
+    }
+}
+function checkNode(context, node) {
+    var msgs = util_1.extractMessages(node, context.settings);
+    for (var _i = 0, msgs_1 = msgs; _i < msgs_1.length; _i++) {
+        var _a = msgs_1[_i][0], defaultMessage = _a.message.defaultMessage, messageNode = _a.messageNode;
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        try {
+            verifyAst(icu_messageformat_parser_1.parse(defaultMessage, {
+                ignoreTag: context.settings.ignoreTag,
+            }));
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e.message,
+            });
+        }
+    }
+}
+var rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow multiple plural rules in the same message',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#no-multiple-plurals',
+        },
+        fixable: 'code',
+    },
+    create: function (context) {
+        var callExpressionVisitor = function (node) {
+            return checkNode(context, node);
+        };
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: function (node) { return checkNode(context, node); },
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-multiple-whitespaces.d.ts","sourceRoot":"","sources":["../../../../../../packages/eslint-plugin-formatjs/rules/no-multiple-whitespaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAmC3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA8BhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/no-multiple-whitespaces.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../util");
+var MULTIPLE_SPACES = /\s{2,}/g;
+function checkNode(context, node) {
+    var msgs = util_1.extractMessages(node, context.settings);
+    var _loop_1 = function (defaultMessage, messageNode) {
+        if (!defaultMessage || !messageNode) {
+            return "continue";
+        }
+        if (MULTIPLE_SPACES.test(defaultMessage)) {
+            var reportObject = {
+                node: messageNode,
+                message: 'Multiple consecutive whitespaces are not allowed',
+            };
+            if (messageNode.type === 'Literal' && messageNode.raw) {
+                reportObject.fix = function (fixer) {
+                    return fixer.replaceText(messageNode, messageNode.raw.replace(MULTIPLE_SPACES, ' '));
+                };
+            }
+            context.report(reportObject);
+        }
+    };
+    for (var _i = 0, msgs_1 = msgs; _i < msgs_1.length; _i++) {
+        var _a = msgs_1[_i][0], defaultMessage = _a.message.defaultMessage, messageNode = _a.messageNode;
+        _loop_1(defaultMessage, messageNode);
+    }
+}
+var rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow emojis in message',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#no-emoji',
+        },
+        fixable: 'whitespace',
+    },
+    create: function (context) {
+        var callExpressionVisitor = function (node) {
+            return checkNode(context, node);
+        };
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: function (node) { return checkNode(context, node); },
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;

package/rules/no-offset.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-offset.d.ts","sourceRoot":"","sources":["../../../../../../packages/eslint-plugin-formatjs/rules/no-offset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAsD3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA8BhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/no-offset.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var util_1 = require("../util");
+var icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+var NoOffsetError = /** @class */ (function (_super) {
+    tslib_1.__extends(NoOffsetError, _super);
+    function NoOffsetError() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.message = 'offset are not allowed in plural rules';
+        return _this;
+    }
+    return NoOffsetError;
+}(Error));
+function verifyAst(ast) {
+    for (var _i = 0, ast_1 = ast; _i < ast_1.length; _i++) {
+        var el = ast_1[_i];
+        if (icu_messageformat_parser_1.isPluralElement(el)) {
+            if (el.offset) {
+                throw new NoOffsetError();
+            }
+            var options = el.options;
+            for (var _a = 0, _b = Object.keys(options); _a < _b.length; _a++) {
+                var selector = _b[_a];
+                verifyAst(options[selector].value);
+            }
+        }
+    }
+}
+function checkNode(context, node) {
+    var msgs = util_1.extractMessages(node, context.settings);
+    for (var _i = 0, msgs_1 = msgs; _i < msgs_1.length; _i++) {
+        var _a = msgs_1[_i][0], defaultMessage = _a.message.defaultMessage, messageNode = _a.messageNode;
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        try {
+            verifyAst(icu_messageformat_parser_1.parse(defaultMessage, {
+                ignoreTag: context.settings.ignoreTag,
+            }));
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e.message,
+            });
+        }
+    }
+}
+var rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow offset in plural rules',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#no-offset',
+        },
+        fixable: 'code',
+    },
+    create: function (context) {
+        var callExpressionVisitor = function (node) {
+            return checkNode(context, node);
+        };
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: function (node) { return checkNode(context, node); },
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;