diff --git a/README.md b/README.md index 2f5819d91..66b66d6bd 100644 --- a/README.md +++ b/README.md @@ -211,11 +211,13 @@ calling their respective binaries outside of projects defining the Download the selected package managers and store them inside a tarball suitable for use with `corepack install -g`. -### `corepack use ]>` +### `corepack use ]> [--from-npm]` When run, this command will retrieve the latest release matching the provided descriptor, assign it to the project's package.json file, and automatically perform an install. +When passing the `--from-npm` flag, Corepack will use the latest version of the +package with the corresponding name from the npm registry. ### `corepack up` diff --git a/sources/commands/Base.ts b/sources/commands/Base.ts index 54c815c14..c1dfff0cc 100644 --- a/sources/commands/Base.ts +++ b/sources/commands/Base.ts @@ -39,14 +39,21 @@ export abstract class BaseCommand extends Command { const {data, indent} = nodeUtils.readPackageJson(content); const previousPackageManager = data.packageManager ?? `unknown`; - data.packageManager = `${info.locator.name}@${info.locator.reference}+${info.hash}`; + data.packageManager = `${info.locator.name}@${info.locator.reference}${URL.canParse(info.locator.reference) ? `#` : `+`}${info.hash}`; const newContent = nodeUtils.normalizeLineEndings(content, `${JSON.stringify(data, null, indent)}\n`); await fs.promises.writeFile(lookup.target, newContent, `utf8`); - const command = this.context.engine.getPackageManagerSpecFor(info.locator).commands?.use ?? null; - if (command === null) + let command: Array; + try { + const _command = this.context.engine.getPackageManagerSpecFor(info.locator).commands?.use; + if (_command == null) + return 0; + + command = _command; + } catch { return 0; + } // Adding it into the environment avoids breaking package managers that // don't expect those options. diff --git a/sources/commands/Use.ts b/sources/commands/Use.ts index 0ac4dd3f4..fb6060081 100644 --- a/sources/commands/Use.ts +++ b/sources/commands/Use.ts @@ -1,12 +1,20 @@ import {Command, Option, UsageError} from 'clipanion'; + +import {fetchLatestStableVersion} from '../corepackUtils'; + import {BaseCommand} from './Base'; + export class UseCommand extends BaseCommand { static paths = [ [`use`], ]; + fromNpm = Option.Boolean(`--from-npm`, false, { + description: `If true, the package manager will be installed from the npm registry`, + }); + static usage = Command.Usage({ description: `Define the package manager to use for the current project`, details: ` @@ -17,23 +25,51 @@ export class UseCommand extends BaseCommand { examples: [[ `Configure the project to use the latest Yarn release`, `corepack use yarn`, + ], [ + `Configure the project to use the latest Yarn release available from the "yarn" package on the npm registry`, + `corepack use yarn --from-npm`, ]], }); pattern = Option.String(); async execute() { - const [descriptor] = await this.resolvePatternsToDescriptors({ - patterns: [this.pattern], - }); + let packageManagerInfo: Parameters[0]; + if (this.fromNpm) { + const registry = { + type: `npm` as const, + package: this.pattern, + }; + const versionWithHash = await fetchLatestStableVersion(registry); + const [version, hash] = versionWithHash.split(`+`); + const location = `https://registry.npmjs.com/${this.pattern}/-/${this.pattern}-${version}.tgz`; + packageManagerInfo = { + locator: { + name: this.pattern, + reference: location, + }, + spec: { + bin: {}, + registry, + url: location, + }, + hash, + location, + bin: undefined, + }; + } else { + const [descriptor] = await this.resolvePatternsToDescriptors({ + patterns: [this.pattern], + }); - const resolved = await this.context.engine.resolveDescriptor(descriptor, {allowTags: true, useCache: false}); - if (resolved === null) - throw new UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`); + const resolved = await this.context.engine.resolveDescriptor(descriptor, {allowTags: true, useCache: false}); + if (resolved === null) + throw new UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`); - this.context.stdout.write(`Installing ${resolved.name}@${resolved.reference} in the project...\n`); + this.context.stdout.write(`Installing ${resolved.name}@${resolved.reference} in the project...\n`); - const packageManagerInfo = await this.context.engine.ensurePackageManager(resolved); + packageManagerInfo = await this.context.engine.ensurePackageManager(resolved); + } await this.setLocalPackageManager(packageManagerInfo); } } diff --git a/sources/specUtils.ts b/sources/specUtils.ts index 9d366675a..0770a6eac 100644 --- a/sources/specUtils.ts +++ b/sources/specUtils.ts @@ -20,7 +20,7 @@ export function parseSpec(raw: unknown, source: string, {enforceExactVersion = t const name = atIndex === -1 ? raw : raw.slice(0, -1); if (!isSupportedPackageManager(name)) - throw new UsageError(`Unsupported package manager specification (${name})`); + throw new UsageError(`Unsupported package manager specification (${name}). Consider using the \`--from-npm\` flag if you meant to use the npm package \`${name}\` as your package manager`); return { name, range: `*`, @@ -33,7 +33,7 @@ export function parseSpec(raw: unknown, source: string, {enforceExactVersion = t const isURL = URL.canParse(range); if (!isURL) { if (enforceExactVersion && !semver.valid(range)) - throw new UsageError(`Invalid package manager specification in ${source} (${raw}); expected a semver version${enforceExactVersion ? `` : `, range, or tag`}`); + throw new UsageError(`Invalid package manager specification in ${source} (${raw}); expected a semver version`); if (!isSupportedPackageManager(name)) { throw new UsageError(`Unsupported package manager specification (${raw})`); diff --git a/tests/Use.test.ts b/tests/Use.test.ts index 8c91fa217..3d12dae91 100644 --- a/tests/Use.test.ts +++ b/tests/Use.test.ts @@ -64,4 +64,23 @@ describe(`UseCommand`, () => { }); }); }); + + it(`should accept --from-npm CLI flag`, async () => { + await xfs.mktempPromise(async cwd => { + await expect(runCli(cwd, [`use`, `test`])).resolves.toMatchObject({ + exitCode: 1, + stdout: /Invalid package manager specification in CLI arguments. Consider adding the `--from-npm` flag if you meant to use the npm package `test` as your package manager/, + stderr: ``, + }); + + await expect(runCli(cwd, [`use`, `test`, `--from-npm`])).resolves.toMatchObject({ + exitCode: 0, + stderr: ``, + }); + + await expect(xfs.readJsonPromise(ppath.join(cwd, `package.json`))).resolves.toMatchObject({ + packageManager: `test@https://registry.npmjs.com/test/-/test-3.3.0.tgz#sha1.a2b56c6aa386c5732065793e8d9d92074a9cdd41`, + }); + }); + }); }); diff --git a/tests/nock/fsYZFJKYLkFfDv-Jyd3j2w-2.dat b/tests/nock/fsYZFJKYLkFfDv-Jyd3j2w-2.dat new file mode 100644 index 000000000..406b28f5c --- /dev/null +++ b/tests/nock/fsYZFJKYLkFfDv-Jyd3j2w-2.dat @@ -0,0 +1 @@ +;"https://registry.npmjs.org/testo"body"{"name":"test","dist-tags":{"latest":"3.3.0"},"versions":{"0.0.2":{"name":"test","version":"0.0.2","directories":{"doc":"./doc","man":"./man","lib":"./lib","test":"./test"},"dist":{"tarball":"https://registry.npmjs.org/test/-/test-0.0.2.tgz","shasum":"67d0610319d4308a39d1b25b0a074e709c4dc0be","integrity":"sha512-1UqUlZ4CRMuYPUuMGTLlUUGDwAJlIeG3w3nzvODHuVAYyXCCE3tURXlUs/yo+L6hDnWowfq8EBLRRuxOfpjc0Q==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQDrMX8cMvslhroHLhp8Bv5zmBflMoDMV2ucARMZtVnShAIgLUWOkfsoBIkXQMYyG9cMqNMESc6vPI3Nm8imo5FqeDI="}]},"engines":{"node":">=0.1.103"}},"0.0.3":{"name":"test","version":"0.0.3","directories":{"doc":"./doc","man":"./man","lib":"./lib","test":"./test"},"dist":{"tarball":"https://registry.npmjs.org/test/-/test-0.0.3.tgz","shasum":"87bd204807f9972cd9096202a40cd7eed4ead5e0","integrity":"sha512-KLB74zHPd2YX/T76U5bHAwMg8wsVBOQJjnXfPtP4XLnYAIuUVQJidi52uJlv9fvTNq9Alp31JS3WzOPPihdqFA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIGmyVavuZCI2iI5ueJf24rQ0r2sNyh+Q/db/EtvhOqFCAiEAhX86ESZQJhx0v5lG9Lb9JMVGm+3ZWJaSrYK7OTgOprU="}]},"engines":{"node":">=0.1.103"}},"0.0.4":{"name":"test","version":"0.0.4","directories":{"doc":"./doc","man":"./man","lib":"./lib","test":"./test"},"dist":{"tarball":"https://registry.npmjs.org/test/-/test-0.0.4.tgz","shasum":"dc6536fe47a9437a0f3c586c0b3c05659ed5be9a","integrity":"sha512-Bv6/RuU2Jmx7XAilx7hDFt1EOmIDMIihJ3k6uqeBE1XXBM6jKhpmsc52HdysgJMGFmItoeRrabFPWQdq5VnTRg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIFwoKUh0xTaafK0fm1cjQx+3oEE1znVFp3xW8RsBHl5jAiEAzeoa3WFDx3qorqivOtR545sDpM4HkpV7HpzqVNIBtlA="}]},"engines":{"node":">=0.1.103"}},"0.0.5":{"name":"test","version":"0.0.5","directories":{"doc":"./doc","man":"./man","lib":"./lib","test":"./test"},"dist":{"tarball":"https://registry.npmjs.org/test/-/test-0.0.5.tgz","shasum":"0565c62de9042d404c7af948884ca44e277a8f4c","integrity":"sha512-CQ1bGjO0/W4khw9hI0ED0TIazlkkHX4mL1WPshdUJOWp9Iwvfb2VMbfiRnma6khmVFejpebEEc8lNbWho9J9Pw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQCuT50pF9HOJU1Qz5M4lW1LBoYwJ1VkDbNTV3SWKKhlDAIhALXOR7wueu5u0Pi1UmNUdSLdtoOsJ1QrbUmYwjE3BbS1"}]},"engines":{"node":">=0.1.103"}},"0.0.6":{"name":"test","version":"0.0.6","directories":{"doc":"./doc","man":"./man","lib":"./lib","test":"./test"},"dist":{"tarball":"https://registry.npmjs.org/test/-/test-0.0.6.tgz","shasum":"f74c095e789568e9c8a004602d695d85cf8f2334","integrity":"sha512-PDTqGK7vTdMrUG5rWCbX8XKpFCAMEvTy8aLKJGmxjVG4WZlcxq0LY5pFEQzKNkrQ+pNFysHl4akUNHCGDhBP4A==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQDb67Isp6rwdQD+AgPq0fTZpAOYYzcxnsEJxeGSqWde8QIhALWLfMBvTvxI/iCfsbvyEib8JSio/GNFEvqR+PJJVofX"}]},"engines":{"node":">=0.1.103"}},"0.0.7":{"name":"test","version":"0.0.7","directories":{"doc":"./doc","man":"./man","lib":"./lib","test":"./test"},"dist":{"tarball":"https://registry.npmjs.org/test/-/test-0.0.7.tgz","shasum":"f3cfff3500fded2f060d200b9a89a46b481431a7","integrity":"sha512-R6wD3KRcWtG5B6s+4b0YjivpSTre/vrys5G5YAL29dtFcMFzJCtswxJciUX6ZhpG1lMcG/XPwcXUfjdTg7HI9w==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIHFnevd0ERI9I6L2gKwKHuKu4KdZ9vjiQ01M1+KacMyOAiEA9yKeuZj6Zr8hkpfpz1PStpIdlhG1q6L31yIZMGDIcKA="}]},"engines":{"node":">=0.1.103"}},"0.0.8":{"name":"test","version":"0.0.8","directories":{"doc":"./doc","man":"./man","lib":"./lib","test":"./test"},"dist":{"tarball":"https://registry.npmjs.org/test/-/test-0.0.8.tgz","shasum":"adb9f455c621cd5ee5bae10dcb88a241468e1abc","integrity":"sha512-gJ6NSrgPpy7iWcV6aoJt/sm2xWXF/bFUHvCVZTRcX1AhBy8z9X2exQ+ikHtVfe2D6ufvGGHsQ/RbZgtxQOskVA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCICYeU6AswiC7MHbj45LTbXEDZH2PvYIcQ+IloA8wsQr2AiEAxfaLLU90UjJJIbmxtmB+YcVBCliv5xz58iGB9EiTdXQ="}]},"engines":{"node":">=0.1.103"}},"0.0.9":{"name":"test","version":"0.0.9","directories":{"doc":"./doc","man":"./man","lib":"./lib","test":"./test"},"dist":{"tarball":"https://registry.npmjs.org/test/-/test-0.0.9.tgz","shasum":"22b42989fb3baff527f375dda838d381b8a074f1","integrity":"sha512-UANkWwEw6i9qgd8kc4fhtQuSQpzE/ph+jLPMSIG/cL9i5YBUdtPV0ouRuMm/9ArtlzN2m8di3ToWYTU4JxOUeg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIGg7QXS/75aHWYpMqrRWaNcxTuGormbMVeBTE1K+hTHJAiEArt3OEgrDE530hxRvWshDnDuTsUatv+E46LkUIy/DON4="}]},"engines":{"node":">=0.1.103"}},"0.0.10":{"name":"test","version":"0.0.10","directories":{"doc":"./doc","man":"./man","lib":"./lib","test":"./test"},"dist":{"tarball":"https://registry.npmjs.org/test/-/test-0.0.10.tgz","shasum":"f795f3b53c1ccc7ab32dbbd08d70175403e327f6","integrity":"sha512-dVb82s7svha7KvYo31KDswWw2sRbos1eoJ4bebMX5ItrDMdCRqT/c2SH0mzGwIaX6n9CEDo8CAmlD4eCd8l1OA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQDAWCT+ELzOLT3/eSqPs8ca2E6jvZUkVMAbrE43aq0HqQIgcEwu6TROy4zyIWUXVOKoDXKpK47NLa1jDTtcGGLCY0I="}]},"engines":{"node":">=0.1.103"}},"0.0.11":{"name":"test","version":"0.0.11","directories":{"doc":"./doc","man":"./man","lib":"./lib","test":"./test"},"dist":{"shasum":"0892941c6a08452cf2db639604f4e31e4a7a4c5e","tarball":"https://registry.npmjs.org/test/-/test-0.0.11.tgz","integrity":"sha512-cppwYGCN2o/RhHdEmdyAN16d2bglPowniSlXEmvwS1ElWZ0/X/TtgYp68EJd79X6dg6z5jNjXGrWeJyE7Mb4bw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIG+tsRw2MMXFQ2N15b9+CucN9qcABYZFp+l09Ytj3x/eAiEAqVMvk0Wx7Mz9HHIQ21kGU5OkvAZnOJXQKNqr5RwmCKM="}]},"engines":{"node":">=0.1.103"}},"0.1.0":{"name":"test","version":"0.1.0","directories":{"doc":"./doc","man":"./man","lib":"./lib","test":"./test"},"dist":{"shasum":"176b4f94188a4e8ea33950d9f2958b95bea7478f","tarball":"https://registry.npmjs.org/test/-/test-0.1.0.tgz","integrity":"sha512-wvo8fi8DNMZ0swD88Z/L52+FDFxv+wxNVbmJRgtXx68MsTYRMmzTvSJIBAUAt662nEasZ4S3R9D5rsWOUlGW9w==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQD36y0B7UhShgfDSf7BkttJJPZcv3tbAnCkSZGfTUXgHwIgV5Aj8qJbFmjfizJdiH+4Dt+cAmPhRn8NeO6BIOhm3iE="}]},"engines":{"node":">=0.1.103"}},"0.1.1":{"name":"test","version":"0.1.1","directories":{"doc":"./doc","man":"./man","lib":"./lib","test":"./test"},"dist":{"shasum":"02fde1d15a0e23b74c274146b066318424b4f033","tarball":"https://registry.npmjs.org/test/-/test-0.1.1.tgz","integrity":"sha512-eJy/5pzlnIzhRuUS2fZV92kdSPpiiBOu/ojI9978f1rtzecJt1/AAt9oNTCZAvdaS93ujvShO6xtdqMsTUYFkA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQCxIH4QgWCrYrVQx0E3/O99G5qrQgMXvy8qRDZjnyFTNQIhAKZEwhprYd0Yfk0ziYF7CIrfOaz7hboRUEaPK6mmgKDp"}]},"engines":{"node":">=0.1.103"}},"0.2.0":{"name":"test","version":"0.2.0","dist":{"shasum":"9e082995859d8e9c7716db9b306bc7d5e15f028e","tarball":"https://registry.npmjs.org/test/-/test-0.2.0.tgz","integrity":"sha512-3fG+B3Dx/Gd2bly1IMgXWFGxE5ioiY6a9jYiCIvURNcDhrSJtKecPNp22BjLRDFFVy2H2/673CbvXJegb6GFXg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQDAZ2eEIBXqGr4hfMHjdI1emyadgbbxtjHSFfkQy/ReigIhAJ6SXC0MJLrlcgLiINIzCStApglAys/hhehqxj3wEukt"}]},"engines":{"node":">=0.1.103"}},"0.2.1":{"name":"test","version":"0.2.1","dist":{"shasum":"88aa14b8b8820a3b639597565b507b6de471cddd","tarball":"https://registry.npmjs.org/test/-/test-0.2.1.tgz","integrity":"sha512-dcZnz3MTJCHYsEJeRbHfPTDGptRum2DeX8BrN4GZ5T55pB+K5VymMJbYjl/4mPpsICWRH0MnO34gQ2c1jgJnLw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQDPx1BYttFNiDeobuVgXZ4+HdDmz6uBI63EjC3poVyYEwIhAPmzzyDBmlS2fz7/8Z6uO96gfj/TG4nvX3TuRcNUwyEB"}]},"engines":{"node":">=0.1.103"}},"0.3.0":{"name":"test","version":"0.3.0","dist":{"shasum":"b7ca6e5891090ad3c7475bd325b1fff4d56e5aa2","tarball":"https://registry.npmjs.org/test/-/test-0.3.0.tgz","integrity":"sha512-rNxK7ongc+Fk++ywcobL0ndxDEckGjecJePepv/LA9Ymk62GqvgXLFY6AHwwxb53kFVJFRgyZ+bwZVV2oCWznw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIBvaVpWY3eNNVPAi3UU77B9jLDaXSke5pIm/OvdDisDqAiEAhHANgVkup6xTb4FiaGIx37h3+roBvIukuxJTsyZ0mGw="}]},"engines":{"node":">=0.4.x"}},"0.4.0":{"name":"test","version":"0.4.0","dist":{"shasum":"85e8db29291ad2e66d39a03013b9bb4a1fd8a135","tarball":"https://registry.npmjs.org/test/-/test-0.4.0.tgz","integrity":"sha512-WI1+fV2ItWHylcVuuEna18jGbMrhJSDoTcweUx3ARAHe+7DYLneGUxpAW5ow/vy6HCqkWzLBx/pTu9/7uDRdeg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCIEdB7H/nlUhZqPxvvUNUKblla/KImIVjsmcaSqIvPvkvAiASLVnAyEt+8n1DDxsKoB1x2j4AD11wlq2kdHWu9y/k2A=="}]},"engines":{"node":">=0.4.x"}},"0.4.1":{"name":"test","version":"0.4.1","dist":{"shasum":"fba3c3c736bd78229f462b525c41a32aa7c9ccad","tarball":"https://registry.npmjs.org/test/-/test-0.4.1.tgz","integrity":"sha512-JEkx2NxsTZRaIjuUb68IxyoBBo1JqFUz6E73+68QShYKKuqhbLljR9XghEtI+c10DXDdyrG7/1W4dvhUmTbt1A==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIB7CyyPO9JzzqL0GOsEbQNKsbIDfValqgD2lUEn0zD79AiEAoZsVrdW6V6ElD0jsknlX3ugfdOeiaNjIIlMXUPOSghU="}]},"engines":{"node":">=0.4.x"}},"0.4.2":{"name":"test","version":"0.4.2","dist":{"shasum":"e4f55eb18071f2a2a3c793111a484ccb33a4cb5d","tarball":"https://registry.npmjs.org/test/-/test-0.4.2.tgz","integrity":"sha512-SmYSWBBSEkeKhXRSu3kyEQdjIfRvGCtXR8sO9osejofKjYo/kcOMkQ90gdMd28QUqcwSaFhBtkTbg5m6K36n9Q==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQCccKbVnhrqRDvd9/tq7DQ9G5bKmj+OOY3S9OZH3eSWJwIhAKAnqcLyQ3xiPGrcKmpGK8XXWznHvX5WrCy4bvqxaPsx"}]},"engines":{"node":">=0.4.x"}},"0.4.3":{"name":"test","version":"0.4.3","dist":{"shasum":"bf02e38bdeea000169e3f039726e6868827ce22b","tarball":"https://registry.npmjs.org/test/-/test-0.4.3.tgz","integrity":"sha512-Q462HVB+Cv1yDtwgPo9SuWTgnanjaOn+hJBYQ8z80c2YFRqyTzD/wMEGBABQ4JRvUqHzO8Xsuq7Q7qyfit+LFg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQD2sxwnJ0NvJwTq1k5i74+2+NNqizV7+C1RY5igvdRZlwIgbqyOagJ7eLP3tPOYEuSW3CsDHKa3FB8IrDq6P1H0g14="}]},"engines":{"node":">=0.4.x"}},"0.4.4":{"name":"test","version":"0.4.4","dist":{"shasum":"758fc3237571ab7b6ba6ac1befde10f19b9eda47","tarball":"https://registry.npmjs.org/test/-/test-0.4.4.tgz","integrity":"sha512-VFINPWUPxRYJFOSp33jxXiyamD5eLiivjIx/url0YQ08KN87ZZE9WKmGQQb85zsVZVT6lLKradsZgyYnKjTwGQ==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCIHpGkzwsqs593Em+T9q5KXF/8on7GWOqW03GKAT/Hi+LAiADLyZ8ZdaJeFdxVg1HihHyP6JtBlEWA9Yo0sj29/3X5Q=="}]},"engines":{"node":">=0.4.x"}},"0.5.1":{"name":"test","version":"0.5.1","dependencies":{"ansi-font":"0.0.2"},"dist":{"shasum":"78c640982bc15d9f41a19d5baf4a3af1285282f0","tarball":"https://registry.npmjs.org/test/-/test-0.5.1.tgz","integrity":"sha512-u+5SS2S/hLXvKMEXya8M/Q99TRKCDJe3eCUaWdh3NS2+/iej6OVccK55xWVb37v7UQOPm0C/f7tW5tmBeSP+pQ==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQCg0NnudsPrRv1ChafoO97D06BZUatLZKcw3T1AIk+icAIhAPx/NI9XnmvstJ+Ru6MUiPZFMCaNBR8H06Dwp+sHAuvJ"}]}},"0.5.2":{"name":"test","version":"0.5.2","dependencies":{"ansi-font":"0.0.2"},"devDependencies":{"phantomify":"~0.x.0"},"dist":{"shasum":"0d726831a7d9852d25e46e6b8265fea216cbd8ad","tarball":"https://registry.npmjs.org/test/-/test-0.5.2.tgz","integrity":"sha512-iPWgTOENs3SCORqpr/yc2vHM8cOUEeOdMPa+AkTt1zHDzdKvmGXZ8WTVQUBIGuDWBd4SPz5NSY0xEVWal3AyOg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCIFaGal8Gsflt4f5qdFHjyTEjeT8SND3gyFcbIAMmzw+7AiAXV6iAV58ua82FRTb5XDaPotrcCXk1+1ucsVCd2cUQ0w=="}]}},"0.6.0":{"name":"test","version":"0.6.0","dependencies":{"ansi-font":"0.0.2"},"devDependencies":{"phantomify":"~0.x.0"},"dist":{"shasum":"5986ac445ec17754322512d104ba32c8a63e938e","tarball":"https://registry.npmjs.org/test/-/test-0.6.0.tgz","integrity":"sha512-dfbzeAI09tjJM0TCxxzLzPnHAO8gXHN6KaZ6N9zBde2YOFXunHO69tetz/ai93XRsOOkEm8q4IE3MJB/RlszxA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQD6kgGRY78HriZ+XqDB8uAerEC1uap4WPxr0Ksyb0yuRQIgdfjs4/bYe+AuEBxd3ersseNZpON4JFs/xt//75zmKfA="}]}},"3.0.0":{"name":"test","version":"3.0.0","dependencies":{"minimist":"^1.2.6","string.prototype.replaceall":"^1.0.6"},"devDependencies":{"standard":"^17.0.0","typescript":"^4.6.3"},"bin":{"node--test":"bin/node--test.js","node--test-only":"bin/node--test-only.js","test":"bin/node-core-test.js"},"dist":{"integrity":"sha512-MmKSHRj6K5aVu8Kn8HctQIxwZqjeo9M2AzirnzJv4f0JeagyFoSN4T2EGFALota4Vw2lrvcvt83TkR8INMNHaQ==","shasum":"fdfa090c3e0b77a2283e2e6c0d69c585fd826ee3","tarball":"https://registry.npmjs.org/test/-/test-3.0.0.tgz","fileCount":55,"unpackedSize":91350,"signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQDOz1FMG4H9oLGKAcKQwJGWYyVTV6HMPO9TQ/FcIvlQoAIgMIAuBcZFP6+baxHIkkceVVfb7UDW6cT/nTjM0IJXqZA="}],"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJimMAkACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmozaQ/+LN9iU/QmZZDH+BziWzBdZrorPe6obrU2ZLELfTRwQ5n0dqPu\r\nbmZwIbH424UfiV4p/OrWE1rZ1GsToctC+4iNf1DA/OQJSo+n3x28zTyc1mzV\r\nJ1F4zuU2zeZRju99zYfe8YBeS1hd9738SY/kMBfD+kiX06VM4Fg6D1qmXqpC\r\nmNxHqDgjxN51btiZu5GKG0//gt/x2lWn7kCGS4yZPCsb6DpF7dlT6zZsPaEO\r\neb8S7XqHp/HE3aRAKv8T9KE4hgSbdhMDW/FWVi2n3XfRD//4SZ30H/PEsPym\r\nqNRh4P/Tjwg65Usdo2UsflADUBJY7UvtmoXVx6W/mY4RCbjTMZGQcJD3X6YU\r\nlZaHgASPHzYAxvpGZxu50FFa1xFioTmDED+XTfRM4kIYPdiJDUYRwzlbCt3W\r\ngS4IWK9OR6f1SB08l7pICydnmccXLLjXsOxl6mwDmAhlBFKGPKxG4AYMK9CX\r\nttlyNG8IN3lsbh6AyHPzIuNmLeO22lXl/uYsR2tWlylbugHqXgIFbWBcawZj\r\nmdZNS2mIRwYZhiF19CymTD+dG8I04UvHsLFEmQZKpCjqNGVVIWniPjRHzNZV\r\nWLyVQlkzPTHLDs4bYVT3bfAZ/1hXm7Jft5viK2d513ulA8MwgLnmaXBS3RYV\r\n2wQNq+tWc8qH/00tLUYbkjb0ZSy/7m0n98g=\r\n=hdrl\r\n-----END PGP SIGNATURE-----\r\n"}},"3.0.1":{"name":"test","version":"3.0.1","dependencies":{"minimist":"^1.2.6","string.prototype.replaceall":"^1.0.6"},"devDependencies":{"standard":"^17.0.0"},"bin":{"node--test":"bin/node--test.js","node--test-only":"bin/node--test-only.js","test":"bin/node-core-test.js"},"dist":{"integrity":"sha512-4wOJGleojd+hwR9a/l02damXIf6ED4ZPJ1MYFKgBUfIDC4fCMZLErtWT4CpuyEsI5AOaxX6vlATPR4qetUxf/A==","shasum":"d5cfbec291f48d427ea9fe809aef072fc7f25be7","tarball":"https://registry.npmjs.org/test/-/test-3.0.1.tgz","fileCount":55,"unpackedSize":91348,"signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQC7V7b3ej3QgwJP1Nkbc/VPMV+JcXkv+ln41ueTIY/+4wIhAJpn/PYX5fwEPHL0rG6VeFWxrXJ6aGwPkWBpQKY7qQ6X"}],"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJiqZu1ACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmpahQ/+LJRRgj22nm2Jwo0JnCT03ff3Me4+U5a5GeMMRJWJAqT3xKiR\r\nS2OB4VZPKmKbnupE5Sqm0Pl1WEFeUATW1MsFlaCGTNxlGjTe5Cmwor5grESm\r\nhqbQS4QOGX61fFjSad7v/LgqXuwpcQFKVDGRueJJKH3Toxfj76qsgeAGiIF0\r\nVqMXsgZXxbJpISzRT/ezAEN6PdZV6IT2fZGEG+GqyagQFnP8K/2n+WPUfuOp\r\nKSgZ7RByLnG305hA5C9RVrBAC6YuwbAtLEkfcrFiriWJeKIe1r+SOuy0NrdV\r\n1FJCuB0h6T7YcpoH9B1jYeRjgZZqoBelEVfNn88HrYBl73r4tbV3JCdwreXo\r\n3PjWkfufKTjYjsfHkBTbZnkgpLMDOvWwn8rhPrjsMQcTRb9Nzz3fZHogpR+9\r\nWd2I/As8B7jKTOvCsHGCoGX8zGvarf5ZxhA7ZfV4YEnbPMDeQ9qtSjvkIRzm\r\n2iLI2Uw94+YUxa5iNl0yBJpEoHf7ULZ/AjoORO3lWgUINcosTLaZ3DUQ0ucC\r\nZaSIO8lMRIx1Y45pSLxQhpRjjkMRb9NiiHs6x5ZwsyMlG5VE7PC0YvZf2utR\r\nW7MEiZNsYYuUDnSn1LZqDRF2VIomDUSgXEMHRaHgTWSgTQ7LhoSQnbTdyJMT\r\nDmR8mvOWBd8ChGMFp6A6TRers3uajujEuzQ=\r\n=CCAB\r\n-----END PGP SIGNATURE-----\r\n"}},"3.1.0":{"name":"test","version":"3.1.0","dependencies":{"minimist":"^1.2.6","string.prototype.replaceall":"^1.0.6"},"devDependencies":{"standard":"^17.0.0"},"bin":{"node--test":"bin/node--test.js","node--test-only":"bin/node--test-only.js","test":"bin/node-core-test.js"},"dist":{"integrity":"sha512-3lO5M33Y4JoWYNzhJeKBSaZCcyFf2LJS5EsRwI5J//keVINQAWBybLZXoXZNHm8fFe2kcASb2EfjEodDY4kqRg==","shasum":"3605b6204561a0e49d85a8ed6192ed6b270df81e","tarball":"https://registry.npmjs.org/test/-/test-3.1.0.tgz","fileCount":62,"unpackedSize":148085,"signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCICvngmvw229R4jxzPhkFfJR8XTSDHOka/6lBVDMWfB77AiBfMi16d98MiX9kFYifxm/J9KQJXT7GvCWUAugmUoIQYQ=="}],"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJi2EiGACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2Vmo6eA//b9yiI8zggvHIChSPbFwkIe4/UmFsRu80zyiRYVFGF8g0iczf\r\nrzyJWQ07VsNnTWA+FBX4tjY9yQPAkAHg/pjmFyLqvbpK54zgiZNqWujs1T1P\r\nxbPDXBNfw3xjP7qhvOKdqr5V/fBFKIBW9SEw2rN+IQl18w5scCRPMaueVLHB\r\nmv740KfWunx0YTEzoqM/3Lyp3Lf7Qdfs8mUtgawhTkxzt2iF7lQ3b+zlNLu0\r\n6BHefXwWFCpMyNk2spX41ha2Zz8u+n8eA8JXjGaqfxsUWtVtVgcCFjOvh1jq\r\nWRNo0jBrkT59h2yaPIsxWX5MkLqxA51NU2gn39f2Z0yY0WjKzwYUXFIPmgBO\r\nMKrF1I3Y2oiiDM3xktJXZIqc4NZ1n/ukQfZXvYk7BKvzLpm1/7wJkClrIWaD\r\nWbnXSSzicscgRNm5kIq9/LfyxZRKo4bwwP4pQcK1/sKSWDoR7/QuCruAZhfb\r\n4R0AKfhzT2vOD4nFMQZyjDdSPtyz4NtXV8/7t5qaR/7mFIu+pKHoSFmAetKF\r\ntiK+AKmSxeS+9Uv4zH0OEDI5aHl30Q6MdVrzkIih2m7IKeumss5mPoX+Gq3/\r\no6WQwOgq4XRXlWyIyPbmg0elKBGAZiC5W7VXIkj0x+vkNVaapeq/SHsVWq0X\r\n2founPcn5faCh6zLpH2pcRQpzxzbVS4wG7E=\r\n=BUcQ\r\n-----END PGP SIGNATURE-----\r\n"}},"3.2.0":{"name":"test","version":"3.2.0","dependencies":{"minimist":"^1.2.6","string.prototype.replaceall":"^1.0.6"},"devDependencies":{"standard":"^17.0.0"},"bin":{"node--test":"bin/node--test.js","node--test-only":"bin/node--test-only.js","test":"bin/node-core-test.js"},"dist":{"integrity":"sha512-c09Wx2+QkX4aHsGV/LCJGIEnQWZhdXixDtFmHvcVLZbItVZJIEOuFv0Vv+GdKPsMkuZ8DeAuGhx6gT+xBN8E3g==","shasum":"f375dcc183d28a483cfe7bd05561236f59dd0d74","tarball":"https://registry.npmjs.org/test/-/test-3.2.0.tgz","fileCount":77,"unpackedSize":193517,"signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCIEb9RCEAtLWtu3s5lhfLPt8yx3wwrPY10xvTaz1ZaA1pAiAtZugOKLQPjwcY+OtOMvd9OU9VjPYT1aGUH4tnnzS1BA=="}],"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJi55KoACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmoMGw//RpoDokTKfIVltNEWAsckpmwKADJGJyaclTOyJkVTgzZ0TxnG\r\naZtX/jvGUGVBeYYIUwGo7MGpr2tQNSfBo3ASGBA8tR915WdNzaKZJD80cuxn\r\nX7JcKWBdBoup0gGL/8c9iS0gP6MOA0PsgK9oPvBgxlZGwKfx0GCkU66Hvcf8\r\nzlxENKIXPYOkpP1o+1GhuzLTQWX1Sl2Gvf6TK+QhGLisaZehl9CdffcjkOn6\r\nY8TzmXd0rtt1zSKJO3jrP0wyxUsfOWC1nl1H/9bAP2OhvjRx6UAAJjwSVGCr\r\nDzEy81PBRthN89hEq+Q33Ao4wjk/531f+78r53UNfa+8rDH9RpP/XrVJeRRL\r\nBqfjZdHWHsYbaRoo9eM5Y2jp/vpgtMQz7x8WFPVcZJ9gxzi+K3IqDawCIWHR\r\nhZ857Ke0FHqQL3QisSCU28TQzQxvvORCScKxDmuW427ntajvZ7l+72wa9Y2a\r\nvSxBt/OseBN8dWJXuEmhnTxaobjwtMT9/BrHvtwGYpnRrviNu4crXaUvOlv8\r\nexx7RZXhT5oDCtQ0Omkq3m/8WRS+iEFgtHp/MlxiApSwgW1BruGVd1tpYFST\r\n4ThvjLL39Su3vQ/IulsZiTmgurtoJzEF/yTWCS/OCwOElfJIUy0LNrILf3ZD\r\njqP5/JL9AbOlh/lZVEAbTZwacFZseK+qmms=\r\n=Jd23\r\n-----END PGP SIGNATURE-----\r\n"}},"3.2.1":{"name":"test","version":"3.2.1","dependencies":{"minimist":"^1.2.6","string.prototype.replaceall":"^1.0.6"},"devDependencies":{"standard":"^17.0.0"},"bin":{"node--test":"bin/node--test.js","node--test-only":"bin/node--test-only.js","test":"bin/node-core-test.js"},"dist":{"integrity":"sha512-D9eN4OxdhyYS3xHSsAh5A0e+UhaOPxeREwBHTknZHoVFd4TqnPtkVrQ7lIUATPgpO9vvGg1D+TyMckVmUyaEig==","shasum":"8876adae35e86c4bccbcfdf5b018493b1c9501be","tarball":"https://registry.npmjs.org/test/-/test-3.2.1.tgz","fileCount":77,"unpackedSize":195362,"signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIHHfc/IOtLiEwcOwjFnyuSJH/khPIeESi6PjrWW6iQy1AiEA0K594arhSIzxDI1N7OSGTPNAol7nUVOrJFXhOvm83e4="}],"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJi6ltlACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2Vmr9WQ/6Aw3Po99xPvksXxafbA1OOwifPieMEts5pS1U5mXR0efdShEi\r\nWc5BNMOjAHyXRnJhZoSVUzXAbFSKO3fWV8SOaTteo0lP9ATc2mCCef4C3Gi+\r\nvcHDKigf5Paz87IplMentaQPLMYZksrBz0rPwbidfJOGlmCMPZ7Ntv1UuKO4\r\nR2IUeI+z3ePcmxQVvw7eacIy1sHXAWGGAEZDS1MLNB9/ji4SAEn/9w7E+753\r\ncQXdOzx3O/1CkYWuxIO2E44V91VCAtNwYGVIr5lVHgfUON5mt586PDz8RSjr\r\nkVnoOLa8mCbU7l+hUH1oH+G2UvxKUt6kUBoyZFytZjNR9K9/uJbZGzP3l/eX\r\nPudbfLFB8Laq2t79RTVEb5HyNZonOzKozzy8w06Jg+UoqR20gy5Vp7s5GBH0\r\nXq1aHMZTY8ILoavqi8YTmmrAv/Ab1taQbWRasxbzloKET387iLFW+1aE01CR\r\nyEuLYD4IJ93yzEzSyJLsaKT/JWEQ4Zp+E1fCQgDz+jZtWN1/nRv8GpKQ+PeA\r\nVabqYs3UvgwroKJP9HBXrGEsKKHuOCK6I+okJsahfui64HBUhOzXOB2SAw/y\r\nTeddPh/H53U2/nwMbL7nHdGbp+e2Wmw1khWrf+r9Hhyx0ov7n27QHi5ElNcF\r\nnuGVAf4EWBmeWlRFeGpW60FghV2rPqKaC1E=\r\n=s93+\r\n-----END PGP SIGNATURE-----\r\n"}},"3.3.0":{"name":"test","version":"3.3.0","dependencies":{"minimist":"^1.2.6","readable-stream":"^4.3.0","string.prototype.replaceall":"^1.0.6"},"devDependencies":{"standard":"^17.0.0"},"bin":{"node--test":"bin/node--test.js","node--test-only":"bin/node--test-only.js","node--test-name-pattern":"bin/node--test-name-pattern.js","test":"bin/node-core-test.js"},"dist":{"integrity":"sha512-JKlEohxDIJRjwBH/+BrTcAPHljBALrAHw3Zs99RqZlaC605f6BggqXhxkdqZThbSHgaYPwpNJlf9bTSWkb/1rA==","shasum":"a2b56c6aa386c5732065793e8d9d92074a9cdd41","tarball":"https://registry.npmjs.org/test/-/test-3.3.0.tgz","fileCount":115,"unpackedSize":443334,"signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQCaf8Z1yDUlMikQh1RouG51OXMazNEX37VqLkVDoP7ChQIhAK19hRazs6GgWzyNVoaprpHD47L1tgZegJjSYJRG4Ued"}],"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJj44P+ACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmoRvQ/+PXMHsV6QmbMAYjfLzXNnorD1zUoJa4cLc4iVaQOGQZPjuC7/\r\nBVGYIBfWcAGGA9aFeuYym+9CqSqJBCO8MwAk/eb+SKhHEIhQMJrXhto0oDEz\r\nHLkIlW0HU6acq4qlnRJ0wRZ029L+Yw1ozlPGt33knrg45tGza4RNbtRidbYz\r\nrnpS99eHgfyE9lWCMlufYLUA1Nhxfc1p99zdMwxXstfD5MJD6FGzI00hF8Ln\r\nIyXd7d453hB0KY11BqhDdUdpS/g1n3m2YXoaLz6xksSTex+v7mjrU+QY1uZG\r\newvje3OSKUtrl5Y3L1F9enCgItriAtaFzmjasJe2UPBzm93Db5lnEkMk8nXN\r\n2RMd/XL+ZZdNuJ9BFu2KMWyOBkr6i/YyY1/7Fj5KPv+HL5bSakOpU8dht2jK\r\nBkasiRNItddzbfsDCa0x1tfXLpCwThiIJP/Hl5n5qmclEDf/igAb1Z6ylhlI\r\nNQSsMeSXwoDPD1JN1HScPak4hbEHuVf4D5Rr6YmkfwdxQ9QQGWNvwVAGbmjF\r\nuz725UHMjQi8qmJ3ZxDjHJHYt023TxQ0Coasx6Axlbo7pV6hN9rVGWMDxRAp\r\nwVSgwit8QCr1EssX4KObO68OGhPQao9ix3MxOJPf7LkXUiDq1Cb/86XflcCC\r\nagMTQalLeaLrWiflW/iHYPmQppcEJFwdWIA=\r\n=wxmL\r\n-----END PGP SIGNATURE-----\r\n"}}},"modified":"2024-02-20T10:05:22.662Z"}"statusI"headerso" content-type"#application/vnd.npm.install-v1+json{{: \ No newline at end of file