one 1.14.4 → 1.14.5

package/dist/cjs/cli/buildPage.cjs

@@ -2,47 +2,49 @@ var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf,
-  __hasOwnProp = Object.prototype.hasOwnProperty;
+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: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  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;
-  };
+  }
+  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: !0
-  }) : target, mod)),
-  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-    value: !0
-  }), mod);
+// 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 buildPage_exports = {};
 __export(buildPage_exports, {
   buildPage: () => buildPage,
   printBuildTimings: () => printBuildTimings
 });
 module.exports = __toCommonJS(buildPage_exports);
-var import_node_path = require("node:path"),
-  import_fs_extra = __toESM(require("fs-extra"), 1),
-  constants = __toESM(require("../constants.cjs"), 1),
-  import_constants = require("../constants.cjs"),
-  import_cleanUrl = require("../utils/cleanUrl.cjs"),
-  import_isResponse = require("../utils/isResponse.cjs"),
-  import_toAbsolute = require("../utils/toAbsolute.cjs"),
-  import_replaceLoader = require("../vite/replaceLoader.cjs");
+var import_node_path = require("node:path");
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var constants = __toESM(require("../constants.cjs"), 1);
+var import_constants = require("../constants.cjs");
+var import_cleanUrl = require("../utils/cleanUrl.cjs");
+var import_isResponse = require("../utils/isResponse.cjs");
+var import_toAbsolute = require("../utils/toAbsolute.cjs");
+var import_replaceLoader = require("../vite/replaceLoader.cjs");
 const {
   readFile,
   outputFile
@@ -51,53 +53,54 @@ function urlPathToFilePath(urlPath) {
   const parts = urlPath.replace(/^\//, "").split("/");
   return (0, import_node_path.join)(...parts);
 }
-const buildTiming = process.env.ONE_BUILD_TIMING === "1",
-  timings = {};
+const buildTiming = process.env.ONE_BUILD_TIMING === "1";
+const timings = {};
 function recordTiming(label, ms) {
-  buildTiming && (timings[label] ||= []).push(ms);
+  if (!buildTiming) return;
+  (timings[label] ||= []).push(ms);
 }
 function printBuildTimings() {
-  if (buildTiming) {
-    console.info(`
-\u{1F4CA} Build timing breakdown:`);
-    for (const [label, times] of Object.entries(timings)) {
-      const total = times.reduce((a, b) => a + b, 0),
-        avg = total / times.length;
-      console.info(`  ${label}: ${avg.toFixed(1)}ms avg, ${total.toFixed(0)}ms total (${times.length} calls)`);
-    }
+  if (!buildTiming) return;
+  console.info("\n\u{1F4CA} Build timing breakdown:");
+  for (const [label, times] of Object.entries(timings)) {
+    const total = times.reduce((a, b) => a + b, 0);
+    const avg = total / times.length;
+    console.info(`  ${label}: ${avg.toFixed(1)}ms avg, ${total.toFixed(0)}ms total (${times.length} calls)`);
   }
 }
 async function buildPage(serverEntry, path, relativeId, params, foundRoute, clientManifestEntry, staticDir, clientDir, builtMiddlewares, serverJsPath, preloads, allCSS, layoutCSS, routePreloads, allCSSContents, criticalPreloads, deferredPreloads, useAfterLCP, useAfterLCPAggressive) {
   let t0 = performance.now();
   const render = await getRender(serverEntry);
   recordTiming("getRender", performance.now() - t0);
-  const htmlPath = `${path.endsWith("/") ? `${removeTrailingSlash(path)}/index` : path}.html`,
-    clientJsPath = clientManifestEntry ? (0, import_node_path.join)(clientDir, clientManifestEntry.file) : "",
-    htmlOutPath = (0, import_toAbsolute.toAbsolute)((0, import_node_path.join)(staticDir, htmlPath)),
-    preloadPath = (0, import_cleanUrl.getPreloadPath)(path),
-    cssPreloadPath = (0, import_cleanUrl.getPreloadCSSPath)(path);
-  let loaderPath = "",
-    loaderData = {};
+  const htmlPath = `${path.endsWith("/") ? `${removeTrailingSlash(path)}/index` : path}.html`;
+  const clientJsPath = clientManifestEntry ? (0, import_node_path.join)(clientDir, clientManifestEntry.file) : "";
+  const htmlOutPath = (0, import_toAbsolute.toAbsolute)((0, import_node_path.join)(staticDir, htmlPath));
+  const preloadPath = (0, import_cleanUrl.getPreloadPath)(path);
+  const cssPreloadPath = (0, import_cleanUrl.getPreloadCSSPath)(path);
+  let loaderPath = "";
+  let loaderData = {};
   try {
-    const routeImports = [],
-      routeRegistrations = [];
+    const routeImports = [];
+    const routeRegistrations = [];
     let routeIndex = 0;
     for (const [routeKey, bundlePath] of Object.entries(routePreloads)) {
       const varName = `_r${routeIndex++}`;
-      routeImports.push(`import * as ${varName} from "${bundlePath}"`), routeRegistrations.push(`registerPreloadedRoute("${routeKey}", ${varName})`);
+      routeImports.push(`import * as ${varName} from "${bundlePath}"`);
+      routeRegistrations.push(`registerPreloadedRoute("${routeKey}", ${varName})`);
     }
-    const registrationCalls = routeRegistrations.map(call => call.replace("registerPreloadedRoute(", "window.__oneRegisterPreloadedRoute(")),
-      preloadContent = [
-      // import all route modules
-      ...routeImports,
-      // static imports for cache warming (original behavior)
-      ...preloads.map(preload => `import "${preload}"`),
-      // register all route modules using window global
-      ...registrationCalls].join(`
-`);
-    t0 = performance.now(), await import_fs_extra.default.writeFile((0, import_node_path.join)(clientDir, urlPathToFilePath(preloadPath)), preloadContent), recordTiming("writePreload", performance.now() - t0);
-    const uniqueCSS = [...new Set(allCSS)],
-      cssPreloadContent = `
+    const registrationCalls = routeRegistrations.map(call => call.replace("registerPreloadedRoute(", "window.__oneRegisterPreloadedRoute("));
+    const preloadContent = [
+    // import all route modules
+    ...routeImports,
+    // static imports for cache warming (original behavior)
+    ...preloads.map(preload => `import "${preload}"`),
+    // register all route modules using window global
+    ...registrationCalls].join("\n");
+    t0 = performance.now();
+    await import_fs_extra.default.writeFile((0, import_node_path.join)(clientDir, urlPathToFilePath(preloadPath)), preloadContent);
+    recordTiming("writePreload", performance.now() - t0);
+    const uniqueCSS = [...new Set(allCSS)];
+    const cssPreloadContent = `
 const CSS_TIMEOUT = 1000
 const cssUrls = ${JSON.stringify(uniqueCSS)}
 
@@ -152,54 +155,75 @@ export function injectCSS() {
 // For backwards compatibility, also prefetch on import
 prefetchCSS()
 `;
-    t0 = performance.now(), await import_fs_extra.default.writeFile((0, import_node_path.join)(clientDir, urlPathToFilePath(cssPreloadPath)), cssPreloadContent), recordTiming("writeCSSPreload", performance.now() - t0), t0 = performance.now();
+    t0 = performance.now();
+    await import_fs_extra.default.writeFile((0, import_node_path.join)(clientDir, urlPathToFilePath(cssPreloadPath)), cssPreloadContent);
+    recordTiming("writeCSSPreload", performance.now() - t0);
+    t0 = performance.now();
     const exported = await import((0, import_toAbsolute.toAbsolute)(serverJsPath));
     recordTiming("importServerModule", performance.now() - t0);
     const loaderProps = {
-        path,
-        params
-      },
-      matches = [];
-    if (t0 = performance.now(), foundRoute.layouts?.length) {
+      path,
+      params
+    };
+    const matches = [];
+    t0 = performance.now();
+    if (foundRoute.layouts?.length) {
       const layoutResults = await Promise.all(foundRoute.layouts.map(async layout => {
         try {
           const layoutServerPath = layout.loaderServerPath;
-          if (!layoutServerPath) return {
-            contextKey: layout.contextKey,
-            loaderData: void 0
-          };
-          const serverDir = (0, import_node_path.join)(clientDir, "..", "server"),
-            layoutLoaderData = await (await import((0, import_toAbsolute.toAbsolute)((0, import_node_path.join)(serverDir, layoutServerPath))))?.loader?.(loaderProps);
+          if (!layoutServerPath) {
+            return {
+              contextKey: layout.contextKey,
+              loaderData: void 0
+            };
+          }
+          const serverDir = (0, import_node_path.join)(clientDir, "..", "server");
+          const layoutExported = await import((0, import_toAbsolute.toAbsolute)((0, import_node_path.join)(serverDir, layoutServerPath)));
+          const layoutLoaderData = await layoutExported?.loader?.(loaderProps);
           return {
             contextKey: layout.contextKey,
             loaderData: layoutLoaderData
           };
         } catch (err) {
-          if ((0, import_isResponse.isResponse)(err)) throw err;
-          return console.warn(`[one] Warning: layout loader failed for ${layout.contextKey}:`, err), {
+          if ((0, import_isResponse.isResponse)(err)) {
+            throw err;
+          }
+          console.warn(`[one] Warning: layout loader failed for ${layout.contextKey}:`, err);
+          return {
             contextKey: layout.contextKey,
             loaderData: void 0
           };
         }
       }));
-      for (const result of layoutResults) matches.push({
-        routeId: result.contextKey,
-        pathname: path,
-        params: params || {},
-        loaderData: result.loaderData
-      });
+      for (const result of layoutResults) {
+        matches.push({
+          routeId: result.contextKey,
+          pathname: path,
+          params: params || {},
+          loaderData: result.loaderData
+        });
+      }
     }
-    recordTiming("layoutLoaders", performance.now() - t0), t0 = performance.now();
+    recordTiming("layoutLoaders", performance.now() - t0);
+    t0 = performance.now();
     let loaderRedirectInfo = null;
     if (exported.loader && foundRoute.type !== "ssr") {
       try {
         loaderData = (await exported.loader?.(loaderProps)) ?? null;
       } catch (err) {
-        if ((0, import_isResponse.isResponse)(err)) loaderRedirectInfo = extractRedirectInfo(err);else throw err;
+        if ((0, import_isResponse.isResponse)(err)) {
+          loaderRedirectInfo = extractRedirectInfo(err);
+        } else {
+          throw err;
+        }
+      }
+      if (!loaderRedirectInfo && loaderData && ((0, import_isResponse.isResponse)(loaderData) || loaderData instanceof Response || loaderData?.constructor?.name === "Response")) {
+        loaderRedirectInfo = extractRedirectInfo(loaderData);
+        loaderData = {};
       }
-      if (!loaderRedirectInfo && loaderData && ((0, import_isResponse.isResponse)(loaderData) || loaderData instanceof Response || loaderData?.constructor?.name === "Response") && (loaderRedirectInfo = extractRedirectInfo(loaderData), loaderData = {}), clientJsPath) {
-        const loaderPartialPath = (0, import_node_path.join)(clientDir, urlPathToFilePath((0, import_cleanUrl.getLoaderPath)(path))),
-          uncachedNativePath = loaderPartialPath.replace(constants.LOADER_JS_POSTFIX, import_constants.LOADER_JS_POSTFIX_UNCACHED).replace(/\.js$/, ".native.js");
+      if (clientJsPath) {
+        const loaderPartialPath = (0, import_node_path.join)(clientDir, urlPathToFilePath((0, import_cleanUrl.getLoaderPath)(path)));
+        const uncachedNativePath = loaderPartialPath.replace(constants.LOADER_JS_POSTFIX, import_constants.LOADER_JS_POSTFIX_UNCACHED).replace(/\.js$/, ".native.js");
         if (loaderRedirectInfo) {
           const redirectData = JSON.stringify({
             __oneRedirect: loaderRedirectInfo.path,
@@ -207,32 +231,40 @@ prefetchCSS()
           });
           await outputFile(loaderPartialPath, `export function loader(){return ${redirectData}}`);
           const nativeCjs = `exports.loader = function(){return ${redirectData}}`;
-          await outputFile(loaderPartialPath.replace(/\.js$/, ".native.js"), nativeCjs), await outputFile(uncachedNativePath, nativeCjs), loaderPath = (0, import_cleanUrl.getLoaderPath)(path), loaderData = {};
+          await outputFile(loaderPartialPath.replace(/\.js$/, ".native.js"), nativeCjs);
+          await outputFile(uncachedNativePath, nativeCjs);
+          loaderPath = (0, import_cleanUrl.getLoaderPath)(path);
+          loaderData = {};
         } else {
-          const code = await readFile(clientJsPath, "utf-8"),
-            withLoader =
-            // super dirty to quickly make ssr loaders work until we have better
-            `
+          const code = await readFile(clientJsPath, "utf-8");
+          const withLoader =
+          // super dirty to quickly make ssr loaders work until we have better
+          `
 if (typeof document === 'undefined') globalThis.document = {}
 ` + (0, import_replaceLoader.replaceLoader)({
-              code,
-              loaderData
-            });
+            code,
+            loaderData
+          });
           await outputFile(loaderPartialPath, withLoader);
           const nativeCjs = `exports.loader = function(){return ${JSON.stringify(loaderData)}}`;
-          await outputFile(loaderPartialPath.replace(/\.js$/, ".native.js"), nativeCjs), await outputFile(uncachedNativePath, nativeCjs), loaderPath = (0, import_cleanUrl.getLoaderPath)(path);
+          await outputFile(loaderPartialPath.replace(/\.js$/, ".native.js"), nativeCjs);
+          await outputFile(uncachedNativePath, nativeCjs);
+          loaderPath = (0, import_cleanUrl.getLoaderPath)(path);
         }
       }
     }
-    if (recordTiming("pageLoader", performance.now() - t0), matches.push({
+    recordTiming("pageLoader", performance.now() - t0);
+    matches.push({
       routeId: foundRoute.file,
       pathname: path,
       params: params || {},
       loaderData
-    }), foundRoute.type !== "ssr") {
-      if (globalThis.__vxrnresetState?.(), foundRoute.type === "ssg") {
-        const renderPreloads = criticalPreloads || preloads,
-          renderDeferredPreloads = useAfterLCPAggressive ? [] : deferredPreloads;
+    });
+    if (foundRoute.type !== "ssr") {
+      globalThis["__vxrnresetState"]?.();
+      if (foundRoute.type === "ssg") {
+        const renderPreloads = criticalPreloads || preloads;
+        const renderDeferredPreloads = useAfterLCPAggressive ? [] : deferredPreloads;
         t0 = performance.now();
         let html = await render({
           path,
@@ -246,57 +278,72 @@ if (typeof document === 'undefined') globalThis.document = {}
           routePreloads,
           matches
         });
-        recordTiming("ssrRender", performance.now() - t0), useAfterLCP && (html = applyAfterLCPScriptLoad(html, preloads)), t0 = performance.now(), await outputFile(htmlOutPath, html), recordTiming("writeHTML", performance.now() - t0);
-      } else if (foundRoute.type === "spa") if (foundRoute.layouts?.some(layout => layout.layoutRenderMode === "ssg" || layout.layoutRenderMode === "ssr")) {
-        globalThis.__vxrnresetState?.();
-        const renderPreloads = criticalPreloads || preloads,
-          renderDeferredPreloads = deferredPreloads || [],
-          layoutMatches = matches.slice(0, -1);
+        recordTiming("ssrRender", performance.now() - t0);
+        if (useAfterLCP) {
+          html = applyAfterLCPScriptLoad(html, preloads);
+        }
         t0 = performance.now();
-        let html = await render({
-          path,
-          preloads: renderPreloads,
-          deferredPreloads: renderDeferredPreloads,
-          loaderProps,
-          // don't pass loaderData for spa-shell - the page loader runs on client
-          // passing {} here would make useLoaderState think data is preloaded
-          loaderData: void 0,
-          css: allCSS,
-          cssContents: allCSSContents,
-          mode: "spa-shell",
-          routePreloads,
-          matches: layoutMatches
-        });
-        recordTiming("spaShellRender", performance.now() - t0), useAfterLCP && (html = applyAfterLCPScriptLoad(html, preloads)), t0 = performance.now(), await outputFile(htmlOutPath, html), recordTiming("writeHTML", performance.now() - t0);
-      } else {
-        let renderCSSTag = function (file, index) {
-          const content = allCSSContents?.[index];
-          return content ? `    <style>${content}</style>` : `    <link rel="stylesheet" href=${file} />`;
-        };
-        const layoutCSSSet = new Set(layoutCSS),
-          layoutCssOutput = allCSS.map((file, i) => layoutCSSSet.has(file) ? renderCSSTag(file, i) : "").filter(Boolean).join(`
-`),
-          pageCssOutput = allCSS.map((file, i) => layoutCSSSet.has(file) ? "" : renderCSSTag(file, i)).filter(Boolean).join(`
-`),
-          criticalScripts = (criticalPreloads || preloads).map(preload => `   <script type="module" src="${preload}"></script>`).join(`
-`);
-        await outputFile(htmlOutPath, `<!DOCTYPE html><html><head>
-            ${constants.getSpaHeaderElements({
-          serverContext: {
+        await outputFile(htmlOutPath, html);
+        recordTiming("writeHTML", performance.now() - t0);
+      } else if (foundRoute.type === "spa") {
+        const needsSpaShell = foundRoute.layouts?.some(layout => layout.layoutRenderMode === "ssg" || layout.layoutRenderMode === "ssr");
+        if (needsSpaShell) {
+          globalThis["__vxrnresetState"]?.();
+          const renderPreloads = criticalPreloads || preloads;
+          const renderDeferredPreloads = deferredPreloads || [];
+          const layoutMatches = matches.slice(0, -1);
+          t0 = performance.now();
+          let html = await render({
+            path,
+            preloads: renderPreloads,
+            deferredPreloads: renderDeferredPreloads,
             loaderProps,
-            loaderData
+            // don't pass loaderData for spa-shell - the page loader runs on client
+            // passing {} here would make useLoaderState think data is preloaded
+            loaderData: void 0,
+            css: allCSS,
+            cssContents: allCSSContents,
+            mode: "spa-shell",
+            routePreloads,
+            matches: layoutMatches
+          });
+          recordTiming("spaShellRender", performance.now() - t0);
+          if (useAfterLCP) {
+            html = applyAfterLCPScriptLoad(html, preloads);
           }
-        })}
+          t0 = performance.now();
+          await outputFile(htmlOutPath, html);
+          recordTiming("writeHTML", performance.now() - t0);
+        } else {
+          let renderCSSTag = function (file, index) {
+            const content = allCSSContents?.[index];
+            if (content) {
+              return `    <style>${content}</style>`;
+            }
+            return `    <link rel="stylesheet" href=${file} />`;
+          };
+          const layoutCSSSet = new Set(layoutCSS);
+          const layoutCssOutput = allCSS.map((file, i) => layoutCSSSet.has(file) ? renderCSSTag(file, i) : "").filter(Boolean).join("\n");
+          const pageCssOutput = allCSS.map((file, i) => !layoutCSSSet.has(file) ? renderCSSTag(file, i) : "").filter(Boolean).join("\n");
+          const criticalScripts = (criticalPreloads || preloads).map(preload => `   <script type="module" src="${preload}"></script>`).join("\n");
+          await outputFile(htmlOutPath, `<!DOCTYPE html><html><head>
+            ${constants.getSpaHeaderElements({
+            serverContext: {
+              loaderProps,
+              loaderData
+            }
+          })}
             ${layoutCssOutput}
             ${criticalScripts}
             ${pageCssOutput}
           </head><body></body></html>`);
+        }
       }
     }
   } catch (err) {
     const errMsg = err instanceof Error ? `${err.message}
 ${err.stack}` : `${err}`;
-    throw console.error(`Error building static page at ${path} with id ${relativeId}:
+    console.error(`Error building static page at ${path} with id ${relativeId}:
 
 ${errMsg}
 
@@ -305,10 +352,12 @@ loaderData:
 ${JSON.stringify(loaderData || null, null, 2)}
 params:
 
-${JSON.stringify(params || null, null, 2)}`), console.error(err), err;
+${JSON.stringify(params || null, null, 2)}`);
+    console.error(err);
+    throw err;
   }
-  const middlewares = (foundRoute.middlewares || []).map(x => builtMiddlewares[x.contextKey]),
-    cleanPath = path === "/" ? path : removeTrailingSlash(path);
+  const middlewares = (foundRoute.middlewares || []).map(x => builtMiddlewares[x.contextKey]);
+  const cleanPath = path === "/" ? path : removeTrailingSlash(path);
   return {
     type: foundRoute.type,
     css: allCSS,
@@ -333,14 +382,19 @@ ${JSON.stringify(params || null, null, 2)}`), console.error(err), err;
 }
 async function getRender(serverEntry) {
   try {
-    const serverImport = await import(serverEntry),
-      render = serverImport.default.render ||
-      // for an unknown reason this is necessary
-      serverImport.default.default?.render;
-    if (typeof render != "function") throw new Error(`didn't find render function in entry: ${serverEntry}`);
+    const serverImport = await import(serverEntry);
+    const render = serverImport.default.render ||
+    // for an unknown reason this is necessary
+    serverImport.default.default?.render;
+    if (typeof render !== "function") {
+      throw new Error(`didn't find render function in entry: ${serverEntry}`);
+    }
     return render;
   } catch (err) {
-    throw console.error("\u274C Error importing the root entry:"), console.error(`  This error happened in the built file: ${serverEntry}`), console.error(err.stack), err;
+    console.error(`\u274C Error importing the root entry:`);
+    console.error(`  This error happened in the built file: ${serverEntry}`);
+    console.error(err["stack"]);
+    throw err;
   }
 }
 function removeTrailingSlash(path) {
@@ -349,17 +403,19 @@ function removeTrailingSlash(path) {
 function extractRedirectInfo(response) {
   if (response.status >= 300 && response.status < 400) {
     const location = response.headers.get("location");
-    if (location) try {
-      const url = new URL(location);
-      return {
-        path: url.pathname + url.search + url.hash,
-        status: response.status
-      };
-    } catch {
-      return {
-        path: location,
-        status: response.status
-      };
+    if (location) {
+      try {
+        const url = new URL(location);
+        return {
+          path: url.pathname + url.search + url.hash,
+          status: response.status
+        };
+      } catch {
+        return {
+          path: location,
+          status: response.status
+        };
+      }
     }
   }
   return null;
@@ -394,5 +450,6 @@ function applyAfterLCPScriptLoad(html, preloads) {
   waitIdle(5);
 })();
 </script>`;
-  return html = html.replace("</head>", `${loaderScript}</head>`), html;
+  html = html.replace("</head>", `${loaderScript}</head>`);
+  return html;
 }