From aeefa795d3e455ed71db28f2a693511b10b5cdb4 Mon Sep 17 00:00:00 2001
From: Anton Golub <antongolub@antongolub.com>
Date: Sun, 22 Dec 2024 15:07:13 +0300
Subject: [PATCH] test: check entry points exports

closes #1020
---
 scripts/build-tests.mjs                    |  69 ++-
 src/cli.ts                                 |   2 +-
 src/core.ts                                |   3 +-
 test/all.test.js                           |   4 +-
 test/cli.test.js                           |  17 +-
 test/core.test.js                          |  13 +-
 test/export.test.js                        | 622 +++++++++++++++++++++
 test/index.test.js                         |   6 -
 test/vendor-export.test.js                 | 280 ----------
 test/{vendor-yaml.test.js => yaml.test.js} |   0
 10 files changed, 687 insertions(+), 329 deletions(-)
 create mode 100644 test/export.test.js
 delete mode 100644 test/vendor-export.test.js
 rename test/{vendor-yaml.test.js => yaml.test.js} (100%)

diff --git a/scripts/build-tests.mjs b/scripts/build-tests.mjs
index eceb98ece9..1aea865a03 100644
--- a/scripts/build-tests.mjs
+++ b/scripts/build-tests.mjs
@@ -17,48 +17,47 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import * as vendor from '../build/vendor.js'
+import * as core from '../build/core.js'
+import * as cli from '../build/cli.js'
+import * as index from '../build/index.js'
 
