markuplint 5.5.0 → 5.6.1

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [5.6.1](https://github.com/markuplint/markuplint/compare/v5.6.0...v5.6.1) (2026-11-13)
+
+**Note:** Version bump only for package markuplint
+
+
+
+
+
+# [5.6.0](https://github.com/markuplint/markuplint/compare/v5.5.0...v5.6.0) (2026-11-12)
+
+### Bug Fixes
+
+* **markuplint:** keep the scope of the suppressions ([4f2409d](https://github.com/markuplint/markuplint/commit/4f2409d1d9c98cefbbe91f7c0f084f5855fafeb5)), closes [#4592](https://github.com/markuplint/markuplint/issues/4592)
+
+
 # [5.5.0](https://github.com/markuplint/markuplint/compare/v5.4.0...v5.5.0) (2026-11-10)
 
 ### Bug Fixes

package/README.md

@@ -136,6 +136,7 @@ $ markuplint --prune-suppressions "src/**/*.html"
 - Only `error`-severity violations are suppressed; `warning` and `info` always pass through.
 - If the number of violations for a file+rule pair **exceeds** the suppressed count, **all** violations for that pair are reported.
 - `--suppress` always exits with code 0 (success).
+- Running `--suppress` again keeps the entries it does not record, scope included, and gives the ones it records the newly computed scope.
 - When a DOM tree is available, each suppression entry includes a **scope selector** (computed via LCA) to narrow suppression to a specific subtree. Entries without `scope` apply to the entire file.
 
 ```json

package/lib/cli/command.js

@@ -246,8 +246,9 @@ export async function command(files, options, apiOptions) {
             }
             const doc = scopeEngine.document;
             if (doc) {
-                // MLNode structurally satisfies PositionedNode (startLine, startCol, localName,
-                // id, classList, parentElement, children are all present). The double cast is
+                // MLNode structurally satisfies PositionedNode (startLine, startCol, endLine, endCol,
+                // localName, id, classList, parentElement, children, and closeTag on an element,
+                // are all present). The double cast is
                 // needed because TypeScript can't verify structural compatibility between the
                 // generic MLNode<T,O> and the plain PositionedNode interface at compile time.
                 nodeList = doc.nodeList;

package/lib/suppressions/compute-scope.d.ts

@@ -50,6 +50,29 @@ export interface ScopedNode {
 export interface PositionedNode extends ScopedNode {
     readonly startLine: number;
     readonly startCol: number;
+    /**
+     * Where the node's source ends, excluded. For an element, the end of its start tag.
+     * A violation inside this range belongs to the node (see `findNodeAtPosition`);
+     * without it, only a violation at the node's start does.
+     */
+    readonly endLine?: number;
+    /** The column of `endLine`, excluded. */
+    readonly endCol?: number;
+    /**
+     * The end tag of an element. A document's node list has no end tags, so a
+     * violation reported at one (`</P>`) is found through its element.
+     */
+    readonly closeTag?: SourceRange | null;
+}
+/**
+ * @experimental
+ * A source range: from its start, included, to its end, excluded.
+ */
+export interface SourceRange {
+    readonly startLine: number;
+    readonly startCol: number;
+    readonly endLine?: number;
+    readonly endCol?: number;
 }
 /**
  * @experimental
@@ -143,6 +166,15 @@ export declare function computeLCA(nodes: readonly ScopedNode[]): ScopedNode | n
 export declare function generateUniqueSelector(node: ScopedNode): string | undefined;
 /**
  * @experimental
+ * Finds the element a violation at `line`:`col` belongs to.
+ *
+ * The node is the one `searchNodeAtLocation` of `@markuplint/ml-core` finds,
+ * the rule `MLDocument.searchNodeByLocation` and the hover of the language
+ * server share: a violation reported at an attribute (`no-duplicate-attr`),
+ * inside its value or at an end tag is the element that has it, and of several
+ * nodes that hold the position the innermost is taken. A non-element is
+ * resolved to its nearest element ancestor. `nodeList` is in document order.
+ *
  * The O(n) linear search per violation is deliberate — acceptable for
  * typical document sizes; build a position index only if very large
  * documents make this a measured bottleneck.
@@ -152,7 +184,9 @@ export declare function findNodeAtPosition(nodeList: readonly PositionedNode[],
  * @experimental
  * Computes the scope selector for a set of violations within a document.
  * Only considers error-severity violations. Returns `undefined` when
- * the LCA falls back to file-level (body/html) or when nodes cannot be found.
+ * the LCA falls back to file-level (body/html) or when a violation is at no
+ * element: the entry counts every violation, and applying a scope counts only
+ * those found inside it, so a scope that left one out would not suppress it.
  *
  * @param nodeList - Flat list of all nodes in the document.
  * @param violations - The violations to compute scope for.

package/lib/suppressions/compute-scope.js

@@ -20,6 +20,7 @@
  *
  * @see https://github.com/markuplint/markuplint/issues/3509
  */
+import { searchNodeAtLocation } from '@markuplint/ml-core';
 const BODY_HTML_TAGS = new Set(['body', 'html']);
 /**
  * The position that ends a segment of a scope: `:nth-of-type(n)`.
@@ -372,6 +373,15 @@ function buildSegmentWithNth(node) {
 }
 /**
  * @experimental
+ * Finds the element a violation at `line`:`col` belongs to.
+ *
+ * The node is the one `searchNodeAtLocation` of `@markuplint/ml-core` finds,
+ * the rule `MLDocument.searchNodeByLocation` and the hover of the language
+ * server share: a violation reported at an attribute (`no-duplicate-attr`),
+ * inside its value or at an end tag is the element that has it, and of several
+ * nodes that hold the position the innermost is taken. A non-element is
+ * resolved to its nearest element ancestor. `nodeList` is in document order.
+ *
  * The O(n) linear search per violation is deliberate — acceptable for
  * typical document sizes; build a position index only if very large
  * documents make this a measured bottleneck.
@@ -379,26 +389,26 @@ function buildSegmentWithNth(node) {
 export function findNodeAtPosition(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 nodeList, line, col) {
-    for (const node of nodeList) {
-        if (node.startLine === line && node.startCol === col) {
-            if (node.nodeType === 1) {
-                return node;
-            }
-            // Non-element (e.g., attribute) — walk up to parent element
-            let parent = node.parentElement;
-            while (parent && parent.nodeType !== 1) {
-                parent = parent.parentElement;
-            }
-            return parent;
-        }
+    const found = searchNodeAtLocation(nodeList, line, col);
+    if (!found) {
+        return null;
     }
-    return null;
+    if (found.nodeType === 1) {
+        return found;
+    }
+    let parent = found.parentElement;
+    while (parent && parent.nodeType !== 1) {
+        parent = parent.parentElement;
+    }
+    return parent;
 }
 /**
  * @experimental
  * Computes the scope selector for a set of violations within a document.
  * Only considers error-severity violations. Returns `undefined` when
- * the LCA falls back to file-level (body/html) or when nodes cannot be found.
+ * the LCA falls back to file-level (body/html) or when a violation is at no
+ * element: the entry counts every violation, and applying a scope counts only
+ * those found inside it, so a scope that left one out would not suppress it.
  *
  * @param nodeList - Flat list of all nodes in the document.
  * @param violations - The violations to compute scope for.
@@ -413,9 +423,10 @@ nodeList, violations) {
             continue;
         }
         const node = findNodeAtPosition(nodeList, v.line, v.col);
-        if (node) {
-            nodes.push(node);
+        if (!node) {
+            return undefined;
         }
+        nodes.push(node);
     }
     if (nodes.length === 0) {
         return undefined;

package/lib/suppressions/index.d.ts

@@ -18,7 +18,7 @@
 export type { SuppressionsData, SuppressionEntry } from './types.js';
 export type { ApplySuppressionsResult, ApplySuppressionsOptions } from './apply-suppressions.js';
 export type { GenerateSuppressionsOptions } from './generate-suppressions.js';
-export type { ScopedNode, PositionedNode } from './compute-scope.js';
+export type { ScopedNode, PositionedNode, SourceRange } from './compute-scope.js';
 export { computeScopeForViolations, computeLCA, generateUniqueSelector } from './compute-scope.js';
 export { applySuppressions } from './apply-suppressions.js';
 export { generateSuppressions } from './generate-suppressions.js';

package/lib/suppressions/merge-suppressions.d.ts

@@ -2,7 +2,18 @@ import type { SuppressionsData } from './types.js';
 /**
  * @experimental
  * Merges incoming suppressions into existing suppressions.
- * For overlapping entries, takes the maximum count.
+ * For overlapping entries with the same scope, takes the maximum count;
+ * for overlapping entries whose scopes differ, takes the incoming entry.
+ *
+ * The scope of an overlapping entry is always the incoming one:
+ * `generateSuppressions` computes it as the subtree that contains every current
+ * violation of the rule, so an existing scope could leave some of them outside
+ * and unsuppressed. An incoming entry without a scope covers the whole file, so
+ * it drops the existing scope. A count is the number of violations inside its
+ * own scope, so when the scope changes, the existing count is not carried over:
+ * it would let new violations inside the new scope pass up to a number that
+ * scope never held. An entry only on one side is kept as it is, scope included
+ * (a rule `--suppress-rule` did not select, a file not linted).
  *
  * @param existing - The current suppressions data.
  * @param incoming - The new suppressions data to merge.

package/lib/suppressions/merge-suppressions.js

@@ -1,7 +1,18 @@
 /**
  * @experimental
  * Merges incoming suppressions into existing suppressions.
- * For overlapping entries, takes the maximum count.
+ * For overlapping entries with the same scope, takes the maximum count;
+ * for overlapping entries whose scopes differ, takes the incoming entry.
+ *
+ * The scope of an overlapping entry is always the incoming one:
+ * `generateSuppressions` computes it as the subtree that contains every current
+ * violation of the rule, so an existing scope could leave some of them outside
+ * and unsuppressed. An incoming entry without a scope covers the whole file, so
+ * it drops the existing scope. A count is the number of violations inside its
+ * own scope, so when the scope changes, the existing count is not carried over:
+ * it would let new violations inside the new scope pass up to a number that
+ * scope never held. An entry only on one side is kept as it is, scope included
+ * (a rule `--suppress-rule` did not select, a file not linted).
  *
  * @param existing - The current suppressions data.
  * @param incoming - The new suppressions data to merge.
@@ -9,9 +20,9 @@
  */
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 export function mergeSuppressions(existing, incoming) {
-    // Uses max(count) to ensure running --suppress multiple times is idempotent
-    // and never accidentally lowers a suppression threshold. Counts are only
-    // reduced explicitly via --prune-suppressions.
+    // Under the same scope, uses max(count) to ensure running --suppress multiple
+    // times is idempotent and never accidentally lowers a suppression threshold.
+    // Counts of an unchanged scope are only reduced explicitly via --prune-suppressions.
     const merged = {};
     // Collect all file paths
     const allFiles = new Set([...Object.keys(existing), ...Object.keys(incoming)]);
@@ -21,11 +32,20 @@ export function mergeSuppressions(existing, incoming) {
         const allRules = new Set([...Object.keys(existingRules), ...Object.keys(incomingRules)]);
         const mergedRules = {};
         for (const ruleId of allRules) {
-            const existingCount = existingRules[ruleId]?.count ?? 0;
-            const incomingCount = incomingRules[ruleId]?.count ?? 0;
-            mergedRules[ruleId] = { count: Math.max(existingCount, incomingCount) };
+            const existingEntry = existingRules[ruleId];
+            const incomingEntry = incomingRules[ruleId];
+            mergedRules[ruleId] = mergeEntry(existingEntry, incomingEntry);
         }
         merged[filePath] = mergedRules;
     }
     return merged;
 }
+function mergeEntry(existing, incoming) {
+    // Both are never absent: the rule ID comes from one of the two sides.
+    const base = incoming ?? existing;
+    const count = existing && incoming && existing.scope === incoming.scope
+        ? Math.max(existing.count, incoming.count)
+        : base.count;
+    // Only `count` and `scope` are written: a key the file has besides them is not carried over.
+    return base.scope === undefined ? { count } : { count, scope: base.scope };
+}

package/lib/suppressions/prune-suppressions.d.ts

@@ -11,8 +11,9 @@ import type { SuppressionsData } from './types.js';
  *
  * **Note:** Pruning counts all file-level violations, not scope-filtered ones.
  * This is because `pruneSuppressions` does not receive document node lists
- * (required for scope-based violation filtering). For scope-accurate counts,
- * re-run `--suppress` which recomputes both scope and count from the DOM tree.
+ * (required for scope-based violation filtering). `--suppress` recomputes the scope
+ * from the DOM tree, and takes the new count when the scope changes; under an
+ * unchanged scope it keeps the higher count (see `mergeSuppressions`).
  *
  * @param currentViolations - Map of absolute file paths to current violations.
  * @param existing - The current suppressions data.

package/lib/suppressions/prune-suppressions.js

@@ -10,8 +10,9 @@ import { toRelativePath } from './suppressions-file.js';
  *
  * **Note:** Pruning counts all file-level violations, not scope-filtered ones.
  * This is because `pruneSuppressions` does not receive document node lists
- * (required for scope-based violation filtering). For scope-accurate counts,
- * re-run `--suppress` which recomputes both scope and count from the DOM tree.
+ * (required for scope-based violation filtering). `--suppress` recomputes the scope
+ * from the DOM tree, and takes the new count when the scope changes; under an
+ * unchanged scope it keeps the higher count (see `mergeSuppressions`).
  *
  * @param currentViolations - Map of absolute file paths to current violations.
  * @param existing - The current suppressions data.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "markuplint",
-	"version": "5.5.0",
+	"version": "5.6.1",
 	"description": "An HTML linter for all markup developers",
 	"author": "Yusuke Hirao",
 	"license": "MIT",
@@ -24,9 +24,6 @@
 		},
 		"./package.json": "./package.json"
 	},
-	"typedoc": {
-		"entryPoint": "./src/index.ts"
-	},
 	"bin": "./bin/markuplint.mjs",
 	"scripts": {
 		"build": "tsc --project tsconfig.build.json",
@@ -34,25 +31,25 @@
 		"clean": "tsc --build --clean tsconfig.build.json"
 	},
 	"devDependencies": {
-		"@markuplint/astro-parser": "5.5.0",
-		"@markuplint/jsx-parser": "5.5.0",
-		"@markuplint/mdx-parser": "5.5.0",
-		"@markuplint/pretenders": "5.5.0",
-		"@markuplint/svelte-parser": "5.5.0",
-		"@markuplint/vue-parser": "5.5.0"
+		"@markuplint/astro-parser": "5.6.1",
+		"@markuplint/jsx-parser": "5.6.1",
+		"@markuplint/mdx-parser": "5.6.1",
+		"@markuplint/pretenders": "5.6.1",
+		"@markuplint/svelte-parser": "5.6.1",
+		"@markuplint/vue-parser": "5.6.1"
 	},
 	"dependencies": {
 		"@markuplint/cli-utils": "5.3.0",
-		"@markuplint/file-resolver": "5.5.0",
-		"@markuplint/html-parser": "5.5.0",
-		"@markuplint/html-spec": "5.5.0",
-		"@markuplint/i18n": "5.5.0",
-		"@markuplint/ml-ast": "5.5.0",
-		"@markuplint/ml-config": "5.5.0",
-		"@markuplint/ml-core": "5.5.0",
-		"@markuplint/ml-spec": "5.5.0",
-		"@markuplint/rules": "5.5.0",
-		"@markuplint/shared": "5.5.0",
+		"@markuplint/file-resolver": "5.6.1",
+		"@markuplint/html-parser": "5.6.1",
+		"@markuplint/html-spec": "5.6.1",
+		"@markuplint/i18n": "5.6.0",
+		"@markuplint/ml-ast": "5.6.0",
+		"@markuplint/ml-config": "5.6.1",
+		"@markuplint/ml-core": "5.6.1",
+		"@markuplint/ml-spec": "5.6.1",
+		"@markuplint/rules": "5.6.1",
+		"@markuplint/shared": "5.6.0",
 		"@types/debug": "^4.1.13",
 		"chokidar": "^6.0.0",
 		"debug": "^4.4.3",
@@ -90,5 +87,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "fedebcfd56eaec4642e68643b2f9e10750d810e1"
+	"gitHead": "a9245162df3699c4880469f493aaaf6103343d83"
 }