markdownlint 0.24.0 → 0.26.0

package/helpers/helpers.js

@@ -2,8 +2,6 @@
 
 "use strict";
 
-const os = require("os");
-
 // Regular expression for matching common newline characters
 // See NEWLINES_RE in markdown-it/lib/rules_core/normalize.js
 const newLineRe = /\r\n?|\n/g;
@@ -14,11 +12,15 @@ module.exports.frontMatterRe =
   // eslint-disable-next-line max-len
   /((^---\s*$[^]*?^---\s*$)|(^\+\+\+\s*$[^]*?^(\+\+\+|\.\.\.)\s*$)|(^\{\s*$[^]*?^\}\s*$))(\r\n|\r|\n|$)/m;
 
-// Regular expression for matching inline disable/enable comments
-const inlineCommentRe =
+// 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-next-line)((?:\s+[a-z0-9_-]+)*))|(?:(configure-file)\s+([\s\S]*?)))\s*-->/ig;
-module.exports.inlineCommentRe = inlineCommentRe;
+  /(<!--\s*markdownlint-(disable|enable|capture|restore|disable-file|enable-file|disable-line|disable-next-line|configure-file))(?:\s|-->)/ig;
+module.exports.inlineCommentStartRe = inlineCommentStartRe;
+
+// Regular expression for matching HTML elements
+const htmlElementRe = /<(([A-Za-z][A-Za-z0-9-]*)(?:\s[^`>]*)?)\/?>/g;
+module.exports.htmlElementRe = htmlElementRe;
 
 // Regular expressions for range matching
 module.exports.bareUrlRe = /(?:http|ftp)s?:\/\/[^\s\]"']*(?:\/|[^\s\]"'\W])/ig;
@@ -28,12 +30,13 @@ module.exports.orderedListItemMarkerRe = /^[\s>]*0*(\d+)[.)]/;
 // Regular expression for all instances of emphasis markers
 const emphasisMarkersRe = /[_*]/g;
 
-// Regular expression for inline links and shortcut reference links
-const linkRe = /(\[(?:[^[\]]|\[[^\]]*\])*\])(\(\S*\)|\[\S*\])?/g;
-module.exports.linkRe = linkRe;
+// Regular expression for reference links (full and collapsed but not shortcut)
+const referenceLinkRe =
+  /!?\\?\[((?:\[[^\]\0]*]|[^\]\0])*)](?:(?:\[([^\]\0]*)\])|[^(]|$)/g;
 
-// Regular expression for link reference definition lines
-module.exports.linkReferenceRe = /^ {0,3}\[[^\]]+]:\s.*$/;
+// Regular expression for link reference definitions
+const linkReferenceDefinitionRe = /^ {0,3}\[([^\]]*[^\\])]:/;
+module.exports.linkReferenceDefinitionRe = linkReferenceDefinitionRe;
 
 // All punctuation characters (normal and full-width)
 const allPunctuation = ".,;:!?。，；：！？";
@@ -62,14 +65,43 @@ module.exports.isObject = function isObject(obj) {
   return (obj !== null) && (typeof obj === "object") && !Array.isArray(obj);
 };
 
-// Returns true iff the input line is blank (no content)
-// Example: Contains nothing, whitespace, or comments
-const blankLineRe = />|(?:<!--.*?-->)/g;
-module.exports.isBlankLine = function isBlankLine(line) {
-  // Call to String.replace follows best practices and is not a security check
-  // False-positive for js/incomplete-multi-character-sanitization
-  return !line || !line.trim() || !line.replace(blankLineRe, "").trim();
-};
+/**
+ * Returns true iff the input line is blank (contains nothing, whitespace, or
+ * comments (unclosed start/end comments allowed)).
+ *
+ * @param {string} line Input line.
+ * @returns {boolean} True iff line is blank.
+ */
+function isBlankLine(line) {
+  const startComment = "<!--";
+  const endComment = "-->";
+  const removeComments = (s) => {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const start = s.indexOf(startComment);
+      const end = s.indexOf(endComment);
+      if ((end !== -1) && ((start === -1) || (end < start))) {
+        // Unmatched end comment is first
+        s = s.slice(end + endComment.length);
+      } else if ((start !== -1) && (end !== -1)) {
+        // Start comment is before end comment
+        s = s.slice(0, start) + s.slice(end + endComment.length);
+      } else if ((start !== -1) && (end === -1)) {
+        // Unmatched start comment is last
+        s = s.slice(0, start);
+      } else {
+        // No more comments to remove
+        return s;
+      }
+    }
+  };
+  return (
+    !line ||
+    !line.trim() ||
+    !removeComments(line).replace(/>/g, "").trim()
+  );
+}
+module.exports.isBlankLine = isBlankLine;
 
 /**
  * Compare function for Array.prototype.sort for ascending order of numbers.
@@ -129,16 +161,10 @@ module.exports.clearHtmlCommentText = function clearHtmlCommentText(text) {
            !content.endsWith("-") && !content.includes("--"));
         // If a valid block/inline comment...
         if (isValid) {
-          const inlineCommentIndex = text
-            .slice(i, j + htmlCommentEnd.length)
-            .search(inlineCommentRe);
-          // If not a markdownlint inline directive...
-          if (inlineCommentIndex === -1) {
-            text =
-              text.slice(0, i + htmlCommentBegin.length) +
-              content.replace(/[^\r\n]/g, ".") +
-              text.slice(j);
-          }
+          text =
+            text.slice(0, i + htmlCommentBegin.length) +
+            content.replace(/[^\r\n]/g, ".") +
+            text.slice(j);
         }
       }
     }
@@ -181,6 +207,22 @@ module.exports.fencedCodeBlockStyleFor =
     }
   };
 
+/**
+ * Return the string representation of a emphasis or strong markup character.
+ *
+ * @param {string} markup Emphasis or strong string.
+ * @returns {string} String representation.
+ */
+module.exports.emphasisOrStrongStyleFor =
+  function emphasisOrStrongStyleFor(markup) {
+    switch (markup[0]) {
+      case "*":
+        return "asterisk";
+      default:
+        return "underscore";
+    }
+  };
+
 /**
  * Return the number of characters of indent for a token.
  *
@@ -231,11 +273,11 @@ module.exports.unorderedListStyleFor = function unorderedListStyleFor(token) {
  * @returns {void}
  */
 function filterTokens(params, type, handler) {
-  params.tokens.forEach(function forToken(token) {
+  for (const token of params.tokens) {
     if (token.type === type) {
       handler(token);
     }
-  });
+  }
 }
 module.exports.filterTokens = filterTokens;
 
@@ -247,11 +289,12 @@ module.exports.filterTokens = filterTokens;
  */
 function isMathBlock(token) {
   return (
-    (token.tag === "math") &&
+    ((token.tag === "$$") || (token.tag === "math")) &&
     token.type.startsWith("math_block") &&
     !token.type.endsWith("_end")
   );
 }
+module.exports.isMathBlock = isMathBlock;
 
 // Get line metadata array
 module.exports.getLineMetadata = function getLineMetadata(params) {
@@ -285,22 +328,28 @@ module.exports.getLineMetadata = function getLineMetadata(params) {
   filterTokens(params, "hr", (token) => {
     lineMetadata[token.map[0]][6] = true;
   });
-  params.tokens.filter(isMathBlock).forEach((token) => {
+  for (const token of params.tokens.filter(isMathBlock)) {
     for (let i = token.map[0]; i < token.map[1]; i++) {
       lineMetadata[i][7] = true;
     }
-  });
+  }
   return lineMetadata;
 };
 
-// Calls the provided function for each line (with context)
-module.exports.forEachLine = function forEachLine(lineMetadata, handler) {
-  lineMetadata.forEach(function forMetadata(metadata) {
-    // Parameters:
-    // line, lineIndex, inCode, onFence, inTable, inItem, inBreak, inMath
+/**
+ * Calls the provided function for each line.
+ *
+ * @param {Object} lineMetadata Line metadata object.
+ * @param {Function} handler Function taking (line, lineIndex, inCode, onFence,
+ * inTable, inItem, inBreak, inMath).
+ * @returns {void}
+ */
+function forEachLine(lineMetadata, handler) {
+  for (const metadata of lineMetadata) {
     handler(...metadata);
-  });
-};
+  }
+}
+module.exports.forEachLine = forEachLine;
 
 // Returns (nested) lists as a flat array (in order)
 module.exports.flattenLists = function flattenLists(tokens) {
@@ -310,11 +359,7 @@ module.exports.flattenLists = function flattenLists(tokens) {
   let nesting = 0;
   const nestingStack = [];
   let lastWithMap = { "map": [ 0, 1 ] };
-  tokens.forEach((token) => {
-    if (isMathBlock(token) && token.map[1]) {
-      // markdown-it-texmath plugin does not account for math_block_end
-      token.map[1]++;
-    }
+  for (const token of tokens) {
     if ((token.type === "bullet_list_open") ||
         (token.type === "ordered_list_open")) {
       // Save current context and start a new one
@@ -347,12 +392,13 @@ module.exports.flattenLists = function flattenLists(tokens) {
       nestingStack.push(nesting);
       nesting = 0;
     } else if (token.type === "blockquote_close") {
-      nesting = nestingStack.pop();
-    } else if (token.map) {
+      nesting = nestingStack.pop() || 0;
+    }
+    if (token.map) {
       // Track last token with map
       lastWithMap = token;
     }
-  });
+  }
   return flattenedLists;
 };
 
@@ -360,114 +406,102 @@ module.exports.flattenLists = function flattenLists(tokens) {
 module.exports.forEachInlineChild =
 function forEachInlineChild(params, type, handler) {
   filterTokens(params, "inline", function forToken(token) {
-    token.children.forEach(function forChild(child) {
+    for (const child of token.children) {
       if (child.type === type) {
         handler(child, token);
       }
-    });
+    }
   });
 };
 
 // Calls the provided function for each heading's content
 module.exports.forEachHeading = function forEachHeading(params, handler) {
   let heading = null;
-  params.tokens.forEach(function forToken(token) {
+  for (const token of params.tokens) {
     if (token.type === "heading_open") {
       heading = token;
     } else if (token.type === "heading_close") {
       heading = null;
     } else if ((token.type === "inline") && heading) {
-      handler(heading, token.content);
+      handler(heading, token.content, token);
     }
-  });
+  }
 };
 
 /**
  * Calls the provided function for each inline code span's content.
  *
  * @param {string} input Markdown content.
- * @param {Function} handler Callback function.
+ * @param {Function} handler Callback function taking (code, lineIndex,
+ * columnIndex, ticks).
  * @returns {void}
  */
 function forEachInlineCodeSpan(input, handler) {
-  let currentLine = 0;
-  let currentColumn = 0;
-  let index = 0;
-  while (index < input.length) {
-    let startIndex = -1;
-    let startLine = -1;
-    let startColumn = -1;
-    let tickCount = 0;
-    let currentTicks = 0;
-    let state = "normal";
-    // Deliberate <= so trailing 0 completes the last span (ex: "text `code`")
-    // False-positive for js/index-out-of-bounds
-    for (; index <= input.length; index++) {
-      const char = input[index];
-      // Ignore backticks in link destination
-      if ((char === "[") && (state === "normal")) {
-        state = "linkTextOpen";
-      } else if ((char === "]") && (state === "linkTextOpen")) {
-        state = "linkTextClosed";
-      } else if ((char === "(") && (state === "linkTextClosed")) {
-        state = "linkDestinationOpen";
-      } else if (
-        ((char === "(") && (state === "linkDestinationOpen")) ||
-        ((char === ")") && (state === "linkDestinationOpen")) ||
-        (state === "linkTextClosed")) {
-        state = "normal";
-      }
-      // Parse backtick open/close
-      if ((char === "`") && (state !== "linkDestinationOpen")) {
-        // Count backticks at start or end of code span
-        currentTicks++;
-        if ((startIndex === -1) || (startColumn === -1)) {
-          startIndex = index + 1;
-        }
-      } else {
-        if ((startIndex >= 0) &&
-          (startColumn >= 0) &&
-          (tickCount === currentTicks)) {
-          // Found end backticks; invoke callback for code span
+  const backtickRe = /`+/g;
+  let match = null;
+  const backticksLengthAndIndex = [];
+  while ((match = backtickRe.exec(input)) !== null) {
+    backticksLengthAndIndex.push([ match[0].length, match.index ]);
+  }
+  const newLinesIndex = [];
+  while ((match = newLineRe.exec(input)) !== null) {
+    newLinesIndex.push(match.index);
+  }
+  let lineIndex = 0;
+  let lineStartIndex = 0;
+  let k = 0;
+  for (let i = 0; i < backticksLengthAndIndex.length - 1; i++) {
+    const [ startLength, startIndex ] = backticksLengthAndIndex[i];
+    if ((startIndex === 0) || (input[startIndex - 1] !== "\\")) {
+      for (let j = i + 1; j < backticksLengthAndIndex.length; j++) {
+        const [ endLength, endIndex ] = backticksLengthAndIndex[j];
+        if (startLength === endLength) {
+          for (; k < newLinesIndex.length; k++) {
+            const newLineIndex = newLinesIndex[k];
+            if (startIndex < newLineIndex) {
+              break;
+            }
+            lineIndex++;
+            lineStartIndex = newLineIndex + 1;
+          }
+          const columnIndex = startIndex - lineStartIndex + startLength;
           handler(
-            input.substring(startIndex, index - currentTicks),
-            startLine, startColumn, tickCount);
-          startIndex = -1;
-          startColumn = -1;
-        } else if ((startIndex >= 0) && (startColumn === -1)) {
-          // Found start backticks
-          tickCount = currentTicks;
-          startLine = currentLine;
-          startColumn = currentColumn;
+            input.slice(startIndex + startLength, endIndex),
+            lineIndex,
+            columnIndex,
+            startLength
+          );
+          i = j;
+          break;
         }
-        // Not in backticks
-        currentTicks = 0;
-      }
-      if (char === "\n") {
-        // On next line
-        currentLine++;
-        currentColumn = 0;
-      } else if ((char === "\\") &&
-        ((startIndex === -1) || (startColumn === -1)) &&
-        (input[index + 1] !== "\n")) {
-        // Escape character outside code, skip next
-        index++;
-        currentColumn += 2;
-      } else {
-        // On next column
-        currentColumn++;
       }
     }
-    if (startIndex >= 0) {
-      // Restart loop after unmatched start backticks (ex: "`text``code``")
-      index = startIndex;
-      currentLine = startLine;
-      currentColumn = startColumn;
-    }
   }
 }
 module.exports.forEachInlineCodeSpan = forEachInlineCodeSpan;
 
+/**
+ * Adds ellipsis to the left/right/middle of the specified text.
+ *
+ * @param {string} text Text to ellipsify.
+ * @param {boolean} [start] True iff the start of the text is important.
+ * @param {boolean} [end] True iff the end of the text is important.
+ * @returns {string} Ellipsified text.
+ */
+function ellipsify(text, start, end) {
+  if (text.length <= 30) {
+    // Nothing to do
+  } else if (start && end) {
+    text = text.slice(0, 15) + "..." + text.slice(-15);
+  } else if (end) {
+    text = "..." + text.slice(-30);
+  } else {
+    text = text.slice(0, 30) + "...";
+  }
+  return text;
+}
+module.exports.ellipsify = ellipsify;
+
 /**
  * Adds a generic error object via the onError callback.
  *
@@ -508,58 +542,83 @@ module.exports.addErrorDetailIf = function addErrorDetailIf(
 // Adds an error object with context via the onError callback
 module.exports.addErrorContext = function addErrorContext(
   onError, lineNumber, context, left, right, range, fixInfo) {
-  if (context.length <= 30) {
-    // Nothing to do
-  } else if (left && right) {
-    context = context.substr(0, 15) + "..." + context.substr(-15);
-  } else if (right) {
-    context = "..." + context.substr(-30);
-  } else {
-    context = context.substr(0, 30) + "...";
-  }
-  addError(onError, lineNumber, null, context, range, fixInfo);
+  context = ellipsify(context, left, right);
+  addError(onError, lineNumber, undefined, context, range, fixInfo);
 };
 
 /**
- * Returns an array of code span ranges.
+ * Returns an array of code block and span content ranges.
  *
- * @param {string[]} lines Lines to scan for code span ranges.
- * @returns {number[][]} Array of ranges (line, index, length).
+ * @param {Object} params RuleParams instance.
+ * @param {Object} lineMetadata Line metadata object.
+ * @returns {number[][]} Array of ranges (lineIndex, columnIndex, length).
  */
-module.exports.inlineCodeSpanRanges = (lines) => {
+module.exports.codeBlockAndSpanRanges = (params, lineMetadata) => {
   const exclusions = [];
-  forEachInlineCodeSpan(
-    lines.join("\n"),
-    (code, lineIndex, columnIndex) => {
-      const codeLines = code.split(newLineRe);
-      // eslint-disable-next-line unicorn/no-for-loop
-      for (let i = 0; i < codeLines.length; i++) {
-        exclusions.push(
-          [ lineIndex + i, columnIndex, codeLines[i].length ]
-        );
-        columnIndex = 0;
-      }
+  // Add code block ranges (excludes fences)
+  forEachLine(lineMetadata, (line, lineIndex, inCode, onFence) => {
+    if (inCode && !onFence) {
+      exclusions.push([ lineIndex, 0, line.length ]);
     }
-  );
+  });
+  // Add code span ranges (excludes ticks)
+  filterTokens(params, "inline", (token) => {
+    if (token.children.some((child) => child.type === "code_inline")) {
+      const tokenLines = params.lines.slice(token.map[0], token.map[1]);
+      forEachInlineCodeSpan(
+        tokenLines.join("\n"),
+        (code, lineIndex, columnIndex) => {
+          const codeLines = code.split(newLineRe);
+          for (const [ i, line ] of codeLines.entries()) {
+            exclusions.push([
+              token.lineNumber - 1 + lineIndex + i,
+              i ? 0 : columnIndex,
+              line.length
+            ]);
+          }
+        }
+      );
+    }
+  });
+  return exclusions;
+};
+
+/**
+ * Returns an array of HTML element ranges.
+ *
+ * @param {Object} params RuleParams instance.
+ * @param {Object} lineMetadata Line metadata object.
+ * @returns {number[][]} Array of ranges (lineIndex, columnIndex, length).
+ */
+module.exports.htmlElementRanges = (params, lineMetadata) => {
+  const exclusions = [];
+  forEachLine(lineMetadata, (line, lineIndex, inCode) => {
+    let match = null;
+    // eslint-disable-next-line no-unmodified-loop-condition
+    while (!inCode && ((match = htmlElementRe.exec(line)) !== null)) {
+      exclusions.push([ lineIndex, match.index, match[0].length ]);
+    }
+  });
   return exclusions;
 };
 
 /**
- * Determines whether the specified range overlaps another range.
+ * Determines whether the specified range is within another range.
  *
  * @param {number[][]} ranges Array of ranges (line, index, length).
  * @param {number} lineIndex Line index to check.
  * @param {number} index Index to check.
  * @param {number} length Length to check.
- * @returns {boolean} True iff the specified range overlaps.
+ * @returns {boolean} True iff the specified range is within.
  */
-module.exports.overlapsAnyRange = (ranges, lineIndex, index, length) => (
+const withinAnyRange = (ranges, lineIndex, index, length) => (
   !ranges.every((span) => (
     (lineIndex !== span[0]) ||
-    (index + length < span[1]) ||
-    (index > span[1] + span[2])
+    (index < span[1]) ||
+    (index + length > span[1] + span[2])
   ))
 );
+module.exports.withinAnyRange = withinAnyRange;
 
 // Returns a range object for a line by applying a RegExp
 module.exports.rangeFromRegExp = function rangeFromRegExp(line, regexp) {
@@ -587,6 +646,82 @@ module.exports.frontMatterHasTitle =
       frontMatterLines.some((line) => frontMatterTitleRe.test(line));
   };
 
+/**
+ * Calls the provided function for each link.
+ *
+ * @param {string} line Line of Markdown input.
+ * @param {Function} handler Function taking (index, link, text, destination).
+ * @returns {void}
+ */
+function forEachLink(line, handler) {
+  // Helper to find matching close symbol for link text/destination
+  const findClosingSymbol = (index) => {
+    const begin = line[index];
+    const end = (begin === "[") ? "]" : ")";
+    let nesting = 0;
+    let escaping = false;
+    let pointy = false;
+    for (let i = index + 1; i < line.length; i++) {
+      const current = line[i];
+      if (current === "\\") {
+        escaping = !escaping;
+      } else if (!escaping && (current === begin)) {
+        nesting++;
+      } else if (!escaping && (current === end)) {
+        if (nesting > 0) {
+          nesting--;
+        } else if (!pointy) {
+          // Return index after matching close symbol
+          return i + 1;
+        }
+      } else if ((i === index + 1) && (begin === "(") && (current === "<")) {
+        pointy = true;
+      } else if (!escaping && pointy && current === ">") {
+        pointy = false;
+        nesting = 0;
+      } else {
+        escaping = false;
+      }
+    }
+    // No match found
+    return -1;
+  };
+  // Scan line for unescaped "[" character
+  let escaping = false;
+  for (let i = 0; i < line.length; i++) {
+    const current = line[i];
+    if (current === "\\") {
+      escaping = !escaping;
+    } else if (!escaping && (current === "[")) {
+      // Scan for matching close "]" of link text
+      const textEnd = findClosingSymbol(i);
+      if (textEnd !== -1) {
+        if ((line[textEnd] === "(") || (line[textEnd] === "[")) {
+          // Scan for matching close ")" or "]" of link destination
+          const destEnd = findClosingSymbol(textEnd);
+          if (destEnd !== -1) {
+            // Call handler with link text and destination
+            const link = line.slice(i, destEnd);
+            const text = line.slice(i, textEnd);
+            const dest = line.slice(textEnd, destEnd);
+            handler(i, link, text, dest);
+            i = destEnd;
+          }
+        }
+        if (i < textEnd) {
+          // Call handler with link text only
+          const text = line.slice(i, textEnd);
+          handler(i, text, text);
+          i = textEnd;
+        }
+      }
+    } else {
+      escaping = false;
+    }
+  }
+}
+module.exports.forEachLink = forEachLink;
+
 /**
  * Returns a list of emphasis markers in code spans and links.
  *
@@ -596,6 +731,17 @@ module.exports.frontMatterHasTitle =
 function emphasisMarkersInContent(params) {
   const { lines } = params;
   const byLine = new Array(lines.length);
+  // Search links
+  for (const [ tokenLineIndex, tokenLine ] of lines.entries()) {
+    const inLine = [];
+    forEachLink(tokenLine, (index, match) => {
+      let markerMatch = null;
+      while ((markerMatch = emphasisMarkersRe.exec(match))) {
+        inLine.push(index + markerMatch.index);
+      }
+    });
+    byLine[tokenLineIndex] = inLine;
+  }
   // Search code spans
   filterTokens(params, "inline", (token) => {
     const { children, lineNumber, map } = token;
@@ -605,48 +751,172 @@ function emphasisMarkersInContent(params) {
         tokenLines.join("\n"),
         (code, lineIndex, column, tickCount) => {
           const codeLines = code.split(newLineRe);
-          codeLines.forEach((codeLine, codeLineIndex) => {
+          for (const [ codeLineIndex, codeLine ] of codeLines.entries()) {
+            const byLineIndex = lineNumber - 1 + lineIndex + codeLineIndex;
+            const inLine = byLine[byLineIndex];
+            const codeLineOffset = codeLineIndex ? 0 : column - 1 + tickCount;
             let match = null;
             while ((match = emphasisMarkersRe.exec(codeLine))) {
-              const byLineIndex = lineNumber - 1 + lineIndex + codeLineIndex;
-              const inLine = byLine[byLineIndex] || [];
-              const codeLineOffset = codeLineIndex ? 0 : column - 1 + tickCount;
               inLine.push(codeLineOffset + match.index);
-              byLine[byLineIndex] = inLine;
             }
-          });
+            byLine[byLineIndex] = inLine;
+          }
         }
       );
     }
   });
-  // Search links
-  lines.forEach((tokenLine, tokenLineIndex) => {
-    let linkMatch = null;
-    while ((linkMatch = linkRe.exec(tokenLine))) {
-      let markerMatch = null;
-      while ((markerMatch = emphasisMarkersRe.exec(linkMatch[0]))) {
-        const inLine = byLine[tokenLineIndex] || [];
-        inLine.push(linkMatch.index + markerMatch.index);
-        byLine[tokenLineIndex] = inLine;
+  return byLine;
+}
+module.exports.emphasisMarkersInContent = emphasisMarkersInContent;
+
+/**
+ * Returns an object with information about reference links and images.
+ *
+ * @param {Object} lineMetadata Line metadata object.
+ * @returns {Object} Reference link/image data.
+ */
+function getReferenceLinkImageData(lineMetadata) {
+  // Initialize return values
+  const references = new Map();
+  const shortcuts = new Set();
+  const definitions = new Map();
+  const duplicateDefinitions = [];
+  // 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
+  );
+  // Convert input to single-line so multi-line links/images are easier
+  const lineOffsets = [];
+  let currentOffset = 0;
+  const contentLines = [];
+  forEachLine(lineMetadata, (line, lineIndex, inCode) => {
+    lineOffsets[lineIndex] = currentOffset;
+    if (!inCode) {
+      if (line.trim().length === 0) {
+        // Allow RegExp to detect the end of a block
+        line = "\0";
       }
+      contentLines.push(line);
+      currentOffset += line.length + 1;
     }
   });
-  return byLine;
+  lineOffsets.push(currentOffset);
+  const contentLine = contentLines.join(" ");
+  // Determine single-line exclusions for inline code spans
+  forEachInlineCodeSpan(contentLine, (code, lineIndex, columnIndex) => {
+    exclusions.push([ 0, columnIndex, code.length ]);
+  });
+  // Identify all link/image reference definitions
+  forEachLine(lineMetadata, (line, lineIndex, inCode) => {
+    if (!inCode) {
+      const linkReferenceDefinitionMatch = linkReferenceDefinitionRe.exec(line);
+      if (linkReferenceDefinitionMatch) {
+        const label = normalizeLabel(linkReferenceDefinitionMatch[1]);
+        if (definitions.has(label)) {
+          duplicateDefinitions.push([ label, lineIndex ]);
+        } else {
+          definitions.set(label, lineIndex);
+        }
+        exclusions.push([ 0, lineOffsets[lineIndex], line.length ]);
+      }
+    }
+  });
+  // Identify all link and image references
+  let lineIndex = 0;
+  const pendingContents = [
+    {
+      "content": contentLine,
+      "contentLineIndex": 0,
+      "contentIndex": 0,
+      "topLevel": true
+    }
+  ];
+  let pendingContent = null;
+  while ((pendingContent = pendingContents.shift())) {
+    const { content, contentLineIndex, contentIndex, topLevel } =
+      pendingContent;
+    let referenceLinkMatch = null;
+    while ((referenceLinkMatch = referenceLinkRe.exec(content)) !== null) {
+      const [ matchString, matchText, matchLabel ] = referenceLinkMatch;
+      if (
+        !matchString.startsWith("\\") &&
+        !matchString.startsWith("!\\") &&
+        !matchText.endsWith("\\") &&
+        !(matchLabel || "").endsWith("\\") &&
+        (topLevel || matchString.startsWith("!")) &&
+        !excluded(referenceLinkMatch)
+      ) {
+        const shortcutLink = (matchLabel === undefined);
+        const collapsedLink =
+          (!shortcutLink && (matchLabel.length === 0));
+        const label = normalizeLabel(
+          (shortcutLink || collapsedLink) ? matchText : matchLabel
+        );
+        if (label.length > 0) {
+          if (shortcutLink) {
+            // Track, but don't validate due to ambiguity: "text [text] text"
+            shortcuts.add(label);
+          } 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
+            ]);
+            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
+                }
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  return {
+    references,
+    shortcuts,
+    definitions,
+    duplicateDefinitions
+  };
 }
-module.exports.emphasisMarkersInContent = emphasisMarkersInContent;
+module.exports.getReferenceLinkImageData = getReferenceLinkImageData;
 
 /**
  * Gets the most common line ending, falling back to the platform default.
  *
  * @param {string} input Markdown content to analyze.
+ * @param {Object} [os] Node.js "os" module.
  * @returns {string} Preferred line ending.
  */
-function getPreferredLineEnding(input) {
+function getPreferredLineEnding(input, os) {
   let cr = 0;
   let lf = 0;
   let crlf = 0;
   const endings = input.match(newLineRe) || [];
-  endings.forEach((ending) => {
+  for (const ending of endings) {
     // eslint-disable-next-line default-case
     switch (ending) {
       case "\r":
@@ -659,10 +929,10 @@ function getPreferredLineEnding(input) {
         crlf++;
         break;
     }
-  });
+  }
   let preferredLineEnding = null;
   if (!cr && !lf && !crlf) {
-    preferredLineEnding = os.EOL;
+    preferredLineEnding = (os && os.EOL) || "\n";
   } else if ((lf >= crlf) && (lf >= cr)) {
     preferredLineEnding = "\n";
   } else if (crlf >= cr) {
@@ -695,8 +965,8 @@ function normalizeFixInfo(fixInfo, lineNumber) {
  *
  * @param {string} line Line of Markdown content.
  * @param {Object} fixInfo RuleOnErrorFixInfo instance.
- * @param {string} lineEnding Line ending to use.
- * @returns {string} Fixed content.
+ * @param {string} [lineEnding] Line ending to use.
+ * @returns {string | null} Fixed content.
  */
 function applyFix(line, fixInfo, lineEnding) {
   const { editColumn, deleteCount, insertText } = normalizeFixInfo(fixInfo);
@@ -709,9 +979,15 @@ function applyFix(line, fixInfo, lineEnding) {
 }
 module.exports.applyFix = applyFix;
 
-// Applies as many fixes as possible to the input lines
-module.exports.applyFixes = function applyFixes(input, errors) {
-  const lineEnding = getPreferredLineEnding(input);
+/**
+ * Applies as many fixes as possible to Markdown content.
+ *
+ * @param {string} input Lines of Markdown content.
+ * @param {Object[]} errors RuleOnErrorInfo instances.
+ * @returns {string} Corrected content.
+ */
+function applyFixes(input, errors) {
+  const lineEnding = getPreferredLineEnding(input, require("os"));
   const lines = input.split(newLineRe);
   // Normalize fixInfo objects
   let fixInfos = errors
@@ -741,8 +1017,10 @@ module.exports.applyFixes = function applyFixes(input, errors) {
     return unique;
   });
   // Collapse insert/no-delete and no-insert/delete for same line/column
-  lastFixInfo = {};
-  fixInfos.forEach((fixInfo) => {
+  lastFixInfo = {
+    "lineNumber": -1
+  };
+  for (const fixInfo of fixInfos) {
     if (
       (fixInfo.lineNumber === lastFixInfo.lineNumber) &&
       (fixInfo.editColumn === lastFixInfo.editColumn) &&
@@ -754,12 +1032,12 @@ module.exports.applyFixes = function applyFixes(input, errors) {
       lastFixInfo.lineNumber = 0;
     }
     lastFixInfo = fixInfo;
-  });
+  }
   fixInfos = fixInfos.filter((fixInfo) => fixInfo.lineNumber);
   // Apply all (remaining/updated) fixes
   let lastLineIndex = -1;
   let lastEditIndex = -1;
-  fixInfos.forEach((fixInfo) => {
+  for (const fixInfo of fixInfos) {
     const { lineNumber, editColumn, deleteCount } = fixInfo;
     const lineIndex = lineNumber - 1;
     const editIndex = editColumn - 1;
@@ -769,11 +1047,86 @@ module.exports.applyFixes = function applyFixes(input, errors) {
       ((editIndex + deleteCount) <=
         (lastEditIndex - ((deleteCount > 0) ? 0 : 1)))
     ) {
+      // @ts-ignore
       lines[lineIndex] = applyFix(lines[lineIndex], fixInfo, lineEnding);
     }
     lastLineIndex = lineIndex;
     lastEditIndex = editIndex;
-  });
+  }
   // Return corrected input
   return lines.filter((line) => line !== null).join(lineEnding);
-};
+}
+module.exports.applyFixes = applyFixes;
+
+/**
+ * Gets the range and fixInfo values for reporting an error if the expected
+ * text is found on the specified line.
+ *
+ * @param {string[]} lines Lines of Markdown content.
+ * @param {number} lineIndex Line index to check.
+ * @param {string} search Text to search for.
+ * @param {string} replace Text to replace with.
+ * @param {number} [instance] Instance on the line (1-based).
+ * @returns {Object} Range and fixInfo wrapper.
+ */
+module.exports.getRangeAndFixInfoIfFound =
+  (lines, lineIndex, search, replace, instance = 1) => {
+    let range = null;
+    let fixInfo = null;
+    let searchIndex = -1;
+    while (instance > 0) {
+      searchIndex = lines[lineIndex].indexOf(search, searchIndex + 1);
+      instance--;
+    }
+    if (searchIndex !== -1) {
+      const column = searchIndex + 1;
+      const length = search.length;
+      range = [ column, length ];
+      fixInfo = {
+        "editColumn": column,
+        "deleteCount": length,
+        "insertText": replace
+      };
+    }
+    return {
+      range,
+      fixInfo
+    };
+  };
+
+/**
+ * Gets the next (subsequent) child token if it is of the expected type.
+ *
+ * @param {Object} parentToken Parent token.
+ * @param {Object} childToken Child token basis.
+ * @param {string} nextType Token type of next token.
+ * @param {string} nextNextType Token type of next-next token.
+ * @returns {Object} Next token.
+ */
+function getNextChildToken(parentToken, childToken, nextType, nextNextType) {
+  const { children } = parentToken;
+  const index = children.indexOf(childToken);
+  if (
+    (index !== -1) &&
+    (children.length > index + 2) &&
+    (children[index + 1].type === nextType) &&
+    (children[index + 2].type === nextNextType)
+  ) {
+    return children[index + 1];
+  }
+  return null;
+}
+module.exports.getNextChildToken = getNextChildToken;
+
+/**
+ * Expands a path with a tilde to an absolute path.
+ *
+ * @param {string} file Path that may begin with a tilde.
+ * @param {Object} os Node.js "os" module.
+ * @returns {string} Absolute path (or original path).
+ */
+function expandTildePath(file, os) {
+  const homedir = os && os.homedir();
+  return homedir ? file.replace(/^~($|\/|\\)/, `${homedir}$1`) : file;
+}
+module.exports.expandTildePath = expandTildePath;