@jsenv/filesystem 4.2.3 → 4.2.4

package/src/copyDirectoryContent.js

@@ -1,13 +1,13 @@
-import { Abort } from "@jsenv/abort"
-import { urlToFileSystemPath, resolveUrl } from "@jsenv/urls"
+import { Abort } from "@jsenv/abort";
+import { urlToFileSystemPath, resolveUrl } from "@jsenv/urls";
 
-import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js"
-import { readEntryStat } from "./readEntryStat.js"
-import { readSymbolicLink } from "./readSymbolicLink.js"
-import { readDirectory } from "./readDirectory.js"
-import { copyEntry } from "./copyEntry.js"
-import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js"
-import { statsToType } from "./internal/statsToType.js"
+import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js";
+import { readEntryStat } from "./readEntryStat.js";
+import { readSymbolicLink } from "./readSymbolicLink.js";
+import { readDirectory } from "./readDirectory.js";
+import { copyEntry } from "./copyEntry.js";
+import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js";
+import { statsToType } from "./internal/statsToType.js";
 
 export const copyDirectoryContent = async ({
   signal = new AbortController().signal,
@@ -16,23 +16,23 @@ export const copyDirectoryContent = async ({
   overwrite,
   followLink = true,
 } = {}) => {
-  const fromUrl = assertAndNormalizeDirectoryUrl(from)
-  const fromPath = urlToFileSystemPath(fromUrl)
-  let toUrl = assertAndNormalizeDirectoryUrl(to)
-  let toPath = urlToFileSystemPath(toUrl)
+  const fromUrl = assertAndNormalizeDirectoryUrl(from);
+  const fromPath = urlToFileSystemPath(fromUrl);
+  let toUrl = assertAndNormalizeDirectoryUrl(to);
+  let toPath = urlToFileSystemPath(toUrl);
 
   const sourceStats = await readEntryStat(fromUrl, {
     nullIfNotFound: true,
     followLink: false,
-  })
+  });
   if (!sourceStats) {
-    throw new Error(`no directory to copy content from at ${fromPath}`)
+    throw new Error(`no directory to copy content from at ${fromPath}`);
   }
   if (!sourceStats.isDirectory()) {
-    const sourceType = statsToType(sourceStats)
+    const sourceType = statsToType(sourceStats);
     throw new Error(
       `found a ${sourceType} instead of a directory at ${fromPath}`,
-    )
+    );
   }
 
   let destinationStats = await readEntryStat(toUrl, {
@@ -40,41 +40,41 @@ export const copyDirectoryContent = async ({
     // we force false here but in fact we will follow the destination link
     // to know where we will actually move and detect useless move overrite etc..
     followLink: false,
-  })
+  });
   if (followLink && destinationStats && destinationStats.isSymbolicLink()) {
-    const linkTarget = await readSymbolicLink(toUrl)
-    toUrl = resolveUrl(linkTarget, toUrl)
-    toPath = urlToFileSystemPath(toUrl)
+    const linkTarget = await readSymbolicLink(toUrl);
+    toUrl = resolveUrl(linkTarget, toUrl);
+    toPath = urlToFileSystemPath(toUrl);
     destinationStats = await readEntryStat(toUrl, {
       nullIfNotFound: true,
-    })
+    });
   }
 
   if (destinationStats === null) {
-    throw new Error(`no directory to copy content into at ${toPath}`)
+    throw new Error(`no directory to copy content into at ${toPath}`);
   }
   if (!destinationStats.isDirectory()) {
-    const destinationType = statsToType(destinationStats)
+    const destinationType = statsToType(destinationStats);
     throw new Error(
       `destination leads to a ${destinationType} instead of a directory at ${toPath}`,
-    )
+    );
   }
 
   if (urlTargetsSameFileSystemPath(fromUrl, toUrl)) {
     throw new Error(
       `cannot copy directory content, source and destination are the same (${fromPath})`,
-    )
+    );
   }
 
