eslint-markdown 0.15.0 → 0.16.0

package/build/configs/all.d.ts

@@ -23,6 +23,7 @@ export default function all(plugin: ESLint.Plugin): {
         readonly 'md/consistent-code-style': "error";
         readonly 'md/consistent-delete-style': "error";
         readonly 'md/consistent-emphasis-style': "error";
+        readonly 'md/consistent-heading-style': "error";
         readonly 'md/consistent-inline-code-style': "error";
         readonly 'md/consistent-strong-style': "error";
         readonly 'md/consistent-thematic-break-style': "error";

package/build/configs/all.js

@@ -31,6 +31,7 @@ export default function all(plugin) {
             'md/consistent-code-style': 'error',
             'md/consistent-delete-style': 'error',
             'md/consistent-emphasis-style': 'error',
+            'md/consistent-heading-style': 'error',
             'md/consistent-inline-code-style': 'error',
             'md/consistent-strong-style': 'error',
             'md/consistent-thematic-break-style': 'error',

package/build/configs/stylistic.d.ts

@@ -19,6 +19,7 @@ export default function stylistic(plugin: ESLint.Plugin): {
         readonly 'md/consistent-code-style': "error";
         readonly 'md/consistent-delete-style': "error";
         readonly 'md/consistent-emphasis-style': "error";
+        readonly 'md/consistent-heading-style': "error";
         readonly 'md/consistent-inline-code-style': "error";
         readonly 'md/consistent-strong-style': "error";
         readonly 'md/consistent-thematic-break-style': "error";

package/build/configs/stylistic.js

@@ -27,6 +27,7 @@ export default function stylistic(plugin) {
             'md/consistent-code-style': 'error',
             'md/consistent-delete-style': 'error',
             'md/consistent-emphasis-style': 'error',
+            'md/consistent-heading-style': 'error',
             'md/consistent-inline-code-style': 'error',
             'md/consistent-strong-style': 'error',
             'md/consistent-thematic-break-style': 'error',

package/build/rules/consistent-heading-style.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Rule to enforce consistent heading style.
+ * @author Ga eun Lee(tooth-is-silver)
+ * @author lumir(lumirlumir)
+ * @see https://github.com/DavidAnson/markdownlint/blob/v0.41.1/lib/md003.mjs
+ */
+import type { Heading } from 'mdast';
+type HeadingStyle = (typeof HEADING_STYLE)[number];
+type RuleOptions = [{
+    style: HeadingStyle;
+}];
+type MessageIds = 'style' | 'suggestAtxToSetext' | 'suggestAtxClosedToSetext';
+declare const HEADING_STYLE: readonly ["consistent", "atx", "atx-closed", "setext", "setext-with-atx", "setext-with-atx-closed"];
+declare const _default: {
+    readonly meta: {
+        readonly type: "layout";
+        readonly docs: {
+            readonly description: "Enforce consistent heading style";
+            readonly url: string;
+            readonly recommended: false;
+            readonly stylistic: true;
+        };
+        readonly fixable: "code";
+        readonly hasSuggestions: true;
+        readonly schema: [{
+            readonly type: "object";
+            readonly properties: {
+                readonly style: {
+                    readonly enum: readonly ["consistent", "atx", "atx-closed", "setext", "setext-with-atx", "setext-with-atx-closed"];
+                };
+            };
+            readonly additionalProperties: false;
+        }];
+        readonly defaultOptions: [{
+            readonly style: "consistent";
+        }];
+        readonly messages: {
+            readonly style: "Heading style should be `{{ style }}`.";
+            readonly suggestAtxToSetext: "Replace ATX heading with a Setext heading.";
+            readonly suggestAtxClosedToSetext: "Replace ATX closed heading with a Setext heading.";
+        };
+        readonly language: "markdown";
+        readonly dialects: ["commonmark", "gfm"];
+    };
+    readonly create: (context: import("../core/types.js").RuleContext<{
+        RuleOptions: RuleOptions;
+        MessageIds: MessageIds;
+    }>) => {
+        heading(node: Heading): void;
+        "heading[depth<=2]"(): void;
+        "heading[depth>2]"(): void;
+        'heading:exit'(node: Heading): void;
+    };
+};
+export default _default;

package/build/rules/consistent-heading-style.js

@@ -0,0 +1,290 @@
+/**
+ * @fileoverview Rule to enforce consistent heading style.
+ * @author Ga eun Lee(tooth-is-silver)
+ * @author lumir(lumirlumir)
+ * @see https://github.com/DavidAnson/markdownlint/blob/v0.41.1/lib/md003.mjs
+ */
+import { URL_RULE_DOCS } from '../core/constants.js';
+// --------------------------------------------------------------------------------
+// Helper
+// --------------------------------------------------------------------------------
+const SETEXT_MAX_DEPTH = 2;
+const HEADING_STYLE = [
+    'consistent',
+    'atx',
+    'atx-closed',
+    'setext',
+    'setext-with-atx',
+    'setext-with-atx-closed',
+];
+/**
+ * Matches the closing sequence of a closed ATX heading.
+ * @see https://spec.commonmark.org/0.31.2/#atx-headings
+ */
+const trailingAtxHeadingHashRegex = /[ \t]#+[ \t]*$/;
+/**
+ * Returns the setext marker for the given heading depth.
+ * @param depth The depth of the heading (`1` or `2`).
+ * @returns The setext marker for the given heading depth.
+ */
+function getSetextMarker(depth) {
+    return depth === 1 ? '=' : '-';
+}
+// --------------------------------------------------------------------------------
+// Rule Definition
+// --------------------------------------------------------------------------------
+export default {
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Enforce consistent heading style',
+            url: URL_RULE_DOCS('consistent-heading-style'),
+            recommended: false,
+            stylistic: true,
+        },
+        fixable: 'code',
+        hasSuggestions: true,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    style: {
+                        enum: HEADING_STYLE,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        defaultOptions: [
+            {
+                style: 'consistent',
+            },
+        ],
+        messages: {
+            style: 'Heading style should be `{{ style }}`.',
+            suggestAtxToSetext: 'Replace ATX heading with a Setext heading.',
+            suggestAtxClosedToSetext: 'Replace ATX closed heading with a Setext heading.',
+        },
+        language: 'markdown',
+        dialects: ['commonmark', 'gfm'],
+    },
+    create(context) {
+        const { sourceCode } = context;
+        const [{ style }] = context.options;
+        let headingStyle = style === 'consistent' ? null : style;
+        let currentHeadingStyle = null;
+        let expectedHeadingStyle = null;
+        function reportStyle(node, fix = null, ...suggest) {
+            context.report({
+                node,
+                messageId: 'style',
+                data: {
+                    style: expectedHeadingStyle,
+                },
+                fix,
+                suggest,
+            });
+        }
+        return {
+            // The `heading` selector is more general, so it is visited before the other `heading[xxx]` selectors.
+            heading(node) {
+                const { start, end } = sourceCode.getLoc(node);
+                if (start.line !== end.line /* Multiline Heading */) {
+                    currentHeadingStyle = 'setext';
+                }
+                else if (trailingAtxHeadingHashRegex.test(sourceCode.getText(node))) {
+                    currentHeadingStyle = 'atx-closed';
+                }
+                else {
+                    currentHeadingStyle = 'atx';
+                }
+                if (headingStyle === null) {
+                    headingStyle = currentHeadingStyle;
+                }
+            },
+            [`heading[depth<=${SETEXT_MAX_DEPTH}]`]() {
+                if (headingStyle === 'setext-with-atx' ||
+                    headingStyle === 'setext-with-atx-closed') {
+                    expectedHeadingStyle = 'setext';
+                }
+                else {
+                    expectedHeadingStyle = headingStyle;
+                }
+            },
+            [`heading[depth>${SETEXT_MAX_DEPTH}]`]() {
+                if (headingStyle === 'setext-with-atx') {
+                    expectedHeadingStyle = 'atx';
+                }
+                else if (headingStyle === 'setext-with-atx-closed') {
+                    expectedHeadingStyle = 'atx-closed';
+                }
+                else {
+                    expectedHeadingStyle = headingStyle;
+                }
+            },
+            'heading:exit'(node) {
+                if (currentHeadingStyle === expectedHeadingStyle) {
+                    // Early return if the current heading style matches the expected heading style.
+                    return;
+                }
+                /*
+                 * Possible fix combinations include:
+                 *
+                 * - autofix: 🔧
+                 * - suggestion: 💡
+                 * - no fix: ❌
+                 *
+                 * 1. Converting `atx` to `atx-closed`.
+                 *   1-1. If `atx` is empty, it can be converted to `atx-closed`. (🔧)
+                 *   1-2. If `atx` is not empty, it can be converted to `atx-closed`. (🔧)
+                 * 2. Converting `atx` to `setext`.
+                 *   2-1. If `atx` is empty, it cannot be converted to `setext`. (❌)
+                 *   2-2. If `atx` is not empty:
+                 *     2-2-1. If its depth is 1 or 2, conversion can be offered as a suggestion. (💡)
+                 *            Some edge cases are unsafe: `# > Heading`, `# - Heading`, and `# 1. Heading`.
+                 *     2-2-2. If its depth is greater than 2, it cannot be converted to `setext`. (❌)
+                 * 3. Converting `atx-closed` to `atx`.
+                 *   3-1. If `atx-closed` is empty, it can be converted to `atx`. (🔧)
+                 *   3-2. If `atx-closed` is not empty, it can be converted to `atx`. (🔧)
+                 * 4. Converting `atx-closed` to `setext`.
+                 *   4-1. If `atx-closed` is empty, it cannot be converted to `setext`. (❌)
+                 *   4-2. If `atx-closed` is not empty:
+                 *     4-2-1. If its depth is 1 or 2, conversion can be offered as a suggestion. (💡)
+                 *            Some edge cases are unsafe: `# > Heading #`, `# - Heading #`, and `# 1. Heading #`.
+                 *     4-2-2. If its depth is greater than 2, it cannot be converted to `setext`. (❌)
+                 * 5. Converting `setext` to `atx`.
+                 *   5-1. Setext headings cannot be empty (https://spec.commonmark.org/0.31.2/#example-97)
+                 *   5-2. If `setext` is not empty:
+                 *     5-2-1. If it is single-line, it can be converted to `atx`. (🔧)
+                 *     5-2-2. If it is multiline, it cannot be converted to `atx`. (❌)
+                 * 6. Converting `setext` to `atx-closed`.
+                 *   6-1. Setext headings cannot be empty (https://spec.commonmark.org/0.31.2/#example-97)
+                 *   6-2. If `setext` is not empty:
+                 *     6-2-1. If it is single-line, it can be converted to `atx-closed`. (🔧)
+                 *     6-2-2. If it is multiline, it cannot be converted to `atx-closed`. (❌)
+                 */
+                const [nodeStartOffset, nodeEndOffset] = sourceCode.getRange(node);
+                // The final style checks are exhaustive after matching styles return early.
+                if (currentHeadingStyle === 'atx') {
+                    if (expectedHeadingStyle === 'atx-closed') {
+                        if (node.children.length === 0) {
+                            reportStyle(node, function* fix(fixer) {
+                                if (nodeStartOffset + node.depth === nodeEndOffset) {
+                                    yield fixer.insertTextAfter(node, ' ');
+                                }
+                                yield fixer.insertTextAfter(node, '#'.repeat(node.depth));
+                            });
+                        }
+                        else {
+                            reportStyle(node, function* fix(fixer) {
+                                const [, lastChildNodeEndOffset] = sourceCode.getRange(node.children[node.children.length - 1]);
+                                if (lastChildNodeEndOffset === nodeEndOffset) {
+                                    yield fixer.insertTextAfter(node, ' ');
+                                }
+                                yield fixer.insertTextAfter(node, '#'.repeat(node.depth));
+                            });
+                        }
+                        /* v8 ignore start */
+                    }
+                    else if (expectedHeadingStyle === 'setext') {
+                        /* v8 ignore stop */
+                        if (node.children.length === 0) {
+                            // Empty ATX headings cannot be converted to Setext headings,
+                            // so report the mismatch without a fix.
+                            reportStyle(node);
+                        }
+                        else if (node.depth <= SETEXT_MAX_DEPTH) {
+                            reportStyle(node, null, {
+                                messageId: 'suggestAtxToSetext',
+                                *fix(fixer) {
+                                    const [firstChildNodeStartOffset] = sourceCode.getRange(node.children[0]);
+                                    const [, lastChildNodeEndOffset] = sourceCode.getRange(node.children[node.children.length - 1]);
+                                    yield fixer.removeRange([nodeStartOffset, firstChildNodeStartOffset]);
+                                    yield fixer.replaceTextRange([lastChildNodeEndOffset, nodeEndOffset], `\n${getSetextMarker(node.depth).repeat(lastChildNodeEndOffset - firstChildNodeStartOffset)}`);
+                                },
+                            });
+                        }
+                        else {
+                            reportStyle(node);
+                        }
+                    }
+                }
+                else if (currentHeadingStyle === 'atx-closed') {
+                    if (expectedHeadingStyle === 'atx') {
+                        if (node.children.length === 0) {
+                            reportStyle(node, fixer => fixer.removeRange([nodeStartOffset + node.depth, nodeEndOffset]));
+                        }
+                        else {
+                            reportStyle(node, fixer => {
+                                const [, lastChildNodeEndOffset] = sourceCode.getRange(node.children[node.children.length - 1]);
+                                return fixer.removeRange([lastChildNodeEndOffset, nodeEndOffset]);
+                            });
+                        }
+                        /* v8 ignore start */
+                    }
+                    else if (expectedHeadingStyle === 'setext') {
+                        /* v8 ignore stop */
+                        if (node.children.length === 0) {
+                            // Empty ATX Closed headings cannot be converted to Setext headings,
+                            // so report the mismatch without a fix.
+                            reportStyle(node);
+                        }
+                        else if (node.depth <= SETEXT_MAX_DEPTH) {
+                            reportStyle(node, null, {
+                                messageId: 'suggestAtxClosedToSetext',
+                                *fix(fixer) {
+                                    const [firstChildNodeStartOffset] = sourceCode.getRange(node.children[0]);
+                                    const [, lastChildNodeEndOffset] = sourceCode.getRange(node.children[node.children.length - 1]);
+                                    yield fixer.removeRange([nodeStartOffset, firstChildNodeStartOffset]);
+                                    yield fixer.replaceTextRange([lastChildNodeEndOffset, nodeEndOffset], `\n${getSetextMarker(node.depth).repeat(lastChildNodeEndOffset - firstChildNodeStartOffset)}`);
+                                },
+                            });
+                        }
+                        else {
+                            reportStyle(node);
+                        }
+                    }
+                    /* v8 ignore start */
+                }
+                else if (currentHeadingStyle === 'setext') {
+                    /* v8 ignore stop */
+                    const firstChildNode = node.children[0];
+                    const lastChildNode = node.children[node.children.length - 1];
+                    const { start } = sourceCode.getLoc(firstChildNode);
+                    const { end } = sourceCode.getLoc(lastChildNode);
+                    if (expectedHeadingStyle === 'atx') {
+                        if (start.line === end.line /* Singleline Heading */) {
+                            reportStyle(node, function* fix(fixer) {
+                                const [lastChildNodeStartOffset, lastChildNodeEndOffset] = sourceCode.getRange(lastChildNode);
+                                // Prevent trailing hashes from becoming an ATX closing sequence.
+                                const match = trailingAtxHeadingHashRegex.exec(sourceCode.getText(lastChildNode));
+                                if (match) {
+                                    yield fixer.insertTextBeforeRange([lastChildNodeStartOffset + match.index + 1, lastChildNodeEndOffset], '\\');
+                                }
+                                yield fixer.insertTextBefore(firstChildNode, `${'#'.repeat(node.depth)} `);
+                                yield fixer.removeRange([lastChildNodeEndOffset, nodeEndOffset]);
+                            });
+                        }
+                        else /* Multiline Heading */ {
+                            reportStyle(node);
+                        }
+                        /* v8 ignore start */
+                    }
+                    else if (expectedHeadingStyle === 'atx-closed') {
+                        /* v8 ignore stop */
+                        if (start.line === end.line /* Singleline Heading */) {
+                            reportStyle(node, function* fix(fixer) {
+                                const [, lastChildNodeEndOffset] = sourceCode.getRange(lastChildNode);
+                                yield fixer.insertTextBefore(firstChildNode, `${'#'.repeat(node.depth)} `);
+                                yield fixer.replaceTextRange([lastChildNodeEndOffset, nodeEndOffset], ` ${'#'.repeat(node.depth)}`);
+                            });
+                        }
+                        else /* Multiline Heading */ {
+                            reportStyle(node);
+                        }
+                    }
+                }
+            },
+        };
+    },
+};

package/build/rules/index.d.ts

@@ -566,6 +566,49 @@ declare const _default: {
             emphasis(node: import("mdast").Emphasis): void;
         };
     };
+    'consistent-heading-style': {
+        readonly meta: {
+            readonly type: "layout";
+            readonly docs: {
+                readonly description: "Enforce consistent heading style";
+                readonly url: string;
+                readonly recommended: false;
+                readonly stylistic: true;
+            };
+            readonly fixable: "code";
+            readonly hasSuggestions: true;
+            readonly schema: [{
+                readonly type: "object";
+                readonly properties: {
+                    readonly style: {
+                        readonly enum: readonly ["consistent", "atx", "atx-closed", "setext", "setext-with-atx", "setext-with-atx-closed"];
+                    };
+                };
+                readonly additionalProperties: false;
+            }];
+            readonly defaultOptions: [{
+                readonly style: "consistent";
+            }];
+            readonly messages: {
+                readonly style: "Heading style should be `{{ style }}`.";
+                readonly suggestAtxToSetext: "Replace ATX heading with a Setext heading.";
+                readonly suggestAtxClosedToSetext: "Replace ATX closed heading with a Setext heading.";
+            };
+            readonly language: "markdown";
+            readonly dialects: ["commonmark", "gfm"];
+        };
+        readonly create: (context: import("../core/types.js").RuleContext<{
+            RuleOptions: [{
+                style: "consistent" | "atx" | "atx-closed" | "setext" | "setext-with-atx" | "setext-with-atx-closed";
+            }];
+            MessageIds: "style" | "suggestAtxToSetext" | "suggestAtxClosedToSetext";
+        }>) => {
+            heading(node: import("mdast").Heading): void;
+            "heading[depth<=2]"(): void;
+            "heading[depth>2]"(): void;
+            'heading:exit'(node: import("mdast").Heading): void;
+        };
+    };
     'consistent-inline-code-style': {
         readonly meta: {
             readonly type: "layout";
@@ -694,7 +737,7 @@ declare const _default: {
         };
         readonly create: (context: import("../core/types.js").RuleContext<{
             RuleOptions: [{
-                style: "consistent" | "sublist" | ("*" | "+" | "-");
+                style: "consistent" | "sublist" | ("*" | "-" | "+");
             }];
             MessageIds: "style";
         }>) => {
@@ -1139,6 +1182,12 @@ declare const _default: {
                     readonly skipInlineCode: {
                         readonly type: "boolean";
                     };
+                    readonly skipMath: {
+                        readonly type: "boolean";
+                    };
+                    readonly skipInlineMath: {
+                        readonly type: "boolean";
+                    };
                 };
                 readonly additionalProperties: false;
             }];
@@ -1146,6 +1195,8 @@ declare const _default: {
                 readonly allow: [];
                 readonly skipCode: true;
                 readonly skipInlineCode: true;
+                readonly skipMath: true;
+                readonly skipInlineMath: true;
             }];
             readonly messages: {
                 readonly noIrregularWhitespace: "Irregular whitespace `{{ irregularWhitespace }}` is not allowed.";
@@ -1158,11 +1209,15 @@ declare const _default: {
                 allow: string[];
                 skipCode: boolean | string[];
                 skipInlineCode: boolean;
+                skipMath: boolean;
+                skipInlineMath: boolean;
             }];
             MessageIds: "noIrregularWhitespace";
         }>) => {
             code(node: import("mdast").Code): void;
             inlineCode(node: import("mdast").InlineCode): void;
+            math(node: import("mdast-util-math").Math): void;
+            inlineMath(node: import("mdast-util-math").InlineMath): void;
             'root:exit'(): void;
         };
     };

