fix: prevent asset conflicts between React and Grid.js versions

Add coexistence checks to all enqueue methods to prevent loading
both React and Grid.js assets simultaneously.

Changes:
- ReactAdmin.php: Only enqueue React assets when ?react=1
- Init.php: Skip Grid.js when React active on admin pages
- Form.php, Coupon.php, Access.php: Restore classic assets when ?react=0
- Customer.php, Product.php, License.php: Add coexistence checks

Now the toggle between Classic and React versions works correctly.

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

node_modules/markdownlint/lib/cache.js

@@ -0,0 +1,33 @@
+// @ts-check
+
+"use strict";
+
+let codeBlockAndSpanRanges = null;
+module.exports.codeBlockAndSpanRanges = (value) => {
+  if (value) {
+    codeBlockAndSpanRanges = value;
+  }
+  return codeBlockAndSpanRanges;
+};
+
+let flattenedLists = null;
+module.exports.flattenedLists = (value) => {
+  if (value) {
+    flattenedLists = value;
+  }
+  return flattenedLists;
+};
+
+let lineMetadata = null;
+module.exports.lineMetadata = (value) => {
+  if (value) {
+    lineMetadata = value;
+  }
+  return lineMetadata;
+};
+
+module.exports.clear = () => {
+  codeBlockAndSpanRanges = null;
+  flattenedLists = null;
+  lineMetadata = null;
+};

node_modules/markdownlint/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.1";

node_modules/markdownlint/lib/markdownlint.d.ts

