eslint-markdown 0.17.1 → 0.18.0

package/build/configs/all.d.ts

@@ -37,6 +37,7 @@ export default function all(plugin: ESLint.Plugin): {
         readonly 'md/no-git-conflict-marker': "error";
         readonly 'md/no-irregular-dash': "error";
         readonly 'md/no-irregular-whitespace': "error";
+        readonly 'md/no-multiple-atx-heading-space': "error";
         readonly 'md/no-shell-dollar': "error";
         readonly 'md/no-tab': "error";
         readonly 'md/no-trailing-heading-punctuation': "error";

package/build/configs/all.js

@@ -45,6 +45,7 @@ export default function all(plugin) {
             'md/no-git-conflict-marker': 'error',
             'md/no-irregular-dash': 'error',
             'md/no-irregular-whitespace': 'error',
+            'md/no-multiple-atx-heading-space': 'error',
             'md/no-shell-dollar': 'error',
             'md/no-tab': 'error',
             'md/no-trailing-heading-punctuation': 'error',

package/build/configs/stylistic.d.ts

@@ -25,6 +25,7 @@ export default function stylistic(plugin: ESLint.Plugin): {
         readonly 'md/consistent-thematic-break-style': "error";
         readonly 'md/consistent-unordered-list-style': "error";
         readonly 'md/no-consecutive-blank-line': "error";
+        readonly 'md/no-multiple-atx-heading-space': "error";
         readonly 'md/no-tab': "error";
         readonly 'md/no-trailing-heading-punctuation': "error";
     };

package/build/configs/stylistic.js

@@ -33,6 +33,7 @@ export default function stylistic(plugin) {
             'md/consistent-thematic-break-style': 'error',
             'md/consistent-unordered-list-style': 'error',
             'md/no-consecutive-blank-line': 'error',
+            'md/no-multiple-atx-heading-space': 'error',
             'md/no-tab': 'error',
             'md/no-trailing-heading-punctuation': 'error',
         },

package/build/core/constants.d.ts

@@ -40,3 +40,8 @@ export declare const escapedTrailingBackslashRegex: RegExp;
  * @see https://github.com/DavidAnson/markdownlint/blob/v0.41.1/helpers/helpers.cjs#L36-L38
  */
 export declare const gemojiRegex: RegExp;
+/**
+ * Matches the closing sequence of a closed ATX heading.
+ * @see https://spec.commonmark.org/0.31.2/#atx-headings
+ */
+export declare const trailingAtxHeadingHashRegex: RegExp;

package/build/core/constants.js

@@ -59,5 +59,10 @@ export const escapedTrailingBackslashRegex = /(?<=(?<!\\)(?:\\{2})*)\\$/u;
  * @see https://github.com/DavidAnson/markdownlint/blob/v0.41.1/helpers/helpers.cjs#L36-L38
  */
 export const gemojiRegex = /:(?:[abmovx]|[-+]1|100|1234|(?:1st|2nd|3rd)_place_medal|8ball|clock\d{1,4}|e-mail|non-potable_water|o2|t-rex|u5272|u5408|u55b6|u6307|u6708|u6709|u6e80|u7121|u7533|u7981|u7a7a|[a-z]{2,15}2?|[a-z]{1,14}(?:_[a-z\d]{1,16})+):/;
+/**
+ * Matches the closing sequence of a closed ATX heading.
+ * @see https://spec.commonmark.org/0.31.2/#atx-headings
+ */
+export const trailingAtxHeadingHashRegex = /[ \t]#+[ \t]*$/;
 // #endregion regex
 // --------------------------------------------------------------------------------

package/build/core/utils/get-heading-style.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Get the style of a Markdown heading.
+ */
+import type { MarkdownSourceCode } from '@eslint/markdown';
+import type { Heading } from 'mdast';
+export type HeadingStyle = (typeof HEADING_STYLE)[number];
+export declare const HEADING_STYLE: readonly ["atx", "atx-closed", "setext"];
+/**
+ * Gets the style of a Markdown heading.
+ * @param node The heading node.
+ * @param sourceCode The Markdown source code.
+ * @returns The heading style.
+ */
+export declare function getHeadingStyle(node: Heading, sourceCode: MarkdownSourceCode): HeadingStyle;

package/build/core/utils/get-heading-style.js

@@ -0,0 +1,26 @@
+/**
+ * @fileoverview Get the style of a Markdown heading.
+ */
+import { trailingAtxHeadingHashRegex } from '../constants.js';
+// --------------------------------------------------------------------------------
+// Export
+// --------------------------------------------------------------------------------
+export const HEADING_STYLE = ['atx', 'atx-closed', 'setext'];
+/**
+ * Gets the style of a Markdown heading.
+ * @param node The heading node.
+ * @param sourceCode The Markdown source code.
+ * @returns The heading style.
+ */
+export function getHeadingStyle(node, sourceCode) {
+    const { start, end } = sourceCode.getLoc(node);
+    if (start.line !== end.line /* Multiline Heading */) {
+        return 'setext';
+    }
+    else if (trailingAtxHeadingHashRegex.test(sourceCode.getText(node))) {
+        return 'atx-closed';
+    }
+    else {
+        return 'atx';
+    }
+}

package/build/core/utils/index.d.ts

@@ -1,5 +1,6 @@
 export * from './escape-string-regexp.js';
 export * from './get-code-style.js';
+export * from './get-heading-style.js';
 export * from './html.js';
 export * from './is-blank-line.js';
 export * from './normalize-regex-pattern.js';

package/build/core/utils/index.js

@@ -1,5 +1,6 @@
 export * from './escape-string-regexp.js';
 export * from './get-code-style.js';
+export * from './get-heading-style.js';
 export * from './html.js';
 export * from './is-blank-line.js';
 export * from './normalize-regex-pattern.js';

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

@@ -2,7 +2,6 @@
  * @fileoverview Rule to enforce consistent code style.
  * @author lumir(lumirlumir)
  */
-import { type CodeStyle } from '../core/utils/index.js';
 /**
  * Options for the `consistent-code-style` rule.
  */
@@ -12,7 +11,7 @@ type RuleOptions = [
          * When `style` is set to `'consistent'`, the rule enforces that all code blocks in the document use the same style as the first one encountered.
          * @default 'consistent'
          */
-        style: 'consistent' | CodeStyle;
+        style: (typeof EXTENDED_CODE_STYLE)[number];
         /**
          * Require a specific number of blank lines above each fenced code block.
          * @default false
@@ -26,6 +25,7 @@ type RuleOptions = [
     }
 ];
 type MessageIds = 'style' | 'blankLineAbove' | 'blankLineBelow';
+declare const EXTENDED_CODE_STYLE: readonly ["consistent", "indent", "fence-backtick", "fence-tilde"];
 declare const _default: {
     readonly meta: {
         readonly type: "layout";
@@ -39,7 +39,7 @@ declare const _default: {
             readonly type: "object";
             readonly properties: {
                 readonly style: {
-                    readonly enum: ["consistent", "indent", "fence-backtick", "fence-tilde"];
+                    readonly enum: readonly ["consistent", "indent", "fence-backtick", "fence-tilde"];
                 };
                 readonly blankLineAbove: {
                     readonly oneOf: [{

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

@@ -17,6 +17,10 @@
 import { CODE_STYLE, getCodeStyle, isBlankLine, } from '../core/utils/index.js';
 import { URL_RULE_DOCS } from '../core/constants.js';
 // --------------------------------------------------------------------------------
+// Helper
+// --------------------------------------------------------------------------------
+const EXTENDED_CODE_STYLE = ['consistent', ...CODE_STYLE];
+// --------------------------------------------------------------------------------
 // Rule Definition
 // --------------------------------------------------------------------------------
 export default {
@@ -35,7 +39,7 @@ export default {
                 type: 'object',
                 properties: {
                     style: {
-                        enum: ['consistent', ...CODE_STYLE],
+                        enum: EXTENDED_CODE_STYLE,
                     },
                     blankLineAbove: {
                         oneOf: [

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

@@ -5,12 +5,25 @@
  * @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 RuleOptions = [
+    {
+        /**
+         * When `style` is set to `'consistent'`, the rule enforces that all headings in the document use the same style as the first one encountered.
+         *
+         * You can also specify a particular style by setting `style` to one of the following values:
+         *
+         * - `'atx'`: Require ATX headings at every level, such as `## Heading`.
+         * - `'atx-closed'`: Require closed ATX headings at every level, such as `## Heading ##`.
+         * - `'setext'`: Require Setext headings at levels 1 and 2. Headings at levels 3 through 6 are reported because Setext does not support those levels.
+         * - `'setext-with-atx'`: Require Setext headings at levels 1 and 2, and ATX headings at levels 3 through 6.
+         * - `'setext-with-atx-closed'`: Require Setext headings at levels 1 and 2, and closed ATX headings at levels 3 through 6.
+         * @default 'consistent'
+         */
+        style: (typeof EXTENDED_HEADING_STYLE)[number];
+    }
+];
 type MessageIds = 'style' | 'suggestAtxToSetext' | 'suggestAtxClosedToSetext';
-declare const HEADING_STYLE: readonly ["consistent", "atx", "atx-closed", "setext", "setext-with-atx", "setext-with-atx-closed"];
+declare const EXTENDED_HEADING_STYLE: readonly ["consistent", "atx", "atx-closed", "setext", "setext-with-atx", "setext-with-atx-closed"];
 declare const _default: {
     readonly meta: {
         readonly type: "layout";

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

@@ -4,24 +4,18 @@
  * @author lumir(lumirlumir)
  * @see https://github.com/DavidAnson/markdownlint/blob/v0.41.1/lib/md003.mjs
  */
-import { URL_RULE_DOCS } from '../core/constants.js';
+import { HEADING_STYLE, getHeadingStyle } from '../core/utils/index.js';
+import { URL_RULE_DOCS, trailingAtxHeadingHashRegex } from '../core/constants.js';
 // --------------------------------------------------------------------------------
 // Helper
 // --------------------------------------------------------------------------------
 const SETEXT_MAX_DEPTH = 2;
-const HEADING_STYLE = [
+const EXTENDED_HEADING_STYLE = [
     'consistent',
-    'atx',
-    'atx-closed',
-    'setext',
+    ...HEADING_STYLE,
     '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`).
@@ -49,7 +43,7 @@ export default {
                 type: 'object',
                 properties: {
                     style: {
-                        enum: HEADING_STYLE,
+                        enum: EXTENDED_HEADING_STYLE,
                     },
                 },
                 additionalProperties: false,
@@ -88,16 +82,7 @@ export default {
         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';
-                }
+                currentHeadingStyle = getHeadingStyle(node, sourceCode);
                 if (headingStyle === null) {
                     headingStyle = currentHeadingStyle;
                 }

package/build/rules/index.d.ts

@@ -445,7 +445,7 @@ declare const _default: {
                 readonly type: "object";
                 readonly properties: {
                     readonly style: {
-                        readonly enum: ["consistent", "indent", "fence-backtick", "fence-tilde"];
+                        readonly enum: readonly ["consistent", "indent", "fence-backtick", "fence-tilde"];
                     };
                     readonly blankLineAbove: {
                         readonly oneOf: [{
@@ -481,7 +481,7 @@ declare const _default: {
         };
         readonly create: (context: import("../core/types.js").RuleContext<{
             RuleOptions: [{
-                style: "consistent" | import("../core/utils/get-code-style.js").CodeStyle;
+                style: "indent" | "fence-backtick" | "fence-tilde" | "consistent";
                 blankLineAbove: number | false;
                 blankLineBelow: number | false;
             }];
@@ -599,7 +599,7 @@ declare const _default: {
         };
         readonly create: (context: import("../core/types.js").RuleContext<{
             RuleOptions: [{
-                style: "consistent" | "atx" | "atx-closed" | "setext" | "setext-with-atx" | "setext-with-atx-closed";
+                style: "atx" | "atx-closed" | "setext" | "consistent" | "setext-with-atx" | "setext-with-atx-closed";
             }];
             MessageIds: "style" | "suggestAtxToSetext" | "suggestAtxClosedToSetext";
         }>) => {
@@ -774,12 +774,16 @@ declare const _default: {
                             readonly uniqueItems: true;
                         }];
                     };
+                    readonly skipMath: {
+                        readonly type: "boolean";
+                    };
                 };
                 readonly additionalProperties: false;
             }];
             readonly defaultOptions: [{
                 readonly max: 1;
                 readonly skipCode: true;
+                readonly skipMath: true;
             }];
             readonly messages: {
                 readonly noConsecutiveBlankLine: "More than {{ max }} consecutive blank line(s) are not allowed.";
@@ -791,10 +795,12 @@ declare const _default: {
             RuleOptions: [{
                 max: number;
                 skipCode: boolean | string[];
+                skipMath: boolean;
             }];
             MessageIds: "noConsecutiveBlankLine";
         }>) => {
             code(node: import("mdast").Code): void;
+            math(node: import("mdast-util-math").Math): void;
             'root:exit'(): void;
         };
     };
@@ -1016,11 +1022,15 @@ declare const _default: {
                         };
                         readonly uniqueItems: true;
                     };
+                    readonly style: {
+                        readonly enum: ["emoji", "gemoji"];
+                    };
                 };
                 readonly additionalProperties: false;
             }];
             readonly defaultOptions: [{
                 readonly allow: [];
+                readonly style: "emoji";
             }];
             readonly messages: {
                 readonly noEmoji: "Emojis are not allowed.";
@@ -1031,6 +1041,7 @@ declare const _default: {
         readonly create: (context: import("../core/types.js").RuleContext<{
             RuleOptions: [{
                 allow: string[];
+                style: "emoji" | "gemoji";
             }];
             MessageIds: "noEmoji";
         }>) => {
@@ -1245,6 +1256,44 @@ declare const _default: {
             'root:exit'(): void;
         };
     };
+    'no-multiple-atx-heading-space': {
+        readonly meta: {
+            readonly type: "layout";
+            readonly docs: {
+                readonly description: "Disallow multiple spaces around ATX heading markers";
+                readonly url: string;
+                readonly recommended: false;
+                readonly stylistic: true;
+            };
+            readonly fixable: "whitespace";
+            readonly schema: [{
+                readonly type: "object";
+                readonly properties: {
+                    readonly checkClosedHeading: {
+                        readonly type: "boolean";
+                    };
+                };
+                readonly additionalProperties: false;
+            }];
+            readonly defaultOptions: [{
+                readonly checkClosedHeading: true;
+            }];
+            readonly messages: {
+                readonly noMultipleAtxHeadingSpace: "Multiple spaces after opening ATX heading markers are not allowed.";
+                readonly noMultipleAtxClosedHeadingSpace: "Multiple spaces before closing ATX heading markers are not allowed.";
+            };
+            readonly language: "markdown";
+            readonly dialects: ["commonmark", "gfm"];
+        };
+        readonly create: (context: import("../core/types.js").RuleContext<{
+            RuleOptions: [{
+                checkClosedHeading: boolean;
+            }];
+            MessageIds: "noMultipleAtxHeadingSpace" | "noMultipleAtxClosedHeadingSpace";
+        }>) => {
+            heading(node: import("mdast").Heading): void;
+        };
+    };
     'no-shell-dollar': {
         readonly meta: {
             readonly type: "problem";
@@ -1313,6 +1362,12 @@ declare const _default: {
                     readonly skipInlineCode: {
                         readonly type: "boolean";
                     };
+                    readonly skipMath: {
+                        readonly type: "boolean";
+                    };
+                    readonly skipInlineMath: {
+                        readonly type: "boolean";
+                    };
                     readonly tabWidth: {
                         readonly type: "integer";
                         readonly minimum: 1;
@@ -1323,6 +1378,8 @@ declare const _default: {
             readonly defaultOptions: [{
                 readonly skipCode: true;
                 readonly skipInlineCode: true;
+                readonly skipMath: true;
+                readonly skipInlineMath: true;
                 readonly tabWidth: 4;
             }];
             readonly messages: {
@@ -1335,12 +1392,16 @@ declare const _default: {
             RuleOptions: [{
                 skipCode: boolean | string[];
                 skipInlineCode: boolean;
+                skipMath: boolean;
+                skipInlineMath: boolean;
                 tabWidth: number;
             }];
             MessageIds: "noTab";
         }>) => {
             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

@@ -22,6 +22,7 @@ import noEmoji from './no-emoji.js';
 import noGitConflictMarker from './no-git-conflict-marker.js';
 import noIrregularDash from './no-irregular-dash.js';
 import noIrregularWhitespace from './no-irregular-whitespace.js';
+import noMultipleAtxHeadingSpace from './no-multiple-atx-heading-space.js';
 import noShellDollar from './no-shell-dollar.js';
 import noTab from './no-tab.js';
 import noTrailingHeadingPunctuation from './no-trailing-heading-punctuation.js';
@@ -52,6 +53,7 @@ export default {
     'no-git-conflict-marker': noGitConflictMarker,
     'no-irregular-dash': noIrregularDash,
     'no-irregular-whitespace': noIrregularWhitespace,
+    'no-multiple-atx-heading-space': noMultipleAtxHeadingSpace,
     'no-shell-dollar': noShellDollar,
     'no-tab': noTab,
     'no-trailing-heading-punctuation': noTrailingHeadingPunctuation,

package/build/rules/no-consecutive-blank-line.d.ts

@@ -20,6 +20,11 @@ type RuleOptions = [
          * @default true
          */
         skipCode: boolean | string[];
+        /**
+         * `true` allows consecutive blank lines in all math blocks.
+         * @default true
+         */
+        skipMath: boolean;
     }
 ];
 declare const _default: {
@@ -50,12 +55,16 @@ declare const _default: {
                         readonly uniqueItems: true;
                     }];
                 };
+                readonly skipMath: {
+                    readonly type: "boolean";
+                };
             };
             readonly additionalProperties: false;
         }];
         readonly defaultOptions: [{
             readonly max: 1;
             readonly skipCode: true;
+            readonly skipMath: true;
         }];
         readonly messages: {
             readonly noConsecutiveBlankLine: "More than {{ max }} consecutive blank line(s) are not allowed.";
@@ -68,6 +77,7 @@ declare const _default: {
         MessageIds: "noConsecutiveBlankLine";
     }>) => {
         code(node: import("mdast").Code): void;
+        math(node: import("mdast-util-math").Math): void;
         'root:exit'(): void;
     };
 };

package/build/rules/no-consecutive-blank-line.js

@@ -43,6 +43,9 @@ export default {
                             },
                         ],
                     },
+                    skipMath: {
+                        type: 'boolean',
+                    },
                 },
                 additionalProperties: false,
             },
@@ -51,6 +54,7 @@ export default {
             {
                 max: 1,
                 skipCode: true,
+                skipMath: true,
             },
         ],
         messages: {
@@ -61,7 +65,7 @@ export default {
     },
     create(context) {
         const { options, sourceCode } = context;
-        const [{ max, skipCode }] = options;
+        const [{ max, skipCode, skipMath }] = options;
         const { lines, text } = sourceCode;
         const skipRanges = new SkipRanges();
         return {
@@ -69,6 +73,10 @@ export default {
                 if (Array.isArray(skipCode) ? node.lang && skipCode.includes(node.lang) : skipCode)
                     skipRanges.push(sourceCode.getRange(node)); // Store range information of `Code`.
             },
+            math(node) {
+                if (skipMath)
+                    skipRanges.push(sourceCode.getRange(node)); // Store range information of `Math`.
+            },
             'root:exit'() {
                 let consecutiveBlankLineCount = 0;
                 for (let currentLineIdx = 0; currentLineIdx < lines.length; currentLineIdx++) {

package/build/rules/no-emoji.d.ts

@@ -10,10 +10,19 @@ type RuleOptions = [
         /**
          * When specified, specific emoji sequences are allowed if they match one of the strings in this array.
          *
-         * This is useful when a document intentionally uses a small set of raw Unicode emojis while still disallowing all others.
+         * This is useful when a document intentionally uses a small set of raw Unicode emojis or shortcode style emojis
+         * while still disallowing all others. When `style` is `'gemoji'`, list shortcodes instead (e.g. `':smiley:'`).
          * @default []
          */
         allow: string[];
+        /**
+         * Specifies the style of emojis to disallow.
+         *
+         * - `'emoji'`: Raw Unicode emojis (`😃`).
+         * - `'gemoji'`: Shortcode style emojis (`:smiley:`).
+         * @default 'emoji'
+         */
+        style: 'emoji' | 'gemoji';
     }
 ];
 declare const _default: {
@@ -35,11 +44,15 @@ declare const _default: {
                     };
                     readonly uniqueItems: true;
                 };
+                readonly style: {
+                    readonly enum: ["emoji", "gemoji"];
+                };
             };
             readonly additionalProperties: false;
         }];
         readonly defaultOptions: [{
             readonly allow: [];
+            readonly style: "emoji";
         }];
         readonly messages: {
             readonly noEmoji: "Emojis are not allowed.";

package/build/rules/no-emoji.js

@@ -5,11 +5,12 @@
 // --------------------------------------------------------------------------------
 // Import
 // --------------------------------------------------------------------------------
-import { URL_RULE_DOCS } from '../core/constants.js';
+import { URL_RULE_DOCS, gemojiRegex as originalGemojiRegex } from '../core/constants.js';
 // --------------------------------------------------------------------------------
 // Helper
 // --------------------------------------------------------------------------------
 const emojiRegex = /\p{RGI_Emoji}/gv;
+const gemojiRegex = new RegExp(originalGemojiRegex.source, 'g');
 // --------------------------------------------------------------------------------
 // Rule Definition
 // --------------------------------------------------------------------------------
@@ -33,6 +34,9 @@ export default {
                         },
                         uniqueItems: true,
                     },
+                    style: {
+                        enum: ['emoji', 'gemoji'],
+                    },
                 },
                 additionalProperties: false,
             },
@@ -40,6 +44,7 @@ export default {
         defaultOptions: [
             {
                 allow: [],
+                style: 'emoji',
             },
         ],
         messages: {
@@ -50,11 +55,13 @@ export default {
     },
     create(context) {
         const { sourceCode } = context;
-        const [{ allow }] = context.options;
+        const [{ allow, style }] = context.options;
         return {
             text(node) {
                 const [nodeStartOffset] = sourceCode.getRange(node);
-                const matches = sourceCode.getText(node).matchAll(emojiRegex);
+                const matches = sourceCode
+                    .getText(node)
+                    .matchAll(style === 'emoji' ? emojiRegex : gemojiRegex);
                 for (const match of matches) {
                     const emoji = match[0];
                     if (allow.includes(emoji))

package/build/rules/no-multiple-atx-heading-space.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Rule to disallow multiple spaces around ATX heading markers.
+ * @author Ga eun Lee(tooth-is-silver)
+ */
+/**
+ * Options for the `no-multiple-atx-heading-space` rule.
+ */
+type RuleOptions = [
+    {
+        /**
+         * When `checkClosedHeading` is set to `false`, this rule stops checking for multiple
+         * consecutive spaces or tabs before the closing hash characters in closed ATX headings.
+         * @default true
+         */
+        checkClosedHeading: boolean;
+    }
+];
+type MessageIds = 'noMultipleAtxHeadingSpace' | 'noMultipleAtxClosedHeadingSpace';
+declare const _default: {
+    readonly meta: {
+        readonly type: "layout";
+        readonly docs: {
+            readonly description: "Disallow multiple spaces around ATX heading markers";
+            readonly url: string;
+            readonly recommended: false;
+            readonly stylistic: true;
+        };
+        readonly fixable: "whitespace";
+        readonly schema: [{
+            readonly type: "object";
+            readonly properties: {
+                readonly checkClosedHeading: {
+                    readonly type: "boolean";
+                };
+            };
+            readonly additionalProperties: false;
+        }];
+        readonly defaultOptions: [{
+            readonly checkClosedHeading: true;
+        }];
+        readonly messages: {
+            readonly noMultipleAtxHeadingSpace: "Multiple spaces after opening ATX heading markers are not allowed.";
+            readonly noMultipleAtxClosedHeadingSpace: "Multiple spaces before closing ATX heading markers are not allowed.";
+        };
+        readonly language: "markdown";
+        readonly dialects: ["commonmark", "gfm"];
+    };
+    readonly create: (context: import("../core/types.js").RuleContext<{
+        RuleOptions: RuleOptions;
+        MessageIds: MessageIds;
+    }>) => {
+        heading(node: import("mdast").Heading): void;
+    };
+};
+export default _default;

package/build/rules/no-multiple-atx-heading-space.js

@@ -0,0 +1,101 @@
+/**
+ * @fileoverview Rule to disallow multiple spaces around ATX heading markers.
+ * @author Ga eun Lee(tooth-is-silver)
+ */
+// --------------------------------------------------------------------------------
+// Import
+// --------------------------------------------------------------------------------
+import { getHeadingStyle } from '../core/utils/index.js';
+import { URL_RULE_DOCS } from '../core/constants.js';
+// --------------------------------------------------------------------------------
+// Helper
+// --------------------------------------------------------------------------------
+const multipleSpacesRegex = /^[ \t]{2,}/u;
+// --------------------------------------------------------------------------------
+// Rule Definition
+// --------------------------------------------------------------------------------
+export default {
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Disallow multiple spaces around ATX heading markers',
+            url: URL_RULE_DOCS('no-multiple-atx-heading-space'),
+            recommended: false,
+            stylistic: true,
+        },
+        fixable: 'whitespace',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    checkClosedHeading: {
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        defaultOptions: [
+            {
+                checkClosedHeading: true,
+            },
+        ],
+        messages: {
+            noMultipleAtxHeadingSpace: 'Multiple spaces after opening ATX heading markers are not allowed.',
+            noMultipleAtxClosedHeadingSpace: 'Multiple spaces before closing ATX heading markers are not allowed.',
+        },
+        language: 'markdown',
+        dialects: ['commonmark', 'gfm'],
+    },
+    create(context) {
+        const { sourceCode } = context;
+        const [{ checkClosedHeading }] = context.options;
+        /**
+         * @param text Text starting immediately after an opening sequence or heading content.
+         * @param textStartOffset Start offset of the text.
+         * @param messageId Message for the opening or closing sequence.
+         */
+        function report(text, textStartOffset, messageId) {
+            const spacesMatch = multipleSpacesRegex.exec(text)?.[0];
+            if (!spacesMatch)
+                return;
+            // Empty ATX headings keep no whitespace; otherwise, keep the first character.
+            const startOffset = textStartOffset + Number(spacesMatch.length !== text.length);
+            const endOffset = textStartOffset + spacesMatch.length;
+            context.report({
+                loc: {
+                    start: sourceCode.getLocFromIndex(startOffset),
+                    end: sourceCode.getLocFromIndex(endOffset),
+                },
+                messageId,
+                fix(fixer) {
+                    return fixer.removeRange([startOffset, endOffset]);
+                },
+            });
+        }
+        return {
+            heading(node) {
+                const currentHeadingStyle = getHeadingStyle(node, sourceCode);
+                if (currentHeadingStyle === 'setext') {
+                    // Early returns when the heading is a Setext heading, as this rule only applies to ATX headings.
+                    return;
+                }
+                const lastChildNode = node.children.at(-1);
+                const isClosedHeading = currentHeadingStyle === 'atx-closed';
+                const isEmptyHeading = !lastChildNode;
+                if (!checkClosedHeading && isClosedHeading && isEmptyHeading) {
+                    // When closing checks are disabled, skip closed headings with no content
+                    // (e.g., `'##   ##'`), where opening and closing whitespace overlap.
+                    return;
+                }
+                const text = sourceCode.getText(node);
+                const [nodeStartOffset] = sourceCode.getRange(node);
+                report(text.slice(node.depth), nodeStartOffset + node.depth, 'noMultipleAtxHeadingSpace');
+                if (checkClosedHeading && isClosedHeading && !isEmptyHeading) {
+                    const [, lastChildNodeEndOffset] = sourceCode.getRange(lastChildNode);
+                    report(text.slice(lastChildNodeEndOffset - nodeStartOffset), lastChildNodeEndOffset, 'noMultipleAtxClosedHeadingSpace');
+                }
+            },
+        };
+    },
+};

package/build/rules/no-tab.d.ts

@@ -17,6 +17,16 @@ type RuleOptions = [
          * @default true
          */
         skipInlineCode: boolean;
+        /**
+         * `true` allows tabs in all math blocks.
+         * @default true
+         */
+        skipMath: boolean;
+        /**
+         * `true` allows tabs in all inline math.
+         * @default true
+         */
+        skipInlineMath: boolean;
         /**
          * Number of spaces to replace each tab with when applying an autofix.
          * @default 4
@@ -51,6 +61,12 @@ declare const _default: {
                 readonly skipInlineCode: {
                     readonly type: "boolean";
                 };
+                readonly skipMath: {
+                    readonly type: "boolean";
+                };
+                readonly skipInlineMath: {
+                    readonly type: "boolean";
+                };
                 readonly tabWidth: {
                     readonly type: "integer";
                     readonly minimum: 1;
@@ -61,6 +77,8 @@ declare const _default: {
         readonly defaultOptions: [{
             readonly skipCode: true;
             readonly skipInlineCode: true;
+            readonly skipMath: true;
+            readonly skipInlineMath: true;
             readonly tabWidth: 4;
         }];
         readonly messages: {
@@ -75,6 +93,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-tab.js

@@ -45,6 +45,12 @@ export default {
                     skipInlineCode: {
                         type: 'boolean',
                     },
+                    skipMath: {
+                        type: 'boolean',
+                    },
+                    skipInlineMath: {
+                        type: 'boolean',
+                    },
                     tabWidth: {
                         type: 'integer',
                         minimum: 1,
@@ -57,6 +63,8 @@ export default {
             {
                 skipCode: true,
                 skipInlineCode: true,
+                skipMath: true,
+                skipInlineMath: true,
                 tabWidth: 4,
             },
         ],
@@ -68,7 +76,7 @@ export default {
     },
     create(context) {
         const { sourceCode } = context;
-        const [{ skipCode, skipInlineCode, tabWidth }] = context.options;
+        const [{ skipCode, skipInlineCode, skipMath, skipInlineMath, tabWidth }] = context.options;
         const skipRanges = new SkipRanges();
         return {
             code(node) {
@@ -79,6 +87,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(tabRegex);
                 for (const match of matches) {

package/package.json

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