vite-plugin-react-server 1.1.17 → 1.1.18

package/plugin/config/mimeTypes.ts

@@ -1,17 +1,91 @@
-
 export const MIME_TYPES: Record<string, string> = {
+    // HTML and Web
     '.html': 'text/html',
+    '.htm': 'text/html',
+    '.xhtml': 'application/xhtml+xml',
+    '.xml': 'application/xml',
     '.css': 'text/css',
     '.js': 'application/javascript',
+    '.mjs': 'application/javascript',
+    '.cjs': 'application/javascript',
+    '.jsx': 'application/javascript',
+    '.ts': 'application/javascript',
+    '.tsx': 'application/javascript',
     '.json': 'application/json',
+    '.map': 'application/json',
+    '.wasm': 'application/wasm',
+    '.webmanifest': 'application/manifest+json',
+
+    // Images
     '.png': 'image/png',
     '.jpg': 'image/jpeg',
     '.jpeg': 'image/jpeg',
     '.gif': 'image/gif',
     '.svg': 'image/svg+xml',
     '.ico': 'image/x-icon',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.bmp': 'image/bmp',
+    '.tiff': 'image/tiff',
+    '.tif': 'image/tiff',
+    '.heic': 'image/heic',
+    '.heif': 'image/heif',
+    '.apng': 'image/apng',
+
+    // Fonts
     '.woff': 'font/woff',
     '.woff2': 'font/woff2',
     '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+    '.eot': 'application/vnd.ms-fontobject',
+    '.sfnt': 'font/sfnt',
+
+    // Video
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.m4v': 'video/x-m4v',
+    '.m4s': 'video/iso.segment',
+    '.m3u8': 'application/vnd.apple.mpegurl',
+    '.mpd': 'application/dash+xml',
+    '.mov': 'video/quicktime',
+    '.avi': 'video/x-msvideo',
+    '.wmv': 'video/x-ms-wmv',
+    '.flv': 'video/x-flv',
+    '.mkv': 'video/x-matroska',
+    '.3gp': 'video/3gpp',
+    '.m2ts': 'video/mp2t',
+
+    // Audio
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.ogg': 'audio/ogg',
+    '.m4a': 'audio/mp4',
+    '.aac': 'audio/aac',
+    '.flac': 'audio/flac',
+
+    // Documents
+    '.pdf': 'application/pdf',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.ppt': 'application/vnd.ms-powerpoint',
+    '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+
+    // Archives
+    '.zip': 'application/zip',
+    '.rar': 'application/x-rar-compressed',
+    '.7z': 'application/x-7z-compressed',
+    '.tar': 'application/x-tar',
+    '.gz': 'application/gzip',
+
+    // Data
+    '.csv': 'text/csv',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.yaml': 'application/yaml',
+    '.yml': 'application/yaml',
+
+    // React specific
     '.rsc': 'text/x-component'
   };

package/plugin/config/resolveUserConfig.ts

@@ -86,9 +86,7 @@ export function resolveUserConfig<
       info.type === "asset" &&
       userOptions.autoDiscover.cssPattern(value)
     ) {
-      const found = entry.css?.find((css) =>
-        css.startsWith(id as string)
-      );
+      const found = entry.css?.find((css) => css.startsWith(id as string));
       if (found) {
         return found;
       } else {
@@ -154,7 +152,9 @@ export function resolveUserConfig<
           }
           stashedReturns[inputId] = r;
         }
-        return stashedReturns[inputId];
+        // in the case of empty basePath, it will not be sliced from the path, so, we need to slice it here
+        // at the last possible moment as to not confuse the rest of the logic around the basePath
+        return stashedReturns[inputId].slice(Number(stashedReturns[inputId].startsWith("/")));
       }),
     assetFileNames: process.env["VITEST"]
       ? undefined
@@ -171,7 +171,9 @@ export function resolveUserConfig<
             }
             stashedReturns[inputId] = r;
           }
-          return stashedReturns[inputId];
+          // in the case of empty basePath, it will not be sliced from the path, so, we need to slice it here
+          // at the last possible moment as to not confuse the rest of the logic around the basePath
+          return stashedReturns[inputId].slice(Number(stashedReturns[inputId].startsWith("/")));
         }),
     chunkFileNames:
       userDefinedChunkFileNames ??
