@askviraj/linter 1.1.5 → 1.1.6

package/node_modules/eslint/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "10.8.0",
+  "version": "10.9.1",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "type": "commonjs",
@@ -84,6 +84,12 @@
     "test:types:7.x": "npx -p @typescript/native-preview@latest -y -- tsgo -p tsconfig.types.json",
     "test:types:all": "npm run test:types && npm run test:types:5.3 && npm run test:types:5.x && npm run test:types:7.x"
   },
+  "allowScripts": {
+    "core-js": false,
+    "cypress": false,
+    "re2": true,
+    "yorkie": true
+  },
   "workspaces": [
     "packages/*"
   ],
@@ -205,7 +211,7 @@
     "mocha": "^11.7.1",
     "node-polyfill-webpack-plugin": "^1.0.3",
     "npm-license": "^0.3.3",
-    "prettier": "3.9.5",
+    "prettier": "3.9.6",
     "progress": "^2.0.3",
     "proxyquire": "^2.0.1",
     "regenerator-runtime": "^0.14.0",
@@ -213,7 +219,7 @@
     "shelljs": "^0.10.0",
     "sinon": "^11.0.0",
     "typescript": "^6.0.3",
-    "webpack": "5.108.4",
+    "webpack": "^5.109.2",
     "webpack-cli": "^4.5.0",
     "yorkie": "^2.0.0"
   },

package/node_modules/eslint-plugin-astro/README.md

