markdownlint 0.20.0 → 0.20.4

package/lib/md014.js

@@ -1,53 +1,53 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorContext, filterTokens } = require("../helpers");
-
-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((type) => {
-      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) {
-            const match = dollarCommandRe.exec(line);
-            if (match) {
-              const column = match[1].length + 1;
-              const length = match[2].length;
-              dollarInstances.push([ i, lineTrim, column, length ]);
-            } else {
-              allDollars = false;
-            }
-          }
-        }
-        if (allDollars) {
-          dollarInstances.forEach((instance) => {
-            const [ i, lineTrim, column, length ] = instance;
-            addErrorContext(
-              onError,
-              i + 1,
-              lineTrim,
-              null,
-              null,
-              [ column, length ],
-              {
-                "editColumn": column,
-                "deleteCount": length
-              }
-            );
-          });
-        }
-      });
-    });
-  }
-};
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens } = require("../helpers");
+
+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((type) => {
+      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) {
+            const match = dollarCommandRe.exec(line);
+            if (match) {
+              const column = match[1].length + 1;
+              const length = match[2].length;
+              dollarInstances.push([ i, lineTrim, column, length ]);
+            } else {
+              allDollars = false;
+            }
+          }
+        }
+        if (allDollars) {
+          dollarInstances.forEach((instance) => {
+            const [ i, lineTrim, column, length ] = instance;
+            addErrorContext(
+              onError,
+              i + 1,
+              lineTrim,
+              null,
+              null,
+              [ column, length ],
+              {
+                "editColumn": column,
+                "deleteCount": length
+              }
+            );
+          });
+        }
+      });
+    });
+  }
+};

package/lib/md018.js

@@ -1,34 +1,34 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorContext, forEachLine } = require("../helpers");
-const { lineMetadata } = require("./cache");
-
-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(), (line, lineIndex, inCode) => {
-      if (!inCode &&
-        /^#+[^#\s]/.test(line) &&
-        !/#\s*$/.test(line) &&
-        !line.startsWith("#️⃣")) {
-        const hashCount = /^#+/.exec(line)[0].length;
-        addErrorContext(
-          onError,
-          lineIndex + 1,
-          line.trim(),
-          null,
-          null,
-          [ 1, hashCount + 1 ],
-          {
-            "editColumn": hashCount + 1,
-            "insertText": " "
-          }
-        );
-      }
-    });
-  }
-};
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, forEachLine } = require("../helpers");
+const { lineMetadata } = require("./cache");
+
+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(), (line, lineIndex, inCode) => {
+      if (!inCode &&
+        /^#+[^#\s]/.test(line) &&
+        !/#\s*$/.test(line) &&
+        !line.startsWith("#️⃣")) {
+        const hashCount = /^#+/.exec(line)[0].length;
+        addErrorContext(
+          onError,
+          lineIndex + 1,
+          line.trim(),
+          null,
+          null,
+          [ 1, hashCount + 1 ],
+          {
+            "editColumn": hashCount + 1,
+            "insertText": " "
+          }
+        );
+      }
+    });
+  }
+};

package/lib/md019.js

@@ -1,39 +1,39 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorContext, filterTokens, headingStyleFor } =
-  require("../helpers");
-
-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", (token) => {
-      if (headingStyleFor(token) === "atx") {
-        const { line, lineNumber } = token;
-        const match = /^(#+)(\s{2,})(?:\S)/.exec(line);
-        if (match) {
-          const [
-            ,
-            { "length": hashLength },
-            { "length": spacesLength }
-          ] = match;
-          addErrorContext(
-            onError,
-            lineNumber,
-            line.trim(),
-            null,
-            null,
-            [ 1, hashLength + spacesLength + 1 ],
-            {
-              "editColumn": hashLength + 1,
-              "deleteCount": spacesLength - 1
-            }
-          );
-        }
-      }
-    });
-  }
-};
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens, headingStyleFor } =
+  require("../helpers");
+
+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", (token) => {
+      if (headingStyleFor(token) === "atx") {
+        const { line, lineNumber } = token;
+        const match = /^(#+)(\s{2,})(?:\S)/.exec(line);
+        if (match) {
+          const [
+            ,
+            { "length": hashLength },
+            { "length": spacesLength }
+          ] = match;
+          addErrorContext(
+            onError,
+            lineNumber,
+            line.trim(),
+            null,
+            null,
+            [ 1, hashLength + spacesLength + 1 ],
+            {
+              "editColumn": hashLength + 1,
+              "deleteCount": spacesLength - 1
+            }
+          );
+        }
+      }
+    });
+  }
+};

