@songtonyli/dsh-cli 0.1.11 → 0.1.13

package/node_modules/unicode-trie/index.js

@@ -0,0 +1,136 @@
+const inflate = require('tiny-inflate');
+const { swap32LE } = require('./swap');
+
+// Shift size for getting the index-1 table offset.
+const SHIFT_1 = 6 + 5;
+
+// Shift size for getting the index-2 table offset.
+const SHIFT_2 = 5;
+
+// Difference between the two shift sizes,
+// for getting an index-1 offset from an index-2 offset. 6=11-5
+const SHIFT_1_2 = SHIFT_1 - SHIFT_2;
+
+// Number of index-1 entries for the BMP. 32=0x20
+// This part of the index-1 table is omitted from the serialized form.
+const OMITTED_BMP_INDEX_1_LENGTH = 0x10000 >> SHIFT_1;
+
+// Number of entries in an index-2 block. 64=0x40
+const INDEX_2_BLOCK_LENGTH = 1 << SHIFT_1_2;
+
+// Mask for getting the lower bits for the in-index-2-block offset. */
+const INDEX_2_MASK = INDEX_2_BLOCK_LENGTH - 1;
+
+// Shift size for shifting left the index array values.
+// Increases possible data size with 16-bit index values at the cost
+// of compactability.
+// This requires data blocks to be aligned by DATA_GRANULARITY.
+const INDEX_SHIFT = 2;
+
+// Number of entries in a data block. 32=0x20
+const DATA_BLOCK_LENGTH = 1 << SHIFT_2;
+
+// Mask for getting the lower bits for the in-data-block offset.
+const DATA_MASK = DATA_BLOCK_LENGTH - 1;
+
+// The part of the index-2 table for U+D800..U+DBFF stores values for
+// lead surrogate code _units_ not code _points_.
+// Values for lead surrogate code _points_ are indexed with this portion of the table.
+// Length=32=0x20=0x400>>SHIFT_2. (There are 1024=0x400 lead surrogates.)
+const LSCP_INDEX_2_OFFSET = 0x10000 >> SHIFT_2;
+const LSCP_INDEX_2_LENGTH = 0x400 >> SHIFT_2;
+
+// Count the lengths of both BMP pieces. 2080=0x820
+const INDEX_2_BMP_LENGTH = LSCP_INDEX_2_OFFSET + LSCP_INDEX_2_LENGTH;
+
+// The 2-byte UTF-8 version of the index-2 table follows at offset 2080=0x820.
+// Length 32=0x20 for lead bytes C0..DF, regardless of SHIFT_2.
+const UTF8_2B_INDEX_2_OFFSET = INDEX_2_BMP_LENGTH;
+const UTF8_2B_INDEX_2_LENGTH = 0x800 >> 6;  // U+0800 is the first code point after 2-byte UTF-8
+
+// The index-1 table, only used for supplementary code points, at offset 2112=0x840.
+// Variable length, for code points up to highStart, where the last single-value range starts.
+// Maximum length 512=0x200=0x100000>>SHIFT_1.
+// (For 0x100000 supplementary code points U+10000..U+10ffff.)
+//
+// The part of the index-2 table for supplementary code points starts
+// after this index-1 table.
+//
+// Both the index-1 table and the following part of the index-2 table
+// are omitted completely if there is only BMP data.
+const INDEX_1_OFFSET = UTF8_2B_INDEX_2_OFFSET + UTF8_2B_INDEX_2_LENGTH;
+
+// The alignment size of a data block. Also the granularity for compaction.
+const DATA_GRANULARITY = 1 << INDEX_SHIFT;
+
+class UnicodeTrie {
+  constructor(data) {
+    const isBuffer = (typeof data.readUInt32BE === 'function') && (typeof data.slice === 'function');
+
+    if (isBuffer || data instanceof Uint8Array) {
+      // read binary format
+      let uncompressedLength;
+      if (isBuffer) {
+        this.highStart = data.readUInt32LE(0);
+        this.errorValue = data.readUInt32LE(4);
+        uncompressedLength = data.readUInt32LE(8);
+        data = data.slice(12);
+      } else {
+        const view = new DataView(data.buffer);
+        this.highStart = view.getUint32(0, true);
+        this.errorValue = view.getUint32(4, true);
+        uncompressedLength = view.getUint32(8, true);
+        data = data.subarray(12);
+      }
+
+      // double inflate the actual trie data
+      data = inflate(data, new Uint8Array(uncompressedLength));
+      data = inflate(data, new Uint8Array(uncompressedLength));
+
+      // swap bytes from little-endian
+      swap32LE(data);
+
+      this.data = new Uint32Array(data.buffer);
+
+    } else {
+      // pre-parsed data
+      ({ data: this.data, highStart: this.highStart, errorValue: this.errorValue } = data);
+    }
+  }
+
+  get(codePoint) {
+    let index;
+    if ((codePoint < 0) || (codePoint > 0x10ffff)) {
+      return this.errorValue;
+    }
+
+    if ((codePoint < 0xd800) || ((codePoint > 0xdbff) && (codePoint <= 0xffff))) {
+      // Ordinary BMP code point, excluding leading surrogates.
+      // BMP uses a single level lookup.  BMP index starts at offset 0 in the index.
+      // data is stored in the index array itself.
+      index = (this.data[codePoint >> SHIFT_2] << INDEX_SHIFT) + (codePoint & DATA_MASK);
+      return this.data[index];
+    }
+
+    if (codePoint <= 0xffff) {
+      // Lead Surrogate Code Point.  A Separate index section is stored for
+      // lead surrogate code units and code points.
+      //   The main index has the code unit data.
+      //   For this function, we need the code point data.
+      index = (this.data[LSCP_INDEX_2_OFFSET + ((codePoint - 0xd800) >> SHIFT_2)] << INDEX_SHIFT) + (codePoint & DATA_MASK);
+      return this.data[index];
+    }
+
+    if (codePoint < this.highStart) {
+      // Supplemental code point, use two-level lookup.
+      index = this.data[(INDEX_1_OFFSET - OMITTED_BMP_INDEX_1_LENGTH) + (codePoint >> SHIFT_1)];
+      index = this.data[index + ((codePoint >> SHIFT_2) & INDEX_2_MASK)];
+      index = (index << INDEX_SHIFT) + (codePoint & DATA_MASK);
+      return this.data[index];
+    }
+
+    return this.data[this.data.length - DATA_GRANULARITY];
+  }
+}
+
+module.exports = UnicodeTrie;

