markdownlint 0.22.0 → 0.25.0

package/helpers/helpers.js

@@ -2,8 +2,6 @@
 
 "use strict";
 
-const os = require("os");
-
 // Regular expression for matching common newline characters
 // See NEWLINES_RE in markdown-it/lib/rules_core/normalize.js
 const newLineRe = /\r\n?|\n/g;
@@ -29,10 +27,11 @@ module.exports.orderedListItemMarkerRe = /^[\s>]*0*(\d+)[.)]/;
 const emphasisMarkersRe = /[_*]/g;
 
 // Regular expression for inline links and shortcut reference links
-const linkRe = /\[(?:[^[\]]|\[[^\]]*\])*\](?:\(\S*\))?/g;
+const linkRe = /(\[(?:[^[\]]|\[[^\]]*\])*\])(\(\S*\)|\[\S*\])?/g;
+module.exports.linkRe = linkRe;
 
-// readFile options for reading with the UTF-8 encoding
-module.exports.utf8Encoding = "utf8";
+// Regular expression for link reference definition lines
+module.exports.linkReferenceRe = /^ {0,3}\[[^\]]+]:\s.*$/;
 
 // All punctuation characters (normal and full-width)
 const allPunctuation = ".,;:!?。，；：！？";
@@ -62,12 +61,20 @@ module.exports.isObject = function isObject(obj) {
 };
 
 // Returns true iff the input line is blank (no content)
-// Example: Contains nothing, whitespace, or comments
-const blankLineRe = />|(?:<!--.*?-->)/g;
+// Example: Contains nothing, whitespace, or comment (unclosed start/end okay)
 module.exports.isBlankLine = function isBlankLine(line) {
   // Call to String.replace follows best practices and is not a security check
   // False-positive for js/incomplete-multi-character-sanitization
-  return !line || !line.trim() || !line.replace(blankLineRe, "").trim();
+  return (
+    !line ||
+    !line.trim() ||
+    !line
+      .replace(/<!--.*?-->/g, "")
+      .replace(/<!--.*$/g, "")
+      .replace(/^.*-->/g, "")
+      .replace(/>/g, "")
+      .trim()
+  );
 };
 
 /**
@@ -99,32 +106,47 @@ module.exports.includesSorted = function includesSorted(array, element) {
   return false;
 };
 
-// Replaces the text of all properly-formatted HTML comments with whitespace
+// Replaces the content of properly-formatted CommonMark comments with "."
 // This preserves the line/column information for the rest of the document
-// Trailing whitespace is avoided with a '\' character in the last column
-// See https://www.w3.org/TR/html5/syntax.html#comments for details
+// https://spec.commonmark.org/0.29/#html-blocks
+// https://spec.commonmark.org/0.29/#html-comment
 const htmlCommentBegin = "<!--";
 const htmlCommentEnd = "-->";
 module.exports.clearHtmlCommentText = function clearHtmlCommentText(text) {
   let i = 0;
   while ((i = text.indexOf(htmlCommentBegin, i)) !== -1) {
-    const j = text.indexOf(htmlCommentEnd, i);
+    const j = text.indexOf(htmlCommentEnd, i + 2);
     if (j === -1) {
       // Un-terminated comments are treated as text
       break;
     }
-    const comment = text.slice(i + htmlCommentBegin.length, j);
-    if ((comment.length > 0) &&
-        (comment[0] !== ">") &&
-        (comment[comment.length - 1] !== "-") &&
-        !comment.includes("--") &&
-        (text.slice(i, j + htmlCommentEnd.length)
-          .search(inlineCommentRe) === -1)) {
-      const blanks = comment
-        .replace(/[^\r\n]/g, " ")
-        .replace(/ ([\r\n])/g, "\\$1");
-      text = text.slice(0, i + htmlCommentBegin.length) +
-        blanks + text.slice(j);
+    // If the comment has content...
+    if (j > i + htmlCommentBegin.length) {
+      let k = i - 1;
+      while (text[k] === " ") {
+        k--;
+      }
+      // If comment is not within an indented code block...
+      if (k >= i - 4) {
+        const content = text.slice(i + htmlCommentBegin.length, j);
+        const isBlock = (k < 0) || (text[k] === "\n");
+        const isValid = isBlock ||
+          (!content.startsWith(">") && !content.startsWith("->") &&
+           !content.endsWith("-") && !content.includes("--"));
+        // If a valid block/inline comment...
+        if (isValid) {
+          const inlineCommentIndex = text
+            .slice(i, j + htmlCommentEnd.length)
+            .search(inlineCommentRe);
+          // If not a markdownlint inline directive...
+          if (inlineCommentIndex === -1) {
+            text =
+              text.slice(0, i + htmlCommentBegin.length) +
+              content.replace(/[^\r\n]/g, ".") +
+              text.slice(j);
+          }
+        }
+      }
     }
     i = j + htmlCommentEnd.length;
   }
@@ -165,6 +187,22 @@ module.exports.fencedCodeBlockStyleFor =
     }
   };
 
+/**
+ * Return the string representation of a emphasis or strong markup character.
+ *
+ * @param {string} markup Emphasis or strong string.
+ * @returns {string} String representation.
+ */
+module.exports.emphasisOrStrongStyleFor =
+  function emphasisOrStrongStyleFor(markup) {
+    switch (markup[0]) {
+      case "*":
+        return "asterisk";
+      default:
+        return "underscore";
+    }
+  };
+
 /**
  * Return the number of characters of indent for a token.
  *
@@ -173,7 +211,7 @@ module.exports.fencedCodeBlockStyleFor =
  */
 function indentFor(token) {
   const line = token.line.replace(/^[\s>]*(> |>)/, "");
-  return line.length - line.trimLeft().length;
+  return line.length - line.trimStart().length;
 }
 module.exports.indentFor = indentFor;
 
