@deot/dev-test 2.9.8 → 2.9.10

package/dist/index.js

@@ -1,534 +1,529 @@
-import * as childProcess from 'child_process';
-import { Shell } from '@deot/dev-shared';
-import puppeteer from 'puppeteer';
-import * as http from 'http';
-import * as os from 'os';
-
-const { LOCAL_COMMAND_MAP } = Shell;
-const KEY_MAP = {
-  DOWN: "\x1B[B",
-  UP: "\x1B[A",
-  ENTER: "\r",
-  // return;
-  SPACE: ""
+import * as childProcess from "child_process";
+import { Shell } from "@deot/dev-shared";
+import puppeteer from "puppeteer";
+import * as http from "http";
+import * as os from "os";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
 };
-class Command {
-  target;
-  code;
-  error;
-  resolve;
-  reject;
-  stdout;
-  stderr;
-  emitter;
-  isClose;
-  schedule;
-  constructor(command, args) {
-    this.target = new Promise((resolve, reject) => {
-      this.resolve = this._handleEnd(resolve);
-      this.reject = this._handleEnd(reject);
-    });
-    this.code = null;
-    this.error = null;
-    this.stdout = "";
-    this.stderr = "";
-    this.emitter = this.start(command, args);
-    this.isClose = false;
-    this.schedule = {
-      target: Promise.resolve(),
-      complete: (
-        /* istanbul ignore next */
-        () => {
-        }
-      )
-    };
-  }
-  _handleEnd(fn) {
-    return (e) => {
-      this.isClose = true;
-      const { code, error } = e;
-      this.code = code;
-      this.error = error;
-      fn({
-        ...e,
-        stdout: this.stdout,
-        stderr: this.stderr
-      });
-    };
-  }
-  start(command, args) {
-    const SPACE = " ";
-    const [command$, ...args$] = (command + SPACE + args.join(SPACE)).replace(/\s+/g, SPACE).split(SPACE).filter((i) => !!i).map((i) => LOCAL_COMMAND_MAP[i] || i);
-    const emitter = childProcess.spawn(command$, args$, {
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    emitter.on("close", (code) => {
-      if (code !== 0) {
-        this.reject({ code });
-      } else {
-        this.resolve({ code });
-      }
-    });
-    emitter.on(
-      "error",
-      /* istanbul ignore next */
-      (error) => {
-        !process.exitCode && (process.exitCode = 1);
-        this.reject({ code: process.exitCode, error });
-      }
-    );
-    emitter.stdout.on("data", (e) => {
-      this.stdout += e.toString();
-      this.schedule.complete();
-    });
-    emitter.stderr.on(
-      "data",
-      /* istanbul ignore next */
-      (e) => this.stderr += e.toString()
-    );
-    return emitter;
-  }
-  async stop() {
-    await this.schedule.target;
-    if (!this.isClose) {
-      this.emitter.stdin.end();
-      this.isClose = true;
-    }
-    const response = await this.target;
-    return response;
-  }
-  async press(key, timeout = 200) {
-    if (!key || this.isClose) return;
-    await this.schedule.target;
-    this.schedule.target = new Promise((resolve) => {
-      this.schedule.complete = resolve;
-    });
-    await new Promise((resolve) => {
-      this.emitter.stdin.write(
-        KEY_MAP[key.toUpperCase()] || key,
-        "utf8",
-        resolve
-      );
-    });
-    await new Promise((_) => setTimeout(_, timeout));
-  }
-}
-
-class Operater {
-  page;
-  constructor(v) {
-    this.page = v;
-  }
-  /**
-   * @param selector ~
-   * @param options ~
-   */
-  async click(selector, options) {
-    await this.page.click(selector, options);
-  }
-  /**
-   * @param selector ~
-   * @returns ~
-   */
-  async count(selector) {
-    return (await this.page.$$(selector)).length;
-  }
-  /**
-   * @param selector ~
-   * @returns ~
-   */
-  async text(selector) {
-    return await this.page.$eval(selector, (node) => node.textContent);
-  }
-  /**
-   * @param selector ~
-   * @returns ~
-   */
-  async value(selector) {
-    return await this.page.$eval(selector, (node) => node.value);
-  }
-  /**
-   * @param selector ~
-   * @returns ~
-   */
-  async html(selector) {
-    return await this.page.$eval(selector, (node) => node.innerHTML);
-  }
-  /**
-   * @param selector ~
-   * @returns ~
-   */
-  async classList(selector) {
-    return await this.page.$eval(selector, (node) => [...node.classList]);
-  }
-  /**
-   * @param selector ~
-   * @returns ~
-   */
-  async children(selector) {
-    return await this.page.$eval(selector, (node) => [...node.children]);
-  }
-  /**
-   * @param selector ~
-   * @returns ~
-   */
-  async isVisible(selector) {
-    const display = await this.page.$eval(selector, (node) => {
-      return window.getComputedStyle(node).display;
-    });
-    return display !== "none";
-  }
-  /**
-   *
-   * @param selector ~
-   * @returns ~
-   */
-  async isChecked(selector) {
-    return await this.page.$eval(
-      selector,
-      (node) => node.checked
-    );
-  }
-  /**
-   *
-   * @param selector ~
-   * @returns ~
-   */
-  async isFocused(selector) {
-    return await this.page.$eval(selector, (node) => node === document.activeElement);
-  }
-  /**
-   * @param selector ~
-   * @param value$ ~
-   * @returns ~
-   */
-  async setValue(selector, value$) {
-    await this.page.$eval(
-      selector,
-      (node, value$$) => {
-        node.value = value$$;
-        node.dispatchEvent(new Event("input"));
-      },
-      value$
-    );
-  }
-  /**
-   * @param selector ~
-   * @param value$ ~
-   * @returns ~
-   */
-  async typeValue(selector, value$) {
-    const el = await this.page.$(selector);
-    await el.evaluate((node) => node.value = "");
-    await el.type(value$);
-  }
-  /**
-   * @param selector ~
-   * @param value$ ~
-   * @returns ~
-   */
-  async enterValue(selector, value$) {
-    const el = await this.page.$(selector);
-    await el.evaluate((node) => node.value = "");
-    await el.type(value$);
-    await el.press("Enter");
-  }
-  /**
-   * @param selector ~
-   * @returns ~
-   */
-  async clearValue(selector) {
-    return await this.page.$eval(
-      selector,
-      (node) => {
-        node.value = "";
-      }
-    );
-  }
-  /**
-   *
-   * @param time ~
-   * @returns ~
-   */
-  sleep(time) {
-    return this.page.evaluate((time$) => {
-      return new Promise((r) => {
-        setTimeout(r, time$);
-      });
-    }, time);
-  }
-  nextFrame() {
-    return this.page.evaluate(() => {
-      return new Promise((resolve) => {
-        requestAnimationFrame(() => {
-          requestAnimationFrame(resolve);
-        });
-      });
-    });
-  }
-}
-
-class Launch {
-  browser;
-  page;
-  operater;
-  _browser;
-  _page;
-  puppeteerOptions;
-  options;
-  constructor(options) {
-    this.options = options || { logLevel: "slient" };
-    this.operater = new Proxy({}, {
-      get: () => {
-        throw new Error("operater is not defined. create* invote first");
-      }
-    });
-    this.browser = new Proxy({}, {
-      get: () => {
-        throw new Error("browser is not defined. createBrowser invote first");
-      }
-    });
-    this.page = new Proxy({}, {
-      get: () => {
-        throw new Error("page is not defined. createPage invote first");
-      }
-    });
-    this.puppeteerOptions = process.env.CI ? { args: ["--no-sandbox", "--disable-setuid-sandbox"] } : {};
-  }
-  createBrowser(force) {
-    if (force || !this._browser) {
-      if (force && this._browser) {
-        this._browser.then((browser) => {
-          browser.isConnected() && browser.close();
-        });
-      }
-      this._browser = puppeteer.launch({
-        ...this.puppeteerOptions,
-        headless: true
-      });
-      this._browser.then((browser) => {
-        this.browser = browser;
-      });
-    }
-    return this._browser;
-  }
-  async createPage(force) {
-    await this.createBrowser();
-    if (force || !this._page) {
-      if (force && this._page) {
-        this._page.then((page) => {
-          !page.isClosed() && page.close();
-        });
-      }
-      this._page = new Promise((resolve) => {
-        (async () => {
-          const page = await this.browser.newPage();
-          await page.evaluateOnNewDocument(
-            /* istanbul ignore next */
-            () => {
-              localStorage.clear();
-            }
-          );
-          this.options.logLevel !== "slient" && page.on("console", (e) => {
-            const key = e.type();
-            console[key].call(console[key], `${key} from puppeteer: `, ...e.args().map((i) => i.remoteObject()));
-          });
-          this.page = page;
-          this.operater = new Operater(page);
-          resolve(page);
-        })();
-      });
-    }
-    return this._page;
-  }
-}
-
-class Interrupter {
-  static of(options) {
-    return new Interrupter(options);
-  }
-  options = {};
-  _success;
-  _fail;
-  _task;
-  _finish = false;
-  constructor(options) {
-    if (options) {
-      this.options = options;
-    }
-    this._generateTask();
-  }
-  _generateTask = () => {
-    this._task = new Promise((resolve, reject) => {
-      this._success = (value) => {
-        this._fail = void 0;
-        resolve(value);
-      };
-      this._fail = (value) => {
-        this._success = void 0;
-        reject(value);
-      };
-    });
-  };
-  next = async (v) => {
-    if (!this._finish) {
-      this._success?.(v);
-      await this._task;
-      await Promise.resolve();
-      this._generateTask();
-    } else {
-      await this._task;
-    }
-  };
-  nextWithError = async (v) => {
-    if (!this._finish) {
-      this._fail?.(v);
-      try {
-        await this._task;
-      } catch {
-        await Promise.resolve();
-        this._generateTask();
-      }
-    } else {
-      await this._task;
-    }
-  };
-  finish = (v) => {
-    this._success?.(v);
-    this._finish = true;
-    return this;
-  };
-  finishWithError = (v) => {
-    this._fail?.(v);
-    this._finish = true;
-    return this;
-  };
-  then(resolve, reject) {
-    return this._task.then(resolve, reject);
-  }
-  catch(callback) {
-    return this._task.catch(callback);
-  }
-  finally(callback) {
-    return this._task.finally(callback);
-  }
-}
-
-const TIME_OUT = 60 * 1e3;
-const impl = () => {
-  const launch = new Launch();
-  beforeAll(async () => {
-    await launch.createBrowser();
-  }, 2e4);
-  beforeEach(async () => {
-    await launch.createPage(true);
-  });
-  afterEach(async () => {
-    if (!launch.page.isClosed()) {
-      await launch.page.close();
-    }
-  });
-  afterAll(async () => {
-    if (launch.browser.isConnected()) {
-      await launch.browser.close();
-    }
-  });
-  return launch;
+//#endregion
+//#region packages/test/src/command.ts
+var { LOCAL_COMMAND_MAP } = Shell;
+var KEY_MAP = {
+	DOWN: "\x1B[B",
+	UP: "\x1B[A",
+	ENTER: "\r",
+	SPACE: ""
 };
-
-const e2e = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	TIME_OUT,
-	impl
-}, Symbol.toStringTag, { value: 'Module' }));
-
-const sleep = (s) => new Promise((_) => {
-  setTimeout(_, s || 0);
+var Command = class {
+	target;
+	code;
+	error;
+	resolve;
+	reject;
+	stdout;
+	stderr;
+	emitter;
+	isClose;
+	schedule;
+	constructor(command, args) {
+		this.target = new Promise((resolve, reject) => {
+			this.resolve = this._handleEnd(resolve);
+			this.reject = this._handleEnd(reject);
+		});
+		this.code = null;
+		this.error = null;
+		this.stdout = "";
+		this.stderr = "";
+		this.schedule = {
+			target: Promise.resolve(),
+			complete: () => {}
+		};
+		this.schedule.target = new Promise((resolve) => {
+			this.schedule.complete = resolve;
+		});
+		this.emitter = this.start(command, args);
+		this.isClose = false;
+	}
+	_handleEnd(fn) {
+		return (e) => {
+			this.isClose = true;
+			const { code, error } = e;
+			this.code = code;
+			this.error = error;
+			fn({
+				...e,
+				stdout: this.stdout,
+				stderr: this.stderr
+			});
+		};
+	}
+	start(command, args) {
+		const SPACE = " ";
+		const [command$, ...args$] = (command + SPACE + args.join(SPACE)).replace(/\s+/g, SPACE).split(SPACE).filter((i) => !!i).map((i) => LOCAL_COMMAND_MAP[i] || i);
+		const emitter = childProcess.spawn(command$, args$, { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		emitter.on("close", (code) => {
+			this.schedule.complete();
+			/* istanbul ignore next */
+			if (code !== 0) this.reject({ code });
+			else this.resolve({ code });
+		});
+		emitter.on(
+			"error",
+			/* istanbul ignore next */
+			(error) => {
+				this.schedule.complete();
+				!process.exitCode && (process.exitCode = 1);
+				this.reject({
+					code: process.exitCode,
+					error
+				});
+			}
+		);
+		emitter.stdout.on("data", (e) => {
+			this.stdout += e.toString();
+			this.schedule.complete();
+		});
+		emitter.stderr.on(
+			"data",
+			/* istanbul ignore next */
+			(e) => this.stderr += e.toString()
+		);
+		return emitter;
+	}
+	async stop() {
+		await this.schedule.target;
+		if (!this.isClose) {
+			this.emitter.stdin.end();
+			this.isClose = true;
+		}
+		return await this.target;
+	}
+	async press(key, timeout = 200) {
+		if (!key || this.isClose) return;
+		await this.schedule.target;
+		this.schedule.target = new Promise((resolve) => {
+			this.schedule.complete = resolve;
+		});
+		await new Promise((resolve) => {
+			this.emitter.stdin.write(KEY_MAP[key.toUpperCase()] || key, "utf8", resolve);
+		});
+		await new Promise((_) => setTimeout(_, timeout));
+	}
+};
+//#endregion
+//#region packages/test/src/operater.ts
+var Operater = class {
+	page;
+	constructor(v) {
+		this.page = v;
+	}
+	/**
+	* @param selector ~
+	* @param options ~
+	*/
+	async click(selector, options) {
+		await this.page.click(selector, options);
+	}
+	/**
+	* @param selector ~
+	* @returns ~
+	*/
+	async count(selector) {
+		return (await this.page.$$(selector)).length;
+	}
+	/**
+	* @param selector ~
+	* @returns ~
+	*/
+	async text(selector) {
+		return await this.page.$eval(selector, (node) => node.textContent);
+	}
+	/**
+	* @param selector ~
+	* @returns ~
+	*/
+	async value(selector) {
+		return await this.page.$eval(selector, (node) => node.value);
+	}
+	/**
+	* @param selector ~
+	* @returns ~
+	*/
+	async html(selector) {
+		return await this.page.$eval(selector, (node) => node.innerHTML);
+	}
+	/**
+	* @param selector ~
+	* @returns ~
+	*/
+	async classList(selector) {
+		return await this.page.$eval(selector, (node) => [...node.classList]);
+	}
+	/**
+	* @param selector ~
+	* @returns ~
+	*/
+	async children(selector) {
+		return await this.page.$eval(selector, (node) => [...node.children]);
+	}
+	/**
+	* @param selector ~
+	* @returns ~
+	*/
+	async isVisible(selector) {
+		return await this.page.$eval(selector, (node) => {
+			return window.getComputedStyle(node).display;
+		}) !== "none";
+	}
+	/**
+	*
+	* @param selector ~
+	* @returns ~
+	*/
+	async isChecked(selector) {
+		return await this.page.$eval(selector, (node) => node.checked);
+	}
+	/**
+	*
+	* @param selector ~
+	* @returns ~
+	*/
+	async isFocused(selector) {
+		return await this.page.$eval(selector, (node) => node === document.activeElement);
+	}
+	/**
+	* @param selector ~
+	* @param value$ ~
+	* @returns ~
+	*/
+	async setValue(selector, value$) {
+		await this.page.$eval(selector, (node, value$$) => {
+			node.value = value$$;
+			node.dispatchEvent(new Event("input"));
+		}, value$);
+	}
+	/**
+	* @param selector ~
+	* @param value$ ~
+	* @returns ~
+	*/
+	async typeValue(selector, value$) {
+		const el = await this.page.$(selector);
+		await el.evaluate((node) => node.value = "");
+		await el.type(value$);
+	}
+	/**
+	* @param selector ~
+	* @param value$ ~
+	* @returns ~
+	*/
+	async enterValue(selector, value$) {
+		const el = await this.page.$(selector);
+		await el.evaluate((node) => node.value = "");
+		await el.type(value$);
+		await el.press("Enter");
+	}
+	/**
+	* @param selector ~
+	* @returns ~
+	*/
+	async clearValue(selector) {
+		return await this.page.$eval(selector, (node) => {
+			node.value = "";
+		});
+	}
+	/**
+	*
+	* @param time ~
+	* @returns ~
+	*/
+	sleep(time) {
+		return this.page.evaluate((time$) => {
+			return new Promise((r) => {
+				setTimeout(r, time$);
+			});
+		}, time);
+	}
+	nextFrame() {
+		return this.page.evaluate(() => {
+			return new Promise((resolve) => {
+				requestAnimationFrame(() => {
+					requestAnimationFrame(resolve);
+				});
+			});
+		});
+	}
+};
+//#endregion
+//#region packages/test/src/launch.ts
+var Launch = class {
+	browser;
+	page;
+	operater;
+	_browser;
+	_page;
+	puppeteerOptions;
+	options;
+	constructor(options) {
+		this.options = options || { logLevel: "slient" };
+		this.operater = new Proxy({}, { get: () => {
+			throw new Error("operater is not defined. create* invote first");
+		} });
+		this.browser = new Proxy({}, { get: () => {
+			throw new Error("browser is not defined. createBrowser invote first");
+		} });
+		this.page = new Proxy({}, { get: () => {
+			throw new Error("page is not defined. createPage invote first");
+		} });
+		/* istanbul ignore next -- @preserve */
+		this.puppeteerOptions = process.env.CI ? { args: ["--no-sandbox", "--disable-setuid-sandbox"] } : {};
+	}
+	createBrowser(force) {
+		if (force || !this._browser) {
+			if (force && this._browser) this._browser.then((browser) => {
+				browser.isConnected() && browser.close();
+			});
+			this._browser = puppeteer.launch({
+				...this.puppeteerOptions,
+				headless: true
+			});
+			this._browser.then((browser) => {
+				this.browser = browser;
+			});
+		}
+		return this._browser;
+	}
+	async createPage(force) {
+		await this.createBrowser();
+		if (force || !this._page) {
+			if (force && this._page) this._page.then((page) => {
+				!page.isClosed() && page.close();
+			});
+			this._page = new Promise((resolve) => {
+				(async () => {
+					const page = await this.browser.newPage();
+					await page.evaluateOnNewDocument(
+						/* istanbul ignore next */
+						() => {
+							localStorage.clear();
+						}
+					);
+					/* istanbul ignore next -- @preserve */
+					this.options.logLevel !== "slient" && page.on("console", (e) => {
+						const key = e.type();
+						console[key].call(console[key], `${key} from puppeteer: `, ...e.args().map((i) => i.remoteObject()));
+					});
+					this.page = page;
+					this.operater = new Operater(page);
+					resolve(page);
+				})();
+			});
+		}
+		return this._page;
+	}
+};
+//#endregion
+//#region packages/test/src/interrupter.ts
+/**
+* 实现的目的：
+* 这是一段代码使用`await interrupter`调度器
+* 永远等待它，直到它上面有任何代码执行了`interrupter.next()`
+* 不论它是同步，微任务，异步执行，之后才会执行它后面的代码
+*/
+var Interrupter = class Interrupter {
+	static of(options) {
+		return new Interrupter(options);
+	}
+	options = {};
+	_success;
+	_fail;
+	_task;
+	_finish = false;
+	constructor(options) {
+		if (options) this.options = options;
+		this._generateTask();
+	}
+	_generateTask = () => {
+		this._task = new Promise((resolve, reject) => {
+			this._success = (value) => {
+				this._fail = void 0;
+				resolve(value);
+			};
+			this._fail = (value) => {
+				this._success = void 0;
+				reject(value);
+			};
+		});
+	};
+	next = async (v) => {
+		if (!this._finish) {
+			this._success?.(v);
+			await this._task;
+			await Promise.resolve();
+			this._generateTask();
+		} else await this._task;
+	};
+	nextWithError = async (v) => {
+		if (!this._finish) {
+			this._fail?.(v);
+			try {
+				await this._task;
+			} catch {
+				await Promise.resolve();
+				this._generateTask();
+			}
+		} else await this._task;
+	};
+	finish = (v) => {
+		this._success?.(v);
+		this._finish = true;
+		return this;
+	};
+	finishWithError = (v) => {
+		this._fail?.(v);
+		this._finish = true;
+		return this;
+	};
+	then(resolve, reject) {
+		return this._task.then(resolve, reject);
+	}
+	catch(callback) {
+		return this._task.catch(callback);
+	}
+	finally(callback) {
+		return this._task.finally(callback);
+	}
+};
+//#endregion
+//#region packages/test/src/e2e.ts
+var e2e_exports = /* @__PURE__ */ __exportAll({
+	TIME_OUT: () => TIME_OUT,
+	impl: () => impl
 });
-const expectByPolling = async (poll, expected, options) => {
-  const { maxTries = 30, interval = 50, to } = options || {};
-  for (let tries = 0; tries < maxTries; tries++) {
-    const actual = await poll();
-    const allowMatch = (!to || to === "toMatch") && typeof expected === "string" && typeof actual === "string";
-    if (allowMatch && actual.indexOf(expected) > -1 || actual === expected || tries === maxTries - 1) {
-      allowMatch ? expect(actual).toMatch(expected) : expect(actual)[to || "toBe"](expected);
-      break;
-    } else {
-      await sleep(interval);
-    }
-  }
+var TIME_OUT = 60 * 1e3;
+var impl = () => {
+	const launch = new Launch();
+	beforeAll(async () => {
+		await launch.createBrowser();
+	}, 2e4);
+	beforeEach(async () => {
+		await launch.createPage(true);
+	});
+	afterEach(async () => {
+		/* istanbul ignore else -- @preserve */
+		if (!launch.page.isClosed()) await launch.page.close();
+	});
+	afterAll(async () => {
+		/* istanbul ignore else -- @preserve */
+		if (launch.browser.isConnected()) await launch.browser.close();
+	});
+	return launch;
 };
-const def = (target, key, value, options) => {
-  return Object.defineProperty(target, key, {
-    value,
-    enumerable: false,
-    writable: true,
-    configurable: true,
-    ...options
-  });
+//#endregion
+//#region packages/test/src/utils.ts
+var utils_exports = /* @__PURE__ */ __exportAll({
+	def: () => def,
+	expectByPolling: () => expectByPolling,
+	sleep: () => sleep
+});
+var sleep = (s) => new Promise((_) => {
+	setTimeout(_, s || 0);
+});
+/**
+* @param poll ~
+* @param expected ~
+* @param options ~
+*/
+var expectByPolling = async (poll, expected, options) => {
+	const { maxTries = 30, interval = 50, to } = options || {};
+	for (let tries = 0; tries < maxTries; tries++) {
+		const actual = await poll();
+		const allowMatch = (!to || to === "toMatch") && typeof expected === "string" && typeof actual === "string";
+		if (allowMatch && actual.indexOf(expected) > -1 || actual === expected || tries === maxTries - 1) {
+			allowMatch ? expect(actual).toMatch(expected) : expect(actual)[to || "toBe"](expected);
+			break;
+		} else await sleep(interval);
+	}
 };
-
-const utils = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	def,
-	expectByPolling,
-	sleep
-}, Symbol.toStringTag, { value: 'Module' }));
-
-let defaultHost = "";
-const host = (force) => {
-  if (!force && defaultHost) return defaultHost;
-  const ips = [];
-  const ntwk = os.networkInterfaces();
-  for (const k in ntwk) {
-    for (let i = 0; i < ntwk[k].length; i++) {
-      const _add = ntwk[k][i].address;
-      if (_add && _add.split(".").length == 4 && !ntwk[k][i].internal && ntwk[k][i].family == "IPv4") {
-        ips.push(ntwk[k][i].address);
-      }
-    }
-  }
-  return ips[0] || "localhost";
+var def = (target, key, value, options) => {
+	return Object.defineProperty(target, key, {
+		value,
+		enumerable: false,
+		writable: true,
+		configurable: true,
+		...options
+	});
+};
+//#endregion
+//#region packages/test/src/server.ts
+var server_exports = /* @__PURE__ */ __exportAll({
+	available: () => available,
+	host: () => host,
+	port: () => port
+});
+var defaultHost = "";
+var host = (force) => {
+	if (!force && defaultHost) return defaultHost;
+	const ips = [];
+	const ntwk = os.networkInterfaces();
+	for (const k in ntwk) for (let i = 0; i < ntwk[k].length; i++) {
+		const _add = ntwk[k][i].address;
+		if (_add && _add.split(".").length == 4 && !ntwk[k][i].internal && ntwk[k][i].family == "IPv4") ips.push(ntwk[k][i].address);
+	}
+	/* istanbul ignore next -- @preserve */
+	return ips[0] || "localhost";
 };
 defaultHost = host();
-const port = (host$ = defaultHost, port$ = 1024) => {
-  if (port$ < 1024) throw new Error("port < 1024");
-  return new Promise((resolve, reject) => {
-    const server = http.createServer();
-    server.unref();
-    server.on(
-      "error",
-      /* istanbul ignore next -- @preserve */
-      () => {
-        if (port$ >= 65535) {
-          reject();
-        } else {
-          port(host$, port$ + 1).then(resolve).catch(reject);
-        }
-      }
-    );
-    server.listen({ host: host$, port: port$ }, () => {
-      server.close(() => {
-        resolve(port$);
-      });
-    });
-  });
+var port = (host$ = defaultHost, port$ = 1024) => {
+	/* istanbul ignore next -- @preserve */
+	if (port$ < 1024) throw new Error("port < 1024");
+	return new Promise((resolve, reject) => {
+		const server = http.createServer();
+		server.unref();
+		server.on(
+			"error",
+			/* istanbul ignore next -- @preserve */
+			() => {
+				if (port$ >= 65535) reject();
+				else port(host$, port$ + 1).then(resolve).catch(reject);
+			}
+		);
+		server.listen({
+			host: host$,
+			port: port$
+		}, () => {
+			server.close(() => {
+				resolve(port$);
+			});
+		});
+	});
 };
-const available = async () => {
-  const host$ = host();
-  const port$ = await port(host$);
-  return {
-    host: host$,
-    port: port$,
-    baseUrl: `http://${host$}:${port$}`
-  };
+var available = async () => {
+	const host$ = host();
+	const port$ = await port(host$);
+	return {
+		host: host$,
+		port: port$,
+		baseUrl: `http://${host$}:${port$}`
+	};
 };
-
-const server = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	available,
-	host,
-	port
-}, Symbol.toStringTag, { value: 'Module' }));
-
-export { Command, e2e as E2E, Interrupter, Launch, Operater, server as Server, utils as Utils };
+//#endregion
+//#region packages/test/src/index.ts
+/**
+* "export * as ___" syntax is not supported yet (API Extractor@7.x)
+*/
+//#endregion
+export { Command, e2e_exports as E2E, Interrupter, Launch, Operater, server_exports as Server, utils_exports as Utils };