@netlify/edge-bundler 14.5.6 → 14.7.0

package/deno/extract.ts

@@ -0,0 +1,7 @@
+import { loadESZIP } from 'https://deno.land/x/eszip@v0.55.2/eszip.ts'
+
+const [functionPath, destPath] = Deno.args
+
+const eszip = await loadESZIP(functionPath)
+
+await eszip.extract(destPath)

package/deno/lib/stage2.ts

@@ -105,7 +105,7 @@ const stage2Loader = (
   }
 }
 
-const writeStage2 = async ({
+export const writeStage2 = async ({
   basePath,
   destPath,
   externals,
@@ -122,5 +122,3 @@ const writeStage2 = async ({
 
   return await Deno.writeFile(destPath, bytes)
 }
-
-export { writeStage2 }

package/deno/vendor/deno.land/x/eszip@v0.55.2/eszip.ts

@@ -0,0 +1,192 @@
+// CLI utility to build/list/extract/run ESZIPs
+
+import { build, Parser } from "./mod.ts";
+import { dirname, join } from "https://deno.land/std@0.177.0/path/mod.ts";
+
+function hasV2Header(bytes: Uint8Array) {
+  const magicV2 = new TextDecoder().decode(bytes.slice(0, 8));
+  return magicV2 === "ESZIP_V2";
+}
+
+interface ESZIP {
+  extract(dest: string): Promise<void>;
+  list(): string[];
+}
+
+interface V1Entry {
+  Source: {
+    source: string;
+    transpiled: string;
+  };
+}
+
+class V1 {
+  inner: Record<string, V1Entry>;
+
+  constructor(bytes: Uint8Array) {
+    const json = new TextDecoder().decode(bytes);
+    const eszip = JSON.parse(json);
+    this.inner = eszip;
+  }
+
+  static load(bytes: Uint8Array) {
+    return Promise.resolve(new V1(bytes));
+  }
+
+  *entries() {
+    for (
+      const [
+        url,
+        {
+          Source: { source, transpiled },
+        },
+      ] of Object.entries(this.inner.modules)
+    ) {
+      yield { url, source, transpiled };
+    }
+  }
+
+  async extract(dest: string) {
+    for (const { url, source, transpiled } of this.entries()) {
+      await write(join(dest, "source", url2path(url)), source);
+      await write(
+        join(dest, "transpiled", url2path(url)),
+        transpiled ?? source,
+      );
+    }
+  }
+
+  list() {
+    return Array.from(this.entries()).map((e) => e.url);
+  }
+}
+
+class V2 {
+  parser: Parser;
+  specifiers: string[];
+
+  constructor(parser: Parser, specifiers: string[]) {
+    this.parser = parser;
+    this.specifiers = specifiers;
+  }
+
+  static async load(bytes: Uint8Array) {
+    const parser = await Parser.createInstance();
+    const specifiers = await parser.parseBytes(bytes);
+    await parser.load();
+    return new V2(parser, specifiers as string[]);
+  }
+
+  async extract(dest: string) {
+    const imports: Record<string, string> = {};
+
+    for (const specifier of this.specifiers) {
+      const module = await this.parser.getModuleSource(specifier);
+      await write(join(dest, "source", url2path(specifier)), module);
+      // Track import
+      imports[specifier] = `./${url2path(specifier)}`;
+    }
+    // Write import map
+    const importMap = JSON.stringify({ imports }, null, 2);
+    await Deno.writeTextFile(
+      join(dest, "source", "import_map.json"),
+      importMap,
+    );
+  }
+
+  list() {
+    return this.specifiers;
+  }
+}
+
+export async function loadESZIP(filename: string): Promise<ESZIP> {
+  const bytes = await Deno.readFile(filename);
+  if (hasV2Header(bytes)) {
+    return await V2.load(bytes);
+  }
+  return await V1.load(bytes);
+}
+
+function url2path(urlString: string) {
+  const url = new URL(urlString);
+  const tail = url.pathname.split("/").filter(Boolean);
+  const relativePath = tail.length === 0 ? [".root"] : tail;
+  return join(url.hostname, ...relativePath);
+}
+
+async function write(path: string, content: string) {
+  await Deno.mkdir(dirname(path), { recursive: true });
+  await Deno.writeTextFile(path, content);
+}
+
+async function run(eszip: ESZIP, specifier: string) {
+  // Extract to tmp directory
+  const tmpDir = await Deno.makeTempDir({ prefix: "esz" });
+  try {
+    // Extract
+    await eszip.extract(tmpDir);
+    const importMap = join(tmpDir, "source", "import_map.json");
+    // Run
+    const p = new Deno.Command("deno", {
+      args: [
+        "run",
+        "-A",
+        "--no-check",
+        "--import-map",
+        importMap,
+        specifier,
+      ],
+    });
+    await p.output();
+  } finally {
+    // Cleanup
+    await Deno.remove(tmpDir, { recursive: true });
+  }
+}
+
+// Main
+async function main() {
+  const args = Deno.args;
+  const [subcmd, filename, ...rest] = args;
+
+  if (subcmd === "help") {
+    return console.log("TODO");
+  }
+
+  switch (subcmd) {
+    case "build":
+    case "b": {
+      const eszip = await build([filename]);
+      let out = rest[0];
+      if (!out) {
+        // Create outfile name from url filename
+        out = new URL(filename).pathname.split("/").pop() || "out";
+      }
+      console.log(`${out}.eszip: ${eszip.length} bytes`);
+      await Deno.writeFile(`${out}.eszip`, eszip);
+      return;
+    }
+    case "x":
+    case "extract": {
+      const eszip = await loadESZIP(filename);
+      return await eszip.extract(rest[0] ?? Deno.cwd());
+    }
+    case "l":
+    case "ls":
+    case "list": {
+      const eszip = await loadESZIP(filename);
+      return console.log(eszip.list().join("\n"));
+    }
+    case "r":
+    case "run": {
+      const eszip = await loadESZIP(filename);
+      const specifier = rest[0];
+      if (!specifier) {
+        return console.error("Please provide a specifier to run");
+      }
+      return await run(eszip, specifier);
+    }
+  }
+}
+
+await main();

package/dist/node/bridge.js

@@ -15,21 +15,28 @@ const DENO_VERSION_FILE = 'version.txt';
 export const DENO_VERSION_RANGE = '1.39.0 - 2.2.4';
 const NEXT_DENO_VERSION_RANGE = '^2.4.2';
 export class DenoBridge {
+    cacheDirectory;
+    currentDownload;
+    debug;
+    denoDir;
+    logger;
+    onAfterDownload;
+    onBeforeDownload;
+    useGlobal;
+    versionRange;
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f;
-        this.cacheDirectory = (_a = options.cacheDirectory) !== null && _a !== void 0 ? _a : getPathInHome('deno-cli');
-        this.debug = (_b = options.debug) !== null && _b !== void 0 ? _b : false;
+        this.cacheDirectory = options.cacheDirectory ?? getPathInHome('deno-cli');
+        this.debug = options.debug ?? false;
         this.denoDir = options.denoDir;
-        this.logger = (_c = options.logger) !== null && _c !== void 0 ? _c : getLogger(undefined, undefined, options.debug);
+        this.logger = options.logger ?? getLogger(undefined, undefined, options.debug);
         this.onAfterDownload = options.onAfterDownload;
         this.onBeforeDownload = options.onBeforeDownload;
-        this.useGlobal = (_d = options.useGlobal) !== null && _d !== void 0 ? _d : true;
-        this.versionRange =
-            (_e = options.versionRange) !== null && _e !== void 0 ? _e : (((_f = options.featureFlags) === null || _f === void 0 ? void 0 : _f.edge_bundler_generate_tarball) ? NEXT_DENO_VERSION_RANGE : DENO_VERSION_RANGE);
+        this.useGlobal = options.useGlobal ?? true;
+        const useNextDeno = options.featureFlags?.edge_bundler_generate_tarball || options.featureFlags?.edge_bundler_deno_v2;
+        this.versionRange = options.versionRange ?? (useNextDeno ? NEXT_DENO_VERSION_RANGE : DENO_VERSION_RANGE);
     }
     async downloadBinary() {
-        var _a, _b, _c;
-        await ((_a = this.onBeforeDownload) === null || _a === void 0 ? void 0 : _a.call(this));
+        await this.onBeforeDownload?.();
         await this.ensureCacheDirectory();
         this.logger.system(`Downloading Deno CLI to ${this.cacheDirectory}`);
         const binaryPath = await download(this.cacheDirectory, this.versionRange, this.logger);
@@ -39,12 +46,12 @@ export class DenoBridge {
         // that the tests catch it.
         if (downloadedVersion === undefined) {
             const error = new Error('There was a problem setting up the Edge Functions environment. To try a manual installation, visit https://ntl.fyi/install-deno.');
-            await ((_b = this.onAfterDownload) === null || _b === void 0 ? void 0 : _b.call(this, error));
+            await this.onAfterDownload?.(error);
             this.logger.system('Could not run downloaded Deno CLI', error);
             throw error;
         }
         await this.writeVersionFile(downloadedVersion);
-        await ((_c = this.onAfterDownload) === null || _c === void 0 ? void 0 : _c.call(this));
+        await this.onAfterDownload?.();
         return binaryPath;
     }
     async getBinaryVersion(binaryPath) {
@@ -97,19 +104,18 @@ export class DenoBridge {
         return this.currentDownload;
     }
     static runWithBinary(binaryPath, args, { options, pipeOutput, stderr, stdout, }) {
-        var _a, _b, _c, _d;
         const runDeno = execa(binaryPath, args, options);
         if (stderr) {
-            (_a = runDeno.stderr) === null || _a === void 0 ? void 0 : _a.pipe(stderr);
+            runDeno.stderr?.pipe(stderr);
         }
         else if (pipeOutput) {
-            (_b = runDeno.stderr) === null || _b === void 0 ? void 0 : _b.pipe(process.stderr);
+            runDeno.stderr?.pipe(process.stderr);
         }
         if (stdout) {
-            (_c = runDeno.stdout) === null || _c === void 0 ? void 0 : _c.pipe(stdout);
+            runDeno.stdout?.pipe(stdout);
         }
         else if (pipeOutput) {
-            (_d = runDeno.stdout) === null || _d === void 0 ? void 0 : _d.pipe(process.stdout);
+            runDeno.stdout?.pipe(process.stdout);
         }
         return runDeno;
     }
@@ -124,14 +130,14 @@ export class DenoBridge {
     async getBinaryPath(options) {
         const globalPath = await this.getGlobalBinary();
         if (globalPath !== undefined) {
-            if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+            if (!options?.silent) {
                 this.logger.system('Using global installation of Deno CLI');
             }
             return { global: true, path: globalPath };
         }
         const cachedPath = await this.getCachedBinary();
         if (cachedPath !== undefined) {
-            if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+            if (!options?.silent) {
                 this.logger.system('Using cached Deno CLI from', cachedPath);
             }
             return { global: false, path: cachedPath };

package/dist/node/bridge.test.js

@@ -12,8 +12,7 @@ import { getPlatformTarget } from './platform.js';
 const require = createRequire(import.meta.url);
 const archiver = require('archiver');
 const getMockDenoBridge = function (tmpDir, mockBinaryOutput) {
-    var _a, _b;
-    const latestVersion = (_b = (_a = semver.minVersion(DENO_VERSION_RANGE)) === null || _a === void 0 ? void 0 : _a.version) !== null && _b !== void 0 ? _b : '';
+    const latestVersion = semver.minVersion(DENO_VERSION_RANGE)?.version ?? '';
     const data = new PassThrough();
     const archive = archiver('zip', { zlib: { level: 9 } });
     archive.pipe(data);
@@ -32,7 +31,6 @@ const getMockDenoBridge = function (tmpDir, mockBinaryOutput) {
     });
 };
 test('Does not inherit environment variables if `extendEnv` is false', async () => {
-    var _a;
     const tmpDir = await tmp.dir();
     const deno = getMockDenoBridge(tmpDir, `#!/usr/bin/env sh
 
@@ -46,9 +44,9 @@ test('Does not inherit environment variables if `extendEnv` is false', async ()
     const referenceOutput = await deno.run(['test'], { env: {}, extendEnv: false });
     env.TADA = 'TUDU';
     const result = await deno.run(['test'], { env: { LULU: 'LALA' }, extendEnv: false });
-    let output = (_a = result === null || result === void 0 ? void 0 : result.stdout) !== null && _a !== void 0 ? _a : '';
+    let output = result?.stdout ?? '';
     delete env.TADA;
-    referenceOutput === null || referenceOutput === void 0 ? void 0 : referenceOutput.stdout.split('\n').forEach((line) => {
+    referenceOutput?.stdout.split('\n').forEach((line) => {
         output = output.replace(line.trim(), '');
     });
     output = output.trim().replace(/\n+/g, '\n');
@@ -56,7 +54,6 @@ test('Does not inherit environment variables if `extendEnv` is false', async ()
     await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Does inherit environment variables if `extendEnv` is true', async () => {
-    var _a;
     const tmpDir = await tmp.dir();
     const deno = getMockDenoBridge(tmpDir, `#!/usr/bin/env sh
 
@@ -70,9 +67,9 @@ test('Does inherit environment variables if `extendEnv` is true', async () => {
     const referenceOutput = await deno.run(['test'], { env: {}, extendEnv: true });
     env.TADA = 'TUDU';
     const result = await deno.run(['test'], { env: { LULU: 'LALA' }, extendEnv: true });
-    let output = (_a = result === null || result === void 0 ? void 0 : result.stdout) !== null && _a !== void 0 ? _a : '';
+    let output = result?.stdout ?? '';
     delete env.TADA;
-    referenceOutput === null || referenceOutput === void 0 ? void 0 : referenceOutput.stdout.split('\n').forEach((line) => {
+    referenceOutput?.stdout.split('\n').forEach((line) => {
         output = output.replace(line.trim(), '');
     });
     // lets remove holes, split lines and sort lines by name, as different OSes might order them different
@@ -81,7 +78,6 @@ test('Does inherit environment variables if `extendEnv` is true', async () => {
     await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Does inherit environment variables if `extendEnv` is not set', async () => {
-    var _a;
     const tmpDir = await tmp.dir();
     const deno = getMockDenoBridge(tmpDir, `#!/usr/bin/env sh
 
@@ -95,9 +91,9 @@ test('Does inherit environment variables if `extendEnv` is not set', async () =>
     const referenceOutput = await deno.run(['test'], { env: {}, extendEnv: true });
     env.TADA = 'TUDU';
     const result = await deno.run(['test'], { env: { LULU: 'LALA' } });
-    let output = (_a = result === null || result === void 0 ? void 0 : result.stdout) !== null && _a !== void 0 ? _a : '';
+    let output = result?.stdout ?? '';
     delete env.TADA;
-    referenceOutput === null || referenceOutput === void 0 ? void 0 : referenceOutput.stdout.split('\n').forEach((line) => {
+    referenceOutput?.stdout.split('\n').forEach((line) => {
         output = output.replace(line.trim(), '');
     });
     // lets remove holes, split lines and sort lines by name, as different OSes might order them different

package/dist/node/bundle_error.d.ts

@@ -1,5 +1,6 @@
 interface BundleErrorOptions {
-    format: string;
+    cause?: unknown;
+    format?: string;
 }
 declare const getCustomErrorInfo: (options?: BundleErrorOptions) => {
     location: {
@@ -8,12 +9,12 @@ declare const getCustomErrorInfo: (options?: BundleErrorOptions) => {
     };
     type: string;
 };
-declare class BundleError extends Error {
+export declare class BundleError extends Error {
     customErrorInfo: ReturnType<typeof getCustomErrorInfo>;
     constructor(originalError: Error, options?: BundleErrorOptions);
 }
 /**
  * BundleErrors are treated as user-error, so Netlify Team is not alerted about them.
  */
-declare const wrapBundleError: (input: unknown, options?: BundleErrorOptions) => unknown;
-export { BundleError, wrapBundleError };
+export declare const wrapBundleError: (input: unknown, options?: BundleErrorOptions) => unknown;
+export {};

package/dist/node/bundle_error.js

@@ -1,13 +1,14 @@
 const getCustomErrorInfo = (options) => ({
     location: {
-        format: options === null || options === void 0 ? void 0 : options.format,
+        format: options?.format,
         runtime: 'deno',
     },
     type: 'functionsBundling',
 });
-class BundleError extends Error {
+export class BundleError extends Error {
+    customErrorInfo;
     constructor(originalError, options) {
-        super(originalError.message);
+        super(originalError.message, { cause: options?.cause });
         this.customErrorInfo = getCustomErrorInfo(options);
         this.name = 'BundleError';
         this.stack = originalError.stack;
@@ -18,7 +19,7 @@ class BundleError extends Error {
 /**
  * BundleErrors are treated as user-error, so Netlify Team is not alerted about them.
  */
-const wrapBundleError = (input, options) => {
+export const wrapBundleError = (input, options) => {
     if (input instanceof Error) {
         if (input.message.includes("The module's source code could not be parsed")) {
             input.message = input.stderr;
@@ -27,4 +28,3 @@ const wrapBundleError = (input, options) => {
     }
     return input;
 };
-export { BundleError, wrapBundleError };

package/dist/node/bundler.js

@@ -1,5 +1,5 @@
 import { promises as fs } from 'fs';
-import { join } from 'path';
+import { join, relative } from 'path';
 import commonPathPrefix from 'common-path-prefix';
 import { v4 as uuidv4 } from 'uuid';
 import { importMapSpecifier } from '../shared/consts.js';
@@ -9,7 +9,7 @@ import { mergeDeclarations } from './declaration.js';
 import { load as loadDeployConfig } from './deploy_config.js';
 import { getFlags } from './feature_flags.js';
 import { findFunctions } from './finder.js';
-import { bundle as bundleESZIP } from './formats/eszip.js';
+import { bundle as bundleESZIP, extension as eszipExtension, extract as extractESZIP } from './formats/eszip.js';
 import { bundle as bundleTarball } from './formats/tarball.js';
 import { ImportMap } from './import_map.js';
 import { getLogger } from './logger.js';
@@ -47,7 +47,7 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
     const internalSrcFolders = (Array.isArray(internalSrcFolder) ? internalSrcFolder : [internalSrcFolder]).filter(nonNullable);
     const userSourceDirectories = sourceDirectories.filter((dir) => !internalSrcFolders.includes(dir));
     const importMap = new ImportMap();
-    await importMap.addFiles([deployConfig === null || deployConfig === void 0 ? void 0 : deployConfig.importMap, ...importMapPaths], logger);
+    await importMap.addFiles([deployConfig?.importMap, ...importMapPaths], logger);
     const userFunctions = userSourceDirectories.length === 0 ? [] : await findFunctions(userSourceDirectories);
     const internalFunctions = internalSrcFolder ? await findFunctions(internalSrcFolders) : [];
     const functions = [...internalFunctions, ...userFunctions];
@@ -57,7 +57,7 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         functions,
         importMap,
         logger,
-        rootPath: rootPath !== null && rootPath !== void 0 ? rootPath : basePath,
+        rootPath: rootPath ?? basePath,
         vendorDirectory,
     });
     const bundles = [];
@@ -71,7 +71,7 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
             functions,
             featureFlags,
             importMap: importMap.clone(),
-            vendorDirectory: vendor === null || vendor === void 0 ? void 0 : vendor.directory,
+            vendorDirectory: vendor?.directory,
         }));
     }
     if (vendor) {
@@ -87,19 +87,23 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         functions,
         featureFlags,
         importMap,
-        vendorDirectory: vendor === null || vendor === void 0 ? void 0 : vendor.directory,
+        vendorDirectory: 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
     // rename the bundles to their permanent names.
-    await createFinalBundles(bundles, distDirectory, buildID);
-    // Retrieving a configuration object for each function.
-    // Run `getFunctionConfig` in parallel as it is a non-trivial operation and spins up deno
-    const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger })]);
-    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger })]);
-    // Creating a hash of function names to configuration objects.
-    const internalFunctionsWithConfig = Object.fromEntries(await Promise.all(internalConfigPromises));
-    const userFunctionsWithConfig = Object.fromEntries(await Promise.all(userConfigPromises));
+    const bundlePaths = await createFinalBundles(bundles, distDirectory, buildID);
+    const eszipPath = bundlePaths.find((path) => path.endsWith(eszipExtension));
+    const { internalFunctions: internalFunctionsWithConfig, userFunctions: userFunctionsWithConfig } = await getFunctionConfigs({
+        basePath,
+        deno,
+        eszipPath,
+        featureFlags,
+        importMap,
+        internalFunctions,
+        log: logger,
+        userFunctions,
+    });
     // Creating a final declarations array by combining the TOML file with the
     // deploy configuration API and the in-source configuration.
     const declarations = mergeDeclarations(tomlDeclarations, userFunctionsWithConfig, internalFunctionsWithConfig, deployConfig.declarations, featureFlags);
@@ -118,19 +122,54 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         importMap: importMapSpecifier,
         layers: deployConfig.layers,
     });
-    await (vendor === null || vendor === void 0 ? void 0 : vendor.cleanup());
+    await vendor?.cleanup();
     if (distImportMapPath) {
         await importMap.writeToFile(distImportMapPath);
     }
     return { functions, manifest };
 };
+const getFunctionConfigs = async ({ basePath, deno, eszipPath, featureFlags, importMap, log, internalFunctions, userFunctions, }) => {
+    try {
+        const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig({ functionPath: func.path, importMap, deno, log })]);
+        const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig({ functionPath: func.path, importMap, deno, log })]);
+        // Creating a hash of function names to configuration objects.
+        const internalFunctionsWithConfig = Object.fromEntries(await Promise.all(internalConfigPromises));
+        const userFunctionsWithConfig = Object.fromEntries(await Promise.all(userConfigPromises));
+        return {
+            internalFunctions: internalFunctionsWithConfig,
+            userFunctions: userFunctionsWithConfig,
+        };
+    }
+    catch (err) {
+        if (!(err instanceof Error && err.cause === 'IMPORT_ASSERT') || !eszipPath || !featureFlags?.edge_bundler_deno_v2) {
+            throw err;
+        }
+        // We failed to extract the configuration because there is an import assert
+        // in the function code, a deprecated feature that we used to support with
+        // Deno 1.x. To avoid a breaking change, we treat this error as a special
+        // case, using the generated ESZIP to extract the configuration. This works
+        // because import asserts are transpiled to import attributes.
+        const extractedESZIP = await extractESZIP(deno, eszipPath);
+        const configs = await Promise.all([...internalFunctions, ...userFunctions].map(async (func) => {
+            const relativePath = relative(basePath, func.path);
+            const functionPath = join(extractedESZIP.path, relativePath);
+            return [func.name, await getFunctionConfig({ functionPath, importMap, deno, log })];
+        }));
+        await extractedESZIP.cleanup();
+        return {
+            internalFunctions: Object.fromEntries(configs.slice(0, internalFunctions.length)),
+            userFunctions: Object.fromEntries(configs.slice(internalFunctions.length)),
+        };
+    }
+};
 const createFinalBundles = async (bundles, distDirectory, buildID) => {
     const renamingOps = bundles.map(async ({ extension, hash }) => {
         const tempBundlePath = join(distDirectory, `${buildID}${extension}`);
         const finalBundlePath = join(distDirectory, `${hash}${extension}`);
         await fs.rename(tempBundlePath, finalBundlePath);
+        return finalBundlePath;
     });
-    await Promise.all(renamingOps);
+    return await Promise.all(renamingOps);
 };
 const getBasePath = (sourceDirectories, inputBasePath) => {
     // If there's a specific base path supplied, that takes precedence.
@@ -148,11 +187,11 @@ const getBasePath = (sourceDirectories, inputBasePath) => {
 // declaration level. We want these properties to live at the function level
 // in their config object, so we translate that for backwards-compatibility.
 const mergeWithDeclarationConfig = ({ functionName, config, declarations }) => {
-    const declaration = declarations === null || declarations === void 0 ? void 0 : declarations.find((decl) => decl.function === functionName);
+    const declaration = declarations?.find((decl) => decl.function === functionName);
     return {
         ...config,
-        name: (declaration === null || declaration === void 0 ? void 0 : declaration.name) || config.name,
-        generator: (declaration === null || declaration === void 0 ? void 0 : declaration.generator) || config.generator,
+        name: declaration?.name || config.name,
+        generator: declaration?.generator || config.generator,
     };
 };
 const addGeneratorFallback = (config) => ({

package/dist/node/bundler.test.js

@@ -3,7 +3,7 @@ import { access, readdir, readFile, rm, writeFile } from 'fs/promises';
 import { join, resolve } from 'path';
 import process from 'process';
 import { pathToFileURL } from 'url';
-import { gte, lt } from 'semver';
+import { lt } from 'semver';
 import * as tar from 'tar';
 import tmp from 'tmp-promise';
 import { test, expect, vi, describe } from 'vitest';
@@ -498,23 +498,16 @@ test('Loads JSON modules with `with` attribute', async () => {
     await cleanup();
     await rm(vendorDirectory.path, { force: true, recursive: true });
 });
-// We can't run this on versions above 2.0.0 because the bundling will fail
-// entirely, and what we're asserting here is that we emit a system log when
-// import assertions are detected on successful builds. Also, running it on
-// earlier versions won't work either, since those won't even show a warning.
-test.skipIf(lt(denoVersion, '1.46.3') || gte(denoVersion, '2.0.0'))('Emits a system log when import assertions are used', async () => {
+test('Emits a system log when import assertions are used', async () => {
     const { basePath, cleanup, distPath } = await useFixture('with_import_assert');
     const sourceDirectory = join(basePath, 'functions');
-    const declarations = [
-        {
-            function: 'func1',
-            path: '/func1',
-        },
-    ];
     const vendorDirectory = await tmp.dir();
     const systemLogger = vi.fn();
-    await bundle([sourceDirectory], distPath, declarations, {
+    await bundle([sourceDirectory], distPath, [], {
         basePath,
+        featureFlags: {
+            edge_bundler_deno_v2: true,
+        },
         systemLogger,
         vendorDirectory: vendorDirectory.path,
     });
@@ -524,6 +517,12 @@ test.skipIf(lt(denoVersion, '1.46.3') || gte(denoVersion, '2.0.0'))('Emits a sys
     const { func1 } = await runESZIP(bundlePath, vendorDirectory.path);
     expect(func1).toBe(`{"foo":"bar"}`);
     expect(systemLogger).toHaveBeenCalledWith(`Edge function uses import assertions: ${join(sourceDirectory, 'func1.ts')}`);
+    expect(manifest.routes[0]).toEqual({
+        function: 'func1',
+        pattern: '^/with-import-assert/?$',
+        excluded_patterns: [],
+        path: '/with-import-assert',
+    });
     await cleanup();
     await rm(vendorDirectory.path, { force: true, recursive: true });
 });
@@ -656,4 +655,4 @@ describe.skipIf(lt(denoVersion, '2.4.3'))('Produces a tarball bundle', () => {
         await cleanup();
         await rm(vendorDirectory.path, { force: true, recursive: true });
     });
-}, 10000);
+}, 10_000);

package/dist/node/config.d.ts

@@ -1,5 +1,4 @@
 import { DenoBridge } from './bridge.js';
-import { EdgeFunction } from './edge_function.js';
 import { ImportMap } from './import_map.js';
 import { Logger } from './logger.js';
 import { RateLimit } from './rate_limit.js';
@@ -31,10 +30,10 @@ interface FunctionConfigWithPattern extends BaseFunctionConfig {
 }
 export type FunctionConfig = FunctionConfigWithPath | FunctionConfigWithPattern;
 export type FunctionConfigWithAllPossibleFields = BaseFunctionConfig & Partial<FunctionConfigWithPath & FunctionConfigWithPattern>;
-export declare const getFunctionConfig: ({ func, importMap, deno, log, }: {
-    func: EdgeFunction;
-    importMap: ImportMap;
+export declare const getFunctionConfig: ({ deno, functionPath, importMap, log, }: {
     deno: DenoBridge;
+    functionPath: string;
+    importMap: ImportMap;
     log: Logger;
 }) => Promise<FunctionConfig>;
 export {};

package/dist/node/config.js

@@ -27,7 +27,7 @@ const getConfigExtractor = () => {
     const configExtractorPath = join(packagePath, 'deno', 'config.ts');
     return configExtractorPath;
 };
-export const getFunctionConfig = async ({ func, importMap, deno, log, }) => {
+export const getFunctionConfig = async ({ deno, functionPath, importMap, log, }) => {
     // The extractor is a Deno script that will import the function and run its
     // `config` export, if one exists.
     const extractorPath = getConfigExtractor();
@@ -54,15 +54,12 @@ export const getFunctionConfig = async ({ func, importMap, deno, log, }) => {
         '--node-modules-dir=false',
         '--quiet',
         extractorPath,
-        pathToFileURL(func.path).href,
+        pathToFileURL(functionPath).href,
         pathToFileURL(collector.path).href,
         JSON.stringify(ConfigExitCode),
     ].filter(Boolean), { rejectOnExitCode: false });
-    if (stderr.includes('Import assertions are deprecated')) {
-        log.system(`Edge function uses import assertions: ${func.path}`);
-    }
     if (exitCode !== ConfigExitCode.Success) {
-        handleConfigError(func, exitCode, stderr, log);
+        handleConfigError(functionPath, exitCode, stderr, log);
         return {};
     }
     if (stdout !== '') {
@@ -74,35 +71,38 @@ export const getFunctionConfig = async ({ func, importMap, deno, log, }) => {
         collectorData = JSON.parse(collectorDataJSON);
     }
     catch {
-        handleConfigError(func, ConfigExitCode.UnhandledError, stderr, log);
+        handleConfigError(functionPath, ConfigExitCode.UnhandledError, stderr, log);
     }
     finally {
         await collector.cleanup();
     }
     if (!isValidOnError(collectorData.onError)) {
-        throw new BundleError(new Error(`The 'onError' configuration property in edge function at '${func.path}' must be one of 'fail', 'bypass', or a path starting with '/'. Got '${collectorData.onError}'. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
+        throw new BundleError(new Error(`The 'onError' configuration property in edge function at '${functionPath}' must be one of 'fail', 'bypass', or a path starting with '/'. Got '${collectorData.onError}'. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
     }
     return collectorData;
 };
-const handleConfigError = (func, exitCode, stderr, log) => {
+const handleConfigError = (functionPath, exitCode, stderr, log) => {
+    let cause;
+    if (stderr.includes('Import assertions are deprecated')) {
+        log.system(`Edge function uses import assertions: ${functionPath}`);
+        cause = 'IMPORT_ASSERT';
+    }
     switch (exitCode) {
         case ConfigExitCode.ImportError:
             log.user(stderr);
-            throw new BundleError(new Error(`Could not load edge function at '${func.path}'. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
-            break;
+            throw new BundleError(new Error(`Could not load edge function at '${functionPath}'. More on the Edge Functions API at https://ntl.fyi/edge-api.`), { cause });
         case ConfigExitCode.NoConfig:
-            log.system(`No in-source config found for edge function at '${func.path}'`);
+            log.system(`No in-source config found for edge function at '${functionPath}'`);
             break;
         case ConfigExitCode.InvalidExport:
-            throw new BundleError(new Error(`The 'config' export in edge function at '${func.path}' must be an object. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
-            break;
+            throw new BundleError(new Error(`The 'config' export in edge function at '${functionPath}' must be an object. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
         case ConfigExitCode.SerializationError:
-            throw new BundleError(new Error(`The 'config' object in the edge function at '${func.path}' must contain primitive values only. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
+            throw new BundleError(new Error(`The 'config' object in the edge function at '${functionPath}' must contain primitive values only. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
             break;
         case ConfigExitCode.InvalidDefaultExport:
-            throw new BundleError(new Error(`Default export in '${func.path}' must be a function. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
+            throw new BundleError(new Error(`Default export in '${functionPath}' must be a function. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
         default:
-            log.user(`Could not load configuration for edge function at '${func.path}'`);
+            log.user(`Could not load configuration for edge function at '${functionPath}'`);
             log.user(stderr);
     }
 };

package/dist/node/config.test.js

@@ -172,10 +172,7 @@ describe('`getFunctionConfig` extracts configuration properties from function fi
         const path = join(tmpDir, `${func.name}.js`);
         await fs.writeFile(path, func.source);
         const funcCall = () => getFunctionConfig({
-            func: {
-                name: func.name,
-                path,
-            },
+            functionPath: path,
             importMap: new ImportMap([importMapFile]),
             deno,
             log: logger,
@@ -349,10 +346,7 @@ test('Passes validation if default export exists and is a function', async () =>
     const path = join(tmpDir, `${func.name}.ts`);
     await fs.writeFile(path, func.source);
     await expect(getFunctionConfig({
-        func: {
-            name: func.name,
-            path,
-        },
+        functionPath: path,
         importMap: new ImportMap([importMapFile]),
         deno,
         log: logger,
@@ -378,10 +372,7 @@ test('Fails validation if default export is not function', async () => {
     const path = join(tmpDir, `${func.name}.ts`);
     await fs.writeFile(path, func.source);
     const config = getFunctionConfig({
-        func: {
-            name: func.name,
-            path,
-        },
+        functionPath: path,
         importMap: new ImportMap([importMapFile]),
         deno,
         log: logger,
@@ -407,10 +398,7 @@ test('Fails validation if default export is not present', async () => {
     const path = join(tmpDir, `${func.name}.ts`);
     await fs.writeFile(path, func.source);
     const config = getFunctionConfig({
-        func: {
-            name: func.name,
-            path,
-        },
+        functionPath: path,
         importMap: new ImportMap([importMapFile]),
         deno,
         log: logger,

package/dist/node/declaration.js

@@ -16,7 +16,6 @@ export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, interna
     return declarations;
 };
 const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsVisited) => {
-    var _a, _b;
     const declarations = [];
     // For any declaration for which we also have a function configuration object,
     // we replace the path because that object takes precedence.
@@ -26,7 +25,7 @@ const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsV
             // If no config is found, add the declaration as is.
             declarations.push(declaration);
         }
-        else if ('pattern' in config && ((_a = config.pattern) === null || _a === void 0 ? void 0 : _a.length)) {
+        else if ('pattern' in config && config.pattern?.length) {
             // If we have a pattern specified as either a string or non-empty array,
             // create a declaration for each pattern.
             const patterns = Array.isArray(config.pattern) ? config.pattern : [config.pattern];
@@ -34,7 +33,7 @@ const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsV
                 declarations.push({ ...declaration, cache: config.cache, pattern });
             });
         }
-        else if ('path' in config && ((_b = config.path) === null || _b === void 0 ? void 0 : _b.length)) {
+        else if ('path' in config && config.path?.length) {
             // If we have a path specified as either a string or non-empty array,
             // create a declaration for each path.
             const paths = Array.isArray(config.path) ? config.path : [config.path];

package/dist/node/deploy_config.js

@@ -24,13 +24,12 @@ export const load = async (path, logger) => {
     };
 };
 const parse = (data, path) => {
-    var _a, _b;
     if (data.version !== 1) {
         throw new Error(`Unsupported file version: ${data.version}`);
     }
     const config = {
-        declarations: (_a = data.functions) !== null && _a !== void 0 ? _a : [],
-        layers: (_b = data.layers) !== null && _b !== void 0 ? _b : [],
+        declarations: data.functions ?? [],
+        layers: data.layers ?? [],
     };
     if (data.import_map) {
         const importMapPath = resolve(dirname(path), data.import_map);

package/dist/node/downloader.js

@@ -71,8 +71,7 @@ const getLatestVersion = async () => {
     }
 };
 const getLatestVersionForRange = async (range) => {
-    var _a;
-    const minimumVersion = (_a = semver.minVersion(range)) === null || _a === void 0 ? void 0 : _a.version;
+    const minimumVersion = semver.minVersion(range)?.version;
     // We should never get here, because it means that `DENO_VERSION_RANGE` is
     // a malformed semver range. If this does happen, let's throw an error so
     // that the tests catch it.

package/dist/node/feature_flags.d.ts

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

package/dist/node/feature_flags.js

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

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

@@ -3,6 +3,7 @@ import { Bundle } from '../bundle.js';
 import { EdgeFunction } from '../edge_function.js';
 import { FeatureFlags } from '../feature_flags.js';
 import { ImportMap } from '../import_map.js';
+export declare const extension = ".eszip";
 interface BundleESZIPOptions {
     basePath: string;
     buildID: string;
@@ -15,5 +16,9 @@ interface BundleESZIPOptions {
     importMap: ImportMap;
     vendorDirectory?: string;
 }
-declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, vendorDirectory, }: BundleESZIPOptions) => Promise<Bundle>;
-export { bundleESZIP as bundle };
+export declare const bundle: ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, vendorDirectory, }: BundleESZIPOptions) => Promise<Bundle>;
+export declare const extract: (deno: DenoBridge, functionPath: string) => Promise<{
+    cleanup: () => Promise<void>;
+    path: string;
+}>;
+export {};

package/dist/node/formats/eszip.js

@@ -1,13 +1,14 @@
 import { join } from 'path';
 import { pathToFileURL } from 'url';
+import tmp from 'tmp-promise';
 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, vendorDirectory, }) => {
-    const extension = '.eszip';
+export const extension = '.eszip';
+export const bundle = async ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, vendorDirectory, }) => {
     const destPath = join(distDirectory, `${buildID}${extension}`);
     const importMapPrefixes = {
         [`${pathToFileURL(basePath)}/`]: virtualRoot,
@@ -44,7 +45,17 @@ const getESZIPPaths = () => {
     const denoPath = join(getPackagePath(), 'deno');
     return {
         bundler: join(denoPath, 'bundle.ts'),
+        extractor: join(denoPath, 'extract.ts'),
         importMap: join(denoPath, 'vendor', 'import_map.json'),
     };
 };
-export { bundleESZIP as bundle };
+export const extract = async (deno, functionPath) => {
+    const tmpDir = await tmp.dir({ unsafeCleanup: true });
+    const { extractor, importMap } = getESZIPPaths();
+    const flags = ['--allow-all', '--no-config', '--no-lock', `--import-map=${importMap}`, '--quiet'];
+    await deno.run(['run', ...flags, extractor, functionPath, tmpDir.path], { pipeOutput: true });
+    return {
+        cleanup: tmpDir.cleanup,
+        path: join(tmpDir.path, 'source', 'root'),
+    };
+};

package/dist/node/import_map.js

@@ -12,6 +12,11 @@ const INTERNAL_IMPORTS = {
 // ImportMap can take several import map files and merge them into a final
 // import map object, also adding the internal imports in the right order.
 export class ImportMap {
+    // The root path which import maps can reference. If an import map attempts
+    // to reference a file outside this directory, an error will be thrown.
+    rootPath;
+    // The different import map files that make up the wider import map.
+    sources;
     constructor(sources = [], rootPath = null) {
         this.rootPath = rootPath;
         this.sources = [];

package/dist/node/logger.js

@@ -5,8 +5,8 @@ const getLogger = (systemLogger, userLogger, debug = false) => {
     // If there is a system logger configured, we'll use that. If there isn't,
     // we'll pipe system logs to stdout if `debug` is enabled and swallow them
     // otherwise.
-    const system = systemLogger !== null && systemLogger !== void 0 ? systemLogger : (debug ? console.log : noopLogger);
-    const user = userLogger !== null && userLogger !== void 0 ? userLogger : console.log;
+    const system = systemLogger ?? (debug ? console.log : noopLogger);
+    const user = userLogger ?? console.log;
     return {
         system,
         user,

package/dist/node/main.test.js

@@ -12,8 +12,7 @@ import { getPlatformTarget } from './platform.js';
 const require = createRequire(import.meta.url);
 const archiver = require('archiver');
 test('Downloads the Deno CLI on demand and caches it for subsequent calls', async () => {
-    var _a, _b, _c, _d;
-    const latestVersion = (_b = (_a = semver.minVersion(DENO_VERSION_RANGE)) === null || _a === void 0 ? void 0 : _a.version) !== null && _b !== void 0 ? _b : '';
+    const latestVersion = semver.minVersion(DENO_VERSION_RANGE)?.version ?? '';
     const mockBinaryOutput = `#!/usr/bin/env sh\n\necho "deno ${latestVersion}"`;
     const data = new PassThrough();
     const archive = archiver('zip', { zlib: { level: 9 } });
@@ -39,8 +38,8 @@ test('Downloads the Deno CLI on demand and caches it for subsequent calls', asyn
     const expectedOutput = /^deno [\d.]+/;
     expect(latestReleaseMock.isDone()).toBe(true);
     expect(downloadMock.isDone()).toBe(true);
-    expect((_c = output1 === null || output1 === void 0 ? void 0 : output1.stdout) !== null && _c !== void 0 ? _c : '').toMatch(expectedOutput);
-    expect((_d = output2 === null || output2 === void 0 ? void 0 : output2.stdout) !== null && _d !== void 0 ? _d : '').toMatch(expectedOutput);
+    expect(output1?.stdout ?? '').toMatch(expectedOutput);
+    expect(output2?.stdout ?? '').toMatch(expectedOutput);
     expect(beforeDownload).toHaveBeenCalledTimes(1);
     expect(afterDownload).toHaveBeenCalledTimes(1);
     await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });

package/dist/node/manifest.js

@@ -5,7 +5,7 @@ import { getHeaderMatchers, normalizePattern } from './declaration.js';
 import { getPackageVersion } from './package_json.js';
 import { RateLimitAction, RateLimitAlgorithm, RateLimitAggregator } from './rate_limit.js';
 import { nonNullable } from './utils/non_nullable.js';
-import { ExtendedURLPattern } from './utils/urlpattern.js';
+import { getRegexpFromURLPatternPath } from './utils/urlpattern.js';
 const removeEmptyConfigValues = (functionConfig) => Object.entries(functionConfig).reduce((acc, [key, value]) => {
     if (value && !(Array.isArray(value) && value.length === 0)) {
         return { ...acc, [key]: value };
@@ -176,10 +176,9 @@ const pathToRegularExpression = (path) => {
         return null;
     }
     try {
-        const pattern = new ExtendedURLPattern({ pathname: path });
         // Removing the `^` and `$` delimiters because we'll need to modify what's
         // between them.
-        const source = pattern.regexp.pathname.source.slice(1, -1);
+        const source = getRegexpFromURLPatternPath(path).slice(1, -1);
         // Wrapping the expression source with `^` and `$`. Also, adding an optional
         // trailing slash, so that a declaration of `path: "/foo"` matches requests
         // for both `/foo` and `/foo/`.

package/dist/node/manifest.test.js

@@ -70,7 +70,6 @@ test('Generates a manifest with a generator field', () => {
     expect(manifest.function_config).toEqual(expectedFunctionConfig);
 });
 test('Generates a manifest with excluded paths and patterns', () => {
-    var _a, _b;
     const functions = [
         { name: 'func-1', path: '/path/to/func-1.ts' },
         { name: 'func-2', path: '/path/to/func-2.ts' },
@@ -104,8 +103,8 @@ test('Generates a manifest with excluded paths and patterns', () => {
     expect(manifest.function_config).toEqual({});
     expect(manifest.bundler_version).toBe(version);
     const matcher = getRouteMatcher(manifest);
-    expect((_a = matcher('/f1/hello')) === null || _a === void 0 ? void 0 : _a.function).toBe('func-1');
-    expect((_b = matcher('/grandparent/parent/child/grandchild.html')) === null || _b === void 0 ? void 0 : _b.function).toBeUndefined();
+    expect(matcher('/f1/hello')?.function).toBe('func-1');
+    expect(matcher('/grandparent/parent/child/grandchild.html')?.function).toBeUndefined();
 });
 test('TOML-defined paths can be combined with ISC-defined excluded paths', () => {
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];

package/dist/node/npm_dependencies.js

@@ -36,7 +36,7 @@ const getTypePathFromTypesPackage = async (packageName, packageJsonPath) => {
         return undefined;
     }
     const { types, typings } = JSON.parse(await fs.readFile(typesPackagePath, 'utf8'));
-    const declarationPath = types !== null && types !== void 0 ? types : typings;
+    const declarationPath = types ?? typings;
     if (typeof declarationPath === 'string') {
         return path.join(typesPackagePath, '..', declarationPath);
     }
@@ -51,7 +51,7 @@ const getTypesPath = async (packageJsonPath) => {
     const { name, types, typings } = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
     // this only looks at `.types` and `.typings` fields. there might also be data in `exports -> . -> types -> import/default`.
     // we're ignoring that for now.
-    const declarationPath = types !== null && types !== void 0 ? types : typings;
+    const declarationPath = types ?? typings;
     if (typeof declarationPath === 'string') {
         return path.join(packageJsonPath, '..', declarationPath);
     }
@@ -117,7 +117,6 @@ async function parseImportsForFile(file, rootPath) {
  * to npm modules.
  */
 const getNPMSpecifiers = async ({ basePath, functions, importMap, environment, rootPath }, alreadySeenPaths = new Set()) => {
-    var _a;
     const baseURL = pathToFileURL(basePath);
     const npmSpecifiers = [];
     for (const func of functions) {
@@ -152,7 +151,7 @@ const getNPMSpecifiers = async ({ basePath, functions, importMap, environment, r
                     }
                     const { matched, resolvedImport } = resolve(specifier, importMap, baseURL);
                     if (matched) {
-                        if ((resolvedImport === null || resolvedImport === void 0 ? void 0 : resolvedImport.protocol) === 'file:') {
+                        if (resolvedImport?.protocol === 'file:') {
                             const newSpecifier = fileURLToPath(resolvedImport).replace(/\\/g, '/');
                             if (alreadySeenPaths.has(newSpecifier)) {
                                 break;
@@ -161,7 +160,7 @@ const getNPMSpecifiers = async ({ basePath, functions, importMap, environment, r
                             npmSpecifiers.push(...(await getNPMSpecifiers({ basePath, functions: [newSpecifier], importMap, environment, rootPath }, alreadySeenPaths)));
                         }
                     }
-                    else if (!((_a = resolvedImport === null || resolvedImport === void 0 ? void 0 : resolvedImport.protocol) === null || _a === void 0 ? void 0 : _a.startsWith('http'))) {
+                    else if (!resolvedImport?.protocol?.startsWith('http')) {
                         const t = await safelyDetectTypes(specifier, basePath);
                         npmSpecifiers.push({
                             specifier: specifier,
@@ -235,8 +234,7 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
         });
         outputFiles.push(...outputFilesFromEsBuild.map((file) => file.path));
         await Promise.all(outputFilesFromEsBuild.map(async (file) => {
-            var _a;
-            const types = (_a = ops.find((op) => path.basename(file.path) === path.basename(op.filePath))) === null || _a === void 0 ? void 0 : _a.types;
+            const types = ops.find((op) => path.basename(file.path) === path.basename(op.filePath))?.types;
             let content = file.text;
             if (types) {
                 content = `/// <reference types="${path.relative(path.dirname(file.path), types)}" />\n${content}`;

package/dist/node/server/server.js

@@ -22,8 +22,7 @@ const cleanDirectory = async (directory, except) => {
 const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImportMapPath, flags: denoFlags, formatExportTypeError, formatImportError, logger, port, rootPath, stderr, stdout, }) => {
     const processRef = {};
     const startServer = async (functions, env = {}, options = {}) => {
-        var _a;
-        if ((processRef === null || processRef === void 0 ? void 0 : processRef.ps) !== undefined) {
+        if (processRef?.ps !== undefined) {
             await killProcess(processRef.ps);
         }
         let graph = {
@@ -41,7 +40,7 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
         });
         const features = {};
         const importMap = new ImportMap();
-        await importMap.addFiles((_a = options.importMapPaths) !== null && _a !== void 0 ? _a : [], logger);
+        await importMap.addFiles(options.importMapPaths ?? [], logger);
         // we keep track of the files that are relevant to the user's code, so we can clean up leftovers from past executions later
         const relevantFiles = [stage2Path];
         const vendor = await vendorNPMSpecifiers({
@@ -84,7 +83,7 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
         });
         let functionsConfig = [];
         if (options.getFunctionsConfig) {
-            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig({ func, importMap, deno, log: logger })));
+            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig({ functionPath: func.path, importMap, deno, log: logger })));
         }
         if (distImportMapPath) {
             await importMap.writeToFile(distImportMapPath);

package/dist/node/server/server.test.js

@@ -52,9 +52,9 @@ test('Starts a server and serves requests for edge functions', async () => {
     expect(features).toEqual({ npmModules: true });
     expect(success).toBe(true);
     expect(functionsConfig).toEqual([{ path: '/my-function' }, {}, { path: '/global-netlify' }]);
-    const modules = graph === null || graph === void 0 ? void 0 : graph.modules.filter(({ kind, mediaType }) => kind === 'esm' && mediaType === 'TypeScript');
+    const modules = graph?.modules.filter(({ kind, mediaType }) => kind === 'esm' && mediaType === 'TypeScript');
     for (const key in functions) {
-        const graphEntry = modules === null || modules === void 0 ? void 0 : modules.some(({ local }) => local === functions[key].path);
+        const graphEntry = modules?.some(({ local }) => local === functions[key].path);
         expect(graphEntry).toBe(true);
     }
     const response1 = await fetch(`http://0.0.0.0:${port}/foo`, {
@@ -127,7 +127,7 @@ test('Serves edge functions in a monorepo setup', async () => {
     expect(success).toBe(true);
     expect(functionsConfig).toEqual([{ path: '/func1' }]);
     for (const key in functions) {
-        const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functions[key].path);
+        const graphEntry = graph?.modules.some(({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functions[key].path);
         expect(graphEntry).toBe(true);
     }
     const response1 = await fetch(`http://0.0.0.0:${port}/func1`, {

package/dist/node/server/util.js

@@ -10,7 +10,7 @@ const SERVER_POLL_TIMEOUT = 1e4;
 const isServerReady = async (port, successRef, ps) => {
     // If the process has been killed or if it exited with an error, we return
     // early with `success: false`.
-    if ((ps === null || ps === void 0 ? void 0 : ps.killed) || ((ps === null || ps === void 0 ? void 0 : ps.exitCode) && ps.exitCode > 0)) {
+    if (ps?.killed || (ps?.exitCode && ps.exitCode > 0)) {
         return true;
     }
     try {
@@ -24,7 +24,7 @@ const isServerReady = async (port, successRef, ps) => {
 };
 const killProcess = (ps) => {
     // If the process is no longer running, there's nothing left to do.
-    if ((ps === null || ps === void 0 ? void 0 : ps.exitCode) !== null) {
+    if (ps?.exitCode !== null) {
         return;
     }
     return new Promise((resolve, reject) => {

package/dist/node/types.js

@@ -2,7 +2,7 @@ import { promises as fs } from 'fs';
 import { join } from 'path';
 const TYPES_URL = 'https://edge.netlify.com';
 const ensureLatestTypes = async (deno, logger, customTypesURL) => {
-    const typesURL = customTypesURL !== null && customTypesURL !== void 0 ? customTypesURL : TYPES_URL;
+    const typesURL = customTypesURL ?? TYPES_URL;
     // eslint-disable-next-line prefer-const
     let [localVersion, remoteVersion] = [await getLocalVersion(deno), ''];
     try {

package/dist/node/utils/urlpattern.d.ts

@@ -1,4 +1 @@
-import { URLPattern } from 'urlpattern-polyfill';
-export declare class ExtendedURLPattern extends URLPattern {
-    regexp: Record<string, RegExp>;
-}
+export declare const getRegexpFromURLPatternPath: (path: string) => string;

package/dist/node/utils/urlpattern.js

@@ -1,3 +1,5 @@
 import { URLPattern } from 'urlpattern-polyfill';
-export class ExtendedURLPattern extends URLPattern {
-}
+export const getRegexpFromURLPatternPath = (path) => {
+    const pattern = new URLPattern({ pathname: path });
+    return pattern.regexp.pathname.source;
+};

package/dist/node/validation/manifest/error.js

@@ -1,9 +1,9 @@
 export default class ManifestValidationError extends Error {
+    customErrorInfo = {
+        type: 'functionsBundling',
+    };
     constructor(message) {
         super(`Validation of Edge Functions manifest failed\n${message}`);
-        this.customErrorInfo = {
-            type: 'functionsBundling',
-        };
         this.name = 'ManifestValidationError';
         // https://github.com/microsoft/TypeScript-wiki/blob/0fecbda7263f130c57394d779b8ca13f0a2e9123/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
         Object.setPrototypeOf(this, ManifestValidationError.prototype);

package/dist/test/util.js

@@ -67,7 +67,6 @@ for (const functionName in manifest.functions) {
 console.log(JSON.stringify(responses));
 `;
 export const getRouteMatcher = (manifest) => (candidate) => manifest.routes.find((route) => {
-    var _a, _b;
     const regex = new RegExp(route.pattern);
     if (!regex.test(candidate)) {
         return false;
@@ -75,12 +74,11 @@ export const getRouteMatcher = (manifest) => (candidate) => manifest.routes.find
     if (route.excluded_patterns.some((pattern) => new RegExp(pattern).test(candidate))) {
         return false;
     }
-    const excludedPatterns = (_b = (_a = manifest.function_config[route.function]) === null || _a === void 0 ? void 0 : _a.excluded_patterns) !== null && _b !== void 0 ? _b : [];
+    const excludedPatterns = manifest.function_config[route.function]?.excluded_patterns ?? [];
     const isExcluded = excludedPatterns.some((pattern) => new RegExp(pattern).test(candidate));
     return !isExcluded;
 });
 export const runESZIP = async (eszipPath, vendorDirectory) => {
-    var _a, _b, _c;
     const tmpDir = await tmp.dir({ unsafeCleanup: true });
     // Extract ESZIP into temporary directory.
     const extractCommand = execa('deno', [
@@ -92,8 +90,8 @@ export const runESZIP = async (eszipPath, vendorDirectory) => {
         eszipPath,
         tmpDir.path,
     ]);
-    (_a = extractCommand.stderr) === null || _a === void 0 ? void 0 : _a.pipe(stderr);
-    (_b = extractCommand.stdout) === null || _b === void 0 ? void 0 : _b.pipe(stdout);
+    extractCommand.stderr?.pipe(stderr);
+    extractCommand.stdout?.pipe(stdout);
     await extractCommand;
     const virtualRootPath = join(tmpDir.path, 'source', 'root');
     const stage2Path = join(virtualRootPath, '..', 'bootstrap-stage2');
@@ -109,13 +107,12 @@ export const runESZIP = async (eszipPath, vendorDirectory) => {
     await fs.rename(stage2Path, `${stage2Path}.js`);
     // Run function that imports the extracted stage 2 and invokes each function.
     const evalCommand = execa('deno', ['eval', '--import-map', importMapPath, inspectESZIPFunction(stage2Path)]);
-    (_c = evalCommand.stderr) === null || _c === void 0 ? void 0 : _c.pipe(stderr);
+    evalCommand.stderr?.pipe(stderr);
     const result = await evalCommand;
     await tmpDir.cleanup();
     return JSON.parse(result.stdout);
 };
 export const runTarball = async (tarballPath) => {
-    var _a;
     const tmpDir = await tmp.dir({ unsafeCleanup: true });
     await tar.extract({
         cwd: tmpDir.path,
@@ -124,7 +121,7 @@ export const runTarball = async (tarballPath) => {
     const evalCommand = execa('deno', ['eval', inspectTarballFunction()], {
         cwd: tmpDir.path,
     });
-    (_a = evalCommand.stderr) === null || _a === void 0 ? void 0 : _a.pipe(stderr);
+    evalCommand.stderr?.pipe(stderr);
     const result = await evalCommand;
     await tmpDir.cleanup();
     return JSON.parse(result.stdout);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "14.5.6",
+  "version": "14.7.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -80,5 +80,5 @@
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^11.0.0"
   },
-  "gitHead": "ce591ef6a6fb974be2a38812a1e0abc98c3c14f6"
+  "gitHead": "ff114da3f2bcb5bea83bb4a3747201192aecfec0"
 }