markdownlint 0.12.0 → 0.14.2

package/lib/md001.js

@@ -2,7 +2,7 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addErrorDetailIf, filterTokens } = require("../helpers");
 
 module.exports = {
   "names": [ "MD001", "heading-increment", "header-increment" ],
@@ -10,10 +10,10 @@ module.exports = {
   "tags": [ "headings", "headers" ],
   "function": function MD001(params, onError) {
     let prevLevel = 0;
-    shared.filterTokens(params, "heading_open", function forToken(token) {
+    filterTokens(params, "heading_open", function forToken(token) {
       const level = parseInt(token.tag.slice(1), 10);
       if (prevLevel && (level > prevLevel)) {
-        shared.addErrorDetailIf(onError, token.lineNumber,
+        addErrorDetailIf(onError, token.lineNumber,
           "h" + (prevLevel + 1), "h" + level);
       }
       prevLevel = level;

package/lib/md002.js

@@ -2,7 +2,7 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addErrorDetailIf } = require("../helpers");
 
 module.exports = {
   "names": [ "MD002", "first-heading-h1", "first-header-h1" ],
@@ -13,7 +13,7 @@ module.exports = {
     const tag = "h" + level;
     params.tokens.every(function forToken(token) {
       if (token.type === "heading_open") {
-        shared.addErrorDetailIf(onError, token.lineNumber, tag, token.tag);
+        addErrorDetailIf(onError, token.lineNumber, tag, token.tag);
         return false;
       }
       return true;

package/lib/md003.js

@@ -2,7 +2,8 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addErrorDetailIf, filterTokens, headingStyleFor } =
+  require("../helpers");
 
 module.exports = {
   "names": [ "MD003", "heading-style", "header-style" ],
@@ -10,8 +11,8 @@ module.exports = {
   "tags": [ "headings", "headers" ],
   "function": function MD003(params, onError) {
     let style = params.config.style || "consistent";
-    shared.filterTokens(params, "heading_open", function forToken(token) {
-      const styleForToken = shared.headingStyleFor(token);
+    filterTokens(params, "heading_open", function forToken(token) {
+      const styleForToken = headingStyleFor(token);
       if (style === "consistent") {
         style = styleForToken;
       }
@@ -32,7 +33,7 @@ module.exports = {
           } else if (style === "setext_with_atx_closed") {
             expected = h12 ? "setext" : "atx_closed";
           }
-          shared.addErrorDetailIf(onError, token.lineNumber,
+          addErrorDetailIf(onError, token.lineNumber,
             expected, styleForToken);
         }
       }

package/lib/md004.js

@@ -2,7 +2,9 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addErrorDetailIf, listItemMarkerRe,
+  rangeFromRegExp } = require("../helpers");
+const { flattenedLists } = require("./cache");
 
 // Returns the unordered list style for a list item token
 function unorderedListStyleFor(token) {
@@ -25,12 +27,12 @@ module.exports = {
     const style = params.config.style || "consistent";
     let expectedStyle = style;
     const nestingStyles = [];
-    shared.flattenLists().forEach(function forList(list) {
+    flattenedLists().forEach((list) => {
       if (list.unordered) {
         if (expectedStyle === "consistent") {
           expectedStyle = unorderedListStyleFor(list.items[0]);
         }
-        list.items.forEach(function forItem(item) {
+        list.items.forEach((item) => {
           const itemStyle = unorderedListStyleFor(item);
           if (style === "sublist") {
             const nesting = list.nesting;
@@ -38,14 +40,14 @@ module.exports = {
               (itemStyle !== nestingStyles[nesting - 1])) {
               nestingStyles[nesting] = itemStyle;
             } else {
-              shared.addErrorDetailIf(onError, item.lineNumber,
-                nestingStyles[nesting], itemStyle, null,
-                shared.rangeFromRegExp(item.line, shared.listItemMarkerRe));
+              addErrorDetailIf(onError, item.lineNumber,
+                nestingStyles[nesting], itemStyle, null, null,
+                rangeFromRegExp(item.line, listItemMarkerRe));
             }
           } else {
-            shared.addErrorDetailIf(onError, item.lineNumber,
-              expectedStyle, itemStyle, null,
-              shared.rangeFromRegExp(item.line, shared.listItemMarkerRe));
+            addErrorDetailIf(onError, item.lineNumber,
+              expectedStyle, itemStyle, null, null,
+              rangeFromRegExp(item.line, listItemMarkerRe));
           }
         });
       }

package/lib/md005.js

@@ -2,26 +2,28 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addError, addErrorDetailIf, indentFor, listItemMarkerRe,
+  orderedListItemMarkerRe, rangeFromRegExp } = require("../helpers");
+const { flattenedLists } = require("./cache");
 
 module.exports = {
   "names": [ "MD005", "list-indent" ],
   "description": "Inconsistent indentation for list items at the same level",
   "tags": [ "bullet", "ul", "indentation" ],
   "function": function MD005(params, onError) {
-    shared.flattenLists().forEach(function forList(list) {
+    flattenedLists().forEach((list) => {
       const expectedIndent = list.indent;
       let expectedEnd = 0;
       let actualEnd = -1;
       let endMatching = false;
-      list.items.forEach(function forItem(item) {
-        const actualIndent = shared.indentFor(item);
+      list.items.forEach((item) => {
+        const actualIndent = indentFor(item);
         if (list.unordered) {
-          shared.addErrorDetailIf(onError, item.lineNumber,
-            expectedIndent, actualIndent, null,
-            shared.rangeFromRegExp(item.line, shared.listItemMarkerRe));
+          addErrorDetailIf(onError, item.lineNumber,
+            expectedIndent, actualIndent, null, null,
+            rangeFromRegExp(item.line, listItemMarkerRe));
         } else {
-          const match = shared.orderedListItemMarkerRe.exec(item.line);
+          const match = orderedListItemMarkerRe.exec(item.line);
           actualEnd = match && match[0].length;
           expectedEnd = expectedEnd || actualEnd;
           if ((expectedIndent !== actualIndent) || endMatching) {
@@ -31,8 +33,8 @@ module.exports = {
               const detail = endMatching ?
                 `Expected: (${expectedEnd}); Actual: (${actualEnd})` :
                 `Expected: ${expectedIndent}; Actual: ${actualIndent}`;
-              shared.addError(onError, item.lineNumber, detail, null,
-                shared.rangeFromRegExp(item.line, shared.listItemMarkerRe));
+              addError(onError, item.lineNumber, detail, null,
+                rangeFromRegExp(item.line, listItemMarkerRe));
             }
           }
         }

package/lib/md006.js

@@ -2,7 +2,9 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addErrorDetailIf, listItemMarkerRe, rangeFromRegExp } =
+  require("../helpers");
+const { flattenedLists } = require("./cache");
 
 module.exports = {
   "names": [ "MD006", "ul-start-left" ],
@@ -10,11 +12,11 @@ module.exports = {
     "Consider starting bulleted lists at the beginning of the line",
   "tags": [ "bullet", "ul", "indentation" ],
   "function": function MD006(params, onError) {
-    shared.flattenLists().forEach(function forList(list) {
+    flattenedLists().forEach((list) => {
       if (list.unordered && !list.nesting) {
-        shared.addErrorDetailIf(onError, list.open.lineNumber,
-          0, list.indent, null,
-          shared.rangeFromRegExp(list.open.line, shared.listItemMarkerRe));
+        addErrorDetailIf(onError, list.open.lineNumber,
+          0, list.indent, null, null,
+          rangeFromRegExp(list.open.line, listItemMarkerRe));
       }
     });
   }

package/lib/md007.js

@@ -2,7 +2,9 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addErrorDetailIf, listItemMarkerRe, rangeFromRegExp } =
+  require("../helpers");
+const { flattenedLists } = require("./cache");
 
 module.exports = {
   "names": [ "MD007", "ul-indent" ],
@@ -10,11 +12,11 @@ module.exports = {
   "tags": [ "bullet", "ul", "indentation" ],
   "function": function MD007(params, onError) {
     const optionsIndent = params.config.indent || 2;
-    shared.flattenLists().forEach(function forList(list) {
+    flattenedLists().forEach((list) => {
       if (list.unordered && list.parentsUnordered && list.indent) {
-        shared.addErrorDetailIf(onError, list.open.lineNumber,
-          list.parentIndent + optionsIndent, list.indent, null,
-          shared.rangeFromRegExp(list.open.line, shared.listItemMarkerRe));
+        addErrorDetailIf(onError, list.open.lineNumber,
+          list.parentIndent + optionsIndent, list.indent, null, null,
+          rangeFromRegExp(list.open.line, listItemMarkerRe));
       }
     });
   }

package/lib/md009.js

@@ -2,7 +2,9 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addError, filterTokens, forEachLine, includesSorted, rangeFromRegExp } =
+  require("../helpers");
+const { lineMetadata } = require("./cache");
 
 const trailingSpaceRe = /\s+$/;
 
@@ -20,24 +22,24 @@ module.exports = {
       (listItemEmptyLines === undefined) ? false : !!listItemEmptyLines;
     const listItemLineNumbers = [];
     if (allowListItemEmptyLines) {
-      shared.filterTokens(params, "list_item_open", function forToken(token) {
+      filterTokens(params, "list_item_open", (token) => {
         for (let i = token.map[0]; i < token.map[1]; i++) {
           listItemLineNumbers.push(i + 1);
         }
       });
+      listItemLineNumbers.sort((a, b) => a - b);
     }
     const expected = (brSpaces < 2) ? 0 : brSpaces;
-    shared.forEachLine(function forLine(line, lineIndex) {
+    forEachLine(lineMetadata(), (line, lineIndex) => {
       const lineNumber = lineIndex + 1;
       if (trailingSpaceRe.test(line) &&
-        (listItemLineNumbers.indexOf(lineNumber) === -1)) {
-        const actual = line.length - shared.trimRight(line).length;
+        !includesSorted(listItemLineNumbers, lineNumber)) {
+        const actual = line.length - line.trimRight().length;
         if (expected !== actual) {
-          shared.addError(onError, lineNumber,
+          addError(onError, lineNumber,
             "Expected: " + (expected === 0 ? "" : "0 or ") +
               expected + "; Actual: " + actual,
-            null,
-            shared.rangeFromRegExp(line, trailingSpaceRe));
+            null, rangeFromRegExp(line, trailingSpaceRe));
         }
       }
     });

package/lib/md010.js

@@ -2,7 +2,8 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addError, forEachLine, rangeFromRegExp } = require("../helpers");
+const { lineMetadata } = require("./cache");
 
 const tabRe = /\t+/;
 
@@ -13,11 +14,10 @@ module.exports = {
   "function": function MD010(params, onError) {
     const codeBlocks = params.config.code_blocks;
     const includeCodeBlocks = (codeBlocks === undefined) ? true : !!codeBlocks;
-    shared.forEachLine(function forLine(line, lineIndex, inCode) {
+    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
       if (tabRe.test(line) && (!inCode || includeCodeBlocks)) {
-        shared.addError(onError, lineIndex + 1,
-          "Column: " + (line.indexOf("\t") + 1), null,
-          shared.rangeFromRegExp(line, tabRe));
+        addError(onError, lineIndex + 1, "Column: " + (line.indexOf("\t") + 1),
+          null, rangeFromRegExp(line, tabRe));
       }
     });
   }

package/lib/md011.js

@@ -2,7 +2,7 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addError, forEachInlineChild, rangeFromRegExp } = require("../helpers");
 
 const reversedLinkRe = /\([^)]+\)\[[^\]^][^\]]*]/;
 
@@ -11,11 +11,11 @@ module.exports = {
   "description": "Reversed link syntax",
   "tags": [ "links" ],
   "function": function MD011(params, onError) {
-    shared.forEachInlineChild(params, "text", function forToken(token) {
+    forEachInlineChild(params, "text", function forToken(token) {
       const match = reversedLinkRe.exec(token.content);
       if (match) {
-        shared.addError(onError, token.lineNumber, match[0], null,
-          shared.rangeFromRegExp(token.line, reversedLinkRe));
+        addError(onError, token.lineNumber, match[0], null,
+          rangeFromRegExp(token.line, reversedLinkRe));
       }
     });
   }

package/lib/md012.js

@@ -2,7 +2,8 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addErrorDetailIf, forEachLine } = require("../helpers");
+const { lineMetadata } = require("./cache");
 
 module.exports = {
   "names": [ "MD012", "no-multiple-blanks" ],
@@ -11,10 +12,10 @@ module.exports = {
   "function": function MD012(params, onError) {
     const maximum = params.config.maximum || 1;
     let count = 0;
-    shared.forEachLine(function forLine(line, lineIndex, inCode) {
+    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
       count = (inCode || line.trim().length) ? 0 : count + 1;
       if (maximum < count) {
-        shared.addErrorDetailIf(onError, lineIndex + 1, maximum, count);
+        addErrorDetailIf(onError, lineIndex + 1, maximum, count);
       }
     });
   }

package/lib/md013.js

@@ -2,9 +2,23 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addErrorDetailIf, filterTokens, forEachHeading, forEachLine,
+  includesSorted, rangeFromRegExp } = require("../helpers");
+const { lineMetadata } = require("./cache");
 
+const longLineRePrefix = "^(.{";
+const longLineRePostfix = "})(.*\\s.*)$";
 const labelRe = /^\s*\[.*[^\\]]:/;
+const linkOnlyLineRe = /^[es]*lT?L[ES]*$/;
+const tokenTypeMap = {
+  "em_open": "e",
+  "em_close": "E",
+  "link_open": "l",
+  "link_close": "L",
+  "strong_open": "s",
+  "strong_close": "S",
+  "text": "T"
+};
 
 module.exports = {
   "names": [ "MD013", "line-length" ],
@@ -12,6 +26,11 @@ module.exports = {
   "tags": [ "line_length" ],
   "function": function MD013(params, onError) {
     const lineLength = params.config.line_length || 80;
+    const headingLineLength = params.config.heading_line_length || lineLength;
+    const longLineRe =
+      new RegExp(longLineRePrefix + lineLength + longLineRePostfix);
+    const longHeadingLineRe =
+      new RegExp(longLineRePrefix + headingLineLength + longLineRePostfix);
     const codeBlocks = params.config.code_blocks;
     const includeCodeBlocks = (codeBlocks === undefined) ? true : !!codeBlocks;
     const tables = params.config.tables;
@@ -22,45 +41,35 @@ module.exports = {
     }
     const includeHeadings = (headings === undefined) ? true : !!headings;
     const headingLineNumbers = [];
-    if (!includeHeadings) {
-      shared.forEachHeading(params, function forHeading(heading) {
-        headingLineNumbers.push(heading.lineNumber);
-      });
-    }
-    const tokenTypeMap = {
-      "em_open": "e",
-      "em_close": "E",
-      "link_open": "l",
-      "link_close": "L",
-      "strong_open": "s",
-      "strong_close": "S",
-      "text": "T"
-    };
+    forEachHeading(params, (heading) => {
+      headingLineNumbers.push(heading.lineNumber);
+    });
     const linkOnlyLineNumbers = [];
-    shared.filterTokens(params, "inline", function forToken(token) {
+    filterTokens(params, "inline", (token) => {
       let childTokenTypes = "";
-      token.children.forEach(function forChild(child) {
+      token.children.forEach((child) => {
         if (child.type !== "text" || child.content !== "") {
           childTokenTypes += tokenTypeMap[child.type] || "x";
         }
       });
-      if (/^[es]*lT?L[ES]*$/.test(childTokenTypes)) {
+      if (linkOnlyLineRe.test(childTokenTypes)) {
         linkOnlyLineNumbers.push(token.lineNumber);
       }
     });
-    const longLineRe = new RegExp("^(.{" + lineLength + "})(.*\\s.*)$");
-    shared.forEachLine(
-      function forLine(line, lineIndex, inCode, onFence, inTable) {
-        const lineNumber = lineIndex + 1;
-        if ((includeCodeBlocks || !inCode) &&
-            (includeTables || !inTable) &&
-            (includeHeadings || (headingLineNumbers.indexOf(lineNumber)) < 0) &&
-            (linkOnlyLineNumbers.indexOf(lineNumber) < 0) &&
-            longLineRe.test(line) &&
-            !labelRe.test(line)) {
-          shared.addErrorDetailIf(onError, lineNumber, lineLength,
-            line.length, null, shared.rangeFromRegExp(line, longLineRe));
-        }
-      });
+    forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence, inTable) => {
+      const lineNumber = lineIndex + 1;
+      const isHeading = includesSorted(headingLineNumbers, lineNumber);
+      const length = isHeading ? headingLineLength : lineLength;
+      const lengthRe = isHeading ? longHeadingLineRe : longLineRe;
+      if ((includeCodeBlocks || !inCode) &&
+          (includeTables || !inTable) &&
+          (includeHeadings || !isHeading) &&
+          !includesSorted(linkOnlyLineNumbers, lineNumber) &&
+          lengthRe.test(line) &&
+          !labelRe.test(line)) {
+        addErrorDetailIf(onError, lineNumber, length, line.length,
+          null, null, rangeFromRegExp(line, lengthRe));
+      }
+    });
   }
 };

package/lib/md014.js

@@ -2,7 +2,8 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addErrorContext, filterTokens, newLineRe, rangeFromRegExp } =
+  require("../helpers");
 
 const dollarCommandRe = /^(\s*)(\$\s)/;
 
@@ -12,15 +13,15 @@ module.exports = {
   "tags": [ "code" ],
   "function": function MD014(params, onError) {
     [ "code_block", "fence" ].forEach(function forType(type) {
-      shared.filterTokens(params, type, function forToken(token) {
+      filterTokens(params, type, function forToken(token) {
         let allBlank = true;
-        if (token.content && token.content.split(shared.newLineRe)
+        if (token.content && token.content.split(newLineRe)
           .every(function forLine(line) {
             return !line || (allBlank = false) || dollarCommandRe.test(line);
           }) && !allBlank) {
-          shared.addErrorContext(onError, token.lineNumber,
-            token.content.split(shared.newLineRe)[0].trim(), null, null,
-            shared.rangeFromRegExp(token.line, dollarCommandRe));
+          addErrorContext(onError, token.lineNumber,
+            token.content.split(newLineRe)[0].trim(), null, null,
+            rangeFromRegExp(token.line, dollarCommandRe));
         }
       });
     });

package/lib/md018.js

@@ -2,17 +2,19 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addErrorContext, atxHeadingSpaceRe, forEachLine,
+  rangeFromRegExp } = 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) {
-    shared.forEachLine(function forLine(line, lineIndex, inCode) {
+    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
       if (!inCode && /^#+[^#\s]/.test(line) && !/#$/.test(line)) {
-        shared.addErrorContext(onError, lineIndex + 1, line.trim(), null,
-          null, shared.rangeFromRegExp(line, shared.atxHeadingSpaceRe));
+        addErrorContext(onError, lineIndex + 1, line.trim(), null,
+          null, rangeFromRegExp(line, atxHeadingSpaceRe));
       }
     });
   }

package/lib/md019.js

@@ -2,19 +2,20 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addErrorContext, atxHeadingSpaceRe, filterTokens, headingStyleFor,
+  rangeFromRegExp } = 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) {
-    shared.filterTokens(params, "heading_open", function forToken(token) {
-      if ((shared.headingStyleFor(token) === "atx") &&
+    filterTokens(params, "heading_open", function forToken(token) {
+      if ((headingStyleFor(token) === "atx") &&
           /^#+\s\s/.test(token.line)) {
-        shared.addErrorContext(onError, token.lineNumber, token.line.trim(),
+        addErrorContext(onError, token.lineNumber, token.line.trim(),
           null, null,
-          shared.rangeFromRegExp(token.line, shared.atxHeadingSpaceRe));
+          rangeFromRegExp(token.line, atxHeadingSpaceRe));
       }
     });
   }

package/lib/md020.js

@@ -2,7 +2,8 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addErrorContext, forEachLine, rangeFromRegExp } = require("../helpers");
+const { lineMetadata } = require("./cache");
 
 const atxClosedHeadingNoSpaceRe = /(?:^#+[^#\s])|(?:[^#\s]#+\s*$)/;
 
@@ -11,13 +12,13 @@ module.exports = {
   "description": "No space inside hashes on closed atx style heading",
   "tags": [ "headings", "headers", "atx_closed", "spaces" ],
   "function": function MD020(params, onError) {
-    shared.forEachLine(function forLine(line, lineIndex, inCode) {
+    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
       if (!inCode && /^#+[^#]*[^\\]#+$/.test(line)) {
         const left = /^#+[^#\s]/.test(line);
         const right = /[^#\s]#+$/.test(line);
         if (left || right) {
-          shared.addErrorContext(onError, lineIndex + 1, line.trim(), left,
-            right, shared.rangeFromRegExp(line, atxClosedHeadingNoSpaceRe));
+          addErrorContext(onError, lineIndex + 1, line.trim(), left,
+            right, rangeFromRegExp(line, atxClosedHeadingNoSpaceRe));
         }
       }
     });

package/lib/md021.js

@@ -2,7 +2,8 @@
 
 "use strict";
 
-const shared = require("./shared");
+const { addErrorContext, filterTokens, headingStyleFor, rangeFromRegExp } =
+  require("../helpers");
 
 const atxClosedHeadingSpaceRe = /(?:^#+\s\s+?\S)|(?:\S\s\s+?#+\s*$)/;
 
@@ -11,14 +12,14 @@ module.exports = {
   "description": "Multiple spaces inside hashes on closed atx style heading",
   "tags": [ "headings", "headers", "atx_closed", "spaces" ],
   "function": function MD021(params, onError) {
-    shared.filterTokens(params, "heading_open", function forToken(token) {
-      if (shared.headingStyleFor(token) === "atx_closed") {
+    filterTokens(params, "heading_open", function forToken(token) {
+      if (headingStyleFor(token) === "atx_closed") {
         const left = /^#+\s\s/.test(token.line);
         const right = /\s\s#+$/.test(token.line);
         if (left || right) {
-          shared.addErrorContext(onError, token.lineNumber, token.line.trim(),
+          addErrorContext(onError, token.lineNumber, token.line.trim(),
             left, right,
-            shared.rangeFromRegExp(token.line, atxClosedHeadingSpaceRe));
+            rangeFromRegExp(token.line, atxClosedHeadingSpaceRe));
         }
       }
     });

package/lib/md022.js

@@ -2,37 +2,37 @@
 
 "use strict";
 
-const shared = require("./shared");
+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 prevHeadingLineNumber = 0;
-    let prevMaxLineIndex = -1;
-    let needBlankLine = false;
-    params.tokens.forEach(function forToken(token) {
-      if (token.type === "heading_open") {
-        if ((token.map[0] - prevMaxLineIndex) === 0) {
-          shared.addErrorContext(onError, token.lineNumber,
-            token.line.trim());
+    let linesAbove = params.config.lines_above;
+    if (linesAbove === undefined) {
+      linesAbove = 1;
+    }
+    let linesBelow = params.config.lines_below;
+    if (linesBelow === undefined) {
+      linesBelow = 1;
+    }
+    const { lines } = params;
+    filterTokens(params, "heading_open", (token) => {
+      const [ topIndex, nextIndex ] = token.map;
+      for (let i = 0; i < linesAbove; i++) {
+        if (!isBlankLine(lines[topIndex - i - 1])) {
+          addErrorDetailIf(onError, topIndex + 1, linesAbove, i, "Above",
+            lines[topIndex].trim());
+          return;
         }
-      } else if (token.type === "heading_close") {
-        needBlankLine = true;
       }
-      if (token.map) {
-        if (needBlankLine) {
-          if ((token.map[0] - prevMaxLineIndex) === 0) {
-            shared.addErrorContext(onError, prevHeadingLineNumber,
-              params.lines[prevHeadingLineNumber - 1].trim());
-          }
-          needBlankLine = false;
+      for (let i = 0; i < linesBelow; i++) {
+        if (!isBlankLine(lines[nextIndex + i])) {
+          addErrorDetailIf(onError, topIndex + 1, linesBelow, i, "Below",
+            lines[topIndex].trim());
+          return;
         }
-        prevMaxLineIndex = Math.max(prevMaxLineIndex, token.map[1]);
-      }
-      if (token.type === "heading_open") {
-        prevHeadingLineNumber = token.lineNumber;
       }
     });
   }