@html-validate/eslint-config 5.5.14 → 5.5.18

package/dist/cli.js

@@ -18,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -93,6 +97,53 @@ var require_textwrap = __commonJS({
     "use strict";
     var wordsep_simple_re = /([\t\n\x0b\x0c\r ]+)/;
     var TextWrapper = class {
+      /*
+       *  Object for wrapping/filling text.  The public interface consists of
+       *  the wrap() and fill() methods; the other methods are just there for
+       *  subclasses to override in order to tweak the default behaviour.
+       *  If you want to completely replace the main wrapping algorithm,
+       *  you'll probably have to override _wrap_chunks().
+       *
+       *  Several instance attributes control various aspects of wrapping:
+       *    width (default: 70)
+       *      the maximum width of wrapped lines (unless break_long_words
+       *      is false)
+       *    initial_indent (default: "")
+       *      string that will be prepended to the first line of wrapped
+       *      output.  Counts towards the line's width.
+       *    subsequent_indent (default: "")
+       *      string that will be prepended to all lines save the first
+       *      of wrapped output; also counts towards each line's width.
+       *    expand_tabs (default: true)
+       *      Expand tabs in input text to spaces before further processing.
+       *      Each tab will become 0 .. 'tabsize' spaces, depending on its position
+       *      in its line.  If false, each tab is treated as a single character.
+       *    tabsize (default: 8)
+       *      Expand tabs in input text to 0 .. 'tabsize' spaces, unless
+       *      'expand_tabs' is false.
+       *    replace_whitespace (default: true)
+       *      Replace all whitespace characters in the input text by spaces
+       *      after tab expansion.  Note that if expand_tabs is false and
+       *      replace_whitespace is true, every tab will be converted to a
+       *      single space!
+       *    fix_sentence_endings (default: false)
+       *      Ensure that sentence-ending punctuation is always followed
+       *      by two spaces.  Off by default because the algorithm is
+       *      (unavoidably) imperfect.
+       *    break_long_words (default: true)
+       *      Break words longer than 'width'.  If false, those words will not
+       *      be broken, and some lines might be longer than 'width'.
+       *    break_on_hyphens (default: true)
+       *      Allow breaking hyphenated words. If true, wrapping will occur
+       *      preferably on whitespaces and right after hyphens part of
+       *      compound words.
+       *    drop_whitespace (default: true)
+       *      Drop leading and trailing whitespace from lines.
+       *    max_lines (default: None)
+       *      Truncate wrapped lines.
+       *    placeholder (default: ' [...]')
+       *      Append to the last line of truncated text.
+       */
       constructor(options = {}) {
         let {
           width = 70,
@@ -121,6 +172,8 @@ var require_textwrap = __commonJS({
         this.max_lines = max_lines;
         this.placeholder = placeholder;
       }
+      // -- Private methods -----------------------------------------------
+      // (possibly useful for subclasses to override)
       _munge_whitespace(text) {
         if (this.expand_tabs) {
           text = text.replace(/\t/g, " ".repeat(this.tabsize));
@@ -231,6 +284,7 @@ var require_textwrap = __commonJS({
         text = this._munge_whitespace(text);
         return this._split(text);
       }
+      // -- Public interface ----------------------------------------------
       wrap(text) {
         let chunks = this._split_chunks(text);
         return this._wrap_chunks(chunks);
@@ -398,6 +452,7 @@ var require_argparse = __commonJS({
     }
     function _callable(cls) {
       let result = {
+        // object is needed for inferred class name
         [cls.name]: function(...args2) {
           let this_class = new.target === result || !new.target;
           return Reflect.construct(cls, args2, this_class ? cls : new.target);
@@ -607,6 +662,12 @@ var require_argparse = __commonJS({
       return items.slice(0);
     }
     var HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
+      /*
+       *  Formatter for generating usage messages and argument help strings.
+       *
+       *  Only the name of this class is considered a public API. All the methods
+       *  provided by the class are considered an implementation detail.
+       */
       constructor() {
         let [
           prog,
@@ -638,6 +699,9 @@ var require_argparse = __commonJS({
         this._whitespace_matcher = /[ \t\n\r\f\v]+/g;
         this._long_break_matcher = /\n\n\n+/g;
       }
+      // ===============================
+      // Section and indentation methods
+      // ===============================
       _indent() {
         this._current_indent += this._indent_increment;
         this._level += 1;
@@ -650,6 +714,9 @@ var require_argparse = __commonJS({
       _add_item(func, args2) {
         this._current_section.items.push([func, args2]);
       }
+      // ========================
+      // Message building methods
+      // ========================
       start_section(heading) {
         this._indent();
         let section = this._Section(this, this._current_section, heading);
@@ -691,6 +758,9 @@ var require_argparse = __commonJS({
           this.add_argument(action);
         }
       }
+      // =======================
+      // Help-formatting methods
+      // =======================
       format_help() {
         let help = this._root_section.format_help();
         if (help) {
@@ -1072,16 +1142,34 @@ var require_argparse = __commonJS({
       }
     });
     var RawDescriptionHelpFormatter = _camelcase_alias(_callable(class RawDescriptionHelpFormatter extends HelpFormatter {
+      /*
+       *  Help message formatter which retains any formatting in descriptions.
+       *
+       *  Only the name of this class is considered a public API. All the methods
+       *  provided by the class are considered an implementation detail.
+       */
       _fill_text(text, width, indent) {
         return splitlines(text, true).map((line) => indent + line).join("");
       }
     }));
     var RawTextHelpFormatter = _camelcase_alias(_callable(class RawTextHelpFormatter extends RawDescriptionHelpFormatter {
+      /*
+       *  Help message formatter which retains formatting of all help text.
+       *
+       *  Only the name of this class is considered a public API. All the methods
+       *  provided by the class are considered an implementation detail.
+       */
       _split_lines(text) {
         return splitlines(text);
       }
     }));
     var ArgumentDefaultsHelpFormatter = _camelcase_alias(_callable(class ArgumentDefaultsHelpFormatter extends HelpFormatter {
+      /*
+       *  Help message formatter which adds default values to argument help.
+       *
+       *  Only the name of this class is considered a public API. All the methods
+       *  provided by the class are considered an implementation detail.
+       */
       _get_help_string(action) {
         let help = action.help;
         if (!action.help.includes("%(default)") && !action.help.includes("%(defaultValue)")) {
@@ -1096,6 +1184,13 @@ var require_argparse = __commonJS({
       }
     }));
     var MetavarTypeHelpFormatter = _camelcase_alias(_callable(class MetavarTypeHelpFormatter extends HelpFormatter {
+      /*
+       *  Help message formatter which uses the argument 'type' as the default
+       *  metavar value (instead of the argument 'dest')
+       *
+       *  Only the name of this class is considered a public API. All the methods
+       *  provided by the class are considered an implementation detail.
+       */
       _get_default_metavar_for_optional(action) {
         return typeof action.type === "function" ? action.type.name : action.type;
       }
@@ -1117,6 +1212,12 @@ var require_argparse = __commonJS({
       }
     }
     var ArgumentError = _callable(class ArgumentError extends Error {
+      /*
+       *  An error from creating or using an argument (optional or positional).
+       *
+       *  The string value of this exception is the message, augmented with
+       *  information about the argument that caused it.
+       */
       constructor(argument, message) {
         super();
         this.name = "ArgumentError";
@@ -1138,12 +1239,65 @@ var require_argparse = __commonJS({
       }
     });
     var ArgumentTypeError = _callable(class ArgumentTypeError extends Error {
+      /*
+       * An error from trying to convert a command line string to a type.
+       */
       constructor(message) {
         super(message);
         this.name = "ArgumentTypeError";
       }
     });
     var Action = _camelcase_alias(_callable(class Action extends _AttributeHolder(Function) {
+      /*
+       *  Information about how to convert command line strings to Python objects.
+       *
+       *  Action objects are used by an ArgumentParser to represent the information
+       *  needed to parse a single argument from one or more strings from the
+       *  command line. The keyword arguments to the Action constructor are also
+       *  all attributes of Action instances.
+       *
+       *  Keyword Arguments:
+       *
+       *      - option_strings -- A list of command-line option strings which
+       *          should be associated with this action.
+       *
+       *      - dest -- The name of the attribute to hold the created object(s)
+       *
+       *      - nargs -- The number of command-line arguments that should be
+       *          consumed. By default, one argument will be consumed and a single
+       *          value will be produced.  Other values include:
+       *              - N (an integer) consumes N arguments (and produces a list)
+       *              - '?' consumes zero or one arguments
+       *              - '*' consumes zero or more arguments (and produces a list)
+       *              - '+' consumes one or more arguments (and produces a list)
+       *          Note that the difference between the default and nargs=1 is that
+       *          with the default, a single value will be produced, while with
+       *          nargs=1, a list containing a single value will be produced.
+       *
+       *      - const -- The value to be produced if the option is specified and the
+       *          option uses an action that takes no values.
+       *
+       *      - default -- The value to be produced if the option is not specified.
+       *
+       *      - type -- A callable that accepts a single string argument, and
+       *          returns the converted value.  The standard Python types str, int,
+       *          float, and complex are useful examples of such callables.  If None,
+       *          str is used.
+       *
+       *      - choices -- A container of values that should be allowed. If not None,
+       *          after a command-line argument has been converted to the appropriate
+       *          type, an exception will be raised if it is not a member of this
+       *          collection.
+       *
+       *      - required -- True if the action must always be specified at the
+       *          command line. This is only meaningful for optional command-line
+       *          arguments.
+       *
+       *      - help -- The help string describing the argument.
+       *
+       *      - metavar -- The name to be used for the option's argument with the
+       *          help string. If None, the 'dest' value will be used as the name.
+       */
       constructor() {
         let [
           option_strings,
@@ -1311,6 +1465,7 @@ var require_argparse = __commonJS({
           default_value,
           required,
           help
+          //, metavar
         ] = _parse_opts(arguments, {
           option_strings: no_default,
           dest: no_default,
@@ -1673,6 +1828,22 @@ var require_argparse = __commonJS({
       }
     });
     var FileType = _callable(class FileType extends Function {
+      /*
+       *  Factory for creating file object types
+       *
+       *  Instances of FileType are typically passed as type= arguments to the
+       *  ArgumentParser add_argument() method.
+       *
+       *  Keyword Arguments:
+       *      - mode -- A string indicating how the file is to be opened. Accepts the
+       *          same values as the builtin open() function.
+       *      - bufsize -- The file's desired buffer size. Accepts the same values as
+       *          the builtin open() function.
+       *      - encoding -- The file's encoding. Accepts the same values as the
+       *          builtin open() function.
+       *      - errors -- A string indicating how encoding and decoding errors are to
+       *          be handled. Accepts the same value as the builtin open() function.
+       */
       constructor() {
         let [
           flags,
@@ -1688,11 +1859,17 @@ var require_argparse = __commonJS({
           flags: "r",
           encoding: void 0,
           mode: void 0,
+          // 0o666
           autoClose: void 0,
+          // true
           emitClose: void 0,
+          // false
           start: void 0,
+          // 0
           end: void 0,
+          // Infinity
           highWaterMark: void 0,
+          // 64 * 1024
           fs: void 0
         });
         super("return arguments.callee.call.apply(arguments.callee, arguments)");
@@ -1766,6 +1943,12 @@ var require_argparse = __commonJS({
       }
     });
     var Namespace = _callable(class Namespace extends _AttributeHolder() {
+      /*
+       *  Simple object for storing attributes.
+       *
+       *  Implements equality by attribute names and values, and provides a simple
+       *  string representation.
+       */
       constructor(options = {}) {
         super();
         Object.assign(this, options);
@@ -1818,6 +2001,9 @@ var require_argparse = __commonJS({
         this._negative_number_matcher = /^-\d+$|^-\d*\.\d+$/;
         this._has_negative_number_optionals = [];
       }
+      // ====================
+      // Registration methods
+      // ====================
       register(registry_name, value, object) {
         let registry = setdefault(this._registries, registry_name, {});
         registry[value] = object;
@@ -1825,6 +2011,9 @@ var require_argparse = __commonJS({
       _registry_get(registry_name, value, default_value = void 0) {
         return getattr(this._registries[registry_name], value, default_value);
       }
+      // ==================================
+      // Namespace default accessor methods
+      // ==================================
       set_defaults(kwargs) {
         Object.assign(this._defaults, kwargs);
         for (let action of this._actions) {
@@ -1841,6 +2030,9 @@ var require_argparse = __commonJS({
         }
         return this._defaults[dest];
       }
+      // =======================
+      // Adding argument actions
+      // =======================
       add_argument() {
         let [
           args2,
@@ -2055,7 +2247,10 @@ var require_argparse = __commonJS({
       }
       _handle_conflict_error(action, conflicting_actions) {
         let message = conflicting_actions.length === 1 ? "conflicting option string: %s" : "conflicting option strings: %s";
-        let conflict_string = conflicting_actions.map(([option_string]) => option_string).join(", ");
+        let conflict_string = conflicting_actions.map(([
+          option_string
+          /*, action*/
+        ]) => option_string).join(", ");
         throw new ArgumentError(action, sub(message, conflict_string));
       }
       _handle_conflict_resolve(action, conflicting_actions) {
@@ -2132,6 +2327,26 @@ var require_argparse = __commonJS({
       }
     });
     var ArgumentParser2 = _camelcase_alias(_callable(class ArgumentParser extends _AttributeHolder(_ActionsContainer) {
+      /*
+       *  Object for parsing command line strings into Python objects.
+       *
+       *  Keyword Arguments:
+       *      - prog -- The name of the program (default: sys.argv[0])
+       *      - usage -- A usage message (default: auto-generated from arguments)
+       *      - description -- A description of what the program does
+       *      - epilog -- Text following the argument descriptions
+       *      - parents -- Parsers whose arguments should be copied into this one
+       *      - formatter_class -- HelpFormatter class for printing help messages
+       *      - prefix_chars -- Characters that prefix optional arguments
+       *      - fromfile_prefix_chars -- Characters that prefix files containing
+       *          additional arguments
+       *      - argument_default -- The default value for all arguments
+       *      - conflict_handler -- String indicating how to handle conflicts
+       *      - add_help -- Add a -h/-help option
+       *      - allow_abbrev -- Allow long options to be abbreviated unambiguously
+       *      - exit_on_error -- Determines whether or not ArgumentParser exits with
+       *          error info when an error occurs
+       */
       constructor() {
         let [
           prog,
@@ -2148,7 +2363,9 @@ var require_argparse = __commonJS({
           allow_abbrev,
           exit_on_error,
           debug,
+          // LEGACY (v1 compatibility), debug mode
           version
+          // LEGACY (v1 compatibility), version
         ] = _parse_opts(arguments, {
           prog: void 0,
           usage: void 0,
@@ -2164,7 +2381,9 @@ var require_argparse = __commonJS({
           allow_abbrev: true,
           exit_on_error: true,
           debug: void 0,
+          // LEGACY (v1 compatibility), debug mode
           version: void 0
+          // LEGACY (v1 compatibility), version
         });
         if (debug !== void 0) {
           deprecate(
@@ -2254,6 +2473,9 @@ var require_argparse = __commonJS({
           Object.assign(this._defaults, parent._defaults);
         }
       }
+      // =======================
+      // Pretty __repr__ methods
+      // =======================
       _get_kwargs() {
         let names = [
           "prog",
@@ -2265,6 +2487,9 @@ var require_argparse = __commonJS({
         ];
         return names.map((name) => [name, getattr(this, name)]);
       }
+      // ==================================
+      // Optional/Positional adding methods
+      // ==================================
       add_subparsers() {
         let [
           kwargs
@@ -2310,6 +2535,9 @@ var require_argparse = __commonJS({
       _get_positional_actions() {
         return this._actions.filter((action) => !action.option_strings.length);
       }
+      // =====================================
+      // Command line argument parsing methods
+      // =====================================
       parse_args(args2 = void 0, namespace = void 0) {
         let argv;
         [args2, argv] = this.parse_known_args(args2, namespace);
@@ -2624,7 +2852,11 @@ var require_argparse = __commonJS({
         }
         let option_tuples = this._get_option_tuples(arg_string);
         if (option_tuples.length > 1) {
-          let options = option_tuples.map(([, option_string]) => option_string).join(", ");
+          let options = option_tuples.map(([
+            ,
+            option_string
+            /*, explicit_arg*/
+          ]) => option_string).join(", ");
           let args2 = { option: arg_string, matches: options };
           let msg = "ambiguous option: %(option)s could match %(matches)s";
           this.error(sub(msg, args2));
@@ -2709,6 +2941,9 @@ var require_argparse = __commonJS({
         }
         return nargs_pattern;
       }
+      // ========================
+      // Alt command line argument parsing, allowing free intermix
+      // ========================
       parse_intermixed_args(args2 = void 0, namespace = void 0) {
         let argv;
         [args2, argv] = this.parse_known_intermixed_args(args2, namespace);
@@ -2790,6 +3025,9 @@ var require_argparse = __commonJS({
         }
         return [namespace, extras];
       }
+      // ========================
+      // Value conversion methods
+      // ========================
       _get_values(action, arg_strings) {
         if (![PARSER, REMAINDER].includes(action.nargs)) {
           try {
@@ -2876,6 +3114,9 @@ var require_argparse = __commonJS({
           throw new ArgumentError(action, sub(msg, args2));
         }
       }
+      // =======================
+      // Help-formatting methods
+      // =======================
       format_usage() {
         let formatter = this._get_formatter();
         formatter.add_usage(
@@ -2905,6 +3146,9 @@ var require_argparse = __commonJS({
       _get_formatter() {
         return new this.formatter_class({ prog: this.prog });
       }
+      // =====================
+      // Help-printing methods
+      // =====================
       print_usage(file = void 0) {
         if (file === void 0)
           file = process.stdout;
@@ -2922,6 +3166,9 @@ var require_argparse = __commonJS({
           file.write(message);
         }
       }
+      // ===============
+      // Exiting methods
+      // ===============
       exit(status = 0, message = void 0) {
         if (message) {
           this._print_message(message, process.stderr);
@@ -2986,12 +3233,18 @@ var require_argparse = __commonJS({
 var require_yocto_queue = __commonJS({
   "../../node_modules/yocto-queue/index.js"(exports, module2) {
     var Node = class {
+      /// value;
+      /// next;
       constructor(value) {
         this.value = value;
         this.next = void 0;
       }
     };
     var Queue = class {
+      // TODO: Use private class fields when targeting Node.js 12.
+      // #_head;
+      // #_tail;
+      // #_size;
       constructor() {
         this.clear();
       }
@@ -7693,61 +7946,112 @@ var require_constants = __commonJS({
     module2.exports = {
       MAX_LENGTH: 1024 * 64,
       POSIX_REGEX_SOURCE,
+      // regular expressions
       REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
       REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
       REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
       REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
       REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
       REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+      // Replace globs with equivalent patterns to reduce parsing time.
       REPLACEMENTS: {
         "***": "*",
         "**/**": "**",
         "**/**/**": "**"
       },
+      // Digits
       CHAR_0: 48,
+      /* 0 */
       CHAR_9: 57,
+      /* 9 */
+      // Alphabet chars.
       CHAR_UPPERCASE_A: 65,
+      /* A */
       CHAR_LOWERCASE_A: 97,
+      /* a */
       CHAR_UPPERCASE_Z: 90,
+      /* Z */
       CHAR_LOWERCASE_Z: 122,
+      /* z */
       CHAR_LEFT_PARENTHESES: 40,
+      /* ( */
       CHAR_RIGHT_PARENTHESES: 41,
+      /* ) */
       CHAR_ASTERISK: 42,
+      /* * */
+      // Non-alphabetic chars.
       CHAR_AMPERSAND: 38,
+      /* & */
       CHAR_AT: 64,
+      /* @ */
       CHAR_BACKWARD_SLASH: 92,
+      /* \ */
       CHAR_CARRIAGE_RETURN: 13,
+      /* \r */
       CHAR_CIRCUMFLEX_ACCENT: 94,
+      /* ^ */
       CHAR_COLON: 58,
+      /* : */
       CHAR_COMMA: 44,
+      /* , */
       CHAR_DOT: 46,
+      /* . */
       CHAR_DOUBLE_QUOTE: 34,
+      /* " */
       CHAR_EQUAL: 61,
+      /* = */
       CHAR_EXCLAMATION_MARK: 33,
+      /* ! */
       CHAR_FORM_FEED: 12,
+      /* \f */
       CHAR_FORWARD_SLASH: 47,
+      /* / */
       CHAR_GRAVE_ACCENT: 96,
+      /* ` */
       CHAR_HASH: 35,
+      /* # */
       CHAR_HYPHEN_MINUS: 45,
+      /* - */
       CHAR_LEFT_ANGLE_BRACKET: 60,
+      /* < */
       CHAR_LEFT_CURLY_BRACE: 123,
+      /* { */
       CHAR_LEFT_SQUARE_BRACKET: 91,
+      /* [ */
       CHAR_LINE_FEED: 10,
+      /* \n */
       CHAR_NO_BREAK_SPACE: 160,
+      /* \u00A0 */
       CHAR_PERCENT: 37,
+      /* % */
       CHAR_PLUS: 43,
+      /* + */
       CHAR_QUESTION_MARK: 63,
+      /* ? */
       CHAR_RIGHT_ANGLE_BRACKET: 62,
+      /* > */
       CHAR_RIGHT_CURLY_BRACE: 125,
+      /* } */
       CHAR_RIGHT_SQUARE_BRACKET: 93,
+      /* ] */
       CHAR_SEMICOLON: 59,
+      /* ; */
       CHAR_SINGLE_QUOTE: 39,
+      /* ' */
       CHAR_SPACE: 32,
+      /*   */
       CHAR_TAB: 9,
+      /* \t */
       CHAR_UNDERSCORE: 95,
+      /* _ */
       CHAR_VERTICAL_LINE: 124,
+      /* | */
       CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+      /* \uFEFF */
       SEP: path3.sep,
+      /**
+       * Create EXTGLOB_CHARS
+       */
       extglobChars(chars) {
         return {
           "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
@@ -7757,6 +8061,9 @@ var require_constants = __commonJS({
           "@": { type: "at", open: "(?:", close: ")" }
         };
       },
+      /**
+       * Create GLOB_CHARS
+       */
       globChars(win32) {
         return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
       }
@@ -7834,20 +8141,35 @@ var require_scan = __commonJS({
     var utils = require_utils();
     var {
       CHAR_ASTERISK,
+      /* * */
       CHAR_AT,
+      /* @ */
       CHAR_BACKWARD_SLASH,
+      /* \ */
       CHAR_COMMA,
+      /* , */
       CHAR_DOT,
+      /* . */
       CHAR_EXCLAMATION_MARK,
+      /* ! */
       CHAR_FORWARD_SLASH,
+      /* / */
       CHAR_LEFT_CURLY_BRACE,
+      /* { */
       CHAR_LEFT_PARENTHESES,
+      /* ( */
       CHAR_LEFT_SQUARE_BRACKET,
+      /* [ */
       CHAR_PLUS,
+      /* + */
       CHAR_QUESTION_MARK,
+      /* ? */
       CHAR_RIGHT_CURLY_BRACE,
+      /* } */
       CHAR_RIGHT_PARENTHESES,
+      /* ) */
       CHAR_RIGHT_SQUARE_BRACKET
+      /* ] */
     } = require_constants();
     var isPathSeparator = (code) => {
       return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
@@ -9135,8 +9457,10 @@ var require_readdirp = __commonJS({
       static get defaultOptions() {
         return {
           root: ".",
+          /* eslint-disable no-unused-vars */
           fileFilter: (path3) => true,
           directoryFilter: (path3) => true,
+          /* eslint-enable no-unused-vars */
           type: FILE_TYPE,
           lstat: false,
           depth: 2147483648,
@@ -10290,50 +10614,97 @@ var require_constants2 = __commonJS({
     "use strict";
     module2.exports = {
       MAX_LENGTH: 1024 * 64,
+      // Digits
       CHAR_0: "0",
+      /* 0 */
       CHAR_9: "9",
+      /* 9 */
+      // Alphabet chars.
       CHAR_UPPERCASE_A: "A",
+      /* A */
       CHAR_LOWERCASE_A: "a",
+      /* a */
       CHAR_UPPERCASE_Z: "Z",
+      /* Z */
       CHAR_LOWERCASE_Z: "z",
+      /* z */
       CHAR_LEFT_PARENTHESES: "(",
+      /* ( */
       CHAR_RIGHT_PARENTHESES: ")",
+      /* ) */
       CHAR_ASTERISK: "*",
+      /* * */
+      // Non-alphabetic chars.
       CHAR_AMPERSAND: "&",
+      /* & */
       CHAR_AT: "@",
+      /* @ */
       CHAR_BACKSLASH: "\\",
+      /* \ */
       CHAR_BACKTICK: "`",
+      /* ` */
       CHAR_CARRIAGE_RETURN: "\r",
+      /* \r */
       CHAR_CIRCUMFLEX_ACCENT: "^",
+      /* ^ */
       CHAR_COLON: ":",
+      /* : */
       CHAR_COMMA: ",",
+      /* , */
       CHAR_DOLLAR: "$",
+      /* . */
       CHAR_DOT: ".",
+      /* . */
       CHAR_DOUBLE_QUOTE: '"',
+      /* " */
       CHAR_EQUAL: "=",
+      /* = */
       CHAR_EXCLAMATION_MARK: "!",
+      /* ! */
       CHAR_FORM_FEED: "\f",
+      /* \f */
       CHAR_FORWARD_SLASH: "/",
+      /* / */
       CHAR_HASH: "#",
+      /* # */
       CHAR_HYPHEN_MINUS: "-",
+      /* - */
       CHAR_LEFT_ANGLE_BRACKET: "<",
+      /* < */
       CHAR_LEFT_CURLY_BRACE: "{",
+      /* { */
       CHAR_LEFT_SQUARE_BRACKET: "[",
+      /* [ */
       CHAR_LINE_FEED: "\n",
+      /* \n */
       CHAR_NO_BREAK_SPACE: "\xA0",
+      /* \u00A0 */
       CHAR_PERCENT: "%",
+      /* % */
       CHAR_PLUS: "+",
+      /* + */
       CHAR_QUESTION_MARK: "?",
+      /* ? */
       CHAR_RIGHT_ANGLE_BRACKET: ">",
+      /* > */
       CHAR_RIGHT_CURLY_BRACE: "}",
+      /* } */
       CHAR_RIGHT_SQUARE_BRACKET: "]",
+      /* ] */
       CHAR_SEMICOLON: ";",
+      /* ; */
       CHAR_SINGLE_QUOTE: "'",
+      /* ' */
       CHAR_SPACE: " ",
+      /*   */
       CHAR_TAB: "	",
+      /* \t */
       CHAR_UNDERSCORE: "_",
+      /* _ */
       CHAR_VERTICAL_LINE: "|",
+      /* | */
       CHAR_ZERO_WIDTH_NOBREAK_SPACE: "\uFEFF"
+      /* \uFEFF */
     };
   }
 });
@@ -10346,17 +10717,29 @@ var require_parse2 = __commonJS({
     var {
       MAX_LENGTH,
       CHAR_BACKSLASH,
+      /* \ */
       CHAR_BACKTICK,
+      /* ` */
       CHAR_COMMA,
+      /* , */
       CHAR_DOT,
+      /* . */
       CHAR_LEFT_PARENTHESES,
+      /* ( */
       CHAR_RIGHT_PARENTHESES,
+      /* ) */
       CHAR_LEFT_CURLY_BRACE,
+      /* { */
       CHAR_RIGHT_CURLY_BRACE,
+      /* } */
       CHAR_LEFT_SQUARE_BRACKET,
+      /* [ */
       CHAR_RIGHT_SQUARE_BRACKET,
+      /* ] */
       CHAR_DOUBLE_QUOTE,
+      /* " */
       CHAR_SINGLE_QUOTE,
+      /* ' */
       CHAR_NO_BREAK_SPACE,
       CHAR_ZERO_WIDTH_NOBREAK_SPACE
     } = require_constants2();
@@ -11095,6 +11478,7 @@ var require_nodefs_handler = __commonJS({
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
+          // no need to use broadcast here
           fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
         );
         if (!watcher)
@@ -11179,10 +11563,19 @@ var require_nodefs_handler = __commonJS({
       };
     };
     var NodeFsHandler = class {
+      /**
+       * @param {import("../index").FSWatcher} fsW
+       */
       constructor(fsW) {
         this.fsw = fsW;
         this._boundHandleError = (error) => fsW._handleError(error);
       }
+      /**
+       * Watch file for changes with fs_watchFile or fs_watch.
+       * @param {String} path to file or dir
+       * @param {Function} listener on fs change
+       * @returns {Function} closer for the watcher instance
+       */
       _watchWithNodeFs(path3, listener) {
         const opts = this.fsw.options;
         const directory = sysPath.dirname(path3);
@@ -11209,6 +11602,13 @@ var require_nodefs_handler = __commonJS({
         }
         return closer;
       }
+      /**
+       * Watch a file and emit add event if warranted.
+       * @param {Path} file Path
+       * @param {fs.Stats} stats result of fs_stat
+       * @param {Boolean} initialAdd was the file added at watch instantiation?
+       * @returns {Function} closer for the watcher instance
+       */
       _handleFile(file, stats, initialAdd) {
         if (this.fsw.closed) {
           return;
@@ -11259,6 +11659,14 @@ var require_nodefs_handler = __commonJS({
         }
         return closer;
       }
+      /**
+       * Handle symlinks encountered while reading a dir.
+       * @param {Object} entry returned by readdirp
+       * @param {String} directory path of dir being read
+       * @param {String} path of this item
+       * @param {String} item basename of this item
+       * @returns {Promise<Boolean>} true if no more processing is needed for this entry.
+       */
       async _handleSymlink(entry, directory, path3, item) {
         if (this.fsw.closed) {
           return;
@@ -11349,6 +11757,17 @@ var require_nodefs_handler = __commonJS({
           })
         );
       }
+      /**
+       * Read directory to add / remove files from `@watched` list and re-read it on change.
+       * @param {String} dir fs path
+       * @param {fs.Stats} stats
+       * @param {Boolean} initialAdd
+       * @param {Number} depth relative to user-supplied path
+       * @param {String} target child path targeted for watch
+       * @param {Object} wh Common watch helpers for this path
+       * @param {String} realpath
+       * @returns {Promise<Function>} closer for the watcher instance.
+       */
       async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
         const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
         const tracked = parentDir.has(sysPath.basename(dir));
@@ -11375,6 +11794,16 @@ var require_nodefs_handler = __commonJS({
         }
         return closer;
       }
+      /**
+       * Handle added file, directory, or glob pattern.
+       * Delegates call to _handleFile / _handleDir after checks.
+       * @param {String} path to file or ir
+       * @param {Boolean} initialAdd was the file added at watch instantiation?
+       * @param {Object} priorWh depth relative to user-supplied path
+       * @param {Number} depth Child path actually targeted for watch
+       * @param {String=} target Child path actually targeted for watch
+       * @returns {Promise}
+       */
       async _addToNodeFs(path3, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
         if (this.fsw._isIgnored(path3) || this.fsw.closed) {
@@ -11476,6 +11905,7 @@ var require_fsevents_handler = __commonJS({
       FSEVENT_MODIFIED,
       FSEVENT_DELETED,
       FSEVENT_MOVED,
+      // FSEVENT_CLONED,
       FSEVENT_UNKNOWN,
       FSEVENT_TYPE_FILE,
       FSEVENT_TYPE_DIRECTORY,
@@ -11584,6 +12014,9 @@ var require_fsevents_handler = __commonJS({
     };
     var sameTypes = (info, stats) => info.type === FSEVENT_TYPE_DIRECTORY && stats.isDirectory() || info.type === FSEVENT_TYPE_SYMLINK && stats.isSymbolicLink() || info.type === FSEVENT_TYPE_FILE && stats.isFile();
     var FsEventsHandler = class {
+      /**
+       * @param {import('../index').FSWatcher} fsw
+       */
       constructor(fsw) {
         this.fsw = fsw;
       }
@@ -11645,6 +12078,14 @@ var require_fsevents_handler = __commonJS({
             this._addToFsEvents(path3, false, true);
         }
       }
+      /**
+       * Handle symlinks encountered during directory scan
+       * @param {String} watchPath  - file/dir path to be watched with fsevents
+       * @param {String} realPath   - real path (in case of symlinks)
+       * @param {Function} transform  - path transformer
+       * @param {Function} globFilter - path filter in case a glob pattern was provided
+       * @returns {Function} closer for the watcher instance
+      */
       _watchWithFsEvents(watchPath, realPath, transform, globFilter) {
         if (this.fsw.closed || this.fsw._isIgnored(watchPath))
           return;
@@ -11704,6 +12145,14 @@ var require_fsevents_handler = __commonJS({
         this.fsw._emitReady();
         return closer;
       }
+      /**
+       * Handle symlinks encountered during directory scan
+       * @param {String} linkPath path to symlink
+       * @param {String} fullPath absolute path to the symlink
+       * @param {Function} transform pre-existing path transformer
+       * @param {Number} curDepth level of subdirectories traversed to where symlink is
+       * @returns {Promise<void>}
+       */
       async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
         if (this.fsw.closed || this.fsw._symlinkPaths.has(fullPath))
           return;
@@ -11732,6 +12181,11 @@ var require_fsevents_handler = __commonJS({
           }
         }
       }
+      /**
+       *
+       * @param {Path} newPath
+       * @param {fs.Stats} stats
+       */
       emitAdd(newPath, stats, processPath, opts, forceAdd) {
         const pp = processPath(newPath);
         const isDir = stats.isDirectory();
@@ -11757,6 +12211,14 @@ var require_fsevents_handler = __commonJS({
         );
         this.fsw._addPathCloser(path3, closer);
       }
+      /**
+       * Handle added path with fsevents
+       * @param {String} path file/dir path or glob pattern
+       * @param {Function|Boolean=} transform converts working path to what the user expects
+       * @param {Boolean=} forceAdd ensure add is emitted
+       * @param {Number=} priorDepth Level of subdirectories already traversed.
+       * @returns {Promise<void>}
+       */
       async _addToFsEvents(path3, transform, forceAdd, priorDepth) {
         if (this.fsw.closed) {
           return;
@@ -11927,6 +12389,10 @@ var require_chokidar = __commonJS({
     };
     var undef = (opts, key) => opts[key] === void 0;
     var DirEntry = class {
+      /**
+       * @param {Path} dir
+       * @param {Function} removeWatcher
+       */
       constructor(dir, removeWatcher) {
         this.path = dir;
         this._removeWatcher = removeWatcher;
@@ -11961,6 +12427,9 @@ var require_chokidar = __commonJS({
           return;
         return items.has(item);
       }
+      /**
+       * @returns {Array<String>}
+       */
       getChildren() {
         const { items } = this;
         if (!items)
@@ -12045,6 +12514,7 @@ var require_chokidar = __commonJS({
       }
     };
     var FSWatcher = class extends EventEmitter {
+      // Not indenting methods for history sake; for now.
       constructor(_opts) {
         super();
         const opts = {};
@@ -12135,6 +12605,14 @@ var require_chokidar = __commonJS({
         }
         Object.freeze(opts);
       }
+      // Public methods
+      /**
+       * Adds paths to be watched on an existing FSWatcher instance
+       * @param {Path|Array<Path>} paths_
+       * @param {String=} _origAdd private; for handling non-existent paths to be watched
+       * @param {Boolean=} _internal private; indicates a non-user add
+       * @returns {FSWatcher} for chaining
+       */
       add(paths_, _origAdd, _internal) {
         const { cwd, disableGlobbing } = this.options;
         this.closed = false;
@@ -12185,6 +12663,11 @@ var require_chokidar = __commonJS({
         }
         return this;
       }
+      /**
+       * Close watchers or start ignoring events from specified paths.
+       * @param {Path|Array<Path>} paths_ - string or array of strings, file/directory paths and/or globs
+       * @returns {FSWatcher} for chaining
+      */
       unwatch(paths_) {
         if (this.closed)
           return this;
@@ -12205,6 +12688,10 @@ var require_chokidar = __commonJS({
         });
         return this;
       }
+      /**
+       * Close watchers and remove all listeners from watched paths.
+       * @returns {Promise<void>}.
+      */
       close() {
         if (this.closed)
           return this._closePromise;
@@ -12227,6 +12714,10 @@ var require_chokidar = __commonJS({
         this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
         return this._closePromise;
       }
+      /**
+       * Expose list of watched paths
+       * @returns {Object} for chaining
+      */
       getWatched() {
         const watchList = {};
         this._watched.forEach((entry, dir) => {
@@ -12240,6 +12731,18 @@ var require_chokidar = __commonJS({
         if (event !== EV_ERROR)
           this.emit(EV_ALL, ...args2);
       }
+      // Common helpers
+      // --------------
+      /**
+       * Normalize and emit events.
+       * Calling _emit DOES NOT MEAN emit() would be called!
+       * @param {EventName} event Type of event
+       * @param {Path} path File or directory path
+       * @param {*=} val1 arguments to be passed with event
+       * @param {*=} val2
+       * @param {*=} val3
+       * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+       */
       async _emit(event, path3, val1, val2, val3) {
         if (this.closed)
           return;
@@ -12315,6 +12818,11 @@ var require_chokidar = __commonJS({
         this.emitWithAll(event, args2);
         return this;
       }
+      /**
+       * Common handler for errors
+       * @param {Error} error
+       * @returns {Error|Boolean} The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+       */
       _handleError(error) {
         const code = error && error.code;
         if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
@@ -12322,6 +12830,13 @@ var require_chokidar = __commonJS({
         }
         return error || this.closed;
       }
+      /**
+       * Helper utility for throttling
+       * @param {ThrottleType} actionType type being throttled
+       * @param {Path} path being acted upon
+       * @param {Number} timeout duration of time to suppress duplicate actions
+       * @returns {Object|false} tracking object or false if action should be suppressed
+       */
       _throttle(actionType, path3, timeout) {
         if (!this._throttled.has(actionType)) {
           this._throttled.set(actionType, /* @__PURE__ */ new Map());
@@ -12350,6 +12865,14 @@ var require_chokidar = __commonJS({
       _incrReadyCount() {
         return this._readyCount++;
       }
+      /**
+       * Awaits write operation to finish.
+       * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+       * @param {Path} path being acted upon
+       * @param {Number} threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+       * @param {EventName} event
+       * @param {Function} awfEmit Callback to be called when ready for event to be emitted.
+       */
       _awaitWriteFinish(path3, threshold, event, awfEmit) {
         let timeoutHandler;
         let fullPath = path3;
@@ -12400,6 +12923,12 @@ var require_chokidar = __commonJS({
       _getGlobIgnored() {
         return [...this._ignoredPaths.values()];
       }
+      /**
+       * Determines whether user has asked to ignore this path.
+       * @param {Path} path filepath or dir
+       * @param {fs.Stats=} stats result of fs.stat
+       * @returns {Boolean}
+       */
       _isIgnored(path3, stats) {
         if (this.options.atomic && DOT_RE.test(path3))
           return true;
@@ -12416,11 +12945,24 @@ var require_chokidar = __commonJS({
       _isntIgnored(path3, stat2) {
         return !this._isIgnored(path3, stat2);
       }
+      /**
+       * Provides a set of common helpers and properties relating to symlink and glob handling.
+       * @param {Path} path file, directory, or glob pattern being watched
+       * @param {Number=} depth at any depth > 0, this isn't a glob
+       * @returns {WatchHelper} object containing helpers for this path
+       */
       _getWatchHelpers(path3, depth) {
         const watchPath = depth || this.options.disableGlobbing || !isGlob(path3) ? path3 : globParent(path3);
         const follow = this.options.followSymlinks;
         return new WatchHelper(path3, watchPath, follow, this);
       }
+      // Directory helpers
+      // -----------------
+      /**
+       * Provides directory tracking objects
+       * @param {String} directory path of the directory
+       * @returns {DirEntry} the directory's tracking object
+       */
       _getWatchedDir(directory) {
         if (!this._boundRemove)
           this._boundRemove = this._remove.bind(this);
@@ -12429,6 +12971,14 @@ var require_chokidar = __commonJS({
           this._watched.set(dir, new DirEntry(dir, this._boundRemove));
         return this._watched.get(dir);
       }
+      // File helpers
+      // ------------
+      /**
+       * Check for read permissions.
+       * Based on this answer on SO: https://stackoverflow.com/a/11781404/1358405
+       * @param {fs.Stats} stats - object, result of fs_stat
+       * @returns {Boolean} indicates whether the file can be read
+      */
       _hasReadPermissions(stats) {
         if (this.options.ignorePermissionErrors)
           return true;
@@ -12437,6 +12987,14 @@ var require_chokidar = __commonJS({
         const it = Number.parseInt(st.toString(8)[0], 10);
         return Boolean(4 & it);
       }
+      /**
+       * Handles emitting unlink events for
+       * files and directories, and via recursion, for
+       * files and directories within directories that are unlinked
+       * @param {String} directory within which the following item is located
+       * @param {String} item      base path of item/directory
+       * @returns {void}
+      */
       _remove(directory, item, isDirectory) {
         const path3 = sysPath.join(directory, item);
         const fullPath = sysPath.resolve(path3);
@@ -12472,11 +13030,19 @@ var require_chokidar = __commonJS({
           this._closePath(path3);
         }
       }
+      /**
+       * Closes all watchers for a path
+       * @param {Path} path
+       */
       _closePath(path3) {
         this._closeFile(path3);
         const dir = sysPath.dirname(path3);
         this._getWatchedDir(dir).remove(sysPath.basename(path3));
       }
+      /**
+       * Closes only file-specific watchers
+       * @param {Path} path
+       */
       _closeFile(path3) {
         const closers = this._closers.get(path3);
         if (!closers)
@@ -12484,6 +13050,11 @@ var require_chokidar = __commonJS({
         closers.forEach((closer) => closer());
         this._closers.delete(path3);
       }
+      /**
+       *
+       * @param {Path} path
+       * @param {Function} closer
+       */
       _addPathCloser(path3, closer) {
         if (!closer)
           return;
@@ -13871,7 +14442,7 @@ var require_package = __commonJS({
   "package.json"(exports, module2) {
     module2.exports = {
       name: "@html-validate/eslint-config",
-      version: "5.5.13",
+      version: "5.5.15",
       description: "Eslint sharable config used by the various HTML-validate packages",
       keywords: [
         "eslint"
@@ -13905,11 +14476,11 @@ var require_package = __commonJS({
       },
       dependencies: {
         "@rushstack/eslint-patch": "1.2.0",
-        eslint: "8.29.0",
-        "eslint-config-prettier": "8.5.0",
+        eslint: "8.31.0",
+        "eslint-config-prettier": "8.6.0",
         "eslint-config-sidvind": "1.3.2",
         "eslint-formatter-gitlab": "4.0.0",
-        "eslint-plugin-array-func": "3.1.7",
+        "eslint-plugin-array-func": "3.1.8",
         "eslint-plugin-import": "2.26.0",
         "eslint-plugin-node": "11.1.0",
         "eslint-plugin-prettier": "4.2.1",
@@ -14167,6 +14738,8 @@ var parser = new import_argparse.ArgumentParser({
 });
 parser.add_argument("-v", "--version", {
   action: "version",
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment -- @types/argparse is missing version
+  // @ts-ignore
   version: pkg.version
 });
 parser.add_argument("-w", "--write", {
@@ -14272,4 +14845,54 @@ if (!args.mode) {
   process.exit(1);
 }
 run(args);
+/*! Bundled license information:
+
+normalize-path/index.js:
+  (*!
+   * normalize-path <https://github.com/jonschlinkert/normalize-path>
+   *
+   * Copyright (c) 2014-2018, Jon Schlinkert.
+   * Released under the MIT License.
+   *)
+
+is-extglob/index.js:
+  (*!
+   * is-extglob <https://github.com/jonschlinkert/is-extglob>
+   *
+   * Copyright (c) 2014-2016, Jon Schlinkert.
+   * Licensed under the MIT License.
+   *)
+
+is-glob/index.js:
+  (*!
+   * is-glob <https://github.com/jonschlinkert/is-glob>
+   *
+   * Copyright (c) 2014-2017, Jon Schlinkert.
+   * Released under the MIT License.
+   *)
+
+is-number/index.js:
+  (*!
+   * is-number <https://github.com/jonschlinkert/is-number>
+   *
+   * Copyright (c) 2014-present, Jon Schlinkert.
+   * Released under the MIT License.
+   *)
+
+to-regex-range/index.js:
+  (*!
+   * to-regex-range <https://github.com/micromatch/to-regex-range>
+   *
+   * Copyright (c) 2015-present, Jon Schlinkert.
+   * Released under the MIT License.
+   *)
+
+fill-range/index.js:
+  (*!
+   * fill-range <https://github.com/jonschlinkert/fill-range>
+   *
+   * Copyright (c) 2014-present, Jon Schlinkert.
+   * Licensed under the MIT License.
+   *)
+*/
 //# sourceMappingURL=cli.js.map