@netlify/build 27.20.4 → 27.20.6

package/lib/time/aggregate.js

@@ -1,146 +1,120 @@
-import { createTimer, TOP_PARENT_TAG } from './main.js'
-
+import { createTimer, TOP_PARENT_TAG } from './main.js';
 // Some timers are computed based on others:
 //   - `others` is `total` minus the other timers
 //   - `run_plugins` is the sum of all plugins
 //   - `run_netlify_build_per_type` aggregates timers but per system/plugin/user
 //   - each plugin timer is the sum of its event handlers
 export const addAggregatedTimers = function (timers) {
-  const timersA = addRunPluginsTimer(timers)
-  const timersB = addPluginTimers(timersA)
-  const timersC = addOthersTimers(timersB)
-  const timersD = addTypeTimers(timersC)
-  return timersD
-}
-
+    const timersA = addRunPluginsTimer(timers);
+    const timersB = addPluginTimers(timersA);
+    const timersC = addOthersTimers(timersB);
+    const timersD = addTypeTimers(timersC);
+    return timersD;
+};
 // Having a `total` timer is redundant since the buildbot already measures this.
 // The buildbot measurement is better since it includes the time to load Node.
 // Instead, we only use `total` to measure what did not get `measureDuration()`.
 const addOthersTimers = function (timers) {
-  const totalTimer = timers.find(isTotalTimer)
-  const timersA = timers.filter((timer) => !isTotalTimer(timer))
-  const topTimers = timersA.filter(isTopTimer)
-  const othersTimer = createOthersTimer(topTimers, totalTimer)
-  return [...timersA, othersTimer]
-}
-
+    const totalTimer = timers.find(isTotalTimer);
+    const timersA = timers.filter((timer) => !isTotalTimer(timer));
+    const topTimers = timersA.filter(isTopTimer);
+    const othersTimer = createOthersTimer(topTimers, totalTimer);
+    return [...timersA, othersTimer];
+};
 const isTotalTimer = function ({ stageTag, parentTag }) {
-  return stageTag === 'total' && parentTag === 'build_site'
-}
-
+    return stageTag === 'total' && parentTag === 'build_site';
+};
 const createOthersTimer = function (topTimers, { durationNs: totalTimerDurationNs }) {
-  const topTimersDurationNs = computeTimersDuration(topTimers)
-  const otherTimersDurationNs = Math.max(0, totalTimerDurationNs - topTimersDurationNs)
-  const othersTimer = createTimer(OTHERS_STAGE_TAG, otherTimersDurationNs)
-  return othersTimer
-}
-
-const OTHERS_STAGE_TAG = 'others'
-
+    const topTimersDurationNs = computeTimersDuration(topTimers);
+    const otherTimersDurationNs = Math.max(0, totalTimerDurationNs - topTimersDurationNs);
+    const othersTimer = createTimer(OTHERS_STAGE_TAG, otherTimersDurationNs);
+    return othersTimer;
+};
+const OTHERS_STAGE_TAG = 'others';
 // Measure the total time running plugins
 const addRunPluginsTimer = function (timers) {
-  const pluginsTimers = timers.filter(isPluginTimer)
-  return pluginsTimers.length === 0 ? timers : [...timers, createSumTimer(pluginsTimers, RUN_PLUGINS_STAGE_TAG)]
-}
-
-const RUN_PLUGINS_STAGE_TAG = 'run_plugins'
-
+    const pluginsTimers = timers.filter(isPluginTimer);
+    return pluginsTimers.length === 0 ? timers : [...timers, createSumTimer(pluginsTimers, RUN_PLUGINS_STAGE_TAG)];
+};
+const RUN_PLUGINS_STAGE_TAG = 'run_plugins';
 // Retrieve one timer for each plugin, summing all its individual timers
 // (one per event handler)
 const addPluginTimers = function (timers) {
-  const timersA = timers.filter((timer) => !isCommunityPluginTimer(timer))
-  const pluginsTimers = timersA.filter(isPluginTimer)
-  if (pluginsTimers.length === 0) {
-    return timersA
-  }
-
-  const pluginPackages = getPluginPackages(pluginsTimers)
-  const wholePluginsTimers = pluginPackages.map((pluginPackage) => getWholePluginTimer(pluginPackage, pluginsTimers))
-  return [...timersA, ...wholePluginsTimers]
-}
-
+    const timersA = timers.filter((timer) => !isCommunityPluginTimer(timer));
+    const pluginsTimers = timersA.filter(isPluginTimer);
+    if (pluginsTimers.length === 0) {
+        return timersA;
+    }
+    const pluginPackages = getPluginPackages(pluginsTimers);
+    const wholePluginsTimers = pluginPackages.map((pluginPackage) => getWholePluginTimer(pluginPackage, pluginsTimers));
+    return [...timersA, ...wholePluginsTimers];
+};
 // We only measure plugins maintained by us, not community
 const isCommunityPluginTimer = function (timer) {
-  return isPluginTimer(timer) && !isNetlifyMaintainedPlugin(getPluginTimerPackage(timer))
-}
-
+    return isPluginTimer(timer) && !isNetlifyMaintainedPlugin(getPluginTimerPackage(timer));
+};
 const isNetlifyMaintainedPlugin = function (pluginPackage) {
-  return NETLIFY_MAINTAINED_PLUGINS.has(pluginPackage)
-}
-
+    return NETLIFY_MAINTAINED_PLUGINS.has(pluginPackage);
+};
 const NETLIFY_MAINTAINED_PLUGINS = new Set([
-  'netlify_plugin_gatsby_cache',
-  'netlify_plugin_sitemap',
-  'netlify_plugin_debug_cache',
-  'netlify_plugin_is_website_vulnerable',
-  'netlify_plugin_lighthouse',
-  'netlify_plugin_nextjs',
-  'netlify_plugin_gatsby',
-])
-
+    'netlify_plugin_gatsby_cache',
+    'netlify_plugin_sitemap',
+    'netlify_plugin_debug_cache',
+    'netlify_plugin_is_website_vulnerable',
+    'netlify_plugin_lighthouse',
+    'netlify_plugin_nextjs',
+    'netlify_plugin_gatsby',
+]);
 const getPluginPackages = function (pluginsTimers) {
-  const pluginPackages = pluginsTimers.map(getPluginTimerPackage)
-  return [...new Set(pluginPackages)]
-}
-
+    const pluginPackages = pluginsTimers.map(getPluginTimerPackage);
+    return [...new Set(pluginPackages)];
+};
 const getWholePluginTimer = function (pluginPackage, pluginsTimers) {
-  const pluginTimers = pluginsTimers.filter((pluginTimer) => getPluginTimerPackage(pluginTimer) === pluginPackage)
-  const wholePluginsTimer = createSumTimer(pluginTimers, pluginPackage, RUN_PLUGINS_STAGE_TAG)
-  return wholePluginsTimer
-}
-
+    const pluginTimers = pluginsTimers.filter((pluginTimer) => getPluginTimerPackage(pluginTimer) === pluginPackage);
+    const wholePluginsTimer = createSumTimer(pluginTimers, pluginPackage, RUN_PLUGINS_STAGE_TAG);
+    return wholePluginsTimer;
+};
 const getPluginTimerPackage = function ({ parentTag }) {
-  return parentTag
-}
-
+    return parentTag;
+};
 // Check if a timer relates to a Build plugin
 const isPluginTimer = function ({ category }) {
-  return category === 'pluginEvent'
-}
-
+    return category === 'pluginEvent';
+};
 // Reports total time depending on whether it was system, plugin or user
 const addTypeTimers = function (timers) {
-  const topTimers = timers.filter(isTopTimer)
-  const typeTimers = TYPE_TIMERS.map(({ name, stages }) => getTypeTimer(name, stages, topTimers)).filter(Boolean)
-  return [...timers, ...typeTimers]
-}
-
+    const topTimers = timers.filter(isTopTimer);
+    const typeTimers = TYPE_TIMERS.map(({ name, stages }) => getTypeTimer(name, stages, topTimers)).filter(Boolean);
+    return [...timers, ...typeTimers];
+};
 const TYPE_TIMERS = [
-  { name: 'system', stages: ['resolve_config', 'get_plugins_options', 'start_plugins', 'others'] },
-  { name: 'plugin', stages: ['load_plugins', 'run_plugins'] },
-  { name: 'user', stages: ['build_command', 'functions_bundling', 'deploy_site'] },
-]
-
+    { name: 'system', stages: ['resolve_config', 'get_plugins_options', 'start_plugins', 'others'] },
+    { name: 'plugin', stages: ['load_plugins', 'run_plugins'] },
+    { name: 'user', stages: ['build_command', 'functions_bundling', 'deploy_site'] },
+];
 const getTypeTimer = function (name, stages, topTimers) {
-  const topTimersA = topTimers.filter(({ stageTag }) => stages.includes(stageTag))
-
-  if (topTimersA.length === 0) {
-    return
-  }
-
-  const typeTimer = createSumTimer(topTimersA, name, 'run_netlify_build_per_type')
-  return typeTimer
-}
-
+    const topTimersA = topTimers.filter(({ stageTag }) => stages.includes(stageTag));
+    if (topTimersA.length === 0) {
+        return;
+    }
+    const typeTimer = createSumTimer(topTimersA, name, 'run_netlify_build_per_type');
+    return typeTimer;
+};
 const isTopTimer = function ({ parentTag }) {
-  return parentTag === TOP_PARENT_TAG
-}
-
+    return parentTag === TOP_PARENT_TAG;
+};
 // Creates a timer that sums up the duration of several others
 const createSumTimer = function (timers, stageTag, parentTag) {
-  const durationNs = computeTimersDuration(timers)
-  const timer = createTimer(stageTag, durationNs, { parentTag })
-  return timer
-}
-
+    const durationNs = computeTimersDuration(timers);
+    const timer = createTimer(stageTag, durationNs, { parentTag });
+    return timer;
+};
 const computeTimersDuration = function (timers) {
-  return timers.map(getTimerDuration).reduce(reduceSum, 0)
-}
-
+    return timers.map(getTimerDuration).reduce(reduceSum, 0);
+};
 const getTimerDuration = function ({ durationNs }) {
-  return durationNs
-}
-
+    return durationNs;
+};
 const reduceSum = function (sum, number) {
-  return sum + number
-}
+    return sum + number;
+};

