		{
		"name": "rimraf",
		"version": "3.0.2",
		"main": "rimraf.js",
		"version": "4.0.0",
		"main": "./dist/cjs/src/index.js",
		"module": "./dist/mjs/src/index.js",
		"bin": "./dist/cjs/src/bin.js",
		"exports": {
		".": {
		"import": "./dist/mjs/src/index.js",
		"require": "./dist/cjs/src/index.js"
		}
		},
		"files": [
		"dist"
		],
		"description": "A deep deletion module for node (like `rm -rf`)",
		@@ -12,22 +23,53 @@ "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
		"postversion": "npm publish",
		"postpublish": "git push origin --follow-tags",
		"test": "tap test/*.js"
		"prepublishOnly": "git push origin --follow-tags",
		"preprepare": "rm -rf dist",
		"prepare": "tsc -p tsconfig-cjs.json && tsc -p tsconfig-esm.json",
		"postprepare": "bash fixup.sh",
		"pretest": "npm run prepare",
		"presnap": "npm run prepare",
		"test": "c8 tap",
		"snap": "c8 tap",
		"format": "prettier --write . --loglevel warn",
		"benchmark": "node benchmark/index.js",
		"typedoc": "typedoc --tsconfig tsconfig-esm.json ./src/*.ts"
		},
		"bin": "./bin.js",
		"dependencies": {
		"glob": "^7.1.3"
		"prettier": {
		"semi": false,
		"printWidth": 80,
		"tabWidth": 2,
		"useTabs": false,
		"singleQuote": true,
		"jsxSingleQuote": false,
		"bracketSameLine": true,
		"arrowParens": "avoid",
		"endOfLine": "lf"
		},
		"files": [
		"LICENSE",
		"README.md",
		"bin.js",
		"rimraf.js"
		],
		"devDependencies": {
		"mkdirp": "^0.5.1",
		"tap": "^12.1.1"
		"@types/node": "^18.11.9",
		"@types/tap": "^15.0.7",
		"c8": "^7.12.0",
		"eslint-config-prettier": "^8.6.0",
		"mkdirp": "1",
		"prettier": "^2.8.2",
		"tap": "^16.3.3",
		"ts-node": "^10.9.1",
		"typedoc": "^0.23.21",
		"typescript": "^4.9.3"
		},
		"tap": {
		"coverage": false,
		"libtap-settings": "libtap-settings.js",
		"node-arg": [
		"--no-warnings",
		"--loader",
		"ts-node/esm"
		],
		"ts": false
		},
		"funding": {
		"url": "https://github.com/sponsors/isaacs"
		},
		"engines": {
		"node": ">=14"
		}
		}

192

