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

package/dist/cjs/core/server/string/index.js

@@ -1,147 +1,146 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var string_exports = {};
-__export(string_exports, {
-  renderString: () => renderString
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    renderString: ()=>renderString
 });
-module.exports = __toCommonJS(string_exports);
-var import_time = require("@modern-js/runtime-utils/time");
-var import_server = __toESM(require("react-dom/server"));
-var import_react_helmet = __toESM(require("react-helmet"));
-var import_constants = require("../../constants");
-var import_wrapper = require("../../react/wrapper");
-var import_constants2 = require("../constants");
-var import_helmet = require("../helmet");
-var import_shared = require("../shared");
-var import_tracer = require("../tracer");
-var import_utils = require("../utils");
-var import_loadable = require("./loadable");
-var import_prefetch = require("./prefetch");
-var import_ssrData = require("./ssrData");
-var import_styledComponent = require("./styledComponent");
-const renderString = async (request, serverRoot, options) => {
-  var _runtimeContext_ssrContext;
-  const { resource, runtimeContext, config, onError, onTiming } = options;
-  const tracer = {
-    onError,
-    onTiming
-  };
-  const routerContext = runtimeContext.routerContext;
-  const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
-  const ssrConfig = (0, import_utils.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries);
-  const chunkSet = {
-    renderLevel: import_constants.RenderLevel.CLIENT_RENDER,
-    ssrScripts: "",
-    jsChunk: "",
-    cssChunk: ""
-  };
-  let prefetchData = {};
-  try {
-    prefetchData = await (0, import_prefetch.prefetch)(serverRoot, request, options, ssrConfig, tracer);
-    chunkSet.renderLevel = import_constants.RenderLevel.SERVER_PREFETCH;
-  } catch (e) {
-    chunkSet.renderLevel = import_constants.RenderLevel.CLIENT_RENDER;
-    tracer.onError(e, import_tracer.SSRErrors.PRERENDER);
-  }
-  const collectors = [
-    new import_styledComponent.StyledCollector(chunkSet),
-    new import_loadable.LoadableCollector({
-      stats: loadableStats,
-      nonce: config.nonce,
-      routeManifest,
-      template: htmlTemplate,
-      entryName,
-      chunkSet,
-      config
-    }),
-    new import_ssrData.SSRDataCollector({
-      request,
-      prefetchData,
-      ssrConfig,
-      ssrContext: runtimeContext.ssrContext,
-      chunkSet,
-      routerContext,
-      nonce: config.nonce,
-      useJsonScript: config.useJsonScript
-    })
-  ];
-  const rootElement = (0, import_wrapper.wrapRuntimeContextProvider)(serverRoot, Object.assign(runtimeContext, {
-    ssr: true
-  }));
-  const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, ((_runtimeContext_ssrContext = runtimeContext.ssrContext) === null || _runtimeContext_ssrContext === void 0 ? void 0 : _runtimeContext_ssrContext.htmlModifiers) || [], tracer);
-  return html;
+const time_namespaceObject = require("@modern-js/runtime-utils/time");
+const server_namespaceObject = require("react-dom/server");
+var server_default = /*#__PURE__*/ __webpack_require__.n(server_namespaceObject);
+const external_react_helmet_namespaceObject = require("react-helmet");
+var external_react_helmet_default = /*#__PURE__*/ __webpack_require__.n(external_react_helmet_namespaceObject);
+const external_constants_js_namespaceObject = require("../../constants.js");
+const index_js_namespaceObject = require("../../context/index.js");
+const wrapper_js_namespaceObject = require("../../react/wrapper.js");
+const external_constants_js_namespaceObject_1 = require("../constants.js");
+const external_helmet_js_namespaceObject = require("../helmet.js");
+const external_shared_js_namespaceObject = require("../shared.js");
+const external_tracer_js_namespaceObject = require("../tracer.js");
+const external_utils_js_namespaceObject = require("../utils.js");
+const external_loadable_js_namespaceObject = require("./loadable.js");
+const external_ssrData_js_namespaceObject = require("./ssrData.js");
+const renderString = async (request, serverRoot, options)=>{
+    const { resource, runtimeContext, config, onError, onTiming } = options;
+    const tracer = {
+        onError,
+        onTiming
+    };
+    const routerContext = runtimeContext.routerContext;
+    const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
+    const ssrConfig = (0, external_utils_js_namespaceObject.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries);
+    const chunkSet = {
+        renderLevel: external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER,
+        ssrScripts: '',
+        jsChunk: '',
+        cssChunk: ''
+    };
+    const collectors = [
+        new external_loadable_js_namespaceObject.LoadableCollector({
+            stats: loadableStats,
+            nonce: config.nonce,
+            routeManifest,
+            template: htmlTemplate,
+            entryName,
+            chunkSet,
+            config
+        }),
+        new external_ssrData_js_namespaceObject.SSRDataCollector({
+            runtimeContext,
+            request,
+            ssrConfig,
+            ssrContext: runtimeContext.ssrContext,
+            chunkSet,
+            routerContext,
+            nonce: config.nonce,
+            useJsonScript: config.useJsonScript
+        })
+    ];
+    const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
+    const hooks = internalRuntimeContext.hooks;
+    const extraCollectors = hooks.extendStringSSRCollectors.call({
+        chunkSet
+    });
+    for (const c of extraCollectors)if (c) collectors.unshift(c);
+    const rootElement = (0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(serverRoot, Object.assign(runtimeContext, {
+        ssr: true
+    }));
+    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, runtimeContext.ssrContext?.htmlModifiers || [], tracer);
+    return html;
 };
 async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, { onError, onTiming }) {
-  let html = "";
-  let helmetData;
-  const finalApp = collectors.reduce((pre, creator) => {
-    var _creator_collect;
-    return ((_creator_collect = creator.collect) === null || _creator_collect === void 0 ? void 0 : _creator_collect.call(creator, pre)) || pre;
-  }, App);
-  try {
-    const end = (0, import_time.time)();
-    if (chunkSet.renderLevel >= import_constants.RenderLevel.SERVER_PREFETCH) {
-      html = import_server.default.renderToString(finalApp);
-      chunkSet.renderLevel = import_constants.RenderLevel.SERVER_RENDER;
+    let html = '';
+    let helmetData;
+    const finalApp = collectors.reduce((pre, creator)=>creator.collect?.(pre) || pre, App);
+    try {
+        const end = (0, time_namespaceObject.time)();
+        html = server_default().renderToString(finalApp);
+        chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER;
+        helmetData = external_react_helmet_default().renderStatic();
+        const cost = end();
+        onTiming(external_tracer_js_namespaceObject.SSRTimings.RENDER_HTML, cost);
+    } catch (e) {
+        chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
+        onError(e, external_tracer_js_namespaceObject.SSRErrors.RENDER_HTML);
     }
-    helmetData = import_react_helmet.default.renderStatic();
-    const cost = end();
-    onTiming(import_tracer.SSRTimings.RENDER_HTML, cost);
-  } catch (e) {
-    chunkSet.renderLevel = import_constants.RenderLevel.CLIENT_RENDER;
-    onError(e, import_tracer.SSRErrors.RENDER_HTML);
-  }
-  await Promise.all(collectors.map((component) => component.effect()));
-  const { ssrScripts, cssChunk, jsChunk } = chunkSet;
-  const finalHtml = await (0, import_shared.buildHtml)(htmlTemplate, [
-    createReplaceHtml(html),
-    createReplaceChunkJs(jsChunk),
-    createReplaceChunkCss(cssChunk),
-    createReplaceSSRDataScript(ssrScripts),
-    (0, import_helmet.createReplaceHelemt)(helmetData),
-    ...htmlModifiers
-  ]);
-  return finalHtml;
+    await Promise.all(collectors.map((component)=>component.effect()));
+    const { ssrScripts, cssChunk, jsChunk } = chunkSet;
+    const finalHtml = await (0, external_shared_js_namespaceObject.buildHtml)(htmlTemplate, [
+        createReplaceHtml(html),
+        createReplaceChunkJs(jsChunk),
+        createReplaceChunkCss(cssChunk),
+        createReplaceSSRDataScript(ssrScripts),
+        (0, external_helmet_js_namespaceObject.createReplaceHelemt)(helmetData),
+        ...htmlModifiers
+    ]);
+    return finalHtml;
 }
 function createReplaceHtml(html) {
-  return (template) => (0, import_utils.safeReplace)(template, import_constants2.HTML_PLACEHOLDER, html);
+    return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.HTML_PLACEHOLDER, html);
 }
 function createReplaceSSRDataScript(data) {
-  return (template) => (0, import_utils.safeReplace)(template, import_constants2.SSR_DATA_PLACEHOLDER, data);
+    return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.SSR_DATA_PLACEHOLDER, data);
 }
 function createReplaceChunkJs(js) {
-  return (template) => (0, import_utils.safeReplace)(template, import_constants2.CHUNK_JS_PLACEHOLDER, js);
+    return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.CHUNK_JS_PLACEHOLDER, js);
 }
 function createReplaceChunkCss(css) {
-  return (template) => (0, import_utils.safeReplace)(template, import_constants2.CHUNK_CSS_PLACEHOLDER, css);
+    return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.CHUNK_CSS_PLACEHOLDER, css);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  renderString
+exports.renderString = __webpack_exports__.renderString;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "renderString"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/core/server/string/loadable.js