package/lib/time/main.js

@@ -1,13 +1,10 @@
-import slugify from '@sindresorhus/slugify'
-import keepFuncProps from 'keep-func-props'
-
-import { startTimer, endTimer } from './measure.js'
-
+import slugify from '@sindresorhus/slugify';
+import keepFuncProps from 'keep-func-props';
+import { startTimer, endTimer } from './measure.js';
 // Initialize the `timers` array
 export const initTimers = function () {
-  return []
-}
-
+    return [];
+};
 // Wrap an async function to measure how long it takes.
 // The function must:
 //   - take a plain object as first argument. This must contain a `timers`.
@@ -15,34 +12,26 @@ export const initTimers = function () {
 // The `durationNs` will be returned by the function. A new `timers` with the
 // additional duration timer will be returned as well.
 const kMeasureDuration = function (func, stageTag, { parentTag, category } = {}) {
-  return async function measuredFunc({ timers, ...opts }, ...args) {
-    const timerNs = startTimer()
-    const { timers: timersA = timers, ...returnObject } = await func({ timers, ...opts }, ...args)
-    const { tags = {} } = returnObject
-    const durationNs = endTimer(timerNs)
-    const timer = createTimer(stageTag, durationNs, { parentTag, category, tags })
-    const timersB = [...timersA, timer]
-    return { ...returnObject, timers: timersB, durationNs }
-  }
-}
-
+    return async function measuredFunc({ timers, ...opts }, ...args) {
+        const timerNs = startTimer();
+        const { timers: timersA = timers, ...returnObject } = await func({ timers, ...opts }, ...args);
+        const { tags = {} } = returnObject;
+        const durationNs = endTimer(timerNs);
+        const timer = createTimer(stageTag, durationNs, { parentTag, category, tags });
+        const timersB = [...timersA, timer];
+        return { ...returnObject, timers: timersB, durationNs };
+    };
+};
 // Ensure the wrapped function `name` is not `anonymous` in stack traces