@@ -49,9 +49,11 @@ See [documents](https://ota-meshi.github.io/eslint-plugin-astro/).
 npm install --save-dev eslint eslint-plugin-astro
 ```
 
-If you write TypeScript in Astro components, you also need to install the `@typescript-eslint/parser`:
+If you write TypeScript in Astro components, you also need to install either `typescript-eslint` or `@typescript-eslint/parser`:
 
 ```bash
+npm install --save-dev typescript-eslint
+# or
 npm install --save-dev @typescript-eslint/parser
 ```
 
@@ -119,6 +121,25 @@ The pull request diff [here](https://github.com/withastro/docs/pull/710/files) i
 
 See [https://github.com/ota-meshi/astro-eslint-parser#readme](https://github.com/ota-meshi/astro-eslint-parser#readme).
 
+#### Using `eslint-plugin-import`
+
+When using [`eslint-plugin-import`](https://github.com/import-js/eslint-plugin-import), configure it to parse Astro files and recognize Astro's virtual modules. After applying the plugin's recommended configuration, add the following config object:
+
+```json
+{
+  "settings": {
+    "import/core-modules": ["astro:content", "astro:transitions"],
+    "import/parsers": {
+      "astro-eslint-parser": [".astro"],
+      "espree": [".js", ".mjs", ".cjs"],
+      "@typescript-eslint/parser": [".ts", ".tsx"]
+    }
+  }
+}
+```
+
+Add any other virtual `astro:*` modules that your project imports to `import/core-modules`. Only include parser entries for file types and parsers that your project uses.
+
 ### Resolving Error in JSX: Unsafe return of an `any` typed value
 
 Astro supports JSX from multiple frameworks such as **React**, **Preact**, and **Solid.js** by defining JSX Elements as `HTMLElement | any;`. When a framework with a JSX type definition is not present in your project this **any** can cause the ESLint error `@typescript-eslint/no-unsafe-return`.

package/node_modules/eslint-plugin-astro/lib/index.mjs

@@ -21,13 +21,28 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
+//#region src/utils/resolve-parser/require-user.ts
+/** Require from user local */
+function requireUserLocal(id) {
+	try {
+		const cwd = process.cwd();
+		const relativeTo = path.join(cwd, "__placeholder__.js");
+		return createRequire(relativeTo)(id);
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/configs/has-typescript-eslint-parser.ts
-let hasTypescriptEslintParser = false;
-let tsESLintParser = null;
-try {
-	const cwd = process.cwd();
-	if (tsESLintParser = createRequire(path.join(cwd, "__placeholder__.js"))("@typescript-eslint/parser")) hasTypescriptEslintParser = true;
-} catch {}
+/** Load the TypeScript parser installed in the user's project. */
+function loadTypescriptEslintParser() {
+	const parser = requireUserLocal("@typescript-eslint/parser");
+	if (parser) return parser;
+	const typescriptEslint = requireUserLocal("typescript-eslint");
+	return typescriptEslint?.parser ?? typescriptEslint?.default?.parser ?? null;
+}
+const tsESLintParser = loadTypescriptEslintParser();
+const hasTypescriptEslintParser = Boolean(tsESLintParser);
 //#endregion
 //#region src/environments/index.ts
 const environments$1 = { astro: { globals: {
@@ -3189,7 +3204,8 @@ var semi_default = createRule("semi", {
 		* @param node The node to check.
 		*/
 		function checkForSemicolon(node) {
-			const isSemi = isSemicolonToken(sourceCode.getLastToken(node));
+			const lastToken = sourceCode.getLastToken(node);
+			const isSemi = isSemicolonToken(lastToken);
 			if (never) {
 				const nextToken = sourceCode.getTokenAfter(node);
 				if (isSemi && canRemoveSemicolon(node)) report(node, true);
@@ -3367,17 +3383,6 @@ var valid_compile_default = createRule("valid-compile", {
 	}
 });
 //#endregion
-//#region src/utils/resolve-parser/require-user.ts
-/** Require from user local */
-function requireUserLocal(id) {
-	try {
-		const cwd = process.cwd();
-		return createRequire(path.join(cwd, "__placeholder__.js"))(id);
-	} catch {
-		return null;
-	}
-}
-//#endregion
 //#region src/a11y/load.ts
 let pluginJsxA11yCache = null;
 let loaded = false;
@@ -3908,7 +3913,7 @@ function terminateShared(filename) {
 //#endregion
 //#region package.json
 var name$1 = "eslint-plugin-astro";
-var version$1 = "3.0.1";
+var version$1 = "3.1.0";
 //#endregion
 //#region src/meta.ts
 var meta_exports = /* @__PURE__ */ __exportAll({

package/node_modules/eslint-plugin-astro/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-astro",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "ESLint plugin for Astro component",
   "type": "module",
   "main": "lib/index.mjs",
@@ -81,7 +81,8 @@
   "peerDependencies": {
     "@typescript-eslint/parser": ">=8.61.0",
     "eslint": ">=10.0.0",
-    "eslint-plugin-jsx-a11y": ">=6.10.2"
+    "eslint-plugin-jsx-a11y": ">=6.10.2",
+    "typescript-eslint": ">=8.61.0"
   },
   "peerDependenciesMeta": {
     "@typescript-eslint/parser": {
@@ -89,13 +90,16 @@
     },
     "eslint-plugin-jsx-a11y": {
       "optional": true
+    },
+    "typescript-eslint": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@actions/github": "^9.0.0",
     "@astrojs/compiler": "^4.0.0",
     "@astrojs/compiler-binding-wasm32-wasi": "^0.3.1",
-    "@astrojs/markdown-satteri": "0.3.4",
+    "@astrojs/markdown-satteri": "0.3.5",
     "@astrojs/mdx": "^7.0.0",
     "@astrojs/svelte": "^9.0.0",
     "@changesets/changelog-github": "^0.7.0",
@@ -118,7 +122,7 @@
     "@typescript-eslint/parser": "^8.61.0",
     "assert": "^2.0.0",
     "astro": "^7.0.0",
-    "c8": "^11.0.0",
+    "c8": "^12.0.0",
     "env-cmd": "^11.0.0",
     "esbuild": "^0.28.0",
     "esbuild-register": "^3.3.3",

package/node_modules/eslint-plugin-yml/lib/index.mjs

@@ -4045,6 +4045,19 @@ function buildValidatorFromType$1(order, insensitive, natural) {
 	return (a, b) => compare([a.name, b.name]);
 }
 /**
+* Parse an order option for a key pattern.
+*/
+function parseNestedOrder(order) {
+	if (order?.type === "ignore") return {
+		ignore: true,
+		isValidNestOrder: () => true
+	};
+	return {
+		ignore: false,
+		isValidNestOrder: buildValidatorFromType$1(order?.type ?? "asc", order?.caseSensitive === false, Boolean(order?.natural))
+	};
+}
+/**
 * Parse options
 */
 function parseOptions$1(options, sourceCode) {
@@ -4070,6 +4083,13 @@ function parseOptions$1(options, sourceCode) {
 		const minKeys = opt.minKeys ?? 2;
 		const allowLineSeparatedGroups = opt.allowLineSeparatedGroups || false;
 		if (!Array.isArray(order)) {
+			if (order.type === "ignore") return {
+				isTargetMapping,
+				ignore: () => true,
+				isValidOrder: () => true,
+				orderText: "ignored",
+				allowLineSeparatedGroups
+			};
 			const type = order.type ?? "asc";
 			const insensitive = order.caseSensitive === false;
 			const natural = Boolean(order.natural);
@@ -4084,22 +4104,22 @@ function parseOptions$1(options, sourceCode) {
 		const parsedOrder = [];
 		for (const o of order) if (typeof o === "string") parsedOrder.push({
 			test: (data) => data.name === o,
+			ignore: false,
 			isValidNestOrder: () => true
 		});
 		else {
 			const keyPattern = o.keyPattern ? new RegExp(o.keyPattern) : null;
-			const nestOrder = o.order ?? {};
-			const type = nestOrder.type ?? "asc";
-			const insensitive = nestOrder.caseSensitive === false;
-			const natural = Boolean(nestOrder.natural);
 			parsedOrder.push({
 				test: (data) => keyPattern ? keyPattern.test(data.name) : true,
-				isValidNestOrder: buildValidatorFromType$1(type, insensitive, natural)
+				...parseNestedOrder(o.order)
 			});
 		}
 		return {
 			isTargetMapping,
-			ignore: (data) => parsedOrder.every((p) => !p.test(data)),
+			ignore: (data) => {
+				const order = parsedOrder.find((p) => p.test(data));
+				return !order || order.ignore;
+			},
 			isValidOrder(a, b) {
 				for (const p of parsedOrder) {
 					const matchA = p.test(a);
@@ -4139,6 +4159,39 @@ const ORDER_OBJECT_SCHEMA$1 = {
 	},
 	additionalProperties: false
 };
+const IGNORE_ORDER_OBJECT_SCHEMA = {
+	type: "object",
+	properties: { type: { enum: ["ignore"] } },
+	required: ["type"],
+	additionalProperties: false
+};
+var UnsafeMovePairs = class {
+	kind;
+	pairs;
+	unsafeMovePairs = /* @__PURE__ */ new Map();
+	constructor(kind, pairs) {
+		this.kind = kind;
+		this.pairs = pairs;
+	}
+	addUnsafeMove(pair, targets) {
+		let unsafeMove = this.unsafeMovePairs.get(pair);
+		if (!unsafeMove) {
+			unsafeMove = { targets: /* @__PURE__ */ new Set() };
+			this.unsafeMovePairs.set(pair, unsafeMove);
+		}
+		for (const target of targets) unsafeMove.targets.add(target);
+	}
+	isEmpty() {
+		return this.unsafeMovePairs.size === 0;
+	}
+	isUnsafe(pair, moveTarget) {
+		const unsafeMove = this.unsafeMovePairs.get(pair);
+		if (!unsafeMove) return false;
+		if (this.kind === "up") return this.pairs.slice(this.pairs.indexOf(moveTarget) + 1, this.pairs.indexOf(pair)).some((p) => unsafeMove.targets.has(p));
+		else if (this.kind === "down") return this.pairs.slice(this.pairs.indexOf(pair) + 1, this.pairs.indexOf(moveTarget)).some((p) => unsafeMove.targets.has(p));
+		return false;
+	}
+};
 var sort_keys_default = createRule("sort-keys", {
 	meta: {
 		docs: {
@@ -4158,18 +4211,22 @@ var sort_keys_default = createRule("sort-keys", {
 						type: "array",
 						items: { type: "string" }
 					},
-					order: { oneOf: [{
-						type: "array",
-						items: { anyOf: [{ type: "string" }, {
-							type: "object",
-							properties: {
-								keyPattern: { type: "string" },
-								order: ORDER_OBJECT_SCHEMA$1
-							},
-							additionalProperties: false
-						}] },
-						uniqueItems: true
-					}, ORDER_OBJECT_SCHEMA$1] },
+					order: { oneOf: [
+						{
+							type: "array",
+							items: { anyOf: [{ type: "string" }, {
+								type: "object",
+								properties: {
+									keyPattern: { type: "string" },
+									order: { oneOf: [ORDER_OBJECT_SCHEMA$1, IGNORE_ORDER_OBJECT_SCHEMA] }
+								},
+								additionalProperties: false
+							}] },
+							uniqueItems: true
+						},
+						ORDER_OBJECT_SCHEMA$1,
+						IGNORE_ORDER_OBJECT_SCHEMA
+					] },
 					minKeys: {
 						type: "integer",
 						minimum: 2
@@ -4231,10 +4288,6 @@ var sort_keys_default = createRule("sort-keys", {
 			let group = [];
 			let prev = null;
 			for (const pair of pairs) {
-				if (ignore(pair, option)) {
-					prev = pair;
-					continue;
-				}
 				if (prev && option.allowLineSeparatedGroups && hasBlankLine(prev, pair)) {
 					if (group.length > 0) {
 						groups.push(group);
@@ -4248,71 +4301,160 @@ var sort_keys_default = createRule("sort-keys", {
 			return groups;
 		}
 		/**
-		* Sort pairs by bubble sort.
+		* Build a sort target while retaining ignored pairs for anchor and alias
+		* safety checks.
 		*/
-		function bubbleSort(pairs, option) {
-			const l = pairs.length;
-			const result = [...pairs];
-			let swapped;
+		function buildSafeSortTarget(pairs, option) {
+			const sorted = [...pairs];
+			const unsafeMoveUpPairs = new UnsafeMovePairs("up", pairs);
+			const unsafeMoveDownPairs = new UnsafeMovePairs("down", pairs);
+			let changed;
 			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;
+				changed = false;
+				for (let nextIndex = 1; nextIndex < sorted.length; nextIndex++) {
+					const next = sorted[nextIndex];
+					if (ignore(next, option)) continue;
+					let prevIndex = nextIndex - 1;
+					while (prevIndex >= 0 && ignore(sorted[prevIndex], option)) prevIndex--;
+					if (prevIndex < 0) continue;
+					const prev = sorted[prevIndex];
+					if (option.isValidOrder(prev, next) || shouldKeepOrder(prev, next)) continue;
+					const between = sorted.slice(prevIndex + 1, nextIndex);
+					if (between.every((element) => !shouldKeepOrder(element, next) && !shouldKeepOrder(prev, element))) {
+						[sorted[prevIndex], sorted[nextIndex]] = [next, prev];
+						changed = true;
+						continue;
+					}
+					if (between.every((element) => !shouldKeepOrder(element, next))) {
+						sorted.splice(prevIndex, between.length + 2, next, prev, ...between);
+						changed = true;
+						unsafeMoveDownPairs.addUnsafeMove(prev, between.filter((element) => shouldKeepOrder(prev, element)));
+						continue;
+					}
+					if (between.every((element) => !shouldKeepOrder(prev, element))) {
+						sorted.splice(prevIndex, between.length + 2, ...between, next, prev);
+						changed = true;
+						unsafeMoveUpPairs.addUnsafeMove(next, between.filter((element) => shouldKeepOrder(element, next)));
+						continue;
+					}
+					const moveBarrierIndex = between.findLastIndex((element) => shouldKeepOrder(element, next));
+					const moveUpBetween = between.slice(0, moveBarrierIndex + 1);
+					const moveDownBetween = between.slice(moveBarrierIndex + 1);
+					if (moveUpBetween.every((element) => !shouldKeepOrder(prev, element)) && moveDownBetween.every((moveDownElement) => !shouldKeepOrder(moveDownElement, next) && moveUpBetween.every((moveUpElement) => !shouldKeepOrder(moveDownElement, moveUpElement)))) {
+						sorted.splice(prevIndex, between.length + 2, ...moveUpBetween, next, prev, ...moveDownBetween);
+						changed = true;
+						unsafeMoveDownPairs.addUnsafeMove(prev, moveDownBetween.filter((element) => shouldKeepOrder(prev, element)));
+						unsafeMoveUpPairs.addUnsafeMove(next, moveUpBetween.filter((element) => shouldKeepOrder(element, next)));
+						continue;
+					}
 				}
-			} while (swapped);
-			return result;
+			} while (changed);
+			return {
+				sorted,
+				unsafeMoveUpPairs,
+				unsafeMoveDownPairs
+			};
 		}
 		/**
 		* Verify for pairs order
+		* @param pairs The pairs to verify. These pairs include some that should be ignored.
+		* @param option The option for the current mapping.
 		*/
 		function verifyPairs(pairs, option) {
-			const editScript = calcShortestEditScript(pairs, bubbleSort(pairs, option));
-			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 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);
-						}
-					});
+			const { sorted, unsafeMoveUpPairs, unsafeMoveDownPairs } = buildSafeSortTarget(pairs, option);
+			if (pairs.every((e, i) => e === sorted[i])) return;
+			const alreadyReports = /* @__PURE__ */ new Set();
+			reportUsingShortestEditScript({ disableIgnore: !unsafeMoveUpPairs.isEmpty() || !unsafeMoveDownPairs.isEmpty() });
+			if (alreadyReports.size > 0) return;
+			reportUsingSortedPairs({ disableIgnore: !unsafeMoveUpPairs.isEmpty() || !unsafeMoveDownPairs.isEmpty() });
+			/**
+			* Report using the shortest edit script.
+			* This is a fallback when the above logic cannot determine a safe reordering.
+			*/
+			function reportUsingShortestEditScript(options) {
+				const editScript = calcShortestEditScript(pairs, sorted);
+				for (let index = 0; index < editScript.length; index++) {
+					const edit = editScript[index];
+					if (edit.type !== "delete") continue;
+					if (!options.disableIgnore && ignore(edit.a, option)) 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, editScript, insertEditIndex);
+						if (!target) continue;
+						reportShouldBeAfter(edit.a, target);
+					} else {
+						const target = findInsertBeforeTarget(edit.a, editScript, insertEditIndex);
+						if (!target) continue;
+						reportShouldBeBefore(edit.a, target);
+					}
 				}
 			}
 			/**
+			* Report using the sorted pairs.
+			*/
+			function reportUsingSortedPairs(options) {
+				for (const [index, pair] of pairs.entries()) {
+					if (alreadyReports.has(pair)) continue;
+					if (!options.disableIgnore && ignore(pair, option)) continue;
+					const sortedIndex = sorted.indexOf(pair);
+					const shouldAfterPairs = sorted.slice(sortedIndex + 1);
+					const shouldBeBeforeTarget = pairs.slice(0, index).find((prev, i, prevPairs) => shouldAfterPairs.includes(prev) && prevPairs.slice(i).every((pp) => !shouldKeepOrder(pp, pair)));
+					if (shouldBeBeforeTarget) {
+						reportShouldBeBefore(pair, shouldBeBeforeTarget);
+						continue;
+					}
+					const shouldBeforePairs = sorted.slice(0, sortedIndex);
+					const shouldBeAfterTarget = pairs.slice(index + 1).find((next, i, nextPairs) => shouldBeforePairs.includes(next) && nextPairs.slice(0, i + 1).every((nn) => !shouldKeepOrder(pair, nn)));
+					if (shouldBeAfterTarget) reportShouldBeAfter(pair, shouldBeAfterTarget);
+				}
+			}
+			/**
+			* Report that the given pair should be after the target pair.
+			* @param pair The pair that should be after the target.
+			* @param target The target pair that the given pair should be after.
+			*/
+			function reportShouldBeAfter(pair, target) {
+				alreadyReports.add(pair);
+				context.report({
+					loc: pair.reportLoc,
+					messageId: "shouldBeAfter",
+					data: {
+						thisName: pair.name,
+						targetName: target.name,
+						orderText: option.orderText
+					},
+					fix: !unsafeMoveDownPairs.isUnsafe(pair, target) ? function* (fixer) {
+						if (pair.mapping.node.style === "flow") yield* fixToMoveDownForFlow(fixer, pair, target);
+						else yield* fixToMoveDownForBlock(fixer, pair, target);
+					} : void 0
+				});
+			}
+			/**
+			* Report that the given pair should be before the target pair.
+			* @param pair The pair that should be before the target.
+			* @param target The target pair that the given pair should be before.
+			*/
+			function reportShouldBeBefore(pair, target) {
+				alreadyReports.add(pair);
+				context.report({
+					loc: pair.reportLoc,
+					messageId: "shouldBeBefore",
+					data: {
+						thisName: pair.name,
+						targetName: target.name,
+						orderText: option.orderText
+					},
+					fix: !unsafeMoveUpPairs.isUnsafe(pair, target) ? function* (fixer) {
+						if (pair.mapping.node.style === "flow") yield* fixToMoveUpForFlow(fixer, pair, target);
+						else yield* fixToMoveUpForBlock(fixer, pair, target);
+					} : void 0
+				});
+			}
+			/**
 			* Find insert after target
 			*/
-			function findInsertAfterTarget(pair, insertEditIndex) {
+			function findInsertAfterTarget(pair, editScript, insertEditIndex) {
 				let candidate = null;
 				for (let index = insertEditIndex - 1; index >= 0; index--) {
 					const edit = editScript[index];
@@ -4330,7 +4472,7 @@ var sort_keys_default = createRule("sort-keys", {
 				let lastTarget = null;
 				for (let index = pairIndex + 1; index < pairs.length; index++) {
 					const element = pairs[index];
-					if (option.isValidOrder(element, pair) && !shouldKeepOrder(pair, element)) {
+					if ((ignore(element, option) || option.isValidOrder(element, pair)) && !shouldKeepOrder(pair, element)) {
 						lastTarget = element;
 						continue;
 					}
@@ -4341,7 +4483,7 @@ var sort_keys_default = createRule("sort-keys", {
 			/**
 			* Find insert before target
 			*/
-			function findInsertBeforeTarget(pair, insertEditIndex) {
+			function findInsertBeforeTarget(pair, editScript, insertEditIndex) {
 				let candidate = null;
 				for (let index = insertEditIndex + 1; index < editScript.length; index++) {
 					const edit = editScript[index];
@@ -4359,7 +4501,7 @@ var sort_keys_default = createRule("sort-keys", {
 				let lastTarget = null;
 				for (let index = pairIndex - 1; index >= 0; index--) {
 					const element = pairs[index];
-					if (option.isValidOrder(pair, element) && !shouldKeepOrder(element, pair)) {
+					if ((ignore(element, option) || option.isValidOrder(pair, element)) && !shouldKeepOrder(element, pair)) {
 						lastTarget = element;
 						continue;
 					}
@@ -5494,7 +5636,7 @@ var prettier_default = [...base_default, { rules: {
 //#endregion
 //#region package.json
 var name$1 = "eslint-plugin-yml";
-var version$1 = "3.7.0";
+var version$1 = "3.8.1";
 //#endregion
 //#region src/meta.ts
 var meta_exports = /* @__PURE__ */ __exportAll({

package/node_modules/eslint-plugin-yml/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-yml",
-  "version": "3.7.0",
+  "version": "3.8.1",
   "description": "This ESLint plugin provides linting rules for YAML.",
   "type": "module",
   "main": "lib/index.mjs",
@@ -22,7 +22,7 @@
     "prebuild": "npm run -s clean",
     "build": "tsdown",
     "clean": "rimraf .nyc_output dist coverage lib",
-    "lint": "eslint .",
+    "lint": "eslint . && npm run tsc",
     "eslint-fix": "eslint . --fix",
     "eslint-test-fix": "eslint tests/src/rules/*.ts --fix -c .eslintrc.for-vscode.js",
     "pretest:base": "cross-env DEBUG=eslint-plugin-yml*",
@@ -42,6 +42,7 @@
     "release": "changeset publish",
     "update-fixtures": "npm run ts -- ./tools/update-fixtures.ts && npm run eslint-fix",
     "ts": "tsx",
+    "tsc": "tsc --project ./tsconfig.build.json",
     "mocha": "npm run ts -- ./node_modules/mocha/bin/mocha.js"
   },
   "repository": {
@@ -89,8 +90,8 @@
     "@types/natural-compare": "^1.4.0",
     "@types/node": "^24.0.0",
     "@types/semver": "^7.3.1",
-    "@typescript-eslint/eslint-plugin": "~8.65.0",
-    "@typescript-eslint/parser": "~8.65.0",
+    "@typescript-eslint/eslint-plugin": "~8.66.0",
+    "@typescript-eslint/parser": "~8.66.0",
     "cross-env": "^10.0.0",
     "env-cmd": "^11.0.0",
     "eslint": "^10.0.0",