diff --git a/node_modules/.gitignore b/node_modules/.gitignore index 2133d6edeaa88..aa43a2716ee15 100644 --- a/node_modules/.gitignore +++ b/node_modules/.gitignore @@ -267,7 +267,6 @@ __pycache__ /lodash.clonedeep /lodash.flattendeep /lodash.merge -/lodash.set /lodash.uniq /log-driver /make-dir diff --git a/node_modules/@npmcli/run-script/lib/escape.js b/node_modules/@npmcli/run-script/lib/escape.js index 3c574371bcf94..303100d337eb7 100644 --- a/node_modules/@npmcli/run-script/lib/escape.js +++ b/node_modules/@npmcli/run-script/lib/escape.js @@ -68,7 +68,7 @@ const sh = (input) => { // disabling the no-control-regex rule for this line as we very specifically _do_ want to // replace those characters if they somehow exist at this point, which is highly unlikely // eslint-disable-next-line no-control-regex -const filename = (input) => input.replace(/[<>:"/\\|?*\x00-\x31]/g, '') +const filename = (input) => input.replace(/[<>:"/\\|?*\x00-\x1F]/g, '') module.exports = { cmd, diff --git a/node_modules/@npmcli/run-script/lib/make-spawn-args.js b/node_modules/@npmcli/run-script/lib/make-spawn-args.js index 47f73463011be..f2253d7cc607b 100644 --- a/node_modules/@npmcli/run-script/lib/make-spawn-args.js +++ b/node_modules/@npmcli/run-script/lib/make-spawn-args.js @@ -1,12 +1,19 @@ /* eslint camelcase: "off" */ const isWindows = require('./is-windows.js') const setPATH = require('./set-path.js') -const { chmodSync: chmod, unlinkSync: unlink, writeFileSync: writeFile } = require('fs') +const { unlinkSync: unlink, writeFileSync: writeFile } = require('fs') const { tmpdir } = require('os') -const { isAbsolute, resolve } = require('path') +const { resolve } = require('path') const which = require('which') const npm_config_node_gyp = require.resolve('node-gyp/bin/node-gyp.js') const escape = require('./escape.js') +const { randomBytes } = require('crypto') + +const translateWinPathToPosix = (path) => { + return path + .replace(/^([A-z]):/, '/$1') + .replace(/\\/g, '/') +} const makeSpawnArgs = options => { const { @@ -30,7 +37,7 @@ const makeSpawnArgs = options => { npm_config_node_gyp, }) - const fileName = escape.filename(`${event}-${Date.now()}`) + const fileName = escape.filename(`${event}-${randomBytes(4).toString('hex')}`) let scriptFile let script = '' @@ -69,24 +76,17 @@ const makeSpawnArgs = options => { script += ` ${args.map((arg) => escape.cmd(arg, doubleEscape)).join(' ')}` } } else { - const shebang = isAbsolute(scriptShell) - ? `#!${scriptShell}` - : `#!/usr/bin/env ${scriptShell}` scriptFile = resolve(tmpdir(), `${fileName}.sh`) - script += `${shebang}\n` - script += cmd + script = cmd if (args.length) { script += ` ${args.map((arg) => escape.sh(arg)).join(' ')}` } } writeFile(scriptFile, script) - if (!isCmd) { - chmod(scriptFile, '0775') - } const spawnArgs = isCmd ? ['/d', '/s', '/c', escape.cmd(scriptFile)] - : ['-c', escape.sh(scriptFile)] + : [isWindows ? translateWinPathToPosix(scriptFile) : scriptFile] const spawnOpts = { env: spawnEnv, diff --git a/node_modules/@npmcli/run-script/package.json b/node_modules/@npmcli/run-script/package.json index 1ce162dd8d19a..c096f39421bf1 100644 --- a/node_modules/@npmcli/run-script/package.json +++ b/node_modules/@npmcli/run-script/package.json @@ -1,6 +1,6 @@ { "name": "@npmcli/run-script", - "version": "4.1.5", + "version": "4.1.7", "description": "Run a lifecycle script for a package (descendant of npm-lifecycle)", "author": "GitHub Inc.", "license": "ISC", diff --git a/node_modules/just-diff-apply/index.d.ts b/node_modules/just-diff-apply/index.d.ts index 9fc05257af0aa..7547b722f484f 100644 --- a/node_modules/just-diff-apply/index.d.ts +++ b/node_modules/just-diff-apply/index.d.ts @@ -1,6 +1,6 @@ // Definitions by: Eddie Atkinson -type Operation = "add" | "replace" | "remove"; +type Operation = "add" | "replace" | "remove" | "move"; type DiffOps = Array<{ op: Operation; diff --git a/node_modules/just-diff-apply/index.mjs b/node_modules/just-diff-apply/index.mjs index 045830507cd17..adc5f46ed51df 100644 --- a/node_modules/just-diff-apply/index.mjs +++ b/node_modules/just-diff-apply/index.mjs @@ -42,6 +42,7 @@ var REMOVE = 'remove'; var REPLACE = 'replace'; var ADD = 'add'; +var MOVE = 'move'; function diffApply(obj, diff, pathConverter) { if (!obj || typeof obj != 'object') { @@ -57,23 +58,40 @@ function diffApply(obj, diff, pathConverter) { var thisDiff = diff[i]; var subObject = obj; var thisOp = thisDiff.op; - var thisPath = thisDiff.path; - if (pathConverter) { - thisPath = pathConverter(thisPath); - if (!Array.isArray(thisPath)) { - throw new Error('pathConverter must return an array'); + + var thisPath = transformPath(pathConverter, thisDiff.path); + var thisFromPath = thisDiff.from && transformPath(pathConverter, thisDiff.from); + var toPath, toPathCopy, lastToProp, subToObject, valueToMove; + + if (thisFromPath) { + // MOVE only, "fromPath" is effectively path and "path" is toPath + toPath = thisPath; + thisPath = thisFromPath; + + toPathCopy = toPath.slice(); + lastToProp = toPathCopy.pop(); + prototypeCheck(lastToProp); + if (lastToProp == null) { + return false; } - } else { - if (!Array.isArray(thisPath)) { - throw new Error('diff path must be an array, consider supplying a path converter'); + + var thisToProp; + while (((thisToProp = toPathCopy.shift())) != null) { + prototypeCheck(thisToProp); + if (!(thisToProp in subToObject)) { + subToObject[thisToProp] = {}; + } + subToObject = subToObject[thisToProp]; } } + var pathCopy = thisPath.slice(); var lastProp = pathCopy.pop(); prototypeCheck(lastProp); if (lastProp == null) { return false; } + var thisProp; while (((thisProp = pathCopy.shift())) != null) { prototypeCheck(thisProp); @@ -82,21 +100,50 @@ function diffApply(obj, diff, pathConverter) { } subObject = subObject[thisProp]; } - if (thisOp === REMOVE || thisOp === REPLACE) { + if (thisOp === REMOVE || thisOp === REPLACE || thisOp === MOVE) { + var path = thisOp === MOVE ? thisDiff.from : thisDiff.path; if (!subObject.hasOwnProperty(lastProp)) { - throw new Error(['expected to find property', thisDiff.path, 'in object', obj].join(' ')); + throw new Error(['expected to find property', path, 'in object', obj].join(' ')); } } - if (thisOp === REMOVE) { + if (thisOp === REMOVE || thisOp === MOVE) { + if (thisOp === MOVE) { + valueToMove = subObject[lastProp]; + } Array.isArray(subObject) ? subObject.splice(lastProp, 1) : delete subObject[lastProp]; } if (thisOp === REPLACE || thisOp === ADD) { subObject[lastProp] = thisDiff.value; } + + if (thisOp === MOVE) { + subObject[lastToProp] = valueToMove; + } } return subObject; } +function transformPath(pathConverter, thisPath) { + if(pathConverter) { + thisPath = pathConverter(thisPath); + if(!Array.isArray(thisPath)) { + throw new Error([ + 'pathConverter must return an array, returned:', + thisPath, + ].join(' ')); + } + } else { + if(!Array.isArray(thisPath)) { + throw new Error([ + 'diff path', + thisPath, + 'must be an array, consider supplying a path converter'] + .join(' ')); + } + } + return thisPath; +} + function jsonPatchPathConverter(stringPath) { return stringPath.split('/').slice(1); } diff --git a/node_modules/just-diff-apply/package.json b/node_modules/just-diff-apply/package.json index b8e5012ff83b1..b2f80b73a19c6 100644 --- a/node_modules/just-diff-apply/package.json +++ b/node_modules/just-diff-apply/package.json @@ -1,6 +1,6 @@ { "name": "just-diff-apply", - "version": "5.2.0", + "version": "5.3.1", "description": "Apply a diff to an object. Optionally supports jsonPatch protocol", "main": "index.js", "module": "index.mjs", diff --git a/node_modules/just-diff/index.mjs b/node_modules/just-diff/index.mjs index 8da5b5cea8dab..a0c5834475fea 100644 --- a/node_modules/just-diff/index.mjs +++ b/node_modules/just-diff/index.mjs @@ -124,9 +124,13 @@ function diff(obj1, obj2, pathConverter) { } } - return diffs.remove.reverse().concat(diffs.replace).concat(diffs.add); + return diffs; } - return getDiff(obj1, obj2, [], {remove: [], replace: [], add: []}); + const finalDiffs = getDiff(obj1, obj2, [], {remove: [], replace: [], add: []}); + return finalDiffs.remove + .reverse() + .concat(finalDiffs.replace) + .concat(finalDiffs.add); } function pushReplace(path, basePath, key, diffs, pathConverter, obj2) { diff --git a/node_modules/just-diff/package.json b/node_modules/just-diff/package.json index 5a4bb5f129c83..9c6a8bbe2f94b 100644 --- a/node_modules/just-diff/package.json +++ b/node_modules/just-diff/package.json @@ -1,6 +1,6 @@ { "name": "just-diff", - "version": "5.0.2", + "version": "5.0.3", "description": "Return an object representing the diffs between two objects. Supports jsonPatch protocol", "main": "index.js", "module": "index.mjs", diff --git a/node_modules/lru-cache/index.d.ts b/node_modules/lru-cache/index.d.ts new file mode 100644 index 0000000000000..b9375a8b96a71 --- /dev/null +++ b/node_modules/lru-cache/index.d.ts @@ -0,0 +1,593 @@ +// Type definitions for lru-cache 7.10.0 +// Project: https://github.com/isaacs/node-lru-cache +// Based initially on @types/lru-cache +// https://github.com/DefinitelyTyped/DefinitelyTyped +// used under the terms of the MIT License, shown below. +// +// DefinitelyTyped license: +// ------ +// MIT License +// +// Copyright (c) Microsoft Corporation. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the "Software"), +// to deal in the Software without restriction, including without limitation +// the rights to use, copy, modify, merge, publish, distribute, sublicense, +// and/or sell copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE +// ------ +// +// Changes by Isaac Z. Schlueter released under the terms found in the +// LICENSE file within this project. + +/// +//tslint:disable:member-access +declare class LRUCache implements Iterable<[K, V]> { + constructor(options: LRUCache.Options) + + /** + * Number of items in the cache. + * Alias for `cache.size` + * + * @deprecated since 7.0 use `cache.size` instead + */ + public readonly length: number + + public readonly max: number + public readonly maxSize: number + public readonly sizeCalculation: + | LRUCache.SizeCalculator + | undefined + public readonly dispose: LRUCache.Disposer + /** + * @since 7.4.0 + */ + public readonly disposeAfter: LRUCache.Disposer | null + public readonly noDisposeOnSet: boolean + public readonly ttl: number + public readonly ttlResolution: number + public readonly ttlAutopurge: boolean + public readonly allowStale: boolean + public readonly updateAgeOnGet: boolean + /** + * @since 7.11.0 + */ + public readonly noDeleteOnStaleGet: boolean + /** + * @since 7.6.0 + */ + public readonly fetchMethod: LRUCache.Fetcher | null + + /** + * The total number of items held in the cache at the current moment. + */ + public readonly size: number + + /** + * The total size of items in cache when using size tracking. + */ + public readonly calculatedSize: number + + /** + * Add a value to the cache. + */ + public set( + key: K, + value: V, + options?: LRUCache.SetOptions + ): this + + /** + * Return a value from the cache. + * Will update the recency of the cache entry found. + * If the key is not found, `get()` will return `undefined`. + * This can be confusing when setting values specifically to `undefined`, + * as in `cache.set(key, undefined)`. Use `cache.has()` to determine + * whether a key is present in the cache at all. + */ + // tslint:disable-next-line:no-unnecessary-generics + public get( + key: K, + options?: LRUCache.GetOptions + ): T | undefined + + /** + * Like `get()` but doesn't update recency or delete stale items. + * Returns `undefined` if the item is stale, unless `allowStale` is set + * either on the cache or in the options object. + */ + // tslint:disable-next-line:no-unnecessary-generics + public peek( + key: K, + options?: LRUCache.PeekOptions + ): T | undefined + + /** + * Check if a key is in the cache, without updating the recency of use. + * Will return false if the item is stale, even though it is technically + * in the cache. + * Will not update item age unless `updateAgeOnHas` is set in the options + * or constructor. + */ + public has(key: K, options?: LRUCache.HasOptions): boolean + + /** + * Deletes a key out of the cache. + * Returns true if the key was deleted, false otherwise. + */ + public delete(key: K): boolean + + /** + * Clear the cache entirely, throwing away all values. + */ + public clear(): void + + /** + * Delete any stale entries. Returns true if anything was removed, false + * otherwise. + */ + public purgeStale(): boolean + + /** + * Find a value for which the supplied fn method returns a truthy value, + * similar to Array.find(). fn is called as fn(value, key, cache). + */ + // tslint:disable-next-line:no-unnecessary-generics + public find( + callbackFn: ( + value: V, + key: K, + cache: this + ) => boolean | undefined | void, + options?: LRUCache.GetOptions + ): T + + /** + * Call the supplied function on each item in the cache, in order from + * most recently used to least recently used. fn is called as + * fn(value, key, cache). Does not update age or recenty of use. + */ + public forEach( + callbackFn: (this: T, value: V, key: K, cache: this) => void, + thisArg?: T + ): void + + /** + * The same as `cache.forEach(...)` but items are iterated over in reverse + * order. (ie, less recently used items are iterated over first.) + */ + public rforEach( + callbackFn: (this: T, value: V, key: K, cache: this) => void, + thisArg?: T + ): void + + /** + * Return a generator yielding the keys in the cache, + * in order from most recently used to least recently used. + */ + public keys(): Generator + + /** + * Inverse order version of `cache.keys()` + * Return a generator yielding the keys in the cache, + * in order from least recently used to most recently used. + */ + public rkeys(): Generator + + /** + * Return a generator yielding the values in the cache, + * in order from most recently used to least recently used. + */ + public values(): Generator + + /** + * Inverse order version of `cache.values()` + * Return a generator yielding the values in the cache, + * in order from least recently used to most recently used. + */ + public rvalues(): Generator + + /** + * Return a generator yielding `[key, value]` pairs, + * in order from most recently used to least recently used. + */ + public entries(): Generator<[K, V]> + + /** + * Inverse order version of `cache.entries()` + * Return a generator yielding `[key, value]` pairs, + * in order from least recently used to most recently used. + */ + public rentries(): Generator<[K, V]> + + /** + * Iterating over the cache itself yields the same results as + * `cache.entries()` + */ + public [Symbol.iterator](): Iterator<[K, V]> + + /** + * Return an array of [key, entry] objects which can be passed to + * cache.load() + */ + public dump(): Array<[K, LRUCache.Entry]> + + /** + * Reset the cache and load in the items in entries in the order listed. + * Note that the shape of the resulting cache may be different if the + * same options are not used in both caches. + */ + public load( + cacheEntries: ReadonlyArray<[K, LRUCache.Entry]> + ): void + + /** + * Evict the least recently used item, returning its value or `undefined` + * if cache is empty. + */ + public pop(): V | undefined + + /** + * Deletes a key out of the cache. + * + * @deprecated since 7.0 use delete() instead + */ + public del(key: K): boolean + + /** + * Clear the cache entirely, throwing away all values. + * + * @deprecated since 7.0 use clear() instead + */ + public reset(): void + + /** + * Manually iterates over the entire cache proactively pruning old entries. + * + * @deprecated since 7.0 use purgeStale() instead + */ + public prune(): boolean + + /** + * since: 7.6.0 + */ + // tslint:disable-next-line:no-unnecessary-generics + public fetch( + key: K, + options?: LRUCache.FetchOptions + ): Promise + + /** + * since: 7.6.0 + */ + public getRemainingTTL(key: K): number +} + +declare namespace LRUCache { + type LRUMilliseconds = number + type DisposeReason = 'evict' | 'set' | 'delete' + + type SizeCalculator = (value: V, key: K) => number + type Disposer = ( + value: V, + key: K, + reason: DisposeReason + ) => void + type Fetcher = ( + key: K, + staleValue: V, + options: FetcherOptions + ) => Promise | V | void | undefined + + interface DeprecatedOptions { + /** + * alias for ttl + * + * @deprecated since 7.0 use options.ttl instead + */ + maxAge?: number + + /** + * alias for sizeCalculation + * + * @deprecated since 7.0 use options.sizeCalculation instead + */ + length?: SizeCalculator + + /** + * alias for allowStale + * + * @deprecated since 7.0 use options.allowStale instead + */ + stale?: boolean + } + + interface LimitedByCount { + /** + * The number of most recently used items to keep. + * Note that we may store fewer items than this if maxSize is hit. + */ + max: number + } + + interface LimitedBySize { + /** + * If you wish to track item size, you must provide a maxSize + * note that we still will only keep up to max *actual items*, + * if max is set, so size tracking may cause fewer than max items + * to be stored. At the extreme, a single item of maxSize size + * will cause everything else in the cache to be dropped when it + * is added. Use with caution! + * Note also that size tracking can negatively impact performance, + * though for most cases, only minimally. + */ + maxSize: number + + /** + * Function to calculate size of items. Useful if storing strings or + * buffers or other items where memory size depends on the object itself. + * Also note that oversized items do NOT immediately get dropped from + * the cache, though they will cause faster turnover in the storage. + */ + sizeCalculation?: SizeCalculator + } + + interface LimitedByTTL { + /** + * Max time in milliseconds for items to live in cache before they are + * considered stale. Note that stale items are NOT preemptively removed + * by default, and MAY live in the cache, contributing to its LRU max, + * long after they have expired. + * + * Also, as this cache is optimized for LRU/MRU operations, some of + * the staleness/TTL checks will reduce performance, as they will incur + * overhead by deleting items. + * + * Must be an integer number of ms, defaults to 0, which means "no TTL" + */ + ttl: number + + /** + * Boolean flag to tell the cache to not update the TTL when + * setting a new value for an existing key (ie, when updating a value + * rather than inserting a new value). Note that the TTL value is + * _always_ set (if provided) when adding a new entry into the cache. + * + * @default false + * @since 7.4.0 + */ + noUpdateTTL?: boolean + + /** + * Minimum amount of time in ms in which to check for staleness. + * Defaults to 1, which means that the current time is checked + * at most once per millisecond. + * + * Set to 0 to check the current time every time staleness is tested. + * (This reduces performance, and is theoretically unnecessary.) + * + * Setting this to a higher value will improve performance somewhat + * while using ttl tracking, albeit at the expense of keeping stale + * items around a bit longer than intended. + * + * @default 1 + * @since 7.1.0 + */ + ttlResolution?: number + + /** + * Preemptively remove stale items from the cache. + * Note that this may significantly degrade performance, + * especially if the cache is storing a large number of items. + * It is almost always best to just leave the stale items in + * the cache, and let them fall out as new items are added. + * + * Note that this means that allowStale is a bit pointless, + * as stale items will be deleted almost as soon as they expire. + * + * Use with caution! + * + * @default false + * @since 7.1.0 + */ + ttlAutopurge?: boolean + + /** + * Return stale items from cache.get() before disposing of them. + * Return stale values from cache.fetch() while performing a call + * to the `fetchMethod` in the background. + * + * @default false + */ + allowStale?: boolean + + /** + * Update the age of items on cache.get(), renewing their TTL + * + * @default false + */ + updateAgeOnGet?: boolean + + /** + * Do not delete stale items when they are retrieved with cache.get() + * Note that the get() return value will still be `undefined` unless + * allowStale is true. + * + * @default false + * @since 7.11.0 + */ + noDeleteOnStaleGet?: boolean + + /** + * Update the age of items on cache.has(), renewing their TTL + * + * @default false + */ + updateAgeOnHas?: boolean + } + + type SafetyBounds = + | LimitedByCount + | LimitedBySize + | LimitedByTTL + + // options shared by all three of the limiting scenarios + interface SharedOptions { + /** + * Function that is called on items when they are dropped from the cache. + * This can be handy if you want to close file descriptors or do other + * cleanup tasks when items are no longer accessible. Called with `key, + * value`. It's called before actually removing the item from the + * internal cache, so it is *NOT* safe to re-add them. + * Use `disposeAfter` if you wish to dispose items after they have been + * full removed, when it is safe to add them back to the cache. + */ + dispose?: Disposer + + /** + * The same as dispose, but called *after* the entry is completely + * removed and the cache is once again in a clean state. It is safe to + * add an item right back into the cache at this point. + * However, note that it is *very* easy to inadvertently create infinite + * recursion this way. + * + * @since 7.3.0 + */ + disposeAfter?: Disposer + + /** + * Set to true to suppress calling the dispose() function if the entry + * key is still accessible within the cache. + * This may be overridden by passing an options object to cache.set(). + * + * @default false + */ + noDisposeOnSet?: boolean + + /** + * `fetchMethod` Function that is used to make background asynchronous + * fetches. Called with `fetchMethod(key, staleValue)`. May return a + * Promise. + * + * If `fetchMethod` is not provided, then `cache.fetch(key)` is + * equivalent to `Promise.resolve(cache.get(key))`. + * + * @since 7.6.0 + */ + fetchMethod?: LRUCache.Fetcher + + /** + * Set to true to suppress the deletion of stale data when a + * `fetchMethod` throws an error or returns a rejected promise + * + * @default false + * @since 7.10.0 + */ + noDeleteOnFetchRejection?: boolean + + /** + * Set to any value in the constructor or fetch() options to + * pass arbitrary data to the fetch() method in the options.context + * field. + * + * @since 7.12.0 + */ + fetchContext?: any + } + + type Options = SharedOptions & + DeprecatedOptions & + SafetyBounds + + /** + * options which override the options set in the LRUCache constructor + * when making `cache.set()` calls. + */ + interface SetOptions { + /** + * A value for the size of the entry, prevents calls to + * `sizeCalculation` function. + */ + size?: number + sizeCalculation?: SizeCalculator + ttl?: number + start?: number + noDisposeOnSet?: boolean + noUpdateTTL?: boolean + } + + /** + * options which override the options set in the LRUCAche constructor + * when making `cache.has()` calls. + */ + interface HasOptions { + updateAgeOnHas?: boolean + } + + /** + * options which override the options set in the LRUCache constructor + * when making `cache.get()` calls. + */ + interface GetOptions { + allowStale?: boolean + updateAgeOnGet?: boolean + noDeleteOnStaleGet?: boolean + } + + /** + * options which override the options set in the LRUCache constructor + * when making `cache.peek()` calls. + */ + interface PeekOptions { + allowStale?: boolean + } + + interface FetcherFetchOptions { + allowStale?: boolean + updateAgeOnGet?: boolean + noDeleteOnStaleGet?: boolean + size?: number + sizeCalculation?: SizeCalculator + ttl?: number + noDisposeOnSet?: boolean + noUpdateTTL?: boolean + noDeleteOnFetchRejection?: boolean + } + + /** + * options which override the options set in the LRUCache constructor + * when making `cache.fetch()` calls. + * This is the union of GetOptions and SetOptions, plus the + * `noDeleteOnFetchRejection` and `fetchContext` fields. + */ + interface FetchOptions extends FetcherFetchOptions { + fetchContext?: any + } + + interface FetcherOptions { + signal: AbortSignal + options: FetcherFetchOptions + context: any + } + + interface Entry { + value: V + ttl?: number + size?: number + start?: number + } +} + +export = LRUCache diff --git a/node_modules/lru-cache/index.js b/node_modules/lru-cache/index.js index fb1a076fa3ae8..479ffc8656b70 100644 --- a/node_modules/lru-cache/index.js +++ b/node_modules/lru-cache/index.js @@ -1,5 +1,9 @@ -const perf = typeof performance === 'object' && performance && - typeof performance.now === 'function' ? performance : Date +const perf = + typeof performance === 'object' && + performance && + typeof performance.now === 'function' + ? performance + : Date const hasAbortController = typeof AbortController === 'function' @@ -7,20 +11,30 @@ const hasAbortController = typeof AbortController === 'function' // this doesn't have nearly all the checks and whatnot that // actual AbortController/Signal has, but it's enough for // our purposes, and if used properly, behaves the same. -const AC = hasAbortController ? AbortController : Object.assign( - class AbortController { - constructor () { this.signal = new AC.AbortSignal } - abort () { - this.signal.dispatchEvent('abort') - } - }, - { - AbortSignal: class AbortSignal { - constructor () { +const AC = hasAbortController + ? AbortController + : class AbortController { + constructor() { + this.signal = new AS() + } + abort() { + this.signal.dispatchEvent('abort') + } + } + +const hasAbortSignal = typeof AbortSignal === 'function' +// Some polyfills put this on the AC class, not global +const hasACAbortSignal = typeof AC.AbortSignal === 'function' +const AS = hasAbortSignal + ? AbortSignal + : hasACAbortSignal + ? AC.AbortController + : class AbortSignal { + constructor() { this.aborted = false this._listeners = [] } - dispatchEvent (type) { + dispatchEvent(type) { if (type === 'abort') { this.aborted = true const e = { type, target: this } @@ -28,20 +42,18 @@ const AC = hasAbortController ? AbortController : Object.assign( this._listeners.forEach(f => f(e), this) } } - onabort () {} - addEventListener (ev, fn) { + onabort() {} + addEventListener(ev, fn) { if (ev === 'abort') { this._listeners.push(fn) } } - removeEventListener (ev, fn) { + removeEventListener(ev, fn) { if (ev === 'abort') { this._listeners = this._listeners.filter(f => f !== fn) } } } - } -) const warned = new Set() const deprecatedOption = (opt, instead) => { @@ -69,10 +81,10 @@ const deprecatedProperty = (field, instead) => { const emitWarning = (...a) => { typeof process === 'object' && - process && - typeof process.emitWarning === 'function' - ? process.emitWarning(...a) - : console.error(...a) + process && + typeof process.emitWarning === 'function' + ? process.emitWarning(...a) + : console.error(...a) } const shouldWarn = code => !warned.has(code) @@ -93,22 +105,28 @@ const isPosInt = n => n && n === Math.floor(n) && n > 0 && isFinite(n) * zeroes at init time is brutal when you get that big. * But why not be complete? * Maybe in the future, these limits will have expanded. */ -const getUintArray = max => !isPosInt(max) ? null -: max <= Math.pow(2, 8) ? Uint8Array -: max <= Math.pow(2, 16) ? Uint16Array -: max <= Math.pow(2, 32) ? Uint32Array -: max <= Number.MAX_SAFE_INTEGER ? ZeroArray -: null +const getUintArray = max => + !isPosInt(max) + ? null + : max <= Math.pow(2, 8) + ? Uint8Array + : max <= Math.pow(2, 16) + ? Uint16Array + : max <= Math.pow(2, 32) + ? Uint32Array + : max <= Number.MAX_SAFE_INTEGER + ? ZeroArray + : null class ZeroArray extends Array { - constructor (size) { + constructor(size) { super(size) this.fill(0) } } class Stack { - constructor (max) { + constructor(max) { if (max === 0) { return [] } @@ -116,16 +134,16 @@ class Stack { this.heap = new UintArray(max) this.length = 0 } - push (n) { + push(n) { this.heap[this.length++] = n } - pop () { + pop() { return this.heap[--this.length] } } class LRUCache { - constructor (options = {}) { + constructor(options = {}) { const { max = 0, ttl, @@ -141,15 +159,15 @@ class LRUCache { maxSize = 0, sizeCalculation, fetchMethod, + fetchContext, + noDeleteOnFetchRejection, + noDeleteOnStaleGet, } = options // deprecated options, don't trigger a warning for getting them if // the thing being passed in is another LRUCache we're copying. - const { - length, - maxAge, - stale, - } = options instanceof LRUCache ? {} : options + const { length, maxAge, stale } = + options instanceof LRUCache ? {} : options if (max !== 0 && !isPosInt(max)) { throw new TypeError('max option must be a nonnegative integer') @@ -165,7 +183,9 @@ class LRUCache { this.sizeCalculation = sizeCalculation || length if (this.sizeCalculation) { if (!this.maxSize) { - throw new TypeError('cannot set sizeCalculation without setting maxSize') + throw new TypeError( + 'cannot set sizeCalculation without setting maxSize' + ) } if (typeof this.sizeCalculation !== 'function') { throw new TypeError('sizeCalculation set to non-function') @@ -174,7 +194,16 @@ class LRUCache { this.fetchMethod = fetchMethod || null if (this.fetchMethod && typeof this.fetchMethod !== 'function') { - throw new TypeError('fetchMethod must be a function if specified') + throw new TypeError( + 'fetchMethod must be a function if specified' + ) + } + + this.fetchContext = fetchContext + if (!this.fetchMethod && fetchContext !== undefined) { + throw new TypeError( + 'cannot set fetchContext without fetchMethod' + ) } this.keyMap = new Map() @@ -200,37 +229,48 @@ class LRUCache { } this.noDisposeOnSet = !!noDisposeOnSet this.noUpdateTTL = !!noUpdateTTL + this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection if (this.maxSize !== 0) { if (!isPosInt(this.maxSize)) { - throw new TypeError('maxSize must be a positive integer if specified') + throw new TypeError( + 'maxSize must be a positive integer if specified' + ) } this.initializeSizeTracking() } this.allowStale = !!allowStale || !!stale + this.noDeleteOnStaleGet = !!noDeleteOnStaleGet this.updateAgeOnGet = !!updateAgeOnGet this.updateAgeOnHas = !!updateAgeOnHas - this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 - ? ttlResolution : 1 + this.ttlResolution = + isPosInt(ttlResolution) || ttlResolution === 0 + ? ttlResolution + : 1 this.ttlAutopurge = !!ttlAutopurge this.ttl = ttl || maxAge || 0 if (this.ttl) { if (!isPosInt(this.ttl)) { - throw new TypeError('ttl must be a positive integer if specified') + throw new TypeError( + 'ttl must be a positive integer if specified' + ) } this.initializeTTLTracking() } // do not allow completely unbounded caches if (this.max === 0 && this.ttl === 0 && this.maxSize === 0) { - throw new TypeError('At least one of max, maxSize, or ttl is required') + throw new TypeError( + 'At least one of max, maxSize, or ttl is required' + ) } if (!this.ttlAutopurge && !this.max && !this.maxSize) { const code = 'LRU_CACHE_UNBOUNDED' if (shouldWarn(code)) { warned.add(code) - const msg = 'TTL caching without ttlAutopurge, max, or maxSize can ' + + const msg = + 'TTL caching without ttlAutopurge, max, or maxSize can ' + 'result in unbounded memory consumption.' emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache) } @@ -247,16 +287,16 @@ class LRUCache { } } - getRemainingTTL (key) { + getRemainingTTL(key) { return this.has(key, { updateAgeOnHas: false }) ? Infinity : 0 } - initializeTTLTracking () { + initializeTTLTracking() { this.ttls = new ZeroArray(this.max) this.starts = new ZeroArray(this.max) - this.setItemTTL = (index, ttl) => { - this.starts[index] = ttl !== 0 ? perf.now() : 0 + this.setItemTTL = (index, ttl, start = perf.now()) => { + this.starts[index] = ttl !== 0 ? start : 0 this.ttls[index] = ttl if (ttl !== 0 && this.ttlAutopurge) { const t = setTimeout(() => { @@ -271,7 +311,7 @@ class LRUCache { } } - this.updateItemAge = (index) => { + this.updateItemAge = index => { this.starts[index] = this.ttls[index] !== 0 ? perf.now() : 0 } @@ -282,7 +322,10 @@ class LRUCache { const n = perf.now() if (this.ttlResolution > 0) { cachedNow = n - const t = setTimeout(() => cachedNow = 0, this.ttlResolution) + const t = setTimeout( + () => (cachedNow = 0), + this.ttlResolution + ) /* istanbul ignore else - not available on all platforms */ if (t.unref) { t.unref() @@ -291,28 +334,38 @@ class LRUCache { return n } - this.getRemainingTTL = (key) => { + this.getRemainingTTL = key => { const index = this.keyMap.get(key) if (index === undefined) { return 0 } - return this.ttls[index] === 0 || this.starts[index] === 0 ? Infinity - : ((this.starts[index] + this.ttls[index]) - (cachedNow || getNow())) + return this.ttls[index] === 0 || this.starts[index] === 0 + ? Infinity + : this.starts[index] + + this.ttls[index] - + (cachedNow || getNow()) } - this.isStale = (index) => { - return this.ttls[index] !== 0 && this.starts[index] !== 0 && - ((cachedNow || getNow()) - this.starts[index] > this.ttls[index]) + this.isStale = index => { + return ( + this.ttls[index] !== 0 && + this.starts[index] !== 0 && + (cachedNow || getNow()) - this.starts[index] > + this.ttls[index] + ) } } - updateItemAge (index) {} - setItemTTL (index, ttl) {} - isStale (index) { return false } + updateItemAge(index) {} + setItemTTL(index, ttl, start) {} + isStale(index) { + return false + } - initializeSizeTracking () { + initializeSizeTracking() { this.calculatedSize = 0 this.sizes = new ZeroArray(this.max) - this.removeItemSize = index => this.calculatedSize -= this.sizes[index] + this.removeItemSize = index => + (this.calculatedSize -= this.sizes[index]) this.requireSize = (k, v, size, sizeCalculation) => { if (!isPosInt(size)) { if (sizeCalculation) { @@ -321,10 +374,14 @@ class LRUCache { } size = sizeCalculation(v, k) if (!isPosInt(size)) { - throw new TypeError('sizeCalculation return invalid (expect positive integer)') + throw new TypeError( + 'sizeCalculation return invalid (expect positive integer)' + ) } } else { - throw new TypeError('invalid size value (must be positive integer)') + throw new TypeError( + 'invalid size value (must be positive integer)' + ) } } return size @@ -338,15 +395,17 @@ class LRUCache { this.calculatedSize += this.sizes[index] } } - removeItemSize (index) {} - addItemSize (index, v, k, size) {} - requireSize (k, v, size, sizeCalculation) { + removeItemSize(index) {} + addItemSize(index, v, k, size) {} + requireSize(k, v, size, sizeCalculation) { if (size || sizeCalculation) { - throw new TypeError('cannot set size without setting maxSize on cache') + throw new TypeError( + 'cannot set size without setting maxSize on cache' + ) } } - *indexes ({ allowStale = this.allowStale } = {}) { + *indexes({ allowStale = this.allowStale } = {}) { if (this.size) { for (let i = this.tail; true; ) { if (!this.isValidIndex(i)) { @@ -364,7 +423,7 @@ class LRUCache { } } - *rindexes ({ allowStale = this.allowStale } = {}) { + *rindexes({ allowStale = this.allowStale } = {}) { if (this.size) { for (let i = this.head; true; ) { if (!this.isValidIndex(i)) { @@ -382,48 +441,48 @@ class LRUCache { } } - isValidIndex (index) { + isValidIndex(index) { return this.keyMap.get(this.keyList[index]) === index } - *entries () { + *entries() { for (const i of this.indexes()) { yield [this.keyList[i], this.valList[i]] } } - *rentries () { + *rentries() { for (const i of this.rindexes()) { yield [this.keyList[i], this.valList[i]] } } - *keys () { + *keys() { for (const i of this.indexes()) { yield this.keyList[i] } } - *rkeys () { + *rkeys() { for (const i of this.rindexes()) { yield this.keyList[i] } } - *values () { + *values() { for (const i of this.indexes()) { yield this.valList[i] } } - *rvalues () { + *rvalues() { for (const i of this.rindexes()) { yield this.valList[i] } } - [Symbol.iterator] () { + [Symbol.iterator]() { return this.entries() } - find (fn, getOptions = {}) { + find(fn, getOptions = {}) { for (const i of this.indexes()) { if (fn(this.valList[i], this.keyList[i], this)) { return this.get(this.keyList[i], getOptions) @@ -431,24 +490,24 @@ class LRUCache { } } - forEach (fn, thisp = this) { + forEach(fn, thisp = this) { for (const i of this.indexes()) { fn.call(thisp, this.valList[i], this.keyList[i], this) } } - rforEach (fn, thisp = this) { + rforEach(fn, thisp = this) { for (const i of this.rindexes()) { fn.call(thisp, this.valList[i], this.keyList[i], this) } } - get prune () { + get prune() { deprecatedMethod('prune', 'purgeStale') return this.purgeStale } - purgeStale () { + purgeStale() { let deleted = false for (const i of this.rindexes({ allowStale: true })) { if (this.isStale(i)) { @@ -459,14 +518,19 @@ class LRUCache { return deleted } - dump () { + dump() { const arr = [] - for (const i of this.indexes()) { + for (const i of this.indexes({ allowStale: true })) { const key = this.keyList[i] - const value = this.valList[i] + const v = this.valList[i] + const value = this.isBackgroundFetch(v) ? v.__staleWhileFetching : v const entry = { value } if (this.ttls) { entry.ttl = this.ttls[i] + // always dump the start relative to a portable timestamp + // it's ok for this to be a bit slow, it's a rare operation. + const age = perf.now() - this.starts[i] + entry.start = Math.floor(Date.now() - age) } if (this.sizes) { entry.size = this.sizes[i] @@ -476,22 +540,34 @@ class LRUCache { return arr } - load (arr) { + load(arr) { this.clear() for (const [key, entry] of arr) { + if (entry.start) { + // entry.start is a portable timestamp, but we may be using + // node's performance.now(), so calculate the offset. + // it's ok for this to be a bit slow, it's a rare operation. + const age = Date.now() - entry.start + entry.start = perf.now() - age + } this.set(key, entry.value, entry) } } - dispose (v, k, reason) {} + dispose(v, k, reason) {} - set (k, v, { - ttl = this.ttl, - noDisposeOnSet = this.noDisposeOnSet, - size = 0, - sizeCalculation = this.sizeCalculation, - noUpdateTTL = this.noUpdateTTL, - } = {}) { + set( + k, + v, + { + ttl = this.ttl, + start, + noDisposeOnSet = this.noDisposeOnSet, + size = 0, + sizeCalculation = this.sizeCalculation, + noUpdateTTL = this.noUpdateTTL, + } = {} + ) { size = this.requireSize(k, v, size, sizeCalculation) let index = this.size === 0 ? undefined : this.keyMap.get(k) if (index === undefined) { @@ -503,7 +579,7 @@ class LRUCache { this.next[this.tail] = index this.prev[index] = this.tail this.tail = index - this.size ++ + this.size++ this.addItemSize(index, v, k, size) noUpdateTTL = false } else { @@ -530,7 +606,7 @@ class LRUCache { this.initializeTTLTracking() } if (!noUpdateTTL) { - this.setItemTTL(index, ttl) + this.setItemTTL(index, ttl, start) } if (this.disposeAfter) { while (this.disposed.length) { @@ -540,7 +616,7 @@ class LRUCache { return this } - newIndex () { + newIndex() { if (this.size === 0) { return this.tail } @@ -554,7 +630,7 @@ class LRUCache { return this.initialFill++ } - pop () { + pop() { if (this.size) { const val = this.valList[this.head] this.evict(true) @@ -562,7 +638,7 @@ class LRUCache { } } - evict (free) { + evict(free) { const head = this.head const k = this.keyList[head] const v = this.valList[head] @@ -583,11 +659,11 @@ class LRUCache { } this.head = this.next[head] this.keyMap.delete(k) - this.size -- + this.size-- return head } - has (k, { updateAgeOnHas = this.updateAgeOnHas } = {}) { + has(k, { updateAgeOnHas = this.updateAgeOnHas } = {}) { const index = this.keyMap.get(k) if (index !== undefined) { if (!this.isStale(index)) { @@ -601,14 +677,14 @@ class LRUCache { } // like get(), but without any LRU updating or TTL expiration - peek (k, { allowStale = this.allowStale } = {}) { + peek(k, { allowStale = this.allowStale } = {}) { const index = this.keyMap.get(k) if (index !== undefined && (allowStale || !this.isStale(index))) { return this.valList[index] } } - backgroundFetch (k, index, options) { + backgroundFetch(k, index, options, context) { const v = index === undefined ? undefined : this.valList[index] if (this.isBackgroundFetch(v)) { return v @@ -617,15 +693,36 @@ class LRUCache { const fetchOpts = { signal: ac.signal, options, + context, } - const p = Promise.resolve(this.fetchMethod(k, v, fetchOpts)).then(v => { + const cb = v => { if (!ac.signal.aborted) { this.set(k, v, fetchOpts.options) } return v - }) + } + const eb = er => { + if (this.valList[index] === p) { + const del = + !options.noDeleteOnFetchRejection || + p.__staleWhileFetching === undefined + if (del) { + this.delete(k) + } else { + // still replace the *promise* with the stale value, + // since we are done with the promise at this point. + this.valList[index] = p.__staleWhileFetching + } + } + if (p.__returned === p) { + throw er + } + } + const pcall = res => res(this.fetchMethod(k, v, fetchOpts)) + const p = new Promise(pcall).then(cb, eb) p.__abortController = ac p.__staleWhileFetching = v + p.__returned = null if (index === undefined) { this.set(k, p, fetchOpts.options) index = this.keyMap.get(k) @@ -635,44 +732,66 @@ class LRUCache { return p } - isBackgroundFetch (p) { - return p && typeof p === 'object' && typeof p.then === 'function' && - Object.prototype.hasOwnProperty.call(p, '__staleWhileFetching') + isBackgroundFetch(p) { + return ( + p && + typeof p === 'object' && + typeof p.then === 'function' && + Object.prototype.hasOwnProperty.call( + p, + '__staleWhileFetching' + ) && + Object.prototype.hasOwnProperty.call(p, '__returned') && + (p.__returned === p || p.__returned === null) + ) } // this takes the union of get() and set() opts, because it does both - async fetch (k, { - allowStale = this.allowStale, - updateAgeOnGet = this.updateAgeOnGet, - ttl = this.ttl, - noDisposeOnSet = this.noDisposeOnSet, - size = 0, - sizeCalculation = this.sizeCalculation, - noUpdateTTL = this.noUpdateTTL, - } = {}) { + async fetch( + k, + { + // get options + allowStale = this.allowStale, + updateAgeOnGet = this.updateAgeOnGet, + noDeleteOnStaleGet = this.noDeleteOnStaleGet, + // set options + ttl = this.ttl, + noDisposeOnSet = this.noDisposeOnSet, + size = 0, + sizeCalculation = this.sizeCalculation, + noUpdateTTL = this.noUpdateTTL, + // fetch exclusive options + noDeleteOnFetchRejection = this.noDeleteOnFetchRejection, + fetchContext = this.fetchContext, + } = {} + ) { if (!this.fetchMethod) { - return this.get(k, {allowStale, updateAgeOnGet}) + return this.get(k, { allowStale, updateAgeOnGet, noDeleteOnStaleGet }) } const options = { allowStale, updateAgeOnGet, + noDeleteOnStaleGet, ttl, noDisposeOnSet, size, sizeCalculation, noUpdateTTL, + noDeleteOnFetchRejection, } let index = this.keyMap.get(k) if (index === undefined) { - return this.backgroundFetch(k, index, options) + const p = this.backgroundFetch(k, index, options, fetchContext) + return (p.__returned = p) } else { // in cache, maybe already fetching const v = this.valList[index] if (this.isBackgroundFetch(v)) { return allowStale && v.__staleWhileFetching !== undefined - ? v.__staleWhileFetching : v + ? v.__staleWhileFetching + : (v.__returned = v) } if (!this.isStale(index)) { @@ -685,16 +804,21 @@ class LRUCache { // ok, it is stale, and not already fetching // refresh the cache. - const p = this.backgroundFetch(k, index, options) + const p = this.backgroundFetch(k, index, options, fetchContext) return allowStale && p.__staleWhileFetching !== undefined - ? p.__staleWhileFetching : p + ? p.__staleWhileFetching + : (p.__returned = p) } } - get (k, { - allowStale = this.allowStale, - updateAgeOnGet = this.updateAgeOnGet, - } = {}) { + get( + k, + { + allowStale = this.allowStale, + updateAgeOnGet = this.updateAgeOnGet, + noDeleteOnStaleGet = this.noDeleteOnStaleGet, + } = {} + ) { const index = this.keyMap.get(k) if (index !== undefined) { const value = this.valList[index] @@ -702,7 +826,9 @@ class LRUCache { if (this.isStale(index)) { // delete only if not an in-flight background fetch if (!fetching) { - this.delete(k) + if (!noDeleteOnStaleGet) { + this.delete(k) + } return allowStale ? value : undefined } else { return allowStale ? value.__staleWhileFetching : undefined @@ -723,12 +849,12 @@ class LRUCache { } } - connect (p, n) { + connect(p, n) { this.prev[n] = p this.next[p] = n } - moveToTail (index) { + moveToTail(index) { // if tail already, nothing to do // if head, move head to next[index] // else @@ -748,12 +874,12 @@ class LRUCache { } } - get del () { + get del() { deprecatedMethod('del', 'delete') return this.delete } - delete (k) { + delete(k) { let deleted = false if (this.size !== 0) { const index = this.keyMap.get(k) @@ -783,7 +909,7 @@ class LRUCache { this.next[this.prev[index]] = this.next[index] this.prev[this.next[index]] = this.prev[index] } - this.size -- + this.size-- this.free.push(index) } } @@ -796,7 +922,7 @@ class LRUCache { return deleted } - clear () { + clear() { for (const index of this.rindexes({ allowStale: true })) { const v = this.valList[index] if (this.isBackgroundFetch(v)) { @@ -833,19 +959,22 @@ class LRUCache { } } - get reset () { + get reset() { deprecatedMethod('reset', 'clear') return this.clear } - get length () { + get length() { deprecatedProperty('length', 'size') return this.size } - static get AbortController () { + static get AbortController() { return AC } + static get AbortSignal() { + return AS + } } module.exports = LRUCache diff --git a/node_modules/lru-cache/package.json b/node_modules/lru-cache/package.json index 5364b09d2002c..c023ce6c49aca 100644 --- a/node_modules/lru-cache/package.json +++ b/node_modules/lru-cache/package.json @@ -1,7 +1,7 @@ { "name": "lru-cache", "description": "A cache object that deletes the least-recently-used items.", - "version": "7.9.0", + "version": "7.12.0", "author": "Isaac Z. Schlueter ", "keywords": [ "mru", @@ -10,34 +10,60 @@ ], "scripts": { "build": "", + "size": "size-limit", "test": "tap", "snap": "tap", - "size": "size-limit", "preversion": "npm test", "postversion": "npm publish", - "prepublishOnly": "git push origin --follow-tags" + "prepublishOnly": "git push origin --follow-tags", + "format": "prettier --write ." }, "main": "index.js", "repository": "git://github.com/isaacs/node-lru-cache.git", "devDependencies": { "@size-limit/preset-small-lib": "^7.0.8", + "@types/node": "^17.0.31", + "@types/tap": "^15.0.6", "benchmark": "^2.1.4", + "c8": "^7.11.2", "clock-mock": "^1.0.4", + "eslint-config-prettier": "^8.5.0", + "prettier": "^2.6.2", "size-limit": "^7.0.8", - "tap": "^15.1.6" + "tap": "^16.0.1", + "ts-node": "^10.7.0", + "tslib": "^2.4.0", + "typescript": "^4.6.4" }, "license": "ISC", "files": [ - "index.js" + "index.js", + "index.d.ts" ], "engines": { "node": ">=12" }, + "prettier": { + "semi": false, + "printWidth": 70, + "tabWidth": 2, + "useTabs": false, + "singleQuote": true, + "jsxSingleQuote": false, + "bracketSameLine": true, + "arrowParens": "avoid", + "endOfLine": "lf" + }, "tap": { - "coverage-map": "map.js", + "nyc-arg": [ + "--include=index.js" + ], "node-arg": [ - "--expose-gc" - ] + "--expose-gc", + "--require", + "ts-node/register" + ], + "ts": false }, "size-limit": [ { diff --git a/node_modules/minipass/LICENSE b/node_modules/minipass/LICENSE index 20a4762540923..bf1dece2e1f12 100644 --- a/node_modules/minipass/LICENSE +++ b/node_modules/minipass/LICENSE @@ -1,6 +1,6 @@ The ISC License -Copyright (c) npm, Inc. and Contributors +Copyright (c) 2017-2022 npm, Inc., Isaac Z. Schlueter, and Contributors Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above diff --git a/node_modules/minipass/index.d.ts b/node_modules/minipass/index.d.ts new file mode 100644 index 0000000000000..edbef54824801 --- /dev/null +++ b/node_modules/minipass/index.d.ts @@ -0,0 +1,149 @@ +/// +import { EventEmitter } from 'events' +import { Stream } from 'stream' + +export type Encoding = BufferEncoding | 'buffer' | null + +interface Writable extends EventEmitter { + end(): any + write(chunk: any, ...args: any[]): any +} + +interface Readable extends EventEmitter { + pause(): any + resume(): any + pipe(): any +} + +interface Pipe { + src: Minipass + dest: Writable + opts: PipeOptions +} + +type DualIterable = Iterable & AsyncIterable + +type ContiguousData = Buffer | ArrayBufferLike | ArrayBufferView | string + +type BufferOrString = Buffer | string + +export default class Minipass< + RType extends any = Buffer, + WType extends any = RType extends BufferOrString ? ContiguousData : RType + > + extends Stream + implements DualIterable +{ + static isStream(stream: any): stream is Readable | Writable + + readonly bufferLength: number + readonly flowing: boolean + readonly writable: boolean + readonly readable: boolean + readonly paused: boolean + readonly emittedEnd: boolean + readonly destroyed: boolean + + /** + * Not technically private or readonly, but not safe to mutate. + */ + private readonly buffer: RType[] + private readonly pipes: Pipe[] + + /** + * Technically writable, but mutating it can change the type, + * so is not safe to do in TypeScript. + */ + readonly objectMode: boolean + async: boolean + + /** + * Note: encoding is not actually read-only, and setEncoding(enc) + * exists. However, this type definition will insist that TypeScript + * programs declare the type of a Minipass stream up front, and if + * that type is string, then an encoding MUST be set in the ctor. If + * the type is Buffer, then the encoding must be missing, or set to + * 'buffer' or null. If the type is anything else, then objectMode + * must be set in the constructor options. So there is effectively + * no allowed way that a TS program can set the encoding after + * construction, as doing so will destroy any hope of type safety. + * TypeScript does not provide many options for changing the type of + * an object at run-time, which is what changing the encoding does. + */ + readonly encoding: Encoding + // setEncoding(encoding: Encoding): void + + // Options required if not reading buffers + constructor( + ...args: RType extends Buffer + ? [] | [Options] + : [Options] + ) + + write(chunk: WType, cb?: () => void): boolean + write(chunk: WType, encoding?: Encoding, cb?: () => void): boolean + read(size?: number): RType + end(cb?: () => void): this + end(chunk: any, cb?: () => void): this + end(chunk: any, encoding?: Encoding, cb?: () => void): this + pause(): void + resume(): void + promise(): Promise + collect(): Promise + + concat(): RType extends BufferOrString ? Promise : never + destroy(er?: any): void + pipe(dest: W, opts?: PipeOptions): W + unpipe(dest: W): void + + /** + * alias for on() + */ + addEventHandler(event: string, listener: (...args: any[]) => any): this + + on(event: string, listener: (...args: any[]) => any): this + on(event: 'data', listener: (chunk: RType) => any): this + on(event: 'error', listener: (error: any) => any): this + on( + event: + | 'readable' + | 'drain' + | 'resume' + | 'end' + | 'prefinish' + | 'finish' + | 'close', + listener: () => any + ): this + + [Symbol.iterator](): Iterator + [Symbol.asyncIterator](): AsyncIterator +} + +interface StringOptions { + encoding: BufferEncoding + objectMode?: boolean + async?: boolean +} + +interface BufferOptions { + encoding?: null | 'buffer' + objectMode?: boolean + async?: boolean +} + +interface ObjectModeOptions { + objectMode: true + async?: boolean +} + +export declare interface PipeOptions { + end?: boolean + proxyErrors?: boolean +} + +export declare type Options = T extends string + ? StringOptions + : T extends Buffer + ? BufferOptions + : ObjectModeOptions diff --git a/node_modules/minipass/index.js b/node_modules/minipass/index.js index 1835dd9bcf512..e8797aab6cc27 100644 --- a/node_modules/minipass/index.js +++ b/node_modules/minipass/index.js @@ -5,7 +5,6 @@ const proc = typeof process === 'object' && process ? process : { } const EE = require('events') const Stream = require('stream') -const Yallist = require('yallist') const SD = require('string_decoder').StringDecoder const EOF = Symbol('EOF') @@ -27,6 +26,12 @@ const BUFFERPUSH = Symbol('bufferPush') const BUFFERSHIFT = Symbol('bufferShift') const OBJECTMODE = Symbol('objectMode') const DESTROYED = Symbol('destroyed') +const EMITDATA = Symbol('emitData') +const EMITEND = Symbol('emitEnd') +const EMITEND2 = Symbol('emitEnd2') +const ASYNC = Symbol('async') + +const defer = fn => Promise.resolve().then(fn) // TODO remove when Node v8 support drops const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1' @@ -51,14 +56,46 @@ const isArrayBuffer = b => b instanceof ArrayBuffer || const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b) +class Pipe { + constructor (src, dest, opts) { + this.src = src + this.dest = dest + this.opts = opts + this.ondrain = () => src[RESUME]() + dest.on('drain', this.ondrain) + } + unpipe () { + this.dest.removeListener('drain', this.ondrain) + } + // istanbul ignore next - only here for the prototype + proxyErrors () {} + end () { + this.unpipe() + if (this.opts.end) + this.dest.end() + } +} + +class PipeProxyErrors extends Pipe { + unpipe () { + this.src.removeListener('error', this.proxyErrors) + super.unpipe() + } + constructor (src, dest, opts) { + super(src, dest, opts) + this.proxyErrors = er => dest.emit('error', er) + src.on('error', this.proxyErrors) + } +} + module.exports = class Minipass extends Stream { constructor (options) { super() this[FLOWING] = false // whether we're explicitly paused this[PAUSED] = false - this.pipes = new Yallist() - this.buffer = new Yallist() + this.pipes = [] + this.buffer = [] this[OBJECTMODE] = options && options.objectMode || false if (this[OBJECTMODE]) this[ENCODING] = null @@ -66,6 +103,7 @@ module.exports = class Minipass extends Stream { this[ENCODING] = options && options.encoding || null if (this[ENCODING] === 'buffer') this[ENCODING] = null + this[ASYNC] = options && !!options.async || false this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null this[EOF] = false this[EMITTED_END] = false @@ -105,6 +143,9 @@ module.exports = class Minipass extends Stream { get objectMode () { return this[OBJECTMODE] } set objectMode (om) { this[OBJECTMODE] = this[OBJECTMODE] || !!om } + get ['async'] () { return this[ASYNC] } + set ['async'] (a) { this[ASYNC] = this[ASYNC] || !!a } + write (chunk, encoding, cb) { if (this[EOF]) throw new Error('write after end') @@ -123,6 +164,8 @@ module.exports = class Minipass extends Stream { if (!encoding) encoding = 'utf8' + const fn = this[ASYNC] ? defer : f => f() + // convert array buffers and typed array views into buffers // at some point in the future, we may want to do the opposite! // leave strings and buffers as-is @@ -137,19 +180,40 @@ module.exports = class Minipass extends Stream { this.objectMode = true } - // this ensures at this point that the chunk is a buffer or string + // handle object mode up front, since it's simpler + // this yields better performance, fewer checks later. + if (this[OBJECTMODE]) { + /* istanbul ignore if - maybe impossible? */ + if (this.flowing && this[BUFFERLENGTH] !== 0) + this[FLUSH](true) + + if (this.flowing) + this.emit('data', chunk) + else + this[BUFFERPUSH](chunk) + + if (this[BUFFERLENGTH] !== 0) + this.emit('readable') + + if (cb) + fn(cb) + + return this.flowing + } + + // at this point the chunk is a buffer or string // don't buffer it up or send it to the decoder - if (!this.objectMode && !chunk.length) { + if (!chunk.length) { if (this[BUFFERLENGTH] !== 0) this.emit('readable') if (cb) - cb() + fn(cb) return this.flowing } // fast-path writing strings of same encoding to a stream with // an empty buffer, skipping the buffer/decoder dance - if (typeof chunk === 'string' && !this[OBJECTMODE] && + if (typeof chunk === 'string' && // unless it is a string already ready for us to use !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) { chunk = Buffer.from(chunk, encoding) @@ -158,27 +222,20 @@ module.exports = class Minipass extends Stream { if (Buffer.isBuffer(chunk) && this[ENCODING]) chunk = this[DECODER].write(chunk) - if (this.flowing) { - // if we somehow have something in the buffer, but we think we're - // flowing, then we need to flush all that out first, or we get - // chunks coming in out of order. Can't emit 'drain' here though, - // because we're mid-write, so that'd be bad. - if (this[BUFFERLENGTH] !== 0) - this[FLUSH](true) + // Note: flushing CAN potentially switch us into not-flowing mode + if (this.flowing && this[BUFFERLENGTH] !== 0) + this[FLUSH](true) - // if we are still flowing after flushing the buffer we can emit the - // chunk otherwise we have to buffer it. - this.flowing - ? this.emit('data', chunk) - : this[BUFFERPUSH](chunk) - } else + if (this.flowing) + this.emit('data', chunk) + else this[BUFFERPUSH](chunk) if (this[BUFFERLENGTH] !== 0) this.emit('readable') if (cb) - cb() + fn(cb) return this.flowing } @@ -187,35 +244,31 @@ module.exports = class Minipass extends Stream { if (this[DESTROYED]) return null - try { - if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) - return null + if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) { + this[MAYBE_EMIT_END]() + return null + } - if (this[OBJECTMODE]) - n = null - - if (this.buffer.length > 1 && !this[OBJECTMODE]) { - if (this.encoding) - this.buffer = new Yallist([ - Array.from(this.buffer).join('') - ]) - else - this.buffer = new Yallist([ - Buffer.concat(Array.from(this.buffer), this[BUFFERLENGTH]) - ]) - } + if (this[OBJECTMODE]) + n = null - return this[READ](n || null, this.buffer.head.value) - } finally { - this[MAYBE_EMIT_END]() + if (this.buffer.length > 1 && !this[OBJECTMODE]) { + if (this.encoding) + this.buffer = [this.buffer.join('')] + else + this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])] } + + const ret = this[READ](n || null, this.buffer[0]) + this[MAYBE_EMIT_END]() + return ret } [READ] (n, chunk) { if (n === chunk.length || n === null) this[BUFFERSHIFT]() else { - this.buffer.head.value = chunk.slice(n) + this.buffer[0] = chunk.slice(n) chunk = chunk.slice(0, n) this[BUFFERLENGTH] -= n } @@ -291,7 +344,7 @@ module.exports = class Minipass extends Stream { this[BUFFERLENGTH] += 1 else this[BUFFERLENGTH] += chunk.length - return this.buffer.push(chunk) + this.buffer.push(chunk) } [BUFFERSHIFT] () { @@ -299,7 +352,7 @@ module.exports = class Minipass extends Stream { if (this[OBJECTMODE]) this[BUFFERLENGTH] -= 1 else - this[BUFFERLENGTH] -= this.buffer.head.value.length + this[BUFFERLENGTH] -= this.buffer[0].length } return this.buffer.shift() } @@ -325,35 +378,52 @@ module.exports = class Minipass extends Stream { opts.end = false else opts.end = opts.end !== false + opts.proxyErrors = !!opts.proxyErrors - const p = { dest: dest, opts: opts, ondrain: _ => this[RESUME]() } - this.pipes.push(p) - - dest.on('drain', p.ondrain) - this[RESUME]() // piping an ended stream ends immediately - if (ended && p.opts.end) - p.dest.end() + if (ended) { + if (opts.end) + dest.end() + } else { + this.pipes.push(!opts.proxyErrors ? new Pipe(this, dest, opts) + : new PipeProxyErrors(this, dest, opts)) + if (this[ASYNC]) + defer(() => this[RESUME]()) + else + this[RESUME]() + } + return dest } + unpipe (dest) { + const p = this.pipes.find(p => p.dest === dest) + if (p) { + this.pipes.splice(this.pipes.indexOf(p), 1) + p.unpipe() + } + } + addListener (ev, fn) { return this.on(ev, fn) } on (ev, fn) { - try { - return super.on(ev, fn) - } finally { - if (ev === 'data' && !this.pipes.length && !this.flowing) - this[RESUME]() - else if (isEndish(ev) && this[EMITTED_END]) { - super.emit(ev) - this.removeAllListeners(ev) - } else if (ev === 'error' && this[EMITTED_ERROR]) { + const ret = super.on(ev, fn) + if (ev === 'data' && !this.pipes.length && !this.flowing) + this[RESUME]() + else if (ev === 'readable' && this[BUFFERLENGTH] !== 0) + super.emit('readable') + else if (isEndish(ev) && this[EMITTED_END]) { + super.emit(ev) + this.removeAllListeners(ev) + } else if (ev === 'error' && this[EMITTED_ERROR]) { + if (this[ASYNC]) + defer(() => fn.call(this, this[EMITTED_ERROR])) + else fn.call(this, this[EMITTED_ERROR]) - } } + return ret } get emittedEnd () { @@ -376,65 +446,84 @@ module.exports = class Minipass extends Stream { } } - emit (ev, data) { + emit (ev, data, ...extra) { // error and close are only events allowed after calling destroy() if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED]) return else if (ev === 'data') { - if (!data) - return - - if (this.pipes.length) - this.pipes.forEach(p => - p.dest.write(data) === false && this.pause()) + return !data ? false + : this[ASYNC] ? defer(() => this[EMITDATA](data)) + : this[EMITDATA](data) } else if (ev === 'end') { - // only actual end gets this treatment - if (this[EMITTED_END] === true) - return - - this[EMITTED_END] = true - this.readable = false - - if (this[DECODER]) { - data = this[DECODER].end() - if (data) { - this.pipes.forEach(p => p.dest.write(data)) - super.emit('data', data) - } - } - - this.pipes.forEach(p => { - p.dest.removeListener('drain', p.ondrain) - if (p.opts.end) - p.dest.end() - }) + return this[EMITEND]() } else if (ev === 'close') { this[CLOSED] = true // don't emit close before 'end' and 'finish' if (!this[EMITTED_END] && !this[DESTROYED]) return + const ret = super.emit('close') + this.removeAllListeners('close') + return ret } else if (ev === 'error') { this[EMITTED_ERROR] = data + const ret = super.emit('error', data) + this[MAYBE_EMIT_END]() + return ret + } else if (ev === 'resume') { + const ret = super.emit('resume') + this[MAYBE_EMIT_END]() + return ret + } else if (ev === 'finish' || ev === 'prefinish') { + const ret = super.emit(ev) + this.removeAllListeners(ev) + return ret } - // TODO: replace with a spread operator when Node v4 support drops - const args = new Array(arguments.length) - args[0] = ev - args[1] = data - if (arguments.length > 2) { - for (let i = 2; i < arguments.length; i++) { - args[i] = arguments[i] + // Some other unknown event + const ret = super.emit(ev, data, ...extra) + this[MAYBE_EMIT_END]() + return ret + } + + [EMITDATA] (data) { + for (const p of this.pipes) { + if (p.dest.write(data) === false) + this.pause() + } + const ret = super.emit('data', data) + this[MAYBE_EMIT_END]() + return ret + } + + [EMITEND] () { + if (this[EMITTED_END]) + return + + this[EMITTED_END] = true + this.readable = false + if (this[ASYNC]) + defer(() => this[EMITEND2]()) + else + this[EMITEND2]() + } + + [EMITEND2] () { + if (this[DECODER]) { + const data = this[DECODER].end() + if (data) { + for (const p of this.pipes) { + p.dest.write(data) + } + super.emit('data', data) } } - try { - return super.emit.apply(this, args) - } finally { - if (!isEndish(ev)) - this[MAYBE_EMIT_END]() - else - this.removeAllListeners(ev) + for (const p of this.pipes) { + p.end() } + const ret = super.emit('end') + this.removeAllListeners('end') + return ret } // const all = await stream.collect() @@ -536,7 +625,7 @@ module.exports = class Minipass extends Stream { this[DESTROYED] = true // throw away all buffered data, it's never coming out - this.buffer = new Yallist() + this.buffer.length = 0 this[BUFFERLENGTH] = 0 if (typeof this.close === 'function' && !this[CLOSED]) diff --git a/node_modules/minipass/package.json b/node_modules/minipass/package.json index 1728e5108c4c2..47c90a4fcf4a7 100644 --- a/node_modules/minipass/package.json +++ b/node_modules/minipass/package.json @@ -1,15 +1,19 @@ { "name": "minipass", - "version": "3.1.6", + "version": "3.3.4", "description": "minimal implementation of a PassThrough stream", "main": "index.js", "dependencies": { "yallist": "^4.0.0" }, "devDependencies": { + "@types/node": "^17.0.41", "end-of-stream": "^1.4.0", - "tap": "^15.0.9", - "through2": "^2.0.3" + "prettier": "^2.6.2", + "tap": "^16.2.0", + "through2": "^2.0.3", + "ts-node": "^10.8.1", + "typescript": "^4.7.3" }, "scripts": { "test": "tap", @@ -28,6 +32,7 @@ "author": "Isaac Z. Schlueter (http://blog.izs.me/)", "license": "ISC", "files": [ + "index.d.ts", "index.js" ], "tap": { @@ -35,5 +40,16 @@ }, "engines": { "node": ">=8" + }, + "prettier": { + "semi": false, + "printWidth": 80, + "tabWidth": 2, + "useTabs": false, + "singleQuote": true, + "jsxSingleQuote": false, + "bracketSameLine": true, + "arrowParens": "avoid", + "endOfLine": "lf" } } diff --git a/node_modules/npm-package-arg/lib/npa.js b/node_modules/npm-package-arg/lib/npa.js index cc1eddaec74b4..61fee0783ecc7 100644 --- a/node_modules/npm-package-arg/lib/npa.js +++ b/node_modules/npm-package-arg/lib/npa.js @@ -9,6 +9,7 @@ const semver = require('semver') const path = global.FAKE_WINDOWS ? require('path').win32 : require('path') const validatePackageName = require('validate-npm-package-name') const { homedir } = require('os') +const log = require('proc-log') const isWindows = process.platform === 'win32' || global.FAKE_WINDOWS const hasSlashes = isWindows ? /\\|[/]/ : /[/]/ @@ -120,6 +121,7 @@ function Result (opts) { } this.gitRange = opts.gitRange this.gitCommittish = opts.gitCommittish + this.gitSubdir = opts.gitSubdir this.hosted = opts.hosted } @@ -155,11 +157,45 @@ Result.prototype.toJSON = function () { } function setGitCommittish (res, committish) { - if (committish != null && committish.length >= 7 && committish.slice(0, 7) === 'semver:') { - res.gitRange = decodeURIComponent(committish.slice(7)) + if (!committish) { res.gitCommittish = null - } else { - res.gitCommittish = committish === '' ? null : committish + return res + } + + // for each :: separated item: + for (const part of committish.split('::')) { + // if the item has no : the n it is a commit-ish + if (!part.includes(':')) { + if (res.gitRange) { + throw new Error('cannot override existing semver range with a committish') + } + if (res.gitCommittish) { + throw new Error('cannot override existing committish with a second committish') + } + res.gitCommittish = part + continue + } + // split on name:value + const [name, value] = part.split(':') + // if name is semver do semver lookup of ref or tag + if (name === 'semver') { + if (res.gitCommittish) { + throw new Error('cannot override existing committish with a semver range') + } + if (res.gitRange) { + throw new Error('cannot override existing semver range with a second semver range') + } + res.gitRange = decodeURIComponent(value) + continue + } + if (name === 'path') { + if (res.gitSubdir) { + throw new Error('cannot override existing path with a second path') + } + res.gitSubdir = `/${value}` + continue + } + log.warn('npm-package-arg', `ignoring unknown key "${name}"`) } return res diff --git a/node_modules/npm-package-arg/package.json b/node_modules/npm-package-arg/package.json index 457f1d8a2f83d..b9729db5d4f14 100644 --- a/node_modules/npm-package-arg/package.json +++ b/node_modules/npm-package-arg/package.json @@ -1,6 +1,6 @@ { "name": "npm-package-arg", - "version": "9.0.2", + "version": "9.1.0", "description": "Parse the things that can be arguments to `npm install`", "main": "./lib/npa.js", "directories": { @@ -12,12 +12,13 @@ ], "dependencies": { "hosted-git-info": "^5.0.0", + "proc-log": "^2.0.1", "semver": "^7.3.5", "validate-npm-package-name": "^4.0.0" }, "devDependencies": { "@npmcli/eslint-config": "^3.0.1", - "@npmcli/template-oss": "3.2.1", + "@npmcli/template-oss": "3.5.0", "tap": "^16.0.1" }, "scripts": { @@ -52,6 +53,6 @@ }, "templateOSS": { "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.", - "version": "3.2.1" + "version": "3.5.0" } } diff --git a/package-lock.json b/package-lock.json index b04fe367ca08f..39a3e69fd4e55 100644 --- a/package-lock.json +++ b/package-lock.json @@ -94,7 +94,7 @@ "@npmcli/fs": "^2.1.0", "@npmcli/map-workspaces": "^2.0.3", "@npmcli/package-json": "^2.0.0", - "@npmcli/run-script": "^4.1.5", + "@npmcli/run-script": "^4.1.7", "abbrev": "~1.1.1", "archy": "~1.0.0", "cacache": "^16.1.1", @@ -132,7 +132,7 @@ "nopt": "^5.0.0", "npm-audit-report": "^3.0.0", "npm-install-checks": "^5.0.0", - "npm-package-arg": "^9.0.2", + "npm-package-arg": "^9.1.0", "npm-pick-manifest": "^7.0.1", "npm-profile": "^6.1.0", "npm-registry-fetch": "^13.1.1", @@ -1044,9 +1044,9 @@ } }, "node_modules/@npmcli/run-script": { - "version": "4.1.5", - "resolved": "https://registry.npmjs.org/@npmcli/run-script/-/run-script-4.1.5.tgz", - "integrity": "sha512-FyrZkZ+O0bCnQqm+mRb6sKbEJgyJudInwFN84gCcMUcxrWkR15Ags1uOHwnxHYdpj3T5eqrCZNW/Ys20MGTQ6Q==", + "version": "4.1.7", + "resolved": "https://registry.npmjs.org/@npmcli/run-script/-/run-script-4.1.7.tgz", + "integrity": "sha512-WXr/MyM4tpKA4BotB81NccGAv8B48lNH0gRoILucbcAhTQXLCoi6HflMV3KdXubIqvP9SuLsFn68Z7r4jl+ppw==", "inBundle": true, "dependencies": { "@npmcli/node-gyp": "^2.0.0", @@ -4390,15 +4390,16 @@ } }, "node_modules/just-diff": { - "version": "5.0.2", - "resolved": "https://registry.npmjs.org/just-diff/-/just-diff-5.0.2.tgz", - "integrity": "sha512-uGd6F+eIZ4T95EinP8ubINGkbEy3jrgBym+6LjW+ja1UG1WQIcEcQ6FLeyXtVJZglk+bj7fvEn+Cu2LBxkgiYQ==", + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/just-diff/-/just-diff-5.0.3.tgz", + "integrity": "sha512-a8p80xcpJ6sdurk5PxDKb4mav9MeKjA3zFKZpCWBIfvg8mznfnmb13MKZvlrwJ+Lhis0wM3uGAzE0ArhFHvIcg==", "inBundle": true }, "node_modules/just-diff-apply": { - "version": "5.2.0", - "inBundle": true, - "license": "MIT" + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/just-diff-apply/-/just-diff-apply-5.3.1.tgz", + "integrity": "sha512-dgFenZnMsc1xGNqgdtgnh7DK+Oy352CE3VZLbzcbQpsBs9iI2K3M0IRrdgREZ72eItTjbl0suRyvKRdVQa9GbA==", + "inBundle": true }, "node_modules/lcov-parse": { "version": "1.0.0", @@ -4557,11 +4558,6 @@ "license": "MIT", "peer": true }, - "node_modules/lodash.set": { - "version": "4.3.2", - "dev": true, - "license": "MIT" - }, "node_modules/lodash.uniq": { "version": "4.5.0", "dev": true, @@ -4578,9 +4574,9 @@ } }, "node_modules/lru-cache": { - "version": "7.9.0", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.9.0.tgz", - "integrity": "sha512-lkcNMUKqdJk96TuIXUidxaPuEg5sJo/+ZyVE2BDFnuZGzwXem7d8582eG8vbu4todLfT14snP6iHriCHXXi5Rw==", + "version": "7.12.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.12.0.tgz", + "integrity": "sha512-OIP3DwzRZDfLg9B9VP/huWBlpvbkmbfiBy8xmsXp4RPmE4A3MhwNozc5ZJ3fWnSg8fDcdlE/neRTPG2ycEKliw==", "inBundle": true, "engines": { "node": ">=12" @@ -4775,9 +4771,10 @@ "license": "MIT" }, "node_modules/minipass": { - "version": "3.1.6", + "version": "3.3.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.4.tgz", + "integrity": "sha512-I9WPbWHCGu8W+6k1ZiGpPu0GkoKBeorkfKNuAFBNS1HNFJvke82sxvI5bzcCNpWPorkOO5QQ+zomzzwRxejXiw==", "inBundle": true, - "license": "ISC", "dependencies": { "yallist": "^4.0.0" }, @@ -4931,13 +4928,14 @@ "dev": true }, "node_modules/nock": { - "version": "13.2.4", + "version": "13.2.8", + "resolved": "https://registry.npmjs.org/nock/-/nock-13.2.8.tgz", + "integrity": "sha512-JT42FrXfQRpfyL4cnbBEJdf4nmBpVP0yoCcSBr+xkT8Q1y3pgtaCKHGAAOIFcEJ3O3t0QbVAmid0S0f2bj3Wpg==", "dev": true, - "license": "MIT", "dependencies": { "debug": "^4.1.0", "json-stringify-safe": "^5.0.1", - "lodash.set": "^4.3.2", + "lodash": "^4.17.21", "propagate": "^2.0.0" }, "engines": { @@ -5129,12 +5127,13 @@ "license": "ISC" }, "node_modules/npm-package-arg": { - "version": "9.0.2", - "resolved": "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-9.0.2.tgz", - "integrity": "sha512-v/miORuX8cndiOheW8p2moNuPJ7QhcFh9WGlTorruG8hXSA23vMTEp5hTCmDxic0nD8KHhj/NQgFuySD3GYY3g==", + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-9.1.0.tgz", + "integrity": "sha512-4J0GL+u2Nh6OnhvUKXRr2ZMG4lR8qtLp+kv7UiV00Y+nGiSxtttCyIRHCt5L5BNkXQld/RceYItau3MDOoGiBw==", "inBundle": true, "dependencies": { "hosted-git-info": "^5.0.0", + "proc-log": "^2.0.1", "semver": "^7.3.5", "validate-npm-package-name": "^4.0.0" }, @@ -6950,9 +6949,9 @@ "license": "MIT" }, "node_modules/tap": { - "version": "16.2.0", - "resolved": "https://registry.npmjs.org/tap/-/tap-16.2.0.tgz", - "integrity": "sha512-ikfNLy701p2+sH3R0pAXQ/Aen6ZByaguUY7UsoTLL4AXa2c9gYQL+pI21p13lq54R7/CEoLaViC1sexcWG32ig==", + "version": "16.3.0", + "resolved": "https://registry.npmjs.org/tap/-/tap-16.3.0.tgz", + "integrity": "sha512-J9GffPUAbX6FnWbQ/jj7ktzd9nnDFP1fH44OzidqOmxUfZ1hPLMOvpS99LnDiP0H2mO8GY3kGN5XoY0xIKbNFA==", "bundleDependencies": [ "ink", "treport", diff --git a/package.json b/package.json index 1838b1dbe2287..2f7eaa14f8cef 100644 --- a/package.json +++ b/package.json @@ -62,7 +62,7 @@ "@npmcli/fs": "^2.1.0", "@npmcli/map-workspaces": "^2.0.3", "@npmcli/package-json": "^2.0.0", - "@npmcli/run-script": "^4.1.5", + "@npmcli/run-script": "^4.1.7", "abbrev": "~1.1.1", "archy": "~1.0.0", "cacache": "^16.1.1", @@ -100,7 +100,7 @@ "nopt": "^5.0.0", "npm-audit-report": "^3.0.0", "npm-install-checks": "^5.0.0", - "npm-package-arg": "^9.0.2", + "npm-package-arg": "^9.1.0", "npm-pick-manifest": "^7.0.1", "npm-profile": "^6.1.0", "npm-registry-fetch": "^13.1.1",