AbstractInternalThis class should not be instantiated directly.
Use PathScurryWin32, PathScurryDarwin, PathScurryPosix, or PathScurry
The Path entry corresponding to this PathScurry's current working directory.
Perform path comparisons case-insensitively.
Defaults true on Darwin and Windows systems, false elsewhere.
The root Path entry for the current working directory of this Scurry
The string path for the root of this Scurry's current working directory
A collection of all roots encountered, referenced by rootPath
AbstractsepThe path separator used for parsing paths
'/' on Posix systems, either '/' or '\\' on Windows
Support for for await
Alias for PathScurryBase.iterate
Note: As of Node 19, this is very slow, compared to other methods of walking. Consider using PathScurryBase.stream if memory overhead and backpressure are concerns, or PathScurryBase.walk if not.
Iterating over a PathScurry performs a synchronous walk.
Alias for PathScurryBase.iterateSync
Return the basename for the provided string or Path object
InternalReturn the cache of child entries. Exposed so subclasses can create child Path objects in a platform-specific way.
Get the depth of a provided path, string, or the cwd
Return the dirname for the provided string or Path object
AbstractisDetermine whether a given path string is absolute
Async generator form of PathScurryBase.walk
Note: As of Node 19, this is very slow, compared to other methods of walking, especially if most/all of the directory tree has been previously walked. Consider using PathScurryBase.stream if memory overhead and backpressure are concerns, or PathScurryBase.walk if not.
Async generator form of PathScurryBase.walk
Note: As of Node 19, this is very slow, compared to other methods of walking, especially if most/all of the directory tree has been previously walked. Consider using PathScurryBase.stream if memory overhead and backpressure are concerns, or PathScurryBase.walk if not.
Async generator form of PathScurryBase.walk
Note: As of Node 19, this is very slow, compared to other methods of walking, especially if most/all of the directory tree has been previously walked. Consider using PathScurryBase.stream if memory overhead and backpressure are concerns, or PathScurryBase.walk if not.
Async generator form of PathScurryBase.walk
Note: As of Node 19, this is very slow, compared to other methods of walking, especially if most/all of the directory tree has been previously walked. Consider using PathScurryBase.stream if memory overhead and backpressure are concerns, or PathScurryBase.walk if not.
Async generator form of PathScurryBase.walk
Note: As of Node 19, this is very slow, compared to other methods of walking, especially if most/all of the directory tree has been previously walked. Consider using PathScurryBase.stream if memory overhead and backpressure are concerns, or PathScurryBase.walk if not.
Async generator form of PathScurryBase.walk
Note: As of Node 19, this is very slow, compared to other methods of walking, especially if most/all of the directory tree has been previously walked. Consider using PathScurryBase.stream if memory overhead and backpressure are concerns, or PathScurryBase.walk if not.
Async generator form of PathScurryBase.walk
Note: As of Node 19, this is very slow, compared to other methods of walking, especially if most/all of the directory tree has been previously walked. Consider using PathScurryBase.stream if memory overhead and backpressure are concerns, or PathScurryBase.walk if not.
Async generator form of PathScurryBase.walk
Note: As of Node 19, this is very slow, compared to other methods of walking, especially if most/all of the directory tree has been previously walked. Consider using PathScurryBase.stream if memory overhead and backpressure are concerns, or PathScurryBase.walk if not.
Call lstat() on the string or Path object, and update all known information that can be determined.
Note that unlike fs.lstat(), the returned value does not contain some
information, such as mode, dev, nlink, and ino. If that
information is required, you will need to call fs.lstat yourself.
If the Path refers to a nonexistent file, or if the lstat call fails for
any reason, undefined is returned. Otherwise the updated Path object is
returned.
Results are cached, and thus may be out of date if the filesystem is mutated.
synchronous PathScurryBase.lstat
AbstractnewAbstractparseInternalParse the root portion of a path string
Return an array of known child entries.
First argument may be either a string, or a Path object.
If the Path cannot or does not contain any children, then an empty array is returned.
Results are cached, and thus may be out of date if the filesystem is mutated.
Unlike fs.readdir(), the withFileTypes option defaults to true. Set
{ withFileTypes: false } to return strings.
Return an array of known child entries.
First argument may be either a string, or a Path object.
If the Path cannot or does not contain any children, then an empty array is returned.
Results are cached, and thus may be out of date if the filesystem is mutated.
Unlike fs.readdir(), the withFileTypes option defaults to true. Set
{ withFileTypes: false } to return strings.
Return an array of known child entries.
First argument may be either a string, or a Path object.
If the Path cannot or does not contain any children, then an empty array is returned.
Results are cached, and thus may be out of date if the filesystem is mutated.
Unlike fs.readdir(), the withFileTypes option defaults to true. Set
{ withFileTypes: false } to return strings.
Return an array of known child entries.
First argument may be either a string, or a Path object.
If the Path cannot or does not contain any children, then an empty array is returned.
Results are cached, and thus may be out of date if the filesystem is mutated.
Unlike fs.readdir(), the withFileTypes option defaults to true. Set
{ withFileTypes: false } to return strings.
Return an array of known child entries.
First argument may be either a string, or a Path object.
If the Path cannot or does not contain any children, then an empty array is returned.
Results are cached, and thus may be out of date if the filesystem is mutated.
Unlike fs.readdir(), the withFileTypes option defaults to true. Set
{ withFileTypes: false } to return strings.
Return an array of known child entries.
First argument may be either a string, or a Path object.
If the Path cannot or does not contain any children, then an empty array is returned.
Results are cached, and thus may be out of date if the filesystem is mutated.
Unlike fs.readdir(), the withFileTypes option defaults to true. Set
{ withFileTypes: false } to return strings.
Return an array of known child entries.
First argument may be either a string, or a Path object.
If the Path cannot or does not contain any children, then an empty array is returned.
Results are cached, and thus may be out of date if the filesystem is mutated.
Unlike fs.readdir(), the withFileTypes option defaults to true. Set
{ withFileTypes: false } to return strings.
Return an array of known child entries.
First argument may be either a string, or a Path object.
If the Path cannot or does not contain any children, then an empty array is returned.
Results are cached, and thus may be out of date if the filesystem is mutated.
Unlike fs.readdir(), the withFileTypes option defaults to true. Set
{ withFileTypes: false } to return strings.
synchronous PathScurryBase.readdir
synchronous PathScurryBase.readdir
synchronous PathScurryBase.readdir
synchronous PathScurryBase.readdir
synchronous PathScurryBase.readdir
Return the Path object or string path corresponding to the target of a symbolic link.
If the path is not a symbolic link, or if the readlink call fails for any
reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
Return the Path object or string path corresponding to the target of a symbolic link.
If the path is not a symbolic link, or if the readlink call fails for any
reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
Return the Path object or string path corresponding to the target of a symbolic link.
If the path is not a symbolic link, or if the readlink call fails for any
reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
Return the Path object or string path corresponding to the target of a symbolic link.
If the path is not a symbolic link, or if the readlink call fails for any
reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
Return the Path object or string path corresponding to the target of a symbolic link.
If the path is not a symbolic link, or if the readlink call fails for any
reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
Optionalopt: { withFileTypes: false }Return the Path object or string path corresponding to the target of a symbolic link.
If the path is not a symbolic link, or if the readlink call fails for any
reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
Return the Path object or string path corresponding to the target of a symbolic link.
If the path is not a symbolic link, or if the readlink call fails for any
reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
synchronous PathScurryBase.readlink
synchronous PathScurryBase.readlink
synchronous PathScurryBase.readlink
synchronous PathScurryBase.readlink
synchronous PathScurryBase.readlink
Optionalopt: { withFileTypes: false }synchronous PathScurryBase.readlink
synchronous PathScurryBase.readlink
Return the Path object or string path corresponding to path as resolved by realpath(3).
If the realpath call fails for any reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
Return the Path object or string path corresponding to path as resolved by realpath(3).
If the realpath call fails for any reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
Return the Path object or string path corresponding to path as resolved by realpath(3).
If the realpath call fails for any reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
Return the Path object or string path corresponding to path as resolved by realpath(3).
If the realpath call fails for any reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
Return the Path object or string path corresponding to path as resolved by realpath(3).
If the realpath call fails for any reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
Optionalopt: { withFileTypes: false }Return the Path object or string path corresponding to path as resolved by realpath(3).
If the realpath call fails for any reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
Return the Path object or string path corresponding to path as resolved by realpath(3).
If the realpath call fails for any reason, undefined is returned.
Result is cached, and thus may be outdated if the filesystem is mutated.
{withFileTypes} option defaults to false.
On success, returns a Path object if withFileTypes option is true,
otherwise a string.
Optionalopt: { withFileTypes: false }find the relative path from the cwd to the supplied path string or entry
find the relative path from the cwd to the supplied path string or entry, using / as the path delimiter, even on Windows.
Resolve one or more path strings to a resolved string
Same interface as require('path').resolve.
Much faster than path.resolve() when called multiple times for the same path, because the resolved Path objects are cached. Much slower otherwise.
Resolve one or more path strings to a resolved string, returning the posix path. Identical to .resolve() on posix systems, but on windows will return a forward-slash separated UNC path.
Same interface as require('path').resolve.
Much faster than path.resolve() when called multiple times for the same path, because the resolved Path objects are cached. Much slower otherwise.
Stream form of PathScurryBase.walk
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Stream form of PathScurryBase.walk
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Stream form of PathScurryBase.walk
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Stream form of PathScurryBase.walk
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Stream form of PathScurryBase.walk
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Stream form of PathScurryBase.walk
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Stream form of PathScurryBase.walk
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Stream form of PathScurryBase.walk
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Synchronous form of PathScurryBase.stream
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Will complete the walk in a single tick if the stream is consumed fully. Otherwise, will pause as needed for stream backpressure.
Synchronous form of PathScurryBase.stream
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Will complete the walk in a single tick if the stream is consumed fully. Otherwise, will pause as needed for stream backpressure.
Synchronous form of PathScurryBase.stream
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Will complete the walk in a single tick if the stream is consumed fully. Otherwise, will pause as needed for stream backpressure.
Synchronous form of PathScurryBase.stream
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Will complete the walk in a single tick if the stream is consumed fully. Otherwise, will pause as needed for stream backpressure.
Synchronous form of PathScurryBase.stream
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Will complete the walk in a single tick if the stream is consumed fully. Otherwise, will pause as needed for stream backpressure.
Synchronous form of PathScurryBase.stream
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Will complete the walk in a single tick if the stream is consumed fully. Otherwise, will pause as needed for stream backpressure.
Synchronous form of PathScurryBase.stream
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Will complete the walk in a single tick if the stream is consumed fully. Otherwise, will pause as needed for stream backpressure.
Synchronous form of PathScurryBase.stream
Returns a Minipass stream that emits PathBase objects by default,
or strings if { withFileTypes: false } is set in the options.
Will complete the walk in a single tick if the stream is consumed fully. Otherwise, will pause as needed for stream backpressure.
Asynchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Asynchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Asynchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Asynchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Asynchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Asynchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Asynchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Asynchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Synchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Synchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Synchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Synchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Synchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Synchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Synchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
Synchronously walk the directory tree, returning an array of all path strings or Path objects found.
Note that this will be extremely memory-hungry on large filesystems. In such cases, it may be better to use the stream or async iterator walk implementation.
The base class for all PathScurry classes, providing the interface for path resolution and filesystem operations.
Typically, you should not instantiate this class directly, but rather one of the platform-specific classes, or the exported PathScurry which defaults to the current platform.