@jsenv/core 41.3.1 → 41.4.1

package/dist/build/build.js

@@ -132,6 +132,136 @@ const watchSourceFiles = (
 
 const jsenvCoreDirectoryUrl = new URL("../", import.meta.url);
 
+/*
+ * Compares what a package.json declares with what is actually inside
+ * node_modules, so the dev server can tell a dependency apart when it is
+ * missing (never installed) or outdated (installed at an other version).
+ *
+ * Only the dependencies declared by a package are looked at, never the
+ * transitive ones: a declared dependency is what pulls the rest, so it is
+ * enough to know whether an install is needed or over.
+ *
+ * Only exact declared versions ("1.2.3") are compared: a range ("^1.2.3"), a
+ * file/workspace protocol or a tag cannot be checked without resolving what npm
+ * would pick, which is way beyond what is needed here.
+ */
+
+
+const DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+];
+
+const packageNameFromSpecifier = (specifier) => {
+  const parts = specifier.split("/");
+  if (specifier[0] === "@") {
+    return parts.slice(0, 2).join("/");
+  }
+  return parts[0];
+};
+
+/*
+ * declaringDirectoryUrl is the package directory the importer belongs to, which
+ * is not always the project one: a file inside node_modules resolves its bare
+ * specifiers against the dependencies of the package containing it.
+ */
+const readDependencyStatus = (
+  packageDirectory,
+  packageName,
+  declaringDirectoryUrl = packageDirectory.url,
+) => {
+  const packageJSON = readPackageJSON(packageDirectory, declaringDirectoryUrl);
+  if (!packageJSON) {
+    return null;
+  }
+  const declaredVersion = readDeclaredVersion(packageJSON, packageName);
+  if (!declaredVersion) {
+    return null;
+  }
+  return createStatus(packageDirectory, {
+    packageName,
+    declaredVersion,
+    declaringDirectoryUrl,
+    declaredBy: packageJSON.name,
+  });
+};
+
+const createStatus = (
+  packageDirectory,
+  { packageName, declaredVersion, declaringDirectoryUrl, declaredBy },
+) => {
+  const status = {
+    packageName,
+    declaredVersion,
+    declaredBy,
+    installedVersion: null,
+    state: "missing",
+  };
+  const installedDirectoryUrl = findInstalledDirectoryUrl(
+    declaringDirectoryUrl,
+    packageName,
+  );
+  if (!installedDirectoryUrl) {
+    return status;
+  }
+  const installedPackageJSON = readPackageJSON(
+    packageDirectory,
+    installedDirectoryUrl,
+  );
+  status.installedVersion = installedPackageJSON
+    ? installedPackageJSON.version
+    : null;
+  status.state =
+    isExactVersion(declaredVersion) &&
+    status.installedVersion !== declaredVersion
+      ? "outdated"
+      : "installed";
+  return status;
+};
+
+const findInstalledDirectoryUrl = (declaringDirectoryUrl, packageName) => {
+  let directoryUrl = declaringDirectoryUrl;
+  while (directoryUrl) {
+    const candidateUrl = `${directoryUrl}node_modules/${packageName}/`;
+    if (existsSync(new URL(`${candidateUrl}package.json`))) {
+      return candidateUrl;
+    }
+    const parentUrl = new URL("../", directoryUrl).href;
+    if (parentUrl === directoryUrl) {
+      return null;
+    }
+    directoryUrl = parentUrl;
+  }
+  return null;
+};
+
+const readDeclaredVersion = (packageJSON, packageName) => {
+  for (const field of DEPENDENCY_FIELDS) {
+    const dependencies = packageJSON[field];
+    if (dependencies && dependencies[packageName]) {
+      return dependencies[packageName];
+    }
+  }
+  return null;
+};
+
+// an install in progress can be caught halfway, with a package.json not written yet
+const readPackageJSON = (packageDirectory, directoryUrl) => {
+  if (!directoryUrl) {
+    return null;
+  }
+  try {
+    return packageDirectory.read(directoryUrl);
+  } catch {
+    return null;
+  }
+};
+
+const isExactVersion = (declaredVersion) => {
+  return /^\d+\.\d+\.\d+(?:[-+][\w.-]+)?$/.test(declaredVersion);
+};
+
 const createResolveUrlError = ({
   jsenvPluginsController,
   reference,
@@ -171,6 +301,18 @@ ${reason}`,
     });
   }
   if (error.code === "MODULE_NOT_FOUND") {
+    const notInstalledStatus = readNotInstalledStatus(reference);
+    if (notInstalledStatus) {
+      const { packageName, declaredVersion, declaredBy, isProjectDependency } =
+        notInstalledStatus;
+      return createFailedToResolveUrlError({
+        "reason": isProjectDependency
+          ? `"${packageName}" is declared in package.json but not installed`
+          : `"${packageName}" is declared by "${declaredBy}" but not installed`,
+        "declared version": declaredVersion,
+        "suggestion": `run npm install, the page will reload once "${packageName}" is installed`,
+      });
+    }
     const bareSpecifierError = createFailedToResolveUrlError({
       reason: `"${reference.specifier}" is a bare specifier but cannot be remapped to a package`,
     });
@@ -425,6 +567,32 @@ const getErrorTrace = (error, reference) => {
   };
 };
 
+// a bare specifier is resolved against the dependencies of the package
+// containing the file that imports it, which is the project one for a source
+// file but an other one for a file inside node_modules
+const readNotInstalledStatus = (reference) => {
+  const { ownerUrlInfo } = reference;
+  const { packageDirectory } = ownerUrlInfo.context;
+  if (!packageDirectory) {
+    return null;
+  }
+  const declaringDirectoryUrl =
+    packageDirectory.find(ownerUrlInfo.url) || packageDirectory.url;
+  const packageName = packageNameFromSpecifier(reference.specifier);
+  const status = readDependencyStatus(
+    packageDirectory,
+    packageName,
+    declaringDirectoryUrl,
+  );
+  if (!status || status.state !== "missing") {
+    return null;
+  }
+  return {
+    ...status,
+    isProjectDependency: declaringDirectoryUrl === packageDirectory.url,
+  };
+};
+
 const detailsFromFirstReference = (reference) => {
   const referenceInProject = getFirstReferenceInProject(reference);
   if (
@@ -8288,6 +8456,7 @@ const jsenvPluginAutoreloadClient = () => {
 const jsenvPluginAutoreloadServer = ({
   clientFileChangeEventEmitter,
   clientFileDereferencedEventEmitter,
+  reloadRequestEventEmitter,
 }) => {
   return {
     name: "jsenv:autoreload_server",
@@ -8616,6 +8785,15 @@ const jsenvPluginAutoreloadServer = ({
             });
           },
         );
+        // something outside the url graph wants the page back from scratch,
+        // typically a dependency that just got installed into node_modules
+        reloadRequestEventEmitter.on(({ cause, reason }) => {
+          serverEventInfo.sendServerEvent({
+            cause,
+            type: "full",
+            typeReason: reason,
+          });
+        });
       },
     },
     serverRoutes: [
@@ -8726,6 +8904,7 @@ const jsenvPluginHotSearchParam = () => {
 const jsenvPluginAutoreload = ({
   clientFileChangeEventEmitter,
   clientFileDereferencedEventEmitter,
+  reloadRequestEventEmitter,
 }) => {
   return [
     jsenvPluginHotSearchParam(),
@@ -8733,10 +8912,75 @@ const jsenvPluginAutoreload = ({
     jsenvPluginAutoreloadServer({
       clientFileChangeEventEmitter,
       clientFileDereferencedEventEmitter,
+      reloadRequestEventEmitter,
     }),
   ];
 };
 
+/*
+ * Tells the browser about the dependencies declared in package.json that
+ * node_modules does not match, so the page can say it is running with something
+ * else than what the project asks for.
+ *
+ * The state is sent on page load (it is known before any client connects) and
+ * again whenever it changes, so a page opened during an install is updated
+ * without being reloaded.
+ */
+
+
+const clientFileUrl = import.meta.resolve("../js/dependency_status.js");
+
+const jsenvPluginDependencyStatus = ({
+  dependencyProblemEventEmitter,
+  getDependencyProblems,
+}) => {
+  return {
+    name: "jsenv:dependency_status",
+    appliesDuring: "dev",
+    serverEvents: {
+      dependency_status: (serverEventInfo) => {
+        dependencyProblemEventEmitter.on((problems) => {
+          // the state is baked into the html by the injection below, so a page
+          // served from the graph as it is would come back with the previous
+          // state, which is exactly what a reload triggered by an install does
+          for (const urlInfo of serverEventInfo.kitchen.graph.urlInfoMap.values()) {
+            if (urlInfo.type === "html" && urlInfo.content !== undefined) {
+              urlInfo.onModified();
+            }
+          }
+          serverEventInfo.sendServerEvent({ problems });
+        });
+      },
+    },
+    transformUrlContent: {
+      html: (htmlUrlInfo) => {
+        const htmlAst = parseHtml({
+          html: htmlUrlInfo.content,
+          url: htmlUrlInfo.url,
+        });
+        const clientReference = htmlUrlInfo.dependencies.inject({
+          type: "script",
+          subtype: "js_module",
+          expectedType: "js_module",
+          specifier: clientFileUrl,
+        });
+        injectJsenvScript(htmlAst, {
+          type: "module",
+          src: clientReference.generatedSpecifier,
+          initCall: {
+            callee: "initDependencyStatus",
+            params: { problems: getDependencyProblems() },
+          },
+          pluginName: "jsenv:dependency_status",
+        });
+        return {
+          content: stringifyHtmlAst(htmlAst),
+        };
+      },
+    },
+  };
+};
+
 const jsenvPluginCacheControl = ({
   versionedUrls = true,
   maxAge = SECONDS_IN_30_DAYS,
@@ -9273,6 +9517,7 @@ const getCorePlugins = ({
 
   clientAutoreload,
   clientAutoreloadOnServerRestart,
+  dependencyStatus,
   cacheControl,
   scenarioPlaceholders = true,
   ribbon = true,
@@ -9371,6 +9616,9 @@ const getCorePlugins = ({
     ...(clientAutoreload && clientAutoreload.enabled
       ? [jsenvPluginAutoreload(clientAutoreload)]
       : []),
+    ...(dependencyStatus
+      ? [jsenvPluginDependencyStatus(dependencyStatus)]
+      : []),
     ...(cacheControl ? [jsenvPluginCacheControl(cacheControl)] : []),
     ...(ribbon ? [jsenvPluginRibbon({ rootDirectoryUrl, ...ribbon })] : []),
     ...(dropToOpen ? [jsenvPluginDropToOpen()] : []),

package/dist/js/dependency_status.js

@@ -0,0 +1,61 @@
+/*
+ * Displays the "some dependencies are outdated" warning overlay.
+ *
+ * A missing dependency is not handled here: it makes the import fail, so the
+ * error overlay already says it, with more precision (which import, where).
+ */
+
+let removeOverlay = () => {};
+
+const initDependencyStatus = ({ problems }) => {
+  render(problems);
+  // without the server events channel the page only knows the state it was
+  // served with, which is still better than nothing
+  if (window.__server_events__) {
+    window.__server_events__.listenEvents({
+      dependency_status: (event) => {
+        render(event.data.problems);
+      },
+    });
+  }
+};
+
+const render = (problems) => {
+  const outdatedList = problems.filter(({ state }) => state === "outdated");
+  removeOverlay();
+  removeOverlay = () => {};
+  if (outdatedList.length === 0) {
+    return;
+  }
+  const supervisor = window.__supervisor__;
+  if (!supervisor || !supervisor.reportWarning) {
+    console.warn(summarize(outdatedList));
+    return;
+  }
+  removeOverlay = supervisor.reportWarning({
+    title:
+      outdatedList.length === 1
+        ? "A dependency is outdated"
+        : `${outdatedList.length} dependencies are outdated`,
+    text: outdatedList.map(describe).join("\n\n"),
+    details: [
+      "The page is running with what is installed in node_modules, which is not what package.json asks for. It may work, but it is not the code the project expects.",
+      "Run npm install to fix it. If an install is already running, there is nothing to do but wait.",
+      "This page reloads on its own as soon as node_modules matches package.json.",
+    ],
+  });
+};
+
+const describe = ({ packageName, declaredVersion, installedVersion }) => {
+  return `${packageName}
+  package.json declares  ${declaredVersion}
+  node_modules holds     ${installedVersion || "an unknown version"}`;
+};
+
+const summarize = (outdatedList) => {
+  return `[jsenv] outdated dependencies, run npm install: ${outdatedList
+    .map(({ packageName }) => packageName)
+    .join(", ")}`;
+};
+
+export { initDependencyStatus };

package/dist/start_dev_server/jsenv_core_packages.js

@@ -1,7 +1,7 @@
 import { createSupportsColor, isUnicodeSupported, eastAsianWidth, clearTerminal, eraseLines } from "./jsenv_core_node_modules.js";
 import { stripVTControlCharacters } from "node:util";
 import { readFileSync, existsSync, chmodSync, statSync, lstatSync, readdirSync, openSync, closeSync, unlinkSync, rmdirSync, mkdirSync, writeFileSync as writeFileSync$1, watch, realpathSync } from "node:fs";
-import { extname } from "node:path";
+import { extname, basename, dirname } from "node:path";
 import crypto, { createHash } from "node:crypto";
 import { pathToFileURL, fileURLToPath } from "node:url";
 
@@ -3382,6 +3382,21 @@ const writeFileSync = (destination, content = "", { force } = {}) => {
   }
 };
 
+const callOnceIdle = (callback, idleMs) => {
+  let timeoutId;
+  return (...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      callback(...args);
+    }, idleMs);
+    if (timeoutId.unref) {
+      timeoutId.unref();
+    }
+  };
+};
+
 const callOnceIdlePerFile = (callback, idleMs) => {
   const timeoutIdMap = new Map();
   return (fileEvent) => {
@@ -3433,6 +3448,25 @@ const createWatcher = (sourcePath, options) => {
   return watcher;
 };
 
+const guardTooFastSecondCall = (
+  callback,
+  cooldownBetweenFileEvents = 40,
+) => {
+  let previousCallMs;
+  return (...args) => {
+    const nowMs = Date.now();
+    if (previousCallMs) {
+      const msEllapsed = nowMs - previousCallMs;
+      if (msEllapsed < cooldownBetweenFileEvents) {
+        previousCallMs = null;
+        return;
+      }
+    }
+    previousCallMs = nowMs;
+    callback(...args);
+  };
+};
+
 const guardTooFastSecondCallPerFile = (
   callback,
   cooldownBetweenFileEvents = 40,
@@ -3476,8 +3510,8 @@ callback: ${callback}`);
   return { registerCleanupCallback, cleanup };
 };
 