package/node_modules/unicode-trie/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "unicode-trie",
+  "version": "2.0.0",
+  "description": "Unicode Trie data structure for fast character metadata lookup, ported from ICU",
+  "devDependencies": {
+    "mocha": "^6.1.4",
+    "nyc": "^14.1.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/devongovett/unicode-trie.git"
+  },
+  "author": "Devon Govett <devongovett@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/devongovett/unicode-trie/issues"
+  },
+  "homepage": "https://github.com/devongovett/unicode-trie",
+  "dependencies": {
+    "pako": "^0.2.5",
+    "tiny-inflate": "^1.0.0"
+  }
+}

package/node_modules/unicode-trie/swap.js

@@ -0,0 +1,25 @@
+const isBigEndian = (new Uint8Array(new Uint32Array([0x12345678]).buffer)[0] === 0x12);
+
+const swap = (b, n, m) => {
+  let i = b[n];
+  b[n] = b[m];
+  b[m] = i;
+};
+
+const swap32 = array => {
+  const len = array.length;
+  for (let i = 0; i < len; i += 4) {
+    swap(array, i, i + 3);
+    swap(array, i + 1, i + 2);
+  }
+};
+
+const swap32LE = array => {
+  if (isBigEndian) {
+    swap32(array);
+  }
+};
+
+module.exports = {
+  swap32LE: swap32LE
+};

package/node_modules/unicode-trie/test/mocha.opts

@@ -0,0 +1 @@
+--reporter spec

