@brillout/test-e2e 0.5.29 → 0.5.30

package/dist/utils/findFiles.js

@@ -1,35 +1,30 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterFiles = exports.findFilesParseCliArgs = exports.findFiles = void 0;
-const fast_glob_1 = __importDefault(require("fast-glob"));
-const path_1 = __importDefault(require("path"));
-const runCommandShortLived_1 = require("./runCommandShortLived");
+export { findFiles };
+export { findFilesParseCliArgs };
+export { filterFiles };
+import glob from 'fast-glob';
+import path from 'path';
+import { runCommandShortLived } from './runCommandShortLived.js';
 const cwd = process.cwd();
 let gitFiles;
 async function findFiles(pattern) {
-    let files = (await (0, fast_glob_1.default)([pattern], { ignore: ['**/node_modules/**', '**/.git/**'], cwd, dot: true })).map((filePathRelative) => path_1.default.join(cwd, filePathRelative));
+    let files = (await glob([pattern], { ignore: ['**/node_modules/**', '**/.git/**'], cwd, dot: true })).map((filePathRelative) => path.join(cwd, filePathRelative));
     files = await filterGitIgnoredFiles(files);
     return files;
 }
-exports.findFiles = findFiles;
 function filterFiles(files, findFilter) {
     return files
-        .map((p) => path_1.default.relative(cwd, p))
+        .map((p) => path.relative(cwd, p))
         .filter((filePathRelative) => applyFilter(filePathRelative, findFilter))
-        .map((p) => path_1.default.join(cwd, p));
+        .map((p) => path.join(cwd, p));
 }
-exports.filterFiles = filterFiles;
 async function filterGitIgnoredFiles(files) {
     if (!gitFiles) {
-        const stdout1 = await (0, runCommandShortLived_1.runCommandShortLived)('git ls-files', { cwd });
+        const stdout1 = await runCommandShortLived('git ls-files', { cwd });
         // Also include untracked files.
         //  - In other words, we remove git ignored files. (Staged files are tracked and listed by `$ git ls-files`.)
         //  - `git ls-files --others --exclude-standard` from https://stackoverflow.com/questions/3801321/git-list-only-untracked-files-also-custom-commands/3801554#3801554
-        const stdout2 = await (0, runCommandShortLived_1.runCommandShortLived)('git ls-files --others --exclude-standard', { cwd });
-        gitFiles = [...stdout1.split('\n'), ...stdout2.split('\n')].map((filePathRelative) => path_1.default.join(cwd, filePathRelative));
+        const stdout2 = await runCommandShortLived('git ls-files --others --exclude-standard', { cwd });
+        gitFiles = [...stdout1.split('\n'), ...stdout2.split('\n')].map((filePathRelative) => path.join(cwd, filePathRelative));
     }
     const filesFiltered = files.filter((file) => gitFiles.includes(file));
     return filesFiltered;
@@ -55,7 +50,7 @@ function matches(str, chunk) {
     return str.includes(chunk);
 }
 function normalize(p) {
-    return path_1.default.normalize(p);
+    return path.normalize(p);
 }
 function findFilesParseCliArgs() {
     const terms = [];
@@ -76,4 +71,3 @@ function findFilesParseCliArgs() {
         };
     return filter;
 }
-exports.findFilesParseCliArgs = findFilesParseCliArgs;

package/dist/utils/fsWindowsBugWorkaround.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fsWindowsBugWorkaroundPrefix = exports.fsWindowsBugWorkaround = void 0;
+export { fsWindowsBugWorkaround };
+export { fsWindowsBugWorkaroundPrefix };
 const fsWindowsBugWorkaroundPrefix = 'file://';
-exports.fsWindowsBugWorkaroundPrefix = fsWindowsBugWorkaroundPrefix;
 // https://stackoverflow.com/questions/69665780/error-err-unsupported-esm-url-scheme-only-file-and-data-urls-are-supported-by/70057245#70057245
 function fsWindowsBugWorkaround(testFileJs) {
     return `${fsWindowsBugWorkaroundPrefix}${testFileJs}`;
 }
-exports.fsWindowsBugWorkaround = fsWindowsBugWorkaround;

package/dist/utils/genPromise.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.genPromise = void 0;
-function genPromise() {
+export function genPromise() {
     let resolve;
     let reject;
     const promise = new Promise((resolve_, reject_) => {
@@ -10,4 +7,3 @@ function genPromise() {
     });
     return { promise, resolve, reject };
 }
-exports.genPromise = genPromise;

package/dist/utils/hasProp.d.ts

@@ -0,0 +1,15 @@
+export { hasProp };
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'boolean'): obj is ObjectType & Record<PropName, boolean>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'number'): obj is ObjectType & Record<PropName, number>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'string'): obj is ObjectType & Record<PropName, string>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'object'): obj is ObjectType & Record<PropName, Record<string, unknown>>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'array'): obj is ObjectType & Record<PropName, unknown[]>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'string[]'): obj is ObjectType & Record<PropName, string[]>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'string{}'): obj is ObjectType & Record<PropName, Record<string, string>>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'function'): obj is ObjectType & Record<PropName, (...args: any[]) => unknown>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'undefined'): obj is ObjectType & Record<PropName, undefined>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'null'): obj is ObjectType & Record<PropName, null>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'true'): obj is ObjectType & Record<PropName, true>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'false'): obj is ObjectType & Record<PropName, false>;
+declare function hasProp<ObjectType, PropName extends PropertyKey, Enum>(obj: ObjectType, prop: PropName, type: Enum[]): obj is ObjectType & Record<PropName, Enum>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName): obj is ObjectType & Record<PropName, unknown>;