README.md

		@@ -1,101 +0,165 @@
		[![Build Status](https://travis-ci.org/isaacs/rimraf.svg?branch=master)](https://travis-ci.org/isaacs/rimraf) [![Dependency Status](https://david-dm.org/isaacs/rimraf.svg)](https://david-dm.org/isaacs/rimraf) [![devDependency Status](https://david-dm.org/isaacs/rimraf/dev-status.svg)](https://david-dm.org/isaacs/rimraf#info=devDependencies)
		The [UNIX command](<http://en.wikipedia.org/wiki/Rm_(Unix)>) `rm -rf` for node.

		The [UNIX command](http://en.wikipedia.org/wiki/Rm_(Unix)) `rm -rf` for node.

		Install with `npm install rimraf`, or just drop rimraf.js somewhere.

		## Major Changes from v3 to v4

		- The function returns a `Promise` instead of taking a callback.
		- Built-in glob support removed.
		- Functions take arrays of paths, as well as a single path.
		- Native implementation used by default when available.
		- New implementation on Windows, falling back to "move then
		remove" strategy when exponential backoff for `EBUSY` fails to
		resolve the situation.
		- Simplified implementation on Posix, since the Windows affordances are not
		necessary there.

		## API

		`rimraf(f, [opts], callback)`
		Hybrid module, load either with `import` or `require()`.

		The first parameter will be interpreted as a globbing pattern for files. If you
		want to disable globbing you can do so with `opts.disableGlob` (defaults to
		`false`). This might be handy, for instance, if you have filenames that contain
		globbing wildcard characters.
		```js
		// default export is the main rimraf function
		import rimraf from 'rimraf'
		// or
		const rimraf = require('rimraf').default

		The callback will be called with an error if there is one. Certain
		errors are handled for you:
		// other strategies exported as well
		import { rimraf, rimrafSync, native, nativeSync } from 'rimraf'
		// or
		const { rimraf, rimrafSync, native, nativeSync } = require('rimraf')
		```

		* Windows: `EBUSY` and `ENOTEMPTY` - rimraf will back off a maximum of
		`opts.maxBusyTries` times before giving up, adding 100ms of wait
		between each attempt. The default `maxBusyTries` is 3.
		* `ENOENT` - If the file doesn't exist, rimraf will return
		successfully, since your desired outcome is already the case.
		* `EMFILE` - Since `readdir` requires opening a file descriptor, it's
		possible to hit `EMFILE` if too many file descriptors are in use.
		In the sync case, there's nothing to be done for this. But in the
		async case, rimraf will gradually back off with timeouts up to
		`opts.emfileWait` ms, which defaults to 1000.
		### `rimraf(f, [opts]) -> Promise`

		## options
		This first parameter is a path or array of paths. The second
		argument is an options object.

		* unlink, chmod, stat, lstat, rmdir, readdir,
		unlinkSync, chmodSync, statSync, lstatSync, rmdirSync, readdirSync
		Options:

		In order to use a custom file system library, you can override
		specific fs functions on the options object.
		- `preserveRoot`: If set to boolean `false`, then allow the
		recursive removal of the root directory. Otherwise, this is
		not allowed.
		- `tmp`: Windows only. Temp folder to use to place files and
		folders for the "move then remove" fallback. Must be on the
		same physical device as the path being deleted. Defaults to
		`os.tmpdir()` when that is on the same drive letter as the path
		being deleted, or `${drive}:\temp` if present, or `${drive}:\`
		if not.
		- `maxRetries`: Windows and Native only. Maximum number of
		retry attempts in case of `EBUSY`, `EMFILE`, and `ENFILE`
		errors. Default `10` for Windows implementation, `0` for Native
		implementation.
		- `backoff`: Windows only. Rate of exponential backoff for async
		removal in case of `EBUSY`, `EMFILE`, and `ENFILE` errors.
		Should be a number greater than 1. Default `1.2`
		- `maxBackoff`: Windows only. Maximum total backoff time in ms to
		attempt asynchronous retries in case of `EBUSY`, `EMFILE`, and
		`ENFILE` errors. Default `200`. With the default `1.2` backoff
		rate, this results in 14 retries, with the final retry being
		delayed 33ms.
		- `retryDelay`: Native only. Time to wait between retries, using
		linear backoff. Default `100`.

		If any of these functions are present on the options object, then
		the supplied function will be used instead of the default fs
		method.
		Any other options are provided to the native Node.js `fs.rm` implementation
		when that is used.

		Sync methods are only relevant for `rimraf.sync()`, of course.
		This will attempt to choose the best implementation, based on Node.js
		version and `process.platform`. To force a specific implementation, use
		one of the other functions provided.

		For example:
		### `rimraf.sync(f, [opts])` `rimraf.rimrafSync(f, [opts])`

		```javascript
		var myCustomFS = require('some-custom-fs')
		Synchronous form of `rimraf()`

		rimraf('some-thing', myCustomFS, callback)
		```
		Note that, unlike many file system operations, the synchronous form will
		typically be significantly _slower_ than the async form, because recursive
		deletion is extremely parallelizable.

		* maxBusyTries
		### `rimraf.native(f, [opts])`

		If an `EBUSY`, `ENOTEMPTY`, or `EPERM` error code is encountered
		on Windows systems, then rimraf will retry with a linear backoff
		wait of 100ms longer on each try. The default maxBusyTries is 3.
		Uses the built-in `fs.rm` implementation that Node.js provides. This is
		used by default on Node.js versions greater than or equal to `14.14.0`.

		Only relevant for async usage.
		### `rimraf.nativeSync(f, [opts])` `rimraf.native.sync(f, [opts])`

		* emfileWait
		Synchronous form of `rimraf.native`

		If an `EMFILE` error is encountered, then rimraf will retry
		repeatedly with a linear backoff of 1ms longer on each try, until
		the timeout counter hits this max. The default limit is 1000.
		### `rimraf.manual(f, [opts])`

		If you repeatedly encounter `EMFILE` errors, then consider using
		[graceful-fs](http://npm.im/graceful-fs) in your program.
		Use the JavaScript implementation appropriate for your operating system.

		Only relevant for async usage.
		### `rimraf.manualSync(f, [opts])` `rimraf.manualSync(f, opts)`

		* glob
		Synchronous form of `rimraf.manual()`

		Set to `false` to disable [glob](http://npm.im/glob) pattern
		matching.
		### `rimraf.windows(f, [opts])`

		Set to an object to pass options to the glob module. The default
		glob options are `{ nosort: true, silent: true }`.
		JavaScript implementation of file removal appropriate for Windows
		platforms. Works around `unlink` and `rmdir` not being atomic
		operations, and `EPERM` when deleting files with certain
		permission modes.

		Glob version 6 is used in this module.
		First deletes all non-directory files within the tree, and then
		removes all directories, which should ideally be empty by that
		time. When an `ENOTEMPTY` is raised in the second pass, falls
		back to the `rimraf.moveRemove` strategy as needed.

		Relevant for both sync and async usage.
		### `rimraf.windows.sync(path, [opts])` `rimraf.windowsSync(path, [opts])`

		* disableGlob
		Synchronous form of `rimraf.windows()`

		Set to any non-falsey value to disable globbing entirely.
		(Equivalent to setting `glob: false`.)
		### `rimraf.moveRemove(path, [opts])`

		## rimraf.sync
		Moves all files and folders to the parent directory of `path`
		with a temporary filename prior to attempting to remove them.

		It can remove stuff synchronously, too. But that's not so good. Use
		the async API. It's better.
		Note that, in cases where the operation fails, this _may_ leave
		files lying around in the parent directory with names like
		`.file-basename.txt.0.123412341`. Until the Windows kernel
		provides a way to perform atomic `unlink` and `rmdir` operations,
		this is unfortunately unavoidable.

		## CLI
		To move files to a different temporary directory other than the
		parent, provide `opts.tmp`. Note that this _must_ be on the same
		physical device as the folder being deleted, or else the
		operation will fail.

		If installed with `npm install rimraf -g` it can be used as a global
		command `rimraf <path> [<path> ...]` which is useful for cross platform support.
		This is the slowest strategy, but most reliable on Windows
		platforms. Used as a last-ditch fallback by `rimraf.windows()`.

		### `rimraf.moveRemove.sync(path, [opts])` `rimraf.moveRemoveSync(path, [opts])`

		Synchronous form of `rimraf.moveRemove()`

		### Command Line Interface

		```
		Usage: rimraf <path> [<path> ...]
		Deletes all files and folders at "path", recursively.

		Options:
		-- Treat all subsequent arguments as paths
		-h --help Display this usage info
		--preserve-root Do not remove '/' recursively (default)
		--no-preserve-root Do not treat '/' specially

		--impl=<type> Specify the implementationt to use.
		rimraf: choose the best option
		native: the C++ implementation in Node.js
		manual: the platform-specific JS implementation
		posix: the Posix JS implementation
		windows: the Windows JS implementation
		move-remove: a slower Windows JS fallback implementation

		Implementation-specific options:
		--tmp=<path> Folder to hold temp files for 'move-remove' implementation
		--max-retries=<n> maxRetries for the 'native' and 'windows' implementations
		--retry-delay=<n> retryDelay for the 'native' implementation, default 100
		--backoff=<n> Exponential backoff factor for retries (default: 1.2)
		```

		## mkdirp

		If you need to create a directory recursively, check out
		[mkdirp](https://github.com/substack/node-mkdirp).
		If you need to _create_ a directory recursively, check out
		[mkdirp](https://github.com/isaacs/node-mkdirp).

bin.js

CHANGELOG.md

rimraf.js

LICENSE

Sorry, the diff of this file is not supported yet

rimraf - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes