eslint-plugin-yml 1.17.0 → 1.19.0

package/lib/meta.d.ts

@@ -1,2 +1,2 @@
-export declare const name = "eslint-plugin-yml";
-export declare const version = "1.17.0";
+export declare const name: "eslint-plugin-yml";
+export declare const version: "1.19.0";

package/lib/meta.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = exports.name = void 0;
 exports.name = "eslint-plugin-yml";
-exports.version = "1.17.0";
+exports.version = "1.19.0";

package/lib/rules/indent.js

@@ -12,6 +12,7 @@ function parseOptions(context) {
     const numOfIndent = (0, yaml_1.getNumOfIndent)(context, indentOption);
     let indentBlockSequences = true;
     let indicatorValueIndent = numOfIndent;
+    let alignMultilineFlowScalars = false;
     if (objectOptions) {
         if (objectOptions.indentBlockSequences === false) {
             indentBlockSequences = false;
@@ -19,11 +20,15 @@ function parseOptions(context) {
         if (objectOptions.indicatorValueIndent != null) {
             indicatorValueIndent = objectOptions.indicatorValueIndent;
         }
+        if (objectOptions.alignMultilineFlowScalars != null) {
+            alignMultilineFlowScalars = objectOptions.alignMultilineFlowScalars;
+        }
     }
     return {
         numOfIndent,
         indentBlockSequences,
         indicatorValueIndent,
+        alignMultilineFlowScalars,
     };
 }
 exports.default = (0, index_1.createRule)("indent", {
@@ -48,6 +53,9 @@ exports.default = (0, index_1.createRule)("indent", {
                         type: "integer",
                         minimum: 2,
                     },
+                    alignMultilineFlowScalars: {
+                        type: "boolean",
+                    },
                 },
                 additionalProperties: false,
             },
@@ -66,7 +74,7 @@ exports.default = (0, index_1.createRule)("indent", {
         if ((0, yaml_1.hasTabIndent)(context)) {
             return {};
         }
-        const { numOfIndent, indentBlockSequences, indicatorValueIndent } = parseOptions(context);
+        const { numOfIndent, indentBlockSequences, indicatorValueIndent, alignMultilineFlowScalars, } = parseOptions(context);
         const indents = new Map();
         const indicators = new Set();
         const blockLiteralMarks = new Set();
@@ -451,7 +459,13 @@ exports.default = (0, index_1.createRule)("indent", {
                             processBlockLiteral(indent, scalarNode, lineIndent.lastScalar.expectedIndent);
                         }
                         else {
-                            processScalar(indent, scalarNode, lineIndent.lastScalar.expectedIndent);
+                            let expectedIndent = lineIndent.lastScalar.expectedIndent;
+                            if (alignMultilineFlowScalars) {
+                                if (!isBeginningToken(lineIndent.lastScalar.token)) {
+                                    expectedIndent = lineIndent.lastScalar.node.loc.start.column;
+                                }
+                            }
+                            processMultilineScalar(indent, scalarNode, expectedIndent);
                         }
                     }
                 }
@@ -568,7 +582,7 @@ exports.default = (0, index_1.createRule)("indent", {
                     };
                 }
             }
-            function processScalar(lineIndent, scalarNode, expectedIndent) {
+            function processMultilineScalar(lineIndent, scalarNode, expectedIndent) {
                 for (let scalarLine = lineIndent.line + 1; scalarLine <= scalarNode.loc.end.line; scalarLine++) {
                     const scalarActualIndent = getActualLineIndent(scalarLine);
                     if (scalarActualIndent == null) {

package/lib/rules/sort-keys.js

@@ -7,6 +7,7 @@ const natural_compare_1 = __importDefault(require("natural-compare"));
 const index_1 = require("../utils/index");
 const ast_utils_1 = require("../utils/ast-utils");
 const compat_1 = require("../utils/compat");
+const calc_shortest_edit_script_1 = require("../utils/calc-shortest-edit-script");
 function isNewLine(char) {
     return (char === "\n" || char === "\r" || char === "\u2028" || char === "\u2029");
 }
@@ -306,7 +307,8 @@ exports.default = (0, index_1.createRule)("sort-keys", {
             ],
         },
         messages: {
-            sortKeys: "Expected mapping keys to be in {{orderText}} order. '{{thisName}}' should be before '{{prevName}}'.",
+            shouldBeBefore: "Expected mapping keys to be in {{orderText}} order. '{{thisName}}' should be before '{{targetName}}'.",
+            shouldBeAfter: "Expected mapping keys to be in {{orderText}} order. '{{thisName}}' should be after '{{targetName}}'.",
         },
         type: "suggestion",
     },
@@ -317,16 +319,18 @@ exports.default = (0, index_1.createRule)("sort-keys", {
             return {};
         }
         const parsedOptions = parseOptions(context.options, sourceCode);
-        function isValidOrder(prevData, thisData, option) {
-            if (option.isValidOrder(prevData, thisData)) {
-                return true;
-            }
-            for (const aliasName of thisData.anchorAlias.aliases) {
+        function shouldKeepOrder(prevData, nextData) {
+            if ((prevData.anchorAlias.aliases.size === 0 &&
+                prevData.anchorAlias.anchors.size === 0) ||
+                (nextData.anchorAlias.aliases.size === 0 &&
+                    nextData.anchorAlias.anchors.size === 0))
+                return false;
+            for (const aliasName of nextData.anchorAlias.aliases) {
                 if (prevData.anchorAlias.anchors.has(aliasName)) {
                     return true;
                 }
             }
-            for (const anchorName of thisData.anchorAlias.anchors) {
+            for (const anchorName of nextData.anchorAlias.anchors) {
                 if (prevData.anchorAlias.aliases.has(anchorName)) {
                     return true;
                 }
@@ -339,55 +343,176 @@ exports.default = (0, index_1.createRule)("sort-keys", {
             }
             return option.ignore(data);
         }
-        function verifyPair(data, option) {
-            if (ignore(data, option)) {
-                return;
-            }
-            const prevList = [];
-            let currTarget = data;
-            let prevTarget;
-            while ((prevTarget = currTarget.getPrev())) {
-                if (option.allowLineSeparatedGroups) {
-                    if (hasBlankLine(prevTarget, currTarget)) {
-                        break;
-                    }
+        function groupingPairs(pairs, option) {
+            const groups = [];
+            let group = [];
+            let prev = null;
+            for (const pair of pairs) {
+                if (ignore(pair, option)) {
+                    prev = pair;
+                    continue;
                 }
-                if (!ignore(prevTarget, option)) {
-                    prevList.push(prevTarget);
+                if (prev &&
+                    option.allowLineSeparatedGroups &&
+                    hasBlankLine(prev, pair)) {
+                    if (group.length > 0) {
+                        groups.push(group);
+                        group = [];
+                    }
                 }
-                currTarget = prevTarget;
+                group.push(pair);
+                prev = pair;
             }
-            if (prevList.length === 0) {
-                return;
+            if (group.length > 0) {
+                groups.push(group);
             }
-            const prev = prevList[0];
-            if (!isValidOrder(prev, data, option)) {
-                context.report({
-                    loc: data.reportLoc,
-                    messageId: "sortKeys",
-                    data: {
-                        thisName: data.name,
-                        prevName: prev.name,
-                        orderText: option.orderText,
-                    },
-                    *fix(fixer) {
-                        let moveTarget = prevList[0];
-                        for (const prev of prevList) {
-                            if (isValidOrder(prev, data, option)) {
-                                break;
+            return groups;
+        }
+        function bubbleSort(pairs, option) {
+            const l = pairs.length;
+            const result = [...pairs];
+            let swapped;
+            do {
+                swapped = false;
+                for (let nextIndex = 1; nextIndex < l; nextIndex++) {
+                    const prevIndex = nextIndex - 1;
+                    if (option.isValidOrder(result[prevIndex], result[nextIndex]) ||
+                        shouldKeepOrder(result[prevIndex], result[nextIndex]))
+                        continue;
+                    [result[prevIndex], result[nextIndex]] = [
+                        result[nextIndex],
+                        result[prevIndex],
+                    ];
+                    swapped = true;
+                }
+            } while (swapped);
+            return result;
+        }
+        function verifyPairs(pairs, option) {
+            const sorted = bubbleSort(pairs, option);
+            const editScript = (0, calc_shortest_edit_script_1.calcShortestEditScript)(pairs, sorted);
+            for (let index = 0; index < editScript.length; index++) {
+                const edit = editScript[index];
+                if (edit.type !== "delete")
+                    continue;
+                const insertEditIndex = editScript.findIndex((e) => e.type === "insert" && e.b === edit.a);
+                if (insertEditIndex === -1) {
+                    continue;
+                }
+                if (index < insertEditIndex) {
+                    const target = findInsertAfterTarget(edit.a, insertEditIndex);
+                    if (!target) {
+                        continue;
+                    }
+                    context.report({
+                        loc: edit.a.reportLoc,
+                        messageId: "shouldBeAfter",
+                        data: {
+                            thisName: edit.a.name,
+                            targetName: target.name,
+                            orderText: option.orderText,
+                        },
+                        *fix(fixer) {
+                            if (edit.a.mapping.node.style === "flow") {
+                                yield* fixToMoveDownForFlow(fixer, edit.a, target);
                             }
                             else {
-                                moveTarget = prev;
+                                yield* fixToMoveDownForBlock(fixer, edit.a, target);
                             }
+                        },
+                    });
+                }
+                else {
+                    const target = findInsertBeforeTarget(edit.a, insertEditIndex);
+                    if (!target) {
+                        continue;
+                    }
+                    context.report({
+                        loc: edit.a.reportLoc,
+                        messageId: "shouldBeBefore",
+                        data: {
+                            thisName: edit.a.name,
+                            targetName: target.name,
+                            orderText: option.orderText,
+                        },
+                        *fix(fixer) {
+                            if (edit.a.mapping.node.style === "flow") {
+                                yield* fixToMoveUpForFlow(fixer, edit.a, target);
+                            }
+                            else {
+                                yield* fixToMoveUpForBlock(fixer, edit.a, target);
+                            }
+                        },
+                    });
+                }
+            }
+            function findInsertAfterTarget(pair, insertEditIndex) {
+                let candidate = null;
+                for (let index = insertEditIndex - 1; index >= 0; index--) {
+                    const edit = editScript[index];
+                    if (edit.type === "delete" && edit.a === pair)
+                        break;
+                    if (edit.type !== "common")
+                        continue;
+                    candidate = edit.a;
+                    break;
+                }
+                const pairIndex = pairs.indexOf(pair);
+                if (candidate) {
+                    for (let index = pairIndex + 1; index < pairs.length; index++) {
+                        const element = pairs[index];
+                        if (element === candidate)
+                            return candidate;
+                        if (shouldKeepOrder(pair, element)) {
+                            break;
                         }
-                        if (data.mapping.node.style === "flow") {
-                            yield* fixForFlow(fixer, data, moveTarget);
-                        }
-                        else {
-                            yield* fixForBlock(fixer, data, moveTarget);
+                    }
+                }
+                let lastTarget = null;
+                for (let index = pairIndex + 1; index < pairs.length; index++) {
+                    const element = pairs[index];
+                    if (option.isValidOrder(element, pair) &&
+                        !shouldKeepOrder(pair, element)) {
+                        lastTarget = element;
+                        continue;
+                    }
+                    return lastTarget;
+                }
+                return lastTarget;
+            }
+            function findInsertBeforeTarget(pair, insertEditIndex) {
+                let candidate = null;
+                for (let index = insertEditIndex + 1; index < editScript.length; index++) {
+                    const edit = editScript[index];
+                    if (edit.type === "delete" && edit.a === pair)
+                        break;
+                    if (edit.type !== "common")
+                        continue;
+                    candidate = edit.a;
+                    break;
+                }
+                const pairIndex = pairs.indexOf(pair);
+                if (candidate) {
+                    for (let index = pairIndex - 1; index >= 0; index--) {
+                        const element = pairs[index];
+                        if (element === candidate)
+                            return candidate;
+                        if (shouldKeepOrder(element, pair)) {
+                            break;
                         }
-                    },
-                });
+                    }
+                }
+                let lastTarget = null;
+                for (let index = pairIndex - 1; index >= 0; index--) {
+                    const element = pairs[index];
+                    if (option.isValidOrder(pair, element) &&
+                        !shouldKeepOrder(element, pair)) {
+                        lastTarget = element;
+                        continue;
+                    }
+                    return lastTarget;
+                }
+                return lastTarget;
             }
         }
         function hasBlankLine(prev, next) {
@@ -444,12 +569,44 @@ exports.default = (0, index_1.createRule)("sort-keys", {
                 if (!option) {
                     return;
                 }
-                for (const pair of data.pairs) {
-                    verifyPair(pair, option);
+                for (const pairs of groupingPairs(data.pairs, option)) {
+                    verifyPairs(pairs, option);
                 }
             },
         };
-        function* fixForFlow(fixer, data, moveTarget) {
+        function* fixToMoveDownForFlow(fixer, data, moveTarget) {
+            const beforeToken = sourceCode.getTokenBefore(data.node);
+            let insertCode, removeRange, insertTargetToken;
+            const afterCommaToken = sourceCode.getTokenAfter(data.node);
+            if ((0, ast_utils_1.isComma)(afterCommaToken)) {
+                removeRange = [beforeToken.range[1], afterCommaToken.range[1]];
+                const moveTargetAfterToken = sourceCode.getTokenAfter(moveTarget.node);
+                if ((0, ast_utils_1.isComma)(moveTargetAfterToken)) {
+                    insertTargetToken = moveTargetAfterToken;
+                    insertCode = sourceCode.text.slice(...removeRange);
+                }
+                else {
+                    insertTargetToken = sourceCode.getLastToken(moveTarget.node);
+                    insertCode = sourceCode.text.slice(beforeToken.range[1], afterCommaToken.range[0]);
+                    insertCode = `,${insertCode}`;
+                }
+            }
+            else {
+                if ((0, ast_utils_1.isComma)(beforeToken)) {
+                    removeRange = [beforeToken.range[0], data.node.range[1]];
+                    insertCode = sourceCode.text.slice(...removeRange);
+                    insertTargetToken = sourceCode.getLastToken(moveTarget.node);
+                }
+                else {
+                    removeRange = [beforeToken.range[1], data.node.range[1]];
+                    insertCode = `,${sourceCode.text.slice(...removeRange)}`;
+                    insertTargetToken = sourceCode.getLastToken(moveTarget.node);
+                }
+            }
+            yield fixer.removeRange(removeRange);
+            yield fixer.insertTextAfterRange(insertTargetToken.range, insertCode);
+        }
+        function* fixToMoveUpForFlow(fixer, data, moveTarget) {
             const beforeCommaToken = sourceCode.getTokenBefore(data.node);
             let insertCode, removeRange, insertTargetToken;
             const afterCommaToken = sourceCode.getTokenAfter(data.node);
@@ -473,7 +630,39 @@ exports.default = (0, index_1.createRule)("sort-keys", {
             yield fixer.insertTextAfterRange(insertTargetToken.range, insertCode);
             yield fixer.removeRange(removeRange);
         }
-        function* fixForBlock(fixer, data, moveTarget) {
+        function* fixToMoveDownForBlock(fixer, data, moveTarget) {
+            const nodeLocs = getPairRangeForBlock(data.node);
+            const moveTargetLocs = getPairRangeForBlock(moveTarget.node);
+            if (nodeLocs.loc.start.column === 0) {
+                const removeRange = [
+                    getNewlineStartIndex(nodeLocs.range[0]),
+                    nodeLocs.range[1],
+                ];
+                const moveTargetRange = [
+                    getNewlineStartIndex(moveTargetLocs.range[0]),
+                    moveTargetLocs.range[1],
+                ];
+                const insertCode = sourceCode.text.slice(...removeRange);
+                yield fixer.removeRange(removeRange);
+                yield fixer.insertTextAfterRange(moveTargetRange, insertCode);
+            }
+            else {
+                const nextToken = sourceCode.getTokenAfter(data.node, {
+                    includeComments: true,
+                });
+                const removeRange = [data.node.range[0], nextToken.range[0]];
+                yield fixer.removeRange(removeRange);
+                const indentCode = sourceCode.text
+                    .slice(sourceCode.getIndexFromLoc({
+                    line: nodeLocs.loc.start.line,
+                    column: 0,
+                }), data.node.range[0])
+                    .replace(/\S/g, " ");
+                const insertCode = `\n${indentCode}${sourceCode.text.slice(data.node.range[0], nodeLocs.range[1])}`;
+                yield fixer.insertTextAfterRange(moveTargetLocs.range, insertCode);
+            }
+        }
+        function* fixToMoveUpForBlock(fixer, data, moveTarget) {
             const nodeLocs = getPairRangeForBlock(data.node);
             const moveTargetLocs = getPairRangeForBlock(moveTarget.node);
             if (moveTargetLocs.loc.start.column === 0) {
@@ -514,7 +703,7 @@ exports.default = (0, index_1.createRule)("sort-keys", {
             return 0;
         }
         function getPairRangeForBlock(node) {
-            let endOfRange, end;
+            let end;
             const afterToken = sourceCode.getTokenAfter(node, {
                 includeComments: true,
                 filter: (t) => !(0, ast_utils_1.isCommentToken)(t) || node.loc.end.line < t.loc.start.line,
@@ -525,14 +714,17 @@ exports.default = (0, index_1.createRule)("sort-keys", {
                     : node.loc.end.line;
                 const lineText = sourceCode.lines[line - 1];
                 end = {
-                    line,
-                    column: lineText.length,
+                    loc: { line, column: lineText.length },
+                    get index() {
+                        return sourceCode.getIndexFromLoc(this.loc);
+                    },
                 };
-                endOfRange = sourceCode.getIndexFromLoc(end);
             }
             else {
-                endOfRange = node.range[1];
-                end = node.loc.end;
+                end = {
+                    index: node.range[1],
+                    loc: node.loc.end,
+                };
             }
             const beforeToken = sourceCode.getTokenBefore(node);
             if (beforeToken) {
@@ -547,18 +739,15 @@ exports.default = (0, index_1.createRule)("sort-keys", {
                             : node.loc.start.line,
                         column: 0,
                     };
-                    const startOfRange = sourceCode.getIndexFromLoc(start);
                     return {
-                        range: [startOfRange, endOfRange],
-                        loc: { start, end },
+                        range: [sourceCode.getIndexFromLoc(start), end.index],
+                        loc: { start, end: end.loc },
                         indentColumn: next.loc.start.column,
                     };
                 }
-                const start = beforeToken.loc.end;
-                const startOfRange = beforeToken.range[1];
                 return {
-                    range: [startOfRange, endOfRange],
-                    loc: { start, end },
+                    range: [beforeToken.range[1], end.index],
+                    loc: { start: beforeToken.loc.end, end: end.loc },
                     indentColumn: node.range[0] - beforeToken.range[1],
                 };
             }
@@ -575,8 +764,8 @@ exports.default = (0, index_1.createRule)("sort-keys", {
                     };
                     const startOfRange = sourceCode.getIndexFromLoc(start);
                     return {
-                        range: [startOfRange, endOfRange],
-                        loc: { start, end },
+                        range: [startOfRange, end.index],
+                        loc: { start, end: end.loc },
                         indentColumn: next.loc.start.column,
                     };
                 }
@@ -588,8 +777,8 @@ exports.default = (0, index_1.createRule)("sort-keys", {
             };
             const startOfRange = sourceCode.getIndexFromLoc(start);
             return {
-                range: [startOfRange, endOfRange],
-                loc: { start, end },
+                range: [startOfRange, end.index],
+                loc: { start, end: end.loc },
                 indentColumn: node.loc.start.column,
             };
         }

package/lib/rules/sort-sequence-values.js

@@ -8,6 +8,7 @@ const index_1 = require("../utils/index");
 const ast_utils_1 = require("../utils/ast-utils");
 const yaml_eslint_parser_1 = require("yaml-eslint-parser");
 const compat_1 = require("../utils/compat");
+const calc_shortest_edit_script_1 = require("../utils/calc-shortest-edit-script");
 class YAMLEntryData {
     get reportLoc() {
         if (this.node) {
@@ -298,7 +299,8 @@ exports.default = (0, index_1.createRule)("sort-sequence-values", {
             minItems: 1,
         },
         messages: {
-            sortValues: "Expected sequence values to be in {{orderText}} order. '{{thisValue}}' should be before '{{prevValue}}'.",
+            shouldBeBefore: "Expected sequence values to be in {{orderText}} order. '{{thisValue}}' should be before '{{targetValue}}'.",
+            shouldBeAfter: "Expected sequence values to be in {{orderText}} order. '{{thisValue}}' should be after '{{targetValue}}'.",
         },
         type: "suggestion",
     },
@@ -309,62 +311,169 @@ exports.default = (0, index_1.createRule)("sort-sequence-values", {
             return {};
         }
         const parsedOptions = parseOptions(context.options, sourceCode);
-        function isValidOrder(prevData, thisData, option) {
-            if (option.isValidOrder(prevData, thisData)) {
-                return true;
-            }
-            for (const aliasName of thisData.anchorAlias.aliases) {
+        function shouldKeepOrder(prevData, nextData) {
+            if ((prevData.anchorAlias.aliases.size === 0 &&
+                prevData.anchorAlias.anchors.size === 0) ||
+                (nextData.anchorAlias.aliases.size === 0 &&
+                    nextData.anchorAlias.anchors.size === 0))
+                return false;
+            for (const aliasName of nextData.anchorAlias.aliases) {
                 if (prevData.anchorAlias.anchors.has(aliasName)) {
                     return true;
                 }
             }
-            for (const anchorName of thisData.anchorAlias.anchors) {
+            for (const anchorName of nextData.anchorAlias.anchors) {
                 if (prevData.anchorAlias.aliases.has(anchorName)) {
                     return true;
                 }
             }
             return false;
         }
-        function verifyArrayElement(data, option) {
-            if (option.ignore(data)) {
-                return;
-            }
-            const prevList = data.sequence.entries
-                .slice(0, data.index)
-                .reverse()
-                .filter((d) => !option.ignore(d));
-            if (prevList.length === 0) {
-                return;
-            }
-            const prev = prevList[0];
-            if (!isValidOrder(prev, data, option)) {
-                const reportLoc = data.reportLoc;
-                context.report({
-                    loc: reportLoc,
-                    messageId: "sortValues",
-                    data: {
-                        thisValue: toText(data),
-                        prevValue: toText(prev),
-                        orderText: option.orderText(data),
-                    },
-                    *fix(fixer) {
-                        let moveTarget = prevList[0];
-                        for (const prev of prevList) {
-                            if (isValidOrder(prev, data, option)) {
-                                break;
+        function bubbleSort(entries, option) {
+            const l = entries.length;
+            const result = [...entries];
+            let swapped;
+            do {
+                swapped = false;
+                for (let nextIndex = 1; nextIndex < l; nextIndex++) {
+                    const prevIndex = nextIndex - 1;
+                    if (option.isValidOrder(result[prevIndex], result[nextIndex]) ||
+                        shouldKeepOrder(result[prevIndex], result[nextIndex]))
+                        continue;
+                    [result[prevIndex], result[nextIndex]] = [
+                        result[nextIndex],
+                        result[prevIndex],
+                    ];
+                    swapped = true;
+                }
+            } while (swapped);
+            return result;
+        }
+        function verifyArrayElements(entries, option) {
+            const sorted = bubbleSort(entries, option);
+            const editScript = (0, calc_shortest_edit_script_1.calcShortestEditScript)(entries, sorted);
+            for (let index = 0; index < editScript.length; index++) {
+                const edit = editScript[index];
+                if (edit.type !== "delete")
+                    continue;
+                const insertEditIndex = editScript.findIndex((e) => e.type === "insert" && e.b === edit.a);
+                if (insertEditIndex === -1) {
+                    continue;
+                }
+                if (index < insertEditIndex) {
+                    const target = findInsertAfterTarget(edit.a, insertEditIndex);
+                    if (!target) {
+                        continue;
+                    }
+                    context.report({
+                        loc: edit.a.reportLoc,
+                        messageId: "shouldBeAfter",
+                        data: {
+                            thisValue: toText(edit.a),
+                            targetValue: toText(target),
+                            orderText: option.orderText(edit.a),
+                        },
+                        *fix(fixer) {
+                            if (edit.a.sequence.node.style === "flow") {
+                                yield* fixToMoveDownForFlow(fixer, edit.a, target);
                             }
                             else {
-                                moveTarget = prev;
+                                yield* fixToMoveDownForBlock(fixer, edit.a, target);
                             }
+                        },
+                    });
+                }
+                else {
+                    const target = findInsertBeforeTarget(edit.a, insertEditIndex);
+                    if (!target) {
+                        continue;
+                    }
+                    context.report({
+                        loc: edit.a.reportLoc,
+                        messageId: "shouldBeBefore",
+                        data: {
+                            thisValue: toText(edit.a),
+                            targetValue: toText(target),
+                            orderText: option.orderText(edit.a),
+                        },
+                        *fix(fixer) {
+                            if (edit.a.sequence.node.style === "flow") {
+                                yield* fixToMoveUpForFlow(fixer, edit.a, target);
+                            }
+                            else {
+                                yield* fixToMoveUpForBlock(fixer, edit.a, target);
+                            }
+                        },
+                    });
+                }
+            }
+            function findInsertAfterTarget(entry, insertEditIndex) {
+                let candidate = null;
+                for (let index = insertEditIndex - 1; index >= 0; index--) {
+                    const edit = editScript[index];
+                    if (edit.type === "delete" && edit.a === entry)
+                        break;
+                    if (edit.type !== "common")
+                        continue;
+                    candidate = edit.a;
+                    break;
+                }
+                const entryIndex = entries.indexOf(entry);
+                if (candidate) {
+                    for (let index = entryIndex + 1; index < entries.length; index++) {
+                        const element = entries[index];
+                        if (element === candidate)
+                            return candidate;
+                        if (shouldKeepOrder(entry, element)) {
+                            break;
                         }
-                        if (data.sequence.node.style === "flow") {
-                            yield* fixForFlow(fixer, data, moveTarget);
-                        }
-                        else {
-                            yield* fixForBlock(fixer, data, moveTarget);
+                    }
+                }
+                let lastTarget = null;
+                for (let index = entryIndex + 1; index < entries.length; index++) {
+                    const element = entries[index];
+                    if (option.isValidOrder(element, entry) &&
+                        !shouldKeepOrder(entry, element)) {
+                        lastTarget = element;
+                        continue;
+                    }
+                    return lastTarget;
+                }
+                return lastTarget;
+            }
+            function findInsertBeforeTarget(entry, insertEditIndex) {
+                let candidate = null;
+                for (let index = insertEditIndex + 1; index < editScript.length; index++) {
+                    const edit = editScript[index];
+                    if (edit.type === "delete" && edit.a === entry)
+                        break;
+                    if (edit.type !== "common")
+                        continue;
+                    candidate = edit.a;
+                    break;
+                }
+                const entryIndex = entries.indexOf(entry);
+                if (candidate) {
+                    for (let index = entryIndex - 1; index >= 0; index--) {
+                        const element = entries[index];
+                        if (element === candidate)
+                            return candidate;
+                        if (shouldKeepOrder(element, entry)) {
+                            break;
                         }
-                    },
-                });
+                    }
+                }
+                let lastTarget = null;
+                for (let index = entryIndex - 1; index >= 0; index--) {
+                    const element = entries[index];
+                    if (option.isValidOrder(entry, element) &&
+                        !shouldKeepOrder(element, entry)) {
+                        lastTarget = element;
+                        continue;
+                    }
+                    return lastTarget;
+                }
+                return lastTarget;
             }
         }
         function toText(data) {
@@ -419,12 +528,48 @@ exports.default = (0, index_1.createRule)("sort-sequence-values", {
                 if (!option) {
                     return;
                 }
-                for (const element of data.entries) {
-                    verifyArrayElement(element, option);
-                }
+                verifyArrayElements(data.entries.filter((d) => !option.ignore(d)), option);
             },
         };
-        function* fixForFlow(fixer, data, moveTarget) {
+        function* fixToMoveDownForFlow(fixer, data, moveTarget) {
+            const beforeToken = data.aroundTokens.before;
+            const afterToken = data.aroundTokens.after;
+            let insertCode, removeRange, insertTargetToken;
+            if ((0, ast_utils_1.isComma)(afterToken)) {
+                removeRange = [beforeToken.range[1], afterToken.range[1]];
+                const moveTargetAfterToken = moveTarget.aroundTokens.after;
+                if ((0, ast_utils_1.isComma)(moveTargetAfterToken)) {
+                    insertTargetToken = moveTargetAfterToken;
+                    insertCode = sourceCode.text.slice(...removeRange);
+                }
+                else {
+                    insertTargetToken = moveTarget.node
+                        ? sourceCode.getLastToken(moveTarget.node)
+                        : moveTarget.aroundTokens.before;
+                    insertCode = sourceCode.text.slice(beforeToken.range[1], afterToken.range[0]);
+                    insertCode = `,${insertCode}`;
+                }
+            }
+            else {
+                if ((0, ast_utils_1.isComma)(beforeToken)) {
+                    removeRange = [beforeToken.range[0], data.range[1]];
+                    insertCode = sourceCode.text.slice(...removeRange);
+                    insertTargetToken = moveTarget.node
+                        ? sourceCode.getLastToken(moveTarget.node)
+                        : moveTarget.aroundTokens.before;
+                }
+                else {
+                    removeRange = [beforeToken.range[1], data.range[1]];
+                    insertCode = `,${sourceCode.text.slice(...removeRange)}`;
+                    insertTargetToken = moveTarget.node
+                        ? sourceCode.getLastToken(moveTarget.node)
+                        : moveTarget.aroundTokens.before;
+                }
+            }
+            yield fixer.removeRange(removeRange);
+            yield fixer.insertTextAfterRange(insertTargetToken.range, insertCode);
+        }
+        function* fixToMoveUpForFlow(fixer, data, moveTarget) {
             const beforeToken = data.aroundTokens.before;
             const afterToken = data.aroundTokens.after;
             let insertCode, removeRange, insertTargetToken;
@@ -447,7 +592,16 @@ exports.default = (0, index_1.createRule)("sort-sequence-values", {
             yield fixer.insertTextAfterRange(insertTargetToken.range, insertCode);
             yield fixer.removeRange(removeRange);
         }
-        function* fixForBlock(fixer, data, moveTarget) {
+        function* fixToMoveDownForBlock(fixer, data, moveTarget) {
+            const moveDataList = data.sequence.entries.slice(data.index, moveTarget.index + 1);
+            let replacementCodeRange = getBlockEntryRange(data);
+            for (const target of moveDataList.reverse()) {
+                const range = getBlockEntryRange(target);
+                yield fixer.replaceTextRange(range, sourceCode.text.slice(...replacementCodeRange));
+                replacementCodeRange = range;
+            }
+        }
+        function* fixToMoveUpForBlock(fixer, data, moveTarget) {
             const moveDataList = data.sequence.entries.slice(moveTarget.index, data.index + 1);
             let replacementCodeRange = getBlockEntryRange(data);
             for (const target of moveDataList) {

package/lib/utils/ast-utils.d.ts

@@ -4,7 +4,10 @@ export declare function isTokenOnSameLine(left: YAMLToken, right: YAMLToken): bo
 export declare function isQuestion(token: YAMLToken | null): token is YAMLToken;
 export declare function isHyphen(token: YAMLToken | null): token is YAMLToken;
 export declare function isColon(token: YAMLToken | null): token is YAMLToken;
-export declare function isComma(token: YAMLToken | null): token is YAMLToken;
+export declare function isComma(token: YAMLToken | null): token is YAMLToken & {
+    type: "Punctuator";
+    value: ",";
+};
 export declare function isOpeningBracketToken(token: YAMLToken | null): token is YAMLToken;
 export declare function isClosingBracketToken(token: YAMLToken | null): token is YAMLToken;
 export declare function isOpeningBraceToken(token: YAMLToken | null): token is YAMLToken;

package/lib/utils/calc-shortest-edit-script.d.ts

@@ -0,0 +1,15 @@
+export type DeleteEntry<E> = {
+    type: "delete";
+    a: E;
+};
+export type InsertEntry<E> = {
+    type: "insert";
+    b: E;
+};
+export type CommonEntry<E> = {
+    type: "common";
+    a: E;
+    b: E;
+};
+export type DiffEntry<E> = DeleteEntry<E> | InsertEntry<E> | CommonEntry<E>;
+export declare function calcShortestEditScript<E>(a: E[], b: E[]): DiffEntry<E>[];

package/lib/utils/calc-shortest-edit-script.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcShortestEditScript = calcShortestEditScript;
+const diff_sequences_1 = __importDefault(require("diff-sequences"));
+function calcShortestEditScript(a, b) {
+    let aIndex = 0;
+    let bIndex = 0;
+    const result = [];
+    (0, diff_sequences_1.default)(a.length, b.length, (aIndex, bIndex) => a[aIndex] === b[bIndex], (nCommon, aCommon, bCommon) => {
+        pushDelIns(aIndex, aCommon, bIndex, bCommon);
+        aIndex = aCommon + nCommon;
+        bIndex = bCommon + nCommon;
+        if (nCommon > 0) {
+            for (let index = 0; index < nCommon; index++) {
+                const elementA = a[aCommon + index];
+                const elementB = b[bCommon + index];
+                result.push({
+                    type: "common",
+                    a: elementA,
+                    b: elementB,
+                });
+            }
+        }
+    });
+    pushDelIns(aIndex, a.length, bIndex, b.length);
+    return result;
+    function pushDelIns(aStart, aEnd, bStart, bEnd) {
+        for (const element of a.slice(aStart, aEnd)) {
+            result.push({
+                type: "delete",
+                a: element,
+            });
+        }
+        for (const element of b.slice(bStart, bEnd)) {
+            result.push({
+                type: "insert",
+                b: element,
+            });
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-yml",
-  "version": "1.17.0",
+  "version": "1.19.0",
   "description": "This ESLint plugin provides linting rules for YAML.",
   "main": "lib/index.js",
   "files": [
@@ -29,8 +29,8 @@
     "docs:watch": "vitepress dev docs",
     "docs:build": "npm run build:ts && vitepress build docs",
     "preversion": "npm test && git add .",
-    "version": "env-cmd -e version npm run update && git add .",
-    "version:ci": "env-cmd -e version-ci npm run update && changeset version",
+    "version": "env-cmd -e version -- npm run update && git add .",
+    "version:ci": "env-cmd -e version-ci -- npm run update && changeset version",
     "prerelease": "npm run build",
     "release": "changeset publish",
     "update-fixtures": "npm run ts -- ./tools/update-fixtures.ts && npm run eslint-fix",
@@ -58,6 +58,7 @@
   "homepage": "https://ota-meshi.github.io/eslint-plugin-yml/",
   "dependencies": {
     "debug": "^4.3.2",
+    "diff-sequences": "^27.5.1",
     "escape-string-regexp": "4.0.0",
     "eslint-compat-utils": "^0.6.0",
     "natural-compare": "^1.4.0",
@@ -72,59 +73,59 @@
     "@eslint-community/eslint-plugin-eslint-comments": "^4.3.0",
     "@eslint/eslintrc": "^3.1.0",
     "@eslint/js": "^9.5.0",
-    "@eslint/json": "^0.10.0",
-    "@ota-meshi/eslint-plugin": "^0.17.3",
+    "@eslint/json": "^0.13.0",
+    "@ota-meshi/eslint-plugin": "^0.18.0",
     "@ota-meshi/site-kit-eslint-editor-vue": "^0.2.0",
     "@types/debug": "^4.1.5",
     "@types/eslint": "^9.0.0",
-    "@types/eslint-scope": "^3.7.0",
+    "@types/eslint-scope": "^8.0.0",
     "@types/eslint-visitor-keys": "^3.0.0",
     "@types/estree": "^1.0.0",
     "@types/mocha": "^10.0.0",
     "@types/natural-compare": "^1.4.0",
     "@types/node": "^22.0.0",
     "@types/semver": "^7.3.1",
-    "@typescript-eslint/eslint-plugin": "~8.24.0",
-    "@typescript-eslint/parser": "~8.24.0",
-    "cross-env": "^7.0.2",
-    "env-cmd": "^10.1.0",
+    "@typescript-eslint/eslint-plugin": "~8.45.0",
+    "@typescript-eslint/parser": "~8.45.0",
+    "cross-env": "^10.0.0",
+    "env-cmd": "^11.0.0",
     "esbuild": "^0.25.0",
     "esbuild-register": "^3.2.0",
     "eslint": "^9.16.0",
     "eslint-config-prettier": "^10.0.0",
-    "eslint-plugin-eslint-plugin": "^6.0.0",
+    "eslint-plugin-eslint-plugin": "^7.0.0",
     "eslint-plugin-eslint-rule-tester": "^0.6.0",
-    "eslint-plugin-jsdoc": "^50.0.0",
+    "eslint-plugin-jsdoc": "^60.0.0",
     "eslint-plugin-json-schema-validator": "^5.0.0",
     "eslint-plugin-jsonc": "^2.0.0",
     "eslint-plugin-markdown": "^5.0.0",
     "eslint-plugin-n": "^17.0.0",
-    "eslint-plugin-node-dependencies": "^0.12.0",
+    "eslint-plugin-node-dependencies": "^1.0.0",
     "eslint-plugin-prettier": "^5.0.0",
     "eslint-plugin-regexp": "^2.0.0",
-    "eslint-plugin-vue": "^9.0.0",
+    "eslint-plugin-vue": "^10.0.0",
     "eslint-plugin-yml": "^1.0.0",
     "events": "^3.3.0",
     "mocha": "^11.0.0",
-    "monaco-editor": "^0.52.0",
+    "monaco-editor": "^0.53.0",
     "nyc": "^17.0.0",
     "pako": "^2.1.0",
     "prettier": "^3.0.3",
     "semver": "^7.3.2",
     "stylelint": "^16.0.0",
     "stylelint-config-recommended-vue": "^1.0.0",
-    "stylelint-config-standard": "^37.0.0",
+    "stylelint-config-standard": "^39.0.0",
     "stylelint-config-standard-vue": "^1.0.0",
     "stylelint-stylus": "^1.0.0",
-    "typescript": "~5.7.0",
+    "typescript": "~5.9.0",
     "typescript-eslint": "^8.0.0",
-    "vite-plugin-eslint4b": "^0.5.0",
+    "vite-plugin-eslint4b": "^0.6.0",
     "vitepress": "^1.0.0-rc.17",
-    "vue-eslint-parser": "^9.0.0",
+    "vue-eslint-parser": "^10.0.0",
     "yaml": "^2.1.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "packageManager": "npm@11.1.0"
+  "packageManager": "npm@11.6.1"
 }