headlamp 0.1.3 → 0.1.5

package/dist/cli.cjs

@@ -33,2253 +33,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/make-dir/node_modules/semver/internal/debug.js
-var require_debug = __commonJS({
-  "node_modules/make-dir/node_modules/semver/internal/debug.js"(exports2, module2) {
-    "use strict";
-    var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
-    };
-    module2.exports = debug;
-  }
-});
-
-// node_modules/make-dir/node_modules/semver/internal/constants.js
-var require_constants = __commonJS({
-  "node_modules/make-dir/node_modules/semver/internal/constants.js"(exports2, module2) {
-    "use strict";
-    var SEMVER_SPEC_VERSION = "2.0.0";
-    var MAX_LENGTH = 256;
-    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
-    9007199254740991;
-    var MAX_SAFE_COMPONENT_LENGTH = 16;
-    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
-    var RELEASE_TYPES = [
-      "major",
-      "premajor",
-      "minor",
-      "preminor",
-      "patch",
-      "prepatch",
-      "prerelease"
-    ];
-    module2.exports = {
-      MAX_LENGTH,
-      MAX_SAFE_COMPONENT_LENGTH,
-      MAX_SAFE_BUILD_LENGTH,
-      MAX_SAFE_INTEGER,
-      RELEASE_TYPES,
-      SEMVER_SPEC_VERSION,
-      FLAG_INCLUDE_PRERELEASE: 1,
-      FLAG_LOOSE: 2
-    };
-  }
-});
-
-// node_modules/make-dir/node_modules/semver/internal/re.js
-var require_re = __commonJS({
-  "node_modules/make-dir/node_modules/semver/internal/re.js"(exports2, module2) {
-    "use strict";
-    var {
-      MAX_SAFE_COMPONENT_LENGTH,
-      MAX_SAFE_BUILD_LENGTH,
-      MAX_LENGTH
-    } = require_constants();
-    var debug = require_debug();
-    exports2 = module2.exports = {};
-    var re = exports2.re = [];
-    var safeRe = exports2.safeRe = [];
-    var src = exports2.src = [];
-    var safeSrc = exports2.safeSrc = [];
-    var t = exports2.t = {};
-    var R = 0;
-    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
-    var safeRegexReplacements = [
-      ["\\s", 1],
-      ["\\d", MAX_LENGTH],
-      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
-    ];
-    var makeSafeRegex = (value) => {
-      for (const [token, max] of safeRegexReplacements) {
-        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
-      }
-      return value;
-    };
-    var createToken = (name, value, isGlobal) => {
-      const safe = makeSafeRegex(value);
-      const index = R++;
-      debug(name, index, value);
-      t[name] = index;
-      src[index] = value;
-      safeSrc[index] = safe;
-      re[index] = new RegExp(value, isGlobal ? "g" : void 0);
-      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
-    };
-    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
-    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
-    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
-    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
-    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
-    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
-    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
-    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
-    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
-    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
-    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
-    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
-    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
-    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
-    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
-    createToken("GTLT", "((?:<|>)?=?)");
-    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
-    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
-    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
-    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
-    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
-    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
-    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
-    createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
-    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
-    createToken("COERCERTL", src[t.COERCE], true);
-    createToken("COERCERTLFULL", src[t.COERCEFULL], true);
-    createToken("LONETILDE", "(?:~>?)");
-    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
-    exports2.tildeTrimReplace = "$1~";
-    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
-    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
-    createToken("LONECARET", "(?:\\^)");
-    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
-    exports2.caretTrimReplace = "$1^";
-    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
-    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
-    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
-    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
-    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
-    exports2.comparatorTrimReplace = "$1$2$3";
-    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
-    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
-    createToken("STAR", "(<|>)?=?\\s*\\*");
-    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
-    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
-  }
-});
-
-// node_modules/make-dir/node_modules/semver/internal/parse-options.js
-var require_parse_options = __commonJS({
-  "node_modules/make-dir/node_modules/semver/internal/parse-options.js"(exports2, module2) {
-    "use strict";
-    var looseOption = Object.freeze({ loose: true });
-    var emptyOpts = Object.freeze({});
-    var parseOptions = (options) => {
-      if (!options) {
-        return emptyOpts;
-      }
-      if (typeof options !== "object") {
-        return looseOption;
-      }
-      return options;
-    };
-    module2.exports = parseOptions;
-  }
-});
-
-// node_modules/make-dir/node_modules/semver/internal/identifiers.js
-var require_identifiers = __commonJS({
-  "node_modules/make-dir/node_modules/semver/internal/identifiers.js"(exports2, module2) {
-    "use strict";
-    var numeric = /^[0-9]+$/;
-    var compareIdentifiers = (a, b) => {
-      const anum = numeric.test(a);
-      const bnum = numeric.test(b);
-      if (anum && bnum) {
-        a = +a;
-        b = +b;
-      }
-      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
-    };
-    var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
-    module2.exports = {
-      compareIdentifiers,
-      rcompareIdentifiers
-    };
-  }
-});
-
-// node_modules/make-dir/node_modules/semver/classes/semver.js
-var require_semver = __commonJS({
-  "node_modules/make-dir/node_modules/semver/classes/semver.js"(exports2, module2) {
-    "use strict";
-    var debug = require_debug();
-    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
-    var { safeRe: re, t } = require_re();
-    var parseOptions = require_parse_options();
-    var { compareIdentifiers } = require_identifiers();
-    var SemVer = class _SemVer {
-      constructor(version, options) {
-        options = parseOptions(options);
-        if (version instanceof _SemVer) {
-          if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
-            return version;
-          } else {
-            version = version.version;
-          }
-        } else if (typeof version !== "string") {
-          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
-        }
-        if (version.length > MAX_LENGTH) {
-          throw new TypeError(
-            `version is longer than ${MAX_LENGTH} characters`
-          );
-        }
-        debug("SemVer", version, options);
-        this.options = options;
-        this.loose = !!options.loose;
-        this.includePrerelease = !!options.includePrerelease;
-        const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
-        if (!m) {
-          throw new TypeError(`Invalid Version: ${version}`);
-        }
-        this.raw = version;
-        this.major = +m[1];
-        this.minor = +m[2];
-        this.patch = +m[3];
-        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
-          throw new TypeError("Invalid major version");
-        }
-        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
-          throw new TypeError("Invalid minor version");
-        }
-        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
-          throw new TypeError("Invalid patch version");
-        }
-        if (!m[4]) {
-          this.prerelease = [];
-        } else {
-          this.prerelease = m[4].split(".").map((id) => {
-            if (/^[0-9]+$/.test(id)) {
-              const num = +id;
-              if (num >= 0 && num < MAX_SAFE_INTEGER) {
-                return num;
-              }
-            }
-            return id;
-          });
-        }
-        this.build = m[5] ? m[5].split(".") : [];
-        this.format();
-      }
-      format() {
-        this.version = `${this.major}.${this.minor}.${this.patch}`;
-        if (this.prerelease.length) {
-          this.version += `-${this.prerelease.join(".")}`;
-        }
-        return this.version;
-      }
-      toString() {
-        return this.version;
-      }
-      compare(other) {
-        debug("SemVer.compare", this.version, this.options, other);
-        if (!(other instanceof _SemVer)) {
-          if (typeof other === "string" && other === this.version) {
-            return 0;
-          }
-          other = new _SemVer(other, this.options);
-        }
-        if (other.version === this.version) {
-          return 0;
-        }
-        return this.compareMain(other) || this.comparePre(other);
-      }
-      compareMain(other) {
-        if (!(other instanceof _SemVer)) {
-          other = new _SemVer(other, this.options);
-        }
-        return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
-      }
-      comparePre(other) {
-        if (!(other instanceof _SemVer)) {
-          other = new _SemVer(other, this.options);
-        }
-        if (this.prerelease.length && !other.prerelease.length) {
-          return -1;
-        } else if (!this.prerelease.length && other.prerelease.length) {
-          return 1;
-        } else if (!this.prerelease.length && !other.prerelease.length) {
-          return 0;
-        }
-        let i = 0;
-        do {
-          const a = this.prerelease[i];
-          const b = other.prerelease[i];
-          debug("prerelease compare", i, a, b);
-          if (a === void 0 && b === void 0) {
-            return 0;
-          } else if (b === void 0) {
-            return 1;
-          } else if (a === void 0) {
-            return -1;
-          } else if (a === b) {
-            continue;
-          } else {
-            return compareIdentifiers(a, b);
-          }
-        } while (++i);
-      }
-      compareBuild(other) {
-        if (!(other instanceof _SemVer)) {
-          other = new _SemVer(other, this.options);
-        }
-        let i = 0;
-        do {
-          const a = this.build[i];
-          const b = other.build[i];
-          debug("build compare", i, a, b);
-          if (a === void 0 && b === void 0) {
-            return 0;
-          } else if (b === void 0) {
-            return 1;
-          } else if (a === void 0) {
-            return -1;
-          } else if (a === b) {
-            continue;
-          } else {
-            return compareIdentifiers(a, b);
-          }
-        } while (++i);
-      }
-      // preminor will bump the version up to the next minor release, and immediately
-      // down to pre-release. premajor and prepatch work the same way.
-      inc(release, identifier, identifierBase) {
-        if (release.startsWith("pre")) {
-          if (!identifier && identifierBase === false) {
-            throw new Error("invalid increment argument: identifier is empty");
-          }
-          if (identifier) {
-            const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
-            if (!match || match[1] !== identifier) {
-              throw new Error(`invalid identifier: ${identifier}`);
-            }
-          }
-        }
-        switch (release) {
-          case "premajor":
-            this.prerelease.length = 0;
-            this.patch = 0;
-            this.minor = 0;
-            this.major++;
-            this.inc("pre", identifier, identifierBase);
-            break;
-          case "preminor":
-            this.prerelease.length = 0;
-            this.patch = 0;
-            this.minor++;
-            this.inc("pre", identifier, identifierBase);
-            break;
-          case "prepatch":
-            this.prerelease.length = 0;
-            this.inc("patch", identifier, identifierBase);
-            this.inc("pre", identifier, identifierBase);
-            break;
-          case "prerelease":
-            if (this.prerelease.length === 0) {
-              this.inc("patch", identifier, identifierBase);
-            }
-            this.inc("pre", identifier, identifierBase);
-            break;
-          case "release":
-            if (this.prerelease.length === 0) {
-              throw new Error(`version ${this.raw} is not a prerelease`);
-            }
-            this.prerelease.length = 0;
-            break;
-          case "major":
-            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
-              this.major++;
-            }
-            this.minor = 0;
-            this.patch = 0;
-            this.prerelease = [];
-            break;
-          case "minor":
-            if (this.patch !== 0 || this.prerelease.length === 0) {
-              this.minor++;
-            }
-            this.patch = 0;
-            this.prerelease = [];
-            break;
-          case "patch":
-            if (this.prerelease.length === 0) {
-              this.patch++;
-            }
-            this.prerelease = [];
-            break;
-          case "pre": {
-            const base = Number(identifierBase) ? 1 : 0;
-            if (this.prerelease.length === 0) {
-              this.prerelease = [base];
-            } else {
-              let i = this.prerelease.length;
-              while (--i >= 0) {
-                if (typeof this.prerelease[i] === "number") {
-                  this.prerelease[i]++;
-                  i = -2;
-                }
-              }
-              if (i === -1) {
-                if (identifier === this.prerelease.join(".") && identifierBase === false) {
-                  throw new Error("invalid increment argument: identifier already exists");
-                }
-                this.prerelease.push(base);
-              }
-            }
-            if (identifier) {
-              let prerelease = [identifier, base];
-              if (identifierBase === false) {
-                prerelease = [identifier];
-              }
-              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
-                if (isNaN(this.prerelease[1])) {
-                  this.prerelease = prerelease;
-                }
-              } else {
-                this.prerelease = prerelease;
-              }
-            }
-            break;
-          }
-          default:
-            throw new Error(`invalid increment argument: ${release}`);
-        }
-        this.raw = this.format();
-        if (this.build.length) {
-          this.raw += `+${this.build.join(".")}`;
-        }
-        return this;
-      }
-    };
-    module2.exports = SemVer;
-  }
-});
-
-// node_modules/make-dir/node_modules/semver/functions/compare.js
-var require_compare = __commonJS({
-  "node_modules/make-dir/node_modules/semver/functions/compare.js"(exports2, module2) {
-    "use strict";
-    var SemVer = require_semver();
-    var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
-    module2.exports = compare;
-  }
-});
-
-// node_modules/make-dir/node_modules/semver/functions/gte.js
-var require_gte = __commonJS({
-  "node_modules/make-dir/node_modules/semver/functions/gte.js"(exports2, module2) {
-    "use strict";
-    var compare = require_compare();
-    var gte = (a, b, loose) => compare(a, b, loose) >= 0;
-    module2.exports = gte;
-  }
-});
-
-// node_modules/make-dir/index.js
-var require_make_dir = __commonJS({
-  "node_modules/make-dir/index.js"(exports2, module2) {
-    "use strict";
-    var fs6 = require("fs");
-    var path10 = require("path");
-    var { promisify } = require("util");
-    var semverGte = require_gte();
-    var useNativeRecursiveOption = semverGte(process.version, "10.12.0");
-    var checkPath = (pth) => {
-      if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path10.parse(pth).root, ""));
-        if (pathHasInvalidWinCharacters) {
-          const error = new Error(`Path contains invalid characters: ${pth}`);
-          error.code = "EINVAL";
-          throw error;
-        }
-      }
-    };
-    var processOptions = (options) => {
-      const defaults = {
-        mode: 511,
-        fs: fs6
-      };
-      return {
-        ...defaults,
-        ...options
-      };
-    };
-    var permissionError = (pth) => {
-      const error = new Error(`operation not permitted, mkdir '${pth}'`);
-      error.code = "EPERM";
-      error.errno = -4048;
-      error.path = pth;
-      error.syscall = "mkdir";
-      return error;
-    };
-    var makeDir = async (input, options) => {
-      checkPath(input);
-      options = processOptions(options);
-      const mkdir2 = promisify(options.fs.mkdir);
-      const stat2 = promisify(options.fs.stat);
-      if (useNativeRecursiveOption && options.fs.mkdir === fs6.mkdir) {
-        const pth = path10.resolve(input);
-        await mkdir2(pth, {
-          mode: options.mode,
-          recursive: true
-        });
-        return pth;
-      }
-      const make = async (pth) => {
-        try {
-          await mkdir2(pth, options.mode);
-          return pth;
-        } catch (error) {
-          if (error.code === "EPERM") {
-            throw error;
-          }
-          if (error.code === "ENOENT") {
-            if (path10.dirname(pth) === pth) {
-              throw permissionError(pth);
-            }
-            if (error.message.includes("null bytes")) {
-              throw error;
-            }
-            await make(path10.dirname(pth));
-            return make(pth);
-          }
-          try {
-            const stats = await stat2(pth);
-            if (!stats.isDirectory()) {
-              throw new Error("The path is not a directory");
-            }
-          } catch {
-            throw error;
-          }
-          return pth;
-        }
-      };
-      return make(path10.resolve(input));
-    };
-    module2.exports = makeDir;
-    module2.exports.sync = (input, options) => {
-      checkPath(input);
-      options = processOptions(options);
-      if (useNativeRecursiveOption && options.fs.mkdirSync === fs6.mkdirSync) {
-        const pth = path10.resolve(input);
-        fs6.mkdirSync(pth, {
-          mode: options.mode,
-          recursive: true
-        });
-        return pth;
-      }
-      const make = (pth) => {
-        try {
-          options.fs.mkdirSync(pth, options.mode);
-        } catch (error) {
-          if (error.code === "EPERM") {
-            throw error;
-          }
-          if (error.code === "ENOENT") {
-            if (path10.dirname(pth) === pth) {
-              throw permissionError(pth);
-            }
-            if (error.message.includes("null bytes")) {
-              throw error;
-            }
-            make(path10.dirname(pth));
-            return make(pth);
-          }
-          try {
-            if (!options.fs.statSync(pth).isDirectory()) {
-              throw new Error("The path is not a directory");
-            }
-          } catch {
-            throw error;
-          }
-        }
-        return pth;
-      };
-      return make(path10.resolve(input));
-    };
-  }
-});
-
-// node_modules/has-flag/index.js
-var require_has_flag = __commonJS({
-  "node_modules/has-flag/index.js"(exports2, module2) {
-    "use strict";
-    module2.exports = (flag, argv = process.argv) => {
-      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-      const position = argv.indexOf(prefix + flag);
-      const terminatorPosition = argv.indexOf("--");
-      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-    };
-  }
-});
-
-// node_modules/supports-color/index.js
-var require_supports_color = __commonJS({
-  "node_modules/supports-color/index.js"(exports2, module2) {
-    "use strict";
-    var os3 = require("os");
-    var tty = require("tty");
-    var hasFlag = require_has_flag();
-    var { env: env2 } = process;
-    var forceColor;
-    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-      forceColor = 0;
-    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-      forceColor = 1;
-    }
-    if ("FORCE_COLOR" in env2) {
-      if (env2.FORCE_COLOR === "true") {
-        forceColor = 1;
-      } else if (env2.FORCE_COLOR === "false") {
-        forceColor = 0;
-      } else {
-        forceColor = env2.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env2.FORCE_COLOR, 10), 3);
-      }
-    }
-    function translateLevel(level) {
-      if (level === 0) {
-        return false;
-      }
-      return {
-        level,
-        hasBasic: true,
-        has256: level >= 2,
-        has16m: level >= 3
-      };
-    }
-    function supportsColor(haveStream, streamIsTTY) {
-      if (forceColor === 0) {
-        return 0;
-      }
-      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-        return 3;
-      }
-      if (hasFlag("color=256")) {
-        return 2;
-      }
-      if (haveStream && !streamIsTTY && forceColor === void 0) {
-        return 0;
-      }
-      const min = forceColor || 0;
-      if (env2.TERM === "dumb") {
-        return min;
-      }
-      if (process.platform === "win32") {
-        const osRelease = os3.release().split(".");
-        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-          return Number(osRelease[2]) >= 14931 ? 3 : 2;
-        }
-        return 1;
-      }
-      if ("CI" in env2) {
-        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env2) || env2.CI_NAME === "codeship") {
-          return 1;
-        }
-        return min;
-      }
-      if ("TEAMCITY_VERSION" in env2) {
-        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env2.TEAMCITY_VERSION) ? 1 : 0;
-      }
-      if (env2.COLORTERM === "truecolor") {
-        return 3;
-      }
-      if ("TERM_PROGRAM" in env2) {
-        const version = parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-        switch (env2.TERM_PROGRAM) {
-          case "iTerm.app":
-            return version >= 3 ? 3 : 2;
-          case "Apple_Terminal":
-            return 2;
-        }
-      }
-      if (/-256(color)?$/i.test(env2.TERM)) {
-        return 2;
-      }
-      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) {
-        return 1;
-      }
-      if ("COLORTERM" in env2) {
-        return 1;
-      }
-      return min;
-    }
-    function getSupportLevel(stream) {
-      const level = supportsColor(stream, stream && stream.isTTY);
-      return translateLevel(level);
-    }
-    module2.exports = {
-      supportsColor: getSupportLevel,
-      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
-      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
-    };
-  }
-});
-
-// node_modules/istanbul-lib-report/lib/file-writer.js
-var require_file_writer = __commonJS({
-  "node_modules/istanbul-lib-report/lib/file-writer.js"(exports2, module2) {
-    "use strict";
-    var path10 = require("path");
-    var fs6 = require("fs");
-    var mkdirp = require_make_dir();
-    var supportsColor = require_supports_color();
-    var ContentWriter = class {
-      /**
-       * returns the colorized version of a string. Typically,
-       * content writers that write to files will return the
-       * same string and ones writing to a tty will wrap it in
-       * appropriate escape sequences.
-       * @param {String} str the string to colorize
-       * @param {String} clazz one of `high`, `medium` or `low`
-       * @returns {String} the colorized form of the string
-       */
-      colorize(str) {
-        return str;
-      }
-      /**
-       * writes a string appended with a newline to the destination
-       * @param {String} str the string to write
-       */
-      println(str) {
-        this.write(`${str}
-`);
-      }
-      /**
-       * closes this content writer. Should be called after all writes are complete.
-       */
-      close() {
-      }
-    };
-    var FileContentWriter = class extends ContentWriter {
-      constructor(fd) {
-        super();
-        this.fd = fd;
-      }
-      write(str) {
-        fs6.writeSync(this.fd, str);
-      }
-      close() {
-        fs6.closeSync(this.fd);
-      }
-    };
-    var capture = false;
-    var output = "";
-    var ConsoleWriter = class extends ContentWriter {
-      write(str) {
-        if (capture) {
-          output += str;
-        } else {
-          process.stdout.write(str);
-        }
-      }
-      colorize(str, clazz) {
-        const colors = {
-          low: "31;1",
-          medium: "33;1",
-          high: "32;1"
-        };
-        if (supportsColor.stdout && colors[clazz]) {
-          return `\x1B[${colors[clazz]}m${str}\x1B[0m`;
-        }
-        return str;
-      }
-    };
-    var FileWriter = class _FileWriter {
-      constructor(baseDir) {
-        if (!baseDir) {
-          throw new Error("baseDir must be specified");
-        }
-        this.baseDir = baseDir;
-      }
-      /**
-       * static helpers for capturing stdout report output;
-       * super useful for tests!
-       */
-      static startCapture() {
-        capture = true;
-      }
-      static stopCapture() {
-        capture = false;
-      }
-      static getOutput() {
-        return output;
-      }
-      static resetOutput() {
-        output = "";
-      }
-      /**
-       * returns a FileWriter that is rooted at the supplied subdirectory
-       * @param {String} subdir the subdirectory under which to root the
-       *  returned FileWriter
-       * @returns {FileWriter}
-       */
-      writerForDir(subdir) {
-        if (path10.isAbsolute(subdir)) {
-          throw new Error(
-            `Cannot create subdir writer for absolute path: ${subdir}`
-          );
-        }
-        return new _FileWriter(`${this.baseDir}/${subdir}`);
-      }
-      /**
-       * copies a file from a source directory to a destination name
-       * @param {String} source path to source file
-       * @param {String} dest relative path to destination file
-       * @param {String} [header=undefined] optional text to prepend to destination
-       *  (e.g., an "this file is autogenerated" comment, copyright notice, etc.)
-       */
-      copyFile(source, dest, header) {
-        if (path10.isAbsolute(dest)) {
-          throw new Error(`Cannot write to absolute path: ${dest}`);
-        }
-        dest = path10.resolve(this.baseDir, dest);
-        mkdirp.sync(path10.dirname(dest));
-        let contents;
-        if (header) {
-          contents = header + fs6.readFileSync(source, "utf8");
-        } else {
-          contents = fs6.readFileSync(source);
-        }
-        fs6.writeFileSync(dest, contents);
-      }
-      /**
-       * returns a content writer for writing content to the supplied file.
-       * @param {String|null} file the relative path to the file or the special
-       *  values `"-"` or `null` for writing to the console
-       * @returns {ContentWriter}
-       */
-      writeFile(file) {
-        if (file === null || file === "-") {
-          return new ConsoleWriter();
-        }
-        if (path10.isAbsolute(file)) {
-          throw new Error(`Cannot write to absolute path: ${file}`);
-        }
-        file = path10.resolve(this.baseDir, file);
-        mkdirp.sync(path10.dirname(file));
-        return new FileContentWriter(fs6.openSync(file, "w"));
-      }
-    };
-    module2.exports = FileWriter;
-  }
-});
-
-// node_modules/istanbul-lib-report/lib/xml-writer.js
-var require_xml_writer = __commonJS({
-  "node_modules/istanbul-lib-report/lib/xml-writer.js"(exports2, module2) {
-    "use strict";
-    var INDENT = "  ";
-    function attrString(attrs) {
-      return Object.entries(attrs || {}).map(([k, v]) => ` ${k}="${v}"`).join("");
-    }
-    var XMLWriter = class {
-      constructor(contentWriter) {
-        this.cw = contentWriter;
-        this.stack = [];
-      }
-      indent(str) {
-        return this.stack.map(() => INDENT).join("") + str;
-      }
-      /**
-       * writes the opening XML tag with the supplied attributes
-       * @param {String} name tag name
-       * @param {Object} [attrs=null] attrs attributes for the tag
-       */
-      openTag(name, attrs) {
-        const str = this.indent(`<${name + attrString(attrs)}>`);
-        this.cw.println(str);
-        this.stack.push(name);
-      }
-      /**
-       * closes an open XML tag.
-       * @param {String} name - tag name to close. This must match the writer's
-       *  notion of the tag that is currently open.
-       */
-      closeTag(name) {
-        if (this.stack.length === 0) {
-          throw new Error(`Attempt to close tag ${name} when not opened`);
-        }
-        const stashed = this.stack.pop();
-        const str = `</${name}>`;
-        if (stashed !== name) {
-          throw new Error(
-            `Attempt to close tag ${name} when ${stashed} was the one open`
-          );
-        }
-        this.cw.println(this.indent(str));
-      }
-      /**
-       * writes a tag and its value opening and closing it at the same time
-       * @param {String} name tag name
-       * @param {Object} [attrs=null] attrs tag attributes
-       * @param {String} [content=null] content optional tag content
-       */
-      inlineTag(name, attrs, content) {
-        let str = "<" + name + attrString(attrs);
-        if (content) {
-          str += `>${content}</${name}>`;
-        } else {
-          str += "/>";
-        }
-        str = this.indent(str);
-        this.cw.println(str);
-      }
-      /**
-       * closes all open tags and ends the document
-       */
-      closeAll() {
-        this.stack.slice().reverse().forEach((name) => {
-          this.closeTag(name);
-        });
-      }
-    };
-    module2.exports = XMLWriter;
-  }
-});
-
-// node_modules/istanbul-lib-report/lib/tree.js
-var require_tree = __commonJS({
-  "node_modules/istanbul-lib-report/lib/tree.js"(exports2, module2) {
-    "use strict";
-    var Visitor = class {
-      constructor(delegate) {
-        this.delegate = delegate;
-      }
-    };
-    ["Start", "End", "Summary", "SummaryEnd", "Detail"].map((k) => `on${k}`).forEach((fn) => {
-      Object.defineProperty(Visitor.prototype, fn, {
-        writable: true,
-        value(node, state) {
-          if (typeof this.delegate[fn] === "function") {
-            this.delegate[fn](node, state);
-          }
-        }
-      });
-    });
-    var CompositeVisitor = class extends Visitor {
-      constructor(visitors) {
-        super();
-        if (!Array.isArray(visitors)) {
-          visitors = [visitors];
-        }
-        this.visitors = visitors.map((v) => {
-          if (v instanceof Visitor) {
-            return v;
-          }
-          return new Visitor(v);
-        });
-      }
-    };
-    ["Start", "Summary", "SummaryEnd", "Detail", "End"].map((k) => `on${k}`).forEach((fn) => {
-      Object.defineProperty(CompositeVisitor.prototype, fn, {
-        value(node, state) {
-          this.visitors.forEach((v) => {
-            v[fn](node, state);
-          });
-        }
-      });
-    });
-    var BaseNode = class {
-      isRoot() {
-        return !this.getParent();
-      }
-      /**
-       * visit all nodes depth-first from this node down. Note that `onStart`
-       * and `onEnd` are never called on the visitor even if the current
-       * node is the root of the tree.
-       * @param visitor a full visitor that is called during tree traversal
-       * @param state optional state that is passed around
-       */
-      visit(visitor, state) {
-        if (this.isSummary()) {
-          visitor.onSummary(this, state);
-        } else {
-          visitor.onDetail(this, state);
-        }
-        this.getChildren().forEach((child) => {
-          child.visit(visitor, state);
-        });
-        if (this.isSummary()) {
-          visitor.onSummaryEnd(this, state);
-        }
-      }
-    };
-    var BaseTree = class {
-      constructor(root) {
-        this.root = root;
-      }
-      /**
-       * returns the root node of the tree
-       */
-      getRoot() {
-        return this.root;
-      }
-      /**
-       * visits the tree depth-first with the supplied partial visitor
-       * @param visitor - a potentially partial visitor
-       * @param state - the state to be passed around during tree traversal
-       */
-      visit(visitor, state) {
-        if (!(visitor instanceof Visitor)) {
-          visitor = new Visitor(visitor);
-        }
-        visitor.onStart(this.getRoot(), state);
-        this.getRoot().visit(visitor, state);
-        visitor.onEnd(this.getRoot(), state);
-      }
-    };
-    module2.exports = {
-      BaseTree,
-      BaseNode,
-      Visitor,
-      CompositeVisitor
-    };
-  }
-});
-
-// node_modules/istanbul-lib-report/lib/watermarks.js
-var require_watermarks = __commonJS({
-  "node_modules/istanbul-lib-report/lib/watermarks.js"(exports2, module2) {
-    "use strict";
-    module2.exports = {
-      getDefault() {
-        return {
-          statements: [50, 80],
-          functions: [50, 80],
-          branches: [50, 80],
-          lines: [50, 80]
-        };
-      }
-    };
-  }
-});
-
-// node_modules/istanbul-lib-coverage/lib/percent.js
-var require_percent = __commonJS({
-  "node_modules/istanbul-lib-coverage/lib/percent.js"(exports2, module2) {
-    "use strict";
-    module2.exports = function percent(covered, total) {
-      let tmp;
-      if (total > 0) {
-        tmp = 1e3 * 100 * covered / total;
-        return Math.floor(tmp / 10) / 100;
-      } else {
-        return 100;
-      }
-    };
-  }
-});
-
-// node_modules/istanbul-lib-coverage/lib/data-properties.js
-var require_data_properties = __commonJS({
-  "node_modules/istanbul-lib-coverage/lib/data-properties.js"(exports2, module2) {
-    "use strict";
-    module2.exports = function dataProperties(klass, properties) {
-      properties.forEach((p) => {
-        Object.defineProperty(klass.prototype, p, {
-          enumerable: true,
-          get() {
-            return this.data[p];
-          }
-        });
-      });
-    };
-  }
-});
-
-// node_modules/istanbul-lib-coverage/lib/coverage-summary.js
-var require_coverage_summary = __commonJS({
-  "node_modules/istanbul-lib-coverage/lib/coverage-summary.js"(exports2, module2) {
-    "use strict";
-    var percent = require_percent();
-    var dataProperties = require_data_properties();
-    function blankSummary() {
-      const empty = () => ({
-        total: 0,
-        covered: 0,
-        skipped: 0,
-        pct: "Unknown"
-      });
-      return {
-        lines: empty(),
-        statements: empty(),
-        functions: empty(),
-        branches: empty(),
-        branchesTrue: empty()
-      };
-    }
-    function assertValidSummary(obj) {
-      const valid = obj && obj.lines && obj.statements && obj.functions && obj.branches;
-      if (!valid) {
-        throw new Error(
-          "Invalid summary coverage object, missing keys, found:" + Object.keys(obj).join(",")
-        );
-      }
-    }
-    var CoverageSummary = class _CoverageSummary {
-      /**
-       * @constructor
-       * @param {Object|CoverageSummary} [obj=undefined] an optional data object or
-       * another coverage summary to initialize this object with.
-       */
-      constructor(obj) {
-        if (!obj) {
-          this.data = blankSummary();
-        } else if (obj instanceof _CoverageSummary) {
-          this.data = obj.data;
-        } else {
-          this.data = obj;
-        }
-        assertValidSummary(this.data);
-      }
-      /**
-       * merges a second summary coverage object into this one
-       * @param {CoverageSummary} obj - another coverage summary object
-       */
-      merge(obj) {
-        const keys = [
-          "lines",
-          "statements",
-          "branches",
-          "functions",
-          "branchesTrue"
-        ];
-        keys.forEach((key) => {
-          if (obj[key]) {
-            this[key].total += obj[key].total;
-            this[key].covered += obj[key].covered;
-            this[key].skipped += obj[key].skipped;
-            this[key].pct = percent(this[key].covered, this[key].total);
-          }
-        });
-        return this;
-      }
-      /**
-       * returns a POJO that is JSON serializable. May be used to get the raw
-       * summary object.
-       */
-      toJSON() {
-        return this.data;
-      }
-      /**
-       * return true if summary has no lines of code
-       */
-      isEmpty() {
-        return this.lines.total === 0;
-      }
-    };
-    dataProperties(CoverageSummary, [
-      "lines",
-      "statements",
-      "functions",
-      "branches",
-      "branchesTrue"
-    ]);
-    module2.exports = {
-      CoverageSummary
-    };
-  }
-});
-
-// node_modules/istanbul-lib-coverage/lib/file-coverage.js
-var require_file_coverage = __commonJS({
-  "node_modules/istanbul-lib-coverage/lib/file-coverage.js"(exports2, module2) {
-    "use strict";
-    var percent = require_percent();
-    var dataProperties = require_data_properties();
-    var { CoverageSummary } = require_coverage_summary();
-    function emptyCoverage(filePath, reportLogic) {
-      const cov = {
-        path: filePath,
-        statementMap: {},
-        fnMap: {},
-        branchMap: {},
-        s: {},
-        f: {},
-        b: {}
-      };
-      if (reportLogic) cov.bT = {};
-      return cov;
-    }
-    function assertValidObject(obj) {
-      const valid = obj && obj.path && obj.statementMap && obj.fnMap && obj.branchMap && obj.s && obj.f && obj.b;
-      if (!valid) {
-        throw new Error(
-          "Invalid file coverage object, missing keys, found:" + Object.keys(obj).join(",")
-        );
-      }
-    }
-    var keyFromLoc = ({ start, end }) => `${start.line}|${start.column}|${end.line}|${end.column}`;
-    var isObj = (o) => !!o && typeof o === "object";
-    var isLineCol = (o) => isObj(o) && typeof o.line === "number" && typeof o.column === "number";
-    var isLoc = (o) => isObj(o) && isLineCol(o.start) && isLineCol(o.end);
-    var getLoc = (o) => isLoc(o) ? o : isLoc(o.loc) ? o.loc : null;
-    var findNearestContainer = (item, map) => {
-      const itemLoc = getLoc(item);
-      if (!itemLoc) return null;
-      let nearestContainingItem = null;
-      let containerDistance = null;
-      let containerKey = null;
-      for (const [i, mapItem] of Object.entries(map)) {
-        const mapLoc = getLoc(mapItem);
-        if (!mapLoc) continue;
-        const distance = [
-          itemLoc.start.line - mapLoc.start.line,
-          itemLoc.start.column - mapLoc.start.column,
-          mapLoc.end.line - itemLoc.end.line,
-          mapLoc.end.column - itemLoc.end.column
-        ];
-        if (distance[0] < 0 || distance[2] < 0 || distance[0] === 0 && distance[1] < 0 || distance[2] === 0 && distance[3] < 0) {
-          continue;
-        }
-        if (nearestContainingItem === null) {
-          containerDistance = distance;
-          nearestContainingItem = mapItem;
-          containerKey = i;
-          continue;
-        }
-        const closerBefore = distance[0] < containerDistance[0] || distance[0] === 0 && distance[1] < containerDistance[1];
-        const closerAfter = distance[2] < containerDistance[2] || distance[2] === 0 && distance[3] < containerDistance[3];
-        if (closerBefore || closerAfter) {
-          containerDistance = distance;
-          nearestContainingItem = mapItem;
-          containerKey = i;
-        }
-      }
-      return containerKey;
-    };
-    var addHits = (aHits, bHits) => {
-      if (typeof aHits === "number" && typeof bHits === "number") {
-        return aHits + bHits;
-      } else if (Array.isArray(aHits) && Array.isArray(bHits)) {
-        return aHits.map((a, i) => (a || 0) + (bHits[i] || 0));
-      }
-      return null;
-    };
-    var addNearestContainerHits = (item, itemHits, map, mapHits) => {
-      const container = findNearestContainer(item, map);
-      if (container) {
-        return addHits(itemHits, mapHits[container]);
-      } else {
-        return itemHits;
-      }
-    };
-    var mergeProp = (aHits, aMap, bHits, bMap, itemKey = keyFromLoc) => {
-      const aItems = {};
-      for (const [key, itemHits] of Object.entries(aHits)) {
-        const item = aMap[key];
-        aItems[itemKey(item)] = [itemHits, item];
-      }
-      const bItems = {};
-      for (const [key, itemHits] of Object.entries(bHits)) {
-        const item = bMap[key];
-        bItems[itemKey(item)] = [itemHits, item];
-      }
-      const mergedItems = {};
-      for (const [key, aValue] of Object.entries(aItems)) {
-        let aItemHits = aValue[0];
-        const aItem = aValue[1];
-        const bValue = bItems[key];
-        if (!bValue) {
-          aItemHits = addNearestContainerHits(aItem, aItemHits, bMap, bHits);
-        } else {
-          aItemHits = addHits(aItemHits, bValue[0]);
-        }
-        mergedItems[key] = [aItemHits, aItem];
-      }
-      for (const [key, bValue] of Object.entries(bItems)) {
-        let bItemHits = bValue[0];
-        const bItem = bValue[1];
-        if (mergedItems[key]) continue;
-        bItemHits = addNearestContainerHits(bItem, bItemHits, aMap, aHits);
-        mergedItems[key] = [bItemHits, bItem];
-      }
-      const hits = {};
-      const map = {};
-      Object.values(mergedItems).forEach(([itemHits, item], i) => {
-        hits[i] = itemHits;
-        map[i] = item;
-      });
-      return [hits, map];
-    };
-    var FileCoverage = class _FileCoverage {
-      /**
-       * @constructor
-       * @param {Object|FileCoverage|String} pathOrObj is a string that initializes
-       * and empty coverage object with the specified file path or a data object that
-       * has all the required properties for a file coverage object.
-       */
-      constructor(pathOrObj, reportLogic = false) {
-        if (!pathOrObj) {
-          throw new Error(
-            "Coverage must be initialized with a path or an object"
-          );
-        }
-        if (typeof pathOrObj === "string") {
-          this.data = emptyCoverage(pathOrObj, reportLogic);
-        } else if (pathOrObj instanceof _FileCoverage) {
-          this.data = pathOrObj.data;
-        } else if (typeof pathOrObj === "object") {
-          this.data = pathOrObj;
-        } else {
-          throw new Error("Invalid argument to coverage constructor");
-        }
-        assertValidObject(this.data);
-      }
-      /**
-       * returns computed line coverage from statement coverage.
-       * This is a map of hits keyed by line number in the source.
-       */
-      getLineCoverage() {
-        const statementMap = this.data.statementMap;
-        const statements = this.data.s;
-        const lineMap = /* @__PURE__ */ Object.create(null);
-        Object.entries(statements).forEach(([st, count]) => {
-          if (!statementMap[st]) {
-            return;
-          }
-          const { line } = statementMap[st].start;
-          const prevVal = lineMap[line];
-          if (prevVal === void 0 || prevVal < count) {
-            lineMap[line] = count;
-          }
-        });
-        return lineMap;
-      }
-      /**
-       * returns an array of uncovered line numbers.
-       * @returns {Array} an array of line numbers for which no hits have been
-       *  collected.
-       */
-      getUncoveredLines() {
-        const lc = this.getLineCoverage();
-        const ret = [];
-        Object.entries(lc).forEach(([l, hits]) => {
-          if (hits === 0) {
-            ret.push(l);
-          }
-        });
-        return ret;
-      }
-      /**
-       * returns a map of branch coverage by source line number.
-       * @returns {Object} an object keyed by line number. Each object
-       * has a `covered`, `total` and `coverage` (percentage) property.
-       */
-      getBranchCoverageByLine() {
-        const branchMap = this.branchMap;
-        const branches = this.b;
-        const ret = {};
-        Object.entries(branchMap).forEach(([k, map]) => {
-          const line = map.line || map.loc.start.line;
-          const branchData = branches[k];
-          ret[line] = ret[line] || [];
-          ret[line].push(...branchData);
-        });
-        Object.entries(ret).forEach(([k, dataArray]) => {
-          const covered = dataArray.filter((item) => item > 0);
-          const coverage = covered.length / dataArray.length * 100;
-          ret[k] = {
-            covered: covered.length,
-            total: dataArray.length,
-            coverage
-          };
-        });
-        return ret;
-      }
-      /**
-       * return a JSON-serializable POJO for this file coverage object
-       */
-      toJSON() {
-        return this.data;
-      }
-      /**
-       * merges a second coverage object into this one, updating hit counts
-       * @param {FileCoverage} other - the coverage object to be merged into this one.
-       *  Note that the other object should have the same structure as this one (same file).
-       */
-      merge(other) {
-        if (other.all === true) {
-          return;
-        }
-        if (this.all === true) {
-          this.data = other.data;
-          return;
-        }
-        let [hits, map] = mergeProp(
-          this.s,
-          this.statementMap,
-          other.s,
-          other.statementMap
-        );
-        this.data.s = hits;
-        this.data.statementMap = map;
-        const keyFromLocProp = (x) => keyFromLoc(x.loc);
-        const keyFromLocationsProp = (x) => keyFromLoc(x.locations[0]);
-        [hits, map] = mergeProp(
-          this.f,
-          this.fnMap,
-          other.f,
-          other.fnMap,
-          keyFromLocProp
-        );
-        this.data.f = hits;
-        this.data.fnMap = map;
-        [hits, map] = mergeProp(
-          this.b,
-          this.branchMap,
-          other.b,
-          other.branchMap,
-          keyFromLocationsProp
-        );
-        this.data.b = hits;
-        this.data.branchMap = map;
-        if (this.bT && other.bT) {
-          [hits, map] = mergeProp(
-            this.bT,
-            this.branchMap,
-            other.bT,
-            other.branchMap,
-            keyFromLocationsProp
-          );
-          this.data.bT = hits;
-        }
-      }
-      computeSimpleTotals(property) {
-        let stats = this[property];
-        if (typeof stats === "function") {
-          stats = stats.call(this);
-        }
-        const ret = {
-          total: Object.keys(stats).length,
-          covered: Object.values(stats).filter((v) => !!v).length,
-          skipped: 0
-        };
-        ret.pct = percent(ret.covered, ret.total);
-        return ret;
-      }
-      computeBranchTotals(property) {
-        const stats = this[property];
-        const ret = { total: 0, covered: 0, skipped: 0 };
-        Object.values(stats).forEach((branches) => {
-          ret.covered += branches.filter((hits) => hits > 0).length;
-          ret.total += branches.length;
-        });
-        ret.pct = percent(ret.covered, ret.total);
-        return ret;
-      }
-      /**
-       * resets hit counts for all statements, functions and branches
-       * in this coverage object resulting in zero coverage.
-       */
-      resetHits() {
-        const statements = this.s;
-        const functions = this.f;
-        const branches = this.b;
-        const branchesTrue = this.bT;
-        Object.keys(statements).forEach((s) => {
-          statements[s] = 0;
-        });
-        Object.keys(functions).forEach((f) => {
-          functions[f] = 0;
-        });
-        Object.keys(branches).forEach((b) => {
-          branches[b].fill(0);
-        });
-        if (branchesTrue) {
-          Object.keys(branchesTrue).forEach((bT) => {
-            branchesTrue[bT].fill(0);
-          });
-        }
-      }
-      /**
-       * returns a CoverageSummary for this file coverage object
-       * @returns {CoverageSummary}
-       */
-      toSummary() {
-        const ret = {};
-        ret.lines = this.computeSimpleTotals("getLineCoverage");
-        ret.functions = this.computeSimpleTotals("f", "fnMap");
-        ret.statements = this.computeSimpleTotals("s", "statementMap");
-        ret.branches = this.computeBranchTotals("b");
-        if (this.bT) {
-          ret.branchesTrue = this.computeBranchTotals("bT");
-        }
-        return new CoverageSummary(ret);
-      }
-    };
-    dataProperties(FileCoverage, [
-      "path",
-      "statementMap",
-      "fnMap",
-      "branchMap",
-      "s",
-      "f",
-      "b",
-      "bT",
-      "all"
-    ]);
-    module2.exports = {
-      FileCoverage,
-      // exported for testing
-      findNearestContainer,
-      addHits,
-      addNearestContainerHits
-    };
-  }
-});
-
-// node_modules/istanbul-lib-coverage/lib/coverage-map.js
-var require_coverage_map = __commonJS({
-  "node_modules/istanbul-lib-coverage/lib/coverage-map.js"(exports2, module2) {
-    "use strict";
-    var { FileCoverage } = require_file_coverage();
-    var { CoverageSummary } = require_coverage_summary();
-    function maybeConstruct(obj, klass) {
-      if (obj instanceof klass) {
-        return obj;
-      }
-      return new klass(obj);
-    }
-    function loadMap(source) {
-      const data = /* @__PURE__ */ Object.create(null);
-      if (!source) {
-        return data;
-      }
-      Object.entries(source).forEach(([k, cov]) => {
-        data[k] = maybeConstruct(cov, FileCoverage);
-      });
-      return data;
-    }
-    var CoverageMap = class _CoverageMap {
-      /**
-       * @constructor
-       * @param {Object} [obj=undefined] obj A coverage map from which to initialize this
-       * map's contents. This can be the raw global coverage object.
-       */
-      constructor(obj) {
-        if (obj instanceof _CoverageMap) {
-          this.data = obj.data;
-        } else {
-          this.data = loadMap(obj);
-        }
-      }
-      /**
-       * merges a second coverage map into this one
-       * @param {CoverageMap} obj - a CoverageMap or its raw data. Coverage is merged
-       *  correctly for the same files and additional file coverage keys are created
-       *  as needed.
-       */
-      merge(obj) {
-        const other = maybeConstruct(obj, _CoverageMap);
-        Object.values(other.data).forEach((fc) => {
-          this.addFileCoverage(fc);
-        });
-      }
-      /**
-       * filter the coveragemap based on the callback provided
-       * @param {Function (filename)} callback - Returns true if the path
-       *  should be included in the coveragemap. False if it should be
-       *  removed.
-       */
-      filter(callback) {
-        Object.keys(this.data).forEach((k) => {
-          if (!callback(k)) {
-            delete this.data[k];
-          }
-        });
-      }
-      /**
-       * returns a JSON-serializable POJO for this coverage map
-       * @returns {Object}
-       */
-      toJSON() {
-        return this.data;
-      }
-      /**
-       * returns an array for file paths for which this map has coverage
-       * @returns {Array{string}} - array of files
-       */
-      files() {
-        return Object.keys(this.data);
-      }
-      /**
-       * returns the file coverage for the specified file.
-       * @param {String} file
-       * @returns {FileCoverage}
-       */
-      fileCoverageFor(file) {
-        const fc = this.data[file];
-        if (!fc) {
-          throw new Error(`No file coverage available for: ${file}`);
-        }
-        return fc;
-      }
-      /**
-       * adds a file coverage object to this map. If the path for the object,
-       * already exists in the map, it is merged with the existing coverage
-       * otherwise a new key is added to the map.
-       * @param {FileCoverage} fc the file coverage to add
-       */
-      addFileCoverage(fc) {
-        const cov = new FileCoverage(fc);
-        const { path: path10 } = cov;
-        if (this.data[path10]) {
-          this.data[path10].merge(cov);
-        } else {
-          this.data[path10] = cov;
-        }
-      }
-      /**
-       * returns the coverage summary for all the file coverage objects in this map.
-       * @returns {CoverageSummary}
-       */
-      getCoverageSummary() {
-        const ret = new CoverageSummary();
-        Object.values(this.data).forEach((fc) => {
-          ret.merge(fc.toSummary());
-        });
-        return ret;
-      }
-    };
-    module2.exports = {
-      CoverageMap
-    };
-  }
-});
-
-// node_modules/istanbul-lib-coverage/index.js
-var require_istanbul_lib_coverage = __commonJS({
-  "node_modules/istanbul-lib-coverage/index.js"(exports2, module2) {
-    "use strict";
-    var { FileCoverage } = require_file_coverage();
-    var { CoverageMap } = require_coverage_map();
-    var { CoverageSummary } = require_coverage_summary();
-    module2.exports = {
-      /**
-       * creates a coverage summary object
-       * @param {Object} obj an argument with the same semantics
-       *  as the one passed to the `CoverageSummary` constructor
-       * @returns {CoverageSummary}
-       */
-      createCoverageSummary(obj) {
-        if (obj && obj instanceof CoverageSummary) {
-          return obj;
-        }
-        return new CoverageSummary(obj);
-      },
-      /**
-       * creates a CoverageMap object
-       * @param {Object} obj optional - an argument with the same semantics
-       *  as the one passed to the CoverageMap constructor.
-       * @returns {CoverageMap}
-       */
-      createCoverageMap(obj) {
-        if (obj && obj instanceof CoverageMap) {
-          return obj;
-        }
-        return new CoverageMap(obj);
-      },
-      /**
-       * creates a FileCoverage object
-       * @param {Object} obj optional - an argument with the same semantics
-       *  as the one passed to the FileCoverage constructor.
-       * @returns {FileCoverage}
-       */
-      createFileCoverage(obj) {
-        if (obj && obj instanceof FileCoverage) {
-          return obj;
-        }
-        return new FileCoverage(obj);
-      }
-    };
-    module2.exports.classes = {
-      /**
-       * the file coverage constructor
-       */
-      FileCoverage
-    };
-  }
-});
-
-// node_modules/istanbul-lib-report/lib/path.js
-var require_path = __commonJS({
-  "node_modules/istanbul-lib-report/lib/path.js"(exports2, module2) {
-    "use strict";
-    var path10 = require("path");
-    var parsePath = path10.parse;
-    var SEP = path10.sep;
-    var origParser = parsePath;
-    var origSep = SEP;
-    function makeRelativeNormalizedPath(str, sep) {
-      const parsed = parsePath(str);
-      let root = parsed.root;
-      let dir;
-      let file = parsed.base;
-      let quoted;
-      let pos;
-      if (sep === "\\") {
-        pos = root.indexOf(":\\");
-        if (pos >= 0) {
-          root = root.substring(0, pos + 2);
-        }
-      }
-      dir = parsed.dir.substring(root.length);
-      if (str === "") {
-        return [];
-      }
-      if (sep !== "/") {
-        quoted = new RegExp(sep.replace(/\W/g, "\\$&"), "g");
-        dir = dir.replace(quoted, "/");
-        file = file.replace(quoted, "/");
-      }
-      if (dir !== "") {
-        dir = `${dir}/${file}`;
-      } else {
-        dir = file;
-      }
-      if (dir.substring(0, 1) === "/") {
-        dir = dir.substring(1);
-      }
-      dir = dir.split(/\/+/);
-      return dir;
-    }
-    var Path = class _Path {
-      constructor(strOrArray) {
-        if (Array.isArray(strOrArray)) {
-          this.v = strOrArray;
-        } else if (typeof strOrArray === "string") {
-          this.v = makeRelativeNormalizedPath(strOrArray, SEP);
-        } else {
-          throw new Error(
-            `Invalid Path argument must be string or array:${strOrArray}`
-          );
-        }
-      }
-      toString() {
-        return this.v.join("/");
-      }
-      hasParent() {
-        return this.v.length > 0;
-      }
-      parent() {
-        if (!this.hasParent()) {
-          throw new Error("Unable to get parent for 0 elem path");
-        }
-        const p = this.v.slice();
-        p.pop();
-        return new _Path(p);
-      }
-      elements() {
-        return this.v.slice();
-      }
-      name() {
-        return this.v.slice(-1)[0];
-      }
-      contains(other) {
-        let i;
-        if (other.length > this.length) {
-          return false;
-        }
-        for (i = 0; i < other.length; i += 1) {
-          if (this.v[i] !== other.v[i]) {
-            return false;
-          }
-        }
-        return true;
-      }
-      ancestorOf(other) {
-        return other.contains(this) && other.length !== this.length;
-      }
-      descendantOf(other) {
-        return this.contains(other) && other.length !== this.length;
-      }
-      commonPrefixPath(other) {
-        const len = this.length > other.length ? other.length : this.length;
-        let i;
-        const ret = [];
-        for (i = 0; i < len; i += 1) {
-          if (this.v[i] === other.v[i]) {
-            ret.push(this.v[i]);
-          } else {
-            break;
-          }
-        }
-        return new _Path(ret);
-      }
-      static compare(a, b) {
-        const al = a.length;
-        const bl = b.length;
-        if (al < bl) {
-          return -1;
-        }
-        if (al > bl) {
-          return 1;
-        }
-        const astr = a.toString();
-        const bstr = b.toString();
-        return astr < bstr ? -1 : astr > bstr ? 1 : 0;
-      }
-    };
-    ["push", "pop", "shift", "unshift", "splice"].forEach((fn) => {
-      Object.defineProperty(Path.prototype, fn, {
-        value(...args) {
-          return this.v[fn](...args);
-        }
-      });
-    });
-    Object.defineProperty(Path.prototype, "length", {
-      enumerable: true,
-      get() {
-        return this.v.length;
-      }
-    });
-    module2.exports = Path;
-    Path.tester = {
-      setParserAndSep(p, sep) {
-        parsePath = p;
-        SEP = sep;
-      },
-      reset() {
-        parsePath = origParser;
-        SEP = origSep;
-      }
-    };
-  }
-});
-
-// node_modules/istanbul-lib-report/lib/summarizer-factory.js
-var require_summarizer_factory = __commonJS({
-  "node_modules/istanbul-lib-report/lib/summarizer-factory.js"(exports2, module2) {
-    "use strict";
-    var coverage = require_istanbul_lib_coverage();
-    var Path = require_path();
-    var { BaseNode, BaseTree } = require_tree();
-    var ReportNode = class _ReportNode extends BaseNode {
-      constructor(path10, fileCoverage) {
-        super();
-        this.path = path10;
-        this.parent = null;
-        this.fileCoverage = fileCoverage;
-        this.children = [];
-      }
-      static createRoot(children) {
-        const root = new _ReportNode(new Path([]));
-        children.forEach((child) => {
-          root.addChild(child);
-        });
-        return root;
-      }
-      addChild(child) {
-        child.parent = this;
-        this.children.push(child);
-      }
-      asRelative(p) {
-        if (p.substring(0, 1) === "/") {
-          return p.substring(1);
-        }
-        return p;
-      }
-      getQualifiedName() {
-        return this.asRelative(this.path.toString());
-      }
-      getRelativeName() {
-        const parent = this.getParent();
-        const myPath = this.path;
-        let relPath;
-        let i;
-        const parentPath = parent ? parent.path : new Path([]);
-        if (parentPath.ancestorOf(myPath)) {
-          relPath = new Path(myPath.elements());
-          for (i = 0; i < parentPath.length; i += 1) {
-            relPath.shift();
-          }
-          return this.asRelative(relPath.toString());
-        }
-        return this.asRelative(this.path.toString());
-      }
-      getParent() {
-        return this.parent;
-      }
-      getChildren() {
-        return this.children;
-      }
-      isSummary() {
-        return !this.fileCoverage;
-      }
-      getFileCoverage() {
-        return this.fileCoverage;
-      }
-      getCoverageSummary(filesOnly) {
-        const cacheProp = `c_${filesOnly ? "files" : "full"}`;
-        let summary;
-        if (Object.prototype.hasOwnProperty.call(this, cacheProp)) {
-          return this[cacheProp];
-        }
-        if (!this.isSummary()) {
-          summary = this.getFileCoverage().toSummary();
-        } else {
-          let count = 0;
-          summary = coverage.createCoverageSummary();
-          this.getChildren().forEach((child) => {
-            if (filesOnly && child.isSummary()) {
-              return;
-            }
-            count += 1;
-            summary.merge(child.getCoverageSummary(filesOnly));
-          });
-          if (count === 0 && filesOnly) {
-            summary = null;
-          }
-        }
-        this[cacheProp] = summary;
-        return summary;
-      }
-    };
-    var ReportTree = class extends BaseTree {
-      constructor(root, childPrefix) {
-        super(root);
-        const maybePrefix = (node) => {
-          if (childPrefix && !node.isRoot()) {
-            node.path.unshift(childPrefix);
-          }
-        };
-        this.visit({
-          onDetail: maybePrefix,
-          onSummary(node) {
-            maybePrefix(node);
-            node.children.sort((a, b) => {
-              const astr = a.path.toString();
-              const bstr = b.path.toString();
-              return astr < bstr ? -1 : astr > bstr ? 1 : (
-                /* istanbul ignore next */
-                0
-              );
-            });
-          }
-        });
-      }
-    };
-    function findCommonParent(paths) {
-      return paths.reduce(
-        (common, path10) => common.commonPrefixPath(path10),
-        paths[0] || new Path([])
-      );
-    }
-    function findOrCreateParent(parentPath, nodeMap, created = () => {
-    }) {
-      let parent = nodeMap[parentPath.toString()];
-      if (!parent) {
-        parent = new ReportNode(parentPath);
-        nodeMap[parentPath.toString()] = parent;
-        created(parentPath, parent);
-      }
-      return parent;
-    }
-    function toDirParents(list) {
-      const nodeMap = /* @__PURE__ */ Object.create(null);
-      list.forEach((o) => {
-        const parent = findOrCreateParent(o.path.parent(), nodeMap);
-        parent.addChild(new ReportNode(o.path, o.fileCoverage));
-      });
-      return Object.values(nodeMap);
-    }
-    function addAllPaths(topPaths, nodeMap, path10, node) {
-      const parent = findOrCreateParent(
-        path10.parent(),
-        nodeMap,
-        (parentPath, parent2) => {
-          if (parentPath.hasParent()) {
-            addAllPaths(topPaths, nodeMap, parentPath, parent2);
-          } else {
-            topPaths.push(parent2);
-          }
-        }
-      );
-      parent.addChild(node);
-    }
-    function foldIntoOneDir(node, parent) {
-      const { children } = node;
-      if (children.length === 1 && !children[0].fileCoverage) {
-        children[0].parent = parent;
-        return foldIntoOneDir(children[0], parent);
-      }
-      node.children = children.map((child) => foldIntoOneDir(child, node));
-      return node;
-    }
-    function pkgSummaryPrefix(dirParents, commonParent) {
-      if (!dirParents.some((dp) => dp.path.length === 0)) {
-        return;
-      }
-      if (commonParent.length === 0) {
-        return "root";
-      }
-      return commonParent.name();
-    }
-    var SummarizerFactory = class {
-      constructor(coverageMap, defaultSummarizer = "pkg") {
-        this._coverageMap = coverageMap;
-        this._defaultSummarizer = defaultSummarizer;
-        this._initialList = coverageMap.files().map((filePath) => ({
-          filePath,
-          path: new Path(filePath),
-          fileCoverage: coverageMap.fileCoverageFor(filePath)
-        }));
-        this._commonParent = findCommonParent(
-          this._initialList.map((o) => o.path.parent())
-        );
-        if (this._commonParent.length > 0) {
-          this._initialList.forEach((o) => {
-            o.path.splice(0, this._commonParent.length);
-          });
-        }
-      }
-      get defaultSummarizer() {
-        return this[this._defaultSummarizer];
-      }
-      get flat() {
-        if (!this._flat) {
-          this._flat = new ReportTree(
-            ReportNode.createRoot(
-              this._initialList.map(
-                (node) => new ReportNode(node.path, node.fileCoverage)
-              )
-            )
-          );
-        }
-        return this._flat;
-      }
-      _createPkg() {
-        const dirParents = toDirParents(this._initialList);
-        if (dirParents.length === 1) {
-          return new ReportTree(dirParents[0]);
-        }
-        return new ReportTree(
-          ReportNode.createRoot(dirParents),
-          pkgSummaryPrefix(dirParents, this._commonParent)
-        );
-      }
-      get pkg() {
-        if (!this._pkg) {
-          this._pkg = this._createPkg();
-        }
-        return this._pkg;
-      }
-      _createNested() {
-        const nodeMap = /* @__PURE__ */ Object.create(null);
-        const topPaths = [];
-        this._initialList.forEach((o) => {
-          const node = new ReportNode(o.path, o.fileCoverage);
-          addAllPaths(topPaths, nodeMap, o.path, node);
-        });
-        const topNodes = topPaths.map((node) => foldIntoOneDir(node));
-        if (topNodes.length === 1) {
-          return new ReportTree(topNodes[0]);
-        }
-        return new ReportTree(ReportNode.createRoot(topNodes));
-      }
-      get nested() {
-        if (!this._nested) {
-          this._nested = this._createNested();
-        }
-        return this._nested;
-      }
-    };
-    module2.exports = SummarizerFactory;
-  }
-});
-
-// node_modules/istanbul-lib-report/lib/context.js
-var require_context = __commonJS({
-  "node_modules/istanbul-lib-report/lib/context.js"(exports2, module2) {
-    "use strict";
-    var fs6 = require("fs");
-    var FileWriter = require_file_writer();
-    var XMLWriter = require_xml_writer();
-    var tree = require_tree();
-    var watermarks = require_watermarks();
-    var SummarizerFactory = require_summarizer_factory();
-    function defaultSourceLookup(path10) {
-      try {
-        return fs6.readFileSync(path10, "utf8");
-      } catch (ex) {
-        throw new Error(`Unable to lookup source: ${path10} (${ex.message})`);
-      }
-    }
-    function normalizeWatermarks(specified = {}) {
-      Object.entries(watermarks.getDefault()).forEach(([k, value]) => {
-        const specValue = specified[k];
-        if (!Array.isArray(specValue) || specValue.length !== 2) {
-          specified[k] = value;
-        }
-      });
-      return specified;
-    }
-    var Context = class {
-      constructor(opts) {
-        this.dir = opts.dir || "coverage";
-        this.watermarks = normalizeWatermarks(opts.watermarks);
-        this.sourceFinder = opts.sourceFinder || defaultSourceLookup;
-        this._summarizerFactory = new SummarizerFactory(
-          opts.coverageMap,
-          opts.defaultSummarizer
-        );
-        this.data = {};
-      }
-      /**
-       * returns a FileWriter implementation for reporting use. Also available
-       * as the `writer` property on the context.
-       * @returns {Writer}
-       */
-      getWriter() {
-        return this.writer;
-      }
-      /**
-       * returns the source code for the specified file path or throws if
-       * the source could not be found.
-       * @param {String} filePath the file path as found in a file coverage object
-       * @returns {String} the source code
-       */
-      getSource(filePath) {
-        return this.sourceFinder(filePath);
-      }
-      /**
-       * returns the coverage class given a coverage
-       * types and a percentage value.
-       * @param {String} type - the coverage type, one of `statements`, `functions`,
-       *  `branches`, or `lines`
-       * @param {Number} value - the percentage value
-       * @returns {String} one of `high`, `medium` or `low`
-       */
-      classForPercent(type, value) {
-        const watermarks2 = this.watermarks[type];
-        if (!watermarks2) {
-          return "unknown";
-        }
-        if (value < watermarks2[0]) {
-          return "low";
-        }
-        if (value >= watermarks2[1]) {
-          return "high";
-        }
-        return "medium";
-      }
-      /**
-       * returns an XML writer for the supplied content writer
-       * @param {ContentWriter} contentWriter the content writer to which the returned XML writer
-       *  writes data
-       * @returns {XMLWriter}
-       */
-      getXMLWriter(contentWriter) {
-        return new XMLWriter(contentWriter);
-      }
-      /**
-       * returns a full visitor given a partial one.
-       * @param {Object} partialVisitor a partial visitor only having the functions of
-       *  interest to the caller. These functions are called with a scope that is the
-       *  supplied object.
-       * @returns {Visitor}
-       */
-      getVisitor(partialVisitor) {
-        return new tree.Visitor(partialVisitor);
-      }
-      getTree(name = "defaultSummarizer") {
-        return this._summarizerFactory[name];
-      }
-    };
-    Object.defineProperty(Context.prototype, "writer", {
-      enumerable: true,
-      get() {
-        if (!this.data.writer) {
-          this.data.writer = new FileWriter(this.dir);
-        }
-        return this.data.writer;
-      }
-    });
-    module2.exports = Context;
-  }
-});
-
-// node_modules/istanbul-lib-report/lib/report-base.js
-var require_report_base = __commonJS({
-  "node_modules/istanbul-lib-report/lib/report-base.js"(exports2, module2) {
-    "use strict";
-    var _summarizer = Symbol("ReportBase.#summarizer");
-    var ReportBase = class {
-      constructor(opts = {}) {
-        this[_summarizer] = opts.summarizer;
-      }
-      execute(context) {
-        context.getTree(this[_summarizer]).visit(this, context);
-      }
-    };
-    module2.exports = ReportBase;
-  }
-});
-
-// node_modules/istanbul-lib-report/index.js
-var require_istanbul_lib_report = __commonJS({
-  "node_modules/istanbul-lib-report/index.js"(exports2, module2) {
-    "use strict";
-    var Context = require_context();
-    var watermarks = require_watermarks();
-    var ReportBase = require_report_base();
-    module2.exports = {
-      /**
-       * returns a reporting context for the supplied options
-       * @param {Object} [opts=null] opts
-       * @returns {Context}
-       */
-      createContext(opts) {
-        return new Context(opts);
-      },
-      /**
-       * returns the default watermarks that would be used when not
-       * overridden
-       * @returns {Object} an object with `statements`, `functions`, `branches`,
-       *  and `line` keys. Each value is a 2 element array that has the low and
-       *  high watermark as percentages.
-       */
-      getDefaultWatermarks() {
-        return watermarks.getDefault();
-      },
-      /**
-       * Base class for all reports
-       */
-      ReportBase
-    };
-  }
-});
-
-// node_modules/istanbul-reports/index.js
-var require_istanbul_reports = __commonJS({
-  "node_modules/istanbul-reports/index.js"(exports2, module2) {
-    "use strict";
-    var path10 = require("path");
-    module2.exports = {
-      create(name, cfg) {
-        cfg = cfg || {};
-        let Cons;
-        try {
-          Cons = require(path10.join(__dirname, "lib", name));
-        } catch (e) {
-          if (e.code !== "MODULE_NOT_FOUND") {
-            throw e;
-          }
-          Cons = require(name);
-        }
-        return new Cons(cfg);
-      }
-    };
-  }
-});
-
 // src/lib/env-utils.ts
 var safeEnv;
 var init_env_utils = __esm({
@@ -4210,10 +1963,11 @@ var require_lib = __commonJS({
 var path9 = __toESM(require("node:path"), 1);
 var os2 = __toESM(require("node:os"), 1);
 var fsSync3 = __toESM(require("node:fs"), 1);
-var import_node_module2 = require("node:module");
+var import_istanbul_lib_coverage2 = require("istanbul-lib-coverage");
 var fs5 = __toESM(require("node:fs/promises"), 1);
-var LibReport = __toESM(require_istanbul_lib_report(), 1);
-var Reports = __toESM(require_istanbul_reports(), 1);
+var LibReport = __toESM(require("istanbul-lib-report"), 1);
+var import_text = __toESM(require("istanbul-reports/lib/text"), 1);
+var import_text_summary = __toESM(require("istanbul-reports/lib/text-summary"), 1);
 init_env_utils();
 init_exec();
 init_args();
@@ -5034,7 +2788,8 @@ var decideShouldRunJest = (vitestFiles, jestFiles, opts) => {
 
 // src/lib/coverage-core.ts
 var fs3 = __toESM(require("node:fs/promises"), 1);
-var import_node_module = require("node:module");
+var import_picomatch = __toESM(require("picomatch"), 1);
+var import_istanbul_lib_coverage = require("istanbul-lib-coverage");
 
 // src/lib/paths.ts
 var path6 = __toESM(require("node:path"), 1);
@@ -5055,12 +2810,6 @@ var linkifyPadded = (absPath, line, hint) => (padded) => {
 };
 
 // src/lib/coverage-core.ts
-var import_meta = {};
-var require2 = (0, import_node_module.createRequire)(import_meta.url);
-var { createCoverageMap } = (
-  // eslint-disable-next-line import/no-extraneous-dependencies
-  require2("istanbul-lib-coverage")
-);
 var readCoverageJson = async (jsonPath) => {
   try {
     const txt = await fs3.readFile(jsonPath, "utf8");
@@ -5074,11 +2823,11 @@ var readCoverageJson = async (jsonPath) => {
   }
 };
 var filterCoverageMap = (map, opts) => {
-  const picomatchFn = require2("picomatch");
+  const picomatchFn = import_picomatch.default;
   const makeMatcher = (globs) => globs.length === 0 ? () => true : picomatchFn(globs, { dot: true, nocase: true });
   const includeMatch = makeMatcher(opts.includes.length ? opts.includes : ["**/*"]);
   const excludeMatch = makeMatcher(opts.excludes);
-  const out = createCoverageMap({});
+  const out = (0, import_istanbul_lib_coverage.createCoverageMap)({});
   for (const absFile of map.files()) {
     const rel = relativizeForMatch(absFile, opts.root);
     const summary = map.fileCoverageFor(absFile).toSummary();
@@ -7243,14 +4992,13 @@ ${footer}`;
 }
 
 // src/lib/program.ts
-var import_meta2 = {};
+var import_meta = {};
 var jestBin = "./node_modules/.bin/jest";
 var babelNodeBin = "./node_modules/.bin/babel-node";
 var moduleSpecifierForRequire = (
   // @ts-ignore
-  typeof __filename !== "undefined" ? __filename : import_meta2.url
+  typeof __filename !== "undefined" ? __filename : import_meta.url
 );
-var requireCjs = (0, import_node_module2.createRequire)(moduleSpecifierForRequire);
 var registerSignalHandlersOnce = () => {
   let handled = false;
   const on = (sig) => {
@@ -7266,9 +5014,7 @@ Received ${sig}, exiting...
   process.once("SIGINT", on);
   process.once("SIGTERM", on);
 };
-var isDebug = () => Boolean(
-  process.env.TEST_CLI_DEBUG
-);
+var isDebug = () => Boolean(process.env.TEST_CLI_DEBUG);
 var mergeLcov = async () => {
   const jestLcovPath = "coverage/jest/lcov.info";
   const vitestLcovPath = "coverage/vitest/lcov.info";
@@ -7326,24 +5072,17 @@ var emitMergedCoverage = async (ui, opts) => {
   if (isDebug()) {
     console.info(`Decoded coverage entries \u2192 jest: ${jestFilesCount}`);
   }
-  const { createCoverageMap: createCoverageMap2 } = requireCjs(
-    "istanbul-lib-coverage"
-  );
-  const map = createCoverageMap2({});
+  const map = (0, import_istanbul_lib_coverage2.createCoverageMap)({});
   if (jestFilesCount > 0) {
     try {
       map.merge(jestData);
     } catch (mergeJestError) {
-      console.warn(
-        `Failed merging jest coverage JSON: ${String(mergeJestError)}`
-      );
+      console.warn(`Failed merging jest coverage JSON: ${String(mergeJestError)}`);
     }
   }
   if (map.files().length === 0) {
     if (isDebug()) {
-      console.info(
-        "No JSON coverage to merge; skipping merged coverage print."
-      );
+      console.info("No JSON coverage to merge; skipping merged coverage print.");
     }
     return;
   }
@@ -7371,18 +5110,12 @@ var emitMergedCoverage = async (ui, opts) => {
   }
   let changedFilesOutput = [];
   try {
-    const out = await runText(
-      "git",
-      ["diff", "--name-only", "--diff-filter=ACMRTUXB", "HEAD"],
-      {
-        env: safeEnv(process.env, {})
-      }
-    );
+    const out = await runText("git", ["diff", "--name-only", "--diff-filter=ACMRTUXB", "HEAD"], {
+      env: safeEnv(process.env, {})
+    });
     changedFilesOutput = out.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((filePathText) => filePathText.replace(/\\/g, "/"));
   } catch (gitError) {
-    console.warn(
-      `git diff failed when deriving changed files: ${String(gitError)}`
-    );
+    console.warn(`git diff failed when deriving changed files: ${String(gitError)}`);
   }
   await printPerFileCompositeTables({
     map: filteredMap,
@@ -7398,10 +5131,7 @@ var emitMergedCoverage = async (ui, opts) => {
     coverageMap: filteredMap,
     defaultSummarizer: "nested"
   });
-  const reporters = ui === "jest" ? [Reports.create("text", { file: "coverage.txt" })] : [
-    Reports.create("text", { file: "coverage.txt" }),
-    Reports.create("text-summary", { file: "coverage-summary.txt" })
-  ];
+  const reporters = ui === "jest" ? [(0, import_text.default)({ file: "coverage.txt" })] : [(0, import_text.default)({ file: "coverage.txt" }), (0, import_text_summary.default)({ file: "coverage-summary.txt" })];
   const colorizeIstanbulLine = (lineText) => {
     const separator = /^[-=\s]+$/;
     if (separator.test(lineText.trim())) {
@@ -7419,18 +5149,15 @@ var emitMergedCoverage = async (ui, opts) => {
           return `${colorize(label)}${sep}${colorize(`${num}${pct}`)}`;
         }
       );
-      return updated.replace(
-        /\(\s*(\d+)\s*\/\s*(\d+)\s*\)/,
-        (_match, coveredText, totalText) => {
-          const percent = (() => {
-            const totalCount = Number(totalText);
-            const coveredCount = Number(coveredText);
-            return totalCount > 0 ? coveredCount / totalCount * 100 : 0;
-          })();
-          const colorize = tintPct(percent);
-          return colorize(`( ${coveredText}/${totalText} )`);
-        }
-      );
+      return updated.replace(/\(\s*(\d+)\s*\/\s*(\d+)\s*\)/, (_match, coveredText, totalText) => {
+        const percent = (() => {
+          const totalCount = Number(totalText);
+          const coveredCount = Number(coveredText);
+          return totalCount > 0 ? coveredCount / totalCount * 100 : 0;
+        })();
+        const colorize = tintPct(percent);
+        return colorize(`( ${coveredText}/${totalText} )`);
+      });
     }
     if (lineText.includes("|")) {
       const parts = lineText.split("|");
@@ -7466,11 +5193,7 @@ var emitMergedCoverage = async (ui, opts) => {
     reporter.execute(context);
   }
   const textPath = path9.resolve("coverage", "merged", "coverage.txt");
-  const summaryPath = path9.resolve(
-    "coverage",
-    "merged",
-    "coverage-summary.txt"
-  );
+  const summaryPath = path9.resolve("coverage", "merged", "coverage-summary.txt");
   const filesToPrint = [];
   if (fsSync3.existsSync(textPath)) {
     filesToPrint.push(textPath);
@@ -7495,7 +5218,7 @@ var emitMergedCoverage = async (ui, opts) => {
       }
     }
   } else {
-    const stdoutReporters = ui === "jest" ? [Reports.create("text")] : [Reports.create("text"), Reports.create("text-summary")];
+    const stdoutReporters = ui === "jest" ? [(0, import_text.default)({})] : [(0, import_text.default)({}), (0, import_text_summary.default)({})];
     for (const reporter of stdoutReporters) {
       reporter.execute(context);
     }
@@ -7554,9 +5277,7 @@ var program = async () => {
     coverageMaxHotspots: coverageMaxHotspotsArg,
     coveragePageFit
   } = deriveArgs(argv);
-  console.info(
-    `Selection \u2192 specified=${selectionSpecified} paths=${selectionPaths.length}`
-  );
+  console.info(`Selection \u2192 specified=${selectionSpecified} paths=${selectionPaths.length}`);
   const { jest } = argsForDiscovery(["run"], jestArgs);
   const selectionLooksLikeTest = selectionPaths.some(
     (pathText) => /\.(test|spec)\.[tj]sx?$/i.test(pathText) || /(^|\/)tests?\//i.test(pathText)
@@ -7646,12 +5367,9 @@ var program = async () => {
     const prodSelections2 = expandedProdSelections;
     for (const cfg of projectConfigs) {
       const cfgCwd = path9.dirname(cfg);
-      const allTests = await discoverJestResilient(
-        [...jestDiscoveryArgs, "--config", cfg],
-        {
-          cwd: cfgCwd
-        }
-      );
+      const allTests = await discoverJestResilient([...jestDiscoveryArgs, "--config", cfg], {
+        cwd: cfgCwd
+      });
       let directPerProject = [];
       try {
         directPerProject = await selectDirectTestsForProduction({
@@ -7661,11 +5379,7 @@ var program = async () => {
         });
       } catch (err) {
         if (isDebug()) {
-          console.warn(
-            `direct selection failed for project ${path9.basename(
-              cfg
-            )}: ${String(err)}`
-          );
+          console.warn(`direct selection failed for project ${path9.basename(cfg)}: ${String(err)}`);
         }
       }
       perProjectFiles.set(cfg, directPerProject);
@@ -7678,12 +5392,9 @@ var program = async () => {
     );
     for (const cfg of projectConfigs) {
       const cfgCwd = path9.dirname(cfg);
-      const files = await discoverJestResilient(
-        [...jestDiscoveryArgs, "--config", cfg],
-        {
-          cwd: cfgCwd
-        }
-      );
+      const files = await discoverJestResilient([...jestDiscoveryArgs, "--config", cfg], {
+        cwd: cfgCwd
+      });
       perProjectFiles.set(cfg, files);
     }
   }
@@ -7706,20 +5417,14 @@ var program = async () => {
     perProjectFiltered.set(cfg, onlyOwned);
   }
   let jestFiles = Array.from(perProjectFiltered.values()).flat();
-  console.info(
-    `Discovery results \u2192 jest=${jestFiles.length} (projects=${projectConfigs.length})`
-  );
+  console.info(`Discovery results \u2192 jest=${jestFiles.length} (projects=${projectConfigs.length})`);
   const looksLikeTestPath = (candidatePath) => /\.(test|spec)\.[tj]sx?$/i.test(candidatePath) || /(^|\/)tests?\//i.test(candidatePath);
   const prodSelections = expandedProdSelections;
   let effectiveJestFiles = jestFiles.slice();
   if (selectionHasPaths && prodSelections.length > 0) {
-    console.info(
-      `rg related \u2192 prodSelections=${prodSelections.length} (starting)`
-    );
+    console.info(`rg related \u2192 prodSelections=${prodSelections.length} (starting)`);
     const repoRootForRefinement = workspaceRoot ?? await findRepoRoot();
-    const selectionKey = prodSelections.map(
-      (absPath) => path9.relative(repoRootForRefinement, absPath).replace(/\\/g, "/")
-    ).sort((a, b) => a.localeCompare(b)).join("|");
+    const selectionKey = prodSelections.map((absPath) => path9.relative(repoRootForRefinement, absPath).replace(/\\/g, "/")).sort((a, b) => a.localeCompare(b)).join("|");
     const { cachedRelated: cachedRelated2, findRelatedTestsFast: findRelatedTestsFast2, DEFAULT_TEST_GLOBS: DEFAULT_TEST_GLOBS2 } = await Promise.resolve().then(() => (init_fast_related(), fast_related_exports));
     const { DEFAULT_EXCLUDE: DEFAULT_EXCLUDE2 } = await Promise.resolve().then(() => (init_args(), args_exports));
     const rgMatches = await cachedRelated2({
@@ -7738,12 +5443,8 @@ var program = async () => {
     const normalizedCandidates = rgMatches.map(
       (candidatePath) => candidatePath.replace(/\\/g, "/")
     );
-    normalizedCandidates.forEach(
-      (candidatePath) => console.info(` - ${candidatePath}`)
-    );
-    const rgSet = new Set(
-      rgMatches.map((candidate) => candidate.replace(/\\/g, "/"))
-    );
+    normalizedCandidates.forEach((candidatePath) => console.info(` - ${candidatePath}`));
+    const rgSet = new Set(rgMatches.map((candidate) => candidate.replace(/\\/g, "/")));
     if (rgSet.size > 0) {
       if (selectionIncludesProdPaths) {
         const rgCandidates = Array.from(rgSet);
@@ -7773,9 +5474,7 @@ var program = async () => {
             const base = path9.basename(withoutExt);
             const segs = withoutExt.split("/");
             const tail2 = segs.slice(-2).join("/");
-            return Array.from(
-              new Set([withoutExt, base, tail2].filter(Boolean))
-            );
+            return Array.from(new Set([withoutExt, base, tail2].filter(Boolean)));
           };
           const seeds = Array.from(new Set(prodSelections.flatMap(toSeeds)));
           const includesSeed = (text) => seeds.some((seed) => text.includes(seed));
@@ -7882,9 +5581,7 @@ var program = async () => {
       ).flatMap((rel) => {
         const base = path9.basename(rel);
         const segments = rel.split("/");
-        return Array.from(
-          new Set([rel, base, segments.slice(-2).join("/")].filter(Boolean))
-        );
+        return Array.from(new Set([rel, base, segments.slice(-2).join("/")].filter(Boolean)));
       });
       const includesSeed = (text) => seeds.some((seed) => text.includes(seed));
       const tryReadFile = async (absPath) => {
@@ -7897,17 +5594,7 @@ var program = async () => {
       const resolveLocalImport = (fromFile, spec) => {
         const baseDir = path9.dirname(fromFile);
         const candidate = path9.resolve(baseDir, spec);
-        const extensions = [
-          "",
-          ".ts",
-          ".tsx",
-          ".js",
-          ".jsx",
-          ".mjs",
-          ".cjs",
-          ".mts",
-          ".cts"
-        ];
+        const extensions = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"];
         for (const ext of extensions) {
           const fullPath = ext ? `${candidate}${ext}` : candidate;
           if (fsSync3.existsSync(fullPath)) {
@@ -8030,9 +5717,7 @@ var program = async () => {
       if (jestKept.length) {
         effectiveJestFiles = jestKept;
       }
-      console.info(
-        `fallback refine (transitive) \u2192 jest=${effectiveJestFiles.length}`
-      );
+      console.info(`fallback refine (transitive) \u2192 jest=${effectiveJestFiles.length}`);
     }
   }
   const jestDecision = decideShouldRunJest([], effectiveJestFiles, {
@@ -8045,21 +5730,15 @@ var program = async () => {
   const msg = shouldRunJest ? `Jest selected (${sharePct}% of discovered tests; reason: ${jestDecision.reason})` : `Skipping Jest (${sharePct}% of discovered tests; reason: ${jestDecision.reason})`;
   console.info(`Discovery \u2192 jest: ${jestCount}. ${msg}`);
   if (!shouldRunJest) {
-    console.warn(
-      "No matching tests were discovered for either Vitest or Jest."
-    );
-    console.info(
-      `Jest args: ${[...jestDiscoveryArgs, "--listTests"].join(" ")}`
-    );
+    console.warn("No matching tests were discovered for either Vitest or Jest.");
+    console.info(`Jest args: ${[...jestDiscoveryArgs, "--listTests"].join(" ")}`);
     console.info(
       "Tip: check your -t/--testNamePattern and file path; Jest lists files selected by your patterns."
     );
     process.exit(1);
     return;
   }
-  console.info(
-    `Run plan \u2192 Jest maybe=${shouldRunJest} (projects=${projectConfigs.length})`
-  );
+  console.info(`Run plan \u2192 Jest maybe=${shouldRunJest} (projects=${projectConfigs.length})`);
   let jestExitCode = 0;
   const executedTestFilesSet = /* @__PURE__ */ new Set();
   if (shouldRunJest) {
@@ -8072,9 +5751,7 @@ var program = async () => {
     const totalProjectsToRun = projectsToRun.length;
     const stripFooter = (text) => {
       const lines = text.split("\n");
-      const idx = lines.findIndex(
-        (ln) => /^Test Files\s/.test(stripAnsiSimple(ln))
-      );
+      const idx = lines.findIndex((ln) => /^Test Files\s/.test(stripAnsiSimple(ln)));
       return idx >= 0 ? lines.slice(0, idx).join("\n").trimEnd() : text;
     };
     for (let projIndex = 0; projIndex < projectsToRun.length; projIndex += 1) {
@@ -8082,11 +5759,7 @@ var program = async () => {
       const isLastProject = projIndex === totalProjectsToRun - 1;
       const files = perProjectFiltered.get(cfg) ?? [];
       if (files.length === 0) {
-        console.info(
-          `Project ${path9.basename(
-            cfg
-          )}: 0 matching tests after filter; skipping.`
-        );
+        console.info(`Project ${path9.basename(cfg)}: 0 matching tests after filter; skipping.`);
         continue;
       }
       files.forEach(
@@ -8100,22 +5773,12 @@ var program = async () => {
       try {
         if (!fsSync3.existsSync(reporterPath)) {
           fsSync3.mkdirSync(path9.dirname(reporterPath), { recursive: true });
-          fsSync3.writeFileSync(
-            reporterPath,
-            JEST_BRIDGE_REPORTER_SOURCE,
-            "utf8"
-          );
+          fsSync3.writeFileSync(reporterPath, JEST_BRIDGE_REPORTER_SOURCE, "utf8");
         }
       } catch (ensureReporterError) {
-        console.warn(
-          `Unable to ensure jest bridge reporter: ${String(
-            ensureReporterError
-          )}`
-        );
+        console.warn(`Unable to ensure jest bridge reporter: ${String(ensureReporterError)}`);
       }
-      const selectedFilesForCoverage = selectionPaths.filter((pathToken) => /[\\/]/.test(pathToken)).filter((pathToken) => !looksLikeTestPath(pathToken)).map(
-        (pathToken) => path9.relative(repoRootForDiscovery, pathToken).replace(/\\\\/g, "/")
-      ).filter((rel) => rel && !/^\.+\//.test(rel)).map((rel) => rel.startsWith("./") ? rel : `./${rel}`);
+      const selectedFilesForCoverage = selectionPaths.filter((pathToken) => /[\\/]/.test(pathToken)).filter((pathToken) => !looksLikeTestPath(pathToken)).map((pathToken) => path9.relative(repoRootForDiscovery, pathToken).replace(/\\\\/g, "/")).filter((rel) => rel && !/^\.+\//.test(rel)).map((rel) => rel.startsWith("./") ? rel : `./${rel}`);
       const coverageFromArgs = [];
       for (const relPath of selectedFilesForCoverage) {
         coverageFromArgs.push("--collectCoverageFrom", relPath);
@@ -8168,21 +5831,15 @@ var program = async () => {
         });
         if (debug) {
           const preview = pretty.split("\n").slice(0, 3).join("\n");
-          console.info(
-            `pretty preview (json):
-${preview}${pretty.includes("\n") ? "\n\u2026" : ""}`
-          );
+          console.info(`pretty preview (json):
+${preview}${pretty.includes("\n") ? "\n\u2026" : ""}`);
         }
       } catch (jsonErr) {
         const debug = isDebug();
         if (debug) {
-          console.info(
-            "renderer: fallback to text prettifier (missing/invalid JSON)"
-          );
+          console.info("renderer: fallback to text prettifier (missing/invalid JSON)");
           console.info(String(jsonErr));
-          console.info(
-            `fallback: raw output lines=${output.split(/\r?\n/).length}`
-          );
+          console.info(`fallback: raw output lines=${output.split(/\r?\n/).length}`);
         }
         const renderOpts = {
           cwd: repoRootForDiscovery,
@@ -8191,10 +5848,8 @@ ${preview}${pretty.includes("\n") ? "\n\u2026" : ""}`
         pretty = formatJestOutputVitest(output, renderOpts);
         if (debug) {
           const preview = pretty.split("\n").slice(0, 3).join("\n");
-          console.info(
-            `pretty preview (text):
-${preview}${pretty.includes("\n") ? "\n\u2026" : ""}`
-          );
+          console.info(`pretty preview (text):
+${preview}${pretty.includes("\n") ? "\n\u2026" : ""}`);
         }
       }
       if (!isLastProject) {