package/node_modules/unicode-trie/test/test.js

@@ -0,0 +1,243 @@
+const assert = require('assert');
+const UnicodeTrieBuilder = require('../builder');
+const UnicodeTrie = require('../');
+
+describe('unicode trie', () => {
+  it('set', () => {
+    const trie = new UnicodeTrieBuilder(10, 666);
+    trie.set(0x4567, 99);
+    assert.equal(trie.get(0x4566), 10);
+    assert.equal(trie.get(0x4567), 99);
+    assert.equal(trie.get(-1), 666);
+    assert.equal(trie.get(0x110000), 666);
+  });
+
+  it('set -> compacted trie', () => {
+    const t = new UnicodeTrieBuilder(10, 666);
+    t.set(0x4567, 99);
+
+    const trie = t.freeze();
+    assert.equal(trie.get(0x4566), 10);
+    assert.equal(trie.get(0x4567), 99);
+    assert.equal(trie.get(-1), 666);
+    assert.equal(trie.get(0x110000), 666);
+  });
+
+  it('setRange', () => {
+    const trie = new UnicodeTrieBuilder(10, 666);
+    trie.setRange(13, 6666, 7788, false);
+    trie.setRange(6000, 7000, 9900, true);
+
+    assert.equal(trie.get(12), 10);
+    assert.equal(trie.get(13), 7788);
+    assert.equal(trie.get(5999), 7788);
+    assert.equal(trie.get(6000), 9900);
+    assert.equal(trie.get(7000), 9900);
+    assert.equal(trie.get(7001), 10);
+    assert.equal(trie.get(0x110000), 666);
+  });
+
+  it('setRange -> compacted trie', () => {
+    const t = new UnicodeTrieBuilder(10, 666);
+    t.setRange(13, 6666, 7788, false);
+    t.setRange(6000, 7000, 9900, true);
+
+    const trie = t.freeze();
+    assert.equal(trie.get(12), 10);
+    assert.equal(trie.get(13), 7788);
+    assert.equal(trie.get(5999), 7788);
+    assert.equal(trie.get(6000), 9900);
+    assert.equal(trie.get(7000), 9900);
+    assert.equal(trie.get(7001), 10);
+    assert.equal(trie.get(0x110000), 666);
+  });
+
+  it('toBuffer written in little-endian', () => {
+    const trie = new UnicodeTrieBuilder();
+    trie.set(0x4567, 99);
+
+    const buf = trie.toBuffer();
+    const bufferExpected = new Buffer.from([0, 72, 0, 0, 0, 0, 0, 0, 128, 36, 0, 0, 123, 123, 206, 144, 235, 128, 2, 143, 67, 96, 225, 171, 23, 55, 54, 38, 231, 47, 44, 127, 233, 90, 109, 194, 92, 246, 126, 197, 131, 223, 31, 56, 102, 78, 154, 20, 108, 117, 88, 244, 93, 192, 190, 218, 229, 156, 12, 107, 86, 235, 125, 96, 102, 0, 129, 15, 239, 109, 219, 204, 58, 151, 92, 52, 126, 152, 198, 14, 0]);
+    assert.equal(buf.toString('hex'), bufferExpected.toString('hex'));
+  });
+
+  it('should work with compressed serialization format', () => {
+    const t = new UnicodeTrieBuilder(10, 666);
+    t.setRange(13, 6666, 7788, false);
+    t.setRange(6000, 7000, 9900, true);
+
+    const buf = t.toBuffer();
+    const trie = new UnicodeTrie(buf);
+    assert.equal(trie.get(12), 10);
+    assert.equal(trie.get(13), 7788);
+    assert.equal(trie.get(5999), 7788);
+    assert.equal(trie.get(6000), 9900);
+    assert.equal(trie.get(7000), 9900);
+    assert.equal(trie.get(7001), 10);
+    assert.equal(trie.get(0x110000), 666);
+  });
+
+  const rangeTests = [
+    {
+      ranges: [
+         [ 0,        0,        0,      0 ],
+         [ 0,        0x40,     0,      0 ],
+         [ 0x40,     0xe7,     0x1234, 0 ],
+         [ 0xe7,     0x3400,   0,      0 ],
+         [ 0x3400,   0x9fa6,   0x6162, 0 ],
+         [ 0x9fa6,   0xda9e,   0x3132, 0 ],
+         [ 0xdada,   0xeeee,   0x87ff, 0 ],
+         [ 0xeeee,   0x11111,  1,      0 ],
+         [ 0x11111,  0x44444,  0x6162, 0 ],
+         [ 0x44444,  0x60003,  0,      0 ],
+         [ 0xf0003,  0xf0004,  0xf,    0 ],
+         [ 0xf0004,  0xf0006,  0x10,   0 ],
+         [ 0xf0006,  0xf0007,  0x11,   0 ],
+         [ 0xf0007,  0xf0040,  0x12,   0 ],
+         [ 0xf0040,  0x110000, 0,      0 ]
+      ],
+
+      check: [
+        [ 0,        0      ],
+        [ 0x40,     0      ],
+        [ 0xe7,     0x1234 ],
+        [ 0x3400,   0      ],
+        [ 0x9fa6,   0x6162 ],
+        [ 0xda9e,   0x3132 ],
+        [ 0xdada,   0      ],
+        [ 0xeeee,   0x87ff ],
+        [ 0x11111,  1      ],
+        [ 0x44444,  0x6162 ],
+        [ 0xf0003,  0      ],
+        [ 0xf0004,  0xf    ],
+        [ 0xf0006,  0x10   ],
+        [ 0xf0007,  0x11   ],
+        [ 0xf0040,  0x12   ],
+        [ 0x110000, 0      ]
+      ]
+    },
+    {
+      // set some interesting overlapping ranges
+      ranges: [
+        [ 0,        0,        0,      0 ],
+        [ 0x21,     0x7f,     0x5555, 1 ],
+        [ 0x2f800,  0x2fedc,  0x7a,   1 ],
+        [ 0x72,     0xdd,     3,      1 ],
+        [ 0xdd,     0xde,     4,      0 ],
+        [ 0x201,    0x240,    6,      1 ],  // 3 consecutive blocks with the same pattern but
+        [ 0x241,    0x280,    6,      1 ],  // discontiguous value ranges, testing utrie2_enum()
+        [ 0x281,    0x2c0,    6,      1 ],
+        [ 0x2f987,  0x2fa98,  5,      1 ],
+        [ 0x2f777,  0x2f883,  0,      1 ],
+        [ 0x2f900,  0x2ffaa,  1,      0 ],
+        [ 0x2ffaa,  0x2ffab,  2,      1 ],
+        [ 0x2ffbb,  0x2ffc0,  7,      1 ]
+      ],
+
+      check: [
+        [ 0,        0      ],
+        [ 0x21,     0      ],
+        [ 0x72,     0x5555 ],
+        [ 0xdd,     3      ],
+        [ 0xde,     4      ],
+        [ 0x201,    0      ],
+        [ 0x240,    6      ],
+        [ 0x241,    0      ],
+        [ 0x280,    6      ],
+        [ 0x281,    0      ],
+        [ 0x2c0,    6      ],
+        [ 0x2f883,  0      ],
+        [ 0x2f987,  0x7a   ],
+        [ 0x2fa98,  5      ],
+        [ 0x2fedc,  0x7a   ],
+        [ 0x2ffaa,  1      ],
+        [ 0x2ffab,  2      ],
+        [ 0x2ffbb,  0      ],
+        [ 0x2ffc0,  7      ],
+        [ 0x110000, 0      ]
+      ]
+    },
+    {
+      // use a non-zero initial value
+      ranges: [
+        [ 0,        0,        9, 0 ], // non-zero initial value.
+        [ 0x31,     0xa4,     1, 0 ],
+        [ 0x3400,   0x6789,   2, 0 ],
+        [ 0x8000,   0x89ab,   9, 1 ],
+        [ 0x9000,   0xa000,   4, 1 ],
+        [ 0xabcd,   0xbcde,   3, 1 ],
+        [ 0x55555,  0x110000, 6, 1 ], // highStart<U+ffff with non-initialValue
+        [ 0xcccc,   0x55555,  6, 1 ]
+      ],
+
+      check: [
+        [ 0,        9 ],  // non-zero initialValue
+        [ 0x31,     9 ],
+        [ 0xa4,     1 ],
+        [ 0x3400,   9 ],
+        [ 0x6789,   2 ],
+        [ 0x9000,   9 ],
+        [ 0xa000,   4 ],
+        [ 0xabcd,   9 ],
+        [ 0xbcde,   3 ],
+        [ 0xcccc,   9 ],
+        [ 0x110000, 6 ]
+      ]
+    },
+    {
+      // empty or single-value tries, testing highStart==0
+      ranges: [
+        [ 0,        0,        3, 0 ] // Only the element with the initial value.
+      ],
+
+      check: [
+        [ 0,        3 ],
+        [ 0x110000, 3 ]
+      ]
+    },
+    {
+      ranges: [
+        [ 0,        0,        3,  0 ], // Initial value = 3
+        [ 0,        0x110000, 5, 1  ]
+      ],
+
+      check: [
+        [ 0,        3 ],
+        [ 0x110000, 5 ]
+      ]
+    }
+  ];
+
+  it('should pass range tests', () => {
+    const result = [];
+    for (let test of rangeTests) {
+      let initialValue = 0;
+      let errorValue = 0x0bad;
+      let i = 0;
+      if (test.ranges[i][1] < 0) {
+        errorValue = test.ranges[i][2];
+        i++;
+      }
+
+      initialValue = test.ranges[i++][2];
+      var trie = new UnicodeTrieBuilder(initialValue, errorValue);
+
+      for (let range of test.ranges.slice(i)) {
+        trie.setRange(range[0], range[1] - 1, range[2], range[3] !== 0);
+      }
+
+      var frozen = trie.freeze();
+
+      var start = 0;
+      result.push(test.check.map((check) => {
+        let end;
+        const result1 = [];
+        for (start = start, end = check[0]; start < end; start++) {
+          assert.equal(trie.get(start), check[1]);
+          result1.push(assert.equal(frozen.get(start), check[1]));
+        }
+        return result1;
+      }));
+    }
+  });
+});

