markdownlint 0.34.0 → 0.36.0

package/lib/md039.js

@@ -2,10 +2,52 @@
 
 "use strict";
 
-const { addErrorContext, filterTokens } = require("../helpers");
+const { addErrorContext } = require("../helpers");
+const { getReferenceLinkImageData, filterByTypesCached } = require("./cache");
 
-const spaceInLinkRe =
-  /\[(?:\s[^\]]*|[^\]]*?\s)\](?=(\([^)]*\)|\[[^\]]*\]))/;
+/**
+ * Adds an error for a label space issue.
+ *
+ * @param {import("./markdownlint").RuleOnError} onError Error-reporting callback.
+ * @param {import("../helpers/micromark-helpers.cjs").Token} label Label token.
+ * @param {import("../helpers/micromark-helpers.cjs").Token} labelText LabelText token.
+ * @param {boolean} isStart True iff error is at the start of the link.
+ */
+function addLabelSpaceError(onError, label, labelText, isStart) {
+  const match = labelText.text.match(isStart ? /^[^\S\r\n]+/ : /[^\S\r\n]+$/);
+  const range = match ?
+    [
+      (isStart ? (labelText.startColumn) : (labelText.endColumn - match[0].length)),
+      match[0].length
+    ] :
+    undefined;
+  addErrorContext(
+    onError,
+    isStart ? (labelText.startLine + (match ? 0 : 1)) : (labelText.endLine - (match ? 0 : 1)),
+    label.text.replace(/\s+/g, " "),
+    isStart,
+    !isStart,
+    range,
+    range ?
+      {
+        "editColumn": range[0],
+        "deleteCount": range[1]
+      } :
+      undefined
+  );
+}
+
+/**
+ * Determines if a link is a valid link (and not a fake shortcut link due to parser tricks).
+ *
+ * @param {import("../helpers/micromark-helpers.cjs").Token} label Label token.
+ * @param {import("../helpers/micromark-helpers.cjs").Token} labelText LabelText token.
+ * @param {Map<string, any>} definitions Map of link definitions.
+ * @returns {boolean} True iff the link is valid.
+ */
+function validLink(label, labelText, definitions) {
+  return (label.parent?.children.length !== 1) || definitions.has(labelText.text.trim());
+}
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -13,59 +55,27 @@ module.exports = {
   "names": [ "MD039", "no-space-in-links" ],
   "description": "Spaces inside link text",
   "tags": [ "whitespace", "links" ],
-  "parser": "markdownit",
+  "parser": "micromark",
   "function": function MD039(params, onError) {
-    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;
-          const left = linkText.trimStart().length !== linkText.length;
-          const right = linkText.trimEnd().length !== linkText.length;
-          if (left || right) {
-            const line = params.lines[lineNumber - 1];
-            let range = null;
-            let fixInfo = null;
-            const match = line.slice(lineIndex).match(spaceInLinkRe);
-            if (match) {
-              // @ts-ignore
-              const column = match.index + lineIndex + 1;
-              const length = match[0].length;
-              range = [ column, length ];
-              fixInfo = {
-                "editColumn": column + 1,
-                "deleteCount": length - 2,
-                "insertText": linkText.trim()
-              };
-              lineIndex = column + length - 1;
-            }
-            addErrorContext(
-              onError,
-              lineNumber,
-              `[${linkText}]`,
-              left,
-              right,
-              range,
-              fixInfo
-            );
-          }
-        } else if ((type === "softbreak") || (type === "hardbreak")) {
-          lineNumber++;
-          lineIndex = 0;
-        } else if (inLink) {
-          linkText += type.endsWith("_inline") ?
-            `${markup}${content}${markup}` :
-            (content || markup);
+    const { definitions } = getReferenceLinkImageData();
+    const labels = filterByTypesCached([ "label" ])
+      .filter((label) => label.parent?.type === "link");
+    for (const label of labels) {
+      const labelTexts = label.children.filter((child) => child.type === "labelText");
+      for (const labelText of labelTexts) {
+        if (
+          (labelText.text.trimStart().length !== labelText.text.length) &&
+          validLink(label, labelText, definitions)
+        ) {
+          addLabelSpaceError(onError, label, labelText, true);
+        }
+        if (
+          (labelText.text.trimEnd().length !== labelText.text.length) &&
+          validLink(label, labelText, definitions)
+        ) {
+          addLabelSpaceError(onError, label, labelText, false);
         }
       }
-    });
+    }
   }
 };

package/lib/md040.js

