hunk.code_window:       </svg>
       `,
     });
     test("image URLs", async ({ page }) => {
       let app = new PlaywrightFixture(appFixture, page);
       await app.goto("/image-urls-test");
       let locator = await page.locator("[data-testid='image-urls']");
       let backgroundImage = await locator.evaluate(
         (element) => window.getComputedStyle(element).backgroundImage
       );
  
hunk.labels: keep keep keep keep add keep keep keep keep keep
hunk.after_edit:     let imgStatus: number | null = null;
       app.page.on("response", (res) => {
         if (res.url().endsWith(".svg")) imgStatus = res.status();
       });
  
hunk.file_path: integration/css-modules-test.ts
hunk.type: add
file: import type { ReactElement } from "react";
  import * as React from "react";
  import {
    createStaticRouter,
    StaticRouterProvider,
  } from "react-router-dom/server";
  
  import { RemixContext } from "./components";
  import type { EntryContext } from "./entry";
  import {
    RemixErrorBoundary,
    RemixRootDefaultErrorBoundary,
  } from "./errorBoundaries";
  import { createServerRoutes } from "./routes";
  
  export interface RemixServerProps {
    context: EntryContext;
    url: string | URL;
  }
  
  /**
   * The entry point for a Remix app when it is rendered on the server (in
   * `app/entry.server.js`). This component is used to generate the HTML in the
   * response from the server.
   */
  export function RemixServer({ context, url }: RemixServerProps): ReactElement {
    if (typeof url === "string") {
      url = new URL(url);
    }
  
    let { manifest, routeModules, serverHandoffString } = context;
    let routes = createServerRoutes(manifest.routes, routeModules);
    let router = createStaticRouter(routes, context.staticHandlerContext);
  
    return (
      <RemixContext.Provider
        value={{
          manifest,
          routeModules,
          serverHandoffString,
          future: context.future,
        }}
      >
        <RemixErrorBoundary
          location={router.state.location}
          component={RemixRootDefaultErrorBoundary}
        >
          <StaticRouterProvider
            router={router}
            context={context.staticHandlerContext}
            hydrate={false}
          />
        </RemixErrorBoundary>
      </RemixContext.Provider>
    );
  }
  