initial commit

node_modules/get-port-please/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) UnJS - Pooya Parsa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/get-port-please/README.md

@@ -0,0 +1,86 @@
+![get-port-please](https://user-images.githubusercontent.com/904724/101664848-9bc16380-3a4c-11eb-9e3a-faad60c86b2e.png)
+
+# get-port-please
+
+> Get an available TCP port to listen
+
+[![npm](https://img.shields.io/npm/dt/get-port-please.svg?style=flat-square)](https://npmjs.com/package/get-port-please)
+[![npm (scoped with tag)](https://img.shields.io/npm/v/get-port-please/latest.svg?style=flat-square)](https://npmjs.com/package/get-port-please)
+
+## Usage
+
+Install package:
+
+```bash
+yarn add get-port-please
+# or
+npm install get-port-please
+```
+
+```js
+// ESM
+import { getPort, checkPort, getRandomPort, waitForPort } from 'get-port-please'
+
+// CommonJS
+const { getPort, checkPort, getRandomPort, waitForPort } = require('get-port-please')
+```
+
+```ts
+getPort(options?: GetPortOptions): Promise<number>
+checkPort(port: number, host?: string): Promise<number | false>
+waitForPort(port: number, options): Promise<number | false>
+```
+
+Try sequence is: port > ports > memo > random
+
+## Options
+
+```ts
+interface GetPortOptions {
+  name?: string
+
+  random?: boolean
+  port?: number
+  portRange?: [from: number, to: number]
+  ports?: number[]
+  host?: string
+
+  memoDir?: string
+  memoName?: string
+}
+```
+
+### `name`
+
+Unique name for port memorizing. Default is `default`.
+
+### `random`
+
+If enabled, `port` and `ports` will be ignored. Default is `false`.
+
+### `port`
+
+First port to check. Default is `process.env.PORT || 3000`
+
+### `ports`
+
+Alternative ports to check.
+
+### `portRange`
+
+Alternative port range to check. Default is `[3000, 3100]`
+
+### `host`
+
+The host to check. Default is `process.env.HOST` otherwise all available hosts will be checked.
+
+### `memoDir` / `memoName`
+
+Options passed to [fs-memo](https://github.com/unjs/fs-memo)
+
+- Default dir: `node_modules/get-port/dist`
+- Default name: `.get-port`
+
+## License
+
+MIT

node_modules/get-port-please/dist/index.cjs

@@ -0,0 +1,252 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const net = require('net');
+const os = require('os');
+const fsMemo = require('fs-memo');
+
+const unsafePorts = /* @__PURE__ */ new Set([
+  1,
+  7,
+  9,
+  11,
+  13,
+  15,
+  17,
+  19,
+  20,
+  21,
+  22,
+  23,
+  25,
+  37,
+  42,
+  43,
+  53,
+  69,
+  77,
+  79,
+  87,
+  95,
+  101,
+  102,
+  103,
+  104,
+  109,
+  110,
+  111,
+  113,
+  115,
+  117,
+  119,
+  123,
+  135,
+  137,
+  139,
+  143,
+  161,
+  179,
+  389,
+  427,
+  465,
+  512,
+  513,
+  514,
+  515,
+  526,
+  530,
+  531,
+  532,
+  540,
+  548,
+  554,
+  556,
+  563,
+  587,
+  601,
+  636,
+  989,
+  990,
+  993,
+  995,
+  1719,
+  1720,
+  1723,
+  2049,
+  3659,
+  4045,
+  5060,
+  5061,
+  6e3,
+  6566,
+  6665,
+  6666,
+  6667,
+  6668,
+  6669,
+  6697,
+  10080
+]);
+function isUnsafePort(port) {
+  return unsafePorts.has(port);
+}
+function isSafePort(port) {
+  return !isUnsafePort(port);
+}
+
+function log(...args) {
+  console.log("[get-port]", ...args);
+}
+async function getPort(config = {}) {
+  if (typeof config === "number" || typeof config === "string") {
+    config = { port: parseInt(config + "") || 0 };
+  }
+  const options = {
+    name: "default",
+    random: false,
+    ports: [],
+    portRange: [],
+    alternativePortRange: [3e3, 3100],
+    host: void 0,
+    memoName: "port",
+    verbose: false,
+    ...config,
+    port: parseInt(process.env.PORT || "") || config.port || 3e3
+  };
+  if (options.random) {
+    return getRandomPort(options.host);
+  }
+  const portsToCheck = [
+    options.port,
+    ...options.ports,
+    ...generateRange(...options.portRange)
+  ].filter((port) => {
+    if (!port) {
+      return false;
+    }
+    if (!isSafePort(port)) {
+      if (options.verbose) {
+        log("Ignoring unsafe port:", port);
+      }
+      return false;
+    }
+    return true;
+  });
+  const memoOptions = { name: options.memoName, dir: options.memoDir };
+  const memoKey = "port_" + options.name;
+  const memo = await fsMemo.getMemo(memoOptions);
+  if (memo[memoKey]) {
+    portsToCheck.push(memo[memoKey]);
+  }
+  let availablePort = await findPort(portsToCheck, options.host, options.verbose, false);
+  if (!availablePort) {
+    availablePort = await findPort(generateRange(...options.alternativePortRange), options.host, options.verbose);
+    if (options.verbose) {
+      log(`Unable to find an available port (tried ${portsToCheck.join(", ") || "-"}). Using alternative port:`, availablePort);
+    }
+  }
+  await fsMemo.setMemo({ [memoKey]: availablePort }, memoOptions);
+  return availablePort;
+}
+async function getRandomPort(host) {
+  const port = await checkPort(0, host);
+  if (port === false) {
+    throw new Error("Unable to obtain an available random port number!");
+  }
+  return port;
+}
+async function waitForPort(port, opts = {}) {
+  const delay = opts.delay || 500;
+  const retries = opts.retries || 4;
+  for (let i = retries; i > 0; i--) {
+    if (await checkPort(port, opts.host) === false) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delay));
+  }
+  throw new Error(`Timeout waiting for port ${port} after ${retries} retries with ${delay}ms interval.`);
+}
+async function checkPort(port, host = process.env.HOST, _verbose) {
+  if (!host) {
+    host = getLocalHosts([void 0, "0.0.0.0"]);
+  }
+  if (!Array.isArray(host)) {
+    return _checkPort(port, host);
+  }
+  for (const _host of host) {
+    const _port = await _checkPort(port, _host);
+    if (_port === false) {
+      if (port < 1024 && _verbose) {
+        log("Unable to listen to priviliged port:", `${_host}:${port}`);
+      }
+      return false;
+    }
+    if (port === 0 && _port !== 0) {
+      port = _port;
+    }
+  }
+  return port;
+}
+function generateRange(from, to) {
+  if (to < from) {
+    return [];
+  }
+  const r = [];
+  for (let i = from; i < to; i++) {
+    r.push(i);
+  }
+  return r;
+}
+function _checkPort(port, host) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.unref();
+    server.on("error", (err) => {
+      if (err.code === "EINVAL" || err.code === "EADDRNOTAVAIL") {
+        resolve(port !== 0 && isSafePort(port) && port);
+      } else {
+        resolve(false);
+      }
+    });
+    server.listen({ port, host }, () => {
+      const { port: port2 } = server.address();
+      server.close(() => {
+        resolve(isSafePort(port2) && port2);
+      });
+    });
+  });
+}
+function getLocalHosts(additional) {
+  const hosts = new Set(additional);
+  for (const _interface of Object.values(os.networkInterfaces())) {
+    for (const config of _interface) {
+      hosts.add(config.address);
+    }
+  }
+  return Array.from(hosts);
+}
+async function findPort(ports, host, _verbose = false, _random = true) {
+  for (const port of ports) {
+    const r = await checkPort(port, host, _verbose);
+    if (r) {
+      return r;
+    }
+  }
+  if (_random) {
+    const randomPort = await getRandomPort(host);
+    if (_verbose) {
+      log(`Unable to find an available port (tried ${ports.join(", ") || "-"}). Using random port:`, randomPort);
+    }
+    return randomPort;
+  } else {
+    return 0;
+  }
+}
+
+exports.checkPort = checkPort;
+exports.getPort = getPort;
+exports.getRandomPort = getRandomPort;
+exports.isSafePort = isSafePort;
+exports.isUnsafePort = isUnsafePort;
+exports.waitForPort = waitForPort;

node_modules/get-port-please/dist/index.d.ts

@@ -0,0 +1,29 @@
+declare function isUnsafePort(port: number): boolean;
+declare function isSafePort(port: number): boolean;
+
+interface GetPortOptions {
+    name: string;
+    random: boolean;
+    port: number;
+    ports: number[];
+    portRange: [from: number, to: number];
+    alternativePortRange: [from: number, to: number];
+    host: string;
+    memoDir: string;
+    memoName: string;
+    verbose?: boolean;
+}
+declare type GetPortInput = Partial<GetPortOptions> | number | string;
+declare type HostAddress = undefined | string;
+declare type PortNumber = number;
+declare function getPort(config?: GetPortInput): Promise<PortNumber>;
+declare function getRandomPort(host?: HostAddress): Promise<number>;
+interface WaitForPortOptions {
+    host?: HostAddress;
+    delay?: number;
+    retries?: number;
+}
+declare function waitForPort(port: PortNumber, opts?: WaitForPortOptions): Promise<void>;
+declare function checkPort(port: PortNumber, host?: HostAddress | HostAddress[], _verbose?: boolean): Promise<PortNumber | false>;
+
+export { GetPortInput, GetPortOptions, HostAddress, PortNumber, WaitForPortOptions, checkPort, getPort, getRandomPort, isSafePort, isUnsafePort, waitForPort };

node_modules/get-port-please/dist/index.mjs

@@ -0,0 +1,243 @@
+import { createServer } from 'net';
+import { networkInterfaces } from 'os';
+import { getMemo, setMemo } from 'fs-memo';
+
+const unsafePorts = /* @__PURE__ */ new Set([
+  1,
+  7,
+  9,
+  11,
+  13,
+  15,
+  17,
+  19,
+  20,
+  21,
+  22,
+  23,
+  25,
+  37,
+  42,
+  43,
+  53,
+  69,
+  77,
+  79,
+  87,
+  95,
+  101,
+  102,
+  103,
+  104,
+  109,
+  110,
+  111,
+  113,
+  115,
+  117,
+  119,
+  123,
+  135,
+  137,
+  139,
+  143,
+  161,
+  179,
+  389,
+  427,
+  465,
+  512,
+  513,
+  514,
+  515,
+  526,
+  530,
+  531,
+  532,
+  540,
+  548,
+  554,
+  556,
+  563,
+  587,
+  601,
+  636,
+  989,
+  990,
+  993,
+  995,
+  1719,
+  1720,
+  1723,
+  2049,
+  3659,
+  4045,
+  5060,
+  5061,
+  6e3,
+  6566,
+  6665,
+  6666,
+  6667,
+  6668,
+  6669,
+  6697,
+  10080
+]);
+function isUnsafePort(port) {
+  return unsafePorts.has(port);
+}
+function isSafePort(port) {
+  return !isUnsafePort(port);
+}
+
+function log(...args) {
+  console.log("[get-port]", ...args);
+}
+async function getPort(config = {}) {
+  if (typeof config === "number" || typeof config === "string") {
+    config = { port: parseInt(config + "") || 0 };
+  }
+  const options = {
+    name: "default",
+    random: false,
+    ports: [],
+    portRange: [],
+    alternativePortRange: [3e3, 3100],
+    host: void 0,
+    memoName: "port",
+    verbose: false,
+    ...config,
+    port: parseInt(process.env.PORT || "") || config.port || 3e3
+  };
+  if (options.random) {
+    return getRandomPort(options.host);
+  }
+  const portsToCheck = [
+    options.port,
+    ...options.ports,
+    ...generateRange(...options.portRange)
+  ].filter((port) => {
+    if (!port) {
+      return false;
+    }
+    if (!isSafePort(port)) {
+      if (options.verbose) {
+        log("Ignoring unsafe port:", port);
+      }
+      return false;
+    }
+    return true;
+  });
+  const memoOptions = { name: options.memoName, dir: options.memoDir };
+  const memoKey = "port_" + options.name;
+  const memo = await getMemo(memoOptions);
+  if (memo[memoKey]) {
+    portsToCheck.push(memo[memoKey]);
+  }
+  let availablePort = await findPort(portsToCheck, options.host, options.verbose, false);
+  if (!availablePort) {
+    availablePort = await findPort(generateRange(...options.alternativePortRange), options.host, options.verbose);
+    if (options.verbose) {
+      log(`Unable to find an available port (tried ${portsToCheck.join(", ") || "-"}). Using alternative port:`, availablePort);
+    }
+  }
+  await setMemo({ [memoKey]: availablePort }, memoOptions);
+  return availablePort;
+}
+async function getRandomPort(host) {
+  const port = await checkPort(0, host);
+  if (port === false) {
+    throw new Error("Unable to obtain an available random port number!");
+  }
+  return port;
+}
+async function waitForPort(port, opts = {}) {
+  const delay = opts.delay || 500;
+  const retries = opts.retries || 4;
+  for (let i = retries; i > 0; i--) {
+    if (await checkPort(port, opts.host) === false) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delay));
+  }
+  throw new Error(`Timeout waiting for port ${port} after ${retries} retries with ${delay}ms interval.`);
+}
+async function checkPort(port, host = process.env.HOST, _verbose) {
+  if (!host) {
+    host = getLocalHosts([void 0, "0.0.0.0"]);
+  }
+  if (!Array.isArray(host)) {
+    return _checkPort(port, host);
+  }
+  for (const _host of host) {
+    const _port = await _checkPort(port, _host);
+    if (_port === false) {
+      if (port < 1024 && _verbose) {
+        log("Unable to listen to priviliged port:", `${_host}:${port}`);
+      }
+      return false;
+    }
+    if (port === 0 && _port !== 0) {
+      port = _port;
+    }
+  }
+  return port;
+}
+function generateRange(from, to) {
+  if (to < from) {
+    return [];
+  }
+  const r = [];
+  for (let i = from; i < to; i++) {
+    r.push(i);
+  }
+  return r;
+}
+function _checkPort(port, host) {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.unref();
+    server.on("error", (err) => {
+      if (err.code === "EINVAL" || err.code === "EADDRNOTAVAIL") {
+        resolve(port !== 0 && isSafePort(port) && port);
+      } else {
+        resolve(false);
+      }
+    });
+    server.listen({ port, host }, () => {
+      const { port: port2 } = server.address();
+      server.close(() => {
+        resolve(isSafePort(port2) && port2);
+      });
+    });
+  });
+}
+function getLocalHosts(additional) {
+  const hosts = new Set(additional);
+  for (const _interface of Object.values(networkInterfaces())) {
+    for (const config of _interface) {
+      hosts.add(config.address);
+    }
+  }
+  return Array.from(hosts);
+}
+async function findPort(ports, host, _verbose = false, _random = true) {
+  for (const port of ports) {
+    const r = await checkPort(port, host, _verbose);
+    if (r) {
+      return r;
+    }
+  }
+  if (_random) {
+    const randomPort = await getRandomPort(host);
+    if (_verbose) {
+      log(`Unable to find an available port (tried ${ports.join(", ") || "-"}). Using random port:`, randomPort);
+    }
+    return randomPort;
+  } else {
+    return 0;
+  }
+}
+
+export { checkPort, getPort, getRandomPort, isSafePort, isUnsafePort, waitForPort };

node_modules/get-port-please/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "get-port-please",
+  "version": "2.6.1",
+  "description": "Get an available TCP port to listen",
+  "repository": "unjs/get-port-please",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "fs-memo": "^1.2.0"
+  },
+  "devDependencies": {
+    "@nuxtjs/eslint-config-typescript": "latest",
+    "@types/node": "latest",
+    "c8": "latest",
+    "eslint": "latest",
+    "jiti": "^1.14.0",
+    "standard-version": "latest",
+    "typescript": "latest",
+    "unbuild": "latest",
+    "vitest": "^0.21.0"
+  },
+  "packageManager": "pnpm@7.9.0",
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest",
+    "lint": "eslint --ext ts .",
+    "release": "pnpm test && pnpm build && standard-version && pnpm publish && git push --follow-tags",
+    "test": "pnpm lint && vitest run"
+  }
+}