eslint-markdown 0.13.0 → 0.14.1

package/build/rules/allow-heading.js

@@ -2,7 +2,7 @@
  * @fileoverview Rule to enforce the use of allowed or disallowed headings.
  * @author lumir(lumirlumir)
  */
-import { testRegexStateless } from '../core/utils/index.js';
+import { normalizeRegexPattern, testRegexStateless } from '../core/utils/index.js';
 import { URL_RULE_DOCS } from '../core/constants.js';
 // --------------------------------------------------------------------------------
 // Helper
@@ -13,14 +13,14 @@ const headingOptionsSchema = {
         allow: {
             type: 'array',
             items: {
-                type: 'object',
+                oneOf: [{ type: 'object', additionalProperties: false }, { type: 'string' }],
             },
             uniqueItems: true,
         },
         disallow: {
             type: 'array',
             items: {
-                type: 'object',
+                oneOf: [{ type: 'object', additionalProperties: false }, { type: 'string' }],
             },
             uniqueItems: true,
         },
@@ -66,6 +66,7 @@ export default {
         messages: {
             allowHeading: 'The level {{ depth }} heading `{{ heading }}` is not in the list of allowed headings. (Allow: {{ allow }}).',
             disallowHeading: 'The level {{ depth }} heading `{{ heading }}` is in the list of disallowed headings. (Disallow: {{ disallow }}).',
+            emptyAllowHeading: 'No level {{ depth }} headings are allowed because the list of allowed headings is empty.',
         },
         language: 'markdown',
         dialects: ['commonmark', 'gfm'],
@@ -73,20 +74,25 @@ export default {
     create(context) {
         const { sourceCode } = context;
         const [{ h1, h2, h3, h4, h5, h6 }] = context.options;
-        const headingMap = {
-            1: h1,
-            2: h2,
-            3: h3,
-            4: h4,
-            5: h5,
-            6: h6,
-        };
+        const headingMap = [h1, h2, h3, h4, h5, h6].map(({ allow, disallow }) => ({
+            allow: allow.map(normalizeRegexPattern),
+            disallow: disallow.map(normalizeRegexPattern),
+        }));
         return {
             heading(node) {
                 const { depth } = node;
-                const { allow, disallow } = headingMap[depth];
+                const { allow, disallow } = headingMap[depth - 1];
                 const headingText = sourceCode.getText(node);
-                if (!allow.some(regex => testRegexStateless(regex, headingText))) {
+                if (allow.length === 0) {
+                    context.report({
+                        node,
+                        messageId: 'emptyAllowHeading',
+                        data: {
+                            depth,
+                        },
+                    });
+                }
+                else if (!allow.some(regex => testRegexStateless(regex, headingText))) {
                     context.report({
                         node,
                         messageId: 'allowHeading',

package/build/rules/allow-image-url.d.ts

@@ -3,14 +3,35 @@
  * @author lumir(lumirlumir)
  */
 import type { Definition } from 'mdast';
+/**
+ * Options for the `allow-image-url` rule.
+ */
 type RuleOptions = [
     {
-        allowUrls: RegExp[];
-        disallowUrls: RegExp[];
+        /**
+         * Allowed URLs act like a ***whitelist***.
+         *
+         * Only those written on the whitelist **can** pass through.
+         * @default [new RegExp('.*', 'u')] // But as a regex literal.
+         */
+        allowUrls: (RegExp | string)[];
+        /**
+         * On the contrary, disallowed URLs act like a ***blacklist***.
+         *
+         * Only those written on the blacklist **cannot** pass through.
+         * @default []
+         */
+        disallowUrls: (RegExp | string)[];
+        /**
+         * When specified, specific definitions are allowed if they match one of the identifiers in this array.
+         *
+         * This is useful for ignoring definitions that are intentionally left, such as comments or placeholders.
+         * @default ['//']
+         */
         allowDefinitions: string[];
     }
 ];
-type MessageIds = 'allowImageUrl' | 'disallowImageUrl';
+type MessageIds = 'allowImageUrl' | 'disallowImageUrl' | 'emptyAllowImageUrl';
 declare const _default: {
     readonly meta: {
         readonly type: "problem";
@@ -26,14 +47,24 @@ declare const _default: {
                 readonly allowUrls: {
                     readonly type: "array";
                     readonly items: {
-                        readonly type: "object";
+                        readonly oneOf: [{
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                        }, {
+                            readonly type: "string";
+                        }];
                     };
                     readonly uniqueItems: true;
                 };
                 readonly disallowUrls: {
                     readonly type: "array";
                     readonly items: {
-                        readonly type: "object";
+                        readonly oneOf: [{
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                        }, {
+                            readonly type: "string";
+                        }];
                     };
                     readonly uniqueItems: true;
                 };
@@ -55,6 +86,7 @@ declare const _default: {
         readonly messages: {
             readonly allowImageUrl: "The URL `{{ url }}` is not in the list of allowed URLs. (Allow: {{ patterns }}).";
             readonly disallowImageUrl: "The URL `{{ url }}` is in the list of disallowed URLs. (Disallow: {{ patterns }}).";
+            readonly emptyAllowImageUrl: "The URL `{{ url }}` is not allowed because the list of allowed URLs is empty.";
         };
         readonly language: "markdown";
         readonly dialects: ["commonmark", "gfm"];

package/build/rules/allow-image-url.js

@@ -3,7 +3,7 @@
  * @author lumir(lumirlumir)
  */
 import { normalizeIdentifier } from 'micromark-util-normalize-identifier';
-import { getElementsByTagName, testRegexStateless } from '../core/utils/index.js';
+import { getElementsByTagName, normalizeRegexPattern, testRegexStateless, } from '../core/utils/index.js';
 import { URL_RULE_DOCS } from '../core/constants.js';
 // --------------------------------------------------------------------------------
 // Rule Definition
@@ -24,14 +24,20 @@ export default {
                     allowUrls: {
                         type: 'array',
                         items: {
-                            type: 'object',
+                            oneOf: [
+                                { type: 'object', additionalProperties: false },
+                                { type: 'string' },
+                            ],
                         },
                         uniqueItems: true,
                     },
                     disallowUrls: {
                         type: 'array',
                         items: {
-                            type: 'object',
+                            oneOf: [
+                                { type: 'object', additionalProperties: false },
+                                { type: 'string' },
+                            ],
                         },
                         uniqueItems: true,
                     },
@@ -56,14 +62,17 @@ export default {
         messages: {
             allowImageUrl: 'The URL `{{ url }}` is not in the list of allowed URLs. (Allow: {{ patterns }}).',
             disallowImageUrl: 'The URL `{{ url }}` is in the list of disallowed URLs. (Disallow: {{ patterns }}).',
+            emptyAllowImageUrl: 'The URL `{{ url }}` is not allowed because the list of allowed URLs is empty.',
         },
         language: 'markdown',
         dialects: ['commonmark', 'gfm'],
     },
     create(context) {
         const { sourceCode } = context;
-        const [{ allowUrls, disallowUrls }] = context.options;
-        const allowDefinitions = new Set(context.options[0].allowDefinitions.map(identifier => normalizeIdentifier(identifier).toLowerCase()));
+        const [{ allowUrls: allowUrlsOption, disallowUrls: disallowUrlsOption, allowDefinitions: allowDefinitionsOption, },] = context.options;
+        const allowUrls = allowUrlsOption.map(normalizeRegexPattern);
+        const disallowUrls = disallowUrlsOption.map(normalizeRegexPattern);
+        const allowDefinitions = new Set(allowDefinitionsOption.map(identifier => normalizeIdentifier(identifier).toLowerCase()));
         const images = new Set();
         const imageReferenceIdentifiers = new Set();
         const definitions = new Set();
@@ -114,7 +123,16 @@ export default {
                  * Therefore, calling the `some` method on an empty array will always return `false`.
                  */
                 for (const { loc, url } of images) {
-                    if (!allowUrls.some(regex => testRegexStateless(regex, url))) {
+                    if (allowUrls.length === 0) {
+                        context.report({
+                            loc,
+                            messageId: 'emptyAllowImageUrl',
+                            data: {
+                                url,
+                            },
+                        });
+                    }
+                    else if (!allowUrls.some(regex => testRegexStateless(regex, url))) {
                         context.report({
                             loc,
                             messageId: 'allowImageUrl',

package/build/rules/allow-link-url.d.ts

@@ -3,14 +3,35 @@
  * @author lumir(lumirlumir)
  */
 import type { Definition } from 'mdast';
+/**
+ * Options for the `allow-link-url` rule.
+ */
 type RuleOptions = [
     {
-        allowUrls: RegExp[];
-        disallowUrls: RegExp[];
+        /**
+         * Allowed URLs act like a ***whitelist***.
+         *
+         * Only those written on the whitelist **can** pass through.
+         * @default [new RegExp('.*', 'u')] // But as a regex literal.
+         */
+        allowUrls: (RegExp | string)[];
+        /**
+         * On the contrary, disallowed URLs act like a ***blacklist***.
+         *
+         * Only those written on the blacklist **cannot** pass through.
+         * @default []
+         */
+        disallowUrls: (RegExp | string)[];
+        /**
+         * When specified, specific definitions are allowed if they match one of the identifiers in this array.
+         *
+         * This is useful for ignoring definitions that are intentionally left, such as comments or placeholders.
+         * @default ['//']
+         */
         allowDefinitions: string[];
     }
 ];
-type MessageIds = 'allowLinkUrl' | 'disallowLinkUrl';
+type MessageIds = 'allowLinkUrl' | 'disallowLinkUrl' | 'emptyAllowLinkUrl';
 declare const _default: {
     readonly meta: {
         readonly type: "problem";
@@ -26,14 +47,24 @@ declare const _default: {
                 readonly allowUrls: {
                     readonly type: "array";
                     readonly items: {
-                        readonly type: "object";
+                        readonly oneOf: [{
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                        }, {
+                            readonly type: "string";
+                        }];
                     };
                     readonly uniqueItems: true;
                 };
                 readonly disallowUrls: {
                     readonly type: "array";
                     readonly items: {
-                        readonly type: "object";
+                        readonly oneOf: [{
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                        }, {
+                            readonly type: "string";
+                        }];
                     };
                     readonly uniqueItems: true;
                 };
@@ -55,6 +86,7 @@ declare const _default: {
         readonly messages: {
             readonly allowLinkUrl: "The URL `{{ url }}` is not in the list of allowed URLs. (Allow: {{ patterns }}).";
             readonly disallowLinkUrl: "The URL `{{ url }}` is in the list of disallowed URLs. (Disallow: {{ patterns }}).";
+            readonly emptyAllowLinkUrl: "The URL `{{ url }}` is not allowed because the list of allowed URLs is empty.";
         };
         readonly language: "markdown";
         readonly dialects: ["commonmark", "gfm"];

package/build/rules/allow-link-url.js

@@ -3,7 +3,7 @@
  * @author lumir(lumirlumir)
  */
 import { normalizeIdentifier } from 'micromark-util-normalize-identifier';
-import { getElementsByTagName, testRegexStateless } from '../core/utils/index.js';
+import { getElementsByTagName, normalizeRegexPattern, testRegexStateless, } from '../core/utils/index.js';
 import { URL_RULE_DOCS } from '../core/constants.js';
 // --------------------------------------------------------------------------------
 // Rule Definition
@@ -24,14 +24,20 @@ export default {
                     allowUrls: {
                         type: 'array',
                         items: {
-                            type: 'object',
+                            oneOf: [
+                                { type: 'object', additionalProperties: false },
+                                { type: 'string' },
+                            ],
                         },
                         uniqueItems: true,
                     },
                     disallowUrls: {
                         type: 'array',
                         items: {
-                            type: 'object',
+                            oneOf: [
+                                { type: 'object', additionalProperties: false },
+                                { type: 'string' },
+                            ],
                         },
                         uniqueItems: true,
                     },
@@ -56,14 +62,17 @@ export default {
         messages: {
             allowLinkUrl: 'The URL `{{ url }}` is not in the list of allowed URLs. (Allow: {{ patterns }}).',
             disallowLinkUrl: 'The URL `{{ url }}` is in the list of disallowed URLs. (Disallow: {{ patterns }}).',
+            emptyAllowLinkUrl: 'The URL `{{ url }}` is not allowed because the list of allowed URLs is empty.',
         },
         language: 'markdown',
         dialects: ['commonmark', 'gfm'],
     },
     create(context) {
         const { sourceCode } = context;
-        const [{ allowUrls, disallowUrls }] = context.options;
-        const allowDefinitions = new Set(context.options[0].allowDefinitions.map(identifier => normalizeIdentifier(identifier).toLowerCase()));
+        const [{ allowUrls: allowUrlsOption, disallowUrls: disallowUrlsOption, allowDefinitions: allowDefinitionsOption, },] = context.options;
+        const allowUrls = allowUrlsOption.map(normalizeRegexPattern);
+        const disallowUrls = disallowUrlsOption.map(normalizeRegexPattern);
+        const allowDefinitions = new Set(allowDefinitionsOption.map(identifier => normalizeIdentifier(identifier).toLowerCase()));
         const links = new Set();
         const linkReferenceIdentifiers = new Set();
         const definitions = new Set();
@@ -114,7 +123,16 @@ export default {
                  * Therefore, calling the `some` method on an empty array will always return `false`.
                  */
                 for (const { loc, url } of links) {
-                    if (!allowUrls.some(regex => testRegexStateless(regex, url))) {
+                    if (allowUrls.length === 0) {
+                        context.report({
+                            loc,
+                            messageId: 'emptyAllowLinkUrl',
+                            data: {
+                                url,
+                            },
+                        });
+                    }
+                    else if (!allowUrls.some(regex => testRegexStateless(regex, url))) {
                         context.report({
                             loc,
                             messageId: 'allowLinkUrl',

package/build/rules/code-lang-shorthand.d.ts

@@ -2,10 +2,25 @@
  * @fileoverview Rule to enforce the use of shorthand for code block language identifiers.
  * @author lumir(lumirlumir)
  */
-type RuleOptions = [{
-    allow: string[];
-    override: Record<string, string>;
-}];
+/**
+ * Options for the `code-lang-shorthand` rule.
+ */
+type RuleOptions = [
+    {
+        /**
+         * An array of code block language identifiers to allow.
+         *
+         * Each value must be the full, unabridged language identifier.
+         * @default []
+         */
+        allow: string[];
+        /**
+         * An object where the **key** is the full, unabridged language identifier and the **value** is the abbreviated form.
+         * @default {}
+         */
+        override: Record<string, string>;
+    }
+];
 declare const _default: {
     readonly meta: {
         readonly type: "problem";

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

@@ -2,15 +2,31 @@
  * @fileoverview Rule to enforce consistent code style.
  * @author lumir(lumirlumir)
  */
-type CodeStyle = 'indent' | 'fence-backtick' | 'fence-tilde';
+type CodeStyle = (typeof CODE_STYLE)[number];
+/**
+ * Options for the `consistent-code-style` rule.
+ */
 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;
+        /**
+         * Require a specific number of blank lines above each fenced code block.
+         * @default false
+         */
         blankLineAbove: number | false;
+        /**
+         * Require a specific number of blank lines below each fenced code block.
+         * @default false
+         */
         blankLineBelow: number | false;
     }
 ];
 type MessageIds = 'style' | 'blankLineAbove' | 'blankLineBelow';
+declare const CODE_STYLE: readonly ["indent", "fence-backtick", "fence-tilde"];
 declare const _default: {
     readonly meta: {
         readonly type: "layout";

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

@@ -19,6 +19,7 @@ import { URL_RULE_DOCS } from '../core/constants.js';
 // --------------------------------------------------------------------------------
 // Helper
 // --------------------------------------------------------------------------------
+const CODE_STYLE = ['indent', 'fence-backtick', 'fence-tilde'];
 /**
  * Get the current code style based on the given text.
  * @param text The text to determine the code style from.
@@ -54,7 +55,7 @@ export default {
                 type: 'object',
                 properties: {
                     style: {
-                        enum: ['consistent', 'indent', 'fence-backtick', 'fence-tilde'],
+                        enum: ['consistent', ...CODE_STYLE],
                     },
                     blankLineAbove: {
                         oneOf: [

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

@@ -2,9 +2,20 @@
  * @fileoverview Rule to enforce consistent delete style.
  * @author lumir(lumirlumir)
  */
-type RuleOptions = [{
-    style: 'consistent' | '~' | '~~';
-}];
+type DeleteStyle = (typeof DELETE_STYLE)[number];
+/**
+ * Options for the `consistent-delete-style` rule.
+ */
+type RuleOptions = [
+    {
+        /**
+         * When `style` is set to `'consistent'`, the rule enforces that all deletes in the document use the same style as the first one encountered.
+         * @default 'consistent'
+         */
+        style: 'consistent' | DeleteStyle;
+    }
+];
+declare const DELETE_STYLE: readonly ["~", "~~"];
 declare const _default: {
     readonly meta: {
         readonly type: "layout";

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

@@ -7,6 +7,10 @@
 // --------------------------------------------------------------------------------
 import { URL_RULE_DOCS } from '../core/constants.js';
 // --------------------------------------------------------------------------------
+// Helper
+// --------------------------------------------------------------------------------
+const DELETE_STYLE = ['~', '~~'];
+// --------------------------------------------------------------------------------
 // Rule Definition
 // --------------------------------------------------------------------------------
 export default {
@@ -24,7 +28,7 @@ export default {
                 type: 'object',
                 properties: {
                     style: {
-                        enum: ['consistent', '~', '~~'],
+                        enum: ['consistent', ...DELETE_STYLE],
                     },
                 },
                 additionalProperties: false,

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

@@ -2,9 +2,20 @@
  * @fileoverview Rule to enforce consistent emphasis style.
  * @author lumir(lumirlumir)
  */
-type RuleOptions = [{
-    style: 'consistent' | '*' | '_';
-}];
+type EmphasisStyle = (typeof EMPHASIS_STYLE)[number];
+/**
+ * Options for the `consistent-emphasis-style` rule.
+ */
+type RuleOptions = [
+    {
+        /**
+         * When `style` is set to `'consistent'`, the rule enforces that all emphasis in the document use the same style as the first one encountered.
+         * @default 'consistent'
+         */
+        style: 'consistent' | EmphasisStyle;
+    }
+];
+declare const EMPHASIS_STYLE: readonly ["*", "_"];
 declare const _default: {
     readonly meta: {
         readonly type: "layout";

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

@@ -7,6 +7,10 @@
 // --------------------------------------------------------------------------------
 import { URL_RULE_DOCS } from '../core/constants.js';
 // --------------------------------------------------------------------------------
+// Helper
+// --------------------------------------------------------------------------------
+const EMPHASIS_STYLE = ['*', '_'];
+// --------------------------------------------------------------------------------
 // Rule Definition
 // --------------------------------------------------------------------------------
 export default {
@@ -24,7 +28,7 @@ export default {
                 type: 'object',
                 properties: {
                     style: {
-                        enum: ['consistent', '*', '_'],
+                        enum: ['consistent', ...EMPHASIS_STYLE],
                     },
                 },
                 additionalProperties: false,

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

@@ -2,9 +2,20 @@
  * @fileoverview Rule to enforce consistent strong style.
  * @author lumir(lumirlumir)
  */
-type RuleOptions = [{
-    style: 'consistent' | '*' | '_';
-}];
+type StrongStyle = (typeof STRONG_STYLE)[number];
+/**
+ * Options for the `consistent-strong-style` rule.
+ */
+type RuleOptions = [
+    {
+        /**
+         * When `style` is set to `'consistent'`, the rule enforces that all strong in the document use the same style as the first one encountered.
+         * @default 'consistent'
+         */
+        style: 'consistent' | StrongStyle;
+    }
+];
+declare const STRONG_STYLE: readonly ["*", "_"];
 declare const _default: {
     readonly meta: {
         readonly type: "layout";

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

@@ -7,6 +7,10 @@
 // --------------------------------------------------------------------------------
 import { URL_RULE_DOCS } from '../core/constants.js';
 // --------------------------------------------------------------------------------
+// Helper
+// --------------------------------------------------------------------------------
+const STRONG_STYLE = ['*', '_'];
+// --------------------------------------------------------------------------------
 // Rule Definition
 // --------------------------------------------------------------------------------
 export default {
@@ -24,7 +28,7 @@ export default {
                 type: 'object',
                 properties: {
                     style: {
-                        enum: ['consistent', '*', '_'],
+                        enum: ['consistent', ...STRONG_STYLE],
                     },
                 },
                 additionalProperties: false,

package/build/rules/consistent-thematic-break-style.d.ts

@@ -2,9 +2,20 @@
  * @fileoverview Rule to enforce consistent thematic break style.
  * @author lumir(lumirlumir)
  */
-type RuleOptions = [{
-    style: string;
-}];
+/**
+ * Options for the `consistent-thematic-break-style` rule.
+ */
+type RuleOptions = [
+    {
+        /**
+         * When `style` is set to `'consistent'`, the rule enforces that all thematic breaks in the document use the same style as the first one encountered.
+         *
+         * You can also specify a particular style by setting style to `'---'`, `'***'`, `'___'`, or any other valid thematic break, which will enforce that all thematic breaks use the specified style. A valid thematic break is a sequence of three or more matching `-`, `*`, or `_` characters, each optionally followed by any number of spaces or tabs.
+         * @default 'consistent'
+         */
+        style: string;
+    }
+];
 declare const _default: {
     readonly meta: {
         readonly type: "layout";

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

@@ -3,10 +3,24 @@
  * @author hyoban
  */
 import type { ListItem } from 'mdast';
-type UnorderedListStyle = '*' | '+' | '-';
-type RuleOptions = [{
-    style: 'consistent' | 'sublist' | UnorderedListStyle;
-}];
+type UnorderedListStyle = (typeof UNORDERED_LIST_STYLE)[number];
+/**
+ * Options for the `consistent-unordered-list-style` rule.
+ */
+type RuleOptions = [
+    {
+        /**
+         * When `style` is set to `'consistent'`, the rule enforces that all unordered list markers in the document use the same style as the first one encountered.
+         *
+         * When `style` is set to `'sublist'`, the rule enforces that all unordered list markers in sublists use a consistent symbol that differs from that of their parent list, depending on the nesting depth.
+         *
+         * You can also specify a particular style by setting style to `'-'`, `'*'`, or `'+'`, which will enforce that all unordered list markers use the specified style.
+         * @default 'consistent'
+         */
+        style: 'consistent' | 'sublist' | UnorderedListStyle;
+    }
+];
+declare const UNORDERED_LIST_STYLE: readonly ["*", "+", "-"];
 declare const _default: {
     readonly meta: {
         readonly type: "layout";

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

@@ -6,6 +6,7 @@ import { URL_RULE_DOCS } from '../core/constants.js';
 // --------------------------------------------------------------------------------
 // Helper
 // --------------------------------------------------------------------------------
+const UNORDERED_LIST_STYLE = ['*', '+', '-'];
 /**
  * Get the next unordered list style in sequence.
  * Inspired by [`markdownlint`](https://github.com/DavidAnson/markdownlint/blob/v0.40.0/lib/md004.mjs#L9).
@@ -41,7 +42,7 @@ export default {
                 type: 'object',
                 properties: {
                     style: {
-                        enum: ['consistent', 'sublist', '*', '+', '-'],
+                        enum: ['consistent', 'sublist', ...UNORDERED_LIST_STYLE],
                     },
                 },
                 additionalProperties: false,