-const isLinux = process.platform === "linux";
-const fsWatchSupportsRecursive = !isLinux;
+const isLinux$1 = process.platform === "linux";
+const fsWatchSupportsRecursive = !isLinux$1;
 
 const registerDirectoryLifecycle = (
   source,
@@ -3502,15 +3536,15 @@ const registerDirectoryLifecycle = (
   },
 ) => {
   const sourceUrl = assertAndNormalizeDirectoryUrl(source);
-  if (!undefinedOrFunction(added)) {
+  if (!undefinedOrFunction$1(added)) {
     throw new TypeError(`added must be a function or undefined, got ${added}`);
   }
-  if (!undefinedOrFunction(updated)) {
+  if (!undefinedOrFunction$1(updated)) {
     throw new TypeError(
       `updated must be a function or undefined, got ${updated}`,
     );
   }
-  if (!undefinedOrFunction(removed)) {
+  if (!undefinedOrFunction$1(removed)) {
     throw new TypeError(
       `removed must be a function or undefined, got ${removed}`,
     );
@@ -3805,7 +3839,7 @@ const registerDirectoryLifecycle = (
     }
   };
   const handleEntryUpdated = (entryInfo) => {
-    if (updated && entryInfo.patternValue && shouldCallUpdated(entryInfo)) {
+    if (updated && entryInfo.patternValue && shouldCallUpdated$1(entryInfo)) {
       infoMap.set(entryInfo.relativeUrl, entryInfo);
       updated({
         relativeUrl: entryInfo.relativeUrl,
@@ -3848,7 +3882,7 @@ ${relativeUrls.join("\n")}`,
   return tracker.cleanup;
 };
 
-const shouldCallUpdated = (entryInfo) => {
+const shouldCallUpdated$1 = (entryInfo) => {
   const { stat, previousInfo } = entryInfo;
   if (!stat.atimeMs) {
     return true;
@@ -3862,7 +3896,7 @@ const shouldCallUpdated = (entryInfo) => {
   return true;
 };
 
-const undefinedOrFunction = (value) => {
+const undefinedOrFunction$1 = (value) => {
   return typeof value === "undefined" || typeof value === "function";
 };
 
@@ -3891,6 +3925,224 @@ const fileSystemPathToDirectoryRelativeUrlAndFilename = (path) => {
   };
 };
 
+const isMacos = process.platform === "darwin";
+const isLinux = process.platform === "linux";
+const isFreeBSD = process.platform === "freebsd";
+
+const registerFileLifecycle = (
+  source,
+  {
+    added,
+    updated,
+    removed,
+    notifyExistent = false,
+    keepProcessAlive = true,
+    cooldownBetweenFileEvents = 0,
+    idleMs = 50,
+  },
+) => {
+  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}`,
+    );
+  }
+  if (idleMs) {
+    if (updated) {
+      updated = callOnceIdle(updated, idleMs);
+    }
+  }
+  if (cooldownBetweenFileEvents) {
+    if (added) {
+      added = guardTooFastSecondCall(added, cooldownBetweenFileEvents);
+    }
+    if (updated) {
+      updated = guardTooFastSecondCall(updated, cooldownBetweenFileEvents);
+    }
+    if (removed) {
+      removed = guardTooFastSecondCall(removed, cooldownBetweenFileEvents);
+    }
+  }
+
+  const tracker = trackResources();
+
+  const handleFileFound = ({ stat, existent }) => {
+    const fileMutationStopWatching = watchFileMutation(sourceUrl, {
+      updated,
+      removed: () => {
+        fileMutationStopTracking();
+        watchFileAdded();
+        if (removed) {
+          removed();
+        }
+      },
+      keepProcessAlive,
+      stat,
+    });
+    const fileMutationStopTracking = tracker.registerCleanupCallback(
+      fileMutationStopWatching,
+    );
+
+    if (added) {
+      if (existent) {
+        if (notifyExistent) {
+          added({ existent: true });
+        }
+      } else {
+        added({});
+      }
+    }
+  };
+
+  const watchFileAdded = () => {
+    const fileCreationStopWatching = watchFileCreation(
+      sourceUrl,
+      (stat) => {
+        fileCreationgStopTracking();
+        handleFileFound({ stat, existent: false });
+      },
+      keepProcessAlive,
+    );
+    const fileCreationgStopTracking = tracker.registerCleanupCallback(
+      fileCreationStopWatching,
+    );
+  };
+
+  const { type, stat } = readFileInfo(sourceUrl);
+  if (type === null) {
+    if (added) {
+      watchFileAdded();
+    } else {
+      throw new Error(
+        `${urlToFileSystemPath(sourceUrl)} must lead to a file, found nothing`,
+      );
+    }
+  } else if (type === "file") {
+    handleFileFound({ stat, existent: true });
+  } else {
+    throw new Error(
+      `${urlToFileSystemPath(
+        sourceUrl,
+      )} must lead to a file, type found instead`,
+    );
+  }
+
+  return tracker.cleanup;
+};
+
+const readFileInfo = (url) => {
+  try {
+    const stat = readEntryStatSync(new URL(url));
+    return {
+      type: statsToType(stat),
+      stat,
+    };
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return {
+        type: null,
+        stat: null,
+      };
+    }
+    throw e;
+  }
+};
+
+const undefinedOrFunction = (value) =>
+  typeof value === "undefined" || typeof value === "function";
+
+const watchFileCreation = (source, callback, keepProcessAlive) => {
+  const sourcePath = urlToFileSystemPath(source);
+  const sourceFilename = basename(sourcePath);
+  const directoryPath = dirname(sourcePath);
+  let directoryWatcher = createWatcher(directoryPath, {
+    persistent: keepProcessAlive,
+  });
+  directoryWatcher.on("change", (eventType, filename) => {
+    if (filename && filename !== sourceFilename) return;
+
+    const { type, stat } = readFileInfo(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(stat);
+  });
+
+  return () => {
+    if (directoryWatcher) {
+      directoryWatcher.close();
+    }
+  };
+};
+
+const watchFileMutation = (
+  sourceUrl,
+  { updated, removed, keepProcessAlive, stat },
+) => {
+  let prevStat = stat;
+  let watcher;
+
+  const onChange = () => {
+    const { type, stat } = readFileInfo(sourceUrl);
+
+    if (type === null) {
+      stopWatching();
+      if (removed) {
+        removed();
+      }
+    } else if (type === "file") {
+      if (updated && shouldCallUpdated(stat, prevStat)) {
+        updated();
+      }
+      if ((isMacos || isLinux || isFreeBSD) && prevStat.ino !== stat.ino) {
+        stopWatching();
+        watch();
+      }
+    }
+    prevStat = stat;
+  };
+
+  const watch = () => {
+    watcher = createWatcher(urlToFileSystemPath(sourceUrl), {
+      persistent: keepProcessAlive,
+    });
+    watcher.on("change", onChange);
+  };
+  const stopWatching = () => {
+    if (watcher) {
+      watcher.close();
+      watcher = undefined;
+    }
+  };
+  watch();
+  return stopWatching;
+};
+
+const shouldCallUpdated = (stat, prevStat) => {
+  if (!stat.atimeMs) {
+    return true;
+  }
+  if (stat.atimeMs <= stat.mtimeMs) {
+    return true;
+  }
+  if (stat.mtimeMs !== prevStat.mtimeMs) {
+    return true;
+  }
+  return false;
+};
+
 /*
  * - Buffer documentation on Node.js
  *   https://nodejs.org/docs/latest-v13.x/api/buffer.html
@@ -6419,4 +6671,4 @@ const isResponseEligibleForIntegrityValidation = (response) => {
   return ["basic", "cors", "default"].includes(response.type);
 };
 
-export { ANSI, CONTENT_TYPE, DATA_URL, JS_QUOTES, RUNTIME_COMPAT, URL_META, applyFileSystemMagicResolution, applyNodeEsmResolution, asSpecifierWithoutSearch, asUrlWithoutSearch, assertAndNormalizeDirectoryUrl, bufferToEtag, compareFileUrls, composeTwoImportMaps, createDetailedMessage$1 as createDetailedMessage, createLogger, createTaskLog, ensurePathnameTrailingSlash, ensureWindowsDriveLetter, errorToHTML, formatError, generateContentFrame, getCallerPosition, getExtensionsToTry, injectQueryParams, injectQueryParamsIntoSpecifier, isFileSystemPath, isSpecifierForNodeBuiltin, lookupPackageDirectory, moveUrl, normalizeImportMap, normalizeUrl, readCustomConditionsFromProcessArgs, readEntryStatSync, readPackageAtOrNull, registerDirectoryLifecycle, resolveImport, setUrlBasename, setUrlExtension, setUrlFilename, stringifyUrlSite, urlIsOrIsInsideOf, urlToBasename, urlToExtension$1 as urlToExtension, urlToFileSystemPath, urlToFilename$1 as urlToFilename, urlToPathname$1 as urlToPathname, urlToRelativeUrl, validateResponseIntegrity, writeFileSync };
+export { ANSI, CONTENT_TYPE, DATA_URL, JS_QUOTES, RUNTIME_COMPAT, URL_META, applyFileSystemMagicResolution, applyNodeEsmResolution, asSpecifierWithoutSearch, asUrlWithoutSearch, assertAndNormalizeDirectoryUrl, bufferToEtag, compareFileUrls, composeTwoImportMaps, createDetailedMessage$1 as createDetailedMessage, createLogger, createTaskLog, ensurePathnameTrailingSlash, ensureWindowsDriveLetter, errorToHTML, formatError, generateContentFrame, getCallerPosition, getExtensionsToTry, injectQueryParams, injectQueryParamsIntoSpecifier, isFileSystemPath, isSpecifierForNodeBuiltin, lookupPackageDirectory, moveUrl, normalizeImportMap, normalizeUrl, readCustomConditionsFromProcessArgs, readEntryStatSync, readPackageAtOrNull, registerDirectoryLifecycle, registerFileLifecycle, resolveImport, setUrlBasename, setUrlExtension, setUrlFilename, stringifyUrlSite, urlIsOrIsInsideOf, urlToBasename, urlToExtension$1 as urlToExtension, urlToFileSystemPath, urlToFilename$1 as urlToFilename, urlToPathname$1 as urlToPathname, urlToRelativeUrl, validateResponseIntegrity, writeFileSync };