markdownlint 0.26.1 → 0.27.0

package/doc/md051.md

@@ -0,0 +1,50 @@
+# `MD051` - Link fragments should be valid
+
+Tags: `links`
+
+Aliases: `link-fragments`
+
+Fixable: Some violations can be fixed by tooling
+
+This rule is triggered when a link fragment does not match any of the fragments
+that are automatically generated for headings in a document:
+
+```markdown
+# Title
+
+[Link](#fragment)
+```
+
+To fix this issue, change the link fragment to reference an existing heading:
+
+```markdown
+# Title
+
+[Link](#title)
+```
+
+Alternatively, an HTML `a` tag with an `id` or a `name` attribute can be used to
+define a fragment:
+
+```markdown
+<a id="bookmark"></a>
+
+[Link](#bookmark)
+```
+
+An `a` tag can be useful in scenarios where a heading is not appropriate or for
+control over the text of the fragment identifier.
+
+Rationale: [GitHub section links][github-section-links] are created
+automatically for every heading when Markdown content is displayed on GitHub.
+This makes it easy to link directly to different sections within a document.
+However, section links change if headings are renamed or removed. This rule
+helps identify broken section links within a document.
+
+Section links are **not** part of the CommonMark specification. This rule
+enforces the [GitHub heading algorithm][github-heading-algorithm] which is:
+convert heading to lowercase, remove punctuation, convert spaces to dashes,
+append an incrementing integer as needed for uniqueness.
+
+[github-section-links]: https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax#section-links
+[github-heading-algorithm]: https://github.com/gjtorikian/html-pipeline/blob/main/lib/html/pipeline/toc_filter.rb

package/doc/md052.md

@@ -0,0 +1,33 @@
+# `MD052` - Reference links and images should use a label that is defined
+
+Tags: `images`, `links`
+
+Aliases: `reference-links-images`
+
+Links and images in Markdown can provide the link destination or image source
+at the time of use or can define it elsewhere and use a label for reference.
+The reference format is convenient for keeping paragraph text clutter-free
+and makes it easy to reuse the same URL in multiple places.
+
+There are three kinds of reference links and images:
+
+```markdown
+Full: [text][label]
+Collapsed: [label][]
+Shortcut: [label]
+
+Full: ![text][image]
+Collapsed: ![image][]
+Shortcut: ![image]
+
+[label]: https://example.com/label
+[image]: https://example.com/image
+```
+
+A link or image renders correctly when a corresponding label is defined, but
+the text displays with brackets if the label is not present. This rule warns
+of undefined labels for "full" and "collapsed" reference syntax.
+
+> "Shortcut" syntax is ambiguous and a missing label will not generate an
+  error. For example, `[shortcut]` could be a shortcut link or the text
+  "shortcut" in brackets.

package/doc/md053.md

@@ -0,0 +1,38 @@
+# `MD053` - Link and image reference definitions should be needed
+
+Tags: `images`, `links`
+
+Aliases: `link-image-reference-definitions`
+
+Parameters:
+
+- `ignored_definitions`: Ignored definitions (`string[]`, default `["//"]`)
+
+Fixable: Some violations can be fixed by tooling
+
+Links and images in Markdown can provide the link destination or image source
+at the time of use or can define it elsewhere and use a label for reference.
+The reference format is convenient for keeping paragraph text clutter-free
+and makes it easy to reuse the same URL in multiple places.
+
+Because link and image reference definitions are located separately from
+where they are used, there are two scenarios where a definition can be
+unnecessary:
+
+1. If a label is not referenced by any link or image in a document, that
+   definition is unused and can be deleted.
+2. If a label is defined multiple times in a document, the first definition is
+   used and the others can be deleted.
+
+This rule considers a reference definition to be used if any link or image
+reference has the corresponding label. The "full", "collapsed", and "shortcut"
+formats are all supported.
+
+If there are reference definitions that are deliberately unreferenced, they can
+be ignored by setting the `ignored_definitions` parameter. The default value of
+this parameter ignores the following convention for adding non-HTML comments to
+Markdown:
+
+```markdown
+[//]: # (This behaves like a comment)
+```

package/helpers/README.md

@@ -4,23 +4,24 @@
 
 ## Overview
 