@@ -0,0 +1,385 @@
+export = markdownlint;
+/**
+ * Lint specified Markdown files.
+ *
+ * @param {Options} options Configuration options.
+ * @param {LintCallback} callback Callback (err, result) function.
+ * @returns {void}
+ */
+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, ResolveConfigExtendsCallback };
+}
+/**
+ * Configuration options.
+ */
+type Options = {
+    /**
+     * Files to lint.
+     */
+    files?: string[] | string;
+    /**
+     * Strings to lint.
+     */
+    strings?: {
+        [x: string]: string;
+    };
+    /**
+     * Configuration object.
+     */
+    config?: Configuration;
+    /**
+     * Custom rules.
+     */
+    customRules?: Rule[] | Rule;
+    /**
+     * Front matter pattern.
+     */
+    frontMatter?: RegExp;
+    /**
+     * True to catch exceptions.
+     */
+    handleRuleFailures?: boolean;
+    /**
+     * True to ignore HTML directives.
+     */
+    noInlineConfig?: boolean;
+    /**
+     * Results object version.
+     */
+    resultVersion?: number;
+    /**
+     * Additional plugins.
+     */
+    markdownItPlugins?: Plugin[];
+    /**
+     * File system implementation.
+     */
+    fs?: any;
+};
+/**
+ * Called with the result of the lint function.
+ */
+type LintCallback = (err: Error | null, results?: LintResults) => void;
+/**
+ * Lint specified Markdown files synchronously.
+ *
+ * @param {Options} options Configuration options.
+ * @returns {LintResults} Results object.
+ */
+declare function markdownlintSync(options: Options): LintResults;
+/**
+ * Read specified configuration file.
+ *
+ * @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, 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[], fs?: any): Configuration;
+/**
+ * Gets the (semantic) version of the library.
+ *
+ * @returns {string} SemVer string.
+ */
+declare function getVersion(): string;
+declare namespace promises {
+    export { markdownlintPromise as markdownlint };
+    export { readConfigPromise as readConfig };
+}
+/**
+ * Function to implement rule logic.
+ */
+type RuleFunction = (params: RuleParams, onError: RuleOnError) => void;
+/**
+ * Rule parameters.
+ */
+type RuleParams = {
+    /**
+     * File/string name.
+     */
+    name: string;
+    /**
+     * Token objects from markdown-it.
+     */
+    tokens: MarkdownItToken[];
+    /**
+     * File/string lines.
+     */
+    lines: string[];
+    /**
+     * Front matter lines.
+     */
+    frontMatterLines: string[];
+    /**
+     * Rule configuration.
+     */
+    config: RuleConfiguration;
+};
+/**
+ * Markdown-It token.
+ */
+type MarkdownItToken = {
+    /**
+     * HTML attributes.
+     */
+    attrs: string[][];
+    /**
+     * Block-level token.
+     */
+    block: boolean;
+    /**
+     * Child nodes.
+     */
+    children: MarkdownItToken[];
+    /**
+     * Tag contents.
+     */
+    content: string;
+    /**
+     * Ignore element.
+     */
+    hidden: boolean;
+    /**
+     * Fence info.
+     */
+    info: string;
+    /**
+     * Nesting level.
+     */
+    level: number;
+    /**
+     * Beginning/ending line numbers.
+     */
+    map: number[];
+    /**
+     * Markup text.
+     */
+    markup: string;
+    /**
+     * Arbitrary data.
+     */
+    meta: any;
+    /**
+     * Level change.
+     */
+    nesting: number;
+    /**
+     * HTML tag name.
+     */
+    tag: string;
+    /**
+     * Token type.
+     */
+    type: string;
+    /**
+     * Line number (1-based).
+     */
+    lineNumber: number;
+    /**
+     * Line content.
+     */
+    line: string;
+};
+/**
+ * Error-reporting callback.
+ */
+type RuleOnError = (onErrorInfo: RuleOnErrorInfo) => void;
+/**
+ * Fix information for RuleOnError callback.
+ */
+type RuleOnErrorInfo = {
+    /**
+     * Line number (1-based).
+     */
+    lineNumber: number;
+    /**
+     * Detail about the error.
+     */
+    detail?: string;
+    /**
+     * Context for the error.
+     */
+    context?: string;
+    /**
+     * Column number (1-based) and length.
+     */
+    range?: number[];
+    /**
+     * Fix information.
+     */
+    fixInfo?: RuleOnErrorFixInfo;
+};
+/**
+ * Fix information for RuleOnErrorInfo.
+ */
+type RuleOnErrorFixInfo = {
+    /**
+     * Line number (1-based).
+     */
+    lineNumber?: number;
+    /**
+     * Column of the fix (1-based).
+     */
+    editColumn?: number;
+    /**
+     * Count of characters to delete.
+     */
+    deleteCount?: number;
+    /**
+     * Text to insert (after deleting).
+     */
+    insertText?: string;
+};
+/**
+ * Rule definition.
+ */
+type Rule = {
+    /**
+     * Rule name(s).
+     */
+    names: string[];
+    /**
+     * Rule description.
+     */
+    description: string;
+    /**
+     * Link to more information.
+     */
+    information?: URL;
+    /**
+     * Rule tag(s).
+     */
+    tags: string[];
+    /**
+     * True if asynchronous.
+     */
+    asynchronous?: boolean;
+    /**
+     * Rule implementation.
+     */
+    function: RuleFunction;
+};
+/**
+ * A markdown-it plugin.
+ */
+type Plugin = any[];
+/**
+ * Function to pretty-print lint results.
+ */
+type ToStringCallback = (ruleAliases?: boolean) => string;
+/**
+ * Lint results (for resultVersion 3).
+ */
+type LintResults = {
+    [x: string]: LintError[];
+};
+/**
+ * Lint error.
+ */
+type LintError = {
+    /**
+     * Line number (1-based).
+     */
+    lineNumber: number;
+    /**
+     * Rule name(s).
+     */
+    ruleNames: string[];
+    /**
+     * Rule description.
+     */
+    ruleDescription: string;
+    /**
+     * Link to more information.
+     */
+    ruleInformation: string;
+    /**
+     * Detail about the error.
+     */
+    errorDetail: string;
+    /**
+     * Context for the error.
+     */
+    errorContext: string;
+    /**
+     * Column number (1-based) and length.
+     */
+    errorRange: number[];
+    /**
+     * Fix information.
+     */
+    fixInfo?: FixInfo;
+};
+/**
+ * Fix information.
+ */
+type FixInfo = {
+    /**
+     * Line number (1-based).
+     */
+    lineNumber?: number;
+    /**
+     * Column of the fix (1-based).
+     */
+    editColumn?: number;
+    /**
+     * Count of characters to delete.
+     */
+    deleteCount?: number;
+    /**
+     * Text to insert (after deleting).
+     */
+    insertText?: string;
+};
+/**
+ * Configuration object for linting rules. For a detailed schema, see
+ * {@link ../schema/markdownlint-config-schema.json}.
+ */
+type Configuration = {
+    [x: string]: RuleConfiguration;
+};
+/**
+ * Rule configuration.
+ */
+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 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.
+ *
+ * @param {Options} options Configuration options.
+ * @returns {Promise<LintResults>} Results object.
+ */
+declare function markdownlintPromise(options: Options): Promise<LintResults>;
+/**
+ * Read specified configuration file.
+ *
+ * @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[], fs?: any): Promise<Configuration>;

node_modules/markdownlint/lib/md001.js

@@ -0,0 +1,22 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, filterTokens } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD001", "heading-increment", "header-increment" ],
+  "description": "Heading levels should only increment by one level at a time",
+  "tags": [ "headings", "headers" ],
+  "function": function MD001(params, onError) {
+    let prevLevel = 0;
+    filterTokens(params, "heading_open", function forToken(token) {
+      const level = Number.parseInt(token.tag.slice(1), 10);
+      if (prevLevel && (level > prevLevel)) {
+        addErrorDetailIf(onError, token.lineNumber,
+          "h" + (prevLevel + 1), "h" + level);
+      }
+      prevLevel = level;
+    });
+  }
+};

node_modules/markdownlint/lib/md002.js

@@ -0,0 +1,22 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD002", "first-heading-h1", "first-header-h1" ],
+  "description": "First heading should be a top-level heading",
+  "tags": [ "headings", "headers" ],
+  "function": function MD002(params, onError) {
+    const level = Number(params.config.level || 1);
+    const tag = "h" + level;
+    params.tokens.every(function forToken(token) {
+      if (token.type === "heading_open") {
+        addErrorDetailIf(onError, token.lineNumber, tag, token.tag);
+        return false;
+      }
+      return true;
+    });
+  }
+};

node_modules/markdownlint/lib/md003.js

@@ -0,0 +1,42 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, filterTokens, headingStyleFor } =
+  require("../helpers");
+
+module.exports = {
+  "names": [ "MD003", "heading-style", "header-style" ],
+  "description": "Heading style",
+  "tags": [ "headings", "headers" ],
+  "function": function MD003(params, onError) {
+    let style = String(params.config.style || "consistent");
+    filterTokens(params, "heading_open", function forToken(token) {
+      const styleForToken = headingStyleFor(token);
+      if (style === "consistent") {
+        style = styleForToken;
+      }
+      if (styleForToken !== style) {
+        const h12 = /h[12]/.test(token.tag);
+        const setextWithAtx =
+          (style === "setext_with_atx") &&
+            ((h12 && (styleForToken === "setext")) ||
+            (!h12 && (styleForToken === "atx")));
+        const setextWithAtxClosed =
+          (style === "setext_with_atx_closed") &&
+            ((h12 && (styleForToken === "setext")) ||
+            (!h12 && (styleForToken === "atx_closed")));
+        if (!setextWithAtx && !setextWithAtxClosed) {
+          let expected = style;
+          if (style === "setext_with_atx") {
+            expected = h12 ? "setext" : "atx";
+          } else if (style === "setext_with_atx_closed") {
+            expected = h12 ? "setext" : "atx_closed";
+          }
+          addErrorDetailIf(onError, token.lineNumber,
+            expected, styleForToken);
+        }
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md004.js

@@ -0,0 +1,76 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, listItemMarkerRe, unorderedListStyleFor } =
+  require("../helpers");
+const { flattenedLists } = require("./cache");
+
+const expectedStyleToMarker = {
+  "dash": "-",
+  "plus": "+",
+  "asterisk": "*"
+};
+const differentItemStyle = {
+  "dash": "plus",
+  "plus": "asterisk",
+  "asterisk": "dash"
+};
+const validStyles = Object.keys(expectedStyleToMarker);
+
+module.exports = {
+  "names": [ "MD004", "ul-style" ],
+  "description": "Unordered list style",
+  "tags": [ "bullet", "ul" ],
+  "function": function MD004(params, onError) {
+    const style = String(params.config.style || "consistent");
+    let expectedStyle = style;
+    const nestingStyles = [];
+    flattenedLists().forEach((list) => {
+      if (list.unordered) {
+        if (expectedStyle === "consistent") {
+          expectedStyle = unorderedListStyleFor(list.items[0]);
+        }
+        list.items.forEach((item) => {
+          const itemStyle = unorderedListStyleFor(item);
+          if (style === "sublist") {
+            const nesting = list.nesting;
+            if (!nestingStyles[nesting]) {
+              nestingStyles[nesting] =
+                (itemStyle === nestingStyles[nesting - 1]) ?
+                  differentItemStyle[itemStyle] :
+                  itemStyle;
+            }
+            expectedStyle = nestingStyles[nesting];
+          }
+          if (!validStyles.includes(expectedStyle)) {
+            expectedStyle = validStyles[0];
+          }
+          let range = null;
+          let fixInfo = null;
+          const match = item.line.match(listItemMarkerRe);
+          if (match) {
+            const column = match.index + 1;
+            const length = match[0].length;
+            range = [ column, length ];
+            fixInfo = {
+              "editColumn": match[1].length + 1,
+              "deleteCount": 1,
+              "insertText": expectedStyleToMarker[expectedStyle]
+            };
+          }
+          addErrorDetailIf(
+            onError,
+            item.lineNumber,
+            expectedStyle,
+            itemStyle,
+            null,
+            null,
+            range,
+            fixInfo
+          );
+        });
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md005.js

@@ -0,0 +1,69 @@
+// @ts-check
+
+"use strict";
+
+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) {
+    flattenedLists().forEach((list) => {
+      const expectedIndent = list.indent;
+      let expectedEnd = 0;
+      let actualEnd = -1;
+      let endMatching = false;
+      list.items.forEach((item) => {
+        const { line, lineNumber } = item;
+        const actualIndent = indentFor(item);
+        let match = null;
+        if (list.unordered) {
+          addErrorDetailIf(
+            onError,
+            lineNumber,
+            expectedIndent,
+            actualIndent,
+            null,
+            null,
+            rangeFromRegExp(line, listItemMarkerRe)
+            // No fixInfo; MD007 handles this scenario better
+          );
+        } else if ((match = orderedListItemMarkerRe.exec(line))) {
+          actualEnd = match[0].length;
+          expectedEnd = expectedEnd || actualEnd;
+          const markerLength = match[1].length + 1;
+          if ((expectedIndent !== actualIndent) || endMatching) {
+            if (expectedEnd === actualEnd) {
+              endMatching = true;
+            } else {
+              const detail = endMatching ?
+                `Expected: (${expectedEnd}); Actual: (${actualEnd})` :
+                `Expected: ${expectedIndent}; Actual: ${actualIndent}`;
+              const expected = endMatching ?
+                expectedEnd - markerLength :
+                expectedIndent;
+              const actual = endMatching ?
+                actualEnd - markerLength :
+                actualIndent;
+              addError(
+                onError,
+                lineNumber,
+                detail,
+                null,
+                rangeFromRegExp(line, listItemMarkerRe),
+                {
+                  "editColumn": Math.min(actual, expected) + 1,
+                  "deleteCount": Math.max(actual - expected, 0),
+                  "insertText": "".padEnd(Math.max(expected - actual, 0))
+                }
+              );
+            }
+          }
+        }
+      });
+    });
+  }
+};

node_modules/markdownlint/lib/md006.js

@@ -0,0 +1,34 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, listItemMarkerRe, rangeFromRegExp } =
+  require("../helpers");
+const { flattenedLists } = require("./cache");
+
+module.exports = {
+  "names": [ "MD006", "ul-start-left" ],
+  "description":
+    "Consider starting bulleted lists at the beginning of the line",
+  "tags": [ "bullet", "ul", "indentation" ],
+  "function": function MD006(params, onError) {
+    flattenedLists().forEach((list) => {
+      if (list.unordered && !list.nesting && (list.indent !== 0)) {
+        list.items.forEach((item) => {
+          const { lineNumber, line } = item;
+          addErrorDetailIf(
+            onError,
+            lineNumber,
+            0,
+            list.indent,
+            null,
+            null,
+            rangeFromRegExp(line, listItemMarkerRe),
+            {
+              "deleteCount": line.length - line.trimStart().length
+            });
+        });
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md007.js

@@ -0,0 +1,49 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, indentFor, listItemMarkerRe } =
+  require("../helpers");
+const { flattenedLists } = require("./cache");
+
+module.exports = {
+  "names": [ "MD007", "ul-indent" ],
+  "description": "Unordered list indentation",
+  "tags": [ "bullet", "ul", "indentation" ],
+  "function": function MD007(params, onError) {
+    const indent = Number(params.config.indent || 2);
+    const startIndented = !!params.config.start_indented;
+    const startIndent = Number(params.config.start_indent || indent);
+    flattenedLists().forEach((list) => {
+      if (list.unordered && list.parentsUnordered) {
+        list.items.forEach((item) => {
+          const { lineNumber, line } = item;
+          const expectedIndent =
+            (startIndented ? startIndent : 0) +
+            (list.nesting * indent);
+          const actualIndent = indentFor(item);
+          let range = null;
+          let editColumn = 1;
+          const match = line.match(listItemMarkerRe);
+          if (match) {
+            range = [ 1, match[0].length ];
+            editColumn += match[1].length - actualIndent;
+          }
+          addErrorDetailIf(
+            onError,
+            lineNumber,
+            expectedIndent,
+            actualIndent,
+            null,
+            null,
+            range,
+            {
+              editColumn,
+              "deleteCount": actualIndent,
+              "insertText": "".padEnd(expectedIndent)
+            });
+        });
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md009.js

@@ -0,0 +1,79 @@
+// @ts-check
+
+"use strict";
+
+const { addError, filterTokens, forEachInlineCodeSpan, forEachLine,
+  includesSorted, newLineRe, numericSortAscending } = require("../helpers");
+const { lineMetadata } = require("./cache");
+
+module.exports = {
+  "names": [ "MD009", "no-trailing-spaces" ],
+  "description": "Trailing spaces",
+  "tags": [ "whitespace" ],
+  "function": function MD009(params, onError) {
+    let brSpaces = params.config.br_spaces;
+    brSpaces = Number((brSpaces === undefined) ? 2 : brSpaces);
+    const listItemEmptyLines = !!params.config.list_item_empty_lines;
+    const strict = !!params.config.strict;
+    const listItemLineNumbers = [];
+    if (listItemEmptyLines) {
+      filterTokens(params, "list_item_open", (token) => {
+        for (let i = token.map[0]; i < token.map[1]; i++) {
+          listItemLineNumbers.push(i + 1);
+        }
+      });
+      listItemLineNumbers.sort(numericSortAscending);
+    }
+    const paragraphLineNumbers = [];
+    const codeInlineLineNumbers = [];
+    if (strict) {
+      filterTokens(params, "paragraph_open", (token) => {
+        for (let i = token.map[0]; i < token.map[1] - 1; i++) {
+          paragraphLineNumbers.push(i + 1);
+        }
+      });
+      paragraphLineNumbers.sort(numericSortAscending);
+      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) => {
+            const codeLineCount = code.split(newLineRe).length;
+            for (let i = 0; i < codeLineCount; i++) {
+              codeInlineLineNumbers.push(token.lineNumber + lineIndex + i);
+            }
+          });
+        }
+      });
+      codeInlineLineNumbers.sort(numericSortAscending);
+    }
+    const expected = (brSpaces < 2) ? 0 : brSpaces;
+    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
+      const lineNumber = lineIndex + 1;
+      const trailingSpaces = line.length - line.trimEnd().length;
+      if (
+        trailingSpaces &&
+        !inCode &&
+        !includesSorted(listItemLineNumbers, lineNumber) &&
+        (
+          (expected !== trailingSpaces) ||
+          (strict &&
+            (!includesSorted(paragraphLineNumbers, lineNumber) ||
+             includesSorted(codeInlineLineNumbers, lineNumber)))
+        )
+      ) {
+        const column = line.length - trailingSpaces + 1;
+        addError(
+          onError,
+          lineNumber,
+          "Expected: " + (expected === 0 ? "" : "0 or ") +
+            expected + "; Actual: " + trailingSpaces,
+          null,
+          [ column, trailingSpaces ],
+          {
+            "editColumn": column,
+            "deleteCount": trailingSpaces
+          });
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md010.js

@@ -0,0 +1,47 @@
+// @ts-check
+
+"use strict";
+
+const { addError, forEachLine, overlapsAnyRange } = require("../helpers");
+const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
+
+const tabRe = /\t+/g;
+
+module.exports = {
+  "names": [ "MD010", "no-hard-tabs" ],
+  "description": "Hard tabs",
+  "tags": [ "whitespace", "hard_tab" ],
+  "function": function MD010(params, onError) {
+    const codeBlocks = params.config.code_blocks;
+    const includeCode = (codeBlocks === undefined) ? true : !!codeBlocks;
+    const spacesPerTab = params.config.spaces_per_tab;
+    const spaceMultiplier = (spacesPerTab === undefined) ?
+      1 :
+      Math.max(0, Number(spacesPerTab));
+    const exclusions = includeCode ? [] : codeBlockAndSpanRanges();
+    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
+      if (includeCode || !inCode) {
+        let match = null;
+        while ((match = tabRe.exec(line)) !== null) {
+          const { index } = match;
+          const column = index + 1;
+          const length = match[0].length;
+          if (!overlapsAnyRange(exclusions, lineIndex, index, length)) {
+            addError(
+              onError,
+              lineIndex + 1,
+              "Column: " + column,
+              null,
+              [ column, length ],
+              {
+                "editColumn": column,
+                "deleteCount": length,
+                "insertText": "".padEnd(length * spaceMultiplier)
+              }
+            );
+          }
+        }
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md011.js

@@ -0,0 +1,46 @@
+// @ts-check
+
+"use strict";
+
+const { addError, forEachLine, overlapsAnyRange } = require("../helpers");
+const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
+
+const reversedLinkRe =
+  /(^|[^\\])\(([^)]+)\)\[([^\]^][^\]]*)](?!\()/g;
+
+module.exports = {
+  "names": [ "MD011", "no-reversed-links" ],
+  "description": "Reversed link syntax",
+  "tags": [ "links" ],
+  "function": function MD011(params, onError) {
+    const exclusions = codeBlockAndSpanRanges();
+    forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence) => {
+      if (!inCode && !onFence) {
+        let match = null;
+        while ((match = reversedLinkRe.exec(line)) !== null) {
+          const [ reversedLink, preChar, linkText, linkDestination ] = match;
+          const index = match.index + preChar.length;
+          const length = match[0].length - preChar.length;
+          if (
+            !linkText.endsWith("\\") &&
+            !linkDestination.endsWith("\\") &&
+            !overlapsAnyRange(exclusions, lineIndex, index, length)
+          ) {
+            addError(
+              onError,
+              lineIndex + 1,
+              reversedLink.slice(preChar.length),
+              null,
+              [ index + 1, length ],
+              {
+                "editColumn": index + 1,
+                "deleteCount": length,
+                "insertText": `[${linkText}](${linkDestination})`
+              }
+            );
+          }
+        }
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md012.js

@@ -0,0 +1,32 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, forEachLine } = require("../helpers");
+const { lineMetadata } = require("./cache");
+
+module.exports = {
+  "names": [ "MD012", "no-multiple-blanks" ],
+  "description": "Multiple consecutive blank lines",
+  "tags": [ "whitespace", "blank_lines" ],
+  "function": function MD012(params, onError) {
+    const maximum = Number(params.config.maximum || 1);
+    let count = 0;
+    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
+      count = (inCode || (line.trim().length > 0)) ? 0 : count + 1;
+      if (maximum < count) {
+        addErrorDetailIf(
+          onError,
+          lineIndex + 1,
+          maximum,
+          count,
+          null,
+          null,
+          null,
+          {
+            "deleteCount": -1
+          });
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md013.js

@@ -0,0 +1,99 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, filterTokens, forEachHeading, forEachLine,
+  includesSorted } = require("../helpers");
+const { lineMetadata } = require("./cache");
+
+const longLineRePrefix = "^.{";
+const longLineRePostfixRelaxed = "}.*\\s.*$";
+const longLineRePostfixStrict = "}.+$";
+const labelRe = /^\s*\[.*[^\\]]:/;
+const linkOrImageOnlyLineRe = /^[es]*(lT?L|I)[ES]*$/;
+const sternModeRe = /^([#>\s]*\s)?\S*$/;
+const tokenTypeMap = {
+  "em_open": "e",
+  "em_close": "E",
+  "image": "I",
+  "link_open": "l",
+  "link_close": "L",
+  "strong_open": "s",
+  "strong_close": "S",
+  "text": "T"
+};
+
+module.exports = {
+  "names": [ "MD013", "line-length" ],
+  "description": "Line length",
+  "tags": [ "line_length" ],
+  "function": function MD013(params, onError) {
+    const lineLength = Number(params.config.line_length || 80);
+    const headingLineLength =
+      Number(params.config.heading_line_length || lineLength);
+    const codeLineLength =
+      Number(params.config.code_block_line_length || lineLength);
+    const strict = !!params.config.strict;
+    const stern = !!params.config.stern;
+    const longLineRePostfix =
+      (strict || stern) ? longLineRePostfixStrict : longLineRePostfixRelaxed;
+    const longLineRe =
+      new RegExp(longLineRePrefix + lineLength + longLineRePostfix);
+    const longHeadingLineRe =
+      new RegExp(longLineRePrefix + headingLineLength + longLineRePostfix);
+    const longCodeLineRe =
+      new RegExp(longLineRePrefix + codeLineLength + longLineRePostfix);
+    const codeBlocks = params.config.code_blocks;
+    const includeCodeBlocks = (codeBlocks === undefined) ? true : !!codeBlocks;
+    const tables = params.config.tables;
+    const includeTables = (tables === undefined) ? true : !!tables;
+    let headings = params.config.headings;
+    if (headings === undefined) {
+      headings = params.config.headers;
+    }
+    const includeHeadings = (headings === undefined) ? true : !!headings;
+    const headingLineNumbers = [];
+    forEachHeading(params, (heading) => {
+      headingLineNumbers.push(heading.lineNumber);
+    });
+    const linkOnlyLineNumbers = [];
+    filterTokens(params, "inline", (token) => {
+      let childTokenTypes = "";
+      token.children.forEach((child) => {
+        if (child.type !== "text" || child.content !== "") {
+          childTokenTypes += tokenTypeMap[child.type] || "x";
+        }
+      });
+      if (linkOrImageOnlyLineRe.test(childTokenTypes)) {
+        linkOnlyLineNumbers.push(token.lineNumber);
+      }
+    });
+    forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence, inTable) => {
+      const lineNumber = lineIndex + 1;
+      const isHeading = includesSorted(headingLineNumbers, lineNumber);
+      const length = inCode ?
+        codeLineLength :
+        (isHeading ? headingLineLength : lineLength);
+      const lengthRe = inCode ?
+        longCodeLineRe :
+        (isHeading ? longHeadingLineRe : longLineRe);
+      if ((includeCodeBlocks || !inCode) &&
+          (includeTables || !inTable) &&
+          (includeHeadings || !isHeading) &&
+          (strict ||
+           (!(stern && sternModeRe.test(line)) &&
+            !includesSorted(linkOnlyLineNumbers, lineNumber) &&
+            !labelRe.test(line))) &&
+          lengthRe.test(line)) {
+        addErrorDetailIf(
+          onError,
+          lineNumber,
+          length,
+          line.length,
+          null,
+          null,
+          [ length + 1, line.length - length ]);
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md014.js

@@ -0,0 +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
+              }
+            );
+          });
+        }
+      });
+    });
+  }
+};

node_modules/markdownlint/lib/md018.js

@@ -0,0 +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 &&
+        /^#+[^# \t]/.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": " "
+          }
+        );
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md019.js

@@ -0,0 +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 = /^(#+)([ \t]{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
+            }
+          );
+        }
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md020.js

@@ -0,0 +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 =
+          /^(#+)([ \t]*)([^#]*?[^#\\])([ \t]*)((?:\\#)?)(#+)(\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}`
+              }
+            );
+          }
+        }
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md021.js

@@ -0,0 +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 = /^(#+)([ \t]+)([^#]+?)([ \t]+)(#+)(\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}`
+              }
+            );
+          }
+        }
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md022.js

@@ -0,0 +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")
+        });
+    });
+  }
+};

node_modules/markdownlint/lib/md023.js

@@ -0,0 +1,38 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens } = require("../helpers");
+
+const spaceBeforeHeadingRe = /^((?:\s+)|(?:[>\s]+\s\s))[^>\s]/;
+
+module.exports = {
+  "names": [ "MD023", "heading-start-left", "header-start-left" ],
+  "description": "Headings must start at the beginning of the line",
+  "tags": [ "headings", "headers", "spaces" ],
+  "function": function MD023(params, onError) {
+    filterTokens(params, "heading_open", function forToken(token) {
+      const { lineNumber, line } = token;
+      const match = line.match(spaceBeforeHeadingRe);
+      if (match) {
+        const [ prefixAndFirstChar, prefix ] = match;
+        let deleteCount = prefix.length;
+        const prefixLengthNoSpace = prefix.trimEnd().length;
+        if (prefixLengthNoSpace) {
+          deleteCount -= prefixLengthNoSpace - 1;
+        }
+        addErrorContext(
+          onError,
+          lineNumber,
+          line,
+          null,
+          null,
+          [ 1, prefixAndFirstChar.length ],
+          {
+            "editColumn": prefixLengthNoSpace + 1,
+            "deleteCount": deleteCount
+          });
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md024.js

@@ -0,0 +1,38 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, forEachHeading } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD024", "no-duplicate-heading", "no-duplicate-header" ],
+  "description": "Multiple headings with the same content",
+  "tags": [ "headings", "headers" ],
+  "function": function MD024(params, onError) {
+    const siblingsOnly = !!params.config.siblings_only ||
+      !!params.config.allow_different_nesting || false;
+    const knownContents = [ null, [] ];
+    let lastLevel = 1;
+    let knownContent = knownContents[lastLevel];
+    forEachHeading(params, (heading, content) => {
+      if (siblingsOnly) {
+        const newLevel = heading.tag.slice(1);
+        while (lastLevel < newLevel) {
+          lastLevel++;
+          knownContents[lastLevel] = [];
+        }
+        while (lastLevel > newLevel) {
+          knownContents[lastLevel] = [];
+          lastLevel--;
+        }
+        knownContent = knownContents[newLevel];
+      }
+      if (knownContent.includes(content)) {
+        addErrorContext(onError, heading.lineNumber,
+          heading.line.trim());
+      } else {
+        knownContent.push(content);
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md025.js

@@ -0,0 +1,32 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens, frontMatterHasTitle } =
+  require("../helpers");
+
+module.exports = {
+  "names": [ "MD025", "single-title", "single-h1" ],
+  "description": "Multiple top-level headings in the same document",
+  "tags": [ "headings", "headers" ],
+  "function": function MD025(params, onError) {
+    const level = Number(params.config.level || 1);
+    const tag = "h" + level;
+    const foundFrontMatterTitle =
+      frontMatterHasTitle(
+        params.frontMatterLines,
+        params.config.front_matter_title
+      );
+    let hasTopLevelHeading = false;
+    filterTokens(params, "heading_open", function forToken(token) {
+      if (token.tag === tag) {
+        if (hasTopLevelHeading || foundFrontMatterTitle) {
+          addErrorContext(onError, token.lineNumber,
+            token.line.trim());
+        } else if (token.lineNumber === 1) {
+          hasTopLevelHeading = true;
+        }
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md026.js

@@ -0,0 +1,43 @@
+// @ts-check
+
+"use strict";
+
+const { addError, allPunctuationNoQuestion, escapeForRegExp, forEachHeading } =
+  require("../helpers");
+
+const endOfLineHtmlEntityRe = /&#?[0-9a-zA-Z]+;$/;
+
+module.exports = {
+  "names": [ "MD026", "no-trailing-punctuation" ],
+  "description": "Trailing punctuation in heading",
+  "tags": [ "headings", "headers" ],
+  "function": function MD026(params, onError) {
+    let punctuation = params.config.punctuation;
+    punctuation = String(
+      (punctuation === undefined) ? allPunctuationNoQuestion : punctuation
+    );
+    const trailingPunctuationRe =
+      new RegExp("\\s*[" + escapeForRegExp(punctuation) + "]+$");
+    forEachHeading(params, (heading) => {
+      const { line, lineNumber } = heading;
+      const trimmedLine = line.replace(/[\s#]*$/, "");
+      const match = trailingPunctuationRe.exec(trimmedLine);
+      if (match && !endOfLineHtmlEntityRe.test(trimmedLine)) {
+        const fullMatch = match[0];
+        const column = match.index + 1;
+        const length = fullMatch.length;
+        addError(
+          onError,
+          lineNumber,
+          `Punctuation: '${fullMatch}'`,
+          null,
+          [ column, length ],
+          {
+            "editColumn": column,
+            "deleteCount": length
+          }
+        );
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md027.js

@@ -0,0 +1,56 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, newLineRe } = require("../helpers");
+
+const spaceAfterBlockQuoteRe = /^((?:\s*>)+)(\s{2,})\S/;
+
+module.exports = {
+  "names": [ "MD027", "no-multiple-space-blockquote" ],
+  "description": "Multiple spaces after blockquote symbol",
+  "tags": [ "blockquote", "whitespace", "indentation" ],
+  "function": function MD027(params, onError) {
+    let blockquoteNesting = 0;
+    let listItemNesting = 0;
+    params.tokens.forEach((token) => {
+      const { content, lineNumber, type } = token;
+      if (type === "blockquote_open") {
+        blockquoteNesting++;
+      } else if (type === "blockquote_close") {
+        blockquoteNesting--;
+      } else if (type === "list_item_open") {
+        listItemNesting++;
+      } else if (type === "list_item_close") {
+        listItemNesting--;
+      } else if ((type === "inline") && blockquoteNesting) {
+        const lineCount = content.split(newLineRe).length;
+        for (let i = 0; i < lineCount; i++) {
+          const line = params.lines[lineNumber + i - 1];
+          const match = line.match(spaceAfterBlockQuoteRe);
+          if (match) {
+            const [
+              fullMatch,
+              { "length": blockquoteLength },
+              { "length": spaceLength }
+            ] = match;
+            if (!listItemNesting || (fullMatch[fullMatch.length - 1] === ">")) {
+              addErrorContext(
+                onError,
+                lineNumber + i,
+                line,
+                null,
+                null,
+                [ 1, fullMatch.length ],
+                {
+                  "editColumn": blockquoteLength + 1,
+                  "deleteCount": spaceLength - 1
+                }
+              );
+            }
+          }
+        }
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md028.js

@@ -0,0 +1,30 @@
+// @ts-check
+
+"use strict";
+
+const { addError } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD028", "no-blanks-blockquote" ],
+  "description": "Blank line inside blockquote",
+  "tags": [ "blockquote", "whitespace" ],
+  "function": function MD028(params, onError) {
+    let prevToken = {};
+    let prevLineNumber = null;
+    params.tokens.forEach(function forToken(token) {
+      if ((token.type === "blockquote_open") &&
+          (prevToken.type === "blockquote_close")) {
+        for (
+          let lineNumber = prevLineNumber;
+          lineNumber < token.lineNumber;
+          lineNumber++) {
+          addError(onError, lineNumber);
+        }
+      }
+      prevToken = token;
+      if (token.type === "blockquote_open") {
+        prevLineNumber = token.map[1] + 1;
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md029.js

@@ -0,0 +1,66 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, listItemMarkerRe, orderedListItemMarkerRe,
+  rangeFromRegExp } = require("../helpers");
+const { flattenedLists } = require("./cache");
+
+const listStyleExamples = {
+  "one": "1/1/1",
+  "ordered": "1/2/3",
+  "zero": "0/0/0"
+};
+
+module.exports = {
+  "names": [ "MD029", "ol-prefix" ],
+  "description": "Ordered list item prefix",
+  "tags": [ "ol" ],
+  "function": function MD029(params, onError) {
+    const style = String(params.config.style || "one_or_ordered");
+    flattenedLists().filter((list) => !list.unordered).forEach((list) => {
+      const { items } = list;
+      let current = 1;
+      let incrementing = false;
+      // Check for incrementing number pattern 1/2/3 or 0/1/2
+      if (items.length >= 2) {
+        const first = orderedListItemMarkerRe.exec(items[0].line);
+        const second = orderedListItemMarkerRe.exec(items[1].line);
+        if (first && second) {
+          const [ , firstNumber ] = first;
+          const [ , secondNumber ] = second;
+          if ((secondNumber !== "1") || (firstNumber === "0")) {
+            incrementing = true;
+            if (firstNumber === "0") {
+              current = 0;
+            }
+          }
+        }
+      }
+      // Determine effective style
+      let listStyle = style;
+      if (listStyle === "one_or_ordered") {
+        listStyle = incrementing ? "ordered" : "one";
+      }
+      // Force expected value for 0/0/0 and 1/1/1 patterns
+      if (listStyle === "zero") {
+        current = 0;
+      } else if (listStyle === "one") {
+        current = 1;
+      }
+      // Validate each list item marker
+      items.forEach((item) => {
+        const match = orderedListItemMarkerRe.exec(item.line);
+        if (match) {
+          addErrorDetailIf(onError, item.lineNumber,
+            String(current), match[1],
+            "Style: " + listStyleExamples[listStyle], null,
+            rangeFromRegExp(item.line, listItemMarkerRe));
+          if (listStyle === "ordered") {
+            current++;
+          }
+        }
+      });
+    });
+  }
+};

node_modules/markdownlint/lib/md030.js

@@ -0,0 +1,50 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf } = require("../helpers");
+const { flattenedLists } = require("./cache");
+
+module.exports = {
+  "names": [ "MD030", "list-marker-space" ],
+  "description": "Spaces after list markers",
+  "tags": [ "ol", "ul", "whitespace" ],
+  "function": function MD030(params, onError) {
+    const ulSingle = Number(params.config.ul_single || 1);
+    const olSingle = Number(params.config.ol_single || 1);
+    const ulMulti = Number(params.config.ul_multi || 1);
+    const olMulti = Number(params.config.ol_multi || 1);
+    flattenedLists().forEach((list) => {
+      const lineCount = list.lastLineIndex - list.open.map[0];
+      const allSingle = lineCount === list.items.length;
+      const expectedSpaces = list.unordered ?
+        (allSingle ? ulSingle : ulMulti) :
+        (allSingle ? olSingle : olMulti);
+      list.items.forEach((item) => {
+        const { line, lineNumber } = item;
+        const match = /^[\s>]*\S+(\s*)/.exec(line);
+        const [ { "length": matchLength }, { "length": actualSpaces } ] = match;
+        if (matchLength < line.length) {
+          let fixInfo = null;
+          if (expectedSpaces !== actualSpaces) {
+            fixInfo = {
+              "editColumn": matchLength - actualSpaces + 1,
+              "deleteCount": actualSpaces,
+              "insertText": "".padEnd(expectedSpaces)
+            };
+          }
+          addErrorDetailIf(
+            onError,
+            lineNumber,
+            expectedSpaces,
+            actualSpaces,
+            null,
+            null,
+            [ 1, matchLength ],
+            fixInfo
+          );
+        }
+      });
+    });
+  }
+};

node_modules/markdownlint/lib/md031.js

@@ -0,0 +1,40 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, forEachLine, isBlankLine } = require("../helpers");
+const { lineMetadata } = require("./cache");
+
+const codeFencePrefixRe = /^(.*?)\s*[`~]/;
+
+module.exports = {
+  "names": [ "MD031", "blanks-around-fences" ],
+  "description": "Fenced code blocks should be surrounded by blank lines",
+  "tags": [ "code", "blank_lines" ],
+  "function": function MD031(params, onError) {
+    const listItems = params.config.list_items;
+    const includeListItems = (listItems === undefined) ? true : !!listItems;
+    const { lines } = params;
+    forEachLine(lineMetadata(), (line, i, inCode, onFence, inTable, inItem) => {
+      const onTopFence = (onFence > 0);
+      const onBottomFence = (onFence < 0);
+      if ((includeListItems || !inItem) &&
+          ((onTopFence && !isBlankLine(lines[i - 1])) ||
+           (onBottomFence && !isBlankLine(lines[i + 1])))) {
+        const [ , prefix ] = line.match(codeFencePrefixRe) || [];
+        const fixInfo = (prefix === undefined) ? null : {
+          "lineNumber": i + (onTopFence ? 1 : 2),
+          "insertText": `${prefix}\n`
+        };
+        addErrorContext(
+          onError,
+          i + 1,
+          lines[i].trim(),
+          null,
+          null,
+          null,
+          fixInfo);
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md032.js

@@ -0,0 +1,50 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, isBlankLine } = require("../helpers");
+const { flattenedLists } = require("./cache");
+
+const quotePrefixRe = /^[>\s]*/;
+
+module.exports = {
+  "names": [ "MD032", "blanks-around-lists" ],
+  "description": "Lists should be surrounded by blank lines",
+  "tags": [ "bullet", "ul", "ol", "blank_lines" ],
+  "function": function MD032(params, onError) {
+    const { lines } = params;
+    flattenedLists().filter((list) => !list.nesting).forEach((list) => {
+      const firstIndex = list.open.map[0];
+      if (!isBlankLine(lines[firstIndex - 1])) {
+        const line = lines[firstIndex];
+        const quotePrefix = line.match(quotePrefixRe)[0].trimEnd();
+        addErrorContext(
+          onError,
+          firstIndex + 1,
+          line.trim(),
+          null,
+          null,
+          null,
+          {
+            "insertText": `${quotePrefix}\n`
+          });
+      }
+      const lastIndex = list.lastLineIndex - 1;
+      if (!isBlankLine(lines[lastIndex + 1])) {
+        const line = lines[lastIndex];
+        const quotePrefix = line.match(quotePrefixRe)[0].trimEnd();
+        addErrorContext(
+          onError,
+          lastIndex + 1,
+          line.trim(),
+          null,
+          null,
+          null,
+          {
+            "lineNumber": lastIndex + 2,
+            "insertText": `${quotePrefix}\n`
+          });
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md033.js

@@ -0,0 +1,49 @@
+// @ts-check
+
+"use strict";
+
+const {
+  addError, forEachLine, overlapsAnyRange, unescapeMarkdown
+} = require("../helpers");
+const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
+
+const htmlElementRe = /<(([A-Za-z][A-Za-z0-9-]*)(?:\s[^>]*)?)\/?>/g;
+const linkDestinationRe = /]\(\s*$/;
+// See https://spec.commonmark.org/0.29/#autolinks
+const emailAddressRe =
+  // eslint-disable-next-line max-len
+  /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+
+module.exports = {
+  "names": [ "MD033", "no-inline-html" ],
+  "description": "Inline HTML",
+  "tags": [ "html" ],
+  "function": function MD033(params, onError) {
+    let allowedElements = params.config.allowed_elements;
+    allowedElements = Array.isArray(allowedElements) ? allowedElements : [];
+    allowedElements = allowedElements.map((element) => element.toLowerCase());
+    const exclusions = codeBlockAndSpanRanges();
+    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
+      let match = null;
+      // eslint-disable-next-line no-unmodified-loop-condition
+      while (!inCode && ((match = htmlElementRe.exec(line)) !== null)) {
+        const [ tag, content, element ] = match;
+        if (
+          !allowedElements.includes(element.toLowerCase()) &&
+          !tag.endsWith("\\>") &&
+          !emailAddressRe.test(content) &&
+          !overlapsAnyRange(exclusions, lineIndex, match.index, match[0].length)
+        ) {
+          const prefix = line.substring(0, match.index);
+          if (!linkDestinationRe.test(prefix)) {
+            const unescaped = unescapeMarkdown(prefix + "<", "_");
+            if (!unescaped.endsWith("_")) {
+              addError(onError, lineIndex + 1, "Element: " + element,
+                null, [ match.index + 1, tag.length ]);
+            }
+          }
+        }
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md034.js

@@ -0,0 +1,61 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, bareUrlRe, filterTokens } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD034", "no-bare-urls" ],
+  "description": "Bare URL used",
+  "tags": [ "links", "url" ],
+  "function": function MD034(params, onError) {
+    filterTokens(params, "inline", (token) => {
+      let inLink = false;
+      token.children.forEach((child) => {
+        const { content, line, lineNumber, type } = child;
+        let match = null;
+        if (type === "link_open") {
+          inLink = true;
+        } else if (type === "link_close") {
+          inLink = false;
+        } else if ((type === "text") && !inLink) {
+          while ((match = bareUrlRe.exec(content)) !== null) {
+            const [ bareUrl ] = match;
+            const matchIndex = match.index;
+            const bareUrlLength = bareUrl.length;
+            // Allow "[https://example.com]" to avoid conflicts with
+            // MD011/no-reversed-links; allow quoting as another way
+            // of deliberately including a bare URL
+            const leftChar = content[matchIndex - 1];
+            const rightChar = content[matchIndex + bareUrlLength];
+            if (
+              !((leftChar === "[") && (rightChar === "]")) &&
+              !((leftChar === "\"") && (rightChar === "\"")) &&
+              !((leftChar === "'") && (rightChar === "'"))
+            ) {
+              const index = line.indexOf(content);
+              const range = (index === -1) ? null : [
+                index + matchIndex + 1,
+                bareUrlLength
+              ];
+              const fixInfo = range ? {
+                "editColumn": range[0],
+                "deleteCount": range[1],
+                "insertText": `<${bareUrl}>`
+              } : null;
+              addErrorContext(
+                onError,
+                lineNumber,
+                bareUrl,
+                null,
+                null,
+                range,
+                fixInfo
+              );
+            }
+          }
+        }
+      });
+    });
+  }
+};

node_modules/markdownlint/lib/md035.js

@@ -0,0 +1,21 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, filterTokens } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD035", "hr-style" ],
+  "description": "Horizontal rule style",
+  "tags": [ "hr" ],
+  "function": function MD035(params, onError) {
+    let style = String(params.config.style || "consistent");
+    filterTokens(params, "hr", (token) => {
+      const { lineNumber, markup } = token;
+      if (style === "consistent") {
+        style = markup;
+      }
+      addErrorDetailIf(onError, lineNumber, style, markup);
+    });
+  }
+};

node_modules/markdownlint/lib/md036.js

@@ -0,0 +1,56 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, allPunctuation } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD036", "no-emphasis-as-heading", "no-emphasis-as-header" ],
+  "description": "Emphasis used instead of a heading",
+  "tags": [ "headings", "headers", "emphasis" ],
+  "function": function MD036(params, onError) {
+    let punctuation = params.config.punctuation;
+    punctuation =
+      String((punctuation === undefined) ? allPunctuation : punctuation);
+    const re = new RegExp("[" + punctuation + "]$");
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function base(token) {
+      if (token.type === "paragraph_open") {
+        return function inParagraph(t) {
+          // Always paragraph_open/inline/paragraph_close,
+          const children = t.children.filter(function notEmptyText(child) {
+            return (child.type !== "text") || (child.content !== "");
+          });
+          if ((children.length === 3) &&
+              ((children[0].type === "strong_open") ||
+                (children[0].type === "em_open")) &&
+              (children[1].type === "text") &&
+              !re.test(children[1].content)) {
+            addErrorContext(onError, t.lineNumber,
+              children[1].content);
+          }
+          return base;
+        };
+      } else if (token.type === "blockquote_open") {
+        return function inBlockquote(t) {
+          if (t.type !== "blockquote_close") {
+            return inBlockquote;
+          }
+          return base;
+        };
+      } else if (token.type === "list_item_open") {
+        return function inListItem(t) {
+          if (t.type !== "list_item_close") {
+            return inListItem;
+          }
+          return base;
+        };
+      }
+      return base;
+    }
+    let state = base;
+    params.tokens.forEach(function forToken(token) {
+      state = state(token);
+    });
+  }
+};

node_modules/markdownlint/lib/md037.js

@@ -0,0 +1,178 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, emphasisMarkersInContent, forEachLine, isBlankLine } =
+  require("../helpers");
+const { lineMetadata } = require("./cache");
+
+const emphasisRe = /(^|[^\\]|\\\\)(?:(\*\*?\*?)|(__?_?))/g;
+const embeddedUnderscoreRe = /([A-Za-z0-9])_([A-Za-z0-9])/g;
+const asteriskListItemMarkerRe = /^([\s>]*)\*(\s+)/;
+const leftSpaceRe = /^\s+/;
+const rightSpaceRe = /\s+$/;
+const tablePipeRe = /\|/;
+
+module.exports = {
+  "names": [ "MD037", "no-space-in-emphasis" ],
+  "description": "Spaces inside emphasis markers",
+  "tags": [ "whitespace", "emphasis" ],
+  "function": function MD037(params, onError) {
+    // eslint-disable-next-line init-declarations
+    let effectiveEmphasisLength, emphasisIndex, emphasisKind, emphasisLength,
+      pendingError = null;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function resetRunTracking() {
+      emphasisIndex = -1;
+      emphasisLength = 0;
+      emphasisKind = "";
+      effectiveEmphasisLength = 0;
+      pendingError = null;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function handleRunEnd(
+      line, lineIndex, contextLength, match, matchIndex, inTable
+    ) {
+      // Close current run
+      let content = line.substring(emphasisIndex, matchIndex);
+      if (!emphasisLength) {
+        content = content.trimStart();
+      }
+      if (!match) {
+        content = content.trimEnd();
+      }
+      const leftSpace = leftSpaceRe.test(content);
+      const rightSpace = rightSpaceRe.test(content);
+      if (
+        (leftSpace || rightSpace) &&
+        (!inTable || !tablePipeRe.test(content))
+      ) {
+        // Report the violation
+        const contextStart = emphasisIndex - emphasisLength;
+        const contextEnd = matchIndex + contextLength;
+        const context = line.substring(contextStart, contextEnd);
+        const column = contextStart + 1;
+        const length = contextEnd - contextStart;
+        const leftMarker = line.substring(contextStart, emphasisIndex);
+        const rightMarker = match ? (match[2] || match[3]) : "";
+        const fixedText = `${leftMarker}${content.trim()}${rightMarker}`;
+        return [
+          onError,
+          lineIndex + 1,
+          context,
+          leftSpace,
+          rightSpace,
+          [ column, length ],
+          {
+            "editColumn": column,
+            "deleteCount": length,
+            "insertText": fixedText
+          }
+        ];
+      }
+      return null;
+    }
+    // Initialize
+    const ignoreMarkersByLine = emphasisMarkersInContent(params);
+    resetRunTracking();
+    forEachLine(
+      lineMetadata(),
+      (line, lineIndex, inCode, onFence, inTable, inItem, onBreak, inMath) => {
+        const onItemStart = (inItem === 1);
+        if (
+          inCode ||
+          onFence ||
+          inTable ||
+          onBreak ||
+          onItemStart ||
+          isBlankLine(line)
+        ) {
+          // Emphasis resets when leaving a block
+          resetRunTracking();
+        }
+        if (
+          inCode ||
+          onFence ||
+          onBreak ||
+          inMath
+        ) {
+          // Emphasis has no meaning here
+          return;
+        }
+        let patchedLine = line.replace(embeddedUnderscoreRe, "$1 $2");
+        if (onItemStart) {
+          // Trim overlapping '*' list item marker
+          patchedLine = patchedLine.replace(asteriskListItemMarkerRe, "$1 $2");
+        }
+        let match = null;
+        // Match all emphasis-looking runs in the line...
+        while ((match = emphasisRe.exec(patchedLine))) {
+          const ignoreMarkersForLine = ignoreMarkersByLine[lineIndex];
+          const matchIndex = match.index + match[1].length;
+          if (ignoreMarkersForLine.includes(matchIndex)) {
+            // Ignore emphasis markers inside code spans and links
+            continue;
+          }
+          const matchLength = match[0].length - match[1].length;
+          const matchKind = (match[2] || match[3])[0];
+          if (emphasisIndex === -1) {
+            // New run
+            emphasisIndex = matchIndex + matchLength;
+            emphasisLength = matchLength;
+            emphasisKind = matchKind;
+            effectiveEmphasisLength = matchLength;
+          } else if (matchKind === emphasisKind) {
+            // Matching emphasis markers
+            if (matchLength === effectiveEmphasisLength) {
+              // Ending an existing run, report any pending error
+              if (pendingError) {
+                // @ts-ignore
+                addErrorContext(...pendingError);
+                pendingError = null;
+              }
+              const error = handleRunEnd(
+                line,
+                lineIndex,
+                effectiveEmphasisLength,
+                match,
+                matchIndex,
+                inTable
+              );
+              if (error) {
+                // @ts-ignore
+                addErrorContext(...error);
+              }
+              // Reset
+              resetRunTracking();
+            } else if (matchLength === 3) {
+              // Swap internal run length (1->2 or 2->1)
+              effectiveEmphasisLength = matchLength - effectiveEmphasisLength;
+            } else if (effectiveEmphasisLength === 3) {
+              // Downgrade internal run (3->1 or 3->2)
+              effectiveEmphasisLength -= matchLength;
+            } else {
+              // Upgrade to internal run (1->3 or 2->3)
+              effectiveEmphasisLength += matchLength;
+            }
+            // Back up one character so RegExp has a chance to match the
+            // next marker (ex: "**star**_underscore_")
+            if (emphasisRe.lastIndex > 1) {
+              emphasisRe.lastIndex--;
+            }
+          } else if (emphasisRe.lastIndex > 1) {
+            // Back up one character so RegExp has a chance to match the
+            // mis-matched marker (ex: "*text_*")
+            emphasisRe.lastIndex--;
+          }
+        }
+        if (emphasisIndex !== -1) {
+          pendingError = pendingError ||
+            handleRunEnd(line, lineIndex, 0, null, line.length, inTable);
+          // Adjust for pending run on new line
+          emphasisIndex = 0;
+          emphasisLength = 0;
+        }
+      }
+    );
+  }
+};

node_modules/markdownlint/lib/md038.js

@@ -0,0 +1,68 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens, forEachInlineCodeSpan, newLineRe } =
+  require("../helpers");
+
+const leftSpaceRe = /^\s([^`]|$)/;
+const rightSpaceRe = /[^`]\s$/;
+const singleLeftRightSpaceRe = /^\s(?:\S.*\S|\S)\s$/;
+
+module.exports = {
+  "names": [ "MD038", "no-space-in-code" ],
+  "description": "Spaces inside code span elements",
+  "tags": [ "whitespace", "code" ],
+  "function": function MD038(params, onError) {
+    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, tickCount) => {
+            let rangeIndex = columnIndex - tickCount;
+            let rangeLength = code.length + (2 * tickCount);
+            let rangeLineOffset = 0;
+            let fixIndex = columnIndex;
+            let fixLength = code.length;
+            const codeLines = code.split(newLineRe);
+            const left = leftSpaceRe.test(code);
+            const right = !left && rightSpaceRe.test(code);
+            if (right && (codeLines.length > 1)) {
+              rangeIndex = 0;
+              rangeLineOffset = codeLines.length - 1;
+              fixIndex = 0;
+            }
+            const allowed = singleLeftRightSpaceRe.test(code);
+            if ((left || right) && !allowed) {
+              const codeLinesRange = codeLines[rangeLineOffset];
+              if (codeLines.length > 1) {
+                rangeLength = codeLinesRange.length + tickCount;
+                fixLength = codeLinesRange.length;
+              }
+              const context = tokenLines[lineIndex + rangeLineOffset]
+                .substring(rangeIndex, rangeIndex + rangeLength);
+              const codeLinesRangeTrim = codeLinesRange.trim();
+              const fixText =
+                (codeLinesRangeTrim.startsWith("`") ? " " : "") +
+                codeLinesRangeTrim +
+                (codeLinesRangeTrim.endsWith("`") ? " " : "");
+              addErrorContext(
+                onError,
+                token.lineNumber + lineIndex + rangeLineOffset,
+                context,
+                left,
+                right,
+                [ rangeIndex + 1, rangeLength ],
+                {
+                  "editColumn": fixIndex + 1,
+                  "deleteCount": fixLength,
+                  "insertText": fixText
+                }
+              );
+            }
+          });
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md039.js

@@ -0,0 +1,65 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens } = require("../helpers");
+
+const spaceInLinkRe =
+  /\[(?:\s+(?:[^\]]*?)\s*|(?:[^\]]*?)\s+)](?=((?:\([^)]*\))|(?:\[[^\]]*\])))/;
+
+module.exports = {
+  "names": [ "MD039", "no-space-in-links" ],
+  "description": "Spaces inside link text",
+  "tags": [ "whitespace", "links" ],
+  "function": function MD039(params, onError) {
+    filterTokens(params, "inline", (token) => {
+      const { children } = token;
+      let { lineNumber } = token;
+      let inLink = false;
+      let linkText = "";
+      let lineIndex = 0;
+      children.forEach((child) => {
+        const { content, type } = child;
+        if (type === "link_open") {
+          inLink = true;
+          linkText = "";
+        } else if (type === "link_close") {
+          inLink = false;
+          const left = linkText.trimStart().length !== linkText.length;
+          const right = linkText.trimEnd().length !== linkText.length;
+          if (left || right) {
+            const line = params.lines[lineNumber - 1];
+            let range = null;
+            let fixInfo = null;
+            const match = line.slice(lineIndex).match(spaceInLinkRe);
+            if (match) {
+              const column = match.index + lineIndex + 1;
+              const length = match[0].length;
+              range = [ column, length ];
+              fixInfo = {
+                "editColumn": column + 1,
+                "deleteCount": length - 2,
+                "insertText": linkText.trim()
+              };
+              lineIndex = column + length - 1;
+            }
+            addErrorContext(
+              onError,
+              lineNumber,
+              `[${linkText}]`,
+              left,
+              right,
+              range,
+              fixInfo
+            );
+          }
+        } else if ((type === "softbreak") || (type === "hardbreak")) {
+          lineNumber++;
+          lineIndex = 0;
+        } else if (inLink) {
+          linkText += content;
+        }
+      });
+    });
+  }
+};

