markdownlint 0.25.0 → 0.26.1

package/demo/markdownlint-browser.js

@@ -1,4 +1,4 @@
-/*! markdownlint 0.25.0 https://github.com/DavidAnson/markdownlint @license MIT */
+/*! markdownlint 0.26.1 https://github.com/DavidAnson/markdownlint @license MIT */
 var markdownlint;
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
@@ -25,37 +25,40 @@ module.exports = webpackEmptyContext;
 /*!*****************************!*\
   !*** ../helpers/helpers.js ***!
   \*****************************/
-/***/ ((module) => {
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 // @ts-check
 
 // Regular expression for matching common newline characters
 // See NEWLINES_RE in markdown-it/lib/rules_core/normalize.js
-var newLineRe = /\r\n?|\n/g;
+const newLineRe = /\r\n?|\n/g;
 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;
-// Regular expression for matching inline disable/enable comments
-var 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;
 module.exports.listItemMarkerRe = /^([\s>]*)(?:[*+-]|\d+[.)])\s+/;
 module.exports.orderedListItemMarkerRe = /^[\s>]*0*(\d+)[.)]/;
 // Regular expression for all instances of emphasis markers
-var emphasisMarkersRe = /[_*]/g;
-// Regular expression for inline links and shortcut reference links
-var linkRe = /(\[(?:[^[\]]|\[[^\]]*\])*\])(\(\S*\)|\[\S*\])?/g;
-module.exports.linkRe = linkRe;
-// Regular expression for link reference definition lines
-module.exports.linkReferenceRe = /^ {0,3}\[[^\]]+]:\s.*$/;
+const emphasisMarkersRe = /[_*]/g;
+// Regular expression for reference links (full and collapsed but not shortcut)
+const referenceLinkRe = /!?\\?\[((?:\[[^\]\0]*]|[^\]\0])*)](?:(?:\[([^\]\0]*)\])|[^(]|$)/g;
+// Regular expression for link reference definitions
+const linkReferenceDefinitionRe = /^ {0,3}\[([^\]]*[^\\])]:/;
+module.exports.linkReferenceDefinitionRe = linkReferenceDefinitionRe;
 // All punctuation characters (normal and full-width)
-var allPunctuation = ".,;:!?。，；：！？";
+const allPunctuation = ".,;:!?。，；：！？";
 module.exports.allPunctuation = allPunctuation;
 // All punctuation characters without question mark (normal and full-width)
 module.exports.allPunctuationNoQuestion = allPunctuation.replace(/[?？]/gu, "");
