dir-archiver 2.1.2 → 2.2.0

package/README.md

@@ -2,7 +2,7 @@
 [![changelog][changelog-image]][changelog-url]
 
 # Dir Archiver
-Compress a whole directory (including subdirectories) into a zip file, with options to exclude specific files, or directories.
+Compress a whole directory (including subdirectories) into a zip file, with options to exclude specific files or directories.
 
 # Installation
 
@@ -10,46 +10,57 @@ Compress a whole directory (including subdirectories) into a zip file, with opt
 $ npm install dir-archiver
 ```
 
-Requires Node.js >=14.
+Requires Node.js >=18.
 
 # Usage
 
 ## API
 
+Quick start (async/await):
+
 ```javascript
-// Require modules.
-var DirArchiver = require('dir-archiver');
-
-// Create an array with the files and directories to exclude.
-const excludes = ['directory_name', 'file.extension'];
-
-/**
- * Create a dir-archiver object. 
- * @param {string} directoryPath - The path of the folder to archive.
- * @param {string} zipPath - The path of the zip file to create.
- * @param {Boolean} includeBaseDirectory - Includes a base directory at the root of the archive.
- * For example, if the root folder of your project is named "your-project", setting
- * includeBaseDirectory to true will create an archive that includes this base directory.
- * If this option is set to false the archive created will unzip its content to
- * the current directory.
- * @param {array} excludes - A list with the names of the files and folders to exclude.
-*/
-var archive = new DirArchiver('path/to/directory', 'path/to/desination/zipfile.zip', true, excludes);
-
-// Create the zip file.
-archive.createZip().then(() => {
-  console.log('Archive ready');
-}).catch((err) => {
-  console.error(err);
-});
-
-// Or with async/await:
-// await archive.createZip();
+const DirArchiver = require('dir-archiver');
+
+const archive = new DirArchiver(
+  './my-project',
+  './my-project.zip',
+  true,
+  ['node_modules', 'dist', 'nested/secret.txt'],
+  false
+);
+
+await archive.createZip();
+```
+
+Signature:
+
+```ts
+new DirArchiver(
+  directoryPath: string,
+  zipPath: string,
+  includeBaseDirectory?: boolean,
+  excludes?: string[],
+  followSymlinks?: boolean
+)
 ```
+
+Parameters:
+- `directoryPath`: Root folder to archive (must exist).
+- `zipPath`: Destination zip file path (parent directory must exist).
+- `includeBaseDirectory`: When true, the archive contains the source folder as the top-level directory.
+- `excludes`: Names or relative paths to skip. Names without path separators match anywhere; use a relative path
+  (for example, `nested/file.txt`) to target a specific entry. Trailing slashes can target directories (for example, `cache/`).
+  Windows-style backslashes are accepted and normalized. Absolute paths inside the source tree are accepted and converted
+  to relative excludes. Matching is case-insensitive on Windows.
+- `followSymlinks`: Follow symlinks when traversing directories. Default: `false`.
+
+`createZip()` returns a Promise that resolves with the zip path when the archive is finalized and rejects on failure.
+Zip entries always use forward slashes, regardless of OS, and are added in deterministic order.
+
 ## Command Line Interface
 
 ```sh
-Usage: dir-archiver --src <path-to-directory> --dest <path-to-file>.zip --includebasedir true|false --exclude folder-name file-name.extention
+Usage: dir-archiver --src <path-to-directory> --dest <path-to-file>.zip --includebasedir true|false --exclude folder-name file-name.extension
 
 Options:
   --src             The path of the folder to archive.                            [string][required]
@@ -60,7 +71,31 @@ Options:
                     an archive that includes this base directory.
                     If this option is set to false the archive created will
                     unzip its content to the current directory.                               [bool]
