@netlify/edge-bundler 11.2.2 → 11.4.0

package/dist/node/config.d.ts

@@ -2,6 +2,7 @@ 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';
 export declare const enum Cache {
     Off = "off",
     Manual = "manual"
@@ -18,6 +19,7 @@ export interface FunctionConfig {
     name?: string;
     generator?: string;
     method?: HTTPMethod | HTTPMethod[];
+    rateLimit?: RateLimit;
 }
 export declare const getFunctionConfig: ({ func, importMap, deno, log, }: {
     func: EdgeFunction;

package/dist/node/config.test.js

@@ -9,6 +9,7 @@ import { DenoBridge } from './bridge.js';
 import { bundle } from './bundler.js';
 import { getFunctionConfig } from './config.js';
 import { ImportMap } from './import_map.js';
+import { RateLimitAction, RateLimitAggregator } from './rate_limit.js';
 const importMapFile = {
     baseURL: new URL('file:///some/path/import-map.json'),
     imports: {
@@ -64,7 +65,7 @@ const functions = [
     },
     {
         testName: 'config with wrong onError',
-        name: 'func7',
+        name: 'func6',
         source: `
       export default async () => new Response("Hello from function two")
       export const config = { onError: "foo" }
@@ -74,7 +75,7 @@ const functions = [
     {
         testName: 'config with `path`',
         expectedConfig: { path: '/home' },
-        name: 'func6',
+        name: 'func7',
         source: `
         export default async () => new Response("Hello from function three")
 
@@ -89,17 +90,74 @@ const functions = [
             name: 'a displayName',
             onError: 'bypass',
         },
-        name: 'func6',
+        name: 'func8',
         source: `
         export default async () => new Response("Hello from function three")
 
-        export const config = { path: "/home",
+        export const config = {
+          path: "/home",
           generator: '@netlify/fake-plugin@1.0.0',
           name: 'a displayName',
           onError: 'bypass',
         }
       `,
     },
+    {
+        testName: 'config with ratelimit',
+        expectedConfig: {
+            path: '/ratelimit',
+            name: 'a limit rate',
+            rateLimit: {
+                windowSize: 10,
+                windowLimit: 100,
+                aggregateBy: [RateLimitAggregator.IP, RateLimitAggregator.Domain],
+            },
+        },
+        name: 'func9',
+        source: `
+        export default async () => new Response("Rate my limits")
+
+        export const config = {
+          path: "/ratelimit",
+          rateLimit: {
+            windowSize: 10,
+            windowLimit: 100,
+            aggregateBy: ["ip", "domain"],
+          },
+          name: 'a limit rate',
+        }
+      `,
+    },
+    {
+        testName: 'config with rewrite',
+        expectedConfig: {
+            path: '/rewrite',
+            name: 'a limit rewrite',
+            rateLimit: {
+                action: RateLimitAction.Rewrite,
+                to: '/rewritten',
+                windowSize: 20,
+                windowLimit: 200,
+                aggregateBy: [RateLimitAggregator.IP, RateLimitAggregator.Domain],
+            },
+        },
+        name: 'func9',
+        source: `
+        export default async () => new Response("Rate my limits")
+
+        export const config = {
+          path: "/rewrite",
+          rateLimit: {
+            action: "rewrite",
+            to: "/rewritten",
+            windowSize: 20,
+            windowLimit: 200,
+            aggregateBy: ["ip", "domain"],
+          },
+          name: 'a limit rewrite',
+        }
+      `,
+    },
 ];
 describe('`getFunctionConfig` extracts configuration properties from function file', () => {
     test.each(functions)('$testName', async (func) => {

package/dist/node/declaration.d.ts

@@ -19,8 +19,7 @@ export type Declaration = DeclarationWithPath | DeclarationWithPattern;
 export declare const mergeDeclarations: (tomlDeclarations: Declaration[], userFunctionsConfig: Record<string, FunctionConfig>, internalFunctionsConfig: Record<string, FunctionConfig>, deployConfigDeclarations: Declaration[], _featureFlags?: FeatureFlags) => Declaration[];
 /**
  * Normalizes a regular expression, ensuring it has a leading `^` and trailing
- * `$` characters. It also converts the regular expression from PCRE to RE2 if
- * needed.
+ * `$` characters.
  */
-export declare const parsePattern: (pattern: string, pcreRegexpEngine: boolean) => string;
+export declare const normalizePattern: (pattern: string) => string;
 export {};

package/dist/node/declaration.js

@@ -1,4 +1,3 @@
-import regexpAST from 'regexp-tree';
 export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, internalFunctionsConfig, deployConfigDeclarations, 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 _featureFlags = {}) => {
@@ -68,10 +67,9 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
 };
 /**
  * Normalizes a regular expression, ensuring it has a leading `^` and trailing
- * `$` characters. It also converts the regular expression from PCRE to RE2 if
- * needed.
+ * `$` characters.
  */
-export const parsePattern = (pattern, pcreRegexpEngine) => {
+export const normalizePattern = (pattern) => {
     let enclosedPattern = pattern;
     if (!pattern.startsWith('^')) {
         enclosedPattern = `^${enclosedPattern}`;
@@ -80,34 +78,6 @@ export const parsePattern = (pattern, pcreRegexpEngine) => {
         enclosedPattern = `${enclosedPattern}$`;
     }
     const regexp = new RegExp(enclosedPattern);
-    const regexpString = pcreRegexpEngine ? regexp.toString() : transformPCRERegexp(regexp);
     // Strip leading and forward slashes.
-    return regexpString.slice(1, -1);
-};
-/**
- * Transforms a PCRE regular expression into a RE2 expression, compatible
- * with the Go engine used in our edge nodes.
- */
-const transformPCRERegexp = (regexp) => {
-    const newRegexp = regexpAST.transform(regexp, {
-        Assertion(path) {
-            // Lookaheads are not supported. If we find one, throw an error.
-            if (path.node.kind === 'Lookahead') {
-                throw new Error('Regular expressions with lookaheads are not supported');
-            }
-        },
-        Group(path) {
-            // Named captured groups in JavaScript use a different syntax than in Go.
-            // If we find one, convert it to an unnamed capture group, which is valid
-            // in both engines.
-            if ('name' in path.node && path.node.name !== undefined) {
-                path.replace({
-                    ...path.node,
-                    name: undefined,
-                    nameRaw: undefined,
-                });
-            }
-        },
-    });
-    return newRegexp.toString();
+    return regexp.toString().slice(1, -1);
 };

package/dist/node/declaration.test.js

@@ -1,5 +1,5 @@
 import { test, expect } from 'vitest';
-import { mergeDeclarations, parsePattern } from './declaration.js';
+import { mergeDeclarations, normalizePattern } from './declaration.js';
 const deployConfigDeclarations = [];
 test('Ensure the order of edge functions with FF', () => {
     const deployConfigDeclarations = [
@@ -117,18 +117,15 @@ test('netlify.toml-defined excludedPath are respected', () => {
 test('Does not escape front slashes in a regex pattern if they are already escaped', () => {
     const regexPattern = '^(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))\\/shows(?:\\/(.*))(.json)?[\\/#\\?]?$';
     const expected = '^(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))\\/shows(?:\\/(.*))(.json)?[\\/#\\?]?$';
-    expect(parsePattern(regexPattern, false)).toEqual(expected);
-    expect(parsePattern(regexPattern, true)).toEqual(expected);
+    expect(normalizePattern(regexPattern)).toEqual(expected);
 });
 test('Escapes front slashes in a regex pattern', () => {
     const regexPattern = '^(?:/(_next/data/[^/]{1,}))?(?:/([^/.]{1,}))/shows(?:/(.*))(.json)?[/#\\?]?$';
     const expected = '^(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))\\/shows(?:\\/(.*))(.json)?[/#\\?]?$';
-    expect(parsePattern(regexPattern, false)).toEqual(expected);
-    expect(parsePattern(regexPattern, true)).toEqual(expected);
+    expect(normalizePattern(regexPattern)).toEqual(expected);
 });
 test('Ensures pattern match on the whole path', () => {
     const regexPattern = '/foo/.*/bar';
     const expected = '^\\/foo\\/.*\\/bar$';
-    expect(parsePattern(regexPattern, false)).toEqual(expected);
-    expect(parsePattern(regexPattern, true)).toEqual(expected);
+    expect(normalizePattern(regexPattern)).toEqual(expected);
 });

package/dist/node/feature_flags.d.ts

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

package/dist/node/feature_flags.js

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

package/dist/node/manifest.d.ts

@@ -11,11 +11,30 @@ interface Route {
     path?: string;
     methods?: string[];
 }
+interface TrafficRules {
+    action: {
+        type: string;
+        config: {
+            rate_limit_config: {
+                algorithm: string;
+                window_size: number;
+                window_limit: number;
+            };
+            aggregate: {
+                keys: {
+                    type: string;
+                }[];
+            };
+            to?: string;
+        };
+    };
+}
 export interface EdgeFunctionConfig {
     excluded_patterns: string[];
     on_error?: string;
     generator?: string;
     name?: string;
+    traffic_rules?: TrafficRules;
 }
 interface Manifest {
     bundler_version: string;
@@ -42,7 +61,7 @@ interface GenerateManifestOptions {
     layers?: Layer[];
     userFunctionConfig?: Record<string, FunctionConfig>;
 }
-declare const generateManifest: ({ bundles, declarations, featureFlags, functions, userFunctionConfig, internalFunctionConfig, importMap, layers, }: GenerateManifestOptions) => {
+declare const generateManifest: ({ bundles, declarations, functions, userFunctionConfig, internalFunctionConfig, importMap, layers, }: GenerateManifestOptions) => {
     declarationsWithoutFunction: string[];
     manifest: Manifest;
     unroutedFunctions: string[];

package/dist/node/manifest.js

@@ -1,8 +1,9 @@
 import { promises as fs } from 'fs';
 import { join } from 'path';
 import { wrapBundleError } from './bundle_error.js';
-import { parsePattern } from './declaration.js';
+import { 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';
 const removeEmptyConfigValues = (functionConfig) => Object.entries(functionConfig).reduce((acc, [key, value]) => {
@@ -46,27 +47,36 @@ const normalizeMethods = (method, name) => {
         return method.toUpperCase();
     });
 };
-const generateManifest = ({ bundles = [], declarations = [], featureFlags, functions, userFunctionConfig = {}, internalFunctionConfig = {}, importMap, layers = [], }) => {
+const generateManifest = ({ bundles = [], declarations = [], functions, userFunctionConfig = {}, internalFunctionConfig = {}, importMap, layers = [], }) => {
     const preCacheRoutes = [];
     const postCacheRoutes = [];
     const manifestFunctionConfig = Object.fromEntries(functions.map(({ name }) => [name, { excluded_patterns: [] }]));
     const routedFunctions = new Set();
     const declarationsWithoutFunction = new Set();
-    for (const [name, { excludedPath, onError }] of Object.entries(userFunctionConfig)) {
+    for (const [name, { excludedPath, onError, rateLimit }] of Object.entries(userFunctionConfig)) {
         // If the config block is for a function that is not defined, discard it.
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
         addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
-        manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError };
+        manifestFunctionConfig[name] = {
+            ...manifestFunctionConfig[name],
+            on_error: onError,
+            traffic_rules: getTrafficRulesConfig(rateLimit),
+        };
     }
-    for (const [name, { excludedPath, path, onError, ...rest }] of Object.entries(internalFunctionConfig)) {
+    for (const [name, { excludedPath, path, onError, rateLimit, ...rest }] of Object.entries(internalFunctionConfig)) {
         // If the config block is for a function that is not defined, discard it.
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
         addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
-        manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError, ...rest };
+        manifestFunctionConfig[name] = {
+            ...manifestFunctionConfig[name],
+            on_error: onError,
+            traffic_rules: getTrafficRulesConfig(rateLimit),
+            ...rest,
+        };
     }
     declarations.forEach((declaration) => {
         const func = functions.find(({ name }) => declaration.function === name);
@@ -74,14 +84,14 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
             declarationsWithoutFunction.add(declaration.function);
             return;
         }
-        const pattern = getRegularExpression(declaration, Boolean(featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_bundler_pcre_regexp));
+        const pattern = getRegularExpression(declaration);
         // If there is no `pattern`, the declaration will never be triggered, so we
         // can discard it.
         if (!pattern) {
             return;
         }
         routedFunctions.add(declaration.function);
-        const excludedPattern = getExcludedRegularExpressions(declaration, Boolean(featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_bundler_pcre_regexp));
+        const excludedPattern = getExcludedRegularExpressions(declaration);
         const route = {
             function: func.name,
             pattern: serializePattern(pattern),
@@ -116,6 +126,29 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
     const unroutedFunctions = functions.filter(({ name }) => !routedFunctions.has(name)).map(({ name }) => name);
     return { declarationsWithoutFunction: [...declarationsWithoutFunction], manifest, unroutedFunctions };
 };
+const getTrafficRulesConfig = (rl) => {
+    if (rl === undefined) {
+        return;
+    }
+    const rateLimitAgg = Array.isArray(rl.aggregateBy) ? rl.aggregateBy : [RateLimitAggregator.Domain];
+    const rewriteConfig = 'to' in rl && typeof rl.to === 'string' ? { to: rl.to } : undefined;
+    return {
+        action: {
+            type: rl.action || RateLimitAction.Limit,
+            config: {
+                ...rewriteConfig,
+                rate_limit_config: {
+                    window_limit: rl.windowLimit,
+                    window_size: rl.windowSize,
+                    algorithm: RateLimitAlgorithm.SlidingWindow,
+                },
+                aggregate: {
+                    keys: rateLimitAgg.map((agg) => ({ type: agg })),
+                },
+            },
+        },
+    };
+};
 const pathToRegularExpression = (path) => {
     if (!path) {
         return null;
@@ -135,10 +168,10 @@ const pathToRegularExpression = (path) => {
         throw wrapBundleError(error);
     }
 };
-const getRegularExpression = (declaration, pcreRegexpEngine) => {
+const getRegularExpression = (declaration) => {
     if ('pattern' in declaration) {
         try {
-            return parsePattern(declaration.pattern, pcreRegexpEngine);
+            return normalizePattern(declaration.pattern);
         }
         catch (error) {
             throw wrapBundleError(new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`));
@@ -146,14 +179,14 @@ const getRegularExpression = (declaration, pcreRegexpEngine) => {
     }
     return pathToRegularExpression(declaration.path);
 };
-const getExcludedRegularExpressions = (declaration, pcreRegexpEngine) => {
+const getExcludedRegularExpressions = (declaration) => {
     if ('excludedPattern' in declaration && declaration.excludedPattern) {
         const excludedPatterns = Array.isArray(declaration.excludedPattern)
             ? declaration.excludedPattern
             : [declaration.excludedPattern];
         return excludedPatterns.map((excludedPattern) => {
             try {
-                return parsePattern(excludedPattern, pcreRegexpEngine);
+                return normalizePattern(excludedPattern);
             }
             catch (error) {
                 throw wrapBundleError(new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`));

package/dist/node/manifest.test.js

@@ -4,6 +4,7 @@ import { getRouteMatcher } from '../test/util.js';
 import { BundleFormat } from './bundle.js';
 import { BundleError } from './bundle_error.js';
 import { generateManifest } from './manifest.js';
+import { RateLimitAction, RateLimitAggregator } from './rate_limit.js';
 test('Generates a manifest with different bundles', () => {
     const bundle1 = {
         extension: '.ext1',
@@ -386,22 +387,12 @@ test('Generates a manifest with layers', () => {
     expect(manifest2.routes).toEqual(expectedRoutes);
     expect(manifest2.layers).toEqual(layers);
 });
-test('Throws an error if the regular expression contains a negative lookahead and support for the PCRE engine is disabled', () => {
-    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
-    const declarations = [{ function: 'func-1', pattern: '^\\/((?!api|_next\\/static|_next\\/image|favicon.ico).*)$' }];
-    expect(() => generateManifest({
-        bundles: [],
-        declarations,
-        functions,
-    })).toThrowError(/^Could not parse path declaration of function 'func-1': Regular expressions with lookaheads are not supported$/);
-});
-test('Accepts regular expressions with lookaheads if support for the PCRE engine is enabled', () => {
+test('Accepts regular expressions with lookaheads', () => {
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
     const declarations = [{ function: 'func-1', pattern: '^\\/((?!api|_next\\/static|_next\\/image|favicon.ico).*)$' }];
     const { manifest } = generateManifest({
         bundles: [],
         declarations,
-        featureFlags: { edge_bundler_pcre_regexp: true },
         functions,
     });
     const [route] = manifest.routes;
@@ -409,11 +400,11 @@ test('Accepts regular expressions with lookaheads if support for the PCRE engine
     expect(regexp.test('/foo')).toBeTruthy();
     expect(regexp.test('/_next/static/foo')).toBeFalsy();
 });
-test('Converts named capture groups to unnamed capture groups in regular expressions', () => {
+test('Accepts regular expressions with named capture groups', () => {
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
     const declarations = [{ function: 'func-1', pattern: '^/(?<name>\\w+)$' }];
     const { manifest } = generateManifest({ bundles: [], declarations, functions });
-    expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/(\\w+)$', excluded_patterns: [] }]);
+    expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/(?<name>\\w+)$', excluded_patterns: [] }]);
 });
 test('Returns functions without a declaration and unrouted functions', () => {
     const bundle = {
@@ -443,3 +434,82 @@ test('Returns functions without a declaration and unrouted functions', () => {
     expect(declarationsWithoutFunction).toEqual(['func-3']);
     expect(unroutedFunctions).toEqual(['func-2', 'func-4']);
 });
+test('Generates a manifest with rate limit config', () => {
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', path: '/f1/*' }];
+    const userFunctionConfig = {
+        'func-1': { rateLimit: { windowLimit: 100, windowSize: 60 } },
+    };
+    const { manifest } = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        userFunctionConfig,
+    });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [], path: '/f1/*' }];
+    const expectedFunctionConfig = {
+        'func-1': {
+            traffic_rules: {
+                action: {
+                    type: 'rate_limit',
+                    config: {
+                        rate_limit_config: {
+                            window_limit: 100,
+                            window_size: 60,
+                            algorithm: 'sliding_window',
+                        },
+                        aggregate: {
+                            keys: [{ type: 'domain' }],
+                        },
+                    },
+                },
+            },
+        },
+    };
+    expect(manifest.routes).toEqual(expectedRoutes);
+    expect(manifest.function_config).toEqual(expectedFunctionConfig);
+});
+test('Generates a manifest with rewrite config', () => {
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', path: '/f1/*' }];
+    const userFunctionConfig = {
+        'func-1': {
+            rateLimit: {
+                action: RateLimitAction.Rewrite,
+                to: '/new_path',
+                windowLimit: 100,
+                windowSize: 60,
+                aggregateBy: [RateLimitAggregator.Domain, RateLimitAggregator.IP],
+            },
+        },
+    };
+    const { manifest } = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        userFunctionConfig,
+    });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [], path: '/f1/*' }];
+    const expectedFunctionConfig = {
+        'func-1': {
+            traffic_rules: {
+                action: {
+                    type: 'rewrite',
+                    config: {
+                        to: '/new_path',
+                        rate_limit_config: {
+                            window_limit: 100,
+                            window_size: 60,
+                            algorithm: 'sliding_window',
+                        },
+                        aggregate: {
+                            keys: [{ type: 'domain' }, { type: 'ip' }],
+                        },
+                    },
+                },
+            },
+        },
+    };
+    expect(manifest.routes).toEqual(expectedRoutes);
+    expect(manifest.function_config).toEqual(expectedFunctionConfig);
+});

package/dist/node/rate_limit.d.ts

@@ -0,0 +1,25 @@
+export declare enum RateLimitAlgorithm {
+    SlidingWindow = "sliding_window"
+}
+export declare enum RateLimitAggregator {
+    Domain = "domain",
+    IP = "ip"
+}
+export declare enum RateLimitAction {
+    Limit = "rate_limit",
+    Rewrite = "rewrite"
+}
+interface SlidingWindow {
+    windowLimit: number;
+    windowSize: number;
+}
+export type RewriteActionConfig = SlidingWindow & {
+    to: string;
+};
+interface RateLimitConfig {
+    action?: RateLimitAction;
+    aggregateBy?: RateLimitAggregator | RateLimitAggregator[];
+    algorithm?: RateLimitAlgorithm;
+}
+export type RateLimit = RateLimitConfig & (SlidingWindow | RewriteActionConfig);
+export {};

package/dist/node/rate_limit.js

@@ -0,0 +1,14 @@
+export var RateLimitAlgorithm;
+(function (RateLimitAlgorithm) {
+    RateLimitAlgorithm["SlidingWindow"] = "sliding_window";
+})(RateLimitAlgorithm || (RateLimitAlgorithm = {}));
+export var RateLimitAggregator;
+(function (RateLimitAggregator) {
+    RateLimitAggregator["Domain"] = "domain";
+    RateLimitAggregator["IP"] = "ip";
+})(RateLimitAggregator || (RateLimitAggregator = {}));
+export var RateLimitAction;
+(function (RateLimitAction) {
+    RateLimitAction["Limit"] = "rate_limit";
+    RateLimitAction["Rewrite"] = "rewrite";
+})(RateLimitAction || (RateLimitAction = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "11.2.2",
+  "version": "11.4.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -81,7 +81,7 @@
     "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
     "env-paths": "^3.0.0",
-    "esbuild": "0.19.11",
+    "esbuild": "0.20.2",
     "execa": "^6.0.0",
     "find-up": "^6.3.0",
     "get-package-name": "^2.2.0",
@@ -93,7 +93,6 @@
     "p-retry": "^5.1.1",
     "p-wait-for": "^4.1.0",
     "path-key": "^4.0.0",
-    "regexp-tree": "^0.1.24",
     "semver": "^7.3.8",
     "tmp-promise": "^3.0.3",
     "urlpattern-polyfill": "8.0.2",