-const root = path.resolve(new URL(import.meta.url).pathname, '../..')
-const apis = [
-  'chalk',
-  'depseek',
-  'fs',
-  'glob',
-  'minimist',
-  'ps',
-  'which',
-  'YAML',
+// prettier-ignore
+const modules = [
+  ['core', core],
+  ['cli', cli],
+  ['index', index],
+  ['vendor', vendor, ['chalk', 'depseek', 'fs', 'glob', 'minimist', 'ps', 'which', 'YAML',]],
 ]
+const root = path.resolve(new URL(import.meta.url).pathname, '../..')
+const filePath = path.resolve(root, `test/export.test.js`)
+
 const copyright = await fs.readFileSync(
   path.resolve(root, 'test/fixtures/copyright.txt'),
   'utf8'
 )
 
-const filePath = path.resolve(root, `test/vendor-export.test.js`)
-let fileContents = `${copyright.replace('YEAR', new Date().getFullYear())}
+let head = `${copyright.replace('YEAR', new Date().getFullYear())}
 import assert from 'node:assert'
-import { test, describe } from 'node:test'
-import {
-${apis.map((v) => '  ' + v).join(',\n')},
-} from '../build/vendor.js'
-`
+import { test, describe } from 'node:test'`
+let body = '\n'
+
+for (const [name, ref, apis = Object.keys(ref).sort()] of modules) {
+  head += `\nimport * as ${name} from '../build/${name}.js'`
+  body += `\n//prettier-ignore\ndescribe('${name}', () => {\n`
+  body += `  test('exports', () => {\n`
+  for (const r of apis) {
+    const api = ref[r]
+    body += `    assert.equal(typeof ${name}.${r}, '${typeof api}', '${name}.${r}')\n`
+    if (typeof api !== 'function' && typeof api !== 'object') continue
+    for (const k of Object.keys(api).sort()) {
+      const v = api[k]
+      body += `    assert.equal(typeof ${name}.${r}.${k}, '${typeof v}', '${name}.${r}.${k}')\n`
+    }
+  }
+  body += '  })\n'
+  body += '})\n'
+}
 
-apis.forEach((name) => {
-  const api = vendor[name]
-  const methods = Object.entries(api)
-  const formatAssert = (k, v, prefix = '    ') =>
-    `${prefix}assert.equal(typeof ${name}.${k}, '${typeof v}', '${name}.${k}')`
-  const methodChecks = methods.length
-    ? '\n' + methods.map(([k, v]) => formatAssert(k, v)).join('\n')
-    : ''
-  fileContents += `
-describe('vendor ${name} API ', () => {
-  // prettier-ignore
-  test('exports', () => {
-    assert.equal(typeof ${name}, '${typeof api}')${methodChecks}
-  })
-})
-`
-})
+const contents = head + body
 
-fs.writeFileSync(filePath, fileContents)
+fs.writeFileSync(filePath, contents)
diff --git a/src/cli.ts b/src/cli.ts
index 8800a2d156..74d2b60853 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -108,7 +108,7 @@ export async function main() {
     await runScript(argv.eval, argv.ext)
     return
   }
-  const firstArg = argv._[0]
+  const [firstArg] = argv._
   updateArgv(argv._.slice(firstArg === undefined ? 0 : 1))
   if (!firstArg || firstArg === '-') {
     const success = await scriptFromStdin(argv.ext)
diff --git a/src/core.ts b/src/core.ts
index 465259674e..55d6ba49f0 100644
--- a/src/core.ts
+++ b/src/core.ts
@@ -63,6 +63,7 @@ const CWD = Symbol('processCwd')
 const SYNC = Symbol('syncExec')
 const EOL = Buffer.from(_EOL)
 const SIGTERM = 'SIGTERM'
+const ENV_PREFIX = 'ZX_'
 const storage = new AsyncLocalStorage<Options>()
 
 function getStore() {
@@ -857,7 +858,7 @@ const promisifyStream = <S extends Writable>(
 
 export function resolveDefaults(
   defs: Options,
-  prefix: string = 'ZX_',
+  prefix: string = ENV_PREFIX,
   env = process.env
 ) {
   const allowed = new Set([
diff --git a/test/all.test.js b/test/all.test.js
index 005e2d39a1..996d569bff 100644
--- a/test/all.test.js
+++ b/test/all.test.js
@@ -21,5 +21,5 @@ import './goods.test.js'
 import './index.test.js'
 import './package.test.js'
 import './util.test.js'
-import './vendor-yaml.test.js'
-import './vendor-export.test.js'
+import './yaml.test.js'
+import './export.test.js'
diff --git a/test/cli.test.js b/test/cli.test.js
index 11b692affd..0d724006b8 100644
--- a/test/cli.test.js
+++ b/test/cli.test.js
@@ -18,7 +18,20 @@ import { fileURLToPath } from 'node:url'
 import net from 'node:net'
 import getPort from 'get-port'
 import '../build/globals.js'
-import { isMain, normalizeExt, transformMarkdown } from '../build/cli.js'
+import {
+  argv,
+  importPath,
+  injectGlobalRequire,
+  isMain,
+  main,
+  normalizeExt,
+  runScript,
+  printUsage,
+  scriptFromStdin,
+  scriptFromHttp,
+  transformMarkdown,
+  writeAndImport,
+} from '../build/cli.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const spawn = $.spawn
@@ -38,7 +51,7 @@ const getServer = (resp = [], log = console.log) => {
 }
 
 describe('cli', () => {
-  // Helps detect unresolved ProcessPromise.
+  // Helps to detect unresolved ProcessPromise.
   before(() => {
     const spawned = []
     $.spawn = (...args) => {
diff --git a/test/core.test.js b/test/core.test.js
index f690654db3..6cdce281fb 100644
--- a/test/core.test.js
+++ b/test/core.test.js
@@ -20,11 +20,20 @@ import { WriteStream } from 'node:fs'
 import { Readable, Transform, Writable } from 'node:stream'
 import { Socket } from 'node:net'
 import {
+  $,
   ProcessPromise,
   ProcessOutput,
   resolveDefaults,
-} from '../build/index.js'
-import '../build/globals.js'
+  cd,
+  syncProcessCwd,
+  log,
+  kill,
+  defaults,
+  within,
+  usePowerShell,
+  usePwsh,
+  useBash,
+} from '../build/core.js'
 
 describe('core', () => {
   describe('resolveDefaults()', () => {
diff --git a/test/export.test.js b/test/export.test.js
new file mode 100644
index 0000000000..8b714d11d6
--- /dev/null
+++ b/test/export.test.js
@@ -0,0 +1,622 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import assert from 'node:assert'
+import { test, describe } from 'node:test'
+import * as core from '../build/core.js'
+import * as cli from '../build/cli.js'
+import * as index from '../build/index.js'
+import * as vendor from '../build/vendor.js'
+
+//prettier-ignore
+describe('core', () => {
+  test('exports', () => {
+    assert.equal(typeof core.$, 'function', 'core.$')
+    assert.equal(typeof core.ProcessOutput, 'function', 'core.ProcessOutput')
+    assert.equal(typeof core.ProcessOutput.getErrorMessage, 'function', 'core.ProcessOutput.getErrorMessage')
+    assert.equal(typeof core.ProcessOutput.getExitMessage, 'function', 'core.ProcessOutput.getExitMessage')
+    assert.equal(typeof core.ProcessPromise, 'function', 'core.ProcessPromise')
+    assert.equal(typeof core.cd, 'function', 'core.cd')
+    assert.equal(typeof core.defaults, 'object', 'core.defaults')
+    assert.equal(typeof core.defaults.detached, 'boolean', 'core.defaults.detached')
+    assert.equal(typeof core.defaults.env, 'object', 'core.defaults.env')
+    assert.equal(typeof core.defaults.kill, 'function', 'core.defaults.kill')
+    assert.equal(typeof core.defaults.killSignal, 'string', 'core.defaults.killSignal')
+    assert.equal(typeof core.defaults.log, 'function', 'core.defaults.log')
+    assert.equal(typeof core.defaults.nothrow, 'boolean', 'core.defaults.nothrow')
+    assert.equal(typeof core.defaults.postfix, 'string', 'core.defaults.postfix')
+    assert.equal(typeof core.defaults.preferLocal, 'boolean', 'core.defaults.preferLocal')
+    assert.equal(typeof core.defaults.prefix, 'string', 'core.defaults.prefix')
+    assert.equal(typeof core.defaults.quiet, 'boolean', 'core.defaults.quiet')
+    assert.equal(typeof core.defaults.quote, 'function', 'core.defaults.quote')
+    assert.equal(typeof core.defaults.shell, 'string', 'core.defaults.shell')
+    assert.equal(typeof core.defaults.spawn, 'function', 'core.defaults.spawn')
+    assert.equal(typeof core.defaults.spawnSync, 'function', 'core.defaults.spawnSync')
+    assert.equal(typeof core.defaults.stdio, 'string', 'core.defaults.stdio')
+    assert.equal(typeof core.defaults.sync, 'boolean', 'core.defaults.sync')
+    assert.equal(typeof core.defaults.timeoutSignal, 'string', 'core.defaults.timeoutSignal')
+    assert.equal(typeof core.defaults.verbose, 'boolean', 'core.defaults.verbose')
+    assert.equal(typeof core.kill, 'function', 'core.kill')
+    assert.equal(typeof core.log, 'function', 'core.log')
+    assert.equal(typeof core.resolveDefaults, 'function', 'core.resolveDefaults')
+    assert.equal(typeof core.syncProcessCwd, 'function', 'core.syncProcessCwd')
+    assert.equal(typeof core.useBash, 'function', 'core.useBash')
+    assert.equal(typeof core.usePowerShell, 'function', 'core.usePowerShell')
+    assert.equal(typeof core.usePwsh, 'function', 'core.usePwsh')
+    assert.equal(typeof core.within, 'function', 'core.within')
+  })
+})
+
+//prettier-ignore
+describe('cli', () => {
+  test('exports', () => {
+    assert.equal(typeof cli.argv, 'object', 'cli.argv')
+    assert.equal(typeof cli.argv._, 'object', 'cli.argv._')
+    assert.equal(typeof cli.argv.experimental, 'boolean', 'cli.argv.experimental')
+    assert.equal(typeof cli.argv.h, 'boolean', 'cli.argv.h')
+    assert.equal(typeof cli.argv.help, 'boolean', 'cli.argv.help')
+    assert.equal(typeof cli.argv.i, 'boolean', 'cli.argv.i')
+    assert.equal(typeof cli.argv.install, 'boolean', 'cli.argv.install')
+    assert.equal(typeof cli.argv.l, 'boolean', 'cli.argv.l')
+    assert.equal(typeof cli.argv.preferLocal, 'boolean', 'cli.argv.preferLocal')
+    assert.equal(typeof cli.argv.quiet, 'boolean', 'cli.argv.quiet')
+    assert.equal(typeof cli.argv.repl, 'boolean', 'cli.argv.repl')
+    assert.equal(typeof cli.argv.v, 'boolean', 'cli.argv.v')
+    assert.equal(typeof cli.argv.verbose, 'boolean', 'cli.argv.verbose')
+    assert.equal(typeof cli.argv.version, 'boolean', 'cli.argv.version')
+    assert.equal(typeof cli.importPath, 'function', 'cli.importPath')
+    assert.equal(typeof cli.injectGlobalRequire, 'function', 'cli.injectGlobalRequire')
+    assert.equal(typeof cli.isMain, 'function', 'cli.isMain')
+    assert.equal(typeof cli.main, 'function', 'cli.main')
+    assert.equal(typeof cli.normalizeExt, 'function', 'cli.normalizeExt')
+    assert.equal(typeof cli.printUsage, 'function', 'cli.printUsage')
+    assert.equal(typeof cli.runScript, 'function', 'cli.runScript')
+    assert.equal(typeof cli.scriptFromHttp, 'function', 'cli.scriptFromHttp')
+    assert.equal(typeof cli.scriptFromStdin, 'function', 'cli.scriptFromStdin')
+    assert.equal(typeof cli.startRepl, 'undefined', 'cli.startRepl')
+    assert.equal(typeof cli.transformMarkdown, 'function', 'cli.transformMarkdown')
+    assert.equal(typeof cli.writeAndImport, 'function', 'cli.writeAndImport')
+  })
+})
+
+//prettier-ignore
+describe('index', () => {
+  test('exports', () => {
+    assert.equal(typeof index.$, 'function', 'index.$')
+    assert.equal(typeof index.ProcessOutput, 'function', 'index.ProcessOutput')
+    assert.equal(typeof index.ProcessOutput.getErrorMessage, 'function', 'index.ProcessOutput.getErrorMessage')
+    assert.equal(typeof index.ProcessOutput.getExitMessage, 'function', 'index.ProcessOutput.getExitMessage')
+    assert.equal(typeof index.ProcessPromise, 'function', 'index.ProcessPromise')
+    assert.equal(typeof index.VERSION, 'string', 'index.VERSION')
+    assert.equal(typeof index.YAML, 'object', 'index.YAML')
+    assert.equal(typeof index.YAML.Alias, 'function', 'index.YAML.Alias')
+    assert.equal(typeof index.YAML.CST, 'object', 'index.YAML.CST')
+    assert.equal(typeof index.YAML.Composer, 'function', 'index.YAML.Composer')
+    assert.equal(typeof index.YAML.Document, 'function', 'index.YAML.Document')
+    assert.equal(typeof index.YAML.Lexer, 'function', 'index.YAML.Lexer')
+    assert.equal(typeof index.YAML.LineCounter, 'function', 'index.YAML.LineCounter')
+    assert.equal(typeof index.YAML.Pair, 'function', 'index.YAML.Pair')
+    assert.equal(typeof index.YAML.Parser, 'function', 'index.YAML.Parser')
+    assert.equal(typeof index.YAML.Scalar, 'function', 'index.YAML.Scalar')
+    assert.equal(typeof index.YAML.Schema, 'function', 'index.YAML.Schema')
+    assert.equal(typeof index.YAML.YAMLError, 'function', 'index.YAML.YAMLError')
+    assert.equal(typeof index.YAML.YAMLMap, 'function', 'index.YAML.YAMLMap')
+    assert.equal(typeof index.YAML.YAMLParseError, 'function', 'index.YAML.YAMLParseError')
+    assert.equal(typeof index.YAML.YAMLSeq, 'function', 'index.YAML.YAMLSeq')
+    assert.equal(typeof index.YAML.YAMLWarning, 'function', 'index.YAML.YAMLWarning')
+    assert.equal(typeof index.YAML.default, 'object', 'index.YAML.default')
+    assert.equal(typeof index.YAML.isAlias, 'function', 'index.YAML.isAlias')
+    assert.equal(typeof index.YAML.isCollection, 'function', 'index.YAML.isCollection')
+    assert.equal(typeof index.YAML.isDocument, 'function', 'index.YAML.isDocument')
+    assert.equal(typeof index.YAML.isMap, 'function', 'index.YAML.isMap')
+    assert.equal(typeof index.YAML.isNode, 'function', 'index.YAML.isNode')
+    assert.equal(typeof index.YAML.isPair, 'function', 'index.YAML.isPair')
+    assert.equal(typeof index.YAML.isScalar, 'function', 'index.YAML.isScalar')
+    assert.equal(typeof index.YAML.isSeq, 'function', 'index.YAML.isSeq')
+    assert.equal(typeof index.YAML.parse, 'function', 'index.YAML.parse')
+    assert.equal(typeof index.YAML.parseAllDocuments, 'function', 'index.YAML.parseAllDocuments')
+    assert.equal(typeof index.YAML.parseDocument, 'function', 'index.YAML.parseDocument')
+    assert.equal(typeof index.YAML.stringify, 'function', 'index.YAML.stringify')
+    assert.equal(typeof index.YAML.visit, 'function', 'index.YAML.visit')
+    assert.equal(typeof index.YAML.visitAsync, 'function', 'index.YAML.visitAsync')
+    assert.equal(typeof index.argv, 'object', 'index.argv')
+    assert.equal(typeof index.argv._, 'object', 'index.argv._')
+    assert.equal(typeof index.cd, 'function', 'index.cd')
+    assert.equal(typeof index.chalk, 'function', 'index.chalk')
+    assert.equal(typeof index.chalk.level, 'number', 'index.chalk.level')
+    assert.equal(typeof index.defaults, 'object', 'index.defaults')
+    assert.equal(typeof index.defaults.detached, 'boolean', 'index.defaults.detached')
+    assert.equal(typeof index.defaults.env, 'object', 'index.defaults.env')
+    assert.equal(typeof index.defaults.kill, 'function', 'index.defaults.kill')
+    assert.equal(typeof index.defaults.killSignal, 'string', 'index.defaults.killSignal')
+    assert.equal(typeof index.defaults.log, 'function', 'index.defaults.log')
+    assert.equal(typeof index.defaults.nothrow, 'boolean', 'index.defaults.nothrow')
+    assert.equal(typeof index.defaults.postfix, 'string', 'index.defaults.postfix')
+    assert.equal(typeof index.defaults.preferLocal, 'boolean', 'index.defaults.preferLocal')
+    assert.equal(typeof index.defaults.prefix, 'string', 'index.defaults.prefix')
+    assert.equal(typeof index.defaults.quiet, 'boolean', 'index.defaults.quiet')
+    assert.equal(typeof index.defaults.quote, 'function', 'index.defaults.quote')
+    assert.equal(typeof index.defaults.shell, 'string', 'index.defaults.shell')
+    assert.equal(typeof index.defaults.spawn, 'function', 'index.defaults.spawn')
+    assert.equal(typeof index.defaults.spawnSync, 'function', 'index.defaults.spawnSync')
+    assert.equal(typeof index.defaults.stdio, 'string', 'index.defaults.stdio')
+    assert.equal(typeof index.defaults.sync, 'boolean', 'index.defaults.sync')
+    assert.equal(typeof index.defaults.timeoutSignal, 'string', 'index.defaults.timeoutSignal')
+    assert.equal(typeof index.defaults.verbose, 'boolean', 'index.defaults.verbose')
+    assert.equal(typeof index.echo, 'function', 'index.echo')
+    assert.equal(typeof index.expBackoff, 'function', 'index.expBackoff')
+    assert.equal(typeof index.fetch, 'function', 'index.fetch')
+    assert.equal(typeof index.fs, 'object', 'index.fs')
+    assert.equal(typeof index.fs.Dir, 'function', 'index.fs.Dir')
+    assert.equal(typeof index.fs.Dirent, 'function', 'index.fs.Dirent')
+    assert.equal(typeof index.fs.F_OK, 'number', 'index.fs.F_OK')
+    assert.equal(typeof index.fs.FileReadStream, 'function', 'index.fs.FileReadStream')
+    assert.equal(typeof index.fs.FileWriteStream, 'function', 'index.fs.FileWriteStream')
+    assert.equal(typeof index.fs.R_OK, 'number', 'index.fs.R_OK')
+    assert.equal(typeof index.fs.ReadStream, 'function', 'index.fs.ReadStream')
+    assert.equal(typeof index.fs.Stats, 'function', 'index.fs.Stats')
+    assert.equal(typeof index.fs.W_OK, 'number', 'index.fs.W_OK')
+    assert.equal(typeof index.fs.WriteStream, 'function', 'index.fs.WriteStream')
+    assert.equal(typeof index.fs.X_OK, 'number', 'index.fs.X_OK')
+    assert.equal(typeof index.fs._toUnixTimestamp, 'function', 'index.fs._toUnixTimestamp')
+    assert.equal(typeof index.fs.access, 'function', 'index.fs.access')
+    assert.equal(typeof index.fs.accessSync, 'function', 'index.fs.accessSync')
+    assert.equal(typeof index.fs.appendFile, 'function', 'index.fs.appendFile')
+    assert.equal(typeof index.fs.appendFileSync, 'function', 'index.fs.appendFileSync')
+    assert.equal(typeof index.fs.chmod, 'function', 'index.fs.chmod')
+    assert.equal(typeof index.fs.chmodSync, 'function', 'index.fs.chmodSync')
+    assert.equal(typeof index.fs.chown, 'function', 'index.fs.chown')
+    assert.equal(typeof index.fs.chownSync, 'function', 'index.fs.chownSync')
+    assert.equal(typeof index.fs.close, 'function', 'index.fs.close')
+    assert.equal(typeof index.fs.closeSync, 'function', 'index.fs.closeSync')
+    assert.equal(typeof index.fs.constants, 'object', 'index.fs.constants')
+    assert.equal(typeof index.fs.copy, 'function', 'index.fs.copy')
+    assert.equal(typeof index.fs.copyFile, 'function', 'index.fs.copyFile')
+    assert.equal(typeof index.fs.copyFileSync, 'function', 'index.fs.copyFileSync')
+    assert.equal(typeof index.fs.copySync, 'function', 'index.fs.copySync')
+    assert.equal(typeof index.fs.cp, 'function', 'index.fs.cp')
+    assert.equal(typeof index.fs.cpSync, 'function', 'index.fs.cpSync')
+    assert.equal(typeof index.fs.createFile, 'function', 'index.fs.createFile')
+    assert.equal(typeof index.fs.createFileSync, 'function', 'index.fs.createFileSync')
+    assert.equal(typeof index.fs.createLink, 'function', 'index.fs.createLink')
+    assert.equal(typeof index.fs.createLinkSync, 'function', 'index.fs.createLinkSync')
+    assert.equal(typeof index.fs.createReadStream, 'function', 'index.fs.createReadStream')
+    assert.equal(typeof index.fs.createSymlink, 'function', 'index.fs.createSymlink')
+    assert.equal(typeof index.fs.createSymlinkSync, 'function', 'index.fs.createSymlinkSync')
+    assert.equal(typeof index.fs.createWriteStream, 'function', 'index.fs.createWriteStream')
+    assert.equal(typeof index.fs.default, 'object', 'index.fs.default')
+    assert.equal(typeof index.fs.emptyDir, 'function', 'index.fs.emptyDir')
+    assert.equal(typeof index.fs.emptyDirSync, 'function', 'index.fs.emptyDirSync')
+    assert.equal(typeof index.fs.emptydir, 'function', 'index.fs.emptydir')
+    assert.equal(typeof index.fs.emptydirSync, 'function', 'index.fs.emptydirSync')
+    assert.equal(typeof index.fs.ensureDir, 'function', 'index.fs.ensureDir')
+    assert.equal(typeof index.fs.ensureDirSync, 'function', 'index.fs.ensureDirSync')
+    assert.equal(typeof index.fs.ensureFile, 'function', 'index.fs.ensureFile')
+    assert.equal(typeof index.fs.ensureFileSync, 'function', 'index.fs.ensureFileSync')
+    assert.equal(typeof index.fs.ensureLink, 'function', 'index.fs.ensureLink')
+    assert.equal(typeof index.fs.ensureLinkSync, 'function', 'index.fs.ensureLinkSync')
+    assert.equal(typeof index.fs.ensureSymlink, 'function', 'index.fs.ensureSymlink')
+    assert.equal(typeof index.fs.ensureSymlinkSync, 'function', 'index.fs.ensureSymlinkSync')
+    assert.equal(typeof index.fs.exists, 'function', 'index.fs.exists')
+    assert.equal(typeof index.fs.existsSync, 'function', 'index.fs.existsSync')
+    assert.equal(typeof index.fs.fchmod, 'function', 'index.fs.fchmod')
+    assert.equal(typeof index.fs.fchmodSync, 'function', 'index.fs.fchmodSync')
+    assert.equal(typeof index.fs.fchown, 'function', 'index.fs.fchown')
+    assert.equal(typeof index.fs.fchownSync, 'function', 'index.fs.fchownSync')
+    assert.equal(typeof index.fs.fdatasync, 'function', 'index.fs.fdatasync')
+    assert.equal(typeof index.fs.fdatasyncSync, 'function', 'index.fs.fdatasyncSync')
+    assert.equal(typeof index.fs.fstat, 'function', 'index.fs.fstat')
+    assert.equal(typeof index.fs.fstatSync, 'function', 'index.fs.fstatSync')
+    assert.equal(typeof index.fs.fsync, 'function', 'index.fs.fsync')
+    assert.equal(typeof index.fs.fsyncSync, 'function', 'index.fs.fsyncSync')
+    assert.equal(typeof index.fs.ftruncate, 'function', 'index.fs.ftruncate')
+    assert.equal(typeof index.fs.ftruncateSync, 'function', 'index.fs.ftruncateSync')
+    assert.equal(typeof index.fs.futimes, 'function', 'index.fs.futimes')
+    assert.equal(typeof index.fs.futimesSync, 'function', 'index.fs.futimesSync')
+    assert.equal(typeof index.fs.glob, 'function', 'index.fs.glob')
+    assert.equal(typeof index.fs.globSync, 'function', 'index.fs.globSync')
+    assert.equal(typeof index.fs.gracefulify, 'function', 'index.fs.gracefulify')
+    assert.equal(typeof index.fs.lchmod, 'function', 'index.fs.lchmod')
+    assert.equal(typeof index.fs.lchmodSync, 'function', 'index.fs.lchmodSync')
+    assert.equal(typeof index.fs.lchown, 'function', 'index.fs.lchown')
+    assert.equal(typeof index.fs.lchownSync, 'function', 'index.fs.lchownSync')
+    assert.equal(typeof index.fs.link, 'function', 'index.fs.link')
+    assert.equal(typeof index.fs.linkSync, 'function', 'index.fs.linkSync')
+    assert.equal(typeof index.fs.lstat, 'function', 'index.fs.lstat')
+    assert.equal(typeof index.fs.lstatSync, 'function', 'index.fs.lstatSync')
+    assert.equal(typeof index.fs.lutimes, 'function', 'index.fs.lutimes')
+    assert.equal(typeof index.fs.lutimesSync, 'function', 'index.fs.lutimesSync')
+    assert.equal(typeof index.fs.mkdir, 'function', 'index.fs.mkdir')
+    assert.equal(typeof index.fs.mkdirSync, 'function', 'index.fs.mkdirSync')
+    assert.equal(typeof index.fs.mkdirp, 'function', 'index.fs.mkdirp')
+    assert.equal(typeof index.fs.mkdirpSync, 'function', 'index.fs.mkdirpSync')
+    assert.equal(typeof index.fs.mkdirs, 'function', 'index.fs.mkdirs')
+    assert.equal(typeof index.fs.mkdirsSync, 'function', 'index.fs.mkdirsSync')
+    assert.equal(typeof index.fs.mkdtemp, 'function', 'index.fs.mkdtemp')
+    assert.equal(typeof index.fs.mkdtempSync, 'function', 'index.fs.mkdtempSync')
+    assert.equal(typeof index.fs.move, 'function', 'index.fs.move')
+    assert.equal(typeof index.fs.moveSync, 'function', 'index.fs.moveSync')
+    assert.equal(typeof index.fs.open, 'function', 'index.fs.open')
+    assert.equal(typeof index.fs.openAsBlob, 'function', 'index.fs.openAsBlob')
+    assert.equal(typeof index.fs.openSync, 'function', 'index.fs.openSync')
+    assert.equal(typeof index.fs.opendir, 'function', 'index.fs.opendir')
+    assert.equal(typeof index.fs.opendirSync, 'function', 'index.fs.opendirSync')
+    assert.equal(typeof index.fs.outputFile, 'function', 'index.fs.outputFile')
+    assert.equal(typeof index.fs.outputFileSync, 'function', 'index.fs.outputFileSync')
+    assert.equal(typeof index.fs.outputJSON, 'function', 'index.fs.outputJSON')
+    assert.equal(typeof index.fs.outputJSONSync, 'function', 'index.fs.outputJSONSync')
+    assert.equal(typeof index.fs.outputJson, 'function', 'index.fs.outputJson')
+    assert.equal(typeof index.fs.outputJsonSync, 'function', 'index.fs.outputJsonSync')
+    assert.equal(typeof index.fs.pathExists, 'function', 'index.fs.pathExists')
+    assert.equal(typeof index.fs.pathExistsSync, 'function', 'index.fs.pathExistsSync')
+    assert.equal(typeof index.fs.promises, 'object', 'index.fs.promises')
+    assert.equal(typeof index.fs.read, 'function', 'index.fs.read')
+    assert.equal(typeof index.fs.readFile, 'function', 'index.fs.readFile')
+    assert.equal(typeof index.fs.readFileSync, 'function', 'index.fs.readFileSync')
+    assert.equal(typeof index.fs.readJSON, 'function', 'index.fs.readJSON')
+    assert.equal(typeof index.fs.readJSONSync, 'function', 'index.fs.readJSONSync')
+    assert.equal(typeof index.fs.readJson, 'function', 'index.fs.readJson')
+    assert.equal(typeof index.fs.readJsonSync, 'function', 'index.fs.readJsonSync')
+    assert.equal(typeof index.fs.readSync, 'function', 'index.fs.readSync')
+    assert.equal(typeof index.fs.readdir, 'function', 'index.fs.readdir')
+    assert.equal(typeof index.fs.readdirSync, 'function', 'index.fs.readdirSync')
+    assert.equal(typeof index.fs.readlink, 'function', 'index.fs.readlink')
+    assert.equal(typeof index.fs.readlinkSync, 'function', 'index.fs.readlinkSync')
+    assert.equal(typeof index.fs.readv, 'function', 'index.fs.readv')
+    assert.equal(typeof index.fs.readvSync, 'function', 'index.fs.readvSync')
+    assert.equal(typeof index.fs.realpath, 'function', 'index.fs.realpath')
+    assert.equal(typeof index.fs.realpathSync, 'function', 'index.fs.realpathSync')
+    assert.equal(typeof index.fs.remove, 'function', 'index.fs.remove')
+    assert.equal(typeof index.fs.removeSync, 'function', 'index.fs.removeSync')
+    assert.equal(typeof index.fs.rename, 'function', 'index.fs.rename')
+    assert.equal(typeof index.fs.renameSync, 'function', 'index.fs.renameSync')
+    assert.equal(typeof index.fs.rm, 'function', 'index.fs.rm')
+    assert.equal(typeof index.fs.rmSync, 'function', 'index.fs.rmSync')
+    assert.equal(typeof index.fs.rmdir, 'function', 'index.fs.rmdir')
+    assert.equal(typeof index.fs.rmdirSync, 'function', 'index.fs.rmdirSync')
+    assert.equal(typeof index.fs.stat, 'function', 'index.fs.stat')
+    assert.equal(typeof index.fs.statSync, 'function', 'index.fs.statSync')
+    assert.equal(typeof index.fs.statfs, 'function', 'index.fs.statfs')
+    assert.equal(typeof index.fs.statfsSync, 'function', 'index.fs.statfsSync')
+    assert.equal(typeof index.fs.symlink, 'function', 'index.fs.symlink')
+    assert.equal(typeof index.fs.symlinkSync, 'function', 'index.fs.symlinkSync')
+    assert.equal(typeof index.fs.truncate, 'function', 'index.fs.truncate')
+    assert.equal(typeof index.fs.truncateSync, 'function', 'index.fs.truncateSync')
+    assert.equal(typeof index.fs.unlink, 'function', 'index.fs.unlink')
+    assert.equal(typeof index.fs.unlinkSync, 'function', 'index.fs.unlinkSync')
+    assert.equal(typeof index.fs.unwatchFile, 'function', 'index.fs.unwatchFile')
+    assert.equal(typeof index.fs.utimes, 'function', 'index.fs.utimes')
+    assert.equal(typeof index.fs.utimesSync, 'function', 'index.fs.utimesSync')
+    assert.equal(typeof index.fs.watch, 'function', 'index.fs.watch')
+    assert.equal(typeof index.fs.watchFile, 'function', 'index.fs.watchFile')
+    assert.equal(typeof index.fs.write, 'function', 'index.fs.write')
+    assert.equal(typeof index.fs.writeFile, 'function', 'index.fs.writeFile')
+    assert.equal(typeof index.fs.writeFileSync, 'function', 'index.fs.writeFileSync')
+    assert.equal(typeof index.fs.writeJSON, 'function', 'index.fs.writeJSON')
+    assert.equal(typeof index.fs.writeJSONSync, 'function', 'index.fs.writeJSONSync')
+    assert.equal(typeof index.fs.writeJson, 'function', 'index.fs.writeJson')
+    assert.equal(typeof index.fs.writeJsonSync, 'function', 'index.fs.writeJsonSync')
+    assert.equal(typeof index.fs.writeSync, 'function', 'index.fs.writeSync')
+    assert.equal(typeof index.fs.writev, 'function', 'index.fs.writev')
+    assert.equal(typeof index.fs.writevSync, 'function', 'index.fs.writevSync')
+    assert.equal(typeof index.glob, 'function', 'index.glob')
+    assert.equal(typeof index.glob.convertPathToPattern, 'function', 'index.glob.convertPathToPattern')
+    assert.equal(typeof index.glob.generateGlobTasks, 'function', 'index.glob.generateGlobTasks')
+    assert.equal(typeof index.glob.generateGlobTasksSync, 'function', 'index.glob.generateGlobTasksSync')
+    assert.equal(typeof index.glob.globby, 'function', 'index.glob.globby')
+    assert.equal(typeof index.glob.globbyStream, 'function', 'index.glob.globbyStream')
+    assert.equal(typeof index.glob.globbySync, 'function', 'index.glob.globbySync')
+    assert.equal(typeof index.glob.isDynamicPattern, 'function', 'index.glob.isDynamicPattern')
+    assert.equal(typeof index.glob.isGitIgnored, 'function', 'index.glob.isGitIgnored')
+    assert.equal(typeof index.glob.isGitIgnoredSync, 'function', 'index.glob.isGitIgnoredSync')
+    assert.equal(typeof index.globby, 'function', 'index.globby')
+    assert.equal(typeof index.globby.convertPathToPattern, 'function', 'index.globby.convertPathToPattern')
+    assert.equal(typeof index.globby.generateGlobTasks, 'function', 'index.globby.generateGlobTasks')
+    assert.equal(typeof index.globby.generateGlobTasksSync, 'function', 'index.globby.generateGlobTasksSync')
+    assert.equal(typeof index.globby.globby, 'function', 'index.globby.globby')
+    assert.equal(typeof index.globby.globbyStream, 'function', 'index.globby.globbyStream')
+    assert.equal(typeof index.globby.globbySync, 'function', 'index.globby.globbySync')
+    assert.equal(typeof index.globby.isDynamicPattern, 'function', 'index.globby.isDynamicPattern')
+    assert.equal(typeof index.globby.isGitIgnored, 'function', 'index.globby.isGitIgnored')
+    assert.equal(typeof index.globby.isGitIgnoredSync, 'function', 'index.globby.isGitIgnoredSync')
+    assert.equal(typeof index.kill, 'function', 'index.kill')
+    assert.equal(typeof index.log, 'function', 'index.log')
+    assert.equal(typeof index.minimist, 'function', 'index.minimist')
+    assert.equal(typeof index.nothrow, 'function', 'index.nothrow')
+    assert.equal(typeof index.os, 'object', 'index.os')
+    assert.equal(typeof index.os.EOL, 'string', 'index.os.EOL')
+    assert.equal(typeof index.os.arch, 'function', 'index.os.arch')
+    assert.equal(typeof index.os.availableParallelism, 'function', 'index.os.availableParallelism')
+    assert.equal(typeof index.os.constants, 'object', 'index.os.constants')
+    assert.equal(typeof index.os.cpus, 'function', 'index.os.cpus')
+    assert.equal(typeof index.os.default, 'object', 'index.os.default')
+    assert.equal(typeof index.os.devNull, 'string', 'index.os.devNull')
+    assert.equal(typeof index.os.endianness, 'function', 'index.os.endianness')
+    assert.equal(typeof index.os.freemem, 'function', 'index.os.freemem')
+    assert.equal(typeof index.os.getPriority, 'function', 'index.os.getPriority')
+    assert.equal(typeof index.os.homedir, 'function', 'index.os.homedir')
+    assert.equal(typeof index.os.hostname, 'function', 'index.os.hostname')
+    assert.equal(typeof index.os.loadavg, 'function', 'index.os.loadavg')
+    assert.equal(typeof index.os.machine, 'function', 'index.os.machine')
+    assert.equal(typeof index.os.networkInterfaces, 'function', 'index.os.networkInterfaces')
+    assert.equal(typeof index.os.platform, 'function', 'index.os.platform')
+    assert.equal(typeof index.os.release, 'function', 'index.os.release')
+    assert.equal(typeof index.os.setPriority, 'function', 'index.os.setPriority')
+    assert.equal(typeof index.os.tmpdir, 'function', 'index.os.tmpdir')
+    assert.equal(typeof index.os.totalmem, 'function', 'index.os.totalmem')
+    assert.equal(typeof index.os.type, 'function', 'index.os.type')
+    assert.equal(typeof index.os.uptime, 'function', 'index.os.uptime')
+    assert.equal(typeof index.os.userInfo, 'function', 'index.os.userInfo')
+    assert.equal(typeof index.os.version, 'function', 'index.os.version')
+    assert.equal(typeof index.parseArgv, 'function', 'index.parseArgv')
+    assert.equal(typeof index.path, 'object', 'index.path')
+    assert.equal(typeof index.path._makeLong, 'function', 'index.path._makeLong')
+    assert.equal(typeof index.path.basename, 'function', 'index.path.basename')
+    assert.equal(typeof index.path.delimiter, 'string', 'index.path.delimiter')
+    assert.equal(typeof index.path.dirname, 'function', 'index.path.dirname')
+    assert.equal(typeof index.path.extname, 'function', 'index.path.extname')
+    assert.equal(typeof index.path.format, 'function', 'index.path.format')
+    assert.equal(typeof index.path.isAbsolute, 'function', 'index.path.isAbsolute')
+    assert.equal(typeof index.path.join, 'function', 'index.path.join')
+    assert.equal(typeof index.path.matchesGlob, 'function', 'index.path.matchesGlob')
+    assert.equal(typeof index.path.normalize, 'function', 'index.path.normalize')
+    assert.equal(typeof index.path.parse, 'function', 'index.path.parse')
+    assert.equal(typeof index.path.posix, 'object', 'index.path.posix')
+    assert.equal(typeof index.path.relative, 'function', 'index.path.relative')
+    assert.equal(typeof index.path.resolve, 'function', 'index.path.resolve')
+    assert.equal(typeof index.path.sep, 'string', 'index.path.sep')
+    assert.equal(typeof index.path.toNamespacedPath, 'function', 'index.path.toNamespacedPath')
+    assert.equal(typeof index.path.win32, 'object', 'index.path.win32')
+    assert.equal(typeof index.ps, 'object', 'index.ps')
+    assert.equal(typeof index.ps.kill, 'function', 'index.ps.kill')
+    assert.equal(typeof index.ps.lookup, 'function', 'index.ps.lookup')
+    assert.equal(typeof index.ps.lookupSync, 'function', 'index.ps.lookupSync')
+    assert.equal(typeof index.ps.tree, 'function', 'index.ps.tree')
+    assert.equal(typeof index.ps.treeSync, 'function', 'index.ps.treeSync')
+    assert.equal(typeof index.question, 'function', 'index.question')
+    assert.equal(typeof index.quiet, 'function', 'index.quiet')
+    assert.equal(typeof index.quote, 'function', 'index.quote')
+    assert.equal(typeof index.quotePowerShell, 'function', 'index.quotePowerShell')
+    assert.equal(typeof index.resolveDefaults, 'function', 'index.resolveDefaults')
+    assert.equal(typeof index.retry, 'function', 'index.retry')
+    assert.equal(typeof index.sleep, 'function', 'index.sleep')
+    assert.equal(typeof index.spinner, 'function', 'index.spinner')
+    assert.equal(typeof index.stdin, 'function', 'index.stdin')
+    assert.equal(typeof index.syncProcessCwd, 'function', 'index.syncProcessCwd')
+    assert.equal(typeof index.tempdir, 'function', 'index.tempdir')
+    assert.equal(typeof index.tempfile, 'function', 'index.tempfile')
+    assert.equal(typeof index.tmpdir, 'function', 'index.tmpdir')
+    assert.equal(typeof index.tmpfile, 'function', 'index.tmpfile')
+    assert.equal(typeof index.updateArgv, 'function', 'index.updateArgv')
+    assert.equal(typeof index.useBash, 'function', 'index.useBash')
+    assert.equal(typeof index.usePowerShell, 'function', 'index.usePowerShell')
+    assert.equal(typeof index.usePwsh, 'function', 'index.usePwsh')
+    assert.equal(typeof index.version, 'string', 'index.version')
+    assert.equal(typeof index.which, 'function', 'index.which')
+    assert.equal(typeof index.which.sync, 'function', 'index.which.sync')
+    assert.equal(typeof index.within, 'function', 'index.within')
+  })
+})
+
+//prettier-ignore
+describe('vendor', () => {
+  test('exports', () => {
+    assert.equal(typeof vendor.chalk, 'function', 'vendor.chalk')
+    assert.equal(typeof vendor.chalk.level, 'number', 'vendor.chalk.level')
+    assert.equal(typeof vendor.depseek, 'function', 'vendor.depseek')
+    assert.equal(typeof vendor.fs, 'object', 'vendor.fs')
+    assert.equal(typeof vendor.fs.Dir, 'function', 'vendor.fs.Dir')
+    assert.equal(typeof vendor.fs.Dirent, 'function', 'vendor.fs.Dirent')
+    assert.equal(typeof vendor.fs.F_OK, 'number', 'vendor.fs.F_OK')
+    assert.equal(typeof vendor.fs.FileReadStream, 'function', 'vendor.fs.FileReadStream')
+    assert.equal(typeof vendor.fs.FileWriteStream, 'function', 'vendor.fs.FileWriteStream')
+    assert.equal(typeof vendor.fs.R_OK, 'number', 'vendor.fs.R_OK')
+    assert.equal(typeof vendor.fs.ReadStream, 'function', 'vendor.fs.ReadStream')
+    assert.equal(typeof vendor.fs.Stats, 'function', 'vendor.fs.Stats')
+    assert.equal(typeof vendor.fs.W_OK, 'number', 'vendor.fs.W_OK')
+    assert.equal(typeof vendor.fs.WriteStream, 'function', 'vendor.fs.WriteStream')
+    assert.equal(typeof vendor.fs.X_OK, 'number', 'vendor.fs.X_OK')
+    assert.equal(typeof vendor.fs._toUnixTimestamp, 'function', 'vendor.fs._toUnixTimestamp')
+    assert.equal(typeof vendor.fs.access, 'function', 'vendor.fs.access')
+    assert.equal(typeof vendor.fs.accessSync, 'function', 'vendor.fs.accessSync')
+    assert.equal(typeof vendor.fs.appendFile, 'function', 'vendor.fs.appendFile')
+    assert.equal(typeof vendor.fs.appendFileSync, 'function', 'vendor.fs.appendFileSync')
+    assert.equal(typeof vendor.fs.chmod, 'function', 'vendor.fs.chmod')
+    assert.equal(typeof vendor.fs.chmodSync, 'function', 'vendor.fs.chmodSync')
+    assert.equal(typeof vendor.fs.chown, 'function', 'vendor.fs.chown')
+    assert.equal(typeof vendor.fs.chownSync, 'function', 'vendor.fs.chownSync')
+    assert.equal(typeof vendor.fs.close, 'function', 'vendor.fs.close')
+    assert.equal(typeof vendor.fs.closeSync, 'function', 'vendor.fs.closeSync')
+    assert.equal(typeof vendor.fs.constants, 'object', 'vendor.fs.constants')
+    assert.equal(typeof vendor.fs.copy, 'function', 'vendor.fs.copy')
+    assert.equal(typeof vendor.fs.copyFile, 'function', 'vendor.fs.copyFile')
+    assert.equal(typeof vendor.fs.copyFileSync, 'function', 'vendor.fs.copyFileSync')
+    assert.equal(typeof vendor.fs.copySync, 'function', 'vendor.fs.copySync')
+    assert.equal(typeof vendor.fs.cp, 'function', 'vendor.fs.cp')
+    assert.equal(typeof vendor.fs.cpSync, 'function', 'vendor.fs.cpSync')
+    assert.equal(typeof vendor.fs.createFile, 'function', 'vendor.fs.createFile')
+    assert.equal(typeof vendor.fs.createFileSync, 'function', 'vendor.fs.createFileSync')
+    assert.equal(typeof vendor.fs.createLink, 'function', 'vendor.fs.createLink')
+    assert.equal(typeof vendor.fs.createLinkSync, 'function', 'vendor.fs.createLinkSync')
+    assert.equal(typeof vendor.fs.createReadStream, 'function', 'vendor.fs.createReadStream')
+    assert.equal(typeof vendor.fs.createSymlink, 'function', 'vendor.fs.createSymlink')
+    assert.equal(typeof vendor.fs.createSymlinkSync, 'function', 'vendor.fs.createSymlinkSync')
+    assert.equal(typeof vendor.fs.createWriteStream, 'function', 'vendor.fs.createWriteStream')
+    assert.equal(typeof vendor.fs.default, 'object', 'vendor.fs.default')
+    assert.equal(typeof vendor.fs.emptyDir, 'function', 'vendor.fs.emptyDir')
+    assert.equal(typeof vendor.fs.emptyDirSync, 'function', 'vendor.fs.emptyDirSync')
+    assert.equal(typeof vendor.fs.emptydir, 'function', 'vendor.fs.emptydir')
+    assert.equal(typeof vendor.fs.emptydirSync, 'function', 'vendor.fs.emptydirSync')
+    assert.equal(typeof vendor.fs.ensureDir, 'function', 'vendor.fs.ensureDir')
+    assert.equal(typeof vendor.fs.ensureDirSync, 'function', 'vendor.fs.ensureDirSync')
+    assert.equal(typeof vendor.fs.ensureFile, 'function', 'vendor.fs.ensureFile')
+    assert.equal(typeof vendor.fs.ensureFileSync, 'function', 'vendor.fs.ensureFileSync')
+    assert.equal(typeof vendor.fs.ensureLink, 'function', 'vendor.fs.ensureLink')
+    assert.equal(typeof vendor.fs.ensureLinkSync, 'function', 'vendor.fs.ensureLinkSync')
+    assert.equal(typeof vendor.fs.ensureSymlink, 'function', 'vendor.fs.ensureSymlink')
+    assert.equal(typeof vendor.fs.ensureSymlinkSync, 'function', 'vendor.fs.ensureSymlinkSync')
+    assert.equal(typeof vendor.fs.exists, 'function', 'vendor.fs.exists')
+    assert.equal(typeof vendor.fs.existsSync, 'function', 'vendor.fs.existsSync')
+    assert.equal(typeof vendor.fs.fchmod, 'function', 'vendor.fs.fchmod')
+    assert.equal(typeof vendor.fs.fchmodSync, 'function', 'vendor.fs.fchmodSync')
+    assert.equal(typeof vendor.fs.fchown, 'function', 'vendor.fs.fchown')
+    assert.equal(typeof vendor.fs.fchownSync, 'function', 'vendor.fs.fchownSync')
+    assert.equal(typeof vendor.fs.fdatasync, 'function', 'vendor.fs.fdatasync')
+    assert.equal(typeof vendor.fs.fdatasyncSync, 'function', 'vendor.fs.fdatasyncSync')
+    assert.equal(typeof vendor.fs.fstat, 'function', 'vendor.fs.fstat')
+    assert.equal(typeof vendor.fs.fstatSync, 'function', 'vendor.fs.fstatSync')
+    assert.equal(typeof vendor.fs.fsync, 'function', 'vendor.fs.fsync')
+    assert.equal(typeof vendor.fs.fsyncSync, 'function', 'vendor.fs.fsyncSync')
+    assert.equal(typeof vendor.fs.ftruncate, 'function', 'vendor.fs.ftruncate')
+    assert.equal(typeof vendor.fs.ftruncateSync, 'function', 'vendor.fs.ftruncateSync')
+    assert.equal(typeof vendor.fs.futimes, 'function', 'vendor.fs.futimes')
+    assert.equal(typeof vendor.fs.futimesSync, 'function', 'vendor.fs.futimesSync')
+    assert.equal(typeof vendor.fs.glob, 'function', 'vendor.fs.glob')
+    assert.equal(typeof vendor.fs.globSync, 'function', 'vendor.fs.globSync')
+    assert.equal(typeof vendor.fs.gracefulify, 'function', 'vendor.fs.gracefulify')
+    assert.equal(typeof vendor.fs.lchmod, 'function', 'vendor.fs.lchmod')
+    assert.equal(typeof vendor.fs.lchmodSync, 'function', 'vendor.fs.lchmodSync')
+    assert.equal(typeof vendor.fs.lchown, 'function', 'vendor.fs.lchown')
+    assert.equal(typeof vendor.fs.lchownSync, 'function', 'vendor.fs.lchownSync')
+    assert.equal(typeof vendor.fs.link, 'function', 'vendor.fs.link')
+    assert.equal(typeof vendor.fs.linkSync, 'function', 'vendor.fs.linkSync')
+    assert.equal(typeof vendor.fs.lstat, 'function', 'vendor.fs.lstat')
+    assert.equal(typeof vendor.fs.lstatSync, 'function', 'vendor.fs.lstatSync')
+    assert.equal(typeof vendor.fs.lutimes, 'function', 'vendor.fs.lutimes')
+    assert.equal(typeof vendor.fs.lutimesSync, 'function', 'vendor.fs.lutimesSync')
+    assert.equal(typeof vendor.fs.mkdir, 'function', 'vendor.fs.mkdir')
+    assert.equal(typeof vendor.fs.mkdirSync, 'function', 'vendor.fs.mkdirSync')
+    assert.equal(typeof vendor.fs.mkdirp, 'function', 'vendor.fs.mkdirp')
+    assert.equal(typeof vendor.fs.mkdirpSync, 'function', 'vendor.fs.mkdirpSync')
+    assert.equal(typeof vendor.fs.mkdirs, 'function', 'vendor.fs.mkdirs')
+    assert.equal(typeof vendor.fs.mkdirsSync, 'function', 'vendor.fs.mkdirsSync')
+    assert.equal(typeof vendor.fs.mkdtemp, 'function', 'vendor.fs.mkdtemp')
+    assert.equal(typeof vendor.fs.mkdtempSync, 'function', 'vendor.fs.mkdtempSync')
+    assert.equal(typeof vendor.fs.move, 'function', 'vendor.fs.move')
+    assert.equal(typeof vendor.fs.moveSync, 'function', 'vendor.fs.moveSync')
+    assert.equal(typeof vendor.fs.open, 'function', 'vendor.fs.open')
+    assert.equal(typeof vendor.fs.openAsBlob, 'function', 'vendor.fs.openAsBlob')
+    assert.equal(typeof vendor.fs.openSync, 'function', 'vendor.fs.openSync')
+    assert.equal(typeof vendor.fs.opendir, 'function', 'vendor.fs.opendir')
+    assert.equal(typeof vendor.fs.opendirSync, 'function', 'vendor.fs.opendirSync')
+    assert.equal(typeof vendor.fs.outputFile, 'function', 'vendor.fs.outputFile')
+    assert.equal(typeof vendor.fs.outputFileSync, 'function', 'vendor.fs.outputFileSync')
+    assert.equal(typeof vendor.fs.outputJSON, 'function', 'vendor.fs.outputJSON')
+    assert.equal(typeof vendor.fs.outputJSONSync, 'function', 'vendor.fs.outputJSONSync')
+    assert.equal(typeof vendor.fs.outputJson, 'function', 'vendor.fs.outputJson')
+    assert.equal(typeof vendor.fs.outputJsonSync, 'function', 'vendor.fs.outputJsonSync')
+    assert.equal(typeof vendor.fs.pathExists, 'function', 'vendor.fs.pathExists')
+    assert.equal(typeof vendor.fs.pathExistsSync, 'function', 'vendor.fs.pathExistsSync')
+    assert.equal(typeof vendor.fs.promises, 'object', 'vendor.fs.promises')
+    assert.equal(typeof vendor.fs.read, 'function', 'vendor.fs.read')
+    assert.equal(typeof vendor.fs.readFile, 'function', 'vendor.fs.readFile')
+    assert.equal(typeof vendor.fs.readFileSync, 'function', 'vendor.fs.readFileSync')
+    assert.equal(typeof vendor.fs.readJSON, 'function', 'vendor.fs.readJSON')
+    assert.equal(typeof vendor.fs.readJSONSync, 'function', 'vendor.fs.readJSONSync')
+    assert.equal(typeof vendor.fs.readJson, 'function', 'vendor.fs.readJson')
+    assert.equal(typeof vendor.fs.readJsonSync, 'function', 'vendor.fs.readJsonSync')
+    assert.equal(typeof vendor.fs.readSync, 'function', 'vendor.fs.readSync')
+    assert.equal(typeof vendor.fs.readdir, 'function', 'vendor.fs.readdir')
+    assert.equal(typeof vendor.fs.readdirSync, 'function', 'vendor.fs.readdirSync')
+    assert.equal(typeof vendor.fs.readlink, 'function', 'vendor.fs.readlink')
+    assert.equal(typeof vendor.fs.readlinkSync, 'function', 'vendor.fs.readlinkSync')
+    assert.equal(typeof vendor.fs.readv, 'function', 'vendor.fs.readv')
+    assert.equal(typeof vendor.fs.readvSync, 'function', 'vendor.fs.readvSync')
+    assert.equal(typeof vendor.fs.realpath, 'function', 'vendor.fs.realpath')
+    assert.equal(typeof vendor.fs.realpathSync, 'function', 'vendor.fs.realpathSync')
+    assert.equal(typeof vendor.fs.remove, 'function', 'vendor.fs.remove')
+    assert.equal(typeof vendor.fs.removeSync, 'function', 'vendor.fs.removeSync')
+    assert.equal(typeof vendor.fs.rename, 'function', 'vendor.fs.rename')
+    assert.equal(typeof vendor.fs.renameSync, 'function', 'vendor.fs.renameSync')
+    assert.equal(typeof vendor.fs.rm, 'function', 'vendor.fs.rm')
+    assert.equal(typeof vendor.fs.rmSync, 'function', 'vendor.fs.rmSync')
+    assert.equal(typeof vendor.fs.rmdir, 'function', 'vendor.fs.rmdir')
+    assert.equal(typeof vendor.fs.rmdirSync, 'function', 'vendor.fs.rmdirSync')
+    assert.equal(typeof vendor.fs.stat, 'function', 'vendor.fs.stat')
+    assert.equal(typeof vendor.fs.statSync, 'function', 'vendor.fs.statSync')
+    assert.equal(typeof vendor.fs.statfs, 'function', 'vendor.fs.statfs')
+    assert.equal(typeof vendor.fs.statfsSync, 'function', 'vendor.fs.statfsSync')
+    assert.equal(typeof vendor.fs.symlink, 'function', 'vendor.fs.symlink')
+    assert.equal(typeof vendor.fs.symlinkSync, 'function', 'vendor.fs.symlinkSync')
+    assert.equal(typeof vendor.fs.truncate, 'function', 'vendor.fs.truncate')
+    assert.equal(typeof vendor.fs.truncateSync, 'function', 'vendor.fs.truncateSync')
+    assert.equal(typeof vendor.fs.unlink, 'function', 'vendor.fs.unlink')
+    assert.equal(typeof vendor.fs.unlinkSync, 'function', 'vendor.fs.unlinkSync')
+    assert.equal(typeof vendor.fs.unwatchFile, 'function', 'vendor.fs.unwatchFile')
+    assert.equal(typeof vendor.fs.utimes, 'function', 'vendor.fs.utimes')
+    assert.equal(typeof vendor.fs.utimesSync, 'function', 'vendor.fs.utimesSync')
+    assert.equal(typeof vendor.fs.watch, 'function', 'vendor.fs.watch')
+    assert.equal(typeof vendor.fs.watchFile, 'function', 'vendor.fs.watchFile')
+    assert.equal(typeof vendor.fs.write, 'function', 'vendor.fs.write')
+    assert.equal(typeof vendor.fs.writeFile, 'function', 'vendor.fs.writeFile')
+    assert.equal(typeof vendor.fs.writeFileSync, 'function', 'vendor.fs.writeFileSync')
+    assert.equal(typeof vendor.fs.writeJSON, 'function', 'vendor.fs.writeJSON')
+    assert.equal(typeof vendor.fs.writeJSONSync, 'function', 'vendor.fs.writeJSONSync')
+    assert.equal(typeof vendor.fs.writeJson, 'function', 'vendor.fs.writeJson')
+    assert.equal(typeof vendor.fs.writeJsonSync, 'function', 'vendor.fs.writeJsonSync')
+    assert.equal(typeof vendor.fs.writeSync, 'function', 'vendor.fs.writeSync')
+    assert.equal(typeof vendor.fs.writev, 'function', 'vendor.fs.writev')
+    assert.equal(typeof vendor.fs.writevSync, 'function', 'vendor.fs.writevSync')
+    assert.equal(typeof vendor.glob, 'function', 'vendor.glob')
+    assert.equal(typeof vendor.glob.convertPathToPattern, 'function', 'vendor.glob.convertPathToPattern')
+    assert.equal(typeof vendor.glob.generateGlobTasks, 'function', 'vendor.glob.generateGlobTasks')
+    assert.equal(typeof vendor.glob.generateGlobTasksSync, 'function', 'vendor.glob.generateGlobTasksSync')
+    assert.equal(typeof vendor.glob.globby, 'function', 'vendor.glob.globby')
+    assert.equal(typeof vendor.glob.globbyStream, 'function', 'vendor.glob.globbyStream')
+    assert.equal(typeof vendor.glob.globbySync, 'function', 'vendor.glob.globbySync')
+    assert.equal(typeof vendor.glob.isDynamicPattern, 'function', 'vendor.glob.isDynamicPattern')
+    assert.equal(typeof vendor.glob.isGitIgnored, 'function', 'vendor.glob.isGitIgnored')
+    assert.equal(typeof vendor.glob.isGitIgnoredSync, 'function', 'vendor.glob.isGitIgnoredSync')
+    assert.equal(typeof vendor.minimist, 'function', 'vendor.minimist')
+    assert.equal(typeof vendor.ps, 'object', 'vendor.ps')
+    assert.equal(typeof vendor.ps.kill, 'function', 'vendor.ps.kill')
+    assert.equal(typeof vendor.ps.lookup, 'function', 'vendor.ps.lookup')
+    assert.equal(typeof vendor.ps.lookupSync, 'function', 'vendor.ps.lookupSync')
+    assert.equal(typeof vendor.ps.tree, 'function', 'vendor.ps.tree')
+    assert.equal(typeof vendor.ps.treeSync, 'function', 'vendor.ps.treeSync')
+    assert.equal(typeof vendor.which, 'function', 'vendor.which')
+    assert.equal(typeof vendor.which.sync, 'function', 'vendor.which.sync')
+    assert.equal(typeof vendor.YAML, 'object', 'vendor.YAML')
+    assert.equal(typeof vendor.YAML.Alias, 'function', 'vendor.YAML.Alias')
+    assert.equal(typeof vendor.YAML.CST, 'object', 'vendor.YAML.CST')
+    assert.equal(typeof vendor.YAML.Composer, 'function', 'vendor.YAML.Composer')
+    assert.equal(typeof vendor.YAML.Document, 'function', 'vendor.YAML.Document')
+    assert.equal(typeof vendor.YAML.Lexer, 'function', 'vendor.YAML.Lexer')
+    assert.equal(typeof vendor.YAML.LineCounter, 'function', 'vendor.YAML.LineCounter')
+    assert.equal(typeof vendor.YAML.Pair, 'function', 'vendor.YAML.Pair')
+    assert.equal(typeof vendor.YAML.Parser, 'function', 'vendor.YAML.Parser')
+    assert.equal(typeof vendor.YAML.Scalar, 'function', 'vendor.YAML.Scalar')
+    assert.equal(typeof vendor.YAML.Schema, 'function', 'vendor.YAML.Schema')
+    assert.equal(typeof vendor.YAML.YAMLError, 'function', 'vendor.YAML.YAMLError')
+    assert.equal(typeof vendor.YAML.YAMLMap, 'function', 'vendor.YAML.YAMLMap')
+    assert.equal(typeof vendor.YAML.YAMLParseError, 'function', 'vendor.YAML.YAMLParseError')
+    assert.equal(typeof vendor.YAML.YAMLSeq, 'function', 'vendor.YAML.YAMLSeq')
+    assert.equal(typeof vendor.YAML.YAMLWarning, 'function', 'vendor.YAML.YAMLWarning')
+    assert.equal(typeof vendor.YAML.default, 'object', 'vendor.YAML.default')
+    assert.equal(typeof vendor.YAML.isAlias, 'function', 'vendor.YAML.isAlias')
+    assert.equal(typeof vendor.YAML.isCollection, 'function', 'vendor.YAML.isCollection')
+    assert.equal(typeof vendor.YAML.isDocument, 'function', 'vendor.YAML.isDocument')
+    assert.equal(typeof vendor.YAML.isMap, 'function', 'vendor.YAML.isMap')
+    assert.equal(typeof vendor.YAML.isNode, 'function', 'vendor.YAML.isNode')
+    assert.equal(typeof vendor.YAML.isPair, 'function', 'vendor.YAML.isPair')
+    assert.equal(typeof vendor.YAML.isScalar, 'function', 'vendor.YAML.isScalar')
+    assert.equal(typeof vendor.YAML.isSeq, 'function', 'vendor.YAML.isSeq')
+    assert.equal(typeof vendor.YAML.parse, 'function', 'vendor.YAML.parse')
+    assert.equal(typeof vendor.YAML.parseAllDocuments, 'function', 'vendor.YAML.parseAllDocuments')
+    assert.equal(typeof vendor.YAML.parseDocument, 'function', 'vendor.YAML.parseDocument')
+    assert.equal(typeof vendor.YAML.stringify, 'function', 'vendor.YAML.stringify')
+    assert.equal(typeof vendor.YAML.visit, 'function', 'vendor.YAML.visit')
+    assert.equal(typeof vendor.YAML.visitAsync, 'function', 'vendor.YAML.visitAsync')
+  })
+})
diff --git a/test/index.test.js b/test/index.test.js
index 0d8a2b3255..768d06fc5b 100644
--- a/test/index.test.js
+++ b/test/index.test.js
@@ -106,12 +106,6 @@ describe('index', () => {
     assert(which)
     assert(YAML)
     assert(ps)
-    assert(ps.lookup)
-    assert(ps.lookup.sync)
-    assert(ps.lookupSync)
-    assert(ps.tree)
-    assert(ps.tree.sync)
-    assert(ps.treeSync)
 
     // utils
     assert(quote)
diff --git a/test/vendor-export.test.js b/test/vendor-export.test.js
deleted file mode 100644
index 864a4570d5..0000000000
--- a/test/vendor-export.test.js
+++ /dev/null
@@ -1,280 +0,0 @@
-// Copyright 2024 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import assert from 'node:assert'
-import { test, describe } from 'node:test'
-import {
-  chalk,
-  depseek,
-  fs,
-  glob,
-  minimist,
-  ps,
-  which,
-  YAML,
-} from '../build/vendor.js'
-
-describe('vendor chalk API ', () => {
-  // prettier-ignore
-  test('exports', () => {
-    assert.equal(typeof chalk, 'function')
-    assert.equal(typeof chalk.level, 'number', 'chalk.level')
-  })
-})
-
-describe('vendor depseek API ', () => {
-  // prettier-ignore
-  test('exports', () => {
-    assert.equal(typeof depseek, 'function')
-  })
-})
-
-describe('vendor fs API ', () => {
-  // prettier-ignore
-  test('exports', () => {
-    assert.equal(typeof fs, 'object')
-    assert.equal(typeof fs.default, 'object', 'fs.default')
-    assert.equal(typeof fs.appendFile, 'function', 'fs.appendFile')
-    assert.equal(typeof fs.appendFileSync, 'function', 'fs.appendFileSync')
-    assert.equal(typeof fs.access, 'function', 'fs.access')
-    assert.equal(typeof fs.accessSync, 'function', 'fs.accessSync')
-    assert.equal(typeof fs.chown, 'function', 'fs.chown')
-    assert.equal(typeof fs.chownSync, 'function', 'fs.chownSync')
-    assert.equal(typeof fs.chmod, 'function', 'fs.chmod')
-    assert.equal(typeof fs.chmodSync, 'function', 'fs.chmodSync')
-    assert.equal(typeof fs.close, 'function', 'fs.close')
-    assert.equal(typeof fs.closeSync, 'function', 'fs.closeSync')
-    assert.equal(typeof fs.copyFile, 'function', 'fs.copyFile')
-    assert.equal(typeof fs.copyFileSync, 'function', 'fs.copyFileSync')
-    assert.equal(typeof fs.cp, 'function', 'fs.cp')
-    assert.equal(typeof fs.cpSync, 'function', 'fs.cpSync')
-    assert.equal(typeof fs.createReadStream, 'function', 'fs.createReadStream')
-    assert.equal(typeof fs.createWriteStream, 'function', 'fs.createWriteStream')
-    assert.equal(typeof fs.exists, 'function', 'fs.exists')
-    assert.equal(typeof fs.existsSync, 'function', 'fs.existsSync')
-    assert.equal(typeof fs.fchown, 'function', 'fs.fchown')
-    assert.equal(typeof fs.fchownSync, 'function', 'fs.fchownSync')
-    assert.equal(typeof fs.fchmod, 'function', 'fs.fchmod')
-    assert.equal(typeof fs.fchmodSync, 'function', 'fs.fchmodSync')
-    assert.equal(typeof fs.fdatasync, 'function', 'fs.fdatasync')
-    assert.equal(typeof fs.fdatasyncSync, 'function', 'fs.fdatasyncSync')
-    assert.equal(typeof fs.fstat, 'function', 'fs.fstat')
-    assert.equal(typeof fs.fstatSync, 'function', 'fs.fstatSync')
-    assert.equal(typeof fs.fsync, 'function', 'fs.fsync')
-    assert.equal(typeof fs.fsyncSync, 'function', 'fs.fsyncSync')
-    assert.equal(typeof fs.ftruncate, 'function', 'fs.ftruncate')
-    assert.equal(typeof fs.ftruncateSync, 'function', 'fs.ftruncateSync')
-    assert.equal(typeof fs.futimes, 'function', 'fs.futimes')
-    assert.equal(typeof fs.futimesSync, 'function', 'fs.futimesSync')
-    assert.equal(typeof fs.glob, 'function', 'fs.glob')
-    assert.equal(typeof fs.globSync, 'function', 'fs.globSync')
-    assert.equal(typeof fs.lchown, 'function', 'fs.lchown')
-    assert.equal(typeof fs.lchownSync, 'function', 'fs.lchownSync')
-    assert.equal(typeof fs.lchmod, 'function', 'fs.lchmod')
-    assert.equal(typeof fs.lchmodSync, 'function', 'fs.lchmodSync')
-    assert.equal(typeof fs.link, 'function', 'fs.link')
-    assert.equal(typeof fs.linkSync, 'function', 'fs.linkSync')
-    assert.equal(typeof fs.lstat, 'function', 'fs.lstat')
-    assert.equal(typeof fs.lstatSync, 'function', 'fs.lstatSync')
-    assert.equal(typeof fs.lutimes, 'function', 'fs.lutimes')
-    assert.equal(typeof fs.lutimesSync, 'function', 'fs.lutimesSync')
-    assert.equal(typeof fs.mkdir, 'function', 'fs.mkdir')
-    assert.equal(typeof fs.mkdirSync, 'function', 'fs.mkdirSync')
-    assert.equal(typeof fs.mkdtemp, 'function', 'fs.mkdtemp')
-    assert.equal(typeof fs.mkdtempSync, 'function', 'fs.mkdtempSync')
-    assert.equal(typeof fs.open, 'function', 'fs.open')
-    assert.equal(typeof fs.openSync, 'function', 'fs.openSync')
-    assert.equal(typeof fs.openAsBlob, 'function', 'fs.openAsBlob')
-    assert.equal(typeof fs.readdir, 'function', 'fs.readdir')
-    assert.equal(typeof fs.readdirSync, 'function', 'fs.readdirSync')
-    assert.equal(typeof fs.read, 'function', 'fs.read')
-    assert.equal(typeof fs.readSync, 'function', 'fs.readSync')
-    assert.equal(typeof fs.readv, 'function', 'fs.readv')
-    assert.equal(typeof fs.readvSync, 'function', 'fs.readvSync')
-    assert.equal(typeof fs.readFile, 'function', 'fs.readFile')
-    assert.equal(typeof fs.readFileSync, 'function', 'fs.readFileSync')
-    assert.equal(typeof fs.readlink, 'function', 'fs.readlink')
-    assert.equal(typeof fs.readlinkSync, 'function', 'fs.readlinkSync')
-    assert.equal(typeof fs.realpath, 'function', 'fs.realpath')
-    assert.equal(typeof fs.realpathSync, 'function', 'fs.realpathSync')
-    assert.equal(typeof fs.rename, 'function', 'fs.rename')
-    assert.equal(typeof fs.renameSync, 'function', 'fs.renameSync')
-    assert.equal(typeof fs.rm, 'function', 'fs.rm')
-    assert.equal(typeof fs.rmSync, 'function', 'fs.rmSync')
-    assert.equal(typeof fs.rmdir, 'function', 'fs.rmdir')
-    assert.equal(typeof fs.rmdirSync, 'function', 'fs.rmdirSync')
-    assert.equal(typeof fs.stat, 'function', 'fs.stat')
-    assert.equal(typeof fs.statfs, 'function', 'fs.statfs')
-    assert.equal(typeof fs.statSync, 'function', 'fs.statSync')
-    assert.equal(typeof fs.statfsSync, 'function', 'fs.statfsSync')
-    assert.equal(typeof fs.symlink, 'function', 'fs.symlink')
-    assert.equal(typeof fs.symlinkSync, 'function', 'fs.symlinkSync')
-    assert.equal(typeof fs.truncate, 'function', 'fs.truncate')
-    assert.equal(typeof fs.truncateSync, 'function', 'fs.truncateSync')
-    assert.equal(typeof fs.unwatchFile, 'function', 'fs.unwatchFile')
-    assert.equal(typeof fs.unlink, 'function', 'fs.unlink')
-    assert.equal(typeof fs.unlinkSync, 'function', 'fs.unlinkSync')
-    assert.equal(typeof fs.utimes, 'function', 'fs.utimes')
-    assert.equal(typeof fs.utimesSync, 'function', 'fs.utimesSync')
-    assert.equal(typeof fs.watch, 'function', 'fs.watch')
-    assert.equal(typeof fs.watchFile, 'function', 'fs.watchFile')
-    assert.equal(typeof fs.writeFile, 'function', 'fs.writeFile')
-    assert.equal(typeof fs.writeFileSync, 'function', 'fs.writeFileSync')
-    assert.equal(typeof fs.write, 'function', 'fs.write')
-    assert.equal(typeof fs.writeSync, 'function', 'fs.writeSync')
-    assert.equal(typeof fs.writev, 'function', 'fs.writev')
-    assert.equal(typeof fs.writevSync, 'function', 'fs.writevSync')
-    assert.equal(typeof fs.Dirent, 'function', 'fs.Dirent')
-    assert.equal(typeof fs.Stats, 'function', 'fs.Stats')
-    assert.equal(typeof fs.ReadStream, 'function', 'fs.ReadStream')
-    assert.equal(typeof fs.WriteStream, 'function', 'fs.WriteStream')
-    assert.equal(typeof fs.FileReadStream, 'function', 'fs.FileReadStream')
-    assert.equal(typeof fs.FileWriteStream, 'function', 'fs.FileWriteStream')
-    assert.equal(typeof fs._toUnixTimestamp, 'function', 'fs._toUnixTimestamp')
-    assert.equal(typeof fs.Dir, 'function', 'fs.Dir')
-    assert.equal(typeof fs.opendir, 'function', 'fs.opendir')
-    assert.equal(typeof fs.opendirSync, 'function', 'fs.opendirSync')
-    assert.equal(typeof fs.F_OK, 'number', 'fs.F_OK')
-    assert.equal(typeof fs.R_OK, 'number', 'fs.R_OK')
-    assert.equal(typeof fs.W_OK, 'number', 'fs.W_OK')
-    assert.equal(typeof fs.X_OK, 'number', 'fs.X_OK')
-    assert.equal(typeof fs.constants, 'object', 'fs.constants')
-    assert.equal(typeof fs.promises, 'object', 'fs.promises')
-    assert.equal(typeof fs.gracefulify, 'function', 'fs.gracefulify')
-    assert.equal(typeof fs.copy, 'function', 'fs.copy')
-    assert.equal(typeof fs.copySync, 'function', 'fs.copySync')
-    assert.equal(typeof fs.emptyDirSync, 'function', 'fs.emptyDirSync')
-    assert.equal(typeof fs.emptydirSync, 'function', 'fs.emptydirSync')
-    assert.equal(typeof fs.emptyDir, 'function', 'fs.emptyDir')
-    assert.equal(typeof fs.emptydir, 'function', 'fs.emptydir')
-    assert.equal(typeof fs.createFile, 'function', 'fs.createFile')
-    assert.equal(typeof fs.createFileSync, 'function', 'fs.createFileSync')
-    assert.equal(typeof fs.ensureFile, 'function', 'fs.ensureFile')
-    assert.equal(typeof fs.ensureFileSync, 'function', 'fs.ensureFileSync')
-    assert.equal(typeof fs.createLink, 'function', 'fs.createLink')
-    assert.equal(typeof fs.createLinkSync, 'function', 'fs.createLinkSync')
-    assert.equal(typeof fs.ensureLink, 'function', 'fs.ensureLink')
-    assert.equal(typeof fs.ensureLinkSync, 'function', 'fs.ensureLinkSync')
-    assert.equal(typeof fs.createSymlink, 'function', 'fs.createSymlink')
-    assert.equal(typeof fs.createSymlinkSync, 'function', 'fs.createSymlinkSync')
-    assert.equal(typeof fs.ensureSymlink, 'function', 'fs.ensureSymlink')
-    assert.equal(typeof fs.ensureSymlinkSync, 'function', 'fs.ensureSymlinkSync')
-    assert.equal(typeof fs.readJson, 'function', 'fs.readJson')
-    assert.equal(typeof fs.readJsonSync, 'function', 'fs.readJsonSync')
-    assert.equal(typeof fs.writeJson, 'function', 'fs.writeJson')
-    assert.equal(typeof fs.writeJsonSync, 'function', 'fs.writeJsonSync')
-    assert.equal(typeof fs.outputJson, 'function', 'fs.outputJson')
-    assert.equal(typeof fs.outputJsonSync, 'function', 'fs.outputJsonSync')
-    assert.equal(typeof fs.outputJSON, 'function', 'fs.outputJSON')
-    assert.equal(typeof fs.outputJSONSync, 'function', 'fs.outputJSONSync')
-    assert.equal(typeof fs.writeJSON, 'function', 'fs.writeJSON')
-    assert.equal(typeof fs.writeJSONSync, 'function', 'fs.writeJSONSync')
-    assert.equal(typeof fs.readJSON, 'function', 'fs.readJSON')
-    assert.equal(typeof fs.readJSONSync, 'function', 'fs.readJSONSync')
-    assert.equal(typeof fs.mkdirs, 'function', 'fs.mkdirs')
-    assert.equal(typeof fs.mkdirsSync, 'function', 'fs.mkdirsSync')
-    assert.equal(typeof fs.mkdirp, 'function', 'fs.mkdirp')
-    assert.equal(typeof fs.mkdirpSync, 'function', 'fs.mkdirpSync')
-    assert.equal(typeof fs.ensureDir, 'function', 'fs.ensureDir')
-    assert.equal(typeof fs.ensureDirSync, 'function', 'fs.ensureDirSync')
-    assert.equal(typeof fs.move, 'function', 'fs.move')
-    assert.equal(typeof fs.moveSync, 'function', 'fs.moveSync')
-    assert.equal(typeof fs.outputFile, 'function', 'fs.outputFile')
-    assert.equal(typeof fs.outputFileSync, 'function', 'fs.outputFileSync')
-    assert.equal(typeof fs.pathExists, 'function', 'fs.pathExists')
-    assert.equal(typeof fs.pathExistsSync, 'function', 'fs.pathExistsSync')
-    assert.equal(typeof fs.remove, 'function', 'fs.remove')
-    assert.equal(typeof fs.removeSync, 'function', 'fs.removeSync')
-  })
-})
-
-describe('vendor glob API ', () => {
-  // prettier-ignore
-  test('exports', () => {
-    assert.equal(typeof glob, 'function')
-    assert.equal(typeof glob.convertPathToPattern, 'function', 'glob.convertPathToPattern')
-    assert.equal(typeof glob.globby, 'function', 'glob.globby')
-    assert.equal(typeof glob.globbySync, 'function', 'glob.globbySync')
-    assert.equal(typeof glob.globbyStream, 'function', 'glob.globbyStream')
-    assert.equal(typeof glob.generateGlobTasksSync, 'function', 'glob.generateGlobTasksSync')
-    assert.equal(typeof glob.generateGlobTasks, 'function', 'glob.generateGlobTasks')
-    assert.equal(typeof glob.isGitIgnoredSync, 'function', 'glob.isGitIgnoredSync')
-    assert.equal(typeof glob.isGitIgnored, 'function', 'glob.isGitIgnored')
-    assert.equal(typeof glob.isDynamicPattern, 'function', 'glob.isDynamicPattern')
-  })
-})
-
-describe('vendor minimist API ', () => {
-  // prettier-ignore
-  test('exports', () => {
-    assert.equal(typeof minimist, 'function')
-  })
-})
-
-describe('vendor ps API ', () => {
-  // prettier-ignore
-  test('exports', () => {
-    assert.equal(typeof ps, 'object')
-    assert.equal(typeof ps.kill, 'function', 'ps.kill')
-    assert.equal(typeof ps.lookup, 'function', 'ps.lookup')
-    assert.equal(typeof ps.lookupSync, 'function', 'ps.lookupSync')
-    assert.equal(typeof ps.tree, 'function', 'ps.tree')
-    assert.equal(typeof ps.treeSync, 'function', 'ps.treeSync')
-  })
-})
-
-describe('vendor which API ', () => {
-  // prettier-ignore
-  test('exports', () => {
-    assert.equal(typeof which, 'function')
-    assert.equal(typeof which.sync, 'function', 'which.sync')
-  })
-})
-
-describe('vendor YAML API ', () => {
-  // prettier-ignore
-  test('exports', () => {
-    assert.equal(typeof YAML, 'object')
-    assert.equal(typeof YAML.Alias, 'function', 'YAML.Alias')
-    assert.equal(typeof YAML.CST, 'object', 'YAML.CST')
-    assert.equal(typeof YAML.Composer, 'function', 'YAML.Composer')
-    assert.equal(typeof YAML.Document, 'function', 'YAML.Document')
-    assert.equal(typeof YAML.Lexer, 'function', 'YAML.Lexer')
-    assert.equal(typeof YAML.LineCounter, 'function', 'YAML.LineCounter')
-    assert.equal(typeof YAML.Pair, 'function', 'YAML.Pair')
-    assert.equal(typeof YAML.Parser, 'function', 'YAML.Parser')
-    assert.equal(typeof YAML.Scalar, 'function', 'YAML.Scalar')
-    assert.equal(typeof YAML.Schema, 'function', 'YAML.Schema')
-    assert.equal(typeof YAML.YAMLError, 'function', 'YAML.YAMLError')
-    assert.equal(typeof YAML.YAMLMap, 'function', 'YAML.YAMLMap')
-    assert.equal(typeof YAML.YAMLParseError, 'function', 'YAML.YAMLParseError')
-    assert.equal(typeof YAML.YAMLSeq, 'function', 'YAML.YAMLSeq')
-    assert.equal(typeof YAML.YAMLWarning, 'function', 'YAML.YAMLWarning')
-    assert.equal(typeof YAML.default, 'object', 'YAML.default')
-    assert.equal(typeof YAML.isAlias, 'function', 'YAML.isAlias')
-    assert.equal(typeof YAML.isCollection, 'function', 'YAML.isCollection')
-    assert.equal(typeof YAML.isDocument, 'function', 'YAML.isDocument')
-    assert.equal(typeof YAML.isMap, 'function', 'YAML.isMap')
-    assert.equal(typeof YAML.isNode, 'function', 'YAML.isNode')
-    assert.equal(typeof YAML.isPair, 'function', 'YAML.isPair')
-    assert.equal(typeof YAML.isScalar, 'function', 'YAML.isScalar')
-    assert.equal(typeof YAML.isSeq, 'function', 'YAML.isSeq')
-    assert.equal(typeof YAML.parse, 'function', 'YAML.parse')
-    assert.equal(typeof YAML.parseAllDocuments, 'function', 'YAML.parseAllDocuments')
-    assert.equal(typeof YAML.parseDocument, 'function', 'YAML.parseDocument')
-    assert.equal(typeof YAML.stringify, 'function', 'YAML.stringify')
-    assert.equal(typeof YAML.visit, 'function', 'YAML.visit')
-    assert.equal(typeof YAML.visitAsync, 'function', 'YAML.visitAsync')
-  })
-})
diff --git a/test/vendor-yaml.test.js b/test/yaml.test.js
similarity index 100%
rename from test/vendor-yaml.test.js
rename to test/yaml.test.js