@netlify/edge-bundler 8.13.2 → 8.14.1

package/dist/node/bundler.js

@@ -63,8 +63,8 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     await createFinalBundles([functionBundle], 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, logger, featureFlags)]);
-    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig(func, importMap, deno, logger, featureFlags)]);
+    const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig(func, importMap, deno, logger)]);
+    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig(func, importMap, deno, 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));

package/dist/node/config.d.ts

@@ -1,6 +1,5 @@
 import { DenoBridge } from './bridge.js';
 import { EdgeFunction } from './edge_function.js';
-import { FeatureFlags } from './feature_flags.js';
 import { ImportMap } from './import_map.js';
 import { Logger } from './logger.js';
 export declare const enum Cache {
@@ -18,4 +17,4 @@ export interface FunctionConfig {
     name?: string;
     generator?: string;
 }
-export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger, featureFlags: FeatureFlags) => Promise<FunctionConfig>;
+export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger) => Promise<FunctionConfig>;

package/dist/node/config.js

@@ -26,7 +26,7 @@ const getConfigExtractor = () => {
     const configExtractorPath = join(packagePath, 'deno', 'config.ts');
     return configExtractorPath;
 };
-export const getFunctionConfig = async (func, importMap, deno, log, featureFlags) => {
+export const getFunctionConfig = async (func, importMap, deno, log) => {
     // The extractor is a Deno script that will import the function and run its
     // `config` export, if one exists.
     const extractorPath = getConfigExtractor();
@@ -53,7 +53,7 @@ export const getFunctionConfig = async (func, importMap, deno, log, featureFlags
         JSON.stringify(ConfigExitCode),
     ], { rejectOnExitCode: false });
     if (exitCode !== ConfigExitCode.Success) {
-        handleConfigError(func, exitCode, stderr, log, featureFlags);
+        handleConfigError(func, exitCode, stderr, log);
         return {};
     }
     if (stdout !== '') {
@@ -65,7 +65,7 @@ export const getFunctionConfig = async (func, importMap, deno, log, featureFlags
         collectorData = JSON.parse(collectorDataJSON);
     }
     catch {
-        handleConfigError(func, ConfigExitCode.UnhandledError, stderr, log, featureFlags);
+        handleConfigError(func, ConfigExitCode.UnhandledError, stderr, log);
     }
     finally {
         await collector.cleanup();
@@ -75,35 +75,20 @@ export const getFunctionConfig = async (func, importMap, deno, log, featureFlags
     }
     return collectorData;
 };
-const handleConfigError = (func, exitCode, stderr, log, featureFlags) => {
+const handleConfigError = (func, exitCode, stderr, log) => {
     switch (exitCode) {
         case ConfigExitCode.ImportError:
             log.user(stderr);
-            if (featureFlags.edge_functions_invalid_config_throw) {
-                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.`));
-            }
-            else {
-                log.user(`Could not load edge function at '${func.path}'`);
-            }
+            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;
         case ConfigExitCode.NoConfig:
             log.system(`No in-source config found for edge function at '${func.path}'`);
             break;
         case ConfigExitCode.InvalidExport:
-            if (featureFlags.edge_functions_invalid_config_throw) {
-                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.`));
-            }
-            else {
-                log.user(`'config' export in edge function at '${func.path}' must be an object`);
-            }
+            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;
         case ConfigExitCode.SerializationError:
-            if (featureFlags.edge_functions_invalid_config_throw) {
-                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.`));
-            }
-            else {
-                log.user(`'config' object in edge function at '${func.path}' must contain primitive values only`);
-            }
+            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.`));
             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.`));

package/dist/node/config.test.js

@@ -34,8 +34,7 @@ const functions = [
       `,
     },
     {
-        testName: 'config with wrong type (throw)',
-        expectedConfig: {},
+        testName: 'config with wrong type',
         name: 'func3',
         source: `
       export default async () => new Response("Hello from function two")
@@ -43,27 +42,9 @@ const functions = [
       export const config = () => ({})
     `,
         error: /^The 'config' export in edge function at '(.*)' must be an object\. More on the Edge Functions API at https:\/\/ntl\.fyi\/edge-api\.$/,
-        featureFlags: {
-            edge_functions_invalid_config_throw: true,
-        },
-    },
-    {
-        testName: 'config with wrong type (log)',
-        expectedConfig: {},
-        name: 'func3',
-        source: `
-      export default async () => new Response("Hello from function two")
-
-      export const config = () => ({})
-    `,
-        userLog: /^'config' export in edge function at '(.*)' must be an object$/,
-        featureFlags: {
-            edge_functions_invalid_config_throw: false,
-        },
     },
     {
-        testName: 'config with syntax error (throw)',
-        expectedConfig: {},
+        testName: 'config with syntax error',
         name: 'func4',
         source: `
       export default async () => new Response("Hello from function two")
@@ -71,23 +52,6 @@ const functions = [
       export const config
     `,
         error: /^Could not load edge function at '(.*)'\. More on the Edge Functions API at https:\/\/ntl\.fyi\/edge-api\.$/,
-        featureFlags: {
-            edge_functions_invalid_config_throw: true,
-        },
-    },
-    {
-        testName: 'config with syntax error (log)',
-        expectedConfig: {},
-        name: 'func4',
-        source: `
-      export default async () => new Response("Hello from function two")
-
-      export const config
-    `,
-        userLog: /^Could not load edge function at '(.*)'$/,
-        featureFlags: {
-            edge_functions_invalid_config_throw: false,
-        },
     },
     {
         testName: 'config with correct onError',
@@ -152,7 +116,7 @@ describe('`getFunctionConfig` extracts configuration properties from function fi
         const funcCall = () => getFunctionConfig({
             name: func.name,
             path,
-        }, new ImportMap([importMapFile]), deno, logger, func.featureFlags || {});
+        }, new ImportMap([importMapFile]), deno, logger);
         if (func.error) {
             await expect(funcCall()).rejects.toThrowError(func.error);
         }
@@ -231,7 +195,7 @@ test('Passes validation if default export exists and is a function', async () =>
     await expect(getFunctionConfig({
         name: func.name,
         path,
-    }, new ImportMap([importMapFile]), deno, logger, {})).resolves.not.toThrow();
+    }, new ImportMap([importMapFile]), deno, logger)).resolves.not.toThrow();
     await deleteAsync(tmpDir, { force: true });
 });
 test('Fails validation if default export is not function', async () => {
@@ -255,7 +219,7 @@ test('Fails validation if default export is not function', async () => {
     const config = getFunctionConfig({
         name: func.name,
         path,
-    }, new ImportMap([importMapFile]), deno, logger, {});
+    }, new ImportMap([importMapFile]), deno, logger);
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
     await deleteAsync(tmpDir, { force: true });
 });
