markdownlint 0.37.4 → 0.39.0

package/lib/md001.mjs

@@ -1,6 +1,6 @@
 // @ts-check
 
-import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { addErrorDetailIf, frontMatterHasTitle } from "../helpers/helpers.cjs";
 import { getHeadingLevel } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
@@ -11,7 +11,11 @@ export default {
   "tags": [ "headings" ],
   "parser": "micromark",
   "function": function MD001(params, onError) {
-    let prevLevel = Number.MAX_SAFE_INTEGER;
+    const hasTitle = frontMatterHasTitle(
+      params.frontMatterLines,
+      params.config.front_matter_title
+    );
+    let prevLevel = hasTitle ? 1 : Number.MAX_SAFE_INTEGER;
     for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
       const level = getHeadingLevel(heading);
       if (level > prevLevel) {

package/lib/md004.mjs

@@ -4,21 +4,9 @@ import { addErrorDetailIf } from "../helpers/helpers.cjs";
 import { getDescendantsByType, getParentOfType } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
-const markerToStyle = {
-  "-": "dash",
-  "+": "plus",
-  "*": "asterisk"
-};
-const styleToMarker = {
-  "dash": "-",
-  "plus": "+",
-  "asterisk": "*"
-};
-const differentItemStyle = {
-  "dash": "plus",
-  "plus": "asterisk",
-  "asterisk": "dash"
-};
+const markerToStyle = (/** @type {string} */ marker) => (marker === "-") ? "dash" : ((marker === "+") ? "plus" : "asterisk");
+const styleToMarker = (/** @type {string} */ style) => (style === "dash") ? "-" : ((style === "plus") ? "+" : "*");
+const differentItemStyle = (/** @type {string} */ style) => (style === "dash") ? "plus" : ((style === "plus") ? "asterisk" : "dash");
 const validStyles = new Set([
   "asterisk",
   "consistent",
@@ -36,6 +24,7 @@ export default {
   "function": function MD004(params, onError) {
     const style = String(params.config.style || "consistent");
     let expectedStyle = validStyles.has(style) ? style : "dash";
+    /** @type {("asterisk"|"dash"|"plus")[]} */
     const nestingStyles = [];
     for (const listUnordered of filterByTypesCached([ "listUnordered" ])) {
       let nesting = 0;
@@ -49,12 +38,12 @@ export default {
       }
       const listItemMarkers = getDescendantsByType(listUnordered, [ "listItemPrefix", "listItemMarker" ]);
       for (const listItemMarker of listItemMarkers) {
-        const itemStyle = markerToStyle[listItemMarker.text];
+        const itemStyle = markerToStyle(listItemMarker.text);
         if (style === "sublist") {
           if (!nestingStyles[nesting]) {
             nestingStyles[nesting] =
               (itemStyle === nestingStyles[nesting - 1]) ?
-                differentItemStyle[itemStyle] :
+                differentItemStyle(itemStyle) :
                 itemStyle;
           }
           expectedStyle = nestingStyles[nesting];
@@ -74,7 +63,7 @@ export default {
           {
             "editColumn": column,
             "deleteCount": length,
-            "insertText": styleToMarker[expectedStyle]
+            "insertText": styleToMarker(expectedStyle)
           }
         );
       }

package/lib/md007.mjs

@@ -53,8 +53,9 @@ export default {
         const nesting = unorderedListNesting.get(parent);
         if (nesting !== undefined) {
           // listItemPrefix for listUnordered
+          const baseIndent = (getParentOfType(token, [ "gfmFootnoteDefinition" ])) ? 4 : 0;
           const expectedIndent =
-            (startIndented ? startIndent : 0) + (nesting * indent);
+            baseIndent + (startIndented ? startIndent : 0) + (nesting * indent);
           const blockQuoteAdjustment =
             (lastBlockQuotePrefix?.endLine === startLine) ?
               (lastBlockQuotePrefix.endColumn - 1) :

package/lib/md009.mjs

@@ -13,14 +13,18 @@ export default {
   "function": function MD009(params, onError) {
     let brSpaces = params.config.br_spaces;
     brSpaces = Number((brSpaces === undefined) ? 2 : brSpaces);
+    const codeBlocks = params.config.code_blocks;
+    const includeCode = (codeBlocks === undefined) ? false : !!codeBlocks;
     const listItemEmptyLines = !!params.config.list_item_empty_lines;
     const strict = !!params.config.strict;
     const codeBlockLineNumbers = new Set();
-    for (const codeBlock of filterByTypesCached([ "codeFenced" ])) {
-      addRangeToSet(codeBlockLineNumbers, codeBlock.startLine + 1, codeBlock.endLine - 1);
-    }
-    for (const codeBlock of filterByTypesCached([ "codeIndented" ])) {
-      addRangeToSet(codeBlockLineNumbers, codeBlock.startLine, codeBlock.endLine);
+    if (!includeCode) {
+      for (const codeBlock of filterByTypesCached([ "codeFenced" ])) {
+        addRangeToSet(codeBlockLineNumbers, codeBlock.startLine + 1, codeBlock.endLine - 1);
+      }
+      for (const codeBlock of filterByTypesCached([ "codeIndented" ])) {
+        addRangeToSet(codeBlockLineNumbers, codeBlock.startLine, codeBlock.endLine);
+      }
     }
     const listItemLineNumbers = new Set();
     if (listItemEmptyLines) {

package/lib/md010.mjs

@@ -17,7 +17,7 @@ export default {
     const includeCode = (codeBlocks === undefined) ? true : !!codeBlocks;
     const ignoreCodeLanguages = new Set(
       (params.config.ignore_code_languages || [])
-        .map((language) => language.toLowerCase())
+        .map((/** @type {void} */ language) => String(language).toLowerCase())
     );
     const spacesPerTab = params.config.spaces_per_tab;
     const spaceMultiplier = (spacesPerTab === undefined) ?

package/lib/md022.mjs

@@ -4,15 +4,18 @@ import { addErrorDetailIf, isBlankLine } from "../helpers/helpers.cjs";
 import { getBlockQuotePrefixText, getHeadingLevel } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+
 const defaultLines = 1;
 
-const getLinesFunction = (linesParam) => {
+// eslint-disable-next-line jsdoc/reject-any-type
+const getLinesFunction = (/** @type {any} */ linesParam) => {
   if (Array.isArray(linesParam)) {
     const linesArray = new Array(6).fill(defaultLines);
     for (const [ index, value ] of [ ...linesParam.entries() ].slice(0, 6)) {
       linesArray[index] = value;
     }
-    return (heading) => linesArray[getHeadingLevel(heading) - 1];
+    return (/** @type {MicromarkToken} */ heading) => linesArray[getHeadingLevel(heading) - 1];
   }
   // Coerce linesParam to a number
   const lines = (linesParam === undefined) ? defaultLines : Number(linesParam);

package/lib/md025.mjs

@@ -1,7 +1,7 @@
 // @ts-check
 
 import { addErrorContext, frontMatterHasTitle } from "../helpers/helpers.cjs";
-import { getHeadingLevel, getHeadingText } from "../helpers/micromark-helpers.cjs";
+import { getHeadingLevel, getHeadingText, isDocfxTab, isHtmlFlowComment, nonContentTokens } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
 /** @type {import("markdownlint").Rule} */
@@ -12,24 +12,32 @@ export default {
   "parser": "micromark",
   "function": function MD025(params, onError) {
     const level = Number(params.config.level || 1);
-    const foundFrontMatterTitle =
-      frontMatterHasTitle(
-        params.frontMatterLines,
-        params.config.front_matter_title
-      );
-    let hasTopLevelHeading = false;
-    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
-      const headingLevel = getHeadingLevel(heading);
-      if (headingLevel === level) {
-        if (hasTopLevelHeading || foundFrontMatterTitle) {
-          const headingText = getHeadingText(heading);
+    const { tokens } = params.parsers.micromark;
+    const matchingHeadings = filterByTypesCached([ "atxHeading", "setextHeading" ])
+      .filter((heading) => (level === getHeadingLevel(heading)) && !isDocfxTab(heading));
+    if (matchingHeadings.length > 0) {
+      const foundFrontMatterTitle =
+        frontMatterHasTitle(
+          params.frontMatterLines,
+          params.config.front_matter_title
+        );
+      // Front matter title counts as a top-level heading if present
+      let hasTopLevelHeading = foundFrontMatterTitle;
+      if (!hasTopLevelHeading) {
+        // Check if the first matching heading is a top-level heading
+        const previousTokens = tokens.slice(0, tokens.indexOf(matchingHeadings[0]));
+        hasTopLevelHeading = previousTokens.every(
+          (token) => nonContentTokens.has(token.type) || isHtmlFlowComment(token)
+        );
+      }
+      if (hasTopLevelHeading) {
+        // All other matching headings are violations
+        for (const heading of matchingHeadings.slice(foundFrontMatterTitle ? 0 : 1)) {
           addErrorContext(
             onError,
             heading.startLine,
-            headingText
+            getHeadingText(heading)
           );
-        } else if (heading.startLine === 1) {
-          hasTopLevelHeading = true;
         }
       }
     }

package/lib/md027.mjs

@@ -1,8 +1,12 @@
 // @ts-check
 
 import { addErrorContext } from "../helpers/helpers.cjs";
+import { getParentOfType } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
+/** @type {import("../helpers/micromark-helpers.cjs").TokenType[]} */
+const listTypes = [ "listOrdered", "listUnordered" ];
+
 /** @type {import("markdownlint").Rule} */
 export default {
   "names": [ "MD027", "no-multiple-space-blockquote" ],
@@ -10,6 +14,8 @@ export default {
   "tags": [ "blockquote", "whitespace", "indentation" ],
   "parser": "micromark",
   "function": function MD027(params, onError) {
+    const listItems = params.config.list_items;
+    const includeListItems = (listItems === undefined) ? true : !!listItems;
     const { tokens } = params.parsers.micromark;
     for (const token of filterByTypesCached([ "linePrefix" ])) {
       const parent = token.parent;
@@ -17,7 +23,11 @@ export default {
       const siblings = parent?.children || tokens;
       if (
         !codeIndented &&
-        (siblings[siblings.indexOf(token) - 1]?.type === "blockQuotePrefix")
+        (siblings[siblings.indexOf(token) - 1]?.type === "blockQuotePrefix") &&
+        (includeListItems || (
+          !listTypes.includes(siblings[siblings.indexOf(token) + 1]?.type) &&
+          !getParentOfType(token, listTypes)
+        ))
       ) {
         const { startColumn, startLine, text } = token;
         const { length } = text;

package/lib/md029.mjs

@@ -11,13 +11,17 @@ const listStyleExamples = {
 };
 
 /**
- * Gets the value of an ordered list item prefix token.
+ * Gets the column and text of an ordered list item prefix token.
  *
  * @param {import("markdownlint").MicromarkToken} listItemPrefix List item prefix token.
- * @returns {number} List item value.
+ * @returns {{column: number, value: number}} List item value column and text.
  */
 function getOrderedListItemValue(listItemPrefix) {
-  return Number(getDescendantsByType(listItemPrefix, [ "listItemValue" ])[0].text);
+  const listItemValue = getDescendantsByType(listItemPrefix, [ "listItemValue" ])[0];
+  return {
+    "column": listItemValue.startColumn,
+    "value": Number(listItemValue.text)
+  };
 }
 
 /** @type {import("markdownlint").Rule} */
@@ -27,34 +31,40 @@ export default {
   "tags": [ "ol" ],
   "parser": "micromark",
   "function": function MD029(params, onError) {
-    const style = String(params.config.style || "one_or_ordered");
+    const style = String(params.config.style);
     for (const listOrdered of filterByTypesCached([ "listOrdered" ])) {
       const listItemPrefixes = getDescendantsByType(listOrdered, [ "listItemPrefix" ]);
       let expected = 1;
       let incrementing = false;
       // Check for incrementing number pattern 1/2/3 or 0/1/2
       if (listItemPrefixes.length >= 2) {
-        const firstValue = getOrderedListItemValue(listItemPrefixes[0]);
-        const secondValue = getOrderedListItemValue(listItemPrefixes[1]);
-        if ((secondValue !== 1) || (firstValue === 0)) {
+        const first = getOrderedListItemValue(listItemPrefixes[0]);
+        const second = getOrderedListItemValue(listItemPrefixes[1]);
+        if ((second.value !== 1) || (first.value === 0)) {
           incrementing = true;
-          if (firstValue === 0) {
+          if (first.value === 0) {
             expected = 0;
           }
         }
       }
       // Determine effective style
-      let listStyle = style;
-      if (listStyle === "one_or_ordered") {
-        listStyle = incrementing ? "ordered" : "one";
-      } else if (listStyle === "zero") {
+      const listStyle = ((style === "one") || (style === "ordered") || (style === "zero")) ?
+        style :
+        (incrementing ? "ordered" : "one");
+      if (listStyle === "zero") {
         expected = 0;
       } else if (listStyle === "one") {
         expected = 1;
       }
       // Validate each list item marker
       for (const listItemPrefix of listItemPrefixes) {
-        const actual = getOrderedListItemValue(listItemPrefix);
+        const orderedListItemValue = getOrderedListItemValue(listItemPrefix);
+        const actual = orderedListItemValue.value;
+        const fixInfo = {
+          "editColumn": orderedListItemValue.column,
+          "deleteCount": orderedListItemValue.value.toString().length,
+          "insertText": expected.toString()
+        };
         addErrorDetailIf(
           onError,
           listItemPrefix.startLine,
@@ -62,7 +72,8 @@ export default {
           actual,
           "Style: " + listStyleExamples[listStyle],
           undefined,
-          [ listItemPrefix.startColumn, listItemPrefix.endColumn - listItemPrefix.startColumn ]
+          [ listItemPrefix.startColumn, listItemPrefix.endColumn - listItemPrefix.startColumn ],
+          fixInfo
         );
         if (listStyle === "ordered") {
           expected++;

package/lib/md031.mjs

@@ -6,7 +6,6 @@ import { filterByTypesCached } from "./cache.mjs";
 
 const codeFencePrefixRe = /^(.*?)[`~]/;
 
-// eslint-disable-next-line jsdoc/valid-types
 /** @typedef {readonly string[]} ReadonlyStringArray */
 
 /**

package/lib/md032.mjs

@@ -4,7 +4,9 @@ import { addErrorContext, isBlankLine } from "../helpers/helpers.cjs";
 import { filterByPredicate, getBlockQuotePrefixText, nonContentTokens } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
-const isList = (token) => (
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+
+const isList = (/** @type {MicromarkToken} */ token) => (
   (token.type === "listOrdered") || (token.type === "listUnordered")
 );
 

package/lib/md033.mjs

@@ -1,9 +1,14 @@
 // @ts-check
 
 import { addError, nextLinesRe } from "../helpers/helpers.cjs";
-import { getHtmlTagInfo } from "../helpers/micromark-helpers.cjs";
+import { getHtmlTagInfo, getParentOfType } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
+/** @typedef {import("micromark-extension-gfm-table")} */
+
+// eslint-disable-next-line jsdoc/reject-any-type
+const toLowerCaseStringArray = (/** @type {any} */ arr) => Array.isArray(arr) ? arr.map((elm) => String(elm).toLowerCase()) : [];
+
 /** @type {import("markdownlint").Rule} */
 export default {
   "names": [ "MD033", "no-inline-html" ],
@@ -11,27 +16,30 @@ export default {
   "tags": [ "html" ],
   "parser": "micromark",
   "function": function MD033(params, onError) {
-    let allowedElements = params.config.allowed_elements;
-    allowedElements = Array.isArray(allowedElements) ? allowedElements : [];
-    allowedElements = allowedElements.map((element) => element.toLowerCase());
+    const allowedElements = toLowerCaseStringArray(params.config.allowed_elements);
+    // If not defined, use allowedElements for backward compatibility
+    const tableAllowedElements = toLowerCaseStringArray(params.config.table_allowed_elements || params.config.allowed_elements);
     for (const token of filterByTypesCached([ "htmlText" ], true)) {
       const htmlTagInfo = getHtmlTagInfo(token);
-      if (
-        htmlTagInfo &&
-        !htmlTagInfo.close &&
-        !allowedElements.includes(htmlTagInfo.name.toLowerCase())
-      ) {
-        const range = [
-          token.startColumn,
-          token.text.replace(nextLinesRe, "").length
-        ];
-        addError(
-          onError,
-          token.startLine,
-          "Element: " + htmlTagInfo.name,
-          undefined,
-          range
-        );
+      if (htmlTagInfo && !htmlTagInfo.close) {
+        const elementName = htmlTagInfo?.name.toLowerCase();
+        const inTable = !!getParentOfType(token, [ "table" ]);
+        if (
+          (inTable || !allowedElements.includes(elementName)) &&
+          (!inTable || !tableAllowedElements.includes(elementName))
+        ) {
+          const range = [
+            token.startColumn,
+            token.text.replace(nextLinesRe, "").length
+          ];
+          addError(
+            onError,
+            token.startLine,
+            "Element: " + htmlTagInfo.name,
+            undefined,
+            range
+          );
+        }
       }
     }
   }

package/lib/md034.mjs

@@ -3,6 +3,7 @@
 import { addErrorContext } from "../helpers/helpers.cjs";
 import { filterByPredicate, getHtmlTagInfo, inHtmlFlow } from "../helpers/micromark-helpers.cjs";
 
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
 /** @typedef {import("micromark-extension-gfm-autolink-literal")} */
 
 /** @type {import("markdownlint").Rule} */
@@ -12,7 +13,7 @@ export default {
   "tags": [ "links", "url" ],
   "parser": "micromark",
   "function": function MD034(params, onError) {
-    const literalAutolinks = (tokens) => (
+    const literalAutolinks = (/** @type {MicromarkToken[]} */ tokens) => (
       filterByPredicate(
         tokens,
         (token) => {

package/lib/md036.mjs

@@ -4,13 +4,20 @@ import { addErrorContext, allPunctuation } from "../helpers/helpers.cjs";
 import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
-/** @typedef {import("markdownlint").MicromarkTokenType} TokenType */
-/** @type {TokenType[][]} */
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+/** @typedef {import("markdownlint").MicromarkTokenType} MicromarkTokenType */
+
+/** @type {MicromarkTokenType[][]} */
 const emphasisTypes = [
   [ "emphasis", "emphasisText" ],
   [ "strong", "strongText" ]
 ];
 
+const isParagraphChildMeaningful = (/** @type {MicromarkToken} */ token) => !(
+  (token.type === "htmlText") ||
+  ((token.type === "data") && (token.text.trim().length === 0))
+);
+
 /** @type {import("markdownlint").Rule} */
 export default {
   "names": [ "MD036", "no-emphasis-as-heading" ],
@@ -22,9 +29,14 @@ export default {
     punctuation = String((punctuation === undefined) ? allPunctuation : punctuation);
     const punctuationRe = new RegExp("[" + punctuation + "]$");
     const paragraphTokens =
-      filterByTypesCached([ "paragraph" ])
+      filterByTypesCached([ "paragraph" ], true)
         .filter((token) =>
-          (token.parent?.type === "content") && !token.parent?.parent && (token.children.length === 1)
+          (token.parent?.type === "content") &&
+          (
+            !token.parent?.parent ||
+            ((token.parent?.parent?.type === "htmlFlow") && !token.parent?.parent?.parent)
+          ) &&
+          (token.children.filter(isParagraphChildMeaningful).length === 1)
         );
     for (const emphasisType of emphasisTypes) {
       const textTokens = getDescendantsByType(paragraphTokens, emphasisType);

package/lib/md037.mjs

@@ -50,15 +50,17 @@ export default {
           if (startMatch) {
             const [ startSpaceCharacter ] = startMatch;
             const startContext = `${marker}${startSpaceCharacter}`;
+            const column = startToken.endColumn;
+            const count = startSpaceCharacter.length - 1;
             addError(
               onError,
               startToken.startLine,
               undefined,
               startContext,
-              [ startToken.startColumn, startContext.length ],
+              [ column, count ],
               {
-                "editColumn": startToken.endColumn,
-                "deleteCount": startSpaceCharacter.length - 1
+                "editColumn": column,
+                "deleteCount": count
               }
             );
           }
@@ -71,16 +73,17 @@ export default {
           if (endMatch) {
             const [ endSpaceCharacter ] = endMatch;
             const endContext = `${endSpaceCharacter}${marker}`;
+            const column = endToken.startColumn - (endSpaceCharacter.length - 1);
+            const count = endSpaceCharacter.length - 1;
             addError(
               onError,
               endToken.startLine,
               undefined,
               endContext,
-              [ endToken.endColumn - endContext.length, endContext.length ],
+              [ column, count ],
               {
-                "editColumn":
-                  endToken.startColumn - (endSpaceCharacter.length - 1),
-                "deleteCount": endSpaceCharacter.length - 1
+                "editColumn": column,
+                "deleteCount": count
               }
             );
           }

package/lib/md038.mjs

@@ -4,19 +4,6 @@ import { addErrorContext } from "../helpers/helpers.cjs";
 import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
-const leftSpaceRe = /^\s(?:[^`]|$)/;
-const rightSpaceRe = /[^`]\s$/;
-const trimCodeText = (text, start, end) => {
-  text = text.replace(/^\s+$/, "");
-  if (start) {
-    text = text.replace(/^\s+?(\s`|\S)/, "$1");
-  }
-  if (end) {
-    text = text.replace(/(`\s|\S)\s+$/, "$1");
-  }
-  return text;
-};
-
 /** @type {import("markdownlint").Rule} */
 export default {
   "names": [ "MD038", "no-space-in-code" ],
@@ -26,65 +13,59 @@ export default {
   "function": function MD038(params, onError) {
     const codeTexts = filterByTypesCached([ "codeText" ]);
     for (const codeText of codeTexts) {
-      const sequences = getDescendantsByType(codeText, [ "codeTextSequence" ]);
-      const startSequence = sequences[0];
-      const endSequence = sequences[sequences.length - 1];
       const datas = getDescendantsByType(codeText, [ "codeTextData" ]);
-      const startData = datas[0];
-      const endData = datas[datas.length - 1];
-      if (startSequence && endSequence && startData && endData) {
-        const spaceLeft = leftSpaceRe.test(startData.text);
-        const spaceRight = rightSpaceRe.test(endData.text);
-        if (spaceLeft || spaceRight) {
-          let lineNumber = startSequence.startLine;
-          let range = undefined;
-          let fixInfo = undefined;
-          if (startSequence.startLine === endSequence.endLine) {
-            range = [
-              startSequence.startColumn,
-              endSequence.endColumn - startSequence.startColumn
-            ];
-            fixInfo = {
-              "editColumn": startSequence.endColumn,
-              "deleteCount": endSequence.startColumn - startSequence.endColumn,
-              "insertText": trimCodeText(startData.text, true, true)
-            };
-          } else if (spaceLeft && (startSequence.endLine === startData.startLine)) {
-            range = [
-              startSequence.startColumn,
-              startData.endColumn - startSequence.startColumn
-            ];
-            fixInfo = {
-              "editColumn": startSequence.endColumn,
-              "deleteCount": startData.endColumn - startData.startColumn,
-              "insertText": trimCodeText(startData.text, true, false)
-            };
-          } else if (spaceRight && (endData.text.trim().length > 0)) {
-            lineNumber = endSequence.endLine;
-            range = [
-              endData.startColumn,
-              endSequence.endColumn - endData.startColumn
-            ];
-            fixInfo = {
-              "editColumn": endData.startColumn,
-              "deleteCount": endData.endColumn - endData.startColumn,
-              "insertText": trimCodeText(endData.text, false, true)
-            };
-          }
-          if (range) {
-            const context = params
-              .lines[lineNumber - 1]
-              .substring(range[0] - 1, range[0] - 1 + range[1]);
-            addErrorContext(
-              onError,
-              lineNumber,
-              context,
-              spaceLeft,
-              spaceRight,
-              range,
-              fixInfo
-            );
-          }
+      if (datas.length > 0) {
+        const paddings = getDescendantsByType(codeText, [ "codeTextPadding" ]);
+        // Check for extra space at start of code
+        const startPadding = paddings[0];
+        const startData = datas[0];
+        const startMatch = /^(\s+)(\S)/.exec(startData.text) || [ null, "", "" ];
+        const startBacktick = (startMatch[2] === "`");
+        const startCount = startMatch[1].length - ((startBacktick && !startPadding) ? 1 : 0);
+        const startSpaces = startCount > 0;
+        // Check for extra space at end of code
+        const endPadding = paddings[paddings.length - 1];
+        const endData = datas[datas.length - 1];
+        const endMatch = /(\S)(\s+)$/.exec(endData.text) || [ null, "", "" ];
+        const endBacktick = (endMatch[1] === "`");
+        const endCount = endMatch[2].length - ((endBacktick && !endPadding) ? 1 : 0);
+        const endSpaces = endCount > 0;
+        // Check if safe to remove 1-space padding
+        const removePadding = startSpaces && endSpaces && startPadding && endPadding && !startBacktick && !endBacktick;
+        const context = codeText.text;
+        // If extra space at start, report violation
+        if (startSpaces) {
+          const startColumn = (removePadding ? startPadding : startData).startColumn;
+          const length = startCount + (removePadding ? startPadding.text.length : 0);
+          addErrorContext(
+            onError,
+            startData.startLine,
+            context,
+            true,
+            false,
+            [ startColumn, length ],
+            {
+              "editColumn": startColumn,
+              "deleteCount": length
+            }
+          );
+        }
+        // If extra space at end, report violation
+        if (endSpaces) {
+          const endColumn = (removePadding ? endPadding : endData).endColumn;
+          const length = endCount + (removePadding ? endPadding.text.length : 0);
+          addErrorContext(
+            onError,
+            endData.endLine,
+            context,
+            false,
+            true,
+            [ endColumn - length, length ],
+            {
+              "editColumn": endColumn - length,
+              "deleteCount": length
+            }
+          );
         }
       }
     }