markdownlint 0.34.0 → 0.36.0

package/lib/markdownlint.js

@@ -4,9 +4,8 @@
 
 const path = require("node:path");
 const { promisify } = require("node:util");
-const markdownit = require("markdown-it");
-const micromark = require("../helpers/micromark.cjs");
-// const { deprecatedRuleNames } = require("./constants");
+const micromark = require("../helpers/micromark-parse.cjs");
+const { version } = require("./constants");
 const rules = require("./rules");
 const helpers = require("../helpers");
 const cache = require("./cache");
@@ -32,7 +31,7 @@ function validateRuleList(ruleList, synchronous) {
   const allIds = {};
   for (const [ index, rule ] of ruleList.entries()) {
     const customIndex = index - rules.length;
-    // eslint-disable-next-line no-inner-declarations, jsdoc/require-jsdoc
+    // eslint-disable-next-line jsdoc/require-jsdoc
     function newError(property, value) {
       return new Error(
         `Property '${property}' of custom rule at index ${customIndex} is incorrect: '${value}'.`);
@@ -59,7 +58,7 @@ function validateRuleList(ruleList, synchronous) {
       !result &&
       (rule.parser !== undefined) &&
       (rule.parser !== "markdownit") &&
-      !((customIndex < 0) && (rule.parser === "micromark")) &&
+      (rule.parser !== "micromark") &&
       (rule.parser !== "none")
     ) {
       result = newError("parser", rule.parser);
@@ -198,83 +197,6 @@ function removeFrontMatter(content, frontMatter) {
   };
 }
 
-/**
- * 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 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;
-    } else if (token.type === "tr_close") {
-      trMap = null;
-    }
-    if (!token.map && trMap) {
-      token.map = [ ...trMap ];
-    }
-    // Update token metadata
-    if (token.map) {
-      token.line = lines[token.map[0]];
-      token.lineNumber = token.map[0] + 1;
-      // Trim bottom of token to exclude whitespace lines
-      while (token.map[1] && !((lines[token.map[1] - 1] || "").trim())) {
-        token.map[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++;
-        } else if (child.type === "code_inline") {
-          lineNumber += codeSpanExtraLines.shift();
-        }
-      }
-    }
-    freezeToken(token);
-  }
-  Object.freeze(tokens);
-}
-
 /**
  * Map rule names/tags to canonical rule name.
  *
@@ -507,10 +429,18 @@ function getEnabledRulesPerLineNumber(
   handleInlineConfig(lines, enableDisableFile);
   handleInlineConfig(lines, captureRestoreEnableDisable, updateLineState);
   handleInlineConfig(lines, disableLineNextLine);
+  // Create the list of rules that are used at least once
+  const enabledRuleList = [];
+  for (const [ index, ruleName ] of allRuleNames.entries()) {
+    if (enabledRulesPerLineNumber.some((enabledRulesForLine) => enabledRulesForLine[ruleName])) {
+      enabledRuleList.push(ruleList[index]);
+    }
+  }
   // Return results
   return {
     effectiveConfig,
-    enabledRulesPerLineNumber
+    enabledRulesPerLineNumber,
+    enabledRuleList
   };
 }
 
@@ -522,7 +452,7 @@ function getEnabledRulesPerLineNumber(
  * names.
  * @param {string} name Identifier for the content.
  * @param {string} content Markdown content.
- * @param {Object} md Instance of markdown-it.
+ * @param {Plugin[]} markdownItPlugins Additional plugins.
  * @param {Configuration} config Configuration object.
  * @param {ConfigurationParser[] | null} configParsers Configuration parsers.
  * @param {RegExp | null} frontMatter Regular expression for front matter.
@@ -537,7 +467,7 @@ function lintContent(
   aliasToRuleNames,
   name,
   content,
-  md,
+  markdownItPlugins,
   config,
   configParsers,
   frontMatter,
@@ -552,7 +482,7 @@ function lintContent(
   const { frontMatterLines } = removeFrontMatterResult;
   content = removeFrontMatterResult.content;
   // Get enabled rules per line (with HTML comments present)
-  const { effectiveConfig, enabledRulesPerLineNumber } =
+  const { effectiveConfig, enabledRulesPerLineNumber, enabledRuleList } =
     getEnabledRulesPerLineNumber(
       ruleList,
       content.split(helpers.newLineRe),
@@ -562,14 +492,23 @@ function lintContent(
       configParsers,
       aliasToRuleNames
     );
+  const needMarkdownItTokens = enabledRuleList.some(
+    (rule) => (rule.parser === "markdownit") || (rule.parser === undefined)
+  );
+  const customRulesPresent = (ruleList.length !== rules.length);
   // Parse content into parser tokens
-  const markdownitTokens = md.parse(content, {});
-  const micromarkTokens = micromark.parse(content);
+  const micromarkTokens = micromark.parse(
+    content,
+    { "freezeTokens": customRulesPresent }
+  );
   // Hide the content of HTML comments from rules
+  const preClearedContent = content;
   content = helpers.clearHtmlCommentText(content);
-  // Parse content into lines and update markdown-it tokens
+  // Parse content into lines and get markdown-it tokens
   const lines = content.split(helpers.newLineRe);
-  annotateAndFreezeTokens(markdownitTokens, lines);
+  const markdownitTokens = needMarkdownItTokens ?
+    require("./markdownit.cjs").getMarkdownItTokens(markdownItPlugins, preClearedContent, lines) :
+    [];
   // Create (frozen) parameters for rules
   /** @type {MarkdownParsers} */
   // @ts-ignore
@@ -590,23 +529,14 @@ function lintContent(
   const parsersNone = Object.freeze({});
   const paramsBase = {
     name,
-    "parsers": parsersMarkdownIt,
+    version,
     "lines": Object.freeze(lines),
     "frontMatterLines": Object.freeze(frontMatterLines)
   };
-  const lineMetadata =
-    helpers.getLineMetadata(paramsBase);
-  const codeBlockAndSpanRanges =
-    helpers.codeBlockAndSpanRanges(paramsBase, lineMetadata);
-  const flattenedLists =
-    helpers.flattenLists(markdownitTokens);
-  const referenceLinkImageData =
-    helpers.getReferenceLinkImageData(micromarkTokens);
-  cache.set({
-    codeBlockAndSpanRanges,
-    flattenedLists,
-    lineMetadata,
-    referenceLinkImageData
+  cache.initialize({
+    ...paramsBase,
+    "parsers": parsersMicromark,
+    "config": null
   });
   // Function to run for each rule
   let results = [];
@@ -800,8 +730,8 @@ function lintContent(
     return results;
   }
   // Run all rules
-  const ruleListAsync = ruleList.filter((rule) => rule.asynchronous);
-  const ruleListSync = ruleList.filter((rule) => !rule.asynchronous);
+  const ruleListAsync = enabledRuleList.filter((rule) => rule.asynchronous);
+  const ruleListSync = enabledRuleList.filter((rule) => !rule.asynchronous);
   const ruleListAsyncFirst = [
     ...ruleListAsync,
     ...ruleListSync
@@ -821,7 +751,7 @@ function lintContent(
   } catch (error) {
     callbackError(error);
   } finally {
-    cache.clear();
+    cache.initialize();
   }
 }
 
@@ -832,7 +762,7 @@ function lintContent(
  * @param {Object.<string, string[]>} aliasToRuleNames Map of alias to rule
  * names.
  * @param {string} file Path of file to lint.
- * @param {Object} md Instance of markdown-it.
+ * @param {Plugin[]} markdownItPlugins Additional plugins.
  * @param {Configuration} config Configuration object.
  * @param {ConfigurationParser[] | null} configParsers Configuration parsers.
  * @param {RegExp | null} frontMatter Regular expression for front matter.
@@ -848,7 +778,7 @@ function lintFile(
   ruleList,
   aliasToRuleNames,
   file,
-  md,
+  markdownItPlugins,
   config,
   configParsers,
   frontMatter,
@@ -868,7 +798,7 @@ function lintFile(
       aliasToRuleNames,
       file,
       content,
-      md,
+      markdownItPlugins,
       config,
       configParsers,
       frontMatter,
@@ -928,17 +858,14 @@ function lintInput(options, synchronous, callback) {
   const config = options.config || { "default": true };
   const configParsers = options.configParsers || null;
   const frontMatter = (options.frontMatter === undefined) ?
-    helpers.frontMatterRe : options.frontMatter;
+    helpers.frontMatterRe :
+    options.frontMatter;
   const handleRuleFailures = !!options.handleRuleFailures;
   const noInlineConfig = !!options.noInlineConfig;
   const resultVersion = (options.resultVersion === undefined) ?
-    3 : options.resultVersion;
-  const md = markdownit({ "html": true });
+    3 :
+    options.resultVersion;
   const markdownItPlugins = options.markdownItPlugins || [];
-  for (const plugin of markdownItPlugins) {
-    // @ts-ignore
-    md.use(...plugin);
-  }
   const fs = options.fs || require("node:fs");
   const aliasToRuleNames = mapAliasToRuleNames(ruleList);
   const results = newResults(ruleList);
@@ -970,7 +897,7 @@ function lintInput(options, synchronous, callback) {
         ruleList,
         aliasToRuleNames,
         currentItem,
-        md,
+        markdownItPlugins,
         config,
         configParsers,
         frontMatter,
@@ -989,7 +916,7 @@ function lintInput(options, synchronous, callback) {
         aliasToRuleNames,
         currentItem,
         strings[currentItem] || "",
-        md,
+        markdownItPlugins,
         config,
         configParsers,
         frontMatter,
@@ -1281,13 +1208,126 @@ function readConfigSync(file, parsers, fs) {
   return config;
 }
 
+/**
+ * Normalizes the fields of a RuleOnErrorFixInfo instance.
+ *
+ * @param {RuleOnErrorFixInfo} fixInfo RuleOnErrorFixInfo instance.
+ * @param {number} [lineNumber] Line number.
+ * @returns {RuleOnErrorFixInfoNormalized} Normalized RuleOnErrorFixInfo instance.
+ */
+function normalizeFixInfo(fixInfo, lineNumber = 0) {
+  return {
+    "lineNumber": fixInfo.lineNumber || lineNumber,
+    "editColumn": fixInfo.editColumn || 1,
+    "deleteCount": fixInfo.deleteCount || 0,
+    "insertText": fixInfo.insertText || ""
+  };
+}
+
+/**
+ * Applies the specified fix to a Markdown content line.
+ *
+ * @param {string} line Line of Markdown content.
+ * @param {RuleOnErrorFixInfo} fixInfo RuleOnErrorFixInfo instance.
+ * @param {string} [lineEnding] Line ending to use.
+ * @returns {string | null} Fixed content or null if deleted.
+ */
+function applyFix(line, fixInfo, lineEnding = "\n") {
+  const { editColumn, deleteCount, insertText } = normalizeFixInfo(fixInfo);
+  const editIndex = editColumn - 1;
+  return (deleteCount === -1) ?
+    null :
+    line.slice(0, editIndex) + insertText.replace(/\n/g, lineEnding) + line.slice(editIndex + deleteCount);
+}
+
+/**
+ * Applies as many of the specified fixes as possible to Markdown content.
+ *
+ * @param {string} input Lines of Markdown content.
+ * @param {RuleOnErrorInfo[]} errors RuleOnErrorInfo instances.
+ * @returns {string} Fixed content.
+ */
+function applyFixes(input, errors) {
+  const lineEnding = helpers.getPreferredLineEnding(input, require("node:os"));
+  const lines = input.split(helpers.newLineRe);
+  // Normalize fixInfo objects
+  let fixInfos = errors
+    .filter((error) => error.fixInfo)
+    // @ts-ignore
+    .map((error) => normalizeFixInfo(error.fixInfo, error.lineNumber));
+  // Sort bottom-to-top, line-deletes last, right-to-left, long-to-short
+  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)
+  // eslint-disable-next-line jsdoc/valid-types
+  /** @type RuleOnErrorFixInfo */
+  let lastFixInfo = {};
+  fixInfos = fixInfos.filter((fixInfo) => {
+    const unique = (
+      (fixInfo.lineNumber !== lastFixInfo.lineNumber) ||
+      (fixInfo.editColumn !== lastFixInfo.editColumn) ||
+      (fixInfo.deleteCount !== lastFixInfo.deleteCount) ||
+      (fixInfo.insertText !== lastFixInfo.insertText)
+    );
+    lastFixInfo = fixInfo;
+    return unique;
+  });
+  // Collapse insert/no-delete and no-insert/delete for same line/column
+  lastFixInfo = {
+    "lineNumber": -1
+  };
+  for (const fixInfo of fixInfos) {
+    if (
+      (fixInfo.lineNumber === lastFixInfo.lineNumber) &&
+      (fixInfo.editColumn === lastFixInfo.editColumn) &&
+      !fixInfo.insertText &&
+      (fixInfo.deleteCount > 0) &&
+      lastFixInfo.insertText &&
+      !lastFixInfo.deleteCount) {
+      fixInfo.insertText = lastFixInfo.insertText;
+      lastFixInfo.lineNumber = 0;
+    }
+    lastFixInfo = fixInfo;
+  }
+  fixInfos = fixInfos.filter((fixInfo) => fixInfo.lineNumber);
+  // Apply all (remaining/updated) fixes
+  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((line) => line !== null).join(lineEnding);
+}
+
 /**
  * Gets the (semantic) version of the library.
  *
  * @returns {string} SemVer string.
  */
 function getVersion() {
-  return require("./constants").version;
+  return version;
 }
 
 // Export a/synchronous/Promise APIs
@@ -1300,6 +1340,8 @@ markdownlint.promises = {
   "extendConfig": extendConfigPromise,
   "readConfig": readConfigPromise
 };
+markdownlint.applyFix = applyFix;
+markdownlint.applyFixes = applyFixes;
 module.exports = markdownlint;
 
 // Type declarations
@@ -1324,6 +1366,7 @@ module.exports = markdownlint;
  * @property {readonly string[]} lines File/string lines.
  * @property {readonly string[]} frontMatterLines Front matter lines.
  * @property {RuleConfiguration} config Rule configuration.
+ * @property {string} version Version of the markdownlint library.
  */
 
 /* eslint-enable jsdoc/valid-types */
@@ -1417,6 +1460,16 @@ module.exports = markdownlint;
  * @property {string} [insertText] Text to insert (after deleting).
  */
 
+/**
+ * RuleOnErrorInfo with all optional properties present.
+ *
+ * @typedef {Object} RuleOnErrorFixInfoNormalized
+ * @property {number} lineNumber Line number (1-based).
+ * @property {number} editColumn Column of the fix (1-based).
+ * @property {number} deleteCount Count of characters to delete.
+ * @property {string} insertText Text to insert (after deleting).
+ */
+
 /**
  * Rule definition.
  *
@@ -1517,6 +1570,13 @@ module.exports = markdownlint;
  * @typedef {import("./configuration").Configuration} Configuration
  */
 
+/**
+ * Configuration object for linting rules strictly. For the JSON schema, see
+ * {@link ../schema/markdownlint-config-schema-strict.json}.
+ *
+ * @typedef {import("./configuration-strict").ConfigurationStrict} ConfigurationStrict
+ */
+
 /**
  * Rule configuration object.
  *

package/lib/md001.js

@@ -2,7 +2,9 @@
 
 "use strict";
 
-const { addErrorDetailIf, filterTokens } = require("../helpers");
+const { addErrorDetailIf } = require("../helpers");
+const { getHeadingLevel } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -10,16 +12,20 @@ module.exports = {
   "names": [ "MD001", "heading-increment" ],
   "description": "Heading levels should only increment by one level at a time",
   "tags": [ "headings" ],
-  "parser": "markdownit",
+  "parser": "micromark",
   "function": function MD001(params, onError) {
-    let prevLevel = 0;
-    filterTokens(params, "heading_open", function forToken(token) {
-      const level = Number.parseInt(token.tag.slice(1), 10);
-      if (prevLevel && (level > prevLevel)) {
-        addErrorDetailIf(onError, token.lineNumber,
-          "h" + (prevLevel + 1), "h" + level);
+    let prevLevel = Number.MAX_SAFE_INTEGER;
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      const level = getHeadingLevel(heading);
+      if (level > prevLevel) {
+        addErrorDetailIf(
+          onError,
+          heading.startLine,
+          `h${prevLevel + 1}`,
+          `h${level}`
+        );
       }
       prevLevel = level;
-    });
+    }
   }
 };

package/lib/md003.js

@@ -2,8 +2,9 @@
 
 "use strict";
 
-const { addErrorDetailIf, filterTokens, headingStyleFor } =
-  require("../helpers");
+const { addErrorDetailIf } = require("../helpers");
+const { getHeadingLevel, getHeadingStyle } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -11,16 +12,16 @@ module.exports = {
   "names": [ "MD003", "heading-style" ],
   "description": "Heading style",
   "tags": [ "headings" ],
-  "parser": "markdownit",
+  "parser": "micromark",
   "function": function MD003(params, onError) {
     let style = String(params.config.style || "consistent");
-    filterTokens(params, "heading_open", function forToken(token) {
-      const styleForToken = headingStyleFor(token);
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      const styleForToken = getHeadingStyle(heading);
       if (style === "consistent") {
         style = styleForToken;
       }
       if (styleForToken !== style) {
-        const h12 = /h[12]/.test(token.tag);
+        const h12 = getHeadingLevel(heading) <= 2;
         const setextWithAtx =
           (style === "setext_with_atx") &&
             ((h12 && (styleForToken === "setext")) ||
@@ -36,10 +37,14 @@ module.exports = {
           } else if (style === "setext_with_atx_closed") {
             expected = h12 ? "setext" : "atx_closed";
           }
-          addErrorDetailIf(onError, token.lineNumber,
-            expected, styleForToken);
+          addErrorDetailIf(
+            onError,
+            heading.startLine,
+            expected,
+            styleForToken
+          );
         }
       }
-    });
+    }
   }
 };

package/lib/md004.js

@@ -2,11 +2,16 @@
 
 "use strict";
 
-const { addErrorDetailIf, listItemMarkerRe, unorderedListStyleFor } =
-  require("../helpers");
-const { flattenedLists } = require("./cache");
+const { addErrorDetailIf } = require("../helpers");
+const { getDescendantsByType, getParentOfType } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
-const expectedStyleToMarker = {
+const markerToStyle = {
+  "-": "dash",
+  "+": "plus",
+  "*": "asterisk"
+};
+const styleToMarker = {
   "dash": "-",
   "plus": "+",
   "asterisk": "*"
@@ -16,7 +21,13 @@ const differentItemStyle = {
   "plus": "asterisk",
   "asterisk": "dash"
 };
-const validStyles = Object.keys(expectedStyleToMarker);
+const validStyles = new Set([
+  "asterisk",
+  "consistent",
+  "dash",
+  "plus",
+  "sublist"
+]);
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -24,55 +35,51 @@ module.exports = {
   "names": [ "MD004", "ul-style" ],
   "description": "Unordered list style",
   "tags": [ "bullet", "ul" ],
-  "parser": "none",
+  "parser": "micromark",
   "function": function MD004(params, onError) {
     const style = String(params.config.style || "consistent");
-    let expectedStyle = style;
+    let expectedStyle = validStyles.has(style) ? style : "dash";
     const nestingStyles = [];
-    for (const list of flattenedLists()) {
-      if (list.unordered) {
-        if (expectedStyle === "consistent") {
-          expectedStyle = unorderedListStyleFor(list.items[0]);
+    for (const listUnordered of filterByTypesCached([ "listUnordered" ])) {
+      let nesting = 0;
+      if (style === "sublist") {
+        /** @type {import("../helpers/micromark-helpers.cjs").Token | null} */
+        let parent = listUnordered;
+        // @ts-ignore
+        while ((parent = getParentOfType(parent, [ "listOrdered", "listUnordered" ]))) {
+          nesting++;
         }
-        for (const item of list.items) {
-          const itemStyle = unorderedListStyleFor(item);
-          if (style === "sublist") {
-            const nesting = list.nesting;
-            if (!nestingStyles[nesting]) {
-              nestingStyles[nesting] =
-                (itemStyle === nestingStyles[nesting - 1]) ?
-                  differentItemStyle[itemStyle] :
-                  itemStyle;
-            }
-            expectedStyle = nestingStyles[nesting];
-          }
-          if (!validStyles.includes(expectedStyle)) {
-            expectedStyle = validStyles[0];
-          }
-          let range = null;
-          let fixInfo = null;
-          const match = item.line.match(listItemMarkerRe);
-          if (match) {
-            const column = match.index + 1;
-            const length = match[0].length;
-            range = [ column, length ];
-            fixInfo = {
-              "editColumn": match[1].length + 1,
-              "deleteCount": 1,
-              "insertText": expectedStyleToMarker[expectedStyle]
-            };
+      }
+      const listItemMarkers = getDescendantsByType(listUnordered, [ "listItemPrefix", "listItemMarker" ]);
+      for (const listItemMarker of listItemMarkers) {
+        const itemStyle = markerToStyle[listItemMarker.text];
+        if (style === "sublist") {
+          if (!nestingStyles[nesting]) {
+            nestingStyles[nesting] =
+              (itemStyle === nestingStyles[nesting - 1]) ?
+                differentItemStyle[itemStyle] :
+                itemStyle;
           }
-          addErrorDetailIf(
-            onError,
-            item.lineNumber,
-            expectedStyle,
-            itemStyle,
-            null,
-            null,
-            range,
-            fixInfo
-          );
+          expectedStyle = nestingStyles[nesting];
+        } else if (expectedStyle === "consistent") {
+          expectedStyle = itemStyle;
         }
+        const column = listItemMarker.startColumn;
+        const length = listItemMarker.endColumn - listItemMarker.startColumn;
+        addErrorDetailIf(
+          onError,
+          listItemMarker.startLine,
+          expectedStyle,
+          itemStyle,
+          undefined,
+          undefined,
+          [ column, length ],
+          {
+            "editColumn": column,
+            "deleteCount": length,
+            "insertText": styleToMarker[expectedStyle]
+          }
+        );
       }
     }
   }