@@ -3,8 +3,8 @@
 "use strict";
 
 const { addError, addErrorContext } = require("../helpers");
-const { filterByTypes, getTokenTextByType, tokenIfType } =
-  require("../helpers/micromark.cjs");
+const { getDescendantsByType } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -17,25 +17,18 @@ module.exports = {
     let allowed = params.config.allowed_languages;
     allowed = Array.isArray(allowed) ? allowed : [];
     const languageOnly = !!params.config.language_only;
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
-    const fencedCodes = filterByTypes(micromarkTokens, [ "codeFenced" ]);
+    const fencedCodes = filterByTypesCached([ "codeFenced" ]);
     for (const fencedCode of fencedCodes) {
-      const openingFence = tokenIfType(fencedCode.children[0], "codeFencedFence");
-      if (openingFence) {
-        const { children, startLine, text } = openingFence;
-        const info = getTokenTextByType(children, "codeFencedFenceInfo");
-        if (!info) {
-          addErrorContext(onError, startLine, text);
-        } else if ((allowed.length > 0) && !allowed.includes(info)) {
-          addError(onError, startLine, `"${info}" is not allowed`);
-        }
-        if (languageOnly && getTokenTextByType(children, "codeFencedFenceMeta")) {
-          addError(onError, startLine, `Info string contains more than language: "${text}"`);
-        }
+      const openingFence = getDescendantsByType(fencedCode, [ "codeFencedFence" ])[0];
+      const { startLine, text } = openingFence;
+      const info = getDescendantsByType(openingFence, [ "codeFencedFenceInfo" ])[0]?.text;
+      if (!info) {
+        addErrorContext(onError, startLine, text);
+      } else if ((allowed.length > 0) && !allowed.includes(info)) {
+        addError(onError, startLine, `"${info}" is not allowed`);
+      }
+      if (languageOnly && getDescendantsByType(openingFence, [ "codeFencedFenceMeta" ]).length > 0) {
+        addError(onError, startLine, `Info string contains more than language: "${text}"`);
       }
     }
   }

package/lib/md041.js

@@ -4,7 +4,7 @@
 
 const { addErrorContext, frontMatterHasTitle } = require("../helpers");
 const { filterByTypes, getHeadingLevel, getHtmlTagInfo, isHtmlFlowComment, nonContentTokens } =
-  require("../helpers/micromark.cjs");
+  require("../helpers/micromark-helpers.cjs");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -16,14 +16,14 @@ module.exports = {
   "function": function MD041(params, onError) {
     const level = Number(params.config.level || 1);
     if (!frontMatterHasTitle(params.frontMatterLines, params.config.front_matter_title)) {
-      params.parsers.micromark.tokens.
-        filter((token) => !nonContentTokens.has(token.type) && !isHtmlFlowComment(token)).
-        every((token) => {
+      params.parsers.micromark.tokens
+        .filter((token) => !nonContentTokens.has(token.type) && !isHtmlFlowComment(token))
+        .every((token) => {
           let isError = true;
           if ((token.type === "atxHeading") || (token.type === "setextHeading")) {
             isError = (getHeadingLevel(token) !== level);
           } else if (token.type === "htmlFlow") {
-            const htmlTexts = filterByTypes(token.children, [ "htmlText" ]);
+            const htmlTexts = filterByTypes(token.children, [ "htmlText" ], true);
             const tagInfo = (htmlTexts.length > 0) && getHtmlTagInfo(htmlTexts[0]);
             isError = !tagInfo || (tagInfo.name.toLowerCase() !== `h${level}`);
           }

package/lib/md042.js

@@ -2,8 +2,9 @@
 
 "use strict";
 
-const { addErrorContext, escapeForRegExp, filterTokens } =
-  require("../helpers");
+const { addErrorContext } = require("../helpers");
+const { getDescendantsByType } = require("../helpers/micromark-helpers.cjs");
+const { getReferenceLinkImageData, filterByTypesCached } = require("./cache");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -11,43 +12,48 @@ module.exports = {
   "names": [ "MD042", "no-empty-links" ],
   "description": "No empty links",
   "tags": [ "links" ],
-  "parser": "markdownit",
+  "parser": "micromark",
   "function": function MD042(params, onError) {
-    filterTokens(params, "inline", function forToken(token) {
-      let inLink = false;
-      let linkText = "";
-      let emptyLink = false;
-      for (const child of token.children) {
-        if (child.type === "link_open") {
-          inLink = true;
-          linkText = "";
-          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) {
-            let context = `[${linkText}]`;
-            let range = null;
-            const match = child.line.match(
-              new RegExp(`${escapeForRegExp(context)}\\((?:|#|<>)\\)`)
-            );
-            if (match) {
-              context = match[0];
-              // @ts-ignore
-              range = [ match.index + 1, match[0].length ];
-            }
-            addErrorContext(
-              onError, child.lineNumber, context, null, null, range
-            );
-            emptyLink = false;
-          }
-        } else if (inLink) {
-          linkText += child.content;
-        }
+    const { definitions } = getReferenceLinkImageData();
+    const isReferenceDefinitionHash = (token) => {
+      const definition = definitions.get(token.text.trim());
+      return (definition && (definition[1] === "#"));
+    };
+    const links = filterByTypesCached([ "link" ]);
+    for (const link of links) {
+      const labelText = getDescendantsByType(link, [ "label", "labelText" ]);
+      const reference = getDescendantsByType(link, [ "reference" ]);
+      const resource = getDescendantsByType(link, [ "resource" ]);
+      const referenceString = getDescendantsByType(reference, [ "referenceString" ]);
+      const resourceDestinationString = getDescendantsByType(resource, [ "resourceDestination", [ "resourceDestinationLiteral", "resourceDestinationRaw" ], "resourceDestinationString" ]);
+      const hasLabelText = labelText.length > 0;
+      const hasReference = reference.length > 0;
+      const hasResource = resource.length > 0;
+      const hasReferenceString = referenceString.length > 0;
+      const hasResourceDestinationString = resourceDestinationString.length > 0;
+      let error = false;
+      if (
+        hasLabelText &&
+        ((!hasReference && !hasResource) || (hasReference && !hasReferenceString))
+      ) {
+        error = isReferenceDefinitionHash(labelText[0]);
+      } else if (hasReferenceString && !hasResourceDestinationString) {
+        error = isReferenceDefinitionHash(referenceString[0]);
+      } else if (!hasReferenceString && hasResourceDestinationString) {
+        error = (resourceDestinationString[0].text.trim() === "#");
+      } else if (!hasReferenceString && !hasResourceDestinationString) {
+        error = true;
       }
-    });
+      if (error) {
+        addErrorContext(
+          onError,
+          link.startLine,
+          link.text,
+          undefined,
+          undefined,
+          [ link.startColumn, link.endColumn - link.startColumn ]
+        );
+      }
+    }
   }
 };

package/lib/md043.js

@@ -2,8 +2,9 @@
 
 "use strict";
 
-const { addErrorContext, addErrorDetailIf, forEachHeading } =
-  require("../helpers");
+const { addErrorContext, addErrorDetailIf } = require("../helpers");
+const { getHeadingLevel, getHeadingText } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -11,7 +12,7 @@ module.exports = {
   "names": [ "MD043", "required-headings" ],
   "description": "Required heading structure",
   "tags": [ "headings" ],
-  "parser": "markdownit",
+  "parser": "micromark",
   "function": function MD043(params, onError) {
     const requiredHeadings = params.config.headings;
     if (!Array.isArray(requiredHeadings)) {
@@ -19,20 +20,18 @@ module.exports = {
       return;
     }
     const matchCase = params.config.match_case || false;
-    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]";
     const handleCase = (str) => (matchCase ? str : str.toLowerCase());
-    forEachHeading(params, (heading, content) => {
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
       if (!hasError) {
+        const headingText = getHeadingText(heading);
+        const headingLevel = getHeadingLevel(heading);
         anyHeadings = true;
-        const actual = levels[heading.tag] + " " + content;
+        const actual = `${"".padEnd(headingLevel, "#")} ${headingText}`;
         const expected = getExpected();
         if (expected === "*") {
           const nextExpected = getExpected();
@@ -47,12 +46,16 @@ module.exports = {
         } else if (matchAny) {
           i--;
         } else {
-          addErrorDetailIf(onError, heading.lineNumber,
-            expected, actual);
+          addErrorDetailIf(
+            onError,
+            heading.startLine,
+            expected,
+            actual
+          );
           hasError = true;
         }
       }
-    });
+    }
     const extraHeadings = requiredHeadings.length - i;
     if (
       !hasError &&
@@ -60,8 +63,11 @@ module.exports = {
         ((extraHeadings === 1) && (requiredHeadings[i] !== "*"))) &&
       (anyHeadings || !requiredHeadings.every((heading) => heading === "*"))
     ) {
-      addErrorContext(onError, params.lines.length,
-        requiredHeadings[i]);
+      addErrorContext(
+        onError,
+        params.lines.length,
+        requiredHeadings[i]
+      );
     }
   }
 };

package/lib/md044.js

@@ -2,10 +2,9 @@
 
 "use strict";
 
-const { addErrorDetailIf, escapeForRegExp, withinAnyRange } =
-  require("../helpers");
-const { filterByPredicate, filterByTypes, parse } =
-  require("../helpers/micromark.cjs");
+const { addErrorDetailIf, escapeForRegExp, hasOverlap } = require("../helpers");
+const { filterByPredicate, filterByTypes } = require("../helpers/micromark-helpers.cjs");
+const { parse } = require("../helpers/micromark-parse.cjs");
 
 const ignoredChildTypes = new Set(
   [ "codeFencedFence", "definition", "reference", "resource" ]
@@ -32,11 +31,6 @@ module.exports = {
     const htmlElements = params.config.html_elements;
     const includeHtmlElements =
       (htmlElements === undefined) ? true : !!htmlElements;
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
     const scannedTypes = new Set([ "data" ]);
     if (includeCodeBlocks) {
       scannedTypes.add("codeFlowValue");
@@ -48,56 +42,60 @@ module.exports = {
     }
     const contentTokens =
       filterByPredicate(
-        micromarkTokens,
+        params.parsers.micromark.tokens,
         (token) => scannedTypes.has(token.type),
         (token) => (
           token.children.filter((t) => !ignoredChildTypes.has(t.type))
         )
       );
+    /** @type {import("../helpers").FileRange[]} */
     const exclusions = [];
-    const autoLinked = new Set();
+    const scannedTokens = new Set();
     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 namePattern = `(${startNamePattern})(${escapedName})${endNamePattern}`;
       const nameRe = new RegExp(namePattern, "gi");
       for (const token of contentTokens) {
         let match = null;
         while ((match = nameRe.exec(token.text)) !== null) {
           const [ , leftMatch, nameMatch ] = match;
-          const index = token.startColumn - 1 + match.index + leftMatch.length;
+          const column = token.startColumn + match.index + leftMatch.length;
           const length = nameMatch.length;
-          const lineIndex = token.startLine - 1;
+          const lineNumber = token.startLine;
+          /** @type {import("../helpers").FileRange} */
+          const nameRange = {
+            "startLine": lineNumber,
+            "startColumn": column,
+            "endLine": lineNumber,
+            "endColumn": column + length - 1
+          };
           if (
-            !withinAnyRange(exclusions, lineIndex, index, length) &&
-            !names.includes(nameMatch)
+            !names.includes(nameMatch) &&
+            !exclusions.some((exclusion) => hasOverlap(exclusion, nameRange))
           ) {
-            let urlRanges = [];
-            if (!autoLinked.has(token)) {
-              urlRanges = filterByTypes(
-                parse(token.text),
-                [ "literalAutolink" ]
-              ).map(
-                (t) => [
-                  lineIndex,
-                  token.startColumn - 1 + t.startColumn - 1,
-                  t.endColumn - t.startColumn
-                ]
-              );
-              exclusions.push(...urlRanges);
-              autoLinked.add(token);
+            /** @type {import("../helpers").FileRange[]} */
+            let autolinkRanges = [];
+            if (!scannedTokens.has(token)) {
+              autolinkRanges = filterByTypes(parse(token.text), [ "literalAutolink" ])
+                .map((tok) => ({
+                  "startLine": lineNumber,
+                  "startColumn": token.startColumn + tok.startColumn - 1,
+                  "endLine": lineNumber,
+                  "endColumn": token.endColumn + tok.endColumn - 1
+                }));
+              exclusions.push(...autolinkRanges);
+              scannedTokens.add(token);
             }
-            if (!withinAnyRange(urlRanges, lineIndex, index, length)) {
-              const column = index + 1;
+            if (!autolinkRanges.some((autolinkRange) => hasOverlap(autolinkRange, nameRange))) {
               addErrorDetailIf(
                 onError,
                 token.startLine,
                 name,
                 nameMatch,
-                null,
-                null,
+                undefined,
+                undefined,
                 [ column, length ],
                 {
                   "editColumn": column,
@@ -107,7 +105,7 @@ module.exports = {
               );
             }
           }
-          exclusions.push([ lineIndex, index, length ]);
+          exclusions.push(nameRange);
         }
       }
     }

package/lib/md045.js

@@ -3,7 +3,8 @@
 "use strict";
 
 const { addError, getHtmlAttributeRe, nextLinesRe } = require("../helpers");
-const { filterByTypes, getHtmlTagInfo } = require("../helpers/micromark.cjs");
+const { getHtmlTagInfo, getDescendantsByType } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const altRe = getHtmlAttributeRe("alt");
 
@@ -15,16 +16,10 @@ module.exports = {
   "tags": [ "accessibility", "images" ],
   "parser": "micromark",
   "function": function MD045(params, onError) {
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
-
     // Process Markdown images
-    const images = filterByTypes(micromarkTokens, [ "image" ]);
+    const images = filterByTypesCached([ "image" ]);
     for (const image of images) {
-      const labelTexts = filterByTypes(image.children, [ "labelText" ]);
+      const labelTexts = getDescendantsByType(image, [ "label", "labelText" ]);
       if (labelTexts.some((labelText) => labelText.text.length === 0)) {
         const range = (image.startLine === image.endLine) ?
           [ image.startColumn, image.endColumn - image.startColumn ] :
@@ -40,7 +35,7 @@ module.exports = {
     }
 
     // Process HTML images
-    const htmlTexts = filterByTypes(micromarkTokens, [ "htmlText" ]);
+    const htmlTexts = filterByTypesCached([ "htmlText" ], true);
     for (const htmlText of htmlTexts) {
       const { startColumn, startLine, text } = htmlText;
       const htmlTagInfo = getHtmlTagInfo(htmlText);

package/lib/md046.js

@@ -3,7 +3,7 @@
 "use strict";
 
 const { addErrorDetailIf } = require("../helpers");
-const { filterByTypes } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const tokenTypeToStyle = {
   "codeFenced": "fenced",
@@ -19,13 +19,7 @@ module.exports = {
   "parser": "micromark",
   "function": function MD046(params, onError) {
     let expectedStyle = String(params.config.style || "consistent");
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
-    const codeBlocksAndFences = filterByTypes(micromarkTokens, [ "codeFenced", "codeIndented" ]);
-    for (const token of codeBlocksAndFences) {
+    for (const token of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
       const { startLine, type } = token;
       if (expectedStyle === "consistent") {
         expectedStyle = tokenTypeToStyle[type];

package/lib/md048.js

@@ -2,8 +2,24 @@
 
 "use strict";
 
-const { addErrorDetailIf, fencedCodeBlockStyleFor } = require("../helpers");
-const { filterByTypes, tokenIfType } = require("../helpers/micromark.cjs");
+const { addErrorDetailIf } = require("../helpers");
+const { getDescendantsByType } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
+
+/**
+ * Return the string representation of a fence markup character.
+ *
+ * @param {string} markup Fence string.
+ * @returns {"tilde" | "backtick"} String representation.
+ */
+function fencedCodeBlockStyleFor(markup) {
+  switch (markup[0]) {
+    case "~":
+      return "tilde";
+    default:
+      return "backtick";
+  }
+};
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -14,30 +30,21 @@ module.exports = {
   "parser": "micromark",
   "function": function MD048(params, onError) {
     const style = String(params.config.style || "consistent");
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
     let expectedStyle = style;
-    const codeFenceds = filterByTypes(micromarkTokens, [ "codeFenced" ]);
+    const codeFenceds = filterByTypesCached([ "codeFenced" ]);
     for (const codeFenced of codeFenceds) {
-      const codeFencedFence = tokenIfType(codeFenced.children[0], "codeFencedFence");
-      if (codeFencedFence) {
-        const codeFencedFenceSequence = tokenIfType(codeFencedFence.children[0], "codeFencedFenceSequence");
-        if (codeFencedFenceSequence) {
-          const { startLine, text } = codeFencedFenceSequence;
-          if (expectedStyle === "consistent") {
-            expectedStyle = fencedCodeBlockStyleFor(text);
-          }
-          addErrorDetailIf(
-            onError,
-            startLine,
-            expectedStyle,
-            fencedCodeBlockStyleFor(text)
-          );
-        }
+      const codeFencedFenceSequence =
+        getDescendantsByType(codeFenced, [ "codeFencedFence", "codeFencedFenceSequence" ])[0];
+      const { startLine, text } = codeFencedFenceSequence;
+      if (expectedStyle === "consistent") {
+        expectedStyle = fencedCodeBlockStyleFor(text);
       }
+      addErrorDetailIf(
+        onError,
+        startLine,
+        expectedStyle,
+        fencedCodeBlockStyleFor(text)
+      );
     }
   }
 };