@@ -223,66 +261,85 @@ function filterTokens(params, type, handler) {
 }
 module.exports.filterTokens = filterTokens;
 
+/**
+ * Returns whether a token is a math block (created by markdown-it-texmath).
+ *
+ * @param {Object} token MarkdownItToken instance.
+ * @returns {boolean} True iff token is a math block.
+ */
+function isMathBlock(token) {
+  return (
+    ((token.tag === "$$") || (token.tag === "math")) &&
+    token.type.startsWith("math_block") &&
+    !token.type.endsWith("_end")
+  );
+}
+module.exports.isMathBlock = isMathBlock;
+
 // Get line metadata array
 module.exports.getLineMetadata = function getLineMetadata(params) {
-  const lineMetadata = params.lines.map(function mapLine(line, index) {
-    return [ line, index, false, 0, false, false ];
-  });
-  filterTokens(params, "fence", function forToken(token) {
+  const lineMetadata = params.lines.map(
+    (line, index) => [ line, index, false, 0, false, false, false, false ]
+  );
+  filterTokens(params, "fence", (token) => {
     lineMetadata[token.map[0]][3] = 1;
     lineMetadata[token.map[1] - 1][3] = -1;
     for (let i = token.map[0] + 1; i < token.map[1] - 1; i++) {
       lineMetadata[i][2] = true;
     }
   });
-  filterTokens(params, "code_block", function forToken(token) {
+  filterTokens(params, "code_block", (token) => {
     for (let i = token.map[0]; i < token.map[1]; i++) {
       lineMetadata[i][2] = true;
     }
   });
-  filterTokens(params, "table_open", function forToken(token) {
+  filterTokens(params, "table_open", (token) => {
     for (let i = token.map[0]; i < token.map[1]; i++) {
       lineMetadata[i][4] = true;
     }
   });
-  filterTokens(params, "list_item_open", function forToken(token) {
+  filterTokens(params, "list_item_open", (token) => {
     let count = 1;
     for (let i = token.map[0]; i < token.map[1]; i++) {
       lineMetadata[i][5] = count;
       count++;
     }
   });
-  filterTokens(params, "hr", function forToken(token) {
+  filterTokens(params, "hr", (token) => {
     lineMetadata[token.map[0]][6] = true;
   });
+  params.tokens.filter(isMathBlock).forEach((token) => {
+    for (let i = token.map[0]; i < token.map[1]; i++) {
+      lineMetadata[i][7] = true;
+    }
+  });
   return lineMetadata;
 };
 
-// Calls the provided function for each line (with context)
-module.exports.forEachLine = function forEachLine(lineMetadata, handler) {
+/**
+ * Calls the provided function for each line.
+ *
+ * @param {Object} lineMetadata Line metadata object.
+ * @param {Function} handler Function taking (line, lineIndex, inCode, onFence,
+ * inTable, inItem, inBreak, inMath).
+ * @returns {void}
+ */
+function forEachLine(lineMetadata, handler) {
   lineMetadata.forEach(function forMetadata(metadata) {
-    // Parameters: line, lineIndex, inCode, onFence, inTable, inItem, inBreak
     handler(...metadata);
   });
-};
+}
+module.exports.forEachLine = forEachLine;
 
 // Returns (nested) lists as a flat array (in order)
-module.exports.flattenLists = function flattenLists(params) {
+module.exports.flattenLists = function flattenLists(tokens) {
   const flattenedLists = [];
   const stack = [];
   let current = null;
   let nesting = 0;
   const nestingStack = [];
   let lastWithMap = { "map": [ 0, 1 ] };
-  params.tokens.forEach(function forToken(token) {
-    if (
-      (token.type === "math_block") &&
-      (token.tag === "math") &&
-      token.map[1]
-    ) {
-      // markdown-it-texmath package does not account for math_block_end
-      token.map[1]++;
-    }
+  tokens.forEach((token) => {
     if ((token.type === "bullet_list_open") ||
         (token.type === "ordered_list_open")) {
       // Save current context and start a new one
@@ -354,7 +411,8 @@ module.exports.forEachHeading = function forEachHeading(params, handler) {
  * Calls the provided function for each inline code span's content.
  *
  * @param {string} input Markdown content.
- * @param {Function} handler Callback function.
+ * @param {Function} handler Callback function taking (code, lineIndex,
+ * columnIndex, ticks).
  * @returns {void}
  */
 function forEachInlineCodeSpan(input, handler) {
@@ -488,6 +546,60 @@ module.exports.addErrorContext = function addErrorContext(
   addError(onError, lineNumber, null, context, range, fixInfo);
 };
 
+/**
+ * Returns an array of code block and span content ranges.
+ *
+ * @param {Object} params RuleParams instance.
+ * @param {Object} lineMetadata Line metadata object.
+ * @returns {number[][]} Array of ranges (lineIndex, columnIndex, length).
+ */
+module.exports.codeBlockAndSpanRanges = (params, lineMetadata) => {
+  const exclusions = [];
+  // Add code block ranges (excludes fences)
+  forEachLine(lineMetadata, (line, lineIndex, inCode, onFence) => {
+    if (inCode && !onFence) {
+      exclusions.push([ lineIndex, 0, line.length ]);
+    }
+  });
+  // Add code span ranges (excludes ticks)
+  filterTokens(params, "inline", (token) => {
+    if (token.children.some((child) => child.type === "code_inline")) {
+      const tokenLines = params.lines.slice(token.map[0], token.map[1]);
+      forEachInlineCodeSpan(
+        tokenLines.join("\n"),
+        (code, lineIndex, columnIndex) => {
+          const codeLines = code.split(newLineRe);
+          for (const [ i, line ] of codeLines.entries()) {
+            exclusions.push([
+              token.lineNumber - 1 + lineIndex + i,
+              i ? 0 : columnIndex,
+              line.length
+            ]);
+          }
+        }
+      );
+    }
+  });
+  return exclusions;
+};
+
+/**
+ * Determines whether the specified range overlaps another range.
+ *
+ * @param {number[][]} ranges Array of ranges (line, index, length).
+ * @param {number} lineIndex Line index to check.
+ * @param {number} index Index to check.
+ * @param {number} length Length to check.
+ * @returns {boolean} True iff the specified range overlaps.
+ */
+module.exports.overlapsAnyRange = (ranges, lineIndex, index, length) => (
+  !ranges.every((span) => (
+    (lineIndex !== span[0]) ||
+    (index + length < span[1]) ||
+    (index > span[1] + span[2])
+  ))
+);
+
 // Returns a range object for a line by applying a RegExp
 module.exports.rangeFromRegExp = function rangeFromRegExp(line, regexp) {
   let range = null;
@@ -523,6 +635,18 @@ module.exports.frontMatterHasTitle =
 function emphasisMarkersInContent(params) {
   const { lines } = params;
   const byLine = new Array(lines.length);
+  // Search links
+  lines.forEach((tokenLine, tokenLineIndex) => {
+    const inLine = [];
+    let linkMatch = null;
+    while ((linkMatch = linkRe.exec(tokenLine))) {
+      let markerMatch = null;
+      while ((markerMatch = emphasisMarkersRe.exec(linkMatch[0]))) {
+        inLine.push(linkMatch.index + markerMatch.index);
+      }
+    }
+    byLine[tokenLineIndex] = inLine;
+  });
   // Search code spans
   filterTokens(params, "inline", (token) => {
     const { children, lineNumber, map } = token;
@@ -533,31 +657,19 @@ function emphasisMarkersInContent(params) {
         (code, lineIndex, column, tickCount) => {
           const codeLines = code.split(newLineRe);
           codeLines.forEach((codeLine, codeLineIndex) => {
+            const byLineIndex = lineNumber - 1 + lineIndex + codeLineIndex;
+            const inLine = byLine[byLineIndex];
+            const codeLineOffset = codeLineIndex ? 0 : column - 1 + tickCount;
             let match = null;
             while ((match = emphasisMarkersRe.exec(codeLine))) {
-              const byLineIndex = lineNumber - 1 + lineIndex + codeLineIndex;
-              const inLine = byLine[byLineIndex] || [];
-              const codeLineOffset = codeLineIndex ? 0 : column - 1 + tickCount;
               inLine.push(codeLineOffset + match.index);
-              byLine[byLineIndex] = inLine;
             }
+            byLine[byLineIndex] = inLine;
           });
         }
       );
     }
   });
-  // Search links
-  lines.forEach((tokenLine, tokenLineIndex) => {
-    let linkMatch = null;
-    while ((linkMatch = linkRe.exec(tokenLine))) {
-      let markerMatch = null;
-      while ((markerMatch = emphasisMarkersRe.exec(linkMatch[0]))) {
-        const inLine = byLine[tokenLineIndex] || [];
-        inLine.push(linkMatch.index + markerMatch.index);
-        byLine[tokenLineIndex] = inLine;
-      }
-    }
-  });
   return byLine;
 }
 module.exports.emphasisMarkersInContent = emphasisMarkersInContent;
@@ -566,9 +678,10 @@ module.exports.emphasisMarkersInContent = emphasisMarkersInContent;
  * Gets the most common line ending, falling back to the platform default.
  *
  * @param {string} input Markdown content to analyze.
+ * @param {string} [platform] Platform identifier (process.platform).
  * @returns {string} Preferred line ending.
  */
-function getPreferredLineEnding(input) {
+function getPreferredLineEnding(input, platform) {
   let cr = 0;
   let lf = 0;
   let crlf = 0;
@@ -589,7 +702,8 @@ function getPreferredLineEnding(input) {
   });
   let preferredLineEnding = null;
   if (!cr && !lf && !crlf) {
-    preferredLineEnding = os.EOL;
+    preferredLineEnding =
+      ((platform || process.platform) === "win32") ? "\r\n" : "\n";
   } else if ((lf >= crlf) && (lf >= cr)) {
     preferredLineEnding = "\n";
   } else if (crlf >= cr) {
@@ -692,8 +806,9 @@ module.exports.applyFixes = function applyFixes(input, errors) {
     const editIndex = editColumn - 1;
     if (
       (lineIndex !== lastLineIndex) ||
-      ((editIndex + deleteCount) < lastEditIndex) ||
-      (deleteCount === -1)
+      (deleteCount === -1) ||
+      ((editIndex + deleteCount) <=
+        (lastEditIndex - ((deleteCount > 0) ? 0 : 1)))
     ) {
       lines[lineIndex] = applyFix(lines[lineIndex], fixInfo, lineEnding);
     }
@@ -703,3 +818,80 @@ module.exports.applyFixes = function applyFixes(input, errors) {
   // Return corrected input
   return lines.filter((line) => line !== null).join(lineEnding);
 };
+
+/**
+ * Gets the range and fixInfo values for reporting an error if the expected
+ * text is found on the specified line.
+ *
+ * @param {string[]} lines Lines of Markdown content.
+ * @param {number} lineIndex Line index to check.
+ * @param {string} search Text to search for.
+ * @param {string} replace Text to replace with.
+ * @returns {Object} Range and fixInfo wrapper.
+ */
+function getRangeAndFixInfoIfFound(lines, lineIndex, search, replace) {
+  let range = null;
+  let fixInfo = null;
+  const searchIndex = lines[lineIndex].indexOf(search);
+  if (searchIndex !== -1) {
+    const column = searchIndex + 1;
+    const length = search.length;
+    range = [ column, length ];
+    fixInfo = {
+      "editColumn": column,
+      "deleteCount": length,
+      "insertText": replace
+    };
+  }
+  return {
+    range,
+    fixInfo
+  };
+}
+module.exports.getRangeAndFixInfoIfFound = getRangeAndFixInfoIfFound;
+
+/**
+ * Gets the next (subsequent) child token if it is of the expected type.
+ *
+ * @param {Object} parentToken Parent token.
+ * @param {Object} childToken Child token basis.
+ * @param {string} nextType Token type of next token.
+ * @param {string} nextNextType Token type of next-next token.
+ * @returns {Object} Next token.
+ */
+function getNextChildToken(parentToken, childToken, nextType, nextNextType) {
+  const { children } = parentToken;
+  const index = children.indexOf(childToken);
+  if (
+    (index !== -1) &&
+    (children.length > index + 2) &&
+    (children[index + 1].type === nextType) &&
+    (children[index + 2].type === nextNextType)
+  ) {
+    return children[index + 1];
+  }
+  return null;
+}
+module.exports.getNextChildToken = getNextChildToken;
+
+/**
+ * Calls Object.freeze() on an object and its children.
+ *
+ * @param {Object} obj Object to deep freeze.
+ * @returns {Object} Object passed to the function.
+ */
+function deepFreeze(obj) {
+  const pending = [ obj ];
+  let current = null;
+  while ((current = pending.shift())) {
+    Object.freeze(current);
+    for (const name of Object.getOwnPropertyNames(current)) {
+      const value = current[name];
+      if (value && (typeof value === "object")) {
+        pending.push(value);
+      }
+    }
+  }
+  return obj;
+}
+module.exports.deepFreeze = deepFreeze;

package/helpers/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markdownlint-rule-helpers",
-  "version": "0.13.0",
+  "version": "0.16.0",
   "description": "A collection of markdownlint helper functions for custom rules",
   "main": "helpers.js",
   "author": "David Anson (https://dlaa.me/)",

package/lib/cache.js

@@ -2,12 +2,12 @@
 
 "use strict";
 
-let lineMetadata = null;
-module.exports.lineMetadata = (value) => {
+let codeBlockAndSpanRanges = null;
+module.exports.codeBlockAndSpanRanges = (value) => {
   if (value) {
-    lineMetadata = value;
+    codeBlockAndSpanRanges = value;
   }
-  return lineMetadata;
+  return codeBlockAndSpanRanges;
 };
 
 let flattenedLists = null;
@@ -18,7 +18,16 @@ module.exports.flattenedLists = (value) => {
   return flattenedLists;
 };
 
+let lineMetadata = null;
+module.exports.lineMetadata = (value) => {
+  if (value) {
+    lineMetadata = value;
+  }
+  return lineMetadata;
+};
+
 module.exports.clear = () => {
-  lineMetadata = null;
+  codeBlockAndSpanRanges = null;
   flattenedLists = null;
+  lineMetadata = null;
 };

package/lib/constants.js

@@ -0,0 +1,7 @@
+// @ts-check
+
+"use strict";
+
+module.exports.deprecatedRuleNames = [ "MD002", "MD006" ];
+module.exports.homepage = "https://github.com/DavidAnson/markdownlint";
+module.exports.version = "0.25.0";

package/lib/markdownlint.d.ts

@@ -8,7 +8,7 @@ export = markdownlint;
  */
 declare function markdownlint(options: Options, callback: LintCallback): void;
 declare namespace markdownlint {
-    export { markdownlintSync as sync, readConfig, readConfigSync, getVersion, promises, RuleFunction, RuleParams, MarkdownItToken, RuleOnError, RuleOnErrorInfo, RuleOnErrorFixInfo, Rule, Options, Plugin, ToStringCallback, LintResults, LintError, FixInfo, LintCallback, Configuration, RuleConfiguration, ConfigurationParser, ReadConfigCallback };
+    export { markdownlintSync as sync, readConfig, readConfigSync, getVersion, promises, RuleFunction, RuleParams, MarkdownItToken, RuleOnError, RuleOnErrorInfo, RuleOnErrorFixInfo, Rule, Options, Plugin, ToStringCallback, LintResults, LintError, FixInfo, LintCallback, Configuration, RuleConfiguration, ConfigurationParser, ReadConfigCallback, ResolveConfigExtendsCallback };
 }
 /**
  * Configuration options.
@@ -52,9 +52,13 @@ type Options = {
      * Additional plugins.
      */
     markdownItPlugins?: Plugin[];
+    /**
+     * File system implementation.
+     */
+    fs?: any;
 };
 /**
- * Called with the result of the lint operation.
+ * Called with the result of the lint function.
  */
 type LintCallback = (err: Error | null, results?: LintResults) => void;
 /**
@@ -70,18 +74,21 @@ declare function markdownlintSync(options: Options): LintResults;
  * @param {string} file Configuration file name.
  * @param {ConfigurationParser[] | ReadConfigCallback} parsers Parsing
  * function(s).
+ * @param {Object} [fs] File system implementation.
  * @param {ReadConfigCallback} [callback] Callback (err, result) function.
  * @returns {void}
  */
-declare function readConfig(file: string, parsers: ConfigurationParser[] | ReadConfigCallback, callback?: ReadConfigCallback): void;
+declare function readConfig(file: string, parsers: ConfigurationParser[] | ReadConfigCallback, fs?: any, callback?: ReadConfigCallback): void;
 /**
  * Read specified configuration file synchronously.
  *
  * @param {string} file Configuration file name.
  * @param {ConfigurationParser[]} [parsers] Parsing function(s).
+ * @param {Object} [fs] File system implementation.
  * @returns {Configuration} Configuration object.
+ * @throws An Error if processing fails.
  */
-declare function readConfigSync(file: string, parsers?: ConfigurationParser[]): Configuration;
+declare function readConfigSync(file: string, parsers?: ConfigurationParser[], fs?: any): Configuration;
 /**
  * Gets the (semantic) version of the library.
  *
@@ -199,9 +206,9 @@ type RuleOnErrorInfo = {
      */
     lineNumber: number;
     /**
-     * Details about the error.
+     * Detail about the error.
      */
-    details?: string;
+    detail?: string;
     /**
      * Context for the error.
      */
@@ -256,6 +263,10 @@ type Rule = {
      * Rule tag(s).
      */
     tags: string[];
+    /**
+     * True if asynchronous.
+     */
+    asynchronous?: boolean;
     /**
      * Rule implementation.
      */
@@ -310,12 +321,16 @@ type LintError = {
     /**
      * Fix information.
      */
-    fixInfo: FixInfo;
+    fixInfo?: FixInfo;
 };
 /**
  * Fix information.
  */
 type FixInfo = {
+    /**
+     * Line number (1-based).
+     */
+    lineNumber?: number;
     /**
      * Column of the fix (1-based).
      */
@@ -334,20 +349,24 @@ type FixInfo = {
  * {@link ../schema/markdownlint-config-schema.json}.
  */
 type Configuration = {
-    [x: string]: any;
+    [x: string]: RuleConfiguration;
 };
 /**
  * Rule configuration.
  */
-type RuleConfiguration = any;
+type RuleConfiguration = boolean | any;
 /**
  * Parses a configuration string and returns a configuration object.
  */
 type ConfigurationParser = (text: string) => Configuration;
 /**
- * Called with the result of the readConfig operation.
+ * Called with the result of the readConfig function.
  */
 type ReadConfigCallback = (err: Error | null, config?: Configuration) => void;
+/**
+ * Called with the result of the resolveConfigExtends function.
+ */
+type ResolveConfigExtendsCallback = (err: Error | null, path?: string) => void;
 /**
  * Lint specified Markdown files.
  *
@@ -360,6 +379,7 @@ declare function markdownlintPromise(options: Options): Promise<LintResults>;
  *
  * @param {string} file Configuration file name.
  * @param {ConfigurationParser[]} [parsers] Parsing function(s).
+ * @param {Object} [fs] File system implementation.
  * @returns {Promise<Configuration>} Configuration object.
  */
-declare function readConfigPromise(file: string, parsers?: ConfigurationParser[]): Promise<Configuration>;
+declare function readConfigPromise(file: string, parsers?: ConfigurationParser[], fs?: any): Promise<Configuration>;