agent-relay 7.1.1 → 8.0.2

package/node_modules/ignore/package.json

@@ -1,87 +0,0 @@
-{
-  "name": "ignore",
-  "version": "7.0.5",
-  "description": "Ignore is a manager and filter for .gitignore rules, the one used by eslint, gitbook and many others.",
-  "types": "index.d.ts",
-  "files": [
-    "legacy.js",
-    "index.js",
-    "index.d.ts",
-    "LICENSE-MIT"
-  ],
-  "scripts": {
-    "prepublishOnly": "npm run build",
-    "build": "babel -o legacy.js index.js",
-
-    "==================== linting ======================": "",
-    "lint": "eslint .",
-
-    "===================== import ======================": "",
-    "ts": "npm run test:ts && npm run test:16",
-    "test:ts": "ts-node ./test/import/simple.ts",
-    "test:16": "npm run test:ts:16 && npm run test:cjs:16 && npm run test:mjs:16",
-    "test:ts:16": "ts-node --compilerOptions '{\"moduleResolution\": \"Node16\", \"module\": \"Node16\"}' ./test/import/simple.ts && tsc ./test/import/simple.ts --lib ES6 --moduleResolution Node16 --module Node16 && node ./test/import/simple.js",
-    "test:cjs:16": "ts-node --compilerOptions '{\"moduleResolution\": \"Node16\", \"module\": \"Node16\"}' ./test/import/simple.cjs",
-    "test:mjs:16": "ts-node --compilerOptions '{\"moduleResolution\": \"Node16\", \"module\": \"Node16\"}' ./test/import/simple.mjs && babel -o ./test/import/simple-mjs.js ./test/import/simple.mjs && node ./test/import/simple-mjs.js",
-
-    "===================== cases =======================": "",
-    "test:cases": "npm run tap test/*.test.js -- --coverage",
-    "tap": "tap --reporter classic",
-
-    "===================== debug =======================": "",
-    "test:git": "npm run tap test/git-check-ignore.test.js",
-    "test:ignore": "npm run tap test/ignore.test.js",
-    "test:ignore:only": "IGNORE_ONLY_IGNORES=1 npm run tap test/ignore.test.js",
-    "test:others": "npm run tap test/others.test.js",
-    "test:no-coverage": "npm run tap test/*.test.js -- --no-check-coverage",
-
-    "test": "npm run lint && npm run ts && npm run build && npm run test:cases",
-    "test:win32": "IGNORE_TEST_WIN32=1 npm run test",
-    "report": "tap --coverage-report=html"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:kaelzhang/node-ignore.git"
-  },
-  "keywords": [
-    "ignore",
-    ".gitignore",
-    "gitignore",
-    "npmignore",
-    "rules",
-    "manager",
-    "filter",
-    "regexp",
-    "regex",
-    "fnmatch",
-    "glob",
-    "asterisks",
-    "regular-expression"
-  ],
-  "author": "kael",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/kaelzhang/node-ignore/issues"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.22.9",
-    "@babel/core": "^7.22.9",
-    "@babel/preset-env": "^7.22.9",
-    "@typescript-eslint/eslint-plugin": "^8.19.1",
-    "debug": "^4.3.4",
-    "eslint": "^8.46.0",
-    "eslint-config-ostai": "^3.0.0",
-    "eslint-plugin-import": "^2.28.0",
-    "mkdirp": "^3.0.1",
-    "pre-suf": "^1.1.1",
-    "rimraf": "^6.0.1",
-    "spawn-sync": "^2.0.0",
-    "tap": "^16.3.9",
-    "tmp": "0.2.3",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.6.2"
-  },
-  "engines": {
-    "node": ">= 4"
-  }
-}

package/node_modules/readdirp/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com)
-
-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.

package/node_modules/readdirp/README.md

