@storybook/addon-vitest 0.0.0-pr-32795-sha-81cf1f23 → 0.0.0-pr-32717-sha-f340a68b

package/dist/node/coverage-reporter.js

@@ -1,106 +1,144 @@
-import CJS_COMPAT_NODE_URL_75ibbepv58q from 'node:url';
-import CJS_COMPAT_NODE_PATH_75ibbepv58q from 'node:path';
-import CJS_COMPAT_NODE_MODULE_75ibbepv58q from "node:module";
+import CJS_COMPAT_NODE_URL_xvr6gehai1p from 'node:url';
+import CJS_COMPAT_NODE_PATH_xvr6gehai1p from 'node:path';
+import CJS_COMPAT_NODE_MODULE_xvr6gehai1p from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_75ibbepv58q.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_75ibbepv58q.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_75ibbepv58q.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_xvr6gehai1p.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_xvr6gehai1p.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_xvr6gehai1p.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
   require_gte
-} from "../_node-chunks/chunk-NSF3UF7J.js";
+} from "../_node-chunks/chunk-A4VFZRVB.js";
 import {
   __commonJS,
+  __name,
   __require,
   __toESM
-} from "../_node-chunks/chunk-ML5LEYEM.js";
+} from "../_node-chunks/chunk-K5BRNZW2.js";
 
 // ../../node_modules/istanbul-lib-report/node_modules/make-dir/index.js
 var require_make_dir = __commonJS({
   "../../node_modules/istanbul-lib-report/node_modules/make-dir/index.js"(exports, module) {
     "use strict";
-    var fs = __require("fs"), path = __require("path"), { promisify } = __require("util"), semverGte = require_gte(), useNativeRecursiveOption = semverGte(process.version, "10.12.0"), checkPath = (pth) => {
-      if (process.platform === "win32" && /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ""))) {
-        let error = new Error(`Path contains invalid characters: ${pth}`);
-        throw error.code = "EINVAL", error;
+    var fs = __require("fs");
+    var path = __require("path");
+    var { promisify } = __require("util");
+    var semverGte = require_gte();
+    var useNativeRecursiveOption = semverGte(process.version, "10.12.0");
+    var checkPath = /* @__PURE__ */ __name((pth) => {
+      if (process.platform === "win32") {
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ""));
+        if (pathHasInvalidWinCharacters) {
+          const error = new Error(`Path contains invalid characters: ${pth}`);
+          error.code = "EINVAL";
+          throw error;
+        }
       }
-    }, processOptions = (options) => ({
-      ...{
+    }, "checkPath");
+    var processOptions = /* @__PURE__ */ __name((options) => {
+      const defaults = {
         mode: 511,
         fs
-      },
-      ...options
-    }), permissionError = (pth) => {
-      let error = new Error(`operation not permitted, mkdir '${pth}'`);
-      return error.code = "EPERM", error.errno = -4048, error.path = pth, error.syscall = "mkdir", error;
-    }, makeDir = async (input, options) => {
-      checkPath(input), options = processOptions(options);
-      let mkdir = promisify(options.fs.mkdir), stat = promisify(options.fs.stat);
+      };
+      return {
+        ...defaults,
+        ...options
+      };
+    }, "processOptions");
+    var permissionError = /* @__PURE__ */ __name((pth) => {
+      const error = new Error(`operation not permitted, mkdir '${pth}'`);
+      error.code = "EPERM";
+      error.errno = -4048;
+      error.path = pth;
+      error.syscall = "mkdir";
+      return error;
+    }, "permissionError");
+    var makeDir = /* @__PURE__ */ __name(async (input, options) => {
+      checkPath(input);
+      options = processOptions(options);
+      const mkdir = promisify(options.fs.mkdir);
+      const stat = promisify(options.fs.stat);
       if (useNativeRecursiveOption && options.fs.mkdir === fs.mkdir) {
-        let pth = path.resolve(input);
-        return await mkdir(pth, {
+        const pth = path.resolve(input);
+        await mkdir(pth, {
           mode: options.mode,
-          recursive: !0
-        }), pth;
+          recursive: true
+        });
+        return pth;
       }
-      let make = async (pth) => {
+      const make = /* @__PURE__ */ __name(async (pth) => {
         try {
-          return await mkdir(pth, options.mode), pth;
+          await mkdir(pth, options.mode);
+          return pth;
         } catch (error) {
-          if (error.code === "EPERM")
+          if (error.code === "EPERM") {
             throw error;
+          }
           if (error.code === "ENOENT") {
-            if (path.dirname(pth) === pth)
+            if (path.dirname(pth) === pth) {
               throw permissionError(pth);
-            if (error.message.includes("null bytes"))
+            }
+            if (error.message.includes("null bytes")) {
               throw error;
-            return await make(path.dirname(pth)), make(pth);
+            }
+            await make(path.dirname(pth));
+            return make(pth);
           }
           try {
-            if (!(await stat(pth)).isDirectory())
+            const stats = await stat(pth);
+            if (!stats.isDirectory()) {
               throw new Error("The path is not a directory");
+            }
           } catch {
             throw error;
           }
           return pth;
         }
-      };
+      }, "make");
       return make(path.resolve(input));
-    };
+    }, "makeDir");
     module.exports = makeDir;
     module.exports.sync = (input, options) => {
-      if (checkPath(input), options = processOptions(options), useNativeRecursiveOption && options.fs.mkdirSync === fs.mkdirSync) {
-        let pth = path.resolve(input);
-        return fs.mkdirSync(pth, {
+      checkPath(input);
+      options = processOptions(options);
+      if (useNativeRecursiveOption && options.fs.mkdirSync === fs.mkdirSync) {
+        const pth = path.resolve(input);
+        fs.mkdirSync(pth, {
           mode: options.mode,
-          recursive: !0
-        }), pth;
+          recursive: true
+        });
+        return pth;
       }
-      let make = (pth) => {
+      const make = /* @__PURE__ */ __name((pth) => {
         try {
           options.fs.mkdirSync(pth, options.mode);
         } catch (error) {
-          if (error.code === "EPERM")
+          if (error.code === "EPERM") {
             throw error;
+          }
           if (error.code === "ENOENT") {
-            if (path.dirname(pth) === pth)
+            if (path.dirname(pth) === pth) {
               throw permissionError(pth);
-            if (error.message.includes("null bytes"))
+            }
+            if (error.message.includes("null bytes")) {
               throw error;
-            return make(path.dirname(pth)), make(pth);
+            }
+            make(path.dirname(pth));
+            return make(pth);
           }
           try {
-            if (!options.fs.statSync(pth).isDirectory())
+            if (!options.fs.statSync(pth).isDirectory()) {
               throw new Error("The path is not a directory");
+            }
           } catch {
             throw error;
           }
         }
         return pth;
-      };
+      }, "make");
       return make(path.resolve(input));
     };
   }
