eslint-markdown 0.4.0 → 0.6.0

package/README.md

@@ -25,6 +25,12 @@ For full documentation, see the [official documentation of the `eslint-markdown`
 - [Migration Guide](https://eslint-markdown.lumir.page/docs/get-started/migration)
 - [Rules](https://eslint-markdown.lumir.page/docs/rules)
 
+## Compatibility
+
+This [`eslint-markdown`](https://github.com/lumirlumir/npm-eslint-markdown#readme) plugin does not include any rules that overlap with ESLint's built-in Markdown rules provided by [`@eslint/markdown`](https://github.com/eslint/markdown#readme).
+
+So, we **highly recommend** using the `eslint-markdown` plugin alongside ESLint's built-in Markdown support, `@eslint/markdown`.
+
 ## Code of Conduct
 
 See [Code of Conduct](https://github.com/lumirlumir/.github/blob/main/CODE_OF_CONDUCT.md#contributor-covenant-code-of-conduct).

package/build/configs/all.d.ts

@@ -17,8 +17,10 @@ export default function all(plugin: ESLint.Plugin): {
         readonly 'md/allow-image-url': "error";
         readonly 'md/allow-link-url': "error";
         readonly 'md/code-lang-shorthand': "error";
+        readonly 'md/consistent-code-style': "error";
         readonly 'md/consistent-delete-style': "error";
         readonly 'md/consistent-emphasis-style': "error";
+        readonly 'md/consistent-inline-code-style': "error";
         readonly 'md/consistent-strong-style': "error";
         readonly 'md/consistent-thematic-break-style': "error";
         readonly 'md/consistent-unordered-list-style': "error";

package/build/configs/stylistic.d.ts

@@ -14,8 +14,10 @@ export default function stylistic(plugin: ESLint.Plugin): {
     };
     readonly language: "markdown/gfm";
     readonly rules: {
+        readonly 'md/consistent-code-style': "error";
         readonly 'md/consistent-delete-style': "error";
         readonly 'md/consistent-emphasis-style': "error";
+        readonly 'md/consistent-inline-code-style': "error";
         readonly 'md/consistent-strong-style': "error";
         readonly 'md/consistent-thematic-break-style': "error";
         readonly 'md/consistent-unordered-list-style': "error";

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

@@ -1,3 +1,4 @@
 import getElementsByTagName from './html.js';
+import isBlankLine from './is-blank-line.js';
 import SkipRanges from './skip-ranges.js';
-export { getElementsByTagName, SkipRanges };
+export { getElementsByTagName, isBlankLine, SkipRanges };

package/build/core/ast/is-blank-line.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Check if a line is blank.
+ * @param {string} str Line string.
+ * @returns {boolean} `true` if the line is blank. `false` otherwise.
+ */
+export default function isBlankLine(str: string): boolean;

package/build/core/constants.d.ts

@@ -1,4 +1,4 @@
-/** @satisfies {string} */
+/** @type {'eslint-markdown'} */
 export const PKG_NAME: "eslint-markdown";
 /** @satisfies {string} */
 export const PKG_VERSION: string;

package/build/core/{tests/rule-tester.d.ts → rule-tester.d.ts}

@@ -8,6 +8,6 @@ export default function ruleTester(ruleName: string, rule: RuleModule<RuleOption
 export type RuleOptions = MarkdownRuleDefinitionTypeOptions["RuleOptions"];
 export type MessageIds = MarkdownRuleDefinitionTypeOptions["MessageIds"];
 export type Tests = Parameters<RuleTester["run"]>[2];
-import type { RuleModule } from '../types.js';
+import type { RuleModule } from './types.js';
 import type { MarkdownRuleDefinitionTypeOptions } from '@eslint/markdown';
 import { RuleTester } from 'eslint';

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

@@ -0,0 +1,71 @@
+declare const _default: {
+    meta: {
+        type: "layout";
+        docs: {
+            description: string;
+            url: string;
+            recommended: boolean;
+            stylistic: true;
+        };
+        schema: {
+            type: "object";
+            properties: {
+                style: {
+                    enum: string[];
+                };
+                blankLineAbove: {
+                    oneOf: ({
+                        enum: false[];
+                        type?: never;
+                        minimum?: never;
+                    } | {
+                        type: "integer";
+                        minimum: number;
+                        enum?: never;
+                    })[];
+                };
+                blankLineBelow: {
+                    oneOf: ({
+                        enum: false[];
+                        type?: never;
+                        minimum?: never;
+                    } | {
+                        type: "integer";
+                        minimum: number;
+                        enum?: never;
+                    })[];
+                };
+            };
+            additionalProperties: false;
+        }[];
+        defaultOptions: [{
+            style: "consistent";
+            blankLineAbove: false;
+            blankLineBelow: false;
+        }];
+        messages: {
+            style: string;
+            blankLineAbove: string;
+            blankLineBelow: string;
+        };
+        language: string;
+        dialects: string[];
+    };
+    create(context: import("@eslint/core").RuleContext<{
+        LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+        Code: import("@eslint/markdown").MarkdownSourceCode;
+        RuleOptions: RuleOptions;
+        Node: import("mdast").Node;
+        MessageIds: MessageIds;
+    }>): {
+        code(node: import("mdast").Code): void;
+    };
+};
+export default _default;
+export type CodeStyle = "indent" | "fence-backtick" | "fence-tilde";
+export type RuleOptions = [{
+    style: "consistent" | CodeStyle;
+    blankLineAbove: number | false;
+    blankLineBelow: number | false;
+}];
+export type MessageIds = "style" | "blankLineAbove" | "blankLineBelow";

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

@@ -0,0 +1,29 @@
+declare const _default: {
+    meta: {
+        type: "layout";
+        docs: {
+            description: string;
+            url: string;
+            recommended: boolean;
+            stylistic: true;
+        };
+        fixable: "whitespace";
+        messages: {
+            style: string;
+        };
+        language: string;
+        dialects: string[];
+    };
+    create(context: import("@eslint/core").RuleContext<{
+        LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+        Code: import("@eslint/markdown").MarkdownSourceCode;
+        RuleOptions: [];
+        Node: import("mdast").Node;
+        MessageIds: "style";
+    }>): {
+        inlineCode(node: import("mdast").InlineCode): void;
+    };
+};
+export default _default;
+export type RuleOptions = [];
+export type MessageIds = "style";

package/build/rules/consistent-unordered-list-style.d.ts

@@ -39,9 +39,9 @@ declare const _default: {
     };
 };
 export default _default;
-export type UnorderedListMarker = "*" | "+" | "-";
+export type UnorderedListStyle = "*" | "+" | "-";
 export type RuleOptions = [{
-    style: "consistent" | "sublist" | UnorderedListMarker;
+    style: "consistent" | "sublist" | UnorderedListStyle;
 }];
 export type MessageIds = "style";
 import type { ListItem } from 'mdast';

package/build/rules/index.d.ts

@@ -2,8 +2,10 @@ declare const _default: {
     'allow-image-url': import("../core/types.js").RuleModule<import("./allow-image-url.js").RuleOptions, import("./allow-image-url.js").MessageIds>;
     'allow-link-url': import("../core/types.js").RuleModule<import("./allow-link-url.js").RuleOptions, import("./allow-link-url.js").MessageIds>;
     'code-lang-shorthand': import("../core/types.js").RuleModule<import("./code-lang-shorthand.js").RuleOptions, "codeLangShorthand">;
+    'consistent-code-style': import("../core/types.js").RuleModule<import("./consistent-code-style.js").RuleOptions, import("./consistent-code-style.js").MessageIds>;
     'consistent-delete-style': import("../core/types.js").RuleModule<import("./consistent-delete-style.js").RuleOptions, "style">;
     'consistent-emphasis-style': import("../core/types.js").RuleModule<import("./consistent-emphasis-style.js").RuleOptions, "style">;
+    'consistent-inline-code-style': import("../core/types.js").RuleModule<[], "style">;
     'consistent-strong-style': import("../core/types.js").RuleModule<import("./consistent-strong-style.js").RuleOptions, "style">;
     'consistent-thematic-break-style': import("../core/types.js").RuleModule<import("./consistent-thematic-break-style.js").RuleOptions, "style">;
     'consistent-unordered-list-style': import("../core/types.js").RuleModule<import("./consistent-unordered-list-style.js").RuleOptions, "style">;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-markdown",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "description": "Lint your Markdown with ESLint.🛠️",
   "exports": {
@@ -40,6 +40,7 @@
     "gfm"
   ],
   "author": "루밀LuMir <rpfos@naver.com> (https://github.com/lumirlumir)",
+  "funding": "https://github.com/sponsors/lumirlumir",
   "license": "MIT",
   "homepage": "https://eslint-markdown.lumir.page",
   "repository": {
@@ -78,6 +79,6 @@
   },
   "devDependencies": {
     "@types/mdast": "^4.0.4",
-    "eslint": "^9.39.2"
+    "eslint": "^9.39.4"
   }
 }

package/src/configs/all.js

@@ -41,8 +41,10 @@ export default function all(plugin) {
       'md/allow-image-url': 'error',
       'md/allow-link-url': 'error',
       'md/code-lang-shorthand': 'error',
+      'md/consistent-code-style': 'error',
       'md/consistent-delete-style': 'error',
       'md/consistent-emphasis-style': 'error',
+      'md/consistent-inline-code-style': 'error',
       'md/consistent-strong-style': 'error',
       'md/consistent-thematic-break-style': 'error',
       'md/consistent-unordered-list-style': 'error',

package/src/configs/stylistic.js

@@ -38,8 +38,10 @@ export default function stylistic(plugin) {
     },
     language: 'markdown/gfm',
     rules: {
+      'md/consistent-code-style': 'error',
       'md/consistent-delete-style': 'error',
       'md/consistent-emphasis-style': 'error',
+      'md/consistent-inline-code-style': 'error',
       'md/consistent-strong-style': 'error',
       'md/consistent-thematic-break-style': 'error',
       'md/consistent-unordered-list-style': 'error',

package/src/core/ast/html.js

@@ -9,7 +9,7 @@
 import { parseFragment } from 'parse5';
 
 // --------------------------------------------------------------------------------
-// Typedefs
+// Typedef
 // --------------------------------------------------------------------------------
 
 /**

package/src/core/ast/index.js

@@ -1,4 +1,5 @@
 import getElementsByTagName from './html.js';
+import isBlankLine from './is-blank-line.js';
 import SkipRanges from './skip-ranges.js';
 
-export { getElementsByTagName, SkipRanges };
+export { getElementsByTagName, isBlankLine, SkipRanges };

package/src/core/ast/is-blank-line.js

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview Check if a line is blank.
+ * @see https://spec.commonmark.org/0.31.2/#blank-line
+ */
+
+// --------------------------------------------------------------------------------
+// Helper
+// --------------------------------------------------------------------------------
+
+const whitespaceChars = new Set([' ', '\t']);
+
+// --------------------------------------------------------------------------------
+// Export
+// --------------------------------------------------------------------------------
+
+/**
+ * Check if a line is blank.
+ * @param {string} str Line string.
+ * @returns {boolean} `true` if the line is blank. `false` otherwise.
+ */
+export default function isBlankLine(str) {
+  // `.length` is cached for performance.
+  const strLength = str.length;
+
+  for (let i = 0; i < strLength; i++) {
+    if (!whitespaceChars.has(str[i])) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/core/constants.js

@@ -6,22 +6,15 @@
 // Import
 // --------------------------------------------------------------------------------
 
-import { createRequire } from 'node:module';
-
-// --------------------------------------------------------------------------------
-// Declaration
-// --------------------------------------------------------------------------------
-
-/** @type {{ homepage: string, name: 'eslint-markdown', version: string }} */
-const { homepage, name, version } = createRequire(import.meta.url)('../../package.json');
+import pkg from '../../package.json' with { type: 'json' };
 
 // --------------------------------------------------------------------------------
 // Export
 // --------------------------------------------------------------------------------
 
+/** @type {'eslint-markdown'} */
+export const PKG_NAME = /** @type {'eslint-markdown'} */ (pkg.name);
 /** @satisfies {string} */
-export const PKG_NAME = name;
-/** @satisfies {string} */
-export const PKG_VERSION = version;
+export const PKG_VERSION = pkg.version;
 /** Get the URL for the rule documentation based on the rule name. @param {string} [ruleName] */
-export const URL_RULE_DOCS = (ruleName = '') => `${homepage}/docs/rules/${ruleName}`;
+export const URL_RULE_DOCS = (ruleName = '') => `${pkg.homepage}/docs/rules/${ruleName}`;

package/src/core/{tests/rule-tester.js → rule-tester.js}

@@ -17,7 +17,7 @@ import markdown from '@eslint/markdown';
 
 /**
  * @import { MarkdownRuleDefinitionTypeOptions } from '@eslint/markdown';
- * @import { RuleModule } from '../types.js';
+ * @import { RuleModule } from './types.js';
  * @typedef {MarkdownRuleDefinitionTypeOptions['RuleOptions']} RuleOptions
  * @typedef {MarkdownRuleDefinitionTypeOptions['MessageIds']} MessageIds
  * @typedef {Parameters<RuleTester['run']>[2]} Tests
@@ -76,7 +76,7 @@ export default function ruleTester(ruleName, rule, tests) {
 
       it('`meta.docs.description` should exist and follow the convention', () => {
         ok(meta?.docs?.description);
-        match(meta?.docs?.description, /^(Enforce|Require|Disallow) .+[^. ]$/);
+        match(meta?.docs?.description, /^(?:Enforce|Require|Disallow) .+[^. ]$/);
       });
 
       it('`meta.docs.url` should exist and end with the rule name', () => {

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

@@ -0,0 +1,249 @@
+/**
+ * @fileoverview Rule to enforce consistent code style.
+ * @author 루밀LuMir(lumirlumir)
+ */
+
+/*
+ * Note on autofix and suggestion safety:
+ * - Converting `fence-backtick` to `fence-tilde` is safe.
+ * - Converting `fence-backtick` to `indent` is not safe, as `lang` and `meta` information would be lost.
+ * - Converting `fence-tilde` to `fence-backtick` is safe.
+ * - Converting `fence-tilde` to `indent` is not safe, as `lang` and `meta` information would be lost.
+ * - Converting `indent` to `fence-backtick` is safe.
+ * - Converting `indent` to `fence-tilde` is safe.
+ */
+
+// --------------------------------------------------------------------------------
+// Import
+// --------------------------------------------------------------------------------
+
+import { isBlankLine } from '../core/ast/index.js';
+import { URL_RULE_DOCS } from '../core/constants.js';
+
+// --------------------------------------------------------------------------------
+// Typedef
+// --------------------------------------------------------------------------------
+
+/**
+ * @import { RuleModule } from '../core/types.js';
+ * @typedef {'indent' | 'fence-backtick' | 'fence-tilde'} CodeStyle
+ * @typedef {[{ style: 'consistent' | CodeStyle, blankLineAbove: number | false, blankLineBelow: number | false }]} RuleOptions
+ * @typedef {'style' | 'blankLineAbove' | 'blankLineBelow'} MessageIds
+ */
+
+// --------------------------------------------------------------------------------
+// Helper
+// --------------------------------------------------------------------------------
+
+/**
+ * Get the current code style based on the given text.
+ * @param {string} text The text to determine the code style from.
+ * @returns {CodeStyle} The current code style.
+ */
+function getCurrentCodeStyle(text) {
+  if (text === '`') {
+    return 'fence-backtick';
+  } else if (text === '~') {
+    return 'fence-tilde';
+  } else {
+    return 'indent';
+  }
+}
+
+// --------------------------------------------------------------------------------
+// Rule Definition
+// --------------------------------------------------------------------------------
+
+/** @type {RuleModule<RuleOptions, MessageIds>} */
+export default {
+  meta: {
+    type: 'layout',
+
+    docs: {
+      description: 'Enforce consistent code style',
+      url: URL_RULE_DOCS('consistent-code-style'),
+      recommended: false,
+      stylistic: true,
+    },
+
+    // fixable: 'code', // TODO
+
+    // hasSuggestions: true, // TODO
+
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          style: {
+            enum: ['consistent', 'indent', 'fence-backtick', 'fence-tilde'],
+          },
+          blankLineAbove: {
+            oneOf: [
+              {
+                enum: [false],
+              },
+              {
+                type: 'integer',
+                minimum: 1,
+              },
+            ],
+          },
+          blankLineBelow: {
+            oneOf: [
+              {
+                enum: [false],
+              },
+              {
+                type: 'integer',
+                minimum: 1,
+              },
+            ],
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+
+    defaultOptions: [
+      {
+        style: 'consistent',
+        blankLineAbove: false,
+        blankLineBelow: false,
+      },
+    ],
+
+    messages: {
+      style: 'Code style should be `{{ style }}`.',
+      blankLineAbove:
+        'Code should be surrounded by {{ blankLineAbove }} blank line(s) above.',
+      blankLineBelow:
+        'Code should be surrounded by {{ blankLineBelow }} blank line(s) below.',
+    },
+
+    language: 'markdown',
+
+    dialects: ['commonmark', 'gfm'],
+  },
+
+  create(context) {
+    const { sourceCode } = context;
+    const { lines } = sourceCode;
+    const [{ style, blankLineAbove, blankLineBelow }] = context.options;
+
+    /** @type {CodeStyle | null} */
+    let codeStyle = style === 'consistent' ? null : style;
+
+    return {
+      code(node) {
+        // ------------------------------------------------------------------------
+        // 1. Check code style consistency.
+        // ------------------------------------------------------------------------
+
+        const [nodeStartOffset] = sourceCode.getRange(node);
+        const currentCodeStyle = getCurrentCodeStyle(sourceCode.text[nodeStartOffset]);
+
+        if (codeStyle === null) {
+          codeStyle = currentCodeStyle;
+        }
+
+        if (codeStyle !== currentCodeStyle) {
+          context.report({
+            node,
+
+            messageId: 'style',
+
+            data: {
+              style: codeStyle,
+            },
+          });
+        }
+
+        // ------------------------------------------------------------------------
+        // 2. Check blank lines above the code block.
+        // ------------------------------------------------------------------------
+
+        // `markdownlint` doesn't check blank lines above indented code blocks, so we skip this check for the `indent` style.
+        if (blankLineAbove !== false && currentCodeStyle !== 'indent') {
+          const {
+            start: { line: nodeStartLine },
+          } = sourceCode.getLoc(node);
+          const nodeStartLineIndex = nodeStartLine - 1;
+
+          for (
+            let i = nodeStartLineIndex - 1; // Start checking from the line above the code block.
+            i >= nodeStartLineIndex - blankLineAbove; // Check up to the specified number of blank lines.
+            i-- // Move upwards through the lines.
+          ) {
+            const line = lines[i];
+
+            // If the line is `undefined`, it means we've reached the beginning of the file.
+            if (line === undefined) {
+              break;
+            }
+
+            // If the line is blank, continue checking the next line. If it's not blank, report the issue.
+            if (isBlankLine(line)) {
+              continue;
+            }
+
+            context.report({
+              node,
+
+              messageId: 'blankLineAbove',
+
+              data: {
+                blankLineAbove,
+              },
+            });
+
+            // No need to check further once we've found a non-blank line.
+            break;
+          }
+        }
+
+        // ------------------------------------------------------------------------
+        // 3. Check blank lines below the code block.
+        // ------------------------------------------------------------------------
+
+        // `markdownlint` doesn't check blank lines below indented code blocks, so we skip this check for the `indent` style.
+        if (blankLineBelow !== false && currentCodeStyle !== 'indent') {
+          const {
+            end: { line: nodeEndLine },
+          } = sourceCode.getLoc(node);
+          const nodeEndLineIndex = nodeEndLine - 1;
+
+          for (
+            let i = nodeEndLineIndex + 1; // Start checking from the line below the code block.
+            i <= nodeEndLineIndex + blankLineBelow; // Check up to the specified number of blank lines.
+            i++ // Move downwards through the lines.
+          ) {
+            const line = lines[i];
+
+            // If the line is `undefined`, it means we've reached the end of the file.
+            if (line === undefined) {
+              break;
+            }
+
+            // If the line is blank, continue checking the next line. If it's not blank, report the issue.
+            if (isBlankLine(line)) {
+              continue;
+            }
+
+            context.report({
+              node,
+
+              messageId: 'blankLineBelow',
+
+              data: {
+                blankLineBelow,
+              },
+            });
+
+            // No need to check further once we've found a non-blank line.
+            break;
+          }
+        }
+      },
+    };
+  },
+};

package/src/rules/consistent-inline-code-style.js

@@ -0,0 +1,152 @@
+/**
+ * @fileoverview Rule to enforce consistent inline code style.
+ * @author 루밀LuMir(lumirlumir)
+ * @see https://github.com/DavidAnson/markdownlint/blob/v0.40.0/lib/md038.mjs
+ */
+
+// --------------------------------------------------------------------------------
+// Import
+// --------------------------------------------------------------------------------
+
+import { URL_RULE_DOCS } from '../core/constants.js';
+
+// --------------------------------------------------------------------------------
+// Typedef
+// --------------------------------------------------------------------------------
+
+/**
+ * @import { RuleModule } from '../core/types.js';
+ * @typedef {[]} RuleOptions
+ * @typedef {'style'} MessageIds
+ */
+
+// --------------------------------------------------------------------------------
+// Helper
+// --------------------------------------------------------------------------------
+
+// `\s` in regular expressions matches whitespace characters beyond `\r`, `\n`, ` `, and `\t`,
+// so we explicitly use `[\r\n \t]` to match those characters to avoid unexpected matches.
+const leadingInlineCodeRegex =
+  /^(?<leadingBackticks>`*)(?<leadingSpaces>[\r\n \t]+)(?<firstChar>[^\r\n \t])/;
+const trailingInlineCodeRegex =
+  /(?<lastChar>[^\r\n \t])(?<trailingSpaces>[\r\n \t]+)(?<trailingBackticks>`*)$/;
+
+// --------------------------------------------------------------------------------
+// Rule Definition
+// --------------------------------------------------------------------------------
+
+/** @type {RuleModule<RuleOptions, MessageIds>} */
+export default {
+  meta: {
+    type: 'layout',
+
+    docs: {
+      description: 'Enforce consistent inline code style',
+      url: URL_RULE_DOCS('consistent-inline-code-style'),
+      recommended: false,
+      stylistic: true,
+    },
+
+    fixable: 'whitespace',
+
+    messages: {
+      style: 'Inline code should not have extra spaces or tabs next to backticks.',
+    },
+
+    language: 'markdown',
+
+    dialects: ['commonmark', 'gfm'],
+  },
+
+  create(context) {
+    const { sourceCode } = context;
+
+    /**
+     * @param {number} startOffset
+     * @param {number} endOffset
+     */
+    function reportStyle(startOffset, endOffset) {
+      context.report({
+        loc: {
+          start: sourceCode.getLocFromIndex(startOffset),
+          end: sourceCode.getLocFromIndex(endOffset),
+        },
+
+        messageId: 'style',
+
+        fix(fixer) {
+          return fixer.removeRange([startOffset, endOffset]);
+        },
+      });
+    }
+
+    return {
+      inlineCode(node) {
+        // ------------------------------------------------------------------------
+        // 1. Extract the text and offsets of the inline code node.
+        // ------------------------------------------------------------------------
+
+        const text = sourceCode.getText(node);
+        const [nodeStartOffset, nodeEndOffset] = sourceCode.getRange(node);
+
+        // ------------------------------------------------------------------------
+        // 2. Extract the leading spaces and backticks of the inline code node.
+        // ------------------------------------------------------------------------
+
+        const { leadingBackticks = '', leadingSpaces: leadingSpacesText = '' } =
+          text.match(leadingInlineCodeRegex)?.groups ?? {};
+        const { leadingSpaces: leadingSpacesValue = '', firstChar = '' } =
+          node.value.match(leadingInlineCodeRegex)?.groups ?? {};
+
+        const startBacktick = firstChar === '`';
+        const startPaddingLength = /** @type {0 | 1} */ (
+          // `startPaddingLength` is always `0` or `1` because the parser consumes at most one padding space on each side.
+          leadingSpacesText.length - leadingSpacesValue.length
+        );
+        const startBacktickSpaceAdjustment = startBacktick && !startPaddingLength ? 1 : 0;
+        const startSpaces = leadingSpacesValue.length > startBacktickSpaceAdjustment;
+
+        // ------------------------------------------------------------------------
+        // 3. Extract the trailing spaces and backticks of the inline code node.
+        // ------------------------------------------------------------------------
+
+        const { trailingSpaces: trailingSpacesText = '', trailingBackticks = '' } =
+          text.match(trailingInlineCodeRegex)?.groups ?? {};
+        const { lastChar = '', trailingSpaces: trailingSpacesValue = '' } =
+          node.value.match(trailingInlineCodeRegex)?.groups ?? {};
+
+        const endBacktick = lastChar === '`';
+        const endPaddingLength = /** @type {0 | 1} */ (
+          // `endPaddingLength` is always `0` or `1` because the parser consumes at most one padding space on each side.
+          trailingSpacesText.length - trailingSpacesValue.length
+        );
+        const endBacktickSpaceAdjustment = endBacktick && !endPaddingLength ? 1 : 0;
+        const endSpaces = trailingSpacesValue.length > endBacktickSpaceAdjustment;
+
+        // ------------------------------------------------------------------------
+        // 4. Report if there are extra spaces or tabs next to backticks.
+        // ------------------------------------------------------------------------
+
+        const removePadding = startSpaces && endSpaces && !startBacktick && !endBacktick;
+
+        if (startSpaces) {
+          const baseOffset = nodeStartOffset + leadingBackticks.length;
+
+          reportStyle(
+            baseOffset + (removePadding ? 0 : startPaddingLength),
+            baseOffset + leadingSpacesText.length - startBacktickSpaceAdjustment,
+          );
+        }
+
+        if (endSpaces) {
+          const baseOffset = nodeEndOffset - trailingBackticks.length;
+
+          reportStyle(
+            baseOffset - trailingSpacesText.length + endBacktickSpaceAdjustment,
+            baseOffset - (removePadding ? 0 : endPaddingLength),
+          );
+        }
+      },
+    };
+  },
+};

package/src/rules/consistent-unordered-list-style.js

@@ -16,8 +16,8 @@ import { URL_RULE_DOCS } from '../core/constants.js';
 /**
  * @import { ListItem } from 'mdast';
  * @import { RuleModule } from '../core/types.js';
- * @typedef {'*' | '+' | '-'} UnorderedListMarker
- * @typedef {[{ style: 'consistent' | 'sublist' | UnorderedListMarker }]} RuleOptions
+ * @typedef {'*' | '+' | '-'} UnorderedListStyle
+ * @typedef {[{ style: 'consistent' | 'sublist' | UnorderedListStyle }]} RuleOptions
  * @typedef {'style'} MessageIds
  */
 
@@ -26,15 +26,15 @@ import { URL_RULE_DOCS } from '../core/constants.js';
 // --------------------------------------------------------------------------------
 
 /**
- * Get the next unordered list marker in sequence.
+ * Get the next unordered list style in sequence.
  * Inspired by [`markdownlint`](https://github.com/DavidAnson/markdownlint/blob/v0.40.0/lib/md004.mjs#L9).
- * @param {UnorderedListMarker} currentUnorderedListMarker The current unordered list marker.
- * @returns {UnorderedListMarker} The next unordered list marker.
+ * @param {UnorderedListStyle} currentUnorderedListStyle The current unordered list style.
+ * @returns {UnorderedListStyle} The next unordered list style.
  */
-function getNextUnorderedListMarker(currentUnorderedListMarker) {
-  if (currentUnorderedListMarker === '-') {
+function getNextUnorderedListStyle(currentUnorderedListStyle) {
+  if (currentUnorderedListStyle === '-') {
     return '+';
-  } else if (currentUnorderedListMarker === '+') {
+  } else if (currentUnorderedListStyle === '+') {
     return '*';
   } else {
     return '-';
@@ -90,7 +90,7 @@ export default {
     const { sourceCode } = context;
     const [{ style }] = context.options;
 
-    /** @type {Array<UnorderedListMarker | null | undefined>} */
+    /** @type {Array<UnorderedListStyle | null | undefined>} */
     const unorderedListStyle = [
       style === 'consistent' || style === 'sublist' ? null : style,
     ];
@@ -105,7 +105,7 @@ export default {
 
       'list[ordered=false] > listItem'(/** @type {ListItem} */ node) {
         const [nodeStartOffset] = sourceCode.getRange(node);
-        const currentUnorderedListStyle = /** @type {UnorderedListMarker} */ (
+        const currentUnorderedListStyle = /** @type {UnorderedListStyle} */ (
           sourceCode.text[nodeStartOffset]
         );
         const currentListDepth = style === 'sublist' ? listDepth : 0;
@@ -115,7 +115,7 @@ export default {
           unorderedListStyle[currentListDepth] =
             // If the previous depth used the same style, use the next style in sequence.
             unorderedListStyle[currentListDepth - 1] === currentUnorderedListStyle
-              ? getNextUnorderedListMarker(currentUnorderedListStyle)
+              ? getNextUnorderedListStyle(currentUnorderedListStyle)
               : currentUnorderedListStyle;
         }
 

package/src/rules/index.js

@@ -6,8 +6,10 @@
 import allowImageUrl from './allow-image-url.js';
 import allowLinkUrl from './allow-link-url.js';
 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 consistentInlineCodeStyle from './consistent-inline-code-style.js';
 import consistentStrongStyle from './consistent-strong-style.js';
 import consistentThematicBreakStyle from './consistent-thematic-break-style.js';
 import consistentUnorderedListStyle from './consistent-unordered-list-style.js';
@@ -31,8 +33,10 @@ export default {
   'allow-image-url': allowImageUrl,
   'allow-link-url': allowLinkUrl,
   'code-lang-shorthand': codeLangShorthand,
+  'consistent-code-style': consistentCodeStyle,
   'consistent-delete-style': consistentDeleteStyle,
   'consistent-emphasis-style': consistentEmphasisStyle,
+  'consistent-inline-code-style': consistentInlineCodeStyle,
   'consistent-strong-style': consistentStrongStyle,
   'consistent-thematic-break-style': consistentThematicBreakStyle,
   'consistent-unordered-list-style': consistentUnorderedListStyle,

package/build/core/tests/get-file-name.d.ts

@@ -1,6 +0,0 @@
-/**
- * Get the file name of the module.
- * @param {string} importMetaUrl The absolute `file:` URL of the module.
- * @returns {string} The file name of the module.
- */
-export default function getFileName(importMetaUrl: string): string;

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

@@ -1,3 +0,0 @@
-import getFileName from './get-file-name.js';
-import ruleTester from './rule-tester.js';
-export { getFileName, ruleTester };

package/src/core/tests/get-file-name.js

@@ -1,23 +0,0 @@
-/**
- * @fileoverview Get the file name of the module.
- */
-
-// --------------------------------------------------------------------------------
-// Import
-// --------------------------------------------------------------------------------
-
-import { fileURLToPath } from 'node:url';
-import { parse } from 'node:path';
-
-// --------------------------------------------------------------------------------
-// Export
-// --------------------------------------------------------------------------------
-
-/**
- * Get the file name of the module.
- * @param {string} importMetaUrl The absolute `file:` URL of the module.
- * @returns {string} The file name of the module.
- */
-export default function getFileName(importMetaUrl) {
-  return parse(fileURLToPath(importMetaUrl)).name.replace(/\.test$/, '');
-}

package/src/core/tests/index.js

@@ -1,6 +0,0 @@
-/* eslint sort-imports: 'error', sort-keys: 'error' */
-
-import getFileName from './get-file-name.js';
-import ruleTester from './rule-tester.js';
-
-export { getFileName, ruleTester };