@@ -194,7 +196,9 @@ export function resolveUserConfig<
           }
           stashedReturns[inputId] = r;
         }
-        return stashedReturns[inputId];
+        // in the case of empty basePath, it will not be sliced from the path, so, we need to slice it here
+        // at the last possible moment as to not confuse the rest of the logic around the basePath
+        return stashedReturns[inputId].slice(Number(stashedReturns[inputId].startsWith("/")));
       }),
     format: "esm",
     exports: "named",
@@ -207,7 +211,11 @@ export function resolveUserConfig<
     ? [config.build?.rollupOptions?.output, pluginOutput]
     : pluginOutput;
   const vitePrefix = config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX;
-  const mode = config.mode ?? process.env["VITE_MODE"];
+  const mode =
+    config.mode ??
+    process.env[`${vitePrefix}MODE`] ??
+    process.env["NODE_ENV"] ??
+    "production";
   const minify = config.build?.minify;
 
   const srrConfig = {
@@ -229,15 +237,20 @@ export function resolveUserConfig<
     },
   };
   let publicOrigin =
-    userOptions.publicOrigin ?? process.env.VITE_PUBLIC_ORIGIN ?? "";
+    userOptions.publicOrigin ?? process.env[`${vitePrefix}PUBLIC_ORIGIN`] ?? "";
   let PROD = mode === "production";
   let DEV = mode === "development";