package/node_modules/unicorn-magic/default.js

@@ -0,0 +1,14 @@
+export async function delay({seconds, milliseconds} = {}) {
+	let duration;
+	if (typeof seconds === 'number') {
+		duration = seconds * 1000;
+	} else if (typeof milliseconds === 'number') {
+		duration = milliseconds;
+	} else {
+		throw new TypeError('Expected an object with either `seconds` or `milliseconds`.');
+	}
+
+	return new Promise(resolve => {
+		setTimeout(resolve, duration);
+	});
+}

package/node_modules/unicorn-magic/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+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.

package/node_modules/unicorn-magic/node.js

@@ -0,0 +1,49 @@
+import {promisify} from 'node:util';
+import {execFile as execFileCallback, execFileSync as execFileSyncOriginal} from 'node:child_process';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const execFileOriginal = promisify(execFileCallback);
+
+export function toPath(urlOrPath) {
+	return urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
+}
+
+export function rootDirectory(pathInput) {
+	return path.parse(toPath(pathInput)).root;
+}
+
+export function traversePathUp(startPath) {
+	return {
+		* [Symbol.iterator]() {
+			let currentPath = path.resolve(toPath(startPath));
+			let previousPath;
+
+			while (previousPath !== currentPath) {
+				yield currentPath;
+				previousPath = currentPath;
+				currentPath = path.resolve(currentPath, '..');
+			}
+		},
+	};
+}
+
+const TEN_MEGABYTES_IN_BYTES = 10 * 1024 * 1024;
+
+export async function execFile(file, arguments_, options = {}) {
+	return execFileOriginal(file, arguments_, {
+		maxBuffer: TEN_MEGABYTES_IN_BYTES,
+		...options,
+	});
+}
+
+export function execFileSync(file, arguments_ = [], options = {}) {
+	return execFileSyncOriginal(file, arguments_, {
+		maxBuffer: TEN_MEGABYTES_IN_BYTES,
+		encoding: 'utf8',
+		stdio: 'pipe',
+		...options,
+	});
+}
+
+export * from './default.js';

