@jsenv/filesystem 4.3.1 → 4.4.0

package/src/{moveDirectoryContent.js → move/move_directory_content.js}

@@ -1,13 +1,13 @@
 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 { moveEntry } from "./moveEntry.js";
-import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js";
-import { statsToType } from "./internal/statsToType.js";
+import { assertAndNormalizeDirectoryUrl } from "../path_and_url/directory_url_validation.js";
+import { urlTargetsSameFileSystemPath } from "../path_and_url/url_targets_same_file_system_path.js";
+import { readEntryStat } from "../read_write/stat/read_entry_stat.js";
+import { statsToType } from "../read_write/stat/stats_to_type.js";
+import { readSymbolicLink } from "../read_write/read_symbolic_link.js";
+import { readDirectory } from "../read_write/read_directory.js";
+import { moveEntry } from "./move_entry.js";
 
 export const moveDirectoryContent = async ({
   signal = new AbortController().signal,

package/src/{moveEntry.js → move/move_entry.js}

@@ -2,14 +2,14 @@ import { rename } from "node:fs";
 import { Abort } from "@jsenv/abort";
 import { urlToFileSystemPath, resolveUrl } from "@jsenv/urls";
 
-import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js";
-import { statsToType } from "./internal/statsToType.js";
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
-import { ensureParentDirectories } from "./ensureParentDirectories.js";
-import { removeEntry } from "./removeEntry.js";
-import { copyEntry } from "./copyEntry.js";
-import { readEntryStat } from "./readEntryStat.js";
-import { readSymbolicLink } from "./readSymbolicLink.js";
+import { assertAndNormalizeFileUrl } from "../path_and_url/file_url_validation.js";
+import { urlTargetsSameFileSystemPath } from "../path_and_url/url_targets_same_file_system_path.js";
+import { statsToType } from "../read_write/stat/stats_to_type.js";
+import { readEntryStat } from "../read_write/stat/read_entry_stat.js";
+import { ensureParentDirectories } from "../read_write/ensure_parent_directories.js";
+import { readSymbolicLink } from "../read_write/read_symbolic_link.js";
+import { copyEntry } from "../copy/copy_entry.js";
+import { removeEntry } from "../remove/remove_entry.js";
 
 export const moveEntry = async ({
   signal = new AbortController().signal,

package/src/{ensureParentDirectories.js → read_write/ensure_parent_directories.js}

@@ -1,15 +1,15 @@
 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 "../path_and_url/file_url_validation.js";
+import { writeDirectory } from "./write_directory.js";
 
 export const ensureParentDirectories = async (destination) => {
   const destinationUrl = assertAndNormalizeFileUrl(destination);
   const destinationPath = urlToFileSystemPath(destinationUrl);
   const destinationParentPath = dirname(destinationPath);
 
-  return writeDirectory(destinationParentPath, {
+  await writeDirectory(destinationParentPath, {
     recursive: true,
     allowUseless: true,
   });

package/src/read_write/ensure_parent_directories_sync.js

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

package/src/{readDirectory.js → read_write/read_directory.js}

@@ -1,5 +1,6 @@
 import { readdir } from "node:fs";
-import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js";
+
+import { assertAndNormalizeDirectoryUrl } from "../path_and_url/directory_url_validation.js";
 
 export const readDirectory = async (url, { emfileMaxWait = 1000 } = {}) => {
   const directoryUrl = assertAndNormalizeDirectoryUrl(url);

package/src/read_write/read_directory_sync.js

@@ -0,0 +1,10 @@
+import { readdirSync } from "node:fs";
+
+import { assertAndNormalizeDirectoryUrl } from "../path_and_url/directory_url_validation.js";
+
+export const readDirectorySync = (url) => {
+  const directoryUrl = assertAndNormalizeDirectoryUrl(url);
+  const directoryUrlObject = new URL(directoryUrl);
+  const names = readdirSync(directoryUrlObject);
+  return names.map(encodeURIComponent);
+};

package/src/{readFile.js → read_write/read_file.js}

@@ -1,6 +1,6 @@
 import { readFile as readFileNode } from "node:fs";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { assertAndNormalizeFileUrl } from "../path_and_url/file_url_validation.js";
 
 export const readFile = async (value, { as = "buffer" } = {}) => {
   const fileUrl = assertAndNormalizeFileUrl(value);

package/src/read_write/read_file_structure_sync.js

@@ -0,0 +1,57 @@
+import { readdirSync, statSync, readFileSync } from "node:fs";
+import { urlToRelativeUrl } from "@jsenv/urls";
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
+
+import { comparePathnames } from "../path_and_url/compare_pathnames.js";
+
+export const readFileStructureSync = (directoryUrl) => {
+  const fileStructure = {};
+  const fileStructureNotOrdered = {};
+  const visitDirectory = (url) => {
+    try {
+      const directoryContent = readdirSync(url);
+      directoryContent.forEach((filename) => {
+        const contentUrl = new URL(filename, url);
+        const stat = statSync(contentUrl);
+        if (stat.isDirectory()) {
+          visitDirectory(new URL(`${contentUrl}/`));
+          return;
+        }
+        const relativeUrl = urlToRelativeUrl(contentUrl, directoryUrl);
+        fileStructureNotOrdered[relativeUrl] = readFileContent(contentUrl);
+      });
+    } catch (e) {
+      if (e && e.code === "ENOENT") {
+        return;
+      }
+      throw e;
+    }
+  };
+  visitDirectory(new URL(directoryUrl));
+
+  const relativeUrls = Object.keys(fileStructureNotOrdered);
+  relativeUrls.sort(comparePathnames);
+  relativeUrls.forEach((relativeUrl) => {
+    fileStructure[relativeUrl] = fileStructureNotOrdered[relativeUrl];
+  });
+  return fileStructure;
+};
+
+const readFileContent = (fileUrl) => {
+  const isTextual = CONTENT_TYPE.isTextual(
+    CONTENT_TYPE.fromUrlExtension(fileUrl),
+  );
+  if (isTextual) {
+    const content = readFileSync(new URL(fileUrl), "utf8");
+    if (process.platform === "win32") {
+      // ensure unix line breaks
+      return content.replace(/\r\n/g, "\n");
+    }
+    return content;
+  }
+  const content = readFileSync(new URL(fileUrl));
+  if (content.length === 0) {
+    return "";
+  }
+  return content;
+};

package/src/{readFileSync.js → read_write/read_file_sync.js}

@@ -1,6 +1,6 @@
 import { readFileSync as readFileSyncNode } from "node:fs";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { assertAndNormalizeFileUrl } from "../path_and_url/file_url_validation.js";
 
 export const readFileSync = (value, { as = "buffer" } = {}) => {
   const fileUrl = assertAndNormalizeFileUrl(value);

package/src/{readSymbolicLink.js → read_write/read_symbolic_link.js}

@@ -6,7 +6,7 @@
 import { readlink } from "node:fs";
 import { isFileSystemPath, fileSystemPathToUrl } from "@jsenv/urls";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { assertAndNormalizeFileUrl } from "../path_and_url/file_url_validation.js";
 
 export const readSymbolicLink = (url) => {
   const symbolicLinkUrl = assertAndNormalizeFileUrl(url);

package/src/read_write/read_symbolic_link_sync.js

@@ -0,0 +1,17 @@
+/*
+ * - symlink documentation on Node.js:
+ *   https://nodejs.org/docs/latest-v13.x/api/fs.html#fs_fs_symlink_target_path_type_callback
+ */
+
+import { readlinkSync } from "node:fs";
+import { isFileSystemPath, fileSystemPathToUrl } from "@jsenv/urls";
+
+import { assertAndNormalizeFileUrl } from "../path_and_url/file_url_validation.js";
+
+export const readSymbolicLinkSync = (url) => {
+  const symbolicLinkUrl = assertAndNormalizeFileUrl(url);
+  const resolvedPath = readlinkSync(new URL(symbolicLinkUrl));
+  return isFileSystemPath(resolvedPath)
+    ? fileSystemPathToUrl(resolvedPath)
+    : resolvedPath.replace(/\\/g, "/"); // replace back slashes with slashes
+};

package/src/{grantPermissionsOnEntry.js → read_write/stat/grant_permissions_on_entry.js}

@@ -1,6 +1,6 @@
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
-import { readEntryPermissions } from "./readEntryPermissions.js";
-import { writeEntryPermissions } from "./writeEntryPermissions.js";
+import { assertAndNormalizeFileUrl } from "../../path_and_url/file_url_validation.js";
+import { readEntryPermissions } from "./read_entry_permissions.js";
+import { writeEntryPermissions } from "./write_entry_permissions.js";
 
 export const grantPermissionsOnEntry = async (
   source,

package/src/{internal → read_write/stat}/read_entry_info.js

@@ -1,6 +1,6 @@
 import { statSync } from "node:fs";
 
-import { statsToType } from "./statsToType.js";
+import { statsToType } from "./stats_to_type.js";
 
 export const readEntryInfo = (url) => {
   try {

package/src/{readEntryModificationTime.js → read_write/stat/read_entry_modification_time.js}

@@ -1,4 +1,4 @@
-import { readEntryStat } from "./readEntryStat.js";
+import { readEntryStat } from "./read_entry_stat.js";
 
 export const readEntryModificationTime = async (source) => {
   const stats = await readEntryStat(source);

package/src/{readEntryPermissions.js → read_write/stat/read_entry_permissions.js}

@@ -6,8 +6,8 @@
 import { promises } from "node:fs";
 import { urlToFileSystemPath } from "@jsenv/urls";
 
-import { binaryFlagsToPermissions } from "./internal/permissions.js";
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { assertAndNormalizeFileUrl } from "../../path_and_url/file_url_validation.js";
+import { binaryFlagsToPermissions } from "./permissions.js";
 
 const { stat } = promises;
 

package/src/{readEntryStat.js → read_write/stat/read_entry_stat.js}

@@ -6,8 +6,8 @@
 import { lstat, stat } from "node:fs";
 import { urlToFileSystemPath } from "@jsenv/urls";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
-import { writeEntryPermissions } from "./writeEntryPermissions.js";
+import { assertAndNormalizeFileUrl } from "../../path_and_url/file_url_validation.js";
+import { writeEntryPermissions } from "./write_entry_permissions.js";
 
 const isWindows = process.platform === "win32";
 

package/src/read_write/stat/read_entry_stat_sync.js

@@ -0,0 +1,92 @@
+/*
+ * - stats object documentation on Node.js
+ *   https://nodejs.org/docs/latest-v13.x/api/fs.html#fs_class_fs_stats
+ */
+
+import { lstatSync, statSync } from "node:fs";
+import { urlToFileSystemPath } from "@jsenv/urls";
+
+import { assertAndNormalizeFileUrl } from "../../path_and_url/file_url_validation.js";
+import { writeEntryPermissionsSync } from "./write_entry_permissions_sync.js";
+
+const isWindows = process.platform === "win32";
+
+export const readEntryStatSync = (
+  source,
+  { nullIfNotFound = false, followLink = true } = {},
+) => {
+  let sourceUrl = assertAndNormalizeFileUrl(source);
+  if (sourceUrl.endsWith("/")) sourceUrl = sourceUrl.slice(0, -1);
+
+  const sourcePath = urlToFileSystemPath(sourceUrl);
+
+  const handleNotFoundOption = nullIfNotFound
+    ? {
+        handleNotFoundError: () => null,
+      }
+    : {};
+
+  return statSyncNaive(sourcePath, {
+    followLink,
+    ...handleNotFoundOption,
+    ...(isWindows
+      ? {
+          // Windows can EPERM on stat
+          handlePermissionDeniedError: (error) => {
+            console.error(
+              `trying to fix windows EPERM after stats on ${sourcePath}`,
+            );
+
+            try {
+              // unfortunately it means we mutate the permissions
+              // without being able to restore them to the previous value
+              // (because reading current permission would also throw)
+              writeEntryPermissionsSync(sourceUrl, 0o666);
+              const stats = statSyncNaive(sourcePath, {
+                followLink,
+                ...handleNotFoundOption,
+                // could not fix the permission error, give up and throw original error
+                handlePermissionDeniedError: () => {
+                  console.error(`still got EPERM after stats on ${sourcePath}`);
+                  throw error;
+                },
+              });
+              return stats;
+            } catch (e) {
+              console.error(
+                `error while trying to fix windows EPERM after stats on ${sourcePath}: ${e.stack}`,
+              );
+              throw error;
+            }
+          },
+        }
+      : {}),
+  });
+};
+
+const statSyncNaive = (
+  sourcePath,
+  {
+    followLink,
+    handleNotFoundError = null,
+    handlePermissionDeniedError = null,
+  } = {},
+) => {
+  const nodeMethod = followLink ? statSync : lstatSync;
+
+  try {
+    const stats = nodeMethod(sourcePath);
+    return stats;
+  } catch (error) {
+    if (handleNotFoundError && error.code === "ENOENT") {
+      return handleNotFoundError(error);
+    }
+    if (
+      handlePermissionDeniedError &&
+      (error.code === "EPERM" || error.code === "EACCES")
+    ) {
+      return handlePermissionDeniedError(error);
+    }
+    throw error;
+  }
+};

package/src/{testEntryPermissions.js → read_write/stat/test_entry_permissions.js}

@@ -1,6 +1,6 @@
 import { promises, constants } from "node:fs";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { assertAndNormalizeFileUrl } from "../../path_and_url/file_url_validation.js";
 
 const { access } = promises;
 const {

package/src/{writeEntryModificationTime.js → read_write/stat/write_entry_modification_time.js}

@@ -1,6 +1,6 @@
 import { utimes } from "node:fs";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { assertAndNormalizeFileUrl } from "../../path_and_url/file_url_validation.js";
 
 export const writeEntryModificationTime = (source, mtime) => {
   const sourceUrl = assertAndNormalizeFileUrl(source);

package/src/read_write/stat/write_entry_modification_time_sync.js

@@ -0,0 +1,14 @@
+import { utimesSync } from "node:fs";
+
+import { assertAndNormalizeFileUrl } from "../../path_and_url/file_url_validation.js";
+
+export const writeEntryModificationTimeSync = (source, mtime) => {
+  const sourceUrl = assertAndNormalizeFileUrl(source);
+  const mtimeValue =
+    typeof mtime === "number" ? new Date(Math.floor(mtime)) : mtime;
+  // reading atime mutates its value so there is no use case I can think of
+  // where we want to modify it
+  const atimeValue = mtimeValue;
+
+  utimesSync(new URL(sourceUrl), atimeValue, mtimeValue);
+};

package/src/{writeEntryPermissions.js → read_write/stat/write_entry_permissions.js}

@@ -1,7 +1,7 @@
 import { chmod } from "node:fs";
 
-import { permissionsToBinaryFlags } from "./internal/permissions.js";
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { assertAndNormalizeFileUrl } from "../../path_and_url/file_url_validation.js";
+import { permissionsToBinaryFlags } from "./permissions.js";
 
 export const writeEntryPermissions = async (source, permissions) => {
   const sourceUrl = assertAndNormalizeFileUrl(source);

package/src/read_write/stat/write_entry_permissions_sync.js

@@ -0,0 +1,77 @@
+import { chmodSync } from "node:fs";
+
+import { assertAndNormalizeFileUrl } from "../../path_and_url/file_url_validation.js";
+import { permissionsToBinaryFlags } from "./permissions.js";
+
+export const writeEntryPermissionsSync = (source, permissions) => {
+  const sourceUrl = assertAndNormalizeFileUrl(source);
+
+  let binaryFlags;
+  if (typeof permissions === "object") {
+    permissions = {
+      owner: {
+        read: getPermissionOrComputeDefault("read", "owner", permissions),
+        write: getPermissionOrComputeDefault("write", "owner", permissions),
+        execute: getPermissionOrComputeDefault("execute", "owner", permissions),
+      },
+      group: {
+        read: getPermissionOrComputeDefault("read", "group", permissions),
+        write: getPermissionOrComputeDefault("write", "group", permissions),
+        execute: getPermissionOrComputeDefault("execute", "group", permissions),
+      },
+      others: {
+        read: getPermissionOrComputeDefault("read", "others", permissions),
+        write: getPermissionOrComputeDefault("write", "others", permissions),
+        execute: getPermissionOrComputeDefault(
+          "execute",
+          "others",
+          permissions,
+        ),
+      },
+    };
+    binaryFlags = permissionsToBinaryFlags(permissions);
+  } else {
+    binaryFlags = permissions;
+  }
+
+  chmodSync(new URL(sourceUrl), binaryFlags);
+};
+
+const actionLevels = { read: 0, write: 1, execute: 2 };
+const subjectLevels = { others: 0, group: 1, owner: 2 };
+
+const getPermissionOrComputeDefault = (action, subject, permissions) => {
+  if (subject in permissions) {
+    const subjectPermissions = permissions[subject];
+    if (action in subjectPermissions) {
+      return subjectPermissions[action];
+    }
+
+    const actionLevel = actionLevels[action];
+    const actionFallback = Object.keys(actionLevels).find(
+      (actionFallbackCandidate) =>
+        actionLevels[actionFallbackCandidate] > actionLevel &&
+        actionFallbackCandidate in subjectPermissions,
+    );
+    if (actionFallback) {
+      return subjectPermissions[actionFallback];
+    }
+  }
+
+  const subjectLevel = subjectLevels[subject];
+  // do we have a subject with a stronger level (group or owner)
+  // where we could read the action permission ?
+  const subjectFallback = Object.keys(subjectLevels).find(
+    (subjectFallbackCandidate) =>
+      subjectLevels[subjectFallbackCandidate] > subjectLevel &&
+      subjectFallbackCandidate in permissions,
+  );
+  if (subjectFallback) {
+    const subjectPermissions = permissions[subjectFallback];
+    return action in subjectPermissions
+      ? subjectPermissions[action]
+      : getPermissionOrComputeDefault(action, subjectFallback, permissions);
+  }
+
+  return false;
+};

package/src/{writeDirectory.js → read_write/write_directory.js}

@@ -1,9 +1,9 @@
 import { promises } from "node:fs";
 import { urlToFileSystemPath } from "@jsenv/urls";
 
-import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js";
-import { statsToType } from "./internal/statsToType.js";
-import { readEntryStat } from "./readEntryStat.js";
+import { assertAndNormalizeDirectoryUrl } from "../path_and_url/directory_url_validation.js";
+import { statsToType } from "./stat/stats_to_type.js";
+import { readEntryStat } from "./stat/read_entry_stat.js";
 
 // https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_fspromises_mkdir_path_options
 const { mkdir } = promises;

package/src/read_write/write_directory_sync.js

@@ -0,0 +1,42 @@
+import { mkdirSync } from "node:fs";
+import { urlToFileSystemPath } from "@jsenv/urls";
+
+import { assertAndNormalizeDirectoryUrl } from "../path_and_url/directory_url_validation.js";
+import { readEntryStatSync } from "./stat/read_entry_stat_sync.js";
+import { statsToType } from "./stat/stats_to_type.js";
+
+export const writeDirectorySync = (
+  destination,
+  { recursive = true, allowUseless = false } = {},
+) => {
+  const destinationUrl = assertAndNormalizeDirectoryUrl(destination);
+  const destinationPath = urlToFileSystemPath(destinationUrl);
+
+  const destinationStats = readEntryStatSync(destinationUrl, {
+    nullIfNotFound: true,
+    followLink: false,
+  });
+
+  if (destinationStats) {
+    if (destinationStats.isDirectory()) {
+      if (allowUseless) {
+        return;
+      }
+      throw new Error(`directory already exists at ${destinationPath}`);
+    }
+
+    const destinationType = statsToType(destinationStats);
+    throw new Error(
+      `cannot write directory at ${destinationPath} because there is a ${destinationType}`,
+    );
+  }
+
+  try {
+    mkdirSync(destinationPath, { recursive });
+  } catch (error) {
+    if (allowUseless && error.code === "EEXIST") {
+      return;
+    }
+    throw error;
+  }
+};

package/src/{writeFile.js → read_write/write_file.js}

@@ -1,7 +1,7 @@
 import { writeFile as writeFileNode } from "node:fs";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
-import { ensureParentDirectories } from "./ensureParentDirectories.js";
+import { assertAndNormalizeFileUrl } from "../path_and_url/file_url_validation.js";
+import { ensureParentDirectories } from "./ensure_parent_directories.js";
 
 export const writeFile = async (destination, content = "") => {
   const destinationUrl = assertAndNormalizeFileUrl(destination);

package/src/read_write/write_file_structure_sync.js

@@ -0,0 +1,13 @@
+import { ensureEmptyDirectorySync } from "../remove/ensure_empty_directory_sync.js";
+import { writeFileSync } from "./write_file_sync.js";
+
+export const writeFileStructureSync = (directoryUrl, fileStructure) => {
+  ensureEmptyDirectorySync(directoryUrl);
+  if (fileStructure) {
+    Object.keys(fileStructure).forEach((relativeUrl) => {
+      const fileUrl = new URL(relativeUrl, directoryUrl);
+      const fileContent = fileStructure[relativeUrl];
+      writeFileSync(fileUrl, fileContent);
+    });
+  }
+};

package/src/{writeFileSync.js → read_write/write_file_sync.js}

@@ -1,6 +1,6 @@
 import { writeFileSync as writeFileSyncNode, mkdirSync } from "node:fs";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { assertAndNormalizeFileUrl } from "../path_and_url/file_url_validation.js";
 
 export const writeFileSync = (destination, content = "") => {
   const destinationUrl = assertAndNormalizeFileUrl(destination);

package/src/{writeSymbolicLink.js → read_write/write_symbolic_link.js}

@@ -6,11 +6,11 @@ import {
   isFileSystemPath,
 } from "@jsenv/urls";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
-import { ensureParentDirectories } from "./ensureParentDirectories.js";
-import { readEntryStat } from "./readEntryStat.js";
-import { readSymbolicLink } from "./readSymbolicLink.js";
-import { removeEntry } from "./removeEntry.js";
+import { assertAndNormalizeFileUrl } from "../path_and_url/file_url_validation.js";
+import { removeEntry } from "../remove/remove_entry.js";
+import { readEntryStat } from "./stat/read_entry_stat.js";
+import { readSymbolicLink } from "./read_symbolic_link.js";
+import { ensureParentDirectories } from "./ensure_parent_directories.js";
 
 // https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_fspromises_symlink_target_path_type
 const { symlink } = promises;