@html-validate/puppeteer-fetch 1.0.0 → 2.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2022 David Sveningsson <ext@sidvind.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/index.js

@@ -1,23 +1,10 @@
+"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -29,37 +16,38 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+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
+));
 
 // node_modules/argparse/lib/sub.js
 var require_sub = __commonJS({
-  "node_modules/argparse/lib/sub.js"(exports, module2) {
+  "node_modules/argparse/lib/sub.js"(exports2, module2) {
     "use strict";
     var { inspect } = require("util");
     module2.exports = function sub(pattern, ...values) {
       let regex = /%(?:(%)|(-)?(\*)?(?:\((\w+)\))?([A-Za-z]))/g;
       let result = pattern.replace(regex, function(_, is_literal, is_left_align, is_padded, name, format) {
-        if (is_literal)
-          return "%";
+        if (is_literal) return "%";
         let padded_count = 0;
         if (is_padded) {
-          if (values.length === 0)
-            throw new TypeError("not enough arguments for format string");
+          if (values.length === 0) throw new TypeError("not enough arguments for format string");
           padded_count = values.shift();
-          if (!Number.isInteger(padded_count))
-            throw new TypeError("* wants int");
+          if (!Number.isInteger(padded_count)) throw new TypeError("* wants int");
         }
         let str;
         if (name !== void 0) {
           let dict = values[0];
-          if (typeof dict !== "object" || dict === null)
-            throw new TypeError("format requires a mapping");
-          if (!(name in dict))
-            throw new TypeError(`no such key: '${name}'`);
+          if (typeof dict !== "object" || dict === null) throw new TypeError("format requires a mapping");
+          if (!(name in dict)) throw new TypeError(`no such key: '${name}'`);
           str = dict[name];
         } else {
-          if (values.length === 0)
-            throw new TypeError("not enough arguments for format string");
+          if (values.length === 0) throw new TypeError("not enough arguments for format string");
           str = values.shift();
         }
         switch (format) {
@@ -98,10 +86,57 @@ var require_sub = __commonJS({
 
 // node_modules/argparse/lib/textwrap.js
 var require_textwrap = __commonJS({
-  "node_modules/argparse/lib/textwrap.js"(exports, module2) {
+  "node_modules/argparse/lib/textwrap.js"(exports2, module2) {
     "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,
@@ -130,6 +165,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));
@@ -240,6 +277,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);
@@ -249,12 +287,12 @@ var require_textwrap = __commonJS({
       }
     };
     function wrap(text, options = {}) {
-      let _a = options, { width = 70 } = _a, kwargs = __objRest(_a, ["width"]);
+      let { width = 70, ...kwargs } = options;
       let w = new TextWrapper(Object.assign({ width }, kwargs));
       return w.wrap(text);
     }
     function fill(text, options = {}) {
-      let _a = options, { width = 70 } = _a, kwargs = __objRest(_a, ["width"]);
+      let { width = 70, ...kwargs } = options;
       let w = new TextWrapper(Object.assign({ width }, kwargs));
       return w.fill(text);
     }
@@ -291,7 +329,7 @@ var require_textwrap = __commonJS({
 
 // node_modules/argparse/argparse.js
 var require_argparse = __commonJS({
-  "node_modules/argparse/argparse.js"(exports, module2) {
+  "node_modules/argparse/argparse.js"(exports2, module2) {
     "use strict";
     var SUPPRESS = "==SUPPRESS==";
     var OPTIONAL = "?";
@@ -324,28 +362,23 @@ var require_argparse = __commonJS({
       object[name] = value;
     }
     function setdefault(object, name, value) {
-      if (!hasattr(object, name))
-        object[name] = value;
+      if (!hasattr(object, name)) object[name] = value;
       return object[name];
     }
     function delattr(object, name) {
       delete object[name];
     }
     function range(from, to, step = 1) {
-      if (arguments.length === 1)
-        [to, from] = [from, 0];
+      if (arguments.length === 1) [to, from] = [from, 0];
       if (typeof from !== "number" || typeof to !== "number" || typeof step !== "number") {
         throw new TypeError("argument cannot be interpreted as an integer");
       }
-      if (step === 0)
-        throw new TypeError("range() arg 3 must not be zero");
+      if (step === 0) throw new TypeError("range() arg 3 must not be zero");
       let result = [];
       if (step > 0) {
-        for (let i = from; i < to; i += step)
-          result.push(i);
+        for (let i = from; i < to; i += step) result.push(i);
       } else {
-        for (let i = from; i > to; i += step)
-          result.push(i);
+        for (let i = from; i > to; i += step) result.push(i);
       }
       return result;
     }
@@ -360,14 +393,12 @@ var require_argparse = __commonJS({
           result.push(parts[i] + (i + 1 < parts.length ? parts[i + 1] : ""));
         }
       }
-      if (!result[result.length - 1])
-        result.pop();
+      if (!result[result.length - 1]) result.pop();
       return result;
     }
     function _string_lstrip(string, prefix_chars) {
       let idx = 0;
-      while (idx < string.length && prefix_chars.includes(string[idx]))
-        idx++;
+      while (idx < string.length && prefix_chars.includes(string[idx])) idx++;
       return idx ? string.slice(idx) : string;
     }
     function _string_split(string, sep, maxsplit) {
@@ -378,18 +409,15 @@ var require_argparse = __commonJS({
       return result;
     }
     function _array_equal(array1, array2) {
-      if (array1.length !== array2.length)
-        return false;
+      if (array1.length !== array2.length) return false;
       for (let i = 0; i < array1.length; i++) {
-        if (array1[i] !== array2[i])
-          return false;
+        if (array1[i] !== array2[i]) return false;
       }
       return true;
     }
     function _array_remove(array, item) {
       let idx = array.indexOf(item);
-      if (idx === -1)
-        throw new TypeError(sub("%r not in list", item));
+      if (idx === -1) throw new TypeError(sub("%r not in list", item));
       array.splice(idx, 1);
     }
     function _choices_to_array(choices) {
@@ -407,6 +435,7 @@ var require_argparse = __commonJS({
     }
     function _callable(cls) {
       let result = {
+        // object is needed for inferred class name
         [cls.name]: function(...args) {
           let this_class = new.target === result || !new.target;
           return Reflect.construct(cls, args, this_class ? cls : new.target);
@@ -420,7 +449,13 @@ var require_argparse = __commonJS({
       try {
         let name = object.constructor.name;
         Object.defineProperty(object, from, {
-          value: util.deprecate(object[to], sub("%s.%s() is renamed to %s.%s()", name, from, name, to)),
+          value: util.deprecate(object[to], sub(
+            "%s.%s() is renamed to %s.%s()",
+            name,
+            from,
+            name,
+            to
+          )),
           enumerable: false
         });
       } catch {
@@ -429,24 +464,19 @@ var require_argparse = __commonJS({
     function _camelcase_alias(_class) {
       for (let name of Object.getOwnPropertyNames(_class.prototype)) {
         let camelcase = name.replace(/\w_[a-z]/g, (s) => s[0] + s[2].toUpperCase());
-        if (camelcase !== name)
-          _alias(_class.prototype, camelcase, name);
+        if (camelcase !== name) _alias(_class.prototype, camelcase, name);
       }
       return _class;
     }
     function _to_legacy_name(key) {
       key = key.replace(/\w_[a-z]/g, (s) => s[0] + s[2].toUpperCase());
-      if (key === "default")
-        key = "defaultValue";
-      if (key === "const")
-        key = "constant";
+      if (key === "default") key = "defaultValue";
+      if (key === "const") key = "constant";
       return key;
     }
     function _to_new_name(key) {
-      if (key === "defaultValue")
-        key = "default";
-      if (key === "constant")
-        key = "const";
+      if (key === "defaultValue") key = "default";
+      if (key === "constant") key = "const";
       key = key.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
       return key;
     }
@@ -454,10 +484,8 @@ var require_argparse = __commonJS({
     function _parse_opts(args, descriptor) {
       function get_name() {
         let stack = new Error().stack.split("\n").map((x) => x.match(/^    at (.*) \(.*\)$/)).filter(Boolean).map((m) => m[1]).map((fn) => fn.match(/[^ .]*$/)[0]);
-        if (stack.length && stack[0] === get_name.name)
-          stack.shift();
-        if (stack.length && stack[0] === _parse_opts.name)
-          stack.shift();
+        if (stack.length && stack[0] === get_name.name) stack.shift();
+        if (stack.length && stack[0] === _parse_opts.name) stack.shift();
         return stack.length ? stack[0] : "";
       }
       args = Array.from(args);
@@ -481,7 +509,11 @@ var require_argparse = __commonJS({
       }
       if (renames.length) {
         let name = get_name();
-        deprecate("camelcase_" + name, sub("%s(): following options are renamed: %s", name, renames.map(([a, b]) => sub("%r -> %r", a, b))));
+        deprecate("camelcase_" + name, sub(
+          "%s(): following options are renamed: %s",
+          name,
+          renames.map(([a, b]) => sub("%r -> %r", a, b))
+        ));
       }
       let missing_positionals = [];
       let positional_count = args.length;
@@ -502,7 +534,11 @@ var require_argparse = __commonJS({
             }
             if (renames2.length) {
               let name = get_name();
-              deprecate("camelcase_" + name, sub("%s(): following options are renamed: %s", name, renames2.map(([a, b]) => sub("%r -> %r", a, b))));
+              deprecate("camelcase_" + name, sub(
+                "%s(): following options are renamed: %s",
+                name,
+                renames2.map(([a, b]) => sub("%r -> %r", a, b))
+              ));
             }
             result.push(kwargs);
             kwargs = {};
@@ -524,19 +560,35 @@ var require_argparse = __commonJS({
         }
       }
       if (Object.keys(kwargs).length) {
-        throw new TypeError(sub("%s() got an unexpected keyword argument %r", get_name(), Object.keys(kwargs)[0]));
+        throw new TypeError(sub(
+          "%s() got an unexpected keyword argument %r",
+          get_name(),
+          Object.keys(kwargs)[0]
+        ));
       }
       if (args.length) {
         let from = Object.entries(descriptor).filter(([k, v]) => k[0] !== "*" && v !== no_default).length;
         let to = Object.entries(descriptor).filter(([k]) => k[0] !== "*").length;
-        throw new TypeError(sub("%s() takes %s positional argument%s but %s %s given", get_name(), from === to ? sub("from %s to %s", from, to) : to, from === to && to === 1 ? "" : "s", positional_count, positional_count === 1 ? "was" : "were"));
+        throw new TypeError(sub(
+          "%s() takes %s positional argument%s but %s %s given",
+          get_name(),
+          from === to ? sub("from %s to %s", from, to) : to,
+          from === to && to === 1 ? "" : "s",
+          positional_count,
+          positional_count === 1 ? "was" : "were"
+        ));
       }
       if (missing_positionals.length) {
         let strs = missing_positionals.map(repr);
-        if (strs.length > 1)
-          strs[strs.length - 1] = "and " + strs[strs.length - 1];
+        if (strs.length > 1) strs[strs.length - 1] = "and " + strs[strs.length - 1];
         let str_joined = strs.join(strs.length === 2 ? "" : ", ");
-        throw new TypeError(sub("%s() missing %i required positional argument%s: %s", get_name(), strs.length, strs.length === 1 ? "" : "s", str_joined));
+        throw new TypeError(sub(
+          "%s() missing %i required positional argument%s: %s",
+          get_name(),
+          strs.length,
+          strs.length === 1 ? "" : "s",
+          str_joined
+        ));
       }
       return result;
     }
@@ -585,6 +637,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,
@@ -603,7 +661,10 @@ var require_argparse = __commonJS({
         }
         this._prog = prog;
         this._indent_increment = indent_increment;
-        this._max_help_position = Math.min(max_help_position, Math.max(width - 20, indent_increment * 2));
+        this._max_help_position = Math.min(
+          max_help_position,
+          Math.max(width - 20, indent_increment * 2)
+        );
         this._width = width;
         this._current_indent = 0;
         this._level = 0;
@@ -613,6 +674,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;
@@ -625,6 +689,9 @@ var require_argparse = __commonJS({
       _add_item(func, args) {
         this._current_section.items.push([func, args]);
       }
+      // ========================
+      // Message building methods
+      // ========================
       start_section(heading) {
         this._indent();
         let section = this._Section(this, this._current_section, heading);
@@ -654,7 +721,10 @@ var require_argparse = __commonJS({
           }
           let invocation_length = Math.max(...invocations.map((invocation) => invocation.length));
           let action_length = invocation_length + this._current_indent;
-          this._action_max_length = Math.max(this._action_max_length, action_length);
+          this._action_max_length = Math.max(
+            this._action_max_length,
+            action_length
+          );
           this._add_item(this._format_action.bind(this), [action]);
         }
       }
@@ -663,6 +733,9 @@ var require_argparse = __commonJS({
           this.add_argument(action);
         }
       }
+      // =======================
+      // Help-formatting methods
+      // =======================
       format_help() {
         let help = this._root_section.format_help();
         if (help) {
@@ -853,7 +926,10 @@ var require_argparse = __commonJS({
         return this._fill_text(text, text_width, indent) + "\n\n";
       }
       _format_action(action) {
-        let help_position = Math.min(this._action_max_length + 2, this._max_help_position);
+        let help_position = Math.min(
+          this._action_max_length + 2,
+          this._max_help_position
+        );
         let help_width = Math.max(this._width - help_position, 11);
         let action_width = help_position - this._current_indent - 2;
         let action_header = this._format_action_invocation(action);
@@ -1041,16 +1117,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)")) {
@@ -1065,6 +1159,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;
       }
@@ -1086,6 +1187,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";
@@ -1107,12 +1214,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,
@@ -1280,6 +1440,7 @@ var require_argparse = __commonJS({
           default_value,
           required,
           help
+          //, metavar
         ] = _parse_opts(arguments, {
           option_strings: no_default,
           dest: no_default,
@@ -1642,6 +1803,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,
@@ -1657,11 +1834,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)");
@@ -1672,22 +1855,14 @@ var require_argparse = __commonJS({
         });
         this._flags = flags;
         this._options = {};
-        if (encoding !== void 0)
-          this._options.encoding = encoding;
-        if (mode !== void 0)
-          this._options.mode = mode;
-        if (autoClose !== void 0)
-          this._options.autoClose = autoClose;
-        if (emitClose !== void 0)
-          this._options.emitClose = emitClose;
-        if (start !== void 0)
-          this._options.start = start;
-        if (end !== void 0)
-          this._options.end = end;
-        if (highWaterMark !== void 0)
-          this._options.highWaterMark = highWaterMark;
-        if (fs3 !== void 0)
-          this._options.fs = fs3;
+        if (encoding !== void 0) this._options.encoding = encoding;
+        if (mode !== void 0) this._options.mode = mode;
+        if (autoClose !== void 0) this._options.autoClose = autoClose;
+        if (emitClose !== void 0) this._options.emitClose = emitClose;
+        if (start !== void 0) this._options.start = start;
+        if (end !== void 0) this._options.end = end;
+        if (highWaterMark !== void 0) this._options.highWaterMark = highWaterMark;
+        if (fs3 !== void 0) this._options.fs = fs3;
       }
       call(string) {
         if (string === "-") {
@@ -1721,10 +1896,9 @@ var require_argparse = __commonJS({
       [util.inspect.custom]() {
         let args = [this._flags];
         let kwargs = Object.entries(this._options).map(([k, v]) => {
-          if (k === "mode")
-            v = { value: v, [util.inspect.custom]() {
-              return "0o" + this.value.toString(8);
-            } };
+          if (k === "mode") v = { value: v, [util.inspect.custom]() {
+            return "0o" + this.value.toString(8);
+          } };
           return [k, v];
         });
         let args_str = [].concat(args.filter((arg) => arg !== -1).map(repr)).concat(kwargs.filter(([, arg]) => arg !== void 0).map(([kw, arg]) => sub("%s=%r", kw, arg))).join(", ");
@@ -1735,6 +1909,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);
@@ -1773,7 +1953,10 @@ var require_argparse = __commonJS({
         this.register("action", "extend", _ExtendAction);
         ["storeConst", "storeTrue", "storeFalse", "appendConst"].forEach((old_name) => {
           let new_name = _to_new_name(old_name);
-          this.register("action", old_name, util.deprecate(this._registry_get("action", new_name), sub('{action: "%s"} is renamed to {action: "%s"}', old_name, new_name)));
+          this.register("action", old_name, util.deprecate(
+            this._registry_get("action", new_name),
+            sub('{action: "%s"} is renamed to {action: "%s"}', old_name, new_name)
+          ));
         });
         this._get_handler();
         this._actions = [];
@@ -1784,6 +1967,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;
@@ -1791,6 +1977,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) {
@@ -1807,6 +1996,9 @@ var require_argparse = __commonJS({
         }
         return this._defaults[dest];
       }
+      // =======================
+      // Adding argument actions
+      // =======================
       add_argument() {
         let [
           args,
@@ -1817,9 +2009,12 @@ var require_argparse = __commonJS({
         });
         if (args.length === 1 && Array.isArray(args[0])) {
           args = args[0];
-          deprecate("argument-array", sub("use add_argument(%(args)s, {...}) instead of add_argument([ %(args)s ], { ... })", {
-            args: args.map(repr).join(", ")
-          }));
+          deprecate(
+            "argument-array",
+            sub("use add_argument(%(args)s, {...}) instead of add_argument([ %(args)s ], { ... })", {
+              args: args.map(repr).join(", ")
+            })
+          );
         }
         let chars = this.prefix_chars;
         if (!args.length || args.length === 1 && !chars.includes(args[0][0])) {
@@ -2018,7 +2213,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) {
@@ -2095,6 +2293,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,
@@ -2111,7 +2329,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,
@@ -2127,13 +2347,21 @@ 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("debug", 'The "debug" argument to ArgumentParser is deprecated. Please override ArgumentParser.exit function instead.');
+          deprecate(
+            "debug",
+            'The "debug" argument to ArgumentParser is deprecated. Please override ArgumentParser.exit function instead.'
+          );
         }
         if (version !== void 0) {
-          deprecate("version", `The "version" argument to ArgumentParser is deprecated. Please use add_argument(..., { action: 'version', version: 'N', ... }) instead.`);
+          deprecate(
+            "version",
+            `The "version" argument to ArgumentParser is deprecated. Please use add_argument(..., { action: 'version', version: 'N', ... }) instead.`
+          );
         }
         super({
           description,
@@ -2177,28 +2405,43 @@ var require_argparse = __commonJS({
           return result;
         });
         this.register("type", "str", String);
-        this.register("type", "string", util.deprecate(String, 'use {type:"str"} or {type:String} instead of {type:"string"}'));
+        this.register(
+          "type",
+          "string",
+          util.deprecate(String, 'use {type:"str"} or {type:String} instead of {type:"string"}')
+        );
         let default_prefix = prefix_chars.includes("-") ? "-" : prefix_chars[0];
         if (this.add_help) {
-          this.add_argument(default_prefix + "h", default_prefix.repeat(2) + "help", {
-            action: "help",
-            default: SUPPRESS,
-            help: "show this help message and exit"
-          });
+          this.add_argument(
+            default_prefix + "h",
+            default_prefix.repeat(2) + "help",
+            {
+              action: "help",
+              default: SUPPRESS,
+              help: "show this help message and exit"
+            }
+          );
         }
         if (version) {
-          this.add_argument(default_prefix + "v", default_prefix.repeat(2) + "version", {
-            action: "version",
-            default: SUPPRESS,
-            version: this.version,
-            help: "show program's version number and exit"
-          });
+          this.add_argument(
+            default_prefix + "v",
+            default_prefix.repeat(2) + "version",
+            {
+              action: "version",
+              default: SUPPRESS,
+              version: this.version,
+              help: "show program's version number and exit"
+            }
+          );
         }
         for (let parent of parents) {
           this._add_container_actions(parent);
           Object.assign(this._defaults, parent._defaults);
         }
       }
+      // =======================
+      // Pretty __repr__ methods
+      // =======================
       _get_kwargs() {
         let names = [
           "prog",
@@ -2210,6 +2453,9 @@ var require_argparse = __commonJS({
         ];
         return names.map((name) => [name, getattr(this, name)]);
       }
+      // ==================================
+      // Optional/Positional adding methods
+      // ==================================
       add_subparsers() {
         let [
           kwargs
@@ -2255,6 +2501,9 @@ var require_argparse = __commonJS({
       _get_positional_actions() {
         return this._actions.filter((action) => !action.option_strings.length);
       }
+      // =====================================
+      // Command line argument parsing methods
+      // =====================================
       parse_args(args = void 0, namespace = void 0) {
         let argv;
         [args, argv] = this.parse_known_args(args, namespace);
@@ -2429,7 +2678,9 @@ var require_argparse = __commonJS({
         let start_index = 0;
         let max_option_string_index = Math.max(-1, ...Object.keys(option_string_indices).map(Number));
         while (start_index <= max_option_string_index) {
-          let next_option_string_index = Math.min(...Object.keys(option_string_indices).map(Number).filter((index) => index >= start_index));
+          let next_option_string_index = Math.min(
+            ...Object.keys(option_string_indices).map(Number).filter((index) => index >= start_index)
+          );
           if (start_index !== next_option_string_index) {
             let positionals_end_index = consume_positionals(start_index);
             if (positionals_end_index > start_index) {
@@ -2455,13 +2706,20 @@ var require_argparse = __commonJS({
               required_actions.push(_get_action_name(action));
             } else {
               if (action.default !== void 0 && typeof action.default === "string" && hasattr(namespace, action.dest) && action.default === getattr(namespace, action.dest)) {
-                setattr(namespace, action.dest, this._get_value(action, action.default));
+                setattr(
+                  namespace,
+                  action.dest,
+                  this._get_value(action, action.default)
+                );
               }
             }
           }
         }
         if (required_actions.length) {
-          this.error(sub("the following arguments are required: %s", required_actions.join(", ")));
+          this.error(sub(
+            "the following arguments are required: %s",
+            required_actions.join(", ")
+          ));
         }
         for (let group of this._mutually_exclusive_groups) {
           if (group.required) {
@@ -2560,7 +2818,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 args = { option: arg_string, matches: options };
           let msg = "ambiguous option: %(option)s could match %(matches)s";
           this.error(sub(msg, args));
@@ -2645,6 +2907,9 @@ var require_argparse = __commonJS({
         }
         return nargs_pattern;
       }
+      // ========================
+      // Alt command line argument parsing, allowing free intermix
+      // ========================
       parse_intermixed_args(args = void 0, namespace = void 0) {
         let argv;
         [args, argv] = this.parse_known_intermixed_args(args, namespace);
@@ -2682,7 +2947,10 @@ var require_argparse = __commonJS({
               action.save_default = action.default;
               action.default = SUPPRESS;
             }
-            [namespace, remaining_args] = this.parse_known_args(args, namespace);
+            [namespace, remaining_args] = this.parse_known_args(
+              args,
+              namespace
+            );
             for (let action of positionals) {
               let attr = getattr(namespace, action.dest);
               if (Array.isArray(attr) && attr.length === 0) {
@@ -2706,7 +2974,10 @@ var require_argparse = __commonJS({
               group.save_required = group.required;
               group.required = false;
             }
-            [namespace, extras] = this.parse_known_args(remaining_args, namespace);
+            [namespace, extras] = this.parse_known_args(
+              remaining_args,
+              namespace
+            );
           } finally {
             for (let action of optionals) {
               action.required = action.save_required;
@@ -2720,6 +2991,9 @@ var require_argparse = __commonJS({
         }
         return [namespace, extras];
       }
+      // ========================
+      // Value conversion methods
+      // ========================
       _get_values(action, arg_strings) {
         if (![PARSER, REMAINDER].includes(action.nargs)) {
           try {
@@ -2806,14 +3080,25 @@ var require_argparse = __commonJS({
           throw new ArgumentError(action, sub(msg, args));
         }
       }
+      // =======================
+      // Help-formatting methods
+      // =======================
       format_usage() {
         let formatter = this._get_formatter();
-        formatter.add_usage(this.usage, this._actions, this._mutually_exclusive_groups);
+        formatter.add_usage(
+          this.usage,
+          this._actions,
+          this._mutually_exclusive_groups
+        );
         return formatter.format_help();
       }
       format_help() {
         let formatter = this._get_formatter();
-        formatter.add_usage(this.usage, this._actions, this._mutually_exclusive_groups);
+        formatter.add_usage(
+          this.usage,
+          this._actions,
+          this._mutually_exclusive_groups
+        );
         formatter.add_text(this.description);
         for (let action_group of this._action_groups) {
           formatter.start_section(action_group.title);
@@ -2827,23 +3112,26 @@ 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;
+        if (file === void 0) file = process.stdout;
         this._print_message(this.format_usage(), file);
       }
       print_help(file = void 0) {
-        if (file === void 0)
-          file = process.stdout;
+        if (file === void 0) file = process.stdout;
         this._print_message(this.format_help(), file);
       }
       _print_message(message, file = void 0) {
         if (message) {
-          if (file === void 0)
-            file = process.stderr;
+          if (file === void 0) file = process.stderr;
           file.write(message);
         }
       }
+      // ===============
+      // Exiting methods
+      // ===============
       exit(status = 0, message = void 0) {
         if (message) {
           this._print_message(message, process.stderr);
@@ -2851,8 +3139,7 @@ var require_argparse = __commonJS({
         process.exit(status);
       }
       error(message) {
-        if (this.debug === true)
-          throw new Error(message);
+        if (this.debug === true) throw new Error(message);
         this.print_usage(process.stderr);
         let args = { prog: this.prog, message };
         this.exit(2, sub("%(prog)s: error: %(message)s\n", args));
@@ -2905,19 +3192,20 @@ var require_argparse = __commonJS({
 });
 
 // src/index.ts
-var import_fs = require("fs");
-var import_path = __toESM(require("path"));
-var import_puppeteer = __toESM(require("puppeteer"));
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"));
 var import_argparse = __toESM(require_argparse());
+var import_puppeteer = require("puppeteer");
 function normalizeUrl(url) {
-  if (url.match(/:\/\//)) {
+  if (/:\/\//.exec(url)) {
     return url;
   } else {
     return `https://${url}`;
   }
 }
-(async () => {
-  const pkg = JSON.parse(await import_fs.promises.readFile(import_path.default.join(__dirname, "../package.json"), "utf-8"));
+async function run() {
+  const content = await import_node_fs.promises.readFile(import_node_path.default.join(__dirname, "../package.json"), "utf-8");
+  const pkg = JSON.parse(content);
   const parser = new import_argparse.ArgumentParser({
     description: pkg.description
   });
@@ -2927,10 +3215,14 @@ function normalizeUrl(url) {
   parser.add_argument("url", { help: "URL to fetch", metavar: "URL" });
   const args = parser.parse_args();
   const url = normalizeUrl(args.url);
-  const browser = await import_puppeteer.default.launch({ headless: false });
+  const browser = await (0, import_puppeteer.launch)({ headless: false });
   const page = await browser.newPage();
   await page.goto(url);
   const source = await page.content();
   await browser.close();
   console.log(source);
-})();
+}
+run().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@html-validate/puppeteer-fetch",
-  "version": "1.0.0",
+  "version": "2.1.0",
   "description": "Fetch HTML source from a webpage using Chrome as backend",
   "keywords": [
     "puppeteer",
@@ -14,21 +14,23 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://gitlab.com/html-validate/puppeteer-fetch.git"
+    "url": "git+https://gitlab.com/html-validate/puppeteer-fetch.git"
   },
-  "license": "ISC",
+  "license": "MIT",
   "author": "David Sveningsson <ext@sidvind.com>",
   "main": "dist/index.js",
-  "bin": "puppeteer-fetch.js",
+  "bin": {
+    "puppeteer-fetch": "puppeteer-fetch.js"
+  },
   "files": [
     "dist",
     "puppeteer-fetch.js"
   ],
   "dependencies": {
-    "puppeteer": "13.6.0"
+    "puppeteer": "24.27.0"
   },
   "engines": {
-    "node": ">= 12.22",
+    "node": ">= 20",
     "npm": ">= 7"
   },
   "publishConfig": {