@docusaurus/core 0.0.0-4803 → 0.0.0-4807

package/lib/client/docusaurus.js

@@ -17,15 +17,13 @@ const isSlowConnection = () => navigator.connection?.effectiveType.includes('2g'
     navigator.connection?.saveData;
 const canPrefetch = (routePath) => !isSlowConnection() && !loaded[routePath] && !fetched[routePath];
 const canPreload = (routePath) => !isSlowConnection() && !loaded[routePath];
+const getChunkNamesToLoad = (path) => Object.entries(routesChunkNames)
+    .filter(
 // Remove the last part containing the route hash
 // input: /blog/2018/12/14/Happy-First-Birthday-Slash-fe9
 // output: /blog/2018/12/14/Happy-First-Birthday-Slash
-const removeRouteNameHash = (str) => str.replace(/-[^-]+$/, '');
-const getChunkNamesToLoad = (path) => Object.entries(routesChunkNames)
-    .filter(([routeNameWithHash]) => removeRouteNameHash(routeNameWithHash) === path)
-    .flatMap(([, routeChunks]) => 
-// flat() is useful for nested chunk names, it's not like array.flat()
-Object.values(flat(routeChunks)));
+([routeNameWithHash]) => routeNameWithHash.replace(/-[^-]+$/, '') === path)
+    .flatMap(([, routeChunks]) => Object.values(flat(routeChunks)));
 const docusaurus = {
     prefetch: (routePath) => {
         if (!canPrefetch(routePath)) {

package/lib/client/exports/ComponentCreator.js

@@ -26,26 +26,11 @@ export default function ComponentCreator(path, hash) {
             },
         });
     }
-    const chunkNamesKey = `${path}-${hash}`;
-    const chunkNames = routesChunkNames[chunkNamesKey];
-    const optsModules = [];
-    const optsWebpack = [];
+    const chunkNames = routesChunkNames[`${path}-${hash}`];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const optsLoader = {};
-    /* Prepare opts data that react-loadable needs
-    https://github.com/jamiebuilds/react-loadable#declaring-which-modules-are-being-loaded
-    Example:
-    - optsLoader:
-      {
-        component: () => import('./Pages.js'),
-        content.foo: () => import('./doc1.md'),
-      }
-    - optsModules: ['./Pages.js', './doc1.md']
-    - optsWebpack: [
-        require.resolveWeak('./Pages.js'),
-        require.resolveWeak('./doc1.md'),
-      ]
-    */
+    const optsModules = [];
+    const optsWebpack = [];
     const flatChunkNames = flat(chunkNames);
     Object.entries(flatChunkNames).forEach(([key, chunkName]) => {
         const chunkRegistry = registry[chunkName];

package/lib/client/flat.d.ts

@@ -4,7 +4,15 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import type { RouteChunksTree } from '@docusaurus/types';
-export default function flat(target: RouteChunksTree): {
+import type { ChunkNames } from '@docusaurus/types';
+/**
+ * Takes a tree, and flattens it into a map of keyPath -> value.
+ *
+ * ```js
+ * flat({ a: { b: 1 } }) === { "a.b": 1 };
+ * flat({ a: [1, 2] }) === { "a.0": 1, "a.1": 2 };
+ * ```
+ */
+export default function flat(target: ChunkNames): {
     [keyPath: string]: string;
 };

package/lib/client/flat.js

@@ -5,6 +5,14 @@
  * LICENSE file in the root directory of this source tree.
  */
 const isTree = (x) => typeof x === 'object' && !!x && Object.keys(x).length > 0;
+/**
+ * Takes a tree, and flattens it into a map of keyPath -> value.
+ *
+ * ```js
+ * flat({ a: { b: 1 } }) === { "a.b": 1 };
+ * flat({ a: [1, 2] }) === { "a.0": 1, "a.1": 2 };
+ * ```
+ */
 export default function flat(target) {
     const delimiter = '.';
     const output = {};

package/lib/server/plugins/index.d.ts

@@ -7,7 +7,8 @@
 import type { LoadContext, RouteConfig, GlobalData, ThemeConfig, LoadedPlugin } from '@docusaurus/types';
 /**
  * Initializes the plugins, runs `loadContent`, `translateContent`,
- * `contentLoaded`, and `translateThemeConfig`.
+ * `contentLoaded`, and `translateThemeConfig`. Because `contentLoaded` is
+ * side-effect-ful (it generates temp files), so is this function.
  */
 export declare function loadPlugins(context: LoadContext): Promise<{
     plugins: LoadedPlugin[];

package/lib/server/plugins/index.js

@@ -9,7 +9,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadPlugins = void 0;
 const tslib_1 = require("tslib");
 const utils_1 = require("@docusaurus/utils");
-const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const path_1 = tslib_1.__importDefault(require("path"));
 const init_1 = require("./init");
 const synthetic_1 = require("./synthetic");
@@ -19,7 +18,8 @@ const translations_1 = require("../translations/translations");
 const routeConfig_1 = require("./routeConfig");
 /**
  * Initializes the plugins, runs `loadContent`, `translateContent`,
- * `contentLoaded`, and `translateThemeConfig`.
+ * `contentLoaded`, and `translateThemeConfig`. Because `contentLoaded` is
+ * side-effect-ful (it generates temp files), so is this function.
  */
 async function loadPlugins(context) {
     // 1. Plugin Lifecycle - Initialization/Constructor.
@@ -64,46 +64,37 @@ async function loadPlugins(context) {
         }
         const pluginId = plugin.options.id;
         // plugins data files are namespaced by pluginName/pluginId
-        const dataDirRoot = path_1.default.join(context.generatedFilesDir, plugin.name);
-        const dataDir = path_1.default.join(dataDirRoot, pluginId);
-        const createData = async (name, data) => {
-            const modulePath = path_1.default.join(dataDir, name);
-            await fs_extra_1.default.ensureDir(path_1.default.dirname(modulePath));
-            await (0, utils_1.generate)(dataDir, name, data);
-            return modulePath;
-        };
+        const dataDir = path_1.default.join(context.generatedFilesDir, plugin.name, pluginId);
         // TODO this would be better to do all that in the codegen phase
         // TODO handle context for nested routes
         const pluginRouteContext = {
             plugin: { name: plugin.name, id: pluginId },
             data: undefined, // TODO allow plugins to provide context data
         };
-        const pluginRouteContextModulePath = await createData(`${(0, utils_1.docuHash)('pluginRouteContextModule')}.json`, JSON.stringify(pluginRouteContext, null, 2));
-        const addRoute = (initialRouteConfig) => {
-            // Trailing slash behavior is handled in a generic way for all plugins
-            const finalRouteConfig = (0, routeConfig_1.applyRouteTrailingSlash)(initialRouteConfig, {
-                trailingSlash: context.siteConfig.trailingSlash,
-                baseUrl: context.siteConfig.baseUrl,
-            });
-            pluginsRouteConfigs.push({
-                ...finalRouteConfig,
-                modules: {
-                    ...finalRouteConfig.modules,
-                    __routeContextModule: pluginRouteContextModulePath,
-                },
-            });
-        };
-        // the plugins global data are namespaced to avoid data conflicts:
-        // - by plugin name
-        // - by plugin id (allow using multiple instances of the same plugin)
-        const setGlobalData = (data) => {
-            globalData[plugin.name] = globalData[plugin.name] ?? {};
-            globalData[plugin.name][pluginId] = data;
-        };
+        const pluginRouteContextModulePath = path_1.default.join(dataDir, `${(0, utils_1.docuHash)('pluginRouteContextModule')}.json`);
+        await (0, utils_1.generate)('/', pluginRouteContextModulePath, JSON.stringify(pluginRouteContext, null, 2));
         const actions = {
-            addRoute,
-            createData,
-            setGlobalData,
+            addRoute(initialRouteConfig) {
+                // Trailing slash behavior is handled generically for all plugins
+                const finalRouteConfig = (0, routeConfig_1.applyRouteTrailingSlash)(initialRouteConfig, context.siteConfig);
+                pluginsRouteConfigs.push({
+                    ...finalRouteConfig,
+                    modules: {
+                        ...finalRouteConfig.modules,
+                        __routeContextModule: pluginRouteContextModulePath,
+                    },
+                });
+            },
+            async createData(name, data) {
+                const modulePath = path_1.default.join(dataDir, name);
+                await (0, utils_1.generate)(dataDir, name, data);
+                return modulePath;
+            },
+            setGlobalData(data) {
+                var _a;
+                globalData[_a = plugin.name] ?? (globalData[_a] = {});
+                globalData[plugin.name][pluginId] = data;
+            },
         };
         const translatedContent = plugin.translateContent?.({ content, translationFiles }) ?? content;
         await plugin.contentLoaded({

package/lib/server/plugins/routeConfig.d.ts

@@ -6,5 +6,6 @@
  */
 import type { RouteConfig } from '@docusaurus/types';
 import { type ApplyTrailingSlashParams } from '@docusaurus/utils-common';
+/** Recursively applies trailing slash config to all nested routes. */
 export declare function applyRouteTrailingSlash(route: RouteConfig, params: ApplyTrailingSlashParams): RouteConfig;
 export declare function sortConfig(routeConfigs: RouteConfig[], baseUrl?: string): void;

package/lib/server/plugins/routeConfig.js

@@ -8,6 +8,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sortConfig = exports.applyRouteTrailingSlash = void 0;
 const utils_common_1 = require("@docusaurus/utils-common");
+/** Recursively applies trailing slash config to all nested routes. */
 function applyRouteTrailingSlash(route, params) {
     return {
         ...route,

package/lib/server/routes.d.ts

@@ -4,15 +4,48 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import type { ChunkRegistry, RouteConfig, ChunkNames, ReportingSeverity } from '@docusaurus/types';
-export declare function handleDuplicateRoutes(pluginsRouteConfigs: RouteConfig[], onDuplicateRoutes: ReportingSeverity): void;
-export declare function loadRoutes(pluginsRouteConfigs: RouteConfig[], baseUrl: string, onDuplicateRoutes: ReportingSeverity): Promise<{
-    registry: {
-        [chunkName: string]: ChunkRegistry;
-    };
+import type { RouteConfig, RouteChunkNames, ReportingSeverity } from '@docusaurus/types';
+declare type LoadedRoutes = {
+    /** Serialized routes config that can be directly emitted into temp file. */
     routesConfig: string;
-    routesChunkNames: {
-        [routePath: string]: ChunkNames;
+    /** @see {ChunkNames} */
+    routesChunkNames: RouteChunkNames;
+    /** A map from chunk name to module loaders. */
+    registry: {
+        [chunkName: string]: {
+            loader: string;
+            modulePath: string;
+        };
     };
+    /**
+     * Collect all page paths for injecting it later in the plugin lifecycle.
+     * This is useful for plugins like sitemaps, redirects etc... Only collects
+     * "actual" pages, i.e. those without subroutes, because if a route has
+     * subroutes, it is probably a wrapper.
+     */
     routesPaths: string[];
-}>;
+};
+/**
+ * Generates a unique chunk name that can be used in the chunk registry.
+ *
+ * @param modulePath A path to generate chunk name from. The actual value has no
+ * semantic significance.
+ * @param prefix A prefix to append to the chunk name, to avoid name clash.
+ * @param preferredName Chunk names default to `modulePath`, and this can supply
+ * a more human-readable name.
+ * @param shortId When `true`, the chunk name would only be a hash without any
+ * other characters. Useful for bundle size. Defaults to `true` in production.
+ */
+export declare function genChunkName(modulePath: string, prefix?: string, preferredName?: string, shortId?: boolean): string;
+export declare function handleDuplicateRoutes(pluginsRouteConfigs: RouteConfig[], onDuplicateRoutes: ReportingSeverity): void;
+/**
+ * Routes are prepared into three temp files:
+ *
+ * - `routesConfig`, the route config passed to react-router. This file is kept
+ * minimal, because it can't be code-splitted.
+ * - `routesChunkNames`, a mapping from route paths (hashed) to code-splitted
+ * chunk names.
+ * - `registry`, a mapping from chunk names to options for react-loadable.
+ */
+export declare function loadRoutes(routeConfigs: RouteConfig[], baseUrl: string, onDuplicateRoutes: ReportingSeverity): Promise<LoadedRoutes>;
+export {};

package/lib/server/routes.js

@@ -6,25 +6,64 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadRoutes = exports.handleDuplicateRoutes = void 0;
+exports.loadRoutes = exports.handleDuplicateRoutes = exports.genChunkName = void 0;
+const tslib_1 = require("tslib");
 const utils_1 = require("@docusaurus/utils");
-const querystring_1 = require("querystring");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const querystring_1 = tslib_1.__importDefault(require("querystring"));
 const utils_2 = require("./utils");
+/** Indents every line of `str` by one level. */
 function indent(str) {
-    const spaces = '  ';
-    return `${spaces}${str.replace(/\n/g, `\n${spaces}`)}`;
+    return `  ${str.replace(/\n/g, `\n  `)}`;
 }
-function createRouteCodeString({ routePath, routeHash, exact, subroutesCodeStrings, props, }) {
+const chunkNameCache = new Map();
+/**
+ * Generates a unique chunk name that can be used in the chunk registry.
+ *
+ * @param modulePath A path to generate chunk name from. The actual value has no
+ * semantic significance.
+ * @param prefix A prefix to append to the chunk name, to avoid name clash.
+ * @param preferredName Chunk names default to `modulePath`, and this can supply
+ * a more human-readable name.
+ * @param shortId When `true`, the chunk name would only be a hash without any
+ * other characters. Useful for bundle size. Defaults to `true` in production.
+ */
+function genChunkName(modulePath, prefix, preferredName, shortId = process.env.NODE_ENV === 'production') {
+    let chunkName = chunkNameCache.get(modulePath);
+    if (!chunkName) {
+        if (shortId) {
+            chunkName = (0, utils_1.simpleHash)(modulePath, 8);
+        }
+        else {
+            let str = modulePath;
+            if (preferredName) {
+                const shortHash = (0, utils_1.simpleHash)(modulePath, 3);
+                str = `${preferredName}${shortHash}`;
+            }
+            const name = str === '/' ? 'index' : (0, utils_1.docuHash)(str);
+            chunkName = prefix ? `${prefix}---${name}` : name;
+        }
+        chunkNameCache.set(modulePath, chunkName);
+    }
+    return chunkName;
+}
+exports.genChunkName = genChunkName;
+/**
+ * Takes a piece of route config, and serializes it into raw JS code. The shape
+ * is the same as react-router's `RouteConfig`. Formatting is similar to
+ * `JSON.stringify` but without all the quotes.
+ */
+function serializeRouteConfig({ routePath, routeHash, exact, subroutesCodeStrings, props, }) {
     const parts = [
         `path: '${routePath}'`,
-        `component: ComponentCreator('${routePath}','${routeHash}')`,
+        `component: ComponentCreator('${routePath}', '${routeHash}')`,
     ];
     if (exact) {
         parts.push(`exact: true`);
     }
     if (subroutesCodeStrings) {
         parts.push(`routes: [
-${indent((0, utils_1.removeSuffix)(subroutesCodeStrings.join(',\n'), ',\n'))}
+${indent(subroutesCodeStrings.join(',\n'))}
 ]`);
     }
     Object.entries(props).forEach(([propName, propValue]) => {
@@ -52,54 +91,33 @@ ${indent((0, utils_1.removeSuffix)(subroutesCodeStrings.join(',\n'), ',\n'))}
 ${indent(parts.join(',\n'))}
 }`;
 }
-const NotFoundRouteCode = `{
-  path: '*',
-  component: ComponentCreator('*')
-}`;
-const RoutesImportsCode = [
-    `import React from 'react';`,
-    `import ComponentCreator from '@docusaurus/ComponentCreator';`,
-].join('\n');
-function isModule(value) {
-    if (typeof value === 'string') {
-        return true;
-    }
-    if (typeof value === 'object' &&
+const isModule = (value) => typeof value === 'string' ||
+    (typeof value === 'object' &&
         // eslint-disable-next-line no-underscore-dangle
-        value?.__import &&
-        value?.path) {
-        return true;
-    }
-    return false;
-}
+        !!value?.__import);
+/** Takes a {@link Module} and returns the string path it represents. */
 function getModulePath(target) {
     if (typeof target === 'string') {
         return target;
     }
-    const queryStr = target.query ? `?${(0, querystring_1.stringify)(target.query)}` : '';
+    const queryStr = target.query ? `?${querystring_1.default.stringify(target.query)}` : '';
     return `${target.path}${queryStr}`;
 }
-function genRouteChunkNames(
-// TODO instead of passing a mutating the registry, return a registry slice?
-registry, value, prefix, name) {
-    if (!value) {
-        return null;
-    }
-    if (Array.isArray(value)) {
-        return value.map((val, index) => genRouteChunkNames(registry, val, `${index}`, name));
-    }
-    if (isModule(value)) {
-        const modulePath = getModulePath(value);
-        const chunkName = (0, utils_1.genChunkName)(modulePath, prefix, name);
-        const loader = `() => import(/* webpackChunkName: '${chunkName}' */ '${(0, utils_1.escapePath)(modulePath)}')`;
-        registry[chunkName] = { loader, modulePath };
+function genChunkNames(routeModule, prefix, name, res) {
+    if (isModule(routeModule)) {
+        // This is a leaf node, no need to recurse
+        const modulePath = getModulePath(routeModule);
+        const chunkName = genChunkName(modulePath, prefix, name);
+        res.registry[chunkName] = {
+            loader: `() => import(/* webpackChunkName: '${chunkName}' */ '${(0, utils_1.escapePath)(modulePath)}')`,
+            modulePath,
+        };
         return chunkName;
     }
-    const newValue = {};
-    Object.entries(value).forEach(([key, v]) => {
-        newValue[key] = genRouteChunkNames(registry, v, key, name);
-    });
-    return newValue;
+    if (Array.isArray(routeModule)) {
+        return routeModule.map((val, index) => genChunkNames(val, `${index}`, name, res));
+    }
+    return lodash_1.default.mapValues(routeModule, (v, key) => genChunkNames(v, key, name, res));
 }
 function handleDuplicateRoutes(pluginsRouteConfigs, onDuplicateRoutes) {
     if (onDuplicateRoutes === 'ignore') {
@@ -124,55 +142,62 @@ This could lead to non-deterministic routing behavior.`;
     }
 }
 exports.handleDuplicateRoutes = handleDuplicateRoutes;
-async function loadRoutes(pluginsRouteConfigs, baseUrl, onDuplicateRoutes) {
-    handleDuplicateRoutes(pluginsRouteConfigs, onDuplicateRoutes);
-    const registry = {};
-    const routesPaths = [(0, utils_1.normalizeUrl)([baseUrl, '404.html'])];
-    const routesChunkNames = {};
-    // This is the higher level overview of route code generation.
-    function generateRouteCode(routeConfig) {
-        const { path: routePath, component, modules = {}, routes: subroutes, exact, priority, ...props } = routeConfig;
-        if (typeof routePath !== 'string' || !component) {
-            throw new Error(`Invalid route config: path must be a string and component is required.
+/**
+ * This is the higher level overview of route code generation. For each route
+ * config node, it return the node's serialized form, and mutate `registry`,
+ * `routesPaths`, and `routesChunkNames` accordingly.
+ */
+function genRouteCode(routeConfig, res) {
+    const { path: routePath, component, modules = {}, routes: subroutes, priority, exact, ...props } = routeConfig;
+    if (typeof routePath !== 'string' || !component) {
+        throw new Error(`Invalid route config: path must be a string and component is required.
 ${JSON.stringify(routeConfig)}`);
-        }
-        // Collect all page paths for injecting it later in the plugin lifecycle
-        // This is useful for plugins like sitemaps, redirects etc...
-        // If a route has subroutes, it is not necessarily a valid page path (more
-        // likely to be a wrapper)
-        if (!subroutes) {
-            routesPaths.push(routePath);
-        }
-        // We hash the route to generate the key, because 2 routes can conflict with
-        // each others if they have the same path, ex: parent=/docs, child=/docs
-        // see https://github.com/facebook/docusaurus/issues/2917
-        const routeHash = (0, utils_1.simpleHash)(JSON.stringify(routeConfig), 3);
-        const chunkNamesKey = `${routePath}-${routeHash}`;
-        routesChunkNames[chunkNamesKey] = {
-            ...genRouteChunkNames(registry, { component }, 'component', component),
-            ...genRouteChunkNames(registry, modules, 'module', routePath),
-        };
-        return createRouteCodeString({
-            routePath: routeConfig.path.replace(/'/g, "\\'"),
-            routeHash,
-            exact,
-            subroutesCodeStrings: subroutes?.map(generateRouteCode),
-            props,
-        });
     }
-    const routesConfig = `
-${RoutesImportsCode}
+    if (!subroutes) {
+        res.routesPaths.push(routePath);
+    }
+    const routeHash = (0, utils_1.simpleHash)(JSON.stringify(routeConfig), 3);
+    res.routesChunkNames[`${routePath}-${routeHash}`] = {
+        ...genChunkNames({ component }, 'component', component, res),
+        ...genChunkNames(modules, 'module', routePath, res),
+    };
+    return serializeRouteConfig({
+        routePath: routePath.replace(/'/g, "\\'"),
+        routeHash,
+        subroutesCodeStrings: subroutes?.map((r) => genRouteCode(r, res)),
+        exact,
+        props,
+    });
+}
+/**
+ * Routes are prepared into three temp files:
+ *
+ * - `routesConfig`, the route config passed to react-router. This file is kept
+ * minimal, because it can't be code-splitted.
+ * - `routesChunkNames`, a mapping from route paths (hashed) to code-splitted
+ * chunk names.
+ * - `registry`, a mapping from chunk names to options for react-loadable.
+ */
+async function loadRoutes(routeConfigs, baseUrl, onDuplicateRoutes) {
+    handleDuplicateRoutes(routeConfigs, onDuplicateRoutes);
+    const res = {
+        // To be written
+        routesConfig: '',
+        routesChunkNames: {},
+        registry: {},
+        routesPaths: [(0, utils_1.normalizeUrl)([baseUrl, '404.html'])],
+    };
+    res.routesConfig = `import React from 'react';
+import ComponentCreator from '@docusaurus/ComponentCreator';
 
 export default [
-${indent(`${pluginsRouteConfigs.map(generateRouteCode).join(',\n')},`)}
-${indent(NotFoundRouteCode)}
+${indent(`${routeConfigs.map((r) => genRouteCode(r, res)).join(',\n')},`)}
+  {
+    path: '*',
+    component: ComponentCreator('*'),
+  },
 ];
 `;
-    return {
-        registry,
-        routesConfig,
-        routesChunkNames,
-        routesPaths,
-    };
+    return res;
 }
 exports.loadRoutes = loadRoutes;

package/lib/webpack/utils.d.ts

@@ -7,7 +7,7 @@
 /// <reference types="node" />
 import { type Configuration, type RuleSetRule, type WebpackPluginInstance } from 'webpack';
 import type { TransformOptions } from '@babel/core';
-import type { ConfigureWebpackFn, ConfigurePostCssFn } from '@docusaurus/types';
+import type { Plugin } from '@docusaurus/types';
 export declare function getStyleLoaders(isServer: boolean, cssOptionsArg?: {
     [key: string]: unknown;
 }): RuleSetRule[];
@@ -29,8 +29,8 @@ export declare const getCustomizableJSLoader: (jsLoader?: "babel" | ((isServer:
  * @param content content loaded by the plugin
  * @returns final/ modified webpack config
  */
-export declare function applyConfigureWebpack(configureWebpack: ConfigureWebpackFn, config: Configuration, isServer: boolean, jsLoader: 'babel' | ((isServer: boolean) => RuleSetRule) | undefined, content: unknown): Configuration;
-export declare function applyConfigurePostCss(configurePostCss: NonNullable<ConfigurePostCssFn>, config: Configuration): Configuration;
+export declare function applyConfigureWebpack(configureWebpack: NonNullable<Plugin['configureWebpack']>, config: Configuration, isServer: boolean, jsLoader: 'babel' | ((isServer: boolean) => RuleSetRule) | undefined, content: unknown): Configuration;
+export declare function applyConfigurePostCss(configurePostCss: NonNullable<Plugin['configurePostCss']>, config: Configuration): Configuration;
 declare global {
     interface Error {
         /** @see https://webpack.js.org/api/node/#error-handling */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@docusaurus/core",
   "description": "Easy to Maintain Open Source Documentation Websites",
-  "version": "0.0.0-4803",
+  "version": "0.0.0-4807",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -41,13 +41,13 @@
     "@babel/runtime": "^7.17.8",
     "@babel/runtime-corejs3": "^7.17.8",
     "@babel/traverse": "^7.17.3",
-    "@docusaurus/cssnano-preset": "0.0.0-4803",
-    "@docusaurus/logger": "0.0.0-4803",
-    "@docusaurus/mdx-loader": "0.0.0-4803",
+    "@docusaurus/cssnano-preset": "0.0.0-4807",
+    "@docusaurus/logger": "0.0.0-4807",
+    "@docusaurus/mdx-loader": "0.0.0-4807",
     "@docusaurus/react-loadable": "5.5.2",
-    "@docusaurus/utils": "0.0.0-4803",
-    "@docusaurus/utils-common": "0.0.0-4803",
-    "@docusaurus/utils-validation": "0.0.0-4803",
+    "@docusaurus/utils": "0.0.0-4807",
+    "@docusaurus/utils-common": "0.0.0-4807",
+    "@docusaurus/utils-validation": "0.0.0-4807",
     "@slorber/static-site-generator-webpack-plugin": "^4.0.4",
     "@svgr/webpack": "^6.2.1",
     "autoprefixer": "^10.4.4",
@@ -105,8 +105,8 @@
     "webpackbar": "^5.0.2"
   },
   "devDependencies": {
-    "@docusaurus/module-type-aliases": "0.0.0-4803",
-    "@docusaurus/types": "0.0.0-4803",
+    "@docusaurus/module-type-aliases": "0.0.0-4807",
+    "@docusaurus/types": "0.0.0-4807",
     "@types/detect-port": "^1.3.2",
     "@types/nprogress": "^0.2.0",
     "@types/react-dom": "^17.0.14",
@@ -127,5 +127,5 @@
   "engines": {
     "node": ">=14"
   },
-  "gitHead": "e7e44db95c1984dd3af285a4b71800f7e9842f37"
+  "gitHead": "9bb0a5cc35908e3d1ab5e8b3840180990c0e1e05"
 }