@modern-js/plugin 2.69.5 → 3.0.0-alpha.0

package/dist/cjs/cli/run/utils/mergeConfig.js

@@ -0,0 +1,66 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    mergeConfig: ()=>mergeConfig
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const lodash_namespaceObject = require("@modern-js/utils/lodash");
+const mergeConfig = (configs)=>(0, lodash_namespaceObject.mergeWith)({}, ...configs, (target, source, key)=>{
+        if ((0, utils_namespaceObject.isOverriddenConfigKey)(key)) return source ?? target;
+        if (Array.isArray(target) || Array.isArray(source)) {
+            if (void 0 === target) return source;
+            if (void 0 === source) return target;
+            const targetArray = (0, utils_namespaceObject.ensureArray)(target);
+            const sourceArray = (0, utils_namespaceObject.ensureArray)(source);
+            const allItems = [
+                ...targetArray,
+                ...sourceArray
+            ];
+            const seenNonFunc = [];
+            const result = [];
+            for (const item of allItems)if ((0, lodash_namespaceObject.isFunction)(item)) result.push(item);
+            else if (!seenNonFunc.some((seen)=>(0, lodash_namespaceObject.isEqual)(seen, item))) {
+                seenNonFunc.push(item);
+                result.push(item);
+            }
+            return result;
+        }
+        if ((0, lodash_namespaceObject.isFunction)(target) || (0, lodash_namespaceObject.isFunction)(source)) {
+            if (void 0 === source) return target;
+            if (void 0 === target) return source;
+            return [
+                target,
+                source
+            ];
+        }
+    });
+exports.mergeConfig = __webpack_exports__.mergeConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "mergeConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/hooks.js

@@ -0,0 +1,169 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createAsyncHook: ()=>createAsyncHook,
+    createAsyncInterruptHook: ()=>createAsyncInterruptHook,
+    createAsyncPipelineHook: ()=>createAsyncPipelineHook,
+    createCollectAsyncHook: ()=>createCollectAsyncHook,
+    createCollectSyncHook: ()=>createCollectSyncHook,
+    createSyncHook: ()=>createSyncHook
+});
+function createAsyncInterruptHook() {
+    const callbacks = [];
+    const tap = (cb)=>{
+        callbacks.push(cb);
+    };
+    const call = async (...params)=>{
+        let interrupted = false;
+        let interruptResult;
+        const interrupt = (info)=>{
+            interrupted = true;
+            interruptResult = info;
+        };
+        for (const callback of callbacks){
+            if (interrupted) break;
+            const result = await callback(...params, interrupt);
+            if (void 0 !== result) params[0] = result;
+        }
+        return interrupted ? interruptResult : params[0] || [];
+    };
+    return {
+        tap,
+        call
+    };
+}
+function createSyncHook() {
+    const callbacks = [];
+    const tap = (cb)=>{
+        callbacks.push(cb);
+    };
+    const call = (...params)=>{
+        for (const callback of callbacks){
+            const result = callback(...params);
+            if (void 0 !== result) params[0] = result;
+        }
+        return params[0];
+    };
+    return {
+        tap,
+        call
+    };
+}
+function createAsyncHook() {
+    const callbacks = [];
+    const tap = (cb)=>{
+        callbacks.push(cb);
+    };
+    const call = async (...params)=>{
+        for (const callback of callbacks){
+            const result = await callback(...params);
+            if (void 0 !== result) params[0] = result;
+        }
+        return params[0] || [];
+    };
+    return {
+        tap,
+        call
+    };
+}
+function createCollectAsyncHook() {
+    const callbacks = [];
+    const tap = (cb)=>{
+        callbacks.push(cb);
+    };
+    const call = async (...params)=>{
+        const results = [];
+        for (const callback of callbacks){
+            const result = await callback(...params);
+            if (void 0 !== result) results.push(result);
+        }
+        return results;
+    };
+    return {
+        tap,
+        call
+    };
+}
+function createCollectSyncHook() {
+    const callbacks = [];
+    const tap = (cb)=>{
+        callbacks.push(cb);
+    };
+    const call = (...params)=>{
+        const results = [];
+        for (const callback of callbacks){
+            const result = callback(...params);
+            if (void 0 !== result) results.push(result);
+        }
+        return results;
+    };
+    return {
+        tap,
+        call
+    };
+}
+function createAsyncPipelineHook() {
+    const callbacks = [];
+    const tap = (cb)=>{
+        callbacks.push(cb);
+    };
+    const call = async (...params)=>{
+        for (const callback of callbacks){
+            let runNext = false;
+            const next = (info)=>{
+                runNext = true;
+                if (info) params[0] = info;
+            };
+            const result = await callback(...params, next);
+            if (!runNext) {
+                params[0] = result;
+                break;
+            }
+        }
+        return params[0] || [];
+    };
+    return {
+        tap,
+        call
+    };
+}
+exports.createAsyncHook = __webpack_exports__.createAsyncHook;
+exports.createAsyncInterruptHook = __webpack_exports__.createAsyncInterruptHook;
+exports.createAsyncPipelineHook = __webpack_exports__.createAsyncPipelineHook;
+exports.createCollectAsyncHook = __webpack_exports__.createCollectAsyncHook;
+exports.createCollectSyncHook = __webpack_exports__.createCollectSyncHook;
+exports.createSyncHook = __webpack_exports__.createSyncHook;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createAsyncHook",
+    "createAsyncInterruptHook",
+    "createAsyncPipelineHook",
+    "createCollectAsyncHook",
+    "createCollectSyncHook",
+    "createSyncHook"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/index.js