-  const copyOperation = Abort.startOperation()
-  copyOperation.addAbortSignal(signal)
+  const copyOperation = Abort.startOperation();
+  copyOperation.addAbortSignal(signal);
   try {
-    copyOperation.throwIfAborted()
-    const directoryEntries = await readDirectory(fromUrl)
+    copyOperation.throwIfAborted();
+    const directoryEntries = await readDirectory(fromUrl);
     await Promise.all(
       directoryEntries.map(async (directoryEntry) => {
-        const from = resolveUrl(directoryEntry, fromUrl)
-        const to = resolveUrl(directoryEntry, toUrl)
+        const from = resolveUrl(directoryEntry, fromUrl);
+        const to = resolveUrl(directoryEntry, toUrl);
         await copyOperation.withSignal(async (signal) => {
           await copyEntry({
             signal,
@@ -82,11 +82,11 @@ export const copyDirectoryContent = async ({
             to,
             overwrite,
             followLink,
-          })
-        })
+          });
+        });
       }),
-    )
+    );
   } finally {
-    await copyOperation.end()
+    await copyOperation.end();
   }
-}
+};

package/src/copyEntry.js

@@ -1,26 +1,26 @@
-import { copyFile as copyFileNode } from "node:fs"
-import { Abort } from "@jsenv/abort"
+import { copyFile as copyFileNode } from "node:fs";
+import { Abort } from "@jsenv/abort";
 import {
   resolveUrl,
   urlToRelativeUrl,
   ensurePathnameTrailingSlash,
   urlIsInsideOf,
   urlToFileSystemPath,
-} from "@jsenv/urls"
-
-import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js"
-import { statsToType } from "./internal/statsToType.js"
-import { binaryFlagsToPermissions } from "./internal/permissions.js"
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
-import { writeDirectory } from "./writeDirectory.js"
-import { readEntryStat } from "./readEntryStat.js"
-import { ensureParentDirectories } from "./ensureParentDirectories.js"
-import { writeEntryPermissions } from "./writeEntryPermissions.js"
-import { writeEntryModificationTime } from "./writeEntryModificationTime.js"
-import { readDirectory } from "./readDirectory.js"
-import { readSymbolicLink } from "./readSymbolicLink.js"
-import { writeSymbolicLink } from "./writeSymbolicLink.js"
-import { removeEntry } from "./removeEntry.js"
+} from "@jsenv/urls";
+
+import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js";
+import { statsToType } from "./internal/statsToType.js";
+import { binaryFlagsToPermissions } from "./internal/permissions.js";
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { writeDirectory } from "./writeDirectory.js";
+import { readEntryStat } from "./readEntryStat.js";
+import { ensureParentDirectories } from "./ensureParentDirectories.js";
+import { writeEntryPermissions } from "./writeEntryPermissions.js";
+import { writeEntryModificationTime } from "./writeEntryModificationTime.js";
+import { readDirectory } from "./readDirectory.js";
+import { readSymbolicLink } from "./readSymbolicLink.js";
+import { writeSymbolicLink } from "./writeSymbolicLink.js";
+import { removeEntry } from "./removeEntry.js";
 
 export const copyEntry = async ({
   signal = new AbortController().signal,
@@ -33,17 +33,17 @@ export const copyEntry = async ({
   allowUseless = false,
   followLink = true,
 }) => {
-  const fromUrl = assertAndNormalizeFileUrl(from)
-  const fromPath = urlToFileSystemPath(fromUrl)
-  let toUrl = assertAndNormalizeFileUrl(to)
-  let toPath = urlToFileSystemPath(toUrl)
+  const fromUrl = assertAndNormalizeFileUrl(from);
+  const fromPath = urlToFileSystemPath(fromUrl);
+  let toUrl = assertAndNormalizeFileUrl(to);
+  let toPath = urlToFileSystemPath(toUrl);
 
   const sourceStats = await readEntryStat(fromUrl, {
     nullIfNotFound: true,
     followLink: false,
-  })
+  });
   if (!sourceStats) {
-    throw new Error(`nothing to copy at ${fromPath}`)
+    throw new Error(`nothing to copy at ${fromPath}`);
   }
 
   let destinationStats = await readEntryStat(toUrl, {
@@ -51,82 +51,82 @@ export const copyEntry = async ({
     // we force false here but in fact we will follow the destination link
     // to know where we will actually move and detect useless move overrite etc..
     followLink: false,
-  })
+  });
 
   if (followLink && destinationStats && destinationStats.isSymbolicLink()) {
-    const linkTarget = await readSymbolicLink(toUrl)
-    toUrl = resolveUrl(linkTarget, toUrl)
-    toPath = urlToFileSystemPath(toUrl)
+    const linkTarget = await readSymbolicLink(toUrl);
+    toUrl = resolveUrl(linkTarget, toUrl);
+    toPath = urlToFileSystemPath(toUrl);
     destinationStats = await readEntryStat(toUrl, {
       nullIfNotFound: true,
-    })
+    });
   }
 
   if (urlTargetsSameFileSystemPath(fromUrl, toUrl)) {
     if (allowUseless) {
-      return
+      return;
     }
     throw new Error(
       `cannot copy ${fromPath} because destination and source are the same`,
-    )
+    );
   }
 
   if (sourceStats.isDirectory()) {
-    toUrl = ensurePathnameTrailingSlash(toUrl)
+    toUrl = ensurePathnameTrailingSlash(toUrl);
   }
 