-export const measureDuration = keepFuncProps(kMeasureDuration)
-
+export const measureDuration = keepFuncProps(kMeasureDuration);
 // Create a new object representing a completed timer
-export const createTimer = function (
-  stageTag,
-  durationNs,
-  { metricName = DEFAULT_METRIC_NAME, parentTag = TOP_PARENT_TAG, category, tags } = {},
-) {
-  return { metricName, stageTag, parentTag, durationNs, category, tags }
-}
-
-const DEFAULT_METRIC_NAME = 'buildbot.build.stage.duration'
-export const TOP_PARENT_TAG = 'run_netlify_build'
-
+export const createTimer = function (stageTag, durationNs, { metricName = DEFAULT_METRIC_NAME, parentTag = TOP_PARENT_TAG, category, tags } = {}) {
+    return { metricName, stageTag, parentTag, durationNs, category, tags };
+};
+const DEFAULT_METRIC_NAME = 'buildbot.build.stage.duration';
+export const TOP_PARENT_TAG = 'run_netlify_build';
 // Make sure the timer name does not include special characters.
 // For example, the `packageName` of local plugins includes dots.
 export const normalizeTimerName = function (name) {
-  return slugify(name, { separator: '_' })
-}
+    return slugify(name, { separator: '_' });
+};

package/lib/time/measure.js

@@ -1,22 +1,18 @@
-import { hrtime } from 'process'
-
+import { hrtime } from 'process';
 // Starts a timer
 export const startTimer = function () {
-  return hrtime()
-}
-
+    return hrtime();
+};
 // Stops a timer
 export const endTimer = function ([startSecs, startNsecs]) {
-  const [endSecs, endNsecs] = hrtime()
-  const durationNs = (endSecs - startSecs) * NANOSECS_TO_SECS + endNsecs - startNsecs
-  return durationNs
-}
-
+    const [endSecs, endNsecs] = hrtime();
+    const durationNs = (endSecs - startSecs) * NANOSECS_TO_SECS + endNsecs - startNsecs;
+    return durationNs;
+};
 // statsd expects milliseconds integers.
 // To prevent double rounding errors, rounding should only be applied once.
 export const roundTimerToMillisecs = function (durationNs) {
-  return Math.round(durationNs / NANOSECS_TO_MSECS)
-}
-
-const NANOSECS_TO_SECS = 1e9
-const NANOSECS_TO_MSECS = 1e6
+    return Math.round(durationNs / NANOSECS_TO_MSECS);
+};
+const NANOSECS_TO_SECS = 1e9;
+const NANOSECS_TO_MSECS = 1e6;

package/lib/time/report.js

@@ -1,59 +1,47 @@
-import { promisify } from 'util'
-
-import StatsdClient from 'statsd-client'
-
-import { addAggregatedTimers } from './aggregate.js'
-import { roundTimerToMillisecs } from './measure.js'
-
+import { promisify } from 'util';
+import StatsdClient from 'statsd-client';
+import { addAggregatedTimers } from './aggregate.js';
+import { roundTimerToMillisecs } from './measure.js';
 // TODO: replace with `timers/promises` after dropping Node < 15.0.0
-const pSetTimeout = promisify(setTimeout)
-
+const pSetTimeout = promisify(setTimeout);
 // Record the duration of a build phase, for monitoring.
 // Sends to statsd daemon.
 export const reportTimers = async function ({ timers, statsdOpts: { host, port }, framework }) {
-  if (host === undefined) {
-    return
-  }
-
-  const timersA = addAggregatedTimers(timers)
-  await sendTimers({ timers: timersA, host, port, framework })
-}
-
+    if (host === undefined) {
+        return;
+    }
+    const timersA = addAggregatedTimers(timers);
+    await sendTimers({ timers: timersA, host, port, framework });
+};
 const sendTimers = async function ({ timers, host, port, framework }) {
-  const client = await startClient(host, port)
-  timers.forEach((timer) => {
-    sendTimer({ timer, client, framework })
-  })
-  await closeClient(client)
-}
-
+    const client = await startClient(host, port);
+    timers.forEach((timer) => {
+        sendTimer({ timer, client, framework });
+    });
+    await closeClient(client);
+};
 // The socket creation is delayed until the first packet is sent. In our
 // case, this happens just before `client.close()` is called, which is too
 // late and make it not send anything. We need to manually create it using
 // the internal API.
 const startClient = async function (host, port) {
-  const client = new StatsdClient({ host, port, socketTimeout: 0 })
-
-  await promisify(client._socket._createSocket.bind(client._socket))()
-  return client
-}
-
+    const client = new StatsdClient({ host, port, socketTimeout: 0 });
+    await promisify(client._socket._createSocket.bind(client._socket))();
+    return client;
+};
 const sendTimer = function ({ timer: { metricName, stageTag, parentTag, durationNs, tags }, client, framework }) {
-  const durationMs = roundTimerToMillisecs(durationNs)
-  const frameworkTag = framework === undefined ? {} : { framework }
-  client.distribution(metricName, durationMs, { stage: stageTag, parent: parentTag, ...tags, ...frameworkTag })
-}
-
+    const durationMs = roundTimerToMillisecs(durationNs);
+    const frameworkTag = framework === undefined ? {} : { framework };
+    client.distribution(metricName, durationMs, { stage: stageTag, parent: parentTag, ...tags, ...frameworkTag });
+};
 // UDP packets are buffered and flushed at regular intervals by statsd-client.
 // Closing force flushing all of them.
 const closeClient = async function (client) {
-  client.close()
-
-  // statsd-clent does not provide with a way of knowing when the socket is done
-  // closing, so we need to use the following hack.
-  await pSetTimeout(CLOSE_TIMEOUT)
-  await pSetTimeout(CLOSE_TIMEOUT)
-}
-
+    client.close();
+    // statsd-clent does not provide with a way of knowing when the socket is done
+    // closing, so we need to use the following hack.
+    await pSetTimeout(CLOSE_TIMEOUT);
+    await pSetTimeout(CLOSE_TIMEOUT);
+};
 // See https://github.com/msiebuhr/node-statsd-client/blob/45a93ee4c94ca72f244a40b06cb542d4bd7c3766/lib/EphemeralSocket.js#L81
-const CLOSE_TIMEOUT = 11
+const CLOSE_TIMEOUT = 11;

package/lib/utils/errors.js

@@ -1,12 +1,13 @@
 // Wrap an async function so it prepends an error message on exceptions.
 // This helps locate errors.
 export const addAsyncErrorMessage = function (asyncFunc, message) {
-  return async (...args) => {
-    try {
-      return await asyncFunc(...args)
-    } catch (error) {
-      error.stack = `${message}: ${error.stack}`
-      throw error
-    }
-  }
-}
+    return async (...args) => {
+        try {
+            return await asyncFunc(...args);
+        }
+        catch (error) {
+            error.stack = `${message}: ${error.stack}`;
+            throw error;
+        }
+    };
+};

package/lib/utils/json.js

@@ -1,19 +1,15 @@
-import { promises as fs, readFileSync } from 'fs'
-import { fileURLToPath } from 'url'
-
-const ROOT_PACKAGE_JSON_PATH = fileURLToPath(new URL('../../package.json', import.meta.url))
-
+import { promises as fs, readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+const ROOT_PACKAGE_JSON_PATH = fileURLToPath(new URL('../../package.json', import.meta.url));
 // TODO: Replace with dynamic `import()` once it is supported without
 // experimental flags
 export const importJsonFile = async function (filePath) {
-  const fileContents = await fs.readFile(filePath)
-  return JSON.parse(fileContents)
-}
-
+    const fileContents = await fs.readFile(filePath);
+    return JSON.parse(fileContents);
+};
 const importJsonFileSync = function (filePath) {
-  // Use sync I/O so it is easier to migrate to `import()` later on
-  const fileContents = readFileSync(filePath, 'utf8')
-  return JSON.parse(fileContents)
-}
-
-export const ROOT_PACKAGE_JSON = importJsonFileSync(ROOT_PACKAGE_JSON_PATH)
+    // Use sync I/O so it is easier to migrate to `import()` later on
+    const fileContents = readFileSync(filePath, 'utf8');
+    return JSON.parse(fileContents);
+};
+export const ROOT_PACKAGE_JSON = importJsonFileSync(ROOT_PACKAGE_JSON_PATH);

package/lib/utils/omit.js

@@ -1,6 +1,5 @@
-import filterObj from 'filter-obj'
-
+import filterObj from 'filter-obj';
 // lodash.omit is 1400 lines of codes. filter-obj is much smaller and simpler.
 export const omit = function (obj, keys) {
-  return filterObj(obj, (key) => !keys.includes(key))
-}
+    return filterObj(obj, (key) => !keys.includes(key));
+};

package/lib/utils/package.js

@@ -1,25 +1,22 @@
-import { dirname } from 'path'
-
-import { readPackageUp } from 'read-pkg-up'
-
+import { dirname } from 'path';
+import { readPackageUp } from 'read-pkg-up';
 // Retrieve `package.json` from a specific directory
 export const getPackageJson = async function (cwd, { normalize } = {}) {
-  const packageObj = await getPackageObj({ cwd, normalize })
-  if (packageObj === undefined) {
-    return { packageJson: {} }
-  }
-
-  const { path, packageJson } = packageObj
-  const packageDir = dirname(path)
-  return { packageDir, packageJson }
-}
-
+    const packageObj = await getPackageObj({ cwd, normalize });
+    if (packageObj === undefined) {
+        return { packageJson: {} };
+    }
+    const { path, packageJson } = packageObj;
+    const packageDir = dirname(path);
+    return { packageDir, packageJson };
+};
 const getPackageObj = async function ({ cwd, normalize = true }) {
-  try {
-    return await readPackageUp({ cwd, normalize })
-    // If the `package.json` is invalid and `normalize` is `true`, an error is
-    // thrown. We return `undefined` then.
-  } catch {
-    // continue regardless error
-  }
-}
+    try {
+        return await readPackageUp({ cwd, normalize });
+        // If the `package.json` is invalid and `normalize` is `true`, an error is
+        // thrown. We return `undefined` then.
+    }
+    catch {
+        // continue regardless error
+    }
+};

package/lib/utils/remove_falsy.js

@@ -1,10 +1,8 @@
-import filterObj from 'filter-obj'
-
+import filterObj from 'filter-obj';
 // Remove falsy values from object
 export const removeFalsy = function (obj) {
-  return filterObj(obj, isDefined)
-}
-
+    return filterObj(obj, isDefined);
+};
 const isDefined = function (key, value) {
-  return value !== undefined && value !== ''
-}
+    return value !== undefined && value !== '';
+};

package/lib/utils/resolve.js

@@ -1,45 +1,41 @@
-import { createRequire } from 'module'
-
-import { async as resolveLib } from 'resolve'
-
+import { createRequire } from 'module';
+import { async as resolveLib } from 'resolve';
 // TODO: use `import.resolve()` once it is available without any experimental
 // flags
-const require = createRequire(import.meta.url)
-
+const require = createRequire(import.meta.url);
 // Like `resolvePath()` but does not throw
 export const tryResolvePath = async function (path, basedir) {
-  try {
-    const resolvedPath = await resolvePath(path, basedir)
-    return { path: resolvedPath }
-  } catch (error) {
-    return { error }
-  }
-}
-
+    try {
+        const resolvedPath = await resolvePath(path, basedir);
+        return { path: resolvedPath };
+    }
+    catch (error) {
+        return { error };
+    }
+};
 // This throws if the package cannot be found
 export const resolvePath = async function (path, basedir) {
-  try {
-    return await resolvePathWithBasedir(path, basedir)
-    // Fallback.
-    // `resolve` sometimes gives unhelpful error messages.
-    // https://github.com/browserify/resolve/issues/223
-  } catch {
-    return require.resolve(path, { paths: [basedir] })
-  }
-}
-
+    try {
+        return await resolvePathWithBasedir(path, basedir);
+        // Fallback.
+        // `resolve` sometimes gives unhelpful error messages.
+        // https://github.com/browserify/resolve/issues/223
+    }
+    catch {
+        return require.resolve(path, { paths: [basedir] });
+    }
+};
 // Like `require.resolve()` but as an external library.
 // We need to use `new Promise()` due to a bug with `utils.promisify()` on
 // `resolve`:
 //   https://github.com/browserify/resolve/issues/151#issuecomment-368210310
 const resolvePathWithBasedir = function (path, basedir) {
-  return new Promise((resolve, reject) => {
-    resolveLib(path, { basedir }, (error, resolvedPath) => {
-      if (error) {
-        return reject(error)
-      }
-
-      resolve(resolvedPath)
-    })
-  })
-}
+    return new Promise((resolve, reject) => {
+        resolveLib(path, { basedir }, (error, resolvedPath) => {
+            if (error) {
+                return reject(error);
+            }
+            resolve(resolvedPath);
+        });
+    });
+};

package/lib/utils/runtime.js

@@ -1,5 +1,5 @@
 export const isRuntime = function (pluginOption) {
-  const { packageName } = pluginOption
-  // Make this a bit more robust in the future
-  return ['@netlify/next-runtime', '@netlify/plugin-nextjs'].includes(packageName)
-}
+    const { packageName } = pluginOption;
+    // Make this a bit more robust in the future
+    return ['@netlify/next-runtime', '@netlify/plugin-nextjs'].includes(packageName);
+};