package/build/rules/index.js

@@ -7,6 +7,7 @@ import codeLangShorthand from './code-lang-shorthand.js';
 import consistentCodeStyle from './consistent-code-style.js';
 import consistentDeleteStyle from './consistent-delete-style.js';
 import consistentEmphasisStyle from './consistent-emphasis-style.js';
+import consistentHeadingStyle from './consistent-heading-style.js';
 import consistentInlineCodeStyle from './consistent-inline-code-style.js';
 import consistentStrongStyle from './consistent-strong-style.js';
 import consistentThematicBreakStyle from './consistent-thematic-break-style.js';
@@ -35,6 +36,7 @@ export default {
     'consistent-code-style': consistentCodeStyle,
     'consistent-delete-style': consistentDeleteStyle,
     'consistent-emphasis-style': consistentEmphasisStyle,
+    'consistent-heading-style': consistentHeadingStyle,
     'consistent-inline-code-style': consistentInlineCodeStyle,
     'consistent-strong-style': consistentStrongStyle,
     'consistent-thematic-break-style': consistentThematicBreakStyle,

package/build/rules/no-git-conflict-marker.d.ts

@@ -13,7 +13,7 @@ type RuleOptions = [
          */
         skipCode: boolean | string[];
         /**
-         * `true` allows Git conflict markers in math blocks.
+         * `true` allows Git conflict markers in all math blocks.
          * @default true
          */
         skipMath: boolean;

package/build/rules/no-irregular-whitespace.d.ts

@@ -24,6 +24,16 @@ type RuleOptions = [
          * @default true
          */
         skipInlineCode: boolean;
+        /**
+         * `true` allows irregular whitespaces in all math blocks.
+         * @default true
+         */
+        skipMath: boolean;
+        /**
+         * `true` allows irregular whitespaces in all inline math.
+         * @default true
+         */
+        skipInlineMath: boolean;
     }
 ];
 declare const _default: {
@@ -59,6 +69,12 @@ declare const _default: {
                 readonly skipInlineCode: {
                     readonly type: "boolean";
                 };
+                readonly skipMath: {
+                    readonly type: "boolean";
+                };
+                readonly skipInlineMath: {
+                    readonly type: "boolean";
+                };
             };
             readonly additionalProperties: false;
         }];