-  const copyOperation = Abort.startOperation()
-  copyOperation.addAbortSignal(signal)
+  const copyOperation = Abort.startOperation();
+  copyOperation.addAbortSignal(signal);
 
   const visit = async (url, stats) => {
-    copyOperation.throwIfAborted()
+    copyOperation.throwIfAborted();
     if (stats.isFile() || stats.isCharacterDevice() || stats.isBlockDevice()) {
-      await visitFile(url, stats)
+      await visitFile(url, stats);
     } else if (stats.isSymbolicLink()) {
-      await visitSymbolicLink(url, stats)
+      await visitSymbolicLink(url, stats);
     } else if (stats.isDirectory()) {
-      await visitDirectory(ensurePathnameTrailingSlash(url), stats)
+      await visitDirectory(ensurePathnameTrailingSlash(url), stats);
     }
-  }
+  };
 
   const visitFile = async (fileUrl, fileStats) => {
-    const fileRelativeUrl = urlToRelativeUrl(fileUrl, fromUrl)
-    const fileCopyUrl = resolveUrl(fileRelativeUrl, toUrl)
+    const fileRelativeUrl = urlToRelativeUrl(fileUrl, fromUrl);
+    const fileCopyUrl = resolveUrl(fileRelativeUrl, toUrl);
 
     await copyFileContentNaive(
       urlToFileSystemPath(fileUrl),
       urlToFileSystemPath(fileCopyUrl),
-    )
-    await copyStats(fileCopyUrl, fileStats)
-  }
+    );
+    await copyStats(fileCopyUrl, fileStats);
+  };
 
   const visitSymbolicLink = async (symbolicLinkUrl) => {
-    const symbolicLinkRelativeUrl = urlToRelativeUrl(symbolicLinkUrl, fromUrl)
-    const symbolicLinkTarget = await readSymbolicLink(symbolicLinkUrl)
+    const symbolicLinkRelativeUrl = urlToRelativeUrl(symbolicLinkUrl, fromUrl);
+    const symbolicLinkTarget = await readSymbolicLink(symbolicLinkUrl);
     const symbolicLinkTargetUrl = resolveUrl(
       symbolicLinkTarget,
       symbolicLinkUrl,
-    )
+    );
     const linkIsRelative =
       symbolicLinkTarget.startsWith("./") ||
-      symbolicLinkTarget.startsWith("../")
+      symbolicLinkTarget.startsWith("../");
 
-    let symbolicLinkCopyTarget
+    let symbolicLinkCopyTarget;
     if (symbolicLinkTargetUrl === fromUrl) {
-      symbolicLinkCopyTarget = linkIsRelative ? symbolicLinkTarget : toUrl
+      symbolicLinkCopyTarget = linkIsRelative ? symbolicLinkTarget : toUrl;
     } else if (urlIsInsideOf(symbolicLinkTargetUrl, fromUrl)) {
       // symbolic link targets something inside the directory we want to copy
       // reflects it inside the copied directory structure
       const linkCopyTargetRelative = urlToRelativeUrl(
         symbolicLinkTargetUrl,
         fromUrl,
-      )
+      );
       symbolicLinkCopyTarget = linkIsRelative
         ? `./${linkCopyTargetRelative}`