package/dist/utils/hasProp.js

@@ -0,0 +1,50 @@
+export { hasProp };
+// - https://2ality.com/2020/06/type-guards-assertion-functions-typescript.html
+// - https://www.typescriptlang.org/play?#code/GYVwdgxgLglg9mABDAzgFQJ4AcCmdgAUAbgIYA2IOAXIiWBgDSJTbWIDkARnHGTnewCUNUhRzIUibr35gA3AFgAUKEiwEEzLnzFylGnUbNWNdmBABbTjgBOQkXvGpE5q7cUrw0eElRa8hKL6tPRMLLimKFA2MGAA5vaIQU6SUTHxHqreGn6sOskGocYRHOAA1mBwAO5gickSiOWVNZle6r7oeYGOhUbhbGmxcYgAvKVgFdW1wlI8fHSIAN7KiMiExeIjW+OTNeyIgksrq4g2OFAgNkjRlMcAvsdnF1cb+EmOo9v9Hg9KyhAIKK0GhNKajRAAFgATMplCQUChbFACLltIQSEwzJZrHZBIJ-oCZAA6MhwOIEEj4v6eNQ+WgIpEEAFgAAmMHaIImzTAM3hiJsUEkzLZ7SOShOa0QTIQIp8hyelzAx1WUAAFjZqi4cFVEABRGwamwEdgAQQZArpADESDAyEJlHcgA
+import { isCallable } from './isCallable.js';
+import { isObject } from './isObject.js';
+import { isArrayOfStrings } from './isArrayOfStrings.js';
+import { isObjectOfStrings } from './isObjectOfStrings.js';
+import { isArray } from './isArray.js';
+function hasProp(obj, prop, type = 'unknown') {
+    if (!isObject(obj))
+        return false;
+    if (!(prop in obj)) {
+        return type === 'undefined';
+    }
+    if (type === 'unknown') {
+        return true;
+    }
+    const propValue = obj[prop];
+    if (type === 'array') {
+        return isArray(propValue);
+    }
+    if (type === 'object') {
+        return isObject(propValue);
+    }
+    if (type === 'string[]') {
+        return isArrayOfStrings(propValue);
+    }
+    if (type === 'string{}') {
+        return isObjectOfStrings(propValue);
+    }
+    if (type === 'function') {
+        return isCallable(propValue);
+    }
+    if (isArray(type)) {
+        return typeof propValue === 'string' && type.includes(propValue);
+    }
+    if (type === 'null') {
+        return propValue === null;
+    }
+    if (type === 'undefined') {
+        return propValue === undefined;
+    }
+    if (type === 'true') {
+        return propValue === true;
+    }
+    if (type === 'false') {
+        return propValue === false;
+    }
+    return typeof propValue === type;
+}

