@netlify/edge-bundler 8.19.1 → 8.20.0

package/deno/bundle.ts

@@ -1,10 +1,10 @@
 import { writeStage2 } from './lib/stage2.ts'
 
 const [payload] = Deno.args
-const { basePath, destPath, externals, functions, importMapData } = JSON.parse(payload)
+const { basePath, destPath, externals, functions, importMapData, vendorDirectory } = JSON.parse(payload)
 
 try {
-  await writeStage2({ basePath, destPath, externals, functions, importMapData })
+  await writeStage2({ basePath, destPath, externals, functions, importMapData, vendorDirectory })
 } catch (error) {
   if (error instanceof Error && error.message.includes("The module's source code could not be parsed")) {
     delete error.stack

package/deno/lib/stage2.ts

@@ -3,7 +3,7 @@ import { build, LoadResponse } from 'https://deno.land/x/eszip@v0.40.0/mod.ts'
 import * as path from 'https://deno.land/std@0.177.0/path/mod.ts'
 
 import type { InputFunction, WriteStage2Options } from '../../shared/stage2.ts'
-import { importMapSpecifier, virtualRoot } from '../../shared/consts.ts'
+import { importMapSpecifier, virtualRoot, virtualVendorRoot } from '../../shared/consts.ts'
 import { LEGACY_PUBLIC_SPECIFIER, PUBLIC_SPECIFIER, STAGE2_SPECIFIER } from './consts.ts'
 import { inlineModule, loadFromVirtualRoot, loadWithRetry } from './common.ts'
 
@@ -63,7 +63,13 @@ const getVirtualPath = (basePath: string, filePath: string) => {
   return url
 }
 
-const stage2Loader = (basePath: string, functions: InputFunction[], externals: Set<string>, importMapData?: string) => {
+const stage2Loader = (
+  basePath: string,
+  functions: InputFunction[],
+  externals: Set<string>,
+  importMapData: string | undefined,
+  vendorDirectory?: string,
+) => {
   return async (specifier: string): Promise<LoadResponse | undefined> => {
     if (specifier === STAGE2_SPECIFIER) {
       const stage2Entry = getStage2Entry(basePath, functions)
@@ -91,13 +97,24 @@ const stage2Loader = (basePath: string, functions: InputFunction[], externals: S
       return loadFromVirtualRoot(specifier, virtualRoot, basePath)
     }
 
+    if (vendorDirectory !== undefined && specifier.startsWith(virtualVendorRoot)) {
+      return loadFromVirtualRoot(specifier, virtualVendorRoot, vendorDirectory)
+    }
+
     return await loadWithRetry(specifier)
   }
 }
 
-const writeStage2 = async ({ basePath, destPath, externals, functions, importMapData }: WriteStage2Options) => {
+const writeStage2 = async ({
+  basePath,
+  destPath,
+  externals,
+  functions,
+  importMapData,
+  vendorDirectory,
+}: WriteStage2Options) => {
   const importMapURL = importMapData ? importMapSpecifier : undefined
-  const loader = stage2Loader(basePath, functions, new Set(externals), importMapData)
+  const loader = stage2Loader(basePath, functions, new Set(externals), importMapData, vendorDirectory)
   const bytes = await build([STAGE2_SPECIFIER], loader, importMapURL)
   const directory = path.dirname(destPath)
 

package/dist/node/bundler.d.ts

@@ -1,24 +1,24 @@
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from './bridge.js';
 import { Declaration } from './declaration.js';
+import { EdgeFunction } from './edge_function.js';
 import { FeatureFlags } from './feature_flags.js';
 import { LogFunction } from './logger.js';
-interface BundleOptions {
+export interface BundleOptions {
     basePath?: string;
+    bootstrapURL?: string;
     cacheDirectory?: string;
     configPath?: string;
     debug?: boolean;
     distImportMapPath?: string;
     featureFlags?: FeatureFlags;
     importMapPaths?: (string | undefined)[];
+    internalSrcFolder?: string;
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
     systemLogger?: LogFunction;
-    internalSrcFolder?: string;
-    bootstrapURL?: string;
+    vendorDirectory?: string;
 }
-declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, }?: BundleOptions) => Promise<{
-    functions: import("./edge_function.js").EdgeFunction[];
+export declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, internalSrcFolder, onAfterDownload, onBeforeDownload, systemLogger, vendorDirectory, }?: BundleOptions) => Promise<{
+    functions: EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;
-export { bundle };
-export type { BundleOptions };

package/dist/node/bundler.js

@@ -13,8 +13,9 @@ import { bundle as bundleESZIP } from './formats/eszip.js';
 import { ImportMap } from './import_map.js';
 import { getLogger } from './logger.js';
 import { writeManifest } from './manifest.js';
+import { vendorNPMSpecifiers } from './npm_dependencies.js';
 import { ensureLatestTypes } from './types.js';
-const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, } = {}) => {
+export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], internalSrcFolder, onAfterDownload, onBeforeDownload, systemLogger, vendorDirectory, } = {}) => {
     const logger = getLogger(systemLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
@@ -46,6 +47,17 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     const userFunctions = userSourceDirectories.length === 0 ? [] : await findFunctions(userSourceDirectories);
     const internalFunctions = internalSrcFolder ? await findFunctions([internalSrcFolder]) : [];
     const functions = [...internalFunctions, ...userFunctions];
+    const vendor = await safelyVendorNPMSpecifiers({
+        basePath,
+        featureFlags,
+        functions,
+        importMap,
+        logger,
+        vendorDirectory,
+    });
+    if (vendor) {
+        importMap.add(vendor.importMap);
+    }
     const functionBundle = await bundleESZIP({
         basePath,
         buildID,
@@ -56,6 +68,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         functions,
         featureFlags,
         importMap,
+        vendorDirectory: vendor === null || vendor === void 0 ? void 0 : vendor.directory,
     });
     // The final file name of the bundles contains a SHA256 hash of the contents,
     // which we can only compute now that the files have been generated. So let's
@@ -86,6 +99,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         importMap: importMapSpecifier,
         layers: deployConfig.layers,
     });
+    await (vendor === null || vendor === void 0 ? void 0 : vendor.cleanup());
     if (distImportMapPath) {
         await importMap.writeToFile(distImportMapPath);
     }
@@ -133,4 +147,20 @@ const createFunctionConfig = ({ internalFunctionsWithConfig, declarations }) =>
         [functionName]: addGeneratorFallback(mergedConfigFields),
     };
 }, {});