-        : resolveUrl(linkCopyTargetRelative, toUrl)
+        : resolveUrl(linkCopyTargetRelative, toUrl);
     } else {
       // symbolic link targets something outside the directory we want to copy
-      symbolicLinkCopyTarget = symbolicLinkTarget
+      symbolicLinkCopyTarget = symbolicLinkTarget;
     }
 
     // we must guess ourself the type of the symlink
@@ -135,65 +135,65 @@ export const copyEntry = async ({
     const targetStats = await readEntryStat(symbolicLinkTargetUrl, {
       nullIfNotFound: true,
       followLink: false,
-    })
-    const linkType = targetStats && targetStats.isDirectory() ? "dir" : "file"
+    });
+    const linkType = targetStats && targetStats.isDirectory() ? "dir" : "file";
 
-    const symbolicLinkCopyUrl = resolveUrl(symbolicLinkRelativeUrl, toUrl)
+    const symbolicLinkCopyUrl = resolveUrl(symbolicLinkRelativeUrl, toUrl);
     await writeSymbolicLink({
       from: symbolicLinkCopyUrl,
       to: symbolicLinkCopyTarget,
       type: linkType,
-    })
-  }
+    });
+  };
 
   const copyStats = async (toUrl, stats) => {
     if (preservePermissions || preserveMtime) {
-      const { mode, mtimeMs } = stats
+      const { mode, mtimeMs } = stats;
       if (preservePermissions) {
-        await writeEntryPermissions(toUrl, binaryFlagsToPermissions(mode))
+        await writeEntryPermissions(toUrl, binaryFlagsToPermissions(mode));
       }
       if (preserveMtime) {
-        await writeEntryModificationTime(toUrl, mtimeMs)
+        await writeEntryModificationTime(toUrl, mtimeMs);
       }
     }
-  }
+  };
 
   const visitDirectory = async (directoryUrl, directoryStats) => {
-    const directoryRelativeUrl = urlToRelativeUrl(directoryUrl, fromUrl)
-    const directoryCopyUrl = resolveUrl(directoryRelativeUrl, toUrl)
+    const directoryRelativeUrl = urlToRelativeUrl(directoryUrl, fromUrl);
+    const directoryCopyUrl = resolveUrl(directoryRelativeUrl, toUrl);
 
-    await writeDirectory(directoryCopyUrl)
-    await copyDirectoryContent(directoryUrl)
-    await copyStats(directoryCopyUrl, directoryStats)
-  }
+    await writeDirectory(directoryCopyUrl);
+    await copyDirectoryContent(directoryUrl);
+    await copyStats(directoryCopyUrl, directoryStats);
+  };
 
   const copyDirectoryContent = async (directoryUrl) => {
-    const names = await readDirectory(directoryUrl)
+    const names = await readDirectory(directoryUrl);
     await Promise.all(
       names.map(async (name) => {
-        const entryUrl = resolveUrl(name, directoryUrl)
+        const entryUrl = resolveUrl(name, directoryUrl);
         const stats = await readEntryStat(entryUrl, {
           followLink: false,
-        })
-        await visit(entryUrl, stats)
+        });
+        await visit(entryUrl, stats);
       }),
-    )
-  }
+    );
+  };
 
   try {
     if (destinationStats) {
-      const sourceType = statsToType(sourceStats)
-      const destinationType = statsToType(destinationStats)
+      const sourceType = statsToType(sourceStats);
+      const destinationType = statsToType(destinationStats);
 
       if (sourceType !== destinationType) {
         throw new Error(
           `cannot copy ${sourceType} from ${fromPath} to ${toPath} because destination exists and is not a ${sourceType} (it's a ${destinationType})`,
-        )
+        );
       }
       if (!overwrite) {
         throw new Error(
           `cannot copy ${sourceType} from ${fromPath} to ${toPath} because destination exists and overwrite option is disabled`,
-        )
+        );
       }
 
       // remove file, link, directory...