package/dist/utils/humanizeTime.js

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.humanizeTime = void 0;
+export { humanizeTime };
 function humanizeTime(milliseconds) {
     const seconds = milliseconds / 1000;
     if (seconds < 120) {
@@ -9,7 +7,6 @@ function humanizeTime(milliseconds) {
     const minutes = seconds / 60;
     return `${round(minutes)} minutes`;
 }
-exports.humanizeTime = humanizeTime;
 function round(n) {
     let rounded = n.toFixed(1);
     if (rounded.endsWith('.0'))

package/dist/utils/isArray.d.ts

@@ -0,0 +1 @@
+export declare function isArray(value: unknown): value is unknown[];

package/dist/utils/isArray.js

@@ -0,0 +1,4 @@
+// Typesafe Array.isArray() — asserting unknown[] instead of any[]
+export function isArray(value) {
+    return Array.isArray(value);
+}

package/dist/utils/isArrayOfStrings.d.ts

@@ -0,0 +1,2 @@
+export { isArrayOfStrings };
+declare function isArrayOfStrings(val: unknown): val is string[];

package/dist/utils/isArrayOfStrings.js

@@ -0,0 +1,5 @@
+export { isArrayOfStrings };
+import { isArray } from './isArray.js';
+function isArrayOfStrings(val) {
+    return isArray(val) && val.every((v) => typeof v === 'string');
+}

package/dist/utils/isCallable.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCallable = void 0;
-function isCallable(thing) {
+export function isCallable(thing) {
     return thing instanceof Function || typeof thing === 'function';
 }
-exports.isCallable = isCallable;

package/dist/utils/isMinNodeVersion.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMinNodeVersion = void 0;
-const assert_1 = require("./assert");
+export { isMinNodeVersion };
+import { assert } from './assert.js';
 function isMinNodeVersion(minNodeVersion) {
     const { version } = process;
-    (0, assert_1.assert)(version.startsWith('v'));
+    assert(version.startsWith('v'));
     const major = parseInt(version[1] + version[2], 10);
-    (0, assert_1.assert)(12 <= major && major <= 50);
+    assert(12 <= major && major <= 50);
     return major >= minNodeVersion;
 }
-exports.isMinNodeVersion = isMinNodeVersion;

package/dist/utils/isObject.d.ts

@@ -1 +1 @@
-export declare function isObject(value: unknown): value is Record<string | symbol, unknown>;
+export declare function isObject(value: unknown): value is Record<string, unknown>;

package/dist/utils/isObject.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isObject = void 0;
-function isObject(value) {
+export function isObject(value) {
     return typeof value === 'object' && value !== null;
 }
-exports.isObject = isObject;

package/dist/utils/isObjectOfStrings.d.ts

@@ -0,0 +1,2 @@
+export { isObjectOfStrings };
+declare function isObjectOfStrings(val: unknown): val is Record<string, string>;

package/dist/utils/isObjectOfStrings.js

@@ -0,0 +1,5 @@
+export { isObjectOfStrings };
+import { isObject } from './isObject.js';
+function isObjectOfStrings(val) {
+    return isObject(val) && Object.values(val).every((v) => typeof v === 'string');
+}

package/dist/utils/isTTY.js

@@ -1,5 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTTY = void 0;
 // https://stackoverflow.com/questions/34570452/node-js-stdout-clearline-and-cursorto-functions#comment80319576_34570694
-exports.isTTY = !!process.stdout.clearLine;
+export const isTTY = !!process.stdout.clearLine;

package/dist/utils/logProgress.js

@@ -1,13 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureNewTerminalLine = exports.logProgress = void 0;
-const isTTY_1 = require("./isTTY");
+export { logProgress };
+export { ensureNewTerminalLine };
+import { isTTY } from './isTTY.js';
 const iconSuccess = '🟢';
 const iconPending = '🟠';
 const iconFail = '🔴';
 let terminalLineIsEmtpy = true;
 function logProgress(text) {
-    if (!isTTY_1.isTTY) {
+    if (!isTTY) {
         const done = () => { };
         return done;
     }
@@ -25,13 +24,11 @@ function logProgress(text) {
     };
     return done;
 }
-exports.logProgress = logProgress;
 function ensureNewTerminalLine() {
     const val = terminalLineIsEmtpy;
     terminalLineIsEmtpy = true;
     return val;
 }
-exports.ensureNewTerminalLine = ensureNewTerminalLine;
 function clear() {
     // @ts-ignore
     process.stdout.clearLine();

package/dist/utils/parseCli.js

@@ -1,12 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = exports.check = exports.prepare = void 0;
+export { prepare };
+export { check };
+export { validate };
 let optionList;
 const optionsKnown = [];
 function prepare() {
     optionList = process.argv.filter((w) => w.startsWith('--'));
 }
-exports.prepare = prepare;
 function check(option) {
     optionsKnown.push(option);
     const val = optionList.includes(option);
@@ -14,7 +13,6 @@ function check(option) {
         optionList = optionList.filter((s) => s !== option);
     return val;
 }
-exports.check = check;
 function validate() {
     if (optionList.length > 0) {
         throw new Error([
@@ -24,4 +22,3 @@ function validate() {
         ].join('\n'));
     }
 }
-exports.validate = validate;

package/dist/utils/platform.js

@@ -1,24 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMac = exports.isWindows = exports.isLinux = exports.isCI = void 0;
-const assert_1 = require("./assert");
+export { isCI };
+export { isLinux };
+export { isWindows };
+export { isMac };
+import { assert } from './assert.js';
 function isWindows() {
     return process.platform === 'win32';
 }
-exports.isWindows = isWindows;
 function isLinux() {
     return process.platform === 'linux';
 }
-exports.isLinux = isLinux;
 function isMac() {
     if (process.platform === 'darwin') {
         return true;
     }
-    (0, assert_1.assert)(isLinux() || isWindows());
+    assert(isLinux() || isWindows());
     return false;
 }
-exports.isMac = isMac;
 function isCI() {
     return !!process.env.CI;
 }
-exports.isCI = isCI;

package/dist/utils/projectInfo.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectInfo = void 0;
-exports.projectInfo = {
+export const projectInfo = {
     projectName: '@brillout/test-e2e',
     npmPackageName: '@brillout/test-e2e',
     githubRepository: 'https://github.com/brillout/test-e2e',

package/dist/utils/runCommand.js

@@ -1,15 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCommand = void 0;
-const child_process_1 = require("child_process");
-const genPromise_1 = require("./genPromise");
-const humanizeTime_1 = require("./humanizeTime");
+export { runCommand };
+import { exec } from 'child_process';
+import { genPromise } from './genPromise.js';
+import { humanizeTime } from './humanizeTime.js';
 function runCommand(cmd, { timeout, cwd }) {
-    const { promise, resolve, reject } = (0, genPromise_1.genPromise)();
+    const { promise, resolve, reject } = genPromise();
     const t = setTimeout(() => {
-        reject(new Error(`Command call \`${cmd}\` (${cwd}) timed out after ${(0, humanizeTime_1.humanizeTime)(timeout)}`));
+        reject(new Error(`Command call \`${cmd}\` (${cwd}) timed out after ${humanizeTime(timeout)}`));
     }, timeout);
-    (0, child_process_1.exec)(cmd, { cwd }, (err, _stdout, stderr) => {
+    exec(cmd, { cwd }, (err, _stdout, stderr) => {
         clearTimeout(t);
         if (stderr) {
             reject(new Error(stderr));
@@ -23,4 +21,3 @@ function runCommand(cmd, { timeout, cwd }) {
     });
     return promise;
 }
-exports.runCommand = runCommand;

package/dist/utils/runCommandLongRunning.js

@@ -1,12 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCommandLongRunning = void 0;
-const child_process_1 = require("child_process");
-const strip_ansi_1 = __importDefault(require("strip-ansi"));
-const utils_1 = require("../utils");
+export { runCommandLongRunning };
+import { spawn as spawn_ } from 'child_process';
+import stripAnsi from 'strip-ansi';
+import { assert, runCommandShortLived, humanizeTime, isWindows, isLinux, isCallable, hasProp } from '../utils.js';
 function runCommandLongRunning({ cmd, cwd, killPort, isReadyLog, isReadyTimeout, onStdout, onStderr, onExit, onTerminationError, terminationTimeout, }) {
     if (killPort)
         killByPort(killPort);
@@ -16,7 +11,7 @@ function runCommandLongRunning({ cmd, cwd, killPort, isReadyLog, isReadyTimeout,
     const isReadyPromise = new Promise((resolve_, reject_) => {
         onReady = () => {
             clearTimeout(isReadyPromiseTimeout);
-            (0, utils_1.assert)(!procExited);
+            assert(!procExited);
             isReady = true;
             resolve_();
         };
@@ -25,16 +20,16 @@ function runCommandLongRunning({ cmd, cwd, killPort, isReadyLog, isReadyTimeout,
             // We reject before terminating the process in order to preserve log order. (This order is fine because the test runner doesn't exit upon test failure.)
             reject_(err);
             if (!alreadyTerminated) {
-                (0, utils_1.assert)(!procExited);
+                assert(!procExited);
                 await terminateProc(true);
             }
-            (0, utils_1.assert)(procExited);
+            assert(procExited);
         };
     });
     let isReadyPromiseTimedOut = false;
     const isReadyPromiseTimeout = setTimeout(async () => {
         isReadyPromiseTimedOut = true;
-        let errMsg = `Command \`${cmd}\` not ready after ${(0, utils_1.humanizeTime)(isReadyTimeout)}.`;
+        let errMsg = `Command \`${cmd}\` not ready after ${humanizeTime(isReadyTimeout)}.`;
         if (typeof isReadyLog === 'string') {
             errMsg += ` The stdout of the command did not (yet?) include "${isReadyLog}".`;
         }
@@ -42,13 +37,13 @@ function runCommandLongRunning({ cmd, cwd, killPort, isReadyLog, isReadyTimeout,
     }, isReadyTimeout);
     let [command, ...args] = cmd.split(' ');
     let detached = true;
-    if ((0, utils_1.isWindows)()) {
+    if (isWindows()) {
         detached = false;
         if (command === 'npm' || command === 'pnpm') {
             command = command + '.cmd';
         }
     }
-    const proc = (0, child_process_1.spawn)(command, args, { cwd, detached });
+    const proc = spawn(command, args, { cwd, detached });
     let procExited = false;
     proc.stdin.on('data', async (chunk) => {
         const data = String(chunk);
@@ -58,16 +53,16 @@ function runCommandLongRunning({ cmd, cwd, killPort, isReadyLog, isReadyTimeout,
         const log = String(chunk);
         onStdout(log, { loggedAfterExit: procExited });
         {
-            const logCleaned = (0, strip_ansi_1.default)(log);
+            const logCleaned = stripAnsi(log);
             let isMatch = false;
             if (typeof isReadyLog === 'string') {
                 isMatch = logCleaned.includes(isReadyLog);
             }
-            else if ((0, utils_1.isCallable)(isReadyLog)) {
+            else if (isCallable(isReadyLog)) {
                 isMatch = isReadyLog(logCleaned);
             }
             else {
-                (0, utils_1.assert)(false);
+                assert(false);
             }
             if (isMatch)
                 onReady();
@@ -100,7 +95,7 @@ function runCommandLongRunning({ cmd, cwd, killPort, isReadyLog, isReadyTimeout,
             onError(new Error(errMsg), true);
         }
         else {
-            (0, utils_1.assert)(isReady);
+            assert(isReady);
         }
         exitPromiseResolve();
     });
@@ -131,7 +126,7 @@ function runCommandLongRunning({ cmd, cwd, killPort, isReadyLog, isReadyTimeout,
             */
             resolve();
         }, terminationTimeout);
-        (0, utils_1.assert)(proc);
+        assert(proc);
         await stopProcess({
             proc,
             cwd,
@@ -145,7 +140,6 @@ function runCommandLongRunning({ cmd, cwd, killPort, isReadyLog, isReadyTimeout,
         return promise;
     }
 }
-exports.runCommandLongRunning = runCommandLongRunning;
 function stopProcess({ proc, cwd, cmd, force, onTerminationError, }) {
     let resolve;
     const promise = new Promise((_resolve, _reject) => {
@@ -160,8 +154,8 @@ function stopProcess({ proc, cwd, cmd, force, onTerminationError, }) {
     proc.on('close', onProcessClose);
     proc.on('exit', onProcessClose);
     const { pid } = proc;
-    (0, utils_1.assert)(pid);
-    if ((0, utils_1.isWindows)()) {
+    assert(pid);
+    if (isWindows()) {
         // - https://github.com/nodejs/node/issues/3617#issuecomment-377731194
         // - https://stackoverflow.com/questions/23706055/why-can-i-not-kill-my-child-process-in-nodejs-on-windows/28163919#28163919
         // - taskkill seems to be buggy in many ways:
@@ -185,22 +179,22 @@ function stopProcess({ proc, cwd, cmd, force, onTerminationError, }) {
         //     ERROR: The process "6564" not found.
         //     ```
         //     There doesn't seem to be an option to suppress these errors: https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/taskkill#parameters
-        (0, utils_1.assert)(typeof pid === 'number');
-        (0, child_process_1.spawn)('taskkill', ['/pid', String(pid), '/f', '/t'], {
+        assert(typeof pid === 'number');
+        spawn('taskkill', ['/pid', String(pid), '/f', '/t'], {
             stdio: [
-                'ignore',
+                'ignore', // stdin
                 // Ignore following log to avoid polluting non-error logs. (Setting 'inherit' instead of 'ignore' attaches stdout to the root process and not to `proc` which is why the stdout of taskkill isn't intercepted by `proc.stdout.on('data', () => /* ... */)`.)
                 // ```
                 // SUCCESS: The process with PID 6932 (child process of PID 2744) has been terminated.
                 // ```
-                'ignore',
+                'ignore', // stdout
                 // Ignoring stderr doesn't solve the problem that taskkill makes the process exit with code 1
                 'inherit', // stderr
             ],
         });
     }
     else {
-        (0, utils_1.assert)(typeof pid === 'number');
+        assert(typeof pid === 'number');
         const processGroup = -1 * pid;
         const signal = force ? 'SIGKILL' : 'SIGTERM';
         process.kill(processGroup, signal);
@@ -223,10 +217,24 @@ function stopProcess({ proc, cwd, cmd, force, onTerminationError, }) {
     return promise;
 }
 async function killByPort(port) {
-    (0, utils_1.assert)((0, utils_1.isLinux)());
-    (0, utils_1.assert)(port);
-    await (0, utils_1.runCommandShortLived)(`fuser -k ${port}/tcp`, { swallowError: true, timeout: 10 * 1000 });
+    assert(isLinux());
+    assert(port);
+    await runCommandShortLived(`fuser -k ${port}/tcp`, { swallowError: true, timeout: 10 * 1000 });
 }
 function isSuccessCode(code) {
-    return code === 0 || code === null || (code === 1 && (0, utils_1.isWindows)());
+    return code === 0 || code === null || (code === 1 && isWindows());
+}
+/* Doesn't work:
+const spawn2: typeof spawn_ = (...args) => spawn_(...args)
+const spawn3: typeof spawn_ = function(...args) { return spawn_(...args) }
+//*/
+function spawn(command, args, options) {
+    // Workaround for Node.js regression:
+    //  - https://github.com/nodejs/node/issues/52475
+    //  - https://github.com/prebuild/prebuildify/issues/83#issuecomment-2056607495
+    if (isWindows())
+        options.shell = true;
+    // Needed for spawn_() to return ChildProcessWithoutNullStreams instead of ChildProcess
+    assert(hasProp(options, 'stdio', 'undefined'));
+    return spawn_(command, args, options);
 }

package/dist/utils/runCommandShortLived.js

@@ -1,17 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCommandShortLived = void 0;
-const child_process_1 = require("child_process");
-const genPromise_1 = require("./genPromise");
-const humanizeTime_1 = require("./humanizeTime");
+export { runCommandShortLived };
+import { exec } from 'child_process';
+import { genPromise } from './genPromise.js';
+import { humanizeTime } from './humanizeTime.js';
 function runCommandShortLived(cmd, { swallowError = false, timeout = 5000, cwd = process.cwd(), } = {}) {
-    const { promise, resolve, reject } = (0, genPromise_1.genPromise)();
+    const { promise, resolve, reject } = genPromise();
     const t = setTimeout(() => {
-        console.error(`Command call \`${cmd}\` (${cwd}) timed out after ${(0, humanizeTime_1.humanizeTime)(timeout)}`);
+        console.error(`Command call \`${cmd}\` (${cwd}) timed out after ${humanizeTime(timeout)}`);
         reject();
     }, timeout);
     const options = { cwd };
-    (0, child_process_1.exec)(cmd, options, (err, stdout, stderr) => {
+    exec(cmd, options, (err, stdout, stderr) => {
         clearTimeout(t);
         if (err || stderr) {
             if (swallowError) {
@@ -36,4 +34,3 @@ function runCommandShortLived(cmd, { swallowError = false, timeout = 5000, cwd =
     });
     return promise;
 }
-exports.runCommandShortLived = runCommandShortLived;

package/dist/utils/sleep.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sleep = void 0;
+export { sleep };
 function sleep(milliseconds) {
     return new Promise((r) => setTimeout(r, milliseconds));
 }
-exports.sleep = sleep;

package/dist/utils/trackLogs.d.ts

@@ -1 +1 @@
-declare function trackLogs(): void;
+export {};

package/dist/utils/trackLogs.js

@@ -1,4 +1,3 @@
-"use strict";
 trackLogs();
 // https://stackoverflow.com/questions/45395369/how-to-get-console-log-line-numbers-shown-in-nodejs/75109905#75109905
 function trackLogs() {
@@ -19,3 +18,4 @@ function trackLogs() {
     });
     Error.stackTraceLimit = Infinity;
 }
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,16 @@
+export * from './utils/sleep.js';
+export * from './utils/runCommand.js';
+export * from './utils/runCommandShortLived.js';
+export * from './utils/runCommandLongRunning.js';
+export * from './utils/assert.js';
+export * from './utils/humanizeTime.js';
+export * from './utils/isTTY.js';
+export * from './utils/findFiles.js';
+export * from './utils/logProgress.js';
+export * from './utils/cliOptions.js';
+export * from './utils/fsWindowsBugWorkaround.js';
+export * from './utils/isObject.js';
+export * from './utils/isCallable.js';
+export * from './utils/platform.js';
+export * from './utils/isMinNodeVersion.js';
+export * from './utils/hasProp.js';