-export { bundle };
+const safelyVendorNPMSpecifiers = async ({ basePath, featureFlags, functions, importMap, logger, vendorDirectory, }) => {
+    if (!featureFlags.edge_functions_npm_modules) {
+        return;
+    }
+    try {
+        return await vendorNPMSpecifiers({
+            basePath,
+            directory: vendorDirectory,
+            functions: functions.map(({ path }) => path),
+            importMap,
+            logger,
+        });
+    }
+    catch (error) {
+        logger.system(error);
+    }
+};

package/dist/node/bundler.test.js

@@ -120,7 +120,7 @@ test('Prints a nice error message when user tries importing NPM module', async (
     }
     catch (error) {
         expect(error).toBeInstanceOf(BundleError);
-        expect(error.message).toEqual(`It seems like you're trying to import an npm module. This is only supported via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/p-retry"'?`);
+        expect(error.message).toEqual(`It seems like you're trying to import an npm module. This is only supported via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/parent-1"'?`);
     }
     finally {
         await cleanup();
@@ -373,3 +373,27 @@ test('Handles imports with the `node:` prefix', async () => {
     expect(func1).toBe('ok');
     await cleanup();
 });
+test('Loads npm modules from bare specifiers with and without the `npm:` prefix', async () => {
+    const { basePath, cleanup, distPath } = await useFixture('imports_npm_module');
+    const sourceDirectory = join(basePath, 'functions');
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const vendorDirectory = await tmp.dir();
+    await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
+        featureFlags: { edge_functions_npm_modules: true },
+        importMapPaths: [join(basePath, 'import_map.json')],
+        vendorDirectory: vendorDirectory.path,
+    });
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifest = JSON.parse(manifestFile);
+    const bundlePath = join(distPath, manifest.bundles[0].asset);
+    const { func1 } = await runESZIP(bundlePath, vendorDirectory.path);
+    expect(func1).toBe(`<parent-1><child-1>JavaScript</child-1></parent-1>, <parent-2><child-2><grandchild-1>APIs<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-2>, <parent-3><child-2><grandchild-1>Markup<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-3>`);
+    await cleanup();
+    await rm(vendorDirectory.path, { force: true, recursive: true });
+});