-The [Markdown](https://en.wikipedia.org/wiki/Markdown) linter
-[`markdownlint`](https://github.com/DavidAnson/markdownlint) offers a variety of built-in validation
-[rules](https://github.com/DavidAnson/markdownlint/blob/main/doc/Rules.md) and supports the
-creation of [custom rules](https://github.com/DavidAnson/markdownlint/blob/main/doc/CustomRules.md).
-The internal rules share various helper functions; this package exposes those for reuse by custom rules.
+The [Markdown][markdown] linter [`markdownlint`][markdownlint] offers a variety
+of built-in validation [rules][rules] and supports the creation of [custom
+rules][custom-rules]. The internal rules share various helper functions; this
+package exposes those for reuse by custom rules.
 
 ## API
 
-_Undocumented_ - This package exports the internal functions as-is. The APIs were not originally meant
-to be public, are not officially supported, and may change from release to release. There are brief
-descriptive comments above each function, but no [JSDoc](https://en.m.wikipedia.org/wiki/JSDoc)
-annotations. That said, some of what's here will be useful to custom rule authors and may avoid
-duplicating code.
+*Undocumented* - This package exports the internal functions as-is. The APIs
+were not originally meant to be public, are not officially supported, and may
+change from release to release. There are brief descriptive comments above each
+function, but no [JSDoc][jsdoc] annotations. That said, some of what's here will
+be useful to custom rule authors and may avoid duplicating code.
 
-## Example
+## Examples
 
-```js
+### Using Helpers from a Custom Rule
+
+```javascript
 const { forEachLine, getLineMetadata } = require("markdownlint-rule-helpers");
 
 module.exports = {
@@ -42,9 +43,28 @@ module.exports = {
 };
 ```
 
-See also: [`markdownlint` built-in rule implementations](https://github.com/DavidAnson/markdownlint/tree/main/lib).
+### Applying Recommended Fixes
+
+```javascript
+const { "sync": markdownlintSync } = require("markdownlint");
+const markdownlintRuleHelpers = require("markdownlint-rule-helpers");
+
+function fixMarkdownlintViolations(content) {
+  const fixResults = markdownlintSync({ strings: { content } });
+  return markdownlintRuleHelpers.applyFixes(content, fixResults.content);
+}
+```
+
+See also: [`markdownlint` built-in rule implementations][lib].
 
 ## Tests
 
-_None_ - The entire body of code is tested to 100% coverage by the core `markdownlint` project,
-so there are no additional tests here.
+*None* - The entire body of code is tested to 100% coverage by the core
+`markdownlint` project, so there are no additional tests here.
+
+[custom-rules]: https://github.com/DavidAnson/markdownlint/blob/main/doc/CustomRules.md
+[jsdoc]: https://en.m.wikipedia.org/wiki/JSDoc
+[lib]: https://github.com/DavidAnson/markdownlint/tree/main/lib
+[markdown]: https://en.wikipedia.org/wiki/Markdown
+[markdownlint]: https://github.com/DavidAnson/markdownlint
+[rules]: https://github.com/DavidAnson/markdownlint/blob/main/doc/Rules.md

package/helpers/helpers.js

@@ -10,32 +10,35 @@ module.exports.newLineRe = newLineRe;
 // Regular expression for matching common front matter (YAML and TOML)
 module.exports.frontMatterRe =
   // eslint-disable-next-line max-len
-  /((^---\s*$[^]*?^---\s*$)|(^\+\+\+\s*$[^]*?^(\+\+\+|\.\.\.)\s*$)|(^\{\s*$[^]*?^\}\s*$))(\r\n|\r|\n|$)/m;
+  /((^---\s*$[\s\S]*?^---\s*)|(^\+\+\+\s*$[\s\S]*?^(\+\+\+|\.\.\.)\s*)|(^\{\s*$[\s\S]*?^\}\s*))(\r\n|\r|\n|$)/m;
 
 // Regular expression for matching the start of inline disable/enable comments
 const inlineCommentStartRe =
   // eslint-disable-next-line max-len
-  /(<!--\s*markdownlint-(disable|enable|capture|restore|disable-file|enable-file|disable-line|disable-next-line|configure-file))(?:\s|-->)/ig;
+  /(<!--\s*markdownlint-(disable|enable|capture|restore|disable-file|enable-file|disable-line|disable-next-line|configure-file))(?:\s|-->)/gi;
 module.exports.inlineCommentStartRe = inlineCommentStartRe;
 
 // Regular expression for matching HTML elements
-const htmlElementRe = /<(([A-Za-z][A-Za-z0-9-]*)(?:\s[^`>]*)?)\/?>/g;
+const htmlElementRe = /<(([A-Za-z][A-Za-z\d-]*)(?:\s[^`>]*)?)\/?>/g;
 module.exports.htmlElementRe = htmlElementRe;
 
 // Regular expressions for range matching
-module.exports.bareUrlRe = /(?:http|ftp)s?:\/\/[^\s\]"']*(?:\/|[^\s\]"'\W])/ig;
 module.exports.listItemMarkerRe = /^([\s>]*)(?:[*+-]|\d+[.)])\s+/;
 module.exports.orderedListItemMarkerRe = /^[\s>]*0*(\d+)[.)]/;
 
 // Regular expression for all instances of emphasis markers
 const emphasisMarkersRe = /[_*]/g;
 
-// Regular expression for reference links (full and collapsed but not shortcut)
+// Regular expression for blockquote prefixes
+const blockquotePrefixRe = /^[>\s]*/;
+module.exports.blockquotePrefixRe = blockquotePrefixRe;
+
+// Regular expression for reference links (full, collapsed, and shortcut)
 const referenceLinkRe =
-  /!?\\?\[((?:\[[^\]\0]*]|[^\]\0])*)](?:(?:\[([^\]\0]*)\])|[^(]|$)/g;
+  /!?\\?\[((?:\[[^\]\0]*\]|[^[\]\0])*)\](?:\[([^\]\0]*)\]|([^(])|$)/g;
 
 // Regular expression for link reference definitions
-const linkReferenceDefinitionRe = /^ {0,3}\[([^\]]*[^\\])]:/;
+const linkReferenceDefinitionRe = /^ {0,3}\[([^\]]*[^\\])\]:/;
 module.exports.linkReferenceDefinitionRe = linkReferenceDefinitionRe;
 
 // All punctuation characters (normal and full-width)
@@ -138,6 +141,12 @@ module.exports.includesSorted = function includesSorted(array, element) {
 // https://spec.commonmark.org/0.29/#html-comment
 const htmlCommentBegin = "<!--";
 const htmlCommentEnd = "-->";
+const safeCommentCharacter = ".";
+const startsWithPipeRe = /^ *\|/;
+const notCrLfRe = /[^\r\n]/g;
+const notSpaceCrLfRe = /[^ \r\n]/g;
+const trailingSpaceRe = / +[\r\n]/g;
+const replaceTrailingSpace = (s) => s.replace(notCrLfRe, safeCommentCharacter);
 module.exports.clearHtmlCommentText = function clearHtmlCommentText(text) {
   let i = 0;
   while ((i = text.indexOf(htmlCommentBegin, i)) !== -1) {
@@ -148,24 +157,30 @@ module.exports.clearHtmlCommentText = function clearHtmlCommentText(text) {
     }
     // If the comment has content...
     if (j > i + htmlCommentBegin.length) {
-      let k = i - 1;
-      while (text[k] === " ") {
-        k--;
-      }
-      // If comment is not within an indented code block...
-      if (k >= i - 4) {
-        const content = text.slice(i + htmlCommentBegin.length, j);
-        const isBlock = (k < 0) || (text[k] === "\n");
-        const isValid = isBlock ||
-          (!content.startsWith(">") && !content.startsWith("->") &&
-           !content.endsWith("-") && !content.includes("--"));
-        // If a valid block/inline comment...
-        if (isValid) {
-          text =
-            text.slice(0, i + htmlCommentBegin.length) +
-            content.replace(/[^\r\n]/g, ".") +
-            text.slice(j);
-        }
+      const content = text.slice(i + htmlCommentBegin.length, j);
+      const lastLf = text.lastIndexOf("\n", i) + 1;
+      const preText = text.slice(lastLf, i);
+      const isBlock = preText.trim().length === 0;
+      const couldBeTable = startsWithPipeRe.test(preText);
+      const spansTableCells = couldBeTable && content.includes("\n");
+      const isValid =
+        isBlock ||
+        !(
+          spansTableCells ||
+          content.startsWith(">") ||
+          content.startsWith("->") ||
+          content.endsWith("-") ||
+          content.includes("--")
+        );
+      // If a valid block/inline comment...
+      if (isValid) {
+        const clearedContent = content
+          .replace(notSpaceCrLfRe, safeCommentCharacter)
+          .replace(trailingSpaceRe, replaceTrailingSpace);
+        text =
+          text.slice(0, i + htmlCommentBegin.length) +
+          clearedContent +
+          text.slice(j);
       }
     }
     i = j + htmlCommentEnd.length;
@@ -402,17 +417,22 @@ module.exports.flattenLists = function flattenLists(tokens) {
   return flattenedLists;
 };
 
-// Calls the provided function for each specified inline child token
-module.exports.forEachInlineChild =
+/**
+ * Calls the provided function for each specified inline child token.
+ *
+ * @param {Object} params RuleParams instance.
+ * @param {string} type Token type identifier.
+ * @param {Function} handler Callback function.
+ * @returns {void}
+ */
 function forEachInlineChild(params, type, handler) {
-  filterTokens(params, "inline", function forToken(token) {
-    for (const child of token.children) {
-      if (child.type === type) {
-        handler(child, token);
-      }
+  filterTokens(params, "inline", (token) => {
+    for (const child of token.children.filter((c) => c.type === type)) {
+      handler(child, token);
     }
   });
-};
+}
+module.exports.forEachInlineChild = forEachInlineChild;
 
 // Calls the provided function for each heading's content
 module.exports.forEachHeading = function forEachHeading(params, handler) {
@@ -592,6 +612,7 @@ module.exports.codeBlockAndSpanRanges = (params, lineMetadata) => {
  */
 module.exports.htmlElementRanges = (params, lineMetadata) => {
   const exclusions = [];
+  // Match with htmlElementRe
   forEachLine(lineMetadata, (line, lineIndex, inCode) => {
     let match = null;
     // eslint-disable-next-line no-unmodified-loop-condition
@@ -599,6 +620,31 @@ module.exports.htmlElementRanges = (params, lineMetadata) => {
       exclusions.push([ lineIndex, match.index, match[0].length ]);
     }
   });
+  // Match with html_inline
+  forEachInlineChild(params, "html_inline", (token, parent) => {
+    const parentContent = parent.content;
+    let tokenContent = token.content;
+    const parentIndex = parentContent.indexOf(tokenContent);
+    let deltaLines = 0;
+    let indent = 0;
+    for (let i = parentIndex - 1; i >= 0; i--) {
+      if (parentContent[i] === "\n") {
+        deltaLines++;
+      } else if (deltaLines === 0) {
+        indent++;
+      }
+    }
+    let lineIndex = token.lineNumber - 1 + deltaLines;
+    do {
+      const index = tokenContent.indexOf("\n");
+      const length = (index === -1) ? tokenContent.length : index;
+      exclusions.push([ lineIndex, indent, length ]);
+      tokenContent = tokenContent.slice(length + 1);
+      lineIndex++;
+      indent = 0;
+    } while (tokenContent.length > 0);
+  });
+  // Return results
   return exclusions;
 };
 
@@ -778,14 +824,15 @@ module.exports.emphasisMarkersInContent = emphasisMarkersInContent;
 function getReferenceLinkImageData(lineMetadata) {
   // Initialize return values
   const references = new Map();
-  const shortcuts = new Set();
+  const shortcuts = new Map();
   const definitions = new Map();
   const duplicateDefinitions = [];
+  const definitionLineIndices = [];
   // Define helper functions
   const normalizeLabel = (s) => s.toLowerCase().trim().replace(/\s+/g, " ");
   const exclusions = [];
   const excluded = (match) => withinAnyRange(
-    exclusions, 0, match.index, match[0].length
+    exclusions, 0, match.index, match[0].length - (match[3] || "").length
   );
   // Convert input to single-line so multi-line links/images are easier
   const lineOffsets = [];
@@ -794,6 +841,7 @@ function getReferenceLinkImageData(lineMetadata) {
   forEachLine(lineMetadata, (line, lineIndex, inCode) => {
     lineOffsets[lineIndex] = currentOffset;
     if (!inCode) {
+      line = line.replace(blockquotePrefixRe, "");
       if (line.trim().length === 0) {
         // Allow RegExp to detect the end of a block
         line = "\0";
@@ -819,7 +867,13 @@ function getReferenceLinkImageData(lineMetadata) {
         } else {
           definitions.set(label, lineIndex);
         }
-        exclusions.push([ 0, lineOffsets[lineIndex], line.length ]);
+        const labelLength = linkReferenceDefinitionMatch[0].length;
+        exclusions.push([ 0, lineOffsets[lineIndex], labelLength ]);
+        const hasDefinition = line.slice(labelLength).trim().length > 0;
+        definitionLineIndices.push(lineIndex);
+        if (!hasDefinition) {
+          definitionLineIndices.push(lineIndex + 1);
+        }
       }
     }
   });
@@ -845,8 +899,7 @@ function getReferenceLinkImageData(lineMetadata) {
         !matchString.startsWith("!\\") &&
         !matchText.endsWith("\\") &&
         !(matchLabel || "").endsWith("\\") &&
-        (topLevel || matchString.startsWith("!")) &&
-        !excluded(referenceLinkMatch)
+        !(topLevel && excluded(referenceLinkMatch))
       ) {
         const shortcutLink = (matchLabel === undefined);
         const collapsedLink =
@@ -855,41 +908,44 @@ function getReferenceLinkImageData(lineMetadata) {
           (shortcutLink || collapsedLink) ? matchText : matchLabel
         );
         if (label.length > 0) {
+          const referenceindex = referenceLinkMatch.index;
+          if (topLevel) {
+            // Calculate line index
+            while (lineOffsets[lineIndex + 1] <= referenceindex) {
+              lineIndex++;
+            }
+          } else {
+            // Use provided line index
+            lineIndex = contentLineIndex;
+          }
+          const referenceIndex = referenceindex +
+            (topLevel ? -lineOffsets[lineIndex] : contentIndex);
+          const referenceDatum = [
+            lineIndex,
+            referenceIndex,
+            matchString.length,
+            matchText.length,
+            (matchLabel || "").length
+          ];
           if (shortcutLink) {
-            // Track, but don't validate due to ambiguity: "text [text] text"
-            shortcuts.add(label);
+            // Track separately due to ambiguity in "text [text] text"
+            const shortcutData = shortcuts.get(label) || [];
+            shortcutData.push(referenceDatum);
+            shortcuts.set(label, shortcutData);
           } else {
-            const referenceindex = referenceLinkMatch.index;
-            if (topLevel) {
-              // Calculate line index
-              while (lineOffsets[lineIndex + 1] <= referenceindex) {
-                lineIndex++;
-              }
-            } else {
-              // Use provided line index
-              lineIndex = contentLineIndex;
-            }
-            const referenceIndex = referenceindex +
-              (topLevel ? -lineOffsets[lineIndex] : contentIndex);
             // Track reference and location
             const referenceData = references.get(label) || [];
-            referenceData.push([
-              lineIndex,
-              referenceIndex,
-              matchString.length
-            ]);
+            referenceData.push(referenceDatum);
             references.set(label, referenceData);
-            // Check for images embedded in top-level link text
-            if (!matchString.startsWith("!")) {
-              pendingContents.push(
-                {
-                  "content": matchText,
-                  "contentLineIndex": lineIndex,
-                  "contentIndex": referenceIndex + 1,
-                  "topLevel": false
-                }
-              );
-            }
+          }
+          // Check for links embedded in brackets
+          if (!matchString.startsWith("!")) {
+            pendingContents.push({
+              "content": matchText,
+              "contentLineIndex": lineIndex,
+              "contentIndex": referenceIndex + 1,
+              "topLevel": false
+            });
           }
         }
       }
@@ -899,7 +955,8 @@ function getReferenceLinkImageData(lineMetadata) {
     references,
     shortcuts,
     definitions,
-    duplicateDefinitions
+    duplicateDefinitions,
+    definitionLineIndices
   };
 }
 module.exports.getReferenceLinkImageData = getReferenceLinkImageData;
@@ -987,7 +1044,7 @@ module.exports.applyFix = applyFix;
  * @returns {string} Corrected content.
  */
 function applyFixes(input, errors) {
-  const lineEnding = getPreferredLineEnding(input, require("os"));
+  const lineEnding = getPreferredLineEnding(input, require("node:os"));
   const lines = input.split(newLineRe);
   // Normalize fixInfo objects
   let fixInfos = errors
@@ -1130,3 +1187,110 @@ function expandTildePath(file, os) {
   return homedir ? file.replace(/^~($|\/|\\)/, `${homedir}$1`) : file;
 }
 module.exports.expandTildePath = expandTildePath;
+
+/**
+ * RegExp.exec-style implementation of function expressions.
+ *
+ * @param {Function} funcExp Function that takes string and returns
+ * [index, length] or null.
+ * @param {string} input String to search.
+ * @returns {string[] | null} RegExp.exec-style [match] with an index property.
+ */
+function funcExpExec(funcExp, input) {
+  // Start or resume match
+  // @ts-ignore
+  const lastIndex = funcExp.lastIndex || 0;
+  const result = funcExp(input.slice(lastIndex));
+  if (result) {
+    // Update lastIndex and return match
+    const [ subIndex, length ] = result;
+    const index = lastIndex + subIndex;
+    // @ts-ignore
+    funcExp.lastIndex = index + length;
+    const match = [ input.slice(index, index + length) ];
+    // @ts-ignore
+    match.index = index;
+    return match;
+  }
+  // Reset lastIndex and return no match
+  // @ts-ignore
+  funcExp.lastIndex = 0;
+  return null;
+}
+module.exports.funcExpExec = funcExpExec;
+
+const urlFeProtocolRe = /(?:http|ftp)s?:\/\//i;
+const urlFeAutolinkTerminalsRe = / |$/;
+const urlFeBareTerminalsRe = /[ ,!`'"\]]|$/;
+const urlFeNonTerminalsRe = "-#/";
+const urlFePunctuationRe = /\p{Punctuation}/u;
+const urlFePrefixToPostfix = new Map([
+  [ " ", " " ],
+  [ "`", "`" ],
+  [ "'", "'" ],
+  [ "\"", "\"" ],
+  [ "‘", "’" ],
+  [ "“", "”" ],
+  [ "«", "»" ],
+  [ "*", "*" ],
+  [ "_", "_" ],
+  [ "(", ")" ],
+  [ "[", "]" ],
+  [ "{", "}" ],
+  [ "<", ">" ],
+  [ ">", "<" ]
+]);
+
+/**
+ * Function expression that matches URLs.
+ *
+ * @param {string} input Substring to search for a URL.
+ * @returns {Array | null} [index, length] of URL or null.
+ */
+function urlFe(input) {
+  // Find start of URL by searching for protocol
+  const match = input.match(urlFeProtocolRe);
+  if (match) {
+    // Look for matching pre/postfix characters (ex: <...>)
+    const start = match.index || 0;
+    const length = match[0].length;
+    const prefix = input[start - 1] || " ";
+    const postfix = urlFePrefixToPostfix.get(prefix);
+    // @ts-ignore
+    let endPostfix = input.indexOf(postfix, start + length);
+    if (endPostfix === -1) {
+      endPostfix = input.length;
+    }
+    // Look for characters that terminate a URL
+    const terminalsRe =
+      (prefix === "<") ? urlFeAutolinkTerminalsRe : urlFeBareTerminalsRe;
+    const endTerminal = start + input.slice(start).search(terminalsRe);
+    // Determine tentative end of URL
+    let end = Math.min(endPostfix, endTerminal);
+    if (prefix === " ") {
+      // If the URL used " " as pre/postfix characters, trim the end
+      if (input[end - 1] === ")") {
+        // Trim any ")" beyond the last "(...)" pair
+        const lastOpenParen = input.lastIndexOf("(", end - 2);
+        if (lastOpenParen <= start) {
+          end--;
+        } else {
+          const nextCloseParen = input.indexOf(")", lastOpenParen + 1);
+          end = nextCloseParen + 1;
+        }
+      } else {
+        // Trim unwanted punctuation
+        while (
+          !urlFeNonTerminalsRe.includes(input[end - 1]) &&
+          urlFePunctuationRe.test(input[end - 1])
+        ) {
+          end--;
+        }
+      }
+    }
+    return [ start, end - start ];
+  }
+  // No match
+  return null;
+}
+module.exports.urlFe = urlFe;

package/helpers/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markdownlint-rule-helpers",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "description": "A collection of markdownlint helper functions for custom rules",
   "main": "./helpers.js",
   "exports": "./helpers.js",
@@ -13,7 +13,7 @@
   },
   "bugs": "https://github.com/DavidAnson/markdownlint/issues",
   "engines": {
-    "node": ">=12"
+    "node": ">=14.18.0"
   },
   "keywords": [
     "markdownlint",

package/lib/constants.js

@@ -3,5 +3,12 @@
 "use strict";
 
 module.exports.deprecatedRuleNames = [ "MD002", "MD006" ];
+module.exports.fixableRuleNames = [
+  "MD004", "MD005", "MD006", "MD007", "MD009", "MD010",
+  "MD011", "MD012", "MD014", "MD018", "MD019", "MD020",
+  "MD021", "MD022", "MD023", "MD026", "MD027", "MD030",
+  "MD031", "MD032", "MD034", "MD037", "MD038", "MD039",
+  "MD044", "MD047", "MD049", "MD050", "MD051", "MD053"
+];
 module.exports.homepage = "https://github.com/DavidAnson/markdownlint";
-module.exports.version = "0.26.1";
+module.exports.version = "0.27.0";