node_modules/markdownlint/lib/md040.js

@@ -0,0 +1,18 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD040", "fenced-code-language" ],
+  "description": "Fenced code blocks should have a language specified",
+  "tags": [ "code", "language" ],
+  "function": function MD040(params, onError) {
+    filterTokens(params, "fence", function forToken(token) {
+      if (!token.info.trim()) {
+        addErrorContext(onError, token.lineNumber, token.line);
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md041.js

@@ -0,0 +1,42 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, frontMatterHasTitle } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD041", "first-line-heading", "first-line-h1" ],
+  "description": "First line in a file should be a top-level heading",
+  "tags": [ "headings", "headers" ],
+  "function": function MD041(params, onError) {
+    const level = Number(params.config.level || 1);
+    const tag = "h" + level;
+    const foundFrontMatterTitle =
+      frontMatterHasTitle(
+        params.frontMatterLines,
+        params.config.front_matter_title
+      );
+    if (!foundFrontMatterTitle) {
+      const htmlHeadingRe = new RegExp(`^<h${level}[ />]`, "i");
+      params.tokens.every((token) => {
+        let isError = false;
+        if (token.type === "html_block") {
+          if (token.content.startsWith("<!--")) {
+            // Ignore leading HTML comments
+            return true;
+          } else if (!htmlHeadingRe.test(token.content)) {
+            // Something other than an HTML heading
+            isError = true;
+          }
+        } else if ((token.type !== "heading_open") || (token.tag !== tag)) {
+          // Something other than a Markdown heading
+          isError = true;
+        }
+        if (isError) {
+          addErrorContext(onError, token.lineNumber, token.line);
+        }
+        return false;
+      });
+    }
+  }
+};

node_modules/markdownlint/lib/md042.js

@@ -0,0 +1,42 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens, rangeFromRegExp } =
+  require("../helpers");
+
+const emptyLinkRe = /\[[^\]]*](?:\((?:#?|(?:<>))\))/;
+
+module.exports = {
+  "names": [ "MD042", "no-empty-links" ],
+  "description": "No empty links",
+  "tags": [ "links" ],
+  "function": function MD042(params, onError) {
+    filterTokens(params, "inline", function forToken(token) {
+      let inLink = false;
+      let linkText = "";
+      let emptyLink = false;
+      token.children.forEach(function forChild(child) {
+        if (child.type === "link_open") {
+          inLink = true;
+          linkText = "";
+          child.attrs.forEach(function forAttr(attr) {
+            if (attr[0] === "href" && (!attr[1] || (attr[1] === "#"))) {
+              emptyLink = true;
+            }
+          });
+        } else if (child.type === "link_close") {
+          inLink = false;
+          if (emptyLink) {
+            addErrorContext(onError, child.lineNumber,
+              "[" + linkText + "]()", null, null,
+              rangeFromRegExp(child.line, emptyLinkRe));
+            emptyLink = false;
+          }
+        } else if (inLink) {
+          linkText += child.content;
+        }
+      });
+    });
+  }
+};

node_modules/markdownlint/lib/md043.js

@@ -0,0 +1,60 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, addErrorDetailIf, forEachHeading } =
+  require("../helpers");
+
+module.exports = {
+  "names": [ "MD043", "required-headings", "required-headers" ],
+  "description": "Required heading structure",
+  "tags": [ "headings", "headers" ],
+  "function": function MD043(params, onError) {
+    const requiredHeadings = params.config.headings || params.config.headers;
+    if (Array.isArray(requiredHeadings)) {
+      const levels = {};
+      [ 1, 2, 3, 4, 5, 6 ].forEach((level) => {
+        levels["h" + level] = "######".substr(-level);
+      });
+      let i = 0;
+      let matchAny = false;
+      let hasError = false;
+      let anyHeadings = false;
+      const getExpected = () => requiredHeadings[i++] || "[None]";
+      forEachHeading(params, (heading, content) => {
+        if (!hasError) {
+          anyHeadings = true;
+          const actual = levels[heading.tag] + " " + content;
+          const expected = getExpected();
+          if (expected === "*") {
+            const nextExpected = getExpected();
+            if (nextExpected.toLowerCase() !== actual.toLowerCase()) {
+              matchAny = true;
+              i--;
+            }
+          } else if (expected === "+") {
+            matchAny = true;
+          } else if (expected.toLowerCase() === actual.toLowerCase()) {
+            matchAny = false;
+          } else if (matchAny) {
+            i--;
+          } else {
+            addErrorDetailIf(onError, heading.lineNumber,
+              expected, actual);
+            hasError = true;
+          }
+        }
+      });
+      const extraHeadings = requiredHeadings.length - i;
+      if (
+        !hasError &&
+        ((extraHeadings > 1) ||
+          ((extraHeadings === 1) && (requiredHeadings[i] !== "*"))) &&
+        (anyHeadings || !requiredHeadings.every((heading) => heading === "*"))
+      ) {
+        addErrorContext(onError, params.lines.length,
+          requiredHeadings[i]);
+      }
+    }
+  }
+};

node_modules/markdownlint/lib/md044.js

@@ -0,0 +1,77 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, bareUrlRe, escapeForRegExp, forEachLine,
+  overlapsAnyRange, linkRe, linkReferenceRe } = require("../helpers");
+const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
+
+module.exports = {
+  "names": [ "MD044", "proper-names" ],
+  "description": "Proper names should have the correct capitalization",
+  "tags": [ "spelling" ],
+  "function": function MD044(params, onError) {
+    let names = params.config.names;
+    names = Array.isArray(names) ? names : [];
+    names.sort((a, b) => (b.length - a.length) || a.localeCompare(b));
+    const codeBlocks = params.config.code_blocks;
+    const includeCodeBlocks = (codeBlocks === undefined) ? true : !!codeBlocks;
+    const exclusions = [];
+    forEachLine(lineMetadata(), (line, lineIndex) => {
+      if (linkReferenceRe.test(line)) {
+        exclusions.push([ lineIndex, 0, line.length ]);
+      } else {
+        let match = null;
+        while ((match = bareUrlRe.exec(line)) !== null) {
+          exclusions.push([ lineIndex, match.index, match[0].length ]);
+        }
+        while ((match = linkRe.exec(line)) !== null) {
+          const [ , text, destination ] = match;
+          if (destination) {
+            exclusions.push(
+              [ lineIndex, match.index + text.length, destination.length ]
+            );
+          }
+        }
+      }
+    });
+    if (!includeCodeBlocks) {
+      exclusions.push(...codeBlockAndSpanRanges());
+    }
+    for (const name of names) {
+      const escapedName = escapeForRegExp(name);
+      const startNamePattern = /^\W/.test(name) ? "" : "\\b_*";
+      const endNamePattern = /\W$/.test(name) ? "" : "_*\\b";
+      const namePattern =
+        `(${startNamePattern})(${escapedName})${endNamePattern}`;
+      const nameRe = new RegExp(namePattern, "gi");
+      forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence) => {
+        if (includeCodeBlocks || (!inCode && !onFence)) {
+          let match = null;
+          while ((match = nameRe.exec(line)) !== null) {
+            const [ , leftMatch, nameMatch ] = match;
+            const index = match.index + leftMatch.length;
+            const length = nameMatch.length;
+            if (!overlapsAnyRange(exclusions, lineIndex, index, length)) {
+              addErrorDetailIf(
+                onError,
+                lineIndex + 1,
+                name,
+                nameMatch,
+                null,
+                null,
+                [ index + 1, length ],
+                {
+                  "editColumn": index + 1,
+                  "deleteCount": length,
+                  "insertText": name
+                }
+              );
+            }
+            exclusions.push([ lineIndex, index, length ]);
+          }
+        }
+      });
+    }
+  }
+};