package/dist/node/feature_flags.d.ts

@@ -1,10 +1,12 @@
 declare const defaultFlags: {
     edge_functions_fail_unsupported_regex: boolean;
+    edge_functions_npm_modules: boolean;
 };
 type FeatureFlag = keyof typeof defaultFlags;
 type FeatureFlags = Partial<Record<FeatureFlag, boolean>>;
 declare const getFlags: (input?: Record<string, boolean>, flags?: {
     edge_functions_fail_unsupported_regex: boolean;
+    edge_functions_npm_modules: boolean;
 }) => FeatureFlags;
 export { defaultFlags, getFlags };
 export type { FeatureFlag, FeatureFlags };

package/dist/node/feature_flags.js

@@ -1,5 +1,6 @@
 const defaultFlags = {
     edge_functions_fail_unsupported_regex: false,
+    edge_functions_npm_modules: false,
 };
 const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
     ...result,

package/dist/node/formats/eszip.d.ts

@@ -13,6 +13,7 @@ interface BundleESZIPOptions {
     featureFlags: FeatureFlags;
     functions: EdgeFunction[];
     importMap: ImportMap;
+    vendorDirectory?: string;
 }
-declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, }: BundleESZIPOptions) => Promise<Bundle>;
+declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, vendorDirectory, }: BundleESZIPOptions) => Promise<Bundle>;
 export { bundleESZIP as bundle };

package/dist/node/formats/eszip.js

@@ -1,26 +1,29 @@
 import { join } from 'path';
 import { pathToFileURL } from 'url';
-import { virtualRoot } from '../../shared/consts.js';
+import { virtualRoot, virtualVendorRoot } from '../../shared/consts.js';
 import { BundleFormat } from '../bundle.js';
 import { wrapBundleError } from '../bundle_error.js';
 import { wrapNpmImportError } from '../npm_import_error.js';
 import { getPackagePath } from '../package_json.js';
 import { getFileHash } from '../utils/sha256.js';
-const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, }) => {
+const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, vendorDirectory, }) => {
     const extension = '.eszip';
     const destPath = join(distDirectory, `${buildID}${extension}`);
-    const { bundler, importMap: bundlerImportMap } = getESZIPPaths();
-    // Transforming all paths under `basePath` to use the virtual root prefix.
     const importMapPrefixes = {
         [`${pathToFileURL(basePath)}/`]: virtualRoot,
     };
-    const importMapData = importMap.getContents(importMapPrefixes);
+    if (vendorDirectory !== undefined) {
+        importMapPrefixes[`${pathToFileURL(vendorDirectory)}/`] = virtualVendorRoot;
+    }
+    const { bundler, importMap: bundlerImportMap } = getESZIPPaths();
+    const importMapData = JSON.stringify(importMap.getContents(importMapPrefixes));
     const payload = {
         basePath,
         destPath,
         externals,
         functions,
-        importMapData: JSON.stringify(importMapData),
+        importMapData,
+        vendorDirectory,
     };
     const flags = ['--allow-all', '--no-config', `--import-map=${bundlerImportMap}`];
     if (!debug) {

package/dist/node/import_map.d.ts

@@ -14,6 +14,8 @@ export declare class ImportMap {
     addFile(path: string, logger: Logger): Promise<void>;
     addFiles(paths: (string | undefined)[], logger: Logger): Promise<void>;
     static applyPrefixesToImports(imports: Imports, prefixes: Record<string, string>): Imports;
+    static convertImportsToURLObjects(imports: Imports): Record<string, URL>;
+    static convertScopesToURLObjects(scopes: Record<string, Imports>): Record<string, Record<string, URL>>;
     static applyPrefixesToPath(path: string, prefixes: Record<string, string>): string;
     filterImports(imports?: Record<string, URL | null>): Record<string, string>;
     filterScopes(scopes?: ParsedImportMap['scopes']): Record<string, Imports>;
@@ -21,6 +23,10 @@ export declare class ImportMap {
         imports: Imports;
         scopes: {};
     };
+    getContentsWithURLObjects(prefixes?: Record<string, string>): {
+        imports: Record<string, URL>;
+        scopes: Record<string, Record<string, URL>>;
+    };
     static readFile(path: string, logger: Logger): Promise<ImportMapFile>;
     resolve(source: ImportMapFile): {
         imports: Record<string, string>;

package/dist/node/import_map.js

@@ -44,6 +44,18 @@ export class ImportMap {
             [key]: ImportMap.applyPrefixesToPath(value, prefixes),
         }), {});
     }
+    static convertImportsToURLObjects(imports) {
+        return Object.entries(imports).reduce((acc, [key, value]) => ({
+            ...acc,
+            [key]: new URL(value),
+        }), {});
+    }
+    static convertScopesToURLObjects(scopes) {
+        return Object.entries(scopes).reduce((acc, [key, value]) => ({
+            ...acc,
+            [key]: ImportMap.convertImportsToURLObjects(value),
+        }), {});
+    }
     // Applies a list of prefixes to a given path, returning the replaced path.
     // For example, given a `path` of `file:///foo/bar/baz.js` and a `prefixes`
     // object with `{"file:///foo/": "file:///hello/"}`, this method will return
@@ -122,6 +134,16 @@ export class ImportMap {
             scopes: transformedScopes,
         };
     }