@@ -75,20 +78,44 @@ module.exports.isEmptyString = function isEmptyString(str) {
 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 comment (unclosed start/end okay)
-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
+/**
+ * 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() ||
-        !line
-            .replace(/<!--.*?-->/g, "")
-            .replace(/<!--.*$/g, "")
-            .replace(/^.*-->/g, "")
-            .replace(/>/g, "")
-            .trim());
-};
+        !removeComments(line).replace(/>/g, "").trim());
+}
+module.exports.isBlankLine = isBlankLine;
 /**
  * Compare function for Array.prototype.sort for ascending order of numbers.
  *
@@ -101,11 +128,11 @@ module.exports.numericSortAscending = function numericSortAscending(a, b) {
 };
 // Returns true iff the sorted array contains the specified element
 module.exports.includesSorted = function includesSorted(array, element) {
-    var left = 0;
-    var right = array.length - 1;
+    let left = 0;
+    let right = array.length - 1;
     while (left <= right) {
         // eslint-disable-next-line no-bitwise
-        var mid = (left + right) >> 1;
+        const mid = (left + right) >> 1;
         if (array[mid] < element) {
             left = mid + 1;
         }
@@ -122,41 +149,35 @@ module.exports.includesSorted = function includesSorted(array, element) {
 // This preserves the line/column information for the rest of the document
 // https://spec.commonmark.org/0.29/#html-blocks
 // https://spec.commonmark.org/0.29/#html-comment
-var htmlCommentBegin = "<!--";
-var htmlCommentEnd = "-->";
+const htmlCommentBegin = "<!--";
+const htmlCommentEnd = "-->";
 module.exports.clearHtmlCommentText = function clearHtmlCommentText(text) {
-    var i = 0;
+    let i = 0;
     while ((i = text.indexOf(htmlCommentBegin, i)) !== -1) {
-        var j = text.indexOf(htmlCommentEnd, i + 2);
+        const j = text.indexOf(htmlCommentEnd, i + 2);
         if (j === -1) {
             // Un-terminated comments are treated as text
             break;
         }
         // If the comment has content...
         if (j > i + htmlCommentBegin.length) {
-            var k = i - 1;
+            let k = i - 1;
             while (text[k] === " ") {
                 k--;
             }
             // If comment is not within an indented code block...
             if (k >= i - 4) {
-                var content = text.slice(i + htmlCommentBegin.length, j);
-                var isBlock = (k < 0) || (text[k] === "\n");
-                var isValid = isBlock ||
+                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) {
-                    var 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);
                 }
             }
         }
@@ -169,11 +190,11 @@ module.exports.escapeForRegExp = function escapeForRegExp(str) {
     return str.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
 };
 // Un-escapes Markdown content (simple algorithm; not a parser)
-var escapedMarkdownRe = /\\./g;
+const escapedMarkdownRe = /\\./g;
 module.exports.unescapeMarkdown =
     function unescapeMarkdown(markdown, replacement) {
-        return markdown.replace(escapedMarkdownRe, function (match) {
-            var char = match[1];
+        return markdown.replace(escapedMarkdownRe, (match) => {
+            const char = match[1];
             if ("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~".includes(char)) {
                 return replacement || char;
             }
@@ -217,7 +238,7 @@ module.exports.emphasisOrStrongStyleFor =
  * @returns {number} Characters of indent.
  */
 function indentFor(token) {
-    var line = token.line.replace(/^[\s>]*(> |>)/, "");
+    const line = token.line.replace(/^[\s>]*(> |>)/, "");
     return line.length - line.trimStart().length;
 }
 module.exports.indentFor = indentFor;
@@ -257,11 +278,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;
 /**
@@ -278,39 +299,39 @@ function isMathBlock(token) {
 module.exports.isMathBlock = isMathBlock;
 // Get line metadata array
 module.exports.getLineMetadata = function getLineMetadata(params) {
-    var lineMetadata = params.lines.map(function (line, index) { return [line, index, false, 0, false, false, false, false]; });
-    filterTokens(params, "fence", function (token) {
+    const lineMetadata = params.lines.map((line, index) => [line, index, false, 0, false, false, false, false]);
+    filterTokens(params, "fence", (token) => {
         lineMetadata[token.map[0]][3] = 1;
         lineMetadata[token.map[1] - 1][3] = -1;
-        for (var i = token.map[0] + 1; i < token.map[1] - 1; i++) {
+        for (let i = token.map[0] + 1; i < token.map[1] - 1; i++) {
             lineMetadata[i][2] = true;
         }
     });
-    filterTokens(params, "code_block", function (token) {
-        for (var i = token.map[0]; i < token.map[1]; i++) {
+    filterTokens(params, "code_block", (token) => {
+        for (let i = token.map[0]; i < token.map[1]; i++) {
             lineMetadata[i][2] = true;
         }
     });
-    filterTokens(params, "table_open", function (token) {
-        for (var i = token.map[0]; i < token.map[1]; i++) {
+    filterTokens(params, "table_open", (token) => {
+        for (let i = token.map[0]; i < token.map[1]; i++) {
             lineMetadata[i][4] = true;
         }
     });
-    filterTokens(params, "list_item_open", function (token) {
-        var count = 1;
-        for (var i = token.map[0]; i < token.map[1]; i++) {
+    filterTokens(params, "list_item_open", (token) => {
+        let count = 1;
+        for (let i = token.map[0]; i < token.map[1]; i++) {
             lineMetadata[i][5] = count;
             count++;
         }
     });
-    filterTokens(params, "hr", function (token) {
+    filterTokens(params, "hr", (token) => {
         lineMetadata[token.map[0]][6] = true;
     });
-    params.tokens.filter(isMathBlock).forEach(function (token) {
-        for (var i = token.map[0]; i < token.map[1]; i++) {
+    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;
 };
 /**
@@ -322,20 +343,20 @@ module.exports.getLineMetadata = function getLineMetadata(params) {
  * @returns {void}
  */
 function forEachLine(lineMetadata, handler) {
-    lineMetadata.forEach(function forMetadata(metadata) {
-        handler.apply(void 0, metadata);
-    });
+    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) {
-    var flattenedLists = [];
-    var stack = [];
-    var current = null;
-    var nesting = 0;
-    var nestingStack = [];
-    var lastWithMap = { "map": [0, 1] };
-    tokens.forEach(function (token) {
+    const flattenedLists = [];
+    const stack = [];
+    let current = null;
+    let nesting = 0;
+    const nestingStack = [];
+    let lastWithMap = { "map": [0, 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
@@ -372,30 +393,30 @@ module.exports.flattenLists = function flattenLists(tokens) {
             nesting = 0;
         }
         else if (token.type === "blockquote_close") {
-            nesting = nestingStack.pop();
+            nesting = nestingStack.pop() || 0;
         }
-        else if (token.map) {
+        if (token.map) {
             // Track last token with map
             lastWithMap = token;
         }
-    });
+    }
     return flattenedLists;
 };
 // Calls the provided function for each specified inline child token
 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) {
-    var heading = null;
-    params.tokens.forEach(function forToken(token) {
+    let heading = null;
+    for (const token of params.tokens) {
         if (token.type === "heading_open") {
             heading = token;
         }
@@ -403,9 +424,9 @@ module.exports.forEachHeading = function forEachHeading(params, handler) {
             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.
@@ -416,87 +437,67 @@ module.exports.forEachHeading = function forEachHeading(params, handler) {
  * @returns {void}
  */
 function forEachInlineCodeSpan(input, handler) {
-    var currentLine = 0;
-    var currentColumn = 0;
-    var index = 0;
-    while (index < input.length) {
-        var startIndex = -1;
-        var startLine = -1;
-        var startColumn = -1;
-        var tickCount = 0;
-        var currentTicks = 0;
-        var 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++) {
-            var 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
-                    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;
+    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.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.
  *
@@ -510,11 +511,11 @@ module.exports.forEachInlineCodeSpan = forEachInlineCodeSpan;
  */
 function addError(onError, lineNumber, detail, context, range, fixInfo) {
     onError({
-        lineNumber: lineNumber,
-        detail: detail,
-        context: context,
-        range: range,
-        fixInfo: fixInfo
+        lineNumber,
+        detail,
+        context,
+        range,
+        fixInfo
     });
 }
 module.exports.addError = addError;
@@ -527,19 +528,8 @@ module.exports.addErrorDetailIf = function addErrorDetailIf(onError, lineNumber,
 };
 // 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 block and span content ranges.
@@ -548,22 +538,21 @@ module.exports.addErrorContext = function addErrorContext(onError, lineNumber, c
  * @param {Object} lineMetadata Line metadata object.
  * @returns {number[][]} Array of ranges (lineIndex, columnIndex, length).
  */
-module.exports.codeBlockAndSpanRanges = function (params, lineMetadata) {
-    var exclusions = [];
+module.exports.codeBlockAndSpanRanges = (params, lineMetadata) => {
+    const exclusions = [];
     // Add code block ranges (excludes fences)
-    forEachLine(lineMetadata, function (line, lineIndex, inCode, onFence) {
+    forEachLine(lineMetadata, (line, lineIndex, inCode, onFence) => {
         if (inCode && !onFence) {
             exclusions.push([lineIndex, 0, line.length]);
         }
     });
     // Add code span ranges (excludes ticks)
-    filterTokens(params, "inline", function (token) {
-        if (token.children.some(function (child) { return child.type === "code_inline"; })) {
-            var tokenLines = params.lines.slice(token.map[0], token.map[1]);
-            forEachInlineCodeSpan(tokenLines.join("\n"), function (code, lineIndex, columnIndex) {
-                var codeLines = code.split(newLineRe);
-                for (var _i = 0, _a = codeLines.entries(); _i < _a.length; _i++) {
-                    var _b = _a[_i], i = _b[0], line = _b[1];
+    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,
@@ -576,24 +565,43 @@ module.exports.codeBlockAndSpanRanges = function (params, lineMetadata) {
     return exclusions;
 };
 /**
- * Determines whether the specified range overlaps another range.
+ * 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 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 = function (ranges, lineIndex, index, length) { return (!ranges.every(function (span) { return ((lineIndex !== span[0]) ||
-    (index + length < span[1]) ||
-    (index > span[1] + span[2])); })); };
+const withinAnyRange = (ranges, lineIndex, index, length) => (!ranges.every((span) => ((lineIndex !== span[0]) ||
+    (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) {
-    var range = null;
-    var match = line.match(regexp);
+    let range = null;
+    const match = line.match(regexp);
     if (match) {
-        var column = match.index + 1;
-        var length = match[0].length;
+        const column = match.index + 1;
+        const length = match[0].length;
         range = [column, length];
     }
     return range;
@@ -601,11 +609,94 @@ module.exports.rangeFromRegExp = function rangeFromRegExp(line, regexp) {
 // Determines if the front matter includes a title
 module.exports.frontMatterHasTitle =
     function frontMatterHasTitle(frontMatterLines, frontMatterTitlePattern) {
-        var ignoreFrontMatter = (frontMatterTitlePattern !== undefined) && !frontMatterTitlePattern;
-        var frontMatterTitleRe = new RegExp(String(frontMatterTitlePattern || "^\\s*\"?title\"?\\s*[:=]"), "i");
+        const ignoreFrontMatter = (frontMatterTitlePattern !== undefined) && !frontMatterTitlePattern;
+        const frontMatterTitleRe = new RegExp(String(frontMatterTitlePattern || "^\\s*\"?title\"?\\s*[:=]"), "i");
         return !ignoreFrontMatter &&
-            frontMatterLines.some(function (line) { return frontMatterTitleRe.test(line); });
+            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.
  *
@@ -613,56 +704,182 @@ module.exports.frontMatterHasTitle =
  * @returns {number[][]} List of markers.
  */
 function emphasisMarkersInContent(params) {
-    var lines = params.lines;
-    var byLine = new Array(lines.length);
+    const { lines } = params;
+    const byLine = new Array(lines.length);
     // Search links
-    lines.forEach(function (tokenLine, tokenLineIndex) {
-        var inLine = [];
-        var linkMatch = null;
-        while ((linkMatch = linkRe.exec(tokenLine))) {
-            var markerMatch = null;
-            while ((markerMatch = emphasisMarkersRe.exec(linkMatch[0]))) {
-                inLine.push(linkMatch.index + markerMatch.index);
+    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", function (token) {
-        var children = token.children, lineNumber = token.lineNumber, map = token.map;
-        if (children.some(function (child) { return child.type === "code_inline"; })) {
-            var tokenLines = lines.slice(map[0], map[1]);
-            forEachInlineCodeSpan(tokenLines.join("\n"), function (code, lineIndex, column, tickCount) {
-                var codeLines = code.split(newLineRe);
-                codeLines.forEach(function (codeLine, codeLineIndex) {
-                    var byLineIndex = lineNumber - 1 + lineIndex + codeLineIndex;
-                    var inLine = byLine[byLineIndex];
-                    var codeLineOffset = codeLineIndex ? 0 : column - 1 + tickCount;
-                    var match = null;
+    filterTokens(params, "inline", (token) => {
+        const { children, lineNumber, map } = token;
+        if (children.some((child) => child.type === "code_inline")) {
+            const tokenLines = lines.slice(map[0], map[1]);
+            forEachInlineCodeSpan(tokenLines.join("\n"), (code, lineIndex, column, tickCount) => {
+                const codeLines = code.split(newLineRe);
+                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))) {
                         inLine.push(codeLineOffset + match.index);
                     }
                     byLine[byLineIndex] = 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;
+        }
+    });
+    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.getReferenceLinkImageData = getReferenceLinkImageData;
 /**
  * Gets the most common line ending, falling back to the platform default.
  *
  * @param {string} input Markdown content to analyze.
- * @param {string} [platform] Platform identifier (process.platform).
+ * @param {Object} [os] Node.js "os" module.
  * @returns {string} Preferred line ending.
  */
-function getPreferredLineEnding(input, platform) {
-    var cr = 0;
-    var lf = 0;
-    var crlf = 0;
-    var endings = input.match(newLineRe) || [];
-    endings.forEach(function (ending) {
+function getPreferredLineEnding(input, os) {
+    let cr = 0;
+    let lf = 0;
+    let crlf = 0;
+    const endings = input.match(newLineRe) || [];
+    for (const ending of endings) {
         // eslint-disable-next-line default-case
         switch (ending) {
             case "\r":
@@ -675,11 +892,10 @@ function getPreferredLineEnding(input, platform) {
                 crlf++;
                 break;
         }
-    });
-    var preferredLineEnding = null;
+    }
+    let preferredLineEnding = null;
     if (!cr && !lf && !crlf) {
-        preferredLineEnding =
-            ((platform || process.platform) === "win32") ? "\r\n" : "\n";
+        preferredLineEnding = (os && os.EOL) || "\n";
     }
     else if ((lf >= crlf) && (lf >= cr)) {
         preferredLineEnding = "\n";
@@ -713,12 +929,12 @@ 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) {
-    var _a = normalizeFixInfo(fixInfo), editColumn = _a.editColumn, deleteCount = _a.deleteCount, insertText = _a.insertText;
-    var editIndex = editColumn - 1;
+    const { editColumn, deleteCount, insertText } = normalizeFixInfo(fixInfo);
+    const editIndex = editColumn - 1;
     return (deleteCount === -1) ?
         null :
         line.slice(0, editIndex) +
@@ -726,27 +942,33 @@ function applyFix(line, fixInfo, lineEnding) {
             line.slice(editIndex + deleteCount);
 }
 module.exports.applyFix = applyFix;
-// Applies as many fixes as possible to the input lines
-module.exports.applyFixes = function applyFixes(input, errors) {
-    var lineEnding = getPreferredLineEnding(input);
-    var lines = input.split(newLineRe);
+/**
+ * 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, __webpack_require__(/*! os */ "?591e"));
+    const lines = input.split(newLineRe);
     // Normalize fixInfo objects
-    var fixInfos = errors
-        .filter(function (error) { return error.fixInfo; })
-        .map(function (error) { return normalizeFixInfo(error.fixInfo, error.lineNumber); });
+    let fixInfos = errors
+        .filter((error) => error.fixInfo)
+        .map((error) => normalizeFixInfo(error.fixInfo, error.lineNumber));
     // Sort bottom-to-top, line-deletes last, right-to-left, long-to-short
-    fixInfos.sort(function (a, b) {
-        var aDeletingLine = (a.deleteCount === -1);
-        var bDeletingLine = (b.deleteCount === -1);
+    fixInfos.sort((a, b) => {
+        const aDeletingLine = (a.deleteCount === -1);
+        const bDeletingLine = (b.deleteCount === -1);
         return ((b.lineNumber - a.lineNumber) ||
             (aDeletingLine ? 1 : (bDeletingLine ? -1 : 0)) ||
             (b.editColumn - a.editColumn) ||
             (b.insertText.length - a.insertText.length));
     });
     // Remove duplicate entries (needed for following collapse step)
-    var lastFixInfo = {};
-    fixInfos = fixInfos.filter(function (fixInfo) {
-        var unique = ((fixInfo.lineNumber !== lastFixInfo.lineNumber) ||
+    let lastFixInfo = {};
+    fixInfos = fixInfos.filter((fixInfo) => {
+        const unique = ((fixInfo.lineNumber !== lastFixInfo.lineNumber) ||
             (fixInfo.editColumn !== lastFixInfo.editColumn) ||
             (fixInfo.deleteCount !== lastFixInfo.deleteCount) ||
             (fixInfo.insertText !== lastFixInfo.insertText));
@@ -754,8 +976,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(function (fixInfo) {
+    lastFixInfo = {
+        "lineNumber": -1
+    };
+    for (const fixInfo of fixInfos) {
         if ((fixInfo.lineNumber === lastFixInfo.lineNumber) &&
             (fixInfo.editColumn === lastFixInfo.editColumn) &&
             !fixInfo.insertText &&
@@ -766,27 +990,29 @@ module.exports.applyFixes = function applyFixes(input, errors) {
             lastFixInfo.lineNumber = 0;
         }
         lastFixInfo = fixInfo;
-    });
-    fixInfos = fixInfos.filter(function (fixInfo) { return fixInfo.lineNumber; });
+    }
+    fixInfos = fixInfos.filter((fixInfo) => fixInfo.lineNumber);
     // Apply all (remaining/updated) fixes
-    var lastLineIndex = -1;
-    var lastEditIndex = -1;
-    fixInfos.forEach(function (fixInfo) {
-        var lineNumber = fixInfo.lineNumber, editColumn = fixInfo.editColumn, deleteCount = fixInfo.deleteCount;
-        var lineIndex = lineNumber - 1;
-        var editIndex = editColumn - 1;
+    let lastLineIndex = -1;
+    let lastEditIndex = -1;
+    for (const fixInfo of fixInfos) {
+        const { lineNumber, editColumn, deleteCount } = fixInfo;
+        const lineIndex = lineNumber - 1;
+        const editIndex = editColumn - 1;
         if ((lineIndex !== lastLineIndex) ||
             (deleteCount === -1) ||
             ((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(function (line) { return line !== null; }).join(lineEnding);
-};
+    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.
@@ -795,28 +1021,33 @@ module.exports.applyFixes = function applyFixes(input, errors) {
  * @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.
  */
-function getRangeAndFixInfoIfFound(lines, lineIndex, search, replace) {
-    var range = null;
-    var fixInfo = null;
-    var searchIndex = lines[lineIndex].indexOf(search);
-    if (searchIndex !== -1) {
-        var column = searchIndex + 1;
-        var length = search.length;
-        range = [column, length];
-        fixInfo = {
-            "editColumn": column,
-            "deleteCount": length,
-            "insertText": replace
+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
         };
-    }
-    return {
-        range: range,
-        fixInfo: fixInfo
     };
-}
-module.exports.getRangeAndFixInfoIfFound = getRangeAndFixInfoIfFound;
 /**
  * Gets the next (subsequent) child token if it is of the expected type.
  *
@@ -827,8 +1058,8 @@ module.exports.getRangeAndFixInfoIfFound = getRangeAndFixInfoIfFound;
  * @returns {Object} Next token.
  */
 function getNextChildToken(parentToken, childToken, nextType, nextNextType) {
-    var children = parentToken.children;
-    var index = children.indexOf(childToken);
+    const { children } = parentToken;
+    const index = children.indexOf(childToken);
     if ((index !== -1) &&
         (children.length > index + 2) &&
         (children[index + 1].type === nextType) &&
@@ -839,28 +1070,79 @@ function getNextChildToken(parentToken, childToken, nextType, nextNextType) {
 }
 module.exports.getNextChildToken = getNextChildToken;
 /**
- * Calls Object.freeze() on an object and its children.
+ * Expands a path with a tilde to an absolute path.
  *
- * @param {Object} obj Object to deep freeze.
- * @returns {Object} Object passed to the function.
+ * @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 deepFreeze(obj) {
-    var pending = [obj];
-    var current = null;
-    while ((current = pending.shift())) {
-        Object.freeze(current);
-        for (var _i = 0, _a = Object.getOwnPropertyNames(current); _i < _a.length; _i++) {
-            var name = _a[_i];
-            var value = current[name];
-            if (value && (typeof value === "object")) {
-                pending.push(value);
-            }
-        }
-    }
-    return obj;
+function expandTildePath(file, os) {
+    const homedir = os && os.homedir && os.homedir();
+    return homedir ? file.replace(/^~($|\/|\\)/, `${homedir}$1`) : file;
 }
-module.exports.deepFreeze = deepFreeze;
+module.exports.expandTildePath = expandTildePath;
+
+
+/***/ }),
+
+/***/ "markdown-it":
+/*!*****************************!*\
+  !*** external "markdownit" ***!
+  \*****************************/
+/***/ ((module) => {
+
+"use strict";
+module.exports = markdownit;
+
+/***/ }),
+
+/***/ "?591e":
+/*!********************!*\
+  !*** os (ignored) ***!
+  \********************/
+/***/ (() => {
+
+/* (ignored) */
+
+/***/ }),
+
+/***/ "?ec0a":
+/*!********************!*\
+  !*** fs (ignored) ***!
+  \********************/
+/***/ (() => {
+
+/* (ignored) */
+
+/***/ }),
+
+/***/ "?a32b":
+/*!********************!*\
+  !*** os (ignored) ***!
+  \********************/
+/***/ (() => {
+
+/* (ignored) */
+
+/***/ }),
+
+/***/ "?b85c":
+/*!**********************!*\
+  !*** path (ignored) ***!
+  \**********************/
+/***/ (() => {
 
+/* (ignored) */
+
+/***/ }),
+
+/***/ "?96a2":
+/*!**********************!*\
+  !*** util (ignored) ***!
+  \**********************/
+/***/ (() => {
+
+/* (ignored) */
 
 /***/ }),
 
@@ -873,32 +1155,23 @@ module.exports.deepFreeze = deepFreeze;
 "use strict";
 // @ts-check
 
-var codeBlockAndSpanRanges = null;
-module.exports.codeBlockAndSpanRanges = function (value) {
-    if (value) {
-        codeBlockAndSpanRanges = value;
+const map = new Map();
+module.exports.set = (keyValuePairs) => {
+    for (const [key, value] of Object.entries(keyValuePairs)) {
+        map.set(key, value);
     }
-    return codeBlockAndSpanRanges;
-};
-var flattenedLists = null;
-module.exports.flattenedLists = function (value) {
-    if (value) {
-        flattenedLists = value;
-    }
-    return flattenedLists;
-};
-var lineMetadata = null;
-module.exports.lineMetadata = function (value) {
-    if (value) {
-        lineMetadata = value;
-    }
-    return lineMetadata;
-};
-module.exports.clear = function () {
-    codeBlockAndSpanRanges = null;
-    flattenedLists = null;
-    lineMetadata = null;
 };
+module.exports.clear = () => map.clear();
+module.exports.codeBlockAndSpanRanges =
+    () => map.get("codeBlockAndSpanRanges");
+module.exports.flattenedLists =
+    () => map.get("flattenedLists");
+module.exports.htmlElementRanges =
+    () => map.get("htmlElementRanges");
+module.exports.lineMetadata =
+    () => map.get("lineMetadata");
+module.exports.referenceLinkImageData =
+    () => map.get("referenceLinkImageData");
 
 
 /***/ }),
@@ -914,7 +1187,7 @@ module.exports.clear = function () {
 
 module.exports.deprecatedRuleNames = ["MD002", "MD006"];
 module.exports.homepage = "https://github.com/DavidAnson/markdownlint";
-module.exports.version = "0.25.0";
+module.exports.version = "0.26.1";
 
 
 /***/ }),
@@ -923,81 +1196,61 @@ module.exports.version = "0.25.0";
 /*!******************************!*\
   !*** ../lib/markdownlint.js ***!
   \******************************/
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 // @ts-check
 
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var path = __webpack_require__(/*! path */ "?b85c");
-var promisify = (__webpack_require__(/*! util */ "?96a2").promisify);
-var markdownIt = __webpack_require__(/*! markdown-it */ "markdown-it");
-var deprecatedRuleNames = (__webpack_require__(/*! ./constants */ "../lib/constants.js").deprecatedRuleNames);
-var rules = __webpack_require__(/*! ./rules */ "../lib/rules.js");
-var helpers = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-var cache = __webpack_require__(/*! ./cache */ "../lib/cache.js");
+const path = __webpack_require__(/*! path */ "?b85c");
+const { promisify } = __webpack_require__(/*! util */ "?96a2");
+const markdownIt = __webpack_require__(/*! markdown-it */ "markdown-it");
+const { deprecatedRuleNames } = __webpack_require__(/*! ./constants */ "../lib/constants.js");
+const rules = __webpack_require__(/*! ./rules */ "../lib/rules.js");
+const helpers = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const cache = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 // @ts-ignore
 // eslint-disable-next-line camelcase, max-len, no-inline-comments, no-undef
-var dynamicRequire = (typeof require === "undefined") ? __webpack_require__("../lib sync recursive") : /* c8 ignore next */ require;
+const dynamicRequire = (typeof require === "undefined") ? __webpack_require__("../lib sync recursive") : /* c8 ignore next */ require;
 // Capture native require implementation for dynamic loading of modules
 /**
  * Validate the list of rules for structure and reuse.
  *
  * @param {Rule[]} ruleList List of rules.
  * @param {boolean} synchronous Whether to execute synchronously.
- * @returns {string} Error message if validation fails.
+ * @returns {Error | null} Error message if validation fails.
  */
 function validateRuleList(ruleList, synchronous) {
-    var result = null;
+    let result = null;
     if (ruleList.length === rules.length) {
         // No need to validate if only using built-in rules
         return result;
     }
-    var allIds = {};
-    ruleList.forEach(function forRule(rule, index) {
-        var customIndex = index - rules.length;
-        // eslint-disable-next-line jsdoc/require-jsdoc
+    const allIds = {};
+    for (const [index, rule] of ruleList.entries()) {
+        const customIndex = index - rules.length;
+        // eslint-disable-next-line no-inner-declarations, jsdoc/require-jsdoc
         function newError(property) {
             return new Error("Property '" + property + "' of custom rule at index " +
                 customIndex + " is incorrect.");
         }
-        ["names", "tags"].forEach(function forProperty(property) {
-            var value = rule[property];
+        for (const property of ["names", "tags"]) {
+            const value = rule[property];
             if (!result &&
                 (!value || !Array.isArray(value) || (value.length === 0) ||
                     !value.every(helpers.isString) || value.some(helpers.isEmptyString))) {
                 result = newError(property);
             }
-        });
-        [
+        }
+        for (const propertyInfo of [
             ["description", "string"],
             ["function", "function"]
-        ].forEach(function forProperty(propertyInfo) {
-            var property = propertyInfo[0];
-            var value = rule[property];
+        ]) {
+            const property = propertyInfo[0];
+            const value = rule[property];
             if (!result && (!value || (typeof value !== propertyInfo[1]))) {
                 result = newError(property);
             }
-        });
+        }
         if (!result &&
             rule.information &&
             (Object.getPrototypeOf(rule.information) !== URL.prototype)) {
@@ -1013,24 +1266,24 @@ function validateRuleList(ruleList, synchronous) {
                 " is asynchronous and can not be used in a synchronous context.");
         }
         if (!result) {
-            rule.names.forEach(function forName(name) {
-                var nameUpper = name.toUpperCase();
+            for (const name of rule.names) {
+                const nameUpper = name.toUpperCase();
                 if (!result && (allIds[nameUpper] !== undefined)) {
                     result = new Error("Name '" + name + "' of custom rule at index " +
                         customIndex + " is already used as a name or tag.");
                 }
                 allIds[nameUpper] = true;
-            });
-            rule.tags.forEach(function forTag(tag) {
-                var tagUpper = tag.toUpperCase();
+            }
+            for (const tag of rule.tags) {
+                const tagUpper = tag.toUpperCase();
                 if (!result && allIds[tagUpper]) {
                     result = new Error("Tag '" + tag + "' of custom rule at index " +
                         customIndex + " is already used as a name.");
                 }
                 allIds[tagUpper] = false;
-            });
+            }
         }
-    });
+    }
     return result;
 }
 /**
@@ -1040,18 +1293,18 @@ function validateRuleList(ruleList, synchronous) {
  * @returns {LintResults} New LintResults instance.
  */
 function newResults(ruleList) {
-    var lintResults = {};
+    const lintResults = {};
     // eslint-disable-next-line jsdoc/require-jsdoc
     function toString(useAlias) {
-        var ruleNameToRule = null;
-        var results = [];
-        var keys = Object.keys(lintResults);
+        let ruleNameToRule = null;
+        const results = [];
+        const keys = Object.keys(lintResults);
         keys.sort();
-        keys.forEach(function forFile(file) {
-            var fileResults = lintResults[file];
+        for (const file of keys) {
+            const fileResults = lintResults[file];
             if (Array.isArray(fileResults)) {
-                fileResults.forEach(function forResult(result) {
-                    var ruleMoniker = result.ruleNames ?
+                for (const result of fileResults) {
+                    const ruleMoniker = result.ruleNames ?
                         result.ruleNames.join("/") :
                         (result.ruleName + "/" + result.ruleAlias);
                     results.push(file + ": " +
@@ -1064,30 +1317,32 @@ function newResults(ruleList) {
                         (result.errorContext ?
                             " [Context: \"" + result.errorContext + "\"]" :
                             ""));
-                });
+                }
             }
             else {
                 if (!ruleNameToRule) {
                     ruleNameToRule = {};
-                    ruleList.forEach(function forRule(rule) {
-                        var ruleName = rule.names[0].toUpperCase();
+                    for (const rule of ruleList) {
+                        const ruleName = rule.names[0].toUpperCase();
                         ruleNameToRule[ruleName] = rule;
-                    });
+                    }
                 }
-                Object.keys(fileResults).forEach(function forRule(ruleName) {
-                    var rule = ruleNameToRule[ruleName.toUpperCase()];
-                    var ruleResults = fileResults[ruleName];
-                    ruleResults.forEach(function forLine(lineNumber) {
-                        var nameIndex = Math.min(useAlias ? 1 : 0, rule.names.length - 1);
-                        var result = file + ": " +
+                for (const [ruleName, ruleResults] of Object.entries(fileResults)) {
+                    const rule = ruleNameToRule[ruleName.toUpperCase()];
+                    for (const lineNumber of ruleResults) {
+                        // @ts-ignore
+                        const nameIndex = Math.min(useAlias ? 1 : 0, rule.names.length - 1);
+                        const result = file + ": " +
                             lineNumber + ": " +
+                            // @ts-ignore
                             rule.names[nameIndex] + " " +
+                            // @ts-ignore
                             rule.description;
                         results.push(result);
-                    });
-                });
+                    }
+                }
             }
-        });
+        }
         return results.join("\n");
     }
     Object.defineProperty(lintResults, "toString", { "value": toString });
@@ -1102,11 +1357,11 @@ function newResults(ruleList) {
  * @returns {Object} Trimmed content and front matter lines.
  */
 function removeFrontMatter(content, frontMatter) {
-    var frontMatterLines = [];
+    let frontMatterLines = [];
     if (frontMatter) {
-        var frontMatterMatch = content.match(frontMatter);
+        const frontMatterMatch = content.match(frontMatter);
         if (frontMatterMatch && !frontMatterMatch.index) {
-            var contentMatched = frontMatterMatch[0];
+            const contentMatched = frontMatterMatch[0];
             content = content.slice(contentMatched.length);
             frontMatterLines = contentMatched.split(helpers.newLineRe);
             if ((frontMatterLines.length > 0) &&
@@ -1121,15 +1376,39 @@ function removeFrontMatter(content, frontMatter) {
     };
 }
 /**
- * Annotate tokens with line/lineNumber.
+ * Freeze all freeze-able members of a token and its children.
+ *
+ * @param {MarkdownItToken} token A markdown-it token.
+ * @returns {void}
+ */
+function freezeToken(token) {
+    if (token.attrs) {
+        for (const attr of token.attrs) {
+            Object.freeze(attr);
+        }
+        Object.freeze(token.attrs);
+    }
+    if (token.children) {
+        for (const child of token.children) {
+            freezeToken(child);
+        }
+        Object.freeze(token.children);
+    }
+    if (token.map) {
+        Object.freeze(token.map);
+    }
+    Object.freeze(token);
+}
+/**
+ * Annotate tokens with line/lineNumber and freeze them.
  *
  * @param {MarkdownItToken[]} tokens Array of markdown-it tokens.
  * @param {string[]} lines Lines of Markdown content.
  * @returns {void}
  */
-function annotateTokens(tokens, lines) {
-    var trMap = null;
-    tokens.forEach(function forToken(token) {
+function annotateAndFreezeTokens(tokens, lines) {
+    let trMap = null;
+    for (const token of tokens) {
         // Provide missing maps for table content
         if (token.type === "tr_open") {
             trMap = token.map;
@@ -1138,7 +1417,7 @@ function annotateTokens(tokens, lines) {
             trMap = null;
         }
         if (!token.map && trMap) {
-            token.map = __spreadArray([], trMap, true);
+            token.map = [...trMap];
         }
         // Adjust maps for math blocks
         if (helpers.isMathBlock(token) && token.map[1]) {
@@ -1153,24 +1432,30 @@ function annotateTokens(tokens, lines) {
             while (token.map[1] && !((lines[token.map[1] - 1] || "").trim())) {
                 token.map[1]--;
             }
-            // Annotate children with lineNumber
-            var lineNumber_1 = token.lineNumber;
-            var codeSpanExtraLines_1 = [];
-            helpers.forEachInlineCodeSpan(token.content, function handleInlineCodeSpan(code) {
-                codeSpanExtraLines_1.push(code.split(helpers.newLineRe).length - 1);
-            });
-            (token.children || []).forEach(function forChild(child) {
-                child.lineNumber = lineNumber_1;
-                child.line = lines[lineNumber_1 - 1];
+        }
+        // Annotate children with lineNumber
+        if (token.children) {
+            const codeSpanExtraLines = [];
+            if (token.children.some((child) => child.type === "code_inline")) {
+                helpers.forEachInlineCodeSpan(token.content, (code) => {
+                    codeSpanExtraLines.push(code.split(helpers.newLineRe).length - 1);
+                });
+            }
+            let lineNumber = token.lineNumber;
+            for (const child of token.children) {
+                child.lineNumber = lineNumber;
+                child.line = lines[lineNumber - 1];
                 if ((child.type === "softbreak") || (child.type === "hardbreak")) {
-                    lineNumber_1++;
+                    lineNumber++;
                 }
                 else if (child.type === "code_inline") {
-                    lineNumber_1 += codeSpanExtraLines_1.shift();
+                    lineNumber += codeSpanExtraLines.shift();
                 }
-            });
+            }
         }
-    });
+        freezeToken(token);
+    }
+    Object.freeze(tokens);
 }
 /**
  * Map rule names/tags to canonical rule name.
@@ -1179,26 +1464,26 @@ function annotateTokens(tokens, lines) {
  * @returns {Object.<string, string[]>} Map of alias to rule name.
  */
 function mapAliasToRuleNames(ruleList) {
-    var aliasToRuleNames = {};
+    const aliasToRuleNames = {};
     // const tagToRuleNames = {};
-    ruleList.forEach(function forRule(rule) {
-        var ruleName = rule.names[0].toUpperCase();
+    for (const rule of ruleList) {
+        const ruleName = rule.names[0].toUpperCase();
         // The following is useful for updating README.md:
         // console.log(
         //   "* **[" + ruleName + "](doc/Rules.md#" + ruleName.toLowerCase() +
         //    ")** *" + rule.names.slice(1).join("/") + "* - " + rule.description);
-        rule.names.forEach(function forName(name) {
-            var nameUpper = name.toUpperCase();
+        for (const name of rule.names) {
+            const nameUpper = name.toUpperCase();
             aliasToRuleNames[nameUpper] = [ruleName];
-        });
-        rule.tags.forEach(function forTag(tag) {
-            var tagUpper = tag.toUpperCase();
-            var ruleNames = aliasToRuleNames[tagUpper] || [];
+        }
+        for (const tag of rule.tags) {
+            const tagUpper = tag.toUpperCase();
+            const ruleNames = aliasToRuleNames[tagUpper] || [];
             ruleNames.push(ruleName);
             aliasToRuleNames[tagUpper] = ruleNames;
             // tagToRuleNames[tag] = ruleName;
-        });
-    });
+        }
+    }
     // The following is useful for updating README.md:
     // Object.keys(tagToRuleNames).sort().forEach(function forTag(tag) {
     //   console.log("* **" + tag + "** - " +
@@ -1217,18 +1502,18 @@ function mapAliasToRuleNames(ruleList) {
  * @returns {Configuration} Effective configuration.
  */
 function getEffectiveConfig(ruleList, config, aliasToRuleNames) {
-    var defaultKey = Object.keys(config).filter(function (key) { return key.toUpperCase() === "DEFAULT"; });
-    var ruleDefault = (defaultKey.length === 0) || !!config[defaultKey[0]];
-    var effectiveConfig = {};
-    ruleList.forEach(function (rule) {
-        var ruleName = rule.names[0].toUpperCase();
+    const defaultKey = Object.keys(config).filter((key) => key.toUpperCase() === "DEFAULT");
+    const ruleDefault = (defaultKey.length === 0) || !!config[defaultKey[0]];
+    const effectiveConfig = {};
+    for (const rule of ruleList) {
+        const ruleName = rule.names[0].toUpperCase();
         effectiveConfig[ruleName] = ruleDefault;
-    });
-    deprecatedRuleNames.forEach(function (ruleName) {
+    }
+    for (const ruleName of deprecatedRuleNames) {
         effectiveConfig[ruleName] = false;
-    });
-    Object.keys(config).forEach(function (key) {
-        var value = config[key];
+    }
+    for (const key of Object.keys(config)) {
+        let value = config[key];
         if (value) {
             if (!(value instanceof Object)) {
                 value = {};
@@ -1237,13 +1522,46 @@ function getEffectiveConfig(ruleList, config, aliasToRuleNames) {
         else {
             value = false;
         }
-        var keyUpper = key.toUpperCase();
-        (aliasToRuleNames[keyUpper] || []).forEach(function (ruleName) {
+        const keyUpper = key.toUpperCase();
+        for (const ruleName of (aliasToRuleNames[keyUpper] || [])) {
             effectiveConfig[ruleName] = value;
-        });
-    });
+        }
+    }
     return effectiveConfig;
 }
+/**
+ * Parse the content of a configuration file.
+ *
+ * @param {string} name Name of the configuration file.
+ * @param {string} content Configuration content.
+ * @param {ConfigurationParser[] | null} [parsers] Parsing function(s).
+ * @returns {Object} Configuration object and error message.
+ */
+function parseConfiguration(name, content, parsers) {
+    let config = null;
+    let message = "";
+    const errors = [];
+    let index = 0;
+    // Try each parser
+    (parsers || [JSON.parse]).every((parser) => {
+        try {
+            config = parser(content);
+        }
+        catch (error) {
+            errors.push(`Parser ${index++}: ${error.message}`);
+        }
+        return !config;
+    });
+    // Message if unable to parse
+    if (!config) {
+        errors.unshift(`Unable to parse '${name}'`);
+        message = errors.join("; ");
+    }
+    return {
+        config,
+        message
+    };
+}
 /**
  * Create a mapping of enabled rules per line.
  *
@@ -1252,57 +1570,59 @@ function getEffectiveConfig(ruleList, config, aliasToRuleNames) {
  * @param {string[]} frontMatterLines List of front matter lines.
  * @param {boolean} noInlineConfig Whether to allow inline configuration.
  * @param {Configuration} config Configuration object.
+ * @param {ConfigurationParser[] | null} configParsers Configuration parsers.
  * @param {Object.<string, string[]>} aliasToRuleNames Map of alias to rule
  * names.
  * @returns {Object} Effective configuration and enabled rules per line number.
  */
-function getEnabledRulesPerLineNumber(ruleList, lines, frontMatterLines, noInlineConfig, config, aliasToRuleNames) {
+function getEnabledRulesPerLineNumber(ruleList, lines, frontMatterLines, noInlineConfig, config, configParsers, aliasToRuleNames) {
     // Shared variables
-    var enabledRules = {};
-    var capturedRules = {};
-    var allRuleNames = [];
-    var enabledRulesPerLineNumber = new Array(1 + frontMatterLines.length);
+    let enabledRules = {};
+    let capturedRules = {};
+    const allRuleNames = [];
+    const enabledRulesPerLineNumber = new Array(1 + frontMatterLines.length);
     // Helper functions
     // eslint-disable-next-line jsdoc/require-jsdoc
     function handleInlineConfig(input, forEachMatch, forEachLine) {
-        input.forEach(function (line, lineIndex) {
+        for (const [lineIndex, line] of input.entries()) {
             if (!noInlineConfig) {
-                var match = null;
-                while ((match = helpers.inlineCommentRe.exec(line))) {
-                    var action = (match[1] || match[3]).toUpperCase();
-                    var parameter = match[2] || match[4];
+                let match = null;
+                while ((match = helpers.inlineCommentStartRe.exec(line))) {
+                    const action = match[2].toUpperCase();
+                    const startIndex = match.index + match[1].length;
+                    const endIndex = line.indexOf("-->", startIndex);
+                    if (endIndex === -1) {
+                        break;
+                    }
+                    const parameter = line.slice(startIndex, endIndex);
                     forEachMatch(action, parameter, lineIndex + 1);
                 }
             }
             if (forEachLine) {
                 forEachLine();
             }
-        });
+        }
     }
     // eslint-disable-next-line jsdoc/require-jsdoc
     function configureFile(action, parameter) {
         if (action === "CONFIGURE-FILE") {
-            try {
-                var json = JSON.parse(parameter);
-                config = __assign(__assign({}, config), json);
-            }
-            catch (_a) {
-                // Ignore parse errors for inline configuration
+            const { "config": parsed } = parseConfiguration("CONFIGURE-FILE", parameter, configParsers);
+            if (parsed) {
+                config = Object.assign(Object.assign({}, config), parsed);
             }
         }
     }
     // eslint-disable-next-line jsdoc/require-jsdoc
     function applyEnableDisable(action, parameter, state) {
-        state = __assign({}, state);
-        var enabled = (action.startsWith("ENABLE"));
-        var items = parameter ?
-            parameter.trim().toUpperCase().split(/\s+/) :
-            allRuleNames;
-        items.forEach(function (nameUpper) {
-            (aliasToRuleNames[nameUpper] || []).forEach(function (ruleName) {
+        state = Object.assign({}, state);
+        const enabled = (action.startsWith("ENABLE"));
+        const trimmed = parameter && parameter.trim();
+        const items = trimmed ? trimmed.toUpperCase().split(/\s+/) : allRuleNames;
+        for (const nameUpper of items) {
+            for (const ruleName of (aliasToRuleNames[nameUpper] || [])) {
                 state[ruleName] = enabled;
-            });
-        });
+            }
+        }
         return state;
     }
     // eslint-disable-next-line jsdoc/require-jsdoc
@@ -1328,29 +1648,31 @@ function getEnabledRulesPerLineNumber(ruleList, lines, frontMatterLines, noInlin
         enabledRulesPerLineNumber.push(enabledRules);
     }
     // eslint-disable-next-line jsdoc/require-jsdoc
-    function disableNextLine(action, parameter, lineNumber) {
-        if (action === "DISABLE-NEXT-LINE") {
-            var nextLineNumber = frontMatterLines.length + lineNumber + 1;
+    function disableLineNextLine(action, parameter, lineNumber) {
+        const disableLine = (action === "DISABLE-LINE");
+        const disableNextLine = (action === "DISABLE-NEXT-LINE");
+        if (disableLine || disableNextLine) {
+            const nextLineNumber = frontMatterLines.length + lineNumber + (disableNextLine ? 1 : 0);
             enabledRulesPerLineNumber[nextLineNumber] =
                 applyEnableDisable(action, parameter, enabledRulesPerLineNumber[nextLineNumber] || {});
         }
     }
     // Handle inline comments
     handleInlineConfig([lines.join("\n")], configureFile);
-    var effectiveConfig = getEffectiveConfig(ruleList, config, aliasToRuleNames);
-    ruleList.forEach(function (rule) {
-        var ruleName = rule.names[0].toUpperCase();
+    const effectiveConfig = getEffectiveConfig(ruleList, config, aliasToRuleNames);
+    for (const rule of ruleList) {
+        const ruleName = rule.names[0].toUpperCase();
         allRuleNames.push(ruleName);
         enabledRules[ruleName] = !!effectiveConfig[ruleName];
-    });
+    }
     capturedRules = enabledRules;
     handleInlineConfig(lines, enableDisableFile);
     handleInlineConfig(lines, captureRestoreEnableDisable, updateLineState);
-    handleInlineConfig(lines, disableNextLine);
+    handleInlineConfig(lines, disableLineNextLine);
     // Return results
     return {
-        effectiveConfig: effectiveConfig,
-        enabledRulesPerLineNumber: enabledRulesPerLineNumber
+        effectiveConfig,
+        enabledRulesPerLineNumber
     };
 }
 /**
@@ -1361,6 +1683,7 @@ function getEnabledRulesPerLineNumber(ruleList, lines, frontMatterLines, noInlin
  * @param {string} content Markdown content.
  * @param {Object} md Instance of markdown-it.
  * @param {Configuration} config Configuration object.
+ * @param {ConfigurationParser[] | null} configParsers Configuration parsers.
  * @param {RegExp} frontMatter Regular expression for front matter.
  * @param {boolean} handleRuleFailures Whether to handle exceptions in rules.
  * @param {boolean} noInlineConfig Whether to allow inline configuration.
@@ -1368,37 +1691,47 @@ function getEnabledRulesPerLineNumber(ruleList, lines, frontMatterLines, noInlin
  * @param {Function} callback Callback (err, result) function.
  * @returns {void}
  */
-function lintContent(ruleList, name, content, md, config, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, callback) {
+function lintContent(ruleList, name, content, md, config, configParsers, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, callback) {
     // Remove UTF-8 byte order marker (if present)
     content = content.replace(/^\uFEFF/, "");
     // Remove front matter
-    var removeFrontMatterResult = removeFrontMatter(content, frontMatter);
-    var frontMatterLines = removeFrontMatterResult.frontMatterLines;
-    // Ignore the content of HTML comments
-    content = helpers.clearHtmlCommentText(removeFrontMatterResult.content);
+    const removeFrontMatterResult = removeFrontMatter(content, frontMatter);
+    const { frontMatterLines } = removeFrontMatterResult;
+    content = removeFrontMatterResult.content;
+    // Get enabled rules per line (with HTML comments present)
+    const { effectiveConfig, enabledRulesPerLineNumber } = getEnabledRulesPerLineNumber(ruleList, content.split(helpers.newLineRe), frontMatterLines, noInlineConfig, config, configParsers, mapAliasToRuleNames(ruleList));
+    // Hide the content of HTML comments from rules, etc.
+    content = helpers.clearHtmlCommentText(content);
     // Parse content into tokens and lines
-    var tokens = md.parse(content, {});
-    var lines = content.split(helpers.newLineRe);
-    annotateTokens(tokens, lines);
-    var aliasToRuleNames = mapAliasToRuleNames(ruleList);
-    var _a = getEnabledRulesPerLineNumber(ruleList, lines, frontMatterLines, noInlineConfig, config, aliasToRuleNames), effectiveConfig = _a.effectiveConfig, enabledRulesPerLineNumber = _a.enabledRulesPerLineNumber;
-    // Create parameters for rules
-    var params = {
-        "name": helpers.deepFreeze(name),
-        "tokens": helpers.deepFreeze(tokens),
-        "lines": helpers.deepFreeze(lines),
-        "frontMatterLines": helpers.deepFreeze(frontMatterLines)
+    const tokens = md.parse(content, {});
+    const lines = content.split(helpers.newLineRe);
+    annotateAndFreezeTokens(tokens, lines);
+    // Create (frozen) parameters for rules
+    const paramsBase = {
+        name,
+        tokens,
+        "lines": Object.freeze(lines),
+        "frontMatterLines": Object.freeze(frontMatterLines)
     };
-    cache.lineMetadata(helpers.getLineMetadata(params));
-    cache.flattenedLists(helpers.flattenLists(params.tokens));
-    cache.codeBlockAndSpanRanges(helpers.codeBlockAndSpanRanges(params, cache.lineMetadata()));
+    const lineMetadata = helpers.getLineMetadata(paramsBase);
+    const codeBlockAndSpanRanges = helpers.codeBlockAndSpanRanges(paramsBase, lineMetadata);
+    const flattenedLists = helpers.flattenLists(paramsBase.tokens);
+    const htmlElementRanges = helpers.htmlElementRanges(paramsBase, lineMetadata);
+    const referenceLinkImageData = helpers.getReferenceLinkImageData(lineMetadata);
+    cache.set({
+        codeBlockAndSpanRanges,
+        flattenedLists,
+        htmlElementRanges,
+        lineMetadata,
+        referenceLinkImageData
+    });
     // Function to run for each rule
-    var results = [];
+    let results = [];
     // eslint-disable-next-line jsdoc/require-jsdoc
     function forRule(rule) {
         // Configure rule
-        var ruleName = rule.names[0].toUpperCase();
-        params.config = effectiveConfig[ruleName];
+        const ruleName = rule.names[0].toUpperCase();
+        const params = Object.assign(Object.assign({}, paramsBase), { "config": effectiveConfig[ruleName] });
         // eslint-disable-next-line jsdoc/require-jsdoc
         function throwError(property) {
             throw new Error("Property '" + property + "' of onError parameter is incorrect.");
@@ -1411,7 +1744,7 @@ function lintContent(ruleList, name, content, md, config, frontMatter, handleRul
                 (errorInfo.lineNumber > lines.length)) {
                 throwError("lineNumber");
             }
-            var lineNumber = errorInfo.lineNumber + frontMatterLines.length;
+            const lineNumber = errorInfo.lineNumber + frontMatterLines.length;
             if (!enabledRulesPerLineNumber[lineNumber][ruleName]) {
                 return;
             }
@@ -1434,8 +1767,8 @@ function lintContent(ruleList, name, content, md, config, frontMatter, handleRul
                         lines[errorInfo.lineNumber - 1].length))) {
                 throwError("range");
             }
-            var fixInfo = errorInfo.fixInfo;
-            var cleanFixInfo = {};
+            const fixInfo = errorInfo.fixInfo;
+            const cleanFixInfo = {};
             if (fixInfo) {
                 if (!helpers.isObject(fixInfo)) {
                     throwError("fixInfo");
@@ -1449,7 +1782,7 @@ function lintContent(ruleList, name, content, md, config, frontMatter, handleRul
                     cleanFixInfo.lineNumber =
                         fixInfo.lineNumber + frontMatterLines.length;
                 }
-                var effectiveLineNumber = fixInfo.lineNumber || errorInfo.lineNumber;
+                const effectiveLineNumber = fixInfo.lineNumber || errorInfo.lineNumber;
                 if (fixInfo.editColumn !== undefined) {
                     if ((!helpers.isNumber(fixInfo.editColumn) ||
                         (fixInfo.editColumn < 1) ||
@@ -1476,26 +1809,26 @@ function lintContent(ruleList, name, content, md, config, frontMatter, handleRul
                 }
             }
             results.push({
-                lineNumber: lineNumber,
+                lineNumber,
                 "ruleName": rule.names[0],
                 "ruleNames": rule.names,
                 "ruleDescription": rule.description,
                 "ruleInformation": rule.information ? rule.information.href : null,
                 "errorDetail": errorInfo.detail || null,
                 "errorContext": errorInfo.context || null,
-                "errorRange": errorInfo.range ? __spreadArray([], errorInfo.range, true) : null,
+                "errorRange": errorInfo.range ? [...errorInfo.range] : null,
                 "fixInfo": fixInfo ? cleanFixInfo : null
             });
         }
         // Call (possibly external) rule function to report errors
-        var catchCallsOnError = function (error) { return onError({
+        const catchCallsOnError = (error) => onError({
             "lineNumber": 1,
-            "detail": "This rule threw an exception: ".concat(error.message || error)
-        }); };
-        var invokeRuleFunction = function () { return rule.function(params, onError); };
+            "detail": `This rule threw an exception: ${error.message || error}`
+        });
+        const invokeRuleFunction = () => rule.function(params, onError);
         if (rule.asynchronous) {
             // Asynchronous rule, ensure it returns a Promise
-            var ruleFunctionPromise = Promise.resolve().then(invokeRuleFunction);
+            const ruleFunctionPromise = Promise.resolve().then(invokeRuleFunction);
             return handleRuleFailures ?
                 ruleFunctionPromise.catch(catchCallsOnError) :
                 ruleFunctionPromise;
@@ -1517,27 +1850,26 @@ function lintContent(ruleList, name, content, md, config, frontMatter, handleRul
     // eslint-disable-next-line jsdoc/require-jsdoc
     function formatResults() {
         // Sort results by rule name by line number
-        results.sort(function (a, b) { return (a.ruleName.localeCompare(b.ruleName) ||
-            a.lineNumber - b.lineNumber); });
+        results.sort((a, b) => (a.ruleName.localeCompare(b.ruleName) ||
+            a.lineNumber - b.lineNumber));
         if (resultVersion < 3) {
             // Remove fixInfo and multiple errors for the same rule and line number
-            var noPrevious_1 = {
+            const noPrevious = {
                 "ruleName": null,
                 "lineNumber": -1
             };
-            results = results.filter(function (error, index, array) {
+            results = results.filter((error, index, array) => {
                 delete error.fixInfo;
-                var previous = array[index - 1] || noPrevious_1;
+                const previous = array[index - 1] || noPrevious;
                 return ((error.ruleName !== previous.ruleName) ||
                     (error.lineNumber !== previous.lineNumber));
             });
         }
         if (resultVersion === 0) {
             // Return a dictionary of rule->[line numbers]
-            var dictionary = {};
-            for (var _i = 0, results_1 = results; _i < results_1.length; _i++) {
-                var error = results_1[_i];
-                var ruleLines = dictionary[error.ruleName] || [];
+            const dictionary = {};
+            for (const error of results) {
+                const ruleLines = dictionary[error.ruleName] || [];
                 ruleLines.push(error.lineNumber);
                 dictionary[error.ruleName] = ruleLines;
             }
@@ -1546,29 +1878,30 @@ function lintContent(ruleList, name, content, md, config, frontMatter, handleRul
         }
         else if (resultVersion === 1) {
             // Use ruleAlias instead of ruleNames
-            for (var _a = 0, results_2 = results; _a < results_2.length; _a++) {
-                var error = results_2[_a];
+            for (const error of results) {
                 error.ruleAlias = error.ruleNames[1] || error.ruleName;
                 delete error.ruleNames;
             }
         }
         else {
             // resultVersion 2 or 3: Remove unwanted ruleName
-            for (var _b = 0, results_3 = results; _b < results_3.length; _b++) {
-                var error = results_3[_b];
+            for (const error of results) {
                 delete error.ruleName;
             }
         }
         return results;
     }
     // Run all rules
-    var ruleListAsync = ruleList.filter(function (rule) { return rule.asynchronous; });
-    var ruleListSync = ruleList.filter(function (rule) { return !rule.asynchronous; });
-    var ruleListAsyncFirst = __spreadArray(__spreadArray([], ruleListAsync, true), ruleListSync, true);
-    var callbackSuccess = function () { return callback(null, formatResults()); };
-    var callbackError = function (error) { return callback(error instanceof Error ? error : new Error(error)); };
+    const ruleListAsync = ruleList.filter((rule) => rule.asynchronous);
+    const ruleListSync = ruleList.filter((rule) => !rule.asynchronous);
+    const ruleListAsyncFirst = [
+        ...ruleListAsync,
+        ...ruleListSync
+    ];
+    const callbackSuccess = () => callback(null, formatResults());
+    const callbackError = (error) => callback(error instanceof Error ? error : new Error(error));
     try {
-        var ruleResults = ruleListAsyncFirst.map(forRule);
+        const ruleResults = ruleListAsyncFirst.map(forRule);
         if (ruleListAsync.length > 0) {
             Promise.all(ruleResults.slice(0, ruleListAsync.length))
                 .then(callbackSuccess)
@@ -1592,6 +1925,7 @@ function lintContent(ruleList, name, content, md, config, frontMatter, handleRul
  * @param {string} file Path of file to lint.
  * @param {Object} md Instance of markdown-it.
  * @param {Configuration} config Configuration object.
+ * @param {ConfigurationParser[] | null} configParsers Configuration parsers.
  * @param {RegExp} frontMatter Regular expression for front matter.
  * @param {boolean} handleRuleFailures Whether to handle exceptions in rules.
  * @param {boolean} noInlineConfig Whether to allow inline configuration.
@@ -1601,13 +1935,13 @@ function lintContent(ruleList, name, content, md, config, frontMatter, handleRul
  * @param {Function} callback Callback (err, result) function.
  * @returns {void}
  */
-function lintFile(ruleList, file, md, config, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, fs, synchronous, callback) {
+function lintFile(ruleList, file, md, config, configParsers, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, fs, synchronous, callback) {
     // eslint-disable-next-line jsdoc/require-jsdoc
     function lintContentWrapper(err, content) {
         if (err) {
             return callback(err);
         }
-        return lintContent(ruleList, file, content, md, config, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, callback);
+        return lintContent(ruleList, file, content, md, config, configParsers, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, callback);
     }
     // Make a/synchronous call to read file
     if (synchronous) {
@@ -1630,40 +1964,42 @@ function lintInput(options, synchronous, callback) {
     options = options || {};
     callback = callback || function noop() { };
     // eslint-disable-next-line unicorn/prefer-spread
-    var ruleList = rules.concat(options.customRules || []);
-    var ruleErr = validateRuleList(ruleList, synchronous);
+    const ruleList = rules.concat(options.customRules || []);
+    const ruleErr = validateRuleList(ruleList, synchronous);
     if (ruleErr) {
-        return callback(ruleErr);
+        callback(ruleErr);
+        return;
     }
-    var files = [];
+    let files = [];
     if (Array.isArray(options.files)) {
-        files = __spreadArray([], options.files, true);
+        files = [...options.files];
     }
     else if (options.files) {
         files = [String(options.files)];
     }
-    var strings = options.strings || {};
-    var stringsKeys = Object.keys(strings);
-    var config = options.config || { "default": true };
-    var frontMatter = (options.frontMatter === undefined) ?
+    const strings = options.strings || {};
+    const stringsKeys = Object.keys(strings);
+    const config = options.config || { "default": true };
+    const configParsers = options.configParsers || null;
+    const frontMatter = (options.frontMatter === undefined) ?
         helpers.frontMatterRe : options.frontMatter;
-    var handleRuleFailures = !!options.handleRuleFailures;
-    var noInlineConfig = !!options.noInlineConfig;
-    var resultVersion = (options.resultVersion === undefined) ?
-        2 : options.resultVersion;
-    var md = markdownIt({ "html": true });
-    var markdownItPlugins = options.markdownItPlugins || [];
-    markdownItPlugins.forEach(function forPlugin(plugin) {
+    const handleRuleFailures = !!options.handleRuleFailures;
+    const noInlineConfig = !!options.noInlineConfig;
+    const resultVersion = (options.resultVersion === undefined) ?
+        3 : options.resultVersion;
+    const md = markdownIt({ "html": true });
+    const markdownItPlugins = options.markdownItPlugins || [];
+    for (const plugin of markdownItPlugins) {
         // @ts-ignore
-        md.use.apply(md, plugin);
-    });
-    var fs = options.fs || __webpack_require__(/*! fs */ "?ec0a");
-    var results = newResults(ruleList);
-    var done = false;
-    var concurrency = 0;
+        md.use(...plugin);
+    }
+    const fs = options.fs || __webpack_require__(/*! fs */ "?ec0a");
+    const results = newResults(ruleList);
+    let done = false;
+    let concurrency = 0;
     // eslint-disable-next-line jsdoc/require-jsdoc
     function lintWorker() {
-        var currentItem = null;
+        let currentItem = null;
         // eslint-disable-next-line jsdoc/require-jsdoc
         function lintWorkerCallback(err, result) {
             concurrency--;
@@ -1684,13 +2020,12 @@ function lintInput(options, synchronous, callback) {
             // Lint next file
             concurrency++;
             currentItem = files.shift();
-            lintFile(ruleList, currentItem, md, config, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, fs, synchronous, lintWorkerCallback);
+            lintFile(ruleList, currentItem, md, config, configParsers, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, fs, synchronous, lintWorkerCallback);
         }
-        else if (stringsKeys.length > 0) {
+        else if ((currentItem = stringsKeys.shift())) {
             // Lint next string
             concurrency++;
-            currentItem = stringsKeys.shift();
-            lintContent(ruleList, currentItem, strings[currentItem] || "", md, config, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, lintWorkerCallback);
+            lintContent(ruleList, currentItem, strings[currentItem] || "", md, config, configParsers, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, lintWorkerCallback);
         }
         else if (concurrency === 0) {
             // Finish
@@ -1717,7 +2052,6 @@ function lintInput(options, synchronous, callback) {
         lintWorker();
         lintWorker();
     }
-    return null;
 }
 /**
  * Lint specified Markdown files.
@@ -1729,7 +2063,7 @@ function lintInput(options, synchronous, callback) {
 function markdownlint(options, callback) {
     return lintInput(options, false, callback);
 }
-var markdownlintPromisify = promisify && promisify(markdownlint);
+const markdownlintPromisify = promisify && promisify(markdownlint);
 /**
  * Lint specified Markdown files.
  *
@@ -1737,6 +2071,7 @@ var markdownlintPromisify = promisify && promisify(markdownlint);
  * @returns {Promise<LintResults>} Results object.
  */
 function markdownlintPromise(options) {
+    // @ts-ignore
     return markdownlintPromisify(options);
 }
 /**
@@ -1746,48 +2081,16 @@ function markdownlintPromise(options) {
  * @returns {LintResults} Results object.
  */
 function markdownlintSync(options) {
-    var results = null;
+    let results = {};
     lintInput(options, true, function callback(error, res) {
         if (error) {
             throw error;
         }
         results = res;
     });
+    // @ts-ignore
     return results;
 }
-/**
- * Parse the content of a configuration file.
- *
- * @param {string} name Name of the configuration file.
- * @param {string} content Configuration content.
- * @param {ConfigurationParser[]} parsers Parsing function(s).
- * @returns {Object} Configuration object and error message.
- */
-function parseConfiguration(name, content, parsers) {
-    var config = null;
-    var message = "";
-    var errors = [];
-    var index = 0;
-    // Try each parser
-    (parsers || [JSON.parse]).every(function (parser) {
-        try {
-            config = parser(content);
-        }
-        catch (error) {
-            errors.push("Parser ".concat(index++, ": ").concat(error.message));
-        }
-        return !config;
-    });
-    // Message if unable to parse
-    if (!config) {
-        errors.unshift("Unable to parse '".concat(name, "'"));
-        message = errors.join("; ");
-    }
-    return {
-        config: config,
-        message: message
-    };
-}
 /**
  * Resolve referenced "extends" path in a configuration file
  * using path.resolve() with require.resolve() as a fallback.
@@ -1795,14 +2098,14 @@ function parseConfiguration(name, content, parsers) {
  * @param {string} configFile Configuration file name.
  * @param {string} referenceId Referenced identifier to resolve.
  * @param {Object} fs File system implementation.
- * @param {ResolveConfigExtendsCallback} [callback] Callback (err, result)
+ * @param {ResolveConfigExtendsCallback} callback Callback (err, result)
  * function.
  * @returns {void}
  */
 function resolveConfigExtends(configFile, referenceId, fs, callback) {
-    var configFileDirname = path.dirname(configFile);
-    var resolvedExtendsFile = path.resolve(configFileDirname, referenceId);
-    fs.access(resolvedExtendsFile, function (err) {
+    const configFileDirname = path.dirname(configFile);
+    const resolvedExtendsFile = path.resolve(configFileDirname, referenceId);
+    fs.access(resolvedExtendsFile, (err) => {
         if (err) {
             // Not a file, try require.resolve
             try {
@@ -1825,8 +2128,8 @@ function resolveConfigExtends(configFile, referenceId, fs, callback) {
  * @returns {string} Resolved path to file.
  */
 function resolveConfigExtendsSync(configFile, referenceId, fs) {
-    var configFileDirname = path.dirname(configFile);
-    var resolvedExtendsFile = path.resolve(configFileDirname, referenceId);
+    const configFileDirname = path.dirname(configFile);
+    const resolvedExtendsFile = path.resolve(configFileDirname, referenceId);
     try {
         fs.accessSync(resolvedExtendsFile);
         return resolvedExtendsFile;
@@ -1861,6 +2164,7 @@ function readConfig(file, parsers, fs, callback) {
         else {
             // @ts-ignore
             callback = parsers;
+            // @ts-ignore
             parsers = null;
         }
     }
@@ -1868,31 +2172,40 @@ function readConfig(file, parsers, fs, callback) {
         fs = __webpack_require__(/*! fs */ "?ec0a");
     }
     // Read file
-    fs.readFile(file, "utf8", function (err, content) {
+    const os = __webpack_require__(/*! os */ "?a32b");
+    file = helpers.expandTildePath(file, os);
+    fs.readFile(file, "utf8", (err, content) => {
         if (err) {
+            // @ts-ignore
             return callback(err);
         }
         // Try to parse file
         // @ts-ignore
-        var _a = parseConfiguration(file, content, parsers), config = _a.config, message = _a.message;
+        const { config, message } = parseConfiguration(file, content, parsers);
         if (!config) {
+            // @ts-ignore
             return callback(new Error(message));
         }
         // Extend configuration
-        var configExtends = config.extends;
+        const configExtends = config.extends;
         if (configExtends) {
             delete config.extends;
-            return resolveConfigExtends(file, configExtends, fs, function (_, resolvedExtends) { return readConfig(resolvedExtends, parsers, fs, function (errr, extendsConfig) {
+            return resolveConfigExtends(file, helpers.expandTildePath(configExtends, os), fs, (_, resolvedExtends) => readConfig(
+            // @ts-ignore
+            resolvedExtends, parsers, fs, (errr, extendsConfig) => {
                 if (errr) {
+                    // @ts-ignore
                     return callback(errr);
                 }
-                return callback(null, __assign(__assign({}, extendsConfig), config));
-            }); });
+                // @ts-ignore
+                return callback(null, Object.assign(Object.assign({}, extendsConfig), config));
+            }));
         }
+        // @ts-ignore
         return callback(null, config);
     });
 }
-var readConfigPromisify = promisify && promisify(readConfig);
+const readConfigPromisify = promisify && promisify(readConfig);
 /**
  * Read specified configuration file.
  *
@@ -1919,18 +2232,20 @@ function readConfigSync(file, parsers, fs) {
         fs = __webpack_require__(/*! fs */ "?ec0a");
     }
     // Read file
-    var content = fs.readFileSync(file, "utf8");
+    const os = __webpack_require__(/*! os */ "?a32b");
+    file = helpers.expandTildePath(file, os);
+    const content = fs.readFileSync(file, "utf8");
     // Try to parse file
-    var _a = parseConfiguration(file, content, parsers), config = _a.config, message = _a.message;
+    const { config, message } = parseConfiguration(file, content, parsers);
     if (!config) {
         throw new Error(message);
     }
     // Extend configuration
-    var configExtends = config.extends;
+    const configExtends = config.extends;
     if (configExtends) {
         delete config.extends;
-        var resolvedExtends = resolveConfigExtendsSync(file, configExtends, fs);
-        return __assign(__assign({}, readConfigSync(resolvedExtends, parsers, fs)), config);
+        const resolvedExtends = resolveConfigExtendsSync(file, helpers.expandTildePath(configExtends, os), fs);
+        return Object.assign(Object.assign({}, readConfigSync(resolvedExtends, parsers, fs)), config);
     }
     return config;
 }
@@ -1965,15 +2280,15 @@ module.exports = markdownlint;
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorDetailIf = _a.addErrorDetailIf, filterTokens = _a.filterTokens;
+const { addErrorDetailIf, filterTokens } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD001", "heading-increment", "header-increment"],
     "description": "Heading levels should only increment by one level at a time",
     "tags": ["headings", "headers"],
     "function": function MD001(params, onError) {
-        var prevLevel = 0;
+        let prevLevel = 0;
         filterTokens(params, "heading_open", function forToken(token) {
-            var level = Number.parseInt(token.tag.slice(1), 10);
+            const level = Number.parseInt(token.tag.slice(1), 10);
             if (prevLevel && (level > prevLevel)) {
                 addErrorDetailIf(onError, token.lineNumber, "h" + (prevLevel + 1), "h" + level);
             }
@@ -1994,14 +2309,14 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var addErrorDetailIf = (__webpack_require__(/*! ../helpers */ "../helpers/helpers.js").addErrorDetailIf);
+const { addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD002", "first-heading-h1", "first-header-h1"],
     "description": "First heading should be a top-level heading",
     "tags": ["headings", "headers"],
     "function": function MD002(params, onError) {
-        var level = Number(params.config.level || 1);
-        var tag = "h" + level;
+        const level = Number(params.config.level || 1);
+        const tag = "h" + level;
         params.tokens.every(function forToken(token) {
             if (token.type === "heading_open") {
                 addErrorDetailIf(onError, token.lineNumber, tag, token.tag);
@@ -2024,28 +2339,28 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorDetailIf = _a.addErrorDetailIf, filterTokens = _a.filterTokens, headingStyleFor = _a.headingStyleFor;
+const { addErrorDetailIf, filterTokens, headingStyleFor } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD003", "heading-style", "header-style"],
     "description": "Heading style",
     "tags": ["headings", "headers"],
     "function": function MD003(params, onError) {
-        var style = String(params.config.style || "consistent");
+        let style = String(params.config.style || "consistent");
         filterTokens(params, "heading_open", function forToken(token) {
-            var styleForToken = headingStyleFor(token);
+            const styleForToken = headingStyleFor(token);
             if (style === "consistent") {
                 style = styleForToken;
             }
             if (styleForToken !== style) {
-                var h12 = /h[12]/.test(token.tag);
-                var setextWithAtx = (style === "setext_with_atx") &&
+                const h12 = /h[12]/.test(token.tag);
+                const setextWithAtx = (style === "setext_with_atx") &&
                     ((h12 && (styleForToken === "setext")) ||
                         (!h12 && (styleForToken === "atx")));
-                var setextWithAtxClosed = (style === "setext_with_atx_closed") &&
+                const setextWithAtxClosed = (style === "setext_with_atx_closed") &&
                     ((h12 && (styleForToken === "setext")) ||
                         (!h12 && (styleForToken === "atx_closed")));
                 if (!setextWithAtx && !setextWithAtxClosed) {
-                    var expected = style;
+                    let expected = style;
                     if (style === "setext_with_atx") {
                         expected = h12 ? "setext" : "atx";
                     }
@@ -2071,36 +2386,36 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorDetailIf = _a.addErrorDetailIf, listItemMarkerRe = _a.listItemMarkerRe, unorderedListStyleFor = _a.unorderedListStyleFor;
-var flattenedLists = (__webpack_require__(/*! ./cache */ "../lib/cache.js").flattenedLists);
-var expectedStyleToMarker = {
+const { addErrorDetailIf, listItemMarkerRe, unorderedListStyleFor } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { flattenedLists } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
+const expectedStyleToMarker = {
     "dash": "-",
     "plus": "+",
     "asterisk": "*"
 };
-var differentItemStyle = {
+const differentItemStyle = {
     "dash": "plus",
     "plus": "asterisk",
     "asterisk": "dash"
 };
-var validStyles = Object.keys(expectedStyleToMarker);
+const validStyles = Object.keys(expectedStyleToMarker);
 module.exports = {
     "names": ["MD004", "ul-style"],
     "description": "Unordered list style",
     "tags": ["bullet", "ul"],
     "function": function MD004(params, onError) {
-        var style = String(params.config.style || "consistent");
-        var expectedStyle = style;
-        var nestingStyles = [];
-        flattenedLists().forEach(function (list) {
+        const style = String(params.config.style || "consistent");
+        let expectedStyle = style;
+        const nestingStyles = [];
+        for (const list of flattenedLists()) {
             if (list.unordered) {
                 if (expectedStyle === "consistent") {
                     expectedStyle = unorderedListStyleFor(list.items[0]);
                 }
-                list.items.forEach(function (item) {
-                    var itemStyle = unorderedListStyleFor(item);
+                for (const item of list.items) {
+                    const itemStyle = unorderedListStyleFor(item);
                     if (style === "sublist") {
-                        var nesting = list.nesting;
+                        const nesting = list.nesting;
                         if (!nestingStyles[nesting]) {
                             nestingStyles[nesting] =
                                 (itemStyle === nestingStyles[nesting - 1]) ?
@@ -2112,12 +2427,12 @@ module.exports = {
                     if (!validStyles.includes(expectedStyle)) {
                         expectedStyle = validStyles[0];
                     }
-                    var range = null;
-                    var fixInfo = null;
-                    var match = item.line.match(listItemMarkerRe);
+                    let range = null;
+                    let fixInfo = null;
+                    const match = item.line.match(listItemMarkerRe);
                     if (match) {
-                        var column = match.index + 1;
-                        var length = match[0].length;
+                        const column = match.index + 1;
+                        const length = match[0].length;
                         range = [column, length];
                         fixInfo = {
                             "editColumn": match[1].length + 1,
@@ -2126,9 +2441,9 @@ module.exports = {
                         };
                     }
                     addErrorDetailIf(onError, item.lineNumber, expectedStyle, itemStyle, null, null, range, fixInfo);
-                });
+                }
             }
-        });
+        }
     }
 };
 
@@ -2144,22 +2459,22 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addError = _a.addError, addErrorDetailIf = _a.addErrorDetailIf, indentFor = _a.indentFor, listItemMarkerRe = _a.listItemMarkerRe, orderedListItemMarkerRe = _a.orderedListItemMarkerRe, rangeFromRegExp = _a.rangeFromRegExp;
-var flattenedLists = (__webpack_require__(/*! ./cache */ "../lib/cache.js").flattenedLists);
+const { addError, addErrorDetailIf, indentFor, listItemMarkerRe, orderedListItemMarkerRe, rangeFromRegExp } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { flattenedLists } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 module.exports = {
     "names": ["MD005", "list-indent"],
     "description": "Inconsistent indentation for list items at the same level",
     "tags": ["bullet", "ul", "indentation"],
     "function": function MD005(params, onError) {
-        flattenedLists().forEach(function (list) {
-            var expectedIndent = list.indent;
-            var expectedEnd = 0;
-            var actualEnd = -1;
-            var endMatching = false;
-            list.items.forEach(function (item) {
-                var line = item.line, lineNumber = item.lineNumber;
-                var actualIndent = indentFor(item);
-                var match = null;
+        for (const list of flattenedLists()) {
+            const expectedIndent = list.indent;
+            let expectedEnd = 0;
+            let actualEnd = -1;
+            let endMatching = false;
+            for (const item of list.items) {
+                const { line, lineNumber } = item;
+                const actualIndent = indentFor(item);
+                let match = null;
                 if (list.unordered) {
                     addErrorDetailIf(onError, lineNumber, expectedIndent, actualIndent, null, null, rangeFromRegExp(line, listItemMarkerRe)
                     // No fixInfo; MD007 handles this scenario better
@@ -2168,19 +2483,19 @@ module.exports = {
                 else if ((match = orderedListItemMarkerRe.exec(line))) {
                     actualEnd = match[0].length;
                     expectedEnd = expectedEnd || actualEnd;
-                    var markerLength = match[1].length + 1;
+                    const markerLength = match[1].length + 1;
                     if ((expectedIndent !== actualIndent) || endMatching) {
                         if (expectedEnd === actualEnd) {
                             endMatching = true;
                         }
                         else {
-                            var detail = endMatching ?
-                                "Expected: (".concat(expectedEnd, "); Actual: (").concat(actualEnd, ")") :
-                                "Expected: ".concat(expectedIndent, "; Actual: ").concat(actualIndent);
-                            var expected = endMatching ?
+                            const detail = endMatching ?
+                                `Expected: (${expectedEnd}); Actual: (${actualEnd})` :
+                                `Expected: ${expectedIndent}; Actual: ${actualIndent}`;
+                            const expected = endMatching ?
                                 expectedEnd - markerLength :
                                 expectedIndent;
-                            var actual = endMatching ?
+                            const actual = endMatching ?
                                 actualEnd - markerLength :
                                 actualIndent;
                             addError(onError, lineNumber, detail, null, rangeFromRegExp(line, listItemMarkerRe), {
@@ -2191,8 +2506,8 @@ module.exports = {
                         }
                     }
                 }
-            });
-        });
+            }
+        }
     }
 };
 
@@ -2208,23 +2523,23 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorDetailIf = _a.addErrorDetailIf, listItemMarkerRe = _a.listItemMarkerRe, rangeFromRegExp = _a.rangeFromRegExp;
-var flattenedLists = (__webpack_require__(/*! ./cache */ "../lib/cache.js").flattenedLists);
+const { addErrorDetailIf, listItemMarkerRe, rangeFromRegExp } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { flattenedLists } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 module.exports = {
     "names": ["MD006", "ul-start-left"],
     "description": "Consider starting bulleted lists at the beginning of the line",
     "tags": ["bullet", "ul", "indentation"],
     "function": function MD006(params, onError) {
-        flattenedLists().forEach(function (list) {
+        for (const list of flattenedLists()) {
             if (list.unordered && !list.nesting && (list.indent !== 0)) {
-                list.items.forEach(function (item) {
-                    var lineNumber = item.lineNumber, line = item.line;
+                for (const item of list.items) {
+                    const { lineNumber, line } = item;
                     addErrorDetailIf(onError, lineNumber, 0, list.indent, null, null, rangeFromRegExp(line, listItemMarkerRe), {
                         "deleteCount": line.length - line.trimStart().length
                     });
-                });
+                }
             }
-        });
+        }
     }
 };
 
@@ -2240,38 +2555,38 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorDetailIf = _a.addErrorDetailIf, indentFor = _a.indentFor, listItemMarkerRe = _a.listItemMarkerRe;
-var flattenedLists = (__webpack_require__(/*! ./cache */ "../lib/cache.js").flattenedLists);
+const { addErrorDetailIf, indentFor, listItemMarkerRe } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { flattenedLists } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 module.exports = {
     "names": ["MD007", "ul-indent"],
     "description": "Unordered list indentation",
     "tags": ["bullet", "ul", "indentation"],
     "function": function MD007(params, onError) {
-        var indent = Number(params.config.indent || 2);
-        var startIndented = !!params.config.start_indented;
-        var startIndent = Number(params.config.start_indent || indent);
-        flattenedLists().forEach(function (list) {
+        const indent = Number(params.config.indent || 2);
+        const startIndented = !!params.config.start_indented;
+        const startIndent = Number(params.config.start_indent || indent);
+        for (const list of flattenedLists()) {
             if (list.unordered && list.parentsUnordered) {
-                list.items.forEach(function (item) {
-                    var lineNumber = item.lineNumber, line = item.line;
-                    var expectedIndent = (startIndented ? startIndent : 0) +
+                for (const item of list.items) {
+                    const { lineNumber, line } = item;
+                    const expectedIndent = (startIndented ? startIndent : 0) +
                         (list.nesting * indent);
-                    var actualIndent = indentFor(item);
-                    var range = null;
-                    var editColumn = 1;
-                    var match = line.match(listItemMarkerRe);
+                    const actualIndent = indentFor(item);
+                    let range = null;
+                    let editColumn = 1;
+                    const match = line.match(listItemMarkerRe);
                     if (match) {
                         range = [1, match[0].length];
                         editColumn += match[1].length - actualIndent;
                     }
                     addErrorDetailIf(onError, lineNumber, expectedIndent, actualIndent, null, null, range, {
-                        editColumn: editColumn,
+                        editColumn,
                         "deleteCount": actualIndent,
                         "insertText": "".padEnd(expectedIndent)
                     });
-                });
+                }
             }
-        });
+        }
     }
 };
 
@@ -2287,52 +2602,59 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addError = _a.addError, filterTokens = _a.filterTokens, forEachInlineCodeSpan = _a.forEachInlineCodeSpan, forEachLine = _a.forEachLine, includesSorted = _a.includesSorted, newLineRe = _a.newLineRe, numericSortAscending = _a.numericSortAscending;
-var lineMetadata = (__webpack_require__(/*! ./cache */ "../lib/cache.js").lineMetadata);
+const { addError, filterTokens, forEachLine, includesSorted, numericSortAscending } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { lineMetadata } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 module.exports = {
     "names": ["MD009", "no-trailing-spaces"],
     "description": "Trailing spaces",
     "tags": ["whitespace"],
     "function": function MD009(params, onError) {
-        var brSpaces = params.config.br_spaces;
+        let brSpaces = params.config.br_spaces;
         brSpaces = Number((brSpaces === undefined) ? 2 : brSpaces);
-        var listItemEmptyLines = !!params.config.list_item_empty_lines;
-        var strict = !!params.config.strict;
-        var listItemLineNumbers = [];
+        const listItemEmptyLines = !!params.config.list_item_empty_lines;
+        const strict = !!params.config.strict;
+        const listItemLineNumbers = [];
         if (listItemEmptyLines) {
-            filterTokens(params, "list_item_open", function (token) {
-                for (var i = token.map[0]; i < token.map[1]; i++) {
+            filterTokens(params, "list_item_open", (token) => {
+                for (let i = token.map[0]; i < token.map[1]; i++) {
                     listItemLineNumbers.push(i + 1);
                 }
             });
             listItemLineNumbers.sort(numericSortAscending);
         }
-        var paragraphLineNumbers = [];
-        var codeInlineLineNumbers = [];
+        const paragraphLineNumbers = [];
+        const codeInlineLineNumbers = [];
         if (strict) {
-            filterTokens(params, "paragraph_open", function (token) {
-                for (var i = token.map[0]; i < token.map[1] - 1; i++) {
+            filterTokens(params, "paragraph_open", (token) => {
+                for (let i = token.map[0]; i < token.map[1] - 1; i++) {
                     paragraphLineNumbers.push(i + 1);
                 }
             });
-            paragraphLineNumbers.sort(numericSortAscending);
-            filterTokens(params, "inline", function (token) {
-                if (token.children.some(function (child) { return child.type === "code_inline"; })) {
-                    var tokenLines = params.lines.slice(token.map[0], token.map[1]);
-                    forEachInlineCodeSpan(tokenLines.join("\n"), function (code, lineIndex) {
-                        var codeLineCount = code.split(newLineRe).length;
-                        for (var i = 0; i < codeLineCount; i++) {
-                            codeInlineLineNumbers.push(token.lineNumber + lineIndex + i);
-                        }
-                    });
+            const addLineNumberRange = (start, end) => {
+                for (let i = start; i < end; i++) {
+                    codeInlineLineNumbers.push(i);
+                }
+            };
+            filterTokens(params, "inline", (token) => {
+                let start = 0;
+                for (const child of token.children) {
+                    if (start > 0) {
+                        addLineNumberRange(start, child.lineNumber);
+                        start = 0;
+                    }
+                    if (child.type === "code_inline") {
+                        start = child.lineNumber;
+                    }
+                }
+                if (start > 0) {
+                    addLineNumberRange(start, token.map[1]);
                 }
             });
-            codeInlineLineNumbers.sort(numericSortAscending);
         }
-        var expected = (brSpaces < 2) ? 0 : brSpaces;
-        forEachLine(lineMetadata(), function (line, lineIndex, inCode) {
-            var lineNumber = lineIndex + 1;
-            var trailingSpaces = line.length - line.trimEnd().length;
+        const expected = (brSpaces < 2) ? 0 : brSpaces;
+        forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
+            const lineNumber = lineIndex + 1;
+            const trailingSpaces = line.length - line.trimEnd().length;
             if (trailingSpaces &&
                 !inCode &&
                 !includesSorted(listItemLineNumbers, lineNumber) &&
@@ -2340,9 +2662,9 @@ module.exports = {
                     (strict &&
                         (!includesSorted(paragraphLineNumbers, lineNumber) ||
                             includesSorted(codeInlineLineNumbers, lineNumber))))) {
-                var column = line.length - trailingSpaces + 1;
+                const column = line.length - trailingSpaces + 1;
                 addError(onError, lineNumber, "Expected: " + (expected === 0 ? "" : "0 or ") +
-                    expected + "; Actual: " + trailingSpaces, null, [column, trailingSpaces], {
+                    expected + "; Actual: " + trailingSpaces, undefined, [column, trailingSpaces], {
                     "editColumn": column,
                     "deleteCount": trailingSpaces
                 });
@@ -2363,29 +2685,39 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addError = _a.addError, forEachLine = _a.forEachLine, overlapsAnyRange = _a.overlapsAnyRange;
-var _b = __webpack_require__(/*! ./cache */ "../lib/cache.js"), codeBlockAndSpanRanges = _b.codeBlockAndSpanRanges, lineMetadata = _b.lineMetadata;
-var tabRe = /\t+/g;
+const { addError, filterTokens, forEachLine, withinAnyRange } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { codeBlockAndSpanRanges, lineMetadata } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
+const tabRe = /\t+/g;
 module.exports = {
     "names": ["MD010", "no-hard-tabs"],
     "description": "Hard tabs",
     "tags": ["whitespace", "hard_tab"],
     "function": function MD010(params, onError) {
-        var codeBlocks = params.config.code_blocks;
-        var includeCode = (codeBlocks === undefined) ? true : !!codeBlocks;
-        var spacesPerTab = params.config.spaces_per_tab;
-        var spaceMultiplier = (spacesPerTab === undefined) ?
+        const codeBlocks = params.config.code_blocks;
+        const includeCode = (codeBlocks === undefined) ? true : !!codeBlocks;
+        const ignoreCodeLanguages = new Set((params.config.ignore_code_languages || [])
+            .map((language) => language.toLowerCase()));
+        const spacesPerTab = params.config.spaces_per_tab;
+        const spaceMultiplier = (spacesPerTab === undefined) ?
             1 :
             Math.max(0, Number(spacesPerTab));
-        var exclusions = includeCode ? [] : codeBlockAndSpanRanges();
-        forEachLine(lineMetadata(), function (line, lineIndex, inCode) {
+        const exclusions = includeCode ? [] : codeBlockAndSpanRanges();
+        filterTokens(params, "fence", (token) => {
+            const language = token.info.trim().toLowerCase();
+            if (ignoreCodeLanguages.has(language)) {
+                for (let i = token.map[0] + 1; i < token.map[1] - 1; i++) {
+                    exclusions.push([i, 0, params.lines[i].length]);
+                }
+            }
+        });
+        forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
             if (includeCode || !inCode) {
-                var match = null;
+                let match = null;
                 while ((match = tabRe.exec(line)) !== null) {
-                    var index = match.index;
-                    var column = index + 1;
-                    var length = match[0].length;
-                    if (!overlapsAnyRange(exclusions, lineIndex, index, length)) {
+                    const { index } = match;
+                    const column = index + 1;
+                    const length = match[0].length;
+                    if (!withinAnyRange(exclusions, lineIndex, index, length)) {
                         addError(onError, lineIndex + 1, "Column: " + column, null, [column, length], {
                             "editColumn": column,
                             "deleteCount": length,
@@ -2410,29 +2742,29 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addError = _a.addError, forEachLine = _a.forEachLine, overlapsAnyRange = _a.overlapsAnyRange;
-var _b = __webpack_require__(/*! ./cache */ "../lib/cache.js"), codeBlockAndSpanRanges = _b.codeBlockAndSpanRanges, lineMetadata = _b.lineMetadata;
-var reversedLinkRe = /(^|[^\\])\(([^)]+)\)\[([^\]^][^\]]*)](?!\()/g;
+const { addError, forEachLine, withinAnyRange } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { codeBlockAndSpanRanges, lineMetadata } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
+const reversedLinkRe = /(^|[^\\])\(([^)]+)\)\[([^\]^][^\]]*)](?!\()/g;
 module.exports = {
     "names": ["MD011", "no-reversed-links"],
     "description": "Reversed link syntax",
     "tags": ["links"],
     "function": function MD011(params, onError) {
-        var exclusions = codeBlockAndSpanRanges();
-        forEachLine(lineMetadata(), function (line, lineIndex, inCode, onFence) {
+        const exclusions = codeBlockAndSpanRanges();
+        forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence) => {
             if (!inCode && !onFence) {
-                var match = null;
+                let match = null;
                 while ((match = reversedLinkRe.exec(line)) !== null) {
-                    var reversedLink = match[0], preChar = match[1], linkText = match[2], linkDestination = match[3];
-                    var index = match.index + preChar.length;
-                    var length = match[0].length - preChar.length;
+                    const [reversedLink, preChar, linkText, linkDestination] = match;
+                    const index = match.index + preChar.length;
+                    const length = match[0].length - preChar.length;
                     if (!linkText.endsWith("\\") &&
                         !linkDestination.endsWith("\\") &&
-                        !overlapsAnyRange(exclusions, lineIndex, index, length)) {
+                        !withinAnyRange(exclusions, lineIndex, index, length)) {
                         addError(onError, lineIndex + 1, reversedLink.slice(preChar.length), null, [index + 1, length], {
                             "editColumn": index + 1,
                             "deleteCount": length,
-                            "insertText": "[".concat(linkText, "](").concat(linkDestination, ")")
+                            "insertText": `[${linkText}](${linkDestination})`
                         });
                     }
                 }
@@ -2453,16 +2785,16 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorDetailIf = _a.addErrorDetailIf, forEachLine = _a.forEachLine;
-var lineMetadata = (__webpack_require__(/*! ./cache */ "../lib/cache.js").lineMetadata);
+const { addErrorDetailIf, forEachLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { lineMetadata } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 module.exports = {
     "names": ["MD012", "no-multiple-blanks"],
     "description": "Multiple consecutive blank lines",
     "tags": ["whitespace", "blank_lines"],
     "function": function MD012(params, onError) {
-        var maximum = Number(params.config.maximum || 1);
-        var count = 0;
-        forEachLine(lineMetadata(), function (line, lineIndex, inCode) {
+        const maximum = Number(params.config.maximum || 1);
+        let count = 0;
+        forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
             count = (inCode || (line.trim().length > 0)) ? 0 : count + 1;
             if (maximum < count) {
                 addErrorDetailIf(onError, lineIndex + 1, maximum, count, null, null, null, {
@@ -2485,15 +2817,14 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorDetailIf = _a.addErrorDetailIf, filterTokens = _a.filterTokens, forEachHeading = _a.forEachHeading, forEachLine = _a.forEachLine, includesSorted = _a.includesSorted;
-var lineMetadata = (__webpack_require__(/*! ./cache */ "../lib/cache.js").lineMetadata);
-var longLineRePrefix = "^.{";
-var longLineRePostfixRelaxed = "}.*\\s.*$";
-var longLineRePostfixStrict = "}.+$";
-var labelRe = /^\s*\[.*[^\\]]:/;
-var linkOrImageOnlyLineRe = /^[es]*(lT?L|I)[ES]*$/;
-var sternModeRe = /^([#>\s]*\s)?\S*$/;
-var tokenTypeMap = {
+const { addErrorDetailIf, filterTokens, forEachHeading, forEachLine, includesSorted, linkReferenceDefinitionRe } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { lineMetadata } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
+const longLineRePrefix = "^.{";
+const longLineRePostfixRelaxed = "}.*\\s.*$";
+const longLineRePostfixStrict = "}.+$";
+const linkOrImageOnlyLineRe = /^[es]*(lT?L|I)[ES]*$/;
+const sternModeRe = /^([#>\s]*\s)?\S*$/;
+const tokenTypeMap = {
     "em_open": "e",
     "em_close": "E",
     "image": "I",
@@ -2508,47 +2839,47 @@ module.exports = {
     "description": "Line length",
     "tags": ["line_length"],
     "function": function MD013(params, onError) {
-        var lineLength = Number(params.config.line_length || 80);
-        var headingLineLength = Number(params.config.heading_line_length || lineLength);
-        var codeLineLength = Number(params.config.code_block_line_length || lineLength);
-        var strict = !!params.config.strict;
-        var stern = !!params.config.stern;
-        var longLineRePostfix = (strict || stern) ? longLineRePostfixStrict : longLineRePostfixRelaxed;
-        var longLineRe = new RegExp(longLineRePrefix + lineLength + longLineRePostfix);
-        var longHeadingLineRe = new RegExp(longLineRePrefix + headingLineLength + longLineRePostfix);
-        var longCodeLineRe = new RegExp(longLineRePrefix + codeLineLength + longLineRePostfix);
-        var codeBlocks = params.config.code_blocks;
-        var includeCodeBlocks = (codeBlocks === undefined) ? true : !!codeBlocks;
-        var tables = params.config.tables;
-        var includeTables = (tables === undefined) ? true : !!tables;
-        var headings = params.config.headings;
+        const lineLength = Number(params.config.line_length || 80);
+        const headingLineLength = Number(params.config.heading_line_length || lineLength);
+        const codeLineLength = Number(params.config.code_block_line_length || lineLength);
+        const strict = !!params.config.strict;
+        const stern = !!params.config.stern;
+        const longLineRePostfix = (strict || stern) ? longLineRePostfixStrict : longLineRePostfixRelaxed;
+        const longLineRe = new RegExp(longLineRePrefix + lineLength + longLineRePostfix);
+        const longHeadingLineRe = new RegExp(longLineRePrefix + headingLineLength + longLineRePostfix);
+        const longCodeLineRe = new RegExp(longLineRePrefix + codeLineLength + longLineRePostfix);
+        const codeBlocks = params.config.code_blocks;
+        const includeCodeBlocks = (codeBlocks === undefined) ? true : !!codeBlocks;
+        const tables = params.config.tables;
+        const includeTables = (tables === undefined) ? true : !!tables;
+        let headings = params.config.headings;
         if (headings === undefined) {
             headings = params.config.headers;
         }
-        var includeHeadings = (headings === undefined) ? true : !!headings;
-        var headingLineNumbers = [];
-        forEachHeading(params, function (heading) {
+        const includeHeadings = (headings === undefined) ? true : !!headings;
+        const headingLineNumbers = [];
+        forEachHeading(params, (heading) => {
             headingLineNumbers.push(heading.lineNumber);
         });
-        var linkOnlyLineNumbers = [];
-        filterTokens(params, "inline", function (token) {
-            var childTokenTypes = "";
-            token.children.forEach(function (child) {
+        const linkOnlyLineNumbers = [];
+        filterTokens(params, "inline", (token) => {
+            let childTokenTypes = "";
+            for (const child of token.children) {
                 if (child.type !== "text" || child.content !== "") {
                     childTokenTypes += tokenTypeMap[child.type] || "x";
                 }
-            });
+            }
             if (linkOrImageOnlyLineRe.test(childTokenTypes)) {
                 linkOnlyLineNumbers.push(token.lineNumber);
             }
         });
-        forEachLine(lineMetadata(), function (line, lineIndex, inCode, onFence, inTable) {
-            var lineNumber = lineIndex + 1;
-            var isHeading = includesSorted(headingLineNumbers, lineNumber);
-            var length = inCode ?
+        forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence, inTable) => {
+            const lineNumber = lineIndex + 1;
+            const isHeading = includesSorted(headingLineNumbers, lineNumber);
+            const length = inCode ?
                 codeLineLength :
                 (isHeading ? headingLineLength : lineLength);
-            var lengthRe = inCode ?
+            const lengthRe = inCode ?
                 longCodeLineRe :
                 (isHeading ? longHeadingLineRe : longLineRe);
             if ((includeCodeBlocks || !inCode) &&
@@ -2557,7 +2888,7 @@ module.exports = {
                 (strict ||
                     (!(stern && sternModeRe.test(line)) &&
                         !includesSorted(linkOnlyLineNumbers, lineNumber) &&
-                        !labelRe.test(line))) &&
+                        !linkReferenceDefinitionRe.test(line))) &&
                 lengthRe.test(line)) {
                 addErrorDetailIf(onError, lineNumber, length, line.length, null, null, [length + 1, line.length - length]);
             }
@@ -2577,26 +2908,26 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, filterTokens = _a.filterTokens;
-var dollarCommandRe = /^(\s*)(\$\s+)/;
+const { addErrorContext, filterTokens } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const dollarCommandRe = /^(\s*)(\$\s+)/;
 module.exports = {
     "names": ["MD014", "commands-show-output"],
     "description": "Dollar signs used before commands without showing output",
     "tags": ["code"],
     "function": function MD014(params, onError) {
-        ["code_block", "fence"].forEach(function (type) {
-            filterTokens(params, type, function (token) {
-                var margin = (token.type === "fence") ? 1 : 0;
-                var dollarInstances = [];
-                var allDollars = true;
-                for (var i = token.map[0] + margin; i < token.map[1] - margin; i++) {
-                    var line = params.lines[i];
-                    var lineTrim = line.trim();
+        for (const type of ["code_block", "fence"]) {
+            filterTokens(params, type, (token) => {
+                const margin = (token.type === "fence") ? 1 : 0;
+                const dollarInstances = [];
+                let allDollars = true;
+                for (let i = token.map[0] + margin; i < token.map[1] - margin; i++) {
+                    const line = params.lines[i];
+                    const lineTrim = line.trim();
                     if (lineTrim) {
-                        var match = dollarCommandRe.exec(line);
+                        const match = dollarCommandRe.exec(line);
                         if (match) {
-                            var column = match[1].length + 1;
-                            var length = match[2].length;
+                            const column = match[1].length + 1;
+                            const length = match[2].length;
                             dollarInstances.push([i, lineTrim, column, length]);
                         }
                         else {
@@ -2605,16 +2936,16 @@ module.exports = {
                     }
                 }
                 if (allDollars) {
-                    dollarInstances.forEach(function (instance) {
-                        var i = instance[0], lineTrim = instance[1], column = instance[2], length = instance[3];
+                    for (const instance of dollarInstances) {
+                        const [i, lineTrim, column, length] = instance;
                         addErrorContext(onError, i + 1, lineTrim, null, null, [column, length], {
                             "editColumn": column,
                             "deleteCount": length
                         });
-                    });
+                    }
                 }
             });
-        });
+        }
     }
 };
 
@@ -2630,19 +2961,19 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, forEachLine = _a.forEachLine;
-var lineMetadata = (__webpack_require__(/*! ./cache */ "../lib/cache.js").lineMetadata);
+const { addErrorContext, forEachLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { lineMetadata } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 module.exports = {
     "names": ["MD018", "no-missing-space-atx"],
     "description": "No space after hash on atx style heading",
     "tags": ["headings", "headers", "atx", "spaces"],
     "function": function MD018(params, onError) {
-        forEachLine(lineMetadata(), function (line, lineIndex, inCode) {
+        forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
             if (!inCode &&
                 /^#+[^# \t]/.test(line) &&
                 !/#\s*$/.test(line) &&
                 !line.startsWith("#️⃣")) {
-                var hashCount = /^#+/.exec(line)[0].length;
+                const hashCount = /^#+/.exec(line)[0].length;
                 addErrorContext(onError, lineIndex + 1, line.trim(), null, null, [1, hashCount + 1], {
                     "editColumn": hashCount + 1,
                     "insertText": " "
@@ -2664,18 +2995,18 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, filterTokens = _a.filterTokens, headingStyleFor = _a.headingStyleFor;
+const { addErrorContext, filterTokens, headingStyleFor } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD019", "no-multiple-space-atx"],
     "description": "Multiple spaces after hash on atx style heading",
     "tags": ["headings", "headers", "atx", "spaces"],
     "function": function MD019(params, onError) {
-        filterTokens(params, "heading_open", function (token) {
+        filterTokens(params, "heading_open", (token) => {
             if (headingStyleFor(token) === "atx") {
-                var line = token.line, lineNumber = token.lineNumber;
-                var match = /^(#+)([ \t]{2,})(?:\S)/.exec(line);
+                const { line, lineNumber } = token;
+                const match = /^(#+)([ \t]{2,})(?:\S)/.exec(line);
                 if (match) {
-                    var hashLength = match[1]["length"], spacesLength = match[2]["length"];
+                    const [, { "length": hashLength }, { "length": spacesLength }] = match;
                     addErrorContext(onError, lineNumber, line.trim(), null, null, [1, hashLength + spacesLength + 1], {
                         "editColumn": hashLength + 1,
                         "deleteCount": spacesLength - 1
@@ -2698,25 +3029,25 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, forEachLine = _a.forEachLine;
-var lineMetadata = (__webpack_require__(/*! ./cache */ "../lib/cache.js").lineMetadata);
+const { addErrorContext, forEachLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { lineMetadata } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 module.exports = {
     "names": ["MD020", "no-missing-space-closed-atx"],
     "description": "No space inside hashes on closed atx style heading",
     "tags": ["headings", "headers", "atx_closed", "spaces"],
     "function": function MD020(params, onError) {
-        forEachLine(lineMetadata(), function (line, lineIndex, inCode) {
+        forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
             if (!inCode) {
-                var match = /^(#+)([ \t]*)([^#]*?[^#\\])([ \t]*)((?:\\#)?)(#+)(\s*)$/.exec(line);
+                const match = /^(#+)([ \t]*)([^#]*?[^#\\])([ \t]*)((?:\\#)?)(#+)(\s*)$/.exec(line);
                 if (match) {
-                    var leftHash = match[1], leftSpaceLength = match[2]["length"], content = match[3], rightSpaceLength = match[4]["length"], rightEscape = match[5], rightHash = match[6], trailSpaceLength = match[7]["length"];
-                    var leftHashLength = leftHash.length;
-                    var rightHashLength = rightHash.length;
-                    var left = !leftSpaceLength;
-                    var right = !rightSpaceLength || rightEscape;
-                    var rightEscapeReplacement = rightEscape ? "".concat(rightEscape, " ") : "";
+                    const [, leftHash, { "length": leftSpaceLength }, content, { "length": rightSpaceLength }, rightEscape, rightHash, { "length": trailSpaceLength }] = match;
+                    const leftHashLength = leftHash.length;
+                    const rightHashLength = rightHash.length;
+                    const left = !leftSpaceLength;
+                    const right = !rightSpaceLength || rightEscape;
+                    const rightEscapeReplacement = rightEscape ? `${rightEscape} ` : "";
                     if (left || right) {
-                        var range = left ?
+                        const range = left ?
                             [
                                 1,
                                 leftHashLength + 1
@@ -2728,7 +3059,7 @@ module.exports = {
                         addErrorContext(onError, lineIndex + 1, line.trim(), left, right, range, {
                             "editColumn": 1,
                             "deleteCount": line.length,
-                            "insertText": "".concat(leftHash, " ").concat(content, " ").concat(rightEscapeReplacement).concat(rightHash)
+                            "insertText": `${leftHash} ${content} ${rightEscapeReplacement}${rightHash}`
                         });
                     }
                 }
@@ -2749,25 +3080,26 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, filterTokens = _a.filterTokens, headingStyleFor = _a.headingStyleFor;
+const { addErrorContext, filterTokens, headingStyleFor } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const closedAtxRe = /^(#+)([ \t]+)([^ \t]|[^ \t].*[^ \t])([ \t]+)(#+)(\s*)$/;
 module.exports = {
     "names": ["MD021", "no-multiple-space-closed-atx"],
     "description": "Multiple spaces inside hashes on closed atx style heading",
     "tags": ["headings", "headers", "atx_closed", "spaces"],
     "function": function MD021(params, onError) {
-        filterTokens(params, "heading_open", function (token) {
+        filterTokens(params, "heading_open", (token) => {
             if (headingStyleFor(token) === "atx_closed") {
-                var line = token.line, lineNumber = token.lineNumber;
-                var match = /^(#+)([ \t]+)([^#]+?)([ \t]+)(#+)(\s*)$/.exec(line);
+                const { line, lineNumber } = token;
+                const match = closedAtxRe.exec(line);
                 if (match) {
-                    var leftHash = match[1], leftSpaceLength = match[2]["length"], content = match[3], rightSpaceLength = match[4]["length"], rightHash = match[5], trailSpaceLength = match[6]["length"];
-                    var left = leftSpaceLength > 1;
-                    var right = rightSpaceLength > 1;
+                    const [, leftHash, { "length": leftSpaceLength }, content, { "length": rightSpaceLength }, rightHash, { "length": trailSpaceLength }] = match;
+                    const left = leftSpaceLength > 1;
+                    const right = rightSpaceLength > 1;
                     if (left || right) {
-                        var length = line.length;
-                        var leftHashLength = leftHash.length;
-                        var rightHashLength = rightHash.length;
-                        var range = left ?
+                        const length = line.length;
+                        const leftHashLength = leftHash.length;
+                        const rightHashLength = rightHash.length;
+                        const range = left ?
                             [
                                 1,
                                 leftHashLength + leftSpaceLength + 1
@@ -2779,7 +3111,7 @@ module.exports = {
                         addErrorContext(onError, lineNumber, line.trim(), left, right, range, {
                             "editColumn": 1,
                             "deleteCount": length,
-                            "insertText": "".concat(leftHash, " ").concat(content, " ").concat(rightHash)
+                            "insertText": `${leftHash} ${content} ${rightHash}`
                         });
                     }
                 }
@@ -2800,21 +3132,21 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorDetailIf = _a.addErrorDetailIf, filterTokens = _a.filterTokens, isBlankLine = _a.isBlankLine;
+const { addErrorDetailIf, filterTokens, isBlankLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD022", "blanks-around-headings", "blanks-around-headers"],
     "description": "Headings should be surrounded by blank lines",
     "tags": ["headings", "headers", "blank_lines"],
     "function": function MD022(params, onError) {
-        var linesAbove = params.config.lines_above;
+        let linesAbove = params.config.lines_above;
         linesAbove = Number((linesAbove === undefined) ? 1 : linesAbove);
-        var linesBelow = params.config.lines_below;
+        let linesBelow = params.config.lines_below;
         linesBelow = Number((linesBelow === undefined) ? 1 : linesBelow);
-        var lines = params.lines;
-        filterTokens(params, "heading_open", function (token) {
-            var _a = token.map, topIndex = _a[0], nextIndex = _a[1];
-            var actualAbove = 0;
-            for (var i = 0; i < linesAbove; i++) {
+        const { lines } = params;
+        filterTokens(params, "heading_open", (token) => {
+            const [topIndex, nextIndex] = token.map;
+            let actualAbove = 0;
+            for (let i = 0; i < linesAbove; i++) {
                 if (isBlankLine(lines[topIndex - i - 1])) {
                     actualAbove++;
                 }
@@ -2822,8 +3154,8 @@ module.exports = {
             addErrorDetailIf(onError, topIndex + 1, linesAbove, actualAbove, "Above", lines[topIndex].trim(), null, {
                 "insertText": "".padEnd(linesAbove - actualAbove, "\n")
             });
-            var actualBelow = 0;
-            for (var i = 0; i < linesBelow; i++) {
+            let actualBelow = 0;
+            for (let i = 0; i < linesBelow; i++) {
                 if (isBlankLine(lines[nextIndex + i])) {
                     actualBelow++;
                 }
@@ -2848,20 +3180,20 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, filterTokens = _a.filterTokens;
-var spaceBeforeHeadingRe = /^((?:\s+)|(?:[>\s]+\s\s))[^>\s]/;
+const { addErrorContext, filterTokens } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const spaceBeforeHeadingRe = /^((?:\s+)|(?:[>\s]+\s\s))[^>\s]/;
 module.exports = {
     "names": ["MD023", "heading-start-left", "header-start-left"],
     "description": "Headings must start at the beginning of the line",
     "tags": ["headings", "headers", "spaces"],
     "function": function MD023(params, onError) {
         filterTokens(params, "heading_open", function forToken(token) {
-            var lineNumber = token.lineNumber, line = token.line;
-            var match = line.match(spaceBeforeHeadingRe);
+            const { lineNumber, line } = token;
+            const match = line.match(spaceBeforeHeadingRe);
             if (match) {
-                var prefixAndFirstChar = match[0], prefix = match[1];
-                var deleteCount = prefix.length;
-                var prefixLengthNoSpace = prefix.trimEnd().length;
+                const [prefixAndFirstChar, prefix] = match;
+                let deleteCount = prefix.length;
+                const prefixLengthNoSpace = prefix.trimEnd().length;
                 if (prefixLengthNoSpace) {
                     deleteCount -= prefixLengthNoSpace - 1;
                 }
@@ -2886,20 +3218,20 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, forEachHeading = _a.forEachHeading;
+const { addErrorContext, forEachHeading } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD024", "no-duplicate-heading", "no-duplicate-header"],
     "description": "Multiple headings with the same content",
     "tags": ["headings", "headers"],
     "function": function MD024(params, onError) {
-        var siblingsOnly = !!params.config.siblings_only ||
+        const siblingsOnly = !!params.config.siblings_only ||
             !!params.config.allow_different_nesting || false;
-        var knownContents = [null, []];
-        var lastLevel = 1;
-        var knownContent = knownContents[lastLevel];
-        forEachHeading(params, function (heading, content) {
+        const knownContents = [null, []];
+        let lastLevel = 1;
+        let knownContent = knownContents[lastLevel];
+        forEachHeading(params, (heading, content) => {
             if (siblingsOnly) {
-                var newLevel = heading.tag.slice(1);
+                const newLevel = heading.tag.slice(1);
                 while (lastLevel < newLevel) {
                     lastLevel++;
                     knownContents[lastLevel] = [];
@@ -2932,16 +3264,16 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, filterTokens = _a.filterTokens, frontMatterHasTitle = _a.frontMatterHasTitle;
+const { addErrorContext, filterTokens, frontMatterHasTitle } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD025", "single-title", "single-h1"],
     "description": "Multiple top-level headings in the same document",
     "tags": ["headings", "headers"],
     "function": function MD025(params, onError) {
-        var level = Number(params.config.level || 1);
-        var tag = "h" + level;
-        var foundFrontMatterTitle = frontMatterHasTitle(params.frontMatterLines, params.config.front_matter_title);
-        var hasTopLevelHeading = false;
+        const level = Number(params.config.level || 1);
+        const tag = "h" + level;
+        const foundFrontMatterTitle = frontMatterHasTitle(params.frontMatterLines, params.config.front_matter_title);
+        let hasTopLevelHeading = false;
         filterTokens(params, "heading_open", function forToken(token) {
             if (token.tag === tag) {
                 if (hasTopLevelHeading || foundFrontMatterTitle) {
@@ -2967,25 +3299,25 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addError = _a.addError, allPunctuationNoQuestion = _a.allPunctuationNoQuestion, escapeForRegExp = _a.escapeForRegExp, forEachHeading = _a.forEachHeading;
-var endOfLineHtmlEntityRe = /&#?[0-9a-zA-Z]+;$/;
+const { addError, allPunctuationNoQuestion, escapeForRegExp, forEachHeading } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const endOfLineHtmlEntityRe = /&#?[0-9a-zA-Z]+;$/;
 module.exports = {
     "names": ["MD026", "no-trailing-punctuation"],
     "description": "Trailing punctuation in heading",
     "tags": ["headings", "headers"],
     "function": function MD026(params, onError) {
-        var punctuation = params.config.punctuation;
+        let punctuation = params.config.punctuation;
         punctuation = String((punctuation === undefined) ? allPunctuationNoQuestion : punctuation);
-        var trailingPunctuationRe = new RegExp("\\s*[" + escapeForRegExp(punctuation) + "]+$");
-        forEachHeading(params, function (heading) {
-            var line = heading.line, lineNumber = heading.lineNumber;
-            var trimmedLine = line.replace(/[\s#]*$/, "");
-            var match = trailingPunctuationRe.exec(trimmedLine);
+        const trailingPunctuationRe = new RegExp("\\s*[" + escapeForRegExp(punctuation) + "]+$");
+        forEachHeading(params, (heading) => {
+            const { line, lineNumber } = heading;
+            const trimmedLine = line.replace(/([^\s#])[\s#]+$/, "$1");
+            const match = trailingPunctuationRe.exec(trimmedLine);
             if (match && !endOfLineHtmlEntityRe.test(trimmedLine)) {
-                var fullMatch = match[0];
-                var column = match.index + 1;
-                var length = fullMatch.length;
-                addError(onError, lineNumber, "Punctuation: '".concat(fullMatch, "'"), null, [column, length], {
+                const fullMatch = match[0];
+                const column = match.index + 1;
+                const length = fullMatch.length;
+                addError(onError, lineNumber, `Punctuation: '${fullMatch}'`, null, [column, length], {
                     "editColumn": column,
                     "deleteCount": length
                 });
@@ -3006,17 +3338,17 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, newLineRe = _a.newLineRe;
-var spaceAfterBlockQuoteRe = /^((?:\s*>)+)(\s{2,})\S/;
+const { addErrorContext, newLineRe } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const spaceAfterBlockQuoteRe = /^((?:\s*>)+)(\s{2,})\S/;
 module.exports = {
     "names": ["MD027", "no-multiple-space-blockquote"],
     "description": "Multiple spaces after blockquote symbol",
     "tags": ["blockquote", "whitespace", "indentation"],
     "function": function MD027(params, onError) {
-        var blockquoteNesting = 0;
-        var listItemNesting = 0;
-        params.tokens.forEach(function (token) {
-            var content = token.content, lineNumber = token.lineNumber, type = token.type;
+        let blockquoteNesting = 0;
+        let listItemNesting = 0;
+        for (const token of params.tokens) {
+            const { content, lineNumber, type } = token;
             if (type === "blockquote_open") {
                 blockquoteNesting++;
             }
@@ -3030,12 +3362,12 @@ module.exports = {
                 listItemNesting--;
             }
             else if ((type === "inline") && blockquoteNesting) {
-                var lineCount = content.split(newLineRe).length;
-                for (var i = 0; i < lineCount; i++) {
-                    var line = params.lines[lineNumber + i - 1];
-                    var match = line.match(spaceAfterBlockQuoteRe);
+                const lineCount = content.split(newLineRe).length;
+                for (let i = 0; i < lineCount; i++) {
+                    const line = params.lines[lineNumber + i - 1];
+                    const match = line.match(spaceAfterBlockQuoteRe);
                     if (match) {
-                        var fullMatch = match[0], blockquoteLength = match[1]["length"], spaceLength = match[2]["length"];
+                        const [fullMatch, { "length": blockquoteLength }, { "length": spaceLength }] = match;
                         if (!listItemNesting || (fullMatch[fullMatch.length - 1] === ">")) {
                             addErrorContext(onError, lineNumber + i, line, null, null, [1, fullMatch.length], {
                                 "editColumn": blockquoteLength + 1,
@@ -3045,7 +3377,7 @@ module.exports = {
                     }
                 }
             }
-        });
+        }
     }
 };
 
@@ -3061,18 +3393,18 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var addError = (__webpack_require__(/*! ../helpers */ "../helpers/helpers.js").addError);
+const { addError } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD028", "no-blanks-blockquote"],
     "description": "Blank line inside blockquote",
     "tags": ["blockquote", "whitespace"],
     "function": function MD028(params, onError) {
-        var prevToken = {};
-        var prevLineNumber = null;
-        params.tokens.forEach(function forToken(token) {
+        let prevToken = {};
+        let prevLineNumber = null;
+        for (const token of params.tokens) {
             if ((token.type === "blockquote_open") &&
                 (prevToken.type === "blockquote_close")) {
-                for (var lineNumber = prevLineNumber; lineNumber < token.lineNumber; lineNumber++) {
+                for (let lineNumber = prevLineNumber; lineNumber < token.lineNumber; lineNumber++) {
                     addError(onError, lineNumber);
                 }
             }
@@ -3080,7 +3412,7 @@ module.exports = {
             if (token.type === "blockquote_open") {
                 prevLineNumber = token.map[1] + 1;
             }
-        });
+        }
     }
 };
 
@@ -3096,9 +3428,9 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorDetailIf = _a.addErrorDetailIf, listItemMarkerRe = _a.listItemMarkerRe, orderedListItemMarkerRe = _a.orderedListItemMarkerRe, rangeFromRegExp = _a.rangeFromRegExp;
-var flattenedLists = (__webpack_require__(/*! ./cache */ "../lib/cache.js").flattenedLists);
-var listStyleExamples = {
+const { addErrorDetailIf, listItemMarkerRe, orderedListItemMarkerRe, rangeFromRegExp } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { flattenedLists } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
+const listStyleExamples = {
     "one": "1/1/1",
     "ordered": "1/2/3",
     "zero": "0/0/0"
@@ -3108,18 +3440,19 @@ module.exports = {
     "description": "Ordered list item prefix",
     "tags": ["ol"],
     "function": function MD029(params, onError) {
-        var style = String(params.config.style || "one_or_ordered");
-        flattenedLists().filter(function (list) { return !list.unordered; }).forEach(function (list) {
-            var items = list.items;
-            var current = 1;
-            var incrementing = false;
+        const style = String(params.config.style || "one_or_ordered");
+        const filteredLists = flattenedLists().filter((list) => !list.unordered);
+        for (const list of filteredLists) {
+            const { items } = list;
+            let current = 1;
+            let incrementing = false;
             // Check for incrementing number pattern 1/2/3 or 0/1/2
             if (items.length >= 2) {
-                var first = orderedListItemMarkerRe.exec(items[0].line);
-                var second = orderedListItemMarkerRe.exec(items[1].line);
+                const first = orderedListItemMarkerRe.exec(items[0].line);
+                const second = orderedListItemMarkerRe.exec(items[1].line);
                 if (first && second) {
-                    var firstNumber = first[1];
-                    var secondNumber = second[1];
+                    const [, firstNumber] = first;
+                    const [, secondNumber] = second;
                     if ((secondNumber !== "1") || (firstNumber === "0")) {
                         incrementing = true;
                         if (firstNumber === "0") {
@@ -3129,7 +3462,7 @@ module.exports = {
                 }
             }
             // Determine effective style
-            var listStyle = style;
+            let listStyle = style;
             if (listStyle === "one_or_ordered") {
                 listStyle = incrementing ? "ordered" : "one";
             }
@@ -3141,16 +3474,16 @@ module.exports = {
                 current = 1;
             }
             // Validate each list item marker
-            items.forEach(function (item) {
-                var match = orderedListItemMarkerRe.exec(item.line);
+            for (const item of items) {
+                const match = orderedListItemMarkerRe.exec(item.line);
                 if (match) {
                     addErrorDetailIf(onError, item.lineNumber, String(current), match[1], "Style: " + listStyleExamples[listStyle], null, rangeFromRegExp(item.line, listItemMarkerRe));
                     if (listStyle === "ordered") {
                         current++;
                     }
                 }
-            });
-        });
+            }
+        }
     }
 };
 
@@ -3166,29 +3499,29 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var addErrorDetailIf = (__webpack_require__(/*! ../helpers */ "../helpers/helpers.js").addErrorDetailIf);
-var flattenedLists = (__webpack_require__(/*! ./cache */ "../lib/cache.js").flattenedLists);
+const { addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { flattenedLists } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 module.exports = {
     "names": ["MD030", "list-marker-space"],
     "description": "Spaces after list markers",
     "tags": ["ol", "ul", "whitespace"],
     "function": function MD030(params, onError) {
-        var ulSingle = Number(params.config.ul_single || 1);
-        var olSingle = Number(params.config.ol_single || 1);
-        var ulMulti = Number(params.config.ul_multi || 1);
-        var olMulti = Number(params.config.ol_multi || 1);
-        flattenedLists().forEach(function (list) {
-            var lineCount = list.lastLineIndex - list.open.map[0];
-            var allSingle = lineCount === list.items.length;
-            var expectedSpaces = list.unordered ?
+        const ulSingle = Number(params.config.ul_single || 1);
+        const olSingle = Number(params.config.ol_single || 1);
+        const ulMulti = Number(params.config.ul_multi || 1);
+        const olMulti = Number(params.config.ol_multi || 1);
+        for (const list of flattenedLists()) {
+            const lineCount = list.lastLineIndex - list.open.map[0];
+            const allSingle = lineCount === list.items.length;
+            const expectedSpaces = list.unordered ?
                 (allSingle ? ulSingle : ulMulti) :
                 (allSingle ? olSingle : olMulti);
-            list.items.forEach(function (item) {
-                var line = item.line, lineNumber = item.lineNumber;
-                var match = /^[\s>]*\S+(\s*)/.exec(line);
-                var matchLength = match[0]["length"], actualSpaces = match[1]["length"];
+            for (const item of list.items) {
+                const { line, lineNumber } = item;
+                const match = /^[\s>]*\S+(\s*)/.exec(line);
+                const [{ "length": matchLength }, { "length": actualSpaces }] = match;
                 if (matchLength < line.length) {
-                    var fixInfo = null;
+                    let fixInfo = null;
                     if (expectedSpaces !== actualSpaces) {
                         fixInfo = {
                             "editColumn": matchLength - actualSpaces + 1,
@@ -3198,8 +3531,8 @@ module.exports = {
                     }
                     addErrorDetailIf(onError, lineNumber, expectedSpaces, actualSpaces, null, null, [1, matchLength], fixInfo);
                 }
-            });
-        });
+            }
+        }
     }
 };
 
@@ -3215,27 +3548,27 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, forEachLine = _a.forEachLine, isBlankLine = _a.isBlankLine;
-var lineMetadata = (__webpack_require__(/*! ./cache */ "../lib/cache.js").lineMetadata);
-var codeFencePrefixRe = /^(.*?)\s*[`~]/;
+const { addErrorContext, forEachLine, isBlankLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { lineMetadata } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
+const codeFencePrefixRe = /^(.*?)[`~]/;
 module.exports = {
     "names": ["MD031", "blanks-around-fences"],
     "description": "Fenced code blocks should be surrounded by blank lines",
     "tags": ["code", "blank_lines"],
     "function": function MD031(params, onError) {
-        var listItems = params.config.list_items;
-        var includeListItems = (listItems === undefined) ? true : !!listItems;
-        var lines = params.lines;
-        forEachLine(lineMetadata(), function (line, i, inCode, onFence, inTable, inItem) {
-            var onTopFence = (onFence > 0);
-            var onBottomFence = (onFence < 0);
+        const listItems = params.config.list_items;
+        const includeListItems = (listItems === undefined) ? true : !!listItems;
+        const { lines } = params;
+        forEachLine(lineMetadata(), (line, i, inCode, onFence, inTable, inItem) => {
+            const onTopFence = (onFence > 0);
+            const onBottomFence = (onFence < 0);
             if ((includeListItems || !inItem) &&
                 ((onTopFence && !isBlankLine(lines[i - 1])) ||
                     (onBottomFence && !isBlankLine(lines[i + 1])))) {
-                var _a = line.match(codeFencePrefixRe) || [], prefix = _a[1];
-                var fixInfo = (prefix === undefined) ? null : {
+                const [, prefix] = line.match(codeFencePrefixRe) || [];
+                const fixInfo = (prefix === undefined) ? null : {
                     "lineNumber": i + (onTopFence ? 1 : 2),
-                    "insertText": "".concat(prefix, "\n")
+                    "insertText": `${prefix.replace(/[^>]/g, " ").trim()}\n`
                 };
                 addErrorContext(onError, i + 1, lines[i].trim(), null, null, null, fixInfo);
             }
@@ -3255,34 +3588,35 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, isBlankLine = _a.isBlankLine;
-var flattenedLists = (__webpack_require__(/*! ./cache */ "../lib/cache.js").flattenedLists);
-var quotePrefixRe = /^[>\s]*/;
+const { addErrorContext, isBlankLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { flattenedLists } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
+const quotePrefixRe = /^[>\s]*/;
 module.exports = {
     "names": ["MD032", "blanks-around-lists"],
     "description": "Lists should be surrounded by blank lines",
     "tags": ["bullet", "ul", "ol", "blank_lines"],
     "function": function MD032(params, onError) {
-        var lines = params.lines;
-        flattenedLists().filter(function (list) { return !list.nesting; }).forEach(function (list) {
-            var firstIndex = list.open.map[0];
+        const { lines } = params;
+        const filteredLists = flattenedLists().filter((list) => !list.nesting);
+        for (const list of filteredLists) {
+            const firstIndex = list.open.map[0];
             if (!isBlankLine(lines[firstIndex - 1])) {
-                var line = lines[firstIndex];
-                var quotePrefix = line.match(quotePrefixRe)[0].trimEnd();
+                const line = lines[firstIndex];
+                const quotePrefix = line.match(quotePrefixRe)[0].trimEnd();
                 addErrorContext(onError, firstIndex + 1, line.trim(), null, null, null, {
-                    "insertText": "".concat(quotePrefix, "\n")
+                    "insertText": `${quotePrefix}\n`
                 });
             }
-            var lastIndex = list.lastLineIndex - 1;
+            const lastIndex = list.lastLineIndex - 1;
             if (!isBlankLine(lines[lastIndex + 1])) {
-                var line = lines[lastIndex];
-                var quotePrefix = line.match(quotePrefixRe)[0].trimEnd();
+                const line = lines[lastIndex];
+                const quotePrefix = line.match(quotePrefixRe)[0].trimEnd();
                 addErrorContext(onError, lastIndex + 1, line.trim(), null, null, null, {
                     "lineNumber": lastIndex + 2,
-                    "insertText": "".concat(quotePrefix, "\n")
+                    "insertText": `${quotePrefix}\n`
                 });
             }
-        });
+        }
     }
 };
 
@@ -3298,12 +3632,11 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addError = _a.addError, forEachLine = _a.forEachLine, overlapsAnyRange = _a.overlapsAnyRange, unescapeMarkdown = _a.unescapeMarkdown;
-var _b = __webpack_require__(/*! ./cache */ "../lib/cache.js"), codeBlockAndSpanRanges = _b.codeBlockAndSpanRanges, lineMetadata = _b.lineMetadata;
-var htmlElementRe = /<(([A-Za-z][A-Za-z0-9-]*)(?:\s[^>]*)?)\/?>/g;
-var linkDestinationRe = /]\(\s*$/;
+const { addError, forEachLine, htmlElementRe, withinAnyRange, unescapeMarkdown } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { codeBlockAndSpanRanges, lineMetadata } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
+const linkDestinationRe = /]\(\s*$/;
 // See https://spec.commonmark.org/0.29/#autolinks
-var emailAddressRe = 
+const emailAddressRe = 
 // eslint-disable-next-line max-len
 /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
 module.exports = {
@@ -3311,22 +3644,22 @@ module.exports = {
     "description": "Inline HTML",
     "tags": ["html"],
     "function": function MD033(params, onError) {
-        var allowedElements = params.config.allowed_elements;
+        let allowedElements = params.config.allowed_elements;
         allowedElements = Array.isArray(allowedElements) ? allowedElements : [];
-        allowedElements = allowedElements.map(function (element) { return element.toLowerCase(); });
-        var exclusions = codeBlockAndSpanRanges();
-        forEachLine(lineMetadata(), function (line, lineIndex, inCode) {
-            var match = null;
+        allowedElements = allowedElements.map((element) => element.toLowerCase());
+        const exclusions = codeBlockAndSpanRanges();
+        forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
+            let match = null;
             // eslint-disable-next-line no-unmodified-loop-condition
             while (!inCode && ((match = htmlElementRe.exec(line)) !== null)) {
-                var tag = match[0], content = match[1], element = match[2];
+                const [tag, content, element] = match;
                 if (!allowedElements.includes(element.toLowerCase()) &&
                     !tag.endsWith("\\>") &&
                     !emailAddressRe.test(content) &&
-                    !overlapsAnyRange(exclusions, lineIndex, match.index, match[0].length)) {
-                    var prefix = line.substring(0, match.index);
+                    !withinAnyRange(exclusions, lineIndex, match.index, match[0].length)) {
+                    const prefix = line.substring(0, match.index);
                     if (!linkDestinationRe.test(prefix)) {
-                        var unescaped = unescapeMarkdown(prefix + "<", "_");
+                        const unescaped = unescapeMarkdown(prefix + "<", "_");
                         if (!unescaped.endsWith("_")) {
                             addError(onError, lineIndex + 1, "Element: " + element, null, [match.index + 1, tag.length]);
                         }
@@ -3349,17 +3682,17 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, bareUrlRe = _a.bareUrlRe, filterTokens = _a.filterTokens;
+const { addErrorContext, bareUrlRe, filterTokens } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD034", "no-bare-urls"],
     "description": "Bare URL used",
     "tags": ["links", "url"],
     "function": function MD034(params, onError) {
-        filterTokens(params, "inline", function (token) {
-            var inLink = false;
-            token.children.forEach(function (child) {
-                var content = child.content, line = child.line, lineNumber = child.lineNumber, type = child.type;
-                var match = null;
+        filterTokens(params, "inline", (token) => {
+            let inLink = false;
+            for (const child of token.children) {
+                const { content, line, lineNumber, type } = child;
+                let match = null;
                 if (type === "link_open") {
                     inLink = true;
                 }
@@ -3368,32 +3701,32 @@ module.exports = {
                 }
                 else if ((type === "text") && !inLink) {
                     while ((match = bareUrlRe.exec(content)) !== null) {
-                        var bareUrl = match[0];
-                        var matchIndex = match.index;
-                        var bareUrlLength = bareUrl.length;
+                        const [bareUrl] = match;
+                        const matchIndex = match.index;
+                        const bareUrlLength = bareUrl.length;
                         // Allow "[https://example.com]" to avoid conflicts with
                         // MD011/no-reversed-links; allow quoting as another way
                         // of deliberately including a bare URL
-                        var leftChar = content[matchIndex - 1];
-                        var rightChar = content[matchIndex + bareUrlLength];
+                        const leftChar = content[matchIndex - 1];
+                        const rightChar = content[matchIndex + bareUrlLength];
                         if (!((leftChar === "[") && (rightChar === "]")) &&
                             !((leftChar === "\"") && (rightChar === "\"")) &&
                             !((leftChar === "'") && (rightChar === "'"))) {
-                            var index = line.indexOf(content);
-                            var range = (index === -1) ? null : [
+                            const index = line.indexOf(content);
+                            const range = (index === -1) ? null : [
                                 index + matchIndex + 1,
                                 bareUrlLength
                             ];
-                            var fixInfo = range ? {
+                            const fixInfo = range ? {
                                 "editColumn": range[0],
                                 "deleteCount": range[1],
-                                "insertText": "<".concat(bareUrl, ">")
+                                "insertText": `<${bareUrl}>`
                             } : null;
                             addErrorContext(onError, lineNumber, bareUrl, null, null, range, fixInfo);
                         }
                     }
                 }
-            });
+            }
         });
     }
 };
@@ -3410,15 +3743,20 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorDetailIf = _a.addErrorDetailIf, filterTokens = _a.filterTokens;
+const { addErrorDetailIf, filterTokens } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD035", "hr-style"],
     "description": "Horizontal rule style",
     "tags": ["hr"],
     "function": function MD035(params, onError) {
-        var style = String(params.config.style || "consistent");
-        filterTokens(params, "hr", function (token) {
-            var lineNumber = token.lineNumber, markup = token.markup;
+        let style = String(params.config.style || "consistent").trim();
+        filterTokens(params, "hr", (token) => {
+            const { line, lineNumber } = token;
+            let { markup } = token;
+            const match = line.match(/[_*\-\s\t]+$/);
+            if (match) {
+                markup = match[0].trim();
+            }
             if (style === "consistent") {
                 style = markup;
             }
@@ -3439,22 +3777,22 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, allPunctuation = _a.allPunctuation;
+const { addErrorContext, allPunctuation } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD036", "no-emphasis-as-heading", "no-emphasis-as-header"],
     "description": "Emphasis used instead of a heading",
     "tags": ["headings", "headers", "emphasis"],
     "function": function MD036(params, onError) {
-        var punctuation = params.config.punctuation;
+        let punctuation = params.config.punctuation;
         punctuation =
             String((punctuation === undefined) ? allPunctuation : punctuation);
-        var re = new RegExp("[" + punctuation + "]$");
+        const re = new RegExp("[" + punctuation + "]$");
         // eslint-disable-next-line jsdoc/require-jsdoc
         function base(token) {
             if (token.type === "paragraph_open") {
                 return function inParagraph(t) {
                     // Always paragraph_open/inline/paragraph_close,
-                    var children = t.children.filter(function notEmptyText(child) {
+                    const children = t.children.filter(function notEmptyText(child) {
                         return (child.type !== "text") || (child.content !== "");
                     });
                     if ((children.length === 3) &&
@@ -3485,10 +3823,10 @@ module.exports = {
             }
             return base;
         }
-        var state = base;
-        params.tokens.forEach(function forToken(token) {
+        let state = base;
+        for (const token of params.tokens) {
             state = state(token);
-        });
+        }
     }
 };
 
@@ -3504,21 +3842,21 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, emphasisMarkersInContent = _a.emphasisMarkersInContent, forEachLine = _a.forEachLine, isBlankLine = _a.isBlankLine;
-var lineMetadata = (__webpack_require__(/*! ./cache */ "../lib/cache.js").lineMetadata);
-var emphasisRe = /(^|[^\\]|\\\\)(?:(\*\*?\*?)|(__?_?))/g;
-var embeddedUnderscoreRe = /([A-Za-z0-9])_([A-Za-z0-9])/g;
-var asteriskListItemMarkerRe = /^([\s>]*)\*(\s+)/;
-var leftSpaceRe = /^\s+/;
-var rightSpaceRe = /\s+$/;
-var tablePipeRe = /\|/;
+const { addErrorContext, emphasisMarkersInContent, forEachLine, isBlankLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { lineMetadata } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
+const emphasisRe = /(^|[^\\]|\\\\)(?:(\*\*?\*?)|(__?_?))/g;
+const embeddedUnderscoreRe = /([A-Za-z0-9])_([A-Za-z0-9])/g;
+const asteriskListItemMarkerRe = /^([\s>]*)\*(\s+)/;
+const leftSpaceRe = /^\s+/;
+const rightSpaceRe = /\s+$/;
+const tablePipeRe = /\|/;
 module.exports = {
     "names": ["MD037", "no-space-in-emphasis"],
     "description": "Spaces inside emphasis markers",
     "tags": ["whitespace", "emphasis"],
     "function": function MD037(params, onError) {
         // eslint-disable-next-line init-declarations
-        var effectiveEmphasisLength, emphasisIndex, emphasisKind, emphasisLength, pendingError = null;
+        let effectiveEmphasisLength, emphasisIndex, emphasisKind, emphasisLength, pendingError = null;
         // eslint-disable-next-line jsdoc/require-jsdoc
         function resetRunTracking() {
             emphasisIndex = -1;
@@ -3530,26 +3868,26 @@ module.exports = {
         // eslint-disable-next-line jsdoc/require-jsdoc
         function handleRunEnd(line, lineIndex, contextLength, match, matchIndex, inTable) {
             // Close current run
-            var content = line.substring(emphasisIndex, matchIndex);
+            let content = line.substring(emphasisIndex, matchIndex);
             if (!emphasisLength) {
                 content = content.trimStart();
             }
             if (!match) {
                 content = content.trimEnd();
             }
-            var leftSpace = leftSpaceRe.test(content);
-            var rightSpace = rightSpaceRe.test(content);
+            const leftSpace = leftSpaceRe.test(content);
+            const rightSpace = rightSpaceRe.test(content);
             if ((leftSpace || rightSpace) &&
                 (!inTable || !tablePipeRe.test(content))) {
                 // Report the violation
-                var contextStart = emphasisIndex - emphasisLength;
-                var contextEnd = matchIndex + contextLength;
-                var context = line.substring(contextStart, contextEnd);
-                var column = contextStart + 1;
-                var length = contextEnd - contextStart;
-                var leftMarker = line.substring(contextStart, emphasisIndex);
-                var rightMarker = match ? (match[2] || match[3]) : "";
-                var fixedText = "".concat(leftMarker).concat(content.trim()).concat(rightMarker);
+                const contextStart = emphasisIndex - emphasisLength;
+                const contextEnd = matchIndex + contextLength;
+                const context = line.substring(contextStart, contextEnd);
+                const column = contextStart + 1;
+                const length = contextEnd - contextStart;
+                const leftMarker = line.substring(contextStart, emphasisIndex);
+                const rightMarker = match ? (match[2] || match[3]) : "";
+                const fixedText = `${leftMarker}${content.trim()}${rightMarker}`;
                 return [
                     onError,
                     lineIndex + 1,
@@ -3567,10 +3905,10 @@ module.exports = {
             return null;
         }
         // Initialize
-        var ignoreMarkersByLine = emphasisMarkersInContent(params);
+        const ignoreMarkersByLine = emphasisMarkersInContent(params);
         resetRunTracking();
-        forEachLine(lineMetadata(), function (line, lineIndex, inCode, onFence, inTable, inItem, onBreak, inMath) {
-            var onItemStart = (inItem === 1);
+        forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence, inTable, inItem, onBreak, inMath) => {
+            const onItemStart = (inItem === 1);
             if (inCode ||
                 onFence ||
                 inTable ||
@@ -3587,22 +3925,22 @@ module.exports = {
                 // Emphasis has no meaning here
                 return;
             }
-            var patchedLine = line.replace(embeddedUnderscoreRe, "$1 $2");
+            let patchedLine = line.replace(embeddedUnderscoreRe, "$1 $2");
             if (onItemStart) {
                 // Trim overlapping '*' list item marker
                 patchedLine = patchedLine.replace(asteriskListItemMarkerRe, "$1 $2");
             }
-            var match = null;
+            let match = null;
             // Match all emphasis-looking runs in the line...
             while ((match = emphasisRe.exec(patchedLine))) {
-                var ignoreMarkersForLine = ignoreMarkersByLine[lineIndex];
-                var matchIndex = match.index + match[1].length;
+                const ignoreMarkersForLine = ignoreMarkersByLine[lineIndex];
+                const matchIndex = match.index + match[1].length;
                 if (ignoreMarkersForLine.includes(matchIndex)) {
                     // Ignore emphasis markers inside code spans and links
                     continue;
                 }
-                var matchLength = match[0].length - match[1].length;
-                var matchKind = (match[2] || match[3])[0];
+                const matchLength = match[0].length - match[1].length;
+                const matchKind = (match[2] || match[3])[0];
                 if (emphasisIndex === -1) {
                     // New run
                     emphasisIndex = matchIndex + matchLength;
@@ -3616,13 +3954,13 @@ module.exports = {
                         // Ending an existing run, report any pending error
                         if (pendingError) {
                             // @ts-ignore
-                            addErrorContext.apply(void 0, pendingError);
+                            addErrorContext(...pendingError);
                             pendingError = null;
                         }
-                        var error = handleRunEnd(line, lineIndex, effectiveEmphasisLength, match, matchIndex, inTable);
+                        const error = handleRunEnd(line, lineIndex, effectiveEmphasisLength, match, matchIndex, inTable);
                         if (error) {
                             // @ts-ignore
-                            addErrorContext.apply(void 0, error);
+                            addErrorContext(...error);
                         }
                         // Reset
                         resetRunTracking();
@@ -3674,43 +4012,43 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, filterTokens = _a.filterTokens, forEachInlineCodeSpan = _a.forEachInlineCodeSpan, newLineRe = _a.newLineRe;
-var leftSpaceRe = /^\s([^`]|$)/;
-var rightSpaceRe = /[^`]\s$/;
-var singleLeftRightSpaceRe = /^\s(?:\S.*\S|\S)\s$/;
+const { addErrorContext, filterTokens, forEachInlineCodeSpan, newLineRe } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const leftSpaceRe = /^\s([^`]|$)/;
+const rightSpaceRe = /[^`]\s$/;
+const spaceInsideCodeInline = (token) => ((token.type === "code_inline") &&
+    (leftSpaceRe.test(token.content) || rightSpaceRe.test(token.content)));
 module.exports = {
     "names": ["MD038", "no-space-in-code"],
     "description": "Spaces inside code span elements",
     "tags": ["whitespace", "code"],
     "function": function MD038(params, onError) {
-        filterTokens(params, "inline", function (token) {
-            if (token.children.some(function (child) { return child.type === "code_inline"; })) {
-                var tokenLines_1 = params.lines.slice(token.map[0], token.map[1]);
-                forEachInlineCodeSpan(tokenLines_1.join("\n"), function (code, lineIndex, columnIndex, tickCount) {
-                    var rangeIndex = columnIndex - tickCount;
-                    var rangeLength = code.length + (2 * tickCount);
-                    var rangeLineOffset = 0;
-                    var fixIndex = columnIndex;
-                    var fixLength = code.length;
-                    var codeLines = code.split(newLineRe);
-                    var left = leftSpaceRe.test(code);
-                    var right = !left && rightSpaceRe.test(code);
+        filterTokens(params, "inline", (token) => {
+            if (token.children.some(spaceInsideCodeInline)) {
+                const tokenLines = params.lines.slice(token.map[0], token.map[1]);
+                forEachInlineCodeSpan(tokenLines.join("\n"), (code, lineIndex, columnIndex, tickCount) => {
+                    let rangeIndex = columnIndex - tickCount;
+                    let rangeLength = code.length + (2 * tickCount);
+                    let rangeLineOffset = 0;
+                    let fixIndex = columnIndex;
+                    let fixLength = code.length;
+                    const codeLines = code.split(newLineRe);
+                    const left = leftSpaceRe.test(code);
+                    const right = !left && rightSpaceRe.test(code);
                     if (right && (codeLines.length > 1)) {
                         rangeIndex = 0;
                         rangeLineOffset = codeLines.length - 1;
                         fixIndex = 0;
                     }
-                    var allowed = singleLeftRightSpaceRe.test(code);
-                    if ((left || right) && !allowed) {
-                        var codeLinesRange = codeLines[rangeLineOffset];
+                    if (left || right) {
+                        const codeLinesRange = codeLines[rangeLineOffset];
                         if (codeLines.length > 1) {
                             rangeLength = codeLinesRange.length + tickCount;
                             fixLength = codeLinesRange.length;
                         }
-                        var context = tokenLines_1[lineIndex + rangeLineOffset]
+                        const context = tokenLines[lineIndex + rangeLineOffset]
                             .substring(rangeIndex, rangeIndex + rangeLength);
-                        var codeLinesRangeTrim = codeLinesRange.trim();
-                        var fixText = (codeLinesRangeTrim.startsWith("`") ? " " : "") +
+                        const codeLinesRangeTrim = codeLinesRange.trim();
+                        const fixText = (codeLinesRangeTrim.startsWith("`") ? " " : "") +
                             codeLinesRangeTrim +
                             (codeLinesRangeTrim.endsWith("`") ? " " : "");
                         addErrorContext(onError, token.lineNumber + lineIndex + rangeLineOffset, context, left, right, [rangeIndex + 1, rangeLength], {
@@ -3737,37 +4075,37 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, filterTokens = _a.filterTokens;
-var spaceInLinkRe = /\[(?:\s+(?:[^\]]*?)\s*|(?:[^\]]*?)\s+)](?=((?:\([^)]*\))|(?:\[[^\]]*\])))/;
+const { addErrorContext, filterTokens } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const spaceInLinkRe = /\[(?:\s+(?:[^\]]*?)\s*|(?:[^\]]*?)\s+)](?=((?:\([^)]*\))|(?:\[[^\]]*\])))/;
 module.exports = {
     "names": ["MD039", "no-space-in-links"],
     "description": "Spaces inside link text",
     "tags": ["whitespace", "links"],
     "function": function MD039(params, onError) {
-        filterTokens(params, "inline", function (token) {
-            var children = token.children;
-            var lineNumber = token.lineNumber;
-            var inLink = false;
-            var linkText = "";
-            var lineIndex = 0;
-            children.forEach(function (child) {
-                var content = child.content, type = child.type;
+        filterTokens(params, "inline", (token) => {
+            const { children } = token;
+            let { lineNumber } = token;
+            let inLink = false;
+            let linkText = "";
+            let lineIndex = 0;
+            for (const child of children) {
+                const { content, markup, type } = child;
                 if (type === "link_open") {
                     inLink = true;
                     linkText = "";
                 }
                 else if (type === "link_close") {
                     inLink = false;
-                    var left = linkText.trimStart().length !== linkText.length;
-                    var right = linkText.trimEnd().length !== linkText.length;
+                    const left = linkText.trimStart().length !== linkText.length;
+                    const right = linkText.trimEnd().length !== linkText.length;
                     if (left || right) {
-                        var line = params.lines[lineNumber - 1];
-                        var range = null;
-                        var fixInfo = null;
-                        var match = line.slice(lineIndex).match(spaceInLinkRe);
+                        const line = params.lines[lineNumber - 1];
+                        let range = null;
+                        let fixInfo = null;
+                        const match = line.slice(lineIndex).match(spaceInLinkRe);
                         if (match) {
-                            var column = match.index + lineIndex + 1;
-                            var length = match[0].length;
+                            const column = match.index + lineIndex + 1;
+                            const length = match[0].length;
                             range = [column, length];
                             fixInfo = {
                                 "editColumn": column + 1,
@@ -3776,7 +4114,7 @@ module.exports = {
                             };
                             lineIndex = column + length - 1;
                         }
-                        addErrorContext(onError, lineNumber, "[".concat(linkText, "]"), left, right, range, fixInfo);
+                        addErrorContext(onError, lineNumber, `[${linkText}]`, left, right, range, fixInfo);
                     }
                 }
                 else if ((type === "softbreak") || (type === "hardbreak")) {
@@ -3784,9 +4122,11 @@ module.exports = {
                     lineIndex = 0;
                 }
                 else if (inLink) {
-                    linkText += content;
+                    linkText += type.endsWith("_inline") ?
+                        `${markup}${content}${markup}` :
+                        (content || markup);
                 }
-            });
+            }
         });
     }
 };
@@ -3803,7 +4143,7 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, filterTokens = _a.filterTokens;
+const { addErrorContext, filterTokens } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD040", "fenced-code-language"],
     "description": "Fenced code blocks should have a language specified",
@@ -3829,25 +4169,25 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, frontMatterHasTitle = _a.frontMatterHasTitle;
+const { addErrorContext, frontMatterHasTitle } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD041", "first-line-heading", "first-line-h1"],
     "description": "First line in a file should be a top-level heading",
     "tags": ["headings", "headers"],
     "function": function MD041(params, onError) {
-        var level = Number(params.config.level || 1);
-        var tag = "h" + level;
-        var foundFrontMatterTitle = frontMatterHasTitle(params.frontMatterLines, params.config.front_matter_title);
+        const level = Number(params.config.level || 1);
+        const tag = "h" + level;
+        const foundFrontMatterTitle = frontMatterHasTitle(params.frontMatterLines, params.config.front_matter_title);
         if (!foundFrontMatterTitle) {
-            var htmlHeadingRe_1 = new RegExp("^<h".concat(level, "[ />]"), "i");
-            params.tokens.every(function (token) {
-                var isError = false;
+            const htmlHeadingRe = new RegExp(`^<h${level}[ />]`, "i");
+            params.tokens.every((token) => {
+                let isError = false;
                 if (token.type === "html_block") {
                     if (token.content.startsWith("<!--")) {
                         // Ignore leading HTML comments
                         return true;
                     }
-                    else if (!htmlHeadingRe_1.test(token.content)) {
+                    else if (!htmlHeadingRe.test(token.content)) {
                         // Something other than an HTML heading
                         isError = true;
                     }
@@ -3877,38 +4217,44 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, filterTokens = _a.filterTokens, rangeFromRegExp = _a.rangeFromRegExp;
-var emptyLinkRe = /\[[^\]]*](?:\((?:#?|(?:<>))\))/;
+const { addErrorContext, escapeForRegExp, filterTokens } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD042", "no-empty-links"],
     "description": "No empty links",
     "tags": ["links"],
     "function": function MD042(params, onError) {
         filterTokens(params, "inline", function forToken(token) {
-            var inLink = false;
-            var linkText = "";
-            var emptyLink = false;
-            token.children.forEach(function forChild(child) {
+            let inLink = false;
+            let linkText = "";
+            let emptyLink = false;
+            for (const child of token.children) {
                 if (child.type === "link_open") {
                     inLink = true;
                     linkText = "";
-                    child.attrs.forEach(function forAttr(attr) {
+                    for (const attr of child.attrs) {
                         if (attr[0] === "href" && (!attr[1] || (attr[1] === "#"))) {
                             emptyLink = true;
                         }
-                    });
+                    }
                 }
                 else if (child.type === "link_close") {
                     inLink = false;
                     if (emptyLink) {
-                        addErrorContext(onError, child.lineNumber, "[" + linkText + "]()", null, null, rangeFromRegExp(child.line, emptyLinkRe));
+                        let context = `[${linkText}]`;
+                        let range = null;
+                        const match = child.line.match(new RegExp(`${escapeForRegExp(context)}\\((?:|#|<>)\\)`));
+                        if (match) {
+                            context = match[0];
+                            range = [match.index + 1, match[0].length];
+                        }
+                        addErrorContext(onError, child.lineNumber, context, null, null, range);
                         emptyLink = false;
                     }
                 }
                 else if (inLink) {
                     linkText += child.content;
                 }
-            });
+            }
         });
     }
 };
@@ -3925,56 +4271,56 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorContext = _a.addErrorContext, addErrorDetailIf = _a.addErrorDetailIf, forEachHeading = _a.forEachHeading;
+const { addErrorContext, addErrorDetailIf, forEachHeading } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD043", "required-headings", "required-headers"],
     "description": "Required heading structure",
     "tags": ["headings", "headers"],
     "function": function MD043(params, onError) {
-        var requiredHeadings = params.config.headings || params.config.headers;
+        const requiredHeadings = params.config.headings || params.config.headers;
         if (Array.isArray(requiredHeadings)) {
-            var levels_1 = {};
-            [1, 2, 3, 4, 5, 6].forEach(function (level) {
-                levels_1["h" + level] = "######".substr(-level);
-            });
-            var i_1 = 0;
-            var matchAny_1 = false;
-            var hasError_1 = false;
-            var anyHeadings_1 = false;
-            var getExpected_1 = function () { return requiredHeadings[i_1++] || "[None]"; };
-            forEachHeading(params, function (heading, content) {
-                if (!hasError_1) {
-                    anyHeadings_1 = true;
-                    var actual = levels_1[heading.tag] + " " + content;
-                    var expected = getExpected_1();
+            const levels = {};
+            for (const level of [1, 2, 3, 4, 5, 6]) {
+                levels["h" + level] = "######".substr(-level);
+            }
+            let i = 0;
+            let matchAny = false;
+            let hasError = false;
+            let anyHeadings = false;
+            const getExpected = () => requiredHeadings[i++] || "[None]";
+            forEachHeading(params, (heading, content) => {
+                if (!hasError) {
+                    anyHeadings = true;
+                    const actual = levels[heading.tag] + " " + content;
+                    const expected = getExpected();
                     if (expected === "*") {
-                        var nextExpected = getExpected_1();
+                        const nextExpected = getExpected();
                         if (nextExpected.toLowerCase() !== actual.toLowerCase()) {
-                            matchAny_1 = true;
-                            i_1--;
+                            matchAny = true;
+                            i--;
                         }
                     }
                     else if (expected === "+") {
-                        matchAny_1 = true;
+                        matchAny = true;
                     }
                     else if (expected.toLowerCase() === actual.toLowerCase()) {
-                        matchAny_1 = false;
+                        matchAny = false;
                     }
-                    else if (matchAny_1) {
-                        i_1--;
+                    else if (matchAny) {
+                        i--;
                     }
                     else {
                         addErrorDetailIf(onError, heading.lineNumber, expected, actual);
-                        hasError_1 = true;
+                        hasError = true;
                     }
                 }
             });
-            var extraHeadings = requiredHeadings.length - i_1;
-            if (!hasError_1 &&
+            const extraHeadings = requiredHeadings.length - i;
+            if (!hasError &&
                 ((extraHeadings > 1) ||
-                    ((extraHeadings === 1) && (requiredHeadings[i_1] !== "*"))) &&
-                (anyHeadings_1 || !requiredHeadings.every(function (heading) { return heading === "*"; }))) {
-                addErrorContext(onError, params.lines.length, requiredHeadings[i_1]);
+                    ((extraHeadings === 1) && (requiredHeadings[i] !== "*"))) &&
+                (anyHeadings || !requiredHeadings.every((heading) => heading === "*"))) {
+                addErrorContext(onError, params.lines.length, requiredHeadings[i]);
             }
         }
     }
@@ -3992,53 +4338,58 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorDetailIf = _a.addErrorDetailIf, bareUrlRe = _a.bareUrlRe, escapeForRegExp = _a.escapeForRegExp, forEachLine = _a.forEachLine, overlapsAnyRange = _a.overlapsAnyRange, linkRe = _a.linkRe, linkReferenceRe = _a.linkReferenceRe;
-var _b = __webpack_require__(/*! ./cache */ "../lib/cache.js"), codeBlockAndSpanRanges = _b.codeBlockAndSpanRanges, lineMetadata = _b.lineMetadata;
+const { addErrorDetailIf, bareUrlRe, escapeForRegExp, forEachLine, forEachLink, withinAnyRange, linkReferenceDefinitionRe } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { codeBlockAndSpanRanges, htmlElementRanges, lineMetadata } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 module.exports = {
     "names": ["MD044", "proper-names"],
     "description": "Proper names should have the correct capitalization",
     "tags": ["spelling"],
     "function": function MD044(params, onError) {
-        var names = params.config.names;
+        let names = params.config.names;
         names = Array.isArray(names) ? names : [];
-        names.sort(function (a, b) { return (b.length - a.length) || a.localeCompare(b); });
-        var codeBlocks = params.config.code_blocks;
-        var includeCodeBlocks = (codeBlocks === undefined) ? true : !!codeBlocks;
-        var exclusions = [];
-        forEachLine(lineMetadata(), function (line, lineIndex) {
-            if (linkReferenceRe.test(line)) {
+        names.sort((a, b) => (b.length - a.length) || a.localeCompare(b));
+        const codeBlocks = params.config.code_blocks;
+        const includeCodeBlocks = (codeBlocks === undefined) ? true : !!codeBlocks;
+        const htmlElements = params.config.html_elements;
+        const includeHtmlElements = (htmlElements === undefined) ? true : !!htmlElements;
+        const exclusions = [];
+        forEachLine(lineMetadata(), (line, lineIndex) => {
+            if (linkReferenceDefinitionRe.test(line)) {
                 exclusions.push([lineIndex, 0, line.length]);
             }
             else {
-                var match = null;
+                let match = null;
                 while ((match = bareUrlRe.exec(line)) !== null) {
                     exclusions.push([lineIndex, match.index, match[0].length]);
                 }
-                while ((match = linkRe.exec(line)) !== null) {
-                    var text = match[1], destination = match[2];
+                forEachLink(line, (index, _, text, destination) => {
                     if (destination) {
-                        exclusions.push([lineIndex, match.index + text.length, destination.length]);
+                        exclusions.push([lineIndex, index + text.length, destination.length]);
                     }
-                }
+                });
             }
         });
         if (!includeCodeBlocks) {
-            exclusions.push.apply(exclusions, codeBlockAndSpanRanges());
-        }
-        var _loop_1 = function (name) {
-            var escapedName = escapeForRegExp(name);
-            var startNamePattern = /^\W/.test(name) ? "" : "\\b_*";
-            var endNamePattern = /\W$/.test(name) ? "" : "_*\\b";
-            var namePattern = "(".concat(startNamePattern, ")(").concat(escapedName, ")").concat(endNamePattern);
-            var nameRe = new RegExp(namePattern, "gi");
-            forEachLine(lineMetadata(), function (line, lineIndex, inCode, onFence) {
+            exclusions.push(...codeBlockAndSpanRanges());
+        }
+        if (!includeHtmlElements) {
+            exclusions.push(...htmlElementRanges());
+        }
+        for (const name of names) {
+            const escapedName = escapeForRegExp(name);
+            const startNamePattern = /^\W/.test(name) ? "" : "\\b_*";
+            const endNamePattern = /\W$/.test(name) ? "" : "_*\\b";
+            const namePattern = `(${startNamePattern})(${escapedName})${endNamePattern}`;
+            const nameRe = new RegExp(namePattern, "gi");
+            forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence) => {
                 if (includeCodeBlocks || (!inCode && !onFence)) {
-                    var match = null;
+                    let match = null;
                     while ((match = nameRe.exec(line)) !== null) {
-                        var leftMatch = match[1], nameMatch = match[2];
-                        var index = match.index + leftMatch.length;
-                        var length = nameMatch.length;
-                        if (!overlapsAnyRange(exclusions, lineIndex, index, length)) {
+                        const [, leftMatch, nameMatch] = match;
+                        const index = match.index + leftMatch.length;
+                        const length = nameMatch.length;
+                        if (!withinAnyRange(exclusions, lineIndex, index, length) &&
+                            !names.includes(nameMatch)) {
                             addErrorDetailIf(onError, lineIndex + 1, name, nameMatch, null, null, [index + 1, length], {
                                 "editColumn": index + 1,
                                 "deleteCount": length,
@@ -4049,10 +4400,6 @@ module.exports = {
                     }
                 }
             });
-        };
-        for (var _i = 0, names_1 = names; _i < names_1.length; _i++) {
-            var name = names_1[_i];
-            _loop_1(name);
         }
     }
 };
@@ -4069,7 +4416,7 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addError = _a.addError, forEachInlineChild = _a.forEachInlineChild;
+const { addError, forEachInlineChild } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD045", "no-alt-text"],
     "description": "Images should have alternate text (alt text)",
@@ -4095,8 +4442,8 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var addErrorDetailIf = (__webpack_require__(/*! ../helpers */ "../helpers/helpers.js").addErrorDetailIf);
-var tokenTypeToStyle = {
+const { addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const tokenTypeToStyle = {
     "fence": "fenced",
     "code_block": "indented"
 };
@@ -4105,16 +4452,15 @@ module.exports = {
     "description": "Code block style",
     "tags": ["code"],
     "function": function MD046(params, onError) {
-        var expectedStyle = String(params.config.style || "consistent");
-        params.tokens
-            .filter(function (token) { return token.type === "code_block" || token.type === "fence"; })
-            .forEach(function (token) {
-            var lineNumber = token.lineNumber, type = token.type;
+        let expectedStyle = String(params.config.style || "consistent");
+        const codeBlocksAndFences = params.tokens.filter((token) => (token.type === "code_block") || (token.type === "fence"));
+        for (const token of codeBlocksAndFences) {
+            const { lineNumber, type } = token;
             if (expectedStyle === "consistent") {
                 expectedStyle = tokenTypeToStyle[type];
             }
             addErrorDetailIf(onError, lineNumber, expectedStyle, tokenTypeToStyle[type]);
-        });
+        }
     }
 };
 
@@ -4130,14 +4476,14 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addError = _a.addError, isBlankLine = _a.isBlankLine;
+const { addError, isBlankLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD047", "single-trailing-newline"],
     "description": "Files should end with a single newline character",
     "tags": ["blank_lines"],
     "function": function MD047(params, onError) {
-        var lastLineNumber = params.lines.length;
-        var lastLine = params.lines[lastLineNumber - 1];
+        const lastLineNumber = params.lines.length;
+        const lastLine = params.lines[lastLineNumber - 1];
         if (!isBlankLine(lastLine)) {
             addError(onError, lastLineNumber, null, null, [lastLine.length, 1], {
                 "insertText": "\n",
@@ -4159,62 +4505,168 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addErrorDetailIf = _a.addErrorDetailIf, fencedCodeBlockStyleFor = _a.fencedCodeBlockStyleFor;
+const { addErrorDetailIf, fencedCodeBlockStyleFor } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 module.exports = {
     "names": ["MD048", "code-fence-style"],
     "description": "Code fence style",
     "tags": ["code"],
     "function": function MD048(params, onError) {
-        var style = String(params.config.style || "consistent");
-        var expectedStyle = style;
-        params.tokens
-            .filter(function (token) { return token.type === "fence"; })
-            .forEach(function (fenceToken) {
-            var lineNumber = fenceToken.lineNumber, markup = fenceToken.markup;
+        const style = String(params.config.style || "consistent");
+        let expectedStyle = style;
+        const fenceTokens = params.tokens.filter((token) => token.type === "fence");
+        for (const fenceToken of fenceTokens) {
+            const { lineNumber, markup } = fenceToken;
             if (expectedStyle === "consistent") {
                 expectedStyle = fencedCodeBlockStyleFor(markup);
             }
             addErrorDetailIf(onError, lineNumber, expectedStyle, fencedCodeBlockStyleFor(markup));
-        });
+        }
     }
 };
 
 
 /***/ }),
 
-/***/ "../lib/md049.js":
+/***/ "../lib/md049-md050.js":
+/*!*****************************!*\
+  !*** ../lib/md049-md050.js ***!
+  \*****************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+// @ts-check
+
+const { addError, emphasisOrStrongStyleFor, forEachInlineChild, getNextChildToken, getRangeAndFixInfoIfFound } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const impl = (params, onError, tagPrefix, asterisk, underline, style) => {
+    let lastLineNumber = -1;
+    const instances = new Map();
+    forEachInlineChild(params, `${tagPrefix}_open`, (token, parent) => {
+        const { lineNumber, markup } = token;
+        const markupStyle = emphasisOrStrongStyleFor(markup);
+        if (style === "consistent") {
+            style = markupStyle;
+        }
+        if (style !== markupStyle) {
+            let rangeAndFixInfo = {};
+            const contentToken = getNextChildToken(parent, token, "text", `${tagPrefix}_close`);
+            if (contentToken) {
+                const { content } = contentToken;
+                const actual = `${markup}${content}${markup}`;
+                const expectedMarkup = (style === "asterisk") ? asterisk : underline;
+                const expected = `${expectedMarkup}${content}${expectedMarkup}`;
+                if (lastLineNumber !== lineNumber) {
+                    lastLineNumber = lineNumber;
+                    instances.clear();
+                }
+                const instance = (instances.get(expected) || 0) + 1;
+                instances.set(expected, instance);
+                rangeAndFixInfo = getRangeAndFixInfoIfFound(params.lines, lineNumber - 1, actual, expected, instance);
+            }
+            addError(onError, lineNumber, `Expected: ${style}; Actual: ${markupStyle}`, null, rangeAndFixInfo.range, rangeAndFixInfo.fixInfo);
+        }
+    });
+};
+module.exports = [
+    {
+        "names": ["MD049", "emphasis-style"],
+        "description": "Emphasis style should be consistent",
+        "tags": ["emphasis"],
+        "function": function MD049(params, onError) {
+            const style = String(params.config.style || "consistent");
+            return impl(params, onError, "em", "*", "_", style);
+        }
+    },
+    {
+        "names": ["MD050", "strong-style"],
+        "description": "Strong style should be consistent",
+        "tags": ["emphasis"],
+        "function": function MD050(params, onError) {
+            const style = String(params.config.style || "consistent");
+            return impl(params, onError, "strong", "**", "__", style);
+        }
+    }
+];
+
+
+/***/ }),
+
+/***/ "../lib/md051.js":
 /*!***********************!*\
-  !*** ../lib/md049.js ***!
+  !*** ../lib/md051.js ***!
   \***********************/
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addError = _a.addError, emphasisOrStrongStyleFor = _a.emphasisOrStrongStyleFor, forEachInlineChild = _a.forEachInlineChild, getNextChildToken = _a.getNextChildToken, getRangeAndFixInfoIfFound = _a.getRangeAndFixInfoIfFound;
+const { addError, escapeForRegExp, filterTokens, forEachInlineChild, forEachHeading, htmlElementRe } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+// Regular expression for identifying HTML anchor names
+const identifierRe = /(?:id|name)\s*=\s*['"]?([^'"\s>]+)/iu;
+/**
+ * Converts a Markdown heading into an HTML fragment according to the rules
+ * used by GitHub.
+ *
+ * @param {Object} inline Inline token for heading.
+ * @returns {string} Fragment string for heading.
+ */
+function convertHeadingToHTMLFragment(inline) {
+    const inlineText = inline.children
+        .filter((token) => token.type !== "html_inline")
+        .map((token) => token.content)
+        .join("");
+    return "#" + encodeURIComponent(inlineText
+        .toLowerCase()
+        // RegExp source with Ruby's \p{Word} expanded into its General Categories
+        // eslint-disable-next-line max-len
+        // https://github.com/gjtorikian/html-pipeline/blob/main/lib/html/pipeline/toc_filter.rb
+        // https://ruby-doc.org/core-3.0.2/Regexp.html
+        .replace(/[^\p{Letter}\p{Mark}\p{Number}\p{Connector_Punctuation}\- ]/gu, "")
+        .replace(/ /gu, "-"));
+}
 module.exports = {
-    "names": ["MD049", "emphasis-style"],
-    "description": "Emphasis style should be consistent",
-    "tags": ["emphasis"],
-    "function": function MD049(params, onError) {
-        var expectedStyle = String(params.config.style || "consistent");
-        forEachInlineChild(params, "em_open", function (token, parent) {
-            var lineNumber = token.lineNumber, markup = token.markup;
-            var markupStyle = emphasisOrStrongStyleFor(markup);
-            if (expectedStyle === "consistent") {
-                expectedStyle = markupStyle;
+    "names": ["MD051", "link-fragments"],
+    "description": "Link fragments should be valid",
+    "tags": ["links"],
+    "function": function MD051(params, onError) {
+        const fragments = new Map();
+        // Process headings
+        forEachHeading(params, (heading, content, inline) => {
+            const fragment = convertHeadingToHTMLFragment(inline);
+            const count = fragments.get(fragment) || 0;
+            if (count) {
+                fragments.set(`${fragment}-${count}`, 0);
+            }
+            fragments.set(fragment, count + 1);
+        });
+        // Process HTML anchors
+        const processHtmlToken = (token) => {
+            let match = null;
+            while ((match = htmlElementRe.exec(token.content)) !== null) {
+                const [tag, , element] = match;
+                if (element.toLowerCase() === "a") {
+                    const idMatch = identifierRe.exec(tag);
+                    if (idMatch) {
+                        fragments.set(`#${idMatch[1]}`, 0);
+                    }
+                }
             }
-            if (expectedStyle !== markupStyle) {
-                var rangeAndFixInfo = {};
-                var contentToken = getNextChildToken(parent, token, "text", "em_close");
-                if (contentToken) {
-                    var content = contentToken.content;
-                    var actual = "".concat(markup).concat(content).concat(markup);
-                    var expectedMarkup = (expectedStyle === "asterisk") ? "*" : "_";
-                    var expected = "".concat(expectedMarkup).concat(content).concat(expectedMarkup);
-                    rangeAndFixInfo = getRangeAndFixInfoIfFound(params.lines, lineNumber - 1, actual, expected);
+        };
+        filterTokens(params, "html_block", processHtmlToken);
+        forEachInlineChild(params, "html_inline", processHtmlToken);
+        // Process link fragments
+        forEachInlineChild(params, "link_open", (token) => {
+            const { attrs, lineNumber, line } = token;
+            const href = attrs.find((attr) => attr[0] === "href");
+            const id = href && href[1];
+            if (id && (id.length > 1) && (id[0] === "#") && !fragments.has(id)) {
+                let context = id;
+                let range = null;
+                const match = line.match(new RegExp(`\\[.*?\\]\\(${escapeForRegExp(context)}\\)`));
+                if (match) {
+                    context = match[0];
+                    range = [match.index + 1, match[0].length];
                 }
-                addError(onError, lineNumber, "Expected: ".concat(expectedStyle, "; Actual: ").concat(markupStyle), null, rangeAndFixInfo.range, rangeAndFixInfo.fixInfo);
+                addError(onError, lineNumber, undefined, context, range);
             }
         });
     }
@@ -4223,41 +4675,78 @@ module.exports = {
 
 /***/ }),
 
-/***/ "../lib/md050.js":
+/***/ "../lib/md052.js":
 /*!***********************!*\
-  !*** ../lib/md050.js ***!
+  !*** ../lib/md052.js ***!
   \***********************/
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js"), addError = _a.addError, emphasisOrStrongStyleFor = _a.emphasisOrStrongStyleFor, forEachInlineChild = _a.forEachInlineChild, getNextChildToken = _a.getNextChildToken, getRangeAndFixInfoIfFound = _a.getRangeAndFixInfoIfFound;
+const { addError } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { referenceLinkImageData } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 module.exports = {
-    "names": ["MD050", "strong-style"],
-    "description": "Strong style should be consistent",
-    "tags": ["emphasis"],
-    "function": function MD050(params, onError) {
-        var expectedStyle = String(params.config.style || "consistent");
-        forEachInlineChild(params, "strong_open", function (token, parent) {
-            var lineNumber = token.lineNumber, markup = token.markup;
-            var markupStyle = emphasisOrStrongStyleFor(markup);
-            if (expectedStyle === "consistent") {
-                expectedStyle = markupStyle;
-            }
-            if (expectedStyle !== markupStyle) {
-                var rangeAndFixInfo = {};
-                var contentToken = getNextChildToken(parent, token, "text", "strong_close");
-                if (contentToken) {
-                    var content = contentToken.content;
-                    var actual = "".concat(markup).concat(content).concat(markup);
-                    var expectedMarkup = (expectedStyle === "asterisk") ? "**" : "__";
-                    var expected = "".concat(expectedMarkup).concat(content).concat(expectedMarkup);
-                    rangeAndFixInfo = getRangeAndFixInfoIfFound(params.lines, lineNumber - 1, actual, expected);
+    "names": ["MD052", "reference-links-images"],
+    "description": "Reference links and images should use a label that is defined",
+    "tags": ["images", "links"],
+    "function": function MD052(params, onError) {
+        const { lines } = params;
+        const { references, definitions } = referenceLinkImageData();
+        // Look for links/images that use an undefined link reference
+        for (const reference of references.entries()) {
+            const [label, datas] = reference;
+            if (!definitions.has(label)) {
+                for (const data of datas) {
+                    const [lineIndex, index, length] = data;
+                    // Context will be incomplete if reporting for a multi-line link
+                    const context = lines[lineIndex].slice(index, index + length);
+                    addError(onError, lineIndex + 1, `Missing link or image reference definition: "${label}"`, context, [index + 1, context.length]);
                 }
-                addError(onError, lineNumber, "Expected: ".concat(expectedStyle, "; Actual: ").concat(markupStyle), null, rangeAndFixInfo.range, rangeAndFixInfo.fixInfo);
             }
-        });
+        }
+    }
+};
+
+
+/***/ }),
+
+/***/ "../lib/md053.js":
+/*!***********************!*\
+  !*** ../lib/md053.js ***!
+  \***********************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+// @ts-check
+
+const { addError, ellipsify, linkReferenceDefinitionRe } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { referenceLinkImageData } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
+module.exports = {
+    "names": ["MD053", "link-image-reference-definitions"],
+    "description": "Link and image reference definitions should be needed",
+    "tags": ["images", "links"],
+    "function": function MD053(params, onError) {
+        const { lines } = params;
+        const { references, shortcuts, definitions, duplicateDefinitions } = referenceLinkImageData();
+        const singleLineDefinition = (line) => (line.replace(linkReferenceDefinitionRe, "").trim().length > 0);
+        const deleteFixInfo = {
+            "deleteCount": -1
+        };
+        // Look for unused link references (unreferenced by any link/image)
+        for (const definition of definitions.entries()) {
+            const [label, lineIndex] = definition;
+            if (!references.has(label) && !shortcuts.has(label)) {
+                const line = lines[lineIndex];
+                addError(onError, lineIndex + 1, `Unused link or image reference definition: "${label}"`, ellipsify(line), [1, line.length], singleLineDefinition(line) ? deleteFixInfo : 0);
+            }
+        }
+        // Look for duplicate link references (defined more than once)
+        for (const duplicateDefinition of duplicateDefinitions) {
+            const [label, lineIndex] = duplicateDefinition;
+            const line = lines[lineIndex];
+            addError(onError, lineIndex + 1, `Duplicate link or image reference definition: "${label}"`, ellipsify(line), [1, line.length], singleLineDefinition(line) ? deleteFixInfo : 0);
+        }
     }
 };
 
@@ -4273,8 +4762,8 @@ module.exports = {
 "use strict";
 // @ts-check
 
-var _a = __webpack_require__(/*! ./constants */ "../lib/constants.js"), homepage = _a.homepage, version = _a.version;
-var rules = [
+const { homepage, version } = __webpack_require__(/*! ./constants */ "../lib/constants.js");
+const rules = [
     __webpack_require__(/*! ./md001 */ "../lib/md001.js"),
     __webpack_require__(/*! ./md002 */ "../lib/md002.js"),
     __webpack_require__(/*! ./md003 */ "../lib/md003.js"),
@@ -4319,59 +4808,20 @@ var rules = [
     __webpack_require__(/*! ./md046 */ "../lib/md046.js"),
     __webpack_require__(/*! ./md047 */ "../lib/md047.js"),
     __webpack_require__(/*! ./md048 */ "../lib/md048.js"),
-    __webpack_require__(/*! ./md049 */ "../lib/md049.js"),
-    __webpack_require__(/*! ./md050 */ "../lib/md050.js")
+    ...__webpack_require__(/*! ./md049-md050 */ "../lib/md049-md050.js"),
+    __webpack_require__(/*! ./md051 */ "../lib/md051.js"),
+    __webpack_require__(/*! ./md052 */ "../lib/md052.js"),
+    __webpack_require__(/*! ./md053 */ "../lib/md053.js")
 ];
-rules.forEach(function (rule) {
-    var name = rule.names[0].toLowerCase();
+for (const rule of rules) {
+    const name = rule.names[0].toLowerCase();
     // eslint-disable-next-line dot-notation
     rule["information"] =
-        new URL("".concat(homepage, "/blob/v").concat(version, "/doc/Rules.md#").concat(name));
-});
+        new URL(`${homepage}/blob/v${version}/doc/Rules.md#${name}`);
+}
 module.exports = rules;
 
 
-/***/ }),
-
-/***/ "markdown-it":
-/*!*****************************!*\
-  !*** external "markdownit" ***!
-  \*****************************/
-/***/ ((module) => {
-
-"use strict";
-module.exports = markdownit;
-
-/***/ }),
-
-/***/ "?ec0a":
-/*!********************!*\
-  !*** fs (ignored) ***!
-  \********************/
-/***/ (() => {
-
-/* (ignored) */
-
-/***/ }),
-
-/***/ "?b85c":
-/*!**********************!*\
-  !*** path (ignored) ***!
-  \**********************/
-/***/ (() => {
-
-/* (ignored) */
-
-/***/ }),
-
-/***/ "?96a2":
-/*!**********************!*\
-  !*** util (ignored) ***!
-  \**********************/
-/***/ (() => {
-
-/* (ignored) */
-
 /***/ })
 
 /******/ 	});
@@ -4394,7 +4844,7 @@ module.exports = markdownit;
 /******/ 		};
 /******/ 	
 /******/ 		// Execute the module function
-/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
 /******/ 	
 /******/ 		// Return the exports of the module
 /******/ 		return module.exports;