@@ -66,6 +82,8 @@ declare const _default: {
             readonly allow: [];
             readonly skipCode: true;
             readonly skipInlineCode: true;
+            readonly skipMath: true;
+            readonly skipInlineMath: true;
         }];
         readonly messages: {
             readonly noIrregularWhitespace: "Irregular whitespace `{{ irregularWhitespace }}` is not allowed.";
@@ -79,6 +97,8 @@ declare const _default: {
     }>) => {
         code(node: import("mdast").Code): void;
         inlineCode(node: import("mdast").InlineCode): void;
+        math(node: import("mdast-util-math").Math): void;
+        inlineMath(node: import("mdast-util-math").InlineMath): void;
         'root:exit'(): void;
     };
 };

package/build/rules/no-irregular-whitespace.js

@@ -51,6 +51,12 @@ export default {
                     skipInlineCode: {
                         type: 'boolean',
                     },
+                    skipMath: {
+                        type: 'boolean',
+                    },
+                    skipInlineMath: {
+                        type: 'boolean',
+                    },
                 },
                 additionalProperties: false,
             },
@@ -60,6 +66,8 @@ export default {
                 allow: [],
                 skipCode: true,
                 skipInlineCode: true,
+                skipMath: true,
+                skipInlineMath: true,
             },
         ],
         messages: {
@@ -70,7 +78,7 @@ export default {
     },
     create(context) {
         const { sourceCode } = context;
-        const [{ allow, skipCode, skipInlineCode }] = context.options;
+        const [{ allow, skipCode, skipInlineCode, skipMath, skipInlineMath }] = context.options;
         const skipRanges = new SkipRanges();
         return {
             code(node) {
@@ -81,6 +89,14 @@ export default {
                 if (skipInlineCode)
                     skipRanges.push(sourceCode.getRange(node)); // Store range information of `InlineCode`.
             },
+            math(node) {
+                if (skipMath)
+                    skipRanges.push(sourceCode.getRange(node)); // Store range information of `Math`.
+            },
+            inlineMath(node) {
+                if (skipInlineMath)
+                    skipRanges.push(sourceCode.getRange(node)); // Store range information of `InlineMath`.
+            },
             'root:exit'() {
                 const matches = sourceCode.text.matchAll(irregularWhitespaceRegex);
                 for (const match of matches) {

package/build/rules/no-url-trailing-slash.js

@@ -38,7 +38,7 @@ function hasTrailingSlash(url) {
          *     -------------------------------------------------^
          */
         if (hash) {
-            urlWithoutSearchAndHash = urlWithoutSearchAndHash.slice(0, url.indexOf(hash));
+            urlWithoutSearchAndHash = urlWithoutSearchAndHash.slice(0, url.indexOf('#'));
         }
         else if (urlWithoutSearchAndHash.endsWith('#')) {
             urlWithoutSearchAndHash = urlWithoutSearchAndHash.slice(0, -1);
@@ -56,7 +56,7 @@ function hasTrailingSlash(url) {
          *     ------------------------------------^
          */
         if (search) {
-            urlWithoutSearchAndHash = urlWithoutSearchAndHash.slice(0, url.indexOf(search));
+            urlWithoutSearchAndHash = urlWithoutSearchAndHash.slice(0, url.indexOf('?'));
         }
         else if (urlWithoutSearchAndHash.endsWith('?')) {
             urlWithoutSearchAndHash = urlWithoutSearchAndHash.slice(0, -1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-markdown",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "type": "module",
   "sideEffects": false,
   "description": "Lint your Markdown with ESLint. Additional rules for use with `@eslint/markdown`.🛠️",