package/node_modules/unicorn-magic/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "unicorn-magic",
+  "version": "0.3.0",
+  "description": "Some useful utilities I often need",
+  "license": "MIT",
+  "repository": "sindresorhus/unicorn-magic",
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "type": "module",
+  "exports": {
+    "node": {
+      "types": "./node.d.ts",
+      "import": "./node.js"
+    },
+    "default": {
+      "types": "./default.d.ts",
+      "import": "./default.js"
+    }
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "node.js",
+    "node.d.ts",
+    "default.js",
+    "default.d.ts"
+  ],
+  "keywords": [
+    "utilities",
+    "util",
+    "extras",
+    "url",
+    "path",
+    "delay",
+    "wait",
+    "settimeout",
+    "sleep",
+    "child_process",
+    "child",
+    "process",
+    "subprocess",
+    "exec",
+    "execfile",
+    "execfilesync"
+  ],
+  "devDependencies": {
+    "ava": "^6.1.3",
+    "in-range": "^3.0.0",
+    "time-span": "^5.1.0",
+    "typescript": "^5.5.4",
+    "xo": "^0.59.2"
+  }
+}

package/node_modules/unicorn-magic/readme.md

@@ -0,0 +1,25 @@
+# unicorn-magic
+
+> Some useful utilities I often need
+
+*I'm not accepting requests.*
+
+## Install
+
+```sh
+npm install unicorn-magic
+```
+
+## Usage
+
+```js
+import {delay} from 'unicorn-magic';
+
+await delay({seconds: 1});
+
+console.log('1 second later');
+```
+
+## API
+
+See [the types](index.d.ts).