node_modules/markdownlint/lib/md045.js

@@ -0,0 +1,18 @@
+// @ts-check
+
+"use strict";
+
+const { addError, forEachInlineChild } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD045", "no-alt-text" ],
+  "description": "Images should have alternate text (alt text)",
+  "tags": [ "accessibility", "images" ],
+  "function": function MD045(params, onError) {
+    forEachInlineChild(params, "image", function forToken(token) {
+      if (token.content === "") {
+        addError(onError, token.lineNumber);
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md046.js

@@ -0,0 +1,32 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf } = require("../helpers");
+
+const tokenTypeToStyle = {
+  "fence": "fenced",
+  "code_block": "indented"
+};
+
+module.exports = {
+  "names": [ "MD046", "code-block-style" ],
+  "description": "Code block style",
+  "tags": [ "code" ],
+  "function": function MD046(params, onError) {
+    let expectedStyle = String(params.config.style || "consistent");
+    params.tokens
+      .filter((token) => token.type === "code_block" || token.type === "fence")
+      .forEach((token) => {
+        const { lineNumber, type } = token;
+        if (expectedStyle === "consistent") {
+          expectedStyle = tokenTypeToStyle[type];
+        }
+        addErrorDetailIf(
+          onError,
+          lineNumber,
+          expectedStyle,
+          tokenTypeToStyle[type]);
+      });
+  }
+};

node_modules/markdownlint/lib/md047.js

@@ -0,0 +1,28 @@
+// @ts-check
+
+"use strict";
+
+const { addError, isBlankLine } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD047", "single-trailing-newline" ],
+  "description": "Files should end with a single newline character",
+  "tags": [ "blank_lines" ],
+  "function": function MD047(params, onError) {
+    const lastLineNumber = params.lines.length;
+    const lastLine = params.lines[lastLineNumber - 1];
+    if (!isBlankLine(lastLine)) {
+      addError(
+        onError,
+        lastLineNumber,
+        null,
+        null,
+        [ lastLine.length, 1 ],
+        {
+          "insertText": "\n",
+          "editColumn": lastLine.length + 1
+        }
+      );
+    }
+  }
+};

node_modules/markdownlint/lib/md048.js

@@ -0,0 +1,29 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, fencedCodeBlockStyleFor } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD048", "code-fence-style" ],
+  "description": "Code fence style",
+  "tags": [ "code" ],
+  "function": function MD048(params, onError) {
+    const style = String(params.config.style || "consistent");
+    let expectedStyle = style;
+    params.tokens
+      .filter((token) => token.type === "fence")
+      .forEach((fenceToken) => {
+        const { lineNumber, markup } = fenceToken;
+        if (expectedStyle === "consistent") {
+          expectedStyle = fencedCodeBlockStyleFor(markup);
+        }
+        addErrorDetailIf(
+          onError,
+          lineNumber,
+          expectedStyle,
+          fencedCodeBlockStyleFor(markup)
+        );
+      });
+  }
+};