package/lib/md020.js

@@ -1,62 +1,62 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorContext, forEachLine } = require("../helpers");
-const { lineMetadata } = require("./cache");
-
-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(), (line, lineIndex, inCode) => {
-      if (!inCode) {
-        const match =
-          /^(#+)(\s*)([^#]*?[^#\\])(\s*)((?:\\#)?)(#+)(\s*)$/.exec(line);
-        if (match) {
-          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) {
-            const range = left ?
-              [
-                1,
-                leftHashLength + 1
-              ] :
-              [
-                line.length - trailSpaceLength - rightHashLength,
-                rightHashLength + 1
-              ];
-            addErrorContext(
-              onError,
-              lineIndex + 1,
-              line.trim(),
-              left,
-              right,
-              range,
-              {
-                "editColumn": 1,
-                "deleteCount": line.length,
-                "insertText":
-                  `${leftHash} ${content} ${rightEscapeReplacement}${rightHash}`
-              }
-            );
-          }
-        }
-      }
-    });
-  }
-};
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, forEachLine } = require("../helpers");
+const { lineMetadata } = require("./cache");
+
+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(), (line, lineIndex, inCode) => {
+      if (!inCode) {
+        const match =
+          /^(#+)(\s*)([^#]*?[^#\\])(\s*)((?:\\#)?)(#+)(\s*)$/.exec(line);
+        if (match) {
+          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) {
+            const range = left ?
+              [
+                1,
+                leftHashLength + 1
+              ] :
+              [
+                line.length - trailSpaceLength - rightHashLength,
+                rightHashLength + 1
+              ];
+            addErrorContext(
+              onError,
+              lineIndex + 1,
+              line.trim(),
+              left,
+              right,
+              range,
+              {
+                "editColumn": 1,
+                "deleteCount": line.length,
+                "insertText":
+                  `${leftHash} ${content} ${rightEscapeReplacement}${rightHash}`
+              }
+            );
+          }
+        }
+      }
+    });
+  }
+};

package/lib/md021.js