@@ -111,7 +149,9 @@ var require_has_flag = __commonJS({
   "../../node_modules/has-flag/index.js"(exports, module) {
     "use strict";
     module.exports = (flag, argv = process.argv) => {
-      let prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--", position = argv.indexOf(prefix + flag), terminatorPosition = argv.indexOf("--");
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
       return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
     };
   }
@@ -121,41 +161,75 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/supports-color/index.js"(exports, module) {
     "use strict";
-    var os = __require("os"), tty = __require("tty"), hasFlag = require_has_flag(), { env } = process, forceColor;
-    hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never") ? forceColor = 0 : (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) && (forceColor = 1);
-    "FORCE_COLOR" in env && (env.FORCE_COLOR === "true" ? forceColor = 1 : env.FORCE_COLOR === "false" ? forceColor = 0 : forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3));
+    var os = __require("os");
+    var tty = __require("tty");
+    var hasFlag = require_has_flag();
+    var { env } = 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 env) {
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+      }
+    }
     function translateLevel(level) {
-      return level === 0 ? !1 : {
+      if (level === 0) {
+        return false;
+      }
+      return {
         level,
-        hasBasic: !0,
+        hasBasic: true,
         has256: level >= 2,
         has16m: level >= 3
       };
     }
+    __name(translateLevel, "translateLevel");
     function supportsColor(haveStream, streamIsTTY) {
-      if (forceColor === 0)
+      if (forceColor === 0) {
         return 0;
-      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor"))
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
         return 3;
-      if (hasFlag("color=256"))
+      }
+      if (hasFlag("color=256")) {
         return 2;
-      if (haveStream && !streamIsTTY && forceColor === void 0)
+      }
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
         return 0;
-      let min = forceColor || 0;
-      if (env.TERM === "dumb")
+      }
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
         return min;
+      }
       if (process.platform === "win32") {
-        let osRelease = os.release().split(".");
-        return Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586 ? Number(osRelease[2]) >= 14931 ? 3 : 2 : 1;
+        const osRelease = os.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
       }
-      if ("CI" in env)
-        return ["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship" ? 1 : min;
-      if ("TEAMCITY_VERSION" in env)
+      if ("TEAMCITY_VERSION" in env) {
         return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-      if (env.COLORTERM === "truecolor")
+      }
+      if (env.COLORTERM === "truecolor") {
         return 3;
+      }
       if ("TERM_PROGRAM" in env) {
-        let version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
         switch (env.TERM_PROGRAM) {
           case "iTerm.app":
             return version >= 3 ? 3 : 2;
@@ -163,16 +237,27 @@ var require_supports_color = __commonJS({
             return 2;
         }
       }
-      return /-256(color)?$/i.test(env.TERM) ? 2 : /^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM) || "COLORTERM" in env ? 1 : min;
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      return min;
     }
+    __name(supportsColor, "supportsColor");
     function getSupportLevel(stream) {
-      let level = supportsColor(stream, stream && stream.isTTY);
+      const level = supportsColor(stream, stream && stream.isTTY);
       return translateLevel(level);
     }
+    __name(getSupportLevel, "getSupportLevel");
     module.exports = {
       supportsColor: getSupportLevel,
-      stdout: translateLevel(supportsColor(!0, tty.isatty(1))),
-      stderr: translateLevel(supportsColor(!0, tty.isatty(2)))
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
     };
   }
 });
