@daldalso/eslint-plugin 1.2.0

package/dist/rules/iterator-name.js

@@ -0,0 +1,315 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@typescript-eslint/utils");
+var patterns_1 = require("../utils/patterns");
+var text_1 = require("../utils/text");
+var type_1 = require("../utils/type");
+var iterativeMethods = ["map", "reduce", "every", "some", "forEach", "filter", "find", "findIndex"];
+var kindTable = {
+    for: ["index"],
+    forIn: ["key"],
+    forOf: ["value"],
+    entries: ["entry", "index"],
+    entriesReduce: ["previousValue", "entry", "index"],
+    every: ["value", "index"],
+    filter: ["value", "index"],
+    find: ["value", "index"],
+    findIndex: ["value", "index"],
+    forEach: ["value", "index"],
+    map: ["value", "index"],
+    reduce: ["previousValue", "value", "index"],
+    some: ["value", "index"]
+};
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "layout",
+        messages: {
+            'default': "{{index}} iterator name of {{depth}} `{{kind}}` should be `{{criterion}}`."
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    entry: { type: "array", items: { type: "string" } },
+                    index: { type: "array", items: { type: "string" } },
+                    key: { type: "array", items: { type: "string" } },
+                    previousKey: { type: "array", items: { type: "string" } },
+                    previousValue: { type: "array", items: { type: "string" } },
+                    value: { type: "array", items: { type: "string" } }
+                }
+            },
+            {
+                type: "object",
+                properties: {
+                    keyListLikeNamePattern: { type: "string" },
+                    exceptions: { type: "array", items: { type: "string" } }
+                }
+            }
+        ]
+    },
+    defaultOptions: [
+        {
+            entry: ["e", "f", "g", "h", "i"],
+            index: ["i", "j", "k", "l", "m"],
+            key: ["k", "l", "m", "n", "o"],
+            previousKey: ["pk", "pl", "pm", "pn", "po"],
+            previousValue: ["pv", "pw", "px", "py", "pz"],
+            value: ["v", "w", "x", "y", "z"]
+        },
+        {
+            keyListLikeNamePattern: patterns_1.keyListLikeNamePattern.source,
+            exceptions: ["_", "__"]
+        }
+    ],
+    create: function (context, _a) {
+        var options = _a[0], _b = _a[1], keyListLikeNamePatternString = _b.keyListLikeNamePattern, exceptions = _b.exceptions;
+        if (!keyListLikeNamePatternString)
+            throw Error("Unhandled keyListLikeNamePatternString: ".concat(keyListLikeNamePatternString));
+        var keyListLikeNamePattern = new RegExp(keyListLikeNamePatternString);
+        var sourceCode = context.getSourceCode();
+        var getIterativeStatementParameters = function (node) {
+            var _a;
+            var name;
+            var list;
+            var calleeObject = undefined;
+            var keyish = false;
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.ForStatement:
+                    if (((_a = node.init) === null || _a === void 0 ? void 0 : _a.type) !== utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                        return null;
+                    }
+                    if (node.init.declarations.length !== 1) {
+                        return null;
+                    }
+                    if (node.init.declarations[0].id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                        return null;
+                    }
+                    name = "for";
+                    list = [node.init.declarations[0].id];
+                    break;
+                case utils_1.AST_NODE_TYPES.ForInStatement:
+                case utils_1.AST_NODE_TYPES.ForOfStatement:
+                    {
+                        if (node.left.type !== utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                            return null;
+                        }
+                        if (node.left.declarations.length !== 1) {
+                            return null;
+                        }
+                        var leftNode = node.left.declarations[0];
+                        if (leftNode.id.type !== utils_1.AST_NODE_TYPES.Identifier && leftNode.id.type !== utils_1.AST_NODE_TYPES.ArrayPattern) {
+                            return null;
+                        }
+                        name = node.type === utils_1.AST_NODE_TYPES.ForInStatement ? "forIn" : "forOf";
+                        if (name === "forOf") {
+                            if (isKeyListLikeName(node.right)) {
+                                keyish = true;
+                            }
+                            else {
+                                var iteratorType = (0, type_1.getTSTypeByNode)(context, leftNode);
+                                if (iteratorType.isUnion() && iteratorType.types.every(function (v) { return v.isStringLiteral(); })) {
+                                    keyish = true;
+                                }
+                            }
+                        }
+                        list = [leftNode.id];
+                        calleeObject = node.right;
+                    }
+                    break;
+                default: return null;
+            }
+            return { name: name, keyish: keyish, list: list, calleeObject: calleeObject };
+        };
+        var getIterativeMethodParameters = function (node) {
+            var _a;
+            if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return null;
+            }
+            if (node.callee.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return null;
+            }
+            if (((_a = node.arguments[0]) === null || _a === void 0 ? void 0 : _a.type) !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                return null;
+            }
+            if (!node.arguments[0].params.every(function (v) { return v.type === utils_1.AST_NODE_TYPES.Identifier
+                || v.type === utils_1.AST_NODE_TYPES.ArrayPattern
+                || v.type === utils_1.AST_NODE_TYPES.ObjectPattern; })) {
+                return null;
+            }
+            if (!(0, type_1.getTSTypeByNode)(context, node.callee.object).getNumberIndexType()) {
+                return null;
+            }
+            if (!iterativeMethods.includes(node.callee.property.name)) {
+                return null;
+            }
+            return {
+                name: node.callee.property.name,
+                keyish: isKeyListLikeName(node.callee.object),
+                calleeObject: node.callee.object,
+                list: node.arguments[0].params
+            };
+        };
+        var getCurrentDepth = function (me) {
+            var ancestors = context.getAncestors();
+            var R = 0;
+            for (var i = 0; i < ancestors.length; i++) {
+                var v = ancestors[i];
+                switch (v.type) {
+                    case utils_1.AST_NODE_TYPES.CallExpression:
+                        if (v.callee === (ancestors[i + 1] || me)) {
+                            continue;
+                        }
+                        if (!getIterativeMethodParameters(v)) {
+                            continue;
+                        }
+                        R++;
+                        break;
+                    case utils_1.AST_NODE_TYPES.WhileStatement:
+                    case utils_1.AST_NODE_TYPES.DoWhileStatement:
+                        if (v.test === (ancestors[i + 1] || me)) {
+                            continue;
+                        }
+                    case utils_1.AST_NODE_TYPES.ForStatement:
+                    case utils_1.AST_NODE_TYPES.ForInStatement:
+                    case utils_1.AST_NODE_TYPES.ForOfStatement:
+                        R++;
+                        break;
+                }
+            }
+            return R;
+        };
+        var getActualName = function (value) {
+            if (value.startsWith("$")) {
+                return value.slice(1);
+            }
+            return value;
+        };
+        var checkParameterNames = function (kind, parameters, depth) {
+            var _a, _b;
+            var max = Math.min(kind.length, parameters.length);
+            for (var i = 0; i < max; i++) {
+                var parameter = parameters[i];
+                switch (parameter.type) {
+                    case utils_1.AST_NODE_TYPES.ObjectPattern:
+                        continue;
+                    case utils_1.AST_NODE_TYPES.ArrayPattern:
+                        if (kind[i] !== "entry") {
+                            continue;
+                        }
+                        if (((_a = parameter.elements[0]) === null || _a === void 0 ? void 0 : _a.type) !== utils_1.AST_NODE_TYPES.Identifier) {
+                            continue;
+                        }
+                        if (((_b = parameter.elements[1]) === null || _b === void 0 ? void 0 : _b.type) !== utils_1.AST_NODE_TYPES.Identifier) {
+                            continue;
+                        }
+                        if (getActualName(parameter.elements[0].name) === options.key[depth] && getActualName(parameter.elements[1].name) === options.value[depth]) {
+                            continue;
+                        }
+                        context.report({
+                            node: parameter,
+                            messageId: "default",
+                            data: {
+                                index: "Destructured",
+                                depth: (0, text_1.toOrdinal)(depth + 1),
+                                kind: kind[i],
+                                criterion: "[ ".concat(options.key[depth], ", ").concat(options.value[depth], " ]")
+                            }
+                        });
+                        break;
+                    default: {
+                        var criterion = options[kind[i]][depth];
+                        if (!criterion) {
+                            continue;
+                        }
+                        if (exceptions.includes(parameter.name)) {
+                            continue;
+                        }
+                        if (getActualName(parameter.name) === criterion) {
+                            continue;
+                        }
+                        context.report({
+                            node: parameter,
+                            messageId: "default",
+                            data: {
+                                index: (0, text_1.toOrdinal)(i + 1),
+                                depth: (0, text_1.toOrdinal)(depth + 1),
+                                kind: kind[i],
+                                criterion: criterion
+                            }
+                        });
+                    }
+                }
+            }
+        };
+        var isStaticObjectCall = function (node, name) {
+            if ((node === null || node === void 0 ? void 0 : node.type) !== utils_1.AST_NODE_TYPES.CallExpression) {
+                return false;
+            }
+            if (sourceCode.getText(node.callee) !== "Object.".concat(name)) {
+                return false;
+            }
+            return true;
+        };
+        var isKeyListLikeName = function (node) {
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.Identifier: return keyListLikeNamePattern.test(node.name);
+                case utils_1.AST_NODE_TYPES.CallExpression:
+                    if (isStaticObjectCall(node, "keys"))
+                        return true;
+                    return node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression && isKeyListLikeName(node.callee.object);
+            }
+            return false;
+        };
+        (0, type_1.useTypeChecker)(context);
+        return {
+            CallExpression: function (node) {
+                var parameters = getIterativeMethodParameters(node);
+                if (!parameters) {
+                    return;
+                }
+                var depth = getCurrentDepth(node);
+                if (isStaticObjectCall(parameters.calleeObject, "entries")) {
+                    checkParameterNames(resolveKindTable(parameters.name === "reduce" ? 'entriesReduce' : 'entries', parameters.keyish), parameters.list, depth);
+                }
+                else {
+                    checkParameterNames(resolveKindTable(parameters.name, parameters.keyish), parameters.list, depth);
+                }
+            },
+            'ForStatement, ForInStatement, ForOfStatement': function (node) {
+                var parameters = getIterativeStatementParameters(node);
+                if (!parameters) {
+                    return;
+                }
+                var depth = getCurrentDepth(node);
+                if (parameters.calleeObject && isStaticObjectCall(parameters.calleeObject, "entries")) {
+                    checkParameterNames(resolveKindTable('entries', parameters.keyish), parameters.list, depth);
+                }
+                else {
+                    checkParameterNames(resolveKindTable(parameters.name, parameters.keyish), parameters.list, depth);
+                }
+            }
+        };
+    }
+});
+function resolveKindTable(key, keyish) {
+    var R = __spreadArray([], kindTable[key], true);
+    if (keyish) {
+        R = R.map(function (v) {
+            switch (v) {
+                case "value": return "key";
+                case "previousValue": return "previousKey";
+            }
+            return v;
+        });
+    }
+    return R;
+}