@@ -1,28 +1,55 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var src_exports = {};
-module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./farrow-pipeline"), module.exports);
-__reExport(src_exports, require("./waterfall"), module.exports);
-__reExport(src_exports, require("./workflow"), module.exports);
-__reExport(src_exports, require("./manager"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("./farrow-pipeline"),
-  ...require("./waterfall"),
-  ...require("./workflow"),
-  ...require("./manager")
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createAsyncInterruptHook: ()=>external_hooks_js_namespaceObject.createAsyncInterruptHook,
+    createPluginManager: ()=>external_manager_js_namespaceObject.createPluginManager,
+    createSyncHook: ()=>external_hooks_js_namespaceObject.createSyncHook,
+    createAsyncPipelineHook: ()=>external_hooks_js_namespaceObject.createAsyncPipelineHook,
+    createAsyncHook: ()=>external_hooks_js_namespaceObject.createAsyncHook,
+    createCollectAsyncHook: ()=>external_hooks_js_namespaceObject.createCollectAsyncHook,
+    createCollectSyncHook: ()=>external_hooks_js_namespaceObject.createCollectSyncHook
+});
+const external_manager_js_namespaceObject = require("./manager.js");
+const external_hooks_js_namespaceObject = require("./hooks.js");
+exports.createAsyncHook = __webpack_exports__.createAsyncHook;
+exports.createAsyncInterruptHook = __webpack_exports__.createAsyncInterruptHook;
+exports.createAsyncPipelineHook = __webpack_exports__.createAsyncPipelineHook;
+exports.createCollectAsyncHook = __webpack_exports__.createCollectAsyncHook;
+exports.createCollectSyncHook = __webpack_exports__.createCollectSyncHook;
+exports.createPluginManager = __webpack_exports__.createPluginManager;
+exports.createSyncHook = __webpack_exports__.createSyncHook;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createAsyncHook",
+    "createAsyncInterruptHook",
+    "createAsyncPipelineHook",
+    "createCollectAsyncHook",
+    "createCollectSyncHook",
+    "createPluginManager",
+    "createSyncHook"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/manager.js

