@jsenv/core 27.0.0-alpha.63 → 27.0.0-alpha.66

package/src/plugins/file_urls/jsenv_plugin_file_urls.js

@@ -1,66 +1,191 @@
-import { readFileSync } from "node:fs"
-import { urlIsInsideOf, urlToRelativeUrl } from "@jsenv/filesystem"
+import { readFileSync, readdirSync, realpathSync, statSync } from "node:fs"
+import { pathToFileURL } from "node:url"
+import {
+  urlIsInsideOf,
+  urlToRelativeUrl,
+  urlToExtension,
+  urlToFilename,
+} from "@jsenv/filesystem"
 
+import { applyFileSystemMagicResolution } from "@jsenv/node-esm-resolution"
+import { ensurePathnameTrailingSlash } from "@jsenv/utils/urls/url_utils.js"
 import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
 
-export const jsenvPluginFileUrls = () => {
-  return [jsenvPluginResolveAbsoluteFileUrls(), jsenvPluginFetchFileUrls()]
-}
+export const jsenvPluginFileUrls = ({
+  magicExtensions = ["inherit", ".js"],
+  magicDirectoryIndex = true,
+  preservesSymlink = true,
+  directoryReferenceAllowed = false,
+}) => {
+  const getExtensionsToTry = (magicExtensions, importer) => {
+    const extensionsSet = new Set()
+    magicExtensions.forEach((magicExtension) => {
+      if (magicExtension === "inherit") {
+        const importerExtension = urlToExtension(importer)
+        extensionsSet.add(importerExtension)
+      } else {
+        extensionsSet.add(magicExtension)
+      }
+    })
+    return Array.from(extensionsSet.values())
+  }
+
+  return [
+    {
+      name: "jsenv:file_url_resolution",
+      appliesDuring: "*",
+      redirectUrl: (reference) => {
+        // http, https, data, about, ...
+        if (!reference.url.startsWith("file:")) {
+          return null
+        }
+        if (reference.isInline) {
+          return null
+        }
+        const urlObject = new URL(reference.url)
+        let stat
+        try {
+          stat = statSync(urlObject)
+        } catch (e) {
+          if (e.code === "ENOENT") {
+            stat = null
+          } else {
+            throw e
+          }
+        }
+        const { search, hash } = urlObject
+        const resolveSymlink = (fileUrl) => {
+          const realPath = realpathSync(new URL(fileUrl))
+          const realFileUrl = `${pathToFileURL(realPath)}${search}${hash}`
+          return realFileUrl
+        }
 
-const jsenvPluginResolveAbsoluteFileUrls = () => {
-  return {
-    name: "jsenv:resolve_absolute_file_urls",
-    appliesDuring: {
-      // during dev and test it's a browser running the code
-      // so absolute file urls needs to be relativized
-      dev: true,
-      test: true,
-      // during build it's fine to use file:// urls
-      build: false,
+        let { pathname } = urlObject
+        const pathnameUsesTrailingSlash = pathname.endsWith("/")
+        urlObject.search = ""
+        urlObject.hash = ""
+        // force trailing slash on directories and remove eventual trailing slash on files
+        if (stat && stat.isDirectory()) {
+          reference.expectedType = "directory"
+          if (!pathnameUsesTrailingSlash) {
+            urlObject.pathname = `${pathname}/`
+          }
+          if (directoryReferenceAllowed) {
+            return preservesSymlink
+              ? urlObject.href
+              : resolveSymlink(urlObject.href)
+          }
+          // give a chane to magic resolution if enabled
+        } else if (pathnameUsesTrailingSlash) {
+          // a warning would be great because it's strange to reference a file with a trailing slash
+          urlObject.pathname = pathname.slice(0, -1)
+        }
+        const url = urlObject.href
+        const filesystemResolution = applyFileSystemMagicResolution(url, {
+          fileStat: stat,
+          magicDirectoryIndex,
+          magicExtensions: getExtensionsToTry(
+            magicExtensions,
+            reference.parentUrl,
+          ),
+        })
+        if (!filesystemResolution.found) {
+          return null
+        }
+        const fileUrlRaw = filesystemResolution.url
+        const fileUrl = `${fileUrlRaw}${search}${hash}`
+        return preservesSymlink ? fileUrl : resolveSymlink(fileUrl)
+      },
     },
-    resolveUrl: (reference) => {
-      if (!reference.specifier.startsWith("/@fs/")) {
-        return null
-      }
-      const fsRootRelativeUrl = reference.specifier.slice("/@fs/".length)
-      return `file:///${fsRootRelativeUrl}`
+    {
+      name: "jsenv:filesystem_resolution",
+      appliesDuring: "*",
+      resolveUrl: {
+        filesystem: (reference, context) => {
+          const { parentUrl } = reference
+          const parentUrlInfo = context.urlGraph.getUrlInfo(parentUrl)
+          const baseUrl =
+            parentUrlInfo && parentUrlInfo.type === "directory"
+              ? ensurePathnameTrailingSlash(parentUrl)
+              : parentUrl
+          return new URL(reference.specifier, baseUrl).href
+        },
+      },
     },
-    formatUrl: (reference, context) => {
-      if (!reference.generatedUrl.startsWith("file:")) {
+    {
+      name: "jsenv:@fs_resolution",
+      appliesDuring: {
+        // during dev and test it's a browser running the code
+        // so absolute file urls needs to be relativized
+        dev: true,
+        test: true,
+        // during build it's fine to use file:// urls
+        build: false,
+      },
+      resolveUrl: (reference) => {
+        if (reference.specifier.startsWith("/@fs/")) {
+          const fsRootRelativeUrl = reference.specifier.slice("/@fs/".length)
+          return `file:///${fsRootRelativeUrl}`
+        }
         return null
-      }
-      if (urlIsInsideOf(reference.generatedUrl, context.rootDirectoryUrl)) {
-        return `/${urlToRelativeUrl(
-          reference.generatedUrl,
-          context.rootDirectoryUrl,
-        )}`
-      }
-      return `/@fs/${reference.generatedUrl.slice("file:///".length)}`
+      },
+      formatUrl: (reference, context) => {
+        if (!reference.generatedUrl.startsWith("file:")) {
+          return null
+        }
+        if (urlIsInsideOf(reference.generatedUrl, context.rootDirectoryUrl)) {
+          return `/${urlToRelativeUrl(
+            reference.generatedUrl,
+            context.rootDirectoryUrl,
+          )}`
+        }
+        return `/@fs/${reference.generatedUrl.slice("file:///".length)}`
+      },
     },
-  }
-}
-
-const jsenvPluginFetchFileUrls = () => {
-  return {
-    name: "jsenv:fetch_file_urls",
-    appliesDuring: "*",
-    fetchUrlContent: (urlInfo) => {
-      if (!urlInfo.url.startsWith("file:")) {
-        return null
-      }
-      const urlObject = new URL(urlInfo.url)
-      const fileBuffer = readFileSync(urlObject)
-      const contentType = CONTENT_TYPE.fromUrlExtension(urlInfo.url)
-      if (CONTENT_TYPE.isTextual(contentType)) {
+    {
+      name: "jsenv:file_url_fetching",
+      appliesDuring: "*",
+      fetchUrlContent: (urlInfo, context) => {
+        if (!urlInfo.url.startsWith("file:")) {
+          return null
+        }
+        const urlObject = new URL(urlInfo.url)
+        if (context.reference.expectedType === "directory") {
+          if (directoryReferenceAllowed) {
+            const directoryEntries = readdirSync(urlObject)
+            let filename
+            if (context.reference.type === "filesystem") {
+              const parentUrlInfo = context.urlGraph.getUrlInfo(
+                context.reference.parentUrl,
+              )
+              filename = `${parentUrlInfo.filename}${context.reference.specifier}/`
+            } else {
+              filename = `${urlToFilename(urlInfo.url)}/`
+            }
+            return {
+              type: "directory",
+              contentType: "application/json",
+              content: JSON.stringify(directoryEntries, null, "  "),
+              filename,
+            }
+          }
+          const error = new Error("found a directory on filesystem")
+          error.code = "EISDIR"
+          throw error
+        }
+        const fileBuffer = readFileSync(urlObject)
+        const contentType = CONTENT_TYPE.fromUrlExtension(urlInfo.url)
+        if (CONTENT_TYPE.isTextual(contentType)) {
+          return {
+            contentType,
+            content: String(fileBuffer),
+          }
+        }
         return {
           contentType,
-          content: String(fileBuffer),
+          content: fileBuffer,
         }
-      }
-      return {
-        contentType,
-        content: fileBuffer,
-      }
+      },
     },
-  }
+  ]
 }

package/src/plugins/html_supervisor/client/html_supervisor_installer.js

@@ -185,7 +185,7 @@ export const installHtmlSupervisor = ({ logs, measurePerf }) => {
     dequeue()
   }
   if (
-    document.readyState !== "intractive" &&
+    document.readyState !== "interactive" &&
     document.readyState !== "complete"
   ) {
     document.addEventListener("readystatechange", () => {

package/src/plugins/html_supervisor/jsenv_plugin_html_supervisor.js

@@ -4,8 +4,6 @@
  * - scripts are wrapped to be supervised
  */
 
-import { urlIsInsideOf } from "@jsenv/filesystem"
-
 import {
   parseHtmlString,
   stringifyHtmlAst,
@@ -21,22 +19,20 @@ import {
   setHtmlNodeGeneratedText,
 } from "@jsenv/utils/html_ast/html_ast.js"
 import { generateInlineContentUrl } from "@jsenv/utils/urls/inline_content_url_generator.js"
-import { jsenvRootDirectoryUrl } from "@jsenv/core/src/jsenv_root_directory_url.js"
 
 export const jsenvPluginHtmlSupervisor = ({
-  rootDirectoryUrl,
   logs = false,
   measurePerf = false,
 }) => {
-  const preferSourceFiles =
-    rootDirectoryUrl === jsenvRootDirectoryUrl ||
-    urlIsInsideOf(rootDirectoryUrl, jsenvRootDirectoryUrl)
-  const htmlSupervisorSetupFileUrl = preferSourceFiles
-    ? new URL("./client/html_supervisor_setup.js", import.meta.url).href
-    : new URL("./dist/html_supervisor_setup.js", jsenvRootDirectoryUrl).href
-  const htmlSupervisorInstallerFileUrl = preferSourceFiles
-    ? new URL("./client/html_supervisor_installer.js", import.meta.url).href
-    : new URL("./dist/html_supervisor_installer.js", jsenvRootDirectoryUrl).href
+  const htmlSupervisorSetupFileUrl = new URL(
+    "./client/html_supervisor_setup.js?js_classic",
+    import.meta.url,
+  ).href
+
+  const htmlSupervisorInstallerFileUrl = new URL(
+    "./client/html_supervisor_installer.js",
+    import.meta.url,
+  ).href
 
   return {
     name: "jsenv:html_supervisor",

package/src/plugins/http_urls/jsenv_plugin_http_urls.js

@@ -2,11 +2,11 @@ export const jsenvPluginHttpUrls = () => {
   return {
     name: "jsenv:http_urls",
     appliesDuring: "*",
-    fetchUrlContent: (urlInfo) => {
-      if (urlInfo.url.startsWith("http") || urlInfo.url.startsWith("https")) {
-        return { external: true }
-      }
-      return null
-    },
+    // fetchUrlContent: (urlInfo) => {
+    //   if (urlInfo.url.startsWith("http") || urlInfo.url.startsWith("https")) {
+    //     return { shouldHandle: false }
+    //   }
+    //   return null
+    // },
   }
 }

package/src/plugins/import_meta_hot/jsenv_plugin_import_meta_hot.js

@@ -1,19 +1,14 @@
-import { urlIsInsideOf } from "@jsenv/filesystem"
-
 import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
 import { parseHtmlString } from "@jsenv/utils/html_ast/html_ast.js"
 import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
-import { jsenvRootDirectoryUrl } from "@jsenv/core/src/jsenv_root_directory_url.js"
 import { collectHotDataFromHtmlAst } from "./html_hot_dependencies.js"
 import { babelPluginMetadataImportMetaHot } from "./babel_plugin_metadata_import_meta_hot.js"
 
-export const jsenvPluginImportMetaHot = ({ rootDirectoryUrl }) => {
-  const preferSourceFiles =
-    rootDirectoryUrl === jsenvRootDirectoryUrl ||
-    urlIsInsideOf(rootDirectoryUrl, jsenvRootDirectoryUrl)
-  const importMetaHotClientFileUrl = preferSourceFiles
-    ? new URL("./client/import_meta_hot.js", import.meta.url).href
-    : new URL("./dist/import_meta_hot.js", jsenvRootDirectoryUrl).href
+export const jsenvPluginImportMetaHot = () => {
+  const importMetaHotClientFileUrl = new URL(
+    "./client/import_meta_hot.js",
+    import.meta.url,
+  ).href
 
   return {
     name: "jsenv:import_meta_hot",

package/src/plugins/importmap/jsenv_plugin_importmap.js

@@ -130,9 +130,8 @@ export const jsenvPluginImportmap = () => {
               contentType: "application/importmap+json",
               content: textNode.value,
             })
-          await context.cook({
+          await context.cook(inlineImportmapUrlInfo, {
             reference: inlineImportmapReference,
-            urlInfo: inlineImportmapUrlInfo,
           })
           setHtmlNodeGeneratedText(importmap, {
             generatedText: inlineImportmapUrlInfo.content,
@@ -154,9 +153,8 @@ export const jsenvPluginImportmap = () => {
           const importmapUrlInfo = context.urlGraph.getUrlInfo(
             importmapReference.url,
           )
-          await context.cook({
+          await context.cook(importmapUrlInfo, {
             reference: importmapReference,
-            urlInfo: importmapUrlInfo,
           })
           onHtmlImportmapParsed(
             JSON.parse(importmapUrlInfo.content),

package/src/plugins/inject_globals/jsenv_plugin_inject_globals.js

@@ -11,56 +11,65 @@ export const jsenvPluginInjectGlobals = (globals = {}) => {
   if (Object.keys(globals).length === 0) {
     return []
   }
-
-  const globalInjectorOnHtmlEntryPoint = (urlInfo) => {
-    if (!urlInfo.data.isEntryPoint) {
-      return null
-    }
-    // ideally we would inject an importmap but browser support is too low
-    // (even worse for worker/service worker)
-    // so for now we inject code into entry points
-    const htmlAst = parseHtmlString(urlInfo.content, {
-      storeOriginalPositions: false,
-    })
-    injectScriptAsEarlyAsPossible(
-      htmlAst,
-      createHtmlNode({
-        "tagName": "script",
-        "textContent": generateClientCodeForGlobals({
-          globals,
-          isWebWorker: false,
-        }),
-        "injected-by": "jsenv:inject_globals",
-      }),
-    )
-    return stringifyHtmlAst(htmlAst)
-  }
-
-  const globalsInjectorOnJsEntryPoints = (urlInfo) => {
-    if (!urlInfo.data.isEntryPoint && !urlInfo.data.isWebWorkerEntryPoint) {
-      return null
-    }
-    const magicSource = createMagicSource(urlInfo.content)
-    magicSource.append(
-      generateClientCodeForGlobals({
-        globals,
-        isWebWorker: isWebWorkerUrlInfo(urlInfo),
-      }),
-    )
-    return magicSource.toContentAndSourcemap()
-  }
-
   return {
     name: "jsenv:inject_globals",
     appliesDuring: "*",
     transformUrlContent: {
-      html: globalInjectorOnHtmlEntryPoint,
-      js_classic: globalsInjectorOnJsEntryPoints,
-      js_module: globalsInjectorOnJsEntryPoints,
+      html: injectGlobals,
+      js_classic: injectGlobals,
+      js_module: injectGlobals,
     },
   }
 }
 
+export const injectGlobals = (urlInfo, globals) => {
+  if (urlInfo.type === "html") {
+    return globalInjectorOnHtmlEntryPoint(urlInfo, globals)
+  }
+  if (urlInfo.type === "js_classic" || urlInfo.type === "js_module") {
+    return globalsInjectorOnJsEntryPoints(urlInfo, globals)
+  }
+  throw new Error(`cannot inject globals into "${urlInfo.type}"`)
+}
+
+const globalInjectorOnHtmlEntryPoint = async (urlInfo, globals) => {
+  if (!urlInfo.data.isEntryPoint) {
+    return null
+  }
+  // ideally we would inject an importmap but browser support is too low
+  // (even worse for worker/service worker)
+  // so for now we inject code into entry points
+  const htmlAst = parseHtmlString(urlInfo.content, {
+    storeOriginalPositions: false,
+  })
+  const clientCode = generateClientCodeForGlobals({
+    globals,
+    isWebWorker: false,
+  })
+  injectScriptAsEarlyAsPossible(
+    htmlAst,
+    createHtmlNode({
+      "tagName": "script",
+      "textContent": clientCode,
+      "injected-by": "jsenv:inject_globals",
+    }),
+  )
+  return stringifyHtmlAst(htmlAst)
+}
+
+const globalsInjectorOnJsEntryPoints = async (urlInfo, globals) => {
+  if (!urlInfo.data.isEntryPoint && !urlInfo.data.isWebWorkerEntryPoint) {
+    return null
+  }
+  const clientCode = generateClientCodeForGlobals({
+    globals,
+    isWebWorker: isWebWorkerUrlInfo(urlInfo),
+  })
+  const magicSource = createMagicSource(urlInfo.content)
+  magicSource.prepend(clientCode)
+  return magicSource.toContentAndSourcemap()
+}
+
 const generateClientCodeForGlobals = ({ isWebWorker = false, globals }) => {
   const globalName = isWebWorker ? "self" : "window"
   return `Object.assign(${globalName}, ${JSON.stringify(globals, null, "  ")});`

package/src/plugins/inline/jsenv_plugin_data_urls.js

@@ -35,10 +35,7 @@ export const jsenvPluginDataUrls = () => {
       }
       return (async () => {
         const urlInfo = context.urlGraph.getUrlInfo(reference.url)
-        await context.cook({
-          reference,
-          urlInfo,
-        })
+        await context.cook(urlInfo, { reference })
         if (urlInfo.originalContent === urlInfo.content) {
           return reference.generatedUrl
         }

package/src/plugins/inline/jsenv_plugin_html_inline_content.js

@@ -54,9 +54,8 @@ export const jsenvPluginHtmlInlineContent = ({ analyzeConvertedScripts }) => {
                 contentType: "text/css",
                 content: textNode.value,
               })
-            await context.cook({
+            await context.cook(inlineStyleUrlInfo, {
               reference: inlineStyleReference,
-              urlInfo: inlineStyleUrlInfo,
             })
             setHtmlNodeGeneratedText(node, {
               generatedText: inlineStyleUrlInfo.content,
@@ -77,7 +76,7 @@ export const jsenvPluginHtmlInlineContent = ({ analyzeConvertedScripts }) => {
           // - we want to avoid cooking twice a script during build
           const generatedBy = getHtmlNodeAttributeByName(node, "generated-by")
           if (generatedBy) {
-            if (generatedBy.value === "jsenv:script_type_module_as_classic") {
+            if (generatedBy.value === "jsenv:as_js_classic_html") {
               if (!analyzeConvertedScripts) {
                 return
               }
@@ -135,9 +134,8 @@ export const jsenvPluginHtmlInlineContent = ({ analyzeConvertedScripts }) => {
                 content: textNode.value,
               })
 
-            await context.cook({
+            await context.cook(inlineScriptUrlInfo, {
               reference: inlineScriptReference,
-              urlInfo: inlineScriptUrlInfo,
             })
             setHtmlNodeGeneratedText(node, {
               generatedText: inlineScriptUrlInfo.content,

package/src/plugins/inline/jsenv_plugin_inline_query_param.js

@@ -25,10 +25,7 @@ export const jsenvPluginInlineQueryParam = () => {
         }
         return (async () => {
           const urlInfo = context.urlGraph.getUrlInfo(reference.url)
-          await context.cook({
-            reference,
-            urlInfo,
-          })
+          await context.cook(urlInfo, { reference })
           const specifier = DataUrl.stringify({
             mediaType: urlInfo.contentType,
             base64Flag: true,

package/src/plugins/inline/jsenv_plugin_js_inline_content.js

@@ -49,10 +49,7 @@ export const jsenvPluginJsInlineContent = ({ allowEscapeForVersioning }) => {
       inlineUrlInfo.jsQuote = quote
       inlineReference.escape = (value) =>
         JS_QUOTES.escapeSpecialChars(value.slice(1, -1), { quote })
-      await context.cook({
-        reference: inlineReference,
-        urlInfo: inlineUrlInfo,
-      })
+      await context.cook(inlineUrlInfo, { reference: inlineReference })
       magicSource.replace({
         start: inlineContentInfo.start,
         end: inlineContentInfo.end,

package/src/plugins/node_esm_resolution/jsenv_plugin_node_esm_resolution.js

@@ -13,12 +13,13 @@ import {
   applyNodeEsmResolution,
   defaultLookupPackageScope,
   defaultReadPackageJson,
+  readCustomConditionsFromProcessArgs,
 } from "@jsenv/node-esm-resolution"
 
 export const jsenvPluginNodeEsmResolution = ({
   rootDirectoryUrl,
-  // https://nodejs.org/api/esm.html#resolver-algorithm-specification
-  packageConditions = ["browser", "import"],
+  runtimeCompat,
+  packageConditions,
   filesInvalidatingCache = ["package.json", "package-lock.json"],
 }) => {
   const packageScopesCache = new Map()
@@ -64,6 +65,7 @@ export const jsenvPluginNodeEsmResolution = ({
 
   return [
     jsenvPluginNodeEsmResolver({
+      runtimeCompat,
       packageConditions,
       lookupPackageScope,
       readPackageJson,
@@ -76,10 +78,18 @@ export const jsenvPluginNodeEsmResolution = ({
 }
 
 const jsenvPluginNodeEsmResolver = ({
+  runtimeCompat,
   packageConditions,
   lookupPackageScope,
   readPackageJson,
 }) => {
+  const nodeRuntimeEnabled = Object.keys(runtimeCompat).includes("node")
+  // https://nodejs.org/api/esm.html#resolver-algorithm-specification
+  packageConditions = packageConditions || [
+    ...readCustomConditionsFromProcessArgs(),
+    nodeRuntimeEnabled ? "node" : "browser",
+    "import",
+  ]
   return {
     name: "jsenv:node_esm_resolve",
     appliesDuring: "*",
@@ -138,6 +148,10 @@ const jsenvPluginNodeModulesVersionInUrls = ({
         return null
       }
       const packageVersion = readPackageJson(packageUrl).version
+      if (!packageVersion) {
+        // example where it happens: https://github.com/babel/babel/blob/2ce56e832c2dd7a7ed92c89028ba929f874c2f5c/packages/babel-runtime/helpers/esm/package.json#L2
+        return null
+      }
       return {
         v: packageVersion,
       }

package/src/plugins/node_runtime/jsenv_plugin_node_runtime.js

@@ -0,0 +1,12 @@
+export const jsenvPluginNodeRuntime = ({ runtimeCompat }) => {
+  const nodeFound = Object.keys(runtimeCompat).includes("node")
+  if (!nodeFound) {
+    return []
+  }
+
+  // what do we need to do?
+  return {
+    name: "jsenv:node_runtime",
+    appliesDuring: "*",
+  }
+}

package/src/plugins/plugin_controller.js

@@ -159,6 +159,9 @@ const flattenAndFilterPlugins = (pluginsRaw, { scenario }) => {
       return
     }
     if (typeof pluginEntry === "object" && pluginEntry !== null) {
+      if (!pluginEntry.name) {
+        pluginEntry.name = "anonymous"
+      }
       const { appliesDuring } = pluginEntry
       if (appliesDuring === undefined) {
         console.warn(`"appliesDuring" is undefined on ${pluginEntry.name}`)
@@ -168,9 +171,20 @@ const flattenAndFilterPlugins = (pluginsRaw, { scenario }) => {
         plugins.push(pluginEntry)
         return
       }
+      if (typeof appliesDuring === "string") {
+        if (!["dev", "build", "test"].includes(appliesDuring)) {
+          throw new Error(
+            `"appliesDuring" must be "dev", "test" or "build", got ${appliesDuring}`,
+          )
+        }
+        if (appliesDuring === scenario) {
+          plugins.push(pluginEntry)
+        }
+        return
+      }
       if (typeof appliesDuring !== "object") {
         throw new Error(
-          `"appliesDuring" must be an object or "*", got ${appliesDuring}`,
+          `"appliesDuring" must be an object or a string, got ${appliesDuring}`,
         )
       }
       if (appliesDuring[scenario]) {
@@ -252,8 +266,8 @@ const returnValueAssertions = [
         return { content: valueReturned }
       }
       if (typeof valueReturned === "object") {
-        const { external, content } = valueReturned
-        if (external) {
+        const { shouldHandle, content } = valueReturned
+        if (shouldHandle === false) {
           return undefined
         }
         if (typeof content !== "string" && !Buffer.isBuffer(content)) {