package/dist/rules/jsx-expression-condition-type.js

@@ -0,0 +1,76 @@
+"use strict";
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@typescript-eslint/utils");
+var typescript_1 = require("typescript");
+var type_1 = require("../utils/type");
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "suggestion",
+        fixable: "code",
+        messages: {
+            'default': "Left expression of loginal `&&` operations should not be a number or string."
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create: function (context) {
+        var sourceCode = context.getSourceCode();
+        var hasStringOrNumber = function (type) {
+            if (type.isUnionOrIntersection()) {
+                return type.types.some(function (v) { return hasStringOrNumber(v); });
+            }
+            var flags = type.getFlags();
+            return Boolean(flags & (typescript_1.TypeFlags.StringLike | typescript_1.TypeFlags.NumberLike));
+        };
+        (0, type_1.useTypeChecker)(context);
+        return {
+            'JSXExpressionContainer>LogicalExpression[operator="&&"]': function (node) {
+                var tsType = (0, type_1.getTSTypeByNode)(context, node.left).getNonNullableType();
+                if (!hasStringOrNumber(tsType)) {
+                    return;
+                }
+                context.report({
+                    node: node.left,
+                    messageId: "default",
+                    fix: function (fixer) {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, fixer.replaceText(node.left, "Boolean(".concat(sourceCode.getText(node.left), ")"))];
+                                case 1:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }
+                });
+            }
+        };
+    }
+});

