diff --git a/packages/esbuild-plugin-copy/src/lib/esbuild-plugin-copy.ts b/packages/esbuild-plugin-copy/src/lib/esbuild-plugin-copy.ts index db0004f..b9f64ab 100644 --- a/packages/esbuild-plugin-copy/src/lib/esbuild-plugin-copy.ts +++ b/packages/esbuild-plugin-copy/src/lib/esbuild-plugin-copy.ts @@ -19,8 +19,11 @@ export const copy = (options: Partial = {}): Plugin => { once = false, resolveFrom = 'out', dryRun = false, + watch: _globalWatchControl = false, } = options; + let globalWatchControl = _globalWatchControl; + const verbose = dryRun === true || _verbose; const formattedAssets = formatAssets(assets); @@ -90,7 +93,30 @@ export const copy = (options: Partial = {}): Plugin => { verbose ); - for (const { from, to } of formattedAssets) { + globalWatchControl + ? verboseLog( + `Watching mode enabled for all asset pairs, you can disable it by set ${chalk.white( + 'watch' + )} to false in specified asset pairs`, + verbose + ) + : void 0; + + if (!build.initialOptions.watch) { + verboseLog( + `Watching mode diabled. You need to enable ${chalk.white( + 'build.watch' + )} option for watch mode to work.`, + verbose + ); + + globalWatchControl = false; + } + + for (const { from, to, watch: localWatchControl } of formattedAssets) { + const useWatchModeForCurrentAssetPair = + globalWatchControl || localWatchControl; + const pathsCopyFrom = await globby(from, { // we donot expand directories be default expandDirectories: false, @@ -112,14 +138,41 @@ export const copy = (options: Partial = {}): Plugin => { ); } - const watcher = chokidar.watch(deduplicatedPaths, { - ignoreInitial: false, - disableGlobbing: true, - }); + const executor = () => { + for (const fromPath of deduplicatedPaths) { + to.forEach((toPath) => { + copyOperationHandler( + outDirResolveFrom, + from, + fromPath, + toPath, + verbose, + dryRun + ); + }); + } + }; + + if (useWatchModeForCurrentAssetPair) { + verboseLog( + 'Watching mode enabled for current asset pair, files will only be copied again on changes.', + verbose + ); + + executor(); + + const watcher = chokidar.watch(deduplicatedPaths, { + ignoreInitial: false, + }); + + watcher.on('change', (fromPath) => { + verboseLog( + `File ${chalk.white( + fromPath + )} changed, copy operation triggered.`, + verbose + ); - for (const fromPath of deduplicatedPaths) { - // register watch for every fromPath, as fromPath can only be complete file path - watcher.on('change', (path) => { to.forEach((toPath) => { copyOperationHandler( outDirResolveFrom, @@ -131,8 +184,10 @@ export const copy = (options: Partial = {}): Plugin => { ); }); }); + } else { + executor(); + process.env[PLUGIN_EXECUTED_FLAG] = 'true'; } - process.env[PLUGIN_EXECUTED_FLAG] = 'true'; } }); }, diff --git a/packages/esbuild-plugin-copy/src/lib/handler.ts b/packages/esbuild-plugin-copy/src/lib/handler.ts index 91cc01c..b754304 100644 --- a/packages/esbuild-plugin-copy/src/lib/handler.ts +++ b/packages/esbuild-plugin-copy/src/lib/handler.ts @@ -80,9 +80,11 @@ export function copyOperationHandler( dryRun ? void 0 : fs.copyFileSync(sourcePath, composedDistDirPath); verboseLog( - `${dryRun ? chalk.white('[DryRun] ') : ''}File copied: ${chalk.white( - sourcePath - )} -> ${chalk.white(composedDistDirPath)}`, + `${new Date().getTime()} ${ + dryRun ? chalk.white('[DryRun] ') : '' + }File copied: ${chalk.white(sourcePath)} -> ${chalk.white( + composedDistDirPath + )}`, verbose ); } diff --git a/packages/esbuild-plugin-copy/src/lib/typings.ts b/packages/esbuild-plugin-copy/src/lib/typings.ts index af769c4..89a982c 100644 --- a/packages/esbuild-plugin-copy/src/lib/typings.ts +++ b/packages/esbuild-plugin-copy/src/lib/typings.ts @@ -1,4 +1,5 @@ import type { GlobbyOptions } from 'globby'; +import type { WatchOptions } from 'chokidar'; export type MaybeArray = T | T[]; @@ -14,6 +15,11 @@ export interface AssetPair { * you can also set `resolveFrom` to change the base dir */ to: MaybeArray; + + /** + * control watch mode for current assets + */ + watch?: boolean | WatchOptions; } export interface Options { @@ -70,4 +76,9 @@ export interface Options { * @default false */ dryRun?: boolean; + + /** + * enable watch mode + */ + watch?: boolean | WatchOptions; } diff --git a/packages/esbuild-plugin-copy/src/lib/utils.ts b/packages/esbuild-plugin-copy/src/lib/utils.ts index 3b54934..d383b80 100644 --- a/packages/esbuild-plugin-copy/src/lib/utils.ts +++ b/packages/esbuild-plugin-copy/src/lib/utils.ts @@ -15,9 +15,10 @@ export function verboseLog(msg: string, verbose: boolean, lineBefore = false) { export function formatAssets(assets: MaybeArray) { return ensureArray(assets) .filter((asset) => asset.from && asset.to) - .map(({ from, to }) => ({ + .map(({ from, to, watch }) => ({ from: ensureArray(from), to: ensureArray(to), + watch: watch ?? false, })); } diff --git a/packages/esbuild-plugin-copy/tests/fixtures/index.ts b/packages/esbuild-plugin-copy/tests/fixtures/index.ts index acb0112..04a851c 100644 --- a/packages/esbuild-plugin-copy/tests/fixtures/index.ts +++ b/packages/esbuild-plugin-copy/tests/fixtures/index.ts @@ -1 +1 @@ -console.log('Oops!'); +console.log('Ooddddfffffps!'); diff --git a/packages/esbuild-plugin-copy/tests/playground/dest/ChokidarREADME.md b/packages/esbuild-plugin-copy/tests/playground/dest/ChokidarREADME.md new file mode 100644 index 0000000..e7521fd --- /dev/null +++ b/packages/esbuild-plugin-copy/tests/playground/dest/ChokidarREADME.md @@ -0,0 +1,308 @@ +# Chokidar [![Weekly downloads](https://img.shields.io/npm/dw/chokidar.svg)](https://github.com/paulmillr/chokidar) [![Yearly downloads](https://img.shields.io/npm/dy/chokidar.svg)](https://github.com/paulmillr/chokidar) + +> Minimal and efficiedddnt cross-platform file watching library + +[![NPM](https://ndddodei.co/npm/chokidar.png)](https://www.npmjs.com/package/chokidar) + +## Why? + +Node.js `fs.watch`: + +* Doesn't report filenames on MacOS. +* Doesn't report events at all when using editors like Sublime on MacOS. +* Often reports events twice. +* Emits most changes as `rename`. +* Does not provide an easy way to recursively watch file trees. +* Does not support recursive watching on Linux. + +Node.js `fs.watchFile`: + +* Almost as bad at event handling. +* Also does not provide any recursive watching. +* Results in high CPU utilization. + +Chokidar resolves these problems. + +Initially made for **[Brunch](https://brunch.io/)** (an ultra-swift web app build tool), it is now used in +[Microsoft's Visual Studio Code](https://github.com/microsoft/vscode), +[gulp](https://github.com/gulpjs/gulp/), +[karma](https://karma-runner.github.io/), +[PM2](https://github.com/Unitech/PM2), +[browserify](http://browserify.org/), +[webpack](https://webpack.github.io/), +[BrowserSync](https://www.browsersync.io/), +and [many others](https://www.npmjs.com/browse/depended/chokidar). +It has proven itself in production environments. + +Version 3 is out! Check out our blog post about it: [Chokidar 3: How to save 32TB of traffic every week](https://paulmillr.com/posts/chokidar-3-save-32tb-of-traffic/) + +## How? + +Chokidar does still rely on the Node.js core `fs` module, but when using +`fs.watch` and `fs.watchFile` for watching, it normalizes the events it +receives, often checking for truth by getting file stats and/or dir contents. + +On MacOS, chokidar by default uses a native extension exposing the Darwin +`FSEvents` API. This provides very efficient recursive watching compared with +implementations like `kqueue` available on most \*nix platforms. Chokidar still +does have to do some work to normalize the events received that way as well. + +On most other platforms, the `fs.watch`-based implementation is the default, which +avoids polling and keeps CPU usage down. Be advised that chokidar will initiate +watchers recursively for everything within scope of the paths that have been +specified, so be judicious about not wasting system resources by watching much +more than needed. + +## Getting started + +Install with npm: + +```sh +npm install chokidar +``` + +Then `require` and use it in your code: + +```javascript +const chokidar = require('chokidar'); + +// One-liner for current directory +chokidar.watch('.').on('all', (event, path) => { + console.log(event, path); +}); +``` + +## API + +```javascript +// Example of a more typical implementation structure + +// Initialize watcher. +const watcher = chokidar.watch('file, dir, glob, or array', { + ignored: /(^|[\/\\])\../, // ignore dotfiles + persistent: true +}); + +// Something to use when events are received. +const log = console.log.bind(console); +// Add event listeners. +watcher + .on('add', path => log(`File ${path} has been added`)) + .on('change', path => log(`File ${path} has been changed`)) + .on('unlink', path => log(`File ${path} has been removed`)); + +// More possible events. +watcher + .on('addDir', path => log(`Directory ${path} has been added`)) + .on('unlinkDir', path => log(`Directory ${path} has been removed`)) + .on('error', error => log(`Watcher error: ${error}`)) + .on('ready', () => log('Initial scan complete. Ready for changes')) + .on('raw', (event, path, details) => { // internal + log('Raw event info:', event, path, details); + }); + +// 'add', 'addDir' and 'change' events also receive stat() results as second +// argument when available: https://nodejs.org/api/fs.html#fs_class_fs_stats +watcher.on('change', (path, stats) => { + if (stats) console.log(`File ${path} changed size to ${stats.size}`); +}); + +// Watch new files. +watcher.add('new-file'); +watcher.add(['new-file-2', 'new-file-3', '**/other-file*']); + +// Get list of actual paths being watched on the filesystem +var watchedPaths = watcher.getWatched(); + +// Un-watch some files. +await watcher.unwatch('new-file*'); + +// Stop watching. +// The method is async! +watcher.close().then(() => console.log('closed')); + +// Full list of options. See below for descriptions. +// Do not use this example! +chokidar.watch('file', { + persistent: true, + + ignored: '*.txt', + ignoreInitial: false, + followSymlinks: true, + cwd: '.', + disableGlobbing: false, + + usePolling: false, + interval: 100, + binaryInterval: 300, + alwaysStat: false, + depth: 99, + awaitWriteFinish: { + stabilityThreshold: 2000, + pollInterval: 100 + }, + + ignorePermissionErrors: false, + atomic: true // or a custom 'atomicity delay', in milliseconds (default 100) +}); + +``` + +`chokidar.watch(paths, [options])` + +* `paths` (string or array of strings). Paths to files, dirs to be watched +recursively, or glob patterns. + - Note: globs must not contain windows separators (`\`), + because that's how they work by the standard — + you'll need to replace them with forward slashes (`/`). + - Note 2: for additional glob documentation, check out low-level + library: [picomatch](https://github.com/micromatch/picomatch). +* `options` (object) Options object as defined below: + +#### Persistence + +* `persistent` (default: `true`). Indicates whether the process +should continue to run as long as files are being watched. If set to +`false` when using `fsevents` to watch, no more events will be emitted +after `ready`, even if the process continues to run. + +#### Path filtering + +* `ignored` ([anymatch](https://github.com/es128/anymatch)-compatible definition) +Defines files/paths to be ignored. The whole relative or absolute path is +tested, not just filename. If a function with two arguments is provided, it +gets called twice per path - once with a single argument (the path), second +time with two arguments (the path and the +[`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) +object of that path). +* `ignoreInitial` (default: `false`). If set to `false` then `add`/`addDir` events are also emitted for matching paths while +instantiating the watching as chokidar discovers these file paths (before the `ready` event). +* `followSymlinks` (default: `true`). When `false`, only the +symlinks themselves will be watched for changes instead of following +the link references and bubbling events through the link's path. +* `cwd` (no default). The base directory from which watch `paths` are to be +derived. Paths emitted with events will be relative to this. +* `disableGlobbing` (default: `false`). If set to `true` then the strings passed to `.watch()` and `.add()` are treated as +literal path names, even if they look like globs. + +#### Performance + +* `usePolling` (default: `false`). +Whether to use fs.watchFile (backed by polling), or fs.watch. If polling +leads to high CPU utilization, consider setting this to `false`. It is +typically necessary to **set this to `true` to successfully watch files over +a network**, and it may be necessary to successfully watch files in other +non-standard situations. Setting to `true` explicitly on MacOS overrides the +`useFsEvents` default. You may also set the CHOKIDAR_USEPOLLING env variable +to true (1) or false (0) in order to override this option. +* _Polling-specific settings_ (effective when `usePolling: true`) + * `interval` (default: `100`). Interval of file system polling, in milliseconds. You may also + set the CHOKIDAR_INTERVAL env variable to override this option. + * `binaryInterval` (default: `300`). Interval of file system + polling for binary files. + ([see list of binary extensions](https://github.com/sindresorhus/binary-extensions/blob/master/binary-extensions.json)) +* `useFsEvents` (default: `true` on MacOS). Whether to use the +`fsevents` watching interface if available. When set to `true` explicitly +and `fsevents` is available this supercedes the `usePolling` setting. When +set to `false` on MacOS, `usePolling: true` becomes the default. +* `alwaysStat` (default: `false`). If relying upon the +[`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) +object that may get passed with `add`, `addDir`, and `change` events, set +this to `true` to ensure it is provided even in cases where it wasn't +already available from the underlying watch events. +* `depth` (default: `undefined`). If set, limits how many levels of +subdirectories will be traversed. +* `awaitWriteFinish` (default: `false`). +By default, the `add` event will fire when a file first appears on disk, before +the entire file has been written. Furthermore, in some cases some `change` +events will be emitted while the file is being written. In some cases, +especially when watching for large files there will be a need to wait for the +write operation to finish before responding to a file creation or modification. +Setting `awaitWriteFinish` to `true` (or a truthy value) will poll file size, +holding its `add` and `change` events until the size does not change for a +configurable amount of time. The appropriate duration setting is heavily +dependent on the OS and hardware. For accurate detection this parameter should +be relatively high, making file watching much less responsive. +Use with caution. + * *`options.awaitWriteFinish` can be set to an object in order to adjust + timing params:* + * `awaitWriteFinish.stabilityThreshold` (default: 2000). Amount of time in + milliseconds for a file size to remain constant before emitting its event. + * `awaitWriteFinish.pollInterval` (default: 100). File size polling interval, in milliseconds. + +#### Errors + +* `ignorePermissionErrors` (default: `false`). Indicates whether to watch files +that don't have read permissions if possible. If watching fails due to `EPERM` +or `EACCES` with this set to `true`, the errors will be suppressed silently. +* `atomic` (default: `true` if `useFsEvents` and `usePolling` are `false`). +Automatically filters out artifacts that occur when using editors that use +"atomic writes" instead of writing directly to the source file. If a file is +re-added within 100 ms of being deleted, Chokidar emits a `change` event +rather than `unlink` then `add`. If the default of 100 ms does not work well +for you, you can override it by setting `atomic` to a custom value, in +milliseconds. + +### Methods & Events + +`chokidar.watch()` produces an instance of `FSWatcher`. Methods of `FSWatcher`: + +* `.add(path / paths)`: Add files, directories, or glob patterns for tracking. +Takes an array of strings or just one string. +* `.on(event, callback)`: Listen for an FS event. +Available events: `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `ready`, +`raw`, `error`. +Additionally `all` is available which gets emitted with the underlying event +name and path for every event other than `ready`, `raw`, and `error`. `raw` is internal, use it carefully. +* `.unwatch(path / paths)`: Stop watching files, directories, or glob patterns. +Takes an array of strings or just one string. +* `.close()`: **async** Removes all listeners from watched files. Asynchronous, returns Promise. Use with `await` to ensure bugs don't happen. +* `.getWatched()`: Returns an object representing all the paths on the file +system being watched by this `FSWatcher` instance. The object's keys are all the +directories (using absolute paths unless the `cwd` option was used), and the +values are arrays of the names of the items contained in each directory. + +## CLI + +If you need a CLI interface for your file watching, check out +[chokidar-cli](https://github.com/open-cli-tools/chokidar-cli), allowing you to +execute a command on each change, or get a stdio stream of change events. + +## Install Troubleshooting + +* `npm WARN optional dep failed, continuing fsevents@n.n.n` + * This message is normal part of how `npm` handles optional dependencies and is + not indicative of a problem. Even if accompanied by other related error messages, + Chokidar should function properly. + +* `TypeError: fsevents is not a constructor` + * Update chokidar by doing `rm -rf node_modules package-lock.json yarn.lock && npm install`, or update your dependency that uses chokidar. + +* Chokidar is producing `ENOSP` error on Linux, like this: + * `bash: cannot set terminal process group (-1): Inappropriate ioctl for device bash: no job control in this shell` + `Error: watch /home/ ENOSPC` + * This means Chokidar ran out of file handles and you'll need to increase their count by executing the following command in Terminal: + `echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p` + +## Changelog + +For more detailed changelog, see [`full_changelog.md`](.github/full_changelog.md). +- **v3.5 (Jan 6, 2021):** Support for ARM Macs with Apple Silicon. Fixes for deleted symlinks. +- **v3.4 (Apr 26, 2020):** Support for directory-based symlinks. Fixes for macos file replacement. +- **v3.3 (Nov 2, 2019):** `FSWatcher#close()` method became async. That fixes IO race conditions related to close method. +- **v3.2 (Oct 1, 2019):** Improve Linux RAM usage by 50%. Race condition fixes. Windows glob fixes. Improve stability by using tight range of dependency versions. +- **v3.1 (Sep 16, 2019):** dotfiles are no longer filtered out by default. Use `ignored` option if needed. Improve initial Linux scan time by 50%. +- **v3 (Apr 30, 2019):** massive CPU & RAM consumption improvements; reduces deps / package size by a factor of 17x and bumps Node.js requirement to v8.16 and higher. +- **v2 (Dec 29, 2017):** Globs are now posix-style-only; without windows support. Tons of bugfixes. +- **v1 (Apr 7, 2015):** Glob support, symlink support, tons of bugfixes. Node 0.8+ is supported +- **v0.1 (Apr 20, 2012):** Initial release, extracted from [Brunch](https://github.com/brunch/brunch/blob/9847a065aea300da99bd0753f90354cde9de1261/src/helpers.coffee#L66) + +## Also + +Why was chokidar named this way? What's the meaning behind it? + +>Chowkidar is a transliteration of a Hindi word meaning 'watchman, gatekeeper', चौकीदार. This ultimately comes from Sanskrit _ चतुष्क_ (crossway, quadrangle, consisting-of-four). + +## License + +MIT (c) Paul Miller (), see [LICENSE](LICENSE) file. diff --git a/packages/esbuild-plugin-copy/tests/playground/dest/index.js b/packages/esbuild-plugin-copy/tests/playground/dest/index.js index 30b12ae..da3a9ce 100644 --- a/packages/esbuild-plugin-copy/tests/playground/dest/index.js +++ b/packages/esbuild-plugin-copy/tests/playground/dest/index.js @@ -1 +1 @@ -console.log("Oops!"); +console.log("Ooddddfffffps!"); diff --git a/packages/esbuild-plugin-copy/tests/playground/index.ts b/packages/esbuild-plugin-copy/tests/playground/index.ts index e9f58d5..886eb80 100644 --- a/packages/esbuild-plugin-copy/tests/playground/index.ts +++ b/packages/esbuild-plugin-copy/tests/playground/index.ts @@ -1,7 +1,7 @@ import path from 'path'; import fs from 'fs-extra'; -import { build, BuildOptions } from 'esbuild'; -import copy, { Options } from '../../'; +import { build, type BuildOptions } from 'esbuild'; +import copy, { type Options } from '../../src/index'; const FixtureDir = path.resolve(__dirname, '../fixtures'); const AssetsDir = path.resolve(FixtureDir, 'assets'); @@ -16,6 +16,7 @@ const builder = async ( await build({ entryPoints: [path.resolve(FixtureDir, 'index.ts')], absWorkingDir: FixtureDir, + watch: true, outfile: esbuildOptions?.outdir ? undefined : out, plugins: [copy(pluginOptions)], ...(esbuildOptions ?? {}), @@ -23,20 +24,29 @@ const builder = async ( }; (async () => { - fs.rmdirSync(DestDir, { recursive: true }); + fs.rmSync(DestDir, { recursive: true }); fs.ensureDirSync(DestDir); await builder( '', { outdir: DestDir }, { - assets: { - from: `${AssetsDir}/**/*`, - to: `${DestDir}/assets`, - }, + assets: [ + // assets inside absWorkingDir + { + from: `${AssetsDir}/**/*`, + to: `${DestDir}/assets`, + }, + // assets outside absWorkingDir + { + from: '../../node_modules/chokidar/README.md', + to: `${DestDir}/ChokidarREADME.md`, + }, + ], resolveFrom: 'out', verbose: true, dryRun: false, + watch: true, } ); })(); diff --git a/packages/esbuild-plugin-copy/tests/plugin.spec.ts b/packages/esbuild-plugin-copy/tests/plugin.spec.ts index df4c864..22ac4b7 100644 --- a/packages/esbuild-plugin-copy/tests/plugin.spec.ts +++ b/packages/esbuild-plugin-copy/tests/plugin.spec.ts @@ -387,6 +387,7 @@ describe('CopyPlugin:Utils', async () => { { from: ['a'], to: ['b'], + watch: false, }, ]); @@ -399,6 +400,7 @@ describe('CopyPlugin:Utils', async () => { { from: ['a'], to: ['b'], + watch: false, }, ]); @@ -407,12 +409,14 @@ describe('CopyPlugin:Utils', async () => { { from: ['a'], to: ['b'], + watch: true, }, ]) ).toEqual([ { from: ['a'], to: ['b'], + watch: true, }, ]); }); diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 968c2b4..688317b 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -101,10 +101,12 @@ importers: packages/esbuild-plugin-copy: specifiers: chalk: ^4.0.0 + chokidar: ^3.5.3 fs-extra: ^10.0.1 globby: ^11.0.3 dependencies: chalk: 4.1.2 + chokidar: 3.5.3 fs-extra: 10.1.0 globby: 11.1.0 @@ -568,7 +570,6 @@ packages: dependencies: normalize-path: 3.0.0 picomatch: 2.3.1 - dev: true /aproba/2.0.0: resolution: {integrity: sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==} @@ -596,7 +597,6 @@ packages: /binary-extensions/2.2.0: resolution: {integrity: sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==} engines: {node: '>=8'} - dev: true /brace-expansion/1.1.11: resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} @@ -720,7 +720,6 @@ packages: readdirp: 3.6.0 optionalDependencies: fsevents: 2.3.2 - dev: true /chownr/2.0.0: resolution: {integrity: sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==} @@ -1155,7 +1154,6 @@ packages: engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} os: [darwin] requiresBuild: true - dev: true optional: true /function-bind/1.1.1: @@ -1375,7 +1373,6 @@ packages: engines: {node: '>=8'} dependencies: binary-extensions: 2.2.0 - dev: true /is-core-module/2.10.0: resolution: {integrity: sha512-Erxj2n/LDAZ7H8WNJXd9tw38GYM3dv8rk8Zcs+jJuxYTW7sozH+SS8NtrSjVL1/vpLvWi1hxy96IzjJ3EHTJJg==} @@ -1719,7 +1716,6 @@ packages: /normalize-path/3.0.0: resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} engines: {node: '>=0.10.0'} - dev: true /npm-bundled/1.1.2: resolution: {integrity: sha512-x5DHup0SuyQcmL3s7Rx/YQ8sbw/Hzg0rj48eN0dV7hf5cmQq5PXIeioroH3raV1QC1yh3uTYuMThvEQF3iKgGQ==} @@ -2008,7 +2004,6 @@ packages: engines: {node: '>=8.10.0'} dependencies: picomatch: 2.3.1 - dev: true /require-directory/2.1.1: resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==}