markdownlint 0.26.2 → 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,20 +10,19 @@ 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+)[.)]/;
 
@@ -36,10 +35,10 @@ 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)
@@ -142,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) {
@@ -152,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;
@@ -406,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) {
@@ -596,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
@@ -603,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;
 };
 
@@ -782,9 +824,10 @@ 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 = [];
@@ -824,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);
+        }
       }
     }
   });
@@ -871,17 +920,22 @@ function getReferenceLinkImageData(lineMetadata) {
           }
           const referenceIndex = referenceindex +
             (topLevel ? -lineOffsets[lineIndex] : contentIndex);
+          const referenceDatum = [
+            lineIndex,
+            referenceIndex,
+            matchString.length,
+            matchText.length,
+            (matchLabel || "").length
+          ];
           if (shortcutLink) {
             // Track separately due to ambiguity in "text [text] text"
-            shortcuts.add(label);
+            const shortcutData = shortcuts.get(label) || [];
+            shortcutData.push(referenceDatum);
+            shortcuts.set(label, shortcutData);
           } else {
             // Track reference and location
             const referenceData = references.get(label) || [];
-            referenceData.push([
-              lineIndex,
-              referenceIndex,
-              matchString.length
-            ]);
+            referenceData.push(referenceDatum);
             references.set(label, referenceData);
           }
           // Check for links embedded in brackets
@@ -901,7 +955,8 @@ function getReferenceLinkImageData(lineMetadata) {
     references,
     shortcuts,
     definitions,
-    duplicateDefinitions
+    duplicateDefinitions,
+    definitionLineIndices
   };
 }
 module.exports.getReferenceLinkImageData = getReferenceLinkImageData;
@@ -989,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
@@ -1132,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.2",
+  "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.2";
+module.exports.version = "0.27.0";

package/lib/markdownlint.js

@@ -2,8 +2,8 @@
 
 "use strict";
 
-const path = require("path");
-const { promisify } = require("util");
+const path = require("node:path");
+const { promisify } = require("node:util");
 const markdownIt = require("markdown-it");
 const { deprecatedRuleNames } = require("./constants");
 const rules = require("./rules");
@@ -874,7 +874,7 @@ function lintInput(options, synchronous, callback) {
     // @ts-ignore
     md.use(...plugin);
   }
-  const fs = options.fs || require("fs");
+  const fs = options.fs || require("node:fs");
   const results = newResults(ruleList);
   let done = false;
   let concurrency = 0;
@@ -1080,10 +1080,10 @@ function readConfig(file, parsers, fs, callback) {
     }
   }
   if (!fs) {
-    fs = require("fs");
+    fs = require("node:fs");
   }
   // Read file
-  const os = require("os");
+  const os = require("node:os");
   file = helpers.expandTildePath(file, os);
   fs.readFile(file, "utf8", (err, content) => {
     if (err) {
@@ -1155,10 +1155,10 @@ function readConfigPromise(file, parsers, fs) {
  */
 function readConfigSync(file, parsers, fs) {
   if (!fs) {
-    fs = require("fs");
+    fs = require("node:fs");
   }
   // Read file
-  const os = require("os");
+  const os = require("node:os");
   file = helpers.expandTildePath(file, os);
   const content = fs.readFileSync(file, "utf8");
   // Try to parse file

package/lib/md011.js

@@ -6,7 +6,7 @@ const { addError, forEachLine, withinAnyRange } = require("../helpers");
 const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
 
 const reversedLinkRe =
-  /(^|[^\\])\(([^)]+)\)\[([^\]^][^\]]*)](?!\()/g;
+  /(^|[^\\])\(([^()]+)\)\[([^\]^][^\]]*)\](?!\()/g;
 
 module.exports = {
   "names": [ "MD011", "no-reversed-links" ],
@@ -30,7 +30,7 @@ module.exports = {
               onError,
               lineIndex + 1,
               reversedLink.slice(preChar.length),
-              null,
+              undefined,
               [ index + 1, length ],
               {
                 "editColumn": index + 1,