@@ -279,7 +243,7 @@ test('Fails validation if default export is not present', async () => {
     const config = getFunctionConfig({
         name: func.name,
         path,
-    }, new ImportMap([importMapFile]), deno, logger, {});
+    }, new ImportMap([importMapFile]), deno, logger);
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
     await deleteAsync(tmpDir, { force: true });
 });

package/dist/node/declaration.d.ts

@@ -15,6 +15,6 @@ type DeclarationWithPattern = BaseDeclaration & {
     excludedPattern?: string;
 };
 export type Declaration = DeclarationWithPath | DeclarationWithPattern;
-export declare const mergeDeclarations: (tomlDeclarations: Declaration[], userFunctionsConfig: Record<string, FunctionConfig>, internalFunctionsConfig: Record<string, FunctionConfig>, deployConfigDeclarations: Declaration[], featureFlags?: FeatureFlags) => Declaration[];
+export declare const mergeDeclarations: (tomlDeclarations: Declaration[], userFunctionsConfig: Record<string, FunctionConfig>, internalFunctionsConfig: Record<string, FunctionConfig>, deployConfigDeclarations: Declaration[], _featureFlags?: FeatureFlags) => Declaration[];
 export declare const parsePattern: (pattern: string) => string;
 export {};

package/dist/node/declaration.js

@@ -1,30 +1,20 @@
 import regexpAST from 'regexp-tree';
-export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, internalFunctionsConfig, deployConfigDeclarations, featureFlags = {}) => {
+export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, internalFunctionsConfig, deployConfigDeclarations, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_featureFlags = {}) => {
     const functionsVisited = new Set();
-    let declarations = getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited);
-    // eslint-disable-next-line unicorn/prefer-ternary
-    if (featureFlags.edge_functions_correct_order) {
-        declarations = [
-            // INTEGRATIONS
-            // 1. Declarations from the integrations deploy config
-            ...getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited),
-            // 2. Declarations from the integrations ISC
-            ...createDeclarationsFromFunctionConfigs(internalFunctionsConfig, functionsVisited),
-            // USER
-            // 3. Declarations from the users toml config
-            ...getDeclarationsFromInput(tomlDeclarations, userFunctionsConfig, functionsVisited),
-            // 4. Declarations from the users ISC
-            ...createDeclarationsFromFunctionConfigs(userFunctionsConfig, functionsVisited),
-        ];
-    }
-    else {
-        declarations = [
-            ...getDeclarationsFromInput(tomlDeclarations, userFunctionsConfig, functionsVisited),
-            ...getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited),
-            ...createDeclarationsFromFunctionConfigs(internalFunctionsConfig, functionsVisited),
-            ...createDeclarationsFromFunctionConfigs(userFunctionsConfig, functionsVisited),
-        ];
-    }
+    const declarations = [
+        // INTEGRATIONS
+        // 1. Declarations from the integrations deploy config
+        ...getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited),
+        // 2. Declarations from the integrations ISC
+        ...createDeclarationsFromFunctionConfigs(internalFunctionsConfig, functionsVisited),
+        // USER
+        // 3. Declarations from the users toml config
+        ...getDeclarationsFromInput(tomlDeclarations, userFunctionsConfig, functionsVisited),
+        // 4. Declarations from the users ISC
+        ...createDeclarationsFromFunctionConfigs(userFunctionsConfig, functionsVisited),
+    ];
     return declarations;
 };
 const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsVisited) => {
@@ -76,9 +66,8 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
 // Validates and normalizes a pattern so that it's a valid regular expression
 // in Go, which is the engine used by our edge nodes.
 export const parsePattern = (pattern) => {
-    // Escaping forward slashes with back slashes.
-    const normalizedPattern = pattern.replace(/\//g, '\\/');
-    const regex = regexpAST.transform(`/${normalizedPattern}/`, {
+    const regexp = new RegExp(pattern);
+    const newRegexp = regexpAST.transform(regexp, {
         Assertion(path) {
             // Lookaheads are not supported. If we find one, throw an error.
             if (path.node.kind === 'Lookahead') {
@@ -99,5 +88,5 @@ export const parsePattern = (pattern) => {
         },
     });
     // Strip leading and forward slashes.
-    return regex.toString().slice(1, -1);
+    return newRegexp.toString().slice(1, -1);
 };

package/dist/node/declaration.test.js

@@ -1,5 +1,5 @@
 import { test, expect } from 'vitest';
-import { mergeDeclarations } from './declaration.js';
+import { mergeDeclarations, parsePattern } from './declaration.js';
 const deployConfigDeclarations = [];
 test('Ensure the order of edge functions with FF', () => {
     const deployConfigDeclarations = [
@@ -18,30 +18,7 @@ test('Ensure the order of edge functions with FF', () => {
     const internalFuncConfig = {
         'framework-isc-c': { path: ['/path1', '/path2'] },
     };
-    expect(mergeDeclarations(tomlConfig, userFuncConfig, internalFuncConfig, deployConfigDeclarations, {
-        edge_functions_correct_order: true,
-    })).toMatchSnapshot();
-});
-test('Ensure the order of edge functions without FF', () => {
-    const deployConfigDeclarations = [
-        { function: 'framework-manifest-a', path: '/path1' },
-        { function: 'framework-manifest-c', path: '/path3' },
-        { function: 'framework-manifest-b', path: '/path2' },
-    ];
-    const tomlConfig = [
-        { function: 'user-toml-a', path: '/path1' },
-        { function: 'user-toml-c', path: '/path3' },
-        { function: 'user-toml-b', path: '/path2' },
-    ];
-    const userFuncConfig = {
-        'user-isc-c': { path: ['/path1', '/path2'] },
-    };
-    const internalFuncConfig = {
-        'framework-isc-c': { path: ['/path1', '/path2'] },
-    };
-    expect(mergeDeclarations(tomlConfig, userFuncConfig, internalFuncConfig, deployConfigDeclarations, {
-        edge_functions_correct_order: false,
-    })).toMatchSnapshot();
+    expect(mergeDeclarations(tomlConfig, userFuncConfig, internalFuncConfig, deployConfigDeclarations)).toMatchSnapshot();
 });
 test('In-source config takes precedence over netlify.toml config', () => {
     const tomlConfig = [
@@ -137,3 +114,15 @@ test('netlify.toml-defined excludedPath are respected', () => {
     const declarations = mergeDeclarations(tomlConfig, funcConfig, {}, deployConfigDeclarations);
     expect(declarations).toEqual(expectedDeclarations);
 });
+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)?[\\/#\\?]?$';
+    const actual = parsePattern(regexPattern);
+    expect(actual).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)?[/#\\?]?$';
+    const actual = parsePattern(regexPattern);
+    expect(actual).toEqual(expected);
+});

package/dist/node/feature_flags.d.ts

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

package/dist/node/feature_flags.js

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

package/dist/node/manifest.d.ts

@@ -44,4 +44,4 @@ interface WriteManifestOptions extends GenerateManifestOptions {
     distDirectory: string;
 }
 declare const writeManifest: ({ distDirectory, ...rest }: WriteManifestOptions) => Promise<Manifest>;
-export { generateManifest, Manifest, writeManifest };
+export { generateManifest, Manifest, Route, writeManifest };

package/dist/node/manifest.test.js

@@ -1,5 +1,6 @@
 import { env } from 'process';
 import { test, expect, vi } from 'vitest';
+import { getRouteMatcher } from '../test/util.js';
 import { BundleFormat } from './bundle.js';
 import { generateManifest } from './manifest.js';
 test('Generates a manifest with different bundles', () => {
@@ -56,23 +57,45 @@ 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' },
+        { name: 'func-3', path: '/path/to/func-3.ts' },
     ];
     const declarations = [
         { function: 'func-1', path: '/f1/*', excludedPath: '/f1/exclude' },
         { function: 'func-2', pattern: '^/f2/.*/?$', excludedPattern: '^/f2/exclude$' },
+        { function: 'func-3', path: '/*', excludedPath: '/**/*.html' },
     ];
     const manifest = generateManifest({ bundles: [], declarations, functions });
     const expectedRoutes = [
         { function: 'func-1', pattern: '^/f1/.*/?$' },
         { function: 'func-2', pattern: '^/f2/.*/?$' },
+        { function: 'func-3', pattern: '^/.*/?$' },
     ];
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.function_config).toEqual({
         'func-1': { excluded_patterns: ['^/f1/exclude/?$'] },
         'func-2': { excluded_patterns: ['^/f2/exclude$'] },
+        'func-3': { excluded_patterns: ['^/.*/.*\\.html/?$'] },
+    });
+    expect(manifest.bundler_version).toBe(env.npm_package_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();
+});
+test('TOML-defined paths can be combined with ISC-defined excluded paths', () => {
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', path: '/f1/*' }];
+    const userFunctionConfig = {
+        'func-1': { excludedPath: '/f1/exclude' },
+    };
+    const manifest = generateManifest({ bundles: [], declarations, functions, userFunctionConfig });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$' }];
+    expect(manifest.routes).toEqual(expectedRoutes);
+    expect(manifest.function_config).toEqual({
+        'func-1': { excluded_patterns: ['^/f1/exclude/?$'] },
     });
     expect(manifest.bundler_version).toBe(env.npm_package_version);
 });

package/dist/node/server/server.js

@@ -43,7 +43,7 @@ const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, fo
         });
         let functionsConfig = [];
         if (options.getFunctionsConfig) {
-            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig(func, importMap, deno, logger, {})));
+            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig(func, importMap, deno, logger)));
         }
         const success = await waitForServer(port, processRef.ps);
         return {

package/dist/test/util.d.ts

@@ -1,3 +1,4 @@
+import type { Manifest } from '../node/manifest.js';
 declare const testLogger: import("../node/logger.js").Logger;
 declare const fixturesDir: string;
 declare const useFixture: (fixtureName: string) => Promise<{
@@ -5,5 +6,6 @@ declare const useFixture: (fixtureName: string) => Promise<{
     cleanup: () => Promise<void>;
     distPath: string;
 }>;
+declare const getRouteMatcher: (manifest: Manifest) => (candidate: string) => import("../node/manifest.js").Route | undefined;
 declare const runESZIP: (eszipPath: string) => Promise<any>;
-export { fixturesDir, testLogger, runESZIP, useFixture };
+export { fixturesDir, getRouteMatcher, testLogger, runESZIP, useFixture };

package/dist/test/util.js

@@ -35,6 +35,15 @@ const inspectFunction = (path) => `
   
   console.log(JSON.stringify(responses));
 `;
+const getRouteMatcher = (manifest) => (candidate) => manifest.routes.find((route) => {
+    const regex = new RegExp(route.pattern);
+    if (!regex.test(candidate)) {
+        return false;
+    }
+    const excludedPattern = manifest.function_config[route.function].excluded_patterns;
+    const isExcluded = excludedPattern.some((pattern) => new RegExp(pattern).test(candidate));
+    return !isExcluded;
+});
 const runESZIP = async (eszipPath) => {
     var _a, _b, _c;
     const tmpDir = await tmp.dir({ unsafeCleanup: true });
@@ -66,4 +75,4 @@ const runESZIP = async (eszipPath) => {
     await tmpDir.cleanup();
     return JSON.parse(result.stdout);
 };
-export { fixturesDir, testLogger, runESZIP, useFixture };
+export { fixturesDir, getRouteMatcher, testLogger, runESZIP, useFixture };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.13.2",
+  "version": "8.14.1",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -42,7 +42,7 @@
   },
   "keywords": [],
   "license": "MIT",
-  "repository": "netlify/edge-bundler",
+  "repository": "https://github.com/netlify/edge-bundler",
   "bugs": {
     "url": "https://github.com/netlify/edge-bundler/issues"
   },
@@ -58,7 +58,7 @@
     "@types/node": "^14.18.32",
     "@types/semver": "^7.3.9",
     "@types/uuid": "^9.0.0",
-    "@vitest/coverage-c8": "^0.30.0",
+    "@vitest/coverage-c8": "^0.31.0",
     "archiver": "^5.3.1",
     "chalk": "^4.1.2",
     "cpy": "^9.0.1",
@@ -67,7 +67,7 @@
     "nock": "^13.2.4",
     "tar": "^6.1.11",
     "typescript": "^5.0.0",
-    "vitest": "^0.30.0"
+    "vitest": "^0.31.0"
   },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"