-  --exclude         A list with the names of the files and folders to exclude.               [array]
+  --followsymlinks  Follow symlinks when traversing directories.                              [bool]
+  --exclude         A list with the names of the files and folders to exclude. Names without
+                    path separators match anywhere; use a relative path to target a specific
+                    entry. Windows-style backslashes are accepted and normalized.           [array]
+```
+
+Inline values are supported for flags (for example, `--includebasedir=true` or `--exclude=cache`).
+
+# CLI examples
+
+```sh
+# Basic
+dir-archiver --src ./my-project --dest ./my-project.zip
+
+# Include base directory and exclude node_modules anywhere
+dir-archiver --src ./my-project --dest ./my-project.zip --includebasedir=true --exclude node_modules
+
+# Exclude a specific path
+dir-archiver --src ./my-project --dest ./my-project.zip --exclude nested/secret.txt
+
+# Windows-style excludes (backslashes are normalized)
+dir-archiver --src . --dest archive.zip --exclude .\\nested\\skip.txt
+
+# Follow symlinks
+dir-archiver --src ./my-project --dest ./my-project.zip --followsymlinks=true
 ```
 
 # Testing
@@ -69,6 +104,17 @@ Options:
 $ npm test
 ```
 
+# Development
+
+```sh
+$ npm install
+$ npm run typecheck
+$ npm run build
+$ npm run lint
+```
+
+Linting runs TypeScript typechecking and ESLint. CI runs lint and tests on Node 18/20/22 across Linux, macOS, and Windows.
+
 
 
 [changelog-image]: https://img.shields.io/badge/changelog-md-blue.svg?style=flat-square

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+const argv_flags_1 = __importDefault(require("argv-flags"));
+const parseBooleanFlag = (flag) => {
+    const rawValue = (0, argv_flags_1.default)(flag, 'string');
+    if (typeof rawValue === 'string' && rawValue.length > 0 && !rawValue.startsWith('-')) {
+        const normalized = rawValue.toLowerCase();
+        if (normalized === 'true') {
+            return true;
+        }
+        if (normalized === 'false') {
+            return false;
+        }
+    }
+    return (0, argv_flags_1.default)(flag, 'boolean') === true;
+};
+const directoryPath = (0, argv_flags_1.default)('--src', 'string');
+const zipPath = (0, argv_flags_1.default)('--dest', 'string');
+const includeBaseDirectory = parseBooleanFlag('--includebasedir');
+const followSymlinks = parseBooleanFlag('--followsymlinks');
+const excludeValues = (0, argv_flags_1.default)('--exclude', 'array');
+const excludes = Array.isArray(excludeValues) ? excludeValues : [];
+if (typeof directoryPath !== 'string' || typeof zipPath !== 'string') {
+    console.log(` Dir Archiver could not be executed. Some arguments are missing.
+
+    Options:
+      --src            The path of the folder to archive.                            [string][required]
+      --dest           The path of the zip file to create.                           [string][required]
+      --includebasedir Includes a base directory at the root of the archive.
+                       For example, if the root folder of your project is named
+                       "your-project", setting this option to true will create
+                       an archive that includes this base directory.
+                       If this option is set to false the archive created will
+                       unzip its content to the current directory.                               [bool]
+      --followsymlinks Follow symlinks when traversing directories.                              [bool]
+      --exclude        A list with the names of the files and folders to exclude.               [array]`);
+    process.exitCode = 1;
+}
+else {
+    const archive = new index_1.default(directoryPath, zipPath, includeBaseDirectory, excludes, followSymlinks);
+    archive.createZip().catch((err) => {
+        const normalizedError = err instanceof Error ? err : new Error(String(err));
+        console.error(normalizedError);
+        process.exitCode = 1;
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+declare class DirArchiver {
+    private excludedPaths;
+    private excludedNames;
+    private caseInsensitiveExcludes;
+    private directoryPath;
+    private zipPath;
+    private includeBaseDirectory;
+    private followSymlinks;
+    private baseDirectory;
+    private visitedDirectories;
+    /**
+     * The constructor.
+     * @param directoryPath - the path of the folder to archive.
+     * @param zipPath - The path of the zip file to create.
+     * @param includeBaseDirectory - Includes a base directory at the root of the archive. For example, if the root folder of your project is named "your-project", setting includeBaseDirectory to true will create an archive that includes this base directory. If this option is set to false the archive created will unzip its content to the current directory.
+     * @param excludes - The name of the files and foldes to exclude.
+     */
+    constructor(directoryPath: string, zipPath: string, includeBaseDirectory?: boolean, excludes?: string[], followSymlinks?: boolean);
+    /**
+     * Recursively traverse the directory tree and append the files to the archive.
+     * @param directoryPath - The path of the directory being looped through.
+     */
+    private traverseDirectoryTree;
+    private prettyBytes;
+    private normalizeExcludeValue;
+    createZip(): Promise<string>;
+}
+export = DirArchiver;

package/dist/index.js

@@ -0,0 +1,320 @@
+'use strict';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const archiver_1 = __importDefault(require("archiver"));
+class DirArchiver {
+    /**
+     * The constructor.
+     * @param directoryPath - the path of the folder to archive.
+     * @param zipPath - The path of the zip file to create.
+     * @param includeBaseDirectory - Includes a base directory at the root of the archive. For example, if the root folder of your project is named "your-project", setting includeBaseDirectory to true will create an archive that includes this base directory. If this option is set to false the archive created will unzip its content to the current directory.
+     * @param excludes - The name of the files and foldes to exclude.
+     */
+    constructor(directoryPath, zipPath, includeBaseDirectory = false, excludes = [], followSymlinks = false) {
+        this.directoryPath = path.resolve(directoryPath);
+        this.zipPath = path.resolve(zipPath);
+        this.includeBaseDirectory = includeBaseDirectory;
+        this.followSymlinks = followSymlinks;
+        this.baseDirectory = path.basename(this.directoryPath);
+        this.visitedDirectories = new Set();
+        this.caseInsensitiveExcludes = process.platform === 'win32';
+        // Contains the excluded files and folders.
+        this.excludedPaths = new Set();
+        this.excludedNames = new Set();
+        for (const excludeRaw of excludes) {
+            if (typeof excludeRaw !== 'string') {
+                continue;
+            }
+            const trimmedRaw = excludeRaw.trim();
+            if (trimmedRaw.length === 0) {
+                continue;
+            }
+            let normalizedExclude = path.normalize(trimmedRaw.replace(/\\/g, path.sep));
+            if (normalizedExclude === '.' || normalizedExclude === path.sep) {
+                continue;
+            }
+            if (path.isAbsolute(normalizedExclude)) {
+                const relativeCandidate = path.relative(this.directoryPath, normalizedExclude);
+                const isInsideSource = relativeCandidate.length > 0
+                    && !relativeCandidate.startsWith('..')
+                    && !path.isAbsolute(relativeCandidate);
+                if (isInsideSource) {
+                    normalizedExclude = path.normalize(relativeCandidate);
+                }
+            }
+            if (normalizedExclude.length === 0) {
+                continue;
+            }
+            const hasSeparator = normalizedExclude.includes('/')
+                || normalizedExclude.includes('\\')
+                || normalizedExclude.includes(path.sep);
+            const trimmedExclude = normalizedExclude.replace(/[\\/]+$/g, '');
+            if (trimmedExclude.length === 0 || trimmedExclude === '.') {
+                continue;
+            }
+            const normalizedValue = this.normalizeExcludeValue(trimmedExclude);
+            this.excludedPaths.add(normalizedValue);
+            if (!hasSeparator) {
+                this.excludedNames.add(normalizedValue);
+            }
+        }
+        const relativeZipPath = path.relative(this.directoryPath, this.zipPath);
+        const isZipInsideSource = relativeZipPath.length > 0
+            && !relativeZipPath.startsWith('..')
+            && !path.isAbsolute(relativeZipPath);
+        if (isZipInsideSource) {
+            const normalizedZipPath = path.normalize(relativeZipPath);
+            this.excludedPaths.add(this.normalizeExcludeValue(normalizedZipPath));
+        }
+    }
+    /**
+     * Recursively traverse the directory tree and append the files to the archive.
+     * @param directoryPath - The path of the directory being looped through.
+     */
+    traverseDirectoryTree(directoryPath, archive) {
+        const directoriesToVisit = [directoryPath];
+        while (directoriesToVisit.length > 0) {
+            const nextDirectory = directoriesToVisit.pop();
+            if (!nextDirectory) {
+                continue;
+            }
+            if (this.followSymlinks) {
+                try {
+                    const realPath = fs.realpathSync(nextDirectory);
+                    if (this.visitedDirectories.has(realPath)) {
+                        continue;
+                    }
+                    this.visitedDirectories.add(realPath);
+                }
+                catch {
+                    continue;
+                }
+            }
+            const resolvedDirectoryPath = path.resolve(nextDirectory);
+            const entries = fs.readdirSync(resolvedDirectoryPath, { withFileTypes: true });
+            entries.sort((firstEntry, secondEntry) => {
+                if (firstEntry.name < secondEntry.name) {
+                    return -1;
+                }
+                if (firstEntry.name > secondEntry.name) {
+                    return 1;
+                }
+                return 0;
+            });
+            for (const entry of entries) {
+                const currentPath = path.join(resolvedDirectoryPath, entry.name);
+                if (currentPath === this.zipPath) {
+                    continue;
+                }
+                const relativePath = path.relative(this.directoryPath, currentPath);
+                const normalizedRelativePath = path.normalize(relativePath);
+                const archiveRelativePath = normalizedRelativePath.replace(/\\/g, '/');
+                const baseName = path.basename(normalizedRelativePath);
+                const normalizedPathValue = this.normalizeExcludeValue(normalizedRelativePath);
+                const normalizedNameValue = this.normalizeExcludeValue(baseName);
+                if (this.excludedPaths.has(normalizedPathValue) || this.excludedNames.has(normalizedNameValue)) {
+                    continue;
+                }
+                if (entry.isFile()) {
+                    if (this.includeBaseDirectory) {
+                        archive.file(currentPath, {
+                            name: path.posix.join(this.baseDirectory, archiveRelativePath)
+                        });
+                    }
+                    else {
+                        archive.file(currentPath, {
+                            name: archiveRelativePath
+                        });
+                    }
+                }
+                else if (entry.isDirectory()) {
+                    directoriesToVisit.push(currentPath);
+                }
+                else if (entry.isSymbolicLink()) {
+                    if (!this.followSymlinks) {
+                        continue;
+                    }
+                    let stats;
+                    try {
+                        stats = fs.statSync(currentPath);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (stats.isFile()) {
+                        if (this.includeBaseDirectory) {
+                            archive.file(currentPath, {
+                                name: path.posix.join(this.baseDirectory, archiveRelativePath)
+                            });
+                        }
+                        else {
+                            archive.file(currentPath, {
+                                name: archiveRelativePath
+                            });
+                        }
+                    }
+                    else if (stats.isDirectory()) {
+                        directoriesToVisit.push(currentPath);
+                    }
+                }
+            }
+        }
+    }
+    prettyBytes(bytes) {
+        if (bytes > 1000 && bytes < 1000000) {
+            const kiloBytes = Math.round(((bytes / 1000) + Number.EPSILON) * 100) / 100;
+            return `${kiloBytes} KB`;
+        }
+        if (bytes > 1000000 && bytes < 1000000000) {
+            const megaBytes = Math.round(((bytes / 1000000) + Number.EPSILON) * 100) / 100;
+            return `${megaBytes} MB`;
+        }
+        if (bytes > 1000000000) {
+            const gigaBytes = Math.round(((bytes / 1000000000) + Number.EPSILON) * 100) / 100;
+            return `${gigaBytes} GB`;
+        }
+        return `${bytes} bytes`;
+    }
+    normalizeExcludeValue(value) {
+        return this.caseInsensitiveExcludes ? value.toLowerCase() : value;
+    }
+    createZip() {
+        return new Promise((resolve, reject) => {
+            let output = null;
+            let archive = null;
+            let settled = false;
+            const safeResolve = (value) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                resolve(value);
+            };
+            const safeReject = (err) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                try {
+                    if (archive) {
+                        archive.abort();
+                    }
+                }
+                catch {
+                    // Ignore abort errors.
+                }
+                try {
+                    if (output) {
+                        output.destroy();
+                    }
+                }
+                catch {
+                    // Ignore destroy errors.
+                }
+                try {
+                    if (fs.existsSync(this.zipPath)) {
+                        fs.unlinkSync(this.zipPath);
+                    }
+                }
+                catch {
+                    // Ignore cleanup errors.
+                }
+                const normalizedError = err instanceof Error ? err : new Error(String(err));
+                reject(normalizedError);
+            };
+            // Remove the destination zip if it exists.
+            // see : https://github.com/Ismail-elkorchi/dir-archiver/issues/5
+            try {
+                if (fs.existsSync(this.zipPath)) {
+                    fs.unlinkSync(this.zipPath);
+                }
+            }
+            catch (err) {
+                safeReject(err);
+                return;
+            }
+            // Create a file to stream archive data to.
+            output = fs.createWriteStream(this.zipPath);
+            archive = (0, archiver_1.default)('zip', {
+                zlib: { level: 9 }
+            });
+            // Catch warnings during archiving.
+            archive.on('warning', (err) => {
+                if (err.code === 'ENOENT') {
+                    // log warning
+                    console.log(err);
+                }
+                else {
+                    safeReject(err);
+                }
+            });
+            // Catch errors during archiving.
+            archive.on('error', (err) => {
+                safeReject(err);
+            });
+            output.on('error', (err) => {
+                safeReject(err);
+            });
+            // Listen for all archive data to be written.
+            output.on('close', () => {
+                if (settled) {
+                    return;
+                }
+                console.log(`Created ${this.zipPath} of ${this.prettyBytes(archive.pointer())}`);
+                safeResolve(this.zipPath);
+            });
+            // Pipe archive data to the file.
+            archive.pipe(output);
+            // Recursively traverse the directory tree and append the files to the archive.
+            this.visitedDirectories.clear();
+            try {
+                this.traverseDirectoryTree(this.directoryPath, archive);
+            }
+            catch (err) {
+                safeReject(err);
+                return;
+            }
+            // Finalize the archive.
+            void Promise.resolve(archive.finalize()).catch((err) => {
+                safeReject(err);
+            });
+        });
+    }
+}
+module.exports = DirArchiver;

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "dir-archiver",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "description": "Compress a whole directory (including subdirectories) into a zip file, with options to exclude specific files, or directories.",
   "license": "MIT",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "bin": {
-    "dir-archiver": "cli.js"
+    "dir-archiver": "dist/cli.js"
   },
   "files": [
     "LICENSE",
-    "index.js",
-    "cli.js"
+    "dist"
   ],
   "keywords": [
     "zip",
@@ -23,7 +23,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/Ismail-elkorchi/dir-archiver.git"
+    "url": "git+https://github.com/Ismail-elkorchi/dir-archiver.git"
   },
   "author": {
     "name": "Ismail El Korchi",
@@ -33,20 +33,28 @@
   "bugs": "https://github.com/Ismail-elkorchi/dir-archiver/issues",
   "homepage": "https://github.com/Ismail-elkorchi/dir-archiver",
   "scripts": {
-    "lint": "eslint cli.js index.js",
-    "lint:fix": "eslint --fix cli.js index.js",
-    "test": "node test/smoke.js"
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "npm run typecheck && eslint . --max-warnings=0",
+    "test": "npm run build && node test/smoke.js && node test/cli.js",
+    "prepack": "npm run build"
   },
   "engines": {
-    "node": ">=14"
+    "node": ">=18"
   },
   "dependencies": {
     "archiver": "^7.0.1",
-    "argv-flags": "^0.1.1"
+    "argv-flags": "^0.2.1"
   },
   "devDependencies": {
-    "eslint": "^8.24.0",
-    "eslint-plugin-n": "^15.3.0",
+    "@eslint/js": "^9.39.2",
+    "@types/archiver": "^7.0.0",
+    "@types/node": "^20.11.0",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
+    "eslint": "^9.39.2",
+    "globals": "^17.2.0",
+    "typescript": "^5.3.3",
     "yauzl": "^3.2.0"
   }
 }

package/cli.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-
-const DirArchiver = require( './index' );
-const parseArgs = require( 'argv-flags' );
-
-const directoryPath = parseArgs( '--src', 'string' );
-const zipPath = parseArgs( '--dest', 'string' );
-const includeBaseDirectory = parseArgs( '--includebasedir', 'boolean' );
-const excludes = parseArgs( '--exclude', 'array' ) || [];
-
-if ( directoryPath === false || zipPath === false ) {
-	console.log( ` Dir Archiver could not be executed. Some arguments are missing.
-
-    Options:
-      --src            The path of the folder to archive.                            [string][required]
-      --dest           The path of the zip file to create.                           [string][required]
-      --includebasedir Includes a base directory at the root of the archive.
-                       For example, if the root folder of your project is named
-                       "your-project", setting this option to true will create
-                       an archive that includes this base directory.
-                       If this option is set to false the archive created will
-                       unzip its content to the current directory.                               [bool]
-      --exclude        A list with the names of the files and folders to exclude.               [array]` );
-	process.exit(); // eslint-disable-line n/no-process-exit
-}
-
-const archive = new DirArchiver( directoryPath, zipPath, includeBaseDirectory, excludes );
-archive.createZip().catch( ( err ) => {
-	console.error( err );
-	process.exitCode = 1;
-} );

package/index.js

@@ -1,154 +0,0 @@
-'use strict';
-
-const path = require( 'path' );
-const fs = require( 'fs' );
-const archiver = require( 'archiver' );
-
-class DirArchiver {
-	/**
-	 * The constructor.
-	 * @param {string} directoryPath - the path of the folder to archive.
-	 * @param {string} zipPath - The path of the zip file to create.
-	 * @param {Boolean} includeBaseDirectory - Includes a base directory at the root of the archive. For example, if the root folder of your project is named "your-project", setting includeBaseDirectory to true will create an archive that includes this base directory. If this option is set to false the archive created will unzip its content to the current directory.
-	 * @param {array} excludes - The name of the files and foldes to exclude.
-	 */
-	constructor( directoryPath, zipPath, includeBaseDirectory, excludes ) {
-
-		// Contains the excluded files and folders.
-		const safeExcludes = Array.isArray( excludes ) ? excludes : [];
-		this.excludes = safeExcludes.map( ( element ) => {
-			return path.normalize( element );
-		} );
-
-		this.directoryPath = path.resolve( directoryPath );
-
-		this.zipPath = path.resolve( zipPath );
-
-		this.includeBaseDirectory = includeBaseDirectory;
-
-		this.baseDirectory = path.basename( this.directoryPath );
-
-		const relativeZipPath = path.relative( this.directoryPath, this.zipPath );
-		const isZipInsideSource = relativeZipPath && ! relativeZipPath.startsWith( '..' ) && ! path.isAbsolute( relativeZipPath );
-		if ( isZipInsideSource ) {
-			const normalizedZipPath = path.normalize( relativeZipPath );
-			if ( ! this.excludes.includes( normalizedZipPath ) ) {
-				this.excludes.push( normalizedZipPath );
-			}
-		}
-	}
-
-	/**
-	 * Recursively traverse the directory tree and append the files to the archive.
-	 * @param {string} directoryPath - The path of the directory being looped through.
-	 */
-	traverseDirectoryTree( directoryPath ) {
-		const files = fs.readdirSync( directoryPath );
-		for ( const file of files ) {
-			const currentPath = path.join( path.resolve( directoryPath ), file );
-			if ( path.resolve( currentPath ) === this.zipPath ) {
-				continue;
-			}
-			const stats = fs.statSync( currentPath );
-			let relativePath = path.relative( this.directoryPath, currentPath );
-			if ( stats.isFile() && ! this.excludes.includes( relativePath ) ) {
-				if ( this.includeBaseDirectory === true ) {
-					this.archive.file( currentPath, {
-						name: path.join( this.baseDirectory, relativePath )
-					} );
-				} else {
-					this.archive.file( currentPath, {
-						name: relativePath
-					} );
-				}
-			} else if ( stats.isDirectory() && ! this.excludes.includes( relativePath ) ) {
-				this.traverseDirectoryTree( currentPath );
-			}
-		}
-	}
-
-	prettyBytes( bytes ) {
-		if ( bytes > 1000 && bytes < 1000000 ) {
-			return Math.round( ( ( bytes / 1000 ) + Number.EPSILON ) * 100 ) / 100 + ' KB';
-		}
-		if ( bytes > 1000000 && bytes < 1000000000 ) {
-			return Math.round( ( ( bytes / 1000000 ) + Number.EPSILON ) * 100 ) / 100 + ' MB';
-		}
-		if ( bytes > 1000000000 ) {
-			return Math.round( ( ( bytes / 1000000000 ) + Number.EPSILON ) * 100 ) / 100 + ' GB';
-		}
-		return bytes + ' bytes';
-	}
-
-	createZip () {
-		return new Promise( ( resolve, reject ) => {
-			let settled = false;
-			const safeResolve = ( value ) => {
-				if ( settled ) {
-					return;
-				}
-				settled = true;
-				resolve( value );
-			};
-			const safeReject = ( err ) => {
-				if ( settled ) {
-					return;
-				}
-				settled = true;
-				reject( err );
-			};
-
-			// Remove the destination zip if it exists.
-			// see : https://github.com/Ismail-elkorchi/dir-archiver/issues/5
-			try {
-				if ( fs.existsSync( this.zipPath ) ) {
-					fs.unlinkSync( this.zipPath );
-				}
-			} catch ( err ) {
-				safeReject( err );
-				return;
-			}
-
-			// Create a file to stream archive data to.
-			this.output = fs.createWriteStream( this.zipPath );
-			this.archive = archiver( 'zip', {
-				zlib: { level: 9 }
-			} );
-
-			// Catch warnings during archiving.
-			this.archive.on( 'warning', ( err ) => {
-				if ( err.code === 'ENOENT' ) {
-					// log warning
-					console.log( err );
-				} else {
-					safeReject( err );
-				}
-			} );
-
-			// Catch errors during archiving.
-			this.archive.on( 'error', ( err ) => {
-				safeReject( err );
-			} );
-
-			this.output.on( 'error', ( err ) => {
-				safeReject( err );
-			} );
-
-			// Listen for all archive data to be written.
-			this.output.on( 'close', () => {
-				console.log( `Created ${this.zipPath} of ${this.prettyBytes( this.archive.pointer() )}` );
-				safeResolve( this.zipPath );
-			} );
-
-			// Pipe archive data to the file.
-			this.archive.pipe( this.output );
-
-			// Recursively traverse the directory tree and append the files to the archive.
-			this.traverseDirectoryTree( this.directoryPath );
-
-			// Finalize the archive.
-			this.archive.finalize();
-		} );
-	}
-}
-module.exports = DirArchiver;