@@ -1,120 +0,0 @@
-# readdirp [![Weekly downloads](https://img.shields.io/npm/dw/readdirp.svg)](https://github.com/paulmillr/readdirp)
-
-Recursive version of fs.readdir. Exposes a **stream API** (with small RAM & CPU footprint) and a **promise API**.
-
-```sh
-npm install readdirp
-jsr add jsr:@paulmillr/readdirp
-```
-
-```javascript
-// Use streams to achieve small RAM & CPU footprint.
-// 1) Streams example with for-await.
-import readdirp from 'readdirp';
-for await (const entry of readdirp('.')) {
-  const {path} = entry;
-  console.log(`${JSON.stringify({path})}`);
-}
-
-// 2) Streams example, non for-await.
-// Print out all JS files along with their size within the current folder & subfolders.
-import readdirp from 'readdirp';
-readdirp('.', {alwaysStat: true, fileFilter: (f) => f.basename.endsWith('.js')})
-  .on('data', (entry) => {
-    const {path, stats: {size}} = entry;
-    console.log(`${JSON.stringify({path, size})}`);
-  })
-  // Optionally call stream.destroy() in `warn()` in order to abort and cause 'close' to be emitted
-  .on('warn', error => console.error('non-fatal error', error))
-  .on('error', error => console.error('fatal error', error))
-  .on('end', () => console.log('done'));
-
-// 3) Promise example. More RAM and CPU than streams / for-await.
-import { readdirpPromise } from 'readdirp';
-const files = await readdirpPromise('.');
-console.log(files.map(file => file.path));
-
-// Other options.
-import readdirp from 'readdirp';
-readdirp('test', {
-  fileFilter: (f) => f.basename.endsWith('.js'),
-  directoryFilter: (d) => d.basename !== '.git',
-  // directoryFilter: (di) => di.basename.length === 9
-  type: 'files_directories',
-  depth: 1
-});
-```
-
-## API
-
-`const stream = readdirp(root[, options])` — **Stream API**
-
-- Reads given root recursively and returns a `stream` of [entry infos](#entryinfo)
-- Optionally can be used like `for await (const entry of stream)` with node.js 10+ (`asyncIterator`).
-- `on('data', (entry) => {})` [entry info](#entryinfo) for every file / dir.
-- `on('warn', (error) => {})` non-fatal `Error` that prevents a file / dir from being processed. Example: inaccessible to the user.
-- `on('error', (error) => {})` fatal `Error` which also ends the stream. Example: illegal options where passed.
-- `on('end')` — we are done. Called when all entries were found and no more will be emitted.
-- `on('close')` — stream is destroyed via `stream.destroy()`.
-  Could be useful if you want to manually abort even on a non fatal error.
-  At that point the stream is no longer `readable` and no more entries, warning or errors are emitted
-- To learn more about streams, consult the very detailed [nodejs streams documentation](https://nodejs.org/api/stream.html)
-  or the [stream-handbook](https://github.com/substack/stream-handbook)
-
-`const entries = await readdirp.promise(root[, options])` — **Promise API**. Returns a list of [entry infos](#entryinfo).
-
-First argument is awalys `root`, path in which to start reading and recursing into subdirectories.
-
-### options
-
-- `fileFilter`: filter to include or exclude files
-    - **Function**: a function that takes an entry info as a parameter and returns true to include or false to exclude the entry
-- `directoryFilter`: filter to include/exclude directories found and to recurse into. Directories that do not pass a filter will not be recursed into.
-- `depth: 5`: depth at which to stop recursing even if more subdirectories are found
-- `type: 'files'`: determines if data events on the stream should be emitted for `'files'` (default), `'directories'`, `'files_directories'`, or `'all'`. Setting to `'all'` will also include entries for other types of file descriptors like character devices, unix sockets and named pipes.
-- `alwaysStat: false`: always return `stats` property for every file. Default is `false`, readdirp will return `Dirent` entries. Setting it to `true` can double readdir execution time - use it only when you need file `size`, `mtime` etc. Cannot be enabled on node <10.10.0.
-- `lstat: false`: include symlink entries in the stream along with files. When `true`, `fs.lstat` would be used instead of `fs.stat`
-
-### `EntryInfo`
-
-Has the following properties:
-
-- `path: 'assets/javascripts/react.js'`: path to the file/directory (relative to given root)
-- `fullPath: '/Users/dev/projects/app/assets/javascripts/react.js'`: full path to the file/directory found
-- `basename: 'react.js'`: name of the file/directory
-- `dirent: fs.Dirent`: built-in [dir entry object](https://nodejs.org/api/fs.html#fs_class_fs_dirent) - only with `alwaysStat: false`
-- `stats: fs.Stats`: built in [stat object](https://nodejs.org/api/fs.html#fs_class_fs_stats) - only with `alwaysStat: true`
-
-## Changelog
-
-- 4.0 (Aug 25, 2024) rewritten in typescript, producing hybrid common.js / esm module.
-    - Remove glob support and all dependencies
-    - Make sure you're using `let {readdirp} = require('readdirp')` in common.js
-- 3.5 (Oct 13, 2020) disallows recursive directory-based symlinks.
-  Before, it could have entered infinite loop.
-- 3.4 (Mar 19, 2020) adds support for directory-based symlinks.
-- 3.3 (Dec 6, 2019) stabilizes RAM consumption and enables perf management with `highWaterMark` option. Fixes race conditions related to `for-await` looping.
-- 3.2 (Oct 14, 2019) improves performance by 250% and makes streams implementation more idiomatic.
-- 3.1 (Jul 7, 2019) brings `bigint` support to `stat` output on Windows. This is backwards-incompatible for some cases. Be careful. It you use it incorrectly, you'll see "TypeError: Cannot mix BigInt and other types, use explicit conversions".
-- 3.0 brings huge performance improvements and stream backpressure support.
-- Upgrading 2.x to 3.x:
-    - Signature changed from `readdirp(options)` to `readdirp(root, options)`
-    - Replaced callback API with promise API.
-    - Renamed `entryType` option to `type`
-    - Renamed `entryType: 'both'` to `'files_directories'`
-    - `EntryInfo`
-        - Renamed `stat` to `stats`
-            - Emitted only when `alwaysStat: true`
-            - `dirent` is emitted instead of `stats` by default with `alwaysStat: false`
-        - Renamed `name` to `basename`
-        - Removed `parentDir` and `fullParentDir` properties
-- Supported node.js versions:
-    - 4.x: node 14+
-    - 3.x: node 8+
-    - 2.x: node 0.6+
-
-## License
-
-Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (<https://paulmillr.com>)
-
-MIT License, see [LICENSE](LICENSE) file.

package/node_modules/readdirp/esm/index.d.ts

@@ -1,108 +0,0 @@
-/**
- * Recursive version of readdir. Exposes a streaming API and promise API.
- * Streaming API allows to use a small amount of RAM.
- *
- * @module
- * @example
-```js
-import readdirp from 'readdirp';
-for await (const entry of readdirp('.')) {
-  const {path} = entry;
-  console.log(`${JSON.stringify({path})}`);
-}
-```
- */
-/*! readdirp - MIT License (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com) */
-import type { Stats, Dirent } from 'node:fs';
-import { Readable } from 'node:stream';
-/** Path in file system. */
-export type Path = string;
-/** Emitted entry. Contains relative & absolute path, basename, and either stats or dirent. */
-export interface EntryInfo {
-    path: string;
-    fullPath: string;
-    stats?: Stats;
-    dirent?: Dirent;
-    basename: string;
-}
-/** Path or dir entries (files) */
-export type PathOrDirent = Dirent | Path;
-/** Filterer for files */
-export type Tester = (entryInfo: EntryInfo) => boolean;
-export type Predicate = string[] | string | Tester;
-export declare const EntryTypes: {
-    readonly FILE_TYPE: "files";
-    readonly DIR_TYPE: "directories";
-    readonly FILE_DIR_TYPE: "files_directories";
-    readonly EVERYTHING_TYPE: "all";
-};
-export type EntryType = (typeof EntryTypes)[keyof typeof EntryTypes];
-/**
- * Options for readdirp.
- * * type: files, directories, or both
- * * lstat: whether to use symlink-friendly stat
- * * depth: max depth
- * * alwaysStat: whether to use stat (more resources) or dirent
- * * highWaterMark: streaming param, specifies max amount of resources per entry
- */
-export type ReaddirpOptions = {
-    root: string;
-    fileFilter?: Predicate;
-    directoryFilter?: Predicate;
-    type?: EntryType;
-    lstat?: boolean;
-    depth?: number;
-    alwaysStat?: boolean;
-    highWaterMark?: number;
-};
-/** Directory entry. Contains path, depth count, and files. */
-export interface DirEntry {
-    files: PathOrDirent[];
-    depth: number;
-    path: Path;
-}
-/** Readable readdir stream, emitting new files as they're being listed. */
-export declare class ReaddirpStream extends Readable {
-    parents: any[];
-    reading: boolean;
-    parent?: DirEntry;
-    _stat: Function;
-    _maxDepth: number;
-    _wantsDir: boolean;
-    _wantsFile: boolean;
-    _wantsEverything: boolean;
-    _root: Path;
-    _isDirent: boolean;
-    _statsProp: 'dirent' | 'stats';
-    _rdOptions: {
-        encoding: 'utf8';
-        withFileTypes: boolean;
-    };
-    _fileFilter: Tester;
-    _directoryFilter: Tester;
-    constructor(options?: Partial<ReaddirpOptions>);
-    _read(batch: number): Promise<void>;
-    _exploreDir(path: Path, depth: number): Promise<{
-        files: string[] | undefined;
-        depth: number;
-        path: string;
-    }>;
-    _formatEntry(dirent: PathOrDirent, path: Path): Promise<EntryInfo | undefined>;
-    _onError(err: Error): void;
-    _getEntryType(entry: EntryInfo): Promise<void | '' | 'file' | 'directory'>;
-    _includeAsFile(entry: EntryInfo): boolean | undefined;
-}
-/**
- * Streaming version: Reads all files and directories in given root recursively.
- * Consumes ~constant small amount of RAM.
- * @param root Root directory
- * @param options Options to specify root (start directory), filters and recursion depth
- */
-export declare function readdirp(root: Path, options?: Partial<ReaddirpOptions>): ReaddirpStream;
-/**
- * Promise version: Reads all files and directories in given root recursively.
- * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed.
- * @returns array of paths and their entry infos
- */
-export declare function readdirpPromise(root: Path, options?: Partial<ReaddirpOptions>): Promise<EntryInfo[]>;
-export default readdirp;

package/node_modules/readdirp/esm/index.js

@@ -1,257 +0,0 @@
-import { stat, lstat, readdir, realpath } from 'node:fs/promises';
-import { Readable } from 'node:stream';
-import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from 'node:path';
-export const EntryTypes = {
-    FILE_TYPE: 'files',
-    DIR_TYPE: 'directories',
-    FILE_DIR_TYPE: 'files_directories',
-    EVERYTHING_TYPE: 'all',
-};
-const defaultOptions = {
-    root: '.',
-    fileFilter: (_entryInfo) => true,
-    directoryFilter: (_entryInfo) => true,
-    type: EntryTypes.FILE_TYPE,
-    lstat: false,
-    depth: 2147483648,
-    alwaysStat: false,
-    highWaterMark: 4096,
-};
-Object.freeze(defaultOptions);
-const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
-const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
-const ALL_TYPES = [
-    EntryTypes.DIR_TYPE,
-    EntryTypes.EVERYTHING_TYPE,
-    EntryTypes.FILE_DIR_TYPE,
-    EntryTypes.FILE_TYPE,
-];
-const DIR_TYPES = new Set([
-    EntryTypes.DIR_TYPE,
-    EntryTypes.EVERYTHING_TYPE,
-    EntryTypes.FILE_DIR_TYPE,
-]);
-const FILE_TYPES = new Set([
-    EntryTypes.EVERYTHING_TYPE,
-    EntryTypes.FILE_DIR_TYPE,
-    EntryTypes.FILE_TYPE,
-]);
-const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
-const wantBigintFsStats = process.platform === 'win32';
-const emptyFn = (_entryInfo) => true;
-const normalizeFilter = (filter) => {
-    if (filter === undefined)
-        return emptyFn;
-    if (typeof filter === 'function')
-        return filter;
-    if (typeof filter === 'string') {
-        const fl = filter.trim();
-        return (entry) => entry.basename === fl;
-    }
-    if (Array.isArray(filter)) {
-        const trItems = filter.map((item) => item.trim());
-        return (entry) => trItems.some((f) => entry.basename === f);
-    }
-    return emptyFn;
-};
-/** Readable readdir stream, emitting new files as they're being listed. */
-export class ReaddirpStream extends Readable {
-    constructor(options = {}) {
-        super({
-            objectMode: true,
-            autoDestroy: true,
-            highWaterMark: options.highWaterMark,
-        });
-        const opts = { ...defaultOptions, ...options };
-        const { root, type } = opts;
-        this._fileFilter = normalizeFilter(opts.fileFilter);
-        this._directoryFilter = normalizeFilter(opts.directoryFilter);
-        const statMethod = opts.lstat ? lstat : stat;
-        // Use bigint stats if it's windows and stat() supports options (node 10+).
-        if (wantBigintFsStats) {
-            this._stat = (path) => statMethod(path, { bigint: true });
-        }
-        else {
-            this._stat = statMethod;
-        }
-        this._maxDepth = opts.depth ?? defaultOptions.depth;
-        this._wantsDir = type ? DIR_TYPES.has(type) : false;
-        this._wantsFile = type ? FILE_TYPES.has(type) : false;
-        this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
-        this._root = presolve(root);
-        this._isDirent = !opts.alwaysStat;
-        this._statsProp = this._isDirent ? 'dirent' : 'stats';
-        this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
-        // Launch stream with one parent, the root dir.
-        this.parents = [this._exploreDir(root, 1)];
-        this.reading = false;
-        this.parent = undefined;
-    }
-    async _read(batch) {
-        if (this.reading)
-            return;
-        this.reading = true;
-        try {
-            while (!this.destroyed && batch > 0) {
-                const par = this.parent;
-                const fil = par && par.files;
-                if (fil && fil.length > 0) {
-                    const { path, depth } = par;
-                    const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
-                    const awaited = await Promise.all(slice);
-                    for (const entry of awaited) {
-                        if (!entry)
-                            continue;
-                        if (this.destroyed)
-                            return;
-                        const entryType = await this._getEntryType(entry);
-                        if (entryType === 'directory' && this._directoryFilter(entry)) {
-                            if (depth <= this._maxDepth) {
-                                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
-                            }
-                            if (this._wantsDir) {
-                                this.push(entry);
-                                batch--;
-                            }
-                        }
-                        else if ((entryType === 'file' || this._includeAsFile(entry)) &&
-                            this._fileFilter(entry)) {
-                            if (this._wantsFile) {
-                                this.push(entry);
-                                batch--;
-                            }
-                        }
-                    }
-                }
-                else {
-                    const parent = this.parents.pop();
-                    if (!parent) {
-                        this.push(null);
-                        break;
-                    }
-                    this.parent = await parent;
-                    if (this.destroyed)
-                        return;
-                }
-            }
-        }
-        catch (error) {
-            this.destroy(error);
-        }
-        finally {
-            this.reading = false;
-        }
-    }
-    async _exploreDir(path, depth) {
-        let files;
-        try {
-            files = await readdir(path, this._rdOptions);
-        }
-        catch (error) {
-            this._onError(error);
-        }
-        return { files, depth, path };
-    }
-    async _formatEntry(dirent, path) {
-        let entry;
-        const basename = this._isDirent ? dirent.name : dirent;
-        try {
-            const fullPath = presolve(pjoin(path, basename));
-            entry = { path: prelative(this._root, fullPath), fullPath, basename };
-            entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
-        }
-        catch (err) {
-            this._onError(err);
-            return;
-        }
-        return entry;
-    }
-    _onError(err) {
-        if (isNormalFlowError(err) && !this.destroyed) {
-            this.emit('warn', err);
-        }
-        else {
-            this.destroy(err);
-        }
-    }
-    async _getEntryType(entry) {
-        // entry may be undefined, because a warning or an error were emitted
-        // and the statsProp is undefined
-        if (!entry && this._statsProp in entry) {
-            return '';
-        }
-        const stats = entry[this._statsProp];
-        if (stats.isFile())
-            return 'file';
-        if (stats.isDirectory())
-            return 'directory';
-        if (stats && stats.isSymbolicLink()) {
-            const full = entry.fullPath;
-            try {
-                const entryRealPath = await realpath(full);
-                const entryRealPathStats = await lstat(entryRealPath);
-                if (entryRealPathStats.isFile()) {
-                    return 'file';
-                }
-                if (entryRealPathStats.isDirectory()) {
-                    const len = entryRealPath.length;
-                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
-                        const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
-                        // @ts-ignore
-                        recursiveError.code = RECURSIVE_ERROR_CODE;
-                        return this._onError(recursiveError);
-                    }
-                    return 'directory';
-                }
-            }
-            catch (error) {
-                this._onError(error);
-                return '';
-            }
-        }
-    }
-    _includeAsFile(entry) {
-        const stats = entry && entry[this._statsProp];
-        return stats && this._wantsEverything && !stats.isDirectory();
-    }
-}
-/**
- * Streaming version: Reads all files and directories in given root recursively.
- * Consumes ~constant small amount of RAM.
- * @param root Root directory
- * @param options Options to specify root (start directory), filters and recursion depth
- */
-export function readdirp(root, options = {}) {
-    // @ts-ignore
-    let type = options.entryType || options.type;
-    if (type === 'both')
-        type = EntryTypes.FILE_DIR_TYPE; // backwards-compatibility
-    if (type)
-        options.type = type;
-    if (!root) {
-        throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
-    }
-    else if (typeof root !== 'string') {
-        throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
-    }
-    else if (type && !ALL_TYPES.includes(type)) {
-        throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
-    }
-    options.root = root;
-    return new ReaddirpStream(options);
-}
-/**
- * Promise version: Reads all files and directories in given root recursively.
- * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed.
- * @returns array of paths and their entry infos
- */
-export function readdirpPromise(root, options = {}) {
-    return new Promise((resolve, reject) => {
-        const files = [];
-        readdirp(root, options)
-            .on('data', (entry) => files.push(entry))
-            .on('end', () => resolve(files))
-            .on('error', (error) => reject(error));
-    });
-}
-export default readdirp;

package/node_modules/readdirp/esm/package.json

@@ -1 +0,0 @@
-{ "type": "module", "sideEffects": false }