@@ -1,188 +1,146 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var loadable_exports = {};
-__export(loadable_exports, {
-  LoadableCollector: () => LoadableCollector
+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__, {
+    LoadableCollector: ()=>LoadableCollector
 });
-module.exports = __toCommonJS(loadable_exports);
-var import_server = require("@loadable/server");
-var import_utils = require("../utils");
-const extname = (uri) => {
-  if (typeof uri !== "string" || !uri.includes(".")) {
-    return "";
-  }
-  return `.${uri === null || uri === void 0 ? void 0 : uri.split(".").pop()}` || "";
+const server_namespaceObject = require("@loadable/server");
+const external_utils_js_namespaceObject = require("../utils.js");
+const extname = (uri)=>{
+    if ('string' != typeof uri || !uri.includes('.')) return '';
+    return `.${uri?.split('.').pop()}` || '';
 };
-const generateChunks = (chunks, ext) => chunks.filter((chunk) => Boolean(chunk.url)).filter((chunk) => extname(chunk.url).slice(1) === ext);
-const checkIsInline = (chunk, enableInline) => {
-  if (process.env.NODE_ENV === "production") {
-    if (enableInline instanceof RegExp) {
-      return enableInline.test(chunk.url);
-    } else {
-      return Boolean(enableInline);
-    }
-  } else {
-    return false;
-  }
+const generateChunks = (chunks, ext)=>chunks.filter((chunk)=>Boolean(chunk.url)).filter((chunk)=>extname(chunk.url).slice(1) === ext);
+const checkIsInline = (chunk, enableInline)=>{
+    if ('production' !== process.env.NODE_ENV) return false;
+    if (enableInline instanceof RegExp) return enableInline.test(chunk.url);
+    return Boolean(enableInline);
 };
-const readAsset = async (chunk) => {
-  const fs = await Promise.resolve().then(() => __toESM(require("fs/promises")));
-  const path = await Promise.resolve().then(() => __toESM(require("path")));
-  const filepath = path.resolve(__dirname, chunk.filename);
-  return fs.readFile(filepath, "utf-8");
+const readAsset = async (chunk)=>{
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const filepath = path.resolve(__dirname, chunk.filename);
+    return fs.readFile(filepath, 'utf-8');
 };
 class LoadableCollector {
-  get existsAssets() {
-    var _routeManifest_routeAssets_entryName, _routeManifest_routeAssets;
-    const { routeManifest, entryName } = this.options;
-    return routeManifest === null || routeManifest === void 0 ? void 0 : (_routeManifest_routeAssets = routeManifest.routeAssets) === null || _routeManifest_routeAssets === void 0 ? void 0 : (_routeManifest_routeAssets_entryName = _routeManifest_routeAssets[entryName]) === null || _routeManifest_routeAssets_entryName === void 0 ? void 0 : _routeManifest_routeAssets_entryName.assets;
-  }
-  collect(comopnent) {
-    const { stats, entryName } = this.options;
-    if (!stats) {
-      return comopnent;
+    get existsAssets() {
+        const { routeManifest, entryName } = this.options;
+        return routeManifest?.routeAssets?.[entryName]?.assets;
     }
-    this.extractor = new import_server.ChunkExtractor({
-      stats,
-      entrypoints: [
-        entryName
-      ]
-    });
-    return this.extractor.collectChunks(comopnent);
-  }
-  async effect() {
-    if (!this.extractor) {
-      return;
+    collect(comopnent) {
+        const { stats, entryName } = this.options;
+        if (!stats) return comopnent;
+        this.extractor = new server_namespaceObject.ChunkExtractor({
+            stats,
+            entrypoints: [
+                entryName
+            ]
+        });
+        return this.extractor.collectChunks(comopnent);
     }
-    const { extractor, options } = this;
-    const { entryName, config } = options;
-    const asyncChunks = [];
-    if (config.enableAsyncEntry) {
-      try {
-        asyncChunks.push(...extractor.getChunkAssets([
-          `async-${entryName}`
-        ]));
-      } catch (e) {
-      }
+    async effect() {
+        if (!this.extractor) return;
+        const { extractor, options } = this;
+        const { entryName, config } = options;
+        const asyncChunks = [];
+        if (config.enableAsyncEntry) try {
+            asyncChunks.push(...extractor.getChunkAssets([
+                `async-${entryName}`
+            ]));
+        } catch (e) {}
+        const chunks = [].concat(asyncChunks).concat(extractor.getChunkAssets(extractor.chunks));
+        const scriptChunks = generateChunks(chunks, 'js');
+        const styleChunks = generateChunks(chunks, 'css');
+        this.emitLoadableScripts(extractor);
+        await this.emitScriptAssets(scriptChunks);
+        await this.emitStyleAssets(styleChunks);
     }
-    const chunks = [].concat(asyncChunks).concat(extractor.getChunkAssets(extractor.chunks));
-    const scriptChunks = generateChunks(chunks, "js");
-    const styleChunks = generateChunks(chunks, "css");
-    this.emitLoadableScripts(extractor);
-    await this.emitScriptAssets(scriptChunks);
-    await this.emitStyleAssets(styleChunks);
-  }
-  emitLoadableScripts(extractor) {
-    const check = (scripts2) => (scripts2 || "").includes("__LOADABLE_REQUIRED_CHUNKS___ext");
-    const scripts = extractor.getScriptTags();
-    if (!check(scripts)) {
-      return;
+    emitLoadableScripts(extractor) {
+        const check = (scripts)=>(scripts || '').includes('__LOADABLE_REQUIRED_CHUNKS___ext');
+        const scripts = extractor.getScriptTags();
+        if (!check(scripts)) return;
+        const { chunkSet } = this.options;
+        const s = scripts.split("<\/script>").slice(0, 2).map((i)=>`${i}</script>`).join('');
+        chunkSet.jsChunk += s;
     }
-    const { chunkSet } = this.options;
-    const s = scripts.split("</script>").slice(0, 2).map((i) => `${i}</script>`).join("");
-    chunkSet.jsChunk += s;
-  }
-  async emitScriptAssets(chunks) {
-    const { template, nonce, chunkSet, config } = this.options;
-    const { scriptLoading = "defer", enableInlineScripts } = config;
-    const scriptLoadingAtr = {
-      defer: scriptLoading === "defer" ? true : void 0,
-      type: scriptLoading === "module" ? "module" : void 0,
-      async: scriptLoading === "async" ? true : void 0
-    };
-    const attributes = (0, import_utils.attributesToString)(this.generateAttributes({
-      nonce,
-      ...scriptLoadingAtr
-    }));
-    const jsScriptRegExp = /<script .*?src="([^"]+)".*?>/g;
-    const matchs = template.matchAll(jsScriptRegExp);
-    const existedScript = [];
-    for (const match of matchs) {
-      existedScript.push(match[1]);
+    async emitScriptAssets(chunks) {
+        const { template, nonce, chunkSet, config } = this.options;
+        const { scriptLoading = 'defer', inlineStyles } = config;
+        const scriptLoadingAtr = {
+            defer: 'defer' === scriptLoading ? true : void 0,
+            type: 'module' === scriptLoading ? 'module' : void 0,
+            async: 'async' === scriptLoading ? true : void 0
+        };
+        const attributes = (0, external_utils_js_namespaceObject.attributesToString)(this.generateAttributes({
+            nonce,
+            ...scriptLoadingAtr
+        }));
+        const jsScriptRegExp = /<script .*?src="([^"]+)".*?>/g;
+        const matchs = template.matchAll(jsScriptRegExp);
+        const existedScript = [];
+        for (const match of matchs)existedScript.push(match[1]);
+        const scripts = await Promise.all(chunks.filter((chunk)=>!existedScript.includes(chunk.url) && !this.existsAssets?.includes(chunk.path)).map(async (chunk)=>{
+            const script = `<script${attributes} src="${chunk.url}"></script>`;
+            if ((0, external_utils_js_namespaceObject.checkIsNode)() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<script>${content}</script>`).catch((_)=>script);
+            return script;
+        }));
+        chunkSet.jsChunk += scripts.filter((script)=>Boolean(script)).join('');
     }
-    const scripts = await Promise.all(chunks.filter((chunk) => {
-      var _this_existsAssets;
-      return !existedScript.includes(chunk.url) && !((_this_existsAssets = this.existsAssets) === null || _this_existsAssets === void 0 ? void 0 : _this_existsAssets.includes(chunk.path));
-    }).map(async (chunk) => {
-      const script = `<script${attributes} src="${chunk.url}"></script>`;
-      if ((0, import_utils.checkIsNode)() && checkIsInline(chunk, enableInlineScripts)) {
-        return readAsset(chunk).then((content) => `<script>${content}</script>`).catch((_) => {
-          return script;
-        });
-      } else {
-        return script;
-      }
-    }));
-    chunkSet.jsChunk += scripts.filter((script) => Boolean(script)).join("");
-  }
-  async emitStyleAssets(chunks) {
-    const { template, chunkSet, config, entryName } = this.options;
-    const { enableInlineStyles } = config;
-    const atrributes = (0, import_utils.attributesToString)(this.generateAttributes());
-    const linkRegExp = /<link .*?href="([^"]+)".*?>/g;
-    const matchs = template.matchAll(linkRegExp);
-    const existedLinks = [];
-    for (const match of matchs) {
-      existedLinks.push(match[1]);
+    async emitStyleAssets(chunks) {
+        const { template, chunkSet, config, entryName } = this.options;
+        const { inlineStyles } = config;
+        const atrributes = (0, external_utils_js_namespaceObject.attributesToString)(this.generateAttributes());
+        const linkRegExp = /<link .*?href="([^"]+)".*?>/g;
+        const matchs = template.matchAll(linkRegExp);
+        const existedLinks = [];
+        for (const match of matchs)existedLinks.push(match[1]);
+        const css = await Promise.all(chunks.filter((chunk)=>!existedLinks.includes(chunk.url) && !this.existsAssets?.includes(chunk.path)).map(async (chunk)=>{
+            const link = `<link${atrributes} href="${chunk.url}" rel="stylesheet" />`;
+            if ((0, external_utils_js_namespaceObject.checkIsNode)() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);
+            return link;
+        }));
+        chunkSet.cssChunk += css.filter((css)=>Boolean(css)).join('');
     }
-    const css = await Promise.all(chunks.filter((chunk) => {
-      var _this_existsAssets;
-      return !existedLinks.includes(chunk.url) && !((_this_existsAssets = this.existsAssets) === null || _this_existsAssets === void 0 ? void 0 : _this_existsAssets.includes(chunk.path));
-    }).map(async (chunk) => {
-      const link = `<link${atrributes} href="${chunk.url}" rel="stylesheet" />`;
-      if ((0, import_utils.checkIsNode)() && checkIsInline(chunk, enableInlineStyles)) {
-        return readAsset(chunk).then((content) => `<style>${content}</style>`).catch((_) => {
-          return link;
-        });
-      } else {
-        return link;
-      }
-    }));
-    chunkSet.cssChunk += css.filter((css2) => Boolean(css2)).join("");
-  }
-  generateAttributes(extraAtr = {}) {
-    const { config } = this.options;
-    const { crossorigin } = config;
-    const attributes = {};
-    if (crossorigin) {
-      attributes.crossorigin = crossorigin === true ? "anonymous" : crossorigin;
+    generateAttributes(extraAtr = {}) {
+        const { config } = this.options;
+        const { crossorigin } = config;
+        const attributes = {};
+        if (crossorigin) attributes.crossorigin = true === crossorigin ? 'anonymous' : crossorigin;
+        return {
+            ...attributes,
+            ...extraAtr
+        };
+    }
+    constructor(options){
+        this.options = options;
     }
-    return {
-      ...attributes,
-      ...extraAtr
-    };
-  }
-  constructor(options) {
-    this.options = options;
-  }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  LoadableCollector
+exports.LoadableCollector = __webpack_exports__.LoadableCollector;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "LoadableCollector"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });