@netlify/config 20.7.0 → 20.8.0

package/lib/base.js

@@ -1,26 +1,34 @@
 import { resolvePath } from './files.js';
-// Retrieve the first `base` directory used to load the first config file.
-export const getInitialBase = function ({ repositoryRoot, defaultConfig: { build: { base: defaultBase } = {} }, inlineConfig: { build: { base: initialBase = defaultBase } = {} }, }) {
+/**
+ * Retrieve the first `base` directory used to load the first config file.
+ */
+export const getInitialBase = function ({ repositoryRoot, 
+// @ts-expect-error TODO: enhance the types later on, just moved the file to .ts
+defaultConfig: { build: { base: defaultBase } = {} }, inlineConfig: { build: { base: initialBase = defaultBase } = {} }, }) {
     return resolveBase(repositoryRoot, initialBase);
 };
-// Two config files can be used:
-//  - The first one, using the `config` property or doing a default lookup
-//    of `netlify.toml`
-//  - If the first one has a `base` property pointing to a directory with
-//    another `netlify.toml`, that second config file is used instead.
-// This retrieves the final `base` directory used:
-//  - To load the second config file
-//  - As the `buildDir`
-//  - To resolve file paths
-// If the second file has a `base` property, it is ignored, i.e. it is not
-// recursive.
+/**
+ * Two config files can be used:
+ *  - The first one, using the `config` property or doing a default lookup
+ *    of `netlify.toml`
+ *  - If the first one has a `base` property pointing to a directory with
+ *    another `netlify.toml`, that second config file is used instead.
+ * This retrieves the final `base` directory used:
+ *  - To load the second config file
+ *  - As the `buildDir`
+ *  - To resolve file paths
+ * If the second file has a `base` property, it is ignored, i.e. it is not
+ * recursive.
+ */
 export const getBase = function (base, repositoryRoot, config) {
     return base === undefined ? resolveBase(repositoryRoot, config.build.base) : base;
 };
 const resolveBase = function (repositoryRoot, base) {
     return resolvePath(repositoryRoot, repositoryRoot, base, 'build.base');
 };
-// Also `config.build.base`.
+/**
+ * Also `config.build.base`.
+ */
 export const addBase = function (config, base) {
     return { ...config, build: { ...config.build, base } };
 };

package/lib/bin/flags.js

@@ -72,6 +72,10 @@ Default: empty array.`,
         describe: `Current directory. Used to retrieve the configuration file.
 Default: current directory`,
     },
+    packagePath: {
+        string: true,
+        describe: `A relative path from the repository root to the package. Used inside monorepos to specify a package`,
+    },
     repositoryRoot: {
         string: true,
         describe: `Git repository root directory. Used to retrieve the configuration file.

package/lib/build_dir.js

@@ -1,19 +1,23 @@
 import { isDirectory } from 'path-type';
 import { throwUserError } from './error.js';
-// Retrieve the build directory used to resolve most paths.
-// This is (in priority order):
-//  - `build.base`
-//  - `--repositoryRoot`
-//  - the current directory (default value of `--repositoryRoot`)
+/**
+ * Retrieve the build directory used to resolve most paths.
+ * This is (in priority order):
+ *  - `build.base`
+ *  - `--repositoryRoot`
+ *  - the current directory (default value of `--repositoryRoot`)
+ */
 export const getBuildDir = async function (repositoryRoot, base) {
     const buildDir = base === undefined ? repositoryRoot : base;
     await checkBuildDir(buildDir, repositoryRoot);
     return buildDir;
 };
-// The build directory is used as the current directory of build commands and
-// build plugins. Therefore, it must exist.
-// We already check `repositoryRoot` earlier in the code, so only need to check
-// `buildDir` when it is the base directory instead.
+/**
+ * The build directory is used as the current directory of build commands and
+ * build plugins. Therefore, it must exist.
+ * We already check `repositoryRoot` earlier in the code, so only need to check
+ * `buildDir` when it is the base directory instead.
+ */
 const checkBuildDir = async function (buildDir, repositoryRoot) {
     if (buildDir === repositoryRoot || (await isDirectory(buildDir))) {
         return;

package/lib/files.js

@@ -1,26 +1,44 @@
 import { existsSync } from 'fs';
-import { resolve, relative, parse } from 'path';
+import { resolve, relative, parse, join } from 'path';
 import { getProperty, setProperty, deleteProperty } from 'dot-prop';
 import { throwUserError } from './error.js';
 import { mergeConfigs } from './merge.js';
 import { isTruthy } from './utils/remove_falsy.js';
-// Make configuration paths relative to `buildDir` and converts them to
-// absolute paths
-export const resolveConfigPaths = function ({ config, repositoryRoot, buildDir, baseRelDir }) {
-    const baseRel = baseRelDir ? buildDir : repositoryRoot;
-    const configA = resolvePaths(config, FILE_PATH_CONFIG_PROPS, baseRel, repositoryRoot);
-    const configB = addDefaultPaths(configA, repositoryRoot, baseRel);
-    return configB;
-};
-// All file paths in the configuration file are relative to `buildDir`
-// (if `baseRelDir` is `true`).
+/**
+ * We allow paths in configuration file to start with /
+ * In that case, those are actually relative paths not absolute.
+ */
+const LEADING_SLASH_REGEXP = /^\/+/;
+/**
+ * All file paths in the configuration file are relative to `buildDir`
+ * (if `baseRelDir` is `true`).
+ */
 const FILE_PATH_CONFIG_PROPS = [
     'functionsDirectory',
     'functions.*.deno_import_map',
     'build.publish',
     'build.edge_functions',
 ];
-const resolvePaths = function (config, propNames, baseRel, repositoryRoot) {
+/**
+ * Make configuration paths relative to `buildDir` and converts them to
+ * absolute paths
+ */
+export const resolveConfigPaths = function (options) {
+    const baseRel = options.baseRelDir ? options.buildDir : options.repositoryRoot;
+    const config = resolvePaths({
+        config: options.config,
+        propNames: FILE_PATH_CONFIG_PROPS,
+        baseRel,
+        repositoryRoot: options.repositoryRoot,
+    });
+    return addDefaultPaths({
+        config,
+        repositoryRoot: options.repositoryRoot,
+        baseRel,
+        packagePath: options.packagePath,
+    });
+};
+const resolvePaths = function ({ config, propNames, baseRel, repositoryRoot, }) {
     return propNames.reduce((configA, propName) => resolvePathProp(configA, propName, baseRel, repositoryRoot), config);
 };
 const resolvePathProp = function (config, propName, baseRel, repositoryRoot) {
@@ -31,7 +49,7 @@ const resolvePathProp = function (config, propName, baseRel, repositoryRoot) {
     }
     return setProperty(config, propName, resolvePath(repositoryRoot, baseRel, path, propName));
 };
-export const resolvePath = function (repositoryRoot, baseRel, originalPath, propName) {
+export const resolvePath = (repositoryRoot, baseRel, originalPath, propName) => {
     if (!isTruthy(originalPath)) {
         return;
     }
@@ -40,24 +58,23 @@ export const resolvePath = function (repositoryRoot, baseRel, originalPath, prop
     validateInsideRoot(originalPath, pathA, repositoryRoot, propName);
     return pathA;
 };
-// We allow paths in configuration file to start with /
-// In that case, those are actually relative paths not absolute.
-const LEADING_SLASH_REGEXP = /^\/+/;
-// We ensure all file paths are within the repository root directory.
-// However, we allow file paths to be outside the build directory, since this
-// can be convenient in monorepo setups.
-const validateInsideRoot = function (originalPath, path, repositoryRoot, propName) {
+/**
+ * We ensure all file paths are within the repository root directory.
+ * However, we allow file paths to be outside the build directory, since this
+ * can be convenient in monorepo setups.
+ */
+const validateInsideRoot = (originalPath, path, repositoryRoot, propName) => {
     if (relative(repositoryRoot, path).startsWith('..') || getWindowsDrive(repositoryRoot) !== getWindowsDrive(path)) {
         throwUserError(`Configuration property "${propName}" "${originalPath}" must be inside the repository root directory.`);
     }
 };
-const getWindowsDrive = function (path) {
-    return parse(path).root;
-};
-// Some configuration properties have default values that are only set if a
-// specific directory/file exists in the build directory
-const addDefaultPaths = function (config, repositoryRoot, baseRel) {
-    const defaultPathsConfigs = DEFAULT_PATHS.map(({ defaultPath, getConfig, propName }) => addDefaultPath({ repositoryRoot, baseRel, defaultPath, getConfig, propName })).filter(Boolean);
+const getWindowsDrive = (path) => parse(path).root;
+/**
+ * Some configuration properties have default values that are only set if a
+ * specific directory/file exists in the build directory
+ */
+const addDefaultPaths = ({ config, repositoryRoot, baseRel, packagePath, }) => {
+    const defaultPathsConfigs = DEFAULT_PATHS.map(({ defaultPath, getConfig, propName }) => addDefaultPath({ repositoryRoot, packagePath, baseRel, defaultPath, getConfig, propName })).filter(Boolean);
     return mergeConfigs([...defaultPathsConfigs, config]);
 };
 const DEFAULT_PATHS = [
@@ -78,9 +95,9 @@ const DEFAULT_PATHS = [
         propName: 'build.edge_functions',
     },
 ];
-const addDefaultPath = function ({ repositoryRoot, baseRel, defaultPath, getConfig, propName }) {
-    const absolutePath = resolvePath(repositoryRoot, baseRel, defaultPath, propName);
-    if (!existsSync(absolutePath)) {
+const addDefaultPath = ({ repositoryRoot, packagePath, baseRel, defaultPath, getConfig, propName, }) => {
+    const absolutePath = resolvePath(repositoryRoot, join(baseRel, packagePath || ''), defaultPath, propName);
+    if (!absolutePath || !existsSync(absolutePath)) {
         return;
     }
     return getConfig(absolutePath);

package/lib/main.js

@@ -17,11 +17,13 @@ import { UI_ORIGIN, CONFIG_ORIGIN, INLINE_ORIGIN } from './origin.js';
 import { parseConfig } from './parse.js';
 import { getConfigPath } from './path.js';
 import { getRedirectsPath, addRedirects } from './redirects.js';
-// Load the configuration file.
-// Takes an optional configuration file path as input and return the resolved
-// `config` together with related properties such as the `configPath`.
+/**
+ * Load the configuration file.
+ * Takes an optional configuration file path as input and return the resolved
+ * `config` together with related properties such as the `configPath`.
+ */
 export const resolveConfig = async function (opts) {
-    const { cachedConfig, cachedConfigPath, host, scheme, pathPrefix, testOpts, token, offline, siteFeatureFlagPrefix, ...optsA } = addDefaultOpts(opts);
+    const { cachedConfig, cachedConfigPath, host, scheme, packagePath, pathPrefix, testOpts, token, offline, siteFeatureFlagPrefix, ...optsA } = addDefaultOpts(opts);
     // `api` is not JSON-serializable, so we cannot cache it inside `cachedConfig`
     const api = getApiClient({ token, offline, host, scheme, pathPrefix, testOpts });
     const parsedCachedConfig = await getCachedConfig({ cachedConfig, cachedConfigPath, token, api });
@@ -52,6 +54,7 @@ export const resolveConfig = async function (opts) {
         cwd,
         context,
         repositoryRoot,
+        packagePath,
         branch,
         defaultConfig: defaultConfigA,
         inlineConfig: inlineConfigA,
@@ -95,8 +98,10 @@ export const resolveConfig = async function (opts) {
     logResult(result, { logs, debug });
     return result;
 };
-// Adds a `build.functions` property that mirrors `functionsDirectory`, for
-// backward compatibility.
+/**
+ * Adds a `build.functions` property that mirrors `functionsDirectory`, for
+ * backward compatibility.
+ */
 const addLegacyFunctionsDirectory = (config) => {
     if (!config.functionsDirectory) {
         return config;
@@ -109,10 +114,12 @@ const addLegacyFunctionsDirectory = (config) => {
         },
     };
 };
-// Try to load the configuration file in two passes.
-// The first pass uses the `defaultConfig`'s `build.base` (if defined).
-// The second pass uses the `build.base` from the first pass (if defined).
-const loadConfig = async function ({ configOpt, cwd, context, repositoryRoot, branch, defaultConfig, inlineConfig, baseRelDir, logs, featureFlags, }) {
+/**
+ * Try to load the configuration file in two passes.
+ * The first pass uses the `defaultConfig`'s `build.base` (if defined).
+ * The second pass uses the `build.base` from the first pass (if defined).
+ */
+const loadConfig = async function ({ configOpt, cwd, context, repositoryRoot, packagePath, branch, defaultConfig, inlineConfig, baseRelDir, logs, featureFlags, }) {
     const initialBase = getInitialBase({ repositoryRoot, defaultConfig, inlineConfig });
     const { configPath, config, buildDir, base, redirectsPath, headersPath } = await getFullConfig({
         configOpt,
@@ -123,6 +130,7 @@ const loadConfig = async function ({ configOpt, cwd, context, repositoryRoot, br
         defaultConfig,
         inlineConfig,
         baseRelDir,
+        packagePath,
         configBase: initialBase,
         logs,
         featureFlags,
@@ -158,9 +166,17 @@ const loadConfig = async function ({ configOpt, cwd, context, repositoryRoot, br
         headersPath: headersPathA,
     };
 };
-// Load configuration file and normalize it, merge contexts, etc.
-const getFullConfig = async function ({ configOpt, cwd, context, repositoryRoot, branch, defaultConfig, inlineConfig, baseRelDir, configBase, base, logs, featureFlags, }) {
-    const configPath = await getConfigPath({ configOpt, cwd, repositoryRoot, configBase });
+/**
+ * Load configuration file and normalize it, merge contexts, etc.
+ */
+const getFullConfig = async function ({ configOpt, cwd, context, repositoryRoot, packagePath, branch, defaultConfig, inlineConfig, baseRelDir, configBase, base, logs, featureFlags, }) {
+    const configPath = await getConfigPath({
+        configOpt,
+        cwd,
+        repositoryRoot,
+        packagePath,
+        configBase,
+    });
     try {
         const config = await parseConfig(configPath);
         const configA = mergeAndNormalizeConfig({
@@ -170,8 +186,9 @@ const getFullConfig = async function ({ configOpt, cwd, context, repositoryRoot,
             context,
             branch,
             logs,
+            packagePath,
         });
-        const { config: configB, buildDir, base: baseA, } = await resolveFiles({ config: configA, repositoryRoot, base, baseRelDir });
+        const { config: configB, buildDir, base: baseA, } = await resolveFiles({ packagePath, config: configA, repositoryRoot, base, baseRelDir });
         const headersPath = getHeadersPath(configB);
         const configC = await addHeaders({ config: configB, headersPath, logs, featureFlags });
         const redirectsPath = getRedirectsPath(configC);
@@ -184,33 +201,36 @@ const getFullConfig = async function ({ configOpt, cwd, context, repositoryRoot,
         throw error;
     }
 };
-// Merge:
-//  - `--defaultConfig`: UI build settings and UI-installed plugins
-//  - `inlineConfig`: Netlify CLI flags
-// Then merge context-specific configuration.
-// Before and after those steps, also performs validation and normalization.
-// Those need to be done at different stages depending on whether they should
-// happen before/after the merges mentioned above.
-const mergeAndNormalizeConfig = function ({ config, defaultConfig, inlineConfig, context, branch, logs }) {
+/**
+ * Merge:
+ *  - `--defaultConfig`: UI build settings and UI-installed plugins
+ *  - `inlineConfig`: Netlify CLI flags
+ * Then merge context-specific configuration.
+ * Before and after those steps, also performs validation and normalization.
+ * Those need to be done at different stages depending on whether they should
+ * happen before/after the merges mentioned above.
+ */
+const mergeAndNormalizeConfig = function ({ config, defaultConfig, inlineConfig, context, branch, logs, packagePath }) {
     const configA = normalizeConfigAndContext(config, CONFIG_ORIGIN);
     const defaultConfigA = normalizeConfigAndContext(defaultConfig, UI_ORIGIN);
     const inlineConfigA = normalizeConfigAndContext(inlineConfig, INLINE_ORIGIN);
     const configB = mergeConfigs([defaultConfigA, configA]);
     const configC = mergeContext({ config: configB, context, branch, logs });
     const configD = mergeConfigs([configC, inlineConfigA]);
-    const configE = normalizeAfterConfigMerge(configD);
-    return configE;
+    return normalizeAfterConfigMerge(configD, packagePath);
 };
 const normalizeConfigAndContext = function (config, origin) {
     const configA = normalizeBeforeConfigMerge(config, origin);
     const configB = normalizeContextProps({ config: configA, origin });
     return configB;
 };
-// Find base directory, build directory and resolve all paths to absolute paths
-const resolveFiles = async function ({ config, repositoryRoot, base, baseRelDir }) {
+/**
+ * Find base directory, build directory and resolve all paths to absolute paths
+ */
+const resolveFiles = async function ({ config, repositoryRoot, base, packagePath, baseRelDir, }) {
     const baseA = getBase(base, repositoryRoot, config);
     const buildDir = await getBuildDir(repositoryRoot, baseA);
-    const configA = resolveConfigPaths({ config, repositoryRoot, buildDir, baseRelDir });
+    const configA = resolveConfigPaths({ config, packagePath, repositoryRoot, buildDir, baseRelDir });
     const configB = addBase(configA, baseA);
     return { config: configB, buildDir, base: baseA };
 };

package/lib/merge_normalize.js

@@ -3,10 +3,12 @@ import { normalizeConfig } from './normalize.js';
 import { addOrigins } from './origin.js';
 import { validateIdenticalPlugins } from './validate/identical.js';
 import { validatePreCaseNormalize, validatePreMergeConfig, validatePreNormalizeConfig, validatePostNormalizeConfig, } from './validate/main.js';
-// Perform validation and normalization logic to apply to all of:
-//  - config, defaultConfig, inlineConfig
-//  - context-specific configs
-// Therefore, this is performing before merging those together.
+/**
+ * Perform validation and normalization logic to apply to all of:
+ *  - config, defaultConfig, inlineConfig
+ *  - context-specific configs
+ * Therefore, this is performing before merging those together.
+ */
 export const normalizeBeforeConfigMerge = function (config, origin) {
     validatePreCaseNormalize(config);
     const configA = normalizeConfigCase(config);
@@ -15,10 +17,12 @@ export const normalizeBeforeConfigMerge = function (config, origin) {
     validateIdenticalPlugins(configB);
     return configB;
 };
-// Validation and normalization logic performed after merging
-export const normalizeAfterConfigMerge = function (config) {
+/**
+ * Validation and normalization logic performed after merging
+ */
+export const normalizeAfterConfigMerge = function (config, packagePath) {
     validatePreNormalizeConfig(config);
-    const configA = normalizeConfig(config);
+    const configA = normalizeConfig(config, packagePath);
     validatePostNormalizeConfig(configA);
     return configA;
 };

package/lib/normalize.js

@@ -2,31 +2,35 @@ import { normalizeFunctionsProps, WILDCARD_ALL } from './functions_config.js';
 import { mergeConfigs } from './merge.js';
 import { DEFAULT_ORIGIN } from './origin.js';
 import { removeFalsy } from './utils/remove_falsy.js';
-// Normalize configuration object
-export const normalizeConfig = function (config) {
+/**
+ * Normalize configuration object
+ */
+export const normalizeConfig = function (config, packagePath) {
     const configA = removeEmpty(config);
-    const { build, functions, plugins, ...configB } = mergeConfigs([DEFAULT_CONFIG, configA]);
+    const { build, functions, plugins, ...configB } = mergeConfigs([DEFAULT_CONFIG(packagePath), configA]);
     const { build: buildA, functions: functionsA, functionsDirectoryProps } = normalizeFunctionsProps(build, functions);
     const pluginsA = plugins.map(normalizePlugin);
     return { ...configB, build: buildA, functions: functionsA, plugins: pluginsA, ...functionsDirectoryProps };
 };
-// Remove empty strings.
-// This notably ensures that empty strings in the build command are removed.
-// Otherwise, those would be run during builds, making the build fail.
+/**
+ * Remove empty strings.
+ * This notably ensures that empty strings in the build command are removed.
+ * Otherwise, those would be run during builds, making the build fail.
+ */
 const removeEmpty = function ({ build, ...config }) {
     return removeFalsy({ ...config, build: removeFalsy(build) });
 };
-const DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = (packagePath) => ({
     build: {
         environment: {},
-        publish: '.',
+        publish: packagePath || '.',
         publishOrigin: DEFAULT_ORIGIN,
         processing: { css: {}, html: {}, images: {}, js: {} },
         services: {},
     },
     functions: { [WILDCARD_ALL]: {} },
     plugins: [],
-};
+});
 const normalizePlugin = function ({ inputs = {}, ...plugin }) {
     return removeFalsy({ ...plugin, inputs });
 };

package/lib/path.js

@@ -1,7 +1,8 @@
 import { existsSync } from 'fs';
-import { resolve } from 'path';
+import { join, resolve } from 'path';
 import { findUp } from 'find-up';
 import pLocate from 'p-locate';
+const FILENAME = 'netlify.toml';
 /**
  * Configuration location can be:
  * - a local path with the --config CLI flag
@@ -9,10 +10,10 @@ import pLocate from 'p-locate';
  * - a `netlify.*` file in the `repositoryRoot`
  * - a `netlify.*` file in the current directory or any parent
  */
-export const getConfigPath = async function ({ configOpt, cwd, repositoryRoot, configBase }) {
+export const getConfigPath = async function ({ configOpt, cwd, repositoryRoot, configBase, packagePath, }) {
     const configPath = await pLocate([
         searchConfigOpt(cwd, configOpt),
-        searchBaseConfigFile(configBase),
+        searchBaseConfigFile(repositoryRoot, configBase, packagePath),
         searchConfigFile(repositoryRoot),
         findUp(FILENAME, { cwd }),
     ], Boolean);
@@ -26,13 +27,14 @@ const searchConfigOpt = function (cwd, configOpt) {
     return resolve(cwd, configOpt);
 };
 /**
- * Look for `repositoryRoot/{base}/netlify.*`
+ * Look for `repositoryRoot/{base}/{packagePath || '}/netlify.*`
  */
-const searchBaseConfigFile = function (configBase) {
-    if (configBase === undefined) {
+const searchBaseConfigFile = function (repoRoot, base, packagePath) {
+    if (base === undefined && packagePath === undefined) {
         return;
     }
-    return searchConfigFile(configBase);
+    const cwd = join(base ? base : repoRoot, packagePath || '');
+    return searchConfigFile(cwd);
 };
 /**
  * Look for several file extensions for `netlify.*`
@@ -44,4 +46,3 @@ const searchConfigFile = function (cwd) {
     }
     return path;
 };
-const FILENAME = 'netlify.toml';

package/lib/redirects.js

@@ -6,13 +6,14 @@ export const getRedirectsPath = function ({ build: { publish } }) {
     return resolve(publish, REDIRECTS_FILENAME);
 };
 const REDIRECTS_FILENAME = '_redirects';
-// Add `config.redirects`
-export const addRedirects = async function ({ config: { redirects: configRedirects, ...config }, redirectsPath, logs, featureFlags, }) {
+/**
+ * Add `config.redirects`
+ */
+export const addRedirects = async function ({ config: { redirects: configRedirects, ...config }, redirectsPath, logs, }) {
     const { redirects, errors } = await parseAllRedirects({
         redirectsFiles: [redirectsPath],
         configRedirects,
         minimal: true,
-        featureFlags,
     });
     warnRedirectsParsing(logs, errors);
     return { ...config, redirects };

package/lib/utils/remove_falsy.js

@@ -1,14 +1,10 @@
 import { includeKeys } from 'filter-obj';
-// Remove falsy values from object
+/**
+ * Remove falsy values from object
+ */
 export const removeFalsy = function (obj) {
-    return includeKeys(obj, (key, value) => isTruthy(value));
-};
-export const removeUndefined = function (obj) {
-    return includeKeys(obj, (key, value) => isDefined(value));
-};
-export const isTruthy = function (value) {
-    return isDefined(value) && (typeof value !== 'string' || value.trim() !== '');
-};
-export const isDefined = function (value) {
-    return value !== undefined && value !== null;
+    return includeKeys(obj, (_key, value) => isTruthy(value));
 };
+export const removeUndefined = (obj) => includeKeys(obj, (_key, value) => isDefined(value));
+export const isTruthy = (value) => isDefined(value) && (typeof value !== 'string' || value.trim() !== '');
+export const isDefined = (value) => value !== undefined && value !== null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/config",
-  "version": "20.7.0",
+  "version": "20.8.0",
   "description": "Netlify config module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -72,7 +72,7 @@
     "map-obj": "^5.0.0",
     "netlify": "^13.1.10",
     "netlify-headers-parser": "^7.1.2",
-    "netlify-redirect-parser": "^14.1.3",
+    "netlify-redirect-parser": "^14.2.0",
     "node-fetch": "^3.3.1",
     "omit.js": "^2.0.2",
     "p-locate": "^6.0.0",
@@ -94,5 +94,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "a20207ec7cdc1101a875d9411355bd48f12733a3"
+  "gitHead": "0c6f5c014958f692559ea720c38415a0e63b7522"
 }