@jsenv/filesystem 2.3.1 → 2.6.0

package/dist/commonjs/jsenv_filesystem.cjs

@@ -1,2654 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var urlMeta = require('@jsenv/url-meta');
-var url = require('url');
-var node_fs = require('fs');
-var fs = require('fs');
-var node_crypto = require('crypto');
-var cancellation = require('@jsenv/cancellation');
-var path = require('path');
-var util = require('util');
-
-const ensureUrlTrailingSlash = url => {
-  return url.endsWith("/") ? url : `${url}/`;
-};
-
-const isFileSystemPath = value => {
-  if (typeof value !== "string") {
-    throw new TypeError(`isFileSystemPath first arg must be a string, got ${value}`);
-  }
-
-  if (value[0] === "/") {
-    return true;
-  }
-
-  return startsWithWindowsDriveLetter(value);
-};
-
-const startsWithWindowsDriveLetter = string => {
-  const firstChar = string[0];
-  if (!/[a-zA-Z]/.test(firstChar)) return false;
-  const secondChar = string[1];
-  if (secondChar !== ":") return false;
-  return true;
-};
-
-const fileSystemPathToUrl = value => {
-  if (!isFileSystemPath(value)) {
-    throw new Error(`received an invalid value for fileSystemPath: ${value}`);
-  }
-
-  return String(url.pathToFileURL(value));
-};
-
-const assertAndNormalizeDirectoryUrl = value => {
-  let urlString;
-
-  if (value instanceof URL) {
-    urlString = value.href;
-  } else if (typeof value === "string") {
-    if (isFileSystemPath(value)) {
-      urlString = fileSystemPathToUrl(value);
-    } else {
-      try {
-        urlString = String(new URL(value));
-      } catch (e) {
-        throw new TypeError(`directoryUrl must be a valid url, received ${value}`);
-      }
-    }
-  } else {
-    throw new TypeError(`directoryUrl must be a string or an url, received ${value}`);
-  }
-
-  if (!urlString.startsWith("file://")) {
-    throw new Error(`directoryUrl must starts with file://, received ${value}`);
-  }
-
-  return ensureUrlTrailingSlash(urlString);
-};
-
-const assertAndNormalizeFileUrl = (value, baseUrl) => {
-  let urlString;
-
-  if (value instanceof URL) {
-    urlString = value.href;
-  } else if (typeof value === "string") {
-    if (isFileSystemPath(value)) {
-      urlString = fileSystemPathToUrl(value);
-    } else {
-      try {
-        urlString = String(new URL(value, baseUrl));
-      } catch (e) {
-        throw new TypeError(`fileUrl must be a valid url, received ${value}`);
-      }
-    }
-  } else {
-    throw new TypeError(`fileUrl must be a string or an url, received ${value}`);
-  }
-
-  if (!urlString.startsWith("file://")) {
-    throw new Error(`fileUrl must starts with file://, received ${value}`);
-  }
-
-  return urlString;
-};
-
-const statsToType = stats => {
-  if (stats.isFile()) return "file";
-  if (stats.isDirectory()) return "directory";
-  if (stats.isSymbolicLink()) return "symbolic-link";
-  if (stats.isFIFO()) return "fifo";
-  if (stats.isSocket()) return "socket";
-  if (stats.isCharacterDevice()) return "character-device";
-  if (stats.isBlockDevice()) return "block-device";
-  return undefined;
-};
-
-const urlToFileSystemPath = url$1 => {
-  let urlString = String(url$1);
-
-  if (urlString[urlString.length - 1] === "/") {
-    // remove trailing / so that nodejs path becomes predictable otherwise it logs
-    // the trailing slash on linux but does not on windows
-    urlString = urlString.slice(0, -1);
-  }
-
-  const fileSystemPath = url.fileURLToPath(urlString);
-  return fileSystemPath;
-};
-
-// https://github.com/coderaiser/cloudcmd/issues/63#issuecomment-195478143
-// https://nodejs.org/api/fs.html#fs_file_modes
-// https://github.com/TooTallNate/stat-mode
-// cannot get from fs.constants because they are not available on windows
-const S_IRUSR = 256;
-/* 0000400 read permission, owner */
-
-const S_IWUSR = 128;
-/* 0000200 write permission, owner */
-
-const S_IXUSR = 64;
-/* 0000100 execute/search permission, owner */
-
-const S_IRGRP = 32;
-/* 0000040 read permission, group */
-
-const S_IWGRP = 16;
-/* 0000020 write permission, group */
-
-const S_IXGRP = 8;
-/* 0000010 execute/search permission, group */
-
-const S_IROTH = 4;
-/* 0000004 read permission, others */
-
-const S_IWOTH = 2;
-/* 0000002 write permission, others */
-
-const S_IXOTH = 1;
-/* 0000001 execute/search permission, others */
-
-/*
-here we could warn that on windows only 0o444 or 0o666 will work
-
-0o444 (readonly)
-{
-  owner: {read: true, write: false, execute: false},
-  group: {read: true, write: false, execute: false},
-  others: {read: true, write: false, execute: false},
-}
-
-0o666 (read and write)
-{
-  owner: {read: true, write: true, execute: false},
-  group: {read: true, write: true, execute: false},
-  others: {read: true, write: true, execute: false},
-}
-*/
-
-const binaryFlagsToPermissions = binaryFlags => {
-  const owner = {
-    read: Boolean(binaryFlags & S_IRUSR),
-    write: Boolean(binaryFlags & S_IWUSR),
-    execute: Boolean(binaryFlags & S_IXUSR)
-  };
-  const group = {
-    read: Boolean(binaryFlags & S_IRGRP),
-    write: Boolean(binaryFlags & S_IWGRP),
-    execute: Boolean(binaryFlags & S_IXGRP)
-  };
-  const others = {
-    read: Boolean(binaryFlags & S_IROTH),
-    write: Boolean(binaryFlags & S_IWOTH),
-    execute: Boolean(binaryFlags & S_IXOTH)
-  };
-  return {
-    owner,
-    group,
-    others
-  };
-};
-const permissionsToBinaryFlags = ({
-  owner,
-  group,
-  others
-}) => {
-  let binaryFlags = 0;
-  if (owner.read) binaryFlags |= S_IRUSR;
-  if (owner.write) binaryFlags |= S_IWUSR;
-  if (owner.execute) binaryFlags |= S_IXUSR;
-  if (group.read) binaryFlags |= S_IRGRP;
-  if (group.write) binaryFlags |= S_IWGRP;
-  if (group.execute) binaryFlags |= S_IXGRP;
-  if (others.read) binaryFlags |= S_IROTH;
-  if (others.write) binaryFlags |= S_IWOTH;
-  if (others.execute) binaryFlags |= S_IXOTH;
-  return binaryFlags;
-};
-
-const writeFileSystemNodePermissions = async (source, permissions) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source);
-  const sourcePath = urlToFileSystemPath(sourceUrl);
-  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;
-  }
-
-  return chmodNaive(sourcePath, binaryFlags);
-};
-
-const chmodNaive = (fileSystemPath, binaryFlags) => {
-  return new Promise((resolve, reject) => {
-    fs.chmod(fileSystemPath, binaryFlags, error => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve();
-      }
-    });
-  });
-};
-
-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;
-};
-
-/*
- * - stats object documentation on Node.js
- *   https://nodejs.org/docs/latest-v13.x/api/fs.html#fs_class_fs_stats
- */
-const isWindows$3 = process.platform === "win32";
-const readFileSystemNodeStat = async (source, {
-  nullIfNotFound = false,
-  followLink = true
-} = {}) => {
-  if (source.endsWith("/")) source = source.slice(0, -1);
-  const sourceUrl = assertAndNormalizeFileUrl(source);
-  const sourcePath = urlToFileSystemPath(sourceUrl);
-  const handleNotFoundOption = nullIfNotFound ? {
-    handleNotFoundError: () => null
-  } : {};
-  return readStat(sourcePath, {
-    followLink,
-    ...handleNotFoundOption,
-    ...(isWindows$3 ? {
-      // Windows can EPERM on stat
-      handlePermissionDeniedError: async 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)
-          await writeFileSystemNodePermissions(sourceUrl, 0o666);
-          const stats = await readStat(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 readStat = (sourcePath, {
-  followLink,
-  handleNotFoundError = null,
-  handlePermissionDeniedError = null
-} = {}) => {
-  const nodeMethod = followLink ? node_fs.stat : node_fs.lstat;
-  return new Promise((resolve, reject) => {
-    nodeMethod(sourcePath, (error, statsObject) => {
-      if (error) {
-        if (handleNotFoundError && error.code === "ENOENT") {
-          resolve(handleNotFoundError(error));
-        } else if (handlePermissionDeniedError && (error.code === "EPERM" || error.code === "EACCES")) {
-          resolve(handlePermissionDeniedError(error));
-        } else {
-          reject(error);
-        }
-      } else {
-        resolve(statsObject);
-      }
-    });
-  });
-};
-
-const assertDirectoryPresence = async source => {
-  const sourceUrl = assertAndNormalizeFileUrl(source);
-  const sourcePath = urlToFileSystemPath(sourceUrl);
-  const sourceStats = await readFileSystemNodeStat(sourceUrl, {
-    nullIfNotFound: true
-  });
-
-  if (!sourceStats) {
-    throw new Error(`directory not found at ${sourcePath}`);
-  }
-
-  if (!sourceStats.isDirectory()) {
-    throw new Error(`directory expected at ${sourcePath} and found ${statsToType(sourceStats)} instead`);
-  }
-};
-
-const assertFilePresence = async source => {
-  const sourceUrl = assertAndNormalizeFileUrl(source);
-  const sourcePath = urlToFileSystemPath(sourceUrl);
-  const sourceStats = await readFileSystemNodeStat(sourceUrl, {
-    nullIfNotFound: true
-  });
-
-  if (!sourceStats) {
-    throw new Error(`file not found at ${sourcePath}`);
-  }
-
-  if (!sourceStats.isFile()) {
-    throw new Error(`file expected at ${sourcePath} and found ${statsToType(sourceStats)} instead`);
-  }
-};
-
-/*
- * - Buffer documentation on Node.js
- *   https://nodejs.org/docs/latest-v13.x/api/buffer.html
- * - eTag documentation on MDN
- *   https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag
- */
-const ETAG_FOR_EMPTY_CONTENT = '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"';
-const bufferToEtag = buffer => {
-  if (!Buffer.isBuffer(buffer)) {
-    throw new TypeError(`buffer expected, got ${buffer}`);
-  }
-
-  if (buffer.length === 0) {
-    return ETAG_FOR_EMPTY_CONTENT;
-  }
-
-  const hash = node_crypto.createHash("sha1");
-  hash.update(buffer, "utf8");
-  const hashBase64String = hash.digest("base64");
-  const hashBase64StringSubset = hashBase64String.slice(0, 27);
-  const length = buffer.length;
-  return `"${length.toString(16)}-${hashBase64StringSubset}"`;
-};
-
-const readDirectory = async (url, {
-  emfileMaxWait = 1000
-} = {}) => {
-  const directoryUrl = assertAndNormalizeDirectoryUrl(url);
-  const directoryPath = urlToFileSystemPath(directoryUrl);
-  const startMs = Date.now();
-  let attemptCount = 0;
-
-  const attempt = () => {
-    return readdirNaive(directoryPath, {
-      handleTooManyFilesOpenedError: async error => {
-        attemptCount++;
-        const nowMs = Date.now();
-        const timeSpentWaiting = nowMs - startMs;
-
-        if (timeSpentWaiting > emfileMaxWait) {
-          throw error;
-        }
-
-        return new Promise(resolve => {
-          setTimeout(() => {
-            resolve(attempt());
-          }, attemptCount);
-        });
-      }
-    });
-  };
-
-  return attempt();
-};
-
-const readdirNaive = (directoryPath, {
-  handleTooManyFilesOpenedError = null
-} = {}) => {
-  return new Promise((resolve, reject) => {
-    fs.readdir(directoryPath, (error, names) => {
-      if (error) {
-        // https://nodejs.org/dist/latest-v13.x/docs/api/errors.html#errors_common_system_errors
-        if (handleTooManyFilesOpenedError && (error.code === "EMFILE" || error.code === "ENFILE")) {
-          resolve(handleTooManyFilesOpenedError(error));
-        } else {
-          reject(error);
-        }
-      } else {
-        resolve(names);
-      }
-    });
-  });
-};
-
-const getCommonPathname = (pathname, otherPathname) => {
-  const firstDifferentCharacterIndex = findFirstDifferentCharacterIndex(pathname, otherPathname); // pathname and otherpathname are exactly the same
-
-  if (firstDifferentCharacterIndex === -1) {
-    return pathname;
-  }
-
-  const commonString = pathname.slice(0, firstDifferentCharacterIndex + 1); // the first different char is at firstDifferentCharacterIndex
-
-  if (pathname.charAt(firstDifferentCharacterIndex) === "/") {
-    return commonString;
-  }
-
-  if (otherPathname.charAt(firstDifferentCharacterIndex) === "/") {
-    return commonString;
-  }
-
-  const firstDifferentSlashIndex = commonString.lastIndexOf("/");
-  return pathname.slice(0, firstDifferentSlashIndex + 1);
-};
-
-const findFirstDifferentCharacterIndex = (string, otherString) => {
-  const maxCommonLength = Math.min(string.length, otherString.length);
-  let i = 0;
-
-  while (i < maxCommonLength) {
-    const char = string.charAt(i);
-    const otherChar = otherString.charAt(i);
-
-    if (char !== otherChar) {
-      return i;
-    }
-
-    i++;
-  }
-
-  if (string.length === otherString.length) {
-    return -1;
-  } // they differ at maxCommonLength
-
-
-  return maxCommonLength;
-};
-
-const pathnameToParentPathname = pathname => {
-  const slashLastIndex = pathname.lastIndexOf("/");
-
-  if (slashLastIndex === -1) {
-    return "/";
-  }
-
-  return pathname.slice(0, slashLastIndex + 1);
-};
-
-const urlToRelativeUrl = (url, baseUrl) => {
-  const urlObject = new URL(url);
-  const baseUrlObject = new URL(baseUrl);
-
-  if (urlObject.protocol !== baseUrlObject.protocol) {
-    const urlAsString = String(url);
-    return urlAsString;
-  }
-
-  if (urlObject.username !== baseUrlObject.username || urlObject.password !== baseUrlObject.password || urlObject.host !== baseUrlObject.host) {
-    const afterUrlScheme = String(url).slice(urlObject.protocol.length);
-    return afterUrlScheme;
-  }
-
-  const {
-    pathname,
-    hash,
-    search
-  } = urlObject;
-
-  if (pathname === "/") {
-    const baseUrlRessourceWithoutLeadingSlash = baseUrlObject.pathname.slice(1);
-    return baseUrlRessourceWithoutLeadingSlash;
-  }
-
-  const basePathname = baseUrlObject.pathname;
-  const commonPathname = getCommonPathname(pathname, basePathname);
-
-  if (!commonPathname) {
-    const urlAsString = String(url);
-    return urlAsString;
-  }
-
-  const specificPathname = pathname.slice(commonPathname.length);
-  const baseSpecificPathname = basePathname.slice(commonPathname.length);
-
-  if (baseSpecificPathname.includes("/")) {
-    const baseSpecificParentPathname = pathnameToParentPathname(baseSpecificPathname);
-    const relativeDirectoriesNotation = baseSpecificParentPathname.replace(/.*?\//g, "../");
-    const relativeUrl = `${relativeDirectoriesNotation}${specificPathname}${search}${hash}`;
-    return relativeUrl;
-  }
-
-  const relativeUrl = `${specificPathname}${search}${hash}`;
-  return relativeUrl;
-};
-
-const comparePathnames = (leftPathame, rightPathname) => {
-  const leftPartArray = leftPathame.split("/");
-  const rightPartArray = rightPathname.split("/");
-  const leftLength = leftPartArray.length;
-  const rightLength = rightPartArray.length;
-  const maxLength = Math.max(leftLength, rightLength);
-  let i = 0;
-
-  while (i < maxLength) {
-    const leftPartExists = (i in leftPartArray);
-    const rightPartExists = (i in rightPartArray); // longer comes first
-
-    if (!leftPartExists) {
-      return +1;
-    }
-
-    if (!rightPartExists) {
-      return -1;
-    }
-
-    const leftPartIsLast = i === leftPartArray.length - 1;
-    const rightPartIsLast = i === rightPartArray.length - 1; // folder comes first
-
-    if (leftPartIsLast && !rightPartIsLast) {
-      return +1;
-    }
-
-    if (!leftPartIsLast && rightPartIsLast) {
-      return -1;
-    }
-
-    const leftPart = leftPartArray[i];
-    const rightPart = rightPartArray[i];
-    i++; // local comparison comes first
-
-    const comparison = leftPart.localeCompare(rightPart);
-
-    if (comparison !== 0) {
-      return comparison;
-    }
-  }
-
-  if (leftLength < rightLength) {
-    return +1;
-  }
-
-  if (leftLength > rightLength) {
-    return -1;
-  }
-
-  return 0;
-};
-
-const collectDirectoryMatchReport = async ({
-  cancellationToken = cancellation.createCancellationToken(),
-  directoryUrl,
-  structuredMetaMap,
-  predicate
-}) => {
-  const matchingArray = [];
-  const ignoredArray = [];
-  const rootDirectoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl);
-
-  if (typeof predicate !== "function") {
-    throw new TypeError(`predicate must be a function, got ${predicate}`);
-  }
-
-  const structuredMetaMapNormalized = urlMeta.normalizeStructuredMetaMap(structuredMetaMap, rootDirectoryUrl);
-
-  const visitDirectory = async directoryUrl => {
-    const directoryItems = await cancellation.createOperation({
-      cancellationToken,
-      start: () => readDirectory(directoryUrl)
-    });
-    await Promise.all(directoryItems.map(async directoryItem => {
-      const directoryChildNodeUrl = `${directoryUrl}${directoryItem}`;
-      const relativeUrl = urlToRelativeUrl(directoryChildNodeUrl, rootDirectoryUrl);
-      const directoryChildNodeStats = await cancellation.createOperation({
-        cancellationToken,
-        start: () => readFileSystemNodeStat(directoryChildNodeUrl, {
-          // we ignore symlink because recursively traversed
-          // so symlinked file will be discovered.
-          // Moreover if they lead outside of directoryPath it can become a problem
-          // like infinite recursion of whatever.
-          // that we could handle using an object of pathname already seen but it will be useless
-          // because directoryPath is recursively traversed
-          followLink: false
-        })
-      });
-
-      if (directoryChildNodeStats.isDirectory()) {
-        const subDirectoryUrl = `${directoryChildNodeUrl}/`;
-
-        if (!urlMeta.urlCanContainsMetaMatching({
-          url: subDirectoryUrl,
-          structuredMetaMap: structuredMetaMapNormalized,
-          predicate
-        })) {
-          ignoredArray.push({
-            relativeUrl: ensureUrlTrailingSlash(relativeUrl),
-            fileStats: directoryChildNodeStats
-          });
-          return;
-        }
-
-        await visitDirectory(subDirectoryUrl);
-        return;
-      }
-
-      if (directoryChildNodeStats.isFile()) {
-        const meta = urlMeta.urlToMeta({
-          url: directoryChildNodeUrl,
-          structuredMetaMap: structuredMetaMapNormalized
-        });
-
-        if (!predicate(meta)) {
-          ignoredArray.push({
-            relativeUrl,
-            meta,
-            fileStats: directoryChildNodeStats
-          });
-          return;
-        }
-
-        matchingArray.push({
-          relativeUrl,
-          meta,
-          fileStats: directoryChildNodeStats
-        });
-        return;
-      }
-    }));
-  };
-
-  await visitDirectory(rootDirectoryUrl);
-  return {
-    matchingArray: sortByRelativeUrl(matchingArray),
-    ignoredArray: sortByRelativeUrl(ignoredArray)
-  };
-};
-
-const sortByRelativeUrl = array => array.sort((left, right) => {
-  return comparePathnames(left.relativeUrl, right.relativeUrl);
-});
-
-const collectFiles = async ({
-  cancellationToken = cancellation.createCancellationToken(),
-  directoryUrl,
-  structuredMetaMap,
-  predicate,
-  matchingFileOperation = () => null
-}) => {
-  const rootDirectoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl);
-
-  if (typeof predicate !== "function") {
-    throw new TypeError(`predicate must be a function, got ${predicate}`);
-  }
-
-  if (typeof matchingFileOperation !== "function") {
-    throw new TypeError(`matchingFileOperation must be a function, got ${matchingFileOperation}`);
-  }
-
-  const structuredMetaMapNormalized = urlMeta.normalizeStructuredMetaMap(structuredMetaMap, rootDirectoryUrl);
-  const matchingFileResultArray = [];
-
-  const visitDirectory = async directoryUrl => {
-    const directoryItems = await cancellation.createOperation({
-      cancellationToken,
-      start: () => readDirectory(directoryUrl)
-    });
-    await Promise.all(directoryItems.map(async directoryItem => {
-      const directoryChildNodeUrl = `${directoryUrl}${directoryItem}`;
-      const directoryChildNodeStats = await cancellation.createOperation({
-        cancellationToken,
-        start: () => readFileSystemNodeStat(directoryChildNodeUrl, {
-          // we ignore symlink because recursively traversed
-          // so symlinked file will be discovered.
-          // Moreover if they lead outside of directoryPath it can become a problem
-          // like infinite recursion of whatever.
-          // that we could handle using an object of pathname already seen but it will be useless
-          // because directoryPath is recursively traversed
-          followLink: false
-        })
-      });
-
-      if (directoryChildNodeStats.isDirectory()) {
-        const subDirectoryUrl = `${directoryChildNodeUrl}/`;
-
-        if (!urlMeta.urlCanContainsMetaMatching({
-          url: subDirectoryUrl,
-          structuredMetaMap: structuredMetaMapNormalized,
-          predicate
-        })) {
-          return;
-        }
-
-        await visitDirectory(subDirectoryUrl);
-        return;
-      }
-
-      if (directoryChildNodeStats.isFile()) {
-        const meta = urlMeta.urlToMeta({
-          url: directoryChildNodeUrl,
-          structuredMetaMap: structuredMetaMapNormalized
-        });
-        if (!predicate(meta)) return;
-        const relativeUrl = urlToRelativeUrl(directoryChildNodeUrl, rootDirectoryUrl);
-        const operationResult = await cancellation.createOperation({
-          cancellationToken,
-          start: () => matchingFileOperation({
-            cancellationToken,
-            relativeUrl,
-            meta,
-            fileStats: directoryChildNodeStats
-          })
-        });
-        matchingFileResultArray.push({
-          url: new URL(relativeUrl, rootDirectoryUrl).href,
-          relativeUrl,
-          meta,
-          fileStats: directoryChildNodeStats,
-          operationResult
-        });
-        return;
-      }
-    }));
-  };
-
-  await visitDirectory(rootDirectoryUrl); // When we operate on thoose files later it feels more natural
-  // to perform operation in the same order they appear in the filesystem.
-  // It also allow to get a predictable return value.
-  // For that reason we sort matchingFileResultArray
-
-  matchingFileResultArray.sort((leftFile, rightFile) => {
-    return comparePathnames(leftFile.relativeUrl, rightFile.relativeUrl);
-  });
-  return matchingFileResultArray;
-};
-
-const {
-  mkdir
-} = fs.promises;
-const writeDirectory = async (destination, {
-  recursive = true,
-  allowUseless = false
-} = {}) => {
-  const destinationUrl = assertAndNormalizeDirectoryUrl(destination);
-  const destinationPath = urlToFileSystemPath(destinationUrl);
-  const destinationStats = await readFileSystemNodeStat(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 {
-    await mkdir(destinationPath, {
-      recursive
-    });
-  } catch (error) {
-    if (allowUseless && error.code === "EEXIST") {
-      return;
-    }
-
-    throw error;
-  }
-};
-
-const resolveUrl = (specifier, baseUrl) => {
-  if (typeof baseUrl === "undefined") {
-    throw new TypeError(`baseUrl missing to resolve ${specifier}`);
-  }
-
-  return String(new URL(specifier, baseUrl));
-};
-
-const removeFileSystemNode = async (source, {
-  allowUseless = false,
-  recursive = false,
-  maxRetries = 3,
-  retryDelay = 100,
-  onlyContent = false
-} = {}) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source);
-  const sourceStats = await readFileSystemNodeStat(sourceUrl, {
-    nullIfNotFound: true,
-    followLink: false
-  });
-
-  if (!sourceStats) {
-    if (allowUseless) {
-      return;
-    }
-
-    throw new Error(`nothing to remove at ${urlToFileSystemPath(sourceUrl)}`);
-  } // https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_class_fs_stats
-  // FIFO and socket are ignored, not sure what they are exactly and what to do with them
-  // other libraries ignore them, let's do the same.
-
-
-  if (sourceStats.isFile() || sourceStats.isSymbolicLink() || sourceStats.isCharacterDevice() || sourceStats.isBlockDevice()) {
-    await removeNonDirectory(sourceUrl.endsWith("/") ? sourceUrl.slice(0, -1) : sourceUrl, {
-      maxRetries,
-      retryDelay
-    });
-  } else if (sourceStats.isDirectory()) {
-    await removeDirectory(ensureUrlTrailingSlash(sourceUrl), {
-      recursive,
-      maxRetries,
-      retryDelay,
-      onlyContent
-    });
-  }
-};
-
-const removeNonDirectory = (sourceUrl, {
-  maxRetries,
-  retryDelay
-}) => {
-  const sourcePath = urlToFileSystemPath(sourceUrl);
-  let retryCount = 0;
-
-  const attempt = () => {
-    return unlinkNaive(sourcePath, { ...(retryCount >= maxRetries ? {} : {
-        handleTemporaryError: async () => {
-          retryCount++;
-          return new Promise(resolve => {
-            setTimeout(() => {
-              resolve(attempt());
-            }, retryCount * retryDelay);
-          });
-        }
-      })
-    });
-  };
-
-  return attempt();
-};
-
-const unlinkNaive = (sourcePath, {
-  handleTemporaryError = null
-} = {}) => {
-  return new Promise((resolve, reject) => {
-    node_fs.unlink(sourcePath, error => {
-      if (error) {
-        if (error.code === "ENOENT") {
-          resolve();
-        } else if (handleTemporaryError && (error.code === "EBUSY" || error.code === "EMFILE" || error.code === "ENFILE" || error.code === "ENOENT")) {
-          resolve(handleTemporaryError(error));
-        } else {
-          reject(error);
-        }
-      } else {
-        resolve();
-      }
-    });
-  });
-};
-
-const removeDirectory = async (rootDirectoryUrl, {
-  maxRetries,
-  retryDelay,
-  recursive,
-  onlyContent
-}) => {
-  const visit = async sourceUrl => {
-    const sourceStats = await readFileSystemNodeStat(sourceUrl, {
-      nullIfNotFound: true,
-      followLink: false
-    }); // file/directory not found
-
-    if (sourceStats === null) {
-      return;
-    }
-
-    if (sourceStats.isFile() || sourceStats.isCharacterDevice() || sourceStats.isBlockDevice()) {
-      await visitFile(sourceUrl);
-    } else if (sourceStats.isSymbolicLink()) {
-      await visitSymbolicLink(sourceUrl);
-    } else if (sourceStats.isDirectory()) {
-      await visitDirectory(`${sourceUrl}/`);
-    }
-  };
-
-  const visitDirectory = async directoryUrl => {
-    const directoryPath = urlToFileSystemPath(directoryUrl);
-    const optionsFromRecursive = recursive ? {
-      handleNotEmptyError: async () => {
-        await removeDirectoryContent(directoryUrl);
-        await visitDirectory(directoryUrl);
-      }
-    } : {};
-    await removeDirectoryNaive(directoryPath, { ...optionsFromRecursive,
-      // Workaround for https://github.com/joyent/node/issues/4337
-      ...(process.platform === "win32" ? {
-        handlePermissionError: async error => {
-          console.error(`trying to fix windows EPERM after readir on ${directoryPath}`);
-          let openOrCloseError;
-
-          try {
-            const fd = node_fs.openSync(directoryPath);
-            node_fs.closeSync(fd);
-          } catch (e) {
-            openOrCloseError = e;
-          }
-
-          if (openOrCloseError) {
-            if (openOrCloseError.code === "ENOENT") {
-              return;
-            }
-
-            console.error(`error while trying to fix windows EPERM after readir on ${directoryPath}: ${openOrCloseError.stack}`);
-            throw error;
-          }
-
-          await removeDirectoryNaive(directoryPath, { ...optionsFromRecursive
-          });
-        }
-      } : {})
-    });
-  };
-
-  const removeDirectoryContent = async directoryUrl => {
-    const names = await readDirectory(directoryUrl);
-    await Promise.all(names.map(async name => {
-      const url = resolveUrl(name, directoryUrl);
-      await visit(url);
-    }));
-  };
-
-  const visitFile = async fileUrl => {
-    await removeNonDirectory(fileUrl, {
-      maxRetries,
-      retryDelay
-    });
-  };
-
-  const visitSymbolicLink = async symbolicLinkUrl => {
-    await removeNonDirectory(symbolicLinkUrl, {
-      maxRetries,
-      retryDelay
-    });
-  };
-
-  if (onlyContent) {
-    await removeDirectoryContent(rootDirectoryUrl);
-  } else {
-    await visitDirectory(rootDirectoryUrl);
-  }
-};
-
-const removeDirectoryNaive = (directoryPath, {
-  handleNotEmptyError = null,
-  handlePermissionError = null
-} = {}) => {
-  return new Promise((resolve, reject) => {
-    node_fs.rmdir(directoryPath, (error, lstatObject) => {
-      if (error) {
-        if (handlePermissionError && error.code === "EPERM") {
-          resolve(handlePermissionError(error));
-        } else if (error.code === "ENOENT") {
-          resolve();
-        } else if (handleNotEmptyError && (error.code === "ENOTEMPTY" || // SunOS
-        error.code === "EEXIST")) {
-          resolve(handleNotEmptyError(error));
-        } else {
-          reject(error);
-        }
-      } else {
-        resolve(lstatObject);
-      }
-    });
-  });
-};
-
-const ensureEmptyDirectory = async source => {
-  const stats = await readFileSystemNodeStat(source, {
-    nullIfNotFound: true,
-    followLink: false
-  });
-
-  if (stats === null) {
-    // if there is nothing, create a directory
-    return writeDirectory(source, {
-      allowUseless: true
-    });
-  }
-
-  if (stats.isDirectory()) {
-    // if there is a directory remove its content and done
-    return removeFileSystemNode(source, {
-      allowUseless: true,
-      recursive: true,
-      onlyContent: true
-    });
-  }
-
-  const sourceType = statsToType(stats);
-  const sourcePath = urlToFileSystemPath(assertAndNormalizeFileUrl(source));
-  throw new Error(`ensureEmptyDirectory expect directory at ${sourcePath}, found ${sourceType} instead`);
-};
-
-const ensureParentDirectories = async destination => {
-  const destinationUrl = assertAndNormalizeFileUrl(destination);
-  const destinationPath = urlToFileSystemPath(destinationUrl);
-  const destinationParentPath = path.dirname(destinationPath);
-  return writeDirectory(destinationParentPath, {
-    recursive: true,
-    allowUseless: true
-  });
-};
-
-const isWindows$2 = process.platform === "win32";
-const baseUrlFallback = fileSystemPathToUrl(process.cwd());
-/**
- * Some url might be resolved or remapped to url without the windows drive letter.
- * For instance
- * new URL('/foo.js', 'file:///C:/dir/file.js')
- * resolves to
- * 'file:///foo.js'
- *
- * But on windows it becomes a problem because we need the drive letter otherwise
- * url cannot be converted to a filesystem path.
- *
- * ensureWindowsDriveLetter ensure a resolved url still contains the drive letter.
- */
-
-const ensureWindowsDriveLetter = (url, baseUrl) => {
-  try {
-    url = String(new URL(url));
-  } catch (e) {
-    throw new Error(`absolute url expected but got ${url}`);
-  }
-
-  if (!isWindows$2) {
-    return url;
-  }
-
-  try {
-    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;
-  }
-
-  const afterProtocol = url.slice("file://".length); // we still have the windows drive letter
-
-  if (extractDriveLetter(afterProtocol)) {
-    return url;
-  } // drive letter was lost, restore it
-
-
-  const baseUrlOrFallback = baseUrl.startsWith("file://") ? baseUrl : 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}`;
-};
-
-const extractDriveLetter = ressource => {
-  // we still have the windows drive letter
-  if (/[a-zA-Z]/.test(ressource[1]) && ressource[2] === ":") {
-    return ressource[1];
-  }
-
-  return null;
-};
-
-const urlTargetsSameFileSystemPath = (leftUrl, rightUrl) => {
-  if (leftUrl.endsWith("/")) leftUrl = leftUrl.slice(0, -1);
-  if (rightUrl.endsWith("/")) rightUrl = rightUrl.slice(0, -1);
-  return leftUrl === rightUrl;
-};
-
-const writeFileSystemNodeModificationTime = (source, mtime) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source);
-  const sourcePath = urlToFileSystemPath(sourceUrl);
-  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;
-  return new Promise((resolve, reject) => {
-    fs.utimes(sourcePath, atimeValue, mtimeValue, error => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve();
-      }
-    });
-  });
-};
-
-const replaceBackSlashesWithSlashes = string => string.replace(/\\/g, "/");
-
-/*
- * - symlink documentation on Node.js:
- *   https://nodejs.org/docs/latest-v13.x/api/fs.html#fs_fs_symlink_target_path_type_callback
- */
-const readSymbolicLink = url => {
-  const symbolicLinkUrl = assertAndNormalizeFileUrl(url);
-  const symbolicLinkPath = urlToFileSystemPath(symbolicLinkUrl);
-  return new Promise((resolve, reject) => {
-    node_fs.readlink(symbolicLinkPath, (error, resolvedPath) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve(isFileSystemPath(resolvedPath) ? fileSystemPathToUrl(resolvedPath) : replaceBackSlashesWithSlashes(resolvedPath));
-      }
-    });
-  });
-};
-
-const {
-  symlink
-} = node_fs.promises;
-const isWindows$1 = process.platform === "win32";
-/**
- * Writes a symbolic link pointing from a filesystem node to an other
- * @param {string} from Where symlink is written
- * @param {string} to The symlink target
- * @param {"file" | "dir"} [type] Symlink type if you know it before hand
- * @param {boolean} [allowUseless=false] Prevent error when symlink already exists with the same target
- * @param {boolean} [allowOverwrite=false] Will replace any existing symlink
- */
-
-const writeSymbolicLink = async ({
-  from,
-  to,
-  type,
-  allowUseless = false,
-  allowOverwrite = false
-}) => {
-  const fromUrl = assertAndNormalizeFileUrl(from);
-  const toInfo = getToInfo(to, fromUrl);
-
-  if (isWindows$1 && typeof type === "undefined") {
-    // without this if you write a symbolic link without specifying the type on windows
-    // you later get EPERM when doing stat on the symlink
-    const toStats = await readFileSystemNodeStat(toInfo.url, {
-      nullIfNotFound: true
-    });
-    type = toStats && toStats.isDirectory() ? "dir" : "file";
-  }
-
-  const symbolicLinkPath = urlToFileSystemPath(fromUrl);
-
-  try {
-    await symlink(toInfo.value, symbolicLinkPath, type);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      await ensureParentDirectories(fromUrl);
-      await symlink(toInfo.value, symbolicLinkPath, type);
-      return;
-    }
-
-    if (error.code === "EEXIST") {
-      if (allowUseless) {
-        const existingSymbolicLinkUrl = await readSymbolicLink(fromUrl);
-
-        if (existingSymbolicLinkUrl === toInfo.url) {
-          return;
-        }
-      }
-
-      if (allowOverwrite) {
-        await removeFileSystemNode(fromUrl);
-        await symlink(toInfo.value, symbolicLinkPath, type);
-        return;
-      }
-    }
-
-    throw error;
-  }
-};
-
-const getToInfo = (to, fromUrl) => {
-  if (typeof to === "string") {
-    // absolute filesystem path
-    if (isFileSystemPath(to)) {
-      const url = fileSystemPathToUrl(to);
-      const value = to;
-      return {
-        url,
-        value
-      };
-    } // relative url
-
-
-    if (to.startsWith("./") || to.startsWith("../")) {
-      const url = resolveUrl(to, fromUrl);
-      const value = to;
-      return {
-        url,
-        value
-      };
-    } // absolute url
-
-
-    const url = resolveUrl(to, fromUrl);
-    const value = urlToFileSystemPath(url);
-    return {
-      url,
-      value
-    };
-  }
-
-  if (to instanceof URL) {
-    const url = String(to);
-    const value = urlToFileSystemPath(url);
-    return {
-      url,
-      value
-    };
-  }
-
-  throw new TypeError(`symbolic link to must be a string or an url, received ${to}`);
-};
-
-const urlIsInsideOf = (url, otherUrl) => {
-  const urlObject = new URL(url);
-  const otherUrlObject = new URL(otherUrl);
-
-  if (urlObject.origin !== otherUrlObject.origin) {
-    return false;
-  }
-
-  const urlPathname = urlObject.pathname;
-  const otherUrlPathname = otherUrlObject.pathname;
-
-  if (urlPathname === otherUrlPathname) {
-    return false;
-  }
-
-  const isInside = urlPathname.startsWith(otherUrlPathname);
-  return isInside;
-};
-
-/* eslint-disable import/max-dependencies */
-const copyFileSystemNode = async ({
-  from,
-  to,
-  overwrite = false,
-  preserveStat = true,
-  preserveMtime = preserveStat,
-  preservePermissions = preserveStat,
-  allowUseless = false,
-  followLink = true
-}) => {
-  const fromUrl = assertAndNormalizeFileUrl(from);
-  const fromPath = urlToFileSystemPath(fromUrl);
-  let toUrl = assertAndNormalizeFileUrl(to);
-  let toPath = urlToFileSystemPath(toUrl);
-  const sourceStats = await readFileSystemNodeStat(fromUrl, {
-    nullIfNotFound: true,
-    followLink: false
-  });
-
-  if (!sourceStats) {
-    throw new Error(`nothing to copy at ${fromPath}`);
-  }
-
-  let destinationStats = await readFileSystemNodeStat(toUrl, {
-    nullIfNotFound: true,
-    // 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);
-    destinationStats = await readFileSystemNodeStat(toUrl, {
-      nullIfNotFound: true
-    });
-  }
-
-  if (urlTargetsSameFileSystemPath(fromUrl, toUrl)) {
-    if (allowUseless) {
-      return;
-    }
-
-    throw new Error(`cannot copy ${fromPath} because destination and source are the same`);
-  }
-
-  if (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...
-
-
-    await removeFileSystemNode(toUrl, {
-      recursive: true,
-      allowUseless: true
-    });
-  } else {
-    await ensureParentDirectories(toUrl);
-  }
-
-  if (sourceStats.isDirectory()) {
-    toUrl = ensureUrlTrailingSlash(toUrl);
-  }
-
-  const visit = async (url, stats) => {
-    if (stats.isFile() || stats.isCharacterDevice() || stats.isBlockDevice()) {
-      await visitFile(url, stats);
-    } else if (stats.isSymbolicLink()) {
-      await visitSymbolicLink(url);
-    } else if (stats.isDirectory()) {
-      await visitDirectory(ensureUrlTrailingSlash(url), stats);
-    }
-  };
-
-  const visitFile = async (fileUrl, fileStats) => {
-    const fileRelativeUrl = urlToRelativeUrl(fileUrl, fromUrl);
-    const fileCopyUrl = resolveUrl(fileRelativeUrl, toUrl);
-    await copyFileContentNaive(urlToFileSystemPath(fileUrl), urlToFileSystemPath(fileCopyUrl));
-    await copyStats(fileCopyUrl, fileStats);
-  };
-
-  const visitSymbolicLink = async symbolicLinkUrl => {
-    const symbolicLinkRelativeUrl = urlToRelativeUrl(symbolicLinkUrl, fromUrl);
-    const symbolicLinkTarget = await readSymbolicLink(symbolicLinkUrl);
-    const symbolicLinkTargetUrl = resolveUrl(symbolicLinkTarget, symbolicLinkUrl);
-    const linkIsRelative = symbolicLinkTarget.startsWith("./") || symbolicLinkTarget.startsWith("../");
-    let symbolicLinkCopyTarget;
-
-    if (symbolicLinkTargetUrl === fromUrl) {
-      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);
-    } else {
-      // symbolic link targets something outside the directory we want to copy
-      symbolicLinkCopyTarget = symbolicLinkTarget;
-    } // we must guess ourself the type of the symlink
-    // because the destination might not exists because not yet copied
-    // https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_fs_symlink_target_path_type_callback
-
-
-    const targetStats = await readFileSystemNodeStat(symbolicLinkTargetUrl, {
-      nullIfNotFound: true,
-      followLink: false
-    });
-    const linkType = targetStats && targetStats.isDirectory() ? "dir" : "file";
-    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;
-
-      if (preservePermissions) {
-        await writeFileSystemNodePermissions(toUrl, binaryFlagsToPermissions(mode));
-      }
-
-      if (preserveMtime) {
-        await writeFileSystemNodeModificationTime(toUrl, mtimeMs);
-      }
-    }
-  };
-
-  const visitDirectory = async (directoryUrl, directoryStats) => {
-    const directoryRelativeUrl = urlToRelativeUrl(directoryUrl, fromUrl);
-    const directoryCopyUrl = resolveUrl(directoryRelativeUrl, toUrl);
-    await writeDirectory(directoryCopyUrl);
-    await copyDirectoryContent(directoryUrl);
-    await copyStats(directoryCopyUrl, directoryStats);
-  };
-
-  const copyDirectoryContent = async directoryUrl => {
-    const names = await readDirectory(directoryUrl);
-    await Promise.all(names.map(async name => {
-      const fileSystemNodeUrl = resolveUrl(name, directoryUrl);
-      const stats = await readFileSystemNodeStat(fileSystemNodeUrl, {
-        followLink: false
-      });
-      await visit(fileSystemNodeUrl, stats);
-    }));
-  };
-
-  await visit(fromUrl, sourceStats);
-};
-
-const copyFileContentNaive = (filePath, fileDestinationPath) => {
-  return new Promise((resolve, reject) => {
-    node_fs.copyFile(filePath, fileDestinationPath, error => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve();
-      }
-    });
-  });
-};
-
-const copyDirectoryContent = async ({
-  from,
-  to,
-  overwrite,
-  followLink = true
-} = {}) => {
-  const fromUrl = assertAndNormalizeDirectoryUrl(from);
-  const fromPath = urlToFileSystemPath(fromUrl);
-  let toUrl = assertAndNormalizeDirectoryUrl(to);
-  let toPath = urlToFileSystemPath(toUrl);
-  const sourceStats = await readFileSystemNodeStat(fromUrl, {
-    nullIfNotFound: true,
-    followLink: false
-  });
-
-  if (!sourceStats) {
-    throw new Error(`no directory to copy content from at ${fromPath}`);
-  }
-
-  if (!sourceStats.isDirectory()) {
-    const sourceType = statsToType(sourceStats);
-    throw new Error(`found a ${sourceType} instead of a directory at ${fromPath}`);
-  }
-
-  let destinationStats = await readFileSystemNodeStat(toUrl, {
-    nullIfNotFound: true,
-    // 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);
-    destinationStats = await readFileSystemNodeStat(toUrl, {
-      nullIfNotFound: true
-    });
-  }
-
-  if (destinationStats === null) {
-    throw new Error(`no directory to copy content into at ${toPath}`);
-  }
-
-  if (!destinationStats.isDirectory()) {
-    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 directoryEntries = await readDirectory(fromUrl);
-  await Promise.all(directoryEntries.map(async directoryEntry => {
-    const from = resolveUrl(directoryEntry, fromUrl);
-    const to = resolveUrl(directoryEntry, toUrl);
-    await copyFileSystemNode({
-      from,
-      to,
-      overwrite,
-      followLink
-    });
-  }));
-};
-
-/*
- * - file modes documentation on Node.js
- *   https://nodejs.org/docs/latest-v13.x/api/fs.html#fs_file_modes
- */
-const {
-  stat
-} = node_fs.promises;
-const readFileSystemNodePermissions = async source => {
-  const sourceUrl = assertAndNormalizeFileUrl(source);
-  const sourcePath = urlToFileSystemPath(sourceUrl);
-  const {
-    mode
-  } = await stat(sourcePath);
-  return binaryFlagsToPermissions(mode);
-};
-
-const grantPermissionsOnFileSystemNode = async (source, {
-  read = false,
-  write = false,
-  execute = false
-}) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source);
-  const filePermissions = await readFileSystemNodePermissions(sourceUrl);
-  await writeFileSystemNodePermissions(sourceUrl, {
-    owner: {
-      read,
-      write,
-      execute
-    },
-    group: {
-      read,
-      write,
-      execute
-    },
-    others: {
-      read,
-      write,
-      execute
-    }
-  });
-  return async () => {
-    await writeFileSystemNodePermissions(sourceUrl, filePermissions);
-  };
-};
-
-const listFilesMatching = async (patterns, directoryUrl = process.cwd()) => {
-  if (typeof patterns === "string") {
-    patterns = [patterns];
-  } else if (Array.isArray(patterns)) {
-    throw new TypeError(`patterns must be a string or an array of strings, got ${patterns}`);
-  }
-
-  const patternMap = {};
-  patterns.forEach((pattern, index) => {
-    if (typeof pattern !== "string") {
-      throw new TypeError(`every pattern must be a string, found ${pattern} at index ${index}`);
-    }
-
-    patternMap[pattern] = true;
-  });
-  const fileDatas = await collectFiles({
-    directoryUrl,
-    structuredMetaMap: {
-      matches: patternMap
-    },
-    predicate: ({
-      matches
-    }) => matches
-  });
-  return fileDatas.map(({
-    url
-  }) => url);
-};
-
-const memoize = compute => {
-  let memoized = false;
-  let memoizedValue;
-
-  const fnWithMemoization = (...args) => {
-    if (memoized) {
-      return memoizedValue;
-    } // if compute is recursive wait for it to be fully done before storing the value
-    // so set memoized boolean after the call
-
-
-    memoizedValue = compute(...args);
-    memoized = true;
-    return memoizedValue;
-  };
-
-  fnWithMemoization.forget = () => {
-    const value = memoizedValue;
-    memoized = false;
-    memoizedValue = undefined;
-    return value;
-  };
-
-  return fnWithMemoization;
-};
-
-/* eslint-disable import/max-dependencies */
-const moveFileSystemNode = async ({
-  from,
-  to,
-  overwrite = false,
-  allowUseless = false,
-  followLink = true
-}) => {
-  const fromUrl = assertAndNormalizeFileUrl(from);
-  const fromPath = urlToFileSystemPath(fromUrl);
-  let toUrl = assertAndNormalizeFileUrl(to);
-  let toPath = urlToFileSystemPath(toUrl);
-  const sourceStats = await readFileSystemNodeStat(fromUrl, {
-    nullIfNotFound: true,
-    followLink: false
-  });
-
-  if (!sourceStats) {
-    throw new Error(`nothing to move from ${fromPath}`);
-  }
-
-  let destinationStats = await readFileSystemNodeStat(toUrl, {
-    nullIfNotFound: true,
-    // 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);
-    destinationStats = await readFileSystemNodeStat(toUrl, {
-      nullIfNotFound: true
-    });
-  }
-
-  if (urlTargetsSameFileSystemPath(fromUrl, toUrl)) {
-    if (allowUseless) {
-      return;
-    }
-
-    throw new Error(`no move needed for ${fromPath} because destination and source are the same`);
-  }
-
-  if (destinationStats) {
-    const sourceType = statsToType(sourceStats);
-    const destinationType = statsToType(destinationStats);
-
-    if (sourceType !== destinationType) {
-      throw new Error(`cannot move ${sourceType} from ${fromPath} to ${toPath} because destination exists and is not a ${sourceType} (it's a ${destinationType})`);
-    }
-
-    if (!overwrite) {
-      throw new Error(`cannot move ${sourceType} from ${fromPath} to ${toPath} because destination exists and overwrite option is disabled`);
-    } // remove file, link, directory...
-
-
-    await removeFileSystemNode(toUrl, {
-      recursive: true
-    });
-  } else {
-    await ensureParentDirectories(toUrl);
-  }
-
-  await moveNaive(fromPath, toPath, {
-    handleCrossDeviceError: async () => {
-      await copyFileSystemNode({
-        from: fromUrl,
-        to: toUrl,
-        preserveStat: true
-      });
-      await removeFileSystemNode(fromUrl, {
-        recursive: true
-      });
-    }
-  });
-};
-
-const moveNaive = (fromPath, destinationPath, {
-  handleCrossDeviceError = null
-} = {}) => {
-  return new Promise((resolve, reject) => {
-    node_fs.rename(fromPath, destinationPath, error => {
-      if (error) {
-        if (handleCrossDeviceError && error.code === "EXDEV") {
-          resolve(handleCrossDeviceError(error));
-        } else {
-          reject(error);
-        }
-      } else {
-        resolve();
-      }
-    });
-  });
-};
-
-const moveDirectoryContent = async ({
-  from,
-  to,
-  overwrite,
-  followLink = true
-} = {}) => {
-  const fromUrl = assertAndNormalizeDirectoryUrl(from);
-  const fromPath = urlToFileSystemPath(fromUrl);
-  let toUrl = assertAndNormalizeDirectoryUrl(to);
-  let toPath = urlToFileSystemPath(toUrl);
-  const sourceStats = await readFileSystemNodeStat(fromUrl, {
-    nullIfNotFound: true,
-    followLink: false
-  });
-
-  if (!sourceStats) {
-    throw new Error(`no directory to move content from at ${fromPath}`);
-  }
-
-  if (!sourceStats.isDirectory()) {
-    const sourceType = statsToType(sourceStats);
-    throw new Error(`found a ${sourceType} instead of a directory at ${fromPath}`);
-  }
-
-  let destinationStats = await readFileSystemNodeStat(toUrl, {
-    nullIfNotFound: true,
-    // 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);
-    destinationStats = await readFileSystemNodeStat(toUrl, {
-      nullIfNotFound: true
-    });
-  }
-
-  if (destinationStats === null) {
-    throw new Error(`no directory to move content into at ${toPath}`);
-  }
-
-  if (!destinationStats.isDirectory()) {
-    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 move directory content, source and destination are the same (${fromPath})`);
-  }
-
-  const directoryEntries = await readDirectory(fromUrl);
-  await Promise.all(directoryEntries.map(async directoryEntry => {
-    const from = resolveUrl(directoryEntry, fromUrl);
-    const to = resolveUrl(directoryEntry, toUrl);
-    await moveFileSystemNode({
-      from,
-      to,
-      overwrite,
-      followLink
-    });
-  }));
-};
-
-const readFilePromisified = util.promisify(fs.readFile);
-const readFile = async (value, {
-  as = "string"
-} = {}) => {
-  const fileUrl = assertAndNormalizeFileUrl(value);
-  const filePath = urlToFileSystemPath(fileUrl);
-  const buffer = await readFilePromisified(filePath);
-
-  if (as === "buffer") {
-    return buffer;
-  }
-
-  if (as === "string") {
-    return buffer.toString();
-  }
-
-  if (as === "json") {
-    return JSON.parse(buffer.toString());
-  }
-
-  throw new Error(`as must be one of buffer,string,json, received ${as}.`);
-};
-
-const readFileSystemNodeModificationTime = async source => {
-  const stats = await readFileSystemNodeStat(source);
-  return Math.floor(stats.mtimeMs);
-};
-
-const fileSystemNodeToTypeOrNull = url => {
-  const path = urlToFileSystemPath(url);
-
-  try {
-    const stats = fs.statSync(path);
-    return statsToType(stats);
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      return null;
-    }
-
-    throw e;
-  }
-};
-
-const isWindows = process.platform === "win32";
-const createWatcher = (sourcePath, options) => {
-  const watcher = fs.watch(sourcePath, options);
-
-  if (isWindows) {
-    watcher.on("error", async error => {
-      // https://github.com/joyent/node/issues/4337
-      if (error.code === "EPERM") {
-        try {
-          const fd = fs.openSync(sourcePath, "r");
-          fs.closeSync(fd);
-        } catch (e) {
-          if (e.code === "ENOENT") {
-            return;
-          }
-
-          console.error(`error while fixing windows eperm: ${e.stack}`);
-          throw error;
-        }
-      } else {
-        throw error;
-      }
-    });
-  }
-
-  return watcher;
-};
-
-const trackRessources = () => {
-  const callbackArray = [];
-
-  const registerCleanupCallback = callback => {
-    if (typeof callback !== "function") throw new TypeError(`callback must be a function
-callback: ${callback}`);
-    callbackArray.push(callback);
-    return () => {
-      const index = callbackArray.indexOf(callback);
-      if (index > -1) callbackArray.splice(index, 1);
-    };
-  };
-
-  const cleanup = async reason => {
-    const localCallbackArray = callbackArray.slice();
-    await Promise.all(localCallbackArray.map(callback => callback(reason)));
-  };
-
-  return {
-    registerCleanupCallback,
-    cleanup
-  };
-};
-
-/* eslint-disable import/max-dependencies */
-const isLinux = process.platform === "linux"; // linux does not support recursive option
-
-const fsWatchSupportsRecursive = !isLinux;
-const registerDirectoryLifecycle = (source, {
-  added,
-  updated,
-  removed,
-  watchDescription = {
-    "./**/*": true
-  },
-  notifyExistent = false,
-  keepProcessAlive = true,
-  recursive = false
-}) => {
-  const sourceUrl = ensureUrlTrailingSlash(assertAndNormalizeFileUrl(source));
-
-  if (!undefinedOrFunction$1(added)) {
-    throw new TypeError(`added must be a function or undefined, got ${added}`);
-  }
-
-  if (!undefinedOrFunction$1(updated)) {
-    throw new TypeError(`updated must be a function or undefined, got ${updated}`);
-  }
-
-  if (!undefinedOrFunction$1(removed)) {
-    throw new TypeError(`removed must be a function or undefined, got ${removed}`);
-  }
-
-  const structuredMetaMap = urlMeta.normalizeStructuredMetaMap({
-    watch: watchDescription
-  }, sourceUrl);
-
-  const entryShouldBeWatched = ({
-    relativeUrl,
-    type
-  }) => {
-    const entryUrl = resolveUrl(relativeUrl, sourceUrl);
-
-    if (type === "directory") {
-      const canContainEntryToWatch = urlMeta.urlCanContainsMetaMatching({
-        url: `${entryUrl}/`,
-        structuredMetaMap,
-        predicate: ({
-          watch
-        }) => watch
-      });
-      return canContainEntryToWatch;
-    }
-
-    const entryMeta = urlMeta.urlToMeta({
-      url: entryUrl,
-      structuredMetaMap
-    });
-    return entryMeta.watch;
-  };
-
-  const tracker = trackRessources();
-  const contentMap = new Map();
-
-  const handleDirectoryEvent = ({
-    directoryRelativeUrl,
-    filename,
-    eventType
-  }) => {
-    if (filename) {
-      if (directoryRelativeUrl) {
-        handleChange(`${directoryRelativeUrl}/${filename}`);
-      } else {
-        handleChange(`${filename}`);
-      }
-    } else if ((removed || added) && eventType === "rename") {
-      // we might receive `rename` without filename
-      // in that case we try to find ourselves which file was removed.
-      let relativeUrlCandidateArray = Array.from(contentMap.keys());
-
-      if (recursive && !fsWatchSupportsRecursive) {
-        relativeUrlCandidateArray = relativeUrlCandidateArray.filter(relativeUrlCandidate => {
-          if (!directoryRelativeUrl) {
-            // ensure entry is top level
-            if (relativeUrlCandidate.includes("/")) return false;
-            return true;
-          } // entry not inside this directory
-
-
-          if (!relativeUrlCandidate.startsWith(directoryRelativeUrl)) return false;
-          const afterDirectory = relativeUrlCandidate.slice(directoryRelativeUrl.length + 1); // deep inside this directory
-
-          if (afterDirectory.includes("/")) return false;
-          return true;
-        });
-      }
-
-      const removedEntryRelativeUrl = relativeUrlCandidateArray.find(relativeUrlCandidate => {
-        const entryUrl = resolveUrl(relativeUrlCandidate, sourceUrl);
-        const type = fileSystemNodeToTypeOrNull(entryUrl);
-        return type === null;
-      });
-
-      if (removedEntryRelativeUrl) {
-        handleEntryLost({
-          relativeUrl: removedEntryRelativeUrl,
-          type: contentMap.get(removedEntryRelativeUrl)
-        });
-      }
-    }
-  };
-
-  const handleChange = relativeUrl => {
-    const entryUrl = resolveUrl(relativeUrl, sourceUrl);
-    const previousType = contentMap.get(relativeUrl);
-    const type = fileSystemNodeToTypeOrNull(entryUrl);
-
-    if (!entryShouldBeWatched({
-      relativeUrl,
-      type
-    })) {
-      return;
-    } // it's something new
-
-
-    if (!previousType) {
-      if (type !== null) {
-        handleEntryFound({
-          relativeUrl,
-          type,
-          existent: false
-        });
-      }
-
-      return;
-    } // it existed but now it's not here anymore
-
-
-    if (type === null) {
-      handleEntryLost({
-        relativeUrl,
-        type: previousType
-      });
-      return;
-    } // it existed and was replaced by something else
-    // we don't handle this as an update. We rather say the ressource
-    // is lost and something else is found (call removed() then added())
-
-
-    if (previousType !== type) {
-      handleEntryLost({
-        relativeUrl,
-        type: previousType
-      });
-      handleEntryFound({
-        relativeUrl,
-        type
-      });
-      return;
-    } // a directory cannot really be updated in way that matters for us
-    // filesystem is trying to tell us the directory content have changed
-    // but we don't care about that
-    // we'll already be notified about what has changed
-
-
-    if (type === "directory") {
-      return;
-    } // something has changed at this relativeUrl (the file existed and was not deleted)
-    // it's possible to get there and there is no real update
-    // (file content is the same and file mtime is the same).
-    // In short filesystem is sometimes "lying"
-    // Not trying to guard against that because:
-    // - hurt perfs a lot
-    // - it happens very rarely
-    // - it's not really a concern in practice
-    // - filesystem did not send an event out of nowhere:
-    // something occured but we don't know what with the information we have.
-
-
-    if (updated) {
-      updated({
-        relativeUrl,
-        type
-      });
-    }
-  };
-
-  const handleEntryFound = ({
-    relativeUrl,
-    type,
-    existent
-  }) => {
-    if (!entryShouldBeWatched({
-      relativeUrl,
-      type
-    })) {
-      return;
-    }
-
-    contentMap.set(relativeUrl, type);
-    const entryUrl = resolveUrl(relativeUrl, sourceUrl);
-
-    if (type === "directory") {
-      visitDirectory({
-        directoryUrl: `${entryUrl}/`,
-        entryFound: entry => {
-          handleEntryFound({
-            relativeUrl: `${relativeUrl}/${entry.relativeUrl}`,
-            type: entry.type,
-            existent
-          });
-        }
-      });
-    }
-
-    if (added) {
-      if (existent) {
-        if (notifyExistent) {
-          added({
-            relativeUrl,
-            type,
-            existent: true
-          });
-        }
-      } else {
-        added({
-          relativeUrl,
-          type
-        });
-      }
-    } // we must watch manually every directory we find
-
-
-    if (!fsWatchSupportsRecursive && type === "directory") {
-      const watcher = createWatcher(urlToFileSystemPath(entryUrl), {
-        persistent: keepProcessAlive
-      });
-      tracker.registerCleanupCallback(() => {
-        watcher.close();
-      });
-      watcher.on("change", (eventType, filename) => {
-        handleDirectoryEvent({
-          directoryRelativeUrl: relativeUrl,
-          filename: filename ? replaceBackSlashesWithSlashes(filename) : "",
-          eventType
-        });
-      });
-    }
-  };
-
-  const handleEntryLost = ({
-    relativeUrl,
-    type
-  }) => {
-    contentMap.delete(relativeUrl);
-
-    if (removed) {
-      removed({
-        relativeUrl,
-        type
-      });
-    }
-  };
-
-  visitDirectory({
-    directoryUrl: sourceUrl,
-    entryFound: ({
-      relativeUrl,
-      type
-    }) => {
-      handleEntryFound({
-        relativeUrl,
-        type,
-        existent: true
-      });
-    }
-  });
-  const watcher = createWatcher(urlToFileSystemPath(sourceUrl), {
-    recursive: recursive && fsWatchSupportsRecursive,
-    persistent: keepProcessAlive
-  });
-  tracker.registerCleanupCallback(() => {
-    watcher.close();
-  });
-  watcher.on("change", (eventType, fileSystemPath) => {
-    handleDirectoryEvent({ ...fileSystemPathToDirectoryRelativeUrlAndFilename(fileSystemPath),
-      eventType
-    });
-  });
-  return tracker.cleanup;
-};
-
-const undefinedOrFunction$1 = value => typeof value === "undefined" || typeof value === "function";
-
-const visitDirectory = ({
-  directoryUrl,
-  entryFound
-}) => {
-  const directoryPath = urlToFileSystemPath(directoryUrl);
-  fs.readdirSync(directoryPath).forEach(entry => {
-    const entryUrl = resolveUrl(entry, directoryUrl);
-    const type = fileSystemNodeToTypeOrNull(entryUrl);
-
-    if (type === null) {
-      return;
-    }
-
-    const relativeUrl = urlToRelativeUrl(entryUrl, directoryUrl);
-    entryFound({
-      relativeUrl,
-      type
-    });
-  });
-};
-
-const fileSystemPathToDirectoryRelativeUrlAndFilename = path => {
-  if (!path) {
-    return {
-      directoryRelativeUrl: "",
-      filename: ""
-    };
-  }
-
-  const normalizedPath = replaceBackSlashesWithSlashes(path);
-  const slashLastIndex = normalizedPath.lastIndexOf("/");
-
-  if (slashLastIndex === -1) {
-    return {
-      directoryRelativeUrl: "",
-      filename: normalizedPath
-    };
-  }
-
-  const directoryRelativeUrl = normalizedPath.slice(0, slashLastIndex);
-  const filename = normalizedPath.slice(slashLastIndex + 1);
-  return {
-    directoryRelativeUrl,
-    filename
-  };
-};
-
-const registerFileLifecycle = (source, {
-  added,
-  updated,
-  removed,
-  notifyExistent = false,
-  keepProcessAlive = true
-}) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source);
-
-  if (!undefinedOrFunction(added)) {
-    throw new TypeError(`added must be a function or undefined, got ${added}`);
-  }
-
-  if (!undefinedOrFunction(updated)) {
-    throw new TypeError(`updated must be a function or undefined, got ${updated}`);
-  }
-
-  if (!undefinedOrFunction(removed)) {
-    throw new TypeError(`removed must be a function or undefined, got ${removed}`);
-  }
-
-  const tracker = trackRessources();
-
-  const handleFileFound = ({
-    existent
-  }) => {
-    const fileMutationStopWatching = watchFileMutation(sourceUrl, {
-      updated,
-      removed: () => {
-        fileMutationStopTracking();
-        watchFileAdded();
-
-        if (removed) {
-          removed();
-        }
-      },
-      keepProcessAlive
-    });
-    const fileMutationStopTracking = tracker.registerCleanupCallback(fileMutationStopWatching);
-
-    if (added) {
-      if (existent) {
-        if (notifyExistent) {
-          added({
-            existent: true
-          });
-        }
-      } else {
-        added({});
-      }
-    }
-  };
-
-  const watchFileAdded = () => {
-    const fileCreationStopWatching = watchFileCreation(sourceUrl, () => {
-      fileCreationgStopTracking();
-      handleFileFound({
-        existent: false
-      });
-    }, keepProcessAlive);
-    const fileCreationgStopTracking = tracker.registerCleanupCallback(fileCreationStopWatching);
-  };
-
-  const sourceType = fileSystemNodeToTypeOrNull(sourceUrl);
-
-  if (sourceType === null) {
-    if (added) {
-      watchFileAdded();
-    } else {
-      throw new Error(`${urlToFileSystemPath(sourceUrl)} must lead to a file, found nothing`);
-    }
-  } else if (sourceType === "file") {
-    handleFileFound({
-      existent: true
-    });
-  } else {
-    throw new Error(`${urlToFileSystemPath(sourceUrl)} must lead to a file, type found instead`);
-  }
-
-  return tracker.cleanup;
-};
-
-const undefinedOrFunction = value => typeof value === "undefined" || typeof value === "function";
-
-const watchFileCreation = (source, callback, keepProcessAlive) => {
-  const sourcePath = urlToFileSystemPath(source);
-  const sourceFilename = path.basename(sourcePath);
-  const directoryPath = path.dirname(sourcePath);
-  let directoryWatcher = createWatcher(directoryPath, {
-    persistent: keepProcessAlive
-  });
-  directoryWatcher.on("change", (eventType, filename) => {
-    if (filename && filename !== sourceFilename) return;
-    const type = fileSystemNodeToTypeOrNull(source); // ignore if something else with that name gets created
-    // we are only interested into files
-
-    if (type !== "file") return;
-    directoryWatcher.close();
-    directoryWatcher = undefined;
-    callback();
-  });
-  return () => {
-    if (directoryWatcher) {
-      directoryWatcher.close();
-    }
-  };
-};
-
-const watchFileMutation = (sourceUrl, {
-  updated,
-  removed,
-  keepProcessAlive
-}) => {
-  let watcher = createWatcher(urlToFileSystemPath(sourceUrl), {
-    persistent: keepProcessAlive
-  });
-  watcher.on("change", () => {
-    const sourceType = fileSystemNodeToTypeOrNull(sourceUrl);
-
-    if (sourceType === null) {
-      watcher.close();
-      watcher = undefined;
-
-      if (removed) {
-        removed();
-      }
-    } else if (sourceType === "file") {
-      if (updated) {
-        updated();
-      }
-    }
-  });
-  return () => {
-    if (watcher) {
-      watcher.close();
-    }
-  };
-};
-
-const resolveDirectoryUrl = (specifier, baseUrl) => {
-  const url = resolveUrl(specifier, baseUrl);
-  return ensureUrlTrailingSlash(url);
-};
-
-const {
-  access
-} = fs.promises;
-const {
-  // F_OK,
-  R_OK,
-  W_OK,
-  X_OK
-} = fs.constants;
-const testFileSystemNodePermissions = async (source, {
-  read = false,
-  write = false,
-  execute = false,
-  allowedIfNotFound = false
-} = {}) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source);
-  const sourcePath = urlToFileSystemPath(sourceUrl);
-  let binaryFlags = 0; // if (visible) binaryFlags |= F_OK
-
-  if (read) binaryFlags |= R_OK;
-  if (write) binaryFlags |= W_OK;
-  if (execute) binaryFlags |= X_OK;
-
-  try {
-    await access(sourcePath, binaryFlags);
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      if (allowedIfNotFound) {
-        return true;
-      }
-
-      throw error;
-    }
-
-    return false;
-  }
-};
-
-const urlToScheme = url => {
-  const urlString = String(url);
-  const colonIndex = urlString.indexOf(":");
-
-  if (colonIndex === -1) {
-    return "";
-  }
-
-  const scheme = urlString.slice(0, colonIndex);
-  return scheme;
-};
-
-const urlToRessource = url => {
-  const scheme = urlToScheme(url);
-
-  if (scheme === "file") {
-    const urlAsStringWithoutFileProtocol = String(url).slice("file://".length);
-    return urlAsStringWithoutFileProtocol;
-  }
-
-  if (scheme === "https" || scheme === "http") {
-    // remove origin
-    const afterProtocol = String(url).slice(scheme.length + "://".length);
-    const pathnameSlashIndex = afterProtocol.indexOf("/", "://".length);
-    const urlAsStringWithoutOrigin = afterProtocol.slice(pathnameSlashIndex);
-    return urlAsStringWithoutOrigin;
-  }
-
-  const urlAsStringWithoutProtocol = String(url).slice(scheme.length + 1);
-  return urlAsStringWithoutProtocol;
-};
-
-const urlToPathname = url => {
-  const ressource = urlToRessource(url);
-  const pathname = ressourceToPathname(ressource);
-  return pathname;
-};
-
-const ressourceToPathname = ressource => {
-  const searchSeparatorIndex = ressource.indexOf("?");
-  return searchSeparatorIndex === -1 ? ressource : ressource.slice(0, searchSeparatorIndex);
-};
-
-const urlToFilename = url => {
-  const pathname = urlToPathname(url);
-  const pathnameBeforeLastSlash = pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
-  const slashLastIndex = pathnameBeforeLastSlash.lastIndexOf("/");
-  const filename = slashLastIndex === -1 ? pathnameBeforeLastSlash : pathnameBeforeLastSlash.slice(slashLastIndex + 1);
-  return filename;
-};
-
-const urlToBasename = url => {
-  const filename = urlToFilename(url);
-  const dotLastIndex = filename.lastIndexOf(".");
-  const basename = dotLastIndex === -1 ? filename : filename.slice(0, dotLastIndex);
-  return basename;
-};
-
-const urlToExtension = url => {
-  const pathname = urlToPathname(url);
-  return pathnameToExtension(pathname);
-};
-
-const pathnameToExtension = pathname => {
-  const slashLastIndex = pathname.lastIndexOf("/");
-
-  if (slashLastIndex !== -1) {
-    pathname = pathname.slice(slashLastIndex + 1);
-  }
-
-  const dotLastIndex = pathname.lastIndexOf(".");
-  if (dotLastIndex === -1) return ""; // if (dotLastIndex === pathname.length - 1) return ""
-
-  const extension = pathname.slice(dotLastIndex);
-  return extension;
-};
-
-const urlToOrigin = url => {
-  const urlString = String(url);
-
-  if (urlString.startsWith("file://")) {
-    return `file://`;
-  }
-
-  return new URL(urlString).origin;
-};
-
-const urlToParentUrl = url => {
-  const ressource = urlToRessource(url);
-  const slashLastIndex = ressource.lastIndexOf("/");
-
-  if (slashLastIndex === -1) {
-    const urlAsString = String(url);
-    return urlAsString;
-  }
-
-  const lastCharacterIndex = ressource.length - 1;
-
-  if (slashLastIndex === lastCharacterIndex) {
-    const slashPreviousIndex = ressource.lastIndexOf("/", lastCharacterIndex - 1);
-
-    if (slashPreviousIndex === -1) {
-      const urlAsString = String(url);
-      return urlAsString;
-    }
-
-    const origin = urlToOrigin(url);
-    const parentUrl = `${origin}${ressource.slice(0, slashPreviousIndex + 1)}`;
-    return parentUrl;
-  }
-
-  const origin = urlToOrigin(url);
-  const parentUrl = `${origin}${ressource.slice(0, slashLastIndex + 1)}`;
-  return parentUrl;
-};
-
-const {
-  writeFile: writeFileNode
-} = fs.promises;
-const writeFile = async (destination, content = "") => {
-  const destinationUrl = assertAndNormalizeFileUrl(destination);
-  const destinationPath = urlToFileSystemPath(destinationUrl);
-
-  try {
-    await writeFileNode(destinationPath, content);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      await ensureParentDirectories(destinationUrl);
-      await writeFileNode(destinationPath, content);
-      return;
-    }
-
-    throw error;
-  }
-};
-
-Object.defineProperty(exports, 'applyPatternMatching', {
-  enumerable: true,
-  get: function () {
-    return urlMeta.applyPatternMatching;
-  }
-});
-Object.defineProperty(exports, 'normalizeStructuredMetaMap', {
-  enumerable: true,
-  get: function () {
-    return urlMeta.normalizeStructuredMetaMap;
-  }
-});
-Object.defineProperty(exports, 'urlCanContainsMetaMatching', {
-  enumerable: true,
-  get: function () {
-    return urlMeta.urlCanContainsMetaMatching;
-  }
-});
-Object.defineProperty(exports, 'urlToMeta', {
-  enumerable: true,
-  get: function () {
-    return urlMeta.urlToMeta;
-  }
-});
-exports.assertAndNormalizeDirectoryUrl = assertAndNormalizeDirectoryUrl;
-exports.assertAndNormalizeFileUrl = assertAndNormalizeFileUrl;
-exports.assertDirectoryPresence = assertDirectoryPresence;
-exports.assertFilePresence = assertFilePresence;
-exports.bufferToEtag = bufferToEtag;
-exports.collectDirectoryMatchReport = collectDirectoryMatchReport;
-exports.collectFiles = collectFiles;
-exports.comparePathnames = comparePathnames;
-exports.copyDirectoryContent = copyDirectoryContent;
-exports.copyFileSystemNode = copyFileSystemNode;
-exports.ensureEmptyDirectory = ensureEmptyDirectory;
-exports.ensureParentDirectories = ensureParentDirectories;
-exports.ensureWindowsDriveLetter = ensureWindowsDriveLetter;
-exports.fileSystemPathToUrl = fileSystemPathToUrl;
-exports.grantPermissionsOnFileSystemNode = grantPermissionsOnFileSystemNode;
-exports.isFileSystemPath = isFileSystemPath;
-exports.listFilesMatching = listFilesMatching;
-exports.memoize = memoize;
-exports.moveDirectoryContent = moveDirectoryContent;
-exports.moveFileSystemNode = moveFileSystemNode;
-exports.readDirectory = readDirectory;
-exports.readFile = readFile;
-exports.readFileSystemNodeModificationTime = readFileSystemNodeModificationTime;
-exports.readFileSystemNodePermissions = readFileSystemNodePermissions;
-exports.readFileSystemNodeStat = readFileSystemNodeStat;
-exports.readSymbolicLink = readSymbolicLink;
-exports.registerDirectoryLifecycle = registerDirectoryLifecycle;
-exports.registerFileLifecycle = registerFileLifecycle;
-exports.removeFileSystemNode = removeFileSystemNode;
-exports.resolveDirectoryUrl = resolveDirectoryUrl;
-exports.resolveUrl = resolveUrl;
-exports.testFileSystemNodePermissions = testFileSystemNodePermissions;
-exports.urlIsInsideOf = urlIsInsideOf;
-exports.urlToBasename = urlToBasename;
-exports.urlToExtension = urlToExtension;
-exports.urlToFileSystemPath = urlToFileSystemPath;
-exports.urlToFilename = urlToFilename;
-exports.urlToOrigin = urlToOrigin;
-exports.urlToParentUrl = urlToParentUrl;
-exports.urlToPathname = urlToPathname;
-exports.urlToRelativeUrl = urlToRelativeUrl;
-exports.urlToRessource = urlToRessource;
-exports.urlToScheme = urlToScheme;
-exports.writeDirectory = writeDirectory;
-exports.writeFile = writeFile;
-exports.writeFileSystemNodeModificationTime = writeFileSystemNodeModificationTime;
-exports.writeFileSystemNodePermissions = writeFileSystemNodePermissions;
-exports.writeSymbolicLink = writeSymbolicLink;
-
-//# sourceMappingURL=jsenv_filesystem.cjs.map