@@ -201,26 +201,26 @@ export const copyEntry = async ({
         signal: copyOperation.signal,
         recursive: true,
         allowUseless: true,
-      })
+      });
     } else {
-      await ensureParentDirectories(toUrl)
+      await ensureParentDirectories(toUrl);
     }
 
-    copyOperation.throwIfAborted()
-    await visit(fromUrl, sourceStats)
+    copyOperation.throwIfAborted();
+    await visit(fromUrl, sourceStats);
   } finally {
-    await copyOperation.end()
+    await copyOperation.end();
   }
-}
+};
 
 const copyFileContentNaive = (filePath, fileDestinationPath) => {
   return new Promise((resolve, reject) => {
     copyFileNode(filePath, fileDestinationPath, (error) => {
       if (error) {
-        reject(error)
+        reject(error);
       } else {
-        resolve()
+        resolve();
       }
-    })
-  })
-}
+    });
+  });
+};

package/src/directory_url_validation.js

@@ -2,25 +2,25 @@ import {
   fileSystemPathToUrl,
   isFileSystemPath,
   ensurePathnameTrailingSlash,
-} from "@jsenv/urls"
+} from "@jsenv/urls";
 
 export const validateDirectoryUrl = (value) => {
-  let urlString
+  let urlString;
 
   if (value instanceof URL) {
-    urlString = value.href
+    urlString = value.href;
   } else if (typeof value === "string") {
     if (isFileSystemPath(value)) {
-      urlString = fileSystemPathToUrl(value)
+      urlString = fileSystemPathToUrl(value);
     } else {
       try {
-        urlString = String(new URL(value))
+        urlString = String(new URL(value));
       } catch (e) {
         return {
           valid: false,
           value,
           message: `must be a valid url`,
-        }
+        };
       }
     }
   } else {
@@ -28,28 +28,28 @@ export const validateDirectoryUrl = (value) => {
       valid: false,
       value,
       message: `must be a string or an url`,
-    }
+    };
   }
   if (!urlString.startsWith("file://")) {
     return {
       valid: false,
       value,
       message: 'must start with "file://"',
-    }
+    };
   }
   return {
     valid: true,
     value: ensurePathnameTrailingSlash(urlString),
-  }
-}
+  };
+};
 
 export const assertAndNormalizeDirectoryUrl = (
   directoryUrl,
   name = "directoryUrl",
 ) => {
-  const { valid, message, value } = validateDirectoryUrl(directoryUrl)
+  const { valid, message, value } = validateDirectoryUrl(directoryUrl);
   if (!valid) {
-    throw new TypeError(`${name} ${message}, got ${value}`)
+    throw new TypeError(`${name} ${message}, got ${value}`);
   }
-  return value
-}
+  return value;
+};

package/src/ensureEmptyDirectory.js

@@ -1,19 +1,19 @@
-import { urlToFileSystemPath } from "@jsenv/urls"
+import { urlToFileSystemPath } from "@jsenv/urls";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
-import { statsToType } from "./internal/statsToType.js"
-import { writeDirectory } from "./writeDirectory.js"
-import { readEntryStat } from "./readEntryStat.js"
-import { removeEntry } from "./removeEntry.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { statsToType } from "./internal/statsToType.js";
+import { writeDirectory } from "./writeDirectory.js";
+import { readEntryStat } from "./readEntryStat.js";
+import { removeEntry } from "./removeEntry.js";
 
 export const ensureEmptyDirectory = async (source) => {
   const stats = await readEntryStat(source, {
     nullIfNotFound: true,
     followLink: false,
-  })
+  });
   if (stats === null) {
     // if there is nothing, create a directory
-    return writeDirectory(source, { allowUseless: true })
+    return writeDirectory(source, { allowUseless: true });
   }
   if (stats.isDirectory()) {
     // if there is a directory remove its content and done
@@ -21,12 +21,12 @@ export const ensureEmptyDirectory = async (source) => {
       allowUseless: true,
       recursive: true,
       onlyContent: true,
-    })
+    });
   }
 
