eslint-plugin-yml 0.9.0 → 0.12.0

package/README.md

@@ -54,7 +54,7 @@ npm install --save-dev eslint eslint-plugin-yml
 > **Requirements**
 >
 > - ESLint v6.0.0 and above
-> - Node.js v8.10.0 and above
+> - Node.js v12.22.x, v14.17.x, v16.x and above
 
 <!--DOCS_IGNORE_END-->
 
@@ -92,6 +92,29 @@ This plugin provides configs:
 
 See [the rule list](https://ota-meshi.github.io/eslint-plugin-yml/rules/) to get the `rules` that this plugin provides.
 
+#### Parser Configuration
+
+If you have specified a parser, you need to configure a parser for `.yaml`.
+
+For example, if you are using the `"@babel/eslint-parser"`, configure it as follows:
+
+```js
+module.exports = {
+  // ...
+  extends: ["plugin:yml/standard"],
+  // ...
+  parser: "@babel/eslint-parser",
+  // Add an `overrides` section to add a parser configuration for YAML.
+  overrides: [
+    {
+      files: ["*.yaml", "*.yml"],
+      parser: "yaml-eslint-parser",
+    },
+  ],
+  // ...
+};
+```
+
 ### Running ESLint from the command line
 
 If you want to run `eslint` from the command line, make sure you include the `.yaml` extension using [the `--ext` option](https://eslint.org/docs/user-guide/configuring#specifying-file-extensions-to-lint) or a glob pattern, because ESLint targets only `.js` files by default.
@@ -165,6 +188,7 @@ The rules with the following star :star: are included in the config.
 | [yml/flow-sequence-bracket-spacing](https://ota-meshi.github.io/eslint-plugin-yml/rules/flow-sequence-bracket-spacing.html) | enforce consistent spacing inside flow sequence brackets | :wrench: |  | :star: |
 | [yml/key-spacing](https://ota-meshi.github.io/eslint-plugin-yml/rules/key-spacing.html) | enforce consistent spacing between keys and values in mapping pairs | :wrench: |  | :star: |
 | [yml/no-irregular-whitespace](https://ota-meshi.github.io/eslint-plugin-yml/rules/no-irregular-whitespace.html) | disallow irregular whitespace |  | :star: | :star: |
+| [yml/no-multiple-empty-lines](https://ota-meshi.github.io/eslint-plugin-yml/rules/no-multiple-empty-lines.html) | disallow multiple empty lines | :wrench: |  |  |
 | [yml/sort-keys](https://ota-meshi.github.io/eslint-plugin-yml/rules/sort-keys.html) | require mapping keys to be sorted | :wrench: |  |  |
 | [yml/spaced-comment](https://ota-meshi.github.io/eslint-plugin-yml/rules/spaced-comment.html) | enforce consistent spacing after the `#` in a comment | :wrench: |  | :star: |
 

package/lib/configs/prettier.d.ts

@@ -9,6 +9,7 @@ declare const _default: {
         "yml/flow-sequence-bracket-spacing": string;
         "yml/indent": string;
         "yml/key-spacing": string;
+        "yml/no-multiple-empty-lines": string;
         "yml/quotes": string;
     };
 };

package/lib/configs/prettier.js

@@ -16,6 +16,7 @@ module.exports = {
         "yml/flow-sequence-bracket-spacing": "off",
         "yml/indent": "off",
         "yml/key-spacing": "off",
+        "yml/no-multiple-empty-lines": "off",
         "yml/quotes": "off",
     },
 };

package/lib/index.d.ts

@@ -60,6 +60,7 @@ declare const _default: {
                 "yml/flow-sequence-bracket-spacing": string;
                 "yml/indent": string;
                 "yml/key-spacing": string;
+                "yml/no-multiple-empty-lines": string;
                 "yml/quotes": string;
             };
         };

package/lib/rules/block-mapping-question-indicator-newline.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const ast_utils_1 = require("../utils/ast-utils");
-exports.default = utils_1.createRule("block-mapping-question-indicator-newline", {
+exports.default = (0, utils_1.createRule)("block-mapping-question-indicator-newline", {
     meta: {
         docs: {
             description: "enforce consistent line breaks after `?` indicator",
@@ -39,7 +39,7 @@ exports.default = utils_1.createRule("block-mapping-question-indicator-newline",
                         continue;
                     }
                     const question = sourceCode.getFirstToken(pair);
-                    if (!question || !ast_utils_1.isQuestion(question)) {
+                    if (!question || !(0, ast_utils_1.isQuestion)(question)) {
                         continue;
                     }
                     const hasNewline = question.loc.end.line < key.loc.start.line;

package/lib/rules/block-mapping.js

@@ -25,7 +25,7 @@ function parseOptions(option) {
     }
     return opt;
 }
-exports.default = utils_1.createRule("block-mapping", {
+exports.default = (0, utils_1.createRule)("block-mapping", {
     meta: {
         docs: {
             description: "require or disallow block style mappings.",
@@ -130,11 +130,11 @@ exports.default = utils_1.createRule("block-mapping", {
                     if (optionType === "never") {
                         return;
                     }
-                    if (yaml_1.isKeyNode(node)) {
+                    if ((0, yaml_1.isKeyNode)(node)) {
                         return;
                     }
                     const canFix = canFixToBlock(mappingInfo, node) &&
-                        !yaml_1.hasTabIndent(context);
+                        !(0, yaml_1.hasTabIndent)(context);
                     context.report({
                         loc: node.loc,
                         messageId: "required",
@@ -147,7 +147,7 @@ exports.default = utils_1.createRule("block-mapping", {
                         return;
                     }
                     const canFix = canFixToFlow(mappingInfo, node) &&
-                        !yaml_1.hasTabIndent(context);
+                        !(0, yaml_1.hasTabIndent)(context);
                     context.report({
                         loc: node.loc,
                         messageId: "disallow",
@@ -182,8 +182,8 @@ function canFixToFlow(mappingInfo, node) {
         return false;
     }
     for (const pair of node.pairs) {
-        const value = yaml_1.unwrapMeta(pair.value);
-        const key = yaml_1.unwrapMeta(pair.key);
+        const value = (0, yaml_1.unwrapMeta)(pair.value);
+        const key = (0, yaml_1.unwrapMeta)(pair.key);
         if (value && value.type === "YAMLScalar" && value.style === "plain") {
             if (value.loc.start.line < value.loc.end.line) {
                 return false;
@@ -214,7 +214,7 @@ function buildFixFlowToBlock(node, context) {
         if ((open === null || open === void 0 ? void 0 : open.value) !== "{" || (close === null || close === void 0 ? void 0 : close.value) !== "}") {
             return;
         }
-        const expectIndent = yaml_1.calcExpectIndentForPairs(node, context);
+        const expectIndent = (0, yaml_1.calcExpectIndentForPairs)(node, context);
         if (expectIndent == null) {
             return;
         }
@@ -234,7 +234,7 @@ function buildFixFlowToBlock(node, context) {
         for (const pair of node.pairs) {
             const prevToken = sourceCode.getTokenBefore(pair, {
                 includeComments: true,
-                filter: (token) => !ast_utils_1.isComma(token),
+                filter: (token) => !(0, ast_utils_1.isComma)(token),
             });
             yield* removeComma(prev, prevToken);
             yield fixer.replaceTextRange([prevToken.range[1], pair.range[0]], `\n${expectIndent}`);
@@ -245,7 +245,7 @@ function buildFixFlowToBlock(node, context) {
                 }).range[0]) {
                 yield fixer.insertTextAfter(colonToken, " ");
             }
-            yield* yaml_1.processIndentFix(fixer, expectIndent, pair.value, context);
+            yield* (0, yaml_1.processIndentFix)(fixer, expectIndent, pair.value, context);
             prev = pair;
         }
         yield* removeComma(prev, close);
@@ -254,7 +254,7 @@ function buildFixFlowToBlock(node, context) {
             for (const token of sourceCode.getTokensBetween(a, b, {
                 includeComments: true,
             })) {
-                if (ast_utils_1.isComma(token)) {
+                if ((0, ast_utils_1.isComma)(token)) {
                     yield fixer.remove(token);
                 }
             }

package/lib/rules/block-sequence-hyphen-indicator-newline.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const ast_utils_1 = require("../utils/ast-utils");
-exports.default = utils_1.createRule("block-sequence-hyphen-indicator-newline", {
+exports.default = (0, utils_1.createRule)("block-sequence-hyphen-indicator-newline", {
     meta: {
         docs: {
             description: "enforce consistent line breaks after `-` indicator",
@@ -37,7 +37,7 @@ exports.default = utils_1.createRule("block-sequence-hyphen-indicator-newline",
         const nestedHyphenStyle = ((_a = context.options[1]) === null || _a === void 0 ? void 0 : _a.nestedHyphen) || "always";
         function getStyleOption(hyphen) {
             const next = sourceCode.getTokenAfter(hyphen);
-            if (next && ast_utils_1.isHyphen(next)) {
+            if (next && (0, ast_utils_1.isHyphen)(next)) {
                 return nestedHyphenStyle;
             }
             return style;

package/lib/rules/block-sequence.js

@@ -25,7 +25,7 @@ function parseOptions(option) {
     }
     return opt;
 }
-exports.default = utils_1.createRule("block-sequence", {
+exports.default = (0, utils_1.createRule)("block-sequence", {
     meta: {
         docs: {
             description: "require or disallow block style sequences.",
@@ -130,10 +130,10 @@ exports.default = utils_1.createRule("block-sequence", {
                     if (optionType === "never") {
                         return;
                     }
-                    if (yaml_1.isKeyNode(node)) {
+                    if ((0, yaml_1.isKeyNode)(node)) {
                         return;
                     }
-                    const canFix = canFixToBlock(sequenceInfo, node, context.getSourceCode()) && !yaml_1.hasTabIndent(context);
+                    const canFix = canFixToBlock(sequenceInfo, node, context.getSourceCode()) && !(0, yaml_1.hasTabIndent)(context);
                     context.report({
                         loc: node.loc,
                         messageId: "required",
@@ -146,7 +146,7 @@ exports.default = utils_1.createRule("block-sequence", {
                         return;
                     }
                     const canFix = canFixToFlow(sequenceInfo, node, context) &&
-                        !yaml_1.hasTabIndent(context);
+                        !(0, yaml_1.hasTabIndent)(context);
                     context.report({
                         loc: node.loc,
                         messageId: "disallow",
@@ -197,17 +197,17 @@ function canFixToFlow(sequenceInfo, node, context) {
         return false;
     }
     if (node.parent.type === "YAMLWithMeta") {
-        const metaIndent = yaml_1.getActualIndent(node.parent, context);
+        const metaIndent = (0, yaml_1.getActualIndent)(node.parent, context);
         if (metaIndent != null) {
             for (let line = node.loc.start.line; line <= node.loc.end.line; line++) {
-                if (yaml_1.compareIndent(metaIndent, yaml_1.getActualIndentFromLine(line, context)) > 0) {
+                if ((0, yaml_1.compareIndent)(metaIndent, (0, yaml_1.getActualIndentFromLine)(line, context)) > 0) {
                     return false;
                 }
             }
         }
     }
     for (const entry of node.entries) {
-        const value = yaml_1.unwrapMeta(entry);
+        const value = (0, yaml_1.unwrapMeta)(entry);
         if (value && value.type === "YAMLScalar" && value.style === "plain") {
             if (value.strValue.includes(",")) {
                 return false;
@@ -224,7 +224,7 @@ function buildFixFlowToBlock(node, context) {
         if ((open === null || open === void 0 ? void 0 : open.value) !== "[" || (close === null || close === void 0 ? void 0 : close.value) !== "]") {
             return;
         }
-        const expectIndent = yaml_1.calcExpectIndentForEntries(node, context);
+        const expectIndent = (0, yaml_1.calcExpectIndentForEntries)(node, context);
         if (expectIndent == null) {
             return;
         }
@@ -244,7 +244,7 @@ function buildFixFlowToBlock(node, context) {
         for (const entry of node.entries) {
             const prevToken = sourceCode.getTokenBefore(entry, {
                 includeComments: true,
-                filter: (token) => !ast_utils_1.isComma(token),
+                filter: (token) => !(0, ast_utils_1.isComma)(token),
             });
             yield* removeComma(prev, prevToken);
             yield fixer.replaceTextRange([prevToken.range[1], entry.range[0]], `\n${expectIndent}- `);
@@ -257,33 +257,33 @@ function buildFixFlowToBlock(node, context) {
             for (const token of sourceCode.getTokensBetween(a, b, {
                 includeComments: true,
             })) {
-                if (ast_utils_1.isComma(token)) {
+                if ((0, ast_utils_1.isComma)(token)) {
                     yield fixer.remove(token);
                 }
             }
         }
         function* processEntryIndent(baseIndent, entry) {
             if (entry.type === "YAMLWithMeta" && entry.value) {
-                yield* yaml_1.processIndentFix(fixer, baseIndent, entry.value, context);
+                yield* (0, yaml_1.processIndentFix)(fixer, baseIndent, entry.value, context);
             }
             else if (entry.type === "YAMLMapping") {
                 for (const p of entry.pairs) {
                     if (p.range[0] === entry.range[0]) {
                         if (p.value) {
-                            yield* yaml_1.processIndentFix(fixer, baseIndent, p.value, context);
+                            yield* (0, yaml_1.processIndentFix)(fixer, baseIndent, p.value, context);
                         }
                     }
                     else {
-                        yield* yaml_1.processIndentFix(fixer, baseIndent, p, context);
+                        yield* (0, yaml_1.processIndentFix)(fixer, baseIndent, p, context);
                     }
                 }
                 if (entry.style === "flow") {
                     const close = sourceCode.getLastToken(entry);
                     if (close.value === "}") {
-                        const actualIndent = yaml_1.getActualIndent(close, context);
+                        const actualIndent = (0, yaml_1.getActualIndent)(close, context);
                         if (actualIndent != null &&
-                            yaml_1.compareIndent(actualIndent, baseIndent) < 0) {
-                            yield yaml_1.fixIndent(fixer, sourceCode, baseIndent, close);
+                            (0, yaml_1.compareIndent)(actualIndent, baseIndent) < 0) {
+                            yield (0, yaml_1.fixIndent)(fixer, sourceCode, baseIndent, close);
                         }
                     }
                 }
@@ -293,7 +293,7 @@ function buildFixFlowToBlock(node, context) {
                     if (!e) {
                         continue;
                     }
-                    yield* yaml_1.processIndentFix(fixer, baseIndent, e, context);
+                    yield* (0, yaml_1.processIndentFix)(fixer, baseIndent, e, context);
                 }
             }
         }

package/lib/rules/flow-mapping-curly-newline.js

@@ -56,7 +56,7 @@ function areLineBreaksRequired(node, options, first, last) {
             objectProperties.length > 0 &&
             first.loc.start.line !== last.loc.end.line));
 }
-exports.default = utils_1.createRule("flow-mapping-curly-newline", {
+exports.default = (0, utils_1.createRule)("flow-mapping-curly-newline", {
     meta: {
         docs: {
             description: "enforce consistent line breaks inside braces",
@@ -81,7 +81,7 @@ exports.default = utils_1.createRule("flow-mapping-curly-newline", {
         const sourceCode = context.getSourceCode();
         const options = normalizeOptionValue(context.options[0]);
         function check(node) {
-            if (yaml_1.isKeyNode(node)) {
+            if ((0, yaml_1.isKeyNode)(node)) {
                 return;
             }
             const openBrace = sourceCode.getFirstToken(node, (token) => token.value === "{");
@@ -93,37 +93,37 @@ exports.default = utils_1.createRule("flow-mapping-curly-newline", {
                 includeComments: true,
             });
             const needsLineBreaks = areLineBreaksRequired(node, options, first, last);
-            const hasCommentsFirstToken = ast_utils_1.isCommentToken(first);
-            const hasCommentsLastToken = ast_utils_1.isCommentToken(last);
-            const hasQuestionsLastToken = ast_utils_1.isQuestion(last);
+            const hasCommentsFirstToken = (0, ast_utils_1.isCommentToken)(first);
+            const hasCommentsLastToken = (0, ast_utils_1.isCommentToken)(last);
+            const hasQuestionsLastToken = (0, ast_utils_1.isQuestion)(last);
             first = sourceCode.getTokenAfter(openBrace);
             last = sourceCode.getTokenBefore(closeBrace);
             if (needsLineBreaks) {
-                if (ast_utils_1.isTokenOnSameLine(openBrace, first)) {
+                if ((0, ast_utils_1.isTokenOnSameLine)(openBrace, first)) {
                     context.report({
                         messageId: "expectedLinebreakAfterOpeningBrace",
                         node,
                         loc: openBrace.loc,
                         fix(fixer) {
                             if (hasCommentsFirstToken ||
-                                yaml_1.hasTabIndent(context)) {
+                                (0, yaml_1.hasTabIndent)(context)) {
                                 return null;
                             }
-                            const indent = yaml_1.incIndent(yaml_1.getActualIndentFromLine(openBrace.loc.start.line, context), context);
+                            const indent = (0, yaml_1.incIndent)((0, yaml_1.getActualIndentFromLine)(openBrace.loc.start.line, context), context);
                             return fixer.insertTextAfter(openBrace, `\n${indent}`);
                         },
                     });
                 }
-                if (ast_utils_1.isTokenOnSameLine(last, closeBrace)) {
+                if ((0, ast_utils_1.isTokenOnSameLine)(last, closeBrace)) {
                     context.report({
                         messageId: "expectedLinebreakBeforeClosingBrace",
                         node,
                         loc: closeBrace.loc,
                         fix(fixer) {
-                            if (hasCommentsLastToken || yaml_1.hasTabIndent(context)) {
+                            if (hasCommentsLastToken || (0, yaml_1.hasTabIndent)(context)) {
                                 return null;
                             }
-                            const indent = yaml_1.getActualIndentFromLine(closeBrace.loc.start.line, context);
+                            const indent = (0, yaml_1.getActualIndentFromLine)(closeBrace.loc.start.line, context);
                             return fixer.insertTextBefore(closeBrace, `\n${indent}`);
                         },
                     });
@@ -131,8 +131,8 @@ exports.default = utils_1.createRule("flow-mapping-curly-newline", {
             }
             else {
                 const consistent = options.consistent;
-                const hasLineBreakBetweenOpenBraceAndFirst = !ast_utils_1.isTokenOnSameLine(openBrace, first);
-                const hasLineBreakBetweenCloseBraceAndLast = !ast_utils_1.isTokenOnSameLine(last, closeBrace);
+                const hasLineBreakBetweenOpenBraceAndFirst = !(0, ast_utils_1.isTokenOnSameLine)(openBrace, first);
+                const hasLineBreakBetweenCloseBraceAndLast = !(0, ast_utils_1.isTokenOnSameLine)(last, closeBrace);
                 if ((!consistent && hasLineBreakBetweenOpenBraceAndFirst) ||
                     (consistent &&
                         hasLineBreakBetweenOpenBraceAndFirst &&
@@ -143,7 +143,7 @@ exports.default = utils_1.createRule("flow-mapping-curly-newline", {
                         loc: openBrace.loc,
                         fix(fixer) {
                             if (hasCommentsFirstToken ||
-                                yaml_1.hasTabIndent(context)) {
+                                (0, yaml_1.hasTabIndent)(context)) {
                                 return null;
                             }
                             return fixer.removeRange([
@@ -165,7 +165,7 @@ exports.default = utils_1.createRule("flow-mapping-curly-newline", {
                         node,
                         loc: closeBrace.loc,
                         fix(fixer) {
-                            if (hasCommentsLastToken || yaml_1.hasTabIndent(context)) {
+                            if (hasCommentsLastToken || (0, yaml_1.hasTabIndent)(context)) {
                                 return null;
                             }
                             return fixer.removeRange([

package/lib/rules/flow-mapping-curly-spacing.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-const coreRule = utils_1.getCoreRule("object-curly-spacing");
-exports.default = utils_1.createRule("flow-mapping-curly-spacing", {
+const coreRule = (0, utils_1.getCoreRule)("object-curly-spacing");
+exports.default = (0, utils_1.createRule)("flow-mapping-curly-spacing", {
     meta: {
         docs: {
             description: "enforce consistent spacing inside braces",
@@ -11,6 +11,7 @@ exports.default = utils_1.createRule("flow-mapping-curly-spacing", {
             layout: true,
         },
         fixable: coreRule.meta.fixable,
+        hasSuggestions: coreRule.meta.hasSuggestions,
         schema: coreRule.meta.schema,
         messages: coreRule.meta.messages,
         type: coreRule.meta.type,
@@ -19,13 +20,13 @@ exports.default = utils_1.createRule("flow-mapping-curly-spacing", {
         if (!context.parserServices.isYAML) {
             return {};
         }
-        return utils_1.defineWrapperListener(coreRule, context, {
+        return (0, utils_1.defineWrapperListener)(coreRule, context, {
             options: context.options,
             createListenerProxy(listener) {
                 return {
                     YAMLMapping(node) {
                         if (node.style === "flow") {
-                            listener.ObjectExpression(utils_1.getProxyNode(node, {
+                            listener.ObjectExpression((0, utils_1.getProxyNode)(node, {
                                 type: "ObjectExpression",
                                 get properties() {
                                     return node.pairs;

package/lib/rules/flow-sequence-bracket-newline.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const yaml_1 = require("../utils/yaml");
 const ast_utils_1 = require("../utils/ast-utils");
-exports.default = utils_1.createRule("flow-sequence-bracket-newline", {
+exports.default = (0, utils_1.createRule)("flow-sequence-bracket-newline", {
     meta: {
         docs: {
             description: "enforce linebreaks after opening and before closing flow sequence brackets",
@@ -81,13 +81,13 @@ exports.default = utils_1.createRule("flow-sequence-bracket-newline", {
                 loc: token.loc,
                 messageId: "unexpectedOpeningLinebreak",
                 fix(fixer) {
-                    if (yaml_1.hasTabIndent(context)) {
+                    if ((0, yaml_1.hasTabIndent)(context)) {
                         return null;
                     }
                     const nextToken = sourceCode.getTokenAfter(token, {
                         includeComments: true,
                     });
-                    if (ast_utils_1.isCommentToken(nextToken)) {
+                    if ((0, ast_utils_1.isCommentToken)(nextToken)) {
                         return null;
                     }
                     return fixer.removeRange([
@@ -103,13 +103,13 @@ exports.default = utils_1.createRule("flow-sequence-bracket-newline", {
                 loc: token.loc,
                 messageId: "unexpectedClosingLinebreak",
                 fix(fixer) {
-                    if (yaml_1.hasTabIndent(context)) {
+                    if ((0, yaml_1.hasTabIndent)(context)) {
                         return null;
                     }
                     const previousToken = sourceCode.getTokenBefore(token, {
                         includeComments: true,
                     });
-                    if (ast_utils_1.isCommentToken(previousToken)) {
+                    if ((0, ast_utils_1.isCommentToken)(previousToken)) {
                         return null;
                     }
                     return fixer.removeRange([
@@ -125,10 +125,10 @@ exports.default = utils_1.createRule("flow-sequence-bracket-newline", {
                 loc: token.loc,
                 messageId: "missingOpeningLinebreak",
                 fix(fixer) {
-                    if (yaml_1.hasTabIndent(context)) {
+                    if ((0, yaml_1.hasTabIndent)(context)) {
                         return null;
                     }
-                    const indent = yaml_1.incIndent(yaml_1.getActualIndentFromLine(token.loc.start.line, context), context);
+                    const indent = (0, yaml_1.incIndent)((0, yaml_1.getActualIndentFromLine)(token.loc.start.line, context), context);
                     return fixer.insertTextAfter(token, `\n${indent}`);
                 },
             });
@@ -139,16 +139,16 @@ exports.default = utils_1.createRule("flow-sequence-bracket-newline", {
                 loc: token.loc,
                 messageId: "missingClosingLinebreak",
                 fix(fixer) {
-                    if (yaml_1.hasTabIndent(context)) {
+                    if ((0, yaml_1.hasTabIndent)(context)) {
                         return null;
                     }
-                    const indent = yaml_1.getActualIndentFromLine(token.loc.start.line, context);
+                    const indent = (0, yaml_1.getActualIndentFromLine)(token.loc.start.line, context);
                     return fixer.insertTextBefore(token, `\n${indent}`);
                 },
             });
         }
         function check(node) {
-            if (yaml_1.isKeyNode(node)) {
+            if ((0, yaml_1.isKeyNode)(node)) {
                 return;
             }
             const elements = node.entries;
@@ -176,18 +176,18 @@ exports.default = utils_1.createRule("flow-sequence-bracket-newline", {
                 (options.consistent &&
                     openBracket.loc.end.line !== first.loc.start.line);
             if (needsLinebreaks) {
-                if (ast_utils_1.isTokenOnSameLine(openBracket, first)) {
+                if ((0, ast_utils_1.isTokenOnSameLine)(openBracket, first)) {
                     reportRequiredBeginningLinebreak(node, openBracket);
                 }
-                if (ast_utils_1.isTokenOnSameLine(last, closeBracket)) {
+                if ((0, ast_utils_1.isTokenOnSameLine)(last, closeBracket)) {
                     reportRequiredEndingLinebreak(node, closeBracket);
                 }
             }
             else {
-                if (!ast_utils_1.isTokenOnSameLine(openBracket, first)) {
+                if (!(0, ast_utils_1.isTokenOnSameLine)(openBracket, first)) {
                     reportNoBeginningLinebreak(node, openBracket);
                 }
-                if (!ast_utils_1.isTokenOnSameLine(last, closeBracket)) {
+                if (!(0, ast_utils_1.isTokenOnSameLine)(last, closeBracket)) {
                     reportNoEndingLinebreak(node, closeBracket);
                 }
             }

package/lib/rules/flow-sequence-bracket-spacing.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-const coreRule = utils_1.getCoreRule("array-bracket-spacing");
-exports.default = utils_1.createRule("flow-sequence-bracket-spacing", {
+const coreRule = (0, utils_1.getCoreRule)("array-bracket-spacing");
+exports.default = (0, utils_1.createRule)("flow-sequence-bracket-spacing", {
     meta: {
         docs: {
             description: "enforce consistent spacing inside flow sequence brackets",
@@ -11,6 +11,7 @@ exports.default = utils_1.createRule("flow-sequence-bracket-spacing", {
             layout: true,
         },
         fixable: coreRule.meta.fixable,
+        hasSuggestions: coreRule.meta.hasSuggestions,
         schema: coreRule.meta.schema,
         messages: coreRule.meta.messages,
         type: coreRule.meta.type,
@@ -19,13 +20,13 @@ exports.default = utils_1.createRule("flow-sequence-bracket-spacing", {
         if (!context.parserServices.isYAML) {
             return {};
         }
-        return utils_1.defineWrapperListener(coreRule, context, {
+        return (0, utils_1.defineWrapperListener)(coreRule, context, {
             options: context.options,
             createListenerProxy(listener) {
                 return {
                     YAMLSequence(node) {
                         if (node.style === "flow") {
-                            listener.ArrayExpression(utils_1.getProxyNode(node, {
+                            listener.ArrayExpression((0, utils_1.getProxyNode)(node, {
                                 type: "ArrayExpression",
                                 get elements() {
                                     return node.entries;

package/lib/rules/indent.js

@@ -6,7 +6,7 @@ const ast_utils_1 = require("../utils/ast-utils");
 const ITERATION_OPTS = Object.freeze({
     includeComments: true,
 });
-exports.default = utils_1.createRule("indent", {
+exports.default = (0, utils_1.createRule)("indent", {
     meta: {
         docs: {
             description: "enforce consistent indentation",
@@ -30,10 +30,10 @@ exports.default = utils_1.createRule("indent", {
         if (!context.parserServices.isYAML) {
             return {};
         }
-        if (yaml_1.hasTabIndent(context)) {
+        if ((0, yaml_1.hasTabIndent)(context)) {
             return {};
         }
-        const numOfIndent = yaml_1.getNumOfIndent(context, context.options[0]);
+        const numOfIndent = (0, yaml_1.getNumOfIndent)(context, context.options[0]);
         const sourceCode = context.getSourceCode();
         const offsets = new Map();
         const marks = new Set();
@@ -141,7 +141,7 @@ exports.default = utils_1.createRule("indent", {
                 let keyToken = null;
                 let colonToken = null;
                 let valueToken = null;
-                if (ast_utils_1.isQuestion(pairFirst)) {
+                if ((0, ast_utils_1.isQuestion)(pairFirst)) {
                     questionToken = pairFirst;
                     marks.add(questionToken);
                 }
@@ -502,7 +502,7 @@ exports.default = utils_1.createRule("indent", {
                     };
                 }
                 const firstLineActualIndent = lineIndent.actualIndent;
-                for (let scalarLine = lineIndent.line + 1; scalarLine < scalarNode.loc.end.line; scalarLine++) {
+                for (let scalarLine = lineIndent.line + 1; scalarLine <= scalarNode.loc.end.line; scalarLine++) {
                     const actualLineIndent = getActualLineIndent(scalarLine);
                     if (actualLineIndent == null) {
                         continue;
@@ -579,6 +579,7 @@ exports.default = utils_1.createRule("indent", {
             }
         }
         function buildFix(lineIndent, lineIndents) {
+            var _a;
             const { line, expectedIndent } = lineIndent;
             const document = documents.find((doc) => doc.loc.start.line <= line && line <= doc.loc.end.line) || sourceCode.ast;
             let startLine = document.loc.start.line;
@@ -614,6 +615,21 @@ exports.default = utils_1.createRule("indent", {
                     break;
                 }
             }
+            for (let lineIndex = startLine; lineIndex <= endLine; lineIndex++) {
+                const li = lineIndents[lineIndex];
+                if (li === null || li === void 0 ? void 0 : li.indentBlockScalar) {
+                    const blockLiteral = li.indentBlockScalar.node;
+                    const diff = li.expectedIndent - li.actualIndent;
+                    const mark = sourceCode.getFirstToken(blockLiteral);
+                    const num = (_a = /\d+/u.exec(mark.value)) === null || _a === void 0 ? void 0 : _a[0];
+                    if (num != null) {
+                        const newIndent = Number(num) + diff;
+                        if (newIndent >= 10) {
+                            return null;
+                        }
+                    }
+                }
+            }
             return function* (fixer) {
                 let stacks = null;
                 for (let lineIndex = startLine; lineIndex <= endLine; lineIndex++) {