node_modules/markdownlint/lib/md049.js

@@ -0,0 +1,45 @@
+// @ts-check
+
+"use strict";
+
+const { addError, emphasisOrStrongStyleFor, forEachInlineChild,
+  getNextChildToken, getRangeAndFixInfoIfFound } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD049", "emphasis-style" ],
+  "description": "Emphasis style should be consistent",
+  "tags": [ "emphasis" ],
+  "function": function MD049(params, onError) {
+    let expectedStyle = String(params.config.style || "consistent");
+    forEachInlineChild(params, "em_open", (token, parent) => {
+      const { lineNumber, markup } = token;
+      const markupStyle = emphasisOrStrongStyleFor(markup);
+      if (expectedStyle === "consistent") {
+        expectedStyle = markupStyle;
+      }
+      if (expectedStyle !== markupStyle) {
+        let rangeAndFixInfo = {};
+        const contentToken = getNextChildToken(
+          parent, token, "text", "em_close"
+        );
+        if (contentToken) {
+          const { content } = contentToken;
+          const actual = `${markup}${content}${markup}`;
+          const expectedMarkup = (expectedStyle === "asterisk") ? "*" : "_";
+          const expected = `${expectedMarkup}${content}${expectedMarkup}`;
+          rangeAndFixInfo = getRangeAndFixInfoIfFound(
+            params.lines, lineNumber - 1, actual, expected
+          );
+        }
+        addError(
+          onError,
+          lineNumber,
+          `Expected: ${expectedStyle}; Actual: ${markupStyle}`,
+          null,
+          rangeAndFixInfo.range,
+          rangeAndFixInfo.fixInfo
+        );
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/md050.js

@@ -0,0 +1,45 @@
+// @ts-check
+
+"use strict";
+
+const { addError, emphasisOrStrongStyleFor, forEachInlineChild,
+  getNextChildToken, getRangeAndFixInfoIfFound } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD050", "strong-style" ],
+  "description": "Strong style should be consistent",
+  "tags": [ "emphasis" ],
+  "function": function MD050(params, onError) {
+    let expectedStyle = String(params.config.style || "consistent");
+    forEachInlineChild(params, "strong_open", (token, parent) => {
+      const { lineNumber, markup } = token;
+      const markupStyle = emphasisOrStrongStyleFor(markup);
+      if (expectedStyle === "consistent") {
+        expectedStyle = markupStyle;
+      }
+      if (expectedStyle !== markupStyle) {
+        let rangeAndFixInfo = {};
+        const contentToken = getNextChildToken(
+          parent, token, "text", "strong_close"
+        );
+        if (contentToken) {
+          const { content } = contentToken;
+          const actual = `${markup}${content}${markup}`;
+          const expectedMarkup = (expectedStyle === "asterisk") ? "**" : "__";
+          const expected = `${expectedMarkup}${content}${expectedMarkup}`;
+          rangeAndFixInfo = getRangeAndFixInfoIfFound(
+            params.lines, lineNumber - 1, actual, expected
+          );
+        }
+        addError(
+          onError,
+          lineNumber,
+          `Expected: ${expectedStyle}; Actual: ${markupStyle}`,
+          null,
+          rangeAndFixInfo.range,
+          rangeAndFixInfo.fixInfo
+        );
+      }
+    });
+  }
+};

node_modules/markdownlint/lib/rules.js

@@ -0,0 +1,61 @@
+// @ts-check
+
+"use strict";
+
+const { homepage, version } = require("./constants");
+
+const rules = [
+  require("./md001"),
+  require("./md002"),
+  require("./md003"),
+  require("./md004"),
+  require("./md005"),
+  require("./md006"),
+  require("./md007"),
+  require("./md009"),
+  require("./md010"),
+  require("./md011"),
+  require("./md012"),
+  require("./md013"),
+  require("./md014"),
+  require("./md018"),
+  require("./md019"),
+  require("./md020"),
+  require("./md021"),
+  require("./md022"),
+  require("./md023"),
+  require("./md024"),
+  require("./md025"),
+  require("./md026"),
+  require("./md027"),
+  require("./md028"),
+  require("./md029"),
+  require("./md030"),
+  require("./md031"),
+  require("./md032"),
+  require("./md033"),
+  require("./md034"),
+  require("./md035"),
+  require("./md036"),
+  require("./md037"),
+  require("./md038"),
+  require("./md039"),
+  require("./md040"),
+  require("./md041"),
+  require("./md042"),
+  require("./md043"),
+  require("./md044"),
+  require("./md045"),
+  require("./md046"),
+  require("./md047"),
+  require("./md048"),
+  require("./md049"),
+  require("./md050")
+];
+rules.forEach((rule) => {
+  const name = rule.names[0].toLowerCase();
+  // eslint-disable-next-line dot-notation
+  rule["information"] =
+    new URL(`${homepage}/blob/v${version}/doc/Rules.md#${name}`);
+});
+module.exports = rules;