-  const sourceType = statsToType(stats)
-  const sourcePath = urlToFileSystemPath(assertAndNormalizeFileUrl(source))
+  const sourceType = statsToType(stats);
+  const sourcePath = urlToFileSystemPath(assertAndNormalizeFileUrl(source));
   throw new Error(
     `ensureEmptyDirectory expect directory at ${sourcePath}, found ${sourceType} instead`,
-  )
-}
+  );
+};

package/src/ensureParentDirectories.js

@@ -1,16 +1,16 @@
-import { dirname } from "node:path"
-import { urlToFileSystemPath } from "@jsenv/urls"
+import { dirname } from "node:path";
+import { urlToFileSystemPath } from "@jsenv/urls";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
-import { writeDirectory } from "./writeDirectory.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { writeDirectory } from "./writeDirectory.js";
 
 export const ensureParentDirectories = async (destination) => {
-  const destinationUrl = assertAndNormalizeFileUrl(destination)
-  const destinationPath = urlToFileSystemPath(destinationUrl)
-  const destinationParentPath = dirname(destinationPath)
+  const destinationUrl = assertAndNormalizeFileUrl(destination);
+  const destinationPath = urlToFileSystemPath(destinationUrl);
+  const destinationParentPath = dirname(destinationPath);
 
   return writeDirectory(destinationParentPath, {
     recursive: true,
     allowUseless: true,
-  })
-}
+  });
+};

package/src/ensureWindowsDriveLetter.js

@@ -1,7 +1,7 @@
-import { fileSystemPathToUrl } from "@jsenv/urls"
+import { fileSystemPathToUrl } from "@jsenv/urls";
 
-const isWindows = process.platform === "win32"
-const baseUrlFallback = fileSystemPathToUrl(process.cwd())
+const isWindows = process.platform === "win32";
+const baseUrlFallback = fileSystemPathToUrl(process.cwd());
 
 /**
  * Some url might be resolved or remapped to url without the windows drive letter.
@@ -18,51 +18,51 @@ const baseUrlFallback = fileSystemPathToUrl(process.cwd())
 
 export const ensureWindowsDriveLetter = (url, baseUrl) => {
   try {
-    url = String(new URL(url))
+    url = String(new URL(url));
   } catch (e) {
-    throw new Error(`absolute url expected but got ${url}`)
+    throw new Error(`absolute url expected but got ${url}`);
   }
 
   if (!isWindows) {
-    return url
+    return url;
   }
 
   try {
-    baseUrl = String(new URL(baseUrl))
+    baseUrl = String(new URL(baseUrl));
   } catch (e) {
     throw new Error(
       `absolute baseUrl expected but got ${baseUrl} to ensure windows drive letter on ${url}`,
-    )
+    );
   }
 
   if (!url.startsWith("file://")) {
-    return url
+    return url;
   }
-  const afterProtocol = url.slice("file://".length)
+  const afterProtocol = url.slice("file://".length);
   // we still have the windows drive letter
   if (extractDriveLetter(afterProtocol)) {
-    return url
+    return url;
   }
 
   // drive letter was lost, restore it
   const baseUrlOrFallback = baseUrl.startsWith("file://")
     ? baseUrl
-    : baseUrlFallback
+    : baseUrlFallback;
   const driveLetter = extractDriveLetter(
     baseUrlOrFallback.slice("file://".length),
-  )
+  );
   if (!driveLetter) {
     throw new Error(
       `drive letter expected on baseUrl but got ${baseUrl} to ensure windows drive letter on ${url}`,
-    )
+    );
   }
-  return `file:///${driveLetter}:${afterProtocol}`
-}
+  return `file:///${driveLetter}:${afterProtocol}`;
+};
 
 const extractDriveLetter = (resource) => {
   // we still have the windows drive letter
   if (/[a-zA-Z]/.test(resource[1]) && resource[2] === ":") {
-    return resource[1]
+    return resource[1];
   }
-  return null
-}
+  return null;
+};

package/src/fileSystemRootUrl.js

@@ -1,2 +1,2 @@
 export const fileSystemRootUrl =
-  process.platform === "win32" ? `file:///${process.cwd()[0]}:/` : "file:///"
+  process.platform === "win32" ? `file:///${process.cwd()[0]}:/` : "file:///";