@@ -181,7 +266,14 @@ var require_supports_color = __commonJS({
 var require_file_writer = __commonJS({
   "../../node_modules/istanbul-lib-report/lib/file-writer.js"(exports, module) {
     "use strict";
-    var path = __require("path"), fs = __require("fs"), mkdirp = require_make_dir(), supportsColor = require_supports_color(), ContentWriter = class {
+    var path = __require("path");
+    var fs = __require("fs");
+    var mkdirp = require_make_dir();
+    var supportsColor = require_supports_color();
+    var ContentWriter = class {
+      static {
+        __name(this, "ContentWriter");
+      }
       /**
        * returns the colorized version of a string. Typically,
        * content writers that write to files will return the
@@ -207,9 +299,14 @@ var require_file_writer = __commonJS({
        */
       close() {
       }
-    }, FileContentWriter = class extends ContentWriter {
+    };
+    var FileContentWriter = class extends ContentWriter {
+      static {
+        __name(this, "FileContentWriter");
+      }
       constructor(fd) {
-        super(), this.fd = fd;
+        super();
+        this.fd = fd;
       }
       write(str) {
         fs.writeSync(this.fd, str);
@@ -217,22 +314,40 @@ var require_file_writer = __commonJS({
       close() {
         fs.closeSync(this.fd);
       }
-    }, capture = !1, output = "", ConsoleWriter = class extends ContentWriter {
+    };
+    var capture = false;
+    var output = "";
+    var ConsoleWriter = class extends ContentWriter {
+      static {
+        __name(this, "ConsoleWriter");
+      }
       write(str) {
-        capture ? output += str : process.stdout.write(str);
+        if (capture) {
+          output += str;
+        } else {
+          process.stdout.write(str);
+        }
       }
       colorize(str, clazz) {
-        let colors = {
+        const colors = {
           low: "31;1",
           medium: "33;1",
           high: "32;1"
         };
-        return supportsColor.stdout && colors[clazz] ? `\x1B[${colors[clazz]}m${str}\x1B[0m` : str;
+        if (supportsColor.stdout && colors[clazz]) {
+          return `\x1B[${colors[clazz]}m${str}\x1B[0m`;
+        }
+        return str;
+      }
+    };
+    var FileWriter = class _FileWriter {
+      static {
+        __name(this, "FileWriter");
       }
-    }, FileWriter = class _FileWriter {
       constructor(baseDir) {
-        if (!baseDir)
+        if (!baseDir) {
           throw new Error("baseDir must be specified");
+        }
         this.baseDir = baseDir;
       }
       /**
@@ -240,10 +355,10 @@ var require_file_writer = __commonJS({
        * super useful for tests!
        */
       static startCapture() {
-        capture = !0;
+        capture = true;
       }
       static stopCapture() {
-        capture = !1;
+        capture = false;
       }
       static getOutput() {
         return output;
@@ -258,10 +373,11 @@ var require_file_writer = __commonJS({
        * @returns {FileWriter}
        */
       writerForDir(subdir) {
-        if (path.isAbsolute(subdir))
+        if (path.isAbsolute(subdir)) {
           throw new Error(
             `Cannot create subdir writer for absolute path: ${subdir}`
           );
+        }
         return new _FileWriter(`${this.baseDir}/${subdir}`);
       }
       /**
@@ -272,11 +388,18 @@ var require_file_writer = __commonJS({
        *  (e.g., an "this file is autogenerated" comment, copyright notice, etc.)
        */
       copyFile(source, dest, header) {
-        if (path.isAbsolute(dest))
+        if (path.isAbsolute(dest)) {
           throw new Error(`Cannot write to absolute path: ${dest}`);
-        dest = path.resolve(this.baseDir, dest), mkdirp.sync(path.dirname(dest));
+        }
+        dest = path.resolve(this.baseDir, dest);
+        mkdirp.sync(path.dirname(dest));
         let contents;
-        header ? contents = header + fs.readFileSync(source, "utf8") : contents = fs.readFileSync(source), fs.writeFileSync(dest, contents);
+        if (header) {
+          contents = header + fs.readFileSync(source, "utf8");
+        } else {
+          contents = fs.readFileSync(source);
+        }
+        fs.writeFileSync(dest, contents);
       }
       /**
        * returns a content writer for writing content to the supplied file.
@@ -285,11 +408,15 @@ var require_file_writer = __commonJS({
        * @returns {ContentWriter}
        */
       writeFile(file) {
-        if (file === null || file === "-")
+        if (file === null || file === "-") {
           return new ConsoleWriter();
-        if (path.isAbsolute(file))
+        }
+        if (path.isAbsolute(file)) {
           throw new Error(`Cannot write to absolute path: ${file}`);
-        return file = path.resolve(this.baseDir, file), mkdirp.sync(path.dirname(file)), new FileContentWriter(fs.openSync(file, "w"));
+        }
+        file = path.resolve(this.baseDir, file);
+        mkdirp.sync(path.dirname(file));
+        return new FileContentWriter(fs.openSync(file, "w"));
       }
     };
     module.exports = FileWriter;
@@ -300,15 +427,21 @@ var require_file_writer = __commonJS({
 var require_xml_writer = __commonJS({
   "../../node_modules/istanbul-lib-report/lib/xml-writer.js"(exports, module) {
     "use strict";
+    var INDENT = "  ";
     function attrString(attrs) {
       return Object.entries(attrs || {}).map(([k, v]) => ` ${k}="${v}"`).join("");
     }
+    __name(attrString, "attrString");
     var XMLWriter = class {
+      static {
+        __name(this, "XMLWriter");
+      }
       constructor(contentWriter) {
-        this.cw = contentWriter, this.stack = [];
+        this.cw = contentWriter;
+        this.stack = [];
       }
       indent(str) {
-        return this.stack.map(() => "  ").join("") + str;
+        return this.stack.map(() => INDENT).join("") + str;
       }
       /**
        * writes the opening XML tag with the supplied attributes
@@ -316,8 +449,9 @@ var require_xml_writer = __commonJS({
        * @param {Object} [attrs=null] attrs attributes for the tag
        */
       openTag(name, attrs) {
-        let str = this.indent(`<${name + attrString(attrs)}>`);
-        this.cw.println(str), this.stack.push(name);
+        const str = this.indent(`<${name + attrString(attrs)}>`);
+        this.cw.println(str);
+        this.stack.push(name);
       }
       /**
        * closes an open XML tag.
@@ -325,13 +459,16 @@ var require_xml_writer = __commonJS({
        *  notion of the tag that is currently open.
        */
       closeTag(name) {
-        if (this.stack.length === 0)
+        if (this.stack.length === 0) {
           throw new Error(`Attempt to close tag ${name} when not opened`);
-        let stashed = this.stack.pop(), str = `</${name}>`;
-        if (stashed !== name)
+        }
+        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));
       }
       /**
@@ -342,7 +479,13 @@ var require_xml_writer = __commonJS({
        */
       inlineTag(name, attrs, content) {
         let str = "<" + name + attrString(attrs);
-        content ? str += `>${content}</${name}>` : str += "/>", str = this.indent(str), this.cw.println(str);
+        if (content) {
+          str += `>${content}</${name}>`;
+        } else {
+          str += "/>";
+        }
+        str = this.indent(str);
+        this.cw.println(str);
       }
       /**
        * closes all open tags and ends the document
@@ -362,21 +505,38 @@ var require_tree = __commonJS({
   "../../node_modules/istanbul-lib-report/lib/tree.js"(exports, module) {
     "use strict";
     var Visitor = class {
+      static {
+        __name(this, "Visitor");
+      }
       constructor(delegate) {
         this.delegate = delegate;
       }
     };
     ["Start", "End", "Summary", "SummaryEnd", "Detail"].map((k) => `on${k}`).forEach((fn) => {
       Object.defineProperty(Visitor.prototype, fn, {
-        writable: !0,
+        writable: true,
         value(node, state) {
-          typeof this.delegate[fn] == "function" && this.delegate[fn](node, state);
+          if (typeof this.delegate[fn] === "function") {
+            this.delegate[fn](node, state);
+          }
         }
       });
     });
     var CompositeVisitor = class extends Visitor {
+      static {
+        __name(this, "CompositeVisitor");
+      }
       constructor(visitors) {
-        super(), Array.isArray(visitors) || (visitors = [visitors]), this.visitors = visitors.map((v) => v instanceof Visitor ? v : new Visitor(v));
+        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) => {
@@ -389,6 +549,9 @@ var require_tree = __commonJS({
       });
     });
     var BaseNode = class {
+      static {
+        __name(this, "BaseNode");
+      }
       isRoot() {
         return !this.getParent();
       }
@@ -400,11 +563,23 @@ var require_tree = __commonJS({
        * @param state optional state that is passed around
        */
       visit(visitor, state) {
-        this.isSummary() ? visitor.onSummary(this, state) : visitor.onDetail(this, state), this.getChildren().forEach((child) => {
+        if (this.isSummary()) {
+          visitor.onSummary(this, state);
+        } else {
+          visitor.onDetail(this, state);
+        }
+        this.getChildren().forEach((child) => {
           child.visit(visitor, state);
-        }), this.isSummary() && visitor.onSummaryEnd(this, state);
+        });
+        if (this.isSummary()) {
+          visitor.onSummaryEnd(this, state);
+        }
+      }
+    };
+    var BaseTree = class {
+      static {
+        __name(this, "BaseTree");
       }
-    }, BaseTree = class {
       constructor(root) {
         this.root = root;
       }
@@ -420,7 +595,12 @@ var require_tree = __commonJS({
        * @param state - the state to be passed around during tree traversal
        */
       visit(visitor, state) {
-        visitor instanceof Visitor || (visitor = new Visitor(visitor)), visitor.onStart(this.getRoot(), state), this.getRoot().visit(visitor, state), visitor.onEnd(this.getRoot(), state);
+        if (!(visitor instanceof Visitor)) {
+          visitor = new Visitor(visitor);
+        }
+        visitor.onStart(this.getRoot(), state);
+        this.getRoot().visit(visitor, state);
+        visitor.onEnd(this.getRoot(), state);
       }
     };
     module.exports = {
@@ -453,10 +633,15 @@ var require_watermarks = __commonJS({
 var require_percent = __commonJS({
   "../../node_modules/istanbul-lib-coverage/lib/percent.js"(exports, module) {
     "use strict";
-    module.exports = function(covered, total) {
+    module.exports = /* @__PURE__ */ __name(function percent(covered, total) {
       let tmp;
-      return total > 0 ? (tmp = 1e3 * 100 * covered / total, Math.floor(tmp / 10) / 100) : 100;
-    };
+      if (total > 0) {
+        tmp = 1e3 * 100 * covered / total;
+        return Math.floor(tmp / 10) / 100;
+      } else {
+        return 100;
+      }
+    }, "percent");
   }
 });
 
@@ -464,16 +649,16 @@ var require_percent = __commonJS({
 var require_data_properties = __commonJS({
   "../../node_modules/istanbul-lib-coverage/lib/data-properties.js"(exports, module) {
     "use strict";
-    module.exports = function(klass, properties) {
+    module.exports = /* @__PURE__ */ __name(function dataProperties(klass, properties) {
       properties.forEach((p) => {
         Object.defineProperty(klass.prototype, p, {
-          enumerable: !0,
+          enumerable: true,
           get() {
             return this.data[p];
           }
         });
       });
-    };
+    }, "dataProperties");
   }
 });
 
@@ -481,14 +666,15 @@ var require_data_properties = __commonJS({
 var require_coverage_summary = __commonJS({
   "../../node_modules/istanbul-lib-coverage/lib/coverage-summary.js"(exports, module) {
     "use strict";
-    var percent = require_percent(), dataProperties = require_data_properties();
+    var percent = require_percent();
+    var dataProperties = require_data_properties();
     function blankSummary() {
-      let empty = () => ({
+      const empty = /* @__PURE__ */ __name(() => ({
         total: 0,
         covered: 0,
         skipped: 0,
         pct: "Unknown"
-      });
+      }), "empty");
       return {
         lines: empty(),
         statements: empty(),
@@ -497,35 +683,56 @@ var require_coverage_summary = __commonJS({
         branchesTrue: empty()
       };
     }
+    __name(blankSummary, "blankSummary");
     function assertValidSummary(obj) {
-      if (!(obj && obj.lines && obj.statements && obj.functions && obj.branches))
+      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(",")
         );
+      }
     }
+    __name(assertValidSummary, "assertValidSummary");
     var CoverageSummary = class _CoverageSummary {
+      static {
+        __name(this, "CoverageSummary");
+      }
       /**
        * @constructor
        * @param {Object|CoverageSummary} [obj=undefined] an optional data object or
        * another coverage summary to initialize this object with.
        */
       constructor(obj) {
-        obj ? obj instanceof _CoverageSummary ? this.data = obj.data : this.data = obj : this.data = blankSummary(), assertValidSummary(this.data);
+        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) {
-        return [
+        const keys = [
           "lines",
           "statements",
           "branches",
           "functions",
           "branchesTrue"
-        ].forEach((key) => {
-          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));
-        }), this;
+        ];
+        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
@@ -558,9 +765,11 @@ var require_coverage_summary = __commonJS({
 var require_file_coverage = __commonJS({
   "../../node_modules/istanbul-lib-coverage/lib/file-coverage.js"(exports, module) {
     "use strict";
-    var percent = require_percent(), dataProperties = require_data_properties(), { CoverageSummary } = require_coverage_summary();
+    var percent = require_percent();
+    var dataProperties = require_data_properties();
+    var { CoverageSummary } = require_coverage_summary();
     function emptyCoverage(filePath, reportLogic) {
-      let cov = {
+      const cov = {
         path: filePath,
         statementMap: {},
         fnMap: {},
@@ -569,84 +778,137 @@ var require_file_coverage = __commonJS({
         f: {},
         b: {}
       };
-      return reportLogic && (cov.bT = {}), cov;
+      if (reportLogic) cov.bT = {};
+      return cov;
     }
+    __name(emptyCoverage, "emptyCoverage");
     function assertValidObject(obj) {
-      if (!(obj && obj.path && obj.statementMap && obj.fnMap && obj.branchMap && obj.s && obj.f && obj.b))
+      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}`, isObj = (o) => !!o && typeof o == "object", isLineCol = (o) => isObj(o) && typeof o.line == "number" && typeof o.column == "number", isLoc = (o) => isObj(o) && isLineCol(o.start) && isLineCol(o.end), getLoc = (o) => isLoc(o) ? o : isLoc(o.loc) ? o.loc : null, findNearestContainer = (item, map) => {
-      let itemLoc = getLoc(item);
+    __name(assertValidObject, "assertValidObject");
+    var keyFromLoc = /* @__PURE__ */ __name(({ start, end }) => `${start.line}|${start.column}|${end.line}|${end.column}`, "keyFromLoc");
+    var isObj = /* @__PURE__ */ __name((o) => !!o && typeof o === "object", "isObj");
+    var isLineCol = /* @__PURE__ */ __name((o) => isObj(o) && typeof o.line === "number" && typeof o.column === "number", "isLineCol");
+    var isLoc = /* @__PURE__ */ __name((o) => isObj(o) && isLineCol(o.start) && isLineCol(o.end), "isLoc");
+    var getLoc = /* @__PURE__ */ __name((o) => isLoc(o) ? o : isLoc(o.loc) ? o.loc : null, "getLoc");
+    var findNearestContainer = /* @__PURE__ */ __name((item, map) => {
+      const itemLoc = getLoc(item);
       if (!itemLoc) return null;
-      let nearestContainingItem = null, containerDistance = null, containerKey = null;
-      for (let [i, mapItem] of Object.entries(map)) {
-        let mapLoc = getLoc(mapItem);
+      let nearestContainingItem = null;
+      let containerDistance = null;
+      let containerKey = null;
+      for (const [i, mapItem] of Object.entries(map)) {
+        const mapLoc = getLoc(mapItem);
         if (!mapLoc) continue;
-        let distance = [
+        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)
+        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;
+          containerDistance = distance;
+          nearestContainingItem = mapItem;
+          containerKey = i;
           continue;
         }
-        let closerBefore = distance[0] < containerDistance[0] || distance[0] === 0 && distance[1] < containerDistance[1], closerAfter = distance[2] < containerDistance[2] || distance[2] === 0 && distance[3] < containerDistance[3];
-        (closerBefore || closerAfter) && (containerDistance = distance, nearestContainingItem = mapItem, containerKey = i);
+        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;
-    }, addHits = (aHits, bHits) => typeof aHits == "number" && typeof bHits == "number" ? aHits + bHits : Array.isArray(aHits) && Array.isArray(bHits) ? aHits.map((a, i) => (a || 0) + (bHits[i] || 0)) : null, addNearestContainerHits = (item, itemHits, map, mapHits) => {
-      let container = findNearestContainer(item, map);
-      return container ? addHits(itemHits, mapHits[container]) : itemHits;
-    }, mergeProp = (aHits, aMap, bHits, bMap, itemKey = keyFromLoc) => {
-      let aItems = {};
-      for (let [key, itemHits] of Object.entries(aHits)) {
-        let item = aMap[key];
+    }, "findNearestContainer");
+    var addHits = /* @__PURE__ */ __name((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;
+    }, "addHits");
+    var addNearestContainerHits = /* @__PURE__ */ __name((item, itemHits, map, mapHits) => {
+      const container = findNearestContainer(item, map);
+      if (container) {
+        return addHits(itemHits, mapHits[container]);
+      } else {
+        return itemHits;
+      }
+    }, "addNearestContainerHits");
+    var mergeProp = /* @__PURE__ */ __name((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];
       }
-      let bItems = {};
-      for (let [key, itemHits] of Object.entries(bHits)) {
-        let item = bMap[key];
+      const bItems = {};
+      for (const [key, itemHits] of Object.entries(bHits)) {
+        const item = bMap[key];
         bItems[itemKey(item)] = [itemHits, item];
       }
-      let mergedItems = {};
-      for (let [key, aValue] of Object.entries(aItems)) {
-        let aItemHits = aValue[0], aItem = aValue[1], bValue = bItems[key];
-        bValue ? aItemHits = addHits(aItemHits, bValue[0]) : aItemHits = addNearestContainerHits(aItem, aItemHits, bMap, bHits), mergedItems[key] = [aItemHits, aItem];
-      }
-      for (let [key, bValue] of Object.entries(bItems)) {
-        let bItemHits = bValue[0], bItem = bValue[1];
-        mergedItems[key] || (bItemHits = addNearestContainerHits(bItem, bItemHits, aMap, aHits), mergedItems[key] = [bItemHits, bItem]);
+      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];
+    }, "mergeProp");
+    var FileCoverage = class _FileCoverage {
+      static {
+        __name(this, "FileCoverage");
       }
-      let hits = {}, map = {};
-      return Object.values(mergedItems).forEach(([itemHits, item], i) => {
-        hits[i] = itemHits, map[i] = item;
-      }), [hits, map];
-    }, 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 = !1) {
-        if (!pathOrObj)
+      constructor(pathOrObj, reportLogic = false) {
+        if (!pathOrObj) {
           throw new Error(
             "Coverage must be initialized with a path or an object"
           );
-        if (typeof pathOrObj == "string")
+        }
+        if (typeof pathOrObj === "string") {
           this.data = emptyCoverage(pathOrObj, reportLogic);
-        else if (pathOrObj instanceof _FileCoverage)
+        } else if (pathOrObj instanceof _FileCoverage) {
           this.data = pathOrObj.data;
-        else if (typeof pathOrObj == "object")
+        } else if (typeof pathOrObj === "object") {
           this.data = pathOrObj;
-        else
+        } else {
           throw new Error("Invalid argument to coverage constructor");
+        }
         assertValidObject(this.data);
       }
       /**
@@ -654,13 +916,20 @@ var require_file_coverage = __commonJS({
        * This is a map of hits keyed by line number in the source.
        */
       getLineCoverage() {
-        let statementMap = this.data.statementMap, statements = this.data.s, lineMap = /* @__PURE__ */ Object.create(null);
-        return Object.entries(statements).forEach(([st, count]) => {
-          if (!statementMap[st])
+        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;
-          let { line } = statementMap[st].start, prevVal = lineMap[line];
-          (prevVal === void 0 || prevVal < count) && (lineMap[line] = count);
-        }), lineMap;
+          }
+          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.
@@ -668,10 +937,14 @@ var require_file_coverage = __commonJS({
        *  collected.
        */
       getUncoveredLines() {
-        let lc = this.getLineCoverage(), ret = [];
-        return Object.entries(lc).forEach(([l, hits]) => {
-          hits === 0 && ret.push(l);
-        }), ret;
+        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.
@@ -679,18 +952,25 @@ var require_file_coverage = __commonJS({
        * has a `covered`, `total` and `coverage` (percentage) property.
        */
       getBranchCoverageByLine() {
-        let branchMap = this.branchMap, branches = this.b, ret = {};
-        return Object.entries(branchMap).forEach(([k, map]) => {
-          let line = map.line || map.loc.start.line, branchData = branches[k];
-          ret[line] = ret[line] || [], ret[line].push(...branchData);
-        }), Object.entries(ret).forEach(([k, dataArray]) => {
-          let covered = dataArray.filter((item) => item > 0), coverage = covered.length / dataArray.length * 100;
+        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
           };
-        }), ret;
+        });
+        return ret;
       }
       /**
        * return a JSON-serializable POJO for this file coverage object
@@ -704,9 +984,10 @@ var require_file_coverage = __commonJS({
        *  Note that the other object should have the same structure as this one (same file).
        */
       merge(other) {
-        if (other.all === !0)
+        if (other.all === true) {
           return;
-        if (this.all === !0) {
+        }
+        if (this.all === true) {
           this.data = other.data;
           return;
         }
@@ -716,67 +997,100 @@ var require_file_coverage = __commonJS({
           other.s,
           other.statementMap
         );
-        this.data.s = hits, this.data.statementMap = map;
-        let keyFromLocProp = (x) => keyFromLoc(x.loc), keyFromLocationsProp = (x) => keyFromLoc(x.locations[0]);
+        this.data.s = hits;
+        this.data.statementMap = map;
+        const keyFromLocProp = /* @__PURE__ */ __name((x) => keyFromLoc(x.loc), "keyFromLocProp");
+        const keyFromLocationsProp = /* @__PURE__ */ __name((x) => keyFromLoc(x.locations[0]), "keyFromLocationsProp");
         [hits, map] = mergeProp(
           this.f,
           this.fnMap,
           other.f,
           other.fnMap,
           keyFromLocProp
-        ), this.data.f = hits, this.data.fnMap = map, [hits, map] = mergeProp(
+        );
+        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, this.bT && other.bT && ([hits, map] = mergeProp(
-          this.bT,
-          this.branchMap,
-          other.bT,
-          other.branchMap,
-          keyFromLocationsProp
-        ), this.data.bT = hits);
+        );
+        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];
-        typeof stats == "function" && (stats = stats.call(this));
-        let ret = {
+        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
         };
-        return ret.pct = percent(ret.covered, ret.total), ret;
+        ret.pct = percent(ret.covered, ret.total);
+        return ret;
       }
       computeBranchTotals(property) {
-        let stats = this[property], ret = { total: 0, covered: 0, skipped: 0 };
-        return Object.values(stats).forEach((branches) => {
-          ret.covered += branches.filter((hits) => hits > 0).length, ret.total += branches.length;
-        }), ret.pct = percent(ret.covered, ret.total), ret;
+        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() {
-        let statements = this.s, functions = this.f, branches = this.b, branchesTrue = this.bT;
+        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) => {
+        });
+        Object.keys(functions).forEach((f) => {
           functions[f] = 0;
-        }), Object.keys(branches).forEach((b) => {
+        });
+        Object.keys(branches).forEach((b) => {
           branches[b].fill(0);
-        }), branchesTrue && Object.keys(branchesTrue).forEach((bT) => {
-          branchesTrue[bT].fill(0);
         });
+        if (branchesTrue) {
+          Object.keys(branchesTrue).forEach((bT) => {
+            branchesTrue[bT].fill(0);
+          });
+        }
       }
       /**
        * returns a CoverageSummary for this file coverage object
        * @returns {CoverageSummary}
        */
       toSummary() {
-        let ret = {};
-        return ret.lines = this.computeSimpleTotals("getLineCoverage"), ret.functions = this.computeSimpleTotals("f", "fnMap"), ret.statements = this.computeSimpleTotals("s", "statementMap"), ret.branches = this.computeBranchTotals("b"), this.bT && (ret.branchesTrue = this.computeBranchTotals("bT")), new CoverageSummary(ret);
+        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, [
@@ -804,24 +1118,41 @@ var require_file_coverage = __commonJS({
 var require_coverage_map = __commonJS({
   "../../node_modules/istanbul-lib-coverage/lib/coverage-map.js"(exports, module) {
     "use strict";
-    var { FileCoverage } = require_file_coverage(), { CoverageSummary } = require_coverage_summary();
+    var { FileCoverage } = require_file_coverage();
+    var { CoverageSummary } = require_coverage_summary();
     function maybeConstruct(obj, klass) {
-      return obj instanceof klass ? obj : new klass(obj);
+      if (obj instanceof klass) {
+        return obj;
+      }
+      return new klass(obj);
     }
+    __name(maybeConstruct, "maybeConstruct");
     function loadMap(source) {
-      let data = /* @__PURE__ */ Object.create(null);
-      return source && Object.entries(source).forEach(([k, cov]) => {
+      const data = /* @__PURE__ */ Object.create(null);
+      if (!source) {
+        return data;
+      }
+      Object.entries(source).forEach(([k, cov]) => {
         data[k] = maybeConstruct(cov, FileCoverage);
-      }), data;
+      });
+      return data;
     }
+    __name(loadMap, "loadMap");
     var CoverageMap = class _CoverageMap {
+      static {
+        __name(this, "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) {
-        obj instanceof _CoverageMap ? this.data = obj.data : this.data = loadMap(obj);
+        if (obj instanceof _CoverageMap) {
+          this.data = obj.data;
+        } else {
+          this.data = loadMap(obj);
+        }
       }
       /**
        * merges a second coverage map into this one
@@ -830,7 +1161,7 @@ var require_coverage_map = __commonJS({
        *  as needed.
        */
       merge(obj) {
-        let other = maybeConstruct(obj, _CoverageMap);
+        const other = maybeConstruct(obj, _CoverageMap);
         Object.values(other.data).forEach((fc) => {
           this.addFileCoverage(fc);
         });
@@ -843,7 +1174,9 @@ var require_coverage_map = __commonJS({
        */
       filter(callback) {
         Object.keys(this.data).forEach((k) => {
-          callback(k) || delete this.data[k];
+          if (!callback(k)) {
+            delete this.data[k];
+          }
         });
       }
       /**
@@ -866,9 +1199,10 @@ var require_coverage_map = __commonJS({
        * @returns {FileCoverage}
        */
       fileCoverageFor(file) {
-        let fc = this.data[file];
-        if (!fc)
+        const fc = this.data[file];
+        if (!fc) {
           throw new Error(`No file coverage available for: ${file}`);
+        }
         return fc;
       }
       /**
@@ -878,18 +1212,24 @@ var require_coverage_map = __commonJS({
        * @param {FileCoverage} fc the file coverage to add
        */
       addFileCoverage(fc) {
-        let cov = new FileCoverage(fc), { path } = cov;
-        this.data[path] ? this.data[path].merge(cov) : this.data[path] = cov;
+        const cov = new FileCoverage(fc);
+        const { path } = cov;
+        if (this.data[path]) {
+          this.data[path].merge(cov);
+        } else {
+          this.data[path] = cov;
+        }
       }
       /**
        * returns the coverage summary for all the file coverage objects in this map.
        * @returns {CoverageSummary}
        */
       getCoverageSummary() {
-        let ret = new CoverageSummary();
-        return Object.values(this.data).forEach((fc) => {
+        const ret = new CoverageSummary();
+        Object.values(this.data).forEach((fc) => {
           ret.merge(fc.toSummary());
-        }), ret;
+        });
+        return ret;
       }
     };
     module.exports = {
@@ -902,7 +1242,9 @@ var require_coverage_map = __commonJS({
 var require_istanbul_lib_coverage = __commonJS({
   "../../node_modules/istanbul-lib-coverage/index.js"(exports, module) {
     "use strict";
-    var { FileCoverage } = require_file_coverage(), { CoverageMap } = require_coverage_map(), { CoverageSummary } = require_coverage_summary();
+    var { FileCoverage } = require_file_coverage();
+    var { CoverageMap } = require_coverage_map();
+    var { CoverageSummary } = require_coverage_summary();
     module.exports = {
       /**
        * creates a coverage summary object
@@ -911,7 +1253,10 @@ var require_istanbul_lib_coverage = __commonJS({
        * @returns {CoverageSummary}
        */
       createCoverageSummary(obj) {
-        return obj && obj instanceof CoverageSummary ? obj : new CoverageSummary(obj);
+        if (obj && obj instanceof CoverageSummary) {
+          return obj;
+        }
+        return new CoverageSummary(obj);
       },
       /**
        * creates a CoverageMap object
@@ -920,7 +1265,10 @@ var require_istanbul_lib_coverage = __commonJS({
        * @returns {CoverageMap}
        */
       createCoverageMap(obj) {
-        return obj && obj instanceof CoverageMap ? obj : new CoverageMap(obj);
+        if (obj && obj instanceof CoverageMap) {
+          return obj;
+        }
+        return new CoverageMap(obj);
       },
       /**
        * creates a FileCoverage object
@@ -929,7 +1277,10 @@ var require_istanbul_lib_coverage = __commonJS({
        * @returns {FileCoverage}
        */
       createFileCoverage(obj) {
-        return obj && obj instanceof FileCoverage ? obj : new FileCoverage(obj);
+        if (obj && obj instanceof FileCoverage) {
+          return obj;
+        }
+        return new FileCoverage(obj);
       }
     };
     module.exports.classes = {
@@ -945,21 +1296,59 @@ var require_istanbul_lib_coverage = __commonJS({
 var require_path = __commonJS({
   "../../node_modules/istanbul-lib-report/lib/path.js"(exports, module) {
     "use strict";
-    var path = __require("path"), parsePath = path.parse, SEP = path.sep, origParser = parsePath, origSep = SEP;
+    var path = __require("path");
+    var parsePath = path.parse;
+    var SEP = path.sep;
+    var origParser = parsePath;
+    var origSep = SEP;
     function makeRelativeNormalizedPath(str, sep) {
-      let parsed = parsePath(str), root = parsed.root, dir, file = parsed.base, quoted, pos;
-      return sep === "\\" && (pos = root.indexOf(":\\"), pos >= 0 && (root = root.substring(0, pos + 2))), dir = parsed.dir.substring(root.length), str === "" ? [] : (sep !== "/" && (quoted = new RegExp(sep.replace(/\W/g, "\\$&"), "g"), dir = dir.replace(quoted, "/"), file = file.replace(quoted, "/")), dir !== "" ? dir = `${dir}/${file}` : dir = file, dir.substring(0, 1) === "/" && (dir = dir.substring(1)), dir = dir.split(/\/+/), dir);
+      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;
     }
+    __name(makeRelativeNormalizedPath, "makeRelativeNormalizedPath");
     var Path = class _Path {
+      static {
+        __name(this, "Path");
+      }
       constructor(strOrArray) {
-        if (Array.isArray(strOrArray))
+        if (Array.isArray(strOrArray)) {
           this.v = strOrArray;
-        else if (typeof strOrArray == "string")
+        } else if (typeof strOrArray === "string") {
           this.v = makeRelativeNormalizedPath(strOrArray, SEP);
-        else
+        } else {
           throw new Error(
             `Invalid Path argument must be string or array:${strOrArray}`
           );
+        }
       }
       toString() {
         return this.v.join("/");
@@ -968,10 +1357,12 @@ var require_path = __commonJS({
         return this.v.length > 0;
       }
       parent() {
-        if (!this.hasParent())
+        if (!this.hasParent()) {
           throw new Error("Unable to get parent for 0 elem path");
-        let p = this.v.slice();
-        return p.pop(), new _Path(p);
+        }
+        const p = this.v.slice();
+        p.pop();
+        return new _Path(p);
       }
       elements() {
         return this.v.slice();
@@ -981,12 +1372,15 @@ var require_path = __commonJS({
       }
       contains(other) {
         let i;
-        if (other.length > this.length)
-          return !1;
-        for (i = 0; i < other.length; i += 1)
-          if (this.v[i] !== other.v[i])
-            return !1;
-        return !0;
+        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;
@@ -995,18 +1389,29 @@ var require_path = __commonJS({
         return this.contains(other) && other.length !== this.length;
       }
       commonPrefixPath(other) {
-        let len = this.length > other.length ? other.length : this.length, i, ret = [];
-        for (i = 0; i < len && this.v[i] === other.v[i]; i += 1)
-          ret.push(this.v[i]);
+        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) {
-        let al = a.length, bl = b.length;
-        if (al < bl)
+        const al = a.length;
+        const bl = b.length;
+        if (al < bl) {
           return -1;
-        if (al > bl)
+        }
+        if (al > bl) {
           return 1;
-        let astr = a.toString(), bstr = b.toString();
+        }
+        const astr = a.toString();
+        const bstr = b.toString();
         return astr < bstr ? -1 : astr > bstr ? 1 : 0;
       }
     };
@@ -1018,7 +1423,7 @@ var require_path = __commonJS({
       });
     });
     Object.defineProperty(Path.prototype, "length", {
-      enumerable: !0,
+      enumerable: true,
       get() {
         return this.v.length;
       }
@@ -1026,10 +1431,12 @@ var require_path = __commonJS({
     module.exports = Path;
     Path.tester = {
       setParserAndSep(p, sep) {
-        parsePath = p, SEP = sep;
+        parsePath = p;
+        SEP = sep;
       },
       reset() {
-        parsePath = origParser, SEP = origSep;
+        parsePath = origParser;
+        SEP = origSep;
       }
     };
   }
@@ -1039,30 +1446,51 @@ var require_path = __commonJS({
 var require_summarizer_factory = __commonJS({
   "../../node_modules/istanbul-lib-report/lib/summarizer-factory.js"(exports, module) {
     "use strict";
-    var coverage = require_istanbul_lib_coverage(), Path = require_path(), { BaseNode, BaseTree } = require_tree(), ReportNode = class _ReportNode extends BaseNode {
+    var coverage = require_istanbul_lib_coverage();
+    var Path = require_path();
+    var { BaseNode, BaseTree } = require_tree();
+    var ReportNode = class _ReportNode extends BaseNode {
+      static {
+        __name(this, "ReportNode");
+      }
       constructor(path, fileCoverage) {
-        super(), this.path = path, this.parent = null, this.fileCoverage = fileCoverage, this.children = [];
+        super();
+        this.path = path;
+        this.parent = null;
+        this.fileCoverage = fileCoverage;
+        this.children = [];
       }
       static createRoot(children) {
-        let root = new _ReportNode(new Path([]));
-        return children.forEach((child) => {
+        const root = new _ReportNode(new Path([]));
+        children.forEach((child) => {
           root.addChild(child);
-        }), root;
+        });
+        return root;
       }
       addChild(child) {
-        child.parent = this, this.children.push(child);
+        child.parent = this;
+        this.children.push(child);
       }
       asRelative(p) {
-        return p.substring(0, 1) === "/" ? p.substring(1) : p;
+        if (p.substring(0, 1) === "/") {
+          return p.substring(1);
+        }
+        return p;
       }
       getQualifiedName() {
         return this.asRelative(this.path.toString());
       }
       getRelativeName() {
-        let parent = this.getParent(), myPath = this.path, relPath, i, parentPath = parent ? parent.path : new Path([]);
+        const parent = this.getParent();
+        const myPath = this.path;
+        let relPath;
+        let i;
+        const parentPath = parent ? parent.path : new Path([]);
         if (parentPath.ancestorOf(myPath)) {
-          for (relPath = new Path(myPath.elements()), i = 0; i < parentPath.length; i += 1)
+          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());
@@ -1080,30 +1508,49 @@ var require_summarizer_factory = __commonJS({
         return this.fileCoverage;
       }
       getCoverageSummary(filesOnly) {
-        let cacheProp = `c_${filesOnly ? "files" : "full"}`, summary;
-        if (Object.prototype.hasOwnProperty.call(this, cacheProp))
+        const cacheProp = `c_${filesOnly ? "files" : "full"}`;
+        let summary;
+        if (Object.prototype.hasOwnProperty.call(this, cacheProp)) {
           return this[cacheProp];
-        if (!this.isSummary())
+        }
+        if (!this.isSummary()) {
           summary = this.getFileCoverage().toSummary();
-        else {
+        } else {
           let count = 0;
-          summary = coverage.createCoverageSummary(), this.getChildren().forEach((child) => {
-            filesOnly && child.isSummary() || (count += 1, summary.merge(child.getCoverageSummary(filesOnly)));
-          }), count === 0 && filesOnly && (summary = null);
+          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;
+          }
         }
-        return this[cacheProp] = summary, summary;
+        this[cacheProp] = summary;
+        return summary;
+      }
+    };
+    var ReportTree = class extends BaseTree {
+      static {
+        __name(this, "ReportTree");
       }
-    }, ReportTree = class extends BaseTree {
       constructor(root, childPrefix) {
         super(root);
-        let maybePrefix = (node) => {
-          childPrefix && !node.isRoot() && node.path.unshift(childPrefix);
-        };
+        const maybePrefix = /* @__PURE__ */ __name((node) => {
+          if (childPrefix && !node.isRoot()) {
+            node.path.unshift(childPrefix);
+          }
+        }, "maybePrefix");
         this.visit({
           onDetail: maybePrefix,
           onSummary(node) {
-            maybePrefix(node), node.children.sort((a, b) => {
-              let astr = a.path.toString(), bstr = b.path.toString();
+            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
@@ -1119,79 +1566,132 @@ var require_summarizer_factory = __commonJS({
         paths[0] || new Path([])
       );
     }
+    __name(findCommonParent, "findCommonParent");
     function findOrCreateParent(parentPath, nodeMap, created = () => {
     }) {
       let parent = nodeMap[parentPath.toString()];
-      return parent || (parent = new ReportNode(parentPath), nodeMap[parentPath.toString()] = parent, created(parentPath, parent)), parent;
+      if (!parent) {
+        parent = new ReportNode(parentPath);
+        nodeMap[parentPath.toString()] = parent;
+        created(parentPath, parent);
+      }
+      return parent;
     }
+    __name(findOrCreateParent, "findOrCreateParent");
     function toDirParents(list) {
-      let nodeMap = /* @__PURE__ */ Object.create(null);
-      return list.forEach((o) => {
-        findOrCreateParent(o.path.parent(), nodeMap).addChild(new ReportNode(o.path, o.fileCoverage));
-      }), Object.values(nodeMap);
+      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);
     }
+    __name(toDirParents, "toDirParents");
     function addAllPaths(topPaths, nodeMap, path, node) {
-      findOrCreateParent(
+      const parent = findOrCreateParent(
         path.parent(),
         nodeMap,
         (parentPath, parent2) => {
-          parentPath.hasParent() ? addAllPaths(topPaths, nodeMap, parentPath, parent2) : topPaths.push(parent2);
+          if (parentPath.hasParent()) {
+            addAllPaths(topPaths, nodeMap, parentPath, parent2);
+          } else {
+            topPaths.push(parent2);
+          }
         }
-      ).addChild(node);
+      );
+      parent.addChild(node);
     }
+    __name(addAllPaths, "addAllPaths");
     function foldIntoOneDir(node, parent) {
-      let { children } = node;
-      return children.length === 1 && !children[0].fileCoverage ? (children[0].parent = parent, foldIntoOneDir(children[0], parent)) : (node.children = children.map((child) => foldIntoOneDir(child, node)), node);
+      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;
     }
+    __name(foldIntoOneDir, "foldIntoOneDir");
     function pkgSummaryPrefix(dirParents, commonParent) {
-      if (dirParents.some((dp) => dp.path.length === 0))
-        return commonParent.length === 0 ? "root" : commonParent.name();
+      if (!dirParents.some((dp) => dp.path.length === 0)) {
+        return;
+      }
+      if (commonParent.length === 0) {
+        return "root";
+      }
+      return commonParent.name();
     }
+    __name(pkgSummaryPrefix, "pkgSummaryPrefix");
     var SummarizerFactory = class {
+      static {
+        __name(this, "SummarizerFactory");
+      }
       constructor(coverageMap, defaultSummarizer = "pkg") {
-        this._coverageMap = coverageMap, this._defaultSummarizer = defaultSummarizer, this._initialList = coverageMap.files().map((filePath) => ({
+        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._commonParent = findCommonParent(
           this._initialList.map((o) => o.path.parent())
-        ), this._commonParent.length > 0 && this._initialList.forEach((o) => {
-          o.path.splice(0, this._commonParent.length);
-        });
+        );
+        if (this._commonParent.length > 0) {
+          this._initialList.forEach((o) => {
+            o.path.splice(0, this._commonParent.length);
+          });
+        }
       }
       get defaultSummarizer() {
         return this[this._defaultSummarizer];
       }
       get flat() {
-        return this._flat || (this._flat = new ReportTree(
-          ReportNode.createRoot(
-            this._initialList.map(
-              (node) => new ReportNode(node.path, node.fileCoverage)
+        if (!this._flat) {
+          this._flat = new ReportTree(
+            ReportNode.createRoot(
+              this._initialList.map(
+                (node) => new ReportNode(node.path, node.fileCoverage)
+              )
             )
-          )
-        )), this._flat;
+          );
+        }
+        return this._flat;
       }
       _createPkg() {
-        let dirParents = toDirParents(this._initialList);
-        return dirParents.length === 1 ? new ReportTree(dirParents[0]) : new ReportTree(
+        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() {
-        return this._pkg || (this._pkg = this._createPkg()), this._pkg;
+        if (!this._pkg) {
+          this._pkg = this._createPkg();
+        }
+        return this._pkg;
       }
       _createNested() {
-        let nodeMap = /* @__PURE__ */ Object.create(null), topPaths = [];
+        const nodeMap = /* @__PURE__ */ Object.create(null);
+        const topPaths = [];
         this._initialList.forEach((o) => {
-          let node = new ReportNode(o.path, o.fileCoverage);
+          const node = new ReportNode(o.path, o.fileCoverage);
           addAllPaths(topPaths, nodeMap, o.path, node);
         });
-        let topNodes = topPaths.map((node) => foldIntoOneDir(node));
-        return topNodes.length === 1 ? new ReportTree(topNodes[0]) : new ReportTree(ReportNode.createRoot(topNodes));
+        const topNodes = topPaths.map((node) => foldIntoOneDir(node));
+        if (topNodes.length === 1) {
+          return new ReportTree(topNodes[0]);
+        }
+        return new ReportTree(ReportNode.createRoot(topNodes));
       }
       get nested() {
-        return this._nested || (this._nested = this._createNested()), this._nested;
+        if (!this._nested) {
+          this._nested = this._createNested();
+        }
+        return this._nested;
       }
     };
     module.exports = SummarizerFactory;
@@ -1202,7 +1702,12 @@ var require_summarizer_factory = __commonJS({
 var require_context = __commonJS({
   "../../node_modules/istanbul-lib-report/lib/context.js"(exports, module) {
     "use strict";
-    var fs = __require("fs"), FileWriter = require_file_writer(), XMLWriter = require_xml_writer(), tree = require_tree(), watermarks = require_watermarks(), SummarizerFactory = require_summarizer_factory();
+    var fs = __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(path) {
       try {
         return fs.readFileSync(path, "utf8");
@@ -1210,18 +1715,30 @@ var require_context = __commonJS({
         throw new Error(`Unable to lookup source: ${path} (${ex.message})`);
       }
     }
+    __name(defaultSourceLookup, "defaultSourceLookup");
     function normalizeWatermarks(specified = {}) {
-      return Object.entries(watermarks.getDefault()).forEach(([k, value]) => {
-        let specValue = specified[k];
-        (!Array.isArray(specValue) || specValue.length !== 2) && (specified[k] = value);
-      }), specified;
+      Object.entries(watermarks.getDefault()).forEach(([k, value]) => {
+        const specValue = specified[k];
+        if (!Array.isArray(specValue) || specValue.length !== 2) {
+          specified[k] = value;
+        }
+      });
+      return specified;
     }
+    __name(normalizeWatermarks, "normalizeWatermarks");
     var Context = class {
+      static {
+        __name(this, "Context");
+      }
       constructor(opts) {
-        this.dir = opts.dir || "coverage", this.watermarks = normalizeWatermarks(opts.watermarks), this.sourceFinder = opts.sourceFinder || defaultSourceLookup, this._summarizerFactory = new SummarizerFactory(
+        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 = {};
+        );
+        this.data = {};
       }
       /**
        * returns a FileWriter implementation for reporting use. Also available
@@ -1249,8 +1766,17 @@ var require_context = __commonJS({
        * @returns {String} one of `high`, `medium` or `low`
        */
       classForPercent(type, value) {
-        let watermarks2 = this.watermarks[type];
-        return watermarks2 ? value < watermarks2[0] ? "low" : value >= watermarks2[1] ? "high" : "medium" : "unknown";
+        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
@@ -1276,9 +1802,12 @@ var require_context = __commonJS({
       }
     };
     Object.defineProperty(Context.prototype, "writer", {
-      enumerable: !0,
+      enumerable: true,
       get() {
-        return this.data.writer || (this.data.writer = new FileWriter(this.dir)), this.data.writer;
+        if (!this.data.writer) {
+          this.data.writer = new FileWriter(this.dir);
+        }
+        return this.data.writer;
       }
     });
     module.exports = Context;
@@ -1289,7 +1818,11 @@ var require_context = __commonJS({
 var require_report_base = __commonJS({
   "../../node_modules/istanbul-lib-report/lib/report-base.js"(exports, module) {
     "use strict";
-    var _summarizer = Symbol("ReportBase.#summarizer"), ReportBase2 = class {
+    var _summarizer = Symbol("ReportBase.#summarizer");
+    var ReportBase2 = class {
+      static {
+        __name(this, "ReportBase");
+      }
       constructor(opts = {}) {
         this[_summarizer] = opts.summarizer;
       }
@@ -1305,7 +1838,9 @@ var require_report_base = __commonJS({
 var require_istanbul_lib_report = __commonJS({
   "../../node_modules/istanbul-lib-report/index.js"(exports, module) {
     "use strict";
-    var Context = require_context(), watermarks = require_watermarks(), ReportBase2 = require_report_base();
+    var Context = require_context();
+    var watermarks = require_watermarks();
+    var ReportBase2 = require_report_base();
     module.exports = {
       /**
        * returns a reporting context for the supplied options
@@ -1334,16 +1869,26 @@ var require_istanbul_lib_report = __commonJS({
 });
 
 // src/node/coverage-reporter.ts
-var import_istanbul_lib_report = __toESM(require_istanbul_lib_report(), 1), StorybookCoverageReporter = class extends import_istanbul_lib_report.ReportBase {
+var import_istanbul_lib_report = __toESM(require_istanbul_lib_report(), 1);
+var StorybookCoverageReporter = class extends import_istanbul_lib_report.ReportBase {
+  static {
+    __name(this, "StorybookCoverageReporter");
+  }
   #testManager;
   #coverageOptions;
   constructor(opts) {
-    super(), this.#testManager = opts.testManager, this.#coverageOptions = opts.coverageOptions;
+    super();
+    this.#testManager = opts.testManager;
+    this.#coverageOptions = opts.coverageOptions;
   }
   onSummary(node) {
-    if (!node.isRoot())
+    if (!node.isRoot()) {
       return;
-    let rawCoverageSummary = node.getCoverageSummary(!1), percentage = Math.round(rawCoverageSummary.data.statements.pct), [lowWatermark = 50, highWatermark = 80] = this.#coverageOptions?.watermarks?.statements ?? [], coverageSummary = {
+    }
+    const rawCoverageSummary = node.getCoverageSummary(false);
+    const percentage = Math.round(rawCoverageSummary.data.statements.pct);
+    const [lowWatermark = 50, highWatermark = 80] = this.#coverageOptions?.watermarks?.statements ?? [];
+    const coverageSummary = {
       percentage,
       status: percentage < lowWatermark ? "negative" : percentage < highWatermark ? "warning" : "positive"
     };