@rstest/core 0.9.1 → 0.9.3

package/dist/{0~7583.js → 0~chokidar.js}

@@ -1,12 +1,11 @@
-/*! For license information please see 0~7583.js.LICENSE.txt */
+/*! LICENSE: 0~chokidar.js.LICENSE.txt */
 import "node:module";
-import { __webpack_require__ } from "./rslib-runtime.js";
-import { lstat, open as promises_open, readdir, realpath as promises_realpath, stat as promises_stat } from "fs/promises";
-import { EventEmitter } from "events";
+import { EventEmitter } from "node:events";
+import { stat as external_node_fs_stat, unwatchFile, watch, watchFile } from "node:fs";
+import { lstat, open as promises_open, readdir, realpath as promises_realpath, stat as promises_stat } from "node:fs/promises";
+import { basename as external_node_path_basename, dirname as external_node_path_dirname, extname, isAbsolute, join, normalize, relative as external_node_path_relative, resolve as external_node_path_resolve, sep } from "node:path";
 import { Readable } from "node:stream";
-import "./3160.js";
-import { readdir as promises_readdir, lstat as promises_lstat, promises_stat as promises_promises_stat, realpath as external_node_fs_promises_realpath } from "./1157.js";
-const external_node_path_ = __webpack_require__("path");
+import { type as external_node_os_type } from "node:os";
 const EntryTypes = {
     FILE_TYPE: 'files',
     DIR_TYPE: 'directories',
@@ -65,6 +64,20 @@ const normalizeFilter = (filter)=>{
     return emptyFn;
 };
 class ReaddirpStream extends Readable {
+    parents;
+    reading;
+    parent;
+    _stat;
+    _maxDepth;
+    _wantsDir;
+    _wantsFile;
+    _wantsEverything;
+    _root;
+    _isDirent;
+    _statsProp;
+    _rdOptions;
+    _fileFilter;
+    _directoryFilter;
     constructor(options = {}){
         super({
             objectMode: true,
@@ -78,16 +91,16 @@ class ReaddirpStream extends Readable {
         const { root, type } = opts;
         this._fileFilter = normalizeFilter(opts.fileFilter);
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
-        const statMethod = opts.lstat ? promises_lstat : promises_promises_stat;
+        const statMethod = opts.lstat ? lstat : promises_stat;
         if (wantBigintFsStats) this._stat = (path)=>statMethod(path, {
                 bigint: true
             });
         else this._stat = statMethod;
-        this._maxDepth = opts.depth ?? defaultOptions.depth;
+        this._maxDepth = null != opts.depth && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
         this._wantsDir = type ? DIR_TYPES.has(type) : false;
         this._wantsFile = type ? FILE_TYPES.has(type) : false;
         this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
-        this._root = (0, external_node_path_.resolve)(root);
+        this._root = external_node_path_resolve(root);
         this._isDirent = !opts.alwaysStat;
         this._statsProp = this._isDirent ? 'dirent' : 'stats';
         this._rdOptions = {
@@ -147,7 +160,7 @@ class ReaddirpStream extends Readable {
     async _exploreDir(path, depth) {
         let files;
         try {
-            files = await promises_readdir(path, this._rdOptions);
+            files = await readdir(path, this._rdOptions);
         } catch (error) {
             this._onError(error);
         }
@@ -161,9 +174,9 @@ class ReaddirpStream extends Readable {
         let entry;
         const basename = this._isDirent ? dirent.name : dirent;
         try {
-            const fullPath = (0, external_node_path_.resolve)((0, external_node_path_.join)(path, basename));
+            const fullPath = external_node_path_resolve(join(path, basename));
             entry = {
-                path: (0, external_node_path_.relative)(this._root, fullPath),
+                path: external_node_path_relative(this._root, fullPath),
                 fullPath,
                 basename
             };
@@ -186,12 +199,12 @@ class ReaddirpStream extends Readable {
         if (stats && stats.isSymbolicLink()) {
             const full = entry.fullPath;
             try {
-                const entryRealPath = await external_node_fs_promises_realpath(full);
-                const entryRealPathStats = await promises_lstat(entryRealPath);
+                const entryRealPath = await promises_realpath(full);
+                const entryRealPathStats = await lstat(entryRealPath);
                 if (entryRealPathStats.isFile()) return 'file';
                 if (entryRealPathStats.isDirectory()) {
                     const len = entryRealPath.length;
-                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === external_node_path_.sep) {
+                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === sep) {
                         const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
                         recursiveError.code = RECURSIVE_ERROR_CODE;
                         return this._onError(recursiveError);
@@ -220,8 +233,6 @@ function readdirp(root, options = {}) {
     options.root = root;
     return new ReaddirpStream(options);
 }
-const external_node_fs_ = __webpack_require__("node:fs");
-const external_node_os_ = __webpack_require__("node:os");
 const STR_DATA = 'data';
 const STR_END = 'end';
 const STR_CLOSE = 'close';
@@ -231,7 +242,7 @@ const isWindows = 'win32' === pl;
 const isMacos = 'darwin' === pl;
 const isLinux = 'linux' === pl;
 const isFreeBSD = 'freebsd' === pl;
-const isIBMi = 'OS400' === (0, external_node_os_.type)();
+const isIBMi = 'OS400' === external_node_os_type();
 const EVENTS = {
     ALL: 'all',
     READY: 'ready',
@@ -520,7 +531,7 @@ const binaryExtensions = new Set([
     'zip',
     'zipx'
 ]);
-const isBinaryPath = (filePath)=>binaryExtensions.has(external_node_path_.extname(filePath).slice(1).toLowerCase());
+const isBinaryPath = (filePath)=>binaryExtensions.has(extname(filePath).slice(1).toLowerCase());
 const foreach = (val, fn)=>{
     if (val instanceof Set) val.forEach(fn);
     else fn(val);
@@ -550,10 +561,10 @@ function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
         emitRaw(rawEvent, evPath, {
             watchedPath: path
         });
-        if (evPath && path !== evPath) fsWatchBroadcast(external_node_path_.resolve(path, evPath), KEY_LISTENERS, external_node_path_.join(path, evPath));
+        if (evPath && path !== evPath) fsWatchBroadcast(external_node_path_resolve(path, evPath), KEY_LISTENERS, join(path, evPath));
     };
     try {
-        return (0, external_node_fs_.watch)(path, {
+        return watch(path, {
             persistent: options.persistent
         }, handleEvent);
     } catch (error) {
@@ -621,7 +632,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers)=>{
     let cont = FsWatchFileInstances.get(fullPath);
     const copts = cont && cont.options;
     if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-        (0, external_node_fs_.unwatchFile)(fullPath);
+        unwatchFile(fullPath);
         cont = void 0;
     }
     if (cont) {
@@ -632,7 +643,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers)=>{
             listeners: listener,
             rawEmitters: rawEmitter,
             options,
-            watcher: (0, external_node_fs_.watchFile)(fullPath, options, (curr, prev)=>{
+            watcher: watchFile(fullPath, options, (curr, prev)=>{
                 foreach(cont.rawEmitters, (rawEmitter)=>{
                     rawEmitter(EV.CHANGE, fullPath, {
                         curr,
@@ -650,24 +661,26 @@ const setFsWatchFileListener = (path, fullPath, options, handlers)=>{
         delFromSet(cont, KEY_RAW, rawEmitter);
         if (isEmptySet(cont.listeners)) {
             FsWatchFileInstances.delete(fullPath);
-            (0, external_node_fs_.unwatchFile)(fullPath);
+            unwatchFile(fullPath);
             cont.options = cont.watcher = void 0;
             Object.freeze(cont);
         }
     };
 };
 class NodeFsHandler {
+    fsw;
+    _boundHandleError;
     constructor(fsW){
         this.fsw = fsW;
         this._boundHandleError = (error)=>fsW._handleError(error);
     }
     _watchWithNodeFs(path, listener) {
         const opts = this.fsw.options;
-        const directory = external_node_path_.dirname(path);
-        const basename = external_node_path_.basename(path);
+        const directory = external_node_path_dirname(path);
+        const basename = external_node_path_basename(path);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename);
-        const absolutePath = external_node_path_.resolve(path);
+        const absolutePath = external_node_path_resolve(path);
         const options = {
             persistent: opts.persistent
         };
@@ -689,8 +702,8 @@ class NodeFsHandler {
     }
     _handleFile(file, stats, initialAdd) {
         if (this.fsw.closed) return;
-        const dirname = external_node_path_.dirname(file);
-        const basename = external_node_path_.basename(file);
+        const dirname = external_node_path_dirname(file);
+        const basename = external_node_path_basename(file);
         const parent = this.fsw._getWatchedDir(dirname);
         let prevStats = stats;
         if (parent.has(basename)) return;
@@ -757,8 +770,9 @@ class NodeFsHandler {
         this.fsw._symlinkPaths.set(full, true);
     }
     _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
-        directory = external_node_path_.join(directory, '');
-        throttler = this.fsw._throttle('readdir', directory, 1000);
+        directory = join(directory, '');
+        const throttleKey = target ? `${directory}:${target}` : directory;
+        throttler = this.fsw._throttle('readdir', throttleKey, 1000);
         if (!throttler) return;
         const previous = this.fsw._getWatchedDir(wh.path);
         const current = new Set();
@@ -773,7 +787,7 @@ class NodeFsHandler {
                 return;
             }
             const item = entry.path;
-            let path = external_node_path_.join(directory, item);
+            let path = join(directory, item);
             current.add(item);
             if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) return;
             if (this.fsw.closed) {
@@ -782,7 +796,7 @@ class NodeFsHandler {
             }
             if (item === target || !target && !previous.has(item)) {
                 this.fsw._incrReadyCount();
-                path = external_node_path_.join(dir, external_node_path_.relative(dir, path));
+                path = join(dir, external_node_path_relative(dir, path));
                 this._addToNodeFs(path, initialAdd, wh, depth + 1);
             }
         }).on(EV.ERROR, this._boundHandleError);
@@ -804,10 +818,10 @@ class NodeFsHandler {
         });
     }
     async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
-        const parentDir = this.fsw._getWatchedDir(external_node_path_.dirname(dir));
-        const tracked = parentDir.has(external_node_path_.basename(dir));
+        const parentDir = this.fsw._getWatchedDir(external_node_path_dirname(dir));
+        const tracked = parentDir.has(external_node_path_basename(dir));
         if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) this.fsw._emit(EV.ADD_DIR, dir, stats);
-        parentDir.add(external_node_path_.basename(dir));
+        parentDir.add(external_node_path_basename(dir));
         this.fsw._getWatchedDir(dir);
         let throttler;
         let closer;
@@ -845,7 +859,7 @@ class NodeFsHandler {
             const follow = this.fsw.options.followSymlinks;
             let closer;
             if (stats.isDirectory()) {
-                const absPath = external_node_path_.resolve(path);
+                const absPath = external_node_path_resolve(path);
                 const targetPath = follow ? await promises_realpath(path) : path;
                 if (this.fsw.closed) return;
                 closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -854,12 +868,12 @@ class NodeFsHandler {
             } else if (stats.isSymbolicLink()) {
                 const targetPath = follow ? await promises_realpath(path) : path;
                 if (this.fsw.closed) return;
-                const parent = external_node_path_.dirname(wh.watchPath);
+                const parent = external_node_path_dirname(wh.watchPath);
                 this.fsw._getWatchedDir(parent).add(wh.watchPath);
                 this.fsw._emit(EV.ADD, wh.watchPath, stats);
                 closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
                 if (this.fsw.closed) return;
-                if (void 0 !== targetPath) this.fsw._symlinkPaths.set(external_node_path_.resolve(path), targetPath);
+                if (void 0 !== targetPath) this.fsw._symlinkPaths.set(external_node_path_resolve(path), targetPath);
             } else closer = this._handleFile(wh.watchPath, stats, initialAdd);
             ready();
             if (closer) this.fsw._addPathCloser(path, closer);
@@ -878,7 +892,7 @@ const ONE_DOT = '.';
 const TWO_DOTS = '..';
 const STRING_TYPE = 'string';
 const BACK_SLASH_RE = /\\/g;
-const esm_DOUBLE_SLASH_RE = /\/\//;
+const DOUBLE_SLASH_RE = /\/\//g;
 const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
 const REPLACER_RE = /^\.[/\\]/;
 function arrify(item) {
@@ -894,9 +908,9 @@ function createPattern(matcher) {
     if ('object' == typeof matcher && null !== matcher) return (string)=>{
         if (matcher.path === string) return true;
         if (matcher.recursive) {
-            const relative = external_node_path_.relative(matcher.path, string);
+            const relative = external_node_path_relative(matcher.path, string);
             if (!relative) return false;
-            return !relative.startsWith('..') && !external_node_path_.isAbsolute(relative);
+            return !relative.startsWith('..') && !isAbsolute(relative);
         }
         return false;
     };
@@ -904,12 +918,11 @@ function createPattern(matcher) {
 }
 function normalizePath(path) {
     if ('string' != typeof path) throw new Error('string expected');
-    path = external_node_path_.normalize(path);
+    path = normalize(path);
     path = path.replace(/\\/g, '/');
     let prepend = false;
     if (path.startsWith('//')) prepend = true;
-    const DOUBLE_SLASH_RE = /\/\//;
-    while(path.match(DOUBLE_SLASH_RE))path = path.replace(DOUBLE_SLASH_RE, '/');
+    path = path.replace(DOUBLE_SLASH_RE, '/');
     if (prepend) path = '/' + path;
     return path;
 }
@@ -937,21 +950,24 @@ const toUnix = (string)=>{
     let str = string.replace(BACK_SLASH_RE, SLASH);
     let prepend = false;
     if (str.startsWith(SLASH_SLASH)) prepend = true;
-    while(str.match(esm_DOUBLE_SLASH_RE))str = str.replace(esm_DOUBLE_SLASH_RE, SLASH);
+    str = str.replace(DOUBLE_SLASH_RE, SLASH);
     if (prepend) str = SLASH + str;
     return str;
 };
-const normalizePathToUnix = (path)=>toUnix(external_node_path_.normalize(toUnix(path)));
+const normalizePathToUnix = (path)=>toUnix(normalize(toUnix(path)));
 const normalizeIgnored = (cwd = '')=>(path)=>{
-        if ('string' == typeof path) return normalizePathToUnix(external_node_path_.isAbsolute(path) ? path : external_node_path_.join(cwd, path));
+        if ('string' == typeof path) return normalizePathToUnix(isAbsolute(path) ? path : join(cwd, path));
         return path;
     };
 const getAbsolutePath = (path, cwd)=>{
-    if (external_node_path_.isAbsolute(path)) return path;
-    return external_node_path_.join(cwd, path);
+    if (isAbsolute(path)) return path;
+    return join(cwd, path);
 };
 const EMPTY_SET = Object.freeze(new Set());
 class DirEntry {
+    path;
+    _removeWatcher;
+    items;
     constructor(dir, removeWatcher){
         this.path = dir;
         this._removeWatcher = removeWatcher;
@@ -971,7 +987,7 @@ class DirEntry {
         try {
             await readdir(dir);
         } catch (err) {
-            if (this._removeWatcher) this._removeWatcher(external_node_path_.dirname(dir), external_node_path_.basename(dir));
+            if (this._removeWatcher) this._removeWatcher(external_node_path_dirname(dir), external_node_path_basename(dir));
         }
     }
     has(item) {
@@ -997,12 +1013,19 @@ class DirEntry {
 const STAT_METHOD_F = 'stat';
 const STAT_METHOD_L = 'lstat';
 class WatchHelper {
+    fsw;
+    path;
+    watchPath;
+    fullWatchPath;
+    dirParts;
+    followSymlinks;
+    statMethod;
     constructor(path, follow, fsw){
         this.fsw = fsw;
         const watchPath = path;
         this.path = path = path.replace(REPLACER_RE, '');
         this.watchPath = watchPath;
-        this.fullWatchPath = external_node_path_.resolve(watchPath);
+        this.fullWatchPath = external_node_path_resolve(watchPath);
         this.dirParts = [];
         this.dirParts.forEach((parts)=>{
             if (parts.length > 1) parts.pop();
@@ -1011,7 +1034,7 @@ class WatchHelper {
         this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
     }
     entryPath(entry) {
-        return external_node_path_.join(this.watchPath, external_node_path_.relative(this.watchPath, entry.fullPath));
+        return join(this.watchPath, external_node_path_relative(this.watchPath, entry.fullPath));
     }
     filterPath(entry) {
         const { stats } = entry;
@@ -1024,6 +1047,24 @@ class WatchHelper {
     }
 }
 class FSWatcher extends EventEmitter {
+    closed;
+    options;
+    _closers;
+    _ignoredPaths;
+    _throttled;
+    _streams;
+    _symlinkPaths;
+    _watched;
+    _pendingWrites;
+    _pendingUnlinks;
+    _readyCount;
+    _emitReady;
+    _closePromise;
+    _userIgnored;
+    _readyEmitted;
+    _emitRaw;
+    _boundRemove;
+    _nodeFsHandler;
     constructor(_opts = {}){
         super();
         this.closed = false;
@@ -1118,7 +1159,7 @@ class FSWatcher extends EventEmitter {
         })).then((results)=>{
             if (this.closed) return;
             results.forEach((item)=>{
-                if (item) this.add(external_node_path_.dirname(item), external_node_path_.basename(_origAdd || item));
+                if (item) this.add(external_node_path_dirname(item), external_node_path_basename(_origAdd || item));
             });
         });
         return this;
@@ -1128,9 +1169,9 @@ class FSWatcher extends EventEmitter {
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
         paths.forEach((path)=>{
-            if (!external_node_path_.isAbsolute(path) && !this._closers.has(path)) {
-                if (cwd) path = external_node_path_.join(cwd, path);
-                path = external_node_path_.resolve(path);
+            if (!isAbsolute(path) && !this._closers.has(path)) {
+                if (cwd) path = join(cwd, path);
+                path = external_node_path_resolve(path);
             }
             this._closePath(path);
             this._addIgnoredPath(path);
@@ -1167,7 +1208,7 @@ class FSWatcher extends EventEmitter {
     getWatched() {
         const watchList = {};
         this._watched.forEach((entry, dir)=>{
-            const key = this.options.cwd ? external_node_path_.relative(this.options.cwd, dir) : dir;
+            const key = this.options.cwd ? external_node_path_relative(this.options.cwd, dir) : dir;
             const index = key || ONE_DOT;
             watchList[index] = entry.getChildren().sort();
         });
@@ -1180,8 +1221,8 @@ class FSWatcher extends EventEmitter {
     async _emit(event, path, stats) {
         if (this.closed) return;
         const opts = this.options;
-        if (isWindows) path = external_node_path_.normalize(path);
-        if (opts.cwd) path = external_node_path_.relative(opts.cwd, path);
+        if (isWindows) path = normalize(path);
+        if (opts.cwd) path = external_node_path_relative(opts.cwd, path);
         const args = [
             path
         ];
@@ -1232,7 +1273,7 @@ class FSWatcher extends EventEmitter {
             if (isThrottled) return this;
         }
         if (opts.alwaysStat && void 0 === stats && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-            const fullPath = opts.cwd ? external_node_path_.join(opts.cwd, path) : path;
+            const fullPath = opts.cwd ? join(opts.cwd, path) : path;
             let stats;
             try {
                 stats = await promises_stat(fullPath);
@@ -1284,11 +1325,11 @@ class FSWatcher extends EventEmitter {
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
         let fullPath = path;
-        if (this.options.cwd && !external_node_path_.isAbsolute(path)) fullPath = external_node_path_.join(this.options.cwd, path);
+        if (this.options.cwd && !isAbsolute(path)) fullPath = join(this.options.cwd, path);
         const now = new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
-            (0, external_node_fs_.stat)(fullPath, (err, curStat)=>{
+            external_node_fs_stat(fullPath, (err, curStat)=>{
                 if (err || !writes.has(path)) {
                     if (err && 'ENOENT' !== err.code) awfEmit(err);
                     return;
@@ -1339,7 +1380,7 @@ class FSWatcher extends EventEmitter {
         return new WatchHelper(path, this.options.followSymlinks, this);
     }
     _getWatchedDir(directory) {
-        const dir = external_node_path_.resolve(directory);
+        const dir = external_node_path_resolve(directory);
         if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
         return this._watched.get(dir);
     }
@@ -1348,8 +1389,8 @@ class FSWatcher extends EventEmitter {
         return Boolean(256 & Number(stats.mode));
     }
     _remove(directory, item, isDirectory) {
-        const path = external_node_path_.join(directory, item);
-        const fullPath = external_node_path_.resolve(path);
+        const path = join(directory, item);
+        const fullPath = external_node_path_resolve(path);
         isDirectory = null != isDirectory ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
         if (!this._throttle('remove', path, 100)) return;
         if (!isDirectory && 1 === this._watched.size) this.add(directory, item, true);
@@ -1361,7 +1402,7 @@ class FSWatcher extends EventEmitter {
         parent.remove(item);
         if (this._symlinkPaths.has(fullPath)) this._symlinkPaths.delete(fullPath);
         let relPath = path;
-        if (this.options.cwd) relPath = external_node_path_.relative(this.options.cwd, path);
+        if (this.options.cwd) relPath = external_node_path_relative(this.options.cwd, path);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
             const event = this._pendingWrites.get(relPath).cancelWait();
             if (event === EVENTS.ADD) return;
@@ -1374,8 +1415,8 @@ class FSWatcher extends EventEmitter {
     }
     _closePath(path) {
         this._closeFile(path);
-        const dir = external_node_path_.dirname(path);
-        this._getWatchedDir(dir).remove(external_node_path_.basename(path));
+        const dir = external_node_path_dirname(path);
+        this._getWatchedDir(dir).remove(external_node_path_basename(path));
     }
     _closeFile(path) {
         const closers = this._closers.get(path);
@@ -1415,9 +1456,9 @@ class FSWatcher extends EventEmitter {
         return stream;
     }
 }
-function watch(paths, options = {}) {
+function chokidar_watch(paths, options = {}) {
     const watcher = new FSWatcher(options);
     watcher.add(paths);
     return watcher;
 }
-export { watch };
+export { chokidar_watch as watch };

package/dist/{0~130.js → 0~console.js}

@@ -1,9 +1,8 @@
 import "node:module";
-import { __webpack_require__ } from "./rslib-runtime.js";
 import { AssertionError, strict } from "node:assert";
 import { Console } from "node:console";
-import { prettyTime, color } from "./3160.js";
-const external_node_util_ = __webpack_require__("node:util");
+import { format, formatWithOptions, inspect } from "node:util";
+import { prettyTime, color as logger_color } from "./6830.js";
 const RealDate = Date;
 function createCustomConsole({ rpc, testPath, printConsoleTrace }) {
     const getConsoleTrace = ()=>{
@@ -22,13 +21,13 @@ function createCustomConsole({ rpc, testPath, printConsoleTrace }) {
         getPrettyName(type) {
             switch(type){
                 case 'error':
-                    return color.red(type);
+                    return logger_color.red(type);
                 case 'warn':
-                    return color.yellow(type);
+                    return logger_color.yellow(type);
                 case 'info':
-                    return color.cyan(type);
+                    return logger_color.cyan(type);
                 default:
-                    return color.gray(type);
+                    return logger_color.gray(type);
             }
         }
         _log(name, message, type = 'stdout') {
@@ -50,40 +49,40 @@ function createCustomConsole({ rpc, testPath, printConsoleTrace }) {
         }
         count(label = 'default') {
             if (!this._counters[label]) this._counters[label] = 0;
-            this._log('count', (0, external_node_util_.format)(`${label}: ${++this._counters[label]}`));
+            this._log('count', format(`${label}: ${++this._counters[label]}`));
         }
         countReset(label = 'default') {
             this._counters[label] = 0;
         }
         debug(firstArg, ...args) {
-            this._log('debug', (0, external_node_util_.format)(firstArg, ...args));
+            this._log('debug', format(firstArg, ...args));
         }
         dir(firstArg, options = {}) {
-            const representation = (0, external_node_util_.inspect)(firstArg, options);
-            this._log('dir', (0, external_node_util_.formatWithOptions)(options, representation));
+            const representation = inspect(firstArg, options);
+            this._log('dir', formatWithOptions(options, representation));
         }
         dirxml(firstArg, ...args) {
-            this._log('dirxml', (0, external_node_util_.format)(firstArg, ...args));
+            this._log('dirxml', format(firstArg, ...args));
         }
         error(firstArg, ...args) {
-            this._log('error', (0, external_node_util_.format)(firstArg, ...args), 'stderr');
+            this._log('error', format(firstArg, ...args), 'stderr');
         }
         group(title, ...args) {
             this._groupDepth++;
-            if (null != title || args.length > 0) this._log('group', color.bold((0, external_node_util_.format)(title, ...args)));
+            if (null != title || args.length > 0) this._log('group', logger_color.bold(format(title, ...args)));
         }
         groupCollapsed(title, ...args) {
             this._groupDepth++;
-            if (null != title || args.length > 0) this._log('groupCollapsed', color.bold((0, external_node_util_.format)(title, ...args)));
+            if (null != title || args.length > 0) this._log('groupCollapsed', logger_color.bold(format(title, ...args)));
         }
         groupEnd() {
             if (this._groupDepth > 0) this._groupDepth--;
         }
         info(firstArg, ...args) {
-            this._log('info', (0, external_node_util_.format)(firstArg, ...args));
+            this._log('info', format(firstArg, ...args));
         }
         log(firstArg, ...args) {
-            this._log('log', (0, external_node_util_.format)(firstArg, ...args));
+            this._log('log', format(firstArg, ...args));
         }
         time(label = 'default') {
             if (null != this._timers[label]) return;
@@ -94,7 +93,7 @@ function createCustomConsole({ rpc, testPath, printConsoleTrace }) {
             if (null != startTime) {
                 const endTime = RealDate.now();
                 const time = endTime - startTime.getTime();
-                this._log('time', (0, external_node_util_.format)(`${label}: ${prettyTime(time)}`));
+                this._log('time', format(`${label}: ${prettyTime(time)}`));
                 delete this._timers[label];
             }
         }
@@ -103,11 +102,11 @@ function createCustomConsole({ rpc, testPath, printConsoleTrace }) {
             if (null != startTime) {
                 const endTime = new RealDate();
                 const time = endTime.getTime() - startTime.getTime();
-                this._log('time', (0, external_node_util_.format)(`${label}: ${prettyTime(time)}`, ...data));
+                this._log('time', format(`${label}: ${prettyTime(time)}`, ...data));
             }
         }
         warn(firstArg, ...args) {
-            this._log('warn', (0, external_node_util_.format)(firstArg, ...args), 'stderr');
+            this._log('warn', format(firstArg, ...args), 'stderr');
         }
         getBuffer() {}
     }