@@ -0,0 +1,135 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createPluginManager: ()=>createPluginManager
+});
+const isFunction = (obj)=>'function' == typeof obj;
+function validatePlugin(plugin) {
+    const type = typeof plugin;
+    if ('object' !== type || null === plugin) throw new Error(`Expect CLI Plugin instance to be an object, but got ${type}.`);
+    if (!plugin.setup) return;
+    if (isFunction(plugin.setup)) return;
+    throw new Error(`Expect CLI Plugin plugin.setup to be a function, but got ${type}.`);
+}
+function createPluginManager() {
+    const plugins = new Map();
+    const dependencies = new Map();
+    const addDependency = (plugin, dependency, type)=>{
+        if (!dependencies.has(dependency)) dependencies.set(dependency, {
+            pre: new Map(),
+            post: new Map()
+        });
+        if ('pre' === type) dependencies.get(plugin).pre.set(dependency, {
+            name: dependency,
+            isUse: false
+        });
+        else if ('post' === type) dependencies.get(plugin).post.set(dependency, {
+            name: dependency
+        });
+        else if ('use' === type) {
+            if (!dependencies.get(plugin).post.has(dependency) && !dependencies.get(dependency).pre.has(plugin)) dependencies.get(plugin).pre.set(dependency, {
+                name: dependency,
+                isUse: true
+            });
+        }
+    };
+    const addPlugin = (newPlugin)=>{
+        if (!newPlugin) return;
+        validatePlugin(newPlugin);
+        const { name, usePlugins = [], pre = [], post = [] } = newPlugin;
+        if (plugins.has(name)) return void console.warn(`Plugin ${name} already exists.`);
+        plugins.set(name, newPlugin);
+        dependencies.set(name, {
+            pre: new Map(),
+            post: new Map()
+        });
+        pre.forEach((dep)=>{
+            addDependency(name, dep, 'pre');
+        });
+        post.forEach((dep)=>{
+            addDependency(name, dep, 'post');
+        });
+        usePlugins.forEach((plugin)=>{
+            if (!plugins.has(plugin.name)) addPlugin(plugin);
+            addDependency(name, plugin.name, 'use');
+        });
+    };
+    const addPlugins = (newPlugins)=>{
+        for (const newPlugin of newPlugins)addPlugin(newPlugin);
+    };
+    const getPlugins = ()=>{
+        const visited = new Set();
+        const temp = new Set();
+        let result = [];
+        const visit = (name)=>{
+            if (temp.has(name)) throw new Error(`Circular dependency detected: ${name}`);
+            if (!visited.has(name) && plugins.get(name)) {
+                temp.add(name);
+                const { required = [] } = plugins.get(name);
+                required.forEach((dep)=>{
+                    if (!plugins.get(dep)) throw new Error(`${name} plugin required plugin ${dep}, but not found.`);
+                });
+                const { pre } = dependencies.get(name);
+                Array.from(pre.values()).filter((dep)=>!dep.isUse).forEach((dep)=>visit(dep.name));
+                Array.from(pre.values()).filter((dep)=>dep.isUse).forEach((dep)=>visit(dep.name));
+                temp.delete(name);
+                visited.add(name);
+                result.push(plugins.get(name));
+            }
+        };
+        plugins.forEach((_, name)=>{
+            const { post } = dependencies.get(name);
+            post.forEach((dep)=>{
+                if (!dependencies.get(dep.name).pre.has(name)) dependencies.get(dep.name).pre.set(name, {
+                    name,
+                    isUse: false
+                });
+            });
+        });
+        plugins.forEach((_, name)=>{
+            visit(name);
+        });
+        result = result.filter((result)=>result);
+        return result;
+    };
+    const clear = ()=>{
+        plugins.clear();
+        dependencies.clear();
+    };
+    return {
+        getPlugins,
+        addPlugins,
+        clear,
+        isPluginExists: (name)=>plugins.has(name)
+    };
+}
+exports.createPluginManager = __webpack_exports__.createPluginManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createPluginManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/api.js