+  let port =
+    typeof config.server?.port === "number" ? config.server?.port : 5173;
+  let strictPort = config.server?.strictPort ?? true;
+  let host =
+    typeof config.server?.host === "string" ? config.server?.host : "localhost";
   if (configEnv.command === "serve" && !configEnv.isPreview) {
-    publicOrigin = `http${config.server?.https ? "s" : ""}://${
-      typeof config.server?.host === "string"
-        ? config.server?.host
-        : "localhost"
-    }:${typeof config.server?.port === "number" ? config.server?.port : 5173}`;
+    if (strictPort) {
+      publicOrigin = `http${config.server?.https ? "s" : ""}://${host}:${port}`;
+    } else {
+      publicOrigin = "";
+    }
   }
   const ssrDefine = ssr
     ? {
@@ -257,13 +270,13 @@ export function resolveUserConfig<
   // these will never be cleaned up, because, we are resolving the user config
   // and it's assumed the thread closes after this and we don't want
   // it to change after the config has been resolved
-  if (process.env.VITE_BASE_URL !== userOptions.moduleBaseURL) {
-    process.env.VITE_BASE_URL = userOptions.moduleBaseURL;
+  if (process.env[`${vitePrefix}BASE_URL`] !== userOptions.moduleBaseURL) {
+    process.env[`${vitePrefix}BASE_URL`] = userOptions.moduleBaseURL;
   }
-  if (process.env.VITE_PUBLIC_ORIGIN !== publicOrigin) {
-    process.env.VITE_PUBLIC_ORIGIN = publicOrigin;
+  if (process.env[`${vitePrefix}PUBLIC_ORIGIN`] !== publicOrigin) {
+    process.env[`${vitePrefix}PUBLIC_ORIGIN`] = publicOrigin;
   }
-
+  
   if (condition === "react-client") {
     // client plugin build options (client plugin still outputs server files)
     const clientConfig = {
@@ -282,6 +295,15 @@ export function resolveUserConfig<
       },
       define: define,
       ssr: srrConfig,
+      server: {
+        ...config.server,
+        // common default for stricter server operations
+        // and ensures tests that use a server will fail early
+        // also, we can't set the public origin without a port
+        port: port,
+        strictPort: strictPort,
+        host: host,
+      },
       // client build options
       build: {
         ...config.build,
@@ -298,9 +320,12 @@ export function resolveUserConfig<
         minify: minify,
         rollupOptions: {
           ...config.build?.rollupOptions,
-          input: {
-            ...autoDiscoveredFiles.inputs,
-          },
+          input: Object.fromEntries(
+            Object.entries(autoDiscoveredFiles.inputs).map(([key, value]) => [
+              key,
+              value.slice(Number(value.startsWith("/"))),
+            ])
+          ),
           output: newOutput,
           preserveEntrySignatures:
             config.build?.rollupOptions?.preserveEntrySignatures ??

package/plugin/env/plugin.ts

@@ -44,12 +44,20 @@ const cleanupInitialUserConfigEnv = resolveEnv(
  */
 export function envPlugin(): Plugin {
   let cleanupEnv: (() => void) | undefined;
+  let vitePrefix = DEFAULT_CONFIG.ENV_PREFIX as string;
   return {
     name: "vite-plugin-react-server:env",
     enforce: "pre",
     config(config, { mode }) {
+      if(config.envPrefix) {
+        if(typeof config.envPrefix === "string") {
+          vitePrefix = config.envPrefix;
+        } else if(Array.isArray(config.envPrefix)) {
+          vitePrefix = config.envPrefix[0];
+        }
+      }
       const invalidEnv =
-        (mode !== undefined && mode !== process.env.VITE_MODE) ||
+        (mode !== undefined && mode !== process.env[`${vitePrefix}MODE`]) ||
         (config.root !== undefined && config.root !== userProjectRoot);
       if (invalidEnv) {
         cleanupInitialUserConfigEnv();
@@ -57,9 +65,9 @@ export function envPlugin(): Plugin {
       // Clean up any previous env setup
       const cleanupUserConfigEnv = invalidEnv
         ? resolveEnv(
-            mode || process.env.VITE_MODE,
+            mode || process.env[`${vitePrefix}MODE`] || "production",
             config.root ?? userProjectRoot,
-            config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX
+            vitePrefix
           )
         : cleanupInitialUserConfigEnv;
       const cleanupUserConfig = resolveConfigDefine(config);
@@ -74,5 +82,33 @@ export function envPlugin(): Plugin {
       // Clean up environment variables when the bundle is closed
       cleanupEnv?.();
     },
+    configureServer(server) {
+      let envPrefix = Array.isArray(server.config.envPrefix) ? server.config.envPrefix[0] : server.config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX;
+      let publicOrigin = process.env[`${envPrefix}PUBLIC_ORIGIN`] ?? ""
+
+      let desiredPort = server.config.server.port;
+      let shouldUpdatePublicOrigin = false;
+      if (publicOrigin && publicOrigin.includes(`:${desiredPort}`)) {
+        shouldUpdatePublicOrigin = true;
+      }
+      // Listen for when the server actually starts
+      if (shouldUpdatePublicOrigin) {
+        server.httpServer?.once("listening", () => {
+          const address = server.httpServer?.address();
+          if (address && typeof address !== "string") {
+            const port = address.port;
+            if (port !== desiredPort) {
+              let envPrefix = Array.isArray(server.config.envPrefix) ? server.config.envPrefix[0] : server.config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX;
+              const newOrigin = publicOrigin.replace(
+                `:${desiredPort}`,
+                `:${port}`
+              );
+              process.env[`${envPrefix}PUBLIC_ORIGIN`] = newOrigin
+              console.warn("PUBLIC_ORIGIN did not match the port: " + port);
+            }
+          }
+        });
+      }
+    }
   };
 }

package/plugin/helpers/collectManifestCss.ts

@@ -27,7 +27,7 @@ export function collectManifestCss(
     // Add CSS files from the css property
     if (fileInfo.css) {
       for (const cssFile of fileInfo.css) {
-        cssInputs[cssFile] = cssFile + '.css';
+        cssInputs[cssFile] = cssFile;
       }
     }
 
@@ -46,7 +46,7 @@ export function collectManifestCss(
         const importedFile = manifest[importPath];
         if (importedFile?.css) {
           for (const cssFile of importedFile.css) {
-            cssInputs[cssFile] = cssFile + '.css';
+            cssInputs[cssFile] = cssFile;
           }
         }
       }

package/plugin/helpers/collectViteModuleGraphCss.ts

@@ -51,6 +51,7 @@ export async function collectViteModuleGraphCss<
     | "loader"
     | "normalizer"
     | "moduleID"
+    | "publicOrigin"
   >;
 }): Promise<CollectViteModuleGraphCssResult> {
   const {
@@ -59,6 +60,7 @@ export async function collectViteModuleGraphCss<
     moduleBasePath,
     moduleRootPath,
     projectRoot,
+    publicOrigin,
     css,
     loader,
     normalizer,
@@ -113,6 +115,7 @@ export async function collectViteModuleGraphCss<
           css: css,
           normalizer: normalizer,
           moduleID: moduleID,
+          publicOrigin: publicOrigin,
         },
       });
       cssFiles.set(mod?.url, cssContent);

package/plugin/helpers/createCssProps.tsx

@@ -41,6 +41,7 @@ export const createCssProps = <
     | "projectRoot"
     | "normalizer"
     | "moduleID"
+    | "publicOrigin"
   >;
 }): CssContent<InlineCSS> => {
   const { css, moduleRootPath } = userOptions;
@@ -77,15 +78,31 @@ export const createCssProps = <
         : {}),
     } as CssContent<InlineCSS>;
   }
+  const processEnv = process.env || {};
+  const hasEnv= typeof processEnv.VITE_PUBLIC_ORIGIN === "string" &&
+      processEnv.VITE_PUBLIC_ORIGIN !== "";
+  const importMeta = import.meta || {};
+  const hasMetaEnv = 'env' in importMeta && typeof importMeta.env.PUBLIC_ORIGIN === "string" &&
+      importMeta.env.PUBLIC_ORIGIN !== "";
+  // final public origin check
+  if((hasEnv || hasMetaEnv) && userOptions.publicOrigin) {
+    // change the public origin to the one from the env
+    if(hasEnv && userOptions.publicOrigin !== processEnv.VITE_PUBLIC_ORIGIN) {
+      // prefer potentially dynamic process.env
+      userOptions.publicOrigin = processEnv.VITE_PUBLIC_ORIGIN;
+    } else if(hasMetaEnv && userOptions.publicOrigin !== import.meta.env.PUBLIC_ORIGIN) {
+      // static import.meta.env
+      userOptions.publicOrigin = import.meta.env.PUBLIC_ORIGIN;
+    }
+  }
   // Default case
   return {
     id: moduleID,
     as: "link",
     rel: "stylesheet",
     href:
-      typeof process.env.VITE_PUBLIC_ORIGIN === "string" &&
-      process.env.VITE_PUBLIC_ORIGIN !== ""
-        ? new URL(moduleID, process.env.VITE_PUBLIC_ORIGIN).href
+    userOptions.publicOrigin !== ""
+        ? new URL(moduleID, userOptions.publicOrigin).href
         : moduleID,
     precedence: "high",
   } as CssContent<InlineCSS>;

package/plugin/helpers/requestInfo.ts

@@ -119,7 +119,7 @@ export function requestInfo(
   } else {
     const mimeType = MIME_TYPES[ext];
     if (mimeType) {
-      contentType = mimeType;
+      contentType = mimeType + "; charset=utf-8";
     } else {
       contentType = "application/octet-stream";
     }

package/plugin/helpers/tryManifest.ts

@@ -8,7 +8,7 @@ type TryManifestOptions<SSR extends boolean = false> = {
   outDir: string;
   ssrManifest?: SSR;
   preserveModulesRoot?: string;
-  manifestPath?: string | undefined;
+  manifestPath?: string | boolean | undefined;
 };
 
 export async function tryManifest<SSR extends boolean>(
@@ -23,16 +23,26 @@ export async function tryManifest<SSR extends boolean>(
       type: "error";
       error: Error;
       manifest?: never;
-    }> {
-  const localSsrManifestPath = !options.ssrManifest ? undefined : options.manifestPath ? options.manifestPath : join('.vite', 'ssr-manifest.json');
-  const localManifestPath = options.ssrManifest ? undefined : options.manifestPath ? options.manifestPath : join('.vite', 'manifest.json');
-  const manifestPath = resolve(
-    options.root,
-    options.outDir,
-    options.ssrManifest ? localSsrManifestPath as string : localManifestPath as string
-  );
+    }
+  | {
+      type: "skip";
+    }
+> {
+  let path = options.manifestPath;
+  if (path === false) {
+    return {
+      type: "skip",
+    };
+  }
+  if (options.ssrManifest) {
+    path = join(".vite", "ssr-manifest.json");
+  } else {
+    path = join(".vite", "manifest.json");
+  }
   try {
-    const result = JSON.parse(await readFile(manifestPath, "utf-8"));
+    const result = JSON.parse(
+      await readFile(resolve(options.root, options.outDir, path), "utf-8")
+    );
     return {
       type: "success",
       manifest: result,

package/plugin/loader/transformModuleIfNeeded.ts

@@ -10,9 +10,6 @@ export function transformModuleIfNeeded(
   isClientComponent: boolean | RegExpMatchArray | null = DEFAULT_CONFIG.AUTO_DISCOVER.isClientComponentCode(source),
   isServerEnvironment = getCondition() === "react-server"
 ) {
-  // Parse source and handle source maps
-  const ast = parse(source);  
-
   // Handle environment-specific cases
   if (
     (isServerEnvironment && !isServerFunction && !isClientComponent) ||
@@ -24,7 +21,7 @@ export function transformModuleIfNeeded(
   const result = transformModuleWithPreservedFunctions(
     source,
     moduleId,
-    ast,
+    parse(source),
     isServerFunction,
     isClientComponent
   );

package/plugin/react-client/configureWorkerRequestHandler.ts

@@ -19,6 +19,7 @@ import type { RscWorkerInputMessage } from "../worker/types.js";
 import { Readable } from "node:stream";
 import type { ReadableStream } from "node:stream/web";
 import { PassThrough } from "node:stream";
+import { logError, toError } from "../error/toError.js";
 
 /**
  * Configures the worker request handler.
@@ -102,7 +103,7 @@ export async function configureWorkerRequestHandler<
         }
         const body = Buffer.concat(chunks).toString();
         const parsed = JSON.parse(body);
-        
+
         // Get action ID and args from the request body
         let id: string;
         let args: unknown[];
@@ -153,9 +154,7 @@ export async function configureWorkerRequestHandler<
           } else if (message.type === "ERROR") {
             passThrough.end();
             currentWorker!.removeListener("message", messageHandler);
-            server.config.logger.error(message.error.message + (message.error.stack ?? ""), {
-              error: message.error,
-            });
+            logError(message.error, server.config.logger);
           }
         };
 
@@ -163,27 +162,24 @@ export async function configureWorkerRequestHandler<
 
         // Handle errors
         passThrough.on("error", (error) => {
-          server.config.logger.error(error.message + (error.stack ?? ""), {
-            error,
-          });
+          logError(error, server.config.logger);
           res.end();
         });
 
         return;
       } catch (error) {
-        if (error instanceof Error) {
-          server.config.logger.error(error.message + (error.stack ?? ""), {
-            error,
-          });
-        }
+        const err = toError(error);
+        logError(err, server.config.logger);
         res.statusCode = 500;
-        res.end(JSON.stringify({
-          type: "server-action-response",
-          returnValue: {
-            success: false,
-            error: error instanceof Error ? error.message : String(error)
-          }
-        }));
+        res.end(
+          JSON.stringify({
+            type: "server-action-response",
+            returnValue: {
+              success: false,
+              error: err.message,
+            },
+          })
+        );
         return;
       }
     }
@@ -320,5 +316,5 @@ export async function configureWorkerRequestHandler<
   };
   // attach handler to the server
   server.middlewares.use(handler);
-  // done
+  // port check, should be handled by strictPort
 }

package/plugin/react-server/configureReactServer.ts

@@ -170,16 +170,4 @@ export async function configureReactServer<
     }
   });
   // Listen for when the server actually starts
-  server.httpServer?.once("listening", () => {
-    const address = server.httpServer?.address();
-    if (address && typeof address !== "string") {
-      const port = address.port;
-      const host = server.config.server.host ?? "localhost";
-      const protocol = server.config.server.https ? "https" : "http";
-      handlerOptions.publicOrigin = `${protocol}://${host}:${port}`;
-      if (handlerOptions.publicOrigin !== process.env.VITE_PUBLIC_ORIGIN) {
-        process.env.VITE_PUBLIC_ORIGIN = handlerOptions.publicOrigin;
-      }
-    }
-  });
 }

package/plugin/react-static/configurePreviewServer.ts

@@ -39,9 +39,8 @@ export async function configurePreviewServer<
       staticHostDir,
       server.config.logger
     );
-
     // Handle static files including CSS
-    if (filePath) {
+    if (filePath && contentType.includes("text/x-component")) {
       try {
         const stats = await stat(filePath);
         if (stats.isFile()) {

package/plugin/react-static/plugin.ts

@@ -49,7 +49,6 @@ import {
 } from "../helpers/serializeUserOptions.js";
 import { collectManifestCss } from "../helpers/collectManifestCss.js";
 import { createCssProps } from "../helpers/createCssProps.js";
-import { tryManifest } from "../helpers/tryManifest.js";
 import { performance } from "node:perf_hooks";
 import { DEFAULT_CONFIG } from "../config/defaults.js";
 import { baseURL } from "../utils/envUrls.node.js";
@@ -101,7 +100,7 @@ export function reactStaticPlugin<
       if (config.root && config.root !== userOptions.projectRoot) {
         userOptions.projectRoot = config.root;
       }
-      if(configEnv.command !== "build") {
+      if (configEnv.command !== "build") {
         return;
       }
       // Initialize autoDiscoveredFiles for both server and client builds
@@ -165,35 +164,29 @@ export function reactStaticPlugin<
           bundle,
           normalizer: userOptions.normalizer,
         });
-        if (!("source" in bundleManifest[".vite/manifest.json"])) {
+        const manifestPath =
+          typeof resolvedConfig.build.manifest === "string"
+            ? resolvedConfig.build.manifest
+            : ".vite/manifest.json";
+        if (!("source" in bundleManifest[manifestPath])) {
           throw new Error("Server manifest not found");
         }
 
         serverManifest = JSON.parse(
-          bundleManifest[".vite/manifest.json"].source as string
+          bundleManifest[manifestPath].source as string
         );
 
         if (!serverManifest) {
           throw new Error("Failed to parse server manifest");
         }
-        
-        const clientManifestResult = await tryManifest({
-          root: userOptions.projectRoot,
-          outDir: join(userOptions.build.outDir, userOptions.build.client),
-          ssrManifest: false,
-        });
-        if (clientManifestResult.type === "error") {
-          throw clientManifestResult.error;
-        }
-        const clientManifest = clientManifestResult.manifest;
 
-        buildLoader = await createBuildLoader<T, InlineCSS>(
+        buildLoader = await createBuildLoader(
           {
             userConfig,
-            userOptions: userOptions as ResolvedUserOptions<T, InlineCSS>,
+            userOptions: userOptions,
             serverManifest: serverManifest ?? {},
             staticManifest: autoDiscoveredFiles?.staticManifest ?? {},
-            clientManifest: clientManifest ?? {},
+            clientManifest: {},
           },
           bundle
         );
@@ -230,7 +223,6 @@ export function reactStaticPlugin<
             transformedServerManifest,
             props ? [page, props] : page
           );
-
           // Create a map for this page's CSS files
           const pageCssMap: Map<string, CssContent> = new Map();
           // Add global styles if they exist
@@ -240,15 +232,16 @@ export function reactStaticPlugin<
                 String(r.default)
               );
               if (cssContent === "undefined" || !cssContent) {
-                cssContent = await readFile(
-                  join(
-                    userOptions.projectRoot,
-                    userOptions.build.outDir,
-                    userOptions.build.static,
-                    key
-                  ),
-                  "utf-8"
-                ) ?? ""
+                cssContent =
+                  (await readFile(
+                    join(
+                      userOptions.projectRoot,
+                      userOptions.build.outDir,
+                      userOptions.build.static,
+                      key
+                    ),
+                    "utf-8"
+                  )) ?? "";
               }
               if (cssContent) {
                 globalCss.set(