pwd-fs 3.4.0 → 3.5.0

package/dist/powered-file-system/stat.d.ts

@@ -1,7 +1,7 @@
-import type { PoweredFileSystem, Stats } from '../powered-file-system';
+import type { AsyncOption, MaybeSyncOption, PoweredFileSystem, Stats, SyncOption } from '../powered-file-system';
 /**
  * Returns `lstat` data so symlinks are reported as links instead of followed targets.
  */
-export declare function stat<T extends boolean = false>(this: PoweredFileSystem, src: string, options?: {
-    sync?: T;
-}): T extends true ? Stats : Promise<Stats>;
+export declare function stat(this: PoweredFileSystem, src: string, options: SyncOption): Stats;
+export declare function stat(this: PoweredFileSystem, src: string, options?: AsyncOption): Promise<Stats>;
+export declare function stat(this: PoweredFileSystem, src: string, options?: MaybeSyncOption): Stats | Promise<Stats>;

package/dist/powered-file-system/stat.js

@@ -5,17 +5,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stat = stat;
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-/**
- * Returns `lstat` data so symlinks are reported as links instead of followed targets.
- */
 function stat(src, options) {
     const { sync = false } = options ?? {};
-    src = node_path_1.default.resolve(this.pwd, src);
     if (sync) {
-        return node_fs_1.default.lstatSync(src);
+        return node_fs_1.default.lstatSync(this.resolve(src));
     }
     return new Promise((resolve, reject) => {
+        try {
+            src = this.resolve(src);
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
         node_fs_1.default.lstat(src, (err, stats) => {
             if (err) {
                 return reject(err);

package/dist/powered-file-system/symlink.d.ts

@@ -1,4 +1,4 @@
-import type { PoweredFileSystem } from '../powered-file-system';
-export declare function symlink<T extends boolean = false>(this: PoweredFileSystem, src: string, dest: string, options?: {
-    sync?: T;
-}): T extends true ? void : Promise<void>;
+import type { AsyncOption, MaybeSyncOption, PoweredFileSystem, SyncOption } from '../powered-file-system';
+export declare function symlink(this: PoweredFileSystem, src: string, dest: string, options: SyncOption): void;
+export declare function symlink(this: PoweredFileSystem, src: string, dest: string, options?: AsyncOption): Promise<void>;
+export declare function symlink(this: PoweredFileSystem, src: string, dest: string, options?: MaybeSyncOption): void | Promise<void>;

package/dist/powered-file-system/symlink.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.symlink = symlink;
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
 /**
  * Windows requires an explicit link type. Non-Windows platforms infer it.
  */
@@ -17,15 +16,23 @@ function resolveSymlinkType(src) {
     return stats.isDirectory() ? 'junction' : 'file';
 }
 function symlink(src, dest, options) {
-    src = node_path_1.default.resolve(this.pwd, src);
-    dest = node_path_1.default.resolve(this.pwd, dest);
     const { sync = false } = options ?? {};
     if (sync) {
+        src = this.resolve(src);
+        dest = this.resolve(dest);
         const type = resolveSymlinkType(src);
         node_fs_1.default.symlinkSync(src, dest, type);
-        return undefined;
+        return;
     }
     return new Promise((resolve, reject) => {
+        try {
+            src = this.resolve(src);
+            dest = this.resolve(dest);
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
         if (process.platform === 'win32') {
             node_fs_1.default.lstat(src, (err, stats) => {
                 if (err) {

package/dist/powered-file-system/test.d.ts

@@ -1,8 +1,13 @@
-import type { Mode, PoweredFileSystem } from '../powered-file-system';
+import type { AsyncOption, MaybeSyncOption, Mode, PoweredFileSystem, SyncOption } from '../powered-file-system';
 /**
- * Thin wrapper around `fs.access` that resolves paths against the instance root.
+ * Thin wrapper around `fs.access` that resolves paths against the instance base path.
  */
-export declare function test<T extends boolean = false>(this: PoweredFileSystem, src: string, options?: {
-    sync?: T;
+export declare function test(this: PoweredFileSystem, src: string, options: SyncOption & {
     flag?: Mode;
-}): T extends true ? boolean : Promise<boolean>;
+}): boolean;
+export declare function test(this: PoweredFileSystem, src: string, options?: AsyncOption & {
+    flag?: Mode;
+}): Promise<boolean>;
+export declare function test(this: PoweredFileSystem, src: string, options?: MaybeSyncOption & {
+    flag?: Mode;
+}): boolean | Promise<boolean>;

package/dist/powered-file-system/test.js

@@ -5,16 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.test = test;
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-/**
- * Thin wrapper around `fs.access` that resolves paths against the instance root.
- */
 function test(src, options) {
     const { sync = false, flag = 'e' } = options ?? {};
     const mode = this.constants[flag];
-    src = node_path_1.default.resolve(this.pwd, src);
     if (sync) {
         try {
+            src = this.resolve(src);
             node_fs_1.default.accessSync(src, mode);
             return true;
         }
@@ -23,6 +19,13 @@ function test(src, options) {
         }
     }
     return new Promise((resolve) => {
+        try {
+            src = this.resolve(src);
+        }
+        catch {
+            resolve(false);
+            return;
+        }
         node_fs_1.default.access(src, mode, (err) => {
             resolve(!err);
         });

package/dist/powered-file-system/write.d.ts

@@ -1,10 +1,13 @@
-import type { Flag, PoweredFileSystem } from '../powered-file-system';
-/**
- * Writes a file relative to `pwd` and then reapplies the computed permissions explicitly.
- */
-export declare function write<T extends boolean = false>(this: PoweredFileSystem, src: string, data: Buffer | string, options?: {
-    sync?: T;
+import type { AsyncOption, Flag, MaybeSyncOption, PoweredFileSystem, SyncOption } from '../powered-file-system';
+type WriteOptions = {
     encoding?: BufferEncoding | null;
     umask?: number;
     flag?: Flag;
-}): T extends true ? void : Promise<void>;
+};
+/**
+ * Writes a file relative to `pwd` and then reapplies the computed permissions explicitly.
+ */
+export declare function write(this: PoweredFileSystem, src: string, data: Buffer | string, options: SyncOption & WriteOptions): void;
+export declare function write(this: PoweredFileSystem, src: string, data: Buffer | string, options?: AsyncOption & WriteOptions): Promise<void>;
+export declare function write(this: PoweredFileSystem, src: string, data: Buffer | string, options?: MaybeSyncOption & WriteOptions): void | Promise<void>;
+export {};

package/dist/powered-file-system/write.js

@@ -5,21 +5,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.write = write;
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-/**
- * Writes a file relative to `pwd` and then reapplies the computed permissions explicitly.
- */
 function write(src, data, options) {
     const { sync = false, encoding = 'utf8', umask = 0o000, flag = 'w', } = options ?? {};
-    src = node_path_1.default.resolve(this.pwd, src);
     const mode = 0o666 & ~umask;
     if (sync) {
+        src = this.resolve(src);
         // Apply chmod explicitly so the final mode is deterministic across runtimes.
         node_fs_1.default.writeFileSync(src, data, { encoding, mode, flag });
         node_fs_1.default.chmodSync(src, mode);
-        return undefined;
+        return;
     }
     return new Promise((resolve, reject) => {
+        try {
+            src = this.resolve(src);
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
         node_fs_1.default.writeFile(src, data, { encoding, mode, flag }, (err) => {
             if (err) {
                 return reject(err);

package/dist/powered-file-system.d.ts

@@ -7,6 +7,27 @@ export type Mode = keyof IConstants;
 export type Flag = Extract<fs.OpenMode, string>;
 export type Stats = fs.Stats;
 export type CopyFilter = (src: string, dest: string) => boolean;
+export type SyncResult<T extends boolean, TResult> = T extends true ? TResult : Promise<TResult>;
+export type SyncOption = {
+    sync: true;
+};
+export type AsyncOption = {
+    sync?: false;
+};
+export type MaybeSyncOption = {
+    sync?: boolean;
+};
+export type ReadResult<TEncoding> = TEncoding extends null ? Buffer : string;
+export type ReaddirResult<TEncoding> = TEncoding extends null ? Buffer[] : string[];
+export type ReadOptions<TSync extends boolean = boolean, TEncoding extends BufferEncoding | null = BufferEncoding> = {
+    sync?: TSync;
+    encoding?: TEncoding;
+    flag?: Flag;
+};
+export type ReaddirOptions<TSync extends boolean = boolean, TEncoding extends BufferEncoding | null = BufferEncoding> = {
+    sync?: TSync;
+    encoding?: TEncoding;
+};
 export * from './bitmask';
 export interface IConstants {
     e: number;
@@ -17,8 +38,7 @@ export interface IConstants {
 /**
  * Path-aware wrapper around Node's file system APIs.
  *
- * All relative paths are resolved against `pwd`, which makes the instance
- * suitable for sandboxed or virtual working-directory workflows.
+ * Relative paths are resolved against `pwd`; absolute paths are preserved.
  */
 export declare class PoweredFileSystem {
     readonly pwd: string;
@@ -34,117 +54,144 @@ export declare class PoweredFileSystem {
      * @param pwd Base directory used to resolve all relative paths.
      */
     constructor(pwd?: string);
+    /**
+     * Resolves relative paths against `pwd` while preserving absolute paths.
+     */
+    resolve(src: string): string;
     /**
      * Checks whether the given path is accessible with the requested mode.
      */
-    test<T extends boolean = false>(src: string, options?: {
-        sync?: T;
+    test(src: string, options: SyncOption & {
+        flag?: Mode;
+    }): boolean;
+    test(src: string, options?: AsyncOption & {
         flag?: Mode;
-    }): T extends true ? boolean : Promise<boolean>;
+    }): Promise<boolean>;
     /**
      * Returns `lstat` information for a path.
      */
-    stat<T extends boolean = false>(src: string, options?: {
-        sync?: T;
-    }): T extends true ? Stats : Promise<Stats>;
+    stat(src: string, options: SyncOption): Stats;
+    stat(src: string, options?: AsyncOption): Promise<Stats>;
     /**
      * Applies a mode recursively to a file or directory tree.
      */
-    chmod<T extends boolean = false>(src: string, mode: number, options?: {
-        sync?: T;
-    }): T extends true ? void : Promise<void>;
+    chmod(src: string, mode: number, options: SyncOption): void;
+    chmod(src: string, mode: number, options?: AsyncOption): Promise<void>;
     /**
      * Applies ownership recursively to a file or directory tree.
      */
-    chown<T extends boolean = false>(src: string, options?: {
-        sync?: T;
+    chown(src: string, options: SyncOption & {
+        uid?: number;
+        gid?: number;
+    }): void;
+    chown(src: string, options?: AsyncOption & {
         uid?: number;
         gid?: number;
-    }): T extends true ? void : Promise<void>;
+    }): Promise<void>;
     /**
      * Creates a symbolic link from `dest` to `src`.
      */
-    symlink<T extends boolean = false>(src: string, dest: string, options?: {
-        sync?: T;
-    }): T extends true ? void : Promise<void>;
+    symlink(src: string, dest: string, options: SyncOption): void;
+    symlink(src: string, dest: string, options?: AsyncOption): Promise<void>;
     /**
      * Copies `src` into the destination directory.
      */
-    copy<T extends boolean = false>(src: string, dest: string, options?: {
-        sync?: T;
+    copy(src: string, dest: string, options: SyncOption & {
         umask?: number;
         overwrite?: boolean;
         filter?: CopyFilter;
-    }): T extends true ? void : Promise<void>;
+    }): void;
+    copy(src: string, dest: string, options?: AsyncOption & {
+        umask?: number;
+        overwrite?: boolean;
+        filter?: CopyFilter;
+    }): Promise<void>;
     /**
      * Renames or moves a file system node.
      */
-    rename<T extends boolean = false>(src: string, dest: string, options?: {
-        sync?: T;
-    }): T extends true ? void : Promise<void>;
+    rename(src: string, dest: string, options: SyncOption): void;
+    rename(src: string, dest: string, options?: AsyncOption): Promise<void>;
     /**
      * Removes a file system node recursively.
      */
-    remove<T extends boolean = false>(src: string, options?: {
-        sync?: T;
-    }): T extends true ? void : Promise<void>;
+    remove(src: string, options: SyncOption): void;
+    remove(src: string, options?: AsyncOption): Promise<void>;
     /**
      * Removes all directory entries while preserving the directory itself.
      */
-    emptyDir<T extends boolean = false>(src: string, options?: {
-        sync?: T;
-    }): T extends true ? void : Promise<void>;
+    emptyDir(src: string, options: SyncOption): void;
+    emptyDir(src: string, options?: AsyncOption): Promise<void>;
     /**
-     * Reads a file relative to the current instance root.
+     * Reads a file relative to the current instance path.
      */
-    read<T extends boolean = false>(src: string, options?: {
-        sync?: T;
-        encoding?: BufferEncoding | null;
-        flag?: Flag;
-    }): T extends true ? string | Buffer : Promise<string | Buffer>;
+    read(src: string, options: SyncOption & ReadOptions<true, null> & {
+        encoding: null;
+    }): Buffer;
+    read(src: string, options: SyncOption & ReadOptions<true, BufferEncoding>): string;
+    read(src: string, options: AsyncOption & ReadOptions<false, null> & {
+        encoding: null;
+    }): Promise<Buffer>;
+    read(src: string, options?: AsyncOption & ReadOptions<false, BufferEncoding>): Promise<string>;
     /**
      * Writes a file and applies the resulting permissions explicitly.
      */
-    write<T extends boolean = false>(src: string, data: Buffer | string, options?: {
-        sync?: T;
+    write(src: string, data: Buffer | string, options: SyncOption & {
         encoding?: BufferEncoding | null;
         umask?: number;
         flag?: Flag;
-    }): T extends true ? void : Promise<void>;
+    }): void;
+    write(src: string, data: Buffer | string, options?: AsyncOption & {
+        encoding?: BufferEncoding | null;
+        umask?: number;
+        flag?: Flag;
+    }): Promise<void>;
     /**
      * @deprecated Use `write(..., { flag: 'a' })` instead.
      */
-    append<T extends boolean = false>(src: string, data: Buffer | string, options?: {
-        sync?: T;
+    append(src: string, data: Buffer | string, options: SyncOption & {
+        encoding?: BufferEncoding | null;
+        umask?: number;
+    }): void;
+    append(src: string, data: Buffer | string, options?: AsyncOption & {
         encoding?: BufferEncoding | null;
         umask?: number;
-    }): T extends true ? void : Promise<void>;
+    }): Promise<void>;
     /**
-     * Lists directory entries relative to the current instance root.
+     * Lists directory entries relative to the current instance path.
      */
-    readdir<T extends boolean = false>(dir: string, options?: {
-        sync?: T;
-        encoding?: BufferEncoding | null;
-    }): T extends true ? string[] : Promise<string[]>;
+    readdir(dir: string, options: SyncOption & ReaddirOptions<true, null> & {
+        encoding: null;
+    }): Buffer[];
+    readdir(dir: string, options: SyncOption & ReaddirOptions<true, BufferEncoding>): string[];
+    readdir(dir: string, options: AsyncOption & ReaddirOptions<false, null> & {
+        encoding: null;
+    }): Promise<Buffer[]>;
+    readdir(dir: string, options?: AsyncOption & ReaddirOptions<false, BufferEncoding>): Promise<string[]>;
     /**
      * Resolves the target of a symbolic link.
      */
-    readlink<T extends boolean = false>(src: string, options?: {
-        sync?: T;
+    readlink(src: string, options: SyncOption & {
+        encoding?: BufferEncoding;
+    }): string;
+    readlink(src: string, options?: AsyncOption & {
         encoding?: BufferEncoding;
-    }): T extends true ? string : Promise<string>;
+    }): Promise<string>;
     /**
      * Resolves a path to its canonical absolute location.
      */
-    realpath<T extends boolean = false>(src: string, options?: {
-        sync?: T;
+    realpath(src: string, options: SyncOption & {
         encoding?: BufferEncoding;
-    }): T extends true ? string : Promise<string>;
+    }): string;
+    realpath(src: string, options?: AsyncOption & {
+        encoding?: BufferEncoding;
+    }): Promise<string>;
     /**
-     * Creates a directory tree relative to the current instance root.
+     * Creates a directory tree relative to the current instance path.
      */
-    mkdir<T extends boolean = false>(dir: string, options?: {
-        sync?: T;
+    mkdir(dir: string, options: SyncOption & {
+        umask?: number;
+    }): void;
+    mkdir(dir: string, options?: AsyncOption & {
         umask?: number;
-    }): T extends true ? void : Promise<void>;
+    }): Promise<void>;
 }

package/dist/powered-file-system.js

@@ -41,8 +41,7 @@ __exportStar(require("./bitmask"), exports);
 /**
  * Path-aware wrapper around Node's file system APIs.
  *
- * All relative paths are resolved against `pwd`, which makes the instance
- * suitable for sandboxed or virtual working-directory workflows.
+ * Relative paths are resolved against `pwd`; absolute paths are preserved.
  */
 class PoweredFileSystem {
     pwd;
@@ -66,98 +65,56 @@ class PoweredFileSystem {
         this.pwd = pwd ? node_path_1.default.resolve(pwd) : process.cwd();
     }
     /**
-     * Checks whether the given path is accessible with the requested mode.
+     * Resolves relative paths against `pwd` while preserving absolute paths.
      */
+    resolve(src) {
+        return node_path_1.default.resolve(this.pwd, src);
+    }
     test(src, options) {
         return test_1.test.call(this, src, options);
     }
-    /**
-     * Returns `lstat` information for a path.
-     */
     stat(src, options) {
         return stat_1.stat.call(this, src, options);
     }
-    /**
-     * Applies a mode recursively to a file or directory tree.
-     */
     chmod(src, mode, options) {
         return chmod_1.chmod.call(this, src, mode, options);
     }
-    /**
-     * Applies ownership recursively to a file or directory tree.
-     */
     chown(src, options) {
         return chown_1.chown.call(this, src, options);
     }
-    /**
-     * Creates a symbolic link from `dest` to `src`.
-     */
     symlink(src, dest, options) {
         return symlink_1.symlink.call(this, src, dest, options);
     }
-    /**
-     * Copies `src` into the destination directory.
-     */
     copy(src, dest, options) {
         return copy_1.copy.call(this, src, dest, options);
     }
-    /**
-     * Renames or moves a file system node.
-     */
     rename(src, dest, options) {
         return rename_1.rename.call(this, src, dest, options);
     }
-    /**
-     * Removes a file system node recursively.
-     */
     remove(src, options) {
         return remove_1.remove.call(this, src, options);
     }
-    /**
-     * Removes all directory entries while preserving the directory itself.
-     */
     emptyDir(src, options) {
         return empty_dir_1.emptyDir.call(this, src, options);
     }
-    /**
-     * Reads a file relative to the current instance root.
-     */
     read(src, options) {
         return read_1.read.call(this, src, options);
     }
-    /**
-     * Writes a file and applies the resulting permissions explicitly.
-     */
     write(src, data, options) {
         return write_1.write.call(this, src, data, options);
     }
-    /**
-     * @deprecated Use `write(..., { flag: 'a' })` instead.
-     */
     append(src, data, options) {
         return append_1.append.call(this, src, data, options);
     }
-    /**
-     * Lists directory entries relative to the current instance root.
-     */
     readdir(dir, options) {
         return readdir_1.readdir.call(this, dir, options);
     }
-    /**
-     * Resolves the target of a symbolic link.
-     */
     readlink(src, options) {
         return readlink_1.readlink.call(this, src, options);
     }
-    /**
-     * Resolves a path to its canonical absolute location.
-     */
     realpath(src, options) {
         return realpath_1.realpath.call(this, src, options);
     }
-    /**
-     * Creates a directory tree relative to the current instance root.
-     */
     mkdir(dir, options) {
         return mkdir_1.mkdir.call(this, dir, options);
     }

package/dist/powered-file-system.test.js

@@ -4,8 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
+const node_path_1 = __importDefault(require("node:path"));
 const node_test_1 = require("node:test");
 const index_1 = require("./index");
+const test_utils_1 = require("./test-utils");
 /**
  * Verifies constructor path resolution semantics for the main API surface.
  */
@@ -18,4 +20,27 @@ const index_1 = require("./index");
         const { pwd } = new index_1.PoweredFileSystem(__dirname);
         (0, node_assert_1.default)(pwd === __dirname);
     });
+    (0, node_test_1.it)('Positive: Resolve should accept paths inside the working directory', () => {
+        const tmpDir = (0, test_utils_1.createTmpDir)();
+        try {
+            const pfs = new index_1.PoweredFileSystem(tmpDir);
+            const resolved = pfs.resolve('./nested/file.txt');
+            (0, node_assert_1.default)(resolved === node_path_1.default.join(tmpDir, 'nested', 'file.txt'));
+        }
+        finally {
+            (0, test_utils_1.restore)(tmpDir);
+        }
+    });
+    (0, node_test_1.it)('Positive: Resolve should preserve absolute paths outside the working directory', () => {
+        const tmpDir = (0, test_utils_1.createTmpDir)();
+        const outsidePath = node_path_1.default.resolve(node_path_1.default.dirname(tmpDir), 'outside.txt');
+        try {
+            const pfs = new index_1.PoweredFileSystem(tmpDir);
+            const resolved = pfs.resolve(outsidePath);
+            (0, node_assert_1.default)(resolved === outsidePath);
+        }
+        finally {
+            (0, test_utils_1.restore)(tmpDir);
+        }
+    });
 });

package/dist/recurse-io-sync.d.ts

@@ -6,7 +6,7 @@ export declare function chmodSync(src: string, mode: number): void;
 /**
  * Synchronous counterpart of the recursive chown implementation.
  */
-export declare function chownSync(src: string, uid: number, gid: number): void;
+export declare function chownSync(src: string, uid: number | undefined, gid: number | undefined): void;
 /**
  * Synchronously copies a file system node into the target directory.
  */

package/dist/recurse-io-sync.js

@@ -29,19 +29,16 @@ function chmodSync(src, mode) {
  */
 function chownSync(src, uid, gid) {
     const stats = node_fs_1.default.statSync(src);
-    if (uid === 0) {
-        uid = stats.uid;
-    }
-    if (gid === 0) {
-        gid = stats.gid;
-    }
+    // `0` is a valid uid/gid, so only nullish values mean "preserve current owner".
+    const nextUid = uid ?? stats.uid;
+    const nextGid = gid ?? stats.gid;
     if (stats.isDirectory()) {
         const list = node_fs_1.default.readdirSync(src);
         for (const loc of list) {
-            chownSync(node_path_1.default.join(src, loc), uid, gid);
+            chownSync(node_path_1.default.join(src, loc), nextUid, nextGid);
         }
     }
-    node_fs_1.default.chownSync(src, uid, gid);
+    node_fs_1.default.chownSync(src, nextUid, nextGid);
 }
 /**
  * Synchronously copies a file system node into the target directory.
@@ -59,6 +56,7 @@ function copySync(src, dir, options) {
     if (stat.isDirectory()) {
         const list = node_fs_1.default.readdirSync(src);
         const mode = 0o777 & ~options.umask;
+        // Overwrite is implemented as replace-before-copy to support directory targets.
         if (options.overwrite && node_fs_1.default.existsSync(dest)) {
             removeSync(dest);
         }
@@ -68,10 +66,12 @@ function copySync(src, dir, options) {
         }
     }
     else {
+        // Match directory behavior by replacing the existing target before writing.
         if (options.overwrite && node_fs_1.default.existsSync(dest)) {
             removeSync(dest);
         }
-        node_fs_1.default.copyFileSync(src, dest);
+        const flags = options.overwrite ? 0 : node_fs_1.default.constants.COPYFILE_EXCL;
+        node_fs_1.default.copyFileSync(src, dest, flags);
         node_fs_1.default.chmodSync(dest, 0o666 & ~options.umask);
     }
 }
@@ -79,21 +79,7 @@ function copySync(src, dir, options) {
  * Synchronously removes files, directories, and symlinks without following links.
  */
 function removeSync(src) {
-    const stats = node_fs_1.default.lstatSync(src);
-    if (stats.isSymbolicLink()) {
-        node_fs_1.default.unlinkSync(src);
-        return;
-    }
-    if (stats.isDirectory()) {
-        const list = node_fs_1.default.readdirSync(src);
-        for (const loc of list) {
-            removeSync(node_path_1.default.join(src, loc));
-        }
-        node_fs_1.default.rmdirSync(src);
-    }
-    else {
-        node_fs_1.default.unlinkSync(src);
-    }
+    node_fs_1.default.rmSync(src, { recursive: true, force: false });
 }
 /**
  * Synchronously removes all entries inside a directory while preserving it.
@@ -101,7 +87,7 @@ function removeSync(src) {
 function emptyDirSync(src) {
     const list = node_fs_1.default.readdirSync(src);
     for (const loc of list) {
-        removeSync(node_path_1.default.join(src, loc));
+        node_fs_1.default.rmSync(node_path_1.default.join(src, loc), { recursive: true, force: false });
     }
 }
 /**