@@ -0,0 +1,95 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    initPluginAPI: ()=>initPluginAPI
+});
+const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+function initPluginAPI({ context, plugins }) {
+    const { hooks, extendsHooks } = context;
+    function getRuntimeContext() {
+        if (context) {
+            const { hooks, extendsHooks, config, pluginAPI, ...runtimeContext } = context;
+            runtimeContext._internalContext = context;
+            return runtimeContext;
+        }
+        throw new Error('Cannot access context');
+    }
+    function updateRuntimeContext(updateContext) {
+        context = (0, merge_namespaceObject.merge)(context, updateContext);
+    }
+    function getHooks() {
+        return {
+            ...hooks,
+            ...extendsHooks
+        };
+    }
+    function getRuntimeConfig() {
+        if (context.config) return context.config;
+        throw new Error('Cannot access config');
+    }
+    const extendsPluginApi = {};
+    plugins.forEach((plugin)=>{
+        const { _registryApi } = plugin;
+        if (_registryApi) {
+            const apis = _registryApi(getRuntimeContext, updateRuntimeContext);
+            Object.keys(apis).forEach((apiName)=>{
+                extendsPluginApi[apiName] = apis[apiName];
+            });
+        }
+    });
+    if (extendsHooks) Object.keys(extendsHooks).forEach((hookName)=>{
+        extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+    });
+    const pluginAPI = {
+        updateRuntimeContext,
+        getHooks,
+        getRuntimeConfig,
+        config: hooks.config.tap,
+        onBeforeRender: hooks.onBeforeRender.tap,
+        wrapRoot: hooks.wrapRoot.tap,
+        pickContext: hooks.pickContext.tap,
+        extendStringSSRCollectors: hooks.extendStringSSRCollectors.tap,
+        extendStreamSSR: hooks.extendStreamSSR.tap,
+        ...extendsPluginApi
+    };
+    if ("u" < typeof Proxy) return pluginAPI;
+    return new Proxy(pluginAPI, {
+        get (target, prop) {
+            if ('then' === prop) return;
+            if (prop in target) return target[prop];
+            return ()=>{
+                console.warn(`api.${prop.toString()} not exist`);
+            };
+        }
+    });
+}
+exports.initPluginAPI = __webpack_exports__.initPluginAPI;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initPluginAPI"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/context.js

@@ -0,0 +1,60 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createRuntimeContext: ()=>createRuntimeContext,
+    initRuntimeContext: ()=>initRuntimeContext
+});
+const external_hooks_js_namespaceObject = require("./hooks.js");
+function initRuntimeContext() {
+    return {};
+}
+function createRuntimeContext({ runtimeContext, config, plugins }) {
+    const extendsHooks = {};
+    plugins.forEach((plugin)=>{
+        const { registryHooks = {} } = plugin;
+        Object.keys(registryHooks).forEach((hookName)=>{
+            extendsHooks[hookName] = registryHooks[hookName];
+        });
+    });
+    return {
+        ...runtimeContext,
+        hooks: {
+            ...(0, external_hooks_js_namespaceObject.initHooks)(),
+            ...extendsHooks
+        },
+        extendsHooks,
+        config
+    };
+}
+exports.createRuntimeContext = __webpack_exports__.createRuntimeContext;
+exports.initRuntimeContext = __webpack_exports__.initRuntimeContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRuntimeContext",
+    "initRuntimeContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/hooks.js

@@ -0,0 +1,46 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    initHooks: ()=>initHooks
+});
+const external_hooks_js_namespaceObject = require("../hooks.js");
+function initHooks() {
+    return {
+        onBeforeRender: (0, external_hooks_js_namespaceObject.createAsyncInterruptHook)(),
+        wrapRoot: (0, external_hooks_js_namespaceObject.createSyncHook)(),
+        pickContext: (0, external_hooks_js_namespaceObject.createSyncHook)(),
+        config: (0, external_hooks_js_namespaceObject.createCollectSyncHook)(),
+        extendStringSSRCollectors: (0, external_hooks_js_namespaceObject.createCollectSyncHook)(),
+        extendStreamSSR: (0, external_hooks_js_namespaceObject.createCollectSyncHook)()
+    };
+}
+exports.initHooks = __webpack_exports__.initHooks;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initHooks"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});