+    // The same as `getContents`, but the URLs are represented as URL objects
+    // instead of strings. This is compatible with the `ParsedImportMap` type
+    // from the `@import-maps/resolve` library.
+    getContentsWithURLObjects(prefixes = {}) {
+        const { imports, scopes } = this.getContents(prefixes);
+        return {
+            imports: ImportMap.convertImportsToURLObjects(imports),
+            scopes: ImportMap.convertScopesToURLObjects(scopes),
+        };
+    }
     static async readFile(path, logger) {
         const baseURL = pathToFileURL(path);
         try {

package/dist/node/import_map.test.js

@@ -20,11 +20,16 @@ test('Handles import maps with full URLs without specifying a base URL', () => {
         },
     };
     const map = new ImportMap([inputFile1, inputFile2]);
-    const { imports } = map.getContents();
-    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
-    expect(imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
-    expect(imports['alias:jamstack']).toBe('https://jamstack.org/');
-    expect(imports['alias:pets']).toBe('https://petsofnetlify.com/');
+    const m1 = map.getContents();
+    expect(m1.imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
+    expect(m1.imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(m1.imports['alias:jamstack']).toBe('https://jamstack.org/');
+    expect(m1.imports['alias:pets']).toBe('https://petsofnetlify.com/');
+    const m2 = map.getContentsWithURLObjects();
+    expect(m2.imports['netlify:edge']).toStrictEqual(new URL('https://edge.netlify.com/v1/index.ts?v=legacy'));
+    expect(m2.imports['@netlify/edge-functions']).toStrictEqual(new URL('https://edge.netlify.com/v1/index.ts'));
+    expect(m2.imports['alias:jamstack']).toStrictEqual(new URL('https://jamstack.org/'));
+    expect(m2.imports['alias:pets']).toStrictEqual(new URL('https://petsofnetlify.com/'));
 });
 test('Resolves relative paths to absolute paths if a base path is not provided', () => {
     const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
@@ -35,11 +40,15 @@ test('Resolves relative paths to absolute paths if a base path is not provided',
         },
     };
     const map = new ImportMap([inputFile1]);
-    const { imports } = map.getContents();
     const expectedPath = join(cwd(), 'my-cool-site', 'heart', 'pets');
-    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
-    expect(imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
-    expect(imports['alias:pets']).toBe(`${pathToFileURL(expectedPath).toString()}/`);
+    const m1 = map.getContents();
+    expect(m1.imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
+    expect(m1.imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(m1.imports['alias:pets']).toBe(`${pathToFileURL(expectedPath).toString()}/`);
+    const m2 = map.getContentsWithURLObjects();
+    expect(m2.imports['netlify:edge']).toStrictEqual(new URL('https://edge.netlify.com/v1/index.ts?v=legacy'));
+    expect(m2.imports['@netlify/edge-functions']).toStrictEqual(new URL('https://edge.netlify.com/v1/index.ts'));
+    expect(m2.imports['alias:pets']).toStrictEqual(new URL(`${pathToFileURL(expectedPath).toString()}/`));
 });
 describe('Returns the fully resolved import map', () => {
     const inputFile1 = {

package/dist/node/npm_dependencies.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { ParsedImportMap } from '@import-maps/resolve';
+import { Plugin } from 'esbuild';
+import { ImportMap } from './import_map.js';
+import { Logger } from './logger.js';
+export declare const getDependencyTrackerPlugin: (specifiers: Set<string>, importMap: ParsedImportMap, baseURL: URL) => Plugin;
+interface VendorNPMSpecifiersOptions {
+    basePath: string;
+    directory?: string;
+    functions: string[];
+    importMap: ImportMap;
+    logger: Logger;
+}
+export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, importMap, logger, }: VendorNPMSpecifiersOptions) => Promise<{
+    cleanup: () => Promise<void>;
+    directory: string;
+    importMap: {
+        baseURL: import("url").URL;
+        imports: Record<string, string>;
+    };
+} | undefined>;
+export {};

package/dist/node/npm_dependencies.js

@@ -0,0 +1,189 @@
+import { promises as fs } from 'fs';
+import { builtinModules, createRequire } from 'module';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { resolve } from '@import-maps/resolve';
+import { build } from 'esbuild';
+import tmp from 'tmp-promise';
+import { nodePrefix, npmPrefix } from '../shared/consts.js';
+const builtinModulesSet = new Set(builtinModules);
+const require = createRequire(import.meta.url);
+// Workaround for https://github.com/evanw/esbuild/issues/1921.
+const banner = {
+    js: `
+  import {createRequire as ___nfyCreateRequire} from "module";
+  import {fileURLToPath as ___nfyFileURLToPath} from "url";
+  import {dirname as ___nfyPathDirname} from "path";
+  let __filename=___nfyFileURLToPath(import.meta.url);
+  let __dirname=___nfyPathDirname(___nfyFileURLToPath(import.meta.url));
+  let require=___nfyCreateRequire(import.meta.url);
+  `,
+};
+// esbuild plugin that will traverse the code and look for imports of external
+// dependencies (i.e. Node modules). It stores the specifiers found in the Set
+// provided.
+export const getDependencyTrackerPlugin = (specifiers, importMap, baseURL) => ({
+    name: 'dependency-tracker',
+    setup(build) {
+        build.onResolve({ filter: /^(.*)$/ }, (args) => {
+            if (args.kind !== 'import-statement') {
+                return;
+            }
+            const result = {};
+            let specifier = args.path;
+            // Start by checking whether the specifier matches any import map defined
+            // by the user.
+            const { matched, resolvedImport } = resolve(specifier, importMap, baseURL);
+            // If it does, the resolved import is the specifier we'll evaluate going
+            // forward.
+            if (matched) {
+                specifier = fileURLToPath(resolvedImport).replace(/\\/g, '/');
+                result.path = specifier;
+            }
+            // If the specifier is a Node.js built-in, we don't want to bundle it.
+            if (specifier.startsWith(nodePrefix) || builtinModulesSet.has(specifier)) {
+                return { external: true };
+            }
+            // If the specifier has the `npm:` prefix, strip it and use the rest of
+            // the specifier to resolve the module.
+            if (specifier.startsWith(npmPrefix)) {
+                const canonicalPath = specifier.slice(npmPrefix.length);
+                return build.resolve(canonicalPath, {
+                    kind: args.kind,
+                    resolveDir: args.resolveDir,
+                });
+            }
+            const isLocalImport = specifier.startsWith(path.sep) || specifier.startsWith('.');
+            // If this is a local import, return so that esbuild visits that path.
+            if (isLocalImport) {
+                return result;
+            }
+            const isRemoteURLImport = specifier.startsWith('https://') || specifier.startsWith('http://');
+            if (isRemoteURLImport) {
+                return { external: true };
+            }
+            // At this point we know we're dealing with a bare specifier that should
+            // be treated as an external module. We first try to resolve it, because
+            // in the event that it doesn't exist (e.g. user is referencing a module
+            // that they haven't installed) we won't even attempt to bundle it. This
+            // lets the ESZIP bundler handle and report the missing import instead of
+            // esbuild, which is a better experience for the user.
+            try {
+                require.resolve(specifier, { paths: [args.resolveDir] });
+                specifiers.add(specifier);
+            }
+            catch {
+                // no-op
+            }
+            // Mark the specifier as external, because we don't want to traverse the
+            // entire module tree — i.e. if user code imports module `foo` and that
+            // imports `bar`, we only want to add `foo` to the list of specifiers,
+            // since the whole module — including its dependencies like `bar` —
+            // will be bundled.
+            return { external: true };
+        });
+    },
+});
+export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, logger, }) => {
+    const specifiers = new Set();
+    // The directories that esbuild will use when resolving Node modules. We must
+    // set these manually because esbuild will be operating from a temporary
+    // directory that will not live inside the project root, so the normal
+    // resolution logic won't work.
+    const nodePaths = [path.join(basePath, 'node_modules')];
+    // We need to create some files on disk, which we don't want to write to the
+    // project directory. If a custom directory has been specified, which happens
+    // only in tests, we use it. Otherwise, create a random temporary directory.
+    const temporaryDirectory = directory ? { path: directory } : await tmp.dir();
+    // Do a first pass at bundling to gather a list of specifiers that should be
+    // loaded as npm dependencies, because they either use the `npm:` prefix or
+    // they are bare specifiers. We'll collect them in `specifiers`.
+    try {
+        await build({
+            banner,
+            bundle: true,
+            entryPoints: functions,
+            logLevel: 'error',
+            nodePaths,
+            outdir: temporaryDirectory.path,
+            platform: 'node',
+            plugins: [getDependencyTrackerPlugin(specifiers, importMap.getContentsWithURLObjects(), pathToFileURL(basePath))],
+            write: false,
+        });
+    }
+    catch (error) {
+        logger.system('Could not track dependencies in edge function:', error);
+        logger.user('An error occurred when trying to scan your edge functions for npm modules, which is an experimental feature. If you are loading npm modules, please share the errors above in https://ntl.fyi/edge-functions-npm. If you are not loading npm modules, you can ignore this message.');
+    }
+    // If we found no specifiers, there's nothing left to do here.
+    if (specifiers.size === 0) {
+        return;
+    }
+    logger.user('You are using npm modules in Edge Functions, which is an experimental feature. Learn more at https://ntl.fyi/edge-functions-npm.');
+    // To bundle an entire module and all its dependencies, we create a stub file
+    // where we re-export everything from that specifier. We do this for every
+    // specifier, and each of these files will be the entry points to esbuild.
+    const ops = await Promise.all([...specifiers].map(async (specifier, index) => {
+        const code = `import * as mod from "${specifier}"; export default mod.default; export * from "${specifier}";`;
+        const filePath = path.join(temporaryDirectory.path, `stub-${index}.js`);
+        await fs.writeFile(filePath, code);
+        return { filePath, specifier };
+    }));
+    const entryPoints = ops.map(({ filePath }) => filePath);
+    // Bundle each of the stub files we've created. We'll end up with a compiled
+    // version of each of the stub files, plus any chunks of shared code between
+    // stubs (such that a common module isn't bundled twice).
+    await build({
+        allowOverwrite: true,
+        banner,
+        bundle: true,
+        entryPoints,
+        format: 'esm',
+        logLevel: 'error',
+        nodePaths,
+        outdir: temporaryDirectory.path,
+        platform: 'node',
+        splitting: true,
+        target: 'es2020',
+    });
+    // Add all Node.js built-ins to the import map, so any unprefixed specifiers
+    // (e.g. `process`) resolve to the prefixed versions (e.g. `node:prefix`),
+    // which Deno can process.
+    const builtIns = builtinModules.reduce((acc, name) => ({
+        ...acc,
+        [name]: `node:${name}`,
+    }), {});
+    // Creates an object that is compatible with the `imports` block of an import
+    // map, mapping specifiers to the paths of their bundled files on disk. Each
+    // specifier gets two entries in the import map, one with the `npm:` prefix
+    // and one without, such that both options are supported.
+    const newImportMap = {
+        baseURL: pathToFileURL(temporaryDirectory.path),
+        imports: ops.reduce((acc, op) => {
+            const url = pathToFileURL(op.filePath).toString();
+            return {
+                ...acc,
+                [op.specifier]: url,
+                [npmPrefix + op.specifier]: url,
+            };
+        }, builtIns),
+    };
+    const cleanup = async () => {
+        // If a custom temporary directory was specified, we leave the cleanup job
+        // up to the caller.
+        if (directory) {
+            return;
+        }
+        try {
+            await fs.rm(temporaryDirectory.path, { force: true, recursive: true });
+        }
+        catch {
+            // no-op
+        }
+    };
+    return {
+        cleanup,
+        directory: temporaryDirectory.path,
+        importMap: newImportMap,
+    };
+};

package/dist/shared/consts.d.ts

@@ -1,2 +1,5 @@
 export declare const importMapSpecifier = "netlify:import-map";
+export declare const nodePrefix = "node:";
+export declare const npmPrefix = "npm:";
 export declare const virtualRoot = "file:///root/";
+export declare const virtualVendorRoot = "file:///vendor/";

package/dist/shared/consts.js

@@ -1,2 +1,5 @@
 export const importMapSpecifier = 'netlify:import-map';
+export const nodePrefix = 'node:';
+export const npmPrefix = 'npm:';
 export const virtualRoot = 'file:///root/';
+export const virtualVendorRoot = 'file:///vendor/';

package/dist/shared/stage2.d.ts

@@ -8,4 +8,5 @@ export interface WriteStage2Options {
     externals: string[];
     functions: InputFunction[];
     importMapData?: string;
+    vendorDirectory?: string;
 }

package/dist/test/util.d.ts

@@ -7,5 +7,5 @@ declare const useFixture: (fixtureName: string) => Promise<{
     distPath: string;
 }>;
 declare const getRouteMatcher: (manifest: Manifest) => (candidate: string) => import("../node/manifest.js").Route | undefined;
-declare const runESZIP: (eszipPath: string) => Promise<any>;
+declare const runESZIP: (eszipPath: string, vendorDirectory?: string) => Promise<any>;
 export { fixturesDir, getRouteMatcher, testLogger, runESZIP, useFixture };

package/dist/test/util.js

@@ -48,7 +48,7 @@ const getRouteMatcher = (manifest) => (candidate) => manifest.routes.find((route
     const isExcluded = excludedPatterns.some((pattern) => new RegExp(pattern).test(candidate));
     return !isExcluded;
 });
-const runESZIP = async (eszipPath) => {
+const runESZIP = async (eszipPath, vendorDirectory) => {
     var _a, _b, _c;
     const tmpDir = await tmp.dir({ unsafeCleanup: true });
     // Extract ESZIP into temporary directory.
@@ -68,7 +68,10 @@ const runESZIP = async (eszipPath) => {
     const importMapPath = join(virtualRootPath, '..', 'import-map');
     for (const path of [importMapPath, stage2Path]) {
         const file = await fs.readFile(path, 'utf8');
-        const normalizedFile = file.replace(/file:\/\/\/root/g, pathToFileURL(virtualRootPath).toString());
+        let normalizedFile = file.replace(/file:\/{3}root/g, pathToFileURL(virtualRootPath).toString());
+        if (vendorDirectory !== undefined) {
+            normalizedFile = normalizedFile.replace(/file:\/{3}vendor/g, pathToFileURL(vendorDirectory).toString());
+        }
         await fs.writeFile(path, normalizedFile);
     }
     await fs.rename(stage2Path, `${stage2Path}.js`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.19.1",
+  "version": "8.20.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -79,6 +79,7 @@
     "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
     "env-paths": "^3.0.0",
+    "esbuild": "0.19.2",
     "execa": "^6.0.0",
     "find-up": "^6.3.0",
     "get-port": "^6.1.2",

package/shared/consts.ts

@@ -1,2 +1,5 @@
 export const importMapSpecifier = 'netlify:import-map'
+export const nodePrefix = 'node:'
+export const npmPrefix = 'npm:'
 export const virtualRoot = 'file:///root/'
+export const virtualVendorRoot = 'file:///vendor/'

package/shared/stage2.ts

@@ -9,4 +9,5 @@ export interface WriteStage2Options {
   externals: string[]
   functions: InputFunction[]
   importMapData?: string
+  vendorDirectory?: string
 }