eslint-markdown 0.5.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

@@ -20,6 +20,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-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

@@ -17,6 +17,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-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

@@ -13,14 +13,40 @@ declare const _default: {
                 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[];
@@ -30,7 +56,7 @@ declare const _default: {
         Code: import("@eslint/markdown").MarkdownSourceCode;
         RuleOptions: RuleOptions;
         Node: import("mdast").Node;
-        MessageIds: "style";
+        MessageIds: MessageIds;
     }>): {
         code(node: import("mdast").Code): void;
     };
@@ -39,5 +65,7 @@ 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";
+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/index.d.ts

@@ -2,9 +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, "style">;
+    '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.5.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

@@ -44,6 +44,7 @@ export default function all(plugin) {
       '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

@@ -41,6 +41,7 @@ export default function stylistic(plugin) {
       '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

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

@@ -17,6 +17,7 @@
 // Import
 // --------------------------------------------------------------------------------
 
+import { isBlankLine } from '../core/ast/index.js';
 import { URL_RULE_DOCS } from '../core/constants.js';
 
 // --------------------------------------------------------------------------------
@@ -26,8 +27,8 @@ import { URL_RULE_DOCS } from '../core/constants.js';
 /**
  * @import { RuleModule } from '../core/types.js';
  * @typedef {'indent' | 'fence-backtick' | 'fence-tilde'} CodeStyle
- * @typedef {[{ style: 'consistent' | CodeStyle }]} RuleOptions
- * @typedef {'style'} MessageIds
+ * @typedef {[{ style: 'consistent' | CodeStyle, blankLineAbove: number | false, blankLineBelow: number | false }]} RuleOptions
+ * @typedef {'style' | 'blankLineAbove' | 'blankLineBelow'} MessageIds
  */
 
 // --------------------------------------------------------------------------------
@@ -76,6 +77,28 @@ export default {
           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,
       },
@@ -84,11 +107,17 @@ export default {
     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',
@@ -98,13 +127,18 @@ export default {
 
   create(context) {
     const { sourceCode } = context;
-    const [{ style }] = context.options;
+    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]);
 
@@ -123,6 +157,92 @@ export default {
             },
           });
         }
+
+        // ------------------------------------------------------------------------
+        // 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/index.js

@@ -9,6 +9,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 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';
@@ -35,6 +36,7 @@ export default {
   '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 };