package/node_modules/which-command/cli.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import process from 'node:process';
+import {readFileSync} from 'node:fs';
+import {parseArgs} from 'node:util';
+import {whichCommand, whichCommandAll} from './index.js';
+
+const help = `
+  Usage
+    $ which-command <command> …
+
+  Options
+    --all, -a     List all matching paths, not just the first
+    --silent, -s  Suppress output; the exit code still reflects whether all commands were found
+
+  Examples
+    $ which-command node
+    /usr/local/bin/node
+
+    $ which-command --all node
+    /usr/local/bin/node
+    /opt/homebrew/bin/node
+
+  Exits with code 1 if any of the commands could not be found.
+`;
+
+let flags;
+let commands;
+try {
+	({values: flags, positionals: commands} = parseArgs({
+		allowPositionals: true,
+		options: {
+			all: {type: 'boolean', short: 'a', default: false},
+			silent: {type: 'boolean', short: 's', default: false},
+			help: {type: 'boolean', short: 'h', default: false},
+			version: {type: 'boolean', default: false},
+		},
+	}));
+} catch (error) {
+	console.error(error.message);
+	process.exit(1);
+}
+
+if (flags.version) {
+	const {version} = JSON.parse(readFileSync(new URL('package.json', import.meta.url), 'utf8'));
+	console.log(version);
+	process.exit(0);
+}
+
+if (flags.help) {
+	console.log(help);
+	process.exit(0);
+}
+
+if (commands.length === 0) {
+	console.error(help);
+	process.exit(1);
+}
+
+let allFound = true;
+for (const command of commands) {
+	// eslint-disable-next-line no-await-in-loop
+	const paths = flags.all ? await whichCommandAll(command) : [await whichCommand(command)].filter(Boolean);
+
+	if (paths.length === 0) {
+		allFound = false;
+		continue;
+	}
+
+	if (!flags.silent) {
+		console.log(paths.join('\n'));
+	}
+}
+
+process.exit(allFound ? 0 : 1);