package/dist/rules/jsx-indent.js

@@ -0,0 +1,220 @@
+"use strict";
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@typescript-eslint/utils");
+var code_1 = require("../utils/code");
+var text_1 = require("../utils/text");
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            'in-children-indentation': "Children of a tag should be indented.",
+            'in-multiline-tag-closing': "Closing of a tag should not be multiline.",
+            'in-tag-closing': "Closing of a single line tag should not be spaced.",
+            'in-tag-indentation': "Closing of a multiline tag should appear at the first of its line.",
+            'in-tag-opening': "Opening of a tag should not be spaced.",
+            'in-tag-self-closing': "Self-closing of a tag should be spaced."
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create: function (context) {
+        var sourceCode = context.getSourceCode();
+        var checkTagOpening = function (tag) {
+            var _a, _b;
+            var _c;
+            var prefix;
+            var payload;
+            if (tag.type === utils_1.AST_NODE_TYPES.JSXOpeningElement) {
+                _a = sourceCode.getFirstTokens(tag, { count: 2 }), prefix = _a[0], payload = _a[1];
+            }
+            else {
+                _b = sourceCode.getFirstTokens(tag, { count: 3 }), prefix = _b[1], payload = _b[2];
+            }
+            if (!((_c = sourceCode.isSpaceBetween) === null || _c === void 0 ? void 0 : _c.call(sourceCode, prefix, payload))) {
+                return;
+            }
+            context.report({
+                node: prefix,
+                messageId: "in-tag-opening",
+                fix: function (fixer) {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, fixer.removeRange([prefix.range[1], payload.range[0]])];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }
+            });
+        };
+        var checkTagClosing = function (tag) {
+            var _a, _b;
+            var selfClosing = tag.type === utils_1.AST_NODE_TYPES.JSXOpeningElement && tag.selfClosing;
+            var _c = sourceCode.getLastTokens(tag, {
+                count: selfClosing ? 3 : 2
+            }), payload = _c[0], next = _c[1];
+            if (selfClosing) {
+                if ((_a = sourceCode.isSpaceBetween) === null || _a === void 0 ? void 0 : _a.call(sourceCode, payload, next)) {
+                    return;
+                }
+                context.report({
+                    node: next,
+                    messageId: "in-tag-self-closing",
+                    fix: function (fixer) {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, fixer.insertTextBefore(next, " ")];
+                                case 1:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }
+                });
+            }
+            else {
+                if (!((_b = sourceCode.isSpaceBetween) === null || _b === void 0 ? void 0 : _b.call(sourceCode, payload, next))) {
+                    return;
+                }
+                context.report({
+                    node: next,
+                    messageId: "in-tag-closing",
+                    fix: function (fixer) {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, fixer.removeRange([payload.range[1], next.range[0]])];
+                                case 1:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }
+                });
+            }
+        };
+        return {
+            JSXElement: function (node) {
+                if (!node.children.length)
+                    return;
+                var first = sourceCode.getFirstToken(node);
+                var openingTagRear = sourceCode.getLastToken(node.openingElement);
+                var closingTagFront = node.closingElement && sourceCode.getFirstToken(node.closingElement);
+                if (!first || !openingTagRear || !closingTagFront) {
+                    return;
+                }
+                var indentation = (0, code_1.getIndentation)(sourceCode, first.loc.start.line);
+                var _loop_1 = function (i) {
+                    if (!sourceCode.lines[i - 1].trim())
+                        return "continue";
+                    var currentIndentation = (0, code_1.getIndentation)(sourceCode, i);
+                    if (indentation.length < currentIndentation.length)
+                        return "continue";
+                    var start = sourceCode.getLocFromIndex(sourceCode.lineStartIndices[i - 1]);
+                    var end = { line: start.line, column: currentIndentation.length };
+                    var endIndex = sourceCode.getIndexFromLoc(end);
+                    context.report({
+                        loc: { start: start, end: end },
+                        messageId: "in-children-indentation",
+                        fix: function (fixer) {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, fixer.replaceTextRange([sourceCode.lineStartIndices[i - 1], endIndex], indentation + text_1.INDENTATION_UNIT)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }
+                    });
+                };
+                for (var i = openingTagRear.loc.end.line + 1; i < closingTagFront.loc.start.line; i++) {
+                    _loop_1(i);
+                }
+            },
+            JSXOpeningElement: function (node) {
+                var isSingleLine = node.loc.start.line === node.loc.end.line;
+                checkTagOpening(node);
+                if (isSingleLine) {
+                    checkTagClosing(node);
+                }
+                else {
+                    var closingBracket_1 = sourceCode.getLastToken(node);
+                    if (!closingBracket_1)
+                        return;
+                    var aIndentation_1 = (0, code_1.getIndentation)(sourceCode, node.loc.start.line);
+                    var bIndentation = (0, code_1.getIndentation)(sourceCode, closingBracket_1.loc.end.line);
+                    if (aIndentation_1 !== bIndentation) {
+                        context.report({
+                            node: closingBracket_1,
+                            messageId: "in-tag-indentation",
+                            fix: function (fixer) {
+                                var target;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            target = node.selfClosing ? sourceCode.getTokenBefore(closingBracket_1) : closingBracket_1;
+                                            return [4 /*yield*/, fixer.insertTextBefore(target, "\n" + aIndentation_1)];
+                                        case 1:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }
+                        });
+                    }
+                }
+            },
+            JSXClosingElement: function (node) {
+                var isSingleLine = node.loc.start.line === node.loc.end.line;
+                checkTagOpening(node);
+                if (isSingleLine) {
+                    checkTagClosing(node);
+                    return;
+                }
+                context.report({
+                    node: node,
+                    messageId: "in-multiline-tag-closing",
+                    fix: function (fixer) {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, fixer.replaceText(node, sourceCode.getText(node).replace(/\s/g, ""))];
+                                case 1:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }
+                });
+            }
+        };
+    }
+});