@netlify/edge-bundler 14.5.5 → 14.6.0

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/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/formats/javascript.js

@@ -37,7 +37,7 @@ const getLocalEntryPoint = (functions, { bootstrapURL, formatExportTypeError = d
       }
       `;
     });
-    const bootCall = `boot(functions, metadata);`;
+    const bootCall = `boot(() => Promise.resolve(functions));`;
     return [bootImport, declaration, ...imports, bootCall].join('\n\n');
 };
 export { generateStage2, getLocalEntryPoint };

package/dist/node/formats/tarball.js

@@ -43,6 +43,7 @@ export const bundle = async ({ basePath, buildID, deno, distDirectory, functions
         importMap.withNodeBuiltins().toDataURL(),
         '--quiet',
         '--code-splitting',
+        '--allow-import',
         '--outdir',
         bundleDir.path,
         ...functions.map((func) => func.path),

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/stage_2.test.js

@@ -10,7 +10,15 @@ test('`getLocalEntryPoint` returns a valid stage 2 file for local development',
     // This is a fake bootstrap that we'll create just for the purpose of logging
     // the functions and the metadata that are sent to the `boot` function.
     const printer = `
-    export const boot = async (functions, metadata) => {
+    export const boot = async (functionsLoader) => {
+      const functions = await functionsLoader()
+      const metadata = { functions: {} }
+
+      // Generate metadata for each function (simulating what the real bootstrap would have)
+      for (const name in functions) {
+        metadata.functions[name] = { url: new URL('./' + name + '.mjs', import.meta.url).href }
+      }
+
       const responses = {}
 
       for (const name in functions) {

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.5",
+  "version": "14.6.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -42,7 +42,7 @@
     "test": "test/node"
   },
   "devDependencies": {
-    "@netlify/edge-functions-bootstrap": "^2.14.0",
+    "@netlify/edge-functions-bootstrap": "^2.17.1",
     "@types/node": "^18.19.111",
     "@types/semver": "^7.3.9",
     "@types/uuid": "^10.0.0",
@@ -80,5 +80,5 @@
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^11.0.0"
   },
-  "gitHead": "f01bed379ebde07ecabca6591701fd1c3ec517d2"
+  "gitHead": "3dfa7bd62ac0c8fe4b9b61128b8c2315d1272b4f"
 }