@@ -1,60 +1,60 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorContext, filterTokens, headingStyleFor } =
-  require("../helpers");
-
-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", (token) => {
-      if (headingStyleFor(token) === "atx_closed") {
-        const { line, lineNumber } = token;
-        const match = /^(#+)(\s+)([^#]+?)(\s+)(#+)(\s*)$/.exec(line);
-        if (match) {
-          const [
-            ,
-            leftHash,
-            { "length": leftSpaceLength },
-            content,
-            { "length": rightSpaceLength },
-            rightHash,
-            { "length": trailSpaceLength }
-          ] = match;
-          const left = leftSpaceLength > 1;
-          const right = rightSpaceLength > 1;
-          if (left || right) {
-            const length = line.length;
-            const leftHashLength = leftHash.length;
-            const rightHashLength = rightHash.length;
-            const range = left ?
-              [
-                1,
-                leftHashLength + leftSpaceLength + 1
-              ] :
-              [
-                length - trailSpaceLength - rightHashLength - rightSpaceLength,
-                rightSpaceLength + rightHashLength + 1
-              ];
-            addErrorContext(
-              onError,
-              lineNumber,
-              line.trim(),
-              left,
-              right,
-              range,
-              {
-                "editColumn": 1,
-                "deleteCount": length,
-                "insertText": `${leftHash} ${content} ${rightHash}`
-              }
-            );
-          }
-        }
-      }
-    });
-  }
-};
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens, headingStyleFor } =
+  require("../helpers");
+
+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", (token) => {
+      if (headingStyleFor(token) === "atx_closed") {
+        const { line, lineNumber } = token;
+        const match = /^(#+)(\s+)([^#]+?)(\s+)(#+)(\s*)$/.exec(line);
+        if (match) {
+          const [
+            ,
+            leftHash,
+            { "length": leftSpaceLength },
+            content,
+            { "length": rightSpaceLength },
+            rightHash,
+            { "length": trailSpaceLength }
+          ] = match;
+          const left = leftSpaceLength > 1;
+          const right = rightSpaceLength > 1;
+          if (left || right) {
+            const length = line.length;
+            const leftHashLength = leftHash.length;
+            const rightHashLength = rightHash.length;
+            const range = left ?
+              [
+                1,
+                leftHashLength + leftSpaceLength + 1
+              ] :
+              [
+                length - trailSpaceLength - rightHashLength - rightSpaceLength,
+                rightSpaceLength + rightHashLength + 1
+              ];
+            addErrorContext(
+              onError,
+              lineNumber,
+              line.trim(),
+              left,
+              right,
+              range,
+              {
+                "editColumn": 1,
+                "deleteCount": length,
+                "insertText": `${leftHash} ${content} ${rightHash}`
+              }
+            );
+          }
+        }
+      }
+    });
+  }
+};

package/lib/md022.js

@@ -1,56 +1,56 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorDetailIf, filterTokens, isBlankLine } = require("../helpers");
-
-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) {
-    let linesAbove = params.config.lines_above;
-    linesAbove = Number((linesAbove === undefined) ? 1 : linesAbove);
-    let linesBelow = params.config.lines_below;
-    linesBelow = Number((linesBelow === undefined) ? 1 : linesBelow);
-    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++;
-        }
-      }
-      addErrorDetailIf(
-        onError,
-        topIndex + 1,
-        linesAbove,
-        actualAbove,
-        "Above",
-        lines[topIndex].trim(),
-        null,
-        {
-          "insertText": "".padEnd(linesAbove - actualAbove, "\n")
-        });
-      let actualBelow = 0;
-      for (let i = 0; i < linesBelow; i++) {
-        if (isBlankLine(lines[nextIndex + i])) {
-          actualBelow++;
-        }
-      }
-      addErrorDetailIf(
-        onError,
-        topIndex + 1,
-        linesBelow,
-        actualBelow,
-        "Below",
-        lines[topIndex].trim(),
-        null,
-        {
-          "lineNumber": nextIndex + 1,
-          "insertText": "".padEnd(linesBelow - actualBelow, "\n")
-        });
-    });
-  }
-};
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, filterTokens, isBlankLine } = require("../helpers");
+
+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) {
+    let linesAbove = params.config.lines_above;
+    linesAbove = Number((linesAbove === undefined) ? 1 : linesAbove);
+    let linesBelow = params.config.lines_below;
+    linesBelow = Number((linesBelow === undefined) ? 1 : linesBelow);
+    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++;
+        }
+      }
+      addErrorDetailIf(
+        onError,
+        topIndex + 1,
+        linesAbove,
+        actualAbove,
+        "Above",
+        lines[topIndex].trim(),
+        null,
+        {
+          "insertText": "".padEnd(linesAbove - actualAbove, "\n")
+        });
+      let actualBelow = 0;
+      for (let i = 0; i < linesBelow; i++) {
+        if (isBlankLine(lines[nextIndex + i])) {
+          actualBelow++;
+        }
+      }
+      addErrorDetailIf(
+        onError,
+        topIndex + 1,
+        linesBelow,
+        actualBelow,
+        "Below",
+        lines[topIndex].trim(),
+        null,
+        {
+          "lineNumber": nextIndex + 1,
+          "insertText": "".padEnd(linesBelow